01_pytorch_workflow.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "### PyTorch Workflow\n",
        "\n",
        "Let's explore an example of a PyTorch end-to-end workflow."
      ],
      "metadata": {
        "id": "U9rzWBajVDdz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "what_were_covering = {1:\"data (prepare and load)\",\n",
        "                      2: \"build model\",\n",
        "                      3: \"fitting the model to data (training)\",\n",
        "                      4: \"making predictions and evaluating a model (inference)\",\n",
        "                      5: \"saving and loading a model\",\n",
        "                      6: \"putting it all together\"}\n",
        "what_were_covering"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kGL3YICO12gn",
        "outputId": "8ec29b8b-24c4-40e1-ec3c-c94396d3da7e"
      },
      "execution_count": 189,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{1: 'data (prepare and load)',\n",
              " 2: 'build model',\n",
              " 3: 'fitting the model to data (training)',\n",
              " 4: 'making predictions and evaluating a model (inference)',\n",
              " 5: 'saving and loading a model',\n",
              " 6: 'putting it all together'}"
            ]
          },
          "metadata": {},
          "execution_count": 189
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "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__"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "6s2srMsc2yLi",
        "outputId": "5e703b89-a139-43b6-8159-77f46a795c1c"
      },
      "execution_count": 190,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2.1.0+cu121'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 190
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Data (preparing and loading)\n",
        "\n",
        "Data can be almost anything... in machine learning.\n",
        "\n",
        "* Excel spreadsheet\n",
        "* Images of any kind\n",
        "* Videos (YouTube has lots of data...)\n",
        "* Audio like songs or podcasts\n",
        "* DNA\n",
        "* Text\n",
        "\n",
        "Machine Learning is a game of two parts:\n",
        "\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",
        "We'll use a linear regression formula to make a straight line with known **parameters**."
      ],
      "metadata": {
        "id": "ZV-HX5Xc3oYm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create *known* parameters\n",
        "weight = 0.7\n",
        "bias = 0.3\n",
        "\n",
        "# Create\n",
        "\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]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bKsvq3v75FtV",
        "outputId": "adc1c2ba-40b9-4c71-9ddd-80ebcb7c36b6"
      },
      "execution_count": 191,
      "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": 191
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "len(X), len(y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Der-dfHW5F_n",
        "outputId": "cd2ff84f-6fd8-49d3-b758-40a88d30c89b"
      },
      "execution_count": 192,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(50, 50)"
            ]
          },
          "metadata": {},
          "execution_count": 192
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Splitting data into training and test sets (one of the most important concepts in machine learning in general)"
      ],
      "metadata": {
        "id": "JGWxejqZ54ap"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a train/test split\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)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "i2YejI-03ix7",
        "outputId": "3ca9f677-7dc3-4287-c114-dec91960bb27"
      },
      "execution_count": 193,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(40, 40, 10, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 193
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "How might we better visualize our data?\n",
        "This is where the data explorer's motto comes in!\n",
        "\"Visualize, visualize, visualize!\""
      ],
      "metadata": {
        "id": "jbuHg_kD7TaF"
      }
    },
    {
      "cell_type": "code",
      "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",
        "  \"\"\"\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=\"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",
        "  # 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": "0fLyxBNr3i1f"
      },
      "execution_count": 194,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "PJqdJWeH4mjF",
        "outputId": "ab69e771-784d-401a-95db-57f41542f4eb"
      },
      "execution_count": 195,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. Build model\n",
        "\n",
        "Our first PyTorch model!\n",
        "\n",
        "This is very exciting... let's do it!\n",
        "\n",
        "What our model does:\n",
        "* Start with random values (weight & bias)\n",
        "* Look at training data and adjust the random values to better represent (or get closer to) the ideal values (the weight & bias values we used to create the data)\n",
        "\n",
        "How does it do so?\n",
        "\n",
        "Through two main algorithms:\n",
        "1. Gradient descent\n",
        "2. Backpropagation"
      ],
      "metadata": {
        "id": "_6hai9U54mlg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from torch import nn\n",
        "\n",
        "# Create linear regression model class\n",
        "class LinearRegressionModel(nn.Module): # <- almost everything in PyTorch inherits from nn.Module\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    self.weights = nn.Parameter(torch.randn(1,# <- start with a random weight and try to adjust it to the ideal weight\n",
        "                                          requires_grad=True, # <- can this parameter be updated via gradient descent?\n",
        "                                          dtype=torch.float)) # <- PyTorch loves the datatype torch.float32\n",
        "    self.bias = nn.Parameter(torch.randn(1, # <- start with a random bias and try to adjust it to the ideal bias\n",
        "                                         requires_grad=True, # <- can this parameter be updated via gradient descent?\n",
        "                                         dtype=torch.float)) # <- PyTorch loves the datatype torch.float32\n",
        "  # Forward method to define the computation in the model\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": "ncKIgXyU4moi"
      },
      "execution_count": 196,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### PyTorch model building essentials\n",
        "\n",
        " * torch.nn - contains all of the buildings for computational graphs (a neural network can be considered a computational graph)\n",
        " * torch.nn.Parameter - what parameters should our model try and learn, often a 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 is where the optimizers in PyTorch live, they 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": "4YTQ1sN24msA"
      }
    },
    {
      "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",
        "We can check our model parameters or what's inside our model using .parameters()."
      ],
      "metadata": {
        "id": "dfnRa2ht-2l2"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "torch.randn(1)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZvpY941cXORl",
        "outputId": "4517a9c6-fdd6-4418-8ffc-f2338b8b13c6"
      },
      "execution_count": 197,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0.4740])"
            ]
          },
          "metadata": {},
          "execution_count": 197
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a random seed\n",
        "torch.manual_seed(42)\n",
        "\n",
        "# Create an instance of model (this is a subclass of nn.Module)\n",
        "model_0 = LinearRegressionModel()\n",
        "\n",
        "# Check out the parameters\n",
        "list(model_0.parameters())"
      ],
      "metadata": {
        "id": "tYl2m_s_-2oA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e267cf7b-dcd7-421d-8e18-34bcc213c654"
      },
      "execution_count": 198,
      "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": 198
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# List named parameters\n",
        "model_0.state_dict()"
      ],
      "metadata": {
        "id": "8DGi8U3Y-2qE",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b29a2bda-1525-472f-a94d-789e6f15be7e"
      },
      "execution_count": 199,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "metadata": {},
          "execution_count": 199
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Making predictions using 'torch.inference_mode()'\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 it through the forward() method  "
      ],
      "metadata": {
        "id": "OqpzA-XY-2te"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "y_preds = model_0(X_test)\n",
        "y_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0tSoeZxiJ40y",
        "outputId": "89171a19-33dc-43c2-8a52-31b1a686aa48"
      },
      "execution_count": 200,
      "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": 200
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X_test, y_test"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5eKYLUN8FlfK",
        "outputId": "ca79a35e-eac2-4680-8cea-8a6f7ec5ee4f"
      },
      "execution_count": 201,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[0.8000],\n",
              "         [0.8200],\n",
              "         [0.8400],\n",
              "         [0.8600],\n",
              "         [0.8800],\n",
              "         [0.9000],\n",
              "         [0.9200],\n",
              "         [0.9400],\n",
              "         [0.9600],\n",
              "         [0.9800]]),\n",
              " tensor([[0.8600],\n",
              "         [0.8740],\n",
              "         [0.8880],\n",
              "         [0.9020],\n",
              "         [0.9160],\n",
              "         [0.9300],\n",
              "         [0.9440],\n",
              "         [0.9580],\n",
              "         [0.9720],\n",
              "         [0.9860]]))"
            ]
          },
          "metadata": {},
          "execution_count": 201
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "\n",
        "# Make predictions with model\n",
        "with torch.inference_mode():\n",
        "  y_preds = model_0(X_test)\n",
        "\n",
        "# You can also do somethingn similar with toch.no_grad\n",
        "with torch.no_grad():\n",
        "  y_preds = model_0(X_test)\n",
        "\n",
        "y_preds"
      ],
      "metadata": {
        "id": "LcSwatbuXUFx",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "00273660-ba62-4504-d0cd-90a661a17543"
      },
      "execution_count": 202,
      "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": 202
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        " y_test"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Zox6_A8uE14b",
        "outputId": "6d0b1c39-b19a-4dfa-b4ee-fe07be6aa449"
      },
      "execution_count": 203,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.8600],\n",
              "        [0.8740],\n",
              "        [0.8880],\n",
              "        [0.9020],\n",
              "        [0.9160],\n",
              "        [0.9300],\n",
              "        [0.9440],\n",
              "        [0.9580],\n",
              "        [0.9720],\n",
              "        [0.9860]])"
            ]
          },
          "metadata": {},
          "execution_count": 203
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions(predictions=y_preds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "0y-2gwotEq8v",
        "outputId": "a92c6172-aa5e-4a67-e7fe-55590a843e07"
      },
      "execution_count": 204,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions(predictions=y_preds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "y9J5MyJzEq_x",
        "outputId": "36c2efd7-b2c6-4363-c337-7c7aae197f81"
      },
      "execution_count": 205,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 3. Train model\n",
        "\n",
        "The whole idea of training is for a model to move from some *unknown* parameters (these may be random) to some known parameters.\n",
        "\n",
        "Or in other words from a poor representation of the data to a better representation of the data.\n",
        "\n",
        "One way to measure how poor or how wrong your model's predictions are is to use a loss function.\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 function.\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 outputs, so lower is better.\n",
        "\n",
        "* **Optimizer:** Takes into account the loss of a model and adjusts the model's parameters (e.g. weight & bias in our case) to improve the loss function.\n",
        "\n",
        "Inside the optimizer you will often have to set two parameters:\n",
        "\n",
        "* params - the model parameters you would like to optimize, for example param=model_0.parameters()\n",
        "*lr(learning rate) - the learning rate is a hyperparameter that defines how big/small the optimizer changes the parameters with each step (a small lr results in small changes, a large lr results in large changes)\n",
        "\n",
        "And specifically for PyTorch, we need:\n",
        "* A training loop\n",
        "* A testing loop"
      ],
      "metadata": {
        "id": "Mpj-flVFErCX"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list(model_0.parameters())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "46fBk2wsKiF7",
        "outputId": "dca2f5a1-eeb6-4bb1-ccf2-2f5065a4d918"
      },
      "execution_count": 206,
      "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": 206
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check out our model's parameters (a parameter is a value that the model sets itself)\n",
        "model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SLGt0B9NKiUB",
        "outputId": "97117d8e-1796-4a6a-b210-117e4027c881"
      },
      "execution_count": 207,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "metadata": {},
          "execution_count": 207
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup a loss function\n",
        "loss_fn = nn.L1Loss()\n",
        "\n",
        "\n",
        "# Setup an optimizer (stochastic gradient descent)\n",
        "optimizer = torch.optim.SGD(params=model_0.parameters(),\n",
        "                            lr=0.01) # lr = learning rate = possibly the most important hyperparameter you can set"
      ],
      "metadata": {
        "id": "r5hGyvqCWOFS"
      },
      "execution_count": 208,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "loss_fn"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ldtYzLwfWiCl",
        "outputId": "cf0ef630-c9bb-494d-cebe-7adaa43bfe52"
      },
      "execution_count": 209,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "L1Loss()"
            ]
          },
          "metadata": {},
          "execution_count": 209
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Building a training loop in PyTorch\n",
        "\n",
        "A couple of thing we need in a training loop:\n",
        "0. Loop through the data\n",
        "1. Forward pass (this involves data moving through our models 'forward()' functions) to make predictions on data - also called forward propagation\n",
        "2. Calculate the loss (compare forward pass predictions to ground truth labels)\n",
        "3. Optimizer zero grad\n",
        "4. Loss backcall - move backwards through the network to calculate the gradient of earch of the parameters of our model with respect to the loss (**back propagation**)\n",
        "5. Optimizer step - use the optimizer to adjust our model's parameters to try and improve the loss (**gradient descent**)"
      ],
      "metadata": {
        "id": "B-H5yDNJXUMB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "list(model_0.parameters())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "02RfD0H8UKWv",
        "outputId": "23cc54a2-d38f-43bf-8a88-7bc02f862ffb"
      },
      "execution_count": 210,
      "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": 210
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "\n",
        "# An epoch is one loop through the data... (this is a hyperparameter because we've set it)\n",
        "epochs = 200\n",
        "\n",
        "# Track different values\n",
        "epoch_count = []\n",
        "loss_values = []\n",
        "test_loss_values = []\n",
        "\n",
        "###Training\n",
        "# 0. Loop through the data\n",
        "for epoch in range(epochs):\n",
        "  # Set the model to train mode\n",
        "  model_0.train() # train mode in PyTorch sets all parameters that require gradients to require gradients\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",
        "  print(f\"Loss: {loss}\")\n",
        "\n",
        "  # 3. Optimizer zero grad\n",
        "  optimizer.zero_grad()\n",
        "\n",
        "  # 4. Perform backpropagation on the loss with respect to the parameters of the model\n",
        "  loss.backward()\n",
        "\n",
        "  # 5. Step the optimizer (perform gradient descent)\n",
        "  optimizer.step() # by default how the optimizer changes will accumulate through the loop so... we have to zero them above in step 3 for the next iteration of the loop\n",
        "\n",
        "  # Testing\n",
        "  model_0.eval() # turns off differnt settings in the model not needed for evaluation/testing (dropout/batch norm layers)\n",
        "  with torch.inference_mode(): # turns off gradient tracking & and a couple more things behind the scenes\n",
        "  # with torch.no_grad(): # you may also see torch.no_grad in older PyTorch code\n",
        "    # 1. Do the 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",
        "\n",
        "  # Print out what's happening\n",
        "  if epoch % 10 == 0:\n",
        "    epoch_count.append(epoch)\n",
        "    loss_values.append(loss)\n",
        "    test_loss_values.append(test_loss)\n",
        "    print(f\"Epoch: {epoch} | Loss: {loss} | Test loss: {test_loss}\")\n",
        "    # Print out model state_dict()\n",
        "    print(model_0.state_dict())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "1qst9xA3PIqs",
        "outputId": "1fa1022e-8866-4f45-94c3-440acc96740d"
      },
      "execution_count": 211,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Loss: 0.31288138031959534\n",
            "Epoch: 0 | Loss: 0.31288138031959534 | Test loss: 0.48106518387794495\n",
            "OrderedDict([('weights', tensor([0.3406])), ('bias', tensor([0.1388]))])\n",
            "Loss: 0.3013603389263153\n",
            "Loss: 0.28983935713768005\n",
            "Loss: 0.2783183455467224\n",
            "Loss: 0.26679736375808716\n",
            "Loss: 0.2552763521671295\n",
            "Loss: 0.24375534057617188\n",
            "Loss: 0.23223432898521423\n",
            "Loss: 0.22071333229541779\n",
            "Loss: 0.20919232070446014\n",
            "Loss: 0.1976713240146637\n",
            "Epoch: 10 | Loss: 0.1976713240146637 | Test loss: 0.3463551998138428\n",
            "OrderedDict([('weights', tensor([0.3796])), ('bias', tensor([0.2388]))])\n",
            "Loss: 0.18615034222602844\n",
            "Loss: 0.1746293306350708\n",
            "Loss: 0.16310831904411316\n",
            "Loss: 0.1515873372554779\n",
            "Loss: 0.14006635546684265\n",
            "Loss: 0.1285453587770462\n",
            "Loss: 0.11702437698841095\n",
            "Loss: 0.1060912236571312\n",
            "Loss: 0.09681284427642822\n",
            "Loss: 0.08908725529909134\n",
            "Epoch: 20 | Loss: 0.08908725529909134 | Test loss: 0.21729660034179688\n",
            "OrderedDict([('weights', tensor([0.4184])), ('bias', tensor([0.3333]))])\n",
            "Loss: 0.08227583020925522\n",
            "Loss: 0.07638873159885406\n",
            "Loss: 0.07160007208585739\n",
            "Loss: 0.06747635453939438\n",
            "Loss: 0.06395438313484192\n",
            "Loss: 0.06097004935145378\n",
            "Loss: 0.05845819041132927\n",
            "Loss: 0.05635259300470352\n",
            "Loss: 0.0545857772231102\n",
            "Loss: 0.053148526698350906\n",
            "Epoch: 30 | Loss: 0.053148526698350906 | Test loss: 0.14464017748832703\n",
            "OrderedDict([('weights', tensor([0.4512])), ('bias', tensor([0.3768]))])\n",
            "Loss: 0.05181945487856865\n",
            "Loss: 0.05069301277399063\n",
            "Loss: 0.0498228520154953\n",
            "Loss: 0.04895269125699997\n",
            "Loss: 0.04819351062178612\n",
            "Loss: 0.047531817108392715\n",
            "Loss: 0.04692792519927025\n",
            "Loss: 0.04642331600189209\n",
            "Loss: 0.04591871052980423\n",
            "Loss: 0.04543796554207802\n",
            "Epoch: 40 | Loss: 0.04543796554207802 | Test loss: 0.11360953003168106\n",
            "OrderedDict([('weights', tensor([0.4748])), ('bias', tensor([0.3868]))])\n",
            "Loss: 0.04503796249628067\n",
            "Loss: 0.04463795945048332\n",
            "Loss: 0.04423796385526657\n",
            "Loss: 0.04383796453475952\n",
            "Loss: 0.04343796148896217\n",
            "Loss: 0.043074630200862885\n",
            "Loss: 0.04272563382983208\n",
            "Loss: 0.04237663000822067\n",
            "Loss: 0.04202762991189957\n",
            "Loss: 0.04167863354086876\n",
            "Epoch: 50 | Loss: 0.04167863354086876 | Test loss: 0.09919948130846024\n",
            "OrderedDict([('weights', tensor([0.4938])), ('bias', tensor([0.3843]))])\n",
            "Loss: 0.04132963344454765\n",
            "Loss: 0.04098063334822655\n",
            "Loss: 0.04063162952661514\n",
            "Loss: 0.040282636880874634\n",
            "Loss: 0.039933640509843826\n",
            "Loss: 0.03958464413881302\n",
            "Loss: 0.03923564404249191\n",
            "Loss: 0.03888664394617081\n",
            "Loss: 0.0385376438498497\n",
            "Loss: 0.03818932920694351\n",
            "Epoch: 60 | Loss: 0.03818932920694351 | Test loss: 0.08886633068323135\n",
            "OrderedDict([('weights', tensor([0.5116])), ('bias', tensor([0.3788]))])\n",
            "Loss: 0.03785243630409241\n",
            "Loss: 0.0375034399330616\n",
            "Loss: 0.037164121866226196\n",
            "Loss: 0.03681822493672371\n",
            "Loss: 0.03647511452436447\n",
            "Loss: 0.03613303601741791\n",
            "Loss: 0.03578609973192215\n",
            "Loss: 0.03544783592224121\n",
            "Loss: 0.035098835825920105\n",
            "Loss: 0.03476089984178543\n",
            "Epoch: 70 | Loss: 0.03476089984178543 | Test loss: 0.0805937647819519\n",
            "OrderedDict([('weights', tensor([0.5288])), ('bias', tensor([0.3718]))])\n",
            "Loss: 0.03441363573074341\n",
            "Loss: 0.03407188132405281\n",
            "Loss: 0.03372843936085701\n",
            "Loss: 0.03338287025690079\n",
            "Loss: 0.033043231815099716\n",
            "Loss: 0.03269423171877861\n",
            "Loss: 0.032357655465602875\n",
            "Loss: 0.03200903534889221\n",
            "Loss: 0.03166864812374115\n",
            "Loss: 0.03132382780313492\n",
            "Epoch: 80 | Loss: 0.03132382780313492 | Test loss: 0.07232122868299484\n",
            "OrderedDict([('weights', tensor([0.5459])), ('bias', tensor([0.3648]))])\n",
            "Loss: 0.030979642644524574\n",
            "Loss: 0.030638623982667923\n",
            "Loss: 0.0302906334400177\n",
            "Loss: 0.029953425750136375\n",
            "Loss: 0.02960442565381527\n",
            "Loss: 0.029265418648719788\n",
            "Loss: 0.028919223695993423\n",
            "Loss: 0.028576409444212914\n",
            "Loss: 0.028234025463461876\n",
            "Loss: 0.02788739837706089\n",
            "Epoch: 90 | Loss: 0.02788739837706089 | Test loss: 0.06473556160926819\n",
            "OrderedDict([('weights', tensor([0.5629])), ('bias', tensor([0.3573]))])\n",
            "Loss: 0.02754882536828518\n",
            "Loss: 0.027199819684028625\n",
            "Loss: 0.026862185448408127\n",
            "Loss: 0.02651461586356163\n",
            "Loss: 0.026173178106546402\n",
            "Loss: 0.025829419493675232\n",
            "Loss: 0.02548416517674923\n",
            "Loss: 0.025144213810563087\n",
            "Loss: 0.02479521557688713\n",
            "Loss: 0.024458957836031914\n",
            "Epoch: 100 | Loss: 0.024458957836031914 | Test loss: 0.05646304413676262\n",
            "OrderedDict([('weights', tensor([0.5800])), ('bias', tensor([0.3503]))])\n",
            "Loss: 0.024110013619065285\n",
            "Loss: 0.02376994863152504\n",
            "Loss: 0.02342480979859829\n",
            "Loss: 0.023080935701727867\n",
            "Loss: 0.022739607840776443\n",
            "Loss: 0.022391926497220993\n",
            "Loss: 0.022054409608244896\n",
            "Loss: 0.02170540764927864\n",
            "Loss: 0.021366719156503677\n",
            "Loss: 0.021020207554101944\n",
            "Epoch: 110 | Loss: 0.021020207554101944 | Test loss: 0.04819049686193466\n",
            "OrderedDict([('weights', tensor([0.5972])), ('bias', tensor([0.3433]))])\n",
            "Loss: 0.020677709951996803\n",
            "Loss: 0.02033500373363495\n",
            "Loss: 0.01998869702219963\n",
            "Loss: 0.019649803638458252\n",
            "Loss: 0.019300809130072594\n",
            "Loss: 0.018963487818837166\n",
            "Loss: 0.01861560344696045\n",
            "Loss: 0.018274478614330292\n",
            "Loss: 0.017930403351783752\n",
            "Loss: 0.01758546568453312\n",
            "Epoch: 120 | Loss: 0.01758546568453312 | Test loss: 0.04060482233762741\n",
            "OrderedDict([('weights', tensor([0.6141])), ('bias', tensor([0.3358]))])\n",
            "Loss: 0.017245199531316757\n",
            "Loss: 0.016896454617381096\n",
            "Loss: 0.01656000316143036\n",
            "Loss: 0.016210997477173805\n",
            "Loss: 0.01587124727666378\n",
            "Loss: 0.015525798313319683\n",
            "Loss: 0.015182236209511757\n",
            "Loss: 0.014840595424175262\n",
            "Loss: 0.01449323259294033\n",
            "Loss: 0.014155393466353416\n",
            "Epoch: 130 | Loss: 0.014155393466353416 | Test loss: 0.03233227878808975\n",
            "OrderedDict([('weights', tensor([0.6313])), ('bias', tensor([0.3288]))])\n",
            "Loss: 0.013806397095322609\n",
            "Loss: 0.013468016870319843\n",
            "Loss: 0.013121193274855614\n",
            "Loss: 0.01277900766581297\n",
            "Loss: 0.012435992248356342\n",
            "Loss: 0.01208999752998352\n",
            "Loss: 0.011750795878469944\n",
            "Loss: 0.011401787400245667\n",
            "Loss: 0.011064787395298481\n",
            "Loss: 0.010716589167714119\n",
            "Epoch: 140 | Loss: 0.010716589167714119 | Test loss: 0.024059748277068138\n",
            "OrderedDict([('weights', tensor([0.6485])), ('bias', tensor([0.3218]))])\n",
            "Loss: 0.010375778190791607\n",
            "Loss: 0.010031387209892273\n",
            "Loss: 0.009686763398349285\n",
            "Loss: 0.009346187114715576\n",
            "Loss: 0.008997755125164986\n",
            "Loss: 0.008660981431603432\n",
            "Loss: 0.008311985060572624\n",
            "Loss: 0.007972544990479946\n",
            "Loss: 0.007626785431057215\n",
            "Loss: 0.0072835334576666355\n",
            "Epoch: 150 | Loss: 0.0072835334576666355 | Test loss: 0.016474086791276932\n",
            "OrderedDict([('weights', tensor([0.6654])), ('bias', tensor([0.3143]))])\n",
            "Loss: 0.006941580679267645\n",
            "Loss: 0.006594526115804911\n",
            "Loss: 0.006256377790123224\n",
            "Loss: 0.005907376762479544\n",
            "Loss: 0.005569315515458584\n",
            "Loss: 0.005222178064286709\n",
            "Loss: 0.004880306776612997\n",
            "Loss: 0.004536976106464863\n",
            "Loss: 0.00419129803776741\n",
            "Loss: 0.0038517764769494534\n",
            "Epoch: 160 | Loss: 0.0038517764769494534 | Test loss: 0.008201557211577892\n",
            "OrderedDict([('weights', tensor([0.6826])), ('bias', tensor([0.3073]))])\n",
            "Loss: 0.0035027749836444855\n",
            "Loss: 0.0031660839449614286\n",
            "Loss: 0.002817571861669421\n",
            "Loss: 0.0024770735763013363\n",
            "Loss: 0.0021323717664927244\n",
            "Loss: 0.0017880648374557495\n",
            "Loss: 0.0014518328243866563\n",
            "Loss: 0.0011887758737429976\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Epoch: 170 | Loss: 0.008932482451200485 | Test loss: 0.005023092031478882\n",
            "OrderedDict([('weights', tensor([0.6951])), ('bias', tensor([0.2993]))])\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Epoch: 180 | Loss: 0.008932482451200485 | Test loss: 0.005023092031478882\n",
            "OrderedDict([('weights', tensor([0.6951])), ('bias', tensor([0.2993]))])\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Epoch: 190 | Loss: 0.008932482451200485 | Test loss: 0.005023092031478882\n",
            "OrderedDict([('weights', tensor([0.6951])), ('bias', tensor([0.2993]))])\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Loss: 0.0025885067880153656\n",
            "Loss: 0.008932482451200485\n",
            "Loss: 0.0025885067880153656\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "np.array(torch.tensor(loss_values).numpy()), test_loss_values"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "H7kD6nvFWMYy",
        "outputId": "bd403358-0864-40e3-81dd-4a78e8dd1dc2"
      },
      "execution_count": 212,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(array([0.31288138, 0.19767132, 0.08908726, 0.05314853, 0.04543797,\n",
              "        0.04167863, 0.03818933, 0.0347609 , 0.03132383, 0.0278874 ,\n",
              "        0.02445896, 0.02102021, 0.01758547, 0.01415539, 0.01071659,\n",
              "        0.00728353, 0.00385178, 0.00893248, 0.00893248, 0.00893248],\n",
              "       dtype=float32),\n",
              " [tensor(0.4811),\n",
              "  tensor(0.3464),\n",
              "  tensor(0.2173),\n",
              "  tensor(0.1446),\n",
              "  tensor(0.1136),\n",
              "  tensor(0.0992),\n",
              "  tensor(0.0889),\n",
              "  tensor(0.0806),\n",
              "  tensor(0.0723),\n",
              "  tensor(0.0647),\n",
              "  tensor(0.0565),\n",
              "  tensor(0.0482),\n",
              "  tensor(0.0406),\n",
              "  tensor(0.0323),\n",
              "  tensor(0.0241),\n",
              "  tensor(0.0165),\n",
              "  tensor(0.0082),\n",
              "  tensor(0.0050),\n",
              "  tensor(0.0050),\n",
              "  tensor(0.0050)])"
            ]
          },
          "metadata": {},
          "execution_count": 212
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the loss curves\n",
        "plt.plot(epoch_count, np.array(torch.tensor(loss_values).numpy()), label=\"Train loss\")\n",
        "plt.plot(epoch_count, test_loss_values, label=\"Test loss\")\n",
        "plt.title(\"Training and test loss curves\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.legend();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "FWTqykWOUiHy",
        "outputId": "879ce7b5-d1e3-42de-c2d8-df199ffbc95d"
      },
      "execution_count": 213,
      "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": [
        "epoch_count, loss_values, test_loss_values"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WMdz7L5jbdpe",
        "outputId": "6747fc79-52dc-4fed-ba27-54fdb20b38cb"
      },
      "execution_count": 214,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "([0,\n",
              "  10,\n",
              "  20,\n",
              "  30,\n",
              "  40,\n",
              "  50,\n",
              "  60,\n",
              "  70,\n",
              "  80,\n",
              "  90,\n",
              "  100,\n",
              "  110,\n",
              "  120,\n",
              "  130,\n",
              "  140,\n",
              "  150,\n",
              "  160,\n",
              "  170,\n",
              "  180,\n",
              "  190],\n",
              " [tensor(0.3129, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.1977, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0891, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0531, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0454, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0417, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0382, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0348, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0313, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0279, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0245, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0210, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0176, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0142, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0107, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0073, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0039, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0089, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0089, grad_fn=<MeanBackward0>),\n",
              "  tensor(0.0089, grad_fn=<MeanBackward0>)],\n",
              " [tensor(0.4811),\n",
              "  tensor(0.3464),\n",
              "  tensor(0.2173),\n",
              "  tensor(0.1446),\n",
              "  tensor(0.1136),\n",
              "  tensor(0.0992),\n",
              "  tensor(0.0889),\n",
              "  tensor(0.0806),\n",
              "  tensor(0.0723),\n",
              "  tensor(0.0647),\n",
              "  tensor(0.0565),\n",
              "  tensor(0.0482),\n",
              "  tensor(0.0406),\n",
              "  tensor(0.0323),\n",
              "  tensor(0.0241),\n",
              "  tensor(0.0165),\n",
              "  tensor(0.0082),\n",
              "  tensor(0.0050),\n",
              "  tensor(0.0050),\n",
              "  tensor(0.0050)])"
            ]
          },
          "metadata": {},
          "execution_count": 214
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with torch. inference_mode():\n",
        "  y_preds_new = model_0(X_test)"
      ],
      "metadata": {
        "id": "77G4Xaqag2-_"
      },
      "execution_count": 215,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GREFt8l7PItE",
        "outputId": "9420a2e7-cc7a-4347-87cf-997562bb30a8"
      },
      "execution_count": 216,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
            ]
          },
          "metadata": {},
          "execution_count": 216
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "weight, bias"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bJkyWiLkPIvI",
        "outputId": "93847c91-0b6d-4e32-d37a-903cac2999a3"
      },
      "execution_count": 217,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.7, 0.3)"
            ]
          },
          "metadata": {},
          "execution_count": 217
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions(predictions=y_preds);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "s4iu9_iDPIxU",
        "outputId": "76e5d57d-e9ad-4ba2-c841-c74927bf2aa6"
      },
      "execution_count": 218,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions(predictions=y_preds_new);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "RW_1PiUiLqO2",
        "outputId": "d3b1a65e-a9b8-4f2d-8b8a-2d9932496bc8"
      },
      "execution_count": 219,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Saving a model in PyTorch\n",
        "\n",
        "There are three main methods you should know about for saving and loading 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()' - this allows you to load a model's saved state dictionary"
      ],
      "metadata": {
        "id": "q8_DUGyvNtoW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Kgo1DGq-LkrL",
        "outputId": "7e2082cf-4183-4fed-ba0d-e194324e84ce"
      },
      "execution_count": 220,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
            ]
          },
          "metadata": {},
          "execution_count": 220
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Saving our PyTorch model\n",
        "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_0.pth\"\n",
        "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n",
        "\n",
        "MODEL_SAVE_PATH\n",
        "\n",
        "# 3. Save the model state dict\n",
        "print(f\"Saving model to: {MODEL_SAVE_PATH}\")\n",
        "torch.save(obj=model_0.state_dict(),\n",
        "           f=MODEL_SAVE_PATH)"
      ],
      "metadata": {
        "id": "bFIzptswNtrj",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "cfdfcd02-1928-44ca-b2f2-ce4c21cca8c6"
      },
      "execution_count": 221,
      "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": "us6bFqJQLXeG",
        "outputId": "53d59501-b262-435f-fd2d-2441b983d973"
      },
      "execution_count": 222,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "total 8\n",
            "-rw-r--r-- 1 root root 1680 Dec 30 23:13 01_pytorch_workflow_model_0.pth\n",
            "-rw-r--r-- 1 root root 1744 Dec 30 22:58 01_pytorch_workflow_model_1.pth\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Loading a PyTorch model\n",
        "\n",
        "Since we saved our model's state_dict() rather than the entire model, we'll create a new instance of our model class and load the saved state_dict() into that."
      ],
      "metadata": {
        "id": "tey0nWMsLXhi"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "enkOZyolLXmo",
        "outputId": "cb0b9eba-fc0f-45a4-db6a-40d9419b8146"
      },
      "execution_count": 223,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
            ]
          },
          "metadata": {},
          "execution_count": 223
        }
      ]
    },
    {
      "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": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jPwj3BUaLX2X",
        "outputId": "83174674-2073-46da-d489-1715504fb943"
      },
      "execution_count": 224,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "metadata": {},
          "execution_count": 224
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loaded_model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BWcB64lNnjXT",
        "outputId": "4fb2ec1a-f0bc-4541-b41d-143a7003f38a"
      },
      "execution_count": 225,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
            ]
          },
          "metadata": {},
          "execution_count": 225
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make some predictions with our loaded  model\n",
        "loaded_model_0.eval()\n",
        "with torch.inference_mode():\n",
        "  loaded_model_preds = loaded_model_0(X_test)\n",
        "\n",
        "loaded_model_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HzBWAj0QnjZa",
        "outputId": "6127bcbf-a4eb-4948-ccf0-9dc30dcbeb5a"
      },
      "execution_count": 226,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.8685],\n",
              "        [0.8825],\n",
              "        [0.8965],\n",
              "        [0.9105],\n",
              "        [0.9245],\n",
              "        [0.9384],\n",
              "        [0.9524],\n",
              "        [0.9664],\n",
              "        [0.9804],\n",
              "        [0.9944]])"
            ]
          },
          "metadata": {},
          "execution_count": 226
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Compare loaded model preds with original model preds\n",
        "y_preds == loaded_model_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0cMPe0fZnjc5",
        "outputId": "aafaf4cb-82c7-43bb-8e46-6a986127807a"
      },
      "execution_count": 227,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[False],\n",
              "        [False],\n",
              "        [False],\n",
              "        [False],\n",
              "        [False],\n",
              "        [False],\n",
              "        [False],\n",
              "        [False],\n",
              "        [False],\n",
              "        [False]])"
            ]
          },
          "metadata": {},
          "execution_count": 227
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make some models preds\n",
        "model_0.eval()\n",
        "with torch.inference_mode():\n",
        "  y_preds = model_0(X_test)\n",
        "\n",
        "y_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BAtaRzvrnjoY",
        "outputId": "bd3c355e-74aa-4ad2-8aa3-705c6be6df20"
      },
      "execution_count": 228,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.8685],\n",
              "        [0.8825],\n",
              "        [0.8965],\n",
              "        [0.9105],\n",
              "        [0.9245],\n",
              "        [0.9384],\n",
              "        [0.9524],\n",
              "        [0.9664],\n",
              "        [0.9804],\n",
              "        [0.9944]])"
            ]
          },
          "metadata": {},
          "execution_count": 228
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 6. Putting it all together\n",
        "\n",
        "Let's go back through the steps above and see it all in one place"
      ],
      "metadata": {
        "id": "4P6mX7nDpNmb"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import PyTorch and matplotlib\n",
        "import torch\n",
        "from torch import nn\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "#Check PyTorch version\n",
        "torch.__version__"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "28wc558Rp2GZ",
        "outputId": "0ee57159-d085-4d65-b2f6-71d7329995a9"
      },
      "execution_count": 229,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2.1.0+cu121'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 229
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create device-agnostic code.\n",
        "\n",
        "This means we've got access to a GPU, our code will use it (for potentially faster computing)\n",
        "\n",
        "If no GPU is available, the code will default to using CPU."
      ],
      "metadata": {
        "id": "s1Elblb3p2Iy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup device agnostic code\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"CPU\"\n",
        "print(f\"Using device {device}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dmI_mf1Pp2MO",
        "outputId": "0433bb9f-a3be-4e38-b2c7-7262d074f24f"
      },
      "execution_count": 230,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using device cuda\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.1 Data"
      ],
      "metadata": {
        "id": "z8kMkBVirczY"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create some data using the linear regression formula of y = weight * X + bias\n",
        "weight = 0.7\n",
        "bias = 0.3\n",
        "\n",
        "# Create range values\n",
        "start = 0\n",
        "end = 1\n",
        "step = 0.02\n",
        "\n",
        "# Create X and y (features and labels)\n",
        "X = torch.arange(start, end, step).unsqueeze(dim=1) # without unsqueeze, errors will pop up\n",
        "y = weight * X + bias\n",
        "X[:10], y[:10]\n"
      ],
      "metadata": {
        "id": "huRHJeEVrc17",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "4d806708-588a-4903-c1ce-88cbe2c45c82"
      },
      "execution_count": 231,
      "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": 231
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Split data\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",
        "len(X_train), len(y_train), len(X_test), len(y_test)"
      ],
      "metadata": {
        "id": "q-2wxreKrc4r",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5452a710-3b44-47e1-8a41-796380a48a49"
      },
      "execution_count": 232,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(40, 40, 10, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 232
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the data\n",
        "# Note: if you don't have the plot_predictions() function loaded this will error\n",
        "plot_predictions(X_train, y_train, X_test, y_test)"
      ],
      "metadata": {
        "id": "5UfZ_wberc7e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "outputId": "87c7b988-b8b1-4a05-e8c0-e97554cd8f3a"
      },
      "execution_count": 233,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.2 Building a PyTorch Linear model"
      ],
      "metadata": {
        "id": "IDw-66cRrc-4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a linear model by subclassing nn.Module\n",
        "class LinearRegressionModelV2(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "    # Use nn.Linear() for creating the model parameters / also called: linear transform, probing layer, fully connected layer, dense layer,\n",
        "    self.linear_layer = nn.Linear(in_features=1,\n",
        "                                  out_features=1)\n",
        "\n",
        "  def forward(self, X: torch.Tensor) -> torch.Tensor:\n",
        "    return self.linear_layer(X)\n",
        "\n",
        "# Set the manual seed\n",
        "torch.manual_seed(42)\n",
        "model_1 = LinearRegressionModelV2()\n",
        "model_1, model_1.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tUMYbJQRdzLA",
        "outputId": "33620243-4ec2-481c-cb65-dca2f14c169f"
      },
      "execution_count": 234,
      "outputs": [
        {
          "output_type": "execute_result",
          "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]))]))"
            ]
          },
          "metadata": {},
          "execution_count": 234
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X_train[:5], y_train[:5]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "l9-HANb6dzNS",
        "outputId": "99eeaa8e-0023-43b9-83f3-f59e35412d0d"
      },
      "execution_count": 235,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[0.0000],\n",
              "         [0.0200],\n",
              "         [0.0400],\n",
              "         [0.0600],\n",
              "         [0.0800]]),\n",
              " tensor([[0.3000],\n",
              "         [0.3140],\n",
              "         [0.3280],\n",
              "         [0.3420],\n",
              "         [0.3560]]))"
            ]
          },
          "metadata": {},
          "execution_count": 235
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check the model current device\n",
        "next(model_1.parameters()).device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KE02YUDPjAoH",
        "outputId": "acc89ff9-8ee4-4020-bef7-ecb9fed22eba"
      },
      "execution_count": 236,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cpu')"
            ]
          },
          "metadata": {},
          "execution_count": 236
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Set the model to use the target device\n",
        "model_1.to(device)\n",
        "next(model_1.parameters()).device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eqxWkhGkdzQP",
        "outputId": "f58852c2-f172-4913-e5cf-f934e4b450af"
      },
      "execution_count": 237,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cuda', index=0)"
            ]
          },
          "metadata": {},
          "execution_count": 237
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.3 Training\n",
        "\n",
        "For training we need:\n",
        "* Loss function\n",
        "* Optimizer\n",
        "* Training loop\n",
        "* Testing loop"
      ],
      "metadata": {
        "id": "78g3SjiSdzTs"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model_1.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lBPRjaUrpw6V",
        "outputId": "aef7d683-e1d8-4375-bde4-d68b79207448"
      },
      "execution_count": 238,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('linear_layer.weight', tensor([[0.7645]], device='cuda:0')),\n",
              "             ('linear_layer.bias', tensor([0.8300], device='cuda:0'))])"
            ]
          },
          "metadata": {},
          "execution_count": 238
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup loss function\n",
        "loss_fn = nn.L1Loss() # same as MAE\n",
        "\n",
        "# Setup our optimizer\n",
        "optimizer = torch.optim.SGD(params=model_1.parameters(),\n",
        "                            lr=0.01)"
      ],
      "metadata": {
        "id": "r7KZJTAXpxJ6"
      },
      "execution_count": 239,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Let's write a training loop\n",
        "torch.manual_seed(42)\n",
        "\n",
        "epochs = 200\n",
        "\n",
        "# Put data on the target device (device agnostic code for data)\n",
        "X_train = X_train.to(device)\n",
        "y_train = y_train.to(device)\n",
        "X_test = X_test.to(device)\n",
        "y_test = y_test.to(device)\n",
        "\n",
        "for epoch in range(epochs):\n",
        "  model_1. train()\n",
        "\n",
        "  # 1. Forward pass\n",
        "  y_pred = model_1(X_train)\n",
        "\n",
        "  # 2. Calculate the loss\n",
        "  loss = loss_fn(y_pred, y_train)\n",
        "\n",
        "  # 3. Optimizer zero grad\n",
        "  optimizer.zero_grad()\n",
        "\n",
        "  # 4. Perform backpropagation\n",
        "  loss.backward()\n",
        "\n",
        "  # 5. Optimizer step\n",
        "  optimizer.step()\n",
        "\n",
        "  ### Testing\n",
        "  model_1.eval()\n",
        "  with torch.inference_mode():\n",
        "    test_pred = model_1(X_test)\n",
        "\n",
        "    test_loss = loss_fn(test_pred, y_test)\n",
        "\n",
        "  # Print out what's happening\n",
        "\n",
        "  if epoch % 10 == 0:\n",
        "    print(f\"Epoch:{epoch} | Loss: {loss} | Test loss: {test_loss}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C4mbkXLBdWaA",
        "outputId": "f6e45e76-8813-4f8a-ff94-1bbdfc290c50"
      },
      "execution_count": 240,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch:0 | Loss: 0.5551779866218567 | Test loss: 0.5739762187004089\n",
            "Epoch:10 | Loss: 0.439968079328537 | Test loss: 0.4392664134502411\n",
            "Epoch:20 | Loss: 0.3247582018375397 | Test loss: 0.30455657839775085\n",
            "Epoch:30 | Loss: 0.20954833924770355 | Test loss: 0.16984669864177704\n",
            "Epoch:40 | Loss: 0.09433845430612564 | Test loss: 0.03513690456748009\n",
            "Epoch:50 | Loss: 0.023886388167738914 | Test loss: 0.04784907028079033\n",
            "Epoch:60 | Loss: 0.019956795498728752 | Test loss: 0.045803118497133255\n",
            "Epoch:70 | Loss: 0.016517987474799156 | Test loss: 0.037530567497015\n",
            "Epoch:80 | Loss: 0.013089174404740334 | Test loss: 0.02994490973651409\n",
            "Epoch:90 | Loss: 0.009653178043663502 | Test loss: 0.02167237363755703\n",
            "Epoch:100 | Loss: 0.006215683650225401 | Test loss: 0.014086711220443249\n",
            "Epoch:110 | Loss: 0.00278724217787385 | Test loss: 0.005814164876937866\n",
            "Epoch:120 | Loss: 0.0012645035749301314 | Test loss: 0.013801801018416882\n",
            "Epoch:130 | Loss: 0.0012645035749301314 | Test loss: 0.013801801018416882\n",
            "Epoch:140 | Loss: 0.0012645035749301314 | Test loss: 0.013801801018416882\n",
            "Epoch:150 | Loss: 0.0012645035749301314 | Test loss: 0.013801801018416882\n",
            "Epoch:160 | Loss: 0.0012645035749301314 | Test loss: 0.013801801018416882\n",
            "Epoch:170 | Loss: 0.0012645035749301314 | Test loss: 0.013801801018416882\n",
            "Epoch:180 | Loss: 0.0012645035749301314 | Test loss: 0.013801801018416882\n",
            "Epoch:190 | Loss: 0.0012645035749301314 | Test loss: 0.013801801018416882\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_1.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-FY8cuxWdWcl",
        "outputId": "0a193148-b4cc-453c-a92f-9233e25379a4"
      },
      "execution_count": 241,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('linear_layer.weight', tensor([[0.6968]], device='cuda:0')),\n",
              "             ('linear_layer.bias', tensor([0.3025], device='cuda:0'))])"
            ]
          },
          "metadata": {},
          "execution_count": 241
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "weight, bias"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MyDt-j2adWgH",
        "outputId": "c4c4a7d8-b6de-470d-d60d-62c8261f584a"
      },
      "execution_count": 242,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.7, 0.3)"
            ]
          },
          "metadata": {},
          "execution_count": 242
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.4 Making and evaluating predictions"
      ],
      "metadata": {
        "id": "xj7w7uevrsn6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Turn model into evaluation mode\n",
        "model_1.eval()\n",
        "\n",
        "# Make predictions on the test data\n",
        "with torch.inference_mode():\n",
        "  y_preds = model_1(X_test)\n",
        "y_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "M5ATiydArsuZ",
        "outputId": "44b97eca-dafe-4900-cfad-6db00fd7ca18"
      },
      "execution_count": 243,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.8600],\n",
              "        [0.8739],\n",
              "        [0.8878],\n",
              "        [0.9018],\n",
              "        [0.9157],\n",
              "        [0.9296],\n",
              "        [0.9436],\n",
              "        [0.9575],\n",
              "        [0.9714],\n",
              "        [0.9854]], device='cuda:0')"
            ]
          },
          "metadata": {},
          "execution_count": 243
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check out our model predictions visually\n",
        "plot_predictions(predictions=y_preds.cpu())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "mZZ5OyCirsw9",
        "outputId": "b8039519-a0fd-4429-8248-5ff9bded9ebd"
      },
      "execution_count": 244,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.5 Saving and loading a trained model\n"
      ],
      "metadata": {
        "id": "esEyQrE1sVKo"
      }
    },
    {
      "cell_type": "code",
      "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_1.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_1.state_dict(),\n",
        "           f=MODEL_SAVE_PATH)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Bz_XljnOsVNi",
        "outputId": "e2ea439a-0ed1-457a-8ee0-0930d78f0c7d"
      },
      "execution_count": 245,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving model to: models/01_pytorch_workflow_model_1.pth\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load a PyTorch model\n",
        "\n",
        "# Create a new instance of linear model V2\n",
        "loaded_model_1 = LinearRegressionModelV2()\n",
        "\n",
        "# Load the saved model_1 state_dict\n",
        "loaded_model_1.load_state_dict(torch.load(MODEL_SAVE_PATH))\n",
        "\n",
        "# Put the loaded model to device\n",
        "loaded_model_1.to(device)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q_ICCYEHsVQ_",
        "outputId": "d57a5e7e-4ee2-42f5-929e-7129443eb7bf"
      },
      "execution_count": 246,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LinearRegressionModelV2(\n",
              "  (linear_layer): Linear(in_features=1, out_features=1, bias=True)\n",
              ")"
            ]
          },
          "metadata": {},
          "execution_count": 246
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "next(loaded_model_1.parameters()).device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WY4UyuPxsVWq",
        "outputId": "bc10a529-46cc-4af4-9875-ce39e16ea933"
      },
      "execution_count": 247,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cuda', index=0)"
            ]
          },
          "metadata": {},
          "execution_count": 247
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loaded_model_1.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fVIM4i3Pv2mz",
        "outputId": "f10c4975-5817-4813-93d7-48834d2bd29f"
      },
      "execution_count": 248,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('linear_layer.weight', tensor([[0.6968]], device='cuda:0')),\n",
              "             ('linear_layer.bias', tensor([0.3025], device='cuda:0'))])"
            ]
          },
          "metadata": {},
          "execution_count": 248
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Evaluate loaded model\n",
        "loaded_model_1.eval()\n",
        "with torch.inference_mode():\n",
        "  loaded_model_1_preds = loaded_model_1(X_test)\n",
        "y_preds == loaded_model_1_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X_KwcOxNv2pb",
        "outputId": "5dfb6fac-c162-4ca7-e385-02c5e6493227"
      },
      "execution_count": 249,
      "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]], device='cuda:0')"
            ]
          },
          "metadata": {},
          "execution_count": 249
        }
      ]
    }
  ]
}