PyTorch_CrashCourse AssemblyAI.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# PyTorch Crash Course\n",
        "\n",
        "#### Overview:\n",
        "\n",
        "1. Tensor Basics\n",
        "  - Create, Operations, NumPy, GPU Support\n",
        "2. Autograd\n",
        "  - Linear regression example\n",
        "3. Training Loop with: Model, Loss & Optimizer\n",
        "  - A typical PyTorch training pipeline\n",
        "4. Neural Network\n",
        "  - Also: GPU, Datasets, DataLoader, Transforms & Evaluation\n",
        "5. Convolutional Neural Network\n",
        "  - Also: Save/Load model"
      ],
      "metadata": {
        "id": "MAcpE-kjwVML"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Tensors\n",
        "\n",
        "Everything in PyTorch is based on Tensor operations. A Tensor is a multi-dimensional matrix containing elements of a single data type:\n"
      ],
      "metadata": {
        "id": "mUT_7ZCPwY9E"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "3mWV8uTgo4Bl"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "\n",
        "# torch.empty(size): uninitiallized\n",
        "x = torch.empty(1) # scalar\n",
        "print(\"empty(1):\", x)\n",
        "x = torch.empty(3) # vector\n",
        "print(\"empty(3):\",x)\n",
        "x = torch.empty(2, 3) # matrix\n",
        "print(\"empty(2,3):\",x)\n",
        "x = torch.empty(2, 2, 3) # tensor, 3 dimensions\n",
        "#x = torch.empty(2,2,2,3) # tensor, 4 dimensions\n",
        "print(\"empty(2, 2, 3):\",x)\n",
        "\n",
        "# torch.rand(size): random numbers [0, 1]\n",
        "x = torch.rand(5, 3)\n",
        "print(\"rand(5,3):\", x)\n",
        "\n",
        "# torch.zeros(size), fill with 0\n",
        "# torch.ones(size), fill with 1\n",
        "x = torch.zeros(5, 3)\n",
        "print(\"zeros(5,3):\", x)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# check size\n",
        "print(\"size\", x.size())  # x.size(0)\n",
        "print(\"shape\", x.shape)  # x.shape[0]"
      ],
      "metadata": {
        "id": "Asq_Sgh7cJnN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# check data type\n",
        "print(x.dtype)\n",
        "\n",
        "# specify types, float32 default\n",
        "x = torch.zeros(5, 3, dtype=torch.float16)\n",
        "print(x)\n",
        "\n",
        "# check type\n",
        "print(x.dtype)"
      ],
      "metadata": {
        "id": "DmDNPMrp_zLj"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# construct from data\n",
        "x = torch.tensor([5.5, 3])\n",
        "print(x, x.dtype)"
      ],
      "metadata": {
        "id": "sj2VAgMM_2Vu"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# requires_grad argument\n",
        "# This will tell pytorch that it will need to calculate the gradients for this tensor\n",
        "# later in your optimization steps\n",
        "# i.e. this is a variable in your model that you want to optimize\n",
        "x = torch.tensor([5.5, 3], requires_grad=True)\n",
        "print(x)"
      ],
      "metadata": {
        "id": "uT-3O8wtcMeZ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Operations with Tensors"
      ],
      "metadata": {
        "id": "_cDRipePEhZ_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Operations\n",
        "x = torch.ones(2, 2)\n",
        "y = torch.rand(2, 2)\n",
        "\n",
        "# elementwise addition\n",
        "z = x + y\n",
        "# torch.add(x,y)\n",
        "\n",
        "# in place addition, everythin with a trailing underscore is an inplace operation\n",
        "# i.e. it will modify the variable\n",
        "# y.add_(x)\n",
        "\n",
        "print(x)\n",
        "print(y)\n",
        "print(z)"
      ],
      "metadata": {
        "id": "3pjK4YL6ES9B"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# subtraction\n",
        "z = x - y\n",
        "z = torch.sub(x, y)\n",
        "\n",
        "# multiplication\n",
        "z = x * y\n",
        "z = torch.mul(x,y)\n",
        "\n",
        "# division\n",
        "z = x / y\n",
        "z = torch.div(x,y)"
      ],
      "metadata": {
        "id": "qXEAxoExC2aq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Slicing\n",
        "x = torch.rand(5,3)\n",
        "print(x)\n",
        "print(\"x[:, 0]\", x[:, 0]) # all rows, column 0\n",
        "print(\"x[1, :]\", x[1, :]) # row 1, all columns\n",
        "print(\"x[1, 1]\", x[1,1]) # element at 1, 1\n",
        "\n",
        "# Get the actual value if only 1 element in your tensor\n",
        "print(\"x[1,1].item()\", x[1,1].item())"
      ],
      "metadata": {
        "id": "KPmWwGnIClh_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Reshape with torch.view()\n",
        "x = torch.randn(4, 4)\n",
        "y = x.view(16)\n",
        "z = x.view(-1, 8)  # the size -1 is inferred from other dimensions\n",
        "# if -1 it pytorch will automatically determine the necessary size\n",
        "print(x.size(), y.size(), z.size())"
      ],
      "metadata": {
        "id": "f2D2dznXCouO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### NumPy\n",
        "\n",
        "Converting a Torch Tensor to a NumPy array and vice versa is very easy"
      ],
      "metadata": {
        "id": "rRbfGqafEu77"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "a = torch.ones(5)\n",
        "print(a)\n",
        "\n",
        "# torch to numpy with .numpy()\n",
        "b = a.numpy()\n",
        "print(b)\n",
        "print(type(b))"
      ],
      "metadata": {
        "id": "JB1OCRrUEyBr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Careful: If the Tensor is on the CPU (not the GPU),\n",
        "# both objects will share the same memory location, so changing one\n",
        "# will also change the other\n",
        "a.add_(1)\n",
        "print(a)\n",
        "print(b)"
      ],
      "metadata": {
        "id": "kUzV6XdhdwYJ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# numpy to torch with .from_numpy(x), or torch.tensor() to copy it\n",
        "import numpy as np\n",
        "a = np.ones(5)\n",
        "b = torch.from_numpy(a)\n",
        "c = torch.tensor(a)\n",
        "print(a)\n",
        "print(b)\n",
        "print(c)\n",
        "\n",
        "# again be careful when modifying\n",
        "a += 1\n",
        "print(a)\n",
        "print(b)\n",
        "print(c)"
      ],
      "metadata": {
        "id": "SjHqp4sCeFip"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### GPU Support\n",
        "\n",
        "By default all tensors are created on the CPU. But we can also move them to the GPU (if it's available ), or create them directly on the GPU."
      ],
      "metadata": {
        "id": "d0JweYJEFKSC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "x = torch.rand(2,2).to(device)  # move tensors to GPU device\n",
        "#x = x.to(\"cpu\")\n",
        "#x = x.to(\"cuda\")  \n",
        "\n",
        "x = torch.rand(2,2, device=device)  # or directy create them on GPU"
      ],
      "metadata": {
        "id": "ZKe9RBTzFMRP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. Autograd\n",
        "\n",
        "The autograd package provides automatic differentiation for all operations on Tensors. Generally speaking, *torch.autograd* is an engine for computing the vector-Jacobian product. It computes partial derivates while applying the chain rule.\n",
        "\n",
        "Set `requires_grad = True`:"
      ],
      "metadata": {
        "id": "AUNVPAlvxqlR"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# requires_grad = True -> tracks all operations on the tensor. \n",
        "x = torch.randn(3, requires_grad=True)\n",
        "y = x + 2\n",
        "\n",
        "# y was created as a result of an operation, so it has a grad_fn attribute.\n",
        "# grad_fn: references a Function that has created the Tensor\n",
        "print(x) # created by the user -> grad_fn is None\n",
        "print(y)\n",
        "print(y.grad_fn)"
      ],
      "metadata": {
        "id": "V2uQnrUpw8DA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Do more operations on y\n",
        "z = y * y * 3\n",
        "print(z)\n",
        "z = z.mean()\n",
        "print(z)"
      ],
      "metadata": {
        "id": "4mIlnyc-e5-0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's compute the gradients with backpropagation\n",
        "# When we finish our computation we can call .backward() and have all the gradients computed automatically.\n",
        "# The gradient for this tensor will be accumulated into .grad attribute.\n",
        "# It is the partial derivate of the function w.r.t. the tensor\n",
        "\n",
        "print(x.grad)\n",
        "z.backward()\n",
        "print(x.grad) # dz/dx\n",
        "\n",
        "# !!! Careful!!! backward() accumulates the gradient for this tensor into .grad attribute.\n",
        "# !!! We need to be careful during optimization !!! optimizer.zero_grad()"
      ],
      "metadata": {
        "id": "YcSsY7z_IxOF"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Stop a tensor from tracking history:\n",
        "For example during the training loop when we want to update our weights, or after training during evaluation. These operations should not be part of the gradient computation. To prevent this, we can use:\n",
        "\n",
        "- `x.requires_grad_(False)`\n",
        "- `x.detach()`\n",
        "- wrap in `with torch.no_grad():`"
      ],
      "metadata": {
        "id": "sqft_WDKgPfa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# .requires_grad_(...) changes an existing flag in-place.\n",
        "a = torch.randn(2, 2)\n",
        "b = (a * a).sum()\n",
        "print(a.requires_grad)\n",
        "print(b.grad_fn)\n",
        "\n",
        "a.requires_grad_(True)\n",
        "b = (a * a).sum()\n",
        "print(a.requires_grad)\n",
        "print(b.grad_fn)"
      ],
      "metadata": {
        "id": "ixsK058BgPJq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# .detach(): get a new Tensor with the same content but no gradient computation:\n",
        "a = torch.randn(2, 2, requires_grad=True)\n",
        "b = a.detach()\n",
        "print(a.requires_grad)\n",
        "print(b.requires_grad)"
      ],
      "metadata": {
        "id": "5Ry_MsWhfByT"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# wrap in 'with torch.no_grad():'\n",
        "a = torch.randn(2, 2, requires_grad=True)\n",
        "print(a.requires_grad)\n",
        "with torch.no_grad():\n",
        "    b = a ** 2\n",
        "    print(b.requires_grad)"
      ],
      "metadata": {
        "id": "D1Y9nLXVfFAC"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Gradient Descent Autograd\n",
        "Linear Regression example:\n",
        "\n",
        "$f(x) = w * x + b$\n",
        "\n",
        "here : `f(x) = 2 * x`"
      ],
      "metadata": {
        "id": "L6gdoDj1QZQ6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# Linear regression\n",
        "# f = w * x  + b\n",
        "# here : f = 2 * x\n",
        "\n",
        "X = torch.tensor([1, 2, 3, 4, 5, 6, 7, 8], dtype=torch.float32)\n",
        "Y = torch.tensor([2, 4, 6, 8, 10, 12, 14, 16], dtype=torch.float32)\n",
        "\n",
        "w = torch.tensor(0.0, dtype=torch.float32, requires_grad=True)\n",
        "\n",
        "# model output\n",
        "def forward(x):\n",
        "    return w * x\n",
        "\n",
        "# loss = MSE\n",
        "def loss(y, y_pred):\n",
        "    return ((y_pred - y)**2).mean()\n",
        "\n",
        "X_test = 5.0\n",
        "\n",
        "print(f'Prediction before training: f({X_test}) = {forward(X_test).item():.3f}')"
      ],
      "metadata": {
        "id": "YDzeYp72xnhg"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Training\n",
        "learning_rate = 0.01\n",
        "n_epochs = 100\n",
        "\n",
        "for epoch in range(n_epochs):\n",
        "    # predict = forward pass\n",
        "    y_pred = forward(X)\n",
        "\n",
        "    # loss\n",
        "    l = loss(Y, y_pred)\n",
        "\n",
        "    # calculate gradients = backward pass\n",
        "    l.backward()\n",
        "\n",
        "    # update weights\n",
        "    #w.data = w.data - learning_rate * w.grad\n",
        "    with torch.no_grad():\n",
        "      w -= learning_rate * w.grad\n",
        "    \n",
        "    # zero the gradients after updating\n",
        "    w.grad.zero_()\n",
        "\n",
        "    if (epoch+1) % 10 == 0:\n",
        "        print(f'epoch {epoch+1}: w = {w.item():.3f}, loss = {l.item():.3f}')\n",
        "\n",
        "print(f'Prediction after training: f({X_test}) = {forward(X_test).item():.3f}')"
      ],
      "metadata": {
        "id": "3H_VoUv9pnfP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. Model, Loss & Optimizer\n",
        "\n",
        "A typical PyTorch pipeline looks like this:\n",
        "\n",
        "1. Design model (input, output, forward pass with different layers)\n",
        "2. Construct loss and optimizer\n",
        "3. Training loop:\n",
        "  - Forward = compute prediction and loss\n",
        "  - Backward = compute gradients\n",
        "  - Update weights"
      ],
      "metadata": {
        "id": "Vjq9HmRFQjov"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "\n",
        "# Linear regression\n",
        "# f = w * x \n",
        "# here : f = 2 * x\n",
        "\n",
        "# 0) Training samples, watch the shape!\n",
        "X = torch.tensor([[1], [2], [3], [4], [5], [6], [7], [8]], dtype=torch.float32)\n",
        "Y = torch.tensor([[2], [4], [6], [8], [10], [12], [14], [16]], dtype=torch.float32)\n",
        "\n",
        "n_samples, n_features = X.shape\n",
        "print(f'n_samples = {n_samples}, n_features = {n_features}')\n",
        "\n",
        "# 0) create a test sample\n",
        "X_test = torch.tensor([5], dtype=torch.float32)"
      ],
      "metadata": {
        "id": "e9HD5KW3QGFS"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# 1) Design Model, the model has to implement the forward pass!\n",
        "\n",
        "# Here we could simply use a built-in model from PyTorch\n",
        "# model = nn.Linear(input_size, output_size)\n",
        "\n",
        "class LinearRegression(nn.Module):\n",
        "    def __init__(self, input_dim, output_dim):\n",
        "        super(LinearRegression, self).__init__()\n",
        "        # define different layers\n",
        "        self.lin = nn.Linear(input_dim, output_dim)\n",
        "\n",
        "    def forward(self, x):\n",
        "        return self.lin(x)\n",
        "\n",
        "\n",
        "input_size, output_size = n_features, n_features\n",
        "\n",
        "model = LinearRegression(input_size, output_size)\n",
        "\n",
        "print(f'Prediction before training: f({X_test.item()}) = {model(X_test).item():.3f}')\n",
        "\n",
        "# 2) Define loss and optimizer\n",
        "learning_rate = 0.01\n",
        "n_epochs = 100\n",
        "\n",
        "loss = nn.MSELoss()\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
        "\n",
        "# 3) Training loop\n",
        "for epoch in range(n_epochs):\n",
        "    # predict = forward pass with our model\n",
        "    y_predicted = model(X)\n",
        "\n",
        "    # loss\n",
        "    l = loss(Y, y_predicted)\n",
        "\n",
        "    # calculate gradients = backward pass\n",
        "    l.backward()\n",
        "\n",
        "    # update weights\n",
        "    optimizer.step()\n",
        "\n",
        "    # zero the gradients after updating\n",
        "    optimizer.zero_grad()\n",
        "\n",
        "    if (epoch+1) % 10 == 0:\n",
        "        w, b = model.parameters() # unpack parameters\n",
        "        print('epoch ', epoch+1, ': w = ', w[0][0].item(), ' loss = ', l.item())\n",
        "\n",
        "print(f'Prediction after training: f({X_test.item()}) = {model(X_test).item():.3f}')"
      ],
      "metadata": {
        "id": "eID-YTrgqNUn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4. First Neural Net\n",
        "GPU, Datasets, DataLoader, Transforms, Neural Net, Training & Evaluation\n"
      ],
      "metadata": {
        "id": "M4njny3PUJsI"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Device configuration\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "# Hyper-parameters \n",
        "input_size = 784 # 28x28\n",
        "hidden_size = 500 \n",
        "num_classes = 10\n",
        "num_epochs = 2\n",
        "batch_size = 100\n",
        "learning_rate = 0.001\n",
        "\n",
        "# MNIST dataset \n",
        "train_dataset = torchvision.datasets.MNIST(root='./data', \n",
        "                                           train=True, \n",
        "                                           transform=transforms.ToTensor(),  \n",
        "                                           download=True)\n",
        "\n",
        "test_dataset = torchvision.datasets.MNIST(root='./data', \n",
        "                                          train=False, \n",
        "                                          transform=transforms.ToTensor())\n",
        "\n",
        "# Data loader\n",
        "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, \n",
        "                                           batch_size=batch_size, \n",
        "                                           shuffle=True)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, \n",
        "                                          batch_size=batch_size, \n",
        "                                          shuffle=False)\n",
        "\n",
        "examples = iter(test_loader)\n",
        "example_data, example_targets = examples.next()\n",
        "\n",
        "for i in range(6):\n",
        "    plt.subplot(2,3,i+1)\n",
        "    plt.imshow(example_data[i][0], cmap='gray')\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 267
        },
        "id": "dLpCL5NUQzOZ",
        "outputId": "b0b46056-183c-4ea2-f494-ff503c6eed14"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 6 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Fully connected neural network with one hidden layer\n",
        "class NeuralNet(nn.Module):\n",
        "    def __init__(self, input_size, hidden_size, num_classes):\n",
        "        super(NeuralNet, self).__init__()\n",
        "        self.l1 = nn.Linear(input_size, hidden_size) \n",
        "        self.relu = nn.ReLU()\n",
        "        self.l2 = nn.Linear(hidden_size, num_classes)  \n",
        "    \n",
        "    def forward(self, x):\n",
        "        out = self.l1(x)\n",
        "        out = self.relu(out)\n",
        "        out = self.l2(out)\n",
        "        # no activation and no softmax at the end\n",
        "        return out\n",
        "\n",
        "model = NeuralNet(input_size, hidden_size, num_classes).to(device)\n",
        "\n",
        "# Loss and optimizer\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)  \n",
        "\n",
        "# Train the model\n",
        "n_total_steps = len(train_loader)\n",
        "for epoch in range(num_epochs):\n",
        "    for i, (images, labels) in enumerate(train_loader):  \n",
        "        # origin shape: [100, 1, 28, 28]\n",
        "        # resized: [100, 784]\n",
        "        images = images.reshape(-1, 28*28).to(device)\n",
        "        labels = labels.to(device)\n",
        "        \n",
        "        # Forward pass and loss calculation\n",
        "        outputs = model(images)\n",
        "        loss = criterion(outputs, labels)\n",
        "        \n",
        "        # Backward and optimize\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        optimizer.zero_grad()\n",
        "        \n",
        "        if (i+1) % 100 == 0:\n",
        "            print (f'Epoch [{epoch+1}/{num_epochs}], Step [{i+1}/{n_total_steps}], Loss: {loss.item():.4f}')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "udJ5RnoDrOzp",
        "outputId": "9a139a88-9268-49df-db2b-4a5697305a47"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch [1/2], Step [100/600], Loss: 0.3486\n",
            "Epoch [1/2], Step [200/600], Loss: 0.1807\n",
            "Epoch [1/2], Step [300/600], Loss: 0.2612\n",
            "Epoch [1/2], Step [400/600], Loss: 0.1134\n",
            "Epoch [1/2], Step [500/600], Loss: 0.1875\n",
            "Epoch [1/2], Step [600/600], Loss: 0.3031\n",
            "Epoch [2/2], Step [100/600], Loss: 0.0671\n",
            "Epoch [2/2], Step [200/600], Loss: 0.1215\n",
            "Epoch [2/2], Step [300/600], Loss: 0.1317\n",
            "Epoch [2/2], Step [400/600], Loss: 0.0537\n",
            "Epoch [2/2], Step [500/600], Loss: 0.0350\n",
            "Epoch [2/2], Step [600/600], Loss: 0.0633\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Test the model: we don't need to compute gradients\n",
        "with torch.no_grad():\n",
        "    n_correct = 0\n",
        "    n_samples = len(test_loader.dataset)\n",
        "\n",
        "    for images, labels in test_loader:\n",
        "        images = images.reshape(-1, 28*28).to(device)\n",
        "        labels = labels.to(device)\n",
        "\n",
        "        outputs = model(images)\n",
        "\n",
        "        # max returns (output_value ,index)\n",
        "        _, predicted = torch.max(outputs, 1)\n",
        "        n_correct += (predicted == labels).sum().item()\n",
        "\n",
        "    acc = n_correct / n_samples\n",
        "    print(f'Accuracy of the network on the {n_samples} test images: {100*acc} %')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i9x54JYIrTUd",
        "outputId": "8f7b2b5a-7dc1-489b-f583-a90ad2958cd8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy of the network on the 10000 test images: 96.92 %\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5. CNN\n",
        "\n",
        "This section covers:\n",
        "\n",
        "- Convolutional Layers\n",
        "- MaxPooling\n",
        "- Save/Load model"
      ],
      "metadata": {
        "id": "yKgzU8XCurGW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.nn.functional as F\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# Device configuration\n",
        "device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
        "\n",
        "# Hyper-parameters \n",
        "num_epochs = 10\n",
        "batch_size = 32\n",
        "learning_rate = 0.001\n",
        "\n",
        "# dataset has PILImage images of range [0, 1]. \n",
        "# We transform them to Tensors of normalized range [-1, 1]\n",
        "transform = transforms.Compose(\n",
        "    [transforms.ToTensor(),\n",
        "     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
        "\n",
        "# CIFAR10: 60000 32x32 color images in 10 classes, with 6000 images per class\n",
        "train_dataset = torchvision.datasets.CIFAR10(root='./data', train=True,\n",
        "                                        download=True, transform=transform)\n",
        "\n",
        "test_dataset = torchvision.datasets.CIFAR10(root='./data', train=False,\n",
        "                                       download=True, transform=transform)\n",
        "\n",
        "train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,\n",
        "                                          shuffle=True)\n",
        "\n",
        "test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,\n",
        "                                         shuffle=False)\n",
        "\n",
        "classes = ('plane', 'car', 'bird', 'cat',\n",
        "           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')\n",
        "\n",
        "def imshow(imgs):\n",
        "    imgs = imgs / 2 + 0.5   # unnormalize\n",
        "    npimgs = imgs.numpy()\n",
        "    plt.imshow(np.transpose(npimgs, (1, 2, 0)))\n",
        "    plt.show()\n",
        "\n",
        "# one batch of random training images\n",
        "dataiter = iter(train_loader)\n",
        "images, labels = dataiter.next()\n",
        "img_grid = torchvision.utils.make_grid(images[0:25], nrow=5)\n",
        "imshow(img_grid)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 305
        },
        "id": "Sr91YjuQT-XP",
        "outputId": "dbd7a155-3714-4e84-ae58-77587ca5bb31"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Files already downloaded and verified\n",
            "Files already downloaded and verified\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class ConvNet(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.conv1 = nn.Conv2d(3, 32, 3)\n",
        "        self.pool = nn.MaxPool2d(2, 2)\n",
        "        self.conv2 = nn.Conv2d(32, 64, 3)\n",
        "        self.conv3 = nn.Conv2d(64, 64, 3)\n",
        "        self.fc1 = nn.Linear(64*4*4, 64)\n",
        "        self.fc2 = nn.Linear(64, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        # N, 3, 32, 32\n",
        "        x = F.relu(self.conv1(x))   # -> N, 32, 30, 30\n",
        "        x = self.pool(x)            # -> N, 32, 15, 15\n",
        "        x = F.relu(self.conv2(x))   # -> N, 64, 13, 13\n",
        "        x = self.pool(x)            # -> N, 64, 6, 6\n",
        "        x = F.relu(self.conv3(x))   # -> N, 64, 4, 4\n",
        "        x = torch.flatten(x, 1)     # -> N, 1024\n",
        "        x = F.relu(self.fc1(x))     # -> N, 64\n",
        "        x = self.fc2(x)             # -> N, 10\n",
        "        return x\n",
        "\n",
        "\n",
        "model = ConvNet().to(device)\n",
        "\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)\n",
        "\n",
        "n_total_steps = len(train_loader)\n",
        "for epoch in range(num_epochs):\n",
        "\n",
        "    running_loss = 0.0\n",
        "\n",
        "    for i, (images, labels) in enumerate(train_loader):\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "\n",
        "        # Forward pass\n",
        "        outputs = model(images)\n",
        "        loss = criterion(outputs, labels)\n",
        "\n",
        "        # Backward and optimize\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        optimizer.zero_grad()\n",
        "\n",
        "        running_loss += loss.item()\n",
        "\n",
        "    print(f'[{epoch + 1}] loss: {running_loss / n_total_steps:.3f}')\n",
        "\n",
        "print('Finished Training')\n",
        "PATH = './cnn.pth'\n",
        "torch.save(model.state_dict(), PATH)"
      ],
      "metadata": {
        "id": "n4ekV872wPF5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f8e0d0e3-7349-4479-c0aa-4c74dafebb2d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[1] loss: 1.472\n",
            "[2] loss: 1.105\n",
            "[3] loss: 0.942\n",
            "[4] loss: 0.835\n",
            "[5] loss: 0.762\n",
            "[6] loss: 0.697\n",
            "[7] loss: 0.649\n",
            "[8] loss: 0.603\n",
            "[9] loss: 0.561\n",
            "[10] loss: 0.527\n",
            "Finished Training\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loaded_model = ConvNet()\n",
        "loaded_model.load_state_dict(torch.load(PATH)) # it takes the loaded dictionary, not the path file itself\n",
        "loaded_model.to(device)\n",
        "loaded_model.eval()\n",
        "\n",
        "with torch.no_grad():\n",
        "    n_correct = 0\n",
        "    n_correct2 = 0\n",
        "    n_samples = len(test_loader.dataset)\n",
        "\n",
        "    for images, labels in test_loader:\n",
        "        images = images.to(device)\n",
        "        labels = labels.to(device)\n",
        "        outputs = model(images)\n",
        "\n",
        "        # max returns (value ,index)\n",
        "        _, predicted = torch.max(outputs, 1)\n",
        "        n_correct += (predicted == labels).sum().item()\n",
        "\n",
        "        outputs2 = loaded_model(images)\n",
        "        _, predicted2 = torch.max(outputs2, 1)\n",
        "        n_correct2 += (predicted2 == labels).sum().item()\n",
        "\n",
        "    acc = 100.0 * n_correct / n_samples\n",
        "    print(f'Accuracy of the model: {acc} %')\n",
        "\n",
        "    acc = 100.0 * n_correct2 / n_samples\n",
        "    print(f'Accuracy of the loaded model: {acc} %')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "oVIQkMQXsRIR",
        "outputId": "77c1f6af-0ef4-4394-9f56-910a847065cb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Accuracy of the model: 71.29 %\n",
            "Accuracy of the loaded model: 71.29 %\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "Wk4gdclP9yPQ"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}