pytorch_workflow_exercises.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mekhiya/pytorch-playground/blob/main/pytorch_workflow_exercises.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 01. PyTorch Workflow Exercise Template\n",
        "\n",
        "The following is a template for the PyTorch workflow exercises.\n",
        "\n",
        "It's only starter code and it's your job to fill in the blanks.\n",
        "\n",
        "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n",
        "\n",
        "Don't worry about trying to be *right* just try writing code that suffices the question.\n",
        "\n",
        "You can see one form of [solutions on GitHub](https://github.com/mrdbourke/pytorch-deep-learning/tree/main/extras/solutions) (but try the exercises below yourself first!)."
      ],
      "metadata": {
        "id": "N8LsPXZti9Sw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import necessary libraries\n",
        "import torch\n",
        "from torch import nn\n",
        "import matplotlib.pyplot as plt"
      ],
      "metadata": {
        "id": "Glu2fM4dkNlx"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup device-agnostic code\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\""
      ],
      "metadata": {
        "id": "LqKhXY26m31s"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Create a straight line dataset using the linear regression formula (`weight * X + bias`).\n",
        "  * Set `weight=0.3` and `bias=0.9` there should be at least 100 datapoints total.\n",
        "  * Split the data into 80% training, 20% testing.\n",
        "  * Plot the training and testing data so it becomes visual.\n",
        "\n",
        "Your output of the below cell should look something like:\n",
        "```\n",
        "Number of X samples: 100\n",
        "Number of y samples: 100\n",
        "First 10 X & y samples:\n",
        "X: tensor([0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700, 0.0800,\n",
        "        0.0900])\n",
        "y: tensor([0.9000, 0.9030, 0.9060, 0.9090, 0.9120, 0.9150, 0.9180, 0.9210, 0.9240,\n",
        "        0.9270])\n",
        "```\n",
        "\n",
        "Of course the numbers in `X` and `y` may be different but ideally they're created using the linear regression formula."
      ],
      "metadata": {
        "id": "g7HUhxCxjeBx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the data parameters\n",
        "weight = 0.3\n",
        "bias = 0.9\n",
        "\n",
        "start = 0\n",
        "end = 1\n",
        "steps = 0.01\n",
        "\n",
        "train_split = int(0.8 * len(X))\n",
        "\n",
        "# Make X and y using linear regression feature\n",
        "X = torch.arange(start, end, steps).unsqueeze(dim=1)\n",
        "y = weight * X + bias\n",
        "\n",
        "\n",
        "print(f\"Number of X samples: {len(X)}\")\n",
        "print(f\"Number of y samples: {len(y)}\")\n",
        "print(f\"First 10 X & y samples:\\nX: {X[:10]}\\ny: {y[:10]}\")"
      ],
      "metadata": {
        "id": "KbDG5MV7jhvE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b60b72de-8d21-4e20-df45-2f2f60a417a9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of X samples: 100\n",
            "Number of y samples: 100\n",
            "First 10 X & y samples:\n",
            "X: tensor([[0.0000],\n",
            "        [0.0100],\n",
            "        [0.0200],\n",
            "        [0.0300],\n",
            "        [0.0400],\n",
            "        [0.0500],\n",
            "        [0.0600],\n",
            "        [0.0700],\n",
            "        [0.0800],\n",
            "        [0.0900]])\n",
            "y: tensor([[0.9000],\n",
            "        [0.9030],\n",
            "        [0.9060],\n",
            "        [0.9090],\n",
            "        [0.9120],\n",
            "        [0.9150],\n",
            "        [0.9180],\n",
            "        [0.9210],\n",
            "        [0.9240],\n",
            "        [0.9270]])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Split the data into training and testing\n",
        "X_train, y_train = X[:train_split], y[:train_split]\n",
        "X_test, y_test = X[train_split:], y[train_split:]\n",
        "\n",
        "len(X_train), len(y_train), len(X_test), len(y_test)"
      ],
      "metadata": {
        "id": "GlwtT1djkmLw",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "24cc92db-b955-4013-8427-e260763548ed"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(80, 80, 20, 20)"
            ]
          },
          "metadata": {},
          "execution_count": 21
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the training and testing data\n",
        "def plot_predictions(train_data=X_train,\n",
        "                     train_labels=y_train,\n",
        "                     test_data=X_test,\n",
        "                     test_labels=y_test,\n",
        "                     predictions=None):\n",
        "\n",
        "  plt.figure(figsize = (10,7))\n",
        "  plt.scatter(train_data, train_labels, c=\"b\", s=4, label=\"Training data\")\n",
        "\n",
        "  plt.scatter(test_data, test_labels, c=\"g\", s=4, label=\"Testing data\")\n",
        "\n",
        "  if predictions is not None:\n",
        "    plt.scatter(predictions, test_labels, c=\"r\", s=4, label=\"Predictions\")\n",
        "\n",
        "  plt.legend(prop = {\"size\" : 14});\n",
        "\n",
        "plot_predictions();"
      ],
      "metadata": {
        "id": "29iQZFNhlYJ-",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "outputId": "23cbf9a1-71d5-4db4-f2a6-f1851c745eb2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. Build a PyTorch model by subclassing `nn.Module`.\n",
        "  * Inside should be a randomly initialized `nn.Parameter()` with `requires_grad=True`, one for `weights` and one for `bias`.\n",
        "  * Implement the `forward()` method to compute the linear regression function you used to create the dataset in 1.\n",
        "  * Once you've constructed the model, make an instance of it and check its `state_dict()`.\n",
        "  * **Note:** If you'd like to use `nn.Linear()` instead of `nn.Parameter()` you can."
      ],
      "metadata": {
        "id": "ImZoe3v8jif8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create PyTorch linear regression model by subclassing nn.Module\n",
        "class LinearRegressionModel(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "\n",
        "    self.weight = nn.Parameter(data=torch.randn(1, requires_grad=True, dtype=torch.float))\n",
        "    self.bias = nn.Parameter(data=torch.randn(1, requires_grad=True, dtype=torch.float))\n",
        "\n",
        "  def forward(self, x : torch.Tensor)-> torch.Tensor:\n",
        "    return self.weight * x + self.bias"
      ],
      "metadata": {
        "id": "qzd__Y5rjtB8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class LinearRegressionModel1(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.linear_layer = nn.Linear(in_features=1,\n",
        "                                  out_features=1,\n",
        "                                  device=device)\n",
        "\n",
        "  def forward(self, x: torch.Tensor)-> torch.Tensor:\n",
        "    return self.linear_layer(x)\n"
      ],
      "metadata": {
        "id": "BrvQUn4rvxzB"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Instantiate the model and put it to the target device\n",
        "torch.manual_seed(42)\n",
        "\n",
        "model_0 = LinearRegressionModel()\n",
        "model_0.to(device)\n",
        "model_0.state_dict()"
      ],
      "metadata": {
        "id": "5LdcDnmOmyQ2",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d8fe1bc4-bb2e-4cfe-f811-2b42771f2fff"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weight', tensor([0.3367], device='cuda:0')),\n",
              "             ('bias', tensor([0.1288], device='cuda:0'))])"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. Create a loss function and optimizer using `nn.L1Loss()` and `torch.optim.SGD(params, lr)` respectively.\n",
        "  * Set the learning rate of the optimizer to be 0.01 and the parameters to optimize should be the model parameters from the model you created in 2.\n",
        "  * Write a training loop to perform the appropriate training steps for 300 epochs.\n",
        "  * The training loop should test the model on the test dataset every 20 epochs."
      ],
      "metadata": {
        "id": "G6nYOrJhjtfu"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create the loss function and optimizer\n",
        "loss_fn = nn.L1Loss()\n",
        "\n",
        "optimizer = torch.optim.SGD(model_0.parameters(),\n",
        "                            lr=0.01)"
      ],
      "metadata": {
        "id": "ltvoZ-FWjv1j"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Training loop\n",
        "epochs = 300\n",
        "\n",
        "# Send data to target device\n",
        "\n",
        "X_train = X_train.to(device)\n",
        "y_train = y_train.to(device)\n",
        "X_test = X_test.to(device)\n",
        "y_test = y_test.to(device)\n",
        "\n",
        "# Train model for 300 epochs\n",
        "\n",
        "for epoch in range(epochs):\n",
        "  ### Training\n",
        "\n",
        "  # Put model in train mode\n",
        "  model_0.train()\n",
        "\n",
        "\n",
        "  # 1. Forward pass\n",
        "  y_pred = model_0(X_train)\n",
        "\n",
        "  # 2. Calculate loss\n",
        "  loss = loss_fn(y_pred, y_train)\n",
        "\n",
        "  # 3. Zero gradients\n",
        "  optimizer.zero_grad()\n",
        "\n",
        "  # 4. Backpropagation\n",
        "  loss.backward()\n",
        "\n",
        "  # 5. Step the optimizer\n",
        "  optimizer.step()\n",
        "\n",
        "  ### Perform testing every 20 epochs\n",
        "\n",
        "  model_0.eval()\n",
        "\n",
        "  with torch.inference_mode():\n",
        "    test_pred = model_0(X_test)\n",
        "    test_loss = loss_fn(test_pred, y_test)\n",
        "\n",
        "  if epoch % 30 == 0 :\n",
        "    print(f\"Epoch: {epoch} Train Loss: {loss: .3f} | Test Loss: {test_loss: .3f}\")\n"
      ],
      "metadata": {
        "id": "xpE83NvNnkdV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1dae9b98-94c8-4f1e-f620-704d169966a6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0 Train Loss:  0.757 | Test Loss:  0.725\n",
            "Epoch: 30 Train Loss:  0.410 | Test Loss:  0.319\n",
            "Epoch: 60 Train Loss:  0.077 | Test Loss:  0.073\n",
            "Epoch: 90 Train Loss:  0.049 | Test Loss:  0.112\n",
            "Epoch: 120 Train Loss:  0.039 | Test Loss:  0.089\n",
            "Epoch: 150 Train Loss:  0.028 | Test Loss:  0.066\n",
            "Epoch: 180 Train Loss:  0.018 | Test Loss:  0.042\n",
            "Epoch: 210 Train Loss:  0.008 | Test Loss:  0.018\n",
            "Epoch: 240 Train Loss:  0.004 | Test Loss:  0.006\n",
            "Epoch: 270 Train Loss:  0.004 | Test Loss:  0.006\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_0.state_dict(), weight, bias"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "s2lzZ4C43pyp",
        "outputId": "5c80d5e5-d521-417e-d164-40b99a50d42a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(OrderedDict([('weight', tensor([0.3067], device='cuda:0')),\n",
              "              ('bias', tensor([0.9011], device='cuda:0'))]),\n",
              " 0.3,\n",
              " 0.9)"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 4. Make predictions with the trained model on the test data.\n",
        "  * Visualize these predictions against the original training and testing data (**note:** you may need to make sure the predictions are *not* on the GPU if you want to use non-CUDA-enabled libraries such as matplotlib to plot)."
      ],
      "metadata": {
        "id": "x4j4TM18jwa7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Make predictions with the model\n",
        "model_0.eval()\n",
        "with torch.inference_mode():\n",
        "  y_pred = model_0(X_test)\n",
        "  loss = loss_fn(y_pred, y_test)\n"
      ],
      "metadata": {
        "id": "bbMPK5Qjjyx_"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the predictions (these may need to be on a specific device)\n",
        "plot_predictions(predictions=y_pred.cpu())"
      ],
      "metadata": {
        "id": "K3BdmQaDpFo8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "outputId": "241def3b-e29a-47a1-8264-a3ad45242805"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 5. Save your trained model's `state_dict()` to file.\n",
        "  * Create a new instance of your model class you made in 2. and load in the `state_dict()` you just saved to it.\n",
        "  * Perform predictions on your test data with the loaded model and confirm they match the original model predictions from 4."
      ],
      "metadata": {
        "id": "s2OnlMWKjzX8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pathlib import Path\n",
        "# 1. Create models directory\n",
        "MODEL_PATH = Path(\"models\")\n",
        "MODEL_PATH.mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "# 2. Create model save path\n",
        "MODEL_NAME = \"01_pytorch_model_0.pth\"\n",
        "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n",
        "\n",
        "# 3. Save the model state dict\n",
        "torch.save(obj=model_0.state_dict(), f=MODEL_SAVE_PATH)"
      ],
      "metadata": {
        "id": "hgxhgD14qr-i"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Create new instance of model and load saved state dict (make sure to put it on the target device)\n",
        "loaded_model_0 = LinearRegressionModel()\n",
        "loaded_model_0.load_state_dict(torch.load(f=MODEL_SAVE_PATH))\n",
        "loaded_model_0.to(device)"
      ],
      "metadata": {
        "id": "P9vTgiLRrJ7T",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c9b5f815-0225-4f30-99a4-c56f40f73137"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LinearRegressionModel()"
            ]
          },
          "metadata": {},
          "execution_count": 67
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make predictions with loaded model and compare them to the previous\n",
        "y_preds_new = loaded_model_0(X_test)\n",
        "y_preds_new == y_pred"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eeCMKtva-FnH",
        "outputId": "2eeea763-1c61-4cf3-9bef-93da9977edfe"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True],\n",
              "        [True]], device='cuda:0')"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loaded_model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "QBmaZ55s-Fls",
        "outputId": "5aa5d396-746b-4203-b81a-e6546978873f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weight', tensor([0.3067], device='cuda:0')),\n",
              "             ('bias', tensor([0.9011], device='cuda:0'))])"
            ]
          },
          "metadata": {},
          "execution_count": 70
        }
      ]
    }
  ]
}