01_pytorch_workflow_.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyOLasNxYIpXq8nVZ+45Eclh",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/maronem/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",
      "source": [
        "# PyTorch Workflow\n",
        "\n",
        "Let's explore an example PyTorch end-to-end workflow\n",
        "\n",
        "Resources:\n",
        "* Book version of notebook: https://www.learnpytorch.io/01_pytorch_workflow/"
      ],
      "metadata": {
        "id": "EabV80vPBGQK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "what_were_covering = {1: \"data (prepare and load)\",\n",
        "                      2: \"build model\",\n",
        "                      3: \"fitting the model to the data (training)\",\n",
        "                      4: \"making predictions and evaluate a model (inference)\",\n",
        "                      5: \"save and loading a model\",\n",
        "                      6: \"putting it all together\"}\n",
        "\n",
        "what_were_covering"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "TFNbqKkQCJTM",
        "outputId": "027a32a0-2747-4db4-aa38-6331f7480b5b"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{1: 'data (prepare and load)',\n",
              " 2: 'build model',\n",
              " 3: 'fitting the model to the data (training)',\n",
              " 4: 'making predictions and evaluate a model (inference)',\n",
              " 5: 'save and loading a model',\n",
              " 6: 'putting it all together'}"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "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": 35
        },
        "id": "09Y8OKeNC07f",
        "outputId": "b12543f7-4d46-40e0-b3fe-dadd2a55c855"
      },
      "execution_count": 29,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'1.13.1+cu116'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 1. Data (preparing and loading)\n",
        "\n",
        "Machine learning 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 representation\n",
        "\n",
        "Lets 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": "093A_K70DTtJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create *known* parameters\n",
        "\n",
        "weight = 0.7 \n",
        "bias = 0.3\n",
        "\n",
        "# Create some data\n",
        "\n",
        "start = 0\n",
        "end = 1\n",
        "step = 0.02\n",
        "\n",
        "X = torch.arange(start, end, step=step).unsqueeze(dim=1)\n",
        "y = weight * X + bias\n",
        "\n",
        "X[:10], y[:10]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "tQaecHTPDgQi",
        "outputId": "4262829d-fafb-4120-8439-2eff5f0912dd"
      },
      "execution_count": 30,
      "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]]), 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": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plt.scatter(X,y)\n",
        "plt.ylabel(\"y-values\")\n",
        "plt.xlabel(\"X-values\")\n",
        "plt.title(\"Linear Regression Data\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 312
        },
        "id": "DinBB8C98RqU",
        "outputId": "078357ec-1e89-4a3e-9934-b109fc04c115"
      },
      "execution_count": 31,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "Text(0.5, 1.0, 'Linear Regression Data')"
            ]
          },
          "metadata": {},
          "execution_count": 31
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAfKElEQVR4nO3dfZgcZZ3u8e9tAAXl1UQXQwJBA4igoiPocXdFQQ3oAoKHDb4dvFyjrnFRkd1w5FIW3xB8X1EJiuC6CohuNqsco0dAPCxoJkaBBKMxgmTAJSABVNRE7/NH1UBn6J7peanu6a77c11z0VX1dNXvmQn163p+/VTJNhERUV+P6HYAERHRXUkEERE1l0QQEVFzSQQRETWXRBARUXNJBBERNZdEEFNK0l9JWtftOPqBpDWSDu92HNH/kghiQiTdIunIkettf8/2/t2IaSRJZ0raIuk3kjZL+i9Jz+l2XO2y/RTbV0/1fiVdLen3ku6XdJ+kVZKWSHrkOPZhSU+a6tiiO5IIoi9I2q7FpkttPwaYCVwFfKWCY0tSr/2/tNj2zsCewKnAQuAKSepuWNENvfaPN6Y5SYdL2tiwfIukd0i6QdK9ki6V9KiG7S+V9KOGT+xPbdi2RNLPy0+uayW9rGHbyZKulfRRSXcDZ44Wl+2twL8BsyXNKvexq6TPSbpD0pCk90qaUW6bIenDku6S9AtJi8tPwduV26+W9D5J1wK/A/aVdICkb0v6taR1kk5siPfosg/3l8d6R7l+pqSvl/3/taTvDSeVxqsuSY+U9DFJt5c/Hxv+BD/8O5d0qqQ7y/68tp2/l+3fllcdxwDPAV5S7vNQSdeVcd0h6ZOSdii3XVO+/cfl1dbfStq97McmSfeUr/dqJ4boviSC6IQTgQXAPOCpwMkAkg4BLgTeADwWOB9Y3jBE8XPgr4BdgX8Gvihpz4b9HgZsAB4PvG+0AMqT2GuAu4F7ytUXAVuBJwGHAC8C/q7c9nrgKODpwDOA45rs9tXAImBnYBPwbeBLwOMoPmF/StKBZdvPAW8oP4UfBFxZrj8V2AjMKvvxv4Fm9315J/DsMp6nAYcCZzRs/wuK39Ns4HXAeZJ2H+130sj2L4FBit83wJ+At1FcST0HOAL4+7LtX5dtnmb7MbYvpTiXfB7YG5gLPAB8st3jR3clEUQnfML27bZ/DfwnxckMipPo+ba/b/tPti8G/kBxwsP2V8r3/bk82fyM4gQ47Hbb/2J7q+0HWhz7REmbKU5MrwdebnurpMcDRwNvLT8V3wl8lOIEDkXy+rjtjbbvAc5usu+LbK8przYWALfY/nwZz2rgq8D/LNtuAQ6UtIvte2z/sGH9nsDetreUNZZmieCVwFm277S9iSIxvrph+5Zy+xbbVwC/AcZbq7kd2APA9irb15d9uYUiST+v1Rtt3237q7Z/Z/t+isTcsn1ML0kE0Qm/anj9O+Ax5eu9gVPL4YfN5Ql7DvAEAEmvaRg22kzxSXpmw75ua+PYl9nejeLT9k3AMxuOvT1wR8P+z6f4NE8ZQ+P+mx2rcd3ewGEj+vJKik/qACdQJJ5bJX23oWh9LrAe+JakDZKWtOjHE4BbG5ZvLdcNu7tMSMMaf8/tmg38GkDSfuXwzq8k3Qe8n21/99uQtJOk8yXdWra/BthteKgtprckguim24D32d6t4Wcn21+WtDdwAbAYeGx5Mr8JaCxmtn3rXNt3UVyBnFkOL91GcfUxs+HYu9h+SvmWO4DGMe45zXY7oi/fHdGXx9h+U3n8lbaPpUg0y4DLyvX32z7V9r4U4/Rvl3REk2PdTpFshs0t100JSXMokuT3ylWfBn4CzLe9C8WQ1WiF5FMprkAOK9sPDx+l+NwDkghiMraX9KiGn1bf3GnlAuCNkg5T4dGSXiJpZ+DRFCfaTQBl8fOgyQRrex2wAvhH23cA3wI+LGkXSY+Q9ERJw8MZlwGnSJotaTfgn8bY/deB/SS9WtL25c+zJD1Z0g6SXilpV9tbgPuAP5f9eqmkJ0kScC/F2Pyfm+z/y8AZkmZJmgm8C/jiZH4f5fF3Kvv8H8APgCvKTTuXcf5G0gHAm0a89b+BfRuWd6YYftssaQ/g3ZONLToniSAm4wqK//mHf84cz5ttD1KM23+SooC7nrKQbHst8GHgOoqTzsHAtVMQ87nAIkmPoyge7wCsLY9/OcV4PRRJ6lvADcBqir5upThRN+vL/RTF5oUUn9R/BXwQGC58vxq4pRw2eSPFsBHAfOD/UozpXwd8yvZVTQ7xXopi7g3AjcAPy3UT9UlJ91P8bj9GUc9YYHs4Cb0DeAVwP8Xv4tIR7z8TuLgcBjux3MeOwF3A9cA3JxFbdJjyYJqIsUk6CviM7b3HbBzRY3JFENGEpB3L7/5vJ2k2xVDHv3c7rogq5IogoglJOwHfBQ6gGPb6BnCK7fu6GlhEBZIIIiJqLkNDERE1N96v+3XdzJkzvc8++3Q7jIiInrJq1aq7bM9qtq3nEsE+++zD4OBgt8OIiOgpkm5ttS1DQxERNVdZIpB0YXlL3JtabJekT0har+IWxc+oKpaIiGityiuCiyjuyNjKURSzKudT3APm0xXGEhERLVSWCGxfQ3knwxaOBb7gwvUUdyrcc5T2ERFRgW7WCGaz7W18N5brHkbSIkmDkgY3bdrUkeAiIuqiJ741ZHspsBRgYGAgM+AiolaWrR7i3BXruH3zAzxhtx057cX7c9whTT83T0g3E8EQ297jfa9yXURElJatHuL0r93IA1uKG98ObX6A0792I8CUJYNuDg0tB15Tfnvo2cC95T3iIyKidO6KdQ8mgWEPbPkT565YN2XHqOyKQNKXgcOBmZI2Uty9cXsA25+huL/70RT3oP8d8NqqYomI6FW3b27+OO5W6yeiskRg+6Qxtht4c1XHj4joJa3qAE/YbUeGmpz0n7DbjlN27MwsjojosuE6wNDmBzAP1QGWrR7itBfvz47bz9im/Y7bz+C0F+8/ZcdPIoiI6LLR6gDHHTKbDxx/MLN32xEBs3fbkQ8cf3DffGsoIiIYuw5w3CGzp/TEP1ISQUREBzWrBXSiDjCaDA1FRHRIq1rA8w+YVXkdYDRJBBERHdKqFnDVTzZVXgcYTYaGIiI6ZLRaQNV1gNEkEUREVGA61gJaydBQRMQUm661gFaSCCIipth0rQW0kqGhiIgpNl1rAa0kEURETEIv1QJaydBQRMQE9VotoJUkgoiICeq1WkArGRqKiJigXqsFtJJEEBHRhn6oBbSSoaGIiDH0Sy2glSSCiIgx9EstoJUMDUVEjKFfagGtJBFERJS6+dzgbqp0aEjSAknrJK2XtKTJ9r0lfUfSDZKulrRXlfFERLTS7ecGd1NliUDSDOA84CjgQOAkSQeOaPYh4Au2nwqcBXygqngiIkbT7ecGd1OVQ0OHAuttbwCQdAlwLLC2oc2BwNvL11cByyqMJyKipW4/N7ibqkwEs4HbGpY3AoeNaPNj4Hjg48DLgJ0lPdb23Y2NJC0CFgHMnTu3soAjoh76eU7ARHT766PvAJ4naTXwPGAI+NPIRraX2h6wPTBr1qxOxxgRfaTf5wRMRJWJYAiY07C8V7nuQbZvt3287UOAd5brNlcYU0TUXL/PCZiIKoeGVgLzJc2jSAALgVc0NpA0E/i17T8DpwMXVhhPRETfzwmYiMquCGxvBRYDK4Cbgctsr5F0lqRjymaHA+sk/RR4PPC+quKJiIDWY/51qAW0ItvdjmFcBgYGPDg42O0wIqIHNCsKA5z+tRu3GR7acfsZfT8MJGmV7YFm27pdLI6IqESrojBQ21pAK7nFRET0pdEmiF275AW1PvGPlCuCiOhLY00Qi4fkiiAiel4miE1OrggioqdlgtjkJRFERE/LBLHJy9BQRPS0TBCbvCSCiOgZqQVUI0NDEdETUguoThJBRPSE1AKqk6GhiOgJqQVUJ4kgIqaVuj5AvpsyNBQR00adHyDfTUkEETFt1PkB8t2UoaGImDbq/AD5bkoiiIiuyJyA6SNDQxHRcZkTML0kEUREx2VOwPSSoaGI6LjMCZhekggiolKpBUx/lQ4NSVogaZ2k9ZKWNNk+V9JVklZLukHS0VXGExGdlVpAb6gsEUiaAZwHHAUcCJwk6cARzc4ALrN9CLAQ+FRV8URE56UW0BuqHBo6FFhvewOApEuAY4G1DW0M7FK+3hW4vcJ4IqLDUgvoDVUmgtnAbQ3LG4HDRrQ5E/iWpLcAjwaObLYjSYuARQBz586d8kAjYvJSC+hd3f766EnARbb3Ao4G/lXSw2KyvdT2gO2BWbNmdTzIiBhdagG9rcpEMATMaVjeq1zX6HXAZQC2rwMeBcysMKaIqEBqAb2tyqGhlcB8SfMoEsBC4BUj2vwSOAK4SNKTKRLBpgpjiogKpBbQ2ypLBLa3SloMrABmABfaXiPpLGDQ9nLgVOACSW+jKByfbNtVxRQRk5NnBfQn9dp5d2BgwIODg90OI6J2husAjUNAO24/gw8cfzBAy225GpgeJK2yPdBsW7eLxRHRI/KsgP6VW0xERFvyrID+lUQQEQ+TOQH1kqGhiNhG5gTUTxJBRGwjcwLqJ0NDEbGNzAmonySCiBpLLSAgQ0MRtZVaQAxLIoioqdQCYliGhiJqKrWAGJZEEFEDqQXEaDI0FNHnUguIsSQRRPS51AJiLBkaiuhzqQXEWJIIIvpIagExERkaiugTqQXERCURRPSJ1AJiojI0FNEnUguIiUoiiOgxeW5wTLVKh4YkLZC0TtJ6SUuabP+opB+VPz+VtLnKeCJ6Xas6wLLVQ5z24v1TC4gJqeyKQNIM4DzghcBGYKWk5bbXDrex/baG9m8BDqkqnoh+MNpzg69d8oIH24y8WogYzbgSgaTdgTm2b2ij+aHAetsbyvdeAhwLrG3R/iTg3eOJJ6Ju8tzgqMKYiUDS1cAxZdtVwJ2SrrX99jHeOhu4rWF5I3BYi2PsDcwDrmwj5ohayJyA6JR2agS72r4POB74gu3DgCOnOI6FwOW2/9Rso6RFkgYlDW7atGmKDx0x/WROQHRSO4lgO0l7AicCXx/HvoeAOQ3Le5XrmlkIfLnVjmwvtT1ge2DWrFnjCCGiN2VOQHRSOzWCs4AVwLW2V0raF/hZG+9bCcyXNI8iASwEXjGykaQDgN2B69qOOqLPZU5AdNKYicD2V4CvNCxvAE5o431bJS2mSCIzgAttr5F0FjBoe3nZdCFwiW1PpAMRvS61gOg2jXX+lbQf8Gng8bYPkvRU4Bjb7+1EgCMNDAx4cHCwG4eOmHLDtYDGYaAdt5/BCc+czVdXDT1sfYaBYqIkrbI90GxbOzWCC4DTgS0A5VdHF05deBH1lVpATAft1Ah2sv0DSY3rtlYUT0StpBYQ00E7ieAuSU8EDCDp5cAdlUYV0YdSC4jpqp2hoTcD5wMHSBoC3gq8qdKoIvpM5gXEdDZmIrC9wfaRwCzgANt/afuWyiOL6COpBcR01s4tJt41YhkA22dVFFNE30ktIKazdmoEv214/SjgpcDN1YQT0ftSC4he086Esg83Lkv6EMUksYgYYeS8gOFaQKt5AakFxHQwkQfT7ERx36CIGCG1gOhF7dQIbqT86ijFrSJmUdx/KCJGSC0gelE7NYKXNrzeCvy37Uwoi1rLc4Ojn7QcGpK0h6Q9gPsbfh4AdinXR9RSnhsc/Wa0K4JVFENCarLNwL6VRBQxzeW5wdFvWiYC2/M6GUhEr8hzg6PftPXw+vKh9fMp5hEAYPuaqoKKmC4yJyDqYMyvj0r6O+AairkD/1z+98xqw4rovtwfKOqinXkEpwDPAm61/XzgEGBzpVFFTAOZExB10c7Q0O9t/14Skh5p+yeS8tEn+l7mBERdtJMINkraDVgGfFvSPcCt1YYV0VmpBUSdtXOvoZeVL8+UdBWwK/DNSqOK6KDcHyjqrp1i8Sck/Q8A29+1vdz2H9vZuaQFktZJWi9pSYs2J0paK2mNpC+NL/yIyUstIOqunaGhVcAZZV3g34FLbA+O9SZJM4DzgBcCG4GVkpbbXtvQZj5wOvBc2/dIetxEOhExGakFRN21MzR0MXBxeVuJE4APSppre/4Ybz0UWG97A4CkS4BjgbUNbV4PnGf7nvJYd06gDxFtSy0g4uHGcxvqJwEHAHsDP2mj/WzgtobljeW6RvsB+0m6VtL1khY025GkRZIGJQ1u2rRpHCFHPCTzAiKaa6dGcI6kn1HcevomYMD230zR8bejmLF8OHAScEH5DaVt2F5qe8D2wKxZs6bo0FE3qQVENNdOjeDnwHNs3zXOfQ8BcxqW9yrXNdoIfN/2FuAXkn5KkRhWjvNYEWNKLSCiuXZqBOcPv5b0ddsvHa19g5XAfEnzKBLAQuAVI9oso7gS+LykmRRDRRva3H9ES6kFRLRvvI+qbPsjU/nwmsUU9ya6GbjM9hpJZ0k6pmy2Arhb0lrgKuA023ePM6aIbaQWEDE+7dQI3tIwbr96PDu3fYXt/Ww/0fb7ynXvsr28fG3bb7d9oO2DbV8y7h5EjJBaQMT4tFMjeDwwKOmHwIWSZNtjvSmiW1ILiBifMa8IbJ9BUcD9HHAy8DNJ75f0xIpjixjVstVDPPfsK5m35Bs89+wrWba6+C5CqzH/1AIimmurRlBeAfyq/NkK7A5cLumcCmOLaCnPDY6YOu3UCE6RtAo4B7gWONj2m4BnUsw0jui40Z4bfNwhs1MLiBiHdmoEewDH297m1tO2/yyp3a+SRkypPDc4Yuq0M4/g3aNsu3lqw4l4uMwJiKjWeOcRRHRU5gREVC+JIKa1zAmIqF47NYKIrsmcgIjqJRHEtJFaQER3ZGgopoXUAiK6J4kgpoXUAiK6J0NDMS2kFhDRPUkE0XGpBURMLxkaio5KLSBi+kkiiI5KLSBi+snQUHRUagER008SQVSiWR3guENmpxYQMQ1laCimXJ4VENFbkghiyuVZARG9pdKhIUkLgI8DM4DP2j57xPaTgXOBoXLVJ21/tsqYonp5VkBEb6ksEUiaAZwHvBDYCKyUtNz22hFNL7W9uKo4olqZExDR+6ocGjoUWG97g+0/ApcAx1Z4vOiwzAmI6A9VJoLZwG0NyxvLdSOdIOkGSZdLmtNsR5IWSRqUNLhp06YqYo0JyJyAiP7Q7a+P/ifwZdt/kPQG4GLgBSMb2V4KLAUYGBhwZ0OMVjInIKI/VJkIhoDGT/h78VBRGADbdzcsfhY4p8J4YhJSC4joX1UODa0E5kuaJ2kHYCGwvLGBpD0bFo8Bbq4wnpig1AIi+ltlicD2VmAxsILiBH+Z7TWSzpJ0TNnsHyStkfRj4B+Ak6uKJyYutYCI/ia7t4bcBwYGPDg42O0wamXekm/Q7F+JgF+c/ZJOhxMREyBple2BZtsyszjG1GrMP7WAiP7Q7W8NxTTTrCh82ov35/Sv3bjN8FBqARH9I1cE8aBWRWEgtYCIPpYrgnjQaDeLu3bJC3Lij+hTuSKIB411s7iI6E+5IqipTBCLiGG5IqihTBCLiEZJBDWUCWIR0ShDQzWUm8VFRKMkgj6WB8hHRDsyNNSn8gD5iGhXEkGfygPkI6JdGRrqU3mAfES0K4mgD2ROQERMRoaGelzmBETEZCUR9LjMCYiIycrQUI/LnICImKwkgh6SWkBEVCFDQz0itYCIqEoSQY9ILSAiqlLp0JCkBcDHgRnAZ22f3aLdCcDlwLNs58n0TaQWEBFVqSwRSJoBnAe8ENgIrJS03PbaEe12Bk4Bvl9VLL0mtYCI6KQqh4YOBdbb3mD7j8AlwLFN2r0H+CDw+wpj6RmpBUREp1WZCGYDtzUsbyzXPUjSM4A5tr8x2o4kLZI0KGlw06ZNUx/pNJJaQER0Wte+PirpEcBHgJPHamt7KbAUYGBgwNVG1l2pBUREp1WZCIaAOQ3Le5Xrhu0MHARcLQngL4Dlko6pS8E4tYCImA6qHBpaCcyXNE/SDsBCYPnwRtv32p5pex/b+wDXA7VKAqkFRMR0UFkisL0VWAysAG4GLrO9RtJZko6p6ri9IrWAiJguKq0R2L4CuGLEune1aHt4lbFMN6kFRMR0kXsNVSzPDY6I6S63mKhQnhscEb0giaBCeW5wRPSCDA1VKM8NjohekEQwRTInICJ6VYaGpkDmBEREL0simAKZExARvSxDQ1MgcwIiopclEYxTagER0W8yNDQOqQVERD9KIhiH1AIioh9laGgcUguIiH6URNBCagERURcZGmoitYCIqJMkgiZSC4iIOsnQUBOpBUREndQ+EaQWEBF1V+uhodQCIiJqnghSC4iIqPnQUGoBEREVXxFIWiBpnaT1kpY02f5GSTdK+pGk/yfpwCriWLZ6iOeefSXzlnyD5559JctWDwGtx/xTC4iIOqksEUiaAZwHHAUcCJzU5ET/JdsH2346cA7wkamOI88NjogYXZVXBIcC621vsP1H4BLg2MYGtu9rWHw04KkOIs8NjogYXZU1gtnAbQ3LG4HDRjaS9Gbg7cAOwAua7UjSImARwNy5c8cVRJ4bHBExuq5/a8j2ebafCPwTcEaLNkttD9gemDVr1rj2nzpARMToqkwEQ8CchuW9ynWtXAIcN9VBpA4QETG6KhPBSmC+pHmSdgAWAssbG0ia37D4EuBnUx1E6gAREaOrrEZge6ukxcAKYAZwoe01ks4CBm0vBxZLOhLYAtwD/K8qYkkdICKitUonlNm+ArhixLp3Nbw+pcrjR0TE2LpeLI6IiO5KIoiIqLkkgoiImksiiIioOdlTfleHSknaBNw6wbfPBO6awnB6RV37DfXte/pdL+30e2/bTWfk9lwimAxJg7YHuh1Hp9W131Dfvqff9TLZfmdoKCKi5pIIIiJqrm6JYGm3A+iSuvYb6tv39LteJtXvWtUIIiLi4ep2RRARESMkEURE1FxfJgJJCyStk7Re0pIm2x8p6dJy+/cl7dP5KKdeG/1+u6S1km6Q9B1Je3cjzqk2Vr8b2p0gyZL64uuF7fRb0onl33yNpC91OsaqtPFvfa6kqyStLv+9H92NOKeSpAsl3SnpphbbJekT5e/kBknPaHvntvvqh+KW1z8H9qV4/OWPgQNHtPl74DPl64XApd2Ou0P9fj6wU/n6TXXpd9luZ+Aa4HpgoNtxd+jvPR9YDexeLj+u23F3sO9LgTeVrw8Ebul23FPQ778GngHc1GL70cD/AQQ8G/h+u/vuxyuCQ4H1tjfY/iPFk8+OHdHmWODi8vXlwBGS1MEYqzBmv21fZft35eL1FE+N63Xt/L0B3gN8EPh9J4OrUDv9fj1wnu17AGzf2eEYq9JO3w3sUr7eFbi9g/FVwvY1wK9HaXIs8AUXrgd2k7RnO/vux0QwG7itYXljua5pG9tbgXuBx3Ykuuq00+9Gr6P49NDrxux3eYk8x/Y3OhlYxdr5e+8H7CfpWknXS1rQseiq1U7fzwReJWkjxTNR3tKZ0LpqvOeAB1X6YJqYniS9ChgAntftWKom6RHAR4CTuxxKN2xHMTx0OMXV3zWSDra9uatRdcZJwEW2PyzpOcC/SjrI9p+7Hdh01I9XBEPAnIblvcp1TdtI2o7i0vHujkRXnXb6Tflo0HcCx9j+Q4diq9JY/d4ZOAi4WtItFGOny/ugYNzO33sjsNz2Ftu/AH5KkRh6XTt9fx1wGYDt64BHUdyYrZ+1dQ5oph8TwUpgvqR5knagKAYvH9FmOQ89H/nlwJUuqy09bMx+SzoEOJ8iCfTLePGo/bZ9r+2ZtvexvQ9FbeQY24PdCXfKtPPvfBnF1QCSZlIMFW3oZJAVaafvvwSOAJD0ZIpEsKmjUXbecuA15beHng3ca/uOdt7Yd0NDtrdKWgysoPh2wYW210g6Cxi0vRz4HMWl4nqK4svC7kU8Ndrs97nAY4CvlLXxX9o+pmtBT4E2+9132uz3CuBFktYCfwJOs93rV77t9v1U4AJJb6MoHJ/c6x/2JH2ZIrHPLGsf7wa2B7D9GYpayNHAeuB3wGvb3neP/24iImKS+nFoKCIixiGJICKi5pIIIiJqLokgIqLmkggiImouiSBqS9IcSb+QtEe5vHu5vM8k9nm4pK9PVYwRnZBEELVl+zbg08DZ5aqzgaW2b+laUBFdkEQQdfdR4NmS3gr8JfChxo3lzdqe0rB8taQBSYdKuq683/1/Sdp/5I4lnSnpHQ3LNw1fbUh6laQfSPqRpPMlzSh/Lirb3VhOhoqoXN/NLI4YD9tbJJ0GfBN4ke0tI5pcCpwIvLu8pe+etgcl7QL8VTnL9Ujg/cAJ7RyzvOXB3wLPLY//KeCVwBpgtu2Dyna7TUUfI8aSK4IIOAq4g+LmdCNdRnE/KigSwuXl610pbtVxE8VVxVOavLeVI4BnAisl/ahc3pfiPkD7SvqX8pbR9423IxETkUQQtSbp6cALKe5K+raygPyj8ueNtoeAuyU9leJT/KXlW98DXFV+ev8bipuajbSVbf8fG24j4GLbTy9/9rd9ZvkAmacBVwNvBD47tb2NaC5DQ1Fb5VPpPg281fYvJZ0LnG376SOaXgr8I7Cr7RvKdbvy0C1+T25xiFuAl5bHegYwr1z/HeA/JH3U9p3lt5Z2Bn4L/NH2VyWtA7442T5GtCNXBFFnr6e4A+u3y+VPAU+WNPKBPZdT3KH2soZ15wAfkLSa1h+ovgrsIWkNsJjieQDYXgucAXxL0g3At4E9KZ4mdXU5XPRF4PRJ9i+iLbn7aEREzeWKICKi5pIIIiJqLokgIqLmkggiImouiSAiouaSCCIiai6JICKi5v4/L+GANARX4MkAAAAASUVORK5CYII=\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "len(X), len(y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r4c-f0XL9tuA",
        "outputId": "a6f2ac07-fcdb-491b-8fab-64393c9c7eee"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(50, 50)"
            ]
          },
          "metadata": {},
          "execution_count": 32
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Splitting data into training and test sets (one of the most important concepts in ML)\n",
        "\n",
        "Let's create training and test set with our data"
      ],
      "metadata": {
        "id": "sn6dQQ347nN_"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a train/test split\n",
        "\n",
        "train_split = int(0.8 * len(X)) #80% train data\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": "_mj3yrub9HCJ",
        "outputId": "eabb00b3-46f3-42c7-c33f-3aa530271b6f"
      },
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(40, 40, 10, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "\"Visualize, visualize, visualize\""
      ],
      "metadata": {
        "id": "5zZB9KVk-3Ly"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Visualize X_train, y_train\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 predictions\n",
        "  \"\"\"\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 red\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 predictions in green (if they exist)\n",
        "    plt.scatter(test_data, predictions, c=\"r\", s=4, label=\"Predictions\")\n",
        "\n",
        "  #Show legend\n",
        "  plt.legend(prop={\"size\": 10});"
      ],
      "metadata": {
        "id": "XhYaQneK92mm"
      },
      "execution_count": 34,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "y836LKyu-kUI",
        "outputId": "42d1de4d-118f-43ba-bd0c-e86dabbcd5de"
      },
      "execution_count": 35,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 2. Build model\n",
        "\n",
        "Our first PyTorch model!\n",
        "\n",
        "Linear regression model: Y = m * X + b\n",
        "\n",
        "We will be building classes throughout the course, get familiar with OOP in Python: \n",
        "\n",
        "https://realpython.com/python3-object-oriented-programming/\n",
        "\n",
        "\n",
        "ex) `class Dog: -(Class) - each Dog within the class is an Object` \n",
        "\n",
        "    species = \"Canis familiaris\" -(class attribute)\n",
        "    def __init__(self, name, age): \n",
        "        self.name = name -(instance attribute)\n",
        "        self.age = age` -(instance attribute)\n",
        "\n",
        "* .__init__() sets the initial state of the object by assigning the values of the object’s properties\n",
        "* You can give .__init__() any number of parameters, but the first parameter will always be a variable called self\n",
        "* Attributes created in .__init__() are called **instance attributes** - all Dog objects will have name & age but values for *name* and *age* will vary depending on the Dog instance\n",
        "\n",
        "**What our model does:**\n",
        "* Star with random values (weight & bias)\n",
        "* Look at training data and adjust random values to better represent (or get closer to) the ideal values (weight & bias we used to create the data)\n",
        "\n",
        "How does it do so?\n",
        "\n",
        "Through two main algorithms:\n",
        "1. Gradient descent:\n",
        "  * an iterative first-order optimisation algorithm used to find a local min/max of a given function to minimise a cost/loss function \n",
        "2. Backpropagation:\n",
        "  * backpropagation computes the gradient of the loss function with respect to the weights of the network for a single input–output example"
      ],
      "metadata": {
        "id": "xQczzRUEA1fW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from torch import nn\n",
        "\n",
        "# Create linear regression model\n",
        "class LinearRegressionModel(nn.Module): #almost everything in PyTorch inherets from nn.module subclass\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "\n",
        "    # Initialize the model parameters to be used in compuations\n",
        "    self.weights = nn.Parameter(torch.randn(1, #nn.Parameter stores tensors that can be used with nn.Module\n",
        "                                            requires_grad=True, #used for updating model parameters via gradient descent\n",
        "                                            dtype=torch.float))\n",
        "    self.bias = nn.Parameter(torch.randn(1,\n",
        "                                        requires_grad=True,\n",
        "                                        dtype=torch.float))\n",
        "    \n",
        "  # forward() defines the compuation in the model and is required when calling nn.Module subclass\n",
        "  # this defines the compuation that takes place on the data passed to the particular nn.Module\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": "raIiSowSAGAm"
      },
      "execution_count": 36,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### PyTorch model building essentials\n",
        "\n",
        "* `torch.nn` - contains all of the building blocks for computational graphs (neural network can be considered a computational graph)\n",
        "* `torch.nn.Parameter` - what paramaters 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 neural network modules; if you subclass it, you should overwrite forward()\n",
        "* `torch.optim` - this is where the optimizers in PyTorch live, it will help with gradient descent and optimize the weights and biases\n",
        "* `def forward()` - all nn.Module sublcasses require you to overwrite forward(), this method defines what happens in the forward computation\n"
      ],
      "metadata": {
        "id": "iVX1f9NROSOL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Checking the content of our PyTorch model\n",
        "\n",
        "Now we've created a model, let's see whats inside...\n",
        "\n",
        "We can check out our model parameters or what's inside by using `.parameters()`"
      ],
      "metadata": {
        "id": "NzHGyF_kHbs3"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create a random seed\n",
        "torch.manual_seed(42)\n",
        "\n",
        "# Create an instance of our model (this is a subclass of nn.module)\n",
        "model_0 = LinearRegressionModel()\n",
        "model_0\n",
        "\n",
        "# Check model parameters - parameter values are what they are because they are random! Setting manual seed keeps them consistent every run\n",
        "list(model_0.parameters())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "bwZQTH2SrU6I",
        "outputId": "1f36f38e-bc05-4df5-df63-11b4d2638d10"
      },
      "execution_count": 37,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[Parameter containing:\n",
              " tensor([0.3367], requires_grad=True), Parameter containing:\n",
              " tensor([0.1288], requires_grad=True)]"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Purpose of our NN is to adjust the weights and bias parameters to be as close to our defined weight and bias as possible to best predict our data"
      ],
      "metadata": {
        "id": "qgUc6xMVs5mn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# List named parameters\n",
        "model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RtCceQMartWW",
        "outputId": "51beced5-3abc-4aa9-91b7-fa350cacbbc4"
      },
      "execution_count": 38,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# defined weight and bias\n",
        "weight, bias"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wl6ZO343sHZV",
        "outputId": "023d7697-6b3e-4a8e-c828-a9f8123ac0b5"
      },
      "execution_count": 39,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.7, 0.3)"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "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": "EQwcAoMTs2Ho"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "X_test, y_test"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gsec01d7t9N6",
        "outputId": "e5024c41-44c8-49be-cd60-939d29baa533"
      },
      "execution_count": 40,
      "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]]), 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": 40
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make predictions with model\n",
        "with torch.inference_mode(): # context manager `inference_mode` disables gradient tracking - reduces computing time \n",
        "  y_preds = model_0(X_test)\n",
        "\n",
        "y_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8rMaWie0tomW",
        "outputId": "fe47bf2a-2044-4cfb-8d32-f9309d21b94f"
      },
      "execution_count": 41,
      "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": 41
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "See more on `inference_mode()`: here https://twitter.com/PyTorch/status/1437838231505096708?s=20&t=UIAwRE5XeXTY-7e8P5tSZw\n",
        " * Can also use `torch.no_grad()`, but doesnt do as much as inference_mode and is preffered"
      ],
      "metadata": {
        "id": "XB08Bo3M_Uyw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print(list(y_test))\n",
        "print(list(y_preds))"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "G8NFW1gAuE51",
        "outputId": "b32c3dba-e941-4282-8b3c-4ac8d75f852c"
      },
      "execution_count": 42,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[tensor([0.8600]), tensor([0.8740]), tensor([0.8880]), tensor([0.9020]), tensor([0.9160]), tensor([0.9300]), tensor([0.9440]), tensor([0.9580]), tensor([0.9720]), tensor([0.9860])]\n",
            "[tensor([0.3982]), tensor([0.4049]), tensor([0.4116]), tensor([0.4184]), tensor([0.4251]), tensor([0.4318]), tensor([0.4386]), tensor([0.4453]), tensor([0.4520]), tensor([0.4588])]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions(predictions=y_preds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "kNL3VzzLuoz4",
        "outputId": "8e9fc61b-bd6a-494d-c7bd-d7c032b0b4a5"
      },
      "execution_count": 43,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "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 poor representation to a better representation of the data.\n",
        "\n",
        "To measure how \"poor\" or \"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, we are 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, lower=better \n",
        "* **Optimizer:** takes into account the **loss** of a model and adjusts the model's parameters (e.g. weight & bias) to improve the loss function.\n",
        "  * Larger learning rate = larger adjustment of parameter\n",
        "  * Lower learning rate = smaller adjustment of parameter\n",
        "\n",
        "And specifically for PyTorch, we need:\n",
        "* A training loop\n",
        "* A testing loop\n"
      ],
      "metadata": {
        "id": "N3QXuM8LuuO5"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Check out our model's parameters (a value that the model sets itself)\n",
        "model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "mdpF_EWXAOaq",
        "outputId": "92bbcda6-4f72-4d96-c2f1-475ba99127d5"
      },
      "execution_count": 44,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "metadata": {},
          "execution_count": 44
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup a loss function\n",
        "loss_fn = nn.L1Loss()\n",
        "\n",
        "# Setup an optimizer (stochastic gradient descent)\n",
        "  # Learning rate value will adjust parameters to the same power\n",
        "optimizer = torch.optim.SGD(model_0.parameters(),\n",
        "                            lr=0.01) # lr = learning rate = possibly most important hyperparameter you can set"
      ],
      "metadata": {
        "id": "XuYeP1x7BMuc"
      },
      "execution_count": 45,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "loss_fn"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X4tibxW5CioB",
        "outputId": "6418d9f0-fb19-49f6-97ca-3ca49a583350"
      },
      "execution_count": 46,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "L1Loss()"
            ]
          },
          "metadata": {},
          "execution_count": 46
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Q:** Which loss function should I use? \n",
        "\n",
        "**A:** For our case, linear regression, can use a an `L1Loss()` loss function (MAE) and an optimizer of `optim.SGD()` will suffice\n",
        "\n",
        "But for a classification problem, you'll likely use `nn.BCELoss()` (binary cross-entropy)"
      ],
      "metadata": {
        "id": "9w60BHpkOulU"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Building a training and 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 invovles data moving through our model's forward() function(s)) to make predictions on data - also called forward propagation\n",
        "2. Calculate the loss (compare forward pass predictions to ground truth labels)\n",
        "3. Opimizer zero grad\n",
        "4. Loss backward - move backwards through netwrok to calculare the gradient of each 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 imporve the loss (**gradient descent**)\n"
      ],
      "metadata": {
        "id": "CY9h77BaDouM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "torch.manual_seed(42)\n",
        "\n",
        "# An epoch is one loop through the data... (this is a hyperparameter bc we set it ourselves)\n",
        "epochs = 200\n",
        "\n",
        "# Track different values to be able to compare this exp to future experiments\n",
        "epoch_count = []\n",
        "loss_values = []\n",
        "test_loss_values = []\n",
        "\n",
        "### Training \n",
        "# 0. Loop through the data for a number of epochs\n",
        "for epoch in range(epochs):\n",
        "  # Set the model to training mode:\n",
        "  model_0.train() #train mode in PyTorch sets all parameters that require gradients to require gradients\n",
        "\n",
        "  # 1. Forward pass - run training data through the forward() method in our model\n",
        "  y_pred = model_0(X_train)\n",
        "\n",
        "  # 2. Calculate the loss between the predictions from training set and the ideal values\n",
        "  loss = loss_fn(y_pred, y_train) # Our loss function is L1Loss() and calcs MAE\n",
        "\n",
        "  # 3. Set optimizer to zero_grad\n",
        "  optimizer.zero_grad() # resets the optimizer for backprop following each epoch, otherwise gradient will accumulate\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 the gradient will **accumulate** through the loop so... we ahve to zero them above in step 3 for the next iter of loop\n",
        "\n",
        "  ### Testing\n",
        "  model_0.eval() #turns off settings in model not needed for eval/testing (dropout/batch norm layers)\n",
        "  with torch.inference_mode(): # turns off gradient tracking & other things behind the scenes to speed up computing\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 test loss\n",
        "    test_loss = loss_fn(test_pred, y_test)\n",
        "\n",
        "  # Print whats 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",
        "\n",
        "    # Print out model state_dict()\n",
        "    print(model_0.state_dict())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Dv-OfH8APTcZ",
        "outputId": "c2c86069-eaef-4d12-83b9-22def91e291e"
      },
      "execution_count": 47,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0 | Loss: 0.31288138031959534 | Test Loss: 0.48106518387794495\n",
            "OrderedDict([('weights', tensor([0.3406])), ('bias', tensor([0.1388]))])\n",
            "Epoch: 10 | Loss: 0.1976713240146637 | Test Loss: 0.3463551998138428\n",
            "OrderedDict([('weights', tensor([0.3796])), ('bias', tensor([0.2388]))])\n",
            "Epoch: 20 | Loss: 0.08908725529909134 | Test Loss: 0.21729660034179688\n",
            "OrderedDict([('weights', tensor([0.4184])), ('bias', tensor([0.3333]))])\n",
            "Epoch: 30 | Loss: 0.053148526698350906 | Test Loss: 0.14464017748832703\n",
            "OrderedDict([('weights', tensor([0.4512])), ('bias', tensor([0.3768]))])\n",
            "Epoch: 40 | Loss: 0.04543796554207802 | Test Loss: 0.11360953003168106\n",
            "OrderedDict([('weights', tensor([0.4748])), ('bias', tensor([0.3868]))])\n",
            "Epoch: 50 | Loss: 0.04167863354086876 | Test Loss: 0.09919948130846024\n",
            "OrderedDict([('weights', tensor([0.4938])), ('bias', tensor([0.3843]))])\n",
            "Epoch: 60 | Loss: 0.03818932920694351 | Test Loss: 0.08886633068323135\n",
            "OrderedDict([('weights', tensor([0.5116])), ('bias', tensor([0.3788]))])\n",
            "Epoch: 70 | Loss: 0.03476089984178543 | Test Loss: 0.0805937647819519\n",
            "OrderedDict([('weights', tensor([0.5288])), ('bias', tensor([0.3718]))])\n",
            "Epoch: 80 | Loss: 0.03132382780313492 | Test Loss: 0.07232122868299484\n",
            "OrderedDict([('weights', tensor([0.5459])), ('bias', tensor([0.3648]))])\n",
            "Epoch: 90 | Loss: 0.02788739837706089 | Test Loss: 0.06473556160926819\n",
            "OrderedDict([('weights', tensor([0.5629])), ('bias', tensor([0.3573]))])\n",
            "Epoch: 100 | Loss: 0.024458957836031914 | Test Loss: 0.05646304413676262\n",
            "OrderedDict([('weights', tensor([0.5800])), ('bias', tensor([0.3503]))])\n",
            "Epoch: 110 | Loss: 0.021020207554101944 | Test Loss: 0.04819049686193466\n",
            "OrderedDict([('weights', tensor([0.5972])), ('bias', tensor([0.3433]))])\n",
            "Epoch: 120 | Loss: 0.01758546568453312 | Test Loss: 0.04060482233762741\n",
            "OrderedDict([('weights', tensor([0.6141])), ('bias', tensor([0.3358]))])\n",
            "Epoch: 130 | Loss: 0.014155393466353416 | Test Loss: 0.03233227878808975\n",
            "OrderedDict([('weights', tensor([0.6313])), ('bias', tensor([0.3288]))])\n",
            "Epoch: 140 | Loss: 0.010716589167714119 | Test Loss: 0.024059748277068138\n",
            "OrderedDict([('weights', tensor([0.6485])), ('bias', tensor([0.3218]))])\n",
            "Epoch: 150 | Loss: 0.0072835334576666355 | Test Loss: 0.016474086791276932\n",
            "OrderedDict([('weights', tensor([0.6654])), ('bias', tensor([0.3143]))])\n",
            "Epoch: 160 | Loss: 0.0038517764769494534 | Test Loss: 0.008201557211577892\n",
            "OrderedDict([('weights', tensor([0.6826])), ('bias', tensor([0.3073]))])\n",
            "Epoch: 170 | Loss: 0.008932482451200485 | Test Loss: 0.005023092031478882\n",
            "OrderedDict([('weights', tensor([0.6951])), ('bias', tensor([0.2993]))])\n",
            "Epoch: 180 | Loss: 0.008932482451200485 | Test Loss: 0.005023092031478882\n",
            "OrderedDict([('weights', tensor([0.6951])), ('bias', tensor([0.2993]))])\n",
            "Epoch: 190 | Loss: 0.008932482451200485 | Test Loss: 0.005023092031478882\n",
            "OrderedDict([('weights', tensor([0.6951])), ('bias', tensor([0.2993]))])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "np.array(torch.tensor(loss_values).cpu().numpy())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "DmcuQM7m-FDg",
        "outputId": "5435ac31-22a8-4ddc-e2ce-dc6951455db6"
      },
      "execution_count": 48,
      "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)"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot 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(\"Epoch\")\n",
        "plt.legend();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "TsUwHXeT9g0w",
        "outputId": "5507ff0a-2fe3-4d04-fe6a-ec558b44df56"
      },
      "execution_count": 49,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "with torch.inference_mode(): # turns off gradient tracking & other things not needed for eval/testing\n",
        "  y_preds_new = model_0(X_test)"
      ],
      "metadata": {
        "id": "BNj8KdOoZbHh"
      },
      "execution_count": 50,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "# initial weight/bias\n",
        "model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qfCkwwLwPQC8",
        "outputId": "7d73aad2-29cd-4519-b9ad-af32d30ef24b"
      },
      "execution_count": 51,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "weight, bias"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rqzzf-8fY0j7",
        "outputId": "edc60ee5-e2d8-47dc-f6a1-ff003f693639"
      },
      "execution_count": 52,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.7, 0.3)"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions(predictions=y_preds)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "ErkqkqjdZYqr",
        "outputId": "c83e3aff-4a56-4839-d6b1-16591d0da0f1"
      },
      "execution_count": 53,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions(predictions=y_preds_new) \n",
        "# this is following 200 epochs"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "9vXp7FF5adEa",
        "outputId": "ce501ae4-7c2c-46b9-af72-3f4a0b4c2cc0"
      },
      "execution_count": 54,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Saving a model in PyTorch\n",
        "\n",
        "There are 3 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 - https://docs.python.org/3/library/pickle.htm\n",
        "2. `torch.load()` - allows you to load a saved pytorch object\n",
        "3. `torch.nn.Module.load_state_dict()` - allows you to load a model's saved state dictionary\n",
        "\n",
        "Resource for saving and loading model's in PyTorch: https://pytorch.org/tutorials/beginner/saving_loading_models.html\n"
      ],
      "metadata": {
        "id": "m4LNxXBfaj1D"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qMfQRfRwlXnT",
        "outputId": "3cb84b51-778f-47f2-b26c-80b0ef3d4cf1"
      },
      "execution_count": 55,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
            ]
          },
          "metadata": {},
          "execution_count": 55
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Optimizers also have a state_dict()\n",
        "optimizer.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "E0WB2kKwl3A1",
        "outputId": "330ca690-df24-435c-8593-d2f5a76db800"
      },
      "execution_count": 56,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'state': {0: {'momentum_buffer': None}, 1: {'momentum_buffer': None}},\n",
              " 'param_groups': [{'lr': 0.01,\n",
              "   'momentum': 0,\n",
              "   'dampening': 0,\n",
              "   'weight_decay': 0,\n",
              "   'nesterov': False,\n",
              "   'maximize': False,\n",
              "   'foreach': None,\n",
              "   'differentiable': False,\n",
              "   'params': [0, 1]}]}"
            ]
          },
          "metadata": {},
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Saving our PyTorch model\n",
        "from pathlib import Path\n",
        "\n",
        "# 1. Create model directory\n",
        "MODEL_PATH = Path(\"models\")\n",
        "MODEL_PATH.mkdir(parents=True, exist_ok=True)\n",
        "\n",
        "# 2. Create a model save path\n",
        "MODEL_NAME = \"01_pytorch_workflow_0.pth\"\n",
        "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n",
        "\n",
        "# 3. Save 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": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lv2e_GWgmQn_",
        "outputId": "0fd28da3-d3d5-464a-eb3e-522657973e5a"
      },
      "execution_count": 57,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving model to: models/01_pytorch_workflow_0.pth\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!ls -1 models"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "O1VzfURDnd-_",
        "outputId": "75c37756-45b4-4359-bfd4-1156b094b0d0"
      },
      "execution_count": 58,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "01_pytorch_workflow_0.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": "cunyUYk7qCa-"
      }
    },
    {
      "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 saved state_dict of mode_0 (wil 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": "BHmUSDL_oMbu",
        "outputId": "e261628b-e21a-4868-a921-a060177e8b2f"
      },
      "execution_count": 59,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "loaded_model_0.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0a1GJLo7qmjM",
        "outputId": "9846b1ee-eecf-460e-c9c5-985fb3ceec5c"
      },
      "execution_count": 60,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
            ]
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make some model preds\n",
        "\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": "7rKxHIA8rQ3U",
        "outputId": "e5ed6ab0-ee46-4abc-bda3-e7cff72812b9"
      },
      "execution_count": 61,
      "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": 61
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make some predictions with our loaded model \n",
        "loaded_model_0.eval()\n",
        "\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": "ZYEP3RUdqpPw",
        "outputId": "8eb858d9-a04a-42c4-e8f0-bc11ecaa37fb"
      },
      "execution_count": 62,
      "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": 62
        }
      ]
    },
    {
      "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": "LeaGDcfUrMlU",
        "outputId": "9e52381a-39d3-452f-afef-a11f90708b93"
      },
      "execution_count": 63,
      "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": 63
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 6. Putting it all together\n",
        "\n",
        "Lets go back through the steps above and see it all in one place\n",
        "\n"
      ],
      "metadata": {
        "id": "l0L7Bpi7rScj"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import PyTorch and matplotlib\n",
        "\n",
        "import torch\n",
        "from torch import nn\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "\n",
        "# Check pytorch version\n",
        "\n",
        "torch.__version__"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "28DKl1iQ0hWI",
        "outputId": "3b2af2c7-256c-4b47-f23a-2a8e15ed5095"
      },
      "execution_count": 64,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'1.13.1+cu116'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 64
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Create device-agnostic code.\n",
        "\n",
        "This means if we have access to a GPU, our code will use it for potentially faster computing. \n",
        "\n",
        "If no GPU is available, code will default to CPU"
      ],
      "metadata": {
        "id": "89biJSnO04KU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup device agnostic code\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "print(device)"
      ],
      "metadata": {
        "id": "nG6QvQiy1CYp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "02cc2b5a-48f7-48df-cb09-0fe04bd74aef"
      },
      "execution_count": 65,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "cuda\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!nvidia-smi"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UrdQgOIV1v0O",
        "outputId": "c2811e88-0a12-4a79-805a-437d2105b18a"
      },
      "execution_count": 66,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Thu Feb 23 15:05:50 2023       \n",
            "+-----------------------------------------------------------------------------+\n",
            "| NVIDIA-SMI 510.47.03    Driver Version: 510.47.03    CUDA Version: 11.6     |\n",
            "|-------------------------------+----------------------+----------------------+\n",
            "| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |\n",
            "| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |\n",
            "|                               |                      |               MIG M. |\n",
            "|===============================+======================+======================|\n",
            "|   0  Tesla T4            Off  | 00000000:00:04.0 Off |                    0 |\n",
            "| N/A   40C    P8     9W /  70W |      3MiB / 15360MiB |      0%      Default |\n",
            "|                               |                      |                  N/A |\n",
            "+-------------------------------+----------------------+----------------------+\n",
            "                                                                               \n",
            "+-----------------------------------------------------------------------------+\n",
            "| Processes:                                                                  |\n",
            "|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |\n",
            "|        ID   ID                                                   Usage      |\n",
            "|=============================================================================|\n",
            "|  No running processes found                                                 |\n",
            "+-----------------------------------------------------------------------------+\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.1 Generate / Prepare Data"
      ],
      "metadata": {
        "id": "ARMvKQ7H0QLU"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create parameters\n",
        "weight = 0.1\n",
        "bias = 0.5\n",
        "\n",
        "# Create data\n",
        "start = 0\n",
        "stop = 10\n",
        "step = 0.2\n",
        "\n",
        "X = torch.arange(start, stop, step=step).unsqueeze(dim=1)\n",
        "y = weight * X + bias\n",
        "\n",
        "print(f\"X: {X[:10]}\")\n",
        "print(f\"y: {y[:10]}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3SbO83hF10My",
        "outputId": "6beb3632-8116-4ae3-ce6c-12cb7d406613"
      },
      "execution_count": 67,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "X: tensor([[0.0000],\n",
            "        [0.2000],\n",
            "        [0.4000],\n",
            "        [0.6000],\n",
            "        [0.8000],\n",
            "        [1.0000],\n",
            "        [1.2000],\n",
            "        [1.4000],\n",
            "        [1.6000],\n",
            "        [1.8000]])\n",
            "y: tensor([[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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot generated X,y data\n",
        "plt.scatter(X,y)\n",
        "plt.xlabel(\"X\")\n",
        "plt.ylabel(\"y\");"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "cdB-S1Bz2UqI",
        "outputId": "d97b9c83-2496-4ac4-b322-f51d37fd7275"
      },
      "execution_count": 68,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Split data into training and test sets"
      ],
      "metadata": {
        "id": "_sxIDeIm3dOg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Split data into training and test sets\n",
        "\n",
        "train_split = int(0.8*len(X)) #Create 80/20 split for train/test\n",
        "\n",
        "# Create 80/20 split\n",
        "train_split = int(0.8*len(X))\n",
        "\n",
        "# Subset train and test data\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": "9QbaRarA3HCG",
        "outputId": "e1fa375a-e00f-4db7-cfb6-32ed3f1e4cac"
      },
      "execution_count": 69,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(40, 40, 10, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Visualize X_train, y_train\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",
        "  # Plot training data\n",
        "  plt.scatter(train_data, train_labels, c=\"b\", s=4, label=\"Training data\")\n",
        "\n",
        "  # Plot test data\n",
        "  plt.scatter(test_data, test_labels, c=\"g\", s=4, label=\"Test data\")\n",
        "\n",
        "  #Plot predictions\n",
        "  if predictions is not None:\n",
        "    plt.scatter(test_data, predictions, c=\"r\", s=4, label=\"predictions\")\n",
        "\n",
        "  #Show legend\n",
        "  plt.legend();"
      ],
      "metadata": {
        "id": "Ysk39gDU3zSx"
      },
      "execution_count": 70,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "AyjAVrRZ5pO4",
        "outputId": "bb4a08c9-2c0c-4212-d733-b14b24f0b6ff"
      },
      "execution_count": 71,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.2 Building a PyTorch Linear Model"
      ],
      "metadata": {
        "id": "cQLkh_Ok5se7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Create linear model by subclassing nn.Modue\n",
        "class LinearRegressionModelV2(nn.Module):\n",
        "  def __init__(self):\n",
        "    super().__init__()\n",
        "\n",
        "    # Use nn.Linear() for creating model parameters - Applies a linear transformation to the incoming data\n",
        "    # Also called lienar transform, dense layer, fully connected layer, probing layer\n",
        "    self.linear_layer = nn.Linear(in_features=1, # 1 input feat = X\n",
        "                                  out_features=1) # 1 output feat = y\n",
        "\n",
        "  # Define the forward() method\n",
        "  def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
        "    return self.linear_layer(x)\n",
        "\n",
        "# Set 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": "hkvT2IPH6Fvl",
        "outputId": "f78ebed2-437a-4647-87e9-aa9c580a7a12"
      },
      "execution_count": 72,
      "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": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "X_train[:5], y_train[:5]"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9m0Ctl5v8kaf",
        "outputId": "676acc19-fb6e-4754-d82c-4e25675c53a5"
      },
      "execution_count": 73,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([[0.0000],\n",
              "         [0.2000],\n",
              "         [0.4000],\n",
              "         [0.6000],\n",
              "         [0.8000]]), tensor([[0.5000],\n",
              "         [0.5200],\n",
              "         [0.5400],\n",
              "         [0.5600],\n",
              "         [0.5800]]))"
            ]
          },
          "metadata": {},
          "execution_count": 73
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Test untrained model predictions\n",
        "\n",
        "with torch.inference_mode():\n",
        "  y_preds = model_1(X_test)\n",
        "\n",
        "y_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "0vzEutmB77hp",
        "outputId": "06642b6a-ce39-4f9b-dc80-18c30a042be6"
      },
      "execution_count": 74,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[6.9463],\n",
              "        [7.0992],\n",
              "        [7.2521],\n",
              "        [7.4050],\n",
              "        [7.5579],\n",
              "        [7.7109],\n",
              "        [7.8638],\n",
              "        [8.0167],\n",
              "        [8.1696],\n",
              "        [8.3225]])"
            ]
          },
          "metadata": {},
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions(predictions=y_preds);"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "DgjwsXhbAi2g",
        "outputId": "8ba185f5-b57b-46fa-9a65-60238202c6d8"
      },
      "execution_count": 75,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.3 Train Linear Model"
      ],
      "metadata": {
        "id": "n00R1notAp0m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Setup loss function\n",
        "loss_fn = nn.L1Loss()\n",
        "\n",
        "# Setup optimizer - use gradient descent for linear model\n",
        "optimizer = torch.optim.SGD(model_1.parameters(),\n",
        "                         lr = 0.01)"
      ],
      "metadata": {
        "id": "9TakFkr4BZx1"
      },
      "execution_count": 76,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "loss_fn"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_Kez-Y9NBfP8",
        "outputId": "eb462678-f521-4c02-ae99-5ac20d75e12d"
      },
      "execution_count": 77,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "L1Loss()"
            ]
          },
          "metadata": {},
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#### Build training and testing loops"
      ],
      "metadata": {
        "id": "yNQuwed1CFTv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Set manual seed\n",
        "torch.manual_seed(42)\n",
        "\n",
        "# Track model progress\n",
        "epoch_count = []\n",
        "train_loss_values = []\n",
        "test_loss_values = []\n",
        "\n",
        "# Pass data through set num of epochs\n",
        "epochs = 200\n",
        "\n",
        "for epoch in range(epochs):\n",
        "\n",
        "  ### TRAINING\n",
        "  # Turn model to training mode\n",
        "  model_1.train()\n",
        "\n",
        "  # 1. Forward pass on train data\n",
        "  y_pred = model_1(X_train)\n",
        "\n",
        "  # 2. Calculate the loss\n",
        "  loss = loss_fn(y_pred, y_train)\n",
        "\n",
        "  # 3. Reset optimizer each epoch using zero_grad\n",
        "  optimizer.zero_grad()\n",
        "\n",
        "  # 4. Perform backpropgation on the loss\n",
        "  loss.backward()\n",
        "\n",
        "  # 5. Step optimizer (gradient descent)\n",
        "  optimizer.step()\n",
        "\n",
        "  ###TESTING\n",
        "  # Turn model to eval mode\n",
        "  model_1.eval()\n",
        "\n",
        "  # Turn on inference mode context manager\n",
        "  with torch.inference_mode():\n",
        "\n",
        "    # 1. Foward pass test data\n",
        "    test_pred = model_1(X_test)\n",
        "\n",
        "    # 2. Calculate loss\n",
        "    test_loss = loss_fn(test_pred, y_test)\n",
        "\n",
        "  # Print out output every 10 epochs\n",
        "  if epoch % 10 == 0:\n",
        "    epoch_count.append(epoch)\n",
        "    train_loss_values.append(loss)\n",
        "    test_loss_values.append(test_loss)\n",
        "    print(f\"Epoch: {epoch} | Train Loss: {loss} | Test Loss: {test_loss}\")\n",
        "\n",
        "    print(model_1.state_dict())"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Y5TzUQKiBtIB",
        "outputId": "c5323fb0-ec43-41fb-c511-ccd3aee0fa0a"
      },
      "execution_count": 78,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0 | Train Loss: 2.921708345413208 | Test Loss: 5.887301445007324\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.7255]])), ('linear_layer.bias', tensor([0.8200]))])\n",
            "Epoch: 10 | Train Loss: 1.3007087707519531 | Test Loss: 2.3163018226623535\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.3355]])), ('linear_layer.bias', tensor([0.7200]))])\n",
            "Epoch: 20 | Train Loss: 0.12122870981693268 | Test Loss: 0.0644083246588707\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0766]])), ('linear_layer.bias', tensor([0.6435]))])\n",
            "Epoch: 30 | Train Loss: 0.07699860632419586 | Test Loss: 0.3269083499908447\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0516]])), ('linear_layer.bias', tensor([0.6035]))])\n",
            "Epoch: 40 | Train Loss: 0.05912858247756958 | Test Loss: 0.33627843856811523\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0533]])), ('linear_layer.bias', tensor([0.5790]))])\n",
            "Epoch: 50 | Train Loss: 0.030385762453079224 | Test Loss: 0.1278885304927826\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0784]])), ('linear_layer.bias', tensor([0.5640]))])\n",
            "Epoch: 60 | Train Loss: 0.03956862539052963 | Test Loss: 0.3328384757041931\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0579]])), ('linear_layer.bias', tensor([0.5415]))])\n",
            "Epoch: 70 | Train Loss: 0.05107864737510681 | Test Loss: 0.29182854294776917\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0638]])), ('linear_layer.bias', tensor([0.5300]))])\n",
            "Epoch: 80 | Train Loss: 0.028988689184188843 | Test Loss: 0.32941851019859314\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0607]])), ('linear_layer.bias', tensor([0.5200]))])\n",
            "Epoch: 90 | Train Loss: 0.018198709934949875 | Test Loss: 0.3457085192203522\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0596]])), ('linear_layer.bias', tensor([0.5135]))])\n",
            "Epoch: 100 | Train Loss: 0.011248728260397911 | Test Loss: 0.3551585078239441\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0591]])), ('linear_layer.bias', tensor([0.5085]))])\n",
            "Epoch: 110 | Train Loss: 0.007858882658183575 | Test Loss: 0.35904836654663086\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0590]])), ('linear_layer.bias', tensor([0.5055]))])\n",
            "Epoch: 120 | Train Loss: 0.02106901817023754 | Test Loss: 0.3263382315635681\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0629]])), ('linear_layer.bias', tensor([0.5035]))])\n",
            "Epoch: 130 | Train Loss: 0.01856919936835766 | Test Loss: 0.328838050365448\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0629]])), ('linear_layer.bias', tensor([0.5010]))])\n",
            "Epoch: 140 | Train Loss: 0.01706930622458458 | Test Loss: 0.3303379416465759\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0629]])), ('linear_layer.bias', tensor([0.4995]))])\n",
            "Epoch: 150 | Train Loss: 0.01706930622458458 | Test Loss: 0.3303379416465759\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0629]])), ('linear_layer.bias', tensor([0.4995]))])\n",
            "Epoch: 160 | Train Loss: 0.01706930622458458 | Test Loss: 0.3303379416465759\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0629]])), ('linear_layer.bias', tensor([0.4995]))])\n",
            "Epoch: 170 | Train Loss: 0.01706930622458458 | Test Loss: 0.3303379416465759\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0629]])), ('linear_layer.bias', tensor([0.4995]))])\n",
            "Epoch: 180 | Train Loss: 0.01706930622458458 | Test Loss: 0.3303379416465759\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0629]])), ('linear_layer.bias', tensor([0.4995]))])\n",
            "Epoch: 190 | Train Loss: 0.01706930622458458 | Test Loss: 0.3303379416465759\n",
            "OrderedDict([('linear_layer.weight', tensor([[0.0629]])), ('linear_layer.bias', tensor([0.4995]))])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.4 Making Predictions"
      ],
      "metadata": {
        "id": "LHNiIXuIw7Um"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions(predictions=test_pred)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "ygrb3iH7FLA_",
        "outputId": "324d3e84-af36-4d05-d488-199dbb5fa4f9"
      },
      "execution_count": 79,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Plot loss curves\n",
        "\n",
        "plt.plot(epoch_count, np.array(torch.tensor(train_loss_values).numpy()), label=\"Train Loss\")\n",
        "plt.plot(epoch_count, test_loss_values, label=\"Test Loss\")\n",
        "plt.xlabel(\"Epoch\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.title(\"Training & Test Loss\")\n",
        "plt.legend();"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 295
        },
        "id": "JA_3DOVXFi0g",
        "outputId": "fce1a8ce-23d3-46fb-ac4b-56fea675abf6"
      },
      "execution_count": 80,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 6.5 Saving and loading model "
      ],
      "metadata": {
        "id": "2LdPVC0mGQ1I"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model_1.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dpDPsX_ZxCcT",
        "outputId": "aefbc13f-58ba-4c44-e8bd-ef2f4cde16a7"
      },
      "execution_count": 81,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('linear_layer.weight', tensor([[0.1019]])),\n",
              "             ('linear_layer.bias', tensor([0.5095]))])"
            ]
          },
          "metadata": {},
          "execution_count": 81
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "optimizer.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ndx6xWHAxNtM",
        "outputId": "4543a024-65d9-4052-a608-5c3153f23031"
      },
      "execution_count": 82,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'state': {0: {'momentum_buffer': None}, 1: {'momentum_buffer': None}},\n",
              " 'param_groups': [{'lr': 0.01,\n",
              "   'momentum': 0,\n",
              "   'dampening': 0,\n",
              "   'weight_decay': 0,\n",
              "   'nesterov': False,\n",
              "   'maximize': False,\n",
              "   'foreach': None,\n",
              "   'differentiable': False,\n",
              "   'params': [0, 1]}]}"
            ]
          },
          "metadata": {},
          "execution_count": 82
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Save PyTorch model: model_1 \n",
        "from pathlib import Path\n",
        "\n",
        "# 1. Instantiate model directory -> in Google Colab: content/mkdir_name/model_path\n",
        "# we already created a \"models\" directory path previously using mkdir\n",
        "MODEL_PATH = Path(\"models\")\n",
        "\n",
        "# 2. Create a model save path\n",
        "MODEL_NAME = \"01_pytorch_workflow_1.pth\"\n",
        "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n",
        "\n",
        "# 3. Save 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": "V6sYLym3xx38",
        "outputId": "9b7dff3d-e601-490c-90f1-614d8b002ad0"
      },
      "execution_count": 83,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Saving model to: models/01_pytorch_workflow_1.pth\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Load model\n",
        "\n",
        "loaded_model_1 = LinearRegressionModelV2()\n",
        "\n",
        "loaded_model_1.load_state_dict(torch.load(MODEL_SAVE_PATH))\n",
        "loaded_model_1.state_dict()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "I0ycpCHg0OEH",
        "outputId": "416bb248-5405-4f88-dc67-646a994200bd"
      },
      "execution_count": 84,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('linear_layer.weight', tensor([[0.1019]])),\n",
              "             ('linear_layer.bias', tensor([0.5095]))])"
            ]
          },
          "metadata": {},
          "execution_count": 84
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make predictions with model_1\n",
        "model_1.eval()\n",
        "with torch.inference_mode():\n",
        "  y_preds = model_1(X_test)\n",
        "\n",
        "y_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ACaA2x6r1BcL",
        "outputId": "f78b74da-0768-45e6-96f5-ab431fd33010"
      },
      "execution_count": 85,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[1.3250],\n",
              "        [1.3454],\n",
              "        [1.3658],\n",
              "        [1.3862],\n",
              "        [1.4066],\n",
              "        [1.4270],\n",
              "        [1.4473],\n",
              "        [1.4677],\n",
              "        [1.4881],\n",
              "        [1.5085]])"
            ]
          },
          "metadata": {},
          "execution_count": 85
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Make predictions with loaded_model_1\n",
        "loaded_model_1.eval()\n",
        "with torch.inference_mode():\n",
        "  loaded_y_preds = loaded_model_1(X_test)\n",
        "\n",
        "loaded_y_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "5TaYFR__1Mqe",
        "outputId": "08fe5b7f-08f1-4e40-9697-2d512e556f07"
      },
      "execution_count": 86,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[1.3250],\n",
              "        [1.3454],\n",
              "        [1.3658],\n",
              "        [1.3862],\n",
              "        [1.4066],\n",
              "        [1.4270],\n",
              "        [1.4473],\n",
              "        [1.4677],\n",
              "        [1.4881],\n",
              "        [1.5085]])"
            ]
          },
          "metadata": {},
          "execution_count": 86
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Are predictions from model_1 and loaded_model_1 identical?\n",
        "y_preds == loaded_y_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "VyPItbTp1n82",
        "outputId": "12dd118c-bbea-4c42-a73e-e046630be517"
      },
      "execution_count": 87,
      "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": 87
        }
      ]
    }
  ]
}