extras/exercises/01_pytorch_workflow_exercises.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "colab_type": "text",
        "id": "view-in-github"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/mrdbourke/pytorch-deep-learning/blob/main/extras/exercises/01_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",
      "metadata": {
        "id": "N8LsPXZti9Sw"
      },
      "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!)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "Glu2fM4dkNlx"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'2.3.0+cu118'"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Import necessary libraries\n",
        "import torch\n",
        "from torch import nn # nn contains all of PyTorch's building blocks for neural networks\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Check PyTorch version\n",
        "torch.__version__"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "LqKhXY26m31s"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Using device: cuda\n"
          ]
        }
      ],
      "source": [
        "# Setup device-agnostic code\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "print(f\"Using device: {device}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g7HUhxCxjeBx"
      },
      "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."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "KbDG5MV7jhvE"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "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"
          ]
        }
      ],
      "source": [
        "# Create the data parameters\n",
        "weight = 0.3\n",
        "bias = 0.9\n",
        "\n",
        "init_point = 0\n",
        "end_point = 1\n",
        "step = 0.01\n",
        "\n",
        "X = torch.arange(init_point, end_point, step).unsqueeze(dim=1)\n",
        "y = X * weight + bias\n",
        "\n",
        "# Make X and y using linear regression feature\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]}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "GlwtT1djkmLw"
      },
      "outputs": [],
      "source": [
        "# Split the data into training and testing\n",
        "from sklearn.model_selection import train_test_split\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20, random_state=42)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "29iQZFNhlYJ-"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "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",
        "  Plots training data, test data and compares predictions.\n",
        "  \"\"\"\n",
        "  plt.figure(figsize=(10, 7))\n",
        "\n",
        "  # Plot training data in blue\n",
        "  plt.scatter(train_data, train_labels, c=\"c\", s=4, label=\"Training data\")\n",
        "\n",
        "  # Plot test data in green\n",
        "  plt.scatter(test_data, test_labels, c=\"k\", s=4, label=\"Testing data\")\n",
        "\n",
        "  if predictions is not None:\n",
        "    # Plot the predictions in red (predictions were made on the test data)\n",
        "    plt.scatter(test_data, predictions, c=\"r\", s=4, marker='s', label=\"Predictions\")\n",
        "\n",
        "  # Show the legend\n",
        "  plt.legend(prop={\"size\": 14});\n",
        "\n",
        "plot_predictions(predictions=None)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ImZoe3v8jif8"
      },
      "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."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "id": "qzd__Y5rjtB8"
      },
      "outputs": [],
      "source": [
        "# Create PyTorch linear regression model by subclassing nn.Module\n",
        "class LinearRegressionModel(nn.Module):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.linear_layer = nn.Linear(in_features=1, out_features=1)\n",
        "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
        "        return self.linear_layer(x)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "5LdcDnmOmyQ2"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "device(type='cuda', index=0)"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Instantiate the model and put it to the target device\n",
        "torch.manual_seed(42)\n",
        "model = LinearRegressionModel()\n",
        "model, model.state_dict()\n",
        "\n",
        "model.to(device)\n",
        "next(model.parameters()).device"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G6nYOrJhjtfu"
      },
      "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."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "ltvoZ-FWjv1j"
      },
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "c:\\Users\\ssre_\\.venv_common\\Lib\\site-packages\\tqdm\\auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
            "  from .autonotebook import tqdm as notebook_tqdm\n"
          ]
        }
      ],
      "source": [
        "# Create the loss function and optimizer\n",
        "loss_function = nn.L1Loss()\n",
        "\n",
        "optimizer = torch.optim.SGD(params=model.parameters(), lr=0.01)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "xpE83NvNnkdV"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch: 0 | Train loss: 0.176 | Test loss: 0.146\n",
            "Epoch: 20 | Train loss: 0.098 | Test loss: 0.093\n",
            "Epoch: 40 | Train loss: 0.080 | Test loss: 0.085\n",
            "Epoch: 60 | Train loss: 0.070 | Test loss: 0.076\n",
            "Epoch: 80 | Train loss: 0.061 | Test loss: 0.066\n",
            "Epoch: 100 | Train loss: 0.051 | Test loss: 0.056\n",
            "Epoch: 120 | Train loss: 0.042 | Test loss: 0.045\n",
            "Epoch: 140 | Train loss: 0.032 | Test loss: 0.035\n",
            "Epoch: 160 | Train loss: 0.023 | Test loss: 0.025\n",
            "Epoch: 180 | Train loss: 0.013 | Test loss: 0.014\n",
            "Epoch: 200 | Train loss: 0.004 | Test loss: 0.004\n",
            "Epoch: 220 | Train loss: 0.009 | Test loss: 0.004\n",
            "Epoch: 240 | Train loss: 0.009 | Test loss: 0.004\n",
            "Epoch: 260 | Train loss: 0.009 | Test loss: 0.004\n",
            "Epoch: 280 | Train loss: 0.009 | Test loss: 0.004\n"
          ]
        }
      ],
      "source": [
        "# Training loop\n",
        "\n",
        "# Train model for 300 epochs\n",
        "N_epochs = 300\n",
        "    \n",
        "# Send data to target device\n",
        "X_train = X_train.to(device)\n",
        "X_test = X_test.to(device)\n",
        "y_train = y_train.to(device)\n",
        "y_test = y_test.to(device)\n",
        "\n",
        "### Training\n",
        "\n",
        "for epoch in range(N_epochs):  \n",
        "\n",
        "  # Put model in train mode\n",
        "  model.train()  \n",
        "\n",
        "  # 1. Forward pass\n",
        "  y_pred = model(X_train)\n",
        "  \n",
        "  # 2. Calculate loss\n",
        "  loss = loss_function(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",
        "  if epoch % 20 == 0:\n",
        "\n",
        "    # Put model in evaluation mode and setup inference context \n",
        "    model.eval()\n",
        "\n",
        "    # 1. Forward pass\n",
        "    test_pred = model(X_test)\n",
        "      \n",
        "    # 2. Calculate test loss\n",
        "    test_loss = loss_function(test_pred, y_test)\n",
        "\n",
        "    # Print out what's happening\n",
        "    print(f\"Epoch: {epoch} | Train loss: {loss:.3f} | Test loss: {test_loss:.3f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "x4j4TM18jwa7"
      },
      "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)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "bbMPK5Qjjyx_"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[1.1608],\n",
              "        [1.0677],\n",
              "        [1.1205],\n",
              "        [1.0429],\n",
              "        [1.0398],\n",
              "        [1.0243],\n",
              "        [0.9715],\n",
              "        [1.1515],\n",
              "        [0.9343],\n",
              "        [0.9033],\n",
              "        [0.9591],\n",
              "        [0.9964],\n",
              "        [1.1298],\n",
              "        [1.0057],\n",
              "        [1.1826],\n",
              "        [0.9157],\n",
              "        [1.1391],\n",
              "        [1.1422],\n",
              "        [0.9405],\n",
              "        [0.9995]], device='cuda:0')"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Make predictions with the model\n",
        "model.eval()\n",
        "with torch.inference_mode():\n",
        "    y_preds = model(X_test)\n",
        "y_preds"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "K3BdmQaDpFo8"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Plot the predictions (these may need to be on a specific device)\n",
        "plot_predictions(predictions=y_preds.cpu())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s2OnlMWKjzX8"
      },
      "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."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "hgxhgD14qr-i"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Saving model to: models\\01_pytorch_workflow_model_exercise.pth\n"
          ]
        }
      ],
      "source": [
        "from pathlib import Path\n",
        "\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_workflow_model_exercise.pth\"\n",
        "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n",
        "\n",
        "# 3. Save the model state dict\n",
        "print(f\"Saving model to: {MODEL_SAVE_PATH}\")\n",
        "torch.save(obj=model.state_dict(), # only saving the state_dict() only saves the models learned parameters\n",
        "           f=MODEL_SAVE_PATH)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "P9vTgiLRrJ7T"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "'cuda'"
            ]
          },
          "execution_count": 20,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Create new instance of model and load saved state dict (make sure to put it on the target device)\n",
        "new_model = LinearRegressionModel()\n",
        "new_model.load_state_dict(torch.load(MODEL_SAVE_PATH))\n",
        "new_model.to(device) #Important to move the model to device"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "8UGX3VebrVtI"
      },
      "outputs": [
        {
          "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')"
            ]
          },
          "execution_count": 19,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Make predictions with loaded model and compare them to the previous\n",
        "\n",
        "new_model.eval()\n",
        "with torch.inference_mode():\n",
        "    y_preds_1 = new_model(X_test)\n",
        "y_preds_1 == y_preds"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_predictions(predictions=y_preds_1.cpu())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "accelerator": "GPU",
    "colab": {
      "authorship_tag": "ABX9TyNYzatJtFkfUqqdiR6rYwVL",
      "collapsed_sections": [],
      "include_colab_link": true,
      "name": "01_pytorch_workflow_exercises.ipynb",
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.11.6"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}