CustomLinearRegression.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyNZqUXaa6U8RXZnsfZY24Ry",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/AnshUpadhyay639/LinearRegressionPyTorch/blob/main/CustomLinearRegression.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XgXj844cXQqU",
        "outputId": "741334eb-bc57-4773-d53d-5c89ecef35d3"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.5.1+cu121\n"
          ]
        }
      ],
      "source": [
        "import torch #Colab already has Pytorch preinstalled in it\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from torch import nn\n",
        "print(torch.__version__)"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!nvidia-smi"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lrHeZtKSX6ef",
        "outputId": "477f676a-375d-4f44-8fdc-dff5af5f0d4d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/bin/bash: line 1: nvidia-smi: command not found\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Setup Device Agnostic Code:\n",
        "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
        "print(f\"Using Device: {device}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Ixo8BLMaNhxA",
        "outputId": "b60313b9-ae89-4211-eec3-7bea0ba71be5"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Using Device: cpu\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = torch.tensor([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])\n",
        "tensor.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RdxTgl_1Fozs",
        "outputId": "e8049cf4-c9ae-49c5-e951-cc80fad3fdb3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "torch.Size([2, 2, 2])"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Note: torch.rand() generates numbers that are strictly between 0 and 1 meanwhile torch.randn() generates numbers that can be positive or negative and are centered around 0."
      ],
      "metadata": {
        "id": "GPjchE7XDiCv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "random = torch.rand(2,2,2,dtype=torch.float64) #Creating a random Tensor with giving the input shape and dtype optional\n",
        "random"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "283Az93bSEPq",
        "outputId": "dbf56c78-dab5-49f2-8dad-e0af3955da20"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[[0.0582, 0.0629],\n",
              "         [0.1236, 0.0526]],\n",
              "\n",
              "        [[0.5262, 0.4768],\n",
              "         [0.9552, 0.9288]]], dtype=torch.float64)"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "tensor = torch.randn(1, requires_grad = True, dtype=torch.float) #Creating a random Tensor with giving the input shape and dtype optional\n",
        "tensor"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "m5mHpkTpI4Ph",
        "outputId": "60874784-0269-48d2-b6f7-ba601a28daca"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([0.4617], requires_grad=True)"
            ]
          },
          "metadata": {},
          "execution_count": 39
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Creating some known data using Linear Regression Formula ( y = mx + c) to make a st. line with known parameters where m = weight and c = bias. Aim is to get the model to learn the relationship between X and Y as it does not know the formula. We give the model an random data in the form of X and it calculates Y itself and learns the relationship between them."
      ],
      "metadata": {
        "id": "jiorulR97xpQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Creating known parameters:\n",
        "weight = 0.7\n",
        "bias = 0.3\n",
        "\n",
        "#Creating random input data:\n",
        "start = 0\n",
        "end = 1\n",
        "step = 0.02\n",
        "\n",
        "X = torch.arange(start, end, step).unsqueeze(1) # X stores the Quentions/Data && Y stores the Answers/Labels\n",
        "Y = weight * X + bias\n",
        "print(f\"Input numbers: {X[:10]}, Output numbers: {Y[:10]}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OubjfmLp746b",
        "outputId": "7be4573a-ba64-4a7d-cf5c-2fd5855e6795"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Input numbers: 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]]), Output numbers: 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"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "len(X), len(Y)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YHiqvHZZ9f7q",
        "outputId": "b528c2f6-9bd3-4a5d-e8f0-19736becd65c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(50, 50)"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Create train/test split:\n",
        "\n",
        "train_split = int(0.8 * len(X))             #80% of X -->means--> 80/100 or 0.8\n",
        "X_train = X[:train_split]                   #Contains the first 40(80% of 50 = 40) elements from the start (Starting 40 Qtns)\n",
        "Y_train = Y[:train_split]                   #Same for Y as 80% of both (X and Y) is given to the model to learn the Question and Answers. (Starting 40 Ans)\n",
        "X_test = X[train_split:]                    #Contains the last 10(20% of 50 = 10) elements from the 'train_split'\n",
        "Y_test = Y[train_split:]                    #same as above\n",
        "\n",
        "len(X_train), len(Y_train), len(X_test), len(Y_test)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8nA-QkmM-T03",
        "outputId": "332fbb47-0053-40c2-af92-83a84ef24e73"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(40, 40, 10, 10)"
            ]
          },
          "metadata": {},
          "execution_count": 42
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "X_train.squeeze(1), X_test"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CtcQofqdEOFV",
        "outputId": "829068e9-607e-4fa4-f67f-d977d659bf1c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(tensor([0.0000, 0.0200, 0.0400, 0.0600, 0.0800, 0.1000, 0.1200, 0.1400, 0.1600,\n",
              "         0.1800, 0.2000, 0.2200, 0.2400, 0.2600, 0.2800, 0.3000, 0.3200, 0.3400,\n",
              "         0.3600, 0.3800, 0.4000, 0.4200, 0.4400, 0.4600, 0.4800, 0.5000, 0.5200,\n",
              "         0.5400, 0.5600, 0.5800, 0.6000, 0.6200, 0.6400, 0.6600, 0.6800, 0.7000,\n",
              "         0.7200, 0.7400, 0.7600, 0.7800]),\n",
              " 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]]))"
            ]
          },
          "metadata": {},
          "execution_count": 43
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Data Visualization in the form of graphs:"
      ],
      "metadata": {
        "id": "ietHNs9OIrOn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def plot_predictions(traindata = X_train, trainlabels = Y_train, testdata = X_test, testlabels = Y_test, predictions = None): #Assigning default values which can also be overwritten by calling the same func with diff params\n",
        "  #Create an empty new figure\n",
        "  plt.figure(figsize = (10,7)) #(Width, Height)\n",
        "\n",
        "  plt.xlabel(\"X-axis\",fontsize=12)\n",
        "  plt.ylabel(\"Y-axis\",fontsize=12)\n",
        "\n",
        "  plt.scatter(traindata,trainlabels, c = \"b\", s = 10, label = \"Training Data\") #Scatter(X-axis, Y-axis, color, size, name)\n",
        "\n",
        "  plt.scatter(testdata, testlabels, c=\"g\", s = 5, label = \"Testing Data\") #Rest 10% of the line\n",
        "\n",
        "  if predictions is not None:\n",
        "    plt.scatter(testdata, predictions, c=\"r\", s=5, label = \"Predictions\")\n",
        "\n",
        "  plt.legend(prop={\"size\" : 20}) #Legend describes about the color and the label name in a small box for EZ understanding (prop ->properties)"
      ],
      "metadata": {
        "id": "bHZVE6xyIyVb"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions() #St. line because of 'Y = mX + C'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 623
        },
        "id": "W0s0S5vMJ8xI",
        "outputId": "889af241-9853-42a0-c973-a5553b2ccc74"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1IAAAJeCAYAAAC+kzTIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABhiElEQVR4nO3dfVhUdf7/8ddwLyqYd3iHmhWW6WppDhauVppbrqV8KzdTzG9aabUVX2PSTMk2jalcu9Es025sW20t23YzSzFL0sZVszJLMm+wDBVTUEQQ5vz+mJ+zjtzIQZgZZp6P65pr4H3OmfMemIt89fmcz7EYhmEIAAAAAFBtIb5uAAAAAADqG4IUAAAAAJhEkAIAAAAAkwhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmhfm6AV9zOp3at2+fGjduLIvF4ut2AAAAAPiIYRg6evSo2rRpo5CQqsecgj5I7du3T/Hx8b5uAwAAAICf2Lt3r9q1a1flPkEfpBo3bizJ9cOKiYnxcTcAAAAAfKWgoEDx8fHujFCVoA9Sp6bzxcTEEKQAAAAAVOuSHxabAAAAAACTCFIAAAAAYBJBCgAAAABMIkgBAAAAgEkEKQAAAAAwiSAFAAAAACYRpAAAAADAJL8KUp9//rmGDBmiNm3ayGKx6P333z/rMWvWrNHll1+uyMhIXXjhhXr99dfrvE8AAAAAwc2vglRhYaG6d++uOXPmVGv/Xbt2afDgwbr66qu1ZcsWPfjggxo7dqw+/vjjOu4UAAAAQDAL83UDp7v++ut1/fXXV3v/efPm6fzzz9ezzz4rSbrkkkuUlZWlv/71rxo0aFBdtQkAAAAgyPlVkDJr/fr1GjBggEdt0KBBevDBBys9pri4WMXFxe7vCwoKaq0fp9Op0tJSOZ3OWntNAMEpJCREYWFhCgnxq4kDAADg/6vXQSo3N1dxcXEetbi4OBUUFKioqEgNGjQod8zMmTP1+OOP12of+fn5Kigo0PHjxwlRAGpNSEiIoqOjFRMTo9jYWF+3AwAATlOvg1RNTJo0Sampqe7vCwoKFB8fX6PXMgxD+/fv1+HDhxUdHa3mzZsrKipKISEhslgstdUygCBjGIacTqdOnDihY8eOad++fSoqKlJcXBx/WwAA8BP1Oki1atVK+/fv96jt379fMTExFY5GSVJkZKQiIyNr5fyHDx/W4cOH1apVK5133nm18poAcErDhg3VrFkzHT58WLm5uYqIiFDTpk193RYAAJCfrdpnVp8+fZSZmelRW7lypfr06VPn5zYMQ0eOHFHjxo0JUQDq1HnnnafGjRvryJEjMgzD1+0AAAD5WZA6duyYtmzZoi1btkhyLW++ZcsW5eTkSHJNy0tJSXHvf88992jnzp1KS0vTDz/8oLlz5+qdd97RQw89VOe9lpaWqri4mOsWAHhFbGysiouLVVpa6utWAACA/CxIbdy4UZdddpkuu+wySVJqaqouu+wyTZ06VZL066+/ukOVJJ1//vn68MMPtXLlSnXv3l3PPvusXn31Va8sfV5WViZJCgur17MjAdQTp/7WnPrbAwAAfMuvUkD//v2rnLby+uuvV3jMV199VYddVY0LvwF4A39rAADwL341IgUAAAAA9QFBCgAAAIBPlDpLNf2z6bpu0XWa/tl0lTrrz7XAfjW1DwAAAEDwmLF2htLXpMuQoVU7V0mSpvab6uOuqocRKQAAAAA+kZWTJUOuNRIMGcrKyfJxR9VHkAJqye7du2WxWGSxWCpcGKW29O/fXxaLRf3796+zcwAAAHhDUvskWeRaUMkii5LaJ/m4o+pjah/82u7du3X++eef8+twE1P/1b9/f3322Wfl6g0aNFBsbKyaNm2qrl27qlevXrrpppuUkJDggy4BAEBdmNx3siTXyFRS+yT39/UBI1IA/FJRUZFyc3O1bds2vfPOO0pLS9PFF1+sa6+9Vl9//XWdnz89Pd09wggAAOpGWEiYpvabqk9GfaKp/aYqLKT+jPPUn04RlNq2batvv/220u3dunWTJPXq1Uuvvfaat9qqUMeOHb0y8rVmzZo6P4evnP67Li0t1ZEjR/TLL7/oyy+/1NKlS5Wbm6vVq1erd+/eeuGFF3TXXXf5sFsAABDMCFLwa+Hh4eratetZ92vYsGG19oN/q+x3ePvtt+uZZ57Rc889p0cffVQlJSUaP3682rRpoz/+8Y9e7hIAAICpfQDqicjISKWlpWnRokWSJKfTqbFjx+rEiRM+7gwAAAQjghQC1pmr2/3444+67777dNFFFyk6OloWi0W7d+927//rr79q7ty5uvnmm3XRRRepYcOGioyMVNu2bXXTTTdpyZIlcjqdlZ7vbKv2nXnNzYkTJ/T000/r8ssvV+PGjdW4cWP17t1bL774okpLK78ZXVWr9lXUw8qVKzVkyBC1atVKkZGROv/88zV+/Hj9/PPPZ/0ZHjp0SGlpaercubMaNGiguLg4DRw4UMuWLZMkvf766+7znf6zrEt/+tOfdMstt0iS9u/fr4ULF1a435dffqkpU6aof//+atWqlSIiIhQTE6MuXbpo/Pjx2rZtW4XHnXpPjz/+uLt26j2e/jj9/TqdTq1evVoTJ07UVVddpebNmys8PFxNmjRRjx49NHHiROXk5NTeDwEAAPieEeTy8/MNSUZ+fr6p44qKioxt27YZRUVFddQZqkOSIcno169fuW39+vVzb3v//feNhg0buvc/9di1a5dhGIZRWlpqhISElNt+5mPgwIHG0aNHK+xl165d7v1ee+21ctunTZvm3p6bm2v06NGj0vMMGTLEKCsrq/A8p7+vs/XwyCOPVHqOFi1aGNu2bav0Z/vNN98YcXFxlR5/1113Ga+99lq5n6VZp96PmT9H69at8/idnOn0vip7hIaGGnPmzKnRsWe+39N/t5U9oqOjjffee69GPyPD4G8OAMC/nSw7aTy+5nFj4JsDjcfXPG6cLDvp65ZqxEw24BopBLycnByNHDlS0dHReuyxx9S3b1+FhobqP//5jxo1aiTpv8ujX3PNNbr++uvVrVs3tWjRQkePHtXOnTs1f/58rV+/XitXrtS9996rN95445x6Sk5O1rZt2/TnP/9ZQ4YMUdOmTbV9+3Y98cQT+v777/Wvf/1L8+fP1913313jc8yfP1/r1q1Tv379dPfddyshIUFHjhzRm2++qTfffFMHDx7U//7v/2r9+vXljj1y5Ij+8Ic/aP/+/ZKkUaNGacSIEWrRooV27Nih5557Tq+88opXVs+riNVqVePGjXX06FGtX79epaWlCgv775+z0tJSnXfeebrpppv0+9//3j3CuG/fPm3evFnPP/+88vLydN999+niiy/WNddc4z526NCh6tWrl+bOnauXXnpJkipc8KRt27Ye52vdurWGDRumPn36qFOnToqKitLevXu1bt06zZ07V8eOHdOIESO0efNmXXLJJXX40wEAwPtmrJ2h9DXpMmRo1c5VkqSp/ab6uKs6Vve5zr8xIlW/qRojUpKMNm3aGHv27Kn0dZxOp/Hjjz9Wea6pU6cakgyLxWJkZ2eX225mRCo8PNz49NNPy+1z6NAh9yjQ7373uwr7qO6IlCRj3LhxhtPpLLff2LFj3fts3ry53PYHH3zQvX327NnltpeWlho33XRTpSM0ZtRkRMowDCMpKcl9XE5Ojse2n3/+2SgsLKz02CNHjhi/+93vDElGUlJShfuc/vs6m127dhklJSWVbt+7d6/Rtm1bQ5IxcuTIs75eRfibAwDwZwPfHGgoXe7HwDfLzxipD8xkA66RQlB46qmn1L59+0q3WywWXXjhhVW+xtSpU9W8eXMZhqEPPvjgnPq5//77K7zGqWnTphozZowk1yhIfn5+jc/RunVrvfDCCxXeB2nixInur9euXeuxrbi42H191RVXXKEHHnig3PGhoaF6+eWXFRUVVeP+zlWzZs3cXx8+fNhjW9u2bRUdHV3psbGxsZo+fbokKSsrS4cOHTqnXjp27Kjw8PBKt7dr104PP/ywJOmDDz7gBtEAgICT1D5JFrn+zWGRRUntk3zcUd1jal8Acjik7GwpIUGyWn3dje9FRES4FyeoLqfTqdzcXB09elQnT55019u1a6e8vLxzntJ2++23V7qtZ8+eklzTDXft2qUePXrU6Bw333yzIiMjK9zWuXNnNWrUSMeOHdPOnTs9tm3cuFFHjhyRJI0cObLS14+Li9OgQYP0z3/+s0b9natT0zIl6ejRo1XuW1hYqIMHD6qwsNAdYk4PPl9//bXH9L5zVVBQoEOHDun48ePu850KdgUFBdq1a5c6depUa+cDAMDXJvedLEnKyslSUvsk9/eBjCAVYGw2yW7/7/dpaVJGhu/68QcXXXRRtUZODMPQ3/72Ny1YsEAOh0NFRUWV7puXl3dOPV188cWVbmvatKn767MFhJqeQ5LOO+88HTt2rNw5tm7d6v76VKirTK9evXwWpE7vOyYmptz2vLw8zZo1S++++65+/PHHKkeBzvX3KUl79uzRM888o3/961/as2dPlfvm5eURpAAAASUsJCzwr4k6A0EqgDgcniFKcn2fnBzcI1PnnXfeWfc5ceKEkpOT9dFHH1XrNasKWdVR1bSzkJD/zrgtKyurk3Ocfp4zz3H6NLkWLVpU+Rpn216XTg8/p4dPSdq0aZMGDRpU7Sl75/r7/Oijj3TzzTfr+PHjXjkfAADwPa6RCiDZ2ebqwSI0NPSs+zz55JPuENWvXz+988472rFjh44dO6aysjIZhiHDMNS3b19J4hoXH3M6nfrmm28kuUajWrVq5d5WUlKiW2+9VYcOHVJ4eLhSU1P12Wef6ddff9WJEyfcv8uffvrJfcy5/D7z8vI0YsQIHT9+XI0aNVJ6errWr1+vAwcOqLi42H2+zMzMWjkfAADwD4xIBZCEBHN1uBiGoVdffVWS1LdvX61evdpjVOh0v/32mzdb84nTR/AOHjyohCo+QAcPHvRGS+WsX79ex44dkyT16dPHIyyvXr3afd3X3LlzNXbs2Apfo7Z+l0uXLnVfU7Zs2TINGDCgTs8HAAD8AyNSAcRqdV0TdTqbLbin9VXHb7/9ptzcXEnSLbfcUmmIOnbsmLZv3+7N1nzi0ksvdX+9adOmKvfduHFjXbdTodmzZ7u/HjZsmMe27777zv318OHDK32Ns/Ve0WqHFTl1vqZNm1YaoqpzPgAAUL8QpAJMRob05ZfSm2+6np96ytcd+b/S0lL314WFhZXu9+qrr3rsG6h69eql2NhYSdJbb71V6X779+/Xxx9/7K223BYvXqylS5dKci3xfscdd3hsr87v0+l0av78+VWe5/QFSoqLiyvd79T5Tpw4IafTWeE+x48f16JFi6o8HwAAvlbqLNX0z6brukXXafpn01XqDPx/95wLglQAslqlUaMYiaquFi1aqEmTJpKkv//97xX+o/k///mPHnvsMS935htRUVFKSUmR5Hrfzz33XLl9nE6n7r77bp04ccJrfZWUlOjpp5/WqFGjJLmufVuwYEG5Jd4vuugi99en7od1pkmTJmnz5s1Vnq9169bur0+/nupMp853/PhxvfPOO+W2l5WVaezYsdq3b1+V5wMAwNdmrJ2h9DXpWrlzpdLXpGvG2hm+bsmvcY0Ugl5ISIhuv/12zZkzR998842SkpKUmpqqiy66SPn5+Vq+fLnmzp2rRo0aqU2bNsoOgtU70tPT9Y9//EO5ubl68MEHtWnTJt1+++1q0aKFduzYoeeee07r1q1T7969tWHDBknVnwpXldOXXi8rK9ORI0f0yy+/aP369Vq6dKl7CmZkZKTmzJmj66+/vtxrDBo0SC1bttSBAwc0ZcoU7d69W8OGDVPz5s21Y8cOzZ8/X5mZmbrqqqv0xRdfVNrLlVde6f76oYce0qOPPqrWrVu732fHjh0VFhamW2+9VZMnT1ZxcbHGjBmjLVu2aODAgYqNjdV3332nF154QZs2bTrr+QAA8LWsnCwZci2IZMhQVk6WjzvybwQpQK5V+7744gtt2bJFGzdu1IgRIzy2N23aVO+++66mTp0aFEGqadOmWrFihQYOHKiDBw9q0aJF5aam3XHHHerbt687SFXnXl1n061btyq3WywWXXvttZo1a1al+zZs2FBvvvmmhg4dqhMnTujll1/Wyy+/7LFP//799eKLL6pr166VnuvCCy/UrbfeqnfeeUeffPKJPvnkE4/tu3btUseOHdWuXTu99NJLGjt2rE6cOKGMjAxlnHHztuHDh2vcuHFVXkMFAICvJbVP0qqdq2TIkEUWJbVP8nVLfo2pfYCk2NhYffHFF3riiSfUrVs3RUVFqVGjRrrkkks0ceJEff311/r973/v6za9qnv37tq2bZv+7//+TxdddJEiIyPVvHlzXX311Xr77bf12muvqaCgwL3/qeuqaktUVJTi4uJ0ySWX6NZbb9XTTz+t7du3a+XKlWcNXIMGDdLGjRs1cuRItWnTRuHh4WrRooX69eunV155RZmZmWrYsOFZe3jrrbdkt9vVu3dvxcbGVroQyZgxY7R27VoNHTpULVq0UHh4uFq3bq0//OEPWrJkiRYvXlytZfgBAPClyX0nK71/ugZ2Gqj0/uma3Heyr1vyaxYjyG9oUlBQoNjYWOXn5ysmJqbax504cUK7du3S+eefXyv/Jx6oj8aOHasFCxaoXbt22rt3r6/bCWj8zQEAoO6ZyQaMSAGokaKiIv3zn/+UJCUmJvq4GwAAAO8iSAGo0E8//aTKBqzLyso0fvx45eXlSZJGjx7tzdYAAAB8jsUmAFToiSee0IYNG/SnP/1JVqtVLVu2VFFRkb755hvNnz/fvXz4gAEDNHjwYB93CwAA4F0EKQCV+v777zVt2rRKt1911VVavHhxrSx9DgAAUJ8QpABUaNKkSUpISNCqVau0e/duHTx4UCdPnlSzZs3Uq1cvDR8+XH/6058qXckOAAD4RqmzVDPWzlBWTpaS2idpct/JCgvhn/21jZ8ogAp17txZkydP1uTJLH0KAEB9MmPtDKWvSZchQ6t2rpIkTe031cddBR7+VzIAAAAQQLJysmTItWCUIUNZOVk+7igwEaQAAACAAJLUPkkWua5ftsiipPZJPu4oMDG1DwAAAAggk/u6puWffo0Uah9BCgAAAAggYSFhXBPlBUztAwAAAACTCFIAAAAAYBJBCgAAAABMIkgBAAAAgEkEKQAAAMAPlTpLNf2z6bpu0XWa/tl0lTpLfd0STsOqfQAAAIAfmrF2htLXpMuQoVU7V0kSq/H5EUakAAAAAD+UlZMlQ4YkyZChrJwsH3eE0xGkAAAAAD+U1D5JFlkkSRZZlNQ+yccd4XRM7QMAAAD80OS+kyW5RqaS2ie5v4d/IEgBPtaxY0ft2bNHo0eP1uuvv+7rdgAAgJ8ICwnjmig/RpCCX9u9e7fOP//8c34dwzBqoRtUx6lgeKaGDRsqNjZWzZs3V/fu3XXFFVcoOTlZbdu29UGXAAAA54ZrpIA60L9/f1ksFvXv39/XrfiNwsJC7du3T998840WLVqkP//5z+rQoYOSk5O1e/fuOj//HXfcIYvFoo4dO9b5uQAAQOBjRAp+rW3btvr2228r3d6tWzdJUq9evfTaa695q61a5Y0Q4Qtt2rTRxx9/7P7+5MmTOnz4sPbs2aN169bpH//4h/Lz87Vs2TJlZmbqrbfe0pAhQ3zYMQAAQPURpODXwsPD1bVr17Pu17Bhw2rtB++p6nc3ZswY/fWvf9W0adM0a9YsFRQUaPjw4fr888/Vq1cvL3cKAABgHlP7APhEo0aN9Oyzz+qpp56SJBUVFWns2LE+7goAgNpV6izV9M+m67pF12n6Z9NV6iz1dUuoJQQpBLzNmzfrnnvuUefOndWoUSM1bNhQnTt31vjx45WdnV3lsUeOHNGTTz6pPn366LzzzlN4eLhatGihLl26aNiwYXrppZe0f/9+9/6nrsP57LPPJEmfffaZLBaLx+PMa3Q6duwoi8WiO+64o9z516xZ4z5uzZo1kqR33nlH1157rVq0aKEGDRqoc+fOSktL02+//XbWn0VOTo7Gjx+v888/X1FRUWrTpo2GDh2qTz/9VJKUnp7uPp+3pKWlyWq1SpK+/vprLV++vNw+TqdTq1ev1sSJE3XVVVepefPmCg8PV5MmTdSjRw9NnDhROTk5Fb7+qff0xhtvSJL27NlT7ndy5vstKSnRv/71L91333264oor3L/7Zs2ayWq1Kj09XXl5ebX8kwAABKIZa2cofU26Vu5cqfQ16ZqxdoavW0JtMYJcfn6+IcnIz883dVxRUZGxbds2o6ioqI46Q3VIMiQZ/fr1K7etrKzMeOihhwyLxeLe78xHWFiY8fLLL1f42tu2bTPatGlT6bGnHi+88IL7mNGjR591/w4dOnicp0OHDoYkY/To0eV6+PTTT93HZWZmGiNHjqz0dS+88ELj119/rfRnlZmZaTRq1KjCYy0Wi/Hkk08a06ZNc9dq6tT7OfN9VuXtt992n3fcuHHltp/eV2WP6Oho47333qvRsWe+3+r8Hps1a2ZkZWWZ/vnUFH9zAKB+GvjmQEPpcj8GvjnQ1y2hCmayAddIIWDdf//9mjt3riTp97//ve644w516tRJ0dHR+vrrrzV79mx99913uvvuu9WqVSvdeOONHsePGjVK+/btU3h4uMaNG6frr79erVq1ktPp1M8//6wvv/xSy5Yt8zjmySef1MSJEzVmzBht3LixwkUwIiIiavR+HnvsMa1bt05Dhw5VSkqKOnTooP3792vOnDn68MMPtWPHDj300EP6+9//Xu7YnTt36sYbb1RhYaHCwsI0fvx4DR06VDExMdq6dauefvppPfroo+6RIW8bMGCA++u1a9eW215aWqrWrVtr2LBh6tOnjzp16qSoqCjt3btX69at09y5c3Xs2DGNGDFCmzdv1iWXXOI+dsKECbr55ps1ZcoU/fOf/yy3CEZFSktL1alTJw0bNky9e/dW+/btFRYWpj179mjVqlVauHChDh06pGHDhmnr1q1q2bJl7f0wAAABJal9klbtXCVDhiyyKKl9kq9bQm3xQrDza4xI1W+qZETqk08+cW979dVXKzy2qKjIuOaaa9yjJydPnnRv++mnnyoccTqT0+k0fvvtt3L1fv36VTpSdqbqjkhJMv7yl79U2MN1113nHmE7cOBAuX2GDh3qfo1ly5aV215YWGj07t270hEaM2oyImUYhtGuXTv3ezjTrl27jJKSkkqP3bt3r9G2bVtDkjFy5MgK9zk1ylSdvnbs2GE4nc5Kt3/zzTfu0b0pU6ac9fVqA39zAKB+Oll20nh8zePGwDcHGo+vedw4WXby7AfBZ8xkA66RQkA6tYDB//zP/+jOO++scJ+oqCi9+OKLklzXzZy6TkiScnNz3V///ve/r/Q8FotF5513Xm20fFY9e/bU5MmTK+whNTVVkmskZf369R7b9+3bp3/961+SpJtvvllDhw4t9xrR0dF65ZVXar9pE5o1aybJ9R4KCgo8tnXs2FHh4eGVHtuuXTs9/PDDkqQPPvjgnG/AfMEFF1R5nVi3bt3cC2O8//7753QuAEBgCwsJ09R+U/XJqE80td9UhYUwISxQEKQQcAoKCtwLM9x8881V7nvJJZeoefPmkuQRQFq3bu3++vXXX6/1HmtixIgRlf7jvmfPnu6vd+7c6bHt008/VVlZmSTXdMXKdO/eXd27d6+FTmumUaNG7q+PHj1a5b4FBQXatWuXvvvuO23dulVbt25VdHS0x7badPjwYf30008e52vSpIkkadu2bTp58mStng8AAPg/InGAKXWWasbaGcrKyVJS+yRN7js56P7Px1dffSWn0ylJuu2223TbbbdV67jTR6HOP/989e3bV2vXrtVf//pXffzxx/qf//kf9e/fX4mJie5/tHvTxRdfXOm2pk2bur8+M4Rs3brV/fXpgasivXr10tdff13DDs/N6X3HxMSU275nzx4988wz+te//qU9e/ZU+Vp5eXnq1KnTOfXz7bff6q9//as++ugjj8/GmZxOpw4fPsx1UgAABJng+hd2EDi1xKYhQ6t2rpIkTe031cddedeBAwdqdNzx48c9vv/73/+uW265RevXr9e2bdu0bds2PfHEEwoPD1diYqJGjBihO+64Q1FRUbXR9llVFd5CQv47uHxq9OmUw4cPu79u0aJFlec42/a6dGo58bCwMDVu3Nhj20cffaSbb7653O+oMkVFRefUy4IFC3TPPfeotLR69/o41/MBAID6x++m9s2ZM0cdO3ZUVFSUrFarNmzYUOm+J0+e1PTp03XBBRcoKipK3bt314oVK7zYrf/JysmSIdf1IYYMZeVk+bgj7zs9SLz88sv69ttvq/V48sknPV6nbdu2WrdunVatWqUJEybo0ksvlcVi0cmTJ7V27VqNHz9eXbt2Peu9qHB2Bw4c0L59+yRJnTt39tiWl5enESNG6Pjx42rUqJHS09O1fv16HThwQMXFxTIMQ4ZhKDMz033MuVwj9cMPP7hDVMuWLfX0009r06ZNOnTokEpKStznW7BgQa2cDwAA1E9+NSK1ZMkSpaamat68ebJarZo9e7YGDRqk7du3VzhtZsqUKXrrrbc0f/58XXzxxfr44481bNgwrVu3TpdddpkP3oHvscTmfxctkFyjOF27dj2n17v22mt17bXXSpIOHTqkVatW6ZVXXtHq1av1008/afjw4frqq6/O6Rx16fTFMA4ePKi2bdtWuu/Bgwe90VI5K1eudH+dlOT5mV26dKmOHDkiSVq2bJnHUumnq84Niavj9ddfV2lpqUJDQ/XZZ59VOqWyts4HAKgfuHwCZ/KrEalZs2Zp3LhxGjNmjLp06aJ58+YpOjpaCxcurHD/RYsWafLkybrhhhvUqVMnjR8/XjfccIOeffZZL3fuPyb3naz0/uka2Gmg0vuna3Lf8qu8BboePXq4F2X44osvavW1mzVrpuHDhyszM9N936ktW7boxx9/9NivqhXfvO3SSy91f71p06Yq9924cWNdt1OOYRh6/vnn3d8PGzbMY/t3330nyXUdWGUhSjp779X9nZw6X/fu3au8Ls0XPysAgO+cunxi5c6VSl+TrhlrZ/i6JfiY3wSpkpISbdq0yeMfSiEhIRowYEC55ZxPKS4uLnd9SoMGDZSVFXzT2U5hiU3XdT6JiYmSpLfffrvORllOjVJJ/72+55RTn8vi4uI6ObcZ/fv3d19DtWjRokr3+/rrr32y0ERGRoZ7Cu/ll1+uQYMGeWw/dZ3SiRMn3IuInOn48eNVvjep+r+TU+crLCysdJ9ff/1VH3zwQZWvAwAILFw+gTP5TZDKy8tTWVmZ4uLiPOpxcXGVrpg1aNAgzZo1Sz/++KOcTqdWrlyp9957T7/++mul5ykuLlZBQYHHA4FnypQpklxLYd98883uqWEVKS4u1pw5c3TixAl3bcuWLdqyZUulxxiGoVWrXIt5WCwWdezY0WP7qeXTd+7c6fPrZ9q1a6fBgwdLck2Tq+i+R0VFRbrrrru82texY8c0ceJETZo0SZJrGuarr75abr+LLrpIkissvfPOO+W2l5WVaezYse5rrCpz6ndy4MCBKpdXP3W+H3/8UevWrSu3/fjx4xoxYgQLTABAkElqnySLXLMbgvXyCXiq18MVzz33nMaNG6eLL75YFotFF1xwgcaMGVPpVEBJmjlzph5//HEvdglfuOGGG/TAAw/oueee0+eff65LLrlE99xzj5KSktSsWTMVFhZqx44dWrt2rd577z0dPnxYo0ePdh+/ZcsWjRkzRldccYWGDBmiyy+/XK1atdLJkye1a9cuvfbaa+7rem688UaP+05J0pVXXqnXXntNBw4cUGpqqkaOHKnY2FhJUnh4uDp06OC9H4Zc02YzMzN1/Phx3XLLLRo/fryGDRummJgYbd26VXa7Xdu2bdMVV1yh//znP7VyzpMnT3osvX7y5EkdOXJEu3fv1rp16zyufYqNjdXf/va3Cq9tvPXWWzV58mQVFxdrzJgx2rJliwYOHKjY2Fh99913euGFF7Rp0yZdddVVVU7lvPLKKyW5liu/5557dP/997vvISZJF154oSTXvbZeeOEFOZ1ODR48WA8//LCSkpIUFRWlTZs26a9//at+/PHHs54PABBYTl0ucfo1Ughyhp8oLi42QkNDjWXLlnnUU1JSjBtvvLHKY4uKioyff/7ZcDqdRlpamtGlS5dK9z1x4oSRn5/vfuzdu9eQZOTn55vqt6ioyNi2bZtRVFRk6jjULkmGJKNfv37ltjmdTuPxxx83wsLC3PtV9mjYsKFx/Phx97GvvfbaWY+RZFx55ZVGXl5euXMfPXrU6NSpU4XHdOjQwWPfDh06GJKM0aNHl3udTz/91H3cp59+Wq2fxbRp0yrc/sknnxgNGzas9L1MmzbNeOyxxwxJRlRUVJXnqsqp91OdR1hYmJGcnGzs3r27ytdcuHChERISUunrDB8+3Fi1alWVP6uysjIjMTGx0tc43eOPP15l3//3f//n8RnZtWtXjX9e1cXfHAAA6l5+fn61s4HfTO2LiIhQz549PZYwdjqdyszMVJ8+fao8NioqSm3btlVpaaneffdd3XTTTZXuGxkZqZiYGI8HApPFYtHUqVOVnZ2ttLQ09erVS02bNlVoaKgaN26sLl266Pbbb9cbb7yhX3/9VQ0aNHAfe9ttt2n58uV66KGHlJSUpPPPP1/R0dGKiIhQu3btdOONN+pvf/ub1q5d67FK4CmNGjXSunXr9MADD+iSSy7xyQ18zzRw4EBt3bpVd999tzp06KCIiAjFxcVp8ODBWrFihdLT091TXU+NntWm6OhotW7dWt26ddPIkSP1/PPPa8+ePXr33XfPOkI3ZswYrV27VkOHDlWLFi0UHh6u1q1b6w9/+IOWLFmixYsXKzQ0tMrXCAkJ0SeffKIpU6aoe/fuatSoUaULUEydOlUffvihrrvuOp133nnu33tycrI++eQTPfPMMzX+OQAAgMBgMQz/uQHKkiVLNHr0aL388svq3bu3Zs+erXfeeUc//PCD4uLilJKSorZt22rmzJmSJIfDoV9++UU9evTQL7/8ovT0dO3atUubN29WkyZNqnXOgoICxcbGKj8/31SoOnHihHbt2qXzzz/fazdkBeragAEDlJmZqaSkJK1du9bX7eA0/M0BAKDumckGfnWN1PDhw3Xw4EFNnTpVubm56tGjh1asWOFegCInJ8e9+pjk+ofFlClTtHPnTjVq1Eg33HCDFi1aVO0QBeC/9u3bp88//1yS3KseAgAAoGJ+NSLlC4xIIVjs2LHDvaDCmYqKinTTTTe5F9D45ptv1K1bN2+2h7Pgbw4AAHWv3o5IAag7Y8eOVWFhoW699Vb17NlTTZs21dGjR7Vx40bNnTtXO3bskCTdeeedhCgAQEAqdZZqxtoZHivvBeM9N1E7+OQAQWTjxo3auHFjpduHDRumF154wYsdAQDgPTPWzlD6mnQZMrRqp+t+kFP7TfVxV6ivCFJAkJg1a5aWLVum1atX6+eff9bBgwdlGIZatmypxMREjR49WjfccIOv2wQAoM5k5WTJkOuqFkOGsnKyfNwR6jOCFBAkLr/8cl1++eV64oknfN0KAAA+kdQ+Sat2rpIhQxZZlNQ+ydctoR4jSAEAACAoTO47WZI8rpECaoogBQAAgKAQFhLGNVGoNSFn3wUAAAAAcDqCFAAAAACYRJA6R0F+P2MAXsLfGgAA/AtBqoZCQlw/OqfT6eNOAASDsrIySf/92wMAAHyL/yLXUHh4uEJDQ1VYWOjrVgAEgePHjys0NFTh4eG+bgUAfK7UWarpn03XdYuu0/TPpqvUWerrlhCEWLWvhiwWixo3bqyCggK1aNFCFovF1y0BCFCGYaigoECNGzfmbw0ASJqxdobS16TLkKFVO1dJEqvxwesYkToHsbGxOnnypPbt28f1CwDqhGEY2rdvn06ePKnY2FhftwMAfiErJ0uGXP/2MmQoKyfLxx0hGDEidQ6io6PVrl07/fzzzyoqKlJMTIyio6MVGhrK/zUGUGOGYaisrEzHjx9XQUGBTp48qXbt2ik6OtrXrQGAX0hqn6RVO1fJkCGLLEpqn+TrlhCECFLnqHHjxurQoYPy8/N15MgRHTp0yNctAQgQoaGhaty4sWJjYwlRAHCayX0nS3KNTCW1T3J/D3iTxQjyOWkFBQWKjY1Vfn6+YmJizum1DMPQyZMnWckPwDkLCQlReHg4o9sAAHiRmWzAiFQtslgsioiI8HUbAAAAAOoYi00AAAAAgEkEKQAAAAAwiSAFAAAAACYRpAAAAOATpc5STf9suq5bdJ2mfzZdpc5SX7cEVBuLTQAAAMAnZqydofQ16TJkaNXOVZKkqf2m+rgroHoYkQIAAIBPZOVkyZDrTjyGDGXlZPm4I6D6CFIAAADwiaT2SbLIdb88iyxKap/k446A6mNqHwAAAHxict/JklwjU0ntk9zfA/UBQQoAAAA+ERYSxjVRqLeY2gcAAAAAJhGkAAAAAMAkghQAAAAAmMQ1UgAAADgnDoeUnS0lJEhWq6+7AbyDESkAAADUmM0mJSZKKSmuZ5vN1x0B3kGQAgAAQI04HJLd7lmz2111INARpAAAAFAj2dnm6kAgIUgBAACgRhISzNWBQEKQAgAAQI1YrVJammfNZmPBCQQHVu0DAABAjWVkSMnJrNqH4EOQAgAAwDmxWglQCD5M7QMAAAAAkwhSAAAAAGASU/sAAAAgyXX/J651AqqHESkAAADIZpMSE6WUFNezzebrjgD/RpACAAAIcg6HZLd71ux2Vx1AxQhSAAAAQS4721wdAEEKAAAg6CUkmKsDIEgBAAAEPatVSkvzrNlsLDgBVIVV+wAAAKCMDCk5mVX7gOoiSAEAAECSKzwRoIDqYWofAAAAAJhEkAIAAAAAk5jaBwAAEGAcDq51AuoaI1IAAAABxGaTEhOllBTXs83m646AwESQAgAACBAOh2S3e9bsdlcdQO0iSAEAAASI7GxzdQA1R5ACAAAIEAkJ5uoAao4gBQAAECCsViktzbNms7HgBFAXWLUPAAAggGRkSMnJrNoH1DWCFAAAQICxWglQQF1jah8AAAAAmESQAgAAAACTmNoHAADghxwOrnMC/BkjUgAAAH7GZpMSE6WUFNezzebrjgCcye+C1Jw5c9SxY0dFRUXJarVqw4YNVe4/e/Zsde7cWQ0aNFB8fLweeughnThxwkvdAgAA1C6HQ7LbPWt2u6sOwH/4VZBasmSJUlNTNW3aNG3evFndu3fXoEGDdODAgQr3f/vtt/XII49o2rRp+v7777VgwQItWbJEkydP9nLnAAAAtSM721wdgG/4VZCaNWuWxo0bpzFjxqhLly6aN2+eoqOjtXDhwgr3X7duna666iqNGDFCHTt21HXXXafbbrvtrKNYAAAA/iohwVwdgG/4TZAqKSnRpk2bNGDAAHctJCREAwYM0Pr16ys85sorr9SmTZvcwWnnzp1avny5brjhhkrPU1xcrIKCAo8HAACAv7BapbQ0z5rNxoITgL/xm1X78vLyVFZWpri4OI96XFycfvjhhwqPGTFihPLy8pSUlCTDMFRaWqp77rmnyql9M2fO1OOPP16rvQMAANSmjAwpOZlV+wB/5jcjUjWxZs0azZgxQ3PnztXmzZv13nvv6cMPP9QTTzxR6TGTJk1Sfn6++7F3714vdgwAAFA9Vqs0ahQhCvBXfjMi1bx5c4WGhmr//v0e9f3796tVq1YVHvPYY49p1KhRGjt2rCSpW7duKiws1F133aVHH31UISHlc2JkZKQiIyNr/w0AAAAACBp+MyIVERGhnj17KjMz011zOp3KzMxUnz59Kjzm+PHj5cJSaGioJMkwjLprFgAAAEBQ85sRKUlKTU3V6NGj1atXL/Xu3VuzZ89WYWGhxowZI0lKSUlR27ZtNXPmTEnSkCFDNGvWLF122WWyWq3asWOHHnvsMQ0ZMsQdqAAAAHzJ4eBaJyAQ+VWQGj58uA4ePKipU6cqNzdXPXr00IoVK9wLUOTk5HiMQE2ZMkUWi0VTpkzRL7/8ohYtWmjIkCF68sknffUWAAAA3Gw2z5vrpqW5FpIAUP9ZjCCfA1dQUKDY2Fjl5+crJibG1+0AAIAA4XBIiYnl619+ycgU4K/MZAO/uUYKAAAgkGRnm6sDqF8IUgAAAHUgIcFcHUD9QpACAACoA1ar65qo09lsTOsDAoVfLTYBAAAQSDIypORkVu0DAhFBCgAAoA5ZrQQoIBAxtQ8AAAAATCJIAQAAAIBJTO0DAAA4C4eD65wAeGJECgAAoAo2m+vGuikprmebzdcdAfAHBCkAAIBKOByS3e5Zs9tddQDBjSAFAABQiexsc3UAwYMgBQAAUImEBHN1AMGDIAUAAFAJq1VKS/Os2WwsOAGAVfsAAACqlJEhJSezah8ATwQpAACAs7BaCVAAPDG1DwAAAABMIkgBAAAAgElM7QMAAEHD4eBaJwC1gxEpAAAQFGw2KTFRSklxPdtsvu4IQH1GkAIAAAHP4ZDsds+a3e6qA0BNEKQAAEDAy842VweAsyFIAQCAgJeQYK4OAGdDkAIAAAHPapXS0jxrNhsLTgCoOVbtAwAAQSEjQ0pOZtU+ALWDIAUAAIKG1UqAAlA7mNoHAAAAACYRpAAAAADAJKb2AQCAesfh4FonAL7FiBQAAKhXbDYpMVFKSXE922y+7ghAMCJIAQCAesPhkOx2z5rd7qoDgDcRpAAAQL2RnW2uDgB1hSAFAADqjYQEc3UAqCsEKQAAUG9YrVJammfNZmPBCQDex6p9AACgXsnIkJKTWbUPgG8RpAAAQL1jtRKgAPgWU/sAAAAAwCSCFAAAAACYxNQ+AADgEw4H1zkBqL8YkQIAAF5ns0mJiVJKiuvZZvN1RwBgDkEKAAB4lcMh2e2eNbvdVQeA+oIgBQAAvCo721wdAPwRQQoAAHhVQoK5OgD4I4IUAADwKqtVSkvzrNlsLDgBoH5h1T4AAOB1GRlScjKr9gGovwhSAADAJ6xWAhSA+oupfQAAAABgEkEKAAAAAExiah8AADgnDgfXOgEIPoxIAQCAGrPZpMREKSXF9Wyz+bojAPAOghQAAKgRh0Oy2z1rdrurDgCBjiAFAABqJDvbXB0AAglBCgAA1EhCgrk6AAQSghQAAKgRq1VKS/Os2WwsOAEgOLBqHwAAqLGMDCk5mVX7AAQfghQAADgnVisBCkDwYWofAAAAAJhEkAIAAAAAk5jaBwAA5HBwnRMAmMGIFAAAQc5mkxITpZQU17PN5uuOAMD/EaQAAAhiDodkt3vW7HZXHQBQOb8MUnPmzFHHjh0VFRUlq9WqDRs2VLpv//79ZbFYyj0GDx7sxY4BAKifsrPN1QEALn4XpJYsWaLU1FRNmzZNmzdvVvfu3TVo0CAdOHCgwv3fe+89/frrr+7H1q1bFRoaqltuucXLnQMAUP8kJJirAwBc/C5IzZo1S+PGjdOYMWPUpUsXzZs3T9HR0Vq4cGGF+zdt2lStWrVyP1auXKno6GiCFAAA1WC1SmlpnjWbjQUnAOBs/GrVvpKSEm3atEmTJk1y10JCQjRgwACtX7++Wq+xYMEC/elPf1LDhg3rqk0AAAJKRoaUnMyqfQBghl8Fqby8PJWVlSkuLs6jHhcXpx9++OGsx2/YsEFbt27VggULKt2nuLhYxcXF7u8LCgpq3jAAAAHCaiVAAYAZfje171wsWLBA3bp1U+/evSvdZ+bMmYqNjXU/4uPjvdghAAAAgEDgV0GqefPmCg0N1f79+z3q+/fvV6tWrao8trCwUIsXL9add95Z5X6TJk1Sfn6++7F3795z7hsAAABAcPGrIBUREaGePXsqMzPTXXM6ncrMzFSfPn2qPPYf//iHiouLNXLkyCr3i4yMVExMjMcDAIBA4XBIixZxHygAqGt+FaQkKTU1VfPnz9cbb7yh77//XuPHj1dhYaHGjBkjSUpJSfFYjOKUBQsWaOjQoWrWrJm3WwYAwC/YbFJiopSS4nq22XzdEQAELr9abEKShg8froMHD2rq1KnKzc1Vjx49tGLFCvcCFDk5OQoJ8cx/27dvV1ZWlj755BNftAwAgM85HJLd7lmz212r8bGIBADUPothGIavm/ClgoICxcbGKj8/n2l+AIB6a9Ei10jUmd58Uxo1yvv9AEB9ZCYb+N3UPgAAYF5Cgrk6AODcEKQAAAgAVquUluZZs9mY1gcAdcXvrpECAAA1k5HhuiYqO9s1EkWIAoC6Q5ACACCAWK0EKADwBqb2AQAAAIBJBCkAAAAAMImpfQAA+CGHg2udAMCfMSIFAICfsdmkxETXfaESE13fAwD8C0EKAAA/4nBIdrtnzW531QEA/oMgBQCAH8nONlcHAPgGQQoAAD+SkGCuDgDwDYIUAAB+xGqV0tI8azYbC04AgL+ptVX7jh8/rsWLF6u4uFg33HCDOnToUFsvDQBAUMnIkJKTWbUPAPxZjYLUnXfeKYfDoa1bt0qSSkpKlJiY6P4+NjZWq1ev1mWXXVZ7nQIAEESsVgIUAPizGk3t+/TTT5WcnOz+/u2339bWrVv1t7/9TVu3blWrVq30+OOP11qTAAAAAOBPahSkcnNz1bFjR/f377//vnr16qXbbrtNXbp00bhx4+RgnVYAAAAAAapGQaphw4Y6cuSIJKm0tFRr1qzRoEGD3NsbN26s/Pz8WmkQAID6yuGQFi3iHlAAEIhqdI3U5Zdfrvnz5+vqq6/WBx98oKNHj2rIkCHu7T/99JPi4uJqrUkAAOobm83zxrppaa5FJAAAgcFiGIZh9qCNGzdq0KBBOnLkiAzD0M0336x33nnHvb1z58664oor9NZbb9Vqs3WhoKBAsbGxys/PV0xMjK/bAQAEAIdDSkwsX//ySxaQAAB/ZiYb1GhEqlevXvrhhx+0bt06NWnSRP369XNvO3LkiCZMmOBRAwAgmGRnV14nSAFAYKjRiFQgYUQKAFDbGJECgPqp1kekcnJyJEnt27f3+P5sTu0PAEAwsVpd10Sdfo2UzUaIAoBAUq0RqZCQEFksFhUVFSkiIsL9/dmUlZXVSpN1iREpAEBdcThc0/kSEghRAFAf1PqI1MKFC2WxWBQeHu7xPQAAqJzVSoACgEDFNVKMSAEAAACQuWxQoxvyFhUVnXWfPXv21OSlAQAAAMDv1ShI/e53v9MXX3xR6faXXnpJ3bp1q3FTAAD4E4dDWrTI9QwAgFTDIBUVFaV+/fpp4sSJKi4udtf37t2r6667Tvfee68GDhxYa00CAOArNptrKfOUFNezzebrjgAA/qBGQWrz5s16+OGH9dxzz+myyy6Tw+HQq6++qq5du2rTpk1666239O6779Z2rwAAeJXD4bmEueT6npEpAECNglR4eLhmzpyprKwslZWV6corr9Tdd9+t/v3767vvvtOIESNqu08AALwuO9tcHQAQPGoUpE7ZuXOn8vLyFBERIcMwVFJSoiBfBBAAEEASEszVAQDBo0ZBKi8vTzfffLNuv/12Wa1W/fTTT1q0aJE2bNigSy+9VG+99VZt9wkAgNdZrVJammfNZuPeUACAGt5HqmXLljpx4oSeffZZjRs3zl3/9ddfNW7cOC1fvlw33XSTli1bVqvN1gXuIwUAOBuHwzWdLyGBEAUAgcxMNqhRkLrmmmu0cOFCdezYscLtr732mlJTU3X48GGzL+11BCkAAAAAkheCVHX88ssvatu2bV28dK0iSAEAAACQzGWDc1psoir1IUQBAAAAQE2E1fTAEydO6N1339XmzZuVn58vp9Ppsd1isWjBggXn3CAAALWFa50AALWlRkFqz549uvrqq7V79241adJE+fn5atq0qY4cOaKysjI1b95cjRo1qu1eAQCoMZvN8+a6aWlSRobv+gEA1G81mtr38MMPKz8/X19++aWys7NlGIaWLFmiY8eOKSMjQw0aNNDHH39c270CAFAjDodniJJc3zscvukHAFD/1ShIrV69WhMmTFDv3r0VEuJ6CcMwFBkZqYcffljXXnutHnzwwdrsEwCAGsvONlcHAOBsahSkjh8/7l76PCYmRhaLRfn5+e7tffr0UVZWVq00CADAuUpIMFcHAOBsahSk2rdvr59//lmSFBYWprZt2+rLL790b9+2bZuioqJqp0MAAM6R1eq6Jup0NhsLTgAAaq5Gi01cc801+uc//6lp06ZJku644w7NnDlThw8fltPp1KJFi5SSklKrjQIAcC4yMqTkZFbtAwDUjhrdkDcnJ0f/+c9/9Mc//lGRkZE6ceKE7rvvPr377rsKDQ3VH//4Rz3//PP14ga33JAXAAAAgGQuG9QoSAUSghQAAAAAyVw2qNE1Umc6efKkPv/8c48FJwAAAAAgUNVKkPrtt9909dVXa9OmTbXxcgAAVMrhkBYt4h5QAADfqpUgJbnuIwUAQF2y2aTERCklxfVss/m6IwBAsKp2kOrTp4+2bt1a6XaLxVIrDQEAUBGHQ7LbPWt2OyNTAADfqHaQ2r17t3r27KnJkyfrxIkT5bYzIgUAqEvZ2ebqAADUpWoHqe3bt2vs2LGy2+3q1q2bVq1a5d7WokUL7dq1S1dddVWdNAkAQEKCuToAAHWp2kEqJiZGc+bM0fr16xUTE6NBgwZp1KhROnjwoEJCQtShQwdFRkbWZa8AgCBmtUppaZ41m40b6wIAfKNG95FyOp164YUX9Nhjjyk0NFTx8fHlX9hi0ddff10rTdYl7iMFAPWLw+GazpeQQIgCANQuM9kgrCYnKC0t1cGDB1VcXKxmzZqpWbNmNWoUAACzrFYCFADA90wHqVWrVmnChAnauXOnJkyYoCeffFKNGzeui94AAAAAwC9V+xqpgwcPauTIkRo0aJCio6O1bt06Pf/884QoAAAAAEGn2iNSnTt3VklJiZ566imlpqYqNDS0LvsCAAQ4rnUCANRn1Q5SiYmJmjt3rjp27FiH7QAAgoHN5nlz3bQ0KSPDd/0AAGBWjVbtCySs2gcA3uVwSImJ5etffsnIFADAt8xkg2pfIwUAQG3IzjZXBwDAHxGkAABelZBgrg4AgD/yuyA1Z84cdezYUVFRUbJardqwYUOV+x85ckT33nuvWrdurcjISCUkJGj58uVe6hYAYJbV6rom6nQ2G9P6AAD1S41uyFtXlixZotTUVM2bN09Wq1WzZ8/WoEGDtH37drVs2bLc/iUlJRo4cKBatmyppUuXqm3bttqzZ4+aNGni/eYBANWWkSElJ7NqHwCg/vKrxSasVquuuOIKvfjii5Ikp9Op+Ph43X///XrkkUfK7T9v3jw9/fTT+uGHHxQeHl6jc7LYBAAAAACpni42UVJSok2bNmnAgAHuWkhIiAYMGKD169dXeMwHH3ygPn366N5771VcXJy6du2qGTNmqKysrNLzFBcXq6CgwOMBAAAAAGb4TZDKy8tTWVmZ4uLiPOpxcXHKzc2t8JidO3dq6dKlKisr0/Lly/XYY4/p2Wef1V/+8pdKzzNz5kzFxsa6H/Hx8bX6PgAAAAAEPr8JUjXhdDrVsmVLvfLKK+rZs6eGDx+uRx99VPPmzav0mEmTJik/P9/92Lt3rxc7BoDA4nBIixa5ngEACCZ+s9hE8+bNFRoaqv3793vU9+/fr1atWlV4TOvWrRUeHq7Q0FB37ZJLLlFubq5KSkoUERFR7pjIyEhFRkbWbvMAEIRsNslu/+/3aWmuRSQAAAgGfjMiFRERoZ49eyozM9NdczqdyszMVJ8+fSo85qqrrtKOHTvkdDrdtezsbLVu3brCEAUAqB0Oh2eIklzfMzIFAAgWfhOkJCk1NVXz58/XG2+8oe+//17jx49XYWGhxowZI0lKSUnRpEmT3PuPHz9ev/32mx544AFlZ2frww8/1IwZM3Tvvff66i0AQFDIzjZXBwAg0PjN1D5JGj58uA4ePKipU6cqNzdXPXr00IoVK9wLUOTk5Cgk5L/ZLz4+Xh9//LEeeugh/e53v1Pbtm31wAMPyGaz+eotAEBQSEgwVwcAIND41X2kfIH7SAFAzZx5jZTNJj31lO/6AQDgXJnJBn41IgUAqD8yMqTkZNd0voQEyWr1dUcAAHgPQQoAUGNWKwEKABCc/GqxCQAAAACoDwhSAAAAAGASU/sAAHI4uNYJAAAzGJECgCBns0mJiVJKiuuZO0gAAHB2BCkACGIOh+cS5pLre4fDN/0AAFBfEKQAIIhlZ5urAwAAF4IUAASxhARzdQAA4EKQAoAgZrVKaWmeNZuNBScAADgbVu0DgCCXkSElJ7NqHwAAZhCkAACyWglQAACYwdQ+AAAAADCJIAUAAAAAJjG1DwACiMPBtU4AAHgDI1IAECBsNikxUUpJcT3bbL7uCACAwEWQAoAA4HBIdrtnzW531QEAQO0jSAFAAMjONlcHAADnhiAFAAEgIcFcHQAAnBuCFAAEAKtVSkvzrNlsLDgBAEBdYdU+AAgQGRlScjKr9gEA4A0EKQAIIFYrAQoAAG9gah8AAAAAmESQAgAAAACTmNoHAH7G4eA6JwAA/B0jUgDgR2w2KTFRSklxPdtsvu4IAABUhCAFAH7C4ZDsds+a3e6qAwAA/0KQAgA/kZ1trg4AAHyHIAUAfiIhwVwdAAD4DkEKAPyE1SqlpXnWbDYWnAAAwB+xah8A+JGMDCk5mVX7AADwdwQpAPAzVisBCgAAf8fUPgAAAAAwiSAFAAAAACYxtQ8A6ojDwbVOAAAEKkakAKAO2GxSYqKUkuJ6ttl83REAAKhNBCkAqGUOh2S3e9bsdlcdAAAEBoIUANSy7GxzdQAAUP8QpACgliUkmKsDAID6hyAFALXMapXS0jxrNhsLTgAAEEhYtQ8A6kBGhpSczKp9AAAEKoIUANQRq5UABQBAoGJqHwAAAACYRJACAAAAAJOY2gcAZ+FwcK0TAADwxIgUAFTBZpMSE6WUFNezzebrjgAAgD8gSAFAJRwOyW73rNntrjoAAAhuBCkAqER2trk6AAAIHgQpAKhEQoK5OgAACB4EKQCohNUqpaV51mw2FpwAAACs2gcAVcrIkJKTWbUPAAB4IkgBwFlYrQQoAADgial9AAAAAGASQQoAAAAATGJqH4Cg4HBwnRMAAKg9jEgBCHg2m5SYKKWkuJ5tNl93BAAA6juCFICA5nBIdrtnzW531QEAAGqKIAUgoGVnm6sDAABUB0EKQEBLSDBXBwAAqA6CFICAZrVKaWmeNZuNBScAAMC58csgNWfOHHXs2FFRUVGyWq3asGFDpfu+/vrrslgsHo+oqCgvdgvA32VkSF9+Kb35puv5qad83REAAKjv/G758yVLlig1NVXz5s2T1WrV7NmzNWjQIG3fvl0tW7as8JiYmBht377d/b3FYvFWuwDqCauVUSgAAFB7/G5EatasWRo3bpzGjBmjLl26aN68eYqOjtbChQsrPcZisahVq1buR1xcnBc7BgAAABBs/CpIlZSUaNOmTRowYIC7FhISogEDBmj9+vWVHnfs2DF16NBB8fHxuummm/Tdd99Vum9xcbEKCgo8HgAAAABghl8Fqby8PJWVlZUbUYqLi1Nubm6Fx3Tu3FkLFy7UP//5T7311ltyOp268sor9fPPP1e4/8yZMxUbG+t+xMfH1/r7AFB3HA5p0SLuAwUAAHzLr4JUTfTp00cpKSnq0aOH+vXrp/fee08tWrTQyy+/XOH+kyZNUn5+vvuxd+9eL3cMoKZsNikxUUpJcT3bbL7uCAAABCu/ClLNmzdXaGio9u/f71Hfv3+/WrVqVa3XCA8P12WXXaYdO3ZUuD0yMlIxMTEeDwD+z+GQ7HbPmt3OyBQAAPANvwpSERER6tmzpzIzM901p9OpzMxM9enTp1qvUVZWpm+//VatW7euqzYB+EB2trk6AABAXfK75c9TU1M1evRo9erVS71799bs2bNVWFioMWPGSJJSUlLUtm1bzZw5U5I0ffp0JSYm6sILL9SRI0f09NNPa8+ePRo7dqwv3waAWpaQYK4OAABQl/wuSA0fPlwHDx7U1KlTlZubqx49emjFihXuBShycnIUEvLfgbTDhw9r3Lhxys3N1XnnnaeePXtq3bp16tKli6/eAoA6YLVKaWme0/tsNu4NBQAAfMNiGIbh6yZ8qaCgQLGxscrPz+d6KaAecDhc0/kSEghRAACgdpnJBn43IgUAVbFaCVAAAMD3/GqxCQAAAACoDwhSAAAAAGASU/sAeB3XOQEAgPqOESkAXmWzSYmJUkqK69lm83VHAAAA5hGkAHiNw+G5fLnk+t7h8E0/AAAANUWQAuA12dnm6gAAAP6KIAXAaxISzNUBAAD8FUEKgNdYrVJammfNZmPBCQAAUP+wah8Ar8rIkJKTWbUPAADUbwQpAF5ntRKgAABA/cbUPgAAAAAwiSAFAAAAACYxtQ9AjTkcXOsEAACCEyNSAGrEZpMSE6WUFNezzebrjgAAALyHIAXANIdDsts9a3a7qw4AABAMCFIATMvONlcHAAAINAQpAKYlJJirAwAABBqCFADTrFYpLc2zZrOx4AQAAAgerNoHoEYyMqTkZFbtAwAAwYkgBaDGrFYCFAAACE5M7QMAAAAAkwhSAAAAAGASU/sAyOHgWicAAAAzGJECgpzNJiUmSikprmebzdcdAQAA+D+CFBDEHA7Jbves2e2uOgAAACpHkAKCWHa2uToAAABcCFJAEEtIMFcHAACAC0EKCGJWq5SW5lmz2VhwAgAA4GxYtQ8IchkZUnIyq/YBAACYQZACIKuVAAUAAGAGU/sAAAAAwCSCFAAAAACYxNQ+IEA4HFznBAAA4C2MSAEBwGaTEhOllBTXs83m644AAAACG0EKqOccDslu96zZ7a46AAAA6gZBCqjnsrPN1QEAAHDuCFJAPZeQYK4OAACAc0eQAuo5q1VKS/Os2WwsOAEAAFCXWLUPCAAZGVJyMqv2AQAAeAtBCggQVisBCgAAwFuY2gcAAAAAJhGkAAAAAMAkpvYBfsbh4FonAAAAf8eIFOBHbDYpMVFKSXE922y+7ggAAAAVIUgBfsLhkOx2z5rd7qoDAADAvxCkAD+RnW2uDgAAAN8hSAF+IiHBXB0AAAC+Q5AC/ITVKqWledZsNhacAAAA8Ees2gf4kYwMKTmZVfsAAAD8HUEK8DNWKwEKAADA3zG1DwAAAABMIkgBAAAAgElM7QPqiMPBtU4AAACBihEpoA7YbFJiopSS4nq22XzdEQAAAGoTQQqoZQ6HZLd71ux2Vx0AAACBgSAF1LLsbHN1AAAA1D8EKaCWJSSYqwMAAKD+IUgBtcxqldLSPGs2GwtOAAAABBJW7QPqQEaGlJzMqn0AAACBiiAF1BGrlQAFAAAQqPxyat+cOXPUsWNHRUVFyWq1asOGDdU6bvHixbJYLBo6dGjdNggAAAAgqPldkFqyZIlSU1M1bdo0bd68Wd27d9egQYN04MCBKo/bvXu3Jk6cqL59+3qpUwAAAADByu+C1KxZszRu3DiNGTNGXbp00bx58xQdHa2FCxdWekxZWZluv/12Pf744+rUqZMXu0WgczikRYu4BxQAAAA8+VWQKikp0aZNmzRgwAB3LSQkRAMGDND69esrPW769Olq2bKl7rzzzrOeo7i4WAUFBR4PoCI2m5SYKKWkuJ5tNl93BAAAAH/hV0EqLy9PZWVliouL86jHxcUpNze3wmOysrK0YMECzZ8/v1rnmDlzpmJjY92P+Pj4c+4bgcfhkOx2z5rdzsgUAAAAXPwqSJl19OhRjRo1SvPnz1fz5s2rdcykSZOUn5/vfuzdu7eOu0R9lJ1trg4AAIDg4lfLnzdv3lyhoaHav3+/R33//v1q1apVuf1/+ukn7d69W0OGDHHXnE6nJCksLEzbt2/XBRdc4HFMZGSkIiMj66B7BJKEBHN1AAAABBe/GpGKiIhQz549lZmZ6a45nU5lZmaqT58+5fa/+OKL9e2332rLli3ux4033qirr75aW7ZsYdoeasxqldLSPGs2G/eFAgAAgItfjUhJUmpqqkaPHq1evXqpd+/emj17tgoLCzVmzBhJUkpKitq2bauZM2cqKipKXbt29Ti+SZMmklSuDpiVkSElJ7um8yUkEKIAAADwX34XpIYPH66DBw9q6tSpys3NVY8ePbRixQr3AhQ5OTkKCfGrgTQEMKuVAAUAAIDyLIZhGL5uwpcKCgoUGxur/Px8xcTE+LodAAAAAD5iJhswtAMAAAAAJvnd1D6gLjgcXOsEAACA2sOIFAKezSYlJkopKa5nm83XHQEAAKC+I0ghoDkckt3uWbPbXXUAAACgpghSCGjZ2ebqAAAAQHUQpBDQEhLM1QEAAIDqIEghoFmtUlqaZ81mY8EJAAAAnBtW7UPAy8iQkpNZtQ8AAAC1hyCFoGC1EqAAAABQe5jaBwAAAAAmEaQAAAAAwCSm9qHecDi4zgkAAAD+gREp1As2m5SYKKWkuJ5tNl93BAAAgGBGkILfczgku92zZre76gAAAIAvEKTg97KzzdUBAACAukaQgt9LSDBXBwAAAOoaQQp+z2qV0tI8azYbC04AAADAd1i1D/VCRoaUnMyqfQAAAPAPBCnUG1YrAQoAAAD+gal9AAAAAGASQQoAAAAATGJqH7zO4eBaJwAAANRvjEjBq2w2KTFRSklxPdtsvu4IAAAAMI8gBa9xOCS73bNmt7vqAAAAQH1CkILXZGebqwMAAAD+iiAFr0lIMFcHAAAA/BVBCl5jtUppaZ41m40FJwAAAFD/sGofvCojQ0pOZtU+AAAA1G8EKXid1UqAAgAAQP3G1D4AAAAAMIkgBQAAAAAmMbUPNeZwcK0TAAAAghMjUqgRm01KTJRSUlzPNpuvOwIAAAC8hyAF0xwOyW73rNntrjoAAAAQDAhSMC0721wdAAAACDQEKZiWkGCuDgAAAAQaghRMs1qltDTPms3GghMAAAAIHqzahxrJyJCSk1m1DwAAAMGJIIUas1oJUAAAAAhOTO0DAAAAAJMIUgAAAABgElP7gpzDwXVOAAAAgFmMSAUxm01KTJRSUlzPNpuvOwIAAADqB4JUkHI4JLvds2a3u+oAAAAAqkaQClLZ2ebqAAAAAP6LIBWkEhLM1QEAAAD8F0EqSFmtUlqaZ81mY8EJAAAAoDpYtS+IZWRIycms2gcAAACYRZAKclYrAQoAAAAwi6l9AAAAAGASQQoAAAAATGJqX4BwOLjWCQAAAPAWRqQCgM0mJSZKKSmuZ5vN1x0BAAAAgY0gVc85HJLd7lmz2111AAAAAHWDIFXPZWebqwMAAAA4dwSpei4hwVwdAAAAwLkjSNVzVquUluZZs9lYcAIAAACoS6zaFwAyMqTkZFbtAwAAALyFIBUgrFYCFAAAAOAtTO0DAAAAAJP8MkjNmTNHHTt2VFRUlKxWqzZs2FDpvu+995569eqlJk2aqGHDhurRo4cWLVrkxW4BAAAABBu/C1JLlixRamqqpk2bps2bN6t79+4aNGiQDhw4UOH+TZs21aOPPqr169frm2++0ZgxYzRmzBh9/PHHXu68djgc0qJF3AcKAAAA8GcWwzAMXzdxOqvVqiuuuEIvvviiJMnpdCo+Pl7333+/HnnkkWq9xuWXX67BgwfriSeeOOu+BQUFio2NVX5+vmJiYs6p93Nls3neXDctzbWQBAAAAIC6ZyYb+NWIVElJiTZt2qQBAwa4ayEhIRowYIDWr19/1uMNw1BmZqa2b9+u3//+9xXuU1xcrIKCAo+HP3A4PEOU5PqekSkAAADA//hVkMrLy1NZWZni4uI86nFxccrNza30uPz8fDVq1EgREREaPHiwXnjhBQ0cOLDCfWfOnKnY2Fj3Iz4+vlbfQ01lZ5urAwAAAPAdvwpSNdW4cWNt2bJF//nPf/Tkk08qNTVVa9asqXDfSZMmKT8/3/3Yu3evd5utREKCuToAAAAA3/Gr+0g1b95coaGh2r9/v0d9//79atWqVaXHhYSE6MILL5Qk9ejRQ99//71mzpyp/v37l9s3MjJSkZGRtdp3bbBaXddEnT69z2bj3lAAAACAP/KrEamIiAj17NlTmZmZ7prT6VRmZqb69OlT7ddxOp0qLi6uixbrVEaG9OWX0ptvup6fesrXHQEAAACoiF+NSElSamqqRo8erV69eql3796aPXu2CgsLNWbMGElSSkqK2rZtq5kzZ0pyXfPUq1cvXXDBBSouLtby5cu1aNEivfTSS758GzVmtTIKBQAAAPg7vwtSw4cP18GDBzV16lTl5uaqR48eWrFihXsBipycHIWE/HcgrbCwUBMmTNDPP/+sBg0a6OKLL9Zbb72l4cOH++otAAAAAAhwfncfKW/zp/tIAQAAAPCdensfKQAAAACoDwhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAAAAMIkgBQAAAAAmEaQAAAAAwCSCFAAAAACYRJACAAAAAJMIUgAAAABgEkEKAAAAAEwiSAEAAACASQQpAAAAADCJIAUAAAAAJhGkAAAAAMAkghQAAAAAmESQAgAAAACTwnzdgK8ZhiFJKigo8HEnAAAAAHzpVCY4lRGqEvRB6ujRo5Kk+Ph4H3cCAAAAwB8cPXpUsbGxVe5jMaoTtwKY0+nUvn371LhxY1ksFl+3o4KCAsXHx2vv3r2KiYnxdTuoR/js4Fzw+cG54PODc8HnBzVVF58dwzB09OhRtWnTRiEhVV8FFfQjUiEhIWrXrp2v2ygnJiaGPyaoET47OBd8fnAu+PzgXPD5QU3V9mfnbCNRp7DYBAAAAACYRJACAAAAAJMIUn4mMjJS06ZNU2RkpK9bQT3DZwfngs8PzgWfH5wLPj+oKV9/doJ+sQkAAAAAMIsRKQAAAAAwiSAFAAAAACYRpAAAAADAJIIUAAAAAJhEkPKyOXPmqGPHjoqKipLVatWGDRuq3P8f//iHLr74YkVFRalbt25avny5lzqFPzLz+Zk/f7769u2r8847T+edd54GDBhw1s8bApvZvz+nLF68WBaLRUOHDq3bBuHXzH5+jhw5onvvvVetW7dWZGSkEhIS+G9YEDP7+Zk9e7Y6d+6sBg0aKD4+Xg899JBOnDjhpW7hLz7//HMNGTJEbdq0kcVi0fvvv3/WY9asWaPLL79ckZGRuvDCC/X666/XWX8EKS9asmSJUlNTNW3aNG3evFndu3fXoEGDdODAgQr3X7dunW677Tbdeeed+uqrrzR06FANHTpUW7du9XLn8AdmPz9r1qzRbbfdpk8//VTr169XfHy8rrvuOv3yyy9e7hz+wOzn55Tdu3dr4sSJ6tu3r5c6hT8y+/kpKSnRwIEDtXv3bi1dulTbt2/X/Pnz1bZtWy93Dn9g9vPz9ttv65FHHtG0adP0/fffa8GCBVqyZIkmT57s5c7ha4WFherevbvmzJlTrf137dqlwYMH6+qrr9aWLVv04IMPauzYsfr444/rpkEDXtO7d2/j3nvvdX9fVlZmtGnTxpg5c2aF+996663G4MGDPWpWq9W4++6767RP+Cezn58zlZaWGo0bNzbeeOONumoRfqwmn5/S0lLjyiuvNF599VVj9OjRxk033eSFTuGPzH5+XnrpJaNTp05GSUmJt1qEHzP7+bn33nuNa665xqOWmppqXHXVVXXaJ/ybJGPZsmVV7pOWlmZceumlHrXhw4cbgwYNqpOeGJHykpKSEm3atEkDBgxw10JCQjRgwACtX7++wmPWr1/vsb8kDRo0qNL9Ebhq8vk50/Hjx3Xy5Ek1bdq0rtqEn6rp52f69Olq2bKl7rzzTm+0CT9Vk8/PBx98oD59+ujee+9VXFycunbtqhkzZqisrMxbbcNP1OTzc+WVV2rTpk3u6X87d+7U8uXLdcMNN3ilZ9Rf3v63c1idvCrKycvLU1lZmeLi4jzqcXFx+uGHHyo8Jjc3t8L9c3Nz66xP+KeafH7OZLPZ1KZNm3J/YBD4avL5ycrK0oIFC7RlyxYvdAh/VpPPz86dO7V69WrdfvvtWr58uXbs2KEJEybo5MmTmjZtmjfahp+oyednxIgRysvLU1JSkgzDUGlpqe655x6m9uGsKvu3c0FBgYqKitSgQYNaPR8jUkAQeOqpp7R48WItW7ZMUVFRvm4Hfu7o0aMaNWqU5s+fr+bNm/u6HdRDTqdTLVu21CuvvKKePXtq+PDhevTRRzVv3jxft4Z6YM2aNZoxY4bmzp2rzZs367333tOHH36oJ554wtetAR4YkfKS5s2bKzQ0VPv37/eo79+/X61atarwmFatWpnaH4GrJp+fU5555hk99dRTWrVqlX73u9/VZZvwU2Y/Pz/99JN2796tIUOGuGtOp1OSFBYWpu3bt+uCCy6o26bhN2ry96d169YKDw9XaGiou3bJJZcoNzdXJSUlioiIqNOe4T9q8vl57LHHNGrUKI0dO1aS1K1bNxUWFuquu+7So48+qpAQxgFQscr+7RwTE1Pro1ESI1JeExERoZ49eyozM9NdczqdyszMVJ8+fSo8pk+fPh77S9LKlSsr3R+BqyafH0my2+164okntGLFCvXq1csbrcIPmf38XHzxxfr222+1ZcsW9+PGG290r4IUHx/vzfbhYzX5+3PVVVdpx44d7gAuSdnZ2WrdujUhKsjU5PNz/PjxcmHpVCh3rTkAVMzr/3aukyUsUKHFixcbkZGRxuuvv25s27bNuOuuu4wmTZoYubm5hmEYxqhRo4xHHnnEvf8XX3xhhIWFGc8884zx/fffG9OmTTPCw8ONb7/91ldvAT5k9vPz1FNPGREREcbSpUuNX3/91f04evSor94CfMjs5+dMrNoX3Mx+fnJycozGjRsb9913n7F9+3bj3//+t9GyZUvjL3/5i6/eAnzI7Odn2rRpRuPGjY2///3vxs6dO41PPvnEuOCCC4xbb73VV28BPnL06FHjq6++Mr766itDkjFr1izjq6++Mvbs2WMYhmE88sgjxqhRo9z779y504iOjjYefvhh4/vvvzfmzJljhIaGGitWrKiT/ghSXvbCCy8Y7du3NyIiIozevXsbX375pXtbv379jNGjR3vs/8477xgJCQlGRESEcemllxoffvihlzuGPzHz+enQoYMhqdxj2rRp3m8cfsHs35/TEaRg9vOzbt06w2q1GpGRkUanTp2MJ5980igtLfVy1/AXZj4/J0+eNNLT040LLrjAiIqKMuLj440JEyYYhw8f9n7j8KlPP/20wn/LnPq8jB492ujXr1+5Y3r06GFEREQYnTp1Ml577bU6689iGIyRAgAAAIAZXCMFAAAAACYRpAAAAADAJIIUAAAAAJhEkAIAAAAAkwhSAAAAAGASQQoAAAAATCJIAQAAAIBJBCkAAGrIYrEoPT3d120AAHyAIAUAqDdGjhypqKgoZWdnl9v21FNPyWKx6N///rcPOgMABBuLYRiGr5sAAKA6Dhw4oIsvvlg9evTQ6tWr3fVdu3bp0ksv1Q033KClS5d6rZ8TJ04oLCxMYWFhXjsnAMA/MCIFAKg3WrZsqYyMDH366ad644033PUJEyYoPDxczz33nFf7iYqKIkQBQJAiSAEA6pWxY8fqqquu0sSJE3Xo0CEtXrxYK1as0F/+8he1bdu2ymOfeeYZXXnllWrWrJkaNGignj17lhvBeu2112SxWLRw4UKP+owZM2SxWLR8+XJ37cxrpI4ePaoHH3xQHTt2VGRkpFq2bKmBAwdq8+bN5/7GAQB+hal9AIB657vvvtNll12moUOHau3atWrXrp0cDodCQqr+/4Px8fG68cYb1aVLF5WUlGjx4sXasGGD/v3vf2vw4MHu/YYMGaK1a9fq22+/VXx8vL799lv16tVLo0aN0quvvurez2KxaNq0ae4wdfvtt2vp0qW677771KVLFx06dEhZWVkaPny4br/99jr5WQAAfIMgBQColyZPnqyZM2cqNDRUGzZs0OWXX37WY4qKitSgQQP39ydPntTll1+uli1bKjMz013Pzc3VpZdeqp49e+rf//63EhMTdejQIX377beKiYlx73dmkGrSpIlGjhypF198sfbeKADALzG1DwBQLzVv3lyS1KZNG3Xt2rVax5weog4fPqz8/Hz17du33NS7Vq1aac6cOVq5cqX69u2rLVu2aOHChR4hqiJNmjSRw+HQvn37TL4bAEB9Q5ACANQ7e/fu1bRp09S1a1ft3btXdrvdve23335Tbm6u+5Gfn+/edmp0KSoqSk2bNlWLFi300ksveexzyp/+9CcNHjxYGzZs0Lhx43TttdeetS+73a6tW7cqPj5evXv3Vnp6unbu3Fk7bxoA4FcIUgCAeue+++6TJH300Ue65ZZb9OSTT7oDS3Jyslq3bu1+PPDAA5KktWvX6sYbb1RUVJTmzp2r5cuXa+XKlRoxYoQqmuV+6NAhbdy4UZK0bds2OZ3Os/Z16623aufOnXrhhRfUpk0bPf3007r00kv10Ucf1dZbBwD4CYIUAKBeWbZsmT744AM98cQTateunWbPnq2IiAjde++9kqRnn31WK1eudD/S0tIkSe+++66ioqL08ccf63//9391/fXXa8CAAZWe595779XRo0c1c+ZMZWVlafbs2dXqr3Xr1powYYLef/997dq1S82aNdOTTz55zu8bAOBfuPkFAKDeOHr0qP785z/rsssu0/333y/JdY3UE088oQceeED/+Mc/dMstt1R4bGhoqCwWi8rKyty13bt36/333y+379KlS7VkyRI9//zzuv/++/X1119rypQp+uMf/6iEhIQKX7+srEzHjh1TbGysu9ayZUu1adNGxcXF5/CuAQD+iFX7AAD1xgMPPKAXX3xRX375pa644gp3vaysTL1791Zubq5++OEHNW7cuNyxq1ev1rXXXqu+fftqxIgROnDggObMmaNWrVrpm2++cU/vO3DggC699FJ169ZNmZmZslgsOnTokC699FJ16tRJWVlZ7mXWT1+178iRI2rXrp1uvvlmde/eXY0aNdKqVav0zjvv6Nlnn1Vqaqp3fkgAAK9gah8AoF7YtGmT5syZowkTJniEKMk12jRv3jzl5uZqypQpFR5/zTXXaMGCBcrNzdWDDz6ov//978rIyNCwYcM89hs/fryKi4vdN+aVpGbNmumVV17R+vXr9cwzz1T4+tHR0ZowYYK2bNmiadOm6aGHHtL27ds1d+5cQhQABCBGpAAAAADAJEakAAAAAMAkghQAAAAAmESQAgAAAACTCFIAAAAAYBJBCgAAAABMIkgBAAAAgEkEKQAAAAAwiSAFAAAAACYRpAAAAADAJIIUAAAAAJhEkAIAAAAAkwhSAAAAAGASQQoAAAAATPp/iexWAZAYdm4AAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###Building our first Linear Regression Model:\n",
        "What our model does:\n",
        "1. Start with random values (weight & bias).\n",
        "\n",
        "2. Look at training data and adjust the random values to get closer to the ideal values of weight and bias (which we used to create the data).\n",
        "\n",
        "###How can we make the random values such that it makes a st. Line:\n",
        "1. *Gradient Descent Algorithm*     (Prerequisite: requires_grad = True (To record the gradients throughout))\n",
        "\n",
        "2. *Back Propagation*               (Recorded gradients of 'weights' and 'bias' are updated in this step)"
      ],
      "metadata": {
        "id": "Og-48HJJA6mJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class LinearRegressionModel(nn.Module):         #(Inheritance : \"nn.Module\" is the base class for all neural networks)\n",
        "  def __init__(self):                           #Constructor of base class. When defining methods inside a class, self is used to access and modify the instance variables.\n",
        "    super().__init__()                          #Calling the constructor of super/base class to make sure our class properly inherits all the necessary functionalities for it to behave like a NN.\n",
        "    self.weights = nn.Parameter(torch.randn(1, requires_grad = True, dtype = torch.float32)) #Converts a tensor to a Module parameter\n",
        "    self.bias = nn.Parameter(torch.randn(1, requires_grad = True, dtype = torch.float32)) #requires_grad = True -->ByDefault, Shape = 1 (Scalar).\n",
        "\n",
        "    #Forward Propagation function:\n",
        "  def forward(self, x: torch.Tensor) -> torch.Tensor: #This func takes input data as X (dtype = torch.Tensor) and returns a 'torch.Tensor'\n",
        "    return self.weights * x + self.bias       #Calculates 'Y' on the basis of Linear Regression Formula"
      ],
      "metadata": {
        "id": "mdtEkB7NBD58"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "*def forward() - All torch.nn.Module subclasses requires you to overwrite forward() always. This method defines what happens during the forward propagation in every epoch in the neural network.\n",
        "\n",
        "*torch.optim - Contains various optimization algos which tell the nn.Parameters how to best change to improve gradient descent and in turn reduce the loss"
      ],
      "metadata": {
        "id": "pXQMmpxSYDff"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Alternative way: Using Linear Layer/ Probing Layer/ Linear Transform/ Fully Connected Layer/ Dense Layer.\n",
        "class LinearRegressionModelV2(nn.Module):\n",
        "  def __innit__(self):\n",
        "    super().__innit__()\n",
        "    #Use nn.Linear Layer for creating and initializing parameters i.e.(wts & bias) itelf\n",
        "    self.linear_layer = nn.Linear(in_features = 1, out_features = 1) # Because 1 to 1 relationship is b/w Input value and O/P value\n",
        "\n",
        "  def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
        "    return self.linear_layer(x)"
      ],
      "metadata": {
        "id": "rzwF4U27SB9q"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Create a random seeds because our model parameters are also random\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",
        "model_0"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "GDyJaaWeZVK3",
        "outputId": "431e3820-ab64-41de-bf02-19f1c0cb4bda"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "LinearRegressionModel()"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "list(model_0.parameters()) #list or tuple"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "lal-WsN0oWCg",
        "outputId": "e628d735-3a7f-4425-f878-0428acd5ba34"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[Parameter containing:\n",
              " tensor([0.3367], requires_grad=True),\n",
              " Parameter containing:\n",
              " tensor([0.1288], requires_grad=True)]"
            ]
          },
          "metadata": {},
          "execution_count": 48
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "model_0.state_dict() #Returns the state of the whole Module with named parameters"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "C7ctXShPpM8F",
        "outputId": "f5b91d3d-75c9-4db8-e563-e0f4d27fee61"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "metadata": {},
          "execution_count": 49
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "weight ,  bias # We want to bring the above weight and bias close to this one for our model to work perfectly (in this case we know the ideal values)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OggZXYXIqid0",
        "outputId": "b0a07301-d336-4f2c-f669-7f89a3160e4e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(0.7, 0.3)"
            ]
          },
          "metadata": {},
          "execution_count": 50
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Make predictions with Model\n",
        "y_preds = model_0(X_test)\n",
        "y_preds"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "iDSxhlcesgzn",
        "outputId": "2b62c0e2-4580-4a71-ff4b-34fc27ede119"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.3982],\n",
              "        [0.4049],\n",
              "        [0.4116],\n",
              "        [0.4184],\n",
              "        [0.4251],\n",
              "        [0.4318],\n",
              "        [0.4386],\n",
              "        [0.4453],\n",
              "        [0.4520],\n",
              "        [0.4588]], grad_fn=<AddBackward0>)"
            ]
          },
          "metadata": {},
          "execution_count": 51
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Model predictions Without gradient tracking which saves us time in case of very large datasets\n",
        "with torch.inference_mode(): #OR torch.no_grad() //outdated\n",
        "  y_pred2 = model_0(X_test)\n",
        "\n",
        "y_pred2"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CW1e9HpNtgBc",
        "outputId": "ee704679-8238-42dc-b8ac-70734fc0720c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.3982],\n",
              "        [0.4049],\n",
              "        [0.4116],\n",
              "        [0.4184],\n",
              "        [0.4251],\n",
              "        [0.4318],\n",
              "        [0.4386],\n",
              "        [0.4453],\n",
              "        [0.4520],\n",
              "        [0.4588]])"
            ]
          },
          "metadata": {},
          "execution_count": 52
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "Y_test #y_pred2 should be as close to this as possible"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-SdZZ3g5uYHX",
        "outputId": "5c04bc8d-4992-4538-e9a5-cc9ebba56811"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "tensor([[0.8600],\n",
              "        [0.8740],\n",
              "        [0.8880],\n",
              "        [0.9020],\n",
              "        [0.9160],\n",
              "        [0.9300],\n",
              "        [0.9440],\n",
              "        [0.9580],\n",
              "        [0.9720],\n",
              "        [0.9860]])"
            ]
          },
          "metadata": {},
          "execution_count": 53
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions(predictions=y_pred2) #Initially the model predicts random values"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 623
        },
        "id": "YN8mh-n6t6tm",
        "outputId": "6ca6c659-1de7-4988-8d65-f8c21755db84"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#Setting up a Loss Function / Cost Function / Criterion:\n",
        "Loss_fn = nn.L1Loss()   #Calculates the Mean Absolute Error (MAE): y_pred2 and y_test and then avg the diff of all the examples in it.\n",
        "                        #Such pure Math related functions are used in the case of regression problems only\n",
        "#OR\n",
        "\n",
        "MAE_loss = torch.mean(torch.abs(y_pred2 - Y_test)) #Making ur own representation of the function"
      ],
      "metadata": {
        "id": "fRCmR2VJw9FO"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#Setting up an Optimizer {Stochastic i.e(random) Gradient Descent} OR ADAM for gradients.\n",
        "optimizer = torch.optim.SGD(model_0.parameters(), lr = 0.01) #lr -> Learning Rate is a critical Hyperparameter"
      ],
      "metadata": {
        "id": "qwYCrNV8z-pw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "###**Learning Rate:** It controls how much the model's parameters (such as weights and biases) are adjusted during each step of the optimization process. The learning rate determines the size of the step taken in the direction of the gradient during training. If lr = 0.0001, it will effect the \"7\" from weight = 0.3367. If lr = 0.1, it will effect \"3\". If lr = 0.001, it will effect the \"6\" and so-on"
      ],
      "metadata": {
        "id": "HD6s-KN_12bd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## Building a Training Loop:\n",
        "torch.manual_seed(42)\n",
        "epoch = 200 #Hyperparameter\n",
        "epoch_count = []\n",
        "train_losses = []\n",
        "test_losses = []\n",
        "\n",
        "for epoch in range(epoch):\n",
        "  ## Training the Model:\n",
        "  model_0.train() #Put the model in training mode (Set other layers such as Dropout and BatchNorm to True).\n",
        "\n",
        "  y_pred = model_0(X_train) #1. Forward Pass on Training DataSet.\n",
        "\n",
        "  train_loss = Loss_fn(y_pred,Y_train) #2. Calculate the Loss for Training DataSet (hence we used Y_train).\n",
        "\n",
        "  optimizer.zero_grad() #3. Initialize all the gradients to zero for next fresh computation.\n",
        "\n",
        "  train_loss.backward() #4. Perform Back Propagation on Loss w.r.t the model parameters (Gradients are computed during this step).\n",
        "\n",
        "  optimizer.step() #5. Update the parameters of the model by performing Gradient Descent.\n",
        "\n",
        "\n",
        "  ## Testing the Model:\n",
        "  model_0.eval() #Put the model in evaluation mode and disables many other settings that are not required for testing/evaluation.\n",
        "\n",
        "  with torch.inference_mode(): #Disables Gradient Calculations\n",
        "\n",
        "    test_preds = model_0(X_test) #1. Forward Pass on Testing DataSet.\n",
        "\n",
        "    test_loss = Loss_fn(test_preds, Y_test) #2. Calculate the Loss for Testing DataSet.\n",
        "\n",
        "  if epoch % 10 == 0: # Track Parameters for every 10 epochs\n",
        "    epoch_count.append(epoch)\n",
        "    train_losses.append(train_loss)\n",
        "    test_losses.append(test_loss)\n",
        "    print(f\"Epoch: {epoch} | Train Loss: {train_loss} | Test Loss: {test_loss}\")"
      ],
      "metadata": {
        "id": "Zq3mQeDw2Mqb",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e5e9469a-cc66-43f9-eb4d-28cf97060da6"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch: 0 | Train Loss: 0.31288138031959534 | Test Loss: 0.48106518387794495\n",
            "Epoch: 10 | Train Loss: 0.1976713240146637 | Test Loss: 0.3463551998138428\n",
            "Epoch: 20 | Train Loss: 0.08908725529909134 | Test Loss: 0.21729660034179688\n",
            "Epoch: 30 | Train Loss: 0.053148526698350906 | Test Loss: 0.14464017748832703\n",
            "Epoch: 40 | Train Loss: 0.04543796554207802 | Test Loss: 0.11360953003168106\n",
            "Epoch: 50 | Train Loss: 0.04167863354086876 | Test Loss: 0.09919948130846024\n",
            "Epoch: 60 | Train Loss: 0.03818932920694351 | Test Loss: 0.08886633068323135\n",
            "Epoch: 70 | Train Loss: 0.03476089984178543 | Test Loss: 0.0805937647819519\n",
            "Epoch: 80 | Train Loss: 0.03132382780313492 | Test Loss: 0.07232122868299484\n",
            "Epoch: 90 | Train Loss: 0.02788739837706089 | Test Loss: 0.06473556160926819\n",
            "Epoch: 100 | Train Loss: 0.024458957836031914 | Test Loss: 0.05646304413676262\n",
            "Epoch: 110 | Train Loss: 0.021020207554101944 | Test Loss: 0.04819049686193466\n",
            "Epoch: 120 | Train Loss: 0.01758546568453312 | Test Loss: 0.04060482233762741\n",
            "Epoch: 130 | Train Loss: 0.014155393466353416 | Test Loss: 0.03233227878808975\n",
            "Epoch: 140 | Train Loss: 0.010716589167714119 | Test Loss: 0.024059748277068138\n",
            "Epoch: 150 | Train Loss: 0.0072835334576666355 | Test Loss: 0.016474086791276932\n",
            "Epoch: 160 | Train Loss: 0.0038517764769494534 | Test Loss: 0.008201557211577892\n",
            "Epoch: 170 | Train Loss: 0.008932482451200485 | Test Loss: 0.005023092031478882\n",
            "Epoch: 180 | Train Loss: 0.008932482451200485 | Test Loss: 0.005023092031478882\n",
            "Epoch: 190 | Train Loss: 0.008932482451200485 | Test Loss: 0.005023092031478882\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "###**Optimizer.zero_grad**:  It sets the gradients of all the model's parameters to zero. This is done before computing the gradients for the current batch, ensuring that old gradients from the previous training step are not mixed with the new gradients. This step is necessary because, By default, PyTorch accumulates gradients in the backward pass. Without clearing the gradients, the gradients from previous iterations will accumulate on top of the new gradients, leading to incorrect updates."
      ],
      "metadata": {
        "id": "JroZA3eknD8W"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "## Making new Predictions with an Updated and Better Model\n",
        "with torch.inference_mode():\n",
        "  y_pred3 = model_0(X_test)"
      ],
      "metadata": {
        "id": "Ba8jBLK1bBCU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model_0.state_dict() , print(f\"Optimal Weight :{weight} , Optimal Bias: {bias}\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "FzKBiszB4Q8i",
        "outputId": "5614ee2a-35cf-472b-fbe4-956f347eddb9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Optimal Weight :0.7 , Optimal Bias: 0.3\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))]),\n",
              " None)"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "plot_predictions(predictions=y_pred3) #We have to remove grads before putting in this func as this func uses numpy which does not know grad calculation hence requires_grad needs to be FALSE."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 623
        },
        "id": "o7gerkae5GNu",
        "outputId": "1c1bb9f7-703c-4b20-a18c-b7afbfb510d9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "epoch_count, test_losses, epoch_count"
      ],
      "metadata": {
        "id": "sI_zubz65PJ8",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "2dddfd55-f2f5-41c0-af7d-740bd2298b70"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "([0,\n",
              "  10,\n",
              "  20,\n",
              "  30,\n",
              "  40,\n",
              "  50,\n",
              "  60,\n",
              "  70,\n",
              "  80,\n",
              "  90,\n",
              "  100,\n",
              "  110,\n",
              "  120,\n",
              "  130,\n",
              "  140,\n",
              "  150,\n",
              "  160,\n",
              "  170,\n",
              "  180,\n",
              "  190],\n",
              " [tensor(0.4811),\n",
              "  tensor(0.3464),\n",
              "  tensor(0.2173),\n",
              "  tensor(0.1446),\n",
              "  tensor(0.1136),\n",
              "  tensor(0.0992),\n",
              "  tensor(0.0889),\n",
              "  tensor(0.0806),\n",
              "  tensor(0.0723),\n",
              "  tensor(0.0647),\n",
              "  tensor(0.0565),\n",
              "  tensor(0.0482),\n",
              "  tensor(0.0406),\n",
              "  tensor(0.0323),\n",
              "  tensor(0.0241),\n",
              "  tensor(0.0165),\n",
              "  tensor(0.0082),\n",
              "  tensor(0.0050),\n",
              "  tensor(0.0050),\n",
              "  tensor(0.0050)],\n",
              " [0,\n",
              "  10,\n",
              "  20,\n",
              "  30,\n",
              "  40,\n",
              "  50,\n",
              "  60,\n",
              "  70,\n",
              "  80,\n",
              "  90,\n",
              "  100,\n",
              "  110,\n",
              "  120,\n",
              "  130,\n",
              "  140,\n",
              "  150,\n",
              "  160,\n",
              "  170,\n",
              "  180,\n",
              "  190])"
            ]
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## Plot the Loss Curves:\n",
        "plt.plot(epoch_count, np.array(torch.tensor(train_losses).numpy()), label = \"Train Loss\") #Concerting to numpy array to avoid gradient tracking\n",
        "plt.plot(epoch_count, test_losses, label = \"Test Loss\")\n",
        "plt.title(\"Loss Curves\")\n",
        "plt.ylabel(\"Loss\")\n",
        "plt.xlabel(\"Epochs\")\n",
        "plt.legend() # The point where the line meets is the convergence point and the model is said to be reached convergence after that point."
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 489
        },
        "id": "-AdW02xayddF",
        "outputId": "49366673-bb54-430e-9c9f-82a8d624e318"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "<matplotlib.legend.Legend at 0x7a059e6bcf40>"
            ]
          },
          "metadata": {},
          "execution_count": 62
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# Saving our Pytorch Model:\n",
        "from pathlib import Path\n",
        "\n",
        "#1. Create Model's Directory\n",
        "model_path = Path(\"models\") #Set a Directory Name\n",
        "model_path.mkdir(parents = True, exist_ok = True) #Make a new Directory with that Name\n",
        "\n",
        "#2. Create Model Save Path\n",
        "model_name = \"Pytorch_Model_0.pt\" # Extenstions can be 'pt' or 'pth'\n",
        "model_save_path = model_path / model_name #Define Path to save the model\n",
        "\n",
        "#3. Save the Model\n",
        "torch.save(model_name, model_save_path)\n",
        "\n",
        "#Or save the Model's State Dictionary only:\n",
        "torch.save(model_0.state_dict(), model_save_path)"
      ],
      "metadata": {
        "id": "qHmJXqSX4L64"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!ls -l models #Validating if the model is there or not"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yR-S-F1tBwyU",
        "outputId": "5f608a29-42a7-4a47-b9f4-17f75ce26403"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "total 4\n",
            "-rw-r--r-- 1 root root 1544 Nov 18 16:37 Pytorch_Model_0.pt\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "## Loading our Pytorch Model\n",
        "#If only state of the model is stored then again create a new instance of the model\n",
        "loaded_model_0 = LinearRegressionModel()\n",
        "\n",
        "#Now load the saved state dict of model_0\n",
        "loaded_model_0.load_state_dict(torch.load(model_save_path))\n",
        "\n",
        "#Validating the Original states\n",
        "loaded_model_0.state_dict()"
      ],
      "metadata": {
        "id": "xf7CWjOODYIC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7c151e59-22fd-4ae9-94de-c1b57c9a4c67"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-69-6ed5cc5ab2e2>:6: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
            "  loaded_model_0.load_state_dict(torch.load(model_save_path))\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "dmCzsVWsJGZo"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}