Leather_Defect_Detection.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard",
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "i44nEbzCWDjv"
      },
      "outputs": [],
      "source": [
        "# importing the libraries\n",
        "import random\n",
        "import numpy as np\n",
        "import cv2\n",
        "from google.colab.patches import cv2_imshow\n",
        "import matplotlib.pyplot as plt\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "from torch.utils.data import DataLoader, Dataset, random_split\n",
        "from keras.utils.np_utils import to_categorical\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# mounting drive to access the dataset\n",
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wbpSEgBse82X",
        "outputId": "409864a3-414f-4f96-8016-423d132afb38"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\"\"\"Upload the dataset in zip format to your drive\"\"\"\n",
        "\n",
        "!unzip \"/content/drive/MyDrive/archive.zip\""
      ],
      "metadata": {
        "id": "_eCQtQ2ikWOM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Removing the two outlier images from the dataset\n",
        "# Resizing was an expensive operation so I just went ahead with this\n",
        "\n",
        "import os \n",
        "for file in os.listdir(\"/content/Leather Defect Classification/Grain off\"):\n",
        "  img = cv2.imread(f\"/content/Leather Defect Classification/Grain off/{file}\")\n",
        "  if img.shape == (3288, 4608, 3):\n",
        "    print(file)\n",
        "    os.remove(f\"/content/Leather Defect Classification/Grain off/{file}\")\n",
        "    break\n",
        "    \n",
        "for file in os.listdir(\"/content/Leather Defect Classification/pinhole\"):\n",
        "  img = cv2.imread(f\"/content/Leather Defect Classification/pinhole/{file}\")\n",
        "  if img.shape == (3288, 4608, 3):\n",
        "    print(file)\n",
        "    os.remove(f\"/content/Leather Defect Classification/pinhole/{file}\")\n",
        "    break"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qPHV-OO7fiuS",
        "outputId": "9e7b4219-5155-43a6-9e44-0651f6a197c3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Grain off 01 (327).jpg\n",
            "Pinhole 01 (465).jpg\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# augmenting data with random mirroring of images and normalizing it\n",
        "hflip = transforms.RandomHorizontalFlip(p=0.5)\n",
        "train_transform = transforms.Compose([hflip, transforms.ToTensor(), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])])"
      ],
      "metadata": {
        "id": "xGwyGt-42rRG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# creating the dataset\n",
        "dataset = torchvision.datasets.ImageFolder(root=\"/content/Leather Defect Classification\", transform=train_transform)"
      ],
      "metadata": {
        "id": "neJ8Lb_BL3xv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# dividing the dataset into train and test sets\n",
        "train_dataset, test_dataset = random_split(dataset, lengths=[3300, 298])"
      ],
      "metadata": {
        "id": "a3fNk0m1FYr0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# the dataloaders with 2 worker processes each\n",
        "train_loader = DataLoader(train_dataset, batch_size=32, num_workers=2)\n",
        "test_loader = DataLoader(test_dataset, batch_size=64, num_workers=2)"
      ],
      "metadata": {
        "id": "Gj8ZhzYrTQ1Y"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "len(train_dataset), len(test_dataset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YD7YopSQV0KH",
        "outputId": "c1b330ac-f45b-4de7-c180-303b99b86d8e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(3300, 298)"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# selecting the GPU for training\n",
        "device = torch.device(\"cuda:0\")\n",
        "device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b5IWGFfnuCrH",
        "outputId": "efb70f52-f60b-4aa9-fbe2-0af210c2e589"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cuda', index=0)"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class CNN_Model(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.convolutional_layers = nn.Sequential(\n",
        "        nn.Conv2d(in_channels=3, out_channels=6, kernel_size=3, stride=1),      # out size will be 6 x 225 x 225\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(in_channels=6, out_channels=10, kernel_size=5, stride=1),     # out size will be 10 x 221 x 221\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(kernel_size=2, stride=2),                                  # out size will be 10 x 110 x 110\n",
        "        nn.Conv2d(in_channels=10, out_channels=10, kernel_size=1, stride=1),    # out size will be 10 x 110 x 110\n",
        "        nn.Conv2d(in_channels=10, out_channels=25, kernel_size=3, stride=2),    # out size will be 25 x 54 x 54\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(kernel_size=2, stride=2),                                  # out size will be 25 x 27 x 26\n",
        "        nn.Conv2d(in_channels=25, out_channels=50, kernel_size=5, stride=2),    # out size will be 50 x 12 x 12\n",
        "        nn.ReLU(),\n",
        "        nn.Conv2d(in_channels=50, out_channels=100, kernel_size=3, stride=1),   # out size will be 100 x 10 x 10\n",
        "        nn.ReLU(),\n",
        "        nn.MaxPool2d(kernel_size=2, stride=2)                                   # out size will be 100 x 5 x 5\n",
        "    )\n",
        "\n",
        "    self.linear_layers = nn.Sequential(\n",
        "        nn.Linear(2500, 500),\n",
        "        nn.ReLU(),\n",
        "        nn.Linear(500, 75),\n",
        "        nn.ReLU(),\n",
        "        nn.Linear(75, 6)\n",
        "    )\n",
        "    \n",
        "    self.loss_fn = nn.CrossEntropyLoss(reduction=\"mean\")                        # Loss function with mean reduction to prevent overflow\n",
        "    self.optimizer = torch.optim.Adam(self.parameters(), lr=0.001)              # Adam optimizer with default hyperparameters\n",
        "    self.train_loader = train_loader\n",
        "    self.test_loader = test_loader\n",
        "  \n",
        "  def feed_forward(self, X):\n",
        "    z = self.convolutional_layers(X)\n",
        "    z_linear = z.reshape(z.shape[0], -1)\n",
        "    out = self.linear_layers(z_linear)\n",
        "    return out\n",
        "\n",
        "  def backward(self, predictions, y):\n",
        "    loss = self.loss_fn(predictions, y)\n",
        "    loss.backward()\n",
        "    self.optimizer.step()\n",
        "    self.optimizer.zero_grad()\n",
        "\n",
        "  def accuracy(self):\n",
        "    count = 0\n",
        "    total = 0\n",
        "    for batch, target in self.test_loader:\n",
        "      batch = batch.to(device)\n",
        "      target = target.to(device)\n",
        "      preds = self.feed_forward(batch)\n",
        "      preds.to(device)\n",
        "      correct_preds = torch.sum((torch.argmax(preds, axis=1) == target))\n",
        "      count += correct_preds\n",
        "      total += batch.shape[0]\n",
        "    return count / total\n",
        "\n",
        "\n",
        "  def fit(self, epochs):\n",
        "    for i in range(epochs):\n",
        "      for batch in self.train_loader:\n",
        "        X, y = batch\n",
        "        X = X.to(device)\n",
        "        y = y.to(device)\n",
        "        preds = self.feed_forward(X)\n",
        "        preds.to(device)\n",
        "        self.backward(preds, y)\n",
        "      print(f\"Accuracy at epoch {i+1}: {round(self.accuracy().item(), 4)}\")\n"
      ],
      "metadata": {
        "id": "5nvBKbidZr-o"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# loading the trained model from drive for inferences\n",
        "model = torch.load(\"/content/drive/MyDrive/trained_model.pth\")\n",
        "model"
      ],
      "metadata": {
        "id": "wMuDuyA7PX01"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model.fit(20)"
      ],
      "metadata": {
        "id": "cyPPT36ATc4f",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "6a66929f-25b7-46b8-c5b3-5532ba5bfc43"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy at epoch 1: 0.4291\n",
            "Accuracy at epoch 2: 0.4497\n",
            "Accuracy at epoch 3: 0.6167\n",
            "Accuracy at epoch 4: 0.6036\n",
            "Accuracy at epoch 5: 0.6015\n",
            "Accuracy at epoch 6: 0.717\n",
            "Accuracy at epoch 7: 0.76\n",
            "Accuracy at epoch 8: 0.7515\n",
            "Accuracy at epoch 9: 0.7694\n",
            "Accuracy at epoch 10: 0.8418\n",
            "Accuracy at epoch 11: 0.7324\n",
            "Accuracy at epoch 12: 0.7515\n",
            "Accuracy at epoch 13: 0.7103\n",
            "Accuracy at epoch 14: 0.8245\n",
            "Accuracy at epoch 15: 0.8097\n",
            "Accuracy at epoch 16: 0.8294\n",
            "Accuracy at epoch 17: 0.8136\n",
            "Accuracy at epoch 18: 0.8521\n",
            "Accuracy at epoch 19: 0.8442\n",
            "Accuracy at epoch 20: 0.8706\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# helper functions\n",
        "def forward_single_image(model, img):\n",
        "    img = img.to(device)\n",
        "    z = model.convolutional_layers(img)\n",
        "    z_linear = z.reshape(1, -1)\n",
        "    out = model.linear_layers(z_linear)\n",
        "    return out\n",
        "\n",
        "def convert(img):\n",
        "  x = (img.cpu().numpy()*0.5 + 0.5) * 256\n",
        "  x = np.moveaxis(x, 0, -1)\n",
        "  return x.astype(\"uint8\")\n",
        "\n",
        "# the predict function\n",
        "def predict(model, test_dataset):\n",
        "  indices = [random.randint(0, len(test_dataset)) for _ in range(9)]\n",
        "  fig, axes = plt.subplots(nrows=3, ncols=3)\n",
        "  for i, axis in enumerate(axes.flat):\n",
        "    img, label = test_dataset[indices[i]]\n",
        "    img = img.to(device)\n",
        "    pred = torch.argmax(forward_single_image(model, img))\n",
        "    img = convert(img)\n",
        "    axis.imshow(img)\n",
        "    axis.set_title(f\"Label:{label}, Prediction: {pred}\")\n",
        "  plt.tight_layout(True)\n"
      ],
      "metadata": {
        "id": "SmiN8TO61n1t"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "predict(model, test_dataset)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 299
        },
        "id": "5zB1uchCrRhl",
        "outputId": "1ccf4322-c027-4bde-aea8-7c5c429aae2a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 9 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}