Alexnet_Normal_Training_With_Parameter_Averaging.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AhmadHossain8/Food-Image-Classification/blob/main/Alexnet_Normal_Training_With_Parameter_Averaging.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4b3Pd2EDFGDd"
      },
      "outputs": [],
      "source": [
        "\n",
        "import torch\n",
        "from torch.utils.data import Dataset\n",
        "import numpy as np\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')\n",
        "import zipfile\n",
        "import os\n",
        "import pandas as pd\n",
        "from PIL import Image\n",
        "from torchvision import transforms\n",
        "import os\n",
        "import time\n",
        "import pandas as pd\n",
        "from PIL import Image\n",
        "from torchvision import transforms,models\n",
        "import matplotlib.pyplot as plt\n",
        "from skimage import io,transform\n",
        "\n",
        "device =torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "device\n",
        "\n",
        "\"\"\"**Unzip**\"\"\"\n",
        "\n",
        "DATA_SET_ZIP = '/content/drive/MyDrive/Food 11.zip'\n",
        "with zipfile.ZipFile(DATA_SET_ZIP,\"r\") as zip_ref:\n",
        "  zip_ref.extractall(\"data\")\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "8RAZL-snHxFN"
      },
      "outputs": [],
      "source": [
        "path_of_training_data = '/content/data/training'\n",
        "path_of_evaluation_data = '/content/data/evaluation'\n",
        "path_of_validation_data = '/content/data/validation'\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "-nynPVEhH1a-"
      },
      "outputs": [],
      "source": [
        "class Food_11_Dataset(Dataset):\n",
        "  def __init__(self,data_dir, transform=None):\n",
        "    self.date_dir = data_dir\n",
        "    self.image_list = os.listdir(data_dir)\n",
        "    self.transform = transform\n",
        "\n",
        "  def __getitem__(self,idx):\n",
        "    location = os.path.join(self.date_dir,self.image_list[idx])\n",
        "    image = Image.open(location)\n",
        "    if self.transform is not None:\n",
        "            image = self.transform(image)\n",
        "    label = self.image_list[idx]\n",
        "    label = label.split(\"_\")\n",
        "    label = int(label[0])\n",
        "    return image,label\n",
        "\n",
        "  def __len__(self):\n",
        "    return len(self.image_list)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NDeZ9pyRH8Xh"
      },
      "outputs": [],
      "source": [
        "batch_size = 64\n",
        "\n",
        "transform1 = transforms.Compose(\n",
        "    [transforms.Resize((227,227)),\n",
        "     transforms.RandomHorizontalFlip(),\n",
        "     transforms.ToTensor(),\n",
        "     transforms.Normalize([0.5,0.5,0.5],[0.5,0.5,0.5])\n",
        "    ])\n",
        "\n",
        "transform2 = transforms.Compose(\n",
        "    [transforms.Resize((227,227)),\n",
        "     transforms.RandomHorizontalFlip(),\n",
        "     transforms.ToTensor(),\n",
        "     transforms.Normalize([0.5548, 0.4503, 0.3438],[0.2281, 0.2386, 0.2374])\n",
        "    ])\n",
        "\n",
        "trainset1 = Food_11_Dataset(path_of_training_data,transform=transform1)\n",
        "evaluationset1 = Food_11_Dataset(path_of_evaluation_data,transform=transform1)\n",
        "validset1 = Food_11_Dataset(path_of_validation_data,transform=transform1)\n",
        "\n",
        "\n",
        "\"\"\"**DataLoader**\"\"\"\n",
        "\n",
        "#for normalization1\n",
        "trainset_loader1 = torch.utils.data.DataLoader(trainset1, batch_size=batch_size, shuffle=True)\n",
        "evaluationset_loader1 = torch.utils.data.DataLoader(evaluationset1, batch_size=batch_size, shuffle=True)\n",
        "validset_loader1 = torch.utils.data.DataLoader(validset1, batch_size=batch_size, shuffle=True)\n",
        "\n",
        "\n",
        "import torch.nn as nn\n",
        "number_of_class=11\n",
        "import math\n",
        "\n",
        "#model parameter average\n",
        "model1 = torch.hub.load('pytorch/vision:v0.13.0', 'alexnet', pretrained=True)\n",
        "model1.classifier[6] = torch.nn.Linear(4096,11)\n",
        "model1.to(device)\n",
        "\n",
        "import copy\n",
        "num_epochs = 100\n",
        "\n",
        "#for normalization1\n",
        "learning_rate1 = 0.001\n",
        "\n",
        "\n",
        "\n",
        "PATH1 = \"/content/drive/MyDrive/New Test/model1.pth\"\n",
        "AVG_PATH1 = \"/content/drive/MyDrive/New Test/my_saves_avg.pth\"\n",
        "\n",
        "\n",
        "#for normalization1\n",
        "criterion1 = nn.CrossEntropyLoss()\n",
        "optimizer1 = torch.optim.SGD(model1.parameters(), lr=learning_rate1, weight_decay = 0.005, momentum = 0.9)\n",
        "\n",
        "\n",
        "epoch1 = 0\n",
        "loss1 = 0.0\n",
        "best_acc1 = 0.0\n",
        "best_model_weights1 = []\n",
        "avg_model_weights1 = []\n",
        "\n",
        "\n",
        "\n",
        "if os.path.getsize(PATH1) > 0:\n",
        "  checkpoint = torch.load(PATH1)\n",
        "  model1.load_state_dict(checkpoint['model_state_dict'])\n",
        "  optimizer1.load_state_dict(checkpoint['optimizer_state_dict'])\n",
        "  epoch1 = checkpoint['epoch']\n",
        "  loss1 = checkpoint['loss']\n",
        "  best_acc1 = checkpoint['best_acc']\n",
        "  best_model_weights1 = copy.deepcopy(model1.state_dict())\n",
        "\n",
        "\n",
        "#Normal training\n",
        "model2 = torch.hub.load('pytorch/vision:v0.13.0', 'alexnet', pretrained=True)\n",
        "model2.to(device)\n",
        "\n",
        "\n",
        "PATH2 = \"/content/drive/MyDrive/New Test/model2.pth\"\n",
        "\n",
        "#for normalization1\n",
        "criterion2 = nn.CrossEntropyLoss()\n",
        "optimizer2 = torch.optim.SGD(model2.parameters(), lr=learning_rate1, weight_decay = 0.005, momentum = 0.9)\n",
        "\n",
        "\n",
        "epoch2 = 0\n",
        "loss2 = 0.0\n",
        "best_acc2 = 0.0\n",
        "best_model_weights2 = []\n",
        "\n",
        "\n",
        "\n",
        "if os.path.getsize(PATH2) > 0:\n",
        "  checkpoint = torch.load(PATH2)\n",
        "  model2.load_state_dict(checkpoint['model_state_dict'])\n",
        "  optimizer2.load_state_dict(checkpoint['optimizer_state_dict'])\n",
        "  epoch2 = checkpoint['epoch']\n",
        "  loss2 = checkpoint['loss']\n",
        "  best_acc2 = checkpoint['best_acc']\n",
        "  best_model_weights2 = copy.deepcopy(model2.state_dict())\n",
        "\n",
        "\n",
        "total_step1 = len(trainset_loader1)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4AkHhullIhk3"
      },
      "outputs": [],
      "source": [
        "len(validset1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "bFpcJnWbI4eK"
      },
      "outputs": [],
      "source": [
        "model1_info = {'train_loss' : [] , 'val_acc' : []}\n",
        "PATH1_acc = \"/content/drive/MyDrive/New Test/model1_acc.pth\"\n",
        "if os.path.getsize(PATH1_acc) > 0:\n",
        "  model1_info = torch.load(PATH1_acc)\n",
        "\n",
        "if os.path.getsize(AVG_PATH1) > 0:\n",
        "  checkpoint = torch.load(AVG_PATH1)\n",
        "  avg_model_weights1 = checkpoint['model_state_dict']\n",
        "\n",
        "prev_model = []\n",
        "if len(avg_model_weights1) != 0:\n",
        "  prev_model = avg_model_weights1\n",
        "\n",
        "\n",
        "model2_info = {'train_loss' : [] , 'val_acc' : []}\n",
        "PATH2_acc = \"/content/drive/MyDrive/New Test/model2_acc.pth\"\n",
        "if os.path.getsize(PATH2_acc) > 0:\n",
        "  model2_info = torch.load(PATH2_acc)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "NnL0ECTq6JlF"
      },
      "outputs": [],
      "source": [
        "\n",
        "\n",
        "start_time = time.time()\n",
        "new_time1 = time.time()\n",
        "new_time2 = time.time()\n",
        "\"\"\"**Train**\"\"\"\n",
        "\n",
        "for epoch in range(num_epochs):\n",
        "    new_time1 = time.time()\n",
        "    start_time = time.time()\n",
        "    #Model1\n",
        "    print('Epoch [{}/{}]' .format(epoch+1, num_epochs))\n",
        "    model1.train()\n",
        "    for i, (images, labels) in enumerate(trainset_loader1):  \n",
        "        # Move tensors to the configured device\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        \n",
        "        \n",
        "        # Forward pass\n",
        "        outputs = model1(images)\n",
        "        loss1 = criterion1(outputs, labels)\n",
        "        \n",
        "        # Backward and optimize\n",
        "        optimizer1.zero_grad()\n",
        "        loss1.backward()\n",
        "        optimizer1.step()\n",
        "\n",
        "    print ('Model 1 Step [{}/{}], Loss: {:.4f}' \n",
        "                   .format( i+1, total_step1, loss1.item()))\n",
        "    model1_info['train_loss'].append(loss1.item())\n",
        "\n",
        "    if epoch+1 == 50:\n",
        "      prev_model = best_model_weights1\n",
        "       \n",
        "    elif epoch+1 > 50:\n",
        "        temp_model = copy.deepcopy(model1.state_dict())\n",
        "        for key in prev_model:\n",
        "          prev_model[key] = (prev_model[key] + temp_model[key]) / 2.0\n",
        "          model1.load_state_dict(prev_model)\n",
        "    torch.save({\n",
        "          'model_state_dict': model1.state_dict(),\n",
        "          },AVG_PATH1)       \n",
        "       \n",
        "    # Validation\n",
        "    model1.eval()\n",
        "    with torch.set_grad_enabled(False):\n",
        "        correct = 0\n",
        "        total = 0\n",
        "        for images, labels in validset_loader1:\n",
        "            images = images.to(device)\n",
        "            labels = labels.to(device)\n",
        "            outputs = model1(images)\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "            del images, labels, outputs\n",
        "        accuracy= 100 * correct / total\n",
        "        model1_info['val_acc'].append(accuracy)\n",
        "        torch.save(model1_info,PATH1_acc)  \n",
        "        print('Accuracy of the network on the {} validation images: {} % and time taken {} min'.format(total, accuracy,(time.time() - new_time1)/60))\n",
        "        if accuracy > best_acc1 : \n",
        "            best_acc1 = (100 * correct / total)\n",
        "            best_model_weights1 = copy.deepcopy(model1.state_dict())\n",
        "            torch.save({\n",
        "            'epoch': epoch,\n",
        "            'model_state_dict': model1.state_dict(),\n",
        "            'optimizer_state_dict': optimizer1.state_dict(),\n",
        "            'loss': loss1,\n",
        "            'best_acc' : best_acc1,\n",
        "            },PATH1)\n",
        "    #Model 2\n",
        "    new_time2 = time.time()\n",
        "    model2.train()\n",
        "    for i, (images, labels) in enumerate(trainset_loader1):  \n",
        "        # Move tensors to the configured device\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        \n",
        "        \n",
        "        # Forward pass\n",
        "        outputs = model2(images)\n",
        "        loss2 = criterion2(outputs, labels)\n",
        "        \n",
        "        # Backward and optimize\n",
        "        optimizer2.zero_grad()\n",
        "        loss2.backward()\n",
        "        optimizer2.step()\n",
        "\n",
        "    print ('Model 2 Step [{}/{}], Loss: {:.4f}' \n",
        "                   .format( i+1, total_step1, loss2.item()))\n",
        "    model2_info['train_loss'].append(loss2.item())\n",
        "\n",
        "    # Validation\n",
        "    model2.eval()\n",
        "    with torch.set_grad_enabled(False):\n",
        "        correct = 0\n",
        "        total = 0\n",
        "        for images, labels in validset_loader1:\n",
        "            images = images.to(device)\n",
        "            labels = labels.to(device)\n",
        "            outputs = model2(images)\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "            del images, labels, outputs\n",
        "        accuracy= 100 * correct / total\n",
        "        model2_info['val_acc'].append(accuracy)\n",
        "        torch.save(model2_info,PATH2_acc)  \n",
        "        print('Accuracy of the network on the {} validation images: {} % and time taken {} min'.format(total, accuracy,(time.time() - new_time2)/60))\n",
        "        if accuracy > best_acc2 : \n",
        "            best_acc2 = (100 * correct / total)\n",
        "            best_model_weights2 = copy.deepcopy(model2.state_dict())\n",
        "            torch.save({\n",
        "            'epoch': epoch,\n",
        "            'model_state_dict': model2.state_dict(),\n",
        "            'optimizer_state_dict': optimizer2.state_dict(),\n",
        "            'loss': loss2,\n",
        "            'best_acc' : best_acc2,\n",
        "            },PATH2)\n",
        "  \n",
        "\n",
        "elapsed = (time.time() - start_time)/60\n",
        "print(f'Total Training Time: {elapsed:.2f} min')\n",
        "\n",
        "model1.load_state_dict(best_model_weights1)\n",
        "model1.eval()\n",
        "\n",
        "#For Model1\n",
        "with torch.set_grad_enabled(False):\n",
        "        correct = 0\n",
        "        total = 0\n",
        "        for images, labels in validset_loader1:\n",
        "            images = images.to(device)\n",
        "            labels = labels.to(device)\n",
        "            outputs = model1(images)\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "            del images, labels, outputs\n",
        "        accuracy= 100 * correct / total\n",
        "    \n",
        "        print('Accuracy of the model1 on the {} validation images: {} %'.format(total, accuracy))\n",
        "\n",
        "with torch.set_grad_enabled(False):\n",
        "        correct = 0\n",
        "        total = 0\n",
        "        for images, labels in evaluationset_loader1:\n",
        "            images = images.to(device)\n",
        "            labels = labels.to(device)\n",
        "            outputs = model1(images)\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "            del images, labels, outputs\n",
        "        accuracy= 100 * correct / total\n",
        "    \n",
        "        print('Accuracy of the model1 on the {} Evaluation images: {} %'.format(total, accuracy))\n",
        "\n",
        "\n",
        "model2.load_state_dict(best_model_weights2)\n",
        "model2.eval()\n",
        "with torch.set_grad_enabled(False):\n",
        "        correct = 0\n",
        "        total = 0\n",
        "        for images, labels in validset_loader1:\n",
        "            images = images.to(device)\n",
        "            labels = labels.to(device)\n",
        "            outputs = model2(images)\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "            del images, labels, outputs\n",
        "        accuracy= 100 * correct / total\n",
        "    \n",
        "        print('Accuracy of the model 2 on the {} validation images: {} %'.format(total, accuracy))\n",
        "\n",
        "with torch.set_grad_enabled(False):\n",
        "        correct = 0\n",
        "        total = 0\n",
        "        for images, labels in evaluationset_loader1:\n",
        "            images = images.to(device)\n",
        "            labels = labels.to(device)\n",
        "            outputs = model2(images)\n",
        "            _, predicted = torch.max(outputs.data, 1)\n",
        "            total += labels.size(0)\n",
        "            correct += (predicted == labels).sum().item()\n",
        "            del images, labels, outputs\n",
        "        accuracy= 100 * correct / total\n",
        "    \n",
        "        print('Accuracy of the model 2 on the {} Evaluation images: {} %'.format(total, accuracy))\n",
        "\n",
        "#MODEL 1\n",
        "plt.figure(figsize=(10,5))\n",
        "plt.title(\"Training loss and Validation Accuracy of model 1\")\n",
        "plt.plot(model1_info['val_acc'],label=\"val\")\n",
        "plt.plot(model1_info['train_loss'],label=\"train\")\n",
        "plt.xlabel(\"iterations\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "\n",
        "#MODEL 2\n",
        "plt.figure(figsize=(10,5))\n",
        "plt.title(\"Training loss and Validation Accuracy of model 1\")\n",
        "plt.plot(model2_info['val_acc'],label=\"val\")\n",
        "plt.plot(model2_info['train_loss'],label=\"train\")\n",
        "plt.xlabel(\"iterations\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.legend()\n",
        "plt.show()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "r-LgnWLnpP99"
      },
      "outputs": [],
      "source": [
        "with torch.set_grad_enabled(False):\n",
        "  correct = 0\n",
        "  total = 0\n",
        "  for images, labels in trainset_loader1:\n",
        "      images = images.to(device)\n",
        "      labels = labels.to(device)\n",
        "      outputs = model1(images)\n",
        "      _, predicted = torch.max(outputs.data, 1)\n",
        "      total += labels.size(0)\n",
        "      correct += (predicted == labels).sum().item()\n",
        "      del images, labels, outputs\n",
        "  accuracy= 100 * correct / total\n",
        "\n",
        "  print('Accuracy of the model1 on the {} training images: {} %'.format(total, accuracy))\n",
        "\n"
      ]
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "machine_shape": "hm",
      "provenance": [],
      "include_colab_link": true
    },
    "gpuClass": "standard",
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.10.8 (tags/v3.10.8:aaaf517, Oct 11 2022, 16:50:30) [MSC v.1933 64 bit (AMD64)]"
    },
    "vscode": {
      "interpreter": {
        "hash": "99f3cd6e142120424ee9b340f0a72fd1732cf789e0a499e2c90251ee424f3513"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}