01workflowfundamentals.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 01. PyTorch Workflow Fundamentals\n",
    "\n",
    "Remember the essence of machine learning and deep learning is taking data from the past, building an algorithm to discover patterns and using those patterns to predict future outcomes.\n",
    "\n",
    "Main outline of steps:\n",
    "1. Get data ready (turn into tensors)\n",
    "2. Build or pick pretrained system \n",
    "  2.1 Pick a loss function and optimizer\n",
    "  2.2 Build a training loop\n",
    "3. Fit model to data and make prediction\n",
    "4. Evaluate the model\n",
    "5. Imrpove through experimentation\n",
    "6. Save and reload trained model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.13.1+cpu'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "from torch import nn # Building blocks for neural networks\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "torch.__version__"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data (preparing and loading)\n",
    "\n",
    "1. Turn data (could be anything) into numbers\n",
    "2. Pick or build model to learn the representation as best as possible\n",
    "\n",
    "\n",
    "Example\n",
    "- use linear regression to create data with known parameters\n",
    "- use PyTorch to see if we can build a model to estimate parameters using **gradient descent**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[0.0000],\n",
       "         [0.0200],\n",
       "         [0.0400],\n",
       "         [0.0600],\n",
       "         [0.0800],\n",
       "         [0.1000],\n",
       "         [0.1200],\n",
       "         [0.1400],\n",
       "         [0.1600],\n",
       "         [0.1800]]),\n",
       " tensor([[0.3000],\n",
       "         [0.3140],\n",
       "         [0.3280],\n",
       "         [0.3420],\n",
       "         [0.3560],\n",
       "         [0.3700],\n",
       "         [0.3840],\n",
       "         [0.3980],\n",
       "         [0.4120],\n",
       "         [0.4260]]))"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Known parameters\n",
    "weight = 0.7\n",
    "bias = 0.3\n",
    "\n",
    "# Data\n",
    "start = 0\n",
    "end = 1\n",
    "step = 0.02\n",
    "X = torch.arange(start, end, step).unsqueeze(dim=1)\n",
    "y = weight * X + bias\n",
    "\n",
    "X[:10], y[:10]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now build a model that can learn the relationship between `X` **(features)** and `y` **(labels)**.\n",
    "\n",
    "### Split data into training and test sets\n",
    "\n",
    "Before we build the model, we need to split the data.\n",
    "\n",
    "**Training set**\n",
    "- model learns from this data\n",
    "- usually 60-80%\n",
    "  \n",
    "**Validation set**\n",
    "- model gets tuned in on this data\n",
    "- usually 10-20%\n",
    "- used often, but not always\n",
    "\n",
    "**Testing set**\n",
    "- model gets evaluated on this data to test what has been learned\n",
    "- 10-20%, used always\n",
    "\n",
    "Training is kind of like studying for an exam, validation might be a practice exam and the testing set might be similar to the actual exam you take at the end."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(40, 40, 10, 10)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_split = int(0.8 * len(X)) # Split data 80-20\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)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model we make is going to try and learn the relationshi between `X_train` and `y_train`.\n",
    "\n",
    "Create a function to visualize the data:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "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",
    "    plt.figure(figsize=(10,7))\n",
    "    \n",
    "    # Plot training data in blue\n",
    "    plt.scatter(train_data, train_labels, c=\"b\", s=4, label=\"Training data\")\n",
    "    \n",
    "    # Plot test data in green\n",
    "    plt.scatter(test_data, test_labels, c=\"g\", s=4, label=\"Testing data\")\n",
    "    \n",
    "    if predictions is not None:\n",
    "        # Plot predictions in red\n",
    "        plt.scatter(test_labels, predictions, c=\"r\", s=4, label=\"Predictions\")\n",
    "    \n",
    "    # Show the legend\n",
    "    plt.legend(prop={\"size\": 14})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "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()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Build Model\n",
    "\n",
    "Now, build a model to use the blue dots to predict the green dots.\n",
    "\n",
    "Replicate a standard linear regression model using PyTorch:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class LinearRegressionModel(nn.Module):\n",
    "    def __init__(self) -> None:\n",
    "        super().__init__()\n",
    "        # Start with random weights and biases -- these will get adjusted as the model learns\n",
    "        self.weights = nn.Parameter(torch.randn(1,\n",
    "                                                dtype=torch.float),\n",
    "                                    requires_grad=True)\n",
    "        self.bias = nn.Parameter(torch.randn(1,\n",
    "                                             dtype=torch.float),\n",
    "                                 requires_grad=True)\n",
    "    \n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor: # x is the input (training/testing features)\n",
    "        return self.weights * x + self.bias # This is the linear regression formula"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PyTorch model building essentials\n",
    "\n",
    "These are the four most essential PyTorch modules used for model building:\n",
    "\n",
    "**`torch.nn`** \\\n",
    "Contains all of the building blocks for computational graphs (a series of computations executed in a particular way)\n",
    "\n",
    "**`torch.nn.Parameter`** \\\n",
    "Stores tensors that can be used with `nn.Module`. If `requires_grad=True`, gradients are calculated automatically. These are used for updating model parameters via *gradient descent*.\n",
    "\n",
    "**`torch.nn.Module`** \\\n",
    "Base class for neural network modules, all building blocks for nns are subclasses. If you build a neural network, your models should subclass `nn.Module` -- this requires the implementation of a `forward()` method.\n",
    "\n",
    "**`torch.optim`** \\\n",
    "Contains optimization algorithms that tell model parameters sotred in `torch.nn.Parameter` how to best change to improve gradient descent and reduce loss.\n",
    "\n",
    "**`def forward()`** \\\n",
    "All `nn.Module` subclasses require a `forward()` method, this defines the computation that will take place on the data passed to the module, e.g. the linear regression formula above.\n",
    "\n",
    "**Summary**\n",
    "- `nn.Module` contains larger building blocks (layers)\n",
    "- `nn.Parameter` contains smaller parameters like weights and biases\n",
    "- `forward()` tells larger blocks how to make calculations on inputs within the module\n",
    "- `torch.optim` contains methods on how to improve the parameters to better represent the input data\n",
    "\n",
    "### Checking contents of PyTorch model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Parameter containing:\n",
       " tensor([0.3367], requires_grad=True),\n",
       " Parameter containing:\n",
       " tensor([0.1288], requires_grad=True)]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.manual_seed(42)\n",
    "\n",
    "model_0 = LinearRegressionModel()\n",
    "list(model_0.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Get state (what model contains)\n",
    "model_0.state_dict()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We start from random values (initialized above using `torch.randn()`) and get the model to update them to parameters that fit our data best.\n",
    "\n",
    "### Making predictions using `torch.inference_mode()`\n",
    "\n",
    "To check this, we can pass `X_test` and see how closely it predicts `y_test`.\n",
    "\n",
    "When we pass data to the model, it goes through the model's `forward()` method and produces a result based on the computation we have defined."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "with torch.inference_mode():\n",
    "    y_preds = model_0(X_test)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`torch.inference_mode()` turns off a bunch of things, such as gradient tracking which is necessary for training but not for inference to make **forward-passes** faster."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of testing samples: 10\n",
      "Number of predictions made: 10\n",
      "Predicted values:\n",
      "tensor([[0.3982],\n",
      "        [0.4049],\n",
      "        [0.4116],\n",
      "        [0.4184],\n",
      "        [0.4251],\n",
      "        [0.4318],\n",
      "        [0.4386],\n",
      "        [0.4453],\n",
      "        [0.4520],\n",
      "        [0.4588]])\n"
     ]
    }
   ],
   "source": [
    "print(f\"Number of testing samples: {len(X_test)}\")\n",
    "print(f\"Number of predictions made: {len(y_preds)}\")\n",
    "print(f\"Predicted values:\\n{y_preds}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice how there is one prediction value per testing sample. This is because of the data we are using, one `X` value maps to one `y` value.\n",
    "\n",
    "Machine learning models are flexible, meaning there can be 100 `X` valeus mapping to 10 `y` values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.4618],\n",
       "        [0.4691],\n",
       "        [0.4764],\n",
       "        [0.4836],\n",
       "        [0.4909],\n",
       "        [0.4982],\n",
       "        [0.5054],\n",
       "        [0.5127],\n",
       "        [0.5200],\n",
       "        [0.5272]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test - y_preds"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The reason these predictions aren't close is because we are just using random parameter values to make the predictions. \n",
    "\n",
    "It has not yet looked at the blue dots to make a prediction about the green dots.\n",
    "\n",
    "## 3. Train model\n",
    "\n",
    "Right now the model is making predictions using random parameters, essentially guessing.\n",
    "\n",
    "To fix that, we can update the model's internal parameters. \n",
    "\n",
    "We can hardcode them, since we know the values are `weight = 7, bias = 0.3`, but much of the time we won't have this prior information. Instead, we can let the model try to find out what they are.\n",
    "\n",
    "\n",
    "### Creating a loss function and optimizer in PyTorch\n",
    "\n",
    "In order for the model to update the parameters, we need to add a **loss function** and an **optimizer**.\n",
    "\n",
    "**Loss Function**\n",
    "- measures how wrong your predictions are\n",
    "- many built-in loss functions in `torch.nn`\n",
    "- Common values:\n",
    "  * `torch.nn.L1Loss()` (mean absolute error, for regression problems)\n",
    "  * `torch.nn.BCELoss()` (binary cross entropy, for binary classification problems)\n",
    "\n",
    "**Optimizer**\n",
    "- tells model how to update parameters to lower loss\n",
    "- functions in `torch.optim`\n",
    "- Common values:\n",
    "  * `torch.optim.SGD()` (stochastic gradient descent)\n",
    "  * `torch.optim.Adam()` (adam optimizer)\n",
    "  \n",
    "Use MAE in this case. MAE measures the absolute difference between two points (predictions and labels) and then takes the mean across all examples.\n",
    "\n",
    "For optimization, use SGD (`torch.optims.SGD(params, lr))`, where\n",
    "- `params` is the target model parameters to optimize\n",
    "- `lr` is the learning rate:\n",
    "  * lower means smaller updates, which can sometimes be too small and take too much time\n",
    "  * higher means larger updates, which can be too large and fail as a result\n",
    "  * common startning values are `0.01`, `0.001`, `0.0001`, these can however be changed over time using **learning rate scheduling**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss_fn = nn.L1Loss()\n",
    "\n",
    "optimizer = torch.optim.SGD(params=model_0.parameters(),\n",
    "                            lr=0.01)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating an optimization loop\n",
    "\n",
    "The training loop involves the model going through the training data and learning the relationships between `features` and `labels`\n",
    "\n",
    "The testing loop involves going through testing data and evaluating how good the patterns are which we learned on the training data.\n",
    "\n",
    "Each of these is called \"loop\", since we are looping through the samples in the datasets.\n",
    "\n",
    "### PyTorch training loop\n",
    "\n",
    "1. Forward Pass\n",
    "   - go through all training data once, perform `forward()` calculation\n",
    "2. Calculate Loss\n",
    "   - compare predictions (output) to ground truth and see how wrong they are\n",
    "3. Zero gradients\n",
    "   - set optimizers gradients to zero so they can be recalculated\n",
    "4. Perform backpropagation on the loss\n",
    "   - compute gradient of loss with respect for every model parameter to be updated (each parameter with `requires_grad=True`)\n",
    "5. Update the optimizer (**gradient descent**)\n",
    "   - update parameters with `requires_grad=True` with respect to loss gradients"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PyTorch testing loop\n",
    "\n",
    "1. Forward Pass\n",
    "   - go through all training data once, perform `forward()` calculation\n",
    "2. Calculate the loss\n",
    "   - compare predictions (output) to ground truth and see how wrong they are\n",
    "3. Calculate evaluation metrics (optional)\n",
    "   - alongside the loss value we might want other evaluation metrics\n",
    "\n",
    "Notice how we don't have backpropagation or optimizer updating, since we don't want to change the model parameters during testing. We are only interested in the output of the forward pass through the model."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Put all of the above together and train the model for **100 epochs** (forward passes through the data), and evaluate every 10 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 | MAE train loss: 0.31288138031959534 | MAE test loss: 0.48106518387794495\n",
      "Epoch: 10 | MAE train loss: 0.1976713240146637 | MAE test loss: 0.3463551998138428\n",
      "Epoch: 20 | MAE train loss: 0.08908725529909134 | MAE test loss: 0.21729660034179688\n",
      "Epoch: 30 | MAE train loss: 0.053148526698350906 | MAE test loss: 0.14464017748832703\n",
      "Epoch: 40 | MAE train loss: 0.04543796554207802 | MAE test loss: 0.11360953003168106\n",
      "Epoch: 50 | MAE train loss: 0.04167863354086876 | MAE test loss: 0.09919948130846024\n",
      "Epoch: 60 | MAE train loss: 0.03818932920694351 | MAE test loss: 0.08886633068323135\n",
      "Epoch: 70 | MAE train loss: 0.03476089984178543 | MAE test loss: 0.0805937647819519\n",
      "Epoch: 80 | MAE train loss: 0.03132382780313492 | MAE test loss: 0.07232122868299484\n",
      "Epoch: 90 | MAE train loss: 0.02788739837706089 | MAE test loss: 0.06473556160926819\n"
     ]
    }
   ],
   "source": [
    "torch.manual_seed(42)\n",
    "\n",
    "epochs = 100\n",
    "\n",
    "train_loss_values = []\n",
    "test_loss_values = []\n",
    "epoch_count = []\n",
    "\n",
    "for epoch in range(0, epochs):\n",
    "    ### Training\n",
    "    \n",
    "    # Put model in training mode (default state of model)\n",
    "    model_0.train()\n",
    "    \n",
    "    # 1. Forward pass on training data using forward() method\n",
    "    y_pred = model_0(X_train)\n",
    "    \n",
    "    # 2. Calculate the loss (how different are our predictions to the ground truth?)\n",
    "    loss = loss_fn(y_pred, y_train)\n",
    "    \n",
    "    # 3. Zero grad of the optimizer\n",
    "    optimizer.zero_grad()\n",
    "    \n",
    "    # 4. Loss backwards\n",
    "    loss.backward()\n",
    "    \n",
    "    # 5. Progress the optimizer\n",
    "    optimizer.step()\n",
    "    \n",
    "    ### Testing\n",
    "    \n",
    "    # Put the model in evaluation mode\n",
    "    model_0.eval()\n",
    "    \n",
    "    with torch.inference_mode():\n",
    "        # 1. Forward pass on test data\n",
    "        test_pred = model_0(X_test)\n",
    "        \n",
    "        # 2. Calculate loss on test data\n",
    "        test_loss = loss_fn(test_pred, y_test.type(torch.float)) # preds are in torch.float, so comparisons need to be of the same type\n",
    "        \n",
    "        # Print out what's happening\n",
    "        if epoch % 10 == 0:\n",
    "            epoch_count.append(epoch)\n",
    "            train_loss_values.append(loss.detach().numpy())\n",
    "            test_loss_values.append(test_loss.detach().numpy())\n",
    "            print(f\"Epoch: {epoch} | MAE train loss: {loss} | MAE test loss: {test_loss}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The loss is going down with each epoch."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(epoch_count, train_loss_values, label=\"Train loss\")\n",
    "plt.plot(epoch_count, test_loss_values, label=\"Test loss values\")\n",
    "plt.title(\"Training and test loss curves\")\n",
    "plt.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend();"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The loss curve is going down thanks to our loss function and optimizer, which update the model's internal parameters `weight` and `bias` to better reflect the underlying patters within the data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The model learned the following values for weights and bias:\n",
      "OrderedDict([('weights', tensor([0.5784])), ('bias', tensor([0.3513]))])\n",
      "The original values for weight and bias were: 0.7, 0.3\n"
     ]
    }
   ],
   "source": [
    "print(\"The model learned the following values for weights and bias:\")\n",
    "print(model_0.state_dict())\n",
    "print(f\"The original values for weight and bias were: {weight}, {bias}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The model got pretty close to calculating the original values for `weight` and `bias`, and would probably get even closer if we trained it for longer. It would likely never guess them perfectly, but that's okay since approximation can already be very helpful.\n",
    "\n",
    "This is the idea of machine learning and deep learning. There are some **ideal values** that describe our data, and we can **train a model to figure them out** (or come close to them) programmatically."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Making predictions with a trained PyTorch model (inference)\n",
    "\n",
    "There are three things to remember when making predictions:\n",
    "\n",
    "1. Set the model in evaluation mode (`model.eval()`)\n",
    "2. Make the predictions with the inference mode context manager (`with torch.inference_mode(): ... `)\n",
    "3. All predictions should be made with objects on the same device (data and model on CPU only or on GPU only)\n",
    "\n",
    "The first two make sure that PyTorch turns off settings which are used behind the scenes during testing and training, but aren't necessary for evaluation. The third ensures that we don't run into cross-device errors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.8141],\n",
       "        [0.8256],\n",
       "        [0.8372],\n",
       "        [0.8488],\n",
       "        [0.8603],\n",
       "        [0.8719],\n",
       "        [0.8835],\n",
       "        [0.8950],\n",
       "        [0.9066],\n",
       "        [0.9182]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_0.eval()\n",
    "\n",
    "with torch.inference_mode():\n",
    "    y_preds = model_0(X_test)\n",
    "y_preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. Saving and loading a PyTorch model\n",
    "\n",
    "There are three main methods to be aware of for saving and loading PyTorch models:\n",
    "\n",
    "1. `torch.save`: saves a serialized object using Python's `pickle` utility (Models, tensors and various other Python objects such as dictionaries can be saved using this)\n",
    "2. `torch.load`: uses unpickling features to load pickled Python object files into memory\n",
    "3. `torch.nn.Model.load_state_dict`: loads a model's parameter dictionary (`model.state_dict()`) using a saved `state_dict` object\n",
    "\n",
    "### Saving a PyTorch model's `state_dict()`\n",
    "\n",
    "This is the recommended way for saving a model for inference.\n",
    "\n",
    "1. Create a directory for saving models called `models` using Python's `pathlib` module\n",
    "2. Create a file path to save the model to\n",
    "3. Call `torch.save(obj, f)` where `obj` is the `state_dict` and `f` is the filename of where to save the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving model to models\\01_pytorch_workflow_model_0.pth\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "\n",
    "MODEL_PATH = Path(\"models\")\n",
    "MODEL_PATH.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "MODEL_NAME = \"01_pytorch_workflow_model_0.pth\"\n",
    "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n",
    "\n",
    "print(f\"Saving model to {MODEL_SAVE_PATH}\")\n",
    "torch.save(obj=model_0.state_dict(),\n",
    "           f=MODEL_SAVE_PATH)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading a saved PyTorch model's `state_dict()`\n",
    "\n",
    "We can now load the saved model using using `torch.nn.Module.load_state_dict(torch.load(f))` where `f` is the filepath of our saved model.\n",
    "\n",
    "We call `torch.load()` withing `torch.nn.Module.load_state_dict()`, since we only saved the model's `state_dict()` in the previous steps, which is a dictionary of learned parameters and not the *entire* model.\n",
    "\n",
    "> The disadvantage to saving the entire model as opposed to just the state dict is that serialized data is bound to the specific classes and the exact directory structure used when the model was saved. Because of this, our code can break in various ways when used in other projects and after refactoring.\n",
    "\n",
    "So instead, we use this more flexible method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loaded_model_0 = LinearRegressionModel()\n",
    "\n",
    "loaded_model_0.load_state_dict(torch.load(f=MODEL_SAVE_PATH))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To test the loaded model, perform inference (make predictions) on the test data."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Put model in evaluation mode\n",
    "loaded_model_0.eval()\n",
    "\n",
    "# Use inference mode context manager to make predictions\n",
    "with torch.inference_mode():\n",
    "    loaded_model_preds = loaded_model_0(X_test) # perform forward pass on test data with loaded model\n",
    "\n",
    "# Check if they match our previous predictions\n",
    "y_preds == loaded_model_preds"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Putting it all together\n",
    "\n",
    "Let's put everything above together, and make it device agnostic:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.13.1+cpu'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "from torch import nn # contains building blocks for neural networks\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "torch.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "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}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.1 Data\n",
    "\n",
    "Hard-code some `weight` and `bias` values, then make a range of numbers between `0` and `1` for our X values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[0.0000],\n",
       "         [0.0200],\n",
       "         [0.0400],\n",
       "         [0.0600],\n",
       "         [0.0800],\n",
       "         [0.1000],\n",
       "         [0.1200],\n",
       "         [0.1400],\n",
       "         [0.1600],\n",
       "         [0.1800]]),\n",
       " tensor([[0.3000],\n",
       "         [0.3140],\n",
       "         [0.3280],\n",
       "         [0.3420],\n",
       "         [0.3560],\n",
       "         [0.3700],\n",
       "         [0.3840],\n",
       "         [0.3980],\n",
       "         [0.4120],\n",
       "         [0.4260]]))"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weight = 0.7\n",
    "bias = 0.3\n",
    "\n",
    "start = 0\n",
    "end = 1\n",
    "step = 0.02\n",
    "\n",
    "X = torch.arange(start, end, step).unsqueeze(dim=1)\n",
    "y = weight * X + bias\n",
    "X[:10], y[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(40, 40, 10, 10)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Split data into test and training sets\n",
    "train_split = int(0.8 * len(X))\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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "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(X_train, y_train, X_test, y_test)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.2 Building a PyTorch linear model\n",
    "\n",
    "Instead of manually defining the weight and bias parameters using `nn.Parameter()`, we'll use `nn.Linear(in_features, out_features)`. \n",
    "\n",
    "`in_features` is the number of dimensions the input data has and `out_features` is the number of dimensions to be put out. In this case, both are one since our data has one input feature (`X`) per label (`y`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(LinearRegressionModelV2(\n",
       "   (linear_layer): Linear(in_features=1, out_features=1, bias=True)\n",
       " ),\n",
       " OrderedDict([('linear_layer.weight', tensor([[0.7645]])),\n",
       "              ('linear_layer.bias', tensor([0.8300]))]))"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class LinearRegressionModelV2(nn.Module):\n",
    "    def __init__(self) -> None:\n",
    "        super().__init__()\n",
    "        # Use `nn.Linear()` for creating model parameters\n",
    "        self.linear_layer = nn.Linear(in_features=1,\n",
    "                                      out_features=1)\n",
    "        \n",
    "        # Define forward computation\n",
    "        def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "            return self.linear_layer(x)\n",
    "\n",
    "# Set manual seed for demonstrative purposes\n",
    "torch.manual_seed(42)\n",
    "model_1 = LinearRegressionModelV2()\n",
    "model_1, model_1.state_dict()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that `nn.Linear()` has generated random parameters for us.\n",
    "\n",
    "Now put the model on the GPU, if available:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check model device\n",
    "next(model_1.parameters()).device"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "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.10.6"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "d0620f40e2353b6d35268ab276de4393f4e99801270e1c452fb1fe73380c5b64"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}