01_pytorch_workflow.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "workflow = {1: 'data (prepare and load)',\n",
    "            2: 'build model',\n",
    "            3: 'fitting the model to data (training)', \n",
    "            4: 'making predictions and evaluting a model (inference)',\n",
    "            5: 'saving and loading a model',\n",
    "            6: 'putting it altogether'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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 evaluting a model (inference)',\n",
       " 5: 'saving and loading a model',\n",
       " 6: 'putting it altogether'}"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "workflow"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.12.1+cu102'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import torch\n",
    "from torch import nn \n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "torch.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Data - preparing and loading"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Creating some ***known*** data using linear regression formula"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# parameters\n",
    "weight = 0.7\n",
    "bias = 0.3\n",
    "\n",
    "# create\n",
    "start = 0\n",
    "end = 1\n",
    "step = 0.02\n",
    "X = torch.arange(start, end, step).unsqueeze(dim=1)\n",
    "y = weight * X + bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(X, y)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How to estimate this data?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40 40 10 10\n"
     ]
    }
   ],
   "source": [
    "train_split = int(0.8 * len(X))\n",
    "X_train, y_train = X[:train_split], y[:train_split]\n",
    "X_test, y_test = X[train_split:], y[train_split:]\n",
    "\n",
    "print(len(X_train), len(y_train), len(X_test), len(y_test))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualise predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "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",
    "    \"\"\"\n",
    "    Plots training data, testing data and compares predictions. \n",
    "    \"\"\"\n",
    "    plt.figure(figsize=(10,7))\n",
    "    \n",
    "    plt.scatter(train_data, train_labels, c='b', s=4, label='Training data')\n",
    "    \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.xlabel('X')\n",
    "    plt.ylabel('y')\n",
    "    plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_predictions(X_train, y_train, X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Build Model\n",
    "\n",
    "1. torch.nn - contains all building blocks for computational graphs\n",
    "2. torch.nn.Parameter - what parameters should our model try and learn?\n",
    "3. torch.nn.Module - base class for all neural network modules. If you subclass it, you should overwrite forward()\n",
    "4. torch.optim - optimisers for gradient descent\n",
    "5. forward() - All nn.Module subclasses requires you to override forward"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a linear regression model class\n",
    "\n",
    "class LinearRegressionModel(nn.Module): # class inherits from nn.Module.\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.weights = nn.Parameter(torch.randn(1,\n",
    "                                                requires_grad=True,\n",
    "                                                dtype=torch.float32))\n",
    "        self.bias = nn.Parameter(torch.randn(1, \n",
    "                                             requires_grad=True,\n",
    "                                             dtype=torch.float32))\n",
    "    \n",
    "    # Forward method to define the computation in the model\n",
    "    def forward(self, x: torch.tensor) -> torch.tensor:\n",
    "        return self.weights * x + self.bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a random seed\n",
    "torch.manual_seed(42)\n",
    "\n",
    "# model initialisation\n",
    "model_0 = LinearRegressionModel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Check out Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Parameter containing:\n",
      "tensor([0.3367], requires_grad=True), Parameter containing:\n",
      "tensor([0.1288], requires_grad=True)]\n",
      "----------\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# check out parameters\n",
    "print(list(model_0.parameters()))\n",
    "\n",
    "print('-'*10)\n",
    "# list named parameters\n",
    "model_0.state_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Making predictions in inference mode !!!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "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]], grad_fn=<AddBackward0>)"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_preds = model_0(X_test)\n",
    "y_preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "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": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make predictions using either torch.inference_mode() or torch.no_grad()\n",
    "# torch.inference_mode is preferred tho.\n",
    "# gradient mode is disabled, so less data need to be tracked\n",
    "with torch.inference_mode():\n",
    "    y_preds = model_0(X_test)\n",
    "    \n",
    "# with torch.no_grad():\n",
    "#     y_preds = model_0(X_test)\n",
    "    \n",
    "y_preds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualise predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_predictions(predictions=y_preds) # lol that's very bad. so we need to train "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Train Model\n",
    "\n",
    "1. We need to set up:\n",
    "    1. **Loss function**\n",
    "    2. **Optimiser**: Arguments - `params` (parameters) and `lr` (learning rate)\n",
    "2. Write a training loop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. Set up"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([Parameter containing:\n",
       "  tensor([0.3367], requires_grad=True),\n",
       "  Parameter containing:\n",
       "  tensor([0.1288], requires_grad=True)],\n",
       " OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))]))"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(model_0.parameters()), model_0.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create a random seed\n",
    "torch.manual_seed(42)\n",
    "\n",
    "# model initialisation\n",
    "model_0 = LinearRegressionModel()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# set up a loss function (measures how wrong our model is)\n",
    "loss_fun = nn.L1Loss()\n",
    "\n",
    "# set up an optimiser (adjusts our parameters to optimise the loss fn)\n",
    "optimiser = torch.optim.SGD(params=model_0.parameters(), lr=0.01)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Training loop\n",
    "\n",
    "0. Loop through data\n",
    "1. Forward pass on data for prediction\n",
    "2. Calculate the loss for made predictions\n",
    "3. Optimiser zero grad\n",
    "4. Loss backward - backprop\n",
    "5. Optimiser step - gradient descent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 | Train Loss:0.31288138031959534 | Test Loss: 0.48106518387794495\n",
      "Epoch: 10 | Train Loss:0.1976713240146637 | Test Loss: 0.3463551998138428\n",
      "Epoch: 20 | Train Loss:0.08908725529909134 | Test Loss: 0.21729660034179688\n",
      "Epoch: 30 | Train Loss:0.053148526698350906 | Test Loss: 0.14464017748832703\n",
      "Epoch: 40 | Train Loss:0.04543796554207802 | Test Loss: 0.11360953003168106\n",
      "Epoch: 50 | Train Loss:0.04167863354086876 | Test Loss: 0.09919948130846024\n",
      "Epoch: 60 | Train Loss:0.03818932920694351 | Test Loss: 0.08886633068323135\n",
      "Epoch: 70 | Train Loss:0.03476089984178543 | Test Loss: 0.0805937647819519\n",
      "Epoch: 80 | Train Loss:0.03132382780313492 | Test Loss: 0.07232122868299484\n",
      "Epoch: 90 | Train Loss:0.02788739837706089 | Test Loss: 0.06473556160926819\n",
      "Epoch: 100 | Train Loss:0.024458957836031914 | Test Loss: 0.05646304413676262\n",
      "Epoch: 110 | Train Loss:0.021020207554101944 | Test Loss: 0.04819049686193466\n",
      "Epoch: 120 | Train Loss:0.01758546568453312 | Test Loss: 0.04060482233762741\n",
      "Epoch: 130 | Train Loss:0.014155393466353416 | Test Loss: 0.03233227878808975\n",
      "Epoch: 140 | Train Loss:0.010716589167714119 | Test Loss: 0.024059748277068138\n",
      "OrderedDict([('weights', tensor([0.6638])), ('bias', tensor([0.3153]))])\n"
     ]
    }
   ],
   "source": [
    "# An epoch is one loop through the data\n",
    "epochs = 150 # hyperparameter\n",
    "\n",
    "# Track different values\n",
    "epoch_count = []\n",
    "loss_values = []\n",
    "test_loss_values = []\n",
    "\n",
    "# Loop through data\n",
    "for epoch in range(epochs):\n",
    "    \n",
    "     # Training:: set model to training mode\n",
    "    model_0.train() # now (requires_grad=True), track gradients\n",
    "    \n",
    "    #1. Forward pass\n",
    "    y_pred = model_0(X_train)\n",
    "    \n",
    "    # 2. Calculate the loss\n",
    "    loss = loss_fun(y_pred, y_train)\n",
    "    # print(f'Train Loss:{loss}')\n",
    "    \n",
    "    # 3. Optimiser zero grad\n",
    "    optimiser.zero_grad()\n",
    "    \n",
    "    # 4. Perform backprop\n",
    "    loss.backward()\n",
    "    \n",
    "    # 5. Step the optimiser / gradient descent\n",
    "    optimiser.step()\n",
    "    \n",
    "    # Testing:: \n",
    "    model_0.eval() # turns off setting you don't need for testing\n",
    "    \n",
    "    # turn off tracking gradients, go to inference_mode - check their tweet on this!\n",
    "    # https://twitter.com/PyTorch/status/1437838231505096708?s=20\n",
    "    with torch.inference_mode():\n",
    "        \n",
    "        # 1. Do the forward pass\n",
    "        test_pred = model_0(X_test)\n",
    "        \n",
    "        # 2. Calculate the loss\n",
    "        test_loss = loss_fun(test_pred, y_test)\n",
    "    \n",
    "    # Track progress \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} | Train Loss:{loss} | Test Loss: {test_loss}')\n",
    "        \n",
    "print(model_0.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Visualise the training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAA5PUlEQVR4nO3dd3xV9f348dc7exASIEE2SQhgkREggigoon4dqFRb6wLFUX+2VbRuO/xaa1tt+3W11ln3wImiuBUU3CzZyAoQhoRIwgxZ798f5wQu4Sa5ITl35L6fj8d55N6zPu97CPedz+dzzucjqooxxpjoFRPqAIwxxoSWJQJjjIlylgiMMSbKWSIwxpgoZ4nAGGOinCUCY4yJcpYITKskIjtFJPcQj71QRD5o6ZiijYgUisiJoY7DNM4SgTlAa/nPq6ptVHV1Y/uJSLaIqIjE+Rz7vKr+j7cRGhM+LBGYVsX3Cz1a2TUwTWWJwARERBJF5D4R2egu94lIorstU0TeFpFSEflRRGaKSIy77WYR2SAiO0RkuYic4Ofcw0Vks4jE+qw7S0QWuK+HiciX7vk3ici/RSTBZ18Vkd+IyApghc+6PPf1WBGZJyLbRWS9iNzuU/xn7s9StzlphIhMFJFZPuc/WkS+FZEy9+fRPttmiMifReRz9zN+ICKZDVzHX4rISvc6TRWRLu76h0Tkn3X2fVNErnNfdxGR10SkWETWiMgkn/1uF5FXReQ5EdkOTKzn3++fIrJORH4QkYdFJNndNlpEikTkdyKy1a0VXuhzbLqIPOOWvVZE/lD77+vzmZa6n3+JiAzxKTpfRBa41+4lEUlyj6n3d8aEgKraYsu+BSgETvSz/g7gK6AjkAV8AfzZ3fY34GEg3l1GAQL0BdYDXdz9soFe9ZS7CjjJ5/0rwC3u66HAUUCce46lwLU++yrwIdAeSPZZl+e+Hg0MwPnDZyDwA/BTn5gUiPM530Rglvu6PbANmOCWf777voO7fYYbex8g2X1/Vz2fcQywFRgCJAL/Aj5ztx3rXitx37cD9gBd3LjnALcBCUAusBo42d33dqAS+Km7b7Kfsu8FprqfJw14C/ibz/WpAu5x4zoO2AX0dbc/A7zpHpcNfA9c5m47B9gAHOn+m+cBPX1+l75xP0N799/tyoZ+Z0L9+x+tS8gDsCW8FupPBKuA03zenwwUuq/vcL8o8uockwdsAU4E4hsp907gCfd1mvtF1LOefa8Fpvi8V2BMnX20bjw+2+4D7nVfZ9NwIpgAfFPn+C+Bie7rGcAffLb9GnivnnL/C/zd530b9ws82/0SXQcc6277JfCJ+3o4sK7OuW4FnnRf346bUOopV9zr2ctn3Qhgjft6NE4iSPXZ/jLwRyAWqAD6+Wz7f8AM9/X7wDUN/C6N93n/d+Dhhn5nbAnNYlUxE6guwFqf92vddQD/AFYCH4jIahG5BUBVV+J8ad8ObBGRybVNIX68AJztNjedDcxV1bUAItLHbUbY7DZ9/BWo2/yyvr7A3aan6W7TRhlwpZ/jA/3cuO+7+rzf7PN6N84XfKPnUtWdQAnQVZ1vx8k4NQ6AC4Dn3dc9gS5uM0qpiJQCvwMO8zl3vZ8fpwaXAszxOf49d32tbaq6q85n7IJzneI5+N++9vN3x/kjoT71XRu/vzMmNCwRmEBtxPlCqtXDXYeq7lDV61U1FzgTuK62L0BVX1DVke6xCtzt7+SqugTnC+ZUnC/BF3w2PwQsA3qralucL0Gpe4oGYn8Bp1mku6qm4zRJ1B7f2PC7dT83OJ99QyPHNXouEUkFOvic60Xg5yLSE6cW8Jq7fj3OX+8ZPkuaqp7mc+6GPsdWnGamI3yOT1dV34TVzo3H9zNudI+t5OB/+9qY1wO9Gv3kdTT0O2OCzxKB8SdeRJJ8ljicL6k/iEiW2xl6G/AcgIicLiJ5IiJAGVAN1IhIXxEZ4/6VX47zZVTTQLkvANfgtJe/4rM+DdgO7BSRw4FfNfHzpAE/qmq5iAzDSTS1it2Y6nvm4B2gj4hcICJxInIu0A94u4kxgHMNLxGRfPea/BX4WlULAVR1Hs4X7+PA+6pa6h73DbBDnI73ZBGJFZH+InJkIIWqag3wGHCviHQEEJGuInJynV3/JCIJIjIKOB14RVWrcZqJ/iIiaW6Sug73396N9QYRGSqOPHefBtX3OxPI5zEtzxKB8ecdnC/t2uV2nDb82cACYCEw110H0Bv4CNiJ037+H1WdjtPxeBfOl9tmnI7mWxso90WcjspPVHWrz/obcL68d+B8ob3UxM/za+AOEdmBk8Bert2gqruBvwCfu80mR/keqKolOF+K1+M049wEnF4nvoCo6kc47e6vAZtw/pI+r85uL+D0qbzgc1y1G0M+sIb9ySK9CcXfjNMU85XbvPYRTmd+rc04neAbcZqkrlTVZe62q3H6GFYDs9zYnnBjewXn+r2A8+/zBk7HcGPq+50xIVB7h4IxJkqJyGjgOVXtFuJQTIhYjcAYY6KcJQJjjIly1jRkjDFRztMagYicIs6wAiv93ScszqP8xSIy310u9zIeY4wxB/NscCpxxo15EDgJKAK+FZGp7v3ivl5S1asCPW9mZqZmZ2e3XKDGGBMF5syZs1VVs/xt83KUwmHASnWHAhaRycA4oG4iaJLs7Gxmz57dAuEZY0z0EJG6T8jv42XTUFcOfOy9iAMfy6/1M3d0wldFpLu/E4nIFSIyW0RmFxcXexGrMcZErVDfNfQWkK2qA3FGj3za306q+qiqFqhqQVaW35qNMcaYQ+RlItiAMyBVrW7UGZ9FVUtUda/79nGc4YaNMcYEkZd9BN8CvUUkBycBnMeBY7wgIp1VdZP79kyc8cqNMVGosrKSoqIiysvLQx1KREtKSqJbt27Ex8cHfIxniUBVq0TkKpzxymNxxppfLCJ3ALNVdSowSUTOxBkL/Uf8zKxkjIkORUVFpKWlkZ2djTMWnWkqVaWkpISioiJycnICPs7TuU1V9R2cAcx8193m8/pWGh6EzBgTJcrLyy0JNJOI0KFDB5p6U02oO4uNMWYfSwLNdyjXMHoSQdEc+Oj2UEdhjDFhJ3oSwca5MOte2PRdqCMxxoShkpIS8vPzyc/Pp1OnTnTt2nXf+4qKigaPnT17NpMmTWpSednZ2Wzd2uRpLTzhaR9BWBnwc3j/9zD3WRg7KNTRGGPCTIcOHZg/fz4At99+O23atOGGG27Yt72qqoq4OP9fmQUFBRQUFAQjTE9ET40guR30OxMWvgyVdnuaMaZxEydO5Morr2T48OHcdNNNfPPNN4wYMYLBgwdz9NFHs3z5cgBmzJjB6aefDjhJ5NJLL2X06NHk5ubywAMPNFrOPffcQ//+/enfvz/33XcfALt27WLs2LEMGjSI/v3789JLzsR8t9xyC/369WPgwIEHJKrmiJ4aAcDg8bDwFVj2tlNDMMaEpT+9tZglG7e36Dn7dWnL/55xRJOPKyoq4osvviA2Npbt27czc+ZM4uLi+Oijj/jd737Ha6+9dtAxy5YtY/r06ezYsYO+ffvyq1/9qt77+ufMmcOTTz7J119/jaoyfPhwjjvuOFavXk2XLl2YNm0aAGVlZZSUlDBlyhSWLVuGiFBaWtrkz+NP9NQIALKPhfQeMO+5xvc1xhjgnHPOITY2FnC+jM855xz69+/Pb3/7WxYvXuz3mLFjx5KYmEhmZiYdO3bkhx9+qPf8s2bN4qyzziI1NZU2bdpw9tlnM3PmTAYMGMCHH37IzTffzMyZM0lPTyc9PZ2kpCQuu+wyXn/9dVJSUlrkM0ZXjSAmBgZfCDPugtJ1kNEj1BEZY/w4lL/cvZKamrrv9R//+EeOP/54pkyZQmFhIaNHj/Z7TGJi4r7XsbGxVFVVNbncPn36MHfuXN555x3+8Ic/cMIJJ3DbbbfxzTff8PHHH/Pqq6/y73//m08++aTJ564rumoEAPnuKBfzXwhtHMaYiFNWVkbXrs4gyk899VSLnHPUqFG88cYb7N69m127djFlyhRGjRrFxo0bSUlJYfz48dx4443MnTuXnTt3UlZWxmmnnca9997Ld9+1zF2Q0VUjAKcWkDsa5j0Px97k1BKMMSYAN910ExdffDF33nknY8eObZFzDhkyhIkTJzJs2DAALr/8cgYPHsz777/PjTfeSExMDPHx8Tz00EPs2LGDcePGUV5ejqpyzz33tEgMETdncUFBgTZ7YpqFr8Jrl8GEN6DX8S0SlzGmeZYuXcpPfvKTUIfRKvi7liIyR1X93uManX8OH346JGVYp7ExxhCtiSA+CQb+Apa+BXu2hToaY4wJqehMBOA8U1C912kmMsaYKBa9iaDzIOg0EOY9G+pIjDEmpKI3EQAMnuAMQrdpQagjMcaYkInuRDDg5xCbCPOfD3UkxhgTMtGdCFLaw09OhwUvQdXeUEdjjAmh5gxDDc7Ac1988YXfbU899RRXXXVVS4fcYqLvgbK6Bo+HRa/BsmnQ/+xQR2OMCZHGhqFuzIwZM2jTpg1HH320RxF6J7prBAA5x0F6d3umwBhzkDlz5nDccccxdOhQTj75ZDZt2gTAAw88sG8o6PPOO4/CwkIefvhh7r33XvLz85k5c2a95ywsLGTMmDEMHDiQE044gXXr1gHwyiuv0L9/fwYNGsSxxx4LwOLFixk2bBj5+fkMHDiQFStWePI5rUYQE+uMP/Tp36F0PWR0D3VExph3b4HNC1v2nJ0GwKl3Bby7qnL11Vfz5ptvkpWVxUsvvcTvf/97nnjiCe666y7WrFlDYmIipaWlZGRkcOWVVwZUi7j66qu5+OKLufjii3niiSeYNGkSb7zxBnfccQfvv/8+Xbt23Te89MMPP8w111zDhRdeSEVFBdXV1c25AvWyGgFA/oWAwncvhjoSY0yY2Lt3L4sWLeKkk04iPz+fO++8k6KiIgAGDhzIhRdeyHPPPVfvrGX1+fLLL7ngAmfwywkTJjBr1iwAjjnmGCZOnMhjjz227wt/xIgR/PWvf+Xuu+9m7dq1JCcnt+An3M9qBADtejpNRPOeg1E32EB0xoRaE/5y94qqcsQRR/Dll18etG3atGl89tlnvPXWW/zlL39h4cLm114efvhhvv76a6ZNm8bQoUOZM2cOF1xwAcOHD2fatGmcdtppPPLII4wZM6bZZdVl33i1Bk+A0rVQWH/bnjEmeiQmJlJcXLwvEVRWVrJ48WJqampYv349xx9/PHfffTdlZWXs3LmTtLQ0duzY0eh5jz76aCZPngzA888/z6hRowBYtWoVw4cP54477iArK4v169ezevVqcnNzmTRpEuPGjWPBAm+eebJEUOsnp0NSunUaG2MAiImJ4dVXX+Xmm29m0KBB5Ofn88UXX1BdXc348eMZMGAAgwcPZtKkSWRkZHDGGWcwZcqURjuL//Wvf/Hkk08ycOBAnn32We6//34AbrzxRgYMGED//v05+uijGTRoEC+//DL9+/cnPz+fRYsWcdFFF3nyWaNzGOr6TLveSQTXL4fkDG/KMMb4ZcNQtxwbhro5Bo+HqnJYZAPRGWOihyUCX53z4bAB1jxkjIkqlgh8iTi1go3zYPOiUEdjTNSJtKbqcHQo19ASQV0DfwGxCTYQnTFBlpSURElJiSWDZlBVSkpKSEpKatJx9hxBXSnt4fCx8N1kOPF2iEsMdUTGRIVu3bpRVFREcXFxqEOJaElJSXTr1q1Jx1gi8GfweFg8BZa/C0f8NNTRGBMV4uPjycnJCXUYUcmahvzJPR7adrVOY2NMVPA0EYjIKSKyXERWisgtDez3MxFREfF7j2vQ1Q5Et+pjKNsQ6miMMcZTniUCEYkFHgROBfoB54tIPz/7pQHXAF97Fcshyb8QtAa+eyHUkRhjjKe8rBEMA1aq6mpVrQAmA+P87Pdn4G6g3MNYmq59DmSPcpqHampCHY0xxnjGy0TQFVjv877IXbePiAwBuqvqtIZOJCJXiMhsEZkd1DsKBk+AbYWw9vPglWmMMUEWss5iEYkB7gGub2xfVX1UVQtUtSArK8v74Gr1OxMSbSA6Y0zr5mUi2AD4TvfVzV1XKw3oD8wQkULgKGBq2HQYA8Qnw4CfwZI3obws1NEYY4wnvEwE3wK9RSRHRBKA84CptRtVtUxVM1U1W1Wzga+AM1XVo6FFD9Hg8VC1Bxa9HupIjDHGE54lAlWtAq4C3geWAi+r6mIRuUNEzvSq3BbXZQh0PALmPRvqSIwxxhOePlmsqu8A79RZd1s9+472MpZDVjsQ3fu3wg9L4LCD7oA1xpiIZk8WB2LguRATbwPRGWNaJUsEgUjtAIefBt+9CFUVoY7GGGNalCWCQA2eALtL4Pv3Qh2JMca0KEsEgeo1BtK62DMFxphWxxJBoGJiIf98WPkhbN8Y6miMMabFWCJoin0D0b0Y6kiMMabFWCJoig69oOdIp3nIptMzxrQSlgiaavB4+HE1rPsy1JEYY0yLsETQVP3GQUIazLUnjY0xrYMlgqZKSHEHonsDyreHOhpjjGk2SwSHYvAEqNztTHBvjDERzhLBoeg6FLJ+YgPRGWNaBUsEh6J2ILqib2HLslBHY4wxzWKJ4FANPBdi4mC+PWlsjIlslggOVZss6HsqfDcZqitDHY0xxhwySwTNMXgC7CqG798PdSTGGHPILBE0R68ToE0n6zQ2xkQ0SwTNERsHgy+EFR9AWVGoozHGmENiiaC5hlzkjDtkw1MbYyKUJYLmapftzFUw9xmorgp1NMYY02SWCFpCwSWwfQOs/CjUkRhjTJM1KRGISKqIxHoVTMTqcwq0OQzmPBnqSIwxpskaTAQiEiMiF4jINBHZAiwDNonIEhH5h4jkBSfMMBcb79xKap3GxpgI1FiNYDrQC7gV6KSq3VW1IzAS+Aq4W0TGexxjZKjtNLbhqY0xESauke0nqupBj82q6o/Aa8BrIhLvSWSRpl1PyDvB6TQ+9kbn1lJjjIkADdYIapOAiPQSkUT39WgRmSQiGb77GGDoJbBjo9NEZIwxESLQzuLXgGq3T+BRoDvwgmdRRao+JztPGs95KtSRGGNMwAJNBDWqWgWcBfxLVW8EOnsXVoSKjYchE2Dlh1C6PtTRGGNMQAJNBJUicj5wMfC2u876BvzZ96SxdRobYyJDoIngEmAE8BdVXSMiOUDEfdPV1Kj3hWT0gLwT7UljY0zECCgRqOoSVZ2kqi+KSDsgTVXv9ji2FvXyt+s56d5P2VtV7X1hBZfAjk2wwoanNsaEv4ASgYjMEJG2ItIemAs8JiL3eBtayzosPYlVxbuYOn+j94X1PhnSOlunsTEmIgTaNJSuqtuBs4FnVHU4cKJ3YbW8Y3tn0vewNP47aw2qHjcRxca5Txp/CKXrvC3LGGOaKdBEECcinYFfsL+zuFEicoqILBeRlSJyi5/tV4rIQhGZLyKzRKRfoOduKhHhslE5LNu8g5krtnpVzH5DLnJ+zn3G+7KMMaYZAk0EdwDvA6tU9VsRyQVWNHSAOzjdg8CpQD/gfD9f9C+o6gBVzQf+Dnja3DQuvwtZaYk8NnO1l8U4MrpD75OcISes09gYE8YC7Sx+RVUHquqv3PerVfVnjRw2DFjp7lsBTAbG1Tnvdp+3qYCnbTaJcbFcPKInM1dsZdnm7Y0f0FxDL4Gdm+H797wvyxhjDlGgncXdRGSKiGxxl9dEpFsjh3UFfJ+qKnLX1T33b0RkFU6NYFI95V8hIrNFZHZxcXEgIdfrwuE9SYqP4fGZa5p1noD0/h9I62KdxsaYsBZo09CTwFSgi7u85a5rNlV9UFV7ATcDf6hnn0dVtUBVC7KysppVXrvUBM4Z2p03529gy/byZp2rUbFx7pPGH8G2td6WZYwxhyjQRJClqk+qapW7PAU09o28AWdMolrd3HX1mQz8NMB4muWykTlU1ShPf1nofWGDJ4CIdRobY8JWoImgRETGi0isu4wHSho55lugt4jkiEgCcB5OrWIfEent83YsjXRAt5TszFRO+slhPP/1OnZXeNyRm9Ed8k5yJrevtoFajTHhJ9BEcCnOraObgU3Az3GGnaiXO0jdVTh3Gy0FXlbVxSJyh4ic6e52lYgsFpH5wHU4YxkFxS+PzaV0dyWvzQnCjGIF1mlsjAlf4vnDVS2soKBAZ8+e3ezzqCo//c8XlO2u4OPrRxMbIy0QXT2qq+D+gZB1OEx43btyjDGmHiIyR1UL/G1rcBotEfkXDdzSqap+7/KJBCLCL0flcNUL8/ho6Q+cfEQn7wqrfdL407thWyG0y/auLGOMaaLGmoZmA3MaWCLaKUd0omtGMo8H4wGzIdZpbIwJT41NrNsVeFdV5wUjmGCLi43hkmOyuXPaUuavLyW/e4Z3haV3c54rmPccjL7VmcTGGGPCQGM1glXANSIyT0SeEpFz3WGoW41zj+xOWmJccIadGHoJ7PwBlr/rfVnGGBOgxiavf0lVJ6rqYOB+IBd4XUQ+E5HbRGRYUKL0UFpSPOcP78G7Czex/sfd3hbW+yRo2xXmtMizeMYY0yICvX0UVZ2nqn9T1eOB04HFwOWeRRZEE4/OJkaEJz8v9LagmFhnVNJVnzidxsYYEwYCTgQicrSIXCAiF+E8AZyqqld4FlkQdclIZuzAzrz07TrK9nj80NfgCSAxMOdpb8sxxpgABTro3LPAP4GRwJHu4vd+1Ej1y1G57KqoZvI3Hk8kk94V+pxiTxobY8JGY3cN1SoA+mmkPX3WBP27pnNUbnue+qKQS0fmEB8bcGWp6YZOhOXvOEu/cY3ubowxXgr0224R4OETV+Hhl6Ny2VRWzrQFm7wtKO9EaNsNZlunsTEm9AJNBJnAEhF5X0Sm1i5eBhYKx/ftSG5WKo/NXO3tvMa1ncarp8OPQbht1RhjGhBoIrgdp4P4r8D/+SytSkyMcPnIXBZv3M6XqxsbXLWZhkwAibUnjY0xIRfoVJWf+lu8Di4Uzh7SlQ6pCfzX6xnM2nbZ32lcVeFtWcYY04AGE4GIzHJ/7hCR7T7LDhEJwqS/wZcUH8v4o3ry8bItrNyy09vChk6EXcVOp7ExxoRIY08Wj3R/pqlqW58lTVXbBifE4JswoicJcTH8d5bHtYK8EyC9uz1pbIwJqSbdIykiHUWkR+3iVVChltkmkZ8N6crrc4so2bnXu4L2dRrPgJJV3pVjjDENCPSBsjNFZAWwBvgUKARa9chpl43MZW9VDc9+5fGk84Ot09gYE1qB1gj+DBwFfK+qOcAJwFeeRRUG8jq2YczhHXn2y7WUV1Z7V1DbztD3VJj/vHUaG2NCItBEUKmqJUCMiMSo6nRa2RAT/lw+KoeSXRVMmbfB24JqO42Xve1tOcYY40egiaBURNoAnwHPi8j9wC7vwgoPI3I7cESXtjw+czU1NR4+YNZrDKT3gDlPeVeGMcbUI9BEMA7YDfwWeA9nwpozvAoqXDjzGueyqngXM77f4l1BtZ3Gaz61TmNjTNA1mghEJBZ4W1VrVLVKVZ9W1QfcpqJWb+zAznRqm8Rjn3l8K+ng8W6nsQ1PbYwJrkYTgapWAzUikh6EeMJOfGwME4/J5svVJSzaUOZdQbWdxvOs09gYE1yBNg3tBBaKyH9F5IHaxcvAwsn5w3qQmhDL417Pazz0Eti9FZa95W05xhjjI9BE8DrwR5zO4jnuMturoMJNenI8vziyO28v2MSmsj3eFdRrDGRYp7ExJrgCTQQZbt/AvgVo52Vg4ebSY3KoUeUpL+c1jomBIRfDms+s09gYEzSBJoKL/ayb2IJxhL3u7VM4tX9nXvhmHTv3VnlX0ODxEBNn4w8ZY4KmsdFHzxeRt4Ac3wlpRGQ68GNwQgwfl4/KYUd5FS99u967QtI6uU8avwBVHo5zZIwxrsbmLP4C2IQzQ5nvRDQ7gAVeBRWuBvdoR0HPdjz5+RouHtGTOK/mNR46EZa+BUvehIG/8KYMY4xxNfZNtk5VZ6jqiDqT0sxV1SoAEZEgxBk2Lh+VS9G2Pby/+AfvCskdAx2PgA/+ALu2eleOMcbQeCKYLiJX1x1yWkQSRGSMiDyN//6DVuukfofRs0OKt/Max8TA2Y/Cnm0w9Wrwcv5kY0zUaywRnAJUAy+KyEYRWSIia4AVwPnAfar6lMcxhpXYGOGykTnMX1/KnLXbvCuoU3848U/O7GWzn/CuHGNM1GtshrJyVf2Pqh4D9MQZfnqwqvZU1V+q6rygRBlmfj60G+nJ8Tzm9QNmw690ni14//dQvNzbsowxUSvg3k5VrVTVTapaGugxInKKiCwXkZUicouf7de5tYwFIvKxiPQM9NyhlJIQx/ijevDBkh8o3OrhIKwxMfDThyAhBV67zO4iMsZ4wqPbXvYNVvcgcCrQDzhfRPrV2W0eUKCqA4FXgb97FU9Lu3hENvExMTzxuceD0aV1gjP/DZsXwid3eluWMSYqeZYIgGHASlVdraoVwGSc4az3UdXpqrrbffsV0M3DeFpUx7ZJnJnfhVdmF1G62+NB4g4/DQouhS8ecOY3NsaYFhTonMWpIhLjvu7jzmEc38hhXQHfJ6+K3HX1uYx65kEWkStEZLaIzC4uLg4k5KC4fFQOeyqref7rdd4X9j9/gcw+MOVK2B11z/IZYzwUaI3gMyBJRLoCHwATgKdaKggRGY8z9eU//G1X1UdVtUBVC7Kyslqq2GY7vFNbRvXO5MnPC72d1xicfoKfPe48V2C3lBpjWlCgiUDcJpyzgf+o6jnAEY0cswHo7vO+m7vuwBOLnAj8HjhTVSOuN/TXo/PYunMvr8z2cNiJWp0HwQm3OXMbz33G+/KMMVEh4EQgIiOAC4Fp7rrYRo75FugtIjkikgCcB0ytc9LBwCM4ScDDuSC9c1Rue4b0yODhT1dTWV3jfYEjroKcY+G9W2DrSu/LM8a0eoEmgmuBW4EpqrpYRHKB6Q0d4A5BcRXwPrAUeNk99g4ROdPd7R9AG+AVEZkvIlPrOV3YEhF+c3weG0r3MHX+Ru8LjImBsx6BuET3llKbzcwY0zzS1GES3E7jNqq63ZuQGlZQUKCzZ4fXnDiqyqn3z6SqRvng2mOJiQnC8EtL34KXxsPI6+DE//W+PGNMRBOROapa4G9boHcNvSAibUUkFVgELBGRG1syyEgmIvz6+DxWbtnJB0s8HIzO10/OgCEXwax7Yc3M4JRpjGmVAm0a6ufWAH6Kc4tnDs6dQ8Y1dkBnsjuk8J8ZK70bjK6uk/8G7XNhyv9zBqgzxphDEGgiiHefG/gpMFVVKwG7f9FHbIxw5XG9WFBUxqyVQRo6OrEN/Owx2PkDvHWt3VJqjDkkgSaCR4BCIBX4zB0TKCR9BOHsrCFd6dQ2iQenB/Funq5D4fjfw5I34LsXg1euMabVCCgRqOoDqtpVVU9Tx1rgeI9jiziJcbH88thcvlr9I3PWBvHp32OugZ4j4Z0bbdJ7Y0yTBdpZnC4i99QO8yAi/4dTOzB1nD+sO+1S4vnP9CB+IcfEwtmPOD9fvwKqK4NXtjEm4gXaNPQEzjzFv3CX7cCTXgUVyVIS4rj0mBw+XraFJRuD2HqW3g1Ovw82zIZPI2YQV2NMGAg0EfRS1f91RxJdrap/AnK9DCySXTQimzaJcTz0aZCbafqfDfkXwsx/wtovg1u2MSZiBZoI9ojIyNo3InIMsMebkCJfeko844/qybQFG1nj5cQ1/px6N2T0cJqI9pQGt2xjTEQKNBFcCTwoIoUiUgj8G/h/nkXVClw2Mof42BgeCXatIDENzn4ctm+Ad24IbtnGmIgU6F1D36nqIGAgMFBVBwNjPI0swmWlJXLukd15bW4Rm8qCXHnqfiSMvgUWvgILXg5u2caYiNOkGcpUdbvPGEPXeRBPq3LFsbmowmOfeTydpT+jroceI2Da9bCtMPjlG2MiRnOmqgzCyGqRrVu7FMbld+XFb9ZRsjPIUy3ExDqjlIJ7S2lVcMs3xkSM5iQCG88gAL8anUt5VTVPfVEY/MLb9YSx98D6r2Hm/wW/fGNMRGgwEYjIDhHZ7mfZAXQJUowRLa9jGif368RTXxSyozwED3oNPAcG/AI+vRvWfxP88o0xYa/BRKCqaara1s+SpqpxwQoy0v36+F7sKK/iua+CMMm9P2P/Celd4bXLodyGiDLGHKg5TUMmQAO7ZTCqdyb/nbXa+0nu/UlKh7Mfg7L18O5NwS/fGBPWLBEEyW+Oz2PrzgpeDsYk9/70OAqOvdEZofTVS2F7EKbVNMZEBEsEQTI8pz1De7bjkWBNcu/PsTfB6Fth6dvw7yPh8wdsgDpjjCWCYHEmue8VvEnu/YmNcx40+81XkD0SPvwjPDwS1nwWmniMMWHBEkEQHd+3I4d3SuM/M1ZSUxPCu2/b58IFL8H5k6FyDzx9hjUXGRPFLBEEkVMryGNV8S4+WLI51OFA31PhN1/DcbdYc5ExUcwSQZCd5k5y/+D0VcGb5L4h8clw/K0HNhc9dAys/jTUkRljgsQSQZDFxgi/Gt2LhRvKmLkiSJPcB8K3uaiqHJ45E165xJqLjIkClghC4KzB3eicHuRJ7gNV21w0+lZYNs2ai4yJApYIQiAhLoZfjsrl6zU/MrswiJPcByo+2b276GtrLjImClgiCJHzhnWnfWoC/5kR5IlrmqJ9jjUXGRMFLBGEiDPJfTafLNvC4o1loQ6nYXWbi/5VAJ/fD1UVoY7MGNMCLBGE0ITaSe7DuVZQy7e5KOdY+PA2ePgYWD0j1JEZY5rJEkEIpSfHM2FET6Yt3MTq4p2hDicw7XPggslw/ktQtReeGQevTISyDaGOzBhziCwRhNilx+SQEBvDI5+uDnUoTdP3FJ/monfgvgHwxCnw6T9gwxyoCdF4SsaYJrNEEGJZaYmcd2R3Xp9XxMbSIE9y31y+zUUjr3WGq5h+Jzw2Bv6ZB69eBvNfgB0/hDpSY0wDJCyebm2CgoICnT17dqjDaFFF23Yz+h8zmDCiJ/97xhGhDqd5dhbD6umw8mNY9THsKnbWHzYA8sZA3onQ/SiISwhtnMZEGRGZo6oFfrd5mQhE5BTgfiAWeFxV76qz/VjgPmAgcJ6qvtrYOVtjIgC44ZXveHvBRj6/eQwd2iSGOpyWUVMDPyx0k8InsO5LqKmC+FSnwznvBOg1Bjr0CnWkxrR6DSUCz6abFJFY4EHgJKAI+FZEpqrqEp/d1gETgRu8iiNSXHlcL16bW8STnxdyw8l9Qx1Oy4iJgc6DnGXUdbB3B6yZCSs/cmoL37/r7Ncux00KJ0DOKEhMC23cxkQZL+cdHgasVNXVACIyGRgH7EsEqlrobov6nsW8jm04tX8nnv6ykCuOy6VtUnyoQ2p5iWlw+GnOAlCyan8T0vwX4dvHISbemU2tl9uMdFh/J6EYYzzjZSLoCvjOy1gEDD+UE4nIFcAVAD169Gh+ZGHq16PzeGfhZp77ai2/Hp0X6nC816GXswy/wrkVdd1XTlJY+Ql8/CdnSUp3axX50GUwdMl3ahAioY7emFbDy0TQYlT1UeBRcPoIQhyOZ/p3Tee4Plk8MWsNlx6TQ1J8bKhDCp64RMg9zllOugN2bHb6FdZ/DRvnw1cPQY078N0BySHfSRCWHIw5ZF4mgg1Ad5/33dx1pgG/OT6PXzzyJS/PXs9FI7JDHU7opHWC/AucBZzhLLYsgU3zYeM8Jzl8/TBUu8Nc1E0OnfOdobUtORjTKC8TwbdAbxHJwUkA5wEXeFheqzAspz1HZjuT3J8/rAfxsdY+Dji3m3bJd5ahE511BySH+c5P3+SQmA5dLDkY0xivbx89Def20FjgCVX9i4jcAcxW1akiciQwBWgHlAObVbXBG+lb6+2jvqYv38IlT37LpBN6c+0JvYmJsS+ugPlLDj8sPjA5dB4Ihx0BmX0gqy9k9oXUTEsQplUL2XMEXoiGRKCq/OaFubyzcDMj8zL5xzkD6ZyeHOqwIldVBRQv3d+ktOk7KF4Olbv275PczkkIWX2cBFH7Or2H3bVkWgVLBBFIVZn87Xr+/PYS4mKEO88awJmDuoQ6rNajpga2b4Cty2HrCicxbP3e+bnbZwrRuGTIzHMTQ9/9tYj2vezpaBNRLBFEsMKtu7ju5fnMXVfKGYO6cOe4/qSntMJnDMLJ7h/dxLAcir/f/7Ns3f59JNYZiTWzL2T23t/ElNkbktqGLnZj6mGJIMJVVdfw8KeruO+jFWS2SeSf5wxiZO/MUIcVfSp2ObWHrSvc5ODWIkpW7b+1FSCti9vE1NfnZ19IzbJ+CBMylghaiYVFZfz25fms3LKTiUdnc8uph0fXswbhqroSthUeXIvYugIqfOaZSMo4sHnJ+iFMEFkiaEXKK6u5+71lPPl5Ib2yUrnv3MEM6JYe6rCMP6pOP0Txcp9ahJskakdlBYhLgg69D65FdOjlPGhnTAuwRNAKzVqxlRte+Y6tO/dy7Ym9ufK4XsTZMweRY/eP+zun9/1cDqXrAff/pMRCu2y3czoXOuS5w3LkQVpna2YyTWKJoJUq213JH99cxNTvNjKkRwb3/CKf7MzUUIdlmqNiN5Ss8LmTya1N/Lgaqsr37xef4ty51KE2QeS57/Mgpb0lCXMQSwSt3JvzN/DHNxZRVaP8YWw/zh/WHbEvgtal9nbXkpXw4yqng7pklfO+dK0zz0OtpPQDE0Pt4H7te9kdTVHMEkEU2FS2hxtfWcCslVsZc3hH7vrZADqmJYU6LBMM1ZVQus5JCrXJoTZZlBWxr6kJILXj/sTQoff+zut22RBjNx60ZpYIokRNjfLMl4X87d1lpCbG8dezBnBK/06hDsuEUuUe+HGNT3JYCSWrnZ+7tuzfLzbBqT3su6PJ/dkhz5mb2kQ8SwRRZuWWHVz70nwWbdjOOUO7cdsZ/UhrjRPdmObZs+3gvoji5c6tsPtqEQLteh78TERmH0jOCF3spsksEUShiqoa/vXJCh6cvpIuGcn83zmDGJ7bIdRhmUhQWe7UGOo+WV2yEqr37t+vzWHuuEx1ahF2R1NYskQQxeas3cZ1L89n3Y+7ueLYXK47qQ+JcdYWbA5BTbVTW6j7TETx97C3bP9+iW2doTbq1iIyekJsRMyF1SpZIohyu/ZWcee0pbz4zTr6HNaGMYcfRm5mKrlZqeRkptI+NcHuMjKHThV2/nDwMxHF38POzfv3s36IkLJEYAD4eOkP/OP95awq3kll9f5/97ZJceRktXGSQ2YqOW6CyMlMJSXB/oIzzbCn9OCxmYqXO7e8ao27U20/RJ+Dh99IbhfK6FsVSwTmAFXVNWwo3cPqrbtYU7yLNVudZXXxTjaWlR+wb6e2SU5SyEr1qUW0oVu7ZJs9zRy6g/ohapcVB/ZDpHbcX3vwfbI6owfE2g0QTWGJwARsT0U1hSW+yWEXq7fuZHXxLsr27B9hMy5G6NE+hRw3OXRvn0K7lAQyUuL3/cxISSA1IdaanUzgaqqd2oJv/4O/foiYOKfPoe4Dcx3yoG1XG8TPD0sEpkVs21Xh1CK27mKNmxxqE8beqhq/x8THChkpCWQkOwkiPSWedim+r51tGSkJtEuNJyPZSSI2qqo5gCrsLvH/0FzJKqjas3/fuCRnbKa64zN1yIvqocAtERhP1dQoW3ftpXR3JaW7K9m2u4Iy9+e23ZWU7alg265KSvdU7Nu+bXclFfUkD4Ck+BgnWSTH71syUuIPeJ9ed3tyPG2T44m1OZ6jS00N7Njk88Ccmxx+XOU8TOc7V0RCms+T1Xn7O68ze0NC6x6nyxKBCUt7KqoprU0Suyso3eMkCSehOMmidHcl2/dUUuYupXsqKK+sP4EApCXG0dZv4qjzvs6SlmRJpNWproKy9XVqEW6yKF3HAcNvpHc/+I6mzL6Q2jqev2koEdgtISZkkhNiSU5IpnN6024d3FtVTdkeJ0GU7t6fJMp83m/flzgqWbFl577tDdVCRKBNYly9iaJtA0nEaiJhKjbOmVK0fQ70PvHAbVV7nVFd6972uvaLA5uaUjrUeSbC/ZnerdU0M1kiMBEnMS6WjmmxTR5UT1Upr6w5IHHUXbbXeR9oEoH9NZGDEkVKw4mkbVKczSURCnGJ0PEnzuKrpsaZn3pfR7U7/MaSN51hOWrFp/rMV917/4Nz7XMj7o4maxoyJkDlldUHJYpAkknZnspGm7NqayJOsvBfK/GXSNomx9ttvMGiCru2HvxMxNbvnSHCa8XEOcmg7jMRmX1C2g9hTUPGtICk+FiS4mPp2Lbpw3uXV1azvdx/c5a/JLJm666Ak0hqQmzDTVcN1EgsiTSBCLTJcpbskQdu27vDTQw+t7sWL4Pl74JW798vTPshLBEYEwT7ksghzBHh2ydyQOLYXUnZnqqDEsnakt373u+prG7w3CluEmmsD8R3e1u3xmJjVvlITIOuQ53FV1WF00F9wLzV4dcPYYnAmDB3qH0i4IxC21izle+y/sfdLHJf765oOIkkxcc0qUPdd5+oeU4kLqGBfoj1B4/NVF8/RGYfJzn0PQ0OO6Llw2zxMxpjwkZCXAxZaYlkpSU2+diKqhq2l9fT/+Gneato2x62b9xO2Z5KdjWSRBLjDk4i9SaSOrf9tookEhPjjK/Urif0Pmn/+oP6IVbsv5Np4cvQppMlAmNM8CTExZDZJpHMNk1PIpXVNX5rH/XVSDaWlbNs8w7K9lSyc29Vg+dOqCeJNNQ/EjFJpMF+iJ2eNRNZIjDGtLj42Bg6tEmkwyEkkarqGraXV/lNGP5qJJvLylm+eQfb91SyoxlJxP9dWfvv4EqOD/G4WYltPDu1JQJjTFiJi42hfWoC7VMTmnxsVXUNO+pLIuUH10q27ChnxZYdlO12kkhDd9MnxMbQNrmeZ0Ua6SNJCfPBFy0RGGNajbjYGNqlJtDuEJJIdY2ys54k4q9WUrKzYt+ovNvLKxtMIvGxQtuk+pNFRkpok4glAmOMAWJjxOlTSGn6U8E1NcqOvVUBP3C4bXcFhSW79r2vaSCJxMXIvqTw25P6cMagLs34lPWU0eJnNMaYKBPj82XdvYnH1tQoOyuq9vV7NJRM2qU0vaYTCE8TgYicAtwPxAKPq+pddbYnAs8AQ4ES4FxVLfQyJmOMCScxMU6zUdukpieRFovBqxOLSCzwIHAq0A84X0T61dntMmCbquYB9wJ3exWPMcYY/7wcaGQYsFJVV6tqBTAZGFdnn3HA0+7rV4ETJJy71o0xphXyMhF0Bdb7vC9y1/ndR1WrgDLgoNGXROQKEZktIrOLi4s9CtcYY6JTRAw9qKqPqmqBqhZkZWWFOhxjjGlVvEwEG+CAvo9u7jq/+4hIHJCO02lsjDEmSLxMBN8CvUUkR0QSgPOAqXX2mQpc7L7+OfCJRtpMOcYYE+E8u31UVatE5CrgfZzbR59Q1cUicgcwW1WnAv8FnhWRlcCPOMnCGGNMEHn6HIGqvgO8U2fdbT6vy4FzvIzBGGNMwyJuzmIRKQbWHuLhmcDWFgzHa5EUbyTFCpEVbyTFCpEVbyTFCs2Lt6eq+r3bJuISQXOIyOz6Jm8OR5EUbyTFCpEVbyTFCpEVbyTFCt7FGxG3jxpjjPGOJQJjjIly0ZYIHg11AE0USfFGUqwQWfFGUqwQWfFGUqzgUbxR1UdgjDHmYNFWIzDGGFOHJQJjjIlyUZMIROQUEVkuIitF5JZQx+NLRLqLyHQRWSIii0XkGnd9exH5UERWuD/bhTrWWiISKyLzRORt932OiHztXt+X3GFFwoKIZIjIqyKyTESWisiIML+2v3V/DxaJyIsikhQu11dEnhCRLSKyyGed32spjgfcmBeIyJAwifcf7u/CAhGZIiIZPttudeNdLiInhzpWn23Xi4iKSKb7vkWvbVQkggAnyQmlKuB6Ve0HHAX8xo3vFuBjVe0NfOy+DxfXAEt93t8N3OtOMrQNZ9KhcHE/8J6qHg4Mwok7LK+tiHQFJgEFqtofZ3iW8wif6/sUcEqddfVdy1OB3u5yBfBQkGL09RQHx/sh0F9VBwLfA7cCuP/nzgOOcI/5j/vdESxPcXCsiEh34H+AdT6rW/TaRkUiILBJckJGVTep6lz39Q6cL6quHDhxz9PAT0MSYB0i0g0YCzzuvhdgDM7kQhBesaYDx+KMa4WqVqhqKWF6bV1xQLI7Im8KsIkwub6q+hnOuGC+6ruW44Bn1PEVkCEinYMSqMtfvKr6gTv/CcBXOCMjgxPvZFXdq6prgJU43x0hi9V1L3AT4HtnT4te22hJBIFMkhMWRCQbGAx8DRymqpvcTZuBw0IVVx334fxi1rjvOwClPv+5wun65gDFwJNuU9bjIpJKmF5bVd0A/BPnr79NOJM1zSF8ry/Ufy0j4f/dpcC77uuwi1dExgEbVPW7OptaNNZoSQQRQUTaAK8B16rqdt9t7vDcIb/XV0ROB7ao6pxQxxKgOGAI8JCqDgZ2UacZKFyuLYDbvj4OJ4F1AVLx01wQrsLpWjZGRH6P0yz7fKhj8UdEUoDfAbc1tm9zRUsiCGSSnJASkXicJPC8qr7urv6htrrn/twSqvh8HAOcKSKFOE1sY3Da4DPcpgwIr+tbBBSp6tfu+1dxEkM4XluAE4E1qlqsqpXA6zjXPFyvL9R/LcP2/52ITAROBy70mQMl3OLthfMHwXfu/7duwFwR6UQLxxotiSCQSXJCxm1j/y+wVFXv8dnkO3HPxcCbwY6tLlW9VVW7qWo2znX8RFUvBKbjTC4EYRIrgKpuBtaLSF931QnAEsLw2rrWAUeJSIr7e1Ebb1heX1d913IqcJF7h8tRQJlPE1LIiMgpOE2bZ6rqbp9NU4HzRCRRRHJwOmK/CUWMAKq6UFU7qmq2+/+tCBji/k637LVV1ahYgNNw7hBYBfw+1PHUiW0kTnV6ATDfXU7DaXv/GFgBfAS0D3WsdeIeDbztvs7F+U+zEngFSAx1fD5x5gOz3ev7BtAunK8t8CdgGbAIeBZIDJfrC7yI03dR6X4xXVbftQQE5269VcBCnDuhwiHelTjt67X/1x722f/3brzLgVNDHWud7YVAphfX1oaYMMaYKBctTUPGGGPqYYnAGGOinCUCY4yJcpYIjDEmylkiMMaYKGeJwBiXiFSLyHyfpcUGohORbH+jShoTDuIa38WYqLFHVfNDHYQxwWY1AmMaISKFIvJ3EVkoIt+ISJ67PltEPnHHg/9YRHq46w9zx7n/zl2Odk8VKyKPiTPXwAcikuzuP0mcuSgWiMjkEH1ME8UsERizX3KdpqFzfbaVqeoA4N84o68C/At4Wp1x7Z8HHnDXPwB8qqqDcMY1Wuyu7w08qKpHAKXAz9z1twCD3fNc6c1HM6Z+9mSxMS4R2amqbfysLwTGqOpqd3DAzaraQUS2Ap1VtdJdv0lVM0WkGOimqnt9zpENfKjO5C2IyM1AvKreKSLvATtxhr94Q1V3evxRjTmA1QiMCYzW87op9vq8rmZ/H91YnHFjhgDf+owyakxQWCIwJjDn+vz80n39Bc4IrAAXAjPd1x8Dv4J9czun13dSEYkBuqvqdOBmIB04qFZijJfsLw9j9ksWkfk+799T1dpbSNuJyAKcv+rPd9ddjTPz2Y04s6Bd4q6/BnhURC7D+cv/VzijSvoTCzznJgsBHlBnKk1jgsb6CIxphNtHUKCqW0MdizFesKYhY4yJclYjMMaYKGc1AmOMiXKWCIwxJspZIjDGmChnicAYY6KcJQJjjIly/x9QJ5elPpmVcgAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot loss curves \n",
    "# IMPORTANT: note that the loss values are converted from tensor to numpy to plot them!\n",
    "plt.plot(epoch_count, np.array(torch.tensor(loss_values).numpy()), label='Train loss')\n",
    "plt.plot(epoch_count, np.array(test_loss_values), label='Test loss')\n",
    "plt.title('Loss variation over epochs')\n",
    "plt.xlabel('Epochs')\n",
    "plt.ylabel('Loss (train/loss)')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Making Predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "with torch.inference_mode():\n",
    "        y_preds = model_0(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_predictions(predictions=y_preds) # after training, the predictions are a lot better!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "parameters after training: OrderedDict([('weights', tensor([0.6638])), ('bias', tensor([0.3153]))])\n",
      "\n",
      "og parameters: 0.7 0.3\n"
     ]
    }
   ],
   "source": [
    "print('parameters after training:', model_0.state_dict())\n",
    "print()\n",
    "print('og parameters:', weight, bias)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Saving/Loading model \n",
    "\n",
    "1. `torch.save()`: pickles your model\n",
    "2. `torch.load()`: loads saved model\n",
    "3. `torch.nn.Module.load_state_dict()`: loads model's saved state dictionary\n",
    "\n",
    "Resource: https://pytorch.org/tutorials/beginner/saving_loading_models.html#saving-loading-model-for-inference"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving model to: models/01_pytorch_workflow_model_0.pth\n"
     ]
    }
   ],
   "source": [
    "# Saving our PyTorch model\n",
    "from pathlib import Path\n",
    "\n",
    "# 1. Create a models direction\n",
    "MODEL_PATH = Path('models')\n",
    "MODEL_PATH.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "# 2. Create model save path\n",
    "MODEL_NAME = '01_pytorch_workflow_model_0.pth'\n",
    "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n",
    "\n",
    "print(f'Saving model to: {MODEL_SAVE_PATH}')\n",
    "\n",
    "# 3. Save the model state dict\n",
    "torch.save(obj=model_0.state_dict(), \n",
    "           f=MODEL_SAVE_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Loading the model:\n",
    "# Since we saved our model's state_dict() only, \n",
    "# we'll create a new instance of the model class and load \n",
    "# the saved state_dict() into it.\n",
    "\n",
    "# instantiate model\n",
    "loaded_model_0 = LinearRegressionModel()\n",
    "\n",
    "# load state_dict\n",
    "loaded_model_0.load_state_dict(torch.load(MODEL_SAVE_PATH))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.6638])), ('bias', tensor([0.3153]))])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loaded_model_0.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([[True],\n",
      "        [True],\n",
      "        [True],\n",
      "        [True],\n",
      "        [True],\n",
      "        [True],\n",
      "        [True],\n",
      "        [True],\n",
      "        [True],\n",
      "        [True]])\n"
     ]
    }
   ],
   "source": [
    "# make predictions with loadd model\n",
    "\n",
    "loaded_model_0.eval()\n",
    "with torch.inference_mode():\n",
    "    loaded_model_preds = loaded_model_0(X_test)\n",
    "\n",
    "print(loaded_model_preds == y_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# saving entire model\n",
    "\n",
    "# torch.save(model_0, MODEL_SAVE_PATH)\n",
    "# loaded_model_0 = torch.load(MODEL_SAVE_PATH)\n",
    "# loaded_model_0.eval()\n",
    "# with torch.inference_mode():\n",
    "#     loaded_model_preds = loaded_model_0(X_test)\n",
    "\n",
    "# print(loaded_model_preds == y_preds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Putting it altogether"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device -- cuda\n"
     ]
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "print(\"Using device --\", device)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.1 Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "weight = 0.7\n",
    "bias = 0.3\n",
    "\n",
    "start = 0\n",
    "end = 1 \n",
    "step = 0.02\n",
    "\n",
    "# features\n",
    "X = torch.arange(start, end, step).unsqueeze(dim=1)\n",
    "# X = torch.arange(start, end, step) # YOU WILL GET DIM ERROR WITH THIS. SO SQUEEZE!!\n",
    "\n",
    "# labels\n",
    "y = weight * X + bias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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]]))"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X[:10], y[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(40, 40, 10, 10)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_split = int(0.8 * len(X))\n",
    "X_train, y_train = X[:train_split], y[:train_split]\n",
    "X_test, y_test = X[train_split:], y[train_split:]\n",
    "len(X_train), len(y_train), len(X_test), len(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_predictions(X_train, y_train, X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.2 Building a PyTorch linear model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "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]))]))"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "class LinearRegressionModelV2(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        # Use nn.Linear() to create model parameters\n",
    "        self.linear_layer = nn.Linear(in_features=1,\n",
    "                                      out_features=1)\n",
    "        \n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        return self.linear_layer(x)\n",
    "    \n",
    "torch.manual_seed(42)\n",
    "model_1 = LinearRegressionModelV2()\n",
    "model_1, model_1.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[0.0000],\n",
       "         [0.0200],\n",
       "         [0.0400],\n",
       "         [0.0600],\n",
       "         [0.0800]]),\n",
       " tensor([[0.3000],\n",
       "         [0.3140],\n",
       "         [0.3280],\n",
       "         [0.3420],\n",
       "         [0.3560]]))"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train[:5], y_train[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.3 Create device agnostic code "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(model_1.parameters()).device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=0)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_1.to(device)\n",
    "next(model_1.parameters()).device"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(device(type='cpu'),\n",
       " device(type='cpu'),\n",
       " device(type='cpu'),\n",
       " device(type='cpu'))"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.device, X_test.device, y_train.device, y_test.device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "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)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(device(type='cuda', index=0),\n",
       " device(type='cuda', index=0),\n",
       " device(type='cuda', index=0),\n",
       " device(type='cuda', index=0))"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.device, X_test.device, y_train.device, y_test.device"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.4 Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(42)\n",
    "LR=0.01\n",
    "EPOCHS = 200\n",
    "\n",
    "loss_fn = nn.L1Loss()\n",
    "optimiser = torch.optim.SGD(params=model_1.parameters(),\n",
    "                            lr=LR)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 | Loss: 0.5551779866218567 | Test Loss: 0.5739762187004089\n",
      "Epoch: 10 | Loss: 0.439968079328537 | Test Loss: 0.4392664134502411\n",
      "Epoch: 20 | Loss: 0.3247582018375397 | Test Loss: 0.30455657839775085\n",
      "Epoch: 30 | Loss: 0.20954833924770355 | Test Loss: 0.16984669864177704\n",
      "Epoch: 40 | Loss: 0.09433845430612564 | Test Loss: 0.03513690456748009\n",
      "Epoch: 50 | Loss: 0.023886388167738914 | Test Loss: 0.04784907028079033\n",
      "Epoch: 60 | Loss: 0.019956795498728752 | Test Loss: 0.045803118497133255\n",
      "Epoch: 70 | Loss: 0.016517987474799156 | Test Loss: 0.037530567497015\n",
      "Epoch: 80 | Loss: 0.013089174404740334 | Test Loss: 0.02994490973651409\n",
      "Epoch: 90 | Loss: 0.009653178043663502 | Test Loss: 0.02167237363755703\n",
      "Epoch: 100 | Loss: 0.006215683650225401 | Test Loss: 0.014086711220443249\n",
      "Epoch: 110 | Loss: 0.00278724217787385 | Test Loss: 0.005814164876937866\n",
      "Epoch: 120 | Loss: 0.0012645035749301314 | Test Loss: 0.013801801018416882\n",
      "Epoch: 130 | Loss: 0.0012645035749301314 | Test Loss: 0.013801801018416882\n",
      "Epoch: 140 | Loss: 0.0012645035749301314 | Test Loss: 0.013801801018416882\n",
      "Epoch: 150 | Loss: 0.0012645035749301314 | Test Loss: 0.013801801018416882\n",
      "Epoch: 160 | Loss: 0.0012645035749301314 | Test Loss: 0.013801801018416882\n",
      "Epoch: 170 | Loss: 0.0012645035749301314 | Test Loss: 0.013801801018416882\n",
      "Epoch: 180 | Loss: 0.0012645035749301314 | Test Loss: 0.013801801018416882\n",
      "Epoch: 190 | Loss: 0.0012645035749301314 | Test Loss: 0.013801801018416882\n"
     ]
    }
   ],
   "source": [
    "test_losses = []\n",
    "train_losses = []\n",
    "\n",
    "for epoch in range(EPOCHS):\n",
    "    model_1.train()\n",
    "    \n",
    "    #1. forward pass\n",
    "    y_pred = model_1(X_train)\n",
    "    \n",
    "    # 2. Calculate the loss\n",
    "    loss = loss_fn(y_pred, y_train)\n",
    "    train_losses.append(loss)\n",
    "    \n",
    "    # 3. Optimiser zero grad \n",
    "    optimiser.zero_grad()\n",
    "    \n",
    "    # 4. Backprop\n",
    "    loss.backward()\n",
    "    \n",
    "    # 5. Optimiser step\n",
    "    optimiser.step()\n",
    "    \n",
    "    # Testing\n",
    "    model_1.eval()\n",
    "    \n",
    "    with torch.inference_mode():\n",
    "        test_pred = model_1(X_test)\n",
    "        \n",
    "        test_loss = loss_fn(test_pred, y_test)\n",
    "        test_losses.append(test_loss)\n",
    "        \n",
    "    if epoch % 10 == 0:\n",
    "        print(f\"Epoch: {epoch} | Loss: {loss} | Test Loss: {test_loss}\")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('linear_layer.weight', tensor([[0.6968]], device='cuda:0')),\n",
       "             ('linear_layer.bias', tensor([0.3025], device='cuda:0'))])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_1.state_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plotting predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAGpCAYAAADFpuEPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAmqElEQVR4nO3df5iVdZ3/8efbGQUTFn+Na4GuuKGIiANM+IMrgdWK0DQtW0mvzW+l4Gq47pqWW6bu1X5rv37LSxcFal2z6yphbSt2oyxTwtVaGZJFQFFCSsyvsZikiwSD7+8fZ5xGHGCAuc99Zs7zcV1cZ865P+ect9wX+OI+93ndkZlIkiSpuvYpewBJkqR6ZAiTJEkqgSFMkiSpBIYwSZKkEhjCJEmSStBY9gC769BDD82jjjqq7DEkSZJ2acmSJf+dmU1dbet1Ieyoo46itbW17DEkSZJ2KSJ+uaNtfhwpSZJUAkOYJElSCQxhkiRJJeh154R1ZevWraxbt47NmzeXPYqA/v37M2TIEPbdd9+yR5EkqWb1iRC2bt06Bg4cyFFHHUVElD1OXctMNmzYwLp16xg6dGjZ40iSVLMK+zgyIu6MiN9ExPIdbI+IuDUiVkfEsogYs6fvtXnzZg455BADWA2ICA455BCPSkqStAtFnhN2FzB5J9vfCwxr/3UpcMfevJkBrHa4LyRJ2rXCQlhmLgJe3MmSc4C7s+JnwIER8dai5pEkSaolZX47cjDwbKf769of63U2bNhAc3Mzzc3NHH744QwePLjj/pYtW3b63NbWVmbMmLHL9zj11FN7atw3mDhx4i7Lb2+55RY2bdpUyPtLklSvesWJ+RFxKZWPLDnyyCNLnubNDjnkEJYuXQrADTfcwIABA7j66qs7tre1tdHY2PVvdUtLCy0tLbt8j0ceeaRHZt0Tt9xyCxdddBFvectbSptBkqS+pswjYc8BR3S6P6T9sTfJzDmZ2ZKZLU1NXV5+qeZcfPHFTJ8+nZNOOolrrrmGRx99lFNOOYXRo0dz6qmnsmrVKgAWLlzIWWedBVQC3Ec/+lEmTpzI0Ucfza233trxegMGDOhYP3HiRD74wQ8yfPhwLrzwQjITgAULFjB8+HDGjh3LjBkzOl63s1dffZULLriA4447jnPPPZdXX321Y9tll11GS0sLxx9/PJ/73OcAuPXWW/n1r3/NpEmTmDRp0g7XSZKk3VPmkbD5wBURcQ9wErAxM58vcZ4et27dOh555BEaGhr43e9+x0MPPURjYyP3338/1113Hd/61rfe9Jwnn3ySBx98kJdffpljjz2Wyy677E19W4899hgrVqzgbW97G+PHj+fhhx+mpaWFadOmsWjRIoYOHcrUqVO7nOmOO+7gLW95C0888QTLli1jzJg/fCn185//PAcffDDbtm3j9NNPZ9myZcyYMYMvfelLPPjggxx66KE7XDdq1Kge/J2TJKnvK7Ki4pvAT4FjI2JdRHwsIqZHxPT2JQuANcBq4CvAXxY1S1cuvxwaGyu3RTn//PNpaGgAYOPGjZx//vmMHDmSq666ihUrVnT5nDPPPJN+/fpx6KGHcthhh/HCCy+8ac24ceMYMmQI++yzD83Nzaxdu5Ynn3ySo48+uqOba0chbNGiRVx00UUAjBo16g3had68eYwZM4bRo0ezYsUKVq5c2eVrdHedJEnascKOhGVm1yngD9sTKDAC7dzs2bBtW+V25sxi3uOAAw7o+Pmzn/0skyZN4tvf/jZr165l4sSJXT6nX79+HT83NDTQ1ta2R2t21zPPPMPNN9/M4sWLOeigg7j44ou77Prq7jpJkrRzdXvtyGnToKGhclsNGzduZPDgypc/77rrrh5//WOPPZY1a9awdu1aAObOndvlutNOO41vfOMbACxfvpxly5YB8Lvf/Y4DDjiAQYMG8cILL/D973+/4zkDBw7k5Zdf3uU6SZLUfXUbwmbOhLa24o6Cbe+aa67h05/+NKNHj+6RI1fb23///bn99tuZPHkyY8eOZeDAgQwaNOhN6y677DJeeeUVjjvuOK6//nrGjh0LwIknnsjo0aMZPnw4H/7whxk/fnzHcy699FImT57MpEmTdrpOkqTe4idnnUDbPsFPzjqhtBni9W/W9RYtLS25fa/VE088wXHHHVfSRLXjlVdeYcCAAWQml19+OcOGDeOqq64qZRb3iSSplrXtEzQmtAU0vlZcFoqIJZnZZRdV3R4J64u+8pWv0NzczPHHH8/GjRuZVq3PWiVJ6mUenjKStqjclsUjYSqE+0SSJI+ESZIk1RxDmCRJUgkMYZIkSSUwhEmSpD6hFmondochrAds2LCB5uZmmpubOfzwwxk8eHDH/S1btuzy+QsXLuSRRx7puD9r1izuvvvuHp+z88XCd2Tp0qUsWLCgx99bkqSijV+wnMas3PYGZV7Au8845JBDWLp0KQA33HADAwYM4Oqrr+728xcuXMiAAQM49dRTAZg+ffounlGcpUuX0traypQpU0qbQZKkPfHwlJGMX7Cch6eMZELZw3SDR8IKsmTJEiZMmMDYsWN5z3vew/PPPw/ArbfeyogRIxg1ahQXXHABa9euZdasWXz5y1+mubmZhx56iBtuuIGbb74ZgIkTJ3Lttdcybtw4jjnmGB566CEANm3axIc+9CFGjBjBueeey0knncT21R0AP/jBDxg+fDhjxozhX//1Xzsef/TRRznllFMYPXo0p556KqtWrWLLli1cf/31zJ07l+bmZubOndvlOkmSatGEf3+cxteSCf/+eNmjdItHwgqQmXziE5/gu9/9Lk1NTcydO5e//du/5c477+QLX/gCzzzzDP369eOll17iwAMPZPr06W84evbjH//4Da/X1tbGo48+yoIFC7jxxhu5//77uf322znooINYuXIly5cvp7m5+U1zbN68mUsuuYQHHniAt7/97fz5n/95x7bhw4fz0EMP0djYyP333891113Ht771LW666SZaW1v5x3/8R6Byrciu1kmSpL1TtyHs8u9dzuwls5k2dhozz+zZC0j+/ve/Z/ny5bzrXe8CYNu2bbz1rW8FYNSoUVx44YW8//3v5/3vf3+3Xu+8884DYOzYsR0X6P6P//gPrrzySgBGjhzJqFGj3vS8J598kqFDhzJs2DAALrroIubMmQNULij+kY98hKeffpqIYOvWrV2+d3fXSZKk3VO3H0fOXjKbbbmN2Utm9/hrZybHH388S5cuZenSpTz++OP88Ic/BOB73/sel19+OT//+c95xzve0a2Leffr1w+AhoaGHrv492c/+1kmTZrE8uXL+bd/+zc2b968V+skSdLuqdsQNm3sNBqigWlje/76iv369WP9+vX89Kc/BWDr1q2sWLGC1157jWeffZZJkybxxS9+kY0bN/LKK68wcOBAXn755d16j/HjxzNv3jwAVq5cyeOPv/nz7+HDh7N27Vp+8YtfAPDNb36zY9vGjRsZPHgwAHfddVfH49vPsqN1kiRVS2+rnuiuug1hM8+cSdv1bT3+USTAPvvsw7333su1117LiSeeSHNzM4888gjbtm3joosu4oQTTmD06NHMmDGDAw88kPe97318+9vf7jgxvzv+8i//kvXr1zNixAg+85nPcPzxxzNo0KA3rOnfvz9z5szhzDPPZMyYMRx22GEd26655ho+/elPM3r06DccXZs0aRIrV67sODF/R+skSaqW3lY90V1ewLuX2rZtG1u3bqV///784he/4IwzzmDVqlXst99+ZY8G1Oc+kSQV4ydnnfCH6ole8s3H1+3sAt51e2J+b7dp0yYmTZrE1q1byUxuv/32mglgkiT1pNeDV2/o/todhrBeauDAgV32gkmSpN6hbs8JkyRJKpMhTJIkqQSGMEmSVIq+Wj3RXYYwSZJUir5aPdFdhrAe0tDQQHNzMyNHjuT8889n06ZNe/xaF198Mffeey8AH//4x1m5cuUO1y5cuJBHHnmk4/6sWbO4++679/i9JUmqloenjKQtKrf1yG9H9pD999+fpUuXAnDhhRcya9Ys/vqv/7pje1tbG42Nu//b/dWvfnWn2xcuXMiAAQM49dRTAZg+ffpuv4ckSWXoq9UT3eWRsAK8853vZPXq1SxcuJB3vvOdnH322YwYMYJt27bxyU9+kne84x2MGjWK2bMr163MTK644gqOPfZYzjjjDH7zm990vNbEiRM7qih+8IMfMGbMGE488UROP/101q5dy6xZs/jyl7/c0bZ/ww03cPPNNwOwdOlSTj75ZEaNGsW5557Lb3/7247XvPbaaxk3bhzHHHNMR0v/ihUrGDduHM3NzYwaNYqnn366mr9tkiTVFY+E9bC2tja+//3vM3nyZAB+/vOfs3z5coYOHcqcOXMYNGgQixcv5ve//z3jx4/n3e9+N4899hirVq1i5cqVvPDCC4wYMYKPfvSjb3jd9evXc8kll7Bo0SKGDh3Kiy++yMEHH8z06dMZMGAAV199NQA//vGPO57zF3/xF9x2221MmDCB66+/nhtvvJFbbrmlY85HH32UBQsWcOONN3L//fcza9YsrrzySi688EK2bNnCtm3bqvObJklSHarfI2GXXw6NjZXbHvDqq6/S3NxMS0sLRx55JB/72McAGDduHEOHDgXghz/8IXfffTfNzc2cdNJJbNiwgaeffppFixYxdepUGhoaeNvb3saf/dmfven1f/azn3Haaad1vNbBBx+803k2btzISy+9xIQJlYO8H/nIR1i0aFHH9vPOOw+AsWPHsnbtWgBOOeUU/v7v/54vfvGL/PKXv2T//fffu98USZK0Q/UbwmbPhm3bKrc94PVzwpYuXcptt93WcQmhAw44oGNNZnLbbbd1rHvmmWd497vf3SPvv7v69esHVL5Q8PqFuT/84Q8zf/589t9/f6ZMmcIDDzxQymySpN6r3msndkf9hrBp06ChoXJbJe95z3u444472Lp1KwBPPfUU//M//8Npp53G3Llz2bZtG88//zwPPvjgm5578skns2jRIp555hkAXnzxRaBy+aKXX375TesHDRrEQQcd1HG+19e//vWOo2I7smbNGo4++mhmzJjBOeecw7Jly/bqv1eSVH/qvXZid9TvOWEzZ1Z+VdHHP/5x1q5dy5gxY8hMmpqa+M53vsO5557LAw88wIgRIzjyyCM55ZRT3vTcpqYm5syZw3nnncdrr73GYYcdxo9+9CPe97738cEPfpDvfve73HbbbW94zte+9jWmT5/Opk2bOProo/nnf/7nnc43b948vv71r7Pvvvty+OGHc9111/Xof78kqe97eMpIxi9YzsNTRtbttx67KzKz7Bl2S0tLS25/4eonnniC4447rqSJ1BX3iSRJEBFLMrOlq231+3GkJElSiQxhkiRJJegzIay3fazal7kvJEnatT4Rwvr378+GDRv8n38NyEw2bNhA//79yx5FktSDrJ7oeX3ixPytW7eybt06Nm/eXNJU6qx///4MGTKEfffdt+xRJEk9pG2foDGhLaDxtd6VHcq0sxPz+0RFxb777tvRJC9Jknqe1RM9r0+EMEmSVKwJ//545bbkOfqSPnFOmCRJUm9jCJMkSSpBoSEsIiZHxKqIWB0Rn+pi+59ExI8jYllELIyIIUXOI0mSVCsKC2ER0QDMBN4LjACmRsSI7ZbdDNydmaOAm4D/XdQ8kiTpzayeKE+RR8LGAaszc01mbgHuAc7Zbs0I4IH2nx/sYrskSSrQ+AXLaczKraqryBA2GHi20/117Y919l/Aee0/nwsMjIhDtn+hiLg0IlojonX9+vWFDCtJUj16eMpI2qJyq+oq+8T8q4EJEfEYlW+9Pgds235RZs7JzJbMbGlqaqr2jJIk9VkT/v1xGl/LjgoKVU+RPWHPAUd0uj+k/bEOmflr2o+ERcQA4AOZ+VKBM0mSJNWEIo+ELQaGRcTQiNgPuACY33lBRBwaEa/P8GngzgLnkSRJqhmFhbDMbAOuAO4DngDmZeaKiLgpIs5uXzYRWBURTwF/DHy+qHkkSZJqSZ+4gLckSfqDn5x1wh+u8+i5XqXa2QW8yz4xX5Ik9TBrJ3oHQ5gkSX2MtRO9Q5HfjpQkSSV4/SPICSXPoZ3zSJgkSVIJDGGSJEklMIRJkiSVwBAmSVIv8ZOzTqBtn+AnZ51Q9ijqAYYwSZJ6Casn+hZDmCRJvYTVE32LFRWSJPUSVk/0LR4JkyRJKoEhTJIkqQSGMEmSpBIYwiRJKpnVE/XJECZJUsmsnqhPhjBJkkpm9UR9sqJCkqSSWT1RnzwSJkmSVAJDmCRJUgkMYZIkSSUwhEmSVIDLL4fGxsqt1BVDmCRJBZg9G7Ztq9xKXTGESZJUgGnToKGhcit1JTKz7Bl2S0tLS7a2tpY9hiRJ0i5FxJLMbOlqm0fCJEmSSmAIkyRJKoEhTJIkqQSGMEmSdoPVE+ophjBJknaD1RPqKYYwSZJ2g9UT6ilWVEiSJBXEigpJkqQaYwiTJEkqgSFMkiSpBIYwSVLds3ZCZTCESZLqnrUTKoMhTJJU96ydUBmsqJAkSSqIFRWSJEk1xhAmSZJUAkOYJElSCQoNYRExOSJWRcTqiPhUF9uPjIgHI+KxiFgWEVOKnEeSVF+snlAtK+zE/IhoAJ4C3gWsAxYDUzNzZac1c4DHMvOOiBgBLMjMo3b2up6YL0nqrsbGSvVEQwO0tZU9jepRWSfmjwNWZ+aazNwC3AOcs92aBP6o/edBwK8LnEeSVGesnlAtayzwtQcDz3a6vw44abs1NwA/jIhPAAcAZ3T1QhFxKXApwJFHHtnjg0qS+qaZMyu/pFpU9on5U4G7MnMIMAX4ekS8aabMnJOZLZnZ0tTUVPUhJUmSelqRIew54IhO94e0P9bZx4B5AJn5U6A/cGiBM0mSJNWEIkPYYmBYRAyNiP2AC4D52635FXA6QEQcRyWErS9wJkmSpJpQWAjLzDbgCuA+4AlgXmauiIibIuLs9mV/A1wSEf8FfBO4OHvbdZQkSVVn9YT6Aq8dKUnqdayeUG/htSMlSX2K1RPqCzwSJkmSVBCPhEmSJNUYQ5gkSVIJDGGSJEklMIRJkmqCtROqN4YwSVJNmD27Ujsxe3bZk0jVYQiTJNUEaydUb6yokCRJKogVFZIkSTXGECZJklQCQ5gkSVIJDGGSJEklMIRJkgpl/5fUNUOYJKlQ9n9JXTOESZIKZf+X1DV7wiRJkgpiT5gkSVKNMYRJkiSVwBAmSZJUAkOYJGmPWD0h7R1DmCRpj1g9Ie0dQ5gkaY9YPSHtHSsqJEmSCmJFhSRJUo0xhEmSJJXAECZJklQCQ5gkqYO1E1L1GMIkSR2snZCqxxAmSepg7YRUPVZUSJIkFcSKCkmSpBpjCJMkSSqBIUySJKkEhjBJqgNWT0i1xxAmSXXA6gmp9hjCJKkOWD0h1R4rKiRJkgpiRYUkSVKNMYRJkiSVwBAmSZJUAkOYJPViVk9IvVehISwiJkfEqohYHRGf6mL7lyNiafuvpyLipSLnkaS+xuoJqfcqLIRFRAMwE3gvMAKYGhEjOq/JzKsyszkzm4HbgH8tah5J6ousnpB6ryKPhI0DVmfmmszcAtwDnLOT9VOBbxY4jyT1OTNnQltb5VZS71JkCBsMPNvp/rr2x94kIv4EGAo8sIPtl0ZEa0S0rl+/vscHlSRJqrZaOTH/AuDezNzW1cbMnJOZLZnZ0tTUVOXRJEmSel6RIew54IhO94e0P9aVC/CjSEmSVEeKDGGLgWERMTQi9qMStOZvvygihgMHAT8tcBZJ6jWsnZDqQ2EhLDPbgCuA+4AngHmZuSIiboqIszstvQC4J3vbRSwlqSDWTkj1obHIF8/MBcCC7R67frv7NxQ5gyT1NtOmVQKYtRNS3xa97QBUS0tLtra2lj2GJEnSLkXEksxs6WpbrXw7UpIkqa4YwiRJkkpgCJMkSSqBIUySqsTqCUmdGcIkqUqsnpDUmSFMkqpk2jRoaLB6QlKFFRWSJEkFsaJCkiSpxhjCJEmSSmAIkyRJKoEhTJL2ktUTkvaEIUyS9pLVE5L2hCFMkvaS1ROS9oQVFZIkSQWxokKSJKnGGMIkSZJKYAiTJEkqgSFMkrpg7YSkohnCJKkL1k5IKpohTJK6YO2EpKLtMoRFxCci4qBqDCNJtWLmTGhrq9xKUhG6cyTsj4HFETEvIiZHRBQ9lCRJUl+3yxCWmZ8BhgH/BFwMPB0Rfx8Rf1rwbJIkSX1Wt84Jy0qt/v9r/9UGHATcGxH/UOBskiRJfVZ3zgm7MiKWAP8APAyckJmXAWOBDxQ8nyT1KKsnJNWK7hwJOxg4LzPfk5n/kplbATLzNeCsQqeTpB5m9YSkWtGdc8I+l5m/3MG2J3p+JEkqjtUTkmpFVE736j1aWlqytbW17DEkSZJ2KSKWZGZLV9ssa5UkSSqBIUySJKkEhjBJkqQSGMIk9QlWT0jqbQxhkvoEqyck9TaGMEl9gtUTknobKyokSZIKYkWFJElSjTGESZIklcAQJkmSVAJDmKSaZe2EpL7MECapZlk7IakvKzSERcTkiFgVEasj4lM7WPOhiFgZESsi4htFziOpd7F2QlJfVlhFRUQ0AE8B7wLWAYuBqZm5stOaYcA84M8y87cRcVhm/mZnr2tFhSRJ6i3KqqgYB6zOzDWZuQW4BzhnuzWXADMz87cAuwpgkiRJfUWRIWww8Gyn++vaH+vsGOCYiHg4In4WEZO7eqGIuDQiWiOidf369QWNK0mSVD1ln5jfCAwDJgJTga9ExIHbL8rMOZnZkpktTU1N1Z1QkiSpAEWGsOeAIzrdH9L+WGfrgPmZuTUzn6FyDtmwAmeSVAOsnpCkYkPYYmBYRAyNiP2AC4D52635DpWjYETEoVQ+nlxT4EySaoDVE5JUYAjLzDbgCuA+4AlgXmauiIibIuLs9mX3ARsiYiXwIPDJzNxQ1EySaoPVE5JUYEVFUayokCRJvUVZFRWSJEnaAUOYJElSCQxhkiRJJTCESeoR1k5I0u4xhEnqEdZOSNLuMYRJ6hHWTkjS7rGiQpIkqSBWVEiSJNUYQ5gkSVIJDGGSJEklMIRJ2imrJySpGIYwSTtl9YQkFcMQJmmnrJ6QpGJYUSFJklQQKyokSZJqjCFMkiSpBIYwSZKkEhjCpDpl9YQklcsQJtUpqyckqVyGMKlOWT0hSeWyokKSJKkgVlRIkiTVGEOYJElSCQxhkiRJJTCESX2ItROS1HsYwqQ+xNoJSeo9DGFSH2LthCT1HlZUSJIkFcSKCkmSpBpjCJMkSSqBIUySJKkEhjBJkqQSGMKkXsD+L0nqewxhUi9g/5ck9T2GMKkXsP9Lkvoee8IkSZIKYk+YJElSjTGESZIklcAQJkmSVAJDmFQiqyckqX4ZwqQSWT0hSfXLECaVyOoJSapfhYawiJgcEasiYnVEfKqL7RdHxPqIWNr+6+NFziPVmpkzoa2tcitJqi+NRb1wRDQAM4F3AeuAxRExPzNXbrd0bmZeUdQckiRJtajII2HjgNWZuSYztwD3AOcU+H6SJEm9RpEhbDDwbKf769of294HImJZRNwbEUd09UIRcWlEtEZE6/r164uYVZIkqarKPjH/34CjMnMU8CPga10tysw5mdmSmS1NTU1VHVDaXdZOSJK6o8gQ9hzQ+cjWkPbHOmTmhsz8ffvdrwJjC5xHqgprJyRJ3VFkCFsMDIuIoRGxH3ABML/zgoh4a6e7ZwNPFDiPVBXWTkiSuqOwb0dmZltEXAHcBzQAd2bmioi4CWjNzPnAjIg4G2gDXgQuLmoeqVpmzrRyQpK0a5GZZc+wW1paWrK1tbXsMSRJknYpIpZkZktX28o+MV+SJKkuGcIkSZJKYAiTusnqCUlSTzKESd1k9YQkqScZwqRusnpCktST/HakJElSQfx2pCRJUo0xhEmSJJXAECZJklQCQ5jqntUTkqQyGMJU96yekCSVwRCmumf1hCSpDFZUSJIkFcSKCkmSpBpjCJMkSSqBIUySJKkEhjD1SdZOSJJqnSFMfZK1E5KkWmcIU59k7YQkqdZZUSFJklQQKyokSZJqjCFMkiSpBIYwSZKkEhjC1KtYPSFJ6isMYepVrJ6QJPUVhjD1KlZPSJL6CisqJEmSCmJFhSRJUo0xhEmSJJXAECZJklQCQ5hqgtUTkqR6YwhTTbB6QpJUbwxhqglWT0iS6o0VFZIkSQWxokKSJKnGGMIkSZJKYAiTJEkqgSFMhbF2QpKkHTOEqTDWTkiStGOGMBXG2glJknbMigpJkqSClFZRERGTI2JVRKyOiE/tZN0HIiIjosshJUmS+prCQlhENAAzgfcCI4CpETGii3UDgSuB/yxqFkmSpFpT5JGwccDqzFyTmVuAe4Bzulj3d8AXgc0FziJJklRTigxhg4FnO91f1/5Yh4gYAxyRmd/b2QtFxKUR0RoRrevXr+/5SbVbrJ6QJGnvlfbtyIjYB/gS8De7WpuZczKzJTNbmpqaih9OO2X1hCRJe6/IEPYccESn+0PaH3vdQGAksDAi1gInA/M9Ob/2WT0hSdLeK6yiIiIagaeA06mEr8XAhzNzxQ7WLwSuzsyd9k9YUSFJknqLUioqMrMNuAK4D3gCmJeZKyLipog4u6j3lSRJ6g0ai3zxzFwALNjuset3sHZikbNIkiTVEi9bJEmSVAJDmDpYPSFJUvUYwtTB6glJkqrHEKYOVk9IklQ9hVVUFMWKCkmS1FuUUlEhSZKkHTOESZIklcAQJkmSVAJDWB9n7YQkSbXJENbHWTshSVJtMoT1cdZOSJJUm6yokCRJKogVFZIkSTXGECZJklQCQ5gkSVIJDGG9lNUTkiT1boawXsrqCUmSejdDWC9l9YQkSb2bFRWSJEkFsaJCkiSpxhjCJEmSSmAIkyRJKoEhrIZYOyFJUv0whNUQayckSaofhrAaYu2EJEn1w4oKSZKkglhRIUmSVGMMYZIkSSUwhEmSJJXAEFYFVk9IkqTtGcKqwOoJSZK0PUNYFVg9IUmStmdFhSRJUkGsqJAkSaoxhjBJkqQSGMIkSZJKYAjbC1ZPSJKkPWUI2wtWT0iSpD1lCNsLVk9IkqQ9ZUWFJElSQayokCRJqjGFhrCImBwRqyJidUR8qovt0yPi8YhYGhH/EREjipxHkiSpVhQWwiKiAZgJvBcYAUztImR9IzNPyMxm4B+ALxU1jyRJUi0p8kjYOGB1Zq7JzC3APcA5nRdk5u863T0A6F0nqEmSJO2hIkPYYODZTvfXtT/2BhFxeUT8gsqRsBkFztMtdn9JkqRqKP3E/MycmZl/ClwLfKarNRFxaUS0RkTr+vXrC53H7i9JklQNRYaw54AjOt0f0v7YjtwDvL+rDZk5JzNbMrOlqamp5ybsgt1fkiSpGooMYYuBYRExNCL2Ay4A5ndeEBHDOt09E3i6wHm6ZeZMaGur3EqSJBWlsagXzsy2iLgCuA9oAO7MzBURcRPQmpnzgSsi4gxgK/Bb4CNFzSNJklRLCgthAJm5AFiw3WPXd/r5yiLfX5IkqVaVfmK+JElSPTKESZIklcAQJkmSVAJDmCRJUgkMYZIkSSUwhEmSJJXAECZJklQCQ5gkSVIJDGGSJEklMIRJkiSVwBAmSZJUAkOYJElSCSIzy55ht0TEeuCXBb/NocB/F/we2nPun9rlvqlt7p/a5v6pXXuzb/4kM5u62tDrQlg1RERrZraUPYe65v6pXe6b2ub+qW3un9pV1L7x40hJkqQSGMIkSZJKYAjr2pyyB9BOuX9ql/umtrl/apv7p3YVsm88J0ySJKkEHgmTJEkqgSFMkiSpBHUdwiJickSsiojVEfGpLrb3i4i57dv/MyKOKmHMutWN/fPXEbEyIpZFxI8j4k/KmLMe7WrfdFr3gYjIiPBr91XUnf0TER9q//OzIiK+Ue0Z61U3/l47MiIejIjH2v9um1LGnPUoIu6MiN9ExPIdbI+IuLV93y2LiDF7+551G8IiogGYCbwXGAFMjYgR2y37GPDbzHw78GXgi9Wdsn51c/88BrRk5ijgXuAfqjtlfermviEiBgJXAv9Z3QnrW3f2T0QMAz4NjM/M44G/qvac9aibf3Y+A8zLzNHABcDt1Z2yrt0FTN7J9vcCw9p/XQrcsbdvWLchDBgHrM7MNZm5BbgHOGe7NecAX2v/+V7g9IiIKs5Yz3a5fzLzwczc1H73Z8CQKs9Yr7rzZwfg76j8w2VzNYdTt/bPJcDMzPwtQGb+psoz1qvu7JsE/qj950HAr6s4X13LzEXAiztZcg5wd1b8DDgwIt66N+9ZzyFsMPBsp/vr2h/rck1mtgEbgUOqMp26s386+xjw/UIn0ut2uW/aD9MfkZnfq+ZgArr3Z+cY4JiIeDgifhYRO/vXv3pOd/bNDcBFEbEOWAB8ojqjqRt29/9Lu9S4V+NINSAiLgJagAllzyKIiH2ALwEXlzyKdqyRykcqE6kcQV4UESdk5ktlDiUApgJ3Zeb/jYhTgK9HxMjMfK3swdTz6vlI2HPAEZ3uD2l/rMs1EdFI5dDwhqpMp+7sHyLiDOBvgbMz8/dVmq3e7WrfDARGAgsjYi1wMjDfk/Orpjt/dtYB8zNza2Y+AzxFJZSpWN3ZNx8D5gFk5k+B/lQuHq3ydev/S7ujnkPYYmBYRAyNiP2onAA5f7s184GPtP/8QeCBtN22Wna5fyJiNDCbSgDznJbq2em+ycyNmXloZh6VmUdROV/v7MxsLWfcutOdv9u+Q+UoGBFxKJWPJ9dUccZ61Z198yvgdICIOI5KCFtf1Sm1I/OBv2j/luTJwMbMfH5vXrBuP47MzLaIuAK4D2gA7szMFRFxE9CamfOBf6JyKHg1lZP1Lihv4vrSzf3zf4ABwL+0f1/iV5l5dmlD14lu7huVpJv75z7g3RGxEtgGfDIzPcpfsG7um78BvhIRV1E5Sf9i//FfHRHxTSr/ODm0/Zy8zwH7AmTmLCrn6E0BVgObgP+11+/pvpUkSaq+ev44UpIkqTSGMEmSpBIYwiRJkkpgCJMkSSqBIUySJKkEhjBJdSsijoiIZyLi4Pb7B7XfP6rk0STVAUOYpLqVmc8CdwBfaH/oC8CczFxb2lCS6oY9YZLqWkTsCywB7gQuAZozc2u5U0mqB3XbmC9JAJm5NSI+CfwAeLcBTFK1+HGkJMF7geepXHhckqrCECaprkVEM/Au4GTgqoh4a7kTSaoXhjBJdSsqV36/A/irzPwVlYvC31zuVJLqhSFMUj27BPhVZv6o/f7twHERMaHEmSTVCb8dKUmSVAKPhEmSJJXAECZJklQCQ5gkSVIJDGGSJEklMIRJkiSVwBAmSZJUAkOYJElSCf4/N6MJBeUy65gAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "with torch.inference_mode():\n",
    "        y_preds = model_1(X_test)\n",
    "        \n",
    "plot_predictions(predictions=y_preds.cpu())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.8600],\n",
       "        [0.8739],\n",
       "        [0.8878],\n",
       "        [0.9018],\n",
       "        [0.9157],\n",
       "        [0.9296],\n",
       "        [0.9436],\n",
       "        [0.9575],\n",
       "        [0.9714],\n",
       "        [0.9854]], device='cuda:0')"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_preds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6.4 Save and Load Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving model to:models/01_pytorch_workflow_model_1.pth\n"
     ]
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "# 1. create models directory\n",
    "MODEL_PATH = Path(\"models\")\n",
    "MODEL_PATH.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "# 2. Create model save path\n",
    "MODEL_NAME = \"01_pytorch_workflow_model_1.pth\"\n",
    "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME\n",
    "\n",
    "# 3. Save the model state dict\n",
    "print(f\"Saving model to:{MODEL_SAVE_PATH}\")\n",
    "torch.save(obj=model_1.state_dict(),\n",
    "           f=MODEL_SAVE_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegressionModelV2(\n",
       "  (linear_layer): Linear(in_features=1, out_features=1, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Load model\n",
    "\n",
    "# create instance\n",
    "loaded_model_1 = LinearRegressionModelV2()\n",
    "\n",
    "# load state dict\n",
    "loaded_model_1.load_state_dict(torch.load(MODEL_SAVE_PATH))\n",
    "\n",
    "# move to device\n",
    "loaded_model_1.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=0)"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(loaded_model_1.parameters()).device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x504 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Evaluate loaded model\n",
    "loaded_model_1.eval()\n",
    "\n",
    "with torch.inference_mode():\n",
    "    loaded_model_1_preds = loaded_model_1(X_test)\n",
    "    \n",
    "plot_predictions(predictions=loaded_model_1_preds.cpu())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}