Resnet_transfer_learning.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PyTorch Version:  1.3.0\n",
      "Torchvision Version:  0.4.1a0+d94043a\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "from __future__ import division\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "import torchvision\n",
    "from torchvision import datasets, models, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import os\n",
    "import copy\n",
    "print(\"PyTorch Version: \",torch.__version__)\n",
    "print(\"Torchvision Version: \",torchvision.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define configurations for transfer learning\n",
    "\n",
    "data_dir = 'data/'\n",
    "model_name = 'resnet'\n",
    "\n",
    "num_classes = 2\n",
    "batch_size = 8\n",
    "\n",
    "num_epochs = 15\n",
    "\n",
    "# Flag for feature extracting. When False, we finetune the whole model,\n",
    "# when True we only update the reshaped layer params\n",
    "feature_extract = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, dataloaders, criterion, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing pretrained resnet 18...\n",
      "Params to learn:\n",
      "\t fc.weight\n",
      "\t fc.bias\n",
      "Epoch 0/14\n",
      "----------\n",
      "train Loss: 0.1643 Acc: 0.9456\n",
      "val Loss: 0.4834 Acc: 0.9091\n",
      "\n",
      "Epoch 1/14\n",
      "----------\n",
      "train Loss: 0.1270 Acc: 0.9545\n",
      "val Loss: 0.3179 Acc: 0.9236\n",
      "\n",
      "Epoch 2/14\n",
      "----------\n",
      "train Loss: 0.1165 Acc: 0.9600\n",
      "val Loss: 0.2904 Acc: 0.9164\n",
      "\n",
      "Epoch 3/14\n",
      "----------\n",
      "train Loss: 0.1140 Acc: 0.9636\n",
      "val Loss: 0.4831 Acc: 0.9164\n",
      "\n",
      "Epoch 4/14\n",
      "----------\n",
      "train Loss: 0.1173 Acc: 0.9597\n",
      "val Loss: 0.2782 Acc: 0.9382\n",
      "\n",
      "Epoch 5/14\n",
      "----------\n",
      "train Loss: 0.1081 Acc: 0.9631\n",
      "val Loss: 0.4577 Acc: 0.9127\n",
      "\n",
      "Epoch 6/14\n",
      "----------\n",
      "train Loss: 0.1059 Acc: 0.9628\n",
      "val Loss: 0.3761 Acc: 0.9200\n",
      "\n",
      "Epoch 7/14\n",
      "----------\n",
      "train Loss: 0.1019 Acc: 0.9664\n",
      "val Loss: 0.3612 Acc: 0.9236\n",
      "\n",
      "Epoch 8/14\n",
      "----------\n",
      "train Loss: 0.1051 Acc: 0.9640\n",
      "val Loss: 0.3428 Acc: 0.9164\n",
      "\n",
      "Epoch 9/14\n",
      "----------\n",
      "train Loss: 0.1042 Acc: 0.9674\n",
      "val Loss: 0.4280 Acc: 0.9164\n",
      "\n",
      "Epoch 10/14\n",
      "----------\n",
      "train Loss: 0.1141 Acc: 0.9607\n",
      "val Loss: 0.3900 Acc: 0.9164\n",
      "\n",
      "Epoch 11/14\n",
      "----------\n",
      "train Loss: 0.1031 Acc: 0.9658\n",
      "val Loss: 0.4215 Acc: 0.9200\n",
      "\n",
      "Epoch 12/14\n",
      "----------\n",
      "train Loss: 0.1021 Acc: 0.9636\n",
      "val Loss: 0.3280 Acc: 0.9345\n",
      "\n",
      "Epoch 13/14\n",
      "----------\n",
      "train Loss: 0.1039 Acc: 0.9647\n",
      "val Loss: 0.4083 Acc: 0.9164\n",
      "\n",
      "Epoch 14/14\n",
      "----------\n",
      "train Loss: 0.1017 Acc: 0.9649\n",
      "val Loss: 0.3357 Acc: 0.9418\n",
      "\n",
      "Training complete in 149m 22s\n",
      "Best val Acc: 0.941818\n",
      "Accuracy of the network on the test images: 86 %\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "from __future__ import division\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "import torchvision\n",
    "from torchvision import datasets, models, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import os\n",
    "import copy\n",
    "import numpy as np\n",
    "\n",
    "from classifier import Classifier\n",
    "from optimizer import Optimizer\n",
    "from dataset import DataSet\n",
    "\n",
    "if __name__ == '__main__':\n",
    "\n",
    "    data_dir = 'data'\n",
    "    model_name = 'resnet'\n",
    "    output_classes = 2\n",
    "    feature_extract = True\n",
    "    batch_size = 4\n",
    "    num_epochs = 15\n",
    "\n",
    "    resnetClassifier = Classifier(model_name, output_classes)\n",
    "    model = resnetClassifier.initPretrainedModel(224)\n",
    "\n",
    "    dataloaders, dataset_sizes, class_names = DataSet.initDataLoaders(data_dir, batch_size)\n",
    "    data_transforms = DataSet.setUpDataLoaderTransformers()\n",
    "\n",
    "    image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x]) for x in\n",
    "                      ['train', 'val', 'test']}\n",
    "\n",
    "    # Create training and validation dataloaders\n",
    "    dataloaders_dict = {\n",
    "        x: torch.utils.data.DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True, num_workers=4) for x in\n",
    "        ['train', 'val', 'test']}\n",
    "\n",
    "    # Detect if we have a GPU available\n",
    "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "    sgdOptimizer = Optimizer(device)\n",
    "    optimizer_ft = sgdOptimizer.optimize(model, feature_extract, 0.001, 0.9)\n",
    "\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "    model, hist = resnetClassifier.train_model(model,\n",
    "                                                criterion,\n",
    "                                                optimizer_ft,\n",
    "                                                dataloaders_dict,\n",
    "                                                dataset_sizes)\n",
    "\n",
    "    torch.save({\n",
    "        'name': 'resnet_feature_extraction',\n",
    "        'epoch': 15,\n",
    "        'model_state_dict': model.state_dict(),\n",
    "        'optimizer_state_dict': optimizer_ft.state_dict(),\n",
    "    }, './trainedModels/resnetFeatureExtraction.pt')\n",
    "\n",
    "    # testing\n",
    "    state = torch.load('./trainedModels/resnetFeatureExtraction.pt')\n",
    "    model.load_state_dict(state['model_state_dict'])\n",
    "    predictions = resnetClassifier.testModel(dataloaders_dict, model, class_names, dataset_sizes, batch_size=4)\n",
    "\n",
    "    # save predicted values\n",
    "    np.savetxt('./trainedModels/predictedLabelsResNet.csv', predictions, fmt='%s')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initializing pretrained resnet 18...\n",
      "Params to learn:\n",
      "\t fc.weight\n",
      "\t fc.bias\n",
      "Epoch 0/14\n",
      "----------\n",
      "train Loss: 0.1938 Acc: 0.9388\n",
      "val Loss: 0.4287 Acc: 0.8618\n",
      "\n",
      "Epoch 1/14\n",
      "----------\n",
      "train Loss: 0.1530 Acc: 0.9471\n",
      "val Loss: 0.0902 Acc: 0.9673\n",
      "\n",
      "Epoch 2/14\n",
      "----------\n",
      "train Loss: 0.1593 Acc: 0.9476\n",
      "val Loss: 0.2116 Acc: 0.9164\n",
      "\n",
      "Epoch 3/14\n",
      "----------\n",
      "train Loss: 0.1560 Acc: 0.9496\n",
      "val Loss: 0.1485 Acc: 0.9345\n",
      "\n",
      "Epoch 4/14\n",
      "----------\n",
      "train Loss: 0.1530 Acc: 0.9496\n",
      "val Loss: 0.1176 Acc: 0.9382\n",
      "\n",
      "Epoch 5/14\n",
      "----------\n",
      "train Loss: 0.1523 Acc: 0.9508\n",
      "val Loss: 0.2444 Acc: 0.9164\n",
      "\n",
      "Epoch 6/14\n",
      "----------\n",
      "train Loss: 0.1474 Acc: 0.9510\n",
      "val Loss: 0.1408 Acc: 0.9455\n",
      "\n",
      "Epoch 7/14\n",
      "----------\n",
      "train Loss: 0.1565 Acc: 0.9488\n",
      "val Loss: 0.4150 Acc: 0.8945\n",
      "\n",
      "Epoch 8/14\n",
      "----------\n",
      "train Loss: 0.1566 Acc: 0.9489\n",
      "val Loss: 0.0807 Acc: 0.9709\n",
      "\n",
      "Epoch 9/14\n",
      "----------\n",
      "train Loss: 0.1453 Acc: 0.9516\n",
      "val Loss: 0.0545 Acc: 0.9891\n",
      "\n",
      "Epoch 10/14\n",
      "----------\n",
      "train Loss: 0.1537 Acc: 0.9473\n",
      "val Loss: 0.1329 Acc: 0.9418\n",
      "\n",
      "Epoch 11/14\n",
      "----------\n",
      "train Loss: 0.1451 Acc: 0.9549\n",
      "val Loss: 0.1164 Acc: 0.9418\n",
      "\n",
      "Epoch 12/14\n",
      "----------\n",
      "train Loss: 0.1548 Acc: 0.9515\n",
      "val Loss: 0.0730 Acc: 0.9709\n",
      "\n",
      "Epoch 13/14\n",
      "----------\n",
      "train Loss: 0.1510 Acc: 0.9509\n",
      "val Loss: 0.0719 Acc: 0.9709\n",
      "\n",
      "Epoch 14/14\n",
      "----------\n",
      "train Loss: 0.1485 Acc: 0.9498\n",
      "val Loss: 0.0970 Acc: 0.9600\n",
      "\n",
      "Training complete in 177m 24s\n",
      "Best val Acc: 0.989091\n",
      "Accuracy of the network on the test images: 89 %\n"
     ]
    }
   ],
   "source": [
    "from __future__ import print_function\n",
    "from __future__ import division\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "import torchvision\n",
    "from torchvision import datasets, models, transforms\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import os\n",
    "import copy\n",
    "import numpy as np\n",
    "\n",
    "from classifier import Classifier\n",
    "from optimizer import Optimizer\n",
    "from dataset import DataSet\n",
    "\n",
    "if __name__ == '__main__':\n",
    "\n",
    "    data_dir = 'data'\n",
    "    model_name = 'resnet'\n",
    "    output_classes = 2\n",
    "    feature_extract = True\n",
    "    batch_size = 4\n",
    "    num_epochs = 15\n",
    "\n",
    "    resnetClassifier = Classifier(model_name, output_classes)\n",
    "    model = resnetClassifier.initPretrainedModel(224)\n",
    "\n",
    "    dataloaders, dataset_sizes, class_names = DataSet.initDataLoaders(data_dir, batch_size)\n",
    "    data_transforms = DataSet.setUpDataLoaderTransformers()\n",
    "\n",
    "    image_datasets = {x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x]) for x in\n",
    "                      ['train', 'val', 'test']}\n",
    "\n",
    "    # Create training and validation dataloaders\n",
    "    dataloaders_dict = {\n",
    "        x: torch.utils.data.DataLoader(image_datasets[x], batch_size=batch_size, shuffle=True, num_workers=4) for x in\n",
    "        ['train', 'val', 'test']}\n",
    "\n",
    "    # Detect if we have a GPU available\n",
    "    device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "    sgdOptimizer = Optimizer(device)\n",
    "    optimizer_ft = sgdOptimizer.optimize(model, feature_extract, 0.001, 0.9)\n",
    "\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "\n",
    "    model, hist = resnetClassifier.train_model(model,\n",
    "                                                criterion,\n",
    "                                                optimizer_ft,\n",
    "                                                dataloaders_dict,\n",
    "                                                dataset_sizes)\n",
    "\n",
    "    torch.save({\n",
    "        'name': 'resnet_feature_extraction_2',\n",
    "        'epoch': 15,\n",
    "        'model_state_dict': model.state_dict(),\n",
    "        'optimizer_state_dict': optimizer_ft.state_dict(),\n",
    "    }, './trainedModels/resnetFeatureExtraction2.pt')\n",
    "\n",
    "    # testing\n",
    "    state = torch.load('./trainedModels/resnetFeatureExtraction2.pt')\n",
    "    model.load_state_dict(state['model_state_dict'])\n",
    "    predictions = resnetClassifier.testModel(dataloaders_dict, model, class_names, dataset_sizes, batch_size=4)\n",
    "\n",
    "    # save predicted values\n",
    "    np.savetxt('./trainedModels/predictedLabelsResNet2.csv', predictions, fmt='%s')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn.metrics\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy (Sklearn): 0.6\n",
      "F1-Score (Sklearn): 0.5\n",
      "Precision Score: 0.5\n",
      "Recall Score: 0.5\n",
      "\n",
      "Confusion Matrix:\n",
      "[[2 1]\n",
      " [1 1]]\n",
      "\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "         0.0       0.67      0.67      0.67         3\n",
      "         1.0       0.50      0.50      0.50         2\n",
      "\n",
      "    accuracy                           0.60         5\n",
      "   macro avg       0.58      0.58      0.58         5\n",
      "weighted avg       0.60      0.60      0.60         5\n",
      "\n"
     ]
    }
   ],
   "source": [
    "labels = torch.Tensor([1,0,0,0,1])\n",
    "predicted = torch.Tensor([1,0,0,1,0])\n",
    "\n",
    "try:\n",
    "    print(f\"Accuracy (Sklearn): {sklearn.metrics.accuracy_score(labels.numpy(), predicted.numpy())}\")\n",
    "    print(f\"F1-Score (Sklearn): {sklearn.metrics.f1_score(labels.numpy(), predicted.numpy())}\")\n",
    "    print(f\"Precision Score: {sklearn.metrics.precision_score(labels.numpy(), predicted.numpy())}\")\n",
    "    print(f\"Recall Score: {sklearn.metrics.recall_score(labels.numpy(), predicted.numpy())}\")\n",
    "    print(f\"\\nConfusion Matrix:\\n{sklearn.metrics.confusion_matrix(labels.numpy(), predicted.numpy())}\")\n",
    "    print(f\"\\nClassification Report:\\n{sklearn.metrics.classification_report(labels.numpy(), predicted.numpy())}\")\n",
    "except RuntimeError:\n",
    "    print(\"Error computing metrics: \\n\", RuntimeError)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}