pytorch_tutorial_60min_blitz.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyPwwSb0+n/IriPEVf1hx+Up"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# Pytorch tutorial\n",
        "Taken from [here](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html)."
      ],
      "metadata": {
        "id": "wDRK-SBuFd8g"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Tensors"
      ],
      "metadata": {
        "id": "PKMVfPDBOLM4"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "cl9k9qIQEwjQ"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "import numpy as np"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "data = [[1,2], [3,4]]\n",
        "x_data = torch.tensor(data)"
      ],
      "metadata": {
        "id": "miU2ezVBGDrY"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# from numpy array\n",
        "np_array = np.array(data)\n",
        "print(np_array)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Fow5zA-XGXWv",
        "outputId": "a22fc26f-c260-468b-bb4a-ad9579479525"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2]\n",
            " [3 4]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x_np = torch.from_numpy(np_array)\n",
        "print(x_np)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7TTtdMF-HZvy",
        "outputId": "c65c580a-1bd6-4b10-f2f3-390c8ff2b176"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1, 2],\n",
            "        [3, 4]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "x_ones = torch.ones_like(x_data) # retains the properties of x_data. assuming rows and columns\n",
        "print(f\"Ones Tensor: \\n {x_ones} \\n\")\n",
        "\n",
        "x_rand = torch.rand_like(x_data, dtype=torch.float) # overrides the datatype of x_data\n",
        "print(f\"Random Tensor: \\n {x_rand} \\n\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "e4gAKNsJHjaM",
        "outputId": "4a7d5e8c-3e09-4083-d60e-9394e45597aa"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ones Tensor: \n",
            " tensor([[1, 1],\n",
            "        [1, 1]]) \n",
            "\n",
            "Random Tensor: \n",
            " tensor([[0.6473, 0.7912],\n",
            "        [0.0512, 0.6617]]) \n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "shape = (4, 5,) # rows, columns, depth (height?)\n",
        "rand_tensor = torch.rand(shape)\n",
        "ones_tensor = torch.ones(shape)\n",
        "zeros_tensor = torch.zeros(shape)\n",
        "\n",
        "print(f'Random Tensor:\\n{rand_tensor}\\n')\n",
        "print(f'Ones Tensor:\\n{ones_tensor}\\n')\n",
        "print(f'Zeros Tensor:\\n{zeros_tensor}\\n')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_3kRfTnjHz4V",
        "outputId": "04a6ed66-86d4-4442-fddd-bbd4c8564780"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Random Tensor:\n",
            "tensor([[0.4243, 0.8908, 0.4014, 0.9179, 0.5448],\n",
            "        [0.0248, 0.2829, 0.4383, 0.2235, 0.1077],\n",
            "        [0.3116, 0.3787, 0.7498, 0.6633, 0.2018],\n",
            "        [0.6138, 0.2431, 0.3195, 0.5880, 0.5416]])\n",
            "\n",
            "Ones Tensor:\n",
            "tensor([[1., 1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1., 1.]])\n",
            "\n",
            "Zeros Tensor:\n",
            "tensor([[0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0.],\n",
            "        [0., 0., 0., 0., 0.]])\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tensor Attributes"
      ],
      "metadata": {
        "id": "u8awzQ0mIhUy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = torch.rand((3,4)) # or torch.rand(3,4)\n",
        "\n",
        "print(f'Shape of tensor: {tensor.shape}')\n",
        "print(f'Datatype of tensor: {tensor.dtype}')\n",
        "print(f'Device Tensor is stored on: {tensor.device}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8DX43wL2Ik95",
        "outputId": "e58ba794-caac-4ebd-b852-b8c4449a57ab"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Shape of tensor: torch.Size([3, 4])\n",
            "Datatype of tensor: torch.float32\n",
            "Device Tensor is stored on: cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Tensor Operations"
      ],
      "metadata": {
        "id": "VuJJNCnrLYDu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# changes notebook settings to GPU\n",
        "if torch.cuda.is_available():\n",
        "  tensor = tensor.to('cuda')\n",
        "print(f\"Device tensor is stored on: {tensor.device}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fRbjiGmALbs6",
        "outputId": "486a14bc-86e3-4ec5-c0bf-1ee8962a906b"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Device tensor is stored on: cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# slicing\n",
        "tensor = torch.ones(4, 4)\n",
        "print(tensor)\n",
        "tensor[3,:] = 0\n",
        "print(tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NN6thKa4LxJO",
        "outputId": "a830a188-6abf-4957-eb92-b0180211f4bc"
      },
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.]])\n",
            "tensor([[1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [0., 0., 0., 0.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# concatenating\n",
        "t1 = torch.cat([tensor, tensor, tensor], dim=1)\n",
        "print(t1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GkDd25wCMQaD",
        "outputId": "eaf90860-3e79-47ea-eace-96eb37c1762b"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
            "        [0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# concatenating\n",
        "t2 = torch.cat([tensor, tensor, tensor], dim=0)\n",
        "print(t2)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kPy8hii-MZAD",
        "outputId": "697aa445-f9ad-4a89-dc23-55c1cfaa85c8"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [0., 0., 0., 0.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [0., 0., 0., 0.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [0., 0., 0., 0.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# multiplying, element wise\n",
        "print(tensor * tensor)\n",
        "print(tensor.mul(tensor))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b_VT4QNCMoGs",
        "outputId": "094405b4-29c9-4267-f437-f39848df0555"
      },
      "execution_count": 12,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [0., 0., 0., 0.]])\n",
            "tensor([[1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [0., 0., 0., 0.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# matrix multiplication\n",
        "print(tensor @ tensor)\n",
        "print(tensor.T)\n",
        "print(tensor.matmul(tensor.T))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ahs2y6HjMuOj",
        "outputId": "04d7dbca-9ddd-4ef2-c4af-310f945feb2e"
      },
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[3., 3., 3., 3.],\n",
            "        [3., 3., 3., 3.],\n",
            "        [3., 3., 3., 3.],\n",
            "        [0., 0., 0., 0.]])\n",
            "tensor([[1., 1., 1., 0.],\n",
            "        [1., 1., 1., 0.],\n",
            "        [1., 1., 1., 0.],\n",
            "        [1., 1., 1., 0.]])\n",
            "tensor([[4., 4., 4., 0.],\n",
            "        [4., 4., 4., 0.],\n",
            "        [4., 4., 4., 0.],\n",
            "        [0., 0., 0., 0.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# in place\n",
        "print(tensor, '\\n')\n",
        "tensor.add_(5)\n",
        "print(tensor)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ty9wgtTmNqS9",
        "outputId": "0a964e13-284b-488b-dff5-0af41995fe59"
      },
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [1., 1., 1., 1.],\n",
            "        [0., 0., 0., 0.]]) \n",
            "\n",
            "tensor([[6., 6., 6., 6.],\n",
            "        [6., 6., 6., 6.],\n",
            "        [6., 6., 6., 6.],\n",
            "        [5., 5., 5., 5.]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Bridge with NumPy"
      ],
      "metadata": {
        "id": "rk8brAbrN6Oc"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# like lists, memory locations can be shared\n",
        "t = torch.ones(5)\n",
        "print(f\"t: {t}\")\n",
        "n = t.numpy()\n",
        "print(f\"n: {n}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0-6wROH2N9bz",
        "outputId": "03d659da-317c-4f70-977e-c4f51c1e85bf"
      },
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "t: tensor([1., 1., 1., 1., 1.])\n",
            "n: [1. 1. 1. 1. 1.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "t.add_(1)\n",
        "print(f\"t: {t}\")\n",
        "print(f\"n: {n}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ICXOZMaTOE0S",
        "outputId": "4bea4918-e876-4da1-bee5-0c238e19c78e"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "t: tensor([2., 2., 2., 2., 2.])\n",
            "n: [2. 2. 2. 2. 2.]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# A Gentle Introduction to torch.autograd\n",
        "Helps neural network training. Automatic differentiation engine.\n",
        "\n",
        "**Forward propagation**: Inference. It runs the input data through each of the nodes.\n",
        "\n",
        "**Backward propagation**: Adjust node parameters proportionate to the error in its guess. Traverses backwards from the output, collecting the derivatives of the error with respect to the parameters of the functions (*gradients*), and optimizing the parameters using gradient descent."
      ],
      "metadata": {
        "id": "Z9rOM1PdOHI3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "from torchvision.models import resnet18, ResNet18_Weights"
      ],
      "metadata": {
        "id": "LQQod9p2Oiwm"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = resnet18(weights=ResNet18_Weights.DEFAULT) # Deep Residual Learning for Image Recognition. 18 layers deep\n",
        "data = torch.rand(1, 3, 64, 64) # 1 image, three channels, HxW of 64x64\n",
        "labels = torch.rand(1, 1000) # 1000 labels"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bJ00qR-sWInJ",
        "outputId": "2064482d-4d72-4f92-deaa-f5c3a5d43bfb"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Downloading: \"https://download.pytorch.org/models/resnet18-f37072fd.pth\" to /root/.cache/torch/hub/checkpoints/resnet18-f37072fd.pth\n",
            "100%|██████████| 44.7M/44.7M [00:00<00:00, 106MB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# forward pass\n",
        "prediction = model(data)"
      ],
      "metadata": {
        "id": "dmQ5kXlmWyXd"
      },
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# back propagation\n",
        "loss = (prediction - labels).sum() # calculate error\n",
        "\n",
        "# BP is kicked off. Autograd then calculates and stores the gradients for each\n",
        "# model parameter in the parameter's .grad attribute\n",
        "loss.backward()\n",
        "# interesting error when you call this twice. gradients have not been cleared. Would overwrite previous gradients."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 373
        },
        "id": "SXqrFKHWXDRZ",
        "outputId": "15226f0c-8eb4-42b1-b947-dc988f18f460"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "error",
          "ename": "RuntimeError",
          "evalue": "Trying to backward through the graph a second time (or directly access saved tensors after they have already been freed). Saved intermediate values of the graph are freed when you call .backward() or autograd.grad(). Specify retain_graph=True if you need to backward through the graph a second time or if you need to access saved tensors after calling backward.",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-24-a3bb1da51190>\u001b[0m in \u001b[0;36m<cell line: 6>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;31m# BP is kicked off. Autograd then calculates and stores the gradients for each\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0;31m# model parameter in the parameter's .grad attribute\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mloss\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbackward\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/_tensor.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[1;32m    520\u001b[0m                 \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    521\u001b[0m             )\n\u001b[0;32m--> 522\u001b[0;31m         torch.autograd.backward(\n\u001b[0m\u001b[1;32m    523\u001b[0m             \u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgradient\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mretain_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcreate_graph\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minputs\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0minputs\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    524\u001b[0m         )\n",
            "\u001b[0;32m/usr/local/lib/python3.10/dist-packages/torch/autograd/__init__.py\u001b[0m in \u001b[0;36mbackward\u001b[0;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[1;32m    264\u001b[0m     \u001b[0;31m# some Python versions print out the first line of a multi-line function\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    265\u001b[0m     \u001b[0;31m# calls in the traceback and some print out the last line\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 266\u001b[0;31m     Variable._execution_engine.run_backward(  # Calls into the C++ engine to run the backward pass\n\u001b[0m\u001b[1;32m    267\u001b[0m         \u001b[0mtensors\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    268\u001b[0m         \u001b[0mgrad_tensors_\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mRuntimeError\u001b[0m: Trying to backward through the graph a second time (or directly access saved tensors after they have already been freed). Saved intermediate values of the graph are freed when you call .backward() or autograd.grad(). Specify retain_graph=True if you need to backward through the graph a second time or if you need to access saved tensors after calling backward."
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# register all the parameters of the model in the optimizer\n",
        "optim = torch.optim.SGD(model.parameters(), lr=1e-2, momentum=0.9)"
      ],
      "metadata": {
        "id": "IyLBCmBUYIwt"
      },
      "execution_count": 23,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# initiate gradient descent\n",
        "# the optimizer adjusts each parameter by its gradient stored in .grad\n",
        "optim.step()"
      ],
      "metadata": {
        "id": "UUgmKaazYUDo"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Differentiation in Autograd\n",
        "Further reading later."
      ],
      "metadata": {
        "id": "q63kIIGvYusg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Neural Networks\n",
        "Typical training procedure for a neural network\n",
        " - Define the neural network that has some learnable parameters (or *weights*)\n",
        " - Iterate over a dataset of inputs\n",
        " - Process input through the network\n",
        " - Compute the loss (how far the output is from being correct)\n",
        " - Propagate gradients back into the network's parameters\n",
        " - Update the weights of the network\n",
        "\n",
        "Below Neural Network is LeNet, named after Yann LeCun"
      ],
      "metadata": {
        "id": "5QL5tdc_Z1Co"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "\n",
        "class Net(nn.Module):\n",
        "\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        # 1 input image channel, 6 output channels, 5x5 square convolution\n",
        "        # kernel\n",
        "        self.conv1 = nn.Conv2d(1, 6, 5)\n",
        "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
        "        # an affine operation: y = Wx + b\n",
        "        self.fc1 = nn.Linear(16 * 5 * 5, 120)  # 5*5 from image dimension\n",
        "        self.fc2 = nn.Linear(120, 84)\n",
        "        self.fc3 = nn.Linear(84, 10)\n",
        "\n",
        "    def forward(self, input):\n",
        "        # Convolution layer C1: 1 input image channel, 6 output channels,\n",
        "        # 5x5 square convolution, it uses RELU activation function, and\n",
        "        # outputs a Tensor with size (N, 6, 28, 28), where N is the size of the batch\n",
        "        c1 = F.relu(self.conv1(input))\n",
        "        # Subsampling layer S2: 2x2 grid, purely functional,\n",
        "        # this layer does not have any parameter, and outputs a (N, 6, 14, 14) Tensor\n",
        "        s2 = F.max_pool2d(c1, (2, 2))\n",
        "        # Convolution layer C3: 6 input channels, 16 output channels,\n",
        "        # 5x5 square convolution, it uses RELU activation function, and\n",
        "        # outputs a (N, 16, 10, 10) Tensor\n",
        "        c3 = F.relu(self.conv2(s2))\n",
        "        # Subsampling layer S4: 2x2 grid, purely functional,\n",
        "        # this layer does not have any parameter, and outputs a (N, 16, 5, 5) Tensor\n",
        "        s4 = F.max_pool2d(c3, 2)\n",
        "        # Flatten operation: purely functional, outputs a (N, 400) Tensor\n",
        "        s4 = torch.flatten(s4, 1)\n",
        "        # Fully connected layer F5: (N, 400) Tensor input,\n",
        "        # and outputs a (N, 120) Tensor, it uses RELU activation function\n",
        "        f5 = F.relu(self.fc1(s4))\n",
        "        # Fully connected layer F6: (N, 120) Tensor input, (120 nodes. 120 outputs. 400 inputs.)\n",
        "        # and outputs a (N, 84) Tensor, it uses RELU activation function\n",
        "        f6 = F.relu(self.fc2(f5))\n",
        "        # Gaussian layer OUTPUT: (N, 84) Tensor input, and\n",
        "        # outputs a (N, 10) Tensor\n",
        "        output = self.fc3(f6)\n",
        "        return output\n",
        "\n",
        "\n",
        "net = Net()\n",
        "print(net)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VGYxQ0mrc4PG",
        "outputId": "0ad301a3-cc71-4af9-d0f2-3fbea417731a"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Net(\n",
            "  (conv1): Conv2d(1, 6, kernel_size=(5, 5), stride=(1, 1))\n",
            "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
            "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
            "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
            "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
            ")\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# learnable parameters\n",
        "params = list(net.parameters())\n",
        "print(len(params))\n",
        "print(params[0].size()) # conv1's .weight"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uxp3slm0hbwc",
        "outputId": "f45777b4-f74d-4987-bc0d-229f12ed1da8"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "10\n",
            "torch.Size([6, 1, 5, 5])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "input = torch.randn(1, 1, 32, 32)\n",
        "out = net(input)\n",
        "print(out)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n46LAqSuiIuf",
        "outputId": "20a168c1-7d53-459f-826c-139448a723a5"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([[-0.0647, -0.0913,  0.0902, -0.0407, -0.0919, -0.0211, -0.0375, -0.1097,\n",
            "          0.1323,  0.0847]], grad_fn=<AddmmBackward0>)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "net.zero_grad()\n",
        "out.backward(torch.randn(1, 10))"
      ],
      "metadata": {
        "id": "xOFdsJbFk1-X"
      },
      "execution_count": 30,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Loss function"
      ],
      "metadata": {
        "id": "9cvZlhurlFoy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "output = net(input)\n",
        "target = torch.randn(10) # a dummy target\n",
        "print(target)\n",
        "target = target.view(1, -1)\n",
        "criterion = nn.MSELoss()\n",
        "\n",
        "loss = criterion(output, target)\n",
        "print(loss)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LZYAfMTzluZy",
        "outputId": "32f9e1d0-1dd7-4df2-8c9d-92ceedadf53a"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "tensor([ 0.3305, -1.3622,  0.8693, -0.8384,  0.6571,  1.5641, -0.4850,  0.4011,\n",
            "        -0.0541,  0.8694])\n",
            "tensor(0.7200, grad_fn=<MseLossBackward0>)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(loss.grad_fn) # MSELoss\n",
        "print(loss.grad_fn.next_functions[0][0]) # Linear\n",
        "print(loss.grad_fn.next_functions[0][0].next_functions[0][0])  # ReLU"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Nv1It3RbmQzp",
        "outputId": "34ea3b6c-df87-4eab-f151-7617c4acdcfa"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<MseLossBackward0 object at 0x7ee470f755d0>\n",
            "<AddmmBackward0 object at 0x7ee470f76b30>\n",
            "<AccumulateGrad object at 0x7ee470f755d0>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Backprop\n",
        "To backpropagate the error all we have to do is to `loss.backward()`. You need to clear the existing gradients though, else gradients will be accumulated to existing gradients."
      ],
      "metadata": {
        "id": "AjkORnFQmukS"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "net.zero_grad()\n",
        "\n",
        "print('conv1.bias.grad before backward')\n",
        "print(net.conv1.bias.grad)\n",
        "\n",
        "loss.backward()\n",
        "\n",
        "print('conv1.bias.grad after backward')\n",
        "print(net.conv1.bias.grad)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PfDxmFBXmxDI",
        "outputId": "0fc0cc42-f945-470d-c227-ccf4acfcd695"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "conv1.bias.grad before backward\n",
            "None\n",
            "conv1.bias.grad after backward\n",
            "tensor([ 0.0214, -0.0027,  0.0162, -0.0199,  0.0052,  0.0088])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Update the weights"
      ],
      "metadata": {
        "id": "5XAAqfclniLM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# simplest update rule used in practice is the Stochastic Gradient Descent (SGD)\n",
        "# weight = weight - learning_rate * gradient\n",
        "learning_rate = 0.01\n",
        "for f in net.parameters():\n",
        "  f.data.sub_(f.grad.data * learning_rate)"
      ],
      "metadata": {
        "id": "8g5IFrHQnlhC"
      },
      "execution_count": 40,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "f.data"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CEChtRfin7LE",
        "outputId": "4d219207-7fb1-40d6-ee0e-ab925fd08963"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([-0.0432, -0.0944,  0.0339, -0.0307, -0.0733,  0.0556, -0.0845, -0.0975,\n",
              "         0.1053,  0.0448])"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# may want to use other update rules\n",
        "import torch.optim as optim\n",
        "\n",
        "# create optimizer\n",
        "optimizer = optim.SGD(net.parameters(), lr=0.01)"
      ],
      "metadata": {
        "id": "6Uneu6AVoFOL"
      },
      "execution_count": 44,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# in training loop\n",
        "optimizer.zero_grad()\n",
        "output = net(input)\n",
        "loss = criterion(output, target)\n",
        "loss.backward()\n",
        "optimizer.step() # does the update"
      ],
      "metadata": {
        "id": "BBafbgrEoovt"
      },
      "execution_count": 47,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Note**\n",
        "\n",
        "Observe how gradient buffers had to be manually set to zero using `optimizer.zero_grad()`. This is because gradients are accumulated as explained in the Backprop section."
      ],
      "metadata": {
        "id": "Konf08h9otV7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Training a Classifier\n",
        "You can now define a neural network, compute loss, and make updates to the weights of the network.\n",
        "\n",
        "Generally, when you have to deal with image, text, audio or video data, you can use standard python packages that load data into a numpy array. Then you can convert this array into a torch.*Tensor.\n",
        "\n",
        "- For images, packages such as Pillow, OpenCV are useful\n",
        "- For audio, packages such as scipy and librosa\n",
        "- For text, either raw Python or Cython based loading, or NLTK and SpaCy are useful\n",
        "\n",
        "Now we will train a classifier. Do the following steps in order.\n",
        "1. Load and normalize the CIFAR10 training and test sets using torchvision\n",
        "2. Define a CNN\n",
        "3. Define a loss function\n",
        "4. Train the network on the training data\n",
        "5. Test the network on the test data"
      ],
      "metadata": {
        "id": "syTO8FNXo9D8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms"
      ],
      "metadata": {
        "id": "9XkT_o8yuUta"
      },
      "execution_count": 2,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "transform = transforms.Compose(\n",
        "    [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
        "\n",
        "batch_size = 4\n",
        "\n",
        "trainset = torchvision.datasets.CIFAR10(root='./data', train=True,\n",
        "                                        download=True, transform=transform)\n",
        "\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=batch_size,\n",
        "                                          shuffle=True, num_workers=2)\n",
        "\n",
        "testset = torchvision.datasets.CIFAR10(root='./data', train=False,\n",
        "                                       download=True, transform=transform)\n",
        "\n",
        "testloader = torch.utils.data.DataLoader(testset, batch_size=batch_size,\n",
        "                                         shuffle=False, num_workers=2)\n",
        "\n",
        "classes = ('plane', 'car', 'bird', 'cat',\n",
        "           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y1fwPxNFuZGF",
        "outputId": "18bdbd14-1b7b-4473-d259-beab78f1a192"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 170498071/170498071 [00:13<00:00, 13031808.30it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/cifar-10-python.tar.gz to ./data\n",
            "Files already downloaded and verified\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "#functions to show an image\n",
        "def imshow(img):\n",
        "  img = img / 2 + 0.5 # unnormalize\n",
        "  npimg = img.numpy()\n",
        "  plt.imshow(np.transpose(npimg, (1, 2, 0)))\n",
        "  plt.show()"
      ],
      "metadata": {
        "id": "OrZVhuQzxJID"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# get random training images\n",
        "dataiter = iter(trainloader)\n",
        "images, labels = next(dataiter)\n",
        "\n",
        "# show images\n",
        "imshow(torchvision.utils.make_grid(images))\n",
        "# print labels\n",
        "print(' '.join(f'{classes[labels[j]]}' for j in range(batch_size)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "J1L49vAGxw7l",
        "outputId": "a91cf850-a6d0-4150-d9cc-de4dbfe6e1e2"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/lib/python3.10/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n",
            "  self.pid = os.fork()\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "plane car plane car\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define a CNN"
      ],
      "metadata": {
        "id": "_b6vJWUayULg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "\n",
        "\n",
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.conv1 = nn.Conv2d(3, 32, 5)\n",
        "        self.pool = nn.MaxPool2d(2, 2)\n",
        "        self.conv2 = nn.Conv2d(32, 16, 5)\n",
        "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
        "        self.fc2 = nn.Linear(120, 84)\n",
        "        self.fc3 = nn.Linear(84, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(F.relu(self.conv1(x)))\n",
        "        x = self.pool(F.relu(self.conv2(x)))\n",
        "        x = torch.flatten(x, 1) # flatten all dimensions except batch\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = F.relu(self.fc2(x))\n",
        "        x = self.fc3(x)\n",
        "        return x\n",
        "\n",
        "\n",
        "net = Net()"
      ],
      "metadata": {
        "id": "D6kA7GpfyZ6l"
      },
      "execution_count": 27,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "net.to(device) # GPU"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UR9uB0VL8R9h",
        "outputId": "558899a2-8269-425c-d078-f5a25671efc3"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Net(\n",
              "  (conv1): Conv2d(3, 32, kernel_size=(5, 5), stride=(1, 1))\n",
              "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
              "  (conv2): Conv2d(32, 16, kernel_size=(5, 5), stride=(1, 1))\n",
              "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
              "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
              "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Define a Loss function and optimizer\n"
      ],
      "metadata": {
        "id": "y7BTX2Evyd5L"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# cross entropy Loss with SGD update with momentum\n",
        "import torch.optim as optim\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)"
      ],
      "metadata": {
        "id": "w0VSa5F3yiTc"
      },
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Train the network"
      ],
      "metadata": {
        "id": "8Ad6RBozyxiK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "for epoch in range(2): # 2 epochs i think\n",
        "  running_loss = 0.0\n",
        "  for i, data in enumerate(trainloader, 0):\n",
        "    # inputs, labels = data\n",
        "    inputs, labels = data[0].to(device), data[1].to(device) # gpu. it was a little bit faster. need to change layer sizes\n",
        "\n",
        "    # zero the parameter gradients\n",
        "    optimizer.zero_grad()\n",
        "\n",
        "    # forward + backward + update\n",
        "    outputs = net(inputs)\n",
        "    loss = criterion(outputs, labels)\n",
        "    loss.backward()\n",
        "    optimizer.step()\n",
        "\n",
        "    # print statistics\n",
        "    running_loss += loss.item() # I suppose because the loss is very small\n",
        "    if i % 2000 == 1999: # print every 2000 mini-batches\n",
        "      print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')\n",
        "      running_loss = 0.0\n",
        "\n",
        "print('Finished training')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UaUSfnify1cB",
        "outputId": "b5b80ccb-daa4-4231-ccbb-b8efdbf8f71a"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1,  2000] loss: 2.305\n",
            "[1,  4000] loss: 2.305\n",
            "[1,  6000] loss: 2.303\n",
            "[1,  8000] loss: 2.304\n",
            "[1, 10000] loss: 2.304\n",
            "[1, 12000] loss: 2.305\n",
            "[2,  2000] loss: 2.304\n",
            "[2,  4000] loss: 2.305\n",
            "[2,  6000] loss: 2.304\n",
            "[2,  8000] loss: 2.305\n",
            "[2, 10000] loss: 2.305\n",
            "[2, 12000] loss: 2.304\n",
            "Finished training\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "len(trainloader)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-tjPI_LF1N2Z",
        "outputId": "aa1eabed-a03f-461a-f1e9-11afe9dda2c8"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "12500"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "len(next(iter(trainloader))) # 2. input, label. Batch size 4??"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hWeVdoA81S11",
        "outputId": "0b2bac01-e727-4033-aa08-f897c8cedc1b"
      },
      "execution_count": 62,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/lib/python3.10/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n",
            "  self.pid = os.fork()\n",
            "/usr/lib/python3.10/multiprocessing/popen_fork.py:66: RuntimeWarning: os.fork() was called. os.fork() is incompatible with multithreaded code, and JAX is multithreaded, so this will likely lead to a deadlock.\n",
            "  self.pid = os.fork()\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "PATH = './cifar_net.pth'\n",
        "torch.save(net.state_dict(), PATH)"
      ],
      "metadata": {
        "id": "IETkTvYv1oJn"
      },
      "execution_count": 17,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Test the network on the test data\n",
        "Make an inference and check against the ground truth."
      ],
      "metadata": {
        "id": "7atwMnqo1usd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "dataiter = iter(testloader) # defining it in the same cell where you're iterating just reloads the iterator again and again"
      ],
      "metadata": {
        "id": "LpADzSDP3Fg5"
      },
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "images, labels = next(dataiter)\n",
        "\n",
        "print(len(images))\n",
        "print(images[0])\n",
        "print(len(labels))\n",
        "print(labels)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TW0LF1Av2Dw2",
        "outputId": "0ebf9b2d-5314-43f5-ca63-97be17c0937b"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "4\n",
            "tensor([[[ 0.2392,  0.2471,  0.2941,  ...,  0.0745, -0.0118, -0.0902],\n",
            "         [ 0.1922,  0.1843,  0.2471,  ...,  0.0667, -0.0196, -0.0667],\n",
            "         [ 0.1843,  0.1843,  0.2392,  ...,  0.0902,  0.0196, -0.0588],\n",
            "         ...,\n",
            "         [-0.4667, -0.6706, -0.7569,  ..., -0.7020, -0.8980, -0.6863],\n",
            "         [-0.5216, -0.6157, -0.7255,  ..., -0.7961, -0.7725, -0.8431],\n",
            "         [-0.5765, -0.5608, -0.6471,  ..., -0.8118, -0.7333, -0.8353]],\n",
            "\n",
            "        [[-0.1216, -0.1294, -0.0902,  ..., -0.2549, -0.2863, -0.3333],\n",
            "         [-0.1216, -0.1373, -0.1059,  ..., -0.2549, -0.2863, -0.3098],\n",
            "         [-0.1373, -0.1451, -0.1294,  ..., -0.2314, -0.2549, -0.3020],\n",
            "         ...,\n",
            "         [-0.0275, -0.2157, -0.3098,  ..., -0.2392, -0.4980, -0.3333],\n",
            "         [-0.0902, -0.2000, -0.3333,  ..., -0.3569, -0.3569, -0.4980],\n",
            "         [-0.1608, -0.1765, -0.3020,  ..., -0.3961, -0.3412, -0.4745]],\n",
            "\n",
            "        [[-0.6157, -0.6314, -0.6000,  ..., -0.7176, -0.7176, -0.7412],\n",
            "         [-0.6000, -0.6863, -0.6471,  ..., -0.7569, -0.7490, -0.7333],\n",
            "         [-0.6314, -0.7412, -0.7176,  ..., -0.7333, -0.7333, -0.7412],\n",
            "         ...,\n",
            "         [ 0.3882,  0.1608,  0.0745,  ...,  0.1451, -0.1529, -0.0039],\n",
            "         [ 0.3176,  0.1608,  0.0353,  ...,  0.0196, -0.0118, -0.1608],\n",
            "         [ 0.2549,  0.1686,  0.0353,  ..., -0.0275,  0.0118, -0.1373]]])\n",
            "4\n",
            "tensor([3, 8, 8, 0])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# print images\n",
        "imshow(torchvision.utils.make_grid(images))\n",
        "print('GroundTruth: ', ' '.join(f'{classes[labels[j]]:5s}' for j in range(4)))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 210
        },
        "id": "96bMBV4C2s5H",
        "outputId": "e4d455b9-e840-4227-bbf8-4cd48567fa4f"
      },
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "GroundTruth:  cat   ship  ship  plane\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Loading a saved model"
      ],
      "metadata": {
        "id": "Vu9lfbDt3ZOH"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "net = Net()\n",
        "net.load_state_dict(torch.load(PATH))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SsmwfQ0a3cr-",
        "outputId": "3e555c06-9ac3-4c73-b7a0-695cae9735fd"
      },
      "execution_count": 21,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Making more predictions"
      ],
      "metadata": {
        "id": "Xn_jzl9n3-Bq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "outputs = net(images)"
      ],
      "metadata": {
        "id": "G2_vzZuE3d8-"
      },
      "execution_count": 22,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "_, predicted = torch.max(outputs, 1)\n",
        "\n",
        "print('Predicted: ', ' '.join(f'{classes[predicted[j]]:5s}'\n",
        "                              for j in range(4)))\n",
        "\n",
        "# made a few mistakes!"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "URjpbAn63hh4",
        "outputId": "17c636c2-209a-4052-82aa-d431e322da2c"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Predicted:  cat   ship  ship  ship \n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "correct = 0\n",
        "total = 0\n",
        "# since we're not training, we don't need to calculate the gradients for our outputs\n",
        "with torch.no_grad():\n",
        "    for data in testloader:\n",
        "        images, labels = data\n",
        "        # calculate outputs by running images through the network\n",
        "        outputs = net(images)\n",
        "        # the class with the highest energy is what we choose as prediction\n",
        "        _, predicted = torch.max(outputs.data, 1)\n",
        "        total += labels.size(0)\n",
        "        correct += (predicted == labels).sum().item()\n",
        "\n",
        "print(f'Accuracy of the network on the 10000 test images: {100 * correct // total} %')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rDgqHy8N35kq",
        "outputId": "b44f9255-7067-42ec-edb2-d16ba013d99b"
      },
      "execution_count": 24,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy of the network on the 10000 test images: 56 %\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "labels.size(0)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "58sRdwxX4hiY",
        "outputId": "b1f21273-3bab-4254-90e2-9f001fff3374"
      },
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "4"
            ]
          },
          "metadata": {},
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# prepare to count predictions for each class\n",
        "correct_pred = {classname: 0 for classname in classes}\n",
        "total_pred = {classname: 0 for classname in classes}\n",
        "\n",
        "# again, no gradients needed\n",
        "with torch.no_grad():\n",
        "  for data in testloader:\n",
        "    images, labels = data\n",
        "    outputs = net(images)\n",
        "    _, predictions = torch.max(outputs, 1)\n",
        "    for label, prediction in zip(labels, predictions):\n",
        "      if label == prediction:\n",
        "        correct_pred[classes[label]] += 1\n",
        "      total_pred[classes[label]] += 1\n"
      ],
      "metadata": {
        "id": "pBFurV9T4nRW"
      },
      "execution_count": 25,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# print accuracy for each class\n",
        "for classname in classes:\n",
        "  correct = correct_pred[classname]\n",
        "  total = total_pred[classname]\n",
        "  print(f'Accuracy for {classname:5s}: {100 * (correct / total):.1f}%')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kX8Vw9mV6ZbJ",
        "outputId": "260055b4-c17b-4243-a34b-3dfea87a6713"
      },
      "execution_count": 26,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy for plane: 56.2%\n",
            "Accuracy for car  : 71.4%\n",
            "Accuracy for bird : 24.0%\n",
            "Accuracy for cat  : 55.2%\n",
            "Accuracy for deer : 59.1%\n",
            "Accuracy for dog  : 22.7%\n",
            "Accuracy for frog : 77.1%\n",
            "Accuracy for horse: 64.8%\n",
            "Accuracy for ship : 83.4%\n",
            "Accuracy for truck: 54.8%\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Training using a GPU?"
      ],
      "metadata": {
        "id": "040W_VVz7DUW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')\n",
        "print(device)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QwB4vyCi7GZd",
        "outputId": "c0acaefe-5a98-4e76-cf99-9d67e5a0f900"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda:0\n"
          ]
        }
      ]
    }
  ]
}