01_PyTorch_Workflow.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/ReImage-CollegeProject/Learn_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": "markdown",
      "metadata": {
        "id": "3La8kmHWaCkI"
      },
      "source": [
        "# Pytorch Workflow\n",
        "\n",
        "Resources:\n",
        "* Book : https://www.learnpytorch.io/01_pytorch_workflow/"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "RYLCtvzqZvXk"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VHTMtAmoa3Rg"
      },
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "fxyN2ED5bD3o",
        "outputId": "cc873180-25f9-4a04-a52c-288cf074d331"
      },
      "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 (inferences)',\n",
              " 5: 'saving and loading a model',\n",
              " 6: 'putting it all together'}"
            ]
          },
          "metadata": {},
          "execution_count": 1
        }
      ],
      "source": [
        "what_we_are_covering = {\n",
        "    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 (inferences)\",\n",
        "    5: \"saving and loading a model\",\n",
        "    6: \"putting it all together\"\n",
        "}\n",
        "\n",
        "what_we_are_covering"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 36
        },
        "id": "-GCVKJAVbhRN",
        "outputId": "95d0a1f4-7188-4283-a7c3-71fa2f722448"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'2.1.0+cu121'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 2
        }
      ],
      "source": [
        "import torch\n",
        "from torch import nn    # nn contains all of PyTorch's building blocks for neural network\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "## check PyTorch version\n",
        "torch.__version__\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pYBe0SgKcI-Y"
      },
      "source": [
        "## 1. Data (Preparing and Loading)\n",
        "\n",
        "data can be almost anything .. in machin leanring\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 leaning is a game of two parts:\n",
        "1. Get data into a numerical representation\n",
        "2. Build a model to learn patterns in that numerical representaion\n",
        "\n",
        "To showcase this, let's create some known data using Linear regression data\n",
        "\n",
        "We'll use linear regression formula to make a straight line with known **parameters**."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LeOI_va6buto",
        "outputId": "be1f5933-3fa2-46dd-f100-05861fa56d5a"
      },
      "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
        }
      ],
      "source": [
        " # create known parameter\n",
        " weight = 0.7\n",
        " bias = 0.3\n",
        "\n",
        " # create\n",
        " start = 0\n",
        " end = 1\n",
        " step = 0.02\n",
        " X = torch.arange(start,end,step).unsqueeze(dim=1) # tensor\n",
        " y = weight  * X + bias\n",
        "\n",
        " X[:10], y[:10]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9i8a9ZL5et5b",
        "outputId": "80824ea3-596c-472a-de9b-ce8ce44772f0"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(50, 50)"
            ]
          },
          "metadata": {},
          "execution_count": 4
        }
      ],
      "source": [
        "len(X), len(y)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ScqDdVJPfy2p"
      },
      "source": [
        "### 2. Splitting data into training and test sets (one of the most important concepts in Machine learning in general)\n",
        "\n",
        "* Training set   - (60 - 80%)\n",
        "* Validation set - (10 - 20%)\n",
        "* Testing set    - (10 - 20%)\n",
        "\n",
        "Let's create a training and test set with our data.\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "W1QRdZCIfU1k",
        "outputId": "79d79451-8384-43fa-f31b-4cb6f87c127d"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(40, 40, 10, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ],
      "source": [
        "\n",
        "#  create a train/test split data from given dataset\n",
        "\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",
        "# we can create train split using `scikit learn` train test split\n",
        "## search `scikit learn train test split`\n",
        "\n",
        "\n",
        "len(X_train), len(y_train), len(X_test), len(y_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "q_8eAwefI7WR",
        "outputId": "e268aca9-1455-43c5-eb58-fc9f9538e9a1"
      },
      "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",
              "         [0.2000],\n",
              "         [0.2200],\n",
              "         [0.2400],\n",
              "         [0.2600],\n",
              "         [0.2800],\n",
              "         [0.3000],\n",
              "         [0.3200],\n",
              "         [0.3400],\n",
              "         [0.3600],\n",
              "         [0.3800],\n",
              "         [0.4000],\n",
              "         [0.4200],\n",
              "         [0.4400],\n",
              "         [0.4600],\n",
              "         [0.4800],\n",
              "         [0.5000],\n",
              "         [0.5200],\n",
              "         [0.5400],\n",
              "         [0.5600],\n",
              "         [0.5800],\n",
              "         [0.6000],\n",
              "         [0.6200],\n",
              "         [0.6400],\n",
              "         [0.6600],\n",
              "         [0.6800],\n",
              "         [0.7000],\n",
              "         [0.7200],\n",
              "         [0.7400],\n",
              "         [0.7600],\n",
              "         [0.7800]]),\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],\n",
              "         [0.4400],\n",
              "         [0.4540],\n",
              "         [0.4680],\n",
              "         [0.4820],\n",
              "         [0.4960],\n",
              "         [0.5100],\n",
              "         [0.5240],\n",
              "         [0.5380],\n",
              "         [0.5520],\n",
              "         [0.5660],\n",
              "         [0.5800],\n",
              "         [0.5940],\n",
              "         [0.6080],\n",
              "         [0.6220],\n",
              "         [0.6360],\n",
              "         [0.6500],\n",
              "         [0.6640],\n",
              "         [0.6780],\n",
              "         [0.6920],\n",
              "         [0.7060],\n",
              "         [0.7200],\n",
              "         [0.7340],\n",
              "         [0.7480],\n",
              "         [0.7620],\n",
              "         [0.7760],\n",
              "         [0.7900],\n",
              "         [0.8040],\n",
              "         [0.8180],\n",
              "         [0.8320],\n",
              "         [0.8460]]))"
            ]
          },
          "metadata": {},
          "execution_count": 6
        }
      ],
      "source": [
        "X_train, y_train"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XJs-7AFhLHEk"
      },
      "source": [
        "how to better visualize our data?\n",
        "\n",
        "this is where the data explorer's moto comes in !!!\n",
        "\n",
        "\"Visualize, visualize, visualize\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "ZZrh19ryLEtf"
      },
      "outputs": [],
      "source": [
        "# import the matplotlib library\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "def plot_predictions(train_data=X_train,\n",
        "                     train_labels=y_train,\n",
        "                     test_data=X_test,\n",
        "                     test_labels=y_test,\n",
        "                     predictions=None):\n",
        "  \"\"\"\n",
        "  Plots training data, test data and compares the 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=\"#02d1a8\", s=4, label=\"Testing data\")\n",
        "\n",
        "  # Are there predictions\n",
        "  if predictions is not None:\n",
        "    # plot the predictions if they exists\n",
        "    plt.scatter(test_data, predictions, c=\"r\", s=4, label=\"Predictions\")\n",
        "\n",
        "\n",
        "  #show legend\n",
        "  plt.legend(prop={\"size\": 14})"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "oedkOjrQWDOy",
        "outputId": "8d47bd68-f6d3-4d4c-e901-58455c73819d"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plot_predictions()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "43vIv3s1XHqW"
      },
      "source": [
        "## Build Model\n",
        "\n",
        "### Creating our first PyTorch model for linear regression\n",
        "\n",
        "\n",
        "\n",
        "What our model does:\n",
        "* start with random values (weight & bias)\n",
        "* look at training data and adjus the random values to better represent (or get closer to) the ideal values (the weight and bias values we used to create the data)\n",
        "\n",
        "\n",
        "How to do so?\n",
        "\n",
        "through two main algorithms:\n",
        "1. Gradient descent\n",
        "2. backpropagation"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "5ad_LDhyWFIL"
      },
      "outputs": [],
      "source": [
        "## y = mx + c\n",
        "## y = ax + b\n",
        "\n",
        "from torch import nn\n",
        "import torch\n",
        "\n",
        "# Create linear regresson model class\n",
        "# `nn.Module` contains all the building blocks of the neural network\n",
        "class LinearRegressionModel(nn.Module): # <- almost everything in PyTorch inherihts fom nn.Moudle\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "\n",
        "    # Initialize the model parameters\n",
        "    \"\"\" initialize the *model parameters to be used in various computaitons (these could be different layers from torch.nn,\n",
        "    single parameter, hard-coded values or functions* \"\"\"\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 lovest the datatype torch.float32\n",
        "    \"\"\" `requires_grad=True` means PyTorch will track the gradients of this specific parameter for use\n",
        "    with `torch.autograd` and gradient descent (for many `torch.nn` moduels, `requires_grad=True` is set by default)  \"\"\"\n",
        "\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",
        "\n",
        "  # Forward metho to define the computation in the model\n",
        "  \"\"\"Any subclass of the `nn.Module` needs to override forward()\n",
        "  (this defines the forward computation of 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 y = mx + b"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qyl1GGmg-pVV"
      },
      "source": [
        "### PyTorch model building essentials\n",
        "\n",
        "* `torch.nn` - contains all of the building blocks for computation graphs (a neural network can be considered as computational graph)\n",
        "* `torch.nn.Parameter` - what parameter should our model try and learn, often a PyTorch layer from `torch.nn` will set these for us\n",
        "* `torch.nn.Module` - base class for all the neural network modules, if you subclass it, you should override `forward()` method\n",
        "* `torch.optim` - this is where the optimizers in PyTorch live, they will help with gradient descent\n",
        "* `def forward()` - All the `nn.Module` subclasses require you to override the `forward()` method, this method define what happens in the forward computation  \n",
        "* `torch.utils.data.Dataset` - Represent a map between key(label) and sample(features) pairs of your data. Such as images and their associated labels.\n",
        "* `torch.utils.data.DataLoader` - Creates a Python iterable overa a torch Dataset (allows you to iterate over your data)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "Resources:\n",
        " - PyTorch cheatsheet: https://pytorch.org/tutorials/beginner/ptcheat.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "7ov8QxPvAKqp"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "SG991nFGLp1p"
      },
      "source": [
        "### Checking the contents of our PyTorch model\n",
        "\n",
        "Now we've created the model let's see what's inside\n",
        "\n",
        "So we can checkout our model parameters or what's inside our model using `.parameters()`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3XVtx0WHcbxf",
        "outputId": "d3df72d7-90a3-4c73-81af-8b14eab51757"
      },
      "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": 10
        }
      ],
      "source": [
        "## create a random seed\n",
        "\n",
        "RANDOM_SEED=42\n",
        "torch.manual_seed(RANDOM_SEED)\n",
        "\n",
        "# Create an instace of the model (this is a subclcass of `nn.Module`)\n",
        "model_0 = LinearRegressionModel()\n",
        "\n",
        "\n",
        "# Checkout the parameters\n",
        "\n",
        "list(model_0.parameters())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LzCn8qBqMWU4",
        "outputId": "9ede2440-08b8-4212-dd82-232e53781616"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ],
      "source": [
        "# list named parameters\n",
        "model_0.state_dict()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bKV8tIEXAsJf",
        "outputId": "ef216ff4-3eb7-4f74-f65a-bc10142c678d"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.7, 0.3)"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ],
      "source": [
        "weight, bias"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4GMaZUpeP3PJ"
      },
      "source": [
        "### making prediction 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"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O7JXJTIQRzHu",
        "outputId": "7495120c-64be-49c1-87bd-0af61ca6a68e"
      },
      "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": 13
        }
      ],
      "source": [
        "y_preds = model_0(X_test)\n",
        "y_preds"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rSKRTX5nQo83",
        "outputId": "3a594562-c8bd-420a-d35e-75227985f4cb"
      },
      "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": 14
        }
      ],
      "source": [
        "X_test,y_test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "PC-uhfv3NTvJ",
        "outputId": "43851362-86f1-4133-d6c3-488835648878"
      },
      "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": 15
        }
      ],
      "source": [
        "# Make predictions with model\n",
        "### inference mode disables all of the gradient which is needed while training our model\n",
        "with torch.inference_mode():\n",
        "  y_preds = model_0(X_test)\n",
        "\n",
        "# something similar can be done using `torch.no_grad()`, however `torch.inference_mode()` is preferred\n",
        "# with torch.no_grad():\n",
        "#   y_preds = model_0(X_test)\n",
        "\n",
        "y_preds"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Y7LFJtGjSqvI"
      },
      "source": [
        "Inference mode learning : https://x.com/PyTorch/status/1437838231505096708?s=20"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "O5ikIQ3WPX-S",
        "outputId": "12a17c81-a03b-484f-db62-6916ec03a675"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plot_predictions(predictions=y_preds)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PcnaVkDvDdKg"
      },
      "source": [
        "####  Transfer learning\n",
        "\n",
        "\n",
        "\n",
        "<br>\n",
        "<br>\n",
        "<br>\n",
        "<br>\n",
        "<br>\n",
        "\n",
        "another approach\n",
        ">  start the parameter with unknown random values and then adjust the value accordingly"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "plt7TZHoInVD"
      },
      "source": [
        "## 3. **Train model**\n",
        "\n",
        "The whole idea of training is for a model to move from *unknown* parameters (these may be random) to some *known* parameters.\n",
        "\n",
        "In other words, from a poor representation of the data to a better representation of the data.\n",
        "\n",
        "\n",
        "One way to how poor or how wrong your model predictions are is to use loss function or cost function\n",
        "\n",
        "* **NOTE** : Loss function may also be called `cost function` and `criterion` in different areas. For our case we are going to refer it as a loss function - https://pytorch.org/docs/stable/optim.html\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "thLgGzAFCVC-"
      },
      "source": [
        "---\n",
        "\n",
        "### 3.1 **Pick a loss function and optimizer**\n",
        "\n",
        "Things we are going to need to train our model:\n",
        "\n",
        "* **Loss Function** : A function to measure how wrong your model's predictions are to the ideal outputs, lower is better.\n",
        "* **Optimizer** : Take into account the loss of a model and adjusts the model's paramters (e.g. weight & bias in our case ) to improve the loss function\n",
        "\n",
        "  * Inside the optimizer you will often have to setup two parameters:\n",
        "    * `params`: the model parameters you'd like to optimize, for example: `params=model_0.parameters()`\n",
        "    * `lr` (learning rate): the learning rate is the hyperparameter that decides 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",
        "<br>\n",
        "\n",
        "And specifically for PyTorch we need :\n",
        "* A training loop\n",
        "* A testinng loop"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "G2OFWDgQRcBY"
      },
      "outputs": [],
      "source": [
        "## to check those parameters we can use\n",
        "# list(model_0.parameters())\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mt_6oxXJQo-F",
        "outputId": "35dbed1b-ee96-4e12-dd9d-3366a19094ee"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ],
      "source": [
        "# Check out our model's parameters (a paramter is the value that the model sets itself)\n",
        "## for named parameter we need to use\n",
        "model_0.state_dict()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6VpzOW2FLfO-"
      },
      "outputs": [],
      "source": [
        "## Steup the loss function\n",
        "loss_fn = nn.L1Loss()       # <- measurse the how wrong our model is\n",
        "\n",
        "## Setup an optimizer\n",
        "# optimizer <- adjusts the model parameter to reduce the loss\n",
        "optimizer = torch.optim.SGD(params=model_0.parameters(),\n",
        "                            lr=0.01)       # lr = learning rate (most important  hyperparameter that we can set)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6u70OzoI_guv"
      },
      "source": [
        "**Q**: Which loss function and optimizer should I use ? <br>\n",
        "**A**: The answer of this question is problem specific. <br>\n",
        "  For example: for a regression problem(like ours), a loss function of `nn.L1Loss()` and an optimizer like `torch.optim.SGD()` will suffice\n",
        "\n",
        "\n",
        "But for a classification problem like classifying whether a photo is of a cat or a dog, loss functions of `nn.BCELoss()`(binary cross entropy loss) is likely to be used."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8iZxuGYpBtga"
      },
      "source": [
        "---\n",
        "\n",
        "### 3.2 **Building a training loop (and a testing loop) in PyTorch**\n",
        "\n",
        "A couple of things we need in a training loop:\n",
        "0. Loop through the data and do...\n",
        "1. Forward pass (this involves data moving through our model's `forward()` methods ) to make predictions on data - also called `forward propagtion`\n",
        "2. Calculate the loss (compare forward pass prediction to ground truth labels)\n",
        "3. Optimize the zero grad\n",
        "4. Loss backward - move backward through the network to calculate the gradients of each of the parameters of our model with respect to the loss (**backpropagation**)\n",
        "5. Optimize step - use the optimizer to adjust our model's parameters to try and improve the loss (**gradient descent**)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DzdARtD0Zl3x"
      },
      "outputs": [],
      "source": [
        "list(model_0.eval().parameters())\n",
        "\n",
        "with torch.no_grad():\n",
        "  list(model_0.parameters())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "f_JDdQ16YvOZ",
        "outputId": "12ec558f-eace-41f8-e0b9-45d1d11008af"
      },
      "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": 21
        }
      ],
      "source": [
        "list(model_0.parameters())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I23tCd8LO6mY",
        "outputId": "94f76d72-7134-408b-ee2e-9a40d71fa869"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch : 0 | Loss : 0.31288138031959534 | Test Loss: 0.48106518387794495\n",
            "\t parameters: OrderedDict([('weights', tensor([0.3406])), ('bias', tensor([0.1388]))])\n",
            "\n",
            "\n",
            "Epoch : 10 | Loss : 0.1976713240146637 | Test Loss: 0.3463551998138428\n",
            "\t parameters: OrderedDict([('weights', tensor([0.3796])), ('bias', tensor([0.2388]))])\n",
            "\n",
            "\n",
            "Epoch : 20 | Loss : 0.08908725529909134 | Test Loss: 0.21729660034179688\n",
            "\t parameters: OrderedDict([('weights', tensor([0.4184])), ('bias', tensor([0.3333]))])\n",
            "\n",
            "\n",
            "Epoch : 30 | Loss : 0.053148526698350906 | Test Loss: 0.14464017748832703\n",
            "\t parameters: OrderedDict([('weights', tensor([0.4512])), ('bias', tensor([0.3768]))])\n",
            "\n",
            "\n",
            "Epoch : 40 | Loss : 0.04543796554207802 | Test Loss: 0.11360953003168106\n",
            "\t parameters: OrderedDict([('weights', tensor([0.4748])), ('bias', tensor([0.3868]))])\n",
            "\n",
            "\n",
            "Epoch : 50 | Loss : 0.04167863354086876 | Test Loss: 0.09919948130846024\n",
            "\t parameters: OrderedDict([('weights', tensor([0.4938])), ('bias', tensor([0.3843]))])\n",
            "\n",
            "\n",
            "Epoch : 60 | Loss : 0.03818932920694351 | Test Loss: 0.08886633068323135\n",
            "\t parameters: OrderedDict([('weights', tensor([0.5116])), ('bias', tensor([0.3788]))])\n",
            "\n",
            "\n",
            "Epoch : 70 | Loss : 0.03476089984178543 | Test Loss: 0.0805937647819519\n",
            "\t parameters: OrderedDict([('weights', tensor([0.5288])), ('bias', tensor([0.3718]))])\n",
            "\n",
            "\n",
            "Epoch : 80 | Loss : 0.03132382780313492 | Test Loss: 0.07232122868299484\n",
            "\t parameters: OrderedDict([('weights', tensor([0.5459])), ('bias', tensor([0.3648]))])\n",
            "\n",
            "\n",
            "Epoch : 90 | Loss : 0.02788739837706089 | Test Loss: 0.06473556160926819\n",
            "\t parameters: OrderedDict([('weights', tensor([0.5629])), ('bias', tensor([0.3573]))])\n",
            "\n",
            "\n",
            "Epoch : 100 | Loss : 0.024458957836031914 | Test Loss: 0.05646304413676262\n",
            "\t parameters: OrderedDict([('weights', tensor([0.5800])), ('bias', tensor([0.3503]))])\n",
            "\n",
            "\n",
            "Epoch : 110 | Loss : 0.021020207554101944 | Test Loss: 0.04819049686193466\n",
            "\t parameters: OrderedDict([('weights', tensor([0.5972])), ('bias', tensor([0.3433]))])\n",
            "\n",
            "\n",
            "Epoch : 120 | Loss : 0.01758546568453312 | Test Loss: 0.04060482233762741\n",
            "\t parameters: OrderedDict([('weights', tensor([0.6141])), ('bias', tensor([0.3358]))])\n",
            "\n",
            "\n",
            "Epoch : 130 | Loss : 0.014155393466353416 | Test Loss: 0.03233227878808975\n",
            "\t parameters: OrderedDict([('weights', tensor([0.6313])), ('bias', tensor([0.3288]))])\n",
            "\n",
            "\n",
            "Epoch : 140 | Loss : 0.010716589167714119 | Test Loss: 0.024059748277068138\n",
            "\t parameters: OrderedDict([('weights', tensor([0.6485])), ('bias', tensor([0.3218]))])\n",
            "\n",
            "\n",
            "Epoch : 150 | Loss : 0.0072835334576666355 | Test Loss: 0.016474086791276932\n",
            "\t parameters: OrderedDict([('weights', tensor([0.6654])), ('bias', tensor([0.3143]))])\n",
            "\n",
            "\n",
            "Epoch : 160 | Loss : 0.0038517764769494534 | Test Loss: 0.008201557211577892\n",
            "\t parameters: OrderedDict([('weights', tensor([0.6826])), ('bias', tensor([0.3073]))])\n",
            "\n",
            "\n",
            "Epoch : 170 | Loss : 0.008932482451200485 | Test Loss: 0.005023092031478882\n",
            "\t parameters: OrderedDict([('weights', tensor([0.6951])), ('bias', tensor([0.2993]))])\n",
            "\n",
            "\n",
            "Epoch : 180 | Loss : 0.008932482451200485 | Test Loss: 0.005023092031478882\n",
            "\t parameters: OrderedDict([('weights', tensor([0.6951])), ('bias', tensor([0.2993]))])\n",
            "\n",
            "\n",
            "Epoch : 190 | Loss : 0.008932482451200485 | Test Loss: 0.005023092031478882\n",
            "\t parameters: OrderedDict([('weights', tensor([0.6951])), ('bias', tensor([0.2993]))])\n",
            "\n",
            "\n"
          ]
        }
      ],
      "source": [
        "RANDOM_SEED = 42\n",
        "torch.manual_seed(RANDOM_SEED)\n",
        "# an epoch is one loop through the data... (this is a hyperparameter because we set it ourselves)\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 training mode\n",
        "  model_0.train()     # train mode in PyTorch sets all the 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 (MAE)\n",
        "  loss = loss_fn(y_pred,  y_train)\n",
        "  # print(f\"\\tLoss: {loss}\")\n",
        "\n",
        "  # 3. Optimizer zero grad\n",
        "  optimizer.zero_grad()\n",
        "\n",
        "  # 4. Perform the 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 loop so... we have to zero them above in step 3 for the next iteration of the loop\n",
        "\n",
        "\n",
        "  # Testing\n",
        "  model_0.eval()      # turns off different settings in the model not needed for evaluation/testing (dropout/batch norm layers)\n",
        "  with torch.inference_mode():    # turns of the gradient tracking & a couple more things behind the scenes\n",
        "  # with torch.no_grad():       # <- this is seen in the older version of 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",
        "\n",
        "  # prints 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(f\"\\t parameters: {model_0.state_dict()}\")\n",
        "    print(\"\\n\")\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "zYkr1-217dJx"
      },
      "outputs": [],
      "source": [
        "# epoch_count, loss_values, test_loss_values"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "9zDRL5068UvY"
      },
      "outputs": [],
      "source": [
        "# import numpy as np\n",
        "# np.array(torch.tensor(loss_values).cpu().numpy()), test_loss_values"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "6Gq3ogYoA9P6"
      },
      "outputs": [],
      "source": [
        "# import numpy as np\n",
        "# torch.tensor(loss_values).detach(), test_loss_values\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 490
        },
        "id": "cYrh_l7t7bjp",
        "outputId": "84d4d24b-5103-4fa7-a66f-760a5817e110"
      },
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7b540ce8b190>"
            ]
          },
          "metadata": {},
          "execution_count": 26
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "# Plot the loss curves\n",
        "\n",
        "plt.plot(epoch_count, torch.tensor(loss_values).numpy(), label=\"Train Loss\")   # <- here manual conversion to numpy is required because the value of the list contians `grad_fn`\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()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "pDmwl1qn7Lw1"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "c7IhsEEUbJzg"
      },
      "outputs": [],
      "source": [
        "with torch.inference_mode():\n",
        "  y_preds_new = model_0(X_test)\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "N8xbeog-qABz",
        "outputId": "eebdb451-3fce-4901-f189-f84afb09c0e5"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plot_predictions(predictions=y_preds)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "7FgPhaG_rGot",
        "outputId": "6426cdce-84da-4b6d-a408-0f69fe0e4b0e"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "plot_predictions(predictions=y_preds_new)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7iOnjLThHYZv"
      },
      "source": [
        "## Saving a model in PyTorch\n",
        "\n",
        "\n",
        "There are three main methods 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 your to load a saved PyTorch object\n",
        "3. `toch.nn.Module.load_state_dict()` - this allows to load a model's saved state dictionary\n",
        "\n",
        "\n",
        "\n",
        "PyTorch save & Load code tutorial + extra-curricular https://pytorch.org/tutorials/beginner/saving_loading_models.html"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tKxU-OgqrNjF",
        "outputId": "35d4553d-fdcb-4f1f-a97b-ae0daa722f24"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving model to: models/01_python_workflow_model_0.pth\n"
          ]
        }
      ],
      "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",
        "\n",
        "# 2. Create a model save path\n",
        "MODEL_NAME = \"01_python_workflow_model_0.pth\"\n",
        "MODEL_SAVE_PATH = MODEL_PATH/MODEL_NAME\n",
        "MODEL_SAVE_PATH\n",
        "\n",
        "\n",
        "\n",
        "# 2. Save the model state dict\n",
        "print(f\"Saving model to: {MODEL_SAVE_PATH}\")\n",
        "\n",
        "torch.save(obj=model_0.state_dict(),\n",
        "           f=MODEL_SAVE_PATH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IlDLqo7sIFwy",
        "outputId": "8021b155-a812-4655-85f3-21f9592c18a2"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "total 4\n",
            "-rw-r--r-- 1 root root 1674 Dec 20 23:32 01_python_workflow_model_0.pth\n"
          ]
        }
      ],
      "source": [
        "! ls -l models"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "34PzKwJNX-JG"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Zm3za036ZHA3"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RN3JH-6ZZHWN",
        "outputId": "3d2e17d1-81a0-4851-d548-d7f84f24ced8"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model's state_dict:\n",
            "conv1.weight \t torch.Size([6, 3, 5, 5])\n",
            "conv1.bias \t torch.Size([6])\n",
            "conv2.weight \t torch.Size([16, 6, 5, 5])\n",
            "conv2.bias \t torch.Size([16])\n",
            "fc1.weight \t torch.Size([120, 400])\n",
            "fc1.bias \t torch.Size([120])\n",
            "fc2.weight \t torch.Size([84, 120])\n",
            "fc2.bias \t torch.Size([84])\n",
            "fc3.weight \t torch.Size([10, 84])\n",
            "fc3.bias \t torch.Size([10])\n",
            "Optimizer's state_dict:\n",
            "state \t {}\n",
            "param_groups \t [{'lr': 0.001, 'momentum': 0.9, 'dampening': 0, 'weight_decay': 0, 'nesterov': False, 'maximize': False, 'foreach': None, 'differentiable': False, 'params': [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]}]\n"
          ]
        }
      ],
      "source": [
        "class TheModelClass(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(TheModelClass, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(3, 6, 5)\n",
        "        self.pool = nn.MaxPool2d(2, 2)\n",
        "        self.conv2 = nn.Conv2d(6, 16, 5)\n",
        "        self.fc1 = nn.Linear(16 * 5 * 5, 120)\n",
        "        self.fc2 = nn.Linear(120, 84)\n",
        "        self.fc3 = nn.Linear(84, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = self.pool(F.relu(self.conv1(x)))\n",
        "        x = self.pool(F.relu(self.conv2(x)))\n",
        "        x = x.view(-1, 16 * 5 * 5)\n",
        "        x = F.relu(self.fc1(x))\n",
        "        x = F.relu(self.fc2(x))\n",
        "        x = self.fc3(x)\n",
        "        return x\n",
        "\n",
        "# Initialize model\n",
        "model = TheModelClass()\n",
        "\n",
        "# Initialize optimizer\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
        "\n",
        "# Print model's state_dict\n",
        "print(\"Model's state_dict:\")\n",
        "for param_tensor in model.state_dict():\n",
        "    print(param_tensor, \"\\t\", model.state_dict()[param_tensor].size())\n",
        "\n",
        "# Print optimizer's state_dict\n",
        "print(\"Optimizer's state_dict:\")\n",
        "for var_name in optimizer.state_dict():\n",
        "    print(var_name, \"\\t\", optimizer.state_dict()[var_name])\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "4uuaH0XYZLf0"
      },
      "outputs": [],
      "source": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Loading a PyTorch model\n",
        "\n",
        "Since we saved our model's `state_dict()` rather than entire model, we'll create a new instance of our model class and load the saved `state_dict` into newly created instance"
      ],
      "metadata": {
        "id": "EghElWhM0-yt"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# to load a saved state_dict() we have to instantiate a new instace of our model class\n",
        "loaded_model_0 = LinearRegressionModel()\n",
        "\n",
        "\n",
        "# Load the saved staite_dict of the model_0 (this will update 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": "dWyZHWUo1VuC",
        "outputId": "981081fd-db1d-46da-8f5f-5492d0f85981"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loaded_model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_PW175LS16tU",
        "outputId": "7f239abe-7f8a-4f68-8cdf-9257751a3c23"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loaded_model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "94KXD6h81-xJ",
        "outputId": "ccb33df4-d829-4dfd-a8cb-796fa2016fab"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make some prediction with our loaded model to make sure it is the correct one\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": "6fyeJzj32bgC",
        "outputId": "150b874b-5ae4-422f-c153-70a40f4aaccb"
      },
      "execution_count": null,
      "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": 36
        }
      ]
    },
    {
      "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": "fpOTf44F3dIl",
        "outputId": "c1b24bf8-2b10-494c-8fed-470f9ee6ee78"
      },
      "execution_count": null,
      "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": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Compare loaded model preds with original model preds\n",
        "y_preds == loaded_model_preds\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "hX91rtyQ20A5",
        "outputId": "11c6dd62-71e8-43f9-e938-f4fdbd4587df"
      },
      "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": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "HVxs7RLx3I4L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "MuGAZJ0m3zVV"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 6. Putting it together\n",
        "\n",
        "Let's go back through the steps above and see it all in one place."
      ],
      "metadata": {
        "id": "xegb1PQS460T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import PyTorch and Matplotlib\n",
        "import torch\n",
        "from torch import nn\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# check the PyTorch version"
      ],
      "metadata": {
        "id": "k6Bxpg0u5V4u"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create a device-agnostic code  \n",
        "\n",
        "This means if we got access to 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": "Jz_m_NnW52xb"
      }
    },
    {
      "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": "bNt8tpKC6LBA",
        "outputId": "2d886b6e-ea3a-4363-b924-95a8d8254a64"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using device: cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!nvidia-smi         # to check the specs of the provided GPU"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ycfI2xUd6wmq",
        "outputId": "de50ed47-8083-4c7d-d7f7-66245dc60117"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/bin/bash: line 1: nvidia-smi: command not found\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.1 Data\n",
        "\n"
      ],
      "metadata": {
        "id": "0WfRlBER5GnI"
      }
    },
    {
      "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",
        "\n",
        "# Create range values\n",
        "\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) # this will reduce the dimension of the data to 1 dimension\n",
        "# without unsqueeze, errors will pop up\n",
        "y = weight * X + bias\n",
        "X[:10], y[:10]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_oL51GuZ3zPi",
        "outputId": "4a7322aa-6224-4d77-8b4b-6e38901e4d8e"
      },
      "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": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# split the 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",
        "\n",
        "len(X_train), len(y_train), len(X_test), len(y_test)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0DfP4dUa3ytl",
        "outputId": "0eb519d6-0ff5-477b-b841-ddcf53a83c73"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(40, 40, 10, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot the data\n",
        "plot_predictions(X_train, y_train, X_test, y_test)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "LRdxnYuGA3xF",
        "outputId": "5d7f9419-c892-4f9c-f58f-0d095fe4bcb6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.2 Building a PyTorch Linear Model\n",
        "\n"
      ],
      "metadata": {
        "id": "MdKt8-33EOfZ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# create a linear model by subclassing `nn.Module`\n",
        "import torch\n",
        "from torch import nn\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "class LinearRegressionModelv2(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "\n",
        "    # often time you don't need to initialize the parameter yourself\n",
        "    # you will instead initialize the layers that have the parameters in-built in those layer\n",
        "\n",
        "    # Use `nn.Linear()` for creating the parameters for the Linear Model / alos called linear tranfor, probing layer, fully connected layer, dense layer\n",
        "    # this means we take one feature of `X_train` to output the one feature of `y_train`\n",
        "    self.linear_layer = nn.Linear(in_features=1,      # <- this means the we take input of size 1\n",
        "                                 out_features=1)    # <- this means the output will if size 1\n",
        "\n",
        "\n",
        "  \"\"\" input x should always be `torch.Tensor` and return type of the method will be\n",
        "  `torch.Tensor` \"\"\"\n",
        "  def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
        "    return self.linear_layer(x)\n",
        "\n",
        "\n",
        "# set the manual seed\n",
        "torch.manual_seed(42)\n",
        "model_1 = LinearRegressionModelv2()\n",
        "model_1, model_1.state_dict()\n"
      ],
      "metadata": {
        "id": "kbRuuNFOBHwo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "431f913c-23aa-4587-97f4-103b4b549aad"
      },
      "execution_count": null,
      "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": 45
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Check the model current device\n",
        "next(model_1.parameters()).device"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RVbdpfO-9rHB",
        "outputId": "bd7e9c4e-7b29-44b2-ce1b-91d55f861a08"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cpu')"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "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": "I4CkXaty7FX-",
        "outputId": "d57e3ddc-121d-4eb8-ad8a-1da12876943c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cpu')"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [],
      "metadata": {
        "id": "fnU3-7Rl66H0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "X_train[:5], y_train[:5]"
      ],
      "metadata": {
        "id": "xWfo7pYgFKQv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f3c0d385-66fa-4a97-d8fa-2a07e9234604"
      },
      "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",
              " tensor([[0.3000],\n",
              "         [0.3140],\n",
              "         [0.3280],\n",
              "         [0.3420],\n",
              "         [0.3560]]))"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.3 Training part\n",
        "\n",
        "For training we need\n",
        "* Loss function   - measures how wrong our model is\n",
        "* Optimizer       - adjusts the parameter values so that there is lesser loss value\n",
        "* Training loop\n",
        "* Testing loop"
      ],
      "metadata": {
        "id": "bzN4VFDX-F_A"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup the loss function\n",
        "loss_fn = nn.L1Loss()     # same as MAE(Mean Absolute Error)\n",
        "\n",
        "\n",
        "# Setup our optimizer\n",
        "optimizer = torch.optim.SGD( params=model_1.parameters(), lr=0.01)   # Stochastic Gradient Descent\n"
      ],
      "metadata": {
        "id": "O1TrBepzTUFz"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# Training loop\n",
        "\n",
        "torch.manual_seed(42)\n",
        "\n",
        "epochs = 200\n",
        "\n",
        "\n",
        "# Put the 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",
        "\n",
        "\n",
        "for epoch in range(epochs):\n",
        "  model_1.train()\n",
        "\n",
        "\n",
        "  # 1. forward pass                   # <- this is where we calculate the predictions\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\n",
        "  optimizer.zero_grad()\n",
        "\n",
        "\n",
        "  # 4. backpropagation\n",
        "  loss.backward()\n",
        "\n",
        "  # 5. Optimizer step\n",
        "  optimizer.step()\n",
        "\n",
        "  ### Testing\n",
        "\n",
        "  model_1.eval()      # <- for testing we set the model into evaluation model\n",
        "       # this turn off things like Dropout, BatchNorm etc\n",
        "  with torch.inference_mode():    # <- turn off things like autograd (which is used during model training )\n",
        "    test_pred = model_1(X_test)\n",
        "\n",
        "    test_loss = loss_fn(test_pred, y_test)\n",
        "\n",
        "    # Print's out what's happening\n",
        "\n",
        "    if epoch % 10 == 0:\n",
        "      print(f\"Epoch: {epoch} | Loss : {loss} | Test loss; {test_loss}\")\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pydvcH0y_KW9",
        "outputId": "f891ed82-a79e-4fdd-e2d6-39b68d8585d1"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0 | Loss : 0.5551779866218567 | Test loss; 0.5739762187004089\n",
            "Epoch: 10 | Loss : 0.4399680495262146 | Test loss; 0.4392663538455963\n",
            "Epoch: 20 | Loss : 0.3247582018375397 | Test loss; 0.30455657839775085\n",
            "Epoch: 30 | Loss : 0.20954827964305878 | Test loss; 0.16984674334526062\n",
            "Epoch: 40 | Loss : 0.09433844685554504 | Test loss; 0.03513689711689949\n",
            "Epoch: 50 | Loss : 0.023886386305093765 | Test loss; 0.04784906655550003\n",
            "Epoch: 60 | Loss : 0.0199567973613739 | Test loss; 0.04580312222242355\n",
            "Epoch: 70 | Loss : 0.016517987474799156 | Test loss; 0.0375305712223053\n",
            "Epoch: 80 | Loss : 0.013089170679450035 | Test loss; 0.029944902285933495\n",
            "Epoch: 90 | Loss : 0.009653178043663502 | Test loss; 0.02167237363755703\n",
            "Epoch: 100 | Loss : 0.006215679459273815 | Test loss; 0.014086711220443249\n",
            "Epoch: 110 | Loss : 0.002787243574857712 | Test loss; 0.005814164876937866\n",
            "Epoch: 120 | Loss : 0.0012645035749301314 | Test loss; 0.013801807537674904\n",
            "Epoch: 130 | Loss : 0.0012645035749301314 | Test loss; 0.013801807537674904\n",
            "Epoch: 140 | Loss : 0.0012645035749301314 | Test loss; 0.013801807537674904\n",
            "Epoch: 150 | Loss : 0.0012645035749301314 | Test loss; 0.013801807537674904\n",
            "Epoch: 160 | Loss : 0.0012645035749301314 | Test loss; 0.013801807537674904\n",
            "Epoch: 170 | Loss : 0.0012645035749301314 | Test loss; 0.013801807537674904\n",
            "Epoch: 180 | Loss : 0.0012645035749301314 | Test loss; 0.013801807537674904\n",
            "Epoch: 190 | Loss : 0.0012645035749301314 | Test loss; 0.013801807537674904\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_1.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "xcZb6tz6_tYi",
        "outputId": "701516d3-3113-49b3-c180-26a7cdd848f9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('linear_layer.weight', tensor([[0.6968]])),\n",
              "             ('linear_layer.bias', tensor([0.3025]))])"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "weight, bias"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FsnnwSEpCRkd",
        "outputId": "dfd3032b-11ae-4a27-9a1f-6ac8e948b9e3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.7, 0.3)"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "type(y_preds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Lg071BIIC055",
        "outputId": "81bc9cb2-a633-436c-86de-b6a79bac196c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Tensor"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.4 Making and evaluating predictions"
      ],
      "metadata": {
        "id": "kEwcBy4gEb9p"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#  Turn the model into evaluation mode\n",
        "model_1.eval()      # <- every time we are making prediction or inference we want our model to be in eval mode\n",
        "\n",
        "# Make the prediction on the test data = it means drawing inference from the trained model\n",
        "# by providing the test data\n",
        "with torch.inference_mode():\n",
        "  y_preds = model_1(X_test)\n",
        "\n",
        "y_preds\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-8rmzOsRCTFq",
        "outputId": "df510f80-ae3f-45ed-fd0a-02b67fa99c3c"
      },
      "execution_count": null,
      "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]])"
            ]
          },
          "metadata": {},
          "execution_count": 54
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# check out our model predictions visually\n",
        "plot_predictions(predictions=y_preds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "xjuCOsX-CoPo",
        "outputId": "f675aefb-df70-49a4-f334-4bece962e2e6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**NOTE**:\n",
        "\n",
        "- every time when we want to train our model we turn the model into training mode using `model_0.train()`\n",
        "- every time we want to test or plot the graph of the values of prediced model we want to turn the model into `eval` mode using `model_0.eval()`\n",
        "- while drawing the conclusion or inference of the model we turn on the model into inference mode using `inference_mode()`\n"
      ],
      "metadata": {
        "id": "EA8GxKDIE5xF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.5 Saving & loadin a trained model\n"
      ],
      "metadata": {
        "id": "3gu_Td9uGq9s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pathlib import Path\n",
        "\n",
        "# 1. Create directory\n",
        "MODEL_PATH = Path(\"model\")\n",
        "MODEL_PATH.mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "\n",
        "# 2. create a model save path\n",
        "MODEL_NAME = \"01-pytorch_test.pth\"\n",
        "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n",
        "\n",
        "MODEL_SAVE_PATH\n",
        "\n",
        "\n",
        "# 3. Save the model state_dict()\n",
        "print(f\"Saving the state dict of model to: {MODEL_SAVE_PATH}\")\n",
        "\n",
        "torch.save(obj=model_1.state_dict(),\n",
        "           f=MODEL_SAVE_PATH)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6cVfSIbkFjaB",
        "outputId": "bba96817-e1cb-475e-c5ee-119e14271383"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving the state dict of model to: model/01-pytorch_test.pth\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_1.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "SZkAW03HLuNt",
        "outputId": "85f30c88-4fa2-4ebb-d73e-c63986dbf875"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('linear_layer.weight', tensor([[0.6968]])),\n",
              "             ('linear_layer.bias', tensor([0.3025]))])"
            ]
          },
          "metadata": {},
          "execution_count": 57
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Load a PyTorch Model\n"
      ],
      "metadata": {
        "id": "xtM6BwrqNI3T"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# load pytorch model\n",
        "\n",
        "\n",
        "## Create a new instace of linear regression model v2\n",
        "loaded_model_1 = LinearRegressionModelv2()\n",
        "\n",
        "\n",
        "# load the saved model_1 state_dict\n",
        "\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)\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zr8tdQ1kMeFf",
        "outputId": "8e0cb8f3-d619-4e1c-8b50-fb5271ef1119"
      },
      "execution_count": null,
      "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": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "next(loaded_model_1.parameters()).device\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "EsZS-c3JN2Uo",
        "outputId": "523d1239-ec9f-4bc1-f694-9b9a3570795e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "device(type='cpu')"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loaded_model_1.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L5N9fH6SN7jH",
        "outputId": "d333e3f1-02f5-4494-ef5d-69569d30782d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('linear_layer.weight', tensor([[0.6968]])),\n",
              "             ('linear_layer.bias', tensor([0.3025]))])"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "# Evaluate the loaded model\n",
        "loaded_model_1.eval()\n",
        "\n",
        "\n",
        "with torch.inference_mode():\n",
        "  loaded_model_1_preds = loaded_model_1(X_test)\n",
        "\n",
        "y_preds == loaded_model_1_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-mh_uF7VOAHr",
        "outputId": "a7351a2f-e4a2-4ce4-8da9-2a94bafc894e"
      },
      "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": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#  Excercise\n",
        " - https://www.learnpytorch.io/01_pytorch_workflow/#extra-curriculum"
      ],
      "metadata": {
        "id": "Lgg2hpt0RDl0"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "WmcA43G6QrJ6"
      },
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4",
      "authorship_tag": "ABX9TyMTHyJx93J3wNPzrrERMGFX",
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "nbformat": 4,
  "nbformat_minor": 0
}