model/Plant_Disease_Identifier.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Plant_Disease_Identifier.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "dStzBwM0I5hq"
      },
      "source": [
        "!wget https://github.com/nandakishormpai2001/Plant_Disease_Detector/raw/main/model/dataset.zip"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "w_-vVsdFTRtu"
      },
      "source": [
        "!unzip dataset.zip"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HJi72ExwQwt7"
      },
      "source": [
        "!pip install -r requirements.txt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "STy4Cqp3SS11"
      },
      "source": [
        "from PIL import Image\n",
        "import torch\n",
        "import torchvision\n",
        "from torchvision.transforms import ToTensor\n",
        "import torchvision.transforms as transforms\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torch.nn.functional as F\n",
        "import os\n",
        "import pickle"
      ],
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Wx-fwpX-Stpz"
      },
      "source": [
        "class Dataset():\n",
        "    def __init__(self):\n",
        "        self.labels,self.images = self.load_data()\n",
        "\n",
        "    # To load images and labels for dataloader\n",
        "    def load_data(self):\n",
        "        labels={}\n",
        "        images = {}\n",
        "        count = 0\n",
        "        # setting resize dimensions\n",
        "        resize = transforms.Compose([transforms.Resize((256,256))])\n",
        "        main_dir = os.listdir(os.path.join(\"dataset\",\"train\"))\n",
        "        reference = {}\n",
        "        # iterating through categories\n",
        "        for i,dir in enumerate(main_dir):\n",
        "            reference[dir]=i\n",
        "            images_list = os.listdir(os.path.join(\"dataset\",\"train\",dir))\n",
        "            local_cnt = 0\n",
        "            # iterating through images in a category\n",
        "            for img in images_list:\n",
        "                # 500 images from each category\n",
        "                if local_cnt<500:\n",
        "                    labels[count] = i\n",
        "                    img_path = os.path.join(\"dataset\",\"train\",dir,img)\n",
        "                    image = Image.open(img_path)\n",
        "                    image = ToTensor()(image)\n",
        "                    images[count] = resize(image)\n",
        "                    count+=1\n",
        "                    local_cnt+=1\n",
        "                else:\n",
        "                    break\n",
        "\n",
        "        print(reference)\n",
        "        return labels,images\n",
        "      \n",
        "    def __len__(self):\n",
        "        return len(self.labels)\n",
        "    \n",
        "\n",
        "    # To return x,y values in each iteration over dataloader as batches.\n",
        "    def __getitem__(self, idx):\n",
        "        return (\n",
        "            self.images[idx],\n",
        "            self.labels[idx],\n",
        "        )"
      ],
      "execution_count": 3,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yG0jLPt3g_uu"
      },
      "source": [
        "# Inherit from Dataset class\n",
        "class ValDataset(Dataset):\n",
        "\n",
        "    def load_data(self):\n",
        "          labels={}\n",
        "          images = {}\n",
        "          count = 0\n",
        "          resize = transforms.Compose([transforms.Resize((256,256))])\n",
        "          main_dir = os.listdir(os.path.join(\"dataset\",\"valid\"))\n",
        "          for i,dir in enumerate(main_dir):\n",
        "              print(i,dir)\n",
        "              images_list = os.listdir(os.path.join(\"dataset\",\"valid\",dir))\n",
        "              local_cnt = 0\n",
        "              for img in images_list:\n",
        "                  if(local_cnt<100):\n",
        "                      labels[count] = i\n",
        "                      img_path = os.path.join(\"dataset\",\"valid\",dir,img)\n",
        "                      image = Image.open(img_path)\n",
        "                      image = ToTensor()(image)\n",
        "                      images[count] = resize(image)\n",
        "                      count+=1\n",
        "                      local_cnt+=1\n",
        "                  else:\n",
        "                      break\n",
        "\n",
        "          return labels,images\n"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZA5x0xiGQGDC"
      },
      "source": [
        "# Model Architecture\n",
        "class Network(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Network,self).__init__()\n",
        "\n",
        "        # CNNs for rgb images \n",
        "        self.conv1= nn.Conv2d(in_channels=3,out_channels=6,kernel_size=5)\n",
        "        self.conv2= nn.Conv2d(in_channels=6,out_channels=12,kernel_size=5)\n",
        "        self.conv3= nn.Conv2d(in_channels=12,out_channels=24,kernel_size=5)\n",
        "        self.conv4= nn.Conv2d(in_channels=24,out_channels=48,kernel_size=5)\n",
        "        \n",
        "        # Connecting CNN outputs with Fully Connected layers\n",
        "        self.fc1 = nn.Linear(in_features=48*12*12,out_features=240)\n",
        "        self.fc2 = nn.Linear(in_features=240,out_features=120)\n",
        "        self.out = nn.Linear(in_features=120,out_features=17)\n",
        "        \n",
        "        \n",
        "    def forward(self,t):\n",
        "        t = t\n",
        "        \n",
        "        t=self.conv1(t)\n",
        "        t=F.relu(t)\n",
        "        t=F.max_pool2d(t,kernel_size = 2, stride = 2)\n",
        "        \n",
        "        \n",
        "        t=self.conv2(t)\n",
        "        t=F.relu(t)\n",
        "        t=F.max_pool2d(t,kernel_size = 2, stride = 2)\n",
        "\n",
        "        t=self.conv3(t)\n",
        "        t=F.relu(t)\n",
        "        t=F.max_pool2d(t,kernel_size = 2, stride = 2)\n",
        "\n",
        "        t=self.conv4(t)\n",
        "        t=F.relu(t)\n",
        "        t=F.max_pool2d(t,kernel_size = 2, stride = 2)\n",
        "        \n",
        "        t=t.reshape(-1,48*12*12)\n",
        "        t=self.fc1(t)\n",
        "        t=F.relu(t)\n",
        "        \n",
        "        \n",
        "        t=self.fc2(t)\n",
        "        t=F.relu(t)\n",
        "        \n",
        "        t=self.out(t)\n",
        "        \n",
        "        \n",
        "        return t"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ryeGo-1M_cJr"
      },
      "source": [
        "model = Network()"
      ],
      "execution_count": 20,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gcJOyp8BKWaZ"
      },
      "source": [
        "dataset = Dataset()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "vEESPZpR9u_Y"
      },
      "source": [
        "valdataset = ValDataset()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6SdDIDphMlqK"
      },
      "source": [
        "# Function to return number of correct predictions in a batch\n",
        "def get_num_correct(preds,labels):\n",
        "    return preds.argmax(dim=1).eq(labels).sum().item()"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uqOK7S92LAoi"
      },
      "source": [
        "def train(dataset,valdataset, model):\n",
        "    model.train()\n",
        "\n",
        "    # dataloader in pytorch to load validation and train dataset\n",
        "    dataloader = torch.utils.data.DataLoader(dataset, batch_size=64,shuffle=True)\n",
        "    valdataloader = torch.utils.data.DataLoader(valdataset, batch_size=32,shuffle=True)\n",
        "\n",
        "    # Defining the loss and optimizer\n",
        "    criterion = nn.CrossEntropyLoss()\n",
        "    optimizer = optim.Adam(model.parameters(), lr=0.001)\n",
        "    num_of_epochs = 20\n",
        "    epochs = []\n",
        "    losses = []\n",
        "    for epoch in range(num_of_epochs):\n",
        "        cnt = 0\n",
        "        tot_loss = 0\n",
        "        tot_correct = 0\n",
        "        for batch, (x, y) in enumerate(dataloader):\n",
        "            # Sets the gradients of all optimized tensors to zero\n",
        "            optimizer.zero_grad()\n",
        "            y_pred = model(x)\n",
        "            # Compute loss (here CrossEntropyLoss)\n",
        "            loss = F.cross_entropy(y_pred,y)\n",
        "\n",
        "            loss.backward()\n",
        "            optimizer.step()\n",
        "\n",
        "        for batch, (x, y) in enumerate(valdataloader):\n",
        "            # Sets the gradients of all optimized tensors to zero\n",
        "            optimizer.zero_grad()\n",
        "            with torch.no_grad():\n",
        "                y_pred = model(x)\n",
        "                # Compute loss (here CrossEntropyLoss)\n",
        "                loss = F.cross_entropy(y_pred,y)\n",
        "\n",
        "            tot_loss+=loss.item()\n",
        "            tot_correct +=get_num_correct(y_pred,y)\n",
        "        epochs.append(epoch)\n",
        "        losses.append(tot_loss)\n",
        "        print(\"Epoch\",epoch,\"total_correct\",tot_correct,\"loss:\",tot_loss)\n",
        "        torch.save(model.state_dict(), \"model002_ep\"+str(epoch+1)+\".pth\")\n",
        "\n",
        "    # Plot a Validation Loss vs Epochs graph \n",
        "    plt.plot(epochs, losses, color='green', linewidth = 3, \n",
        "         marker='o', markerfacecolor='blue', markersize=8) \n",
        "    plt.xlabel('epochs ---->',color='m',fontsize='xx-large' ) \n",
        "    plt.ylabel('loss ------>',color='m',fontsize='xx-large') \n",
        "    axes = plt.gca()        # 'gca' - get current axes\n",
        "    axes.set_facecolor('c') #'c' - cyan\n",
        "    axes.tick_params(axis='y', which='both', colors='tomato')\n",
        "    axes.tick_params(axis='x', which='both', colors='#20ff14')\n",
        "    plt.title(\"Val Loss vs Epoch\",color='m',fontsize='xx-large')"
      ],
      "execution_count": 14,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "h282bBs_OFrC",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 659
        },
        "outputId": "19f0ef6a-92d3-4ffb-8105-8730c096bf89"
      },
      "source": [
        "train(dataset,valdataset, model)"
      ],
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Epoch 0 total_correct 413 loss: 121.73731422424316\n",
            "Epoch 1 total_correct 725 loss: 91.92743670940399\n",
            "Epoch 2 total_correct 790 loss: 84.59160953760147\n",
            "Epoch 3 total_correct 977 loss: 70.20228296518326\n",
            "Epoch 4 total_correct 1082 loss: 59.31371080875397\n",
            "Epoch 5 total_correct 1139 loss: 51.01481255888939\n",
            "Epoch 6 total_correct 1233 loss: 45.013969242572784\n",
            "Epoch 7 total_correct 1267 loss: 43.16292858123779\n",
            "Epoch 8 total_correct 1268 loss: 41.74965280294418\n",
            "Epoch 9 total_correct 1321 loss: 36.72149619460106\n",
            "Epoch 10 total_correct 1309 loss: 36.947828978300095\n",
            "Epoch 11 total_correct 1303 loss: 40.06897500157356\n",
            "Epoch 12 total_correct 1339 loss: 39.2538605928421\n",
            "Epoch 13 total_correct 1304 loss: 46.184862941503525\n",
            "Epoch 14 total_correct 1360 loss: 40.347060173749924\n",
            "Epoch 15 total_correct 1284 loss: 56.35446451604366\n",
            "Epoch 16 total_correct 1321 loss: 48.104191690683365\n",
            "Epoch 17 total_correct 1321 loss: 48.540457010269165\n",
            "Epoch 18 total_correct 1326 loss: 55.97410994768143\n",
            "Epoch 19 total_correct 1338 loss: 52.43239432293922\n"
          ],
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "dark"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NXX0aOg-WzE1"
      },
      "source": [
        "# Saving labels to label value as a json\n",
        "main_dir = os.listdir(os.path.join(\"minidataset\",\"train\"))\n",
        "reference = {}\n",
        "for i,dir in enumerate(main_dir):\n",
        "    reference[dir]=i\n",
        "with open('labels.json', 'wb') as iw:\n",
        "    pickle.dump(reference, iw)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "eleHbjJxXgrf"
      },
      "source": [
        "#Save the trained model\n",
        "torch.save(model.state_dict(), \"model.pth\")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g5MXP5iAYFiP"
      },
      "source": [
        "# prediction function to test\n",
        "def predict(img_path):\n",
        "    image = Image.open(img_path)\n",
        "    image = ToTensor()(image)\n",
        "    resize = transforms.Compose([transforms.Resize((256,256))])\n",
        "    y_result = model(resize(image).unsqueeze(0))\n",
        "    result_idx = y_result.argmax(dim=1)\n",
        "    for key,value in reference.items():\n",
        "        if(value==result_idx):\n",
        "            print(key)\n",
        "            break\n",
        "      \n",
        "\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xRv63JfPatKB",
        "outputId": "86e06b3f-dd45-49a2-cefd-95390f487af4"
      },
      "source": [
        "predict(\"img_path\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Potato___healthy\n"
          ],
          "name": "stdout"
        }
      ]
    }
  ]
}