01_pytorch_workflow.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNz9aTI85wik1UONyAooQft",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/tanyasheru23/PyTorch/blob/main/01_pytorch_workflow.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "from torch import nn ##nn contains all pytorch building blocks for neural networks\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "#check PyTorch version\n",
        "torch.__version__"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "Jtlrzt6M0vNX",
        "outputId": "e8d7e5b0-4d48-477f-e36c-64ffff0e5bbf"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2.2.1+cu121'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 2
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Data - Prepraing and loading\n",
        "\n",
        "Data can be in any format\n",
        "\n",
        "*   Excel Sheet\n",
        "*   Images of anykind\n",
        "*   Videos\n",
        "*   Audio\n",
        "*   DNA\n",
        "*   Text\n",
        "\n",
        "Machine Learning consists of two parts:\n",
        "1. Get data into a numerical representation\n",
        "2. Build a model to learn patterns in that numerical representation\n",
        "\n",
        "To showcase this, let's create some *known* data using the linear regression formula\n",
        "\n",
        "`Y = a + bX`\n",
        "\n",
        "We'll use a linear regression formula to make a straight line with *known* **parameters**."
      ],
      "metadata": {
        "id": "v2pSpg7_1bhv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "1. #Create *known* parameters\n",
        "weight = 0.7 #b\n",
        "bias = 0.3   #a\n",
        "\n",
        "# Create\n",
        "start=0\n",
        "end=1\n",
        "step = 0.02\n",
        "\n",
        "#capital rep tensor and lower case a vector\n",
        "X = torch.arange(start, end, step).unsqueeze(dim=1)\n",
        "y = weight*X + bias\n",
        "\n",
        "X[:10], y[:10]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "uX8EJUhy15nM",
        "outputId": "7228a02e-1957-4ec8-abc4-eb8e98b2e043"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "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]]))"
            ]
          },
          "metadata": {},
          "execution_count": 3
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "len(X), len(y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mCiHmjsQKR3E",
        "outputId": "6445c9cd-0fce-40e7-e827-06357d93f276"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(50, 50)"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "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)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q3naR8ysLRBy",
        "outputId": "deb02203-8cff-4fd5-f9ef-dd6d32f0b575"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(40, 40, 10, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Visualize our data\n"
      ],
      "metadata": {
        "id": "tQPncahpPZWb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_prediction(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, testing data and compares prediction\n",
        "  \"\"\"\n",
        "  #Plot training data in blue\n",
        "  plt.scatter(train_data, train_labels, c=\"b\", s=4, label=\"Training  Data\")\n",
        "\n",
        "  #Plot testing data in green\n",
        "  plt.scatter(test_data, test_labels, c=\"g\", s=4, label =\"Test Data\")\n",
        "\n",
        "  # Are there predictions?\n",
        "  if predictions is not None:\n",
        "    # Plot the predictions if they exist\n",
        "    plt.scatter(test_data, predictions,c=\"r\", s=4, label=\"Predictions\")\n",
        "\n",
        "  # Show the legend\n",
        "  plt.legend(prop={\"size\":14});"
      ],
      "metadata": {
        "id": "tE_lQQ6BP2K-"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_prediction()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "id": "NWvTYgDeRdAY",
        "outputId": "284c789e-559e-4c1d-8115-728b3c6595d5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. Build Model\n",
        "\n",
        "\n",
        "What our Model does?\n",
        "* Start with random values\n",
        "* Look at training data and adjust the random values to better represent (or get closer to) the ideal vlaues (the weight & bias values we used to create the data)\n",
        "\n",
        "\n",
        "How does it do so?\n",
        "Through 2 main algorithms:\n",
        "1. Gradient descent → `req_grad = true`\n",
        "2. Back Propogation"
      ],
      "metadata": {
        "id": "e31gtrHrRgxs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create linear regression model class\n",
        "\n",
        "class LinearRegressionModel(nn.Module):\n",
        "  # almost everything in PyTorch inherits from nn.Module\n",
        "  def __init__(self):\n",
        "    super().__init__() #instantiate the super class i.e. here nn.Module\n",
        "\n",
        "    # Initialize model Parameters\n",
        "    # For bigger layers we may not init weights and biases,\n",
        "    # we might init whole list of layers or whatever variables that we need our model to use\n",
        "\n",
        "    self.weights = nn.Parameter(torch.randn(1,\n",
        "                                          requires_grad=True,\n",
        "                                          dtype=torch.float))\n",
        "    self.bias = nn.Parameter(torch.randn(1,\n",
        "                                       requires_grad=True,\n",
        "                                       dtype=torch.float))\n",
        "\n",
        "    # Forward method to define the computation in the model (forward method is the operation that this module does)\n",
        "    # any subclass of nn.module requires a forward method\n",
        "  def forward(self, x:torch.Tensor) ->torch.Tensor: #<- \"x\" is the input data\n",
        "    return self.weights*x + self.bias #this is the linear regression formula"
      ],
      "metadata": {
        "id": "RTEWTFPbjnSv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## PyTorch model building essentials\n",
        "\n",
        "* `torch.nn` - contains all of the building blocks for computational graphs (a neural network can be considered as a computational graph)\n",
        "* `torch.nn.Parameter` - what parameters should our model try and learn, often PyTorch layer from torch.nn will set these for us\n",
        "* `torch.nn.Module` - The base class for all neural network modules, if you subclass it, you should overwrite `forward()`\n",
        "* `torch.optim` - this where the optimizers in PyTorch live, they will help with gradient descent\n",
        "* `def forward()` - All `nn.Module` subclasses require you to overwrite `forward()`, this method defines what happens in the forward computation"
      ],
      "metadata": {
        "id": "qQWJF2nIJeD3"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Checking the contents of our PyTorch Model\n",
        "\n",
        "Now we've created a model, let's see what's inside...\n",
        "\n",
        "So we can check our model parameters or what's inside our model using `.parameters()`."
      ],
      "metadata": {
        "id": "AjUVyf_a14Tt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# create a random seed\n",
        "\n",
        "torch.manual_seed(42)\n",
        "\n",
        "# create an instance of the model (this is a subclass of nn.Module)\n",
        "model_0 = LinearRegressionModel()\n",
        "\n",
        "#check out the parameters\n",
        "list(model_0.parameters())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xMde5wtVE3AZ",
        "outputId": "b3622e9e-92b3-445b-a1a9-4a601d5ff9f6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[Parameter containing:\n",
              " tensor([0.3367], requires_grad=True),\n",
              " Parameter containing:\n",
              " tensor([0.1288], requires_grad=True)]"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "`state_dict()` ⟶ A python dictionary that maps each layer to its parameter tensor"
      ],
      "metadata": {
        "id": "_Lklo3kiRJSP"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# list named parameters\n",
        "model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VBTdsbiUFksD",
        "outputId": "f29e1696-292f-4c6b-8763-a2ef7a8b2b56"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "weight, bias"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VObQPKUsHe25",
        "outputId": "2e81fb76-b5e1-4b7d-a717-dda2f0c02e31"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.7, 0.3)"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Making predictions using `torch.inference_model()`\n",
        "\n",
        "To check our model's predictive power, let's see how well it predicts `y_test` based on `X_test`\n",
        "\n",
        "When we pass data through our model, it's going to run through the `forward()` method\n",
        "\n"
      ],
      "metadata": {
        "id": "aDTtTdYuLxB4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred=model_0(X_test)\n",
        "y_pred"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vbDyuPMlOk4P",
        "outputId": "6d63846e-a709-4ae2-f0ba-7e8d265ad154"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "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]], grad_fn=<AddBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "`torch.inference_mode()` ⟶ turnsoff gradient tracking and etc stuff in the background which are no longer useful for testing\n",
        "\n",
        "Why use inference mode?\n",
        "\n",
        "* To increase speed by reducing unnecessary computations.\n",
        "\n",
        "* When we are doing inference, we are not training so we don't need to keep track of the updates.\n",
        "\n",
        "* Not saving memory of whole bunch of data saves memory for large dataset\n",
        "\n",
        "We can also do something similar with `torch.no_grad()`, however inference mode is preferred"
      ],
      "metadata": {
        "id": "5ENu503tRbkT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Make predictions with model\n",
        "\n",
        "with torch.inference_mode(): #turns off the grad tracking\n",
        "  y_preds = model_0(X_test)\n",
        "y_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mqjmPFVjMyOx",
        "outputId": "d000c55a-bca5-45f9-afbf-c40b8ce4f6a2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "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]])"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_prediction(predictions=y_preds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "id": "mN7K26B3Na4X",
        "outputId": "7a032ee3-616a-49aa-aab5-c6ade088d750"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3. Train Model\n",
        "\n",
        "The whole idea of training is for a model to move from some *unknow* parameters (these might be random) to some *known* parameters\n",
        "\n",
        "Or in other words from poor representaion of the data to a better representation\n",
        "\n",
        "One way to measure how poor or how wrong your predictions are to use loss functions\n",
        "\n",
        "* Note: Loss function may also be called cost function or criterion in different areas. For our case, we're going to refer to it as a loss funtion\n",
        "\n",
        "THINGS WE NEED TO TRAIN:\n",
        "\n",
        "* **Loss function:** A function to measure how wrong your model's predictions are to the ideal output, lower is better.\n",
        "\n",
        "* **Optimiser**: Takes into account the loss of a model and adjust the model's parameters (e.g. weight & bias) in our case to improve the loss funtion\n",
        "  * Optimizer needs 2 parameters: `params` = `model.parameters` and `lr` = learning rate\n",
        "\n",
        "And specifically for PyTorch, we need:\n",
        "* A training loop\n",
        "* A testing loop"
      ],
      "metadata": {
        "id": "saummhZxc2A4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "12SaiEAbl5im",
        "outputId": "d6925a86-7e32-4add-8cb5-9c8e977665b4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# set up a loss function\n",
        "loss_fn = nn.L1Loss()\n",
        "\n",
        "# set up an optimizer\n",
        "optim = torch.optim.SGD(params = model_0.parameters(), lr = 0.001)"
      ],
      "metadata": {
        "id": "k3GMKvRVl-rq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Building a training loop in PyTorch\n",
        "\n",
        "Things needed in a training loop\n",
        "0. Loop through the data\n",
        "1. Forward pass\n",
        "2. Calculate the loss\n",
        "3. Optimizer zero grad\n",
        "4. Loss backward - **Back propagation**\n",
        "5. Optimizer step - use optimizer to adjust model's params to try and imporve the loss **Gradient Descent**"
      ],
      "metadata": {
        "id": "hJeon90a7Rk2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Training Loop\n",
        "\n",
        "`model.train()` ⟶ Train mode sets the params that require gradient to require gradient mode\n",
        "\n",
        "`optimizer.zero_grad()` ⟶ zero the grads of the optimizer, because by default the grads are accumulated and so as to avoid the affect of past gradient in this iteration, we set it to zero\n",
        "\n",
        "`optimizer.step()` ⟶ set optimizer to update the model's params w.r.t grad calculated by to the `loss.backward()` using back propogation\n"
      ],
      "metadata": {
        "id": "WSooX3skL6MR"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Testing\n",
        "`model.eval()` ⟶ Turnsoff the gradient tracking, drop_out, batch_norm etc stuff which are no longer needed for testing\n",
        "\n",
        "`torch.inference_mode()` ⟶ turnsoff gradient tracking and etc stuff in the background which are no longer useful for testing."
      ],
      "metadata": {
        "id": "PLrwIsLRNL1o"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "epochs = 2000\n",
        "\n",
        "epoch_count = []\n",
        "train_loss_values = []\n",
        "test_loss_values = []\n",
        "\n",
        "# 0. Loop through the data\n",
        "for epoch in range(epochs):\n",
        "\n",
        "  # Set the traning mode\n",
        "  model_0.train()\n",
        "\n",
        "  # 1. Forward Pass\n",
        "  y_pred = model_0(X_train)\n",
        "\n",
        "  # 2. Calculate the loss\n",
        "  loss = loss_fn(y_pred, y_train)\n",
        "  epoch_count.append(epoch)\n",
        "  train_loss_values.append(loss.detach().numpy())\n",
        "\n",
        "  # 3. Optimizer zero_grad\n",
        "  optim.zero_grad()\n",
        "\n",
        "  # 4. Back Propagation\n",
        "  loss.backward()\n",
        "\n",
        "  # 5. Gradient Descent (update the weights)\n",
        "  optim.step()\n",
        "\n",
        "  # Testing\n",
        "  model_0.eval()\n",
        "  with torch.inference_mode():\n",
        "    # 1. Forward Pass\n",
        "    test_pred = model_0(X_test)\n",
        "\n",
        "    # 2. Calculate the loss\n",
        "    test_loss = loss_fn(test_pred, y_test)\n",
        "    test_loss_values.append(test_loss)\n",
        "\n",
        "  if epoch % 50 == 0:\n",
        "    print(f\"Epoch: {epoch} | Train: loss {loss} | Test loss: {test_loss}\")\n",
        "    print(model_0.state_dict())\n",
        "    print()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lHX1sMHl8kBO",
        "outputId": "b3282f93-c367-48a9-f729-f9b3b3972256"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0 | Train: loss 0.31288138031959534 | Test loss: 0.4931890368461609\n",
            "OrderedDict([('weights', tensor([0.3371])), ('bias', tensor([0.1298]))])\n",
            "\n",
            "Epoch: 50 | Train: loss 0.2552763819694519 | Test loss: 0.4258342385292053\n",
            "OrderedDict([('weights', tensor([0.3566])), ('bias', tensor([0.1798]))])\n",
            "\n",
            "Epoch: 100 | Train: loss 0.19767141342163086 | Test loss: 0.35847947001457214\n",
            "OrderedDict([('weights', tensor([0.3761])), ('bias', tensor([0.2298]))])\n",
            "\n",
            "Epoch: 150 | Train: loss 0.14006686210632324 | Test loss: 0.2911251187324524\n",
            "OrderedDict([('weights', tensor([0.3956])), ('bias', tensor([0.2798]))])\n",
            "\n",
            "Epoch: 200 | Train: loss 0.08973254263401031 | Test loss: 0.22795839607715607\n",
            "OrderedDict([('weights', tensor([0.4150])), ('bias', tensor([0.3257]))])\n",
            "\n",
            "Epoch: 250 | Train: loss 0.06476505100727081 | Test loss: 0.18208928406238556\n",
            "OrderedDict([('weights', tensor([0.4330])), ('bias', tensor([0.3556]))])\n",
            "\n",
            "Epoch: 300 | Train: loss 0.05357731133699417 | Test loss: 0.15086300671100616\n",
            "OrderedDict([('weights', tensor([0.4485])), ('bias', tensor([0.3730]))])\n",
            "\n",
            "Epoch: 350 | Train: loss 0.04836020991206169 | Test loss: 0.13020753860473633\n",
            "OrderedDict([('weights', tensor([0.4617])), ('bias', tensor([0.3819]))])\n",
            "\n",
            "Epoch: 400 | Train: loss 0.04549176245927811 | Test loss: 0.11657620966434479\n",
            "OrderedDict([('weights', tensor([0.4730])), ('bias', tensor([0.3855]))])\n",
            "\n",
            "Epoch: 450 | Train: loss 0.04341452196240425 | Test loss: 0.10720770061016083\n",
            "OrderedDict([('weights', tensor([0.4831])), ('bias', tensor([0.3858]))])\n",
            "\n",
            "Epoch: 500 | Train: loss 0.04160415381193161 | Test loss: 0.10088418424129486\n",
            "OrderedDict([('weights', tensor([0.4924])), ('bias', tensor([0.3839]))])\n",
            "\n",
            "Epoch: 550 | Train: loss 0.03985908254981041 | Test loss: 0.09537436813116074\n",
            "OrderedDict([('weights', tensor([0.5014])), ('bias', tensor([0.3814]))])\n",
            "\n",
            "Epoch: 600 | Train: loss 0.03811401128768921 | Test loss: 0.08986451476812363\n",
            "OrderedDict([('weights', tensor([0.5104])), ('bias', tensor([0.3789]))])\n",
            "\n",
            "Epoch: 650 | Train: loss 0.03638043254613876 | Test loss: 0.08497253060340881\n",
            "OrderedDict([('weights', tensor([0.5192])), ('bias', tensor([0.3760]))])\n",
            "\n",
            "Epoch: 700 | Train: loss 0.03466346859931946 | Test loss: 0.08097299933433533\n",
            "OrderedDict([('weights', tensor([0.5277])), ('bias', tensor([0.3724]))])\n",
            "\n",
            "Epoch: 750 | Train: loss 0.032946161925792694 | Test loss: 0.07697348296642303\n",
            "OrderedDict([('weights', tensor([0.5363])), ('bias', tensor([0.3688]))])\n",
            "\n",
            "Epoch: 800 | Train: loss 0.03122851625084877 | Test loss: 0.07297395914793015\n",
            "OrderedDict([('weights', tensor([0.5448])), ('bias', tensor([0.3652]))])\n",
            "\n",
            "Epoch: 850 | Train: loss 0.029511287808418274 | Test loss: 0.0689057856798172\n",
            "OrderedDict([('weights', tensor([0.5534])), ('bias', tensor([0.3616]))])\n",
            "\n",
            "Epoch: 900 | Train: loss 0.027794325724244118 | Test loss: 0.06490625441074371\n",
            "OrderedDict([('weights', tensor([0.5619])), ('bias', tensor([0.3580]))])\n",
            "\n",
            "Epoch: 950 | Train: loss 0.02607722207903862 | Test loss: 0.06090673804283142\n",
            "OrderedDict([('weights', tensor([0.5704])), ('bias', tensor([0.3544]))])\n",
            "\n",
            "Epoch: 1000 | Train: loss 0.02435956709086895 | Test loss: 0.05690721794962883\n",
            "OrderedDict([('weights', tensor([0.5790])), ('bias', tensor([0.3508]))])\n",
            "\n",
            "Epoch: 1050 | Train: loss 0.022642139345407486 | Test loss: 0.05283904820680618\n",
            "OrderedDict([('weights', tensor([0.5875])), ('bias', tensor([0.3473]))])\n",
            "\n",
            "Epoch: 1100 | Train: loss 0.02092517353594303 | Test loss: 0.0488395169377327\n",
            "OrderedDict([('weights', tensor([0.5961])), ('bias', tensor([0.3437]))])\n",
            "\n",
            "Epoch: 1150 | Train: loss 0.019208211451768875 | Test loss: 0.04483998939394951\n",
            "OrderedDict([('weights', tensor([0.6046])), ('bias', tensor([0.3401]))])\n",
            "\n",
            "Epoch: 1200 | Train: loss 0.017490629106760025 | Test loss: 0.04084048420190811\n",
            "OrderedDict([('weights', tensor([0.6131])), ('bias', tensor([0.3365]))])\n",
            "\n",
            "Epoch: 1250 | Train: loss 0.015772998332977295 | Test loss: 0.036772288382053375\n",
            "OrderedDict([('weights', tensor([0.6217])), ('bias', tensor([0.3329]))])\n",
            "\n",
            "Epoch: 1300 | Train: loss 0.014056024141609669 | Test loss: 0.03277278691530228\n",
            "OrderedDict([('weights', tensor([0.6302])), ('bias', tensor([0.3293]))])\n",
            "\n",
            "Epoch: 1350 | Train: loss 0.012339059263467789 | Test loss: 0.028773266822099686\n",
            "OrderedDict([('weights', tensor([0.6388])), ('bias', tensor([0.3257]))])\n",
            "\n",
            "Epoch: 1400 | Train: loss 0.010621682740747929 | Test loss: 0.0247737355530262\n",
            "OrderedDict([('weights', tensor([0.6473])), ('bias', tensor([0.3221]))])\n",
            "\n",
            "Epoch: 1450 | Train: loss 0.008904037065804005 | Test loss: 0.020774226635694504\n",
            "OrderedDict([('weights', tensor([0.6559])), ('bias', tensor([0.3185]))])\n",
            "\n",
            "Epoch: 1500 | Train: loss 0.007186878472566605 | Test loss: 0.01670604944229126\n",
            "OrderedDict([('weights', tensor([0.6644])), ('bias', tensor([0.3150]))])\n",
            "\n",
            "Epoch: 1550 | Train: loss 0.005469909869134426 | Test loss: 0.012706518173217773\n",
            "OrderedDict([('weights', tensor([0.6730])), ('bias', tensor([0.3114]))])\n",
            "\n",
            "Epoch: 1600 | Train: loss 0.003752306802198291 | Test loss: 0.008672690019011497\n",
            "OrderedDict([('weights', tensor([0.6815])), ('bias', tensor([0.3078]))])\n",
            "\n",
            "Epoch: 1650 | Train: loss 0.002035337733104825 | Test loss: 0.004673170857131481\n",
            "OrderedDict([('weights', tensor([0.6900])), ('bias', tensor([0.3042]))])\n",
            "\n",
            "Epoch: 1700 | Train: loss 0.0003177322505507618 | Test loss: 0.0006393313524313271\n",
            "OrderedDict([('weights', tensor([0.6986])), ('bias', tensor([0.3006]))])\n",
            "\n",
            "Epoch: 1750 | Train: loss 0.0004444979131221771 | Test loss: 0.0005780101055279374\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n",
            "\n",
            "Epoch: 1800 | Train: loss 0.0004444979131221771 | Test loss: 0.0005780101055279374\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n",
            "\n",
            "Epoch: 1850 | Train: loss 0.0004444979131221771 | Test loss: 0.0005780101055279374\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n",
            "\n",
            "Epoch: 1900 | Train: loss 0.0004444979131221771 | Test loss: 0.0005780101055279374\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n",
            "\n",
            "Epoch: 1950 | Train: loss 0.0004444979131221771 | Test loss: 0.0005780101055279374\n",
            "OrderedDict([('weights', tensor([0.6997])), ('bias', tensor([0.3008]))])\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(epoch_count, train_loss_values, label = \"Train Loss\")\n",
        "plt.plot(epoch_count, test_loss_values, label = \"Test Loss\")\n",
        "plt.title(\"Training and Testing Loss curves\")\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "NneEtRlR-6XJ",
        "outputId": "b66641cf-5d97-45e9-ed2a-788733034149"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with torch.inference_mode():\n",
        "  y_preds_new = model_0(X_test)\n",
        "plot_prediction(predictions=y_preds_new)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "id": "3QfPTbgPADdT",
        "outputId": "ed2798f1-3845-4722-eb4f-8339025c94be"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Saving a model in PyTorch\n",
        "\n",
        "There are 3 main methods - to save and load models in PyTorch\n",
        "\n",
        "1. `torch.save()` - allows you to save a PyTorch object in Python's pickle format\n",
        "2. `torch.load()` - allows you to load a saved PyTorch object\n",
        "3. `torch.nn.Module.load_state_dict()` - allows to load a model's saved state dictionary (RECOMMENDED)"
      ],
      "metadata": {
        "id": "VIksRU7SMAYl"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gc8UIDaZJUEz",
        "outputId": "7f68f1ec-f9e3-4759-c6b4-f86ca6d239c6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6994])), ('bias', tensor([0.2998]))])"
            ]
          },
          "metadata": {},
          "execution_count": 20
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Saving our PyTorch Model\n",
        "\n",
        "from pathlib import Path\n",
        "\n",
        "# 1. Create model 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_0.pth' # a common PyTorch conventions is to save models using either .pt or .pth\n",
        "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n",
        "\n",
        "# 3. Save the model's state_dict\n",
        "print(f\"Saving Model to {MODEL_SAVE_PATH}\")\n",
        "torch.save(obj = model_0.state_dict(), f = MODEL_SAVE_PATH)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_bNb_sLuSL7t",
        "outputId": "49418a39-df6b-4600-9741-7b51f4fa87a8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving Model to models/01_pytorch_workflow_model_0.pth\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!ls -l models"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BC-ThYwQTtLY",
        "outputId": "c88782cb-5d6c-4ab5-ff6d-9ffaf06bf00d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "total 4\n",
            "-rw-r--r-- 1 root root 1680 Mar 17 08:43 01_pytorch_workflow_model_0.pth\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "We can do 2 things\n",
        "* Save only the state_dict\n",
        "* Save the entire model\n",
        "Read and know which is recommended and why"
      ],
      "metadata": {
        "id": "2PLbfN5wPSIt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Loading a PyTorh MODEL\n",
        "\n",
        "Since we saved our model's `state_dict()` rather the entire model, we will have to create and instance of the model class and load the saved `state_dict` into that."
      ],
      "metadata": {
        "id": "P7hhcWh0S1j9"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# To Load in a saved state_dict we have to instantiate a new instance of our model class\n",
        "loaded_model_0 = LinearRegressionModel()\n",
        "\n",
        "# Load the saved state_dict of model_0 (this will update the new instance with updated parameters)\n",
        "loaded_model_0.load_state_dict(torch.load(f=MODEL_SAVE_PATH))"
      ],
      "metadata": {
        "id": "WjC59egBTD1F",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "96bd78fe-9f68-4578-b53e-3e2c69acc32b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loaded_model_0.state_dict()"
      ],
      "metadata": {
        "id": "6B3p87ivUEyE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "957a7a1e-0844-4ba1-b221-493de9326005"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6994])), ('bias', tensor([0.2998]))])"
            ]
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make some predictions with our loaded model\n",
        "loaded_model_0.eval()\n",
        "with torch.inference_mode():\n",
        "  loaded_model_pred = loaded_model_0(X_test)\n",
        "loaded_model_pred"
      ],
      "metadata": {
        "id": "Q0z4OaR4UHbQ",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9e9b2d47-0fe8-4e68-fbb1-0e4067c6c227"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.8593],\n",
              "        [0.8733],\n",
              "        [0.8873],\n",
              "        [0.9013],\n",
              "        [0.9152],\n",
              "        [0.9292],\n",
              "        [0.9432],\n",
              "        [0.9572],\n",
              "        [0.9712],\n",
              "        [0.9852]])"
            ]
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_0.eval()\n",
        "with torch.inference_mode():\n",
        "  model_pred = model_0(X_test)\n",
        "model_pred"
      ],
      "metadata": {
        "id": "mmBBVynhU-Mo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fbb5b0a0-d82c-47b5-8478-88033e04591c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.8593],\n",
              "        [0.8733],\n",
              "        [0.8873],\n",
              "        [0.9013],\n",
              "        [0.9152],\n",
              "        [0.9292],\n",
              "        [0.9432],\n",
              "        [0.9572],\n",
              "        [0.9712],\n",
              "        [0.9852]])"
            ]
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_pred == loaded_model_pred"
      ],
      "metadata": {
        "id": "XZkDCmrjVOVU",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "996dd5ab-2e6c-4125-a6f1-e6dcb8615af3"
      },
      "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]])"
            ]
          },
          "metadata": {},
          "execution_count": 27
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### PUTTING IT ALL TOGETHER\n",
        "Let's go back through the steps above and see it all in one place"
      ],
      "metadata": {
        "id": "abwCu2I4aGdZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# instantiate a new class to load the saved state_dict\n",
        "loaded_model_0 = LinearRegressionModel()\n",
        "\n",
        "print(f\"Params before loading: {loaded_model_0.state_dict()}\\n\")\n",
        "# now load the state_dict and update the new instance with new params\n",
        "loaded_model_0.load_state_dict(torch.load(f=MODEL_SAVE_PATH))\n",
        "print(f\"Params after loading: {loaded_model_0.state_dict()}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Rjx3FiCwVRiy",
        "outputId": "3907303b-e4a9-45ed-fa0c-9cf55cbf138d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Params before loading: OrderedDict([('weights', tensor([-1.1229])), ('bias', tensor([-0.1863]))])\n",
            "\n",
            "Params after loading: OrderedDict([('weights', tensor([0.6994])), ('bias', tensor([0.2998]))])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class LinearRegressionModelv2(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.linear_layer = nn.Linear(in_features = 1,\n",
        "                                  out_features = 1) # it creates params and biases in the background\n",
        "\n",
        "  def forward(self, x:torch.Tensor)->torch.Tensor:\n",
        "    return self.linear_layer(x)"
      ],
      "metadata": {
        "id": "EUgt4vmnWIWG"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "model_1 = LinearRegressionModelv2()\n",
        "model_1.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "n5zPIiZ8elrk",
        "outputId": "e976bac3-5df4-4619-dcfc-95ae9c0a88ad"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('linear_layer.weight', tensor([[0.7645]])),\n",
              "             ('linear_layer.bias', tensor([0.8300]))])"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loss_fn = nn.L1Loss()\n",
        "optim = torch.optim.SGD(params = model_1.parameters(), lr = 0.01)"
      ],
      "metadata": {
        "id": "UUuYaaGMevZp"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "epochs = 150\n",
        "\n",
        "epoch_count = []\n",
        "train_losses = []\n",
        "test_losses = []\n",
        "for epoch in range(epochs):\n",
        "\n",
        "  #training\n",
        "  model_1.train()\n",
        "  y_pred = model_1.forward(X_train) # forward pass\n",
        "  loss = loss_fn(y_pred, y_train)   # calculate the loss\n",
        "  optim.zero_grad()                 # optimizer zero grad\n",
        "  loss.backward()                   # back propogation\n",
        "  optim.step()                      # update the params\n",
        "\n",
        "  # testing\n",
        "  model_1.eval()\n",
        "  with torch.inference_mode():\n",
        "    test_pred = model_1.forward(X_test)\n",
        "    test_loss = loss_fn(test_pred, y_test)\n",
        "\n",
        "  epoch_count.append(epoch)\n",
        "  train_losses.append(loss.detach().numpy())\n",
        "  test_losses.append(test_loss.detach().numpy())\n",
        "\n",
        "  if epoch % 20 == 0:\n",
        "    print(f\"Epoch: {epoch} | Training Loss: {loss} | Testing Loss: {test_loss}\\n\")\n",
        "    print(model_1.state_dict())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nlPc8fgDfDcl",
        "outputId": "d8471976-2afa-431a-b856-7d8c17f3e488"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0 | Training Loss: 0.5551779866218567 | Testing Loss: 0.5739762187004089\n",
            "\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.7606]])), ('linear_layer.bias', tensor([0.8200]))])\n",
            "Epoch: 20 | Training Loss: 0.3247582018375397 | Testing Loss: 0.30455657839775085\n",
            "\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.6826]])), ('linear_layer.bias', tensor([0.6200]))])\n",
            "Epoch: 40 | Training Loss: 0.09433844685554504 | Testing Loss: 0.03513689711689949\n",
            "\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.6046]])), ('linear_layer.bias', tensor([0.4200]))])\n",
            "Epoch: 60 | Training Loss: 0.0199567973613739 | Testing Loss: 0.04580312222242355\n",
            "\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.6025]])), ('linear_layer.bias', tensor([0.3410]))])\n",
            "Epoch: 80 | Training Loss: 0.013089170679450035 | Testing Loss: 0.029944902285933495\n",
            "\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.6366]])), ('linear_layer.bias', tensor([0.3265]))])\n",
            "Epoch: 100 | Training Loss: 0.006215679459273815 | Testing Loss: 0.014086711220443249\n",
            "\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.6707]])), ('linear_layer.bias', tensor([0.3120]))])\n",
            "Epoch: 120 | Training Loss: 0.0012645035749301314 | Testing Loss: 0.013801807537674904\n",
            "\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.6929]])), ('linear_layer.bias', tensor([0.2925]))])\n",
            "Epoch: 140 | Training Loss: 0.0012645035749301314 | Testing Loss: 0.013801807537674904\n",
            "\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.6929]])), ('linear_layer.bias', tensor([0.2925]))])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.plot(epoch_count, train_losses, label = \"Train Loss\")\n",
        "plt.plot(epoch_count, test_losses, label = \"Test Loss\")\n",
        "plt.title(\"Training and Testing Loss curves\")\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "outputId": "b1870620-c4b6-4834-de6d-9d0ac5a013ff",
        "id": "SG-qTFV8gU-1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with torch.inference_mode():\n",
        "  y_preds_new = model_1(X_test)\n",
        "plot_prediction(predictions=y_preds_new)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 430
        },
        "outputId": "6f08fb2b-ff2b-42a3-b943-d1a7f1a2b223",
        "id": "9dpp-IaIgU-_"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "MODEL_NAME_1 = '01_pytorch_workflow_model_1.pth'\n",
        "\n",
        "MODEL_SAVE_PATH_1 = MODEL_PATH / MODEL_NAME_1\n",
        "\n",
        "print(f\"Saving model_1 state_dict to: {MODEL_SAVE_PATH_1}\")\n",
        "torch.save(obj = model_1.state_dict(), f = MODEL_SAVE_PATH_1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BEzwb0R8gozu",
        "outputId": "170996e9-d9d0-4e1c-ee17-67cb9a15197b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving model_1 state_dict to: models/01_pytorch_workflow_model_1.pth\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loaded_model_1 = LinearRegressionModelv2()\n",
        "\n",
        "print(f\"Params before loading saved model: {loaded_model_1.state_dict()}\")\n",
        "loaded_model_1.load_state_dict(torch.load(MODEL_SAVE_PATH_1))\n",
        "print(f\"Params after  loading saved model: {loaded_model_1.state_dict()}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qlXJnoPSh5Fx",
        "outputId": "ecdadd68-b15f-4152-f1df-b72773fce497"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Params before loading saved model: OrderedDict([('linear_layer.weight', tensor([[-0.2343]])), ('linear_layer.bias', tensor([0.9186]))])\n",
            "Params after  loading saved model: OrderedDict([('linear_layer.weight', tensor([[0.6968]])), ('linear_layer.bias', tensor([0.3025]))])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "y_pred_loaded = loaded_model_1(X_test)\n",
        "y_pred_loaded == y_preds_new"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VICVJBaBiqlT",
        "outputId": "dc8f1c0f-8ba6-4cb9-eb48-1eff7f756d15"
      },
      "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]])"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "RCzJIg0Mjfga"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}