01_pytorch_workflow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PyTorch Workflow\n",
    "\n",
    "Lets explore an example PyTorch end-to-end workflow.\n",
    "\n",
    "Resources:\n",
    "\n",
    "- Github notebook: https://github.com/mrdbourke/pytorch-deep-learning/blob/main/01_pytorch_workflow.ipynb\n",
    "- Book version of the notebook: https://www.learnpytorch.io/01_pytorch_workflow/\n",
    "- YouTube video: https://youtu.be/Z_ikDlimN6A\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "what_we_are_covering = {\n",
    "    1: \"data (prepare and load)\",\n",
    "    2: \"build model\",\n",
    "    3: \"fitting a 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",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.2.1+cpu'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "from torch import nn  # nn contains all PyTorch's building blocks for neural networks\n",
    "\n",
    "# Check PyTorch version\n",
    "torch.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Data (preparing and loading)\n",
    "\n",
    "Data can be almost anything... in ML.\n",
    "\n",
    "- Excel spreadsheet (rows and columns)\n",
    "- Images of any kind\n",
    "- Videos (YouTube has lots of data...)\n",
    "- Audio like songs and podcasts\n",
    "- DNA\n",
    "- Text\n",
    "\n",
    "ML is a game of two parts:\n",
    "\n",
    "1. Get data into numerical representation.\n",
    "2. Build a model to learn patterns in that numerical representation.\n",
    "\n",
    "To showcase this, let's create some known data using the linear regression formula _(Y = a + bX) or (Y = mX + c) or (Yi = f(Xi, beta) + ei)_\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a simple dataset using linear regression\n",
    "\n",
    "We'll use a linear regression formula to make a straight line with known **parameters**. _(parameter - something that a model learns)_\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "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": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create *known* parameters\n",
    "weight = 0.7  # b\n",
    "bias = 0.3  # a\n",
    "\n",
    "# Create a range of numbers\n",
    "start = 0\n",
    "end = 1\n",
    "step = 0.02\n",
    "\n",
    "X = torch.arange(start, end, step).unsqueeze(dim=1)\n",
    "# y = mx + c\n",
    "y = weight * X + bias\n",
    "\n",
    "X[:10], y[:10], len(X), len(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Splitting our sata into training and test sets (one of the most important concept in ML)\n",
    "\n",
    "Let's create a training and test set with our data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(40, 40, 10, 10)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create a train/test split\n",
    "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": "markdown",
   "metadata": {},
   "source": [
    "### Building a function to visualize our data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_predictions(\n",
    "    train_data=X_train,\n",
    "    train_labels=y_train,\n",
    "    test_data=X_test,\n",
    "    test_labels=y_test,\n",
    "    predictions=None,\n",
    "):\n",
    "    \"\"\"\n",
    "    Plots training data, test data and compares predictions\n",
    "    \"\"\"\n",
    "    plt.figure(figsize=(10, 7))\n",
    "\n",
    "    # Plot training data in blue\n",
    "    plt.scatter(train_data, train_labels, c=\"b\", s=4, label=\"Training data\")\n",
    "\n",
    "    # Plot test data in green\n",
    "    plt.scatter(test_data, test_labels, c=\"g\", s=4, label=\"Testing data\")\n",
    "\n",
    "    # Are there predictions?\n",
    "    if predictions is not None:\n",
    "        # Plot the predictions if they exist\n",
    "        plt.scatter(test_data, predictions, c=\"r\", s=4, label=\"Predictions\")\n",
    "\n",
    "    # Show the legend\n",
    "    plt.legend(prop={\"size\": 14})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "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",
   "metadata": {},
   "source": [
    "## Creating our first PyTorch model for linear regression\n",
    "\n",
    "we'll be using classes so OOP knowledge will come in handy.\n",
    "Useful resource for OOP from Real Python: https://realpython.com/python3-object-oriented-programming/\n",
    "\n",
    "Also, we'll use `nn.Module` a lot, almost everything in PyTorch inherits from `nn.Module`. Its like a building block, it has a lot of helpful in-built things for building PyTorch models.\n",
    "See PyTorch's documentation.\n",
    "\n",
    "y = wx + b, where w and b are parameters, b is the bias.\n",
    "\n",
    "What our model does:\n",
    "\n",
    "- Start with random values (weight and bias)\n",
    "- Look at training data and adjust the random values to better represent (or get close to) the ideal values (the weight and bias values we used to create the data)\n",
    "\n",
    "How does it do so?\n",
    "\n",
    "Through two main algorithms:\n",
    "\n",
    "1. Gradient descent - https://youtu.be/IHZwWFHWa-w\n",
    "2. Backpropagation - https://youtu.be/llg3gGewQ5U\n",
    "   (3blue1brown videos)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# create linear regression model class\n",
    "\n",
    "\n",
    "class LinearRegressionModel(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        # Initialize model parameters\n",
    "        self.weights = nn.Parameter(\n",
    "            torch.rand(1, requires_grad=True, dtype=torch.float)\n",
    "        )\n",
    "        self.bias = nn.Parameter(torch.rand(1, requires_grad=True, dtype=torch.float))\n",
    "\n",
    "    # forward() to define the computation in the model\n",
    "    def forward(self, x: torch.Tensor):  ## torch.Tensor:  # <- \"x\" is the inputs data\n",
    "        return self.weights * x + self.bias"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Breaking down what's happening in our PyTorch linear regression model\n",
    "\n",
    "5.11.00\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### PyTorch essential neural network building modules\n",
    "\n",
    "- `torch.nn` - contains all of the building for neural networks (computational graphs)\n",
    "- `torch.nn.Parameter` - what parameter should our model try and learn, often a PyTorch layer from `torch.nn` will set these for us.\n",
    "- `torch.nn.Module` - The base class for all neural network modules, if you subclass it, you should overwrite `forward`\n",
    "- `torch.optim` - this's where the optimizers in PyTorch live, (they tell the model parameters stored in `nn.Parameters` how to best change to improve gradient descent and in turn reduce the loss)\n",
    "- `def forward()` - All `nn.Module` subclasses require you to overwrite `forward()`, this method defines what happens in the forward computation\n",
    "\n",
    "There are also others we'll encounter later:\n",
    "\n",
    "- `torch.utils.data.Dataset` - Represents a map between key(label) and sample (features) pairs of your data. Such as images and their associated labels.\n",
    "- `torch.utils.data.Dataloader` - Creates a Python iterable over a `torch Dataset` (allows you to iterate over your data)\n",
    "\n",
    "See docs, PyTorch cheat sheet: https://pytorch.org/tutorials/beginner/ptcheat.html\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Checking out the internals of our PyTorch model\n",
    "\n",
    "Now we've created a model, let's see what's inside...\n",
    "\n",
    "So we ca check our model parameters or what's inside our model using `.parameters()`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LinearRegressionModel() \n",
      "\n",
      "[Parameter containing:\n",
      "tensor([0.8823], requires_grad=True), Parameter containing:\n",
      "tensor([0.9150], requires_grad=True)]\n"
     ]
    }
   ],
   "source": [
    "# Create a random seed\n",
    "torch.manual_seed(42)\n",
    "\n",
    "# Create an instance of the model (this is a subclass of nn.Module)\n",
    "model_0 = LinearRegressionModel()\n",
    "\n",
    "print(model_0, \"\\n\")\n",
    "\n",
    "# Check out the parameters\n",
    "print(list(model_0.parameters()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict({'weights': tensor([0.8823]), 'bias': tensor([0.9150])})\n"
     ]
    }
   ],
   "source": [
    "# Create a random seed\n",
    "torch.manual_seed(42)\n",
    "\n",
    "# Create an instance of the model (this is a subclass of nn.Module)\n",
    "model_0 = LinearRegressionModel()\n",
    "\n",
    "print(model_0.state_dict())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can always came back and re-run the cell above to start a fresh with a new untrained model, or functionalize it.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.8823])), ('bias', tensor([0.9150]))])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List named parameters\n",
    "model_0.state_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Out goal is to use backpropagation and gradient descent to adjust the random values(model parameters), to get them as close as possible to the ideal values (weight and bias)\n",
    "\n",
    "In most cases, we won't know what the ideal values are, but in our case, we know them\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0.7, 0.3)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The ideal values\n",
    "weight, bias"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Making predictions with our random model using `torch.inference_mode()`\n",
    "\n",
    "To check our model's predictve 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.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[0.8000],\n",
       "         [0.8200],\n",
       "         [0.8400],\n",
       "         [0.8600],\n",
       "         [0.8800],\n",
       "         [0.9000],\n",
       "         [0.9200],\n",
       "         [0.9400],\n",
       "         [0.9600],\n",
       "         [0.9800]]),\n",
       " tensor([[0.8600],\n",
       "         [0.8740],\n",
       "         [0.8880],\n",
       "         [0.9020],\n",
       "         [0.9160],\n",
       "         [0.9300],\n",
       "         [0.9440],\n",
       "         [0.9580],\n",
       "         [0.9720],\n",
       "         [0.9860]]))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_test, y_test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[1.6208],\n",
       "        [1.6385],\n",
       "        [1.6561],\n",
       "        [1.6738],\n",
       "        [1.6914],\n",
       "        [1.7090],\n",
       "        [1.7267],\n",
       "        [1.7443],\n",
       "        [1.7620],\n",
       "        [1.7796]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Make predictions with model (inference)\n",
    "with torch.inference_mode():\n",
    "    y_preds = model_0(X_test)\n",
    "\n",
    "y_preds"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`torch.inference_mode()` turns off gradient tracking (better than `torch.no_grad()`)\n",
    "\n",
    "Search: x/twitter torch.inference_mode\n",
    "\n",
    "Thread: https://twitter.com/PyTorch/status/1437838231505096708?s=20&t=cnKav09lTgw0-rfri6u7PQ\n",
    "\n",
    "Since the model parameters are untrained (random), the model'spredictions are just random.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Let's visualize them\n",
    "plot_predictions(predictions=y_preds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training a model with PyTorch (intuition building)\n",
    "\n",
    "The whole idea of training is for a model to move from some unknown parameters (these may be random) to some known\n",
    "\n",
    "Or in other words from a poor representation of the data to a better representation of the data\n",
    "\n",
    "One way tp measure how poor or how wrong your model's predictions are is to use a loss function.\n",
    "\n",
    "- Note: **Loss function** may also be called **cost function** or **criterion** in different areas. For our case, we're going to it as a loss function.\n",
    "\n",
    "Things we need to train:\n",
    "\n",
    "- **Loss function:** A function to measure how wrong your model's predictions are to the ideal outputs, lower is better.\n",
    "\n",
    "  There are many loss functions contained in `torch.nn` (see PyTorch docs on loss functions), Here are a few common ones:\n",
    "\n",
    "  - L1Loss (Mean Absolute Error), will suffice for refression tasks. Its implemented with `torch.nn.L1Loss` or `torch.mean(torch.abs(y_pred-y_test))`\n",
    "  - L2Loss (Meas Squares Error)\n",
    "  - Cross Entropy loss\n",
    "  - BCELoss (Binary Cross Entropy Loss), mostly for binary classification.\n",
    "\n",
    "- **Optimizer:** Takes into account the loss of a model and adjusts the model's parameters (e.g. weight and bias in our case) to improve the loss function (minimize loss).\n",
    "  Its in `torch.optim`.\n",
    "  Most common ones are: - `Adam` - `SGD` (Stochastic/random Gradient Descent). It starts by randomly adjusting the model's parameters to minimize the loss value.\n",
    "\n",
    "* Inside the optimizer, you'll often need to set two parameters:\n",
    "\n",
    "  - `params` - the model parameters you'd like to optimize, e.g. `params=model_0.parameters()`\n",
    "  - `lr` - the learning rate is a **hyperparameter** that defines how big/small the optimizer changes the parameters with each step (a small lr results in small changes, a large lr results in larger changes).\n",
    "\n",
    "    - There is also a concept of lr scheduling, _we reduce the lr as we approach the bottom of the slope_ (convergence)\n",
    "\n",
    "  - The learning rate tells the optimizer how much to adjust the parameters, the higher the lr, the more the optimizer adjusts the params.\n",
    "\n",
    "And specifically for PyTorch, we need:\n",
    "\n",
    "- A training loop\n",
    "- A testing loop\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.8823])), ('bias', tensor([0.9150]))])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# model's parameters\n",
    "model_0.state_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Setting up a loss function and optimizer with PyTorch\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting up a loss function\n",
    "loss_fn = nn.L1Loss()\n",
    "\n",
    "# Setting up an optimizer\n",
    "optimizer = torch.optim.SGD(params=model_0.parameters(), lr=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(L1Loss(),\n",
       " 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": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss_fn, optimizer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Training loop and Testing loop in PyTorch (steps and intuition)\n",
    "\n",
    "A couple of things we need in a training loop:\n",
    "\n",
    "0. Loop through the data. One loop through the data is called an **epoch**. Its a _hyperparameter_ because we set it ourselves.Loop through the data and do...\n",
    "\n",
    "   1. **Forward pass** (this involves data moving through our model's `forward()` function/functions) to make predictions on data\n",
    "   2. Calculate the **loss** (compare forward pass predictions to ground truth labels)\n",
    "   3. Optimizer **zero grad**. Zero the gradients of the optimizer (they accumulate over time by default) _They accumulate every epoch, we zero them to start fresh each forward pass._\n",
    "   4. **Backpropagation**/Loss backward - move backwards through the network to calculate the gradients (slope, rate of change..., steepness of a hill..) of each of the parameters of the model with respect to the loss. (compute the gradient of every parameter with `require_grad=True`)\n",
    "   5. **Gradient Descent**/Optimizer step - use the optimizer to adjust our model's parameters to try and minimize the loss\n",
    "\n",
    "   - by default how the optimizer changes will accumulate through the loop so... we have to zero them above in step 3 for the next iteration of the loop\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basically...\n",
    "\n",
    "- **Backpropagation** is calculating the derivative... gradient/slope curves for each of the parameters in the model.\n",
    "\n",
    "- **Gradient descent** is moving through the gradient curve, stepping through it trying to reach the bottom/convergence. (you can think of it as just from its name, descending on the gradients, or _on a hill, trying to reach the bottom_)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The initial random untrained model parameters:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.8823])), ('bias', tensor([0.9150]))])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Model parameter before training\n",
    "untrained_params = model_0.state_dict()\n",
    "untrained_params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss: 0.6860889196395874\n"
     ]
    }
   ],
   "source": [
    "torch.manual_seed(42)\n",
    "\n",
    "# Set number of epochs\n",
    "epochs = 1\n",
    "\n",
    "# Training loop\n",
    "# 0. Loop/Pass the data through the model for a number of epochs\n",
    "for epoch in range(epochs):\n",
    "    # Set the model to training mode\n",
    "    model_0.train()  # sets all params that require gradients to require gradients\n",
    "\n",
    "    # 1. Forward pass\n",
    "    y_pred = model_0(X_train)\n",
    "\n",
    "    # 2. Calculate 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 model's params\n",
    "    loss.backward()\n",
    "\n",
    "    # 5. Step the optimizer (gradient descent)\n",
    "    optimizer.step()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For some reason, this didn't work, parameters changed even the `untrained_parameters` variable seemed to change (might be a problem with notebooks...)\n",
    "\n",
    "I wanted to display the change, the untrained parameters and the parameters that have been updated, lol.\n",
    "\n",
    "we can always refer to the `untrained_parameters` in the cell up before training cell.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "initial untrained/random parameters: \n",
      "OrderedDict({'weights': tensor([0.8784]), 'bias': tensor([0.9050])})\n",
      "\n",
      "Parameters after training for epochs above: \n",
      "OrderedDict({'weights': tensor([0.8784]), 'bias': tensor([0.9050])})\n"
     ]
    }
   ],
   "source": [
    "# model parameters after training for an epoch above\n",
    "changed_params = model_0.state_dict()\n",
    "print(f\"initial untrained/random parameters: \\n{untrained_params}\\n\")\n",
    "print(f\"Parameters after training for epochs above: \\n{changed_params}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's move the training logic into a function we can call throughout\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(model, inputs, num_epochs, loss_fn, optimizer):\n",
    "    running_loss = []\n",
    "    for epoch in range(num_epochs):\n",
    "        # Setting model to train mode to keep track of gradients\n",
    "        model.train()\n",
    "\n",
    "        # Forward pass\n",
    "        outputs = model(inputs)\n",
    "\n",
    "        # Calculating loss\n",
    "        loss = loss_fn(outputs, inputs)\n",
    "        if num_epochs <= 5:\n",
    "            # print(f\"Loss: {loss}\")\n",
    "            print(f\"Loss (Epoch {epoch + 1}): {loss:.4f}\")\n",
    "\n",
    "        # Zero optimizer gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # Backpropagation\n",
    "        loss.backward()\n",
    "        \n",
    "        # Gradient descent\n",
    "        optimizer.step()\n",
    "        \n",
    "        if (epoch + 1) % 10 == 0:\n",
    "            running_loss.append(loss.item())\n",
    "    \n",
    "    print(f\"Running loss: {running_loss}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.8784])), ('bias', tensor([0.9050]))])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_0.state_dict()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Remember, we already defined the `optimizer` and `loss_fn` earlier\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss (Epoch 1): 0.8576\n",
      "Running loss: []\n",
      "\n",
      "Changed params:\n",
      "OrderedDict({'weights': tensor([0.8745]), 'bias': tensor([0.8950])})\n",
      "\n",
      "Groung truth:\n",
      "(0.7, 0.3)\n"
     ]
    }
   ],
   "source": [
    "torch.manual_seed(42)\n",
    "\n",
    "epochs = 1\n",
    "\n",
    "train(\n",
    "    model=model_0,\n",
    "    inputs=X_train,\n",
    "    num_epochs=epochs,\n",
    "    loss_fn=loss_fn,\n",
    "    optimizer=optimizer,\n",
    ")\n",
    "\n",
    "# Print model stats\n",
    "current_params = model_0.state_dict()\n",
    "ground_truth = weight, bias\n",
    "\n",
    "print(f\"\\nChanged params:\\n{changed_params}\\n\\nGroung truth:\\n{ground_truth}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Seeing Gradient Descent in Action\n",
    "\n",
    "When we run the above cell, we can see the parameters changing, and the error.\n",
    "\n",
    "When we run it many times, we can see error reducing and the parameters approaching the `ground_truth`\n",
    "\n",
    "we can even change the epoch to any number, like 5, 10 ... and we can see how the loss is reducing.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Make predictions with our model\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzoAAAJGCAYAAACTJvC6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABMP0lEQVR4nO3de3hU5bn+8XuSkAkgMxQwIYEICIJYMZyEAiIEolTdAVrcYGkh4GmjKEhUCioEtIi2iFROtmwh0ipgEUgqbFQwgYqhVDDWA2AxIBhIAIUZjgGS9fsjv4yMmcDMkMxh5fu5rrnSrFlrzTOTFZrb9b7PazEMwxAAAAAAmEhEsAsAAAAAgOpG0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKYTFewCvFFWVqaDBw+qQYMGslgswS4HAAAAQJAYhqETJ04oISFBERFV37cJi6Bz8OBBJSYmBrsMAAAAACHiwIEDat68eZXPh0XQadCggaTyN2Oz2YJcDQAAAIBgcTqdSkxMdGWEqoRF0KkYrmaz2Qg6AAAAAC47pYVmBAAAAABMh6ADAAAAwHQIOgAAAABMh6ADAAAAwHQIOgAAAABMh6ADAAAAwHTCor20P0pLS3X+/PlglwEERWRkpOrUqRPsMgAAAILGdEHHMAwVFRXJ4XDIMIxglwMEjdVqVZMmTVh7CgAA1EqmCzoOh0PHjx/X1Vdfrfr16192ISHAbAzD0Pnz5+VwOFRYWChJhB0AAFDrmCroGIahw4cPy2azqUmTJsEuBwiaunXrqkGDBvr222919OhRgg4AAKh1TNWMoLS0VKWlpfxRB0iyWCyy2+0qKSlhvhoAAKh1fA46mzdvVmpqqhISEmSxWLRmzZrLHvPGG28oKSlJ9erVU3x8vO6991599913/tR7SRcuXJAkRUWZ6kYV4LeKhgSlpaVBrgQAACCwfA46p06dUlJSkubPn+/V/lu2bNHIkSN133336YsvvtDf/vY3bdu2TQ888IDPxXqLeTlAOX4XAABAbeXzrY877rhDd9xxh9f75+XlqWXLlho3bpwkqVWrVvqf//kfvfjii76+NAAAAAB4pcbn6PTo0UMHDhzQunXrZBiGiouLtXLlSt15551VHlNSUiKn0+n2AAAAAABv1XjQ6dWrl9544w0NGzZM0dHRatq0qex2+yWHvs2cOVN2u931SExMrOkycQUsFov69u17RefIzc2VxWLRtGnTqqWmmtayZUu1bNky2GUAAACgCjUedL788kuNHz9eU6dO1fbt27V+/Xrt27dPY8aMqfKYyZMny+FwuB4HDhyo6TLDnsVi8emB4Ovbty8/CwAAgBpS4+3JZs6cqV69eunJJ5+UJN10002qX7++evfurd/97neKj4+vdIzVapXVaq3p0kwlIyOj0rY5c+bI4XB4fK467dy5U/Xq1buic3Tr1k07d+5k/SMAAABUixoPOqdPn67U7jkyMlJS+QKfqB6ehnxlZmbK4XDU+HCw66+//orPUa9evWo5DwAAACD5MXTt5MmTys/PV35+viRp7969ys/P1/79+yWVDzsbOXKka//U1FStWrVKCxcuVEFBgbZs2aJx48apW7duSkhIqJ53Aa/t27dPFotFo0aN0s6dO/WLX/xCjRs3lsVi0b59+yRJq1ev1q9+9Su1adNG9erVk91uV+/evfX22297PKenOTqjRo2SxWLR3r179corr+j666+X1WpVixYtNH36dJWVlbntX9UcnYq5MCdPntT48eOVkJAgq9Wqm266SStXrqzyPQ4bNkyNGjXSVVddpT59+mjz5s2aNm2aLBaLcnNzvf68srKydPPNN6tu3bqKi4vTAw88oGPHjnnc96uvvtLEiRPVuXNnNW7cWDExMWrbtq0mTZqkkydPVvrMNm3a5PrfFY9Ro0a59lm8eLEGDRqkli1bKiYmRo0aNdKAAQOUk5Pjdf0AAAC1lc93dD7++GMlJye7vk9PT5ckpaWlKTMzU4cOHXKFHqn8D94TJ05o3rx5evzxx9WwYUP169eP9tJBtmfPHv3sZz9Thw4dNGrUKH333XeKjo6WVB5Wo6Ojdcsttyg+Pl5HjhxRdna27r77br3yyit69NFHvX6dJ598Ups2bdJ//dd/acCAAVqzZo2mTZumc+fOacaMGV6d4/z587r99tt17NgxDRkyRKdPn9by5cs1dOhQrV+/Xrfffrtr38LCQvXs2VOHDh3Sz3/+c3Xq1Em7d+/Wbbfdpn79+vn0GS1dulRpaWmy2WwaMWKEGjZsqHfeeUcpKSk6d+6c6/OqsGrVKr322mtKTk5W3759VVZWpq1bt+rFF1/Upk2btHnzZtcCnhkZGcrMzNQ333zjNrSwY8eOrv89duxYJSUlKSUlRVdffbUKCwu1Zs0apaSkaNWqVRo0aJBP7wcAAMBv2dlSTo6UnCwNHBjsarxjhAGHw2FIMhwOxyX3O3PmjPHll18aZ86cCVBloa1FixbGj3/Ee/fuNSQZkoypU6d6PO7rr7+utO3EiRNGhw4dDLvdbpw6dcrtOUlGnz593LalpaUZkoxWrVoZBw8edG0/cuSI0bBhQ6NBgwZGSUmJa3tOTo4hycjIyPD4HgYNGuS2/4YNGwxJxoABA9z2/81vfmNIMmbMmOG2/bXXXnO975ycHI/v+2IOh8Ow2WxG/fr1jd27d7u2nzt3zrj11lsNSUaLFi3cjvn222/daqwwffp0Q5Lx17/+1W17nz59Kv18LlZQUFBp28GDB42EhATjuuuuu+x7MAx+JwAAQDXIyjIMyTAiI8u/ZmUFtRxvs0GNd11DaGratKmefvppj89de+21lbZdddVVGjVqlBwOh/71r395/TpTpkxxazjRpEkTDRo0SCdOnNDu3bu9Ps/LL7/sdgelf//+atGihVstJSUl+tvf/qbY2Fg9/vjjbsePHj1a7dq18/r11qxZI6fTqXvvvVdt27Z1ba9Tp06Vd6KaNWtW6S6PJD3yyCOSpA0bNnj9+lL54ro/Fh8fryFDhug///mPvvnmG5/OBwAA4JecHCkyUiotLf/qwzSAYCLo+Ck7W5owofxrOEpKSvL4R7kkHT58WOnp6Wrfvr3q1avnmj9SER4OHjzo9et06dKl0rbmzZtLko4fP+7VORo2bOjxj/7mzZu7nWP37t0qKSlR165dK3Xts1gs6tmzp9d1f/rpp5Kk3r17V3quR48elRpsSOXNNRYvXqxbb71VjRo1UmRkpCwWixo3bizJt89NkgoKCvTAAw+odevWiomJcf0c5s6d69f5AAAA/JKc/EPIKS2VrnD9xECp8a5rZpSdLQ0aVP6znjNHysoKn6GKFeLi4jxu//7773XzzTdr//796tWrl1JSUtSwYUNFRkYqPz9fWVlZKikp8fp1bDZbpW0VIaG0tNSrc9jtdo/bo6Ki3JoaOJ1OSVJsbKzH/at6z544HI4qzxUZGekKLxcbN26c5s2bp8TERA0cOFDx8fGuwDV9+nSfPrc9e/aoW7ducjqdSk5OVmpqqmw2myIiIpSbm6tNmzb5dD4AAAC/DRxY/gdvbm55yAmTP3wJOn7wdPcuTH7eLlUtVPnaa69p//79eu655/TMM8+4PffCCy8oKysrEOX5pSJUHT582OPzxcXFXp+rIlx5Oldpaam+++47NWvWzLXt8OHDmj9/vm666Sbl5eW5rStUVFSk6dOne/3aUvlQvWPHjukvf/mLfvOb37g9N2bMGFfHNgAAgIAYODDs/uBl6JofwvTunVe+/vprSfLY0esf//hHoMvxSbt27WS1WrV9+/ZKdzsMw1BeXp7X50pKSpLk+T3n5eXpwoULbtsKCgpkGIZSUlIqLZ5a1edWsZ6UpztbVf0cDMPQli1bvHwXAAAAFwn3uRc+Iuj4oeLu3bhx4Tls7VJatGghSfrwww/dtr/55ptat25dMErymtVq1d13363i4mLNmTPH7bmlS5dq165dXp9r0KBBstlsWrx4sb766ivX9vPnz1e60yX98Ll99NFHbsPpvv32W02ePNnjazRq1EiSdODAgSrP9+OfwwsvvKDPP//c6/cBAAAg6Ye5F3Pnln+tBWGHoWt+CsO7d14ZMWKEXnzxRT366KPKyclRixYt9Omnn2rjxo365S9/qVWrVgW7xEuaOXOmNmzYoEmTJmnTpk2udXTeeecd/fznP9f69esVEXH5fG+32/XKK69o1KhRuvnmm3XPPffIbrfrnXfeUd26dd06yUk/dEN7++231bVrV/Xv31/FxcV655131L9/f9cdmov169dPK1eu1JAhQ3THHXcoJiZGSUlJSk1N1ZgxY7RkyRINGTJEQ4cOVePGjbV161bt2LFDd911l9auXVttnxkAAKgFzDD3wkfc0YGb5s2ba9OmTerfv782bNigP/3pTzp37pzee+89paamBru8y0pMTFReXp7++7//Wx999JHmzJmjw4cP67333lObNm0keW6Q4ElaWppWr16t6667Tq+//rpef/119erVSxs2bPDYsS4zM1OPP/64jh07prlz52rr1q1KT0/Xm2++6fH8DzzwgCZOnKijR4/qxRdf1JQpU/T2229Lkjp16qT33ntPnTt31qpVq7R48WI1bNhQW7ZsUdeuXf38dAAAQK1l5rkXVbAYhmEEu4jLcTqdstvtcjgcl/wj9ezZs9q7d69atWqlmJiYAFaIcHDLLbcoLy9PDodDV111VbDLCQh+JwAAgEt2dth1TvPE22zA0DWYzqFDhyoNLfvrX/+qLVu26Pbbb681IQcAAJhUdnb5ULTkZN8Ci1nnXlSBoAPTufHGG9WpUyfdcMMNrvV/cnNz1aBBA82aNSvY5QEAAPjPDAs6BghzdGA6Y8aM0eHDh7V06VLNmzdPu3fv1vDhw7Vt2zZ16NAh2OUBAAD4z1NTAXjEHR2YzowZMzRjxoxglwEAAFD9kpPL7+TUoqYC/iLoAAAAAOGiYkFHEzQVqGkEHQAAACCc1LKmAv5ijg4AAAAQaNnZ0oQJ5V9RIwg6AAAAQCBVdE6bO7f8K2GnRhB0AAAAgECic1pAEHQAAACAQEpO/iHk0DmtxtCMAAAAAAgkOqcFBEEHAAAACDQ6p9U4hq4BAAAA/qJ7Wsgi6CAg+vbtK4vFEuwyvJKZmSmLxaLMzMxglwIAAEIZ3dNCGkHHJCwWi0+P6jZt2jRZLBbl0jVEkpSbmyuLxaJp06YFuxQAAFBT6J4W0pijYxIZGRmVts2ZM0cOh8Pjc4G2dOlSnT59OthlAAAAVJ/kZGnOHLqnhSiCjkl4unOQmZkph8MREncVrrnmmmCXAAAAUL3onhbSGLpWC507d06zZ89W586dVb9+fTVo0EC9e/dWtodxpQ6HQ1OnTtUNN9ygq666SjabTW3atFFaWpq++eYbSeXzb6ZPny5JSk5Odg2Pa9mypes8nuboXDwX5r333lPPnj1Vr149NW7cWGlpafruu+881v+nP/1JP/3pTxUTE6PExERNnDhRZ8+elcViUV8f/kvK999/rzFjxiguLk716tXTzTffrNWrV1e5/+LFizVo0CC1bNlSMTExatSokQYMGKCcnBy3/aZNm6bk5GRJ0vTp092GDO7bt0+S9NVXX2nixInq3LmzGjdurJiYGLVt21aTJk3SyZMnvX4PAAAgyAYOlGbPJuSEIO7o1DIlJSX6+c9/rtzcXHXs2FH33Xefzp8/r7Vr12rQoEGaO3euHnnkEUmSYRgaMGCA/vnPf6pXr176+c9/roiICH3zzTfKzs7WiBEj1KJFC40aNUqStGnTJqWlpbkCTsOGDb2qKTs7W2vXrlVqaqp69uypzZs3a+nSpfr666/14Ycfuu07depUPffcc4qLi9MDDzygOnXq6K233tKuXbt8+hxOnz6tvn376rPPPlOPHj3Up08fHThwQMOGDdPtt9/u8ZixY8cqKSlJKSkpuvrqq1VYWKg1a9YoJSVFq1at0qBBgySVh7p9+/bp9ddfV58+fdzCV8VnsmrVKr322mtKTk5W3759VVZWpq1bt+rFF1/Upk2btHnzZtWpU8en9wQAAK5Adnb5nJvkZEKLWRhhwOFwGJIMh8Nxyf3OnDljfPnll8aZM2cCVFloa9GihfHjH/FTTz1lSDKmTJlilJWVubY7nU6ja9euRnR0tFFYWGgYhmH8+9//NiQZgwcPrnTus2fPGidOnHB9n5GRYUgycnJyPNbSp0+fSrUsWbLEkGRERUUZH374oWv7hQsXjL59+xqSjLy8PNf23bt3G5GRkUazZs2M4uJit9pvuOEGQ5LRp0+fy38wF9X7wAMPuG1fv369IcmQZCxZssTtuYKCgkrnOXjwoJGQkGBcd911bttzcnIMSUZGRobH1//222+NkpKSStunT59uSDL++te/evU+LoffCQAAvJCVZRiSYURGln/Nygp2RbgEb7MBQ9f8lL07WxPWT1D27vBpI1hWVqaFCxeqdevWriFVFRo0aKCpU6fq3LlzWrVqldtxdevWrXQuq9Wqq666qlrqGj58uHr16uX6PjIyUmlpaZKkf/3rX67ty5YtU2lpqR5//HHFxsa61f7MM8/49JpLly5VdHS0nn32WbftAwYMUP/+/T0e06pVq0rb4uPjNWTIEP3nP/9xDeXzRrNmzRQdHV1pe8XdtA0bNnh9LgAAcIXonmZKDF3zQ/bubA1aPkiRlkjN+eccZd2TpYHtQv8W5+7du3Xs2DElJCS45tRc7MiRI5LkGgbWvn173XTTTVq2bJm+/fZbDR48WH379lXHjh0VEVF9GblLly6VtjVv3lySdPz4cde2Tz/9VJJ0yy23VNr/4qB0OU6nU3v37tUNN9ygpk2bVnq+d+/e2rhxY6XtBQUFmjlzpj744AMVFhaqpKTE7fmDBw+qRYsWXtVgGIaWLFmizMxMff7553I4HCorK3M7FwAACBC6p5kSQccPOXtzFGmJVKlRqkhLpHL35YZF0Pn+++8lSV988YW++OKLKvc7deqUJCkqKkoffPCBpk2bprfffluPP/64JOnqq6/WI488oqefflqRkZFXXJfNZqu0LSqq/NIsLS11bXM6nZLkdjenQlxcnNevd6nzVHWuPXv2qFu3bnI6nUpOTlZqaqpsNpsiIiKUm5urTZs2VQo+lzJu3DjNmzdPiYmJGjhwoOLj42W1WiWVNzDw5VwAAOAK0T3NlAg6fkhulaw5/5zjCjt9W/YNdkleqQgUQ4YM0cqVK706pnHjxpo7d65eeeUV7dq1Sx988IHmzp2rjIwM1alTR5MnT67Jkt1U1H/48OFKd06Ki4v9Oo8nns718ssv69ixY/rLX/6i3/zmN27PjRkzRps2bfL69Q8fPqz58+frpptuUl5enurVq+d6rqioyOPdNgAAUMMGDiTgmAxzdPwwsN1AZd2TpXHdx4XNsDWpfCiazWbTxx9/rPPnz/t0rMViUfv27TV27Fi9//77kuTWjrrizs7Fd2CqW1JSkiRpy5YtlZ776KOPvD6PzWZTq1attGfPHhUVFVV6/h//+EelbV9//bUkuTqrVTAMw2M9l/o8CgoKZBiGUlJS3EJOVa8NAAC8lJ0tTZhQ/hW1HkHHTwPbDdTsAbPDJuRI5cPBHnroIX3zzTd64oknPIadzz//3HWnY9++fa51Xy5WcccjJibGta1Ro0aSpAMHDtRA5eXuueceRURE6KWXXtLRo0dd20+dOqUZM2b4dK4RI0bo3Llzmjp1qtv29957z+P8nIo7SD9ud/3CCy/o888/r7T/pT6PinN99NFHbvNyvv3224DeIQMAwFSys6VBg6S5c8u/EnZqPYau1TLTp0/Xjh079Morr2jt2rW69dZbFRsbq8LCQn322Wf69NNPlZeXp9jYWOXn5+uXv/ylunXr5pq4X7F2TEREhCZMmOA6b8VCoU899ZS++OIL2e12NWzY0NVFrDq0a9dOkyZN0vPPP68OHTpo6NChioqK0qpVq9ShQwd9/vnnXjdJmDhxolatWqVFixbpiy++0K233qoDBw7orbfe0l133aW1a9e67T9mzBgtWbJEQ4YM0dChQ9W4cWNt3bpVO3bs8Lj/9ddfr4SEBC1fvlxWq1XNmzeXxWLRo48+6urU9vbbb6tr167q37+/iouL9c4776h///6uu0cAAMAHnjqnMRStVuOOTi1jtVr1f//3f/rTn/6kpk2b6u2339acOXO0efNmxcfHa+HCherQoYMkqWvXrvrtb38ri8WitWvX6qWXXlJubq5SUlK0ZcsWDbzoH48bbrhBS5YsUZMmTTR37lxNmTJFs2bNqvb6Z8yYoQULFugnP/mJXn31Vb311lu6++67tWDBAkmeGxt4Ur9+fW3atEkPPvig/vOf/2jOnDnatWuXVqxYobvvvrvS/p06ddJ7772nzp07a9WqVVq8eLEaNmyoLVu2qGvXrpX2j4yM1KpVq/Szn/1My5Yt09SpUzVlyhQdO3ZMkpSZmanHH39cx44d09y5c7V161alp6frzTffvIJPBwCAWiw5+YeQQ+c0SLIYhmEEu4jLcTqdstvtcjgcl/xD9uzZs9q7d69atWrlNqwK5rdhwwbddtttmjhxol588cVglxMy+J0AANQq2dl0TqsFvM0GDF1DWDly5IgaNWrk1tb6+PHjrrktgwcPDlJlAAAg6OichosQdBBW3njjDc2aNUv9+vVTQkKCDh06pPXr1+vw4cMaNWqUevToEewSAQDAlcrOLp9zk5xMcIHfCDoIKz179lSXLl20YcMGff/994qMjFT79u01ZcoUPfzww8EuDwAAXKmK7mmRkdKcOeULeRJ24AeCDsJKt27dlJWVFewyAABATaF7GqoJXdcAAAAQOuiehmrCHR0AAACEjoEDy4er0T0NV4igAwAAgNBC9zRUA4auAQAAoGZkZ0sTJpR/BQKMoAMAAIDqV9E9be7c8q+EHQQYQQcAAADVz1P3NCCACDoAAACofnRPQ5DRjAAAAADVj+5pCDKCDgAAAKqWnV0+DC052fewQvc0BBFD11Dj9u3bJ4vFolGjRrlt79u3rywWS429bsuWLdWyZcsaOz8AAKZHQwGEMYKOyVSEiosf0dHRSkxM1PDhw/Xvf/872CVWm1GjRslisWjfvn3BLgUAAHOioQDCGEPXTKp169b6zW9+I0k6efKktm7dqmXLlmnVqlXauHGjevXqFeQKpaVLl+r06dM1dv6NGzfW2LkBAKgVkpOlOXNoKICwRNAxqTZt2mjatGlu25555hnNmDFDTz/9tHJD4L/IXHPNNTV6/tatW9fo+QEAMD0aCiCM+Tx0bfPmzUpNTVVCQoIsFovWrFlz2WNKSkr09NNPq0WLFrJarWrZsqUWL17sT724Ao8++qgk6V//+pckyWKxqG/fviosLNTIkSPVtGlTRUREuIWgip93kyZNZLVadd111+mZZ57xeCemtLRUL774otq0aaOYmBi1adNGM2fOVFlZmcd6LjVHJysrS7fffrsaN26smJgYtWzZUiNGjNDnn38uqXz+zeuvvy5JatWqlWuYXt+L/ktTVXN0Tp06pYyMDF1//fWKiYlRo0aNdNddd2nLli2V9p02bZosFotyc3P15ptvqmPHjqpbt67i4+M1fvx4nTlzptIxb7/9tvr06aPY2FjFxMQoISFBKSkpevvttz2+VwAAQtrAgdLs2YQchB2f7+icOnVKSUlJuvfee/XLX/7Sq2OGDh2q4uJivfbaa2rTpo0OHTpU5R+/qHkXh4vvvvtOPXr0UKNGjXTPPffo7NmzstlskqSFCxdq7NixatiwoVJTUxUbG6uPP/5YM2bMUE5OjnJychQdHe0614MPPqjFixerVatWGjt2rM6ePavZs2fro48+8qm+xx9/XLNnz1ajRo00ePBgxcbG6sCBA9qwYYO6dOmiG2+8UY899pgyMzP16aefavz48WrYsKEkXbb5wNmzZ9WvXz9t27ZNnTt31mOPPabi4mKtWLFC7777rpYtW6b//u//rnTcvHnztH79eg0aNEj9+vXT+vXr9corr+jo0aN64403XPstXLhQDz/8sOLj4/WLX/xCjRs3VlFRkbZt26bVq1dryJAhPn0WAAAA8JNxBSQZq1evvuQ+//d//2fY7Xbju+++8/t1HA6HIclwOByX3O/MmTPGl19+aZw5c8bv1wp3e/fuNSQZAwYMqPTc1KlTDUlGcnKyYRjlPz9JxujRo40LFy647fvFF18YUVFRRlJSknH06FG352bOnGlIMmbNmuXalpOTY0gykpKSjJMnT7q2f/vtt0aTJk0MSUZaWprbefr06WP8+BL8+9//bkgyOnToUOl1z58/bxQVFbm+T0tLMyQZe/fu9fhZtGjRwmjRooXbtunTpxuSjF//+tdGWVmZa/uOHTuM6Ohoo2HDhobT6XRtz8jIMCQZdrvd2LVrl2v76dOnjbZt2xoRERFGYWGha3vnzp2N6Ohoo7i4uFI9P34/gcDvBAAAMBtvs0GNd13Lzs5W165d9fvf/17NmjVT27Zt9cQTT3gc8lOhpKRETqfT7RFysrOlCRNCts3inj17NG3aNE2bNk1PPvmkbr31Vj377LOKiYnRjBkzXPtFR0fr97//vSIjI92O/9Of/qQLFy5o7ty5aty4sdtzEydO1NVXX61ly5a5ti1dulSSNHXqVNWvX9+1vVmzZho/frzXdS9YsECS9Mc//rHS60ZFRSkuLs7rc3ny+uuvq06dOnrhhRfc7mx16tRJaWlpOn78uMfhmOPHj1e7du1c39etW1e/+tWvVFZWpu3bt7vtW6dOHdWpU6fSOX78fgAAAFBzarwZQUFBgT788EPFxMRo9erVOnr0qB5++GF99913WrJkicdjZs6cqenTp9d0af6r6CkfGVneiSQrK+TGrX799deuz7BOnTqKi4vT8OHDNWnSJHXo0MG1X6tWrdSkSZNKx2/dulWS9O6773rsXlanTh3t2rXL9f2nn34qSerdu3elfT1tq8q2bdtktVrVp08fr4/xltPpVEFBgdq3b6/mzZtXej45OVmLFi1Sfn6+RowY4fZcly5dKu1fcY7jx4+7tt1zzz2aOHGibrzxRg0fPlzJycm65ZZbXMMBAQAAEBg1HnTKyspksVj0xhtvyG63S5Jmz56tu+++WwsWLFDdunUrHTN58mSlp6e7vnc6nUpMTKzpUr3nqad8iAWdAQMGaP369Zfdr6o7JN9//70kud39uRSHw6GIiAiPocmXuzAOh0PNmjVTRET132ysuDNYVT3x8fFu+13MU1CJiir/9SktLXVte+KJJ9S4cWMtXLhQL730kmbNmqWoqCjdddddevnll9WqVasrfh8AAAC4vBofuhYfH69mzZq5Qo4ktW/fXoZh6Ntvv/V4jNVqlc1mc3uElOTkH0JOmPeUr6rrWcVn7nQ6ZRhGlY8KdrtdZWVlOnr0aKVzFRcXe11Pw4YNVVRUVCPNKireU1X1FBUVue3nD4vFonvvvVf/+te/dOTIEa1evVq//OUvlZWVpf/6r/9yC0UAAACoOTUedHr16qWDBw/q5MmTrm1fffWVIiIiPA4fCgsVPeXHjQvJYWvVoXv37pJ+GMJ2OUlJSZKkf/zjH5We87StKt26dVNJSYk2bdp02X0r5hV5Gx5sNpuuvfZa7dmzR4WFhZWer2ir3bFjR6/rvZTGjRtr8ODBWrFihfr166cvv/xSe/bsqZZzAwAA4NJ8DjonT55Ufn6+8vPzJUl79+5Vfn6+9u/fL6l82NnIkSNd+w8fPlyNGzfW6NGj9eWXX2rz5s168sknde+993octhY2TN5T/uGHH1ZUVJQeffRR18/2YsePH9cnn3zi+r5iTsuzzz6rU6dOubYXFhbqj3/8o9evO3bsWEnlk/8rhs9VuHDhgtvdmEaNGkmSDhw44PX509LSdP78eU2ePNntjtS///1vZWZmym63a/DgwV6f78dyc3PdzitJ58+fd72XmJgYv88NAAAA7/k8R+fjjz9WcnKy6/uKuTRpaWnKzMzUoUOH3P4wvuqqq/T+++/r0UcfVdeuXdW4cWMNHTpUv/vd76qhfNSUG2+8UQsWLNBDDz2kdu3a6c4771Tr1q114sQJFRQUaNOmTRo1apReffVVSeUT+UePHq0lS5aoQ4cO+sUvfqGSkhKtWLFCP/vZz/TOO+949bp33nmnnnjiCc2aNUvXXXedfvGLXyg2NlaFhYXauHGjnnjiCT322GOSpH79+mnWrFl68MEHNWTIENWvX18tWrSo1EjgYhMnTtTatWv1l7/8RTt37lT//v11+PBhrVixQhcuXNCiRYvUoEEDvz+3wYMHy2az6Wc/+5latGih8+fP6/3339eXX36pu+++Wy1atPD73AAAAPCez0Gnb9++lf6L9cUyMzMrbbv++uv1/vvv+/pSCLIHHnhAHTt21OzZs7V582b9/e9/l91u1zXXXKMJEyYoLS3Nbf9Fixapbdu2WrRokebNm6fmzZsrPT1dQ4cO9TroSNIf/vAH9ejRQ/PmzdPKlSt19uxZxcfHq1+/frrttttc+91xxx36/e9/r0WLFumll17S+fPn1adPn0sGnZiYGH3wwQd68cUXtWLFCr388suqV6+e+vTpo6eeekq33HKL7x/URWbOnKn169dr27Zt+vvf/6769eurdevWWrhwoe67774rOjcAAAC8ZzEulVpChNPplN1ul8PhuORE8bNnz2rv3r1q1aoVQ4QA8TsBAADMx9tsUOPNCAAAAAAg0Ag6AAAAAEyHoAMAAADAdAg6AAAAAEyHoAMAAADAdAg6AAAAAEzHlEEnDDpmAwHB7wIAAKitTBV0oqLK1z+9cOFCkCsBQsP58+clSZGRkUGuBAAAILBMFXQiIyMVGRkpp9MZ7FKAoDMMQw6HQ1arVXXq1Al2OQAAAAEVFewCqpPFYlFsbKwOHTokq9Wq+vXry2KxBLssIKAMw9D58+flcDh08uRJNWvWLNglAQAABJypgo4k2e12nTlzRkePHtWRI0eCXQ4QNFarVc2aNZPNZgt2KQAAAAFnuqBjsVgUHx+v2NhY1/wEoLaJjIxkuBoAAKjVTBd0KlTM1wEAAABQ+5iqGQEAAAAASAQdAAAAACZE0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKbjc9DZvHmzUlNTlZCQIIvFojVr1nh97JYtWxQVFaWOHTv6+rIAAAAA4DWfg86pU6eUlJSk+fPn+3Tc8ePHNXLkSPXv39/XlwQAAAAAn0T5esAdd9yhO+64w+cXGjNmjIYPH67IyMjL3gUqKSlRSUmJ63un0+nz6wEAAACovQIyR2fJkiUqKChQRkaGV/vPnDlTdrvd9UhMTKzhCgEAAACYSY0Hnf/85z+aNGmS/vrXvyoqyrsbSJMnT5bD4XA9Dhw4UMNVAgAAADATn4eu+aK0tFTDhw/X9OnT1bZtW6+Ps1qtslqtNVgZAAAAADOr0aBz4sQJffzxx/rkk0/0yCOPSJLKyspkGIaioqL03nvvqV+/fjVZAgAAAIBaqEaDjs1m02effea2bcGCBfrggw+0cuVKtWrVqiZfHgAAAEAt5XPQOXnypPbs2eP6fu/evcrPz1ejRo10zTXXaPLkySosLNTSpUsVERGhG2+80e342NhYxcTEVNoOAAAAANXF56Dz8ccfKzk52fV9enq6JCktLU2ZmZk6dOiQ9u/fX30VAgAAAICPLIZhGMEu4nKcTqfsdrscDodsNluwywEAAAAQJN5mg4CsowMAAAAAgUTQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApkPQAQAAAGA6BB0AAAAApuNz0Nm8ebNSU1OVkJAgi8WiNWvWXHL/VatW6bbbbtPVV18tm82mHj166N133/W3XgAAAAC4LJ+DzqlTp5SUlKT58+d7tf/mzZt12223ad26ddq+fbuSk5OVmpqqTz75xOdiAQAAAMAbFsMwDL8Ptli0evVqDR482KfjfvrTn2rYsGGaOnWqV/s7nU7Z7XY5HA7ZbDY/KgUAAABgBt5mg6gA1iRJKisr04kTJ9SoUaMq9ykpKVFJSYnre6fTGYjSAAAAAJhEwJsRzJo1SydPntTQoUOr3GfmzJmy2+2uR2JiYgArBAAAABDuAhp03nzzTU2fPl1vvfWWYmNjq9xv8uTJcjgcrseBAwcCWCUAAACAcBewoWvLly/X/fffr7/97W9KSUm55L5Wq1VWqzVAlQEAAAAwm4Dc0Vm2bJlGjx6tZcuW6a677grESwIAAACoxXy+o3Py5Ent2bPH9f3evXuVn5+vRo0a6ZprrtHkyZNVWFiopUuXSiofrpaWlqY//vGP6t69u4qKiiRJdevWld1ur6a3AQAAAAA/8PmOzscff6xOnTqpU6dOkqT09HR16tTJ1Sr60KFD2r9/v2v/P//5z7pw4YLGjh2r+Ph412P8+PHV9BYAAAAAwN0VraMTKKyjAwAAAEDyPhsEvL00AAAAANQ0gg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdgg4AAAAA0yHoAAAAADAdn4PO5s2blZqaqoSEBFksFq1Zs+ayx+Tm5qpz586yWq1q06aNMjMz/SgVAAAAALzjc9A5deqUkpKSNH/+fK/237t3r+666y4lJycrPz9fjz32mO6//369++67PhcLAAAAAN6I8vWAO+64Q3fccYfX+7/66qtq1aqVXnrpJUlS+/bt9eGHH+rll1/WgAEDfH15AAAAALisGp+jk5eXp5SUFLdtAwYMUF5eXpXHlJSUyOl0uj0AAAAAwFs1HnSKiooUFxfnti0uLk5Op1NnzpzxeMzMmTNlt9tdj8TExJouEwAAAICJhGTXtcmTJ8vhcLgeBw4cCHZJAAAAAMKIz3N0fNW0aVMVFxe7bSsuLpbNZlPdunU9HmO1WmW1Wmu6NAAAAAAmVeN3dHr06KGNGze6bXv//ffVo0ePmn5pAAAAANUge3e2JqyfoOzd2cEuxWs+B52TJ08qPz9f+fn5ksrbR+fn52v//v2SyoedjRw50rX/mDFjVFBQoIkTJ2rXrl1asGCB3nrrLU2YMKF63gEAAACAGpO9O1uDlg/S3G1zNWj5oLAJOz4HnY8//lidOnVSp06dJEnp6enq1KmTpk6dKkk6dOiQK/RIUqtWrbR27Vq9//77SkpK0ksvvaT//d//pbU0AAAAEAZy9uYo0hKpUqNUkZZI5e7LDXZJXrEYhmEEu4jLcTqdstvtcjgcstlswS4HAAAAqDUq7uhUhJ2se7I0sN3AoNXjbTao8WYEAAAAAIIve3e2cvbmKLlVsk9BZWC7gcq6J0u5+3LVt2XfoIYcX3BHBwAAADC5ULsrcyW8zQYhuY4OAAAAgOoTrvNsrgRBBwAAADC55FbJrpBTapSqb8u+wS6pxjFHBwAAADC5cJ1ncyWYowMAAACEEX+bCpgFc3QAAAAAkwnXxTuDgaADAAAAhIna2FTAXwQdAAAAIEzUxqYC/qIZAQAAABAmamNTAX/RjAAAAAAIsNreUOBK0IwAAAAACEE0FAgMgg4AAAAQQDQUCAyCDgAAABBANBQIDJoRAAAAAH7yZ64NDQUCg2YEAAAAgB8q5tpU3JnJuieL0BIANCMAAAAAahBzbUIbQQcAAADwA3NtQhtzdAAAAAA/MNcmtDFHBwAAALUeC3iGD+boAAAAAF5gAU9zIugAAACgVqOpgDkRdAAAAFCr0VTAnGhGAAAAAFPwd54NTQXMiWYEAAAACHss3ll70IwAAAAAtQbzbPBjBB0AAACEPebZ4MeYowMAAICwxzwb/BhzdAAAABBSWLwTl8IcHQAAAIQdFu9EdSHoAAAAIGTQVADVhaADAACAkEFTAVQXmhEAAAAgZNBUANWFZgQAAACoETQVQE2gGQEAAACChqYCCDaCDgAAAKodTQUQbAQdAAAAVDuaCiDYaEYAAACAKvk7z4amAgg2mhEAAADAo4p5NhV3ZbLuySKwIOhoRgAAAIArwjwbhDOCDgAAADxing3CGXN0AAAA4BHzbBDOmKMDAABQC2RnSzk5UnKyNJC8gjDGHB0AAABIKg85gwZJc+eWf81m7U7UAgQdAAAAk8vJkSIjpdLS8q+5ucGuCKh5BB0AAACTS07+IeSUlkp9+wa7IqDm0YwAAADA5AYOlLKyyu/k9O3LHB3UDgQdAACAMHElDQUGDiTgoHZh6BoAAEAYoKEA4BuCDgAAQBigoQDgG4IOAABAGKChAOAb5ugAAAAEmD9zbWgoAPjGYhiGEewiLsfb1U8BAABCXcVcm4o7M1lZhBbAF95mA4auAQAABBBzbYDAIOgAAAAEEHNtgMDwK+jMnz9fLVu2VExMjLp3765t27Zdcv85c+aoXbt2qlu3rhITEzVhwgSdPXvWr4IBAADCWcVcm3HjGLYG1CSfmxGsWLFC6enpevXVV9W9e3fNmTNHAwYM0O7duxUbG1tp/zfffFOTJk3S4sWL1bNnT3311VcaNWqULBaLZs+eXS1vAgAAIBj8XcCTxTuBmudzM4Lu3bvr5ptv1rx58yRJZWVlSkxM1KOPPqpJkyZV2v+RRx7Rzp07tXHjRte2xx9/XP/85z/14YcfevWaNCMAAAChhqYCQHDUSDOCc+fOafv27UpJSfnhBBERSklJUV5ensdjevbsqe3bt7uGtxUUFGjdunW68847q3ydkpISOZ1OtwcAAEAooakAENp8CjpHjx5VaWmp4uLi3LbHxcWpqKjI4zHDhw/Xs88+q1tuuUV16tRR69at1bdvXz311FNVvs7MmTNlt9tdj8TERF/KBAAAqHE0FQBCW413XcvNzdXzzz+vBQsWaMeOHVq1apXWrl2r5557rspjJk+eLIfD4XocOHCgpssEAADwCU0FgNDmUzOCJk2aKDIyUsXFxW7bi4uL1bRpU4/HTJkyRSNGjND9998vSerQoYNOnTqlBx98UE8//bQiIipnLavVKqvV6ktpAAAAfvG3oYBEUwEglPl0Ryc6OlpdunRxayxQVlamjRs3qkePHh6POX36dKUwExkZKUnysQ8CAABAtapoKDB3bvnX7OxgVwSguvg8dC09PV2LFi3S66+/rp07d+qhhx7SqVOnNHr0aEnSyJEjNXnyZNf+qampWrhwoZYvX669e/fq/fff15QpU5SamuoKPAAAAMFAQwHAvHxeR2fYsGE6cuSIpk6dqqKiInXs2FHr1693NSjYv3+/2x2cZ555RhaLRc8884wKCwt19dVXKzU1VTNmzKi+dwEAAOCH5GRpzhwaCgBm5PM6OsHAOjoAAOBy/J1rk51dfienb1/m2wDhwNtsQNABAABhj8U7gdqjRhYMBQAACEXMtQHwYwQdAAAQ9li8E8CP+dyMAAAAINRULN7JXBsAFQg6AAAgpPjbVIDFOwFcjKFrAAAgZLCAJ4DqQtABAAAhg6YCAKoLQQcAAIQMmgoAqC7M0QEAANXuSubZ0FQAQHVgwVAAAFCtWLwTQE1iwVAAABAUzLMBEAoIOgAAoFoxzwZAKGCODgAAqFbMswEQCgg6AACgSizeCSBcMXQNAAB4xOKdAMIZQQcAAHhEUwEA4YygAwAAPKKpAIBwxhwdAADgEU0FAIQzgg4AACbnb0MBiaYCAMIXQ9cAADAxGgoAqK0IOgAAmBgNBQDUVgQdAABMjIYCAGor5ugAABAm/JlrQ0MBALWVxTAMI9hFXI7T6ZTdbpfD4ZDNZgt2OQAABFzFXJuKOzNZWYQWALWTt9mAoWsAAIQB5toAgG8IOgAAhAHm2gCAb5ijAwBAGGCuDQD4hqADAECA+buAJ4t3AoD3GLoGAEAAsYAnAAQGQQcAgACiqQAABAZBBwCAAKKpAAAEBnN0AAAIIJoKAEBgEHQAAPCDvw0FJJoKAEAgMHQNAAAf0VAAAEIfQQcAAB/RUAAAQh9BBwAAH9FQAABCH3N0AAC1mj9zbWgoAAChz2IYhhHsIi7H6XTKbrfL4XDIZrMFuxwAgElUzLWpuDOTlUVoAYBQ5202YOgaAKDWYq4NAJgXQQcAUGsx1wYAzIs5OgCAWou5NgBgXgQdAIAp+LuAJ4t3AoA5MXQNABD2WMATAPBjBB0AQNijqQAA4McIOgCAsEdTAQDAjzFHBwAQ9mgqAAD4MYIOACBk+NtQQKKpAADAHUPXAAAhgYYCAIDqRNABAIQEGgoAAKoTQQcAEBJoKAAAqE7M0QEAVDt/5trQUAAAUJ0shmEYwS7icpxOp+x2uxwOh2w2W7DLAQBcQsVcm4o7M1lZhBYAQPXxNhswdA0AUK2YawMACAUEHQBAtWKuDQAgFDBHBwBQrZhrAwAIBQQdAIBHLN4JAAhnfg1dmz9/vlq2bKmYmBh1795d27Ztu+T+x48f19ixYxUfHy+r1aq2bdtq3bp1fhUMAKh5LN4JAAh3PgedFStWKD09XRkZGdqxY4eSkpI0YMAAHT582OP+586d02233aZ9+/Zp5cqV2r17txYtWqRmzZpdcfEAgJpBQwEAQLjzub109+7ddfPNN2vevHmSpLKyMiUmJurRRx/VpEmTKu3/6quv6g9/+IN27dqlOnXqePUaJSUlKikpcX3vdDqVmJhIe2kACBBaRAMAQlWNtJc+d+6ctm/frpSUlB9OEBGhlJQU5eXleTwmOztbPXr00NixYxUXF6cbb7xRzz//vEpLS6t8nZkzZ8put7seiYmJvpQJALhIdrY0YYJvw88qGgqMG0fIAQCEJ5+CztGjR1VaWqq4uDi37XFxcSoqKvJ4TEFBgVauXKnS0lKtW7dOU6ZM0UsvvaTf/e53Vb7O5MmT5XA4XI8DBw74UiYA4P+7krk2AwdKs2cTcgAA4anGu66VlZUpNjZWf/7znxUZGakuXbqosLBQf/jDH5SRkeHxGKvVKqvVWtOlAYDpeZprQ3ABANQGPt3RadKkiSIjI1VcXOy2vbi4WE2bNvV4THx8vNq2bavIyEjXtvbt26uoqEjnzp3zo2QAgLdYvBMAUFv5FHSio6PVpUsXbdy40bWtrKxMGzduVI8ePTwe06tXL+3Zs0dlZWWubV999ZXi4+MVHR3tZ9kAAG8w1wYAUFv53F46PT1dixYt0uuvv66dO3fqoYce0qlTpzR69GhJ0siRIzV58mTX/g899JC+//57jR8/Xl999ZXWrl2r559/XmPHjq2+dwEAtYA/TQUk5toAAGonn+foDBs2TEeOHNHUqVNVVFSkjh07av369a4GBfv371dExA/5KTExUe+++64mTJigm266Sc2aNdP48eP129/+tvreBQCY3MXtnufM4e4MAACX4/M6OsHgba9sADCrCRPKO6dVzLcZN678Lg0AALVNjayjAwAIDpoKAADgmxpvLw0AuHIVTQVyc8tDDsPWAAC4NIIOAARQdnb52jbJyb6HlYEDCTgAAHiLoWsAECAVDQXmzi3/6mv3NAAA4D2CDgAESE7OD3NsIiPLh6EBAICaQdABgAChoQAAAIHDHB0A8IM/c21oKAAAQOCwjg4A+OjixTtLS1m8EwCAQGIdHQCoIcy1AQAg9BF0AMBHzLUBACD0MUcHAHzEXBsAAEIfQQdArebvAp4s3gkAQGhj6BqAWosFPAEAMC+CDoBai6YCAACYF0EHQK1FUwEAAMyLOToAai2aCgAAYF4EHQBhz9+GAhJNBQAAMCuGrgEIazQUAAAAnhB0AIQ1GgoAAABPCDoAwhoNBQAAgCfM0QEQMvyZa0NDAQAA4InFMAwj2EVcjtPplN1ul8PhkM1mC3Y5AGpAxVybijszWVmEFgAAUJm32YChawBCAnNtAABAdSLoAAgJzLUBAADViTk6AEICc20AAEB1IugAqFYs3gkAAEIBQ9cAVBsW7wQAAKGCoAOg2tBQAAAAhAqCDoBqQ0MBAAAQKpijA6Da0FAAAACECoIOAI/8bSpAQwEAABAKGLoGoBKaCgAAgHBH0AFQCU0FAABAuCPoAKiEpgIAACDcMUcHMDl/5trQVAAAAIQ7i2EYRrCLuByn0ym73S6HwyGbzRbscoCwUTHXpuLOTFYWoQUAAIQ3b7MBQ9cAE2OuDQAAqK0IOoCJMdcGAADUVszRAUyMuTYAAKC2IugAYcDfxTslFvAEAAC1E0PXgBDH4p0AAAC+I+gAIY6GAgAAAL4j6AAhjoYCAAAAvmOODhBALN4JAAAQGCwYCgQIi3cCAABcORYMBUIMc20AAAACh6ADBAhzbQAAAAKHOTpAgDDXBgAAIHAIOoCPWLwTAAAg9DF0DfABi3cCAACEB4IO4AMaCgAAAIQHgg7gAxoKAAAAhAfm6AA+oKEAAABAeCDooNbyt6kADQUAAABCH0PXUCvRVAAAAMDc/Ao68+fPV8uWLRUTE6Pu3btr27ZtXh23fPlyWSwWDR482J+XBaoNTQUAAADMzeegs2LFCqWnpysjI0M7duxQUlKSBgwYoMOHD1/yuH379umJJ55Q7969/S4WqC40FQAAADA3n4PO7Nmz9cADD2j06NG64YYb9Oqrr6pevXpavHhxlceUlpbq17/+taZPn65rr732igoGfiw7W5owwbfhZxVNBcaNK//KnBsAAABz8SnonDt3Ttu3b1dKSsoPJ4iIUEpKivLy8qo87tlnn1VsbKzuu+8+r16npKRETqfT7QF4ciVzbQYOlGbPJuQAAACYkU9B5+jRoyotLVVcXJzb9ri4OBUVFXk85sMPP9Rrr72mRYsWef06M2fOlN1udz0SExN9KRO1CHNtAAAA4EmNdl07ceKERowYoUWLFqlJkyZeHzd58mQ5HA7X48CBAzVYJcIZc20AAADgiU/r6DRp0kSRkZEqLi52215cXKymTZtW2v/rr7/Wvn37lJqa6tpWVlZW/sJRUdq9e7dat25d6Tir1Sqr1epLaailWMATAAAAnvgUdKKjo9WlSxdt3LjR1SK6rKxMGzdu1COPPFJp/+uvv16fffaZ27ZnnnlGJ06c0B//+EeGpMHF38U7JRbwBAAAQGU+BR1JSk9PV1pamrp27apu3bppzpw5OnXqlEaPHi1JGjlypJo1a6aZM2cqJiZGN954o9vxDRs2lKRK21F7VTQUiIyU5syhCxoAAACunM9BZ9iwYTpy5IimTp2qoqIidezYUevXr3c1KNi/f78iImp06g9MxlNDAYIOAAAAroTFMAwj2EVcjtPplN1ul8PhkM1mC3Y5qGYX39EpLeWODgAAAKrmbTbw+Y4OUN1oKAAAAIDqRtBBtfK3qQANBQAAAFCdmEyDalMxBG3u3PKv2dnBrggAAAC1FUEH1cZTUwEAAAAgGAg6qDbJyT+EnNLS8vk2AAAAQDAwRwce+TPXhqYCAAAACBW0l0YltHsGAABAqPI2GzB0DZUw1wYAAADhjqCDSphrAwAAgHDHHB1UwlwbAAAAhDuCjon5u3inxAKeAAAACG8MXTMpFu8EAABAbUbQMSkaCgAAAKA2I+iYFA0FAAAAUJsxR8ekaCgAAACA2oygEwb8bSpAQwEAAADUVgxdC3E0FQAAAAB8R9AJcTQVAAAAAHxH0AlxNBUAAAAAfMccnQC5knk2NBUAAAAAfGMxDMMIdhGX43Q6Zbfb5XA4ZLPZgl2Ozyrm2VTclcnKIrAAAAAA/vA2GzB0LQCYZwMAAAAEFkEnAJhnAwAAAAQWc3QCgHk2AAAAQGARdHzE4p0AAABA6GPomg9YvBMAAAAIDwQdH9BUAAAAAAgPBB0f0FQAAAAACA/M0fEBTQUAAACA8EDQ8RFNBQAAAIDQx9A1AAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKZD0AEAAABgOgQdAAAAAKYTFewCvGEYhiTJ6XQGuRIAAAAAwVSRCSoyQlXCIuicOHFCkpSYmBjkSgAAAACEghMnTshut1f5vMW4XBQKAWVlZTp48KAaNGggi8US1FqcTqcSExN14MAB2Wy2oNaC8MP1gyvB9QN/ce3gSnD94ErUxPVjGIZOnDihhIQERURUPRMnLO7oREREqHnz5sEuw43NZuOXHX7j+sGV4PqBv7h2cCW4fnAlqvv6udSdnAo0IwAAAABgOgQdAAAAAKZD0PGR1WpVRkaGrFZrsEtBGOL6wZXg+oG/uHZwJbh+cCWCef2ERTMCAAAAAPAFd3QAAAAAmA5BBwAAAIDpEHQAAAAAmA5BBwAAAIDpEHQAAAAAmA5Bx4P58+erZcuWiomJUffu3bVt27ZL7v+3v/1N119/vWJiYtShQwetW7cuQJUiFPly/SxatEi9e/fWT37yE/3kJz9RSkrKZa83mJuv//5UWL58uSwWiwYPHlyzBSJk+XrtHD9+XGPHjlV8fLysVqvatm3L/3/VYr5eP3PmzFG7du1Ut25dJSYmasKECTp79myAqkUo2bx5s1JTU5WQkCCLxaI1a9Zc9pjc3Fx17txZVqtVbdq0UWZmZo3URtD5kRUrVig9PV0ZGRnasWOHkpKSNGDAAB0+fNjj/h999JF+9atf6b777tMnn3yiwYMHa/Dgwfr8888DXDlCga/XT25urn71q18pJydHeXl5SkxM1O23367CwsIAV45Q4Ov1U2Hfvn164okn1Lt37wBVilDj67Vz7tw53Xbbbdq3b59Wrlyp3bt3a9GiRWrWrFmAK0co8PX6efPNNzVp0iRlZGRo586deu2117RixQo99dRTAa4coeDUqVNKSkrS/Pnzvdp/7969uuuuu5ScnKz8/Hw99thjuv/++/Xuu+9Wf3EG3HTr1s0YO3as6/vS0lIjISHBmDlzpsf9hw4datx1111u27p37278z//8T43WidDk6/XzYxcuXDAaNGhgvP766zVVIkKYP9fPhQsXjJ49exr/+7//a6SlpRmDBg0KQKUINb5eOwsXLjSuvfZa49y5c4EqESHM1+tn7NixRr9+/dy2paenG7169arROhH6JBmrV6++5D4TJ040fvrTn7ptGzZsmDFgwIBqr4c7Ohc5d+6ctm/frpSUFNe2iIgIpaSkKC8vz+MxeXl5bvtL0oABA6rcH+blz/XzY6dPn9b58+fVqFGjmioTIcrf6+fZZ59VbGys7rvvvkCUiRDkz7WTnZ2tHj16aOzYsYqLi9ONN96o559/XqWlpYEqGyHCn+unZ8+e2r59u2t4W0FBgdatW6c777wzIDUjvAXyb+eoaj9jGDt69KhKS0sVFxfntj0uLk67du3yeExRUZHH/YuKimqsToQmf66fH/vtb3+rhISESv8AwPz8uX4+/PBDvfbaa8rPzw9AhQhV/lw7BQUF+uCDD/TrX/9a69at0549e/Twww/r/PnzysjICETZCBH+XD/Dhw/X0aNHdcstt8gwDF24cEFjxoxh6Bq8UtXfzk6nU2fOnFHdunWr7bW4owOEiBdeeEHLly/X6tWrFRMTE+xyEOJOnDihESNGaNGiRWrSpEmwy0GYKSsrU2xsrP785z+rS5cuGjZsmJ5++mm9+uqrwS4NYSA3N1fPP/+8FixYoB07dmjVqlVau3atnnvuuWCXBrjhjs5FmjRposjISBUXF7ttLy4uVtOmTT0e07RpU5/2h3n5c/1UmDVrll544QVt2LBBN910U02WiRDl6/Xz9ddfa9++fUpNTXVtKysrkyRFRUVp9+7dat26dc0WjZDgz7898fHxqlOnjiIjI13b2rdvr6KiIp07d07R0dE1WjNChz/Xz5QpUzRixAjdf//9kqQOHTro1KlTevDBB/X0008rIoL/jo6qVfW3s81mq9a7ORJ3dNxER0erS5cu2rhxo2tbWVmZNm7cqB49eng8pkePHm77S9L7779f5f4wL3+uH0n6/e9/r+eee07r169X165dA1EqQpCv18/111+vzz77TPn5+a7HwIEDXV1sEhMTA1k+gsiff3t69eqlPXv2uMKxJH311VeKj48n5NQy/lw/p0+frhRmKkJz+Xx0oGoB/du52tsbhLnly5cbVqvVyMzMNL788kvjwQcfNBo2bGgUFRUZhmEYI0aMMCZNmuTaf8uWLUZUVJQxa9YsY+fOnUZGRoZRp04d47PPPgvWW0AQ+Xr9vPDCC0Z0dLSxcuVK49ChQ67HiRMngvUWEES+Xj8/Rte12svXa2f//v1GgwYNjEceecTYvXu38c477xixsbHG7373u2C9BQSRr9dPRkaG0aBBA2PZsmVGQUGB8d577xmtW7c2hg4dGqy3gCA6ceKE8cknnxiffPKJIcmYPXu28cknnxjffPONYRiGMWnSJGPEiBGu/QsKCox69eoZTz75pLFz505j/vz5RmRkpLF+/fpqr42g48HcuXONa665xoiOjja6detmbN261fVcnz59jLS0NLf933rrLaNt27ZGdHS08dOf/tRYu3ZtgCtGKPHl+mnRooUhqdIjIyMj8IUjJPj678/FCDq1m6/XzkcffWR0797dsFqtxrXXXmvMmDHDuHDhQoCrRqjw5fo5f/68MW3aNKN169ZGTEyMkZiYaDz88MPGsWPHAl84gi4nJ8fj3zIV10xaWprRp0+fSsd07NjRiI6ONq699lpjyZIlNVKbxTC4xwgAAADAXJijAwAAAMB0CDoAAAAATIegAwAAAMB0CDoAAAAATIegAwAAAMB0CDoAAAAATIegAwAAAMB0CDoAAAAATIegAwAAAMB0CDoAAAAATIegAwAAAMB0/h9ra7LY6/BQ0AAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Previous predictions\n",
    "plot_predictions(predictions=y_preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_0.eval()\n",
    "with torch.inference_mode():\n",
    "    y_preds_new = model_0(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# New predictions\n",
    "plot_predictions(predictions=y_preds_new)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As you can see, after moderate training, the predictions are near the ground truths\n",
    "\n",
    "- _Only if you've trained a couple of times, ~15_\n",
    "\n",
    "try training for 100 epochs and see how it'll hange\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(42)\n",
    "\n",
    "epochs = 100\n",
    "\n",
    "def evaluate_model(n: int=epochs):\n",
    "    \"\"\"\n",
    "    params (n: int) - Takes in number of epochs to train the model for .\n",
    "\n",
    "    Trains the model for n epochs, as defined in epochs, then prints stats, and plots the predictions.\n",
    "    \"\"\"\n",
    "    train(\n",
    "        model=model_0,\n",
    "        inputs=X_train,\n",
    "        num_epochs=epochs,\n",
    "        loss_fn=loss_fn,\n",
    "        optimizer=optimizer,\n",
    "    )\n",
    "\n",
    "    # Print model stats\n",
    "    current_params = model_0.state_dict()\n",
    "    ground_truth = weight, bias\n",
    "\n",
    "    print(f\"\\nChanged params:\\n{current_params}\\n\\nGroung truth:\\n{ground_truth}\")\n",
    "\n",
    "    # Evaluate the model\n",
    "    model_0.eval()\n",
    "    with torch.inference_mode():\n",
    "        y_preds_n_epochs = model_0(X_test)\n",
    "\n",
    "    # New predictions after n epochs\n",
    "    plot_predictions(predictions=y_preds_n_epochs)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running loss: [0.7423580884933472, 0.6271482110023499, 0.5119383931159973, 0.396728515625, 0.2815186381340027, 0.16630874574184418, 0.09566082805395126, 0.08086106926202774, 0.07521500438451767, 0.07133916765451431]\n",
      "\n",
      "Changed params:\n",
      "OrderedDict({'weights': tensor([0.6495]), 'bias': tensor([0.1525])})\n",
      "\n",
      "Groung truth:\n",
      "(0.7, 0.3)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "evaluate_model()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Writing testing loop code\n",
    "\n",
    "- `model.eval()` - Turns off different settings in the model not needed for evaluation/testing (e.g. Dropout/Batch Norm layers)\n",
    "- `torch.inference_mode()` - Turns off gradient tracking, (same as `torch.no_grad()` in older PyTorch code), and a couple of more things behing the scenes.\n",
    "- We still do `forward()` pass.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OrderedDict({'weights': tensor([0.8823]), 'bias': tensor([0.9150])})\n"
     ]
    }
   ],
   "source": [
    "# Create a random seed\n",
    "torch.manual_seed(42)\n",
    "\n",
    "# Instantiate a new model\n",
    "model_1 = LinearRegressionModel()\n",
    "\n",
    "print(model_1.state_dict())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setting up a loss function\n",
    "loss_fn_1 = nn.L1Loss()\n",
    "\n",
    "# Setting up an optimizer\n",
    "optimizer_1 = torch.optim.SGD(params=model_1.parameters(), lr=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Setup empty lists to keep track of model progress\n",
    "epoch_count = []\n",
    "train_loss_values = []\n",
    "test_loss_values = []\n",
    "\n",
    "# wipe values in the list above clean\n",
    "def wipe_values_clean():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.manual_seed(42)\n",
    "\n",
    "def train_test_evaluate(model=model_1, train_inputs_data=X_train, train_output_data=y_train, test_inputs_data=X_test, test_output_data=y_test, num_epochs=1, loss_fn=loss_fn_1, optimizer=optimizer_1, plot=True):\n",
    "\n",
    "    for epoch in range(num_epochs):\n",
    "        # Setting model to train mode to keep track of gradients\n",
    "        model.train()\n",
    "\n",
    "        # Forward pass\n",
    "        predictions = model(train_inputs_data)\n",
    "\n",
    "        # Calculating loss\n",
    "        loss = loss_fn(predictions, train_output_data)\n",
    "\n",
    "        # Zero optimizer gradients\n",
    "        optimizer.zero_grad()\n",
    "\n",
    "        # Backpropagation\n",
    "        loss.backward()\n",
    "        \n",
    "        # Gradient descent\n",
    "        optimizer.step()\n",
    "        \n",
    "        # Evaluate/test the model\n",
    "        model.eval()\n",
    "        with torch.inference_mode():\n",
    "            # 1. Forward pass\n",
    "            test_pred = model(test_inputs_data)\n",
    "\n",
    "            # 2. Calculate test loss\n",
    "            test_loss = loss_fn(test_pred, test_output_data)\n",
    "\n",
    "        # Logging (Print out what's happening and update the value lists)\n",
    "        if epoch % 10 == 0:\n",
    "            epoch_count.append(epoch)\n",
    "            train_loss_values.append(loss.item())\n",
    "            test_loss_values.append(test_loss.item())\n",
    "            print(f\"Epoch: {epoch} | MAE Loss: {loss} | MAE Test loss: {test_loss}\")\n",
    "            # print model weights\n",
    "            print(model.state_dict())\n",
    "    # print Ground truth\n",
    "    print(f\"Ground Truth -> [ weight: {weight} | Bias: {bias} ]\")\n",
    "\n",
    "    # Plot presictions with test data\n",
    "    if plot:\n",
    "        plot_predictions(predictions=test_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "During logging, we add `.item()` to the losses to append them to the lists as `float` data type, instead of `torch.tensors` which doesn't work well with matplotlib (we'd have to add `.detach().numpy()`)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train, Test and Evaluate for 1 epoch\n",
    "# train_test_evaluate()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We'll train the model for longer(100 epochs) and his time plot the predictions against train and test data\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train, Test and Evaluate for 100 epochs\n",
    "# train_test_evaluate(num_epochs=100, plot=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The ultimate goal is to get the red dots(predictions) to match the green dots(test data, unseen during training)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 0 | MAE Loss: 0.11004672944545746 | MAE Test loss: 0.10233600437641144\n",
      "OrderedDict({'weights': tensor([0.6869]), 'bias': tensor([0.4140])})\n",
      "Epoch: 10 | MAE Loss: 0.09852589666843414 | MAE Test loss: 0.08886518329381943\n",
      "OrderedDict({'weights': tensor([0.6830]), 'bias': tensor([0.4040])})\n",
      "Epoch: 20 | MAE Loss: 0.08700504153966904 | MAE Test loss: 0.07539437711238861\n",
      "OrderedDict({'weights': tensor([0.6791]), 'bias': tensor([0.3940])})\n",
      "Epoch: 30 | MAE Loss: 0.07548420131206512 | MAE Test loss: 0.0619235523045063\n",
      "OrderedDict({'weights': tensor([0.6752]), 'bias': tensor([0.3840])})\n",
      "Epoch: 40 | MAE Loss: 0.06396336108446121 | MAE Test loss: 0.04845272749662399\n",
      "OrderedDict({'weights': tensor([0.6713]), 'bias': tensor([0.3740])})\n",
      "Epoch: 50 | MAE Loss: 0.052442509680986404 | MAE Test loss: 0.03498192876577377\n",
      "OrderedDict({'weights': tensor([0.6674]), 'bias': tensor([0.3640])})\n",
      "Epoch: 60 | MAE Loss: 0.040921665728092194 | MAE Test loss: 0.021511107683181763\n",
      "OrderedDict({'weights': tensor([0.6635]), 'bias': tensor([0.3540])})\n",
      "Epoch: 70 | MAE Loss: 0.029400816187262535 | MAE Test loss: 0.008040308952331543\n",
      "OrderedDict({'weights': tensor([0.6596]), 'bias': tensor([0.3440])})\n",
      "Epoch: 80 | MAE Loss: 0.017879974097013474 | MAE Test loss: 0.0054305074736475945\n",
      "OrderedDict({'weights': tensor([0.6557]), 'bias': tensor([0.3340])})\n",
      "Epoch: 90 | MAE Loss: 0.011684718541800976 | MAE Test loss: 0.013987964019179344\n",
      "OrderedDict({'weights': tensor([0.6539]), 'bias': tensor([0.3270])})\n",
      "Epoch: 100 | MAE Loss: 0.010024385526776314 | MAE Test loss: 0.01766524836421013\n",
      "OrderedDict({'weights': tensor([0.6541]), 'bias': tensor([0.3232])})\n",
      "Epoch: 110 | MAE Loss: 0.009334058500826359 | MAE Test loss: 0.0191509909927845\n",
      "OrderedDict({'weights': tensor([0.6551]), 'bias': tensor([0.3208])})\n",
      "Epoch: 120 | MAE Loss: 0.008893127553164959 | MAE Test loss: 0.019572770223021507\n",
      "OrderedDict({'weights': tensor([0.6564]), 'bias': tensor([0.3192])})\n",
      "Epoch: 130 | MAE Loss: 0.008530955761671066 | MAE Test loss: 0.01922694966197014\n",
      "OrderedDict({'weights': tensor([0.6580]), 'bias': tensor([0.3182])})\n",
      "Epoch: 140 | MAE Loss: 0.008178118616342545 | MAE Test loss: 0.018811482936143875\n",
      "OrderedDict({'weights': tensor([0.6596]), 'bias': tensor([0.3172])})\n",
      "Epoch: 150 | MAE Loss: 0.007828602567315102 | MAE Test loss: 0.01825873926281929\n",
      "OrderedDict({'weights': tensor([0.6612]), 'bias': tensor([0.3163])})\n",
      "Epoch: 160 | MAE Loss: 0.00748574361205101 | MAE Test loss: 0.017431367188692093\n",
      "OrderedDict({'weights': tensor([0.6629]), 'bias': tensor([0.3156])})\n",
      "Epoch: 170 | MAE Loss: 0.007141849957406521 | MAE Test loss: 0.016604000702500343\n",
      "OrderedDict({'weights': tensor([0.6646]), 'bias': tensor([0.3149])})\n",
      "Epoch: 180 | MAE Loss: 0.006798344198614359 | MAE Test loss: 0.01584530435502529\n",
      "OrderedDict({'weights': tensor([0.6663]), 'bias': tensor([0.3141])})\n",
      "Epoch: 190 | MAE Loss: 0.006455325987190008 | MAE Test loss: 0.015017908997833729\n",
      "OrderedDict({'weights': tensor([0.6681]), 'bias': tensor([0.3134])})\n",
      "Epoch: 200 | MAE Loss: 0.006111425347626209 | MAE Test loss: 0.014190560206770897\n",
      "OrderedDict({'weights': tensor([0.6698]), 'bias': tensor([0.3127])})\n",
      "Epoch: 210 | MAE Loss: 0.00576809560880065 | MAE Test loss: 0.01343185268342495\n",
      "OrderedDict({'weights': tensor([0.6715]), 'bias': tensor([0.3120])})\n",
      "Epoch: 220 | MAE Loss: 0.0054248906672000885 | MAE Test loss: 0.012604475021362305\n",
      "OrderedDict({'weights': tensor([0.6732]), 'bias': tensor([0.3113])})\n",
      "Epoch: 230 | MAE Loss: 0.005080985836684704 | MAE Test loss: 0.011777120642364025\n",
      "OrderedDict({'weights': tensor([0.6749]), 'bias': tensor([0.3106])})\n",
      "Epoch: 240 | MAE Loss: 0.004737831652164459 | MAE Test loss: 0.011018401011824608\n",
      "OrderedDict({'weights': tensor([0.6766]), 'bias': tensor([0.3098])})\n",
      "Epoch: 250 | MAE Loss: 0.004394450690597296 | MAE Test loss: 0.01019102893769741\n",
      "OrderedDict({'weights': tensor([0.6783]), 'bias': tensor([0.3091])})\n",
      "Epoch: 260 | MAE Loss: 0.004050546791404486 | MAE Test loss: 0.009363656863570213\n",
      "OrderedDict({'weights': tensor([0.6800]), 'bias': tensor([0.3084])})\n",
      "Epoch: 270 | MAE Loss: 0.0037075714208185673 | MAE Test loss: 0.008604961447417736\n",
      "OrderedDict({'weights': tensor([0.6817]), 'bias': tensor([0.3077])})\n",
      "Epoch: 280 | MAE Loss: 0.003364016767591238 | MAE Test loss: 0.007777601480484009\n",
      "OrderedDict({'weights': tensor([0.6834]), 'bias': tensor([0.3070])})\n",
      "Epoch: 290 | MAE Loss: 0.0030201792251318693 | MAE Test loss: 0.0070188818499445915\n",
      "OrderedDict({'weights': tensor([0.6851]), 'bias': tensor([0.3062])})\n",
      "Epoch: 300 | MAE Loss: 0.0026773184072226286 | MAE Test loss: 0.0061914981342852116\n",
      "OrderedDict({'weights': tensor([0.6869]), 'bias': tensor([0.3055])})\n",
      "Epoch: 310 | MAE Loss: 0.0023335821460932493 | MAE Test loss: 0.005364149808883667\n",
      "OrderedDict({'weights': tensor([0.6886]), 'bias': tensor([0.3048])})\n",
      "Epoch: 320 | MAE Loss: 0.0019899189937859774 | MAE Test loss: 0.004605448339134455\n",
      "OrderedDict({'weights': tensor([0.6903]), 'bias': tensor([0.3041])})\n",
      "Epoch: 330 | MAE Loss: 0.001647049910388887 | MAE Test loss: 0.0037780702114105225\n",
      "OrderedDict({'weights': tensor([0.6920]), 'bias': tensor([0.3034])})\n",
      "Epoch: 340 | MAE Loss: 0.001303145312704146 | MAE Test loss: 0.0029507100116461515\n",
      "OrderedDict({'weights': tensor([0.6937]), 'bias': tensor([0.3027])})\n",
      "Epoch: 350 | MAE Loss: 0.0009596645832061768 | MAE Test loss: 0.0021920024883002043\n",
      "OrderedDict({'weights': tensor([0.6954]), 'bias': tensor([0.3019])})\n",
      "Epoch: 360 | MAE Loss: 0.0006166137754917145 | MAE Test loss: 0.001364630414173007\n",
      "OrderedDict({'weights': tensor([0.6971]), 'bias': tensor([0.3012])})\n",
      "Epoch: 370 | MAE Loss: 0.000272712844889611 | MAE Test loss: 0.0005372583982534707\n",
      "OrderedDict({'weights': tensor([0.6988]), 'bias': tensor([0.3005])})\n",
      "Epoch: 380 | MAE Loss: 0.0003208882990293205 | MAE Test loss: 0.0007917463663034141\n",
      "OrderedDict({'weights': tensor([0.6999]), 'bias': tensor([0.3009])})\n",
      "Epoch: 390 | MAE Loss: 0.0003208882990293205 | MAE Test loss: 0.0007917463663034141\n",
      "OrderedDict({'weights': tensor([0.6999]), 'bias': tensor([0.3009])})\n",
      "Epoch: 400 | MAE Loss: 0.0003208882990293205 | MAE Test loss: 0.0007917463663034141\n",
      "OrderedDict({'weights': tensor([0.6999]), 'bias': tensor([0.3009])})\n",
      "Epoch: 410 | MAE Loss: 0.0003208882990293205 | MAE Test loss: 0.0007917463663034141\n",
      "OrderedDict({'weights': tensor([0.6999]), 'bias': tensor([0.3009])})\n",
      "Epoch: 420 | MAE Loss: 0.0003208882990293205 | MAE Test loss: 0.0007917463663034141\n",
      "OrderedDict({'weights': tensor([0.6999]), 'bias': tensor([0.3009])})\n",
      "Epoch: 430 | MAE Loss: 0.0003208882990293205 | MAE Test loss: 0.0007917463663034141\n",
      "OrderedDict({'weights': tensor([0.6999]), 'bias': tensor([0.3009])})\n",
      "Epoch: 440 | MAE Loss: 0.0003208882990293205 | MAE Test loss: 0.0007917463663034141\n",
      "OrderedDict({'weights': tensor([0.6999]), 'bias': tensor([0.3009])})\n",
      "Epoch: 450 | MAE Loss: 0.0003208882990293205 | MAE Test loss: 0.0007917463663034141\n",
      "OrderedDict({'weights': tensor([0.6999]), 'bias': tensor([0.3009])})\n",
      "Epoch: 460 | MAE Loss: 0.0003208882990293205 | MAE Test loss: 0.0007917463663034141\n",
      "OrderedDict({'weights': tensor([0.6999]), 'bias': tensor([0.3009])})\n",
      "Epoch: 470 | MAE Loss: 0.0003208882990293205 | MAE Test loss: 0.0007917463663034141\n",
      "OrderedDict({'weights': tensor([0.6999]), 'bias': tensor([0.3009])})\n",
      "Epoch: 480 | MAE Loss: 0.0003208882990293205 | MAE Test loss: 0.0007917463663034141\n",
      "OrderedDict({'weights': tensor([0.6999]), 'bias': tensor([0.3009])})\n",
      "Epoch: 490 | MAE Loss: 0.0003208882990293205 | MAE Test loss: 0.0007917463663034141\n",
      "OrderedDict({'weights': tensor([0.6999]), 'bias': tensor([0.3009])})\n",
      "Ground Truth -> [ weight: 0.7 | Bias: 0.3 ]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "train_test_evaluate(num_epochs=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "# print([val.dtype() for val in (epoch_count[1:], train_loss_values[1:], test_loss_values[1:])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 10, 20, 30, 40]\n",
      "[<class 'int'>, <class 'int'>, <class 'int'>, <class 'int'>, <class 'int'>]\n"
     ]
    }
   ],
   "source": [
    "print([val for val in epoch_count[:5]])\n",
    "print([type(val) for val in epoch_count[:5]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.11004672944545746, 0.09852589666843414]\n",
      "[<class 'float'>, <class 'float'>]\n"
     ]
    }
   ],
   "source": [
    "print([val for val in train_loss_values[:2]])\n",
    "print([type(val) for val in train_loss_values[:2]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.10233600437641144, 0.08886518329381943]\n",
      "[<class 'float'>, <class 'float'>]\n"
     ]
    }
   ],
   "source": [
    "print([val for val in test_loss_values[:2]])\n",
    "print([type(val) for val in test_loss_values[:2]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train and Test loss curve using the values\n",
    "def plot_loss_curve(epochs=epoch_count, train_losses=train_loss_values, test_losses=test_loss_values):\n",
    "    plt.plot(epochs, train_losses, label=\"Train Loss\")\n",
    "    plt.plot(epochs, test_losses, label=\"Test Loss\")\n",
    "    plt.title(\"Training and Test Loss Curves\")\n",
    "    plt.ylabel(\"Loss\")\n",
    "    plt.xlabel(\"Epochs\")\n",
    "    plt.legend()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_loss_curve()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving a Model in PyTorch\n",
    "\n",
    "There are 3 main methods you should know about for saving and loading models in PyTorch.\n",
    "\n",
    "1. `torch.save()` - Allows you to save a PyTorch object in Python's **pickle** format.\n",
    "2. `torch.load()` - Allows you to load a saved PyTorch object.\n",
    "3. `torch.nn.Module.load_state_dict()` - Allows you to load a model's saved state dictionary.\n",
    "   - Since the model is a sub-class of `torch.nn.Module`, we can call the `load_state_dict()` directly.\n",
    "\n",
    "See Docs - https://pytorch.org/tutorials/beginner/saving_loading_models.html#saving-loading-model-for-inference\n",
    "\n",
    "Also if on colab, search how to save model in drive\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving model to: models\\01_pytorch_workflow.pth\n"
     ]
    }
   ],
   "source": [
    "# Saving our PyTorch model\n",
    "from pathlib import Path\n",
    "\n",
    "# 1. Create models directory\n",
    "MODEL_PATH = Path(\"models\")\n",
    "MODEL_PATH.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "# 2. Create 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(), f=MODEL_SAVE_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ls -l models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading a PyTorch model\n",
    "\n",
    "Since we saved only the model's parameters, `state_dict()` rather than whole model (`torch.save()`), we'll create a new instance of our model class and load the saved `state_dict()` into that.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.6995])), ('bias', tensor([0.2999]))])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model_1.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 1. Instantiate a new instance of our model class\n",
    "loaded_model_1 = LinearRegressionModel()\n",
    "\n",
    "# 2. Load the saved state dict of our model_1 (this will update the new instance with updated parameters)\n",
    "loaded_model_1.load_state_dict(torch.load(f=MODEL_SAVE_PATH))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "OrderedDict([('weights', tensor([0.6995])), ('bias', tensor([0.2999]))])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# The model_1 parameters are exactly same as loaded_model_1 parameters\n",
    "loaded_model_1.state_dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.8595],\n",
       "        [0.8735],\n",
       "        [0.8875],\n",
       "        [0.9015],\n",
       "        [0.9154],\n",
       "        [0.9294],\n",
       "        [0.9434],\n",
       "        [0.9574],\n",
       "        [0.9714],\n",
       "        [0.9854]])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Making some predictions with the loaded model\n",
    "loaded_model_1.eval()\n",
    "with torch.inference_mode():\n",
    "    loaded_model_predictions = loaded_model_1(X_test)\n",
    "\n",
    "loaded_model_predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[0.8595],\n",
       "        [0.8735],\n",
       "        [0.8875],\n",
       "        [0.9015],\n",
       "        [0.9154],\n",
       "        [0.9294],\n",
       "        [0.9434],\n",
       "        [0.9574],\n",
       "        [0.9714],\n",
       "        [0.9854]])"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Predictions with original model_1\n",
    "model_1.eval()\n",
    "with torch.inference_mode():\n",
    "    original_model_preds = model_1(X_test)\n",
    "\n",
    "original_model_preds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "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": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Compare original model preds with loaded model preds\n",
    "original_model_preds == loaded_model_predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some Bugs I Encountered\n",
    "\n",
    "- When I instantiated a new model (`model_1`), I forgot to instantiate a new optimizer for it, used the old one for `model_0` (and in optimizers we pass `model.parameters()` and `learning rate`) so with the wrong model parameters, optimizer won't do sh\\*t.\n",
    "\n",
    "  Got flat parallel train test curves and constant train and test loss values(Why Logging and Visualization are important).\n",
    "\n",
    "  - Rectified it by instantiating a new optimizer and passing new model params.\n",
    "\n",
    "- Passed wrong data .At some point, confused in between X_train, y_train and X_test, y_test data.\n",
    "\n",
    "  - That's why I went with deliberate naming `(train_inputs_data, train_outputs_data, test_inputs_data, test_outputs_data)`.\n",
    "\n",
    "- When Visualizing/plotting the train and test loss curves, encountered typeErrors where matplotlib works only with numpy arrays or Python's native data types and not PyTorch's `torch.tensor()`. The `train_test_evaluate()` loop appended values of type`torch.tensor()` to the `train and test loss values` lists.\n",
    "\n",
    "  - Remedied this by adding `.item()` after loss value, which will convert it to Python native dtypes like `float`.\n",
    "\n",
    "- Also some typos here and there.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Putting it all together\n",
    "\n",
    "Let's go back through the steps above and see it all in one place\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'2.2.1+cpu'"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Import PyTorch and Matplotlib\n",
    "import torch\n",
    "from torch import nn\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# check PyTorch version\n",
    "torch.__version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Device agnostic code\n",
    "\n",
    "Can work on both \"CPU\" and \"GPU\" for fast computing incase have access to a GPU e.g. custom or on colab or kaggle.\n",
    "\n",
    "Default to `cpu` and `cuda` (GPU) only if its available.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using Device: cpu\n"
     ]
    }
   ],
   "source": [
    "# Setting up device agnostic code\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "\n",
    "print(f\"Using Device: {device}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# if have a gpu, to chech type and specs\n",
    "# !nvidia-smi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing Data\n",
    "\n",
    "Create some data using linear regression formula `y = mX + c` same as **y = weight \\* X + bias**, where X = features(inputs) and y = target(labels/outputs).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "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",
       " torch.Size([50, 1]),\n",
       " torch.Size([50, 1]))"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Data with y = weight * X + bias\n",
    "weight2 = 0.7\n",
    "bias2 = 0.3\n",
    "\n",
    "ground_truth_2 = {\"weight_2\": weight2, \"bias_2\": bias2}\n",
    "\n",
    "# range\n",
    "start = 0\n",
    "end = 1\n",
    "step = 0.02\n",
    "\n",
    "# Create X and y (features and labels)\n",
    "X2 = torch.arange(start, end, step).unsqueeze(dim=1) # without unsqueeze, errors will pop up\n",
    "y2 = weight2 * X2 + bias2\n",
    "\n",
    "X2[:10], y2[:10], len(X2), X2.shape, y2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'weight_2': 0.7, 'bias_2': 0.3}"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ground_truth_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(40, 40, 10, 10, 50, 50)"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Split data\n",
    "train_split_2 = int(0.8 * len(X2))\n",
    "\n",
    "X2_train, y2_train = X2[:train_split_2], y2[:train_split_2] # 80% each\n",
    "X2_test, y2_test = X2[train_split_2:], y2[train_split_2:]   # 40% each\n",
    "\n",
    "len(X2_train), len(y2_train), len(X2_test), len(y2_test), len(X2), len(y2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rebuilding the function to plot data and predictions\n",
    "def plot_predictions_2(\n",
    "    train_data=X2_train,\n",
    "    train_labels=y2_train,\n",
    "    test_data=X2_test,\n",
    "    test_labels=y2_test,\n",
    "    predictions=None,\n",
    "):\n",
    "    \"\"\"\n",
    "    Plots training data, test data and compares predictions\n",
    "    \"\"\"\n",
    "    plt.figure(figsize=(10, 7))\n",
    "\n",
    "    # Plot training data in blue\n",
    "    plt.scatter(train_data, train_labels, c=\"b\", s=4, label=\"Training data\")\n",
    "\n",
    "    # Plot test data in green\n",
    "    plt.scatter(test_data, test_labels, c=\"g\", s=4, label=\"Testing data\")\n",
    "\n",
    "    # Are there predictions?\n",
    "    if predictions is not None:\n",
    "        # Plot the predictions if they exist\n",
    "        plt.scatter(test_data, predictions, c=\"r\", s=4, label=\"Predictions\")\n",
    "\n",
    "    # Show the legend\n",
    "    plt.legend(prop={\"size\": 14})\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# plot the data\n",
    "plot_predictions_2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building a PyTorch Linear Model\n",
    "\n",
    "This time we'll create a linear model by subclassing `nn.Modude`\n",
    "\n",
    "The `in_features` and `out_features` are going to be highly dependent on the dimensionality of the training data and labels, in our case, **X2**/X2_train and **y2**/y2_train, which is `[50, 1]`, 1 column.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating a linear model by subclassing nn.Module\n",
    "class LinearRegressionModelV2(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        # Using nn.Linear for creating model parameters (weight and bias)\n",
    "        self.linear_layer = nn.Linear(in_features=1, out_features=1)\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        return self.linear_layer(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LinearRegressionModelV2(\n",
      "  (linear_layer): Linear(in_features=1, out_features=1, bias=True)\n",
      ")\n",
      "OrderedDict({'linear_layer.weight': tensor([[0.7645]]), 'linear_layer.bias': tensor([0.8300])})\n"
     ]
    }
   ],
   "source": [
    "# set manual seed\n",
    "torch.manual_seed(42)\n",
    "\n",
    "# Create model instance\n",
    "model_2 = LinearRegressionModelV2()\n",
    "\n",
    "# view model and its parameters\n",
    "print(model_2)\n",
    "print(model_2.state_dict())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Check the model current device\n",
    "next(model_2.parameters()).device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cpu')"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Set model to use target device, just incase we have a gpu or we use colab\n",
    "model_2.to(device)\n",
    "next(model_2.parameters()).device"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training\n",
    "\n",
    "For training we need:\n",
    "\n",
    "- Loss Function\n",
    "- Optimizer\n",
    "- Training Loop\n",
    "- Testing Loop\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Set up loss function\n",
    "loss_fn_2 = nn.L1Loss() # Mean Absolute Error\n",
    "\n",
    "# Set up optimizer\n",
    "optimizer_2 = torch.optim.SGD(params=model_2.parameters(), lr=0.01)\n",
    "\n",
    "# Manual seed\n",
    "torch.manual_seed(42)\n",
    "\n",
    "# Lists for logging the values\n",
    "epoch_count_2 = []\n",
    "train_loss_values_2 = []\n",
    "test_loss_values_2 = []\n",
    "\n",
    "# We're also adding data to target device to avoid errors where model and data are not in the same davice incase we're using colab GPU.\n",
    "\n",
    "def train_test_2(epochs, ground_truth_2=ground_truth_2, model=model_2,train_data=X2_train.to(device), train_targets=y2_train.to(device), test_data=X2_test.to(device), test_targets=y2_test.to(device), optimizer=optimizer_2, loss_fn=loss_fn_2, plot=True):\n",
    "    \"\"\"Train model for n number of epochs\"\"\"\n",
    "    # Training Loop\n",
    "    for epoch in range(epochs):\n",
    "        ## Train loop\n",
    "        model.train()\n",
    "        # Forward pass\n",
    "        train_preds_2 = model(train_data)\n",
    "        # Calculating Loss\n",
    "        loss_2 = loss_fn(train_preds_2, train_targets)\n",
    "        # zeroing optimizer gradients\n",
    "        optimizer.zero_grad()\n",
    "        # Backpropagation\n",
    "        loss_2.backward()\n",
    "        # Gradient descent\n",
    "        optimizer.step()\n",
    "\n",
    "        ## Test loop\n",
    "        model.eval()\n",
    "        with torch.inference_mode():\n",
    "            # Forward pass\n",
    "            test_preds_2 = model(test_data)\n",
    "            # Loss\n",
    "            test_loss_2 = loss_fn(test_preds_2, test_targets)\n",
    "        \n",
    "        # Logging\n",
    "        if epoch % (epochs * 0.2) == 0: # At every 20% epoch of total epochs\n",
    "            print(f\"\\nEpoch: {epoch}\")\n",
    "            epoch_count_2.append(epoch)\n",
    "            print(f\"Train loss: {loss_2}\")\n",
    "            train_loss_values_2.append(loss_2.item())\n",
    "            print(f\"Test loss: {test_loss_2}\")\n",
    "            test_loss_values_2.append(test_loss_2.item())\n",
    "            \n",
    "    if plot:\n",
    "        plot_predictions_2(predictions=test_preds_2)\n",
    "\n",
    "    print(\"Training and Eval complete\")\n",
    "    print(f\"Model parameters: {model.state_dict()}\")\n",
    "    print(f\"Ground Truth: {ground_truth_2}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Epoch: 0\n",
      "Train loss: 0.5551779866218567\n",
      "Test loss: 0.5739762187004089\n",
      "\n",
      "Epoch: 40\n",
      "Train loss: 0.09433844685554504\n",
      "Test loss: 0.03513689711689949\n",
      "\n",
      "Epoch: 80\n",
      "Train loss: 0.013089170679450035\n",
      "Test loss: 0.029944902285933495\n",
      "\n",
      "Epoch: 120\n",
      "Train loss: 0.0012645035749301314\n",
      "Test loss: 0.013801807537674904\n",
      "\n",
      "Epoch: 160\n",
      "Train loss: 0.0012645035749301314\n",
      "Test loss: 0.013801807537674904\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x700 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training and Eval complete\n",
      "Model parameters: OrderedDict({'linear_layer.weight': tensor([[0.6968]]), 'linear_layer.bias': tensor([0.3025])})\n",
      "Ground Truth: {'weight_2': 0.7, 'bias_2': 0.3}\n"
     ]
    }
   ],
   "source": [
    "# Train for 200 epochs\n",
    "num_epochs_2 = 200\n",
    "\n",
    "train_test_2(epochs=num_epochs_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot train and test loss curves\n",
    "def plot_loss_curves_2(epochs=epoch_count_2, train_losses=train_loss_values_2, test_losses=test_loss_values_2):\n",
    "    plt.plot(epochs, train_losses, label=\"Train Loss\")\n",
    "    plt.plot(epochs, test_losses, label=\"Test Loss\")\n",
    "    plt.title(\"Train and Test loss curves for model_2\")\n",
    "    plt.ylabel(\"Loss\")\n",
    "    plt.xlabel(\"Epochs\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "# plotting\n",
    "plot_loss_curves_2()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### If the model predictions are satisfying, we can proceed to save the model same as earlieer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Saving model to: models\\01_pytorch_workflow_model_2.pth\n"
     ]
    }
   ],
   "source": [
    "# Saving the model\n",
    "from pathlib import Path\n",
    "\n",
    "# 1. Create models directory, skip if it exists\n",
    "MODEL_PATH = Path(\"models\")\n",
    "MODEL_PATH.mkdir(parents=True, exist_ok=True)\n",
    "\n",
    "# 2. Create save path\n",
    "MODEL2_NAME = \"01_pytorch_workflow_model_2.pth\"\n",
    "MODEL2_SAVE_PATH = MODEL_PATH / MODEL2_NAME\n",
    "\n",
    "# 3. Save the model state dict\n",
    "print(f\"Saving model to: {MODEL2_SAVE_PATH}\")\n",
    "torch.save(obj=model_2.state_dict(), f=MODEL2_SAVE_PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Loading saved model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "LinearRegressionModelV2(\n",
       "  (linear_layer): Linear(in_features=1, out_features=1, bias=True)\n",
       ")"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create new instance of the model\n",
    "loaded_model_2 = LinearRegressionModelV2()\n",
    "\n",
    "# Load model state dict\n",
    "loaded_model_2.load_state_dict(torch.load(MODEL2_SAVE_PATH))\n",
    "\n",
    "# Put loaded model to target device\n",
    "loaded_model_2.to(device)"
   ]
  }
 ],
 "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}