Object_Detection(Pytorch).ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# **PyTorch Implementation of Neural Networks**\n",
        "In this week's graded assignment, you will implement a neural network that will perform binary classification on a set of images (ie. is or is not).\n",
        "\n",
        "You are to only write/modify the code in between consecutive `# <START>` and `# <END>` comments. DO NOT modify other parts of the notebook, your assignments will not be graded otherwise.\n",
        "\n",
        "```python\n",
        "\"Don't modify any code here\"\n",
        "\n",
        "# <START>\n",
        "\"YOUR CODE GOES HERE!\"\n",
        "# <END>\n",
        "\n",
        "\"Don't modify any code here\"\n",
        "```\n",
        "## **Before you begin**\n",
        "Before you start with the assignment, you will have to upload the images that you will classify to your Google Drive.  \n",
        "You will be able to find the compressed folder named **\"pizza_vs_not\"** on both the GitHub repo and the Week 1 MS Teams channel.  \n",
        "Download the file, unzip it, and then upload it to your Drive.\n",
        "\n",
        "### **Make sure to upload to the same account that you are using on Colab, otherwise you won't be able to access the files**\n"
      ],
      "metadata": {
        "id": "pbwA7e12AVLe"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Mounting Google Drive**\n",
        "First, we need to import the dataset of images from your Google Drive. To do so, **run the below cell**. This will mount your Drive to the running Colab instance. Then, you will be able to access all your Google Drive data in this notebook."
      ],
      "metadata": {
        "id": "D0lIe1uahq_L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "id": "ObnNbRJPQrYK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5a5ae4ff-8192-48c2-c125-bcce018ee001"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/drive; to attempt to forcibly remount, call drive.mount(\"/content/drive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Import the Libraries**\n",
        "\n",
        "Run the cell below to import all the necessary libraries for building the neural network using PyTorch.  \n",
        "You will primarily use the **`nn` module** of the **PyTorch** library for building the neural network."
      ],
      "metadata": {
        "id": "ElYLMOGFBq1r"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "1ZVxJx87kAAN"
      },
      "outputs": [],
      "source": [
        "import os\n",
        "import numpy as np\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.image as mpimg\n",
        "%matplotlib inline"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Importing the Dataset**\n",
        "\n",
        "We now need to import the dataset from the Google Drive. Below given is a function named `getdata`, which takes the path of the folder from which data is to be imported as its argument.\n",
        "\n",
        "You are required to give in the path of the folder in which the images of `pizza` and `not_pizza` are saved in your Google Drive. Locate the path using the Colab File Explorer (the file icon in the sidebar).\n",
        "\n",
        "The `getdata` function reads each image stored at the given path and converts and stores it as a PyTorch Tensor.\n",
        "\n",
        "_Note: This cell may take a while to finish running_\n",
        "<details>\n",
        "  <summary>Hint</summary>\n",
        "  The Google Drive was mounted to the location \"/content/drive\", containing the folder \"My Drive\", which corresponds to your actual Google Drive.\n",
        "</details>"
      ],
      "metadata": {
        "id": "GpoxEmvICmNr"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def getdata(path):\n",
        "  data = torch.tensor([])\n",
        "  file_list = os.listdir(path)\n",
        "  for file_name in file_list[:350]:\n",
        "    image_path = os.path.join(path, file_name)\n",
        "    image = mpimg.imread(image_path)\n",
        "    imageData = torch.from_numpy(image).long()\n",
        "    data = torch.cat((data, imageData.unsqueeze(0)), dim=0)\n",
        "  return data\n",
        "\n",
        "# <START>\n",
        "pizza_path = '/content/drive/MyDrive/pizza_vs_not/pizza'\n",
        "not_pizza_path = '/content/drive/MyDrive/pizza_vs_not/not_pizza'\n",
        "# <END>\n",
        "\n",
        "not_pizza_data = getdata(not_pizza_path)\n",
        "pizza_data = getdata(pizza_path)"
      ],
      "metadata": {
        "id": "QvO6vf9cqR5i",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "05580a3b-285d-4acf-b68e-3910296acf9e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-4-83f21a4994f3>:7: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n",
            "  imageData = torch.from_numpy(image).long()\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Using the next cell, you can preview the images you've just loaded"
      ],
      "metadata": {
        "id": "SIucUmRBGaZJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Change values of index, data\n",
        "# <START>\n",
        "index = 222 # 0 to 349\n",
        "data = not_pizza_data # pizza_data (or) not_pizza_data\n",
        "# <END>\n",
        "\n",
        "plt.imshow(data[index].int())"
      ],
      "metadata": {
        "id": "7a_9TI1zEd7r",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        },
        "outputId": "a702cb4f-015e-4e8c-9cd9-277808eb6737"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.image.AxesImage at 0x7c035e1b77f0>"
            ]
          },
          "metadata": {},
          "execution_count": 5
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Preprocessing the dataset**\n",
        "\n",
        "Before we begin working with the neural network, we need to make sure our data (in this case, $64\\times64$ RGB images) is in a format that neural networks can work with.\n",
        "\n",
        "First, we create a `train_data` collection of images for training the neural network, and another collection `test_data` that will then be used to check the accuracy of the trained neural network. We do this by taking slices of the total data and concatenating them.  "
      ],
      "metadata": {
        "id": "uiKp-IkYDpB_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "train_data = torch.cat((pizza_data[:300], not_pizza_data[:200]), dim = 0)\n",
        "test_data = torch.cat((pizza_data[300:350], not_pizza_data[200:250]), dim = 0)\n",
        "print(train_data.shape)"
      ],
      "metadata": {
        "id": "qHHnTe3Hq8cr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "70f8ddc0-e94f-43fe-b0c1-41977bce54f6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([500, 64, 64, 3])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Each image is still stored as a $64\\times64\\times3$ tensor ie. a $64\\times64$ array of 3 numbers - the RGB values of the pixel, taking values between **0 to 255**.  \n",
        "You need to flatten the images in both datasets to make *reshaped* data, and normalise them to get the *final* data we will use to train and test the model.\n",
        "\n",
        "<details>\n",
        "  <summary>Hint</summary>\n",
        "  Use the reshape command to flatten the dataset and then normalise the flattened dataset (ie. make sure all the values lie between 0 and 1).\n",
        "</details>"
      ],
      "metadata": {
        "id": "gp5rsLIAEBKa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# <START>\n",
        "\n",
        "reshaped_train_data = [torch.flatten(train_data[x, :]) for x in range(500)]\n",
        "reshaped_test_data = [torch.flatten(test_data[x, :]) for x in range(100)]\n",
        "\n",
        "final_train_data = torch.stack([reshaped_train_data[x] / 255 for x in range(500)])\n",
        "final_test_data = torch.stack([reshaped_test_data[x] / 255 for x in range(100)])\n",
        "\n",
        "# <END>\n",
        "\n",
        "print(final_train_data.shape, final_test_data.shape)"
      ],
      "metadata": {
        "id": "XxdYwPTe3dMr",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "39ecc7ef-55c0-4833-ff3f-fb022d386b79"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([500, 12288]) torch.Size([100, 12288])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now that you have made two datasets, you need to make their corresponding `labels` Tensors, which store the true output for each image (whether or not it is a pizza).\n",
        "\n",
        "In the `labels` Tensor, use **`1`** for images that belong to `pizza` and **`0`** for `not_pizza`. (Try to use the concatenate function instead of simply using *for* loops for generating the `labels` Tensor !!)\n",
        "\n",
        "**Remember** to ensure that both `train_labels` and `test_labels` are 2D tensors of appropriate dimensions. Otherwise, it can cause issues ahead."
      ],
      "metadata": {
        "id": "CN9sZzmAEhed"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# <START>\n",
        "\n",
        "train_labels = torch.cat((torch.ones(300) , torch.zeros(200)) , dim = 0).view(-1,1)\n",
        "\n",
        "test_labels = torch.cat((torch.ones(50) , torch.zeros(50)) , dim = 0).view(-1,1)\n",
        "\n",
        "# <END>\n",
        "\n",
        "print(train_labels.shape, test_labels.shape)"
      ],
      "metadata": {
        "id": "AB9ngSqaruoK",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "183fd867-db03-407b-9cf4-226db872c2a8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([500, 1]) torch.Size([100, 1])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "##**Building the Neural Network**\n",
        "\n",
        "Now, we will start making the actual neural network.\n",
        "\n",
        "First, initialise the hyperparameters of the neural network.  \n",
        "Here, we are going to make a 3 layer neural network (i.e., 1 input layer, 2 hidden layers and 1 output layer). The first hidden layer will have 10 nodes, while the second will have 12.   \n",
        "Enter the number of input parameters, number of nodes of each hidden layer and the number of output parameters."
      ],
      "metadata": {
        "id": "tfcBVaGoFVH-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# <START>\n",
        "\n",
        "D_in = final_train_data.shape[1]\n",
        "H1 = 10\n",
        "H2 = 12\n",
        "D_out = 1\n",
        "\n",
        "# <END>"
      ],
      "metadata": {
        "id": "Nzoq4S8aqY88"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Now you will make the actual model. The Model includes the use of `Linear` function at each layer, alongside non-linear activation functions.\n",
        "\n",
        "We are going to use `ReLU` functions as activation functions for the input and the first hidden layer and `Sigmoid` function for the final output, as we want an output between 0 and 1.\n",
        "\n",
        "(Hint: `Linear`, `ReLU` and `Sigmoid` functions are a part of the `nn` module of the **PyTorch** library)"
      ],
      "metadata": {
        "id": "k99hJnXbGAwS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "model = torch.nn.Sequential(\n",
        "    # Do not hard-code any values, use the variables from the previous cell\n",
        "    # <START>\n",
        "    nn.Linear(D_in , H1) , nn.ReLU() , nn.Linear(H1, H2) ,nn.ReLU() , nn.Linear(H2,1), nn.Sigmoid()\n",
        "\n",
        "    # <END>\n",
        "\n",
        ")\n"
      ],
      "metadata": {
        "id": "YFA7NWqTqdlu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model(final_train_data[0]) #To check if the model works"
      ],
      "metadata": {
        "id": "nkoOyUiYzTGA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "31266aa3-8177-44b8-c35b-7b6b0d809f3f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0.4405], grad_fn=<SigmoidBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "After making the model, we defined the `loss_fn` , i.e., the loss function as the Binary Cross Entropy Loss.\n",
        "\n",
        "Here, you will implement gradient descent.\n",
        "\n",
        "The `learning_rate` is the step size which the neural network takes when it updates the parameters of the network. (Try to explore various values of step size. Values similar to 0.005 are usually suitable). Also play around with the number of `iterations` the gradient descent algorithm needs to take.\n",
        "\n",
        "**Follow the steps given as per the comments.**\n",
        "\n",
        "*Note: When you run the code, it could take about 5 minutes for the network to finish training.*"
      ],
      "metadata": {
        "id": "pI5qXU5fHPG2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "loss_fn = nn.BCELoss()\n",
        "\n",
        "# <START>\n",
        "import torch.optim as optim\n",
        "\n",
        "learning_rate = 0.005\n",
        "iterations = 10000\n",
        "\n",
        "optimizer = optim.SGD(model.parameters(), lr = learning_rate)\n",
        "\n",
        "for t in range(iterations):\n",
        "\n",
        "    # call the model on the dataset\n",
        "    y_pred = model(final_train_data)\n",
        "\n",
        "    #calculate the loss\n",
        "    loss = loss_fn(y_pred , train_labels)\n",
        "\n",
        "    if t%1000 == 1:\n",
        "        print(loss)\n",
        "\n",
        "    #calculate the gradients (dont forget to reset the gradients before you begin)\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "\n",
        "    # update the values of the parameters\n",
        "    with torch.no_grad():\n",
        "      optimizer.zero_grad()\n",
        "\n",
        "# <END>\n",
        "\n",
        "torch.save(model, 'model_best.pt')"
      ],
      "metadata": {
        "id": "WrcyQE-nqgUL",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7c804d29-2b50-497e-9797-7ca5e915f694"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor(0.7146, grad_fn=<BinaryCrossEntropyBackward0>)\n",
            "tensor(0.2629, grad_fn=<BinaryCrossEntropyBackward0>)\n",
            "tensor(0.0780, grad_fn=<BinaryCrossEntropyBackward0>)\n",
            "tensor(0.0311, grad_fn=<BinaryCrossEntropyBackward0>)\n",
            "tensor(0.0154, grad_fn=<BinaryCrossEntropyBackward0>)\n",
            "tensor(0.0083, grad_fn=<BinaryCrossEntropyBackward0>)\n",
            "tensor(0.0050, grad_fn=<BinaryCrossEntropyBackward0>)\n",
            "tensor(0.0034, grad_fn=<BinaryCrossEntropyBackward0>)\n",
            "tensor(0.0025, grad_fn=<BinaryCrossEntropyBackward0>)\n",
            "tensor(0.0020, grad_fn=<BinaryCrossEntropyBackward0>)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Checking the Results**\n",
        "Now that we have used the training set to train the network, we shall use the test set to check how the neural network performs with new inputs."
      ],
      "metadata": {
        "id": "uT_u2Q_EJ4ki"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Change values of index\n",
        "# <START>\n",
        "index = 0 #0 to 99\n",
        "# <END>\n",
        "\n",
        "plt.imshow(test_data[index].int())\n",
        "print (f'According to the neural network, index = {index} is {\"a pizza\" if model(final_test_data[index]) > 0.5 else \"not a pizza\"}' )"
      ],
      "metadata": {
        "id": "Ykt2FcjfHW0S",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 449
        },
        "outputId": "7be70f54-3e04-4d6f-ae56-c080ba6c7b28"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "According to the neural network, index = 0 is a pizza\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "To quantize how accurately the neural network is able to classify images, we have defined a helper `predict` function that takes a dataset and returns the fraction of times the neural network correctly classified the image.  \n",
        "\n",
        "Complete the function such that it prints the correct accuracy of its predictions."
      ],
      "metadata": {
        "id": "3fQcWl1rHcuL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def predict(model, data, labels):\n",
        "\n",
        "    probabilities = model(data)\n",
        "\n",
        "    # <START>\n",
        "\n",
        "    # generate the predictions tensor using the probabilities variable, which indicates the prediction made by the model for the given data using 0 and 1\n",
        "\n",
        "    predictions = []\n",
        "\n",
        "    for i in range(len(probabilities)):\n",
        "      if probabilities[i] >= 0.5:\n",
        "        predictions.append(1)\n",
        "      else:\n",
        "        predictions.append(0)\n",
        "\n",
        "    predictions = torch.tensor(predictions).view(-1,1)\n",
        "\n",
        "    # <END>\n",
        "\n",
        "    print(\"Accuracy: \"  + str(torch.sum((predictions == labels)).item()/predictions.shape[0]))"
      ],
      "metadata": {
        "id": "RFwT6ARBs7gT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Run** the cell below to find out the accuracy of your model for the training and test datasets."
      ],
      "metadata": {
        "id": "7PVdX70uLUY9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "predict(model, final_train_data, train_labels)\n",
        "predict(model,final_test_data,test_labels)\n",
        "print(\"Done!\")"
      ],
      "metadata": {
        "id": "V_iNzulpYpHH",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "12146cbc-51e2-4121-b3eb-37cf75869b72"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy: 1.0\n",
            "Accuracy: 0.81\n",
            "Done!\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Extra Content (Optional)**\n",
        "##### **These are extra exercises you can try after submitting the assignment, for you to try on your own. Feel free to approach us with any doubts, but DO NOT make these changes to the notebook before you submit**\n",
        "- Try varying things like the number and size of the hidden layers, and seeing how that affects the accuracy of the network.\n",
        "- Along with `pizza` and `not_pizza`, you should see another folder `other_dishes` in the dataset. Try using it in place of `not_pizza`. What changes do you see? Why do you think this happens?"
      ],
      "metadata": {
        "id": "DYae7InELIF6"
      }
    }
  ]
}