train_resnet.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8eee28f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from skimage import io\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import os\n",
    "from glob import glob\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from tqdm import tqdm\n",
    "from PIL import Image\n",
    "from network import Net\n",
    "from torch.utils.data import DataLoader, Dataset\n",
    "from torch.autograd import Variable\n",
    "if not os.path.exists('./outputs'):\n",
    "    os.mkdir('./outputs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "745dbbdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global parameters\n",
    "\n",
    "# If USE_CUDA is True, computations will be done using the GPU (may not work in all systems)\n",
    "# This will make the calculations happen faster\n",
    "USE_CUDA = torch.cuda.is_available()\n",
    "\n",
    "DATASET_PATH = './EuroSAT_data'\n",
    "\n",
    "BATCH_SIZE = 64 # Number of images that are used for calculating gradients at each step\n",
    "\n",
    "NUM_EPOCHS = 25 # Number of times we will go through all the training images. Do not go over 25\n",
    "\n",
    "LEARNING_RATE = 0.001 # Controls the step size\n",
    "MOMENTUM = 0.9 # Momentum for the gradient descent\n",
    "WEIGHT_DECAY = 0.0005"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "cc65618c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataloaders OK\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<torch.utils.data.dataloader.DataLoader at 0x154a4020f40>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create datasets and data loaders\n",
    "# Transformations\n",
    "\n",
    "from torchvision import datasets, models, transforms\n",
    "data_transforms = transforms.Compose([\n",
    "        transforms.Resize(64),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])\n",
    "    ])\n",
    "\n",
    "train_dataset = datasets.ImageFolder(os.path.join(DATASET_PATH, 'train'), data_transforms)\n",
    "train_loader = DataLoader(train_dataset, BATCH_SIZE, shuffle=True, num_workers=2, pin_memory=True)\n",
    "\n",
    "\n",
    "test_dataset = datasets.ImageFolder(os.path.join(DATASET_PATH, 'test'), data_transforms)\n",
    "test_loader = DataLoader(test_dataset, BATCH_SIZE, shuffle=False, num_workers=2, pin_memory=True)\n",
    "\n",
    "class_names = train_dataset.classes\n",
    "\n",
    "print('Dataloaders OK')\n",
    "test_loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1b611aaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image label: 6\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x154a3f92520>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Print the corresponding label for the image\n",
    "\n",
    "random_image = train_dataset[13421][0].numpy().transpose((1, 2, 0))   \n",
    "mean = np.array([0.485, 0.456, 0.406])\n",
    "std = np.array([0.229, 0.224, 0.225])\n",
    "random_image = std * random_image + mean\n",
    "random_image = np.clip(random_image, 0, 1)\n",
    "print(\"Image label:\", train_dataset[13421][1])\n",
    "plt.imshow(random_image)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcbc1eb2",
   "metadata": {},
   "source": [
    "# Residual Network Architecture"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b4c9020c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create the model class with ResNet\n",
    "def conv3x3(in_channels, out_channels, stride=1):\n",
    "    return nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False)\n",
    "\n",
    "class ResidualBlock(nn.Module):\n",
    "    def __init__(self, in_channels, out_channels, stride=1, downsample=None):\n",
    "        super(ResidualBlock, self).__init__()\n",
    "        self.conv1 = conv3x3(in_channels, out_channels, stride)\n",
    "        self.bn1 = nn.BatchNorm2d(out_channels)\n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.conv2 = conv3x3(out_channels, out_channels)\n",
    "        self.bn2 = nn.BatchNorm2d(out_channels)\n",
    "        self.downsample = downsample\n",
    "        \n",
    "    def forward(self, x):\n",
    "        residual = x\n",
    "        out = self.conv1(x)\n",
    "        out = self.bn1(out)\n",
    "        out = self.relu(out)\n",
    "        out = self.conv2(out)\n",
    "        out = self.bn2(out)\n",
    "        if self.downsample:\n",
    "            residual = self.downsample(x)\n",
    "        out += residual\n",
    "        out = self.relu(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "dd340b1a",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ResNet(nn.Module):\n",
    "    def __init__(self, block, layers, num_classes=10):\n",
    "        super(ResNet, self).__init__()\n",
    "        self.in_channels = 16 \n",
    "        self.conv = conv3x3(3, 16)\n",
    "        self.bn = nn.BatchNorm2d(16) \n",
    "        self.relu = nn.ReLU(inplace=True)\n",
    "        self.layer1 = self.make_layer(block, 16, layers[0], 1)\n",
    "        self.layer2 = self.make_layer(block, 32, layers[1], 2)\n",
    "        self.layer3 = self.make_layer(block, 64, layers[2], 2)\n",
    "        self.avg_pool = nn.AvgPool2d(16)\n",
    "        self.fc = nn.Linear(64, num_classes)\n",
    "        \n",
    "    def make_layer(self, block, out_channels, blocks, stride=1):\n",
    "        downsample = None\n",
    "        if (stride != 1) or (self.in_channels != out_channels):\n",
    "            downsample = nn.Sequential(conv3x3(self.in_channels, out_channels, stride=stride),\n",
    "                                       nn.BatchNorm2d(out_channels))\n",
    "        layers = []\n",
    "        layers.append(block(self.in_channels, out_channels, stride, downsample))\n",
    "        self.in_channels = out_channels\n",
    "        for i in range(1, blocks):\n",
    "            layers.append(block(out_channels, out_channels))\n",
    "        return nn.Sequential(*layers)\n",
    "    \n",
    "    def forward(self, x):\n",
    "        out = self.conv(x)\n",
    "        out = self.bn(out)\n",
    "        out = self.relu(out)\n",
    "        out = self.layer1(out)\n",
    "        out = self.layer2(out)\n",
    "        out = self.layer3(out)\n",
    "        out = self.avg_pool(out)\n",
    "        out = out.view(x.size(0), -1)\n",
    "        out = self.fc(out)\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd9e37ce",
   "metadata": {},
   "source": [
    "# Create models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f77f06a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create network\n",
    "model = ResNet(ResidualBlock, [2, 2, 2])\n",
    "if USE_CUDA:\n",
    "    model = model.cuda()  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "711b61a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define criterion, optimizer, and scheduler\n",
    "\n",
    "criterion = nn.CrossEntropyLoss()  \n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=LEARNING_RATE, momentum=MOMENTUM, weight_decay=WEIGHT_DECAY)\n",
    "scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=7, gamma=0.1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f4c9f1f",
   "metadata": {},
   "source": [
    "# Training with ResNet"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "df2bc401",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "Running epoch 1 of 25...\n",
      "\n",
      "\n",
      "Epoch 1 validation results: Loss=0.8446428609244964 | Accuracy=69.72222137451172\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 2 of 25...\n",
      "\n",
      "\n",
      "Epoch 2 validation results: Loss=0.5829719642067657 | Accuracy=79.96295928955078\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 3 of 25...\n",
      "\n",
      "\n",
      "Epoch 3 validation results: Loss=0.48173841733266326 | Accuracy=84.05555725097656\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 4 of 25...\n",
      "\n",
      "\n",
      "Epoch 4 validation results: Loss=0.41246457104297246 | Accuracy=86.48148345947266\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 5 of 25...\n",
      "\n",
      "\n",
      "Epoch 5 validation results: Loss=0.588005422231029 | Accuracy=79.61111450195312\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 6 of 25...\n",
      "\n",
      "\n",
      "Epoch 6 validation results: Loss=0.4199164312990273 | Accuracy=86.0740737915039\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 7 of 25...\n",
      "\n",
      "\n",
      "Epoch 7 validation results: Loss=0.35857671645524747 | Accuracy=88.01851654052734\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 8 of 25...\n",
      "\n",
      "\n",
      "Epoch 8 validation results: Loss=0.24340899664470378 | Accuracy=92.25926208496094\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 9 of 25...\n",
      "\n",
      "\n",
      "Epoch 9 validation results: Loss=0.23386396232115872 | Accuracy=92.64814758300781\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 10 of 25...\n",
      "\n",
      "\n",
      "Epoch 10 validation results: Loss=0.22563818443347425 | Accuracy=92.85185241699219\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 11 of 25...\n",
      "\n",
      "\n",
      "Epoch 11 validation results: Loss=0.22737063640619026 | Accuracy=92.70370483398438\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 12 of 25...\n",
      "\n",
      "\n",
      "Epoch 12 validation results: Loss=0.21958333583658232 | Accuracy=93.0\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 13 of 25...\n",
      "\n",
      "\n",
      "Epoch 13 validation results: Loss=0.21333659149377662 | Accuracy=93.24073791503906\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 14 of 25...\n",
      "\n",
      "\n",
      "Epoch 14 validation results: Loss=0.2264574846088448 | Accuracy=92.48148345947266\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 15 of 25...\n",
      "\n",
      "\n",
      "Epoch 15 validation results: Loss=0.20778077644679477 | Accuracy=93.29629516601562\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 16 of 25...\n",
      "\n",
      "\n",
      "Epoch 16 validation results: Loss=0.20989152906352984 | Accuracy=93.05555725097656\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 17 of 25...\n",
      "\n",
      "\n",
      "Epoch 17 validation results: Loss=0.20730044051237842 | Accuracy=93.40740966796875\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 18 of 25...\n",
      "\n",
      "\n",
      "Epoch 18 validation results: Loss=0.20646367304246216 | Accuracy=93.25926208496094\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 19 of 25...\n",
      "\n",
      "\n",
      "Epoch 19 validation results: Loss=0.20829590385889304 | Accuracy=93.44444274902344\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 20 of 25...\n",
      "\n",
      "\n",
      "Epoch 20 validation results: Loss=0.20508580040186644 | Accuracy=93.38888549804688\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 21 of 25...\n",
      "\n",
      "\n",
      "Epoch 21 validation results: Loss=0.20657724000732688 | Accuracy=93.35185241699219\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 22 of 25...\n",
      "\n",
      "\n",
      "Epoch 22 validation results: Loss=0.20511760120006167 | Accuracy=93.38888549804688\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 23 of 25...\n",
      "\n",
      "\n",
      "Epoch 23 validation results: Loss=0.20720102396958015 | Accuracy=93.12963104248047\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 24 of 25...\n",
      "\n",
      "\n",
      "Epoch 24 validation results: Loss=0.2098631633062135 | Accuracy=93.18518829345703\n",
      "\n",
      "\n",
      "\n",
      "Running epoch 25 of 25...\n",
      "\n",
      "\n",
      "Epoch 25 validation results: Loss=0.21340482519829976 | Accuracy=93.05555725097656\n",
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Main loop\n",
    "train_loss = []\n",
    "train_accuracy = []\n",
    "test_loss = []\n",
    "test_accuracy = []\n",
    "epochs = []\n",
    "\n",
    "for epoch in range(1, NUM_EPOCHS+1):\n",
    "    print(f'\\n\\nRunning epoch {epoch} of {NUM_EPOCHS}...\\n')\n",
    "    epochs.append(epoch)\n",
    "\n",
    "    #-------------------------Train-------------------------\n",
    "    \n",
    "    #Reset these below variables to 0 at the begining of every epoch\n",
    "    correct = 0\n",
    "    iterations = 0\n",
    "    iter_loss = 0.0\n",
    "    \n",
    "    model.train()  # Put the network into training mode\n",
    "    \n",
    "    for i, (inputs, labels) in enumerate(train_loader):\n",
    "        if USE_CUDA:\n",
    "            inputs = inputs.cuda()\n",
    "            labels = labels.cuda()        \n",
    "            \n",
    "        outputs = model(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        iter_loss += loss.item()  # Accumulate the loss\n",
    "        optimizer.zero_grad() # Clear off the gradient in (w = w - gradient)\n",
    "        loss.backward()   # Backpropagation \n",
    "        optimizer.step()  # Update the weights\n",
    "        \n",
    "        # Record the correct predictions for training data \n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        correct += (predicted == labels).sum()\n",
    "        iterations += 1\n",
    "        \n",
    "    scheduler.step()\n",
    "        \n",
    "    # Record the training loss\n",
    "    train_loss.append(iter_loss/iterations)\n",
    "    # Record the training accuracy\n",
    "    train_accuracy.append((100 * correct / len(train_dataset)))   \n",
    "     \n",
    "    #-------------------------Test--------------------------\n",
    "    \n",
    "    correct = 0\n",
    "    iterations = 0\n",
    "    testing_loss = 0.0\n",
    "    \n",
    "    model.eval()  # Put the network into evaluation mode\n",
    "    \n",
    "    for i, (inputs, labels) in enumerate(test_loader):\n",
    "\n",
    "        if USE_CUDA:\n",
    "            inputs = inputs.cuda()\n",
    "            labels = labels.cuda()\n",
    "        \n",
    "        outputs = model(inputs)     \n",
    "        loss = criterion(outputs, labels) # Calculate the loss\n",
    "        testing_loss += loss.item()\n",
    "        # Record the correct predictions for training data\n",
    "        _, predicted = torch.max(outputs, 1)\n",
    "        correct += (predicted == labels).sum()\n",
    "        \n",
    "        iterations += 1\n",
    "\n",
    "    # Record the Testing loss\n",
    "    test_loss.append(testing_loss/iterations)\n",
    "    # Record the Testing accuracy\n",
    "    test_accuracy.append((100 * correct / len(test_dataset)))\n",
    "   \n",
    "    print(f'\\nEpoch {epoch} validation results: Loss={test_loss[-1]} | Accuracy={test_accuracy[-1]}\\n')\n",
    "\n",
    "\n",
    "    # Plot and save\n",
    "    plt.figure(figsize=(12, 8), num=1)\n",
    "    plt.clf()\n",
    "    plt.plot(epochs, train_loss, label='Train')\n",
    "    plt.plot(epochs, test_loss, label='Test')\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.title('Cross entropy loss')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.savefig('outputs/01-loss-resnet.pdf')\n",
    "\n",
    "    plt.figure(figsize=(12, 8), num=2)\n",
    "    plt.clf()\n",
    "    plt.plot(epochs, train_accuracy, label='Train')\n",
    "    plt.plot(epochs, test_accuracy, label='Test')\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.title('Accuracy')\n",
    "    plt.xlabel('Epoch')\n",
    "    plt.ylabel('Accuracy')\n",
    "    plt.savefig('outputs/02-accuracy-resnet.pdf')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7deefb22",
   "metadata": {},
   "source": [
    "# Results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "120f56be",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Final train loss: 0.21561731184287183\n",
      "Final test loss: 0.21340482519829976\n",
      "Final train accuracy: 93.14814758300781\n",
      "Final test accuracy: 93.05555725097656\n"
     ]
    }
   ],
   "source": [
    "print(f'Final train loss: {train_loss[-1]}')\n",
    "print(f'Final test loss: {test_loss[-1]}')\n",
    "print(f'Final train accuracy: {train_accuracy[-1]}')\n",
    "print(f'Final test accuracy: {test_accuracy[-1]}')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}