01_pytorch_workflow_video.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a7916957-230b-447a-92a3-1800268516c2",
   "metadata": {},
   "source": [
    "# PyTorch Workflow\n",
    "\n",
    "Let's explore an example pytorch end-to-end workflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "id": "59c20583-be74-4733-98bf-b7739e22f8c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"]= \"5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "id": "d2f6f9ee-03dd-4402-a3a3-b399f994a3c0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "torch.cuda.is_available()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "id": "a59182f4-2c58-4d4e-a9d2-f25c0608be73",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.cuda.device_count()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "c1511d06-bf17-4352-a7b7-50216fed7231",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tue Jan  2 04:45:59 2024       \n",
      "+---------------------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 530.30.02              Driver Version: 530.30.02    CUDA Version: 12.1     |\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  NVIDIA GeForce RTX 3090         On | 00000000:1D:00.0 Off |                  N/A |\n",
      "| 62%   66C    P2              344W / 350W|  11623MiB / 24576MiB |     99%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   1  NVIDIA GeForce RTX 3090         On | 00000000:1E:00.0 Off |                  N/A |\n",
      "| 30%   34C    P8               20W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   2  NVIDIA GeForce RTX 3090         On | 00000000:1F:00.0 Off |                  N/A |\n",
      "| 30%   36C    P8               19W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   3  NVIDIA GeForce RTX 3090         On | 00000000:20:00.0 Off |                  N/A |\n",
      "| 30%   33C    P8               16W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   4  NVIDIA GeForce RTX 3090         On | 00000000:21:00.0 Off |                  N/A |\n",
      "| 30%   31C    P8               19W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   5  NVIDIA GeForce RTX 3090         On | 00000000:22:00.0 Off |                  N/A |\n",
      "| 30%   36C    P8               28W / 350W|    757MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   6  NVIDIA GeForce RTX 3090         On | 00000000:23:00.0 Off |                  N/A |\n",
      "| 30%   32C    P8               24W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   7  NVIDIA GeForce RTX 3090         On | 00000000:24:00.0 Off |                  N/A |\n",
      "| 30%   33C    P8               16W / 350W|      3MiB / 24576MiB |      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",
      "+---------------------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "d539a1c2-322d-40e6-acc9-a53263cbca89",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: 'data (prepare and load)',\n",
       " 2: 'build model',\n",
       " 3: 'fitting the model to data (training)',\n",
       " 4: 'making predictions and evaluating a model (inference)',\n",
       " 5: 'saving and loading a model',\n",
       " 6: 'putting it all together'}"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "what_were_covering = {1: \"data (prepare and load)\",\n",
    "                     2: \"build model\",\n",
    "                     3: \"fitting the model to data (training)\",\n",
    "                     4: \"making predictions and evaluating a model (inference)\",\n",
    "                     5: \"saving and loading a model\",\n",
    "                     6: \"putting it all together\"}\n",
    "what_were_covering"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "524a1b0c-0979-43eb-80f0-cbea81c2e1ee",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.1.2'"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Check PyTorch version\n",
    "torch.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d20f41aa-662a-4a5c-9a86-27e2a664781c",
   "metadata": {},
   "source": [
    "## 1. Data (preparing and loading)\n",
    "\n",
    "Data can be almost anything ... in machine learning\n",
    "\n",
    "* Excel spreadsheet\n",
    "* Images of any kind\n",
    "* Videos (Youtube has lots of data...)\n",
    "* Audio like songs or podcasts\n",
    "* DNA\n",
    "* Text\n",
    "\n",
    "Machine learning is a game of two parts:\n",
    "1. get data into a numerical representation\n",
    "2. Build a model to learn pattterns in that numerical representation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a3a27e13-c2dc-47a7-9d1b-d0c4318ce5da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[0.0000],\n",
       "         [0.0200],\n",
       "         [0.0400],\n",
       "         [0.0600],\n",
       "         [0.0800],\n",
       "         [0.1000],\n",
       "         [0.1200],\n",
       "         [0.1400],\n",
       "         [0.1600],\n",
       "         [0.1800]]),\n",
       " tensor([[0.3000],\n",
       "         [0.3140],\n",
       "         [0.3280],\n",
       "         [0.3420],\n",
       "         [0.3560],\n",
       "         [0.3700],\n",
       "         [0.3840],\n",
       "         [0.3980],\n",
       "         [0.4120],\n",
       "         [0.4260]]),\n",
       " 50,\n",
       " 50)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "weight = 0.7\n",
    "bias = 0.3\n",
    "\n",
    "start = 0\n",
    "end = 1\n",
    "step = 0.02\n",
    "x = torch.arange(start, end, step).unsqueeze(dim = 1)\n",
    "y = weight * x + bias\n",
    "\n",
    "x[:10], y[:10], len(x), len(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2dfa4b0b-43bb-4cd6-988b-9e18b036c483",
   "metadata": {},
   "source": [
    "### splitting data into training and test sets (one of the most important concepts in machine learning in general"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "43cdc1db-fa30-4ff2-9edf-ed13892e7062",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(40, 40, 10, 10)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_split = int(0.8*len(x))\n",
    "\n",
    "x_train , y_train = x[:train_split], y[:train_split]\n",
    "x_test, y_test = x[train_split:], y[train_split:]\n",
    "\n",
    "len(x_train), len(y_train), len(x_test), len(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "8f361517-1e8f-42a5-a537-9f6cf97361e0",
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_predictions(train_data = x_train,\n",
    "                     train_labels = y_train,\n",
    "                     test_data = x_test,\n",
    "                     test_labels = y_test,\n",
    "                     predictions = None):\n",
    "    plt.figure(figsize = (10,7))\n",
    "\n",
    "    plt.scatter(train_data, train_labels, c=\"b\", s= 4, label = \"Training data\")\n",
    "    plt.scatter(test_data, test_labels, c=\"g\", s= 4, label = \"Testing data\")\n",
    "\n",
    "    if predictions is not None:\n",
    "        plt.scatter(test_data, predictions, c = \"r\", s=4, label = \"Predictions\")\n",
    "        \n",
    "    plt.legend(prop = {\"size\":14});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "a302e872-6d7a-43af-bfe1-c294ed94a09c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_predictions()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f39ac0c5-50af-44d8-902f-6ce595b5e4d3",
   "metadata": {},
   "source": [
    "## 2. Build model\n",
    "\n",
    "Our first PyTorch model!\n",
    "\n",
    "This is very exciting... let's do it!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "1adb6f57-a783-481d-a8e0-990e513089c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch import nn\n",
    "\n",
    "class LinearRegressionModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.weights = nn.Parameter(torch.randn(1,\n",
    "                                               requires_grad=True,\n",
    "                                               dtype=torch.float))\n",
    "        self.bias = nn.Parameter(torch.randn(1,\n",
    "                                            requires_grad=True,\n",
    "                                            dtype = torch.float))\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor: \n",
    "        return self.weights * x + self.bias\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8e1c3aa7-6371-4920-8139-535a8e388ab7",
   "metadata": {},
   "source": [
    "### Pytorch model building essentials\n",
    "\n",
    "* torch.nn\n",
    "* torch.nn.Parameter\n",
    "* torch.nn.Module\n",
    "* torch.optim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "7ef93c69-5734-42fd-89a4-6a25c04fb1d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([0.3367])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.randn(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fb41569f-55a2-4256-83b6-e400a1d8cb3d",
   "metadata": {},
   "source": [
    "### Checking the contents of our Pytorch model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "eeb3a775-e0e8-438b-9786-b0caab9b6465",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Parameter containing:\n",
       " tensor([0.3367], requires_grad=True),\n",
       " Parameter containing:\n",
       " tensor([0.1288], requires_grad=True)]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a random seed\n",
    "torch.manual_seed(42)\n",
    "\n",
    "# Created an instance of the model\n",
    "model_0 = LinearRegressionModel()\n",
    "\n",
    "list(model_0.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "65e51bc4-812f-4020-92c4-aef6633adc3c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_0.state_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5da14fd5-2117-42ba-ba32-da51d77c3796",
   "metadata": {},
   "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": 45,
   "id": "df353b57-7778-4faa-8377-bf24a930b56c",
   "metadata": {},
   "outputs": [
    {
     "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]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "with torch.inference_mode():\n",
    "    y_preds = model_0(x_test)\n",
    "\n",
    "# you can also use no_grad similar like inference_mode, but inference is more preference.\n",
    "with torch.no_grad():\n",
    "    y_preds = model_0(x_test)\n",
    "\n",
    "y_preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "760baa97-a751-4366-bfa6-acab9990bed7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.8600],\n",
       "        [0.8740],\n",
       "        [0.8880],\n",
       "        [0.9020],\n",
       "        [0.9160],\n",
       "        [0.9300],\n",
       "        [0.9440],\n",
       "        [0.9580],\n",
       "        [0.9720],\n",
       "        [0.9860]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "8101683c-753d-443c-b0f4-a7fdd1cc3c3c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_predictions(predictions=y_preds)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce175100-6c07-4f9f-9e85-fa10c953cf60",
   "metadata": {},
   "source": [
    "## 3. Train model\n",
    "\n",
    "The whole idea of training is ofr a model to move from some *unknown* parameters (these may be random) to some known parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "76a87589-a393-4ee6-af9d-cf7bb50f59f9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Parameter containing:\n",
       " tensor([0.3367], requires_grad=True),\n",
       " Parameter containing:\n",
       " tensor([0.1288], requires_grad=True)]"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(model_0.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "73c2fe28-4c58-4c9d-ae8c-5a2027f570f6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check out our model's parameters\n",
    "model_0.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "e179a29c-809b-49fb-83bb-05ca2fe57067",
   "metadata": {},
   "outputs": [],
   "source": [
    "# setup a loss function\n",
    "loss_fn = nn.L1Loss()\n",
    "\n",
    "# setup an optimizer\n",
    "optimizer = torch.optim.SGD(params = model_0.parameters(),\n",
    "                           lr = 0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "653fcdca-a08f-4bc3-b20c-90427b20d397",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "L1Loss()"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss_fn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "1e2da811-1b8f-445d-a594-0ab086c7e836",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "SGD (\n",
       "Parameter Group 0\n",
       "    dampening: 0\n",
       "    differentiable: False\n",
       "    foreach: None\n",
       "    lr: 0.01\n",
       "    maximize: False\n",
       "    momentum: 0\n",
       "    nesterov: False\n",
       "    weight_decay: 0\n",
       ")"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "optimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8ddab63-4c88-481d-a20f-f22082a442fa",
   "metadata": {},
   "source": [
    "### Building a training loop (and a testing loop) in Pytorch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "9c12b5a5-112b-4493-a4cd-7b5e743c67ea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "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"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "torch.manual_seed(42)\n",
    "\n",
    "# An epoch is one loop through the data...\n",
    "epochs = 200\n",
    "\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() # sets all parameters that require gradeints to require gradient\n",
    "\n",
    "    # 1. Forward pass\n",
    "    y_pred = model_0(x_train)\n",
    "\n",
    "    # 2. Calculate the loss\n",
    "    loss = loss_fn(y_pred, y_train)\n",
    "    # print(f\"Loss: {loss}\")\n",
    "\n",
    "    # 3. Optimizer zero grad\n",
    "    optimizer.zero_grad()\n",
    "\n",
    "    # 4. Perform backpropagation on the loss with respect to the parameters of the model\n",
    "    loss.backward()\n",
    "\n",
    "    # 5. Step the optimizer\n",
    "    optimizer.step()\n",
    "\n",
    "    # testing\n",
    "    model_0.eval() \n",
    "    with torch.inference_mode(): # turns off the gradient tracking\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",
    "    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(model_0.state_dict())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "2cc24dde-f1a2-4b91-8cbf-659588130194",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\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.xlabel(\"Epochs\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.legend();"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "278de1d5-afd7-4ff8-9e05-66ac303dbdbc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_0.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "cd87ccb2-c65d-4165-8659-91fa8baf7199",
   "metadata": {},
   "outputs": [],
   "source": [
    "with torch.inference_mode():\n",
    "    y_preds_new = model_0(x_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "825f8854-5043-4959-96af-1c29ea1bb1f3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_predictions(predictions=y_preds_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e4eb890-9bbe-4144-9587-2a859be09811",
   "metadata": {},
   "source": [
    "## Saving a model in PyTorch\n",
    "\n",
    "There are three main methods you should about for saving and loading models in pytorch.\n",
    "\n",
    "1. `torch.save()` - allows you save a pytorch object in python's pickle format\n",
    "2. `torch.load()` -allows you load a saved pytorch object\n",
    "3. `torch.nn.Module.load_state_dict()` - this allows to load a model's saved state dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "d763960f-cf69-4945-9624-7661459979ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving model to: models/01_pytorch_workflow_model_0.pth\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "MODEL_PATH = Path(\"models\")\n",
    "MODEL_PATH.mkdir(parents = True, exist_ok = True)\n",
    "\n",
    "MODEL_NAME = \"01_pytorch_workflow_model_0.pth\"\n",
    "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n",
    "\n",
    "print(f\"Saving model to: {MODEL_SAVE_PATH}\")\n",
    "torch.save(obj = model_0.state_dict(), f = MODEL_SAVE_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "14ea1a17-37d1-4103-a169-e1d6b980f8c1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "total 4\n",
      "-rw-r--r-- 1 root root 1680 Jan  2 02:18 01_pytorch_workflow_model_0.pth\n"
     ]
    }
   ],
   "source": [
    "!ls -l models"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5824c6ee-163a-4962-836b-c41685d5f8f5",
   "metadata": {},
   "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"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "2e25a214-5373-4eca-ae40-ce4a34563a59",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_0.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "ae75b9e8-0c07-4e96-9961-68fc6420de67",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loaded_model_0 = LinearRegressionModel()\n",
    "\n",
    "loaded_model_0.load_state_dict(torch.load(f=MODEL_SAVE_PATH))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "3d48d7f2-ce80-45c0-93cd-67b27ea58968",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loaded_model_0.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "d896699b-6cb8-48d9-b79d-2d61769792d6",
   "metadata": {},
   "outputs": [
    {
     "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]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make some predictions with our loaded model\n",
    "\n",
    "loaded_model_0.eval()\n",
    "with torch.inference_mode():\n",
    "    loaded_model_preds = loaded_model_0(x_test)\n",
    "\n",
    "loaded_model_preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "544256b6-c3c6-4507-aa70-6a9a6b9f2bf5",
   "metadata": {},
   "outputs": [
    {
     "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]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_0.eval()\n",
    "with torch.inference_mode():\n",
    "    y_preds = model_0(x_test)\n",
    "\n",
    "y_preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "4909cbc2-4f32-43b9-ba09-598e6d44683e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True],\n",
       "        [True]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_preds == loaded_model_preds"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5147e149-f34d-402e-8d67-817f570a014c",
   "metadata": {},
   "source": [
    "## 6. Putting it all together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "8ff8eb2a-dc37-4691-b6be-93a93d115a1e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.1.2'"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "torch.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "e01875e2-b7b4-4c45-96a6-3e51f7c5a602",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n"
     ]
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "print(f\"Using device: {device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "bb60a6f8-4b7d-40ec-a525-8e4bba303bff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tue Jan  2 02:31:51 2024       \n",
      "+---------------------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 530.30.02              Driver Version: 530.30.02    CUDA Version: 12.1     |\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  NVIDIA GeForce RTX 3090         On | 00000000:1D:00.0 Off |                  N/A |\n",
      "| 30%   37C    P8               33W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   1  NVIDIA GeForce RTX 3090         On | 00000000:1E:00.0 Off |                  N/A |\n",
      "| 30%   33C    P8               19W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   2  NVIDIA GeForce RTX 3090         On | 00000000:1F:00.0 Off |                  N/A |\n",
      "| 30%   33C    P8               19W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   3  NVIDIA GeForce RTX 3090         On | 00000000:20:00.0 Off |                  N/A |\n",
      "| 30%   32C    P8               16W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   4  NVIDIA GeForce RTX 3090         On | 00000000:21:00.0 Off |                  N/A |\n",
      "| 30%   32C    P8               19W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   5  NVIDIA GeForce RTX 3090         On | 00000000:22:00.0 Off |                  N/A |\n",
      "| 30%   33C    P8               28W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   6  NVIDIA GeForce RTX 3090         On | 00000000:23:00.0 Off |                  N/A |\n",
      "| 30%   33C    P8               24W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   7  NVIDIA GeForce RTX 3090         On | 00000000:24:00.0 Off |                  N/A |\n",
      "| 30%   33C    P8               17W / 350W|      3MiB / 24576MiB |      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"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4dcac285-09ef-4787-a8cf-414f527a6993",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fe000b34-2664-46f0-ba91-95ce343a6de4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9084c9b6-2575-483a-ac9e-cfe54d1ae5a9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "60952e33-efa8-48e3-8d49-93eeb40f28d3",
   "metadata": {},
   "source": [
    "# 01. PyTorch Workflow Exercise Template\n",
    "The following is a template for the PyTorch workflow exercises.\n",
    "\n",
    "It's only starter code and it's your job to fill in the blanks.\n",
    "\n",
    "Because of the flexibility of PyTorch, there may be more than one way to answer the question.\n",
    "\n",
    "Don't worry about trying to be right just try writing code that suffices the question.\n",
    "\n",
    "You can see one form of solutions on GitHub (but try the exercises below yourself first!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "8e67e220-39a7-4a56-8b17-40c15def2caf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import necessary libraries\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "from torch import nn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "5907bef6-0b43-49fd-9bd4-d03d8cbceaa9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cuda'"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Setup device-agnostic code\n",
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "\n",
    "device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a96a63de-4a5a-4eec-930c-786761c18654",
   "metadata": {},
   "source": [
    "## 1. Create a straight line dataset using the linear regression formula (weight * X + bias).\n",
    "Set weight=0.3 and bias=0.9 there should be at least 100 datapoints total.\n",
    "Split the data into 80% training, 20% testing.\n",
    "Plot the training and testing data so it becomes visual.\n",
    "Your output of the below cell should look something like:\n",
    "\n",
    "Number of X samples: 100\n",
    "Number of y samples: 100\n",
    "First 10 X & y samples:\n",
    "X: tensor([0.0000, 0.0100, 0.0200, 0.0300, 0.0400, 0.0500, 0.0600, 0.0700, 0.0800,\n",
    "        0.0900])\n",
    "y: tensor([0.9000, 0.9030, 0.9060, 0.9090, 0.9120, 0.9150, 0.9180, 0.9210, 0.9240,\n",
    "        0.9270])\n",
    "Of course the numbers in X and y may be different but ideally they're created using the linear regression formula."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "id": "3c50cece-ef72-48ec-938c-f1cd40bdf679",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of X samples: 100\n",
      "Number of y samples: 100\n",
      "First 10 X & y samples:\n",
      "X: tensor([[0.0000],\n",
      "        [0.0100],\n",
      "        [0.0200],\n",
      "        [0.0300],\n",
      "        [0.0400],\n",
      "        [0.0500],\n",
      "        [0.0600],\n",
      "        [0.0700],\n",
      "        [0.0800],\n",
      "        [0.0900]])\n",
      "y: tensor([[0.9000],\n",
      "        [0.9030],\n",
      "        [0.9060],\n",
      "        [0.9090],\n",
      "        [0.9120],\n",
      "        [0.9150],\n",
      "        [0.9180],\n",
      "        [0.9210],\n",
      "        [0.9240],\n",
      "        [0.9270]])\n"
     ]
    }
   ],
   "source": [
    "# Create the data parameters\n",
    "weight = 0.3\n",
    "bias = 0.9\n",
    "\n",
    "# Make X and y using linear regression feature\n",
    "start = 0\n",
    "end = 1\n",
    "step = 0.01\n",
    "\n",
    "X = torch.arange(start, end, step).unsqueeze(dim = 1)\n",
    "y = weight * X + bias\n",
    "\n",
    "print(f\"Number of X samples: {len(X)}\")\n",
    "print(f\"Number of y samples: {len(y)}\")\n",
    "print(f\"First 10 X & y samples:\\nX: {X[:10]}\\ny: {y[:10]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "74ba6f36-d8f2-4e1d-a209-d79dd11dd4ed",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(80, 80, 20, 20)"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Split the data into training and testing\n",
    "\n",
    "data_len = int(0.8*len(X))\n",
    "X_train, y_train = X[:data_len], y[:data_len]\n",
    "X_test, y_test = X[data_len:], y[data_len:]\n",
    "len(X_train), len(y_train), len(X_test), len(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "id": "5e3177b4-9c9c-4c7b-a469-4f0ae3154704",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the training and testing data \n",
    "def plot_predictions(X_train = X_train, y_train = y_train, X_test = X_test, y_test = y_test, predictions= None):\n",
    "    plt.scatter(X_train, y_train, c=\"b\", s = 4, label = \"train\")\n",
    "    plt.scatter(X_test, y_test, c=\"g\", s= 4, label = \"test\")\n",
    "    if predictions!=None:\n",
    "        plt.scatter(X_test, predictions, c=\"r\", s = 4, label = \"prediction\")\n",
    "    plt.show()\n",
    "plot_predictions()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d2225a1-088e-4371-91e7-d23f660d7131",
   "metadata": {},
   "source": [
    "## 2. Build a PyTorch model by subclassing nn.Module.\n",
    "Inside should be a randomly initialized nn.Parameter() with requires_grad=True, one for weights and one for bias.\n",
    "Implement the forward() method to compute the linear regression function you used to create the dataset in 1.\n",
    "Once you've constructed the model, make an instance of it and check its state_dict().\n",
    "Note: If you'd like to use nn.Linear() instead of nn.Parameter() you can."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "380742f0-1f67-453e-8eb1-5cd6edf18dfc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(LinearRegression(),\n",
       " OrderedDict([('weight', tensor([0.6180])), ('bias', tensor([0.0687]))]))"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create PyTorch linear regression model by subclassing nn.Module\n",
    "class LinearRegression(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.weight = nn.Parameter(torch.rand(1, requires_grad = True, dtype = torch.float))\n",
    "        self.bias = nn.Parameter(torch.rand(1, requires_grad = True, dtype = torch.float))\n",
    "\n",
    "    def forward(self, X):\n",
    "        return self.weight * X + bias\n",
    "\n",
    "torch.manual_seed(50)\n",
    "model_1 = LinearRegression()\n",
    "model_1, model_1.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "15a50d5d-7adc-4e20-9792-69d11d08b581",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegression()"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Instantiate the model and put it to the target device\n",
    "model_1.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "id": "2242b587-4bdb-46d0-afdc-0365fd739bb9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Parameter containing:\n",
       " tensor([0.6180], device='cuda:0', requires_grad=True),\n",
       " Parameter containing:\n",
       " tensor([0.0687], device='cuda:0', requires_grad=True)]"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(model_1.parameters())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "b5428c2d-b411-4af8-bffa-9aba9e397fdc",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tue Jan  2 05:00:52 2024       \n",
      "+---------------------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 530.30.02              Driver Version: 530.30.02    CUDA Version: 12.1     |\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  NVIDIA GeForce RTX 3090         On | 00000000:1D:00.0 Off |                  N/A |\n",
      "| 68%   65C    P2              343W / 350W|  12017MiB / 24576MiB |     98%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   1  NVIDIA GeForce RTX 3090         On | 00000000:1E:00.0 Off |                  N/A |\n",
      "| 30%   34C    P8               20W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   2  NVIDIA GeForce RTX 3090         On | 00000000:1F:00.0 Off |                  N/A |\n",
      "| 30%   38C    P8               19W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   3  NVIDIA GeForce RTX 3090         On | 00000000:20:00.0 Off |                  N/A |\n",
      "| 30%   33C    P8               16W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   4  NVIDIA GeForce RTX 3090         On | 00000000:21:00.0 Off |                  N/A |\n",
      "| 30%   32C    P8               20W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   5  NVIDIA GeForce RTX 3090         On | 00000000:22:00.0 Off |                  N/A |\n",
      "| 30%   41C    P2              114W / 350W|    757MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   6  NVIDIA GeForce RTX 3090         On | 00000000:23:00.0 Off |                  N/A |\n",
      "| 30%   33C    P8               25W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   7  NVIDIA GeForce RTX 3090         On | 00000000:24:00.0 Off |                  N/A |\n",
      "| 30%   33C    P8               17W / 350W|      3MiB / 24576MiB |      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",
      "+---------------------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b0167330-dab1-4b6b-8951-f0d01695d473",
   "metadata": {},
   "source": [
    "## 3. Create a loss function and optimizer using nn.L1Loss() and torch.optim.SGD(params, lr) respectively.\n",
    "Set the learning rate of the optimizer to be 0.01 and the parameters to optimize should be the model parameters from the model you created in 2.\n",
    "Write a training loop to perform the appropriate training steps for 300 epochs.\n",
    "The training loop should test the model on the test dataset every 20 epochs."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "db875e33-9516-41aa-ae4f-2c84045e9daf",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the loss function and optimizer\n",
    "loss_fn = nn.L1Loss()\n",
    "optimizer = torch.optim.SGD(params = model_1.parameters(), lr=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "1b58de47-3e56-4c5e-8e71-947bf4f1818a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 | Train loss: 0.281 | Test loss: 0.008\n",
      "Epoch: 20 | Train loss: 0.210 | Test loss: 0.008\n",
      "Epoch: 40 | Train loss: 0.140 | Test loss: 0.008\n",
      "Epoch: 60 | Train loss: 0.069 | Test loss: 0.008\n",
      "Epoch: 80 | Train loss: 0.002 | Test loss: 0.008\n",
      "Epoch: 100 | Train loss: 0.002 | Test loss: 0.008\n",
      "Epoch: 120 | Train loss: 0.002 | Test loss: 0.008\n",
      "Epoch: 140 | Train loss: 0.002 | Test loss: 0.008\n",
      "Epoch: 160 | Train loss: 0.002 | Test loss: 0.008\n",
      "Epoch: 180 | Train loss: 0.002 | Test loss: 0.008\n",
      "Epoch: 200 | Train loss: 0.002 | Test loss: 0.008\n",
      "Epoch: 220 | Train loss: 0.002 | Test loss: 0.008\n",
      "Epoch: 240 | Train loss: 0.002 | Test loss: 0.008\n",
      "Epoch: 260 | Train loss: 0.002 | Test loss: 0.008\n",
      "Epoch: 280 | Train loss: 0.002 | Test loss: 0.008\n"
     ]
    }
   ],
   "source": [
    "# Training loop\n",
    "torch.manual_seed(42)\n",
    "epochs = 300\n",
    "\n",
    "# Train model for 300 epochs\n",
    "\n",
    "\n",
    "# Send data to target device\n",
    "X_train = X_train.to(device)\n",
    "X_test = X_test.to(device)\n",
    "y_train = y_train.to(device)\n",
    "y_test = y_test.to(device)\n",
    "\n",
    "for epoch in range(epochs):\n",
    "  ### Training\n",
    "\n",
    "  # Put model in train mode\n",
    "  model_1.train()\n",
    "\n",
    "  # 1. Forward pass\n",
    "  y_pred = model_1(X_train)\n",
    "\n",
    "  # 2. Calculate loss\n",
    "  loss = loss_fn(y_pred, y_train)\n",
    "\n",
    "  # 3. Zero gradients\n",
    "  optimizer.zero_grad()\n",
    "\n",
    "  # 4. Backpropagation\n",
    "  loss.backward()\n",
    "\n",
    "  # 5. Step the optimizer\n",
    "  optimizer.step()\n",
    "\n",
    "  ### Perform testing every 20 epochs\n",
    "  if epoch % 20 == 0:\n",
    "\n",
    "    # Put model in evaluation mode and setup inference context \n",
    "    model_1.eval()\n",
    "    with torch.inference_mode():\n",
    "      # 1. Forward pass\n",
    "      y_pred = model_1(X_test)\n",
    "      # 2. Calculate test loss\n",
    "      loss = loss_fn(y_pred, y_test)\n",
    "      # Print out what's happening\n",
    "      print(f\"Epoch: {epoch} | Train loss: {loss:.3f} | Test loss: {test_loss:.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dad9c640-3a0f-4395-b8a9-1ec39dc799e7",
   "metadata": {},
   "source": [
    "## 4. Make predictions with the trained model on the test data.\n",
    "Visualize these predictions against the original training and testing data (note: you may need to make sure the predictions are not on the GPU if you want to use non-CUDA-enabled libraries such as matplotlib to plot)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "349eeea3-d6fd-4771-9248-72ebe87afd09",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1.1416],\n",
       "        [1.1446],\n",
       "        [1.1477],\n",
       "        [1.1507],\n",
       "        [1.1537],\n",
       "        [1.1567],\n",
       "        [1.1597],\n",
       "        [1.1628],\n",
       "        [1.1658],\n",
       "        [1.1688],\n",
       "        [1.1718],\n",
       "        [1.1748],\n",
       "        [1.1779],\n",
       "        [1.1809],\n",
       "        [1.1839],\n",
       "        [1.1869],\n",
       "        [1.1899],\n",
       "        [1.1930],\n",
       "        [1.1960],\n",
       "        [1.1990]], device='cuda:0')"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make predictions with the model\n",
    "model_1.eval()\n",
    "with torch.inference_mode():\n",
    "    y_pred = model_1(X_test)\n",
    "\n",
    "y_pred"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "id": "274eee84-775a-485c-bce1-f7951fa26c3c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot the predictions (these may need to be on a specific device)\n",
    "plot_predictions(predictions=y_pred.cpu())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8d3c5e8-0586-434c-966a-e89518eade3a",
   "metadata": {},
   "source": [
    "## 5. Save your trained model's state_dict() to file.\r\n",
    "Create a new instance of your model class you made in 2. and load in the state_dict() you just saved to it.\r\n",
    "Perform predictions on your test data with the loaded model and confirm they match the original model predictions from 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "id": "8230774a-94ea-40a0-b81c-49f326f02418",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "# 1. Create models directory \n",
    "MODEL_PATH = Path(\"models\")\n",
    "MODEL_PATH.mkdir(parents=True, exist_ok=True)\n",
    "# 2. Create model save path \n",
    "MODEL_NAME = \"01_pytorch\"\n",
    "MODEL_SAVE_PATH = MODEL_PATH/ MODEL_NAME\n",
    "\n",
    "# 3. Save the model state dict\n",
    "torch.save(obj = model_1.state_dict(), f = MODEL_SAVE_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "id": "81b6254b-56de-4c44-9127-8f62bcd32fdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create new instance of model and load saved state dict (make sure to put it on the target device)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "id": "4c48210d-f75a-47c9-b614-69d6ccacd228",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Make predictions with loaded model and compare them to the previous\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "id": "586d6f9a-9b79-4023-8793-80320581c72b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tue Jan  2 05:07:35 2024       \n",
      "+---------------------------------------------------------------------------------------+\n",
      "| NVIDIA-SMI 530.30.02              Driver Version: 530.30.02    CUDA Version: 12.1     |\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  NVIDIA GeForce RTX 3090         On | 00000000:1D:00.0 Off |                  N/A |\n",
      "| 32%   38C    P8               34W / 350W|   1151MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   1  NVIDIA GeForce RTX 3090         On | 00000000:1E:00.0 Off |                  N/A |\n",
      "| 30%   34C    P8               20W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   2  NVIDIA GeForce RTX 3090         On | 00000000:1F:00.0 Off |                  N/A |\n",
      "| 30%   35C    P8               20W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   3  NVIDIA GeForce RTX 3090         On | 00000000:20:00.0 Off |                  N/A |\n",
      "| 30%   33C    P8               16W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   4  NVIDIA GeForce RTX 3090         On | 00000000:21:00.0 Off |                  N/A |\n",
      "| 30%   33C    P8               19W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   5  NVIDIA GeForce RTX 3090         On | 00000000:22:00.0 Off |                  N/A |\n",
      "| 30%   38C    P8               28W / 350W|    757MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   6  NVIDIA GeForce RTX 3090         On | 00000000:23:00.0 Off |                  N/A |\n",
      "| 30%   34C    P8               25W / 350W|      3MiB / 24576MiB |      0%      Default |\n",
      "|                                         |                      |                  N/A |\n",
      "+-----------------------------------------+----------------------+----------------------+\n",
      "|   7  NVIDIA GeForce RTX 3090         On | 00000000:24:00.0 Off |                  N/A |\n",
      "| 30%   34C    P8               17W / 350W|      3MiB / 24576MiB |      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",
      "+---------------------------------------------------------------------------------------+\n"
     ]
    }
   ],
   "source": [
    "!nvidia-smi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6b8dfb5-c3eb-4f8c-8246-252ea83ab26c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}