01_Pytorch_Workflow.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fgtBydCoQwSa"
      },
      "source": [
        "## 1. Data (preparing and loading)\n",
        "\n",
        "I want to stress that \"data\" in machine learning can be almost anything you can imagine. A table of numbers (like a big Excel spreadsheet), images of any kind, videos (YouTube has lots of data!), audio files like songs or podcasts, protein structures, text and more.\n",
        "\n",
        "![machine learning is a game of two parts: 1. turn your data into a representative set of numbers and 2. build or pick a model to learn the representation as best as possible"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dL3TkvZsCFfE"
      },
      "source": [
        "**PyTorch Model Building Essentials**\n",
        "1. torch.nn - it has everything related to neural network.\n",
        "\n",
        "2. torch.nn.Parameter - what parameters should our model try and learn , often a PyTorch layer torch.nn will set this for us.\n",
        "\n",
        "3. torch.nn.Module - base class for all neural network , you can subclass it for inherting all the methods and attributes included in nn.Module , if you use this as parent class that means inheret it , then you have to overwrite the def forward() because this only defines what happens in forward computation.\n",
        "4.torch.optim - this is where optimizers live , it helps with gradient descent."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Po-abbsjDjW4",
        "outputId": "b03cbbde-e965-4324-fcc0-ca4f8c5f9a30"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(tensor([[0.0000],\n",
              "         [0.0200],\n",
              "         [0.0400],\n",
              "         [0.0600],\n",
              "         [0.0800],\n",
              "         [0.1000],\n",
              "         [0.1200],\n",
              "         [0.1400],\n",
              "         [0.1600],\n",
              "         [0.1800]]),\n",
              " tensor([[0.3000],\n",
              "         [0.3140],\n",
              "         [0.3280],\n",
              "         [0.3420],\n",
              "         [0.3560],\n",
              "         [0.3700],\n",
              "         [0.3840],\n",
              "         [0.3980],\n",
              "         [0.4120],\n",
              "         [0.4260]]))"
            ]
          },
          "execution_count": 1,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "import torch\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "\n",
        "# Create *known* parameters\n",
        "weight = 0.7\n",
        "bias = 0.3\n",
        "\n",
        "# Create data\n",
        "start = 0\n",
        "end = 1\n",
        "step = 0.02\n",
        "X = torch.arange(start, end, step).unsqueeze(dim=1)\n",
        "y = weight * X + bias\n",
        "\n",
        "X[:10], y[:10]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4xRXvfM4SxWr",
        "outputId": "80d2f141-6782-408f-e8d4-e8d16415cfa8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(40, 40, 10, 10)"
            ]
          },
          "execution_count": 2,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Create train/test split\n",
        "train_split = int(0.8 * len(X)) # 80% of data used for training set, 20% for testing\n",
        "X_train, y_train = X[:train_split], y[:train_split]\n",
        "X_test, y_test = X[train_split:], y[train_split:]\n",
        "\n",
        "len(X_train), len(y_train), len(X_test), len(y_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "1mjEcplyTEtN"
      },
      "outputs": [],
      "source": [
        "def plot_predictions(train_data=X_train,\n",
        "                     train_labels=y_train,\n",
        "                     test_data=X_test,\n",
        "                     test_labels=y_test,\n",
        "                     predictions=None):\n",
        "  \"\"\"\n",
        "  Plots training data, 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",
        "  if predictions is not None:\n",
        "    # Plot the predictions in red (predictions were made on the test data)\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": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "ghjXDtouTZhU",
        "outputId": "1bc222ae-ae7b-42b4-87ed-3d27d323da93"
      },
      "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": "code",
      "execution_count": 5,
      "metadata": {
        "id": "g4tzvqLXTyX1"
      },
      "outputs": [],
      "source": [
        "import torch\n",
        "from torch import nn\n",
        "\n",
        "# Create a Linear Regression model class\n",
        "class LinearRegressionModel(nn.Module): # <- almost everything in PyTorch is a nn.Module (think of this as neural network lego blocks)\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        self.weights = nn.Parameter(torch.randn(1, # <- start with random weights (this will get adjusted as the model learns)\n",
        "                                                dtype=torch.float), # <- PyTorch loves float32 by default\n",
        "                                   requires_grad=True) # <- can we update this value with gradient descent?)\n",
        "\n",
        "        self.bias = nn.Parameter(torch.randn(1, # <- start with random bias (this will get adjusted as the model learns)\n",
        "                                            dtype=torch.float), # <- PyTorch loves float32 by default\n",
        "                                requires_grad=True) # <- can we update this value with gradient descent?))\n",
        "\n",
        "    # Forward defines the computation in the model\n",
        "    def forward(self, x: torch.Tensor) -> torch.Tensor: # <- \"x\" is the input data (e.g. training/testing features)\n",
        "        return self.weights * x + self.bias # <- this is the linear regression formula (y = m*x + b)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jysLA4YqZoQS",
        "outputId": "3954651d-c36a-45bb-b756-3e797958d25d"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[Parameter containing:\n",
              " tensor([0.3367], requires_grad=True),\n",
              " Parameter containing:\n",
              " tensor([0.1288], requires_grad=True)]"
            ]
          },
          "execution_count": 6,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Set manual seed since nn.Parameter are randomly initialzied\n",
        "torch.manual_seed(42)\n",
        "\n",
        "# Create an instance of the model (this is a subclass of nn.Module that contains nn.Parameter(s))\n",
        "model_0 =  LinearRegressionModel()\n",
        "\n",
        "# Check the nn.Parameter(s) within the nn.Module subclass we created\n",
        "list(model_0.parameters())"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "S3ddUFDJaS3F",
        "outputId": "26915373-40e0-4dd4-9dd4-6da3eb739eb4"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.3367])), ('bias', tensor([0.1288]))])"
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model_0.state_dict()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "L62NGAera0DX",
        "outputId": "568694db-2c1d-4c6c-b284-b023528795f8"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.3982],\n",
              "        [0.4049],\n",
              "        [0.4116],\n",
              "        [0.4184],\n",
              "        [0.4251],\n",
              "        [0.4318],\n",
              "        [0.4386],\n",
              "        [0.4453],\n",
              "        [0.4520],\n",
              "        [0.4588]], grad_fn=<AddBackward0>)"
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y_preds = model_0(X_test)\n",
        "y_preds # These y_preds are directly called from class LinearRegressionModel from def forward with has requires_grad is true , that means it still is keeping track of gradients of number."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "VUV0kvTId1ic"
      },
      "outputs": [],
      "source": [
        "# Make predictions with model\n",
        "# While inference means testing , and while testing or in inference we don't need to keep track of gradient anymore because it's prediction time now so it's a good habit to initiate the torch.inference_mode() on while testing.\n",
        "# Obviously it will make predictions faster , becasue we don't track grads anymore just predicting from the final parameters after the training.\n",
        "with torch.inference_mode():\n",
        "    y_preds = model_0(X_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "V8zTKer-c8in",
        "outputId": "83b42c62-5d58-4268-b4dd-2466a8264808"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.3982],\n",
              "        [0.4049],\n",
              "        [0.4116],\n",
              "        [0.4184],\n",
              "        [0.4251],\n",
              "        [0.4318],\n",
              "        [0.4386],\n",
              "        [0.4453],\n",
              "        [0.4520],\n",
              "        [0.4588]])"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y_preds"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CLyx4YC5c-KZ",
        "outputId": "7b7b6d23-ff7e-4367-832f-91eabf0bf9ea"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "tensor([[0.8600],\n",
              "        [0.8740],\n",
              "        [0.8880],\n",
              "        [0.9020],\n",
              "        [0.9160],\n",
              "        [0.9300],\n",
              "        [0.9440],\n",
              "        [0.9580],\n",
              "        [0.9720],\n",
              "        [0.9860]])"
            ]
          },
          "execution_count": 11,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "y_test"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "c_4V_vvSdAX5",
        "outputId": "ac0141b9-dc3f-4ce9-f7fc-3a201723cd19"
      },
      "outputs": [
        {
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzoAAAJGCAYAAACTJvC6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABUIElEQVR4nO3dfVxUdf7//+cwXGkKrpqIyopZWW2mpenalTNFsZsfZ2xrs/qk6JZ9LcsWal2tFK2PUVsZhXbx8aPZxZa2Zc3ZbK2kwbaitdVsu1Ba8zIS1M0GowQdzu+P+TFEgDIIzMzhcb/d5jZxOOfMa/AQPHm/z/tlM03TFAAAAABYSEy4CwAAAACA1kbQAQAAAGA5BB0AAAAAlkPQAQAAAGA5BB0AAAAAlkPQAQAAAGA5BB0AAAAAlhMb7gKao6amRl9//bW6du0qm80W7nIAAAAAhIlpmjpw4ID69OmjmJimx22iIuh8/fXXSktLC3cZAAAAACLErl271K9fvyY/HxVBp2vXrpICbyYpKSnM1QAAAAAIl4qKCqWlpQUzQlOiIujUTldLSkoi6AAAAAA46i0tLEYAAAAAwHIIOgAAAAAsh6ADAAAAwHIIOgAAAAAsh6ADAAAAwHIIOgAAAAAsJyqWl26JQ4cOye/3h7sMICzi4uJkt9vDXQYAAEDYWC7oVFRUaN++faqqqgp3KUDY2Gw2JScnq3fv3kddYx4AAMCKQg4677zzjh544AGtX79eu3fv1iuvvKJx48Yd8ZiioiLl5OTos88+U1pamu666y5NmjSphSU3raKiQqWlperSpYt69uypuLg4fslDh2OapiorK7V371516tRJ3bp1C3dJAAAA7S7koFNZWakhQ4bod7/7nX7zm98cdf9t27ZpzJgxmjp1qv785z+rsLBQ119/vVJTU5WZmdmiopuyb98+denSRf369SPgoEPr1KmTqqqqtGfPHiUnJ/P9AAAAOpyQg86vf/1r/frXv272/k888YQGDBighx56SJJ06qmn6t1339XDDz/cqkHn0KFDqqqqUs+ePfmlDpCUlJSkiooK+f1+xcZabpYqAADAEbX5qmvFxcXKyMioty0zM1PFxcVNHlNVVaWKiop6j6OpXXggLi7u2AoGLKI23Bw+fDjMlQAAALS/Ng86ZWVlSklJqbctJSVFFRUV+uGHHxo9Ji8vT8nJycFHWlpas1+P0RwggO8FAADQkUVkH51Zs2bJ5/MFH7t27Qp3SQAAAACiSJtP3O/du7fKy8vrbSsvL1dSUpI6derU6DEJCQlKSEho69IAAAAAWFSbj+iMGjVKhYWF9ba99dZbGjVqVFu/NNqJzWaTw+E4pnMUFRXJZrNp7ty5rVJTW0tPT1d6enq4ywAAAEATQg463333nTZu3KiNGzdKCiwfvXHjRu3cuVNSYNrZxIkTg/tPnTpVW7du1YwZM7R582Y99thjevHFF5Wdnd067wCSAmEjlAfCz+Fw8G8BAADQRkKeuvbPf/5TTqcz+HFOTo4kKSsrS8uWLdPu3buDoUeSBgwYoFWrVik7O1uPPPKI+vXrp//7v/9r9R46HV1ubm6Dbfn5+fL5fI1+rjVt2rRJnTt3PqZzjBgxQps2bVLPnj1bqSoAAAB0ZDbTNM1wF3E0FRUVSk5Ols/nU1JSUqP7HDx4UNu2bdOAAQOUmJjYzhVGpvT0dO3YsUNR8E8cdWqnrW3fvr3F53A4HFq7dm2b/fvwPQEAAKyoOdlAitBV19B2tm/fLpvNpkmTJmnTpk267LLL1KNHD9lstuAv7a+88oquvvpqnXjiiercubOSk5N1/vnn6+WXX270nI3dozNp0iTZbDZt27ZNjz76qE455RQlJCSof//+mjdvnmpqaurt39Q9OrX3wnz33Xe69dZb1adPHyUkJOiMM87QSy+91OR7HD9+vLp3764uXbpo9OjReueddzR37lzZbDYVFRU1++vl8Xh09tlnq1OnTkpJSdGUKVO0f//+Rvf94osvNGPGDJ111lnq0aOHEhMTdfLJJ2vmzJn67rvvGnzN1q5dG/zv2sekSZOC+yxdulRut1vp6elKTExU9+7dlZmZKa/X2+z6AQAAOirapXdQW7Zs0S9/+UsNHjxYkyZN0n/+8x/Fx8dLCtxnFR8fr/POO0+pqanau3evDMPQFVdcoUcffVS33HJLs1/nD3/4g9auXav/+q//UmZmpl599VXNnTtX1dXVmj9/frPOcejQIV1yySXav3+/Lr/8cn3//fdavny5rrzySq1evVqXXHJJcN/S0lKdc8452r17t371q1/pzDPPVElJiS6++GJdeOGFIX2NnnnmGWVlZSkpKUkTJkxQt27d9NprrykjI0PV1dXBr1etlStXasmSJXI6nXI4HKqpqdEHH3yg+++/X2vXrtU777wTbGibm5urZcuWaceOHfWmFg4dOjT439OmTdOQIUOUkZGh448/XqWlpXr11VeVkZGhlStXyu12h/R+AAAAWsIoMeTd5pVzgFOuQa5wl9N8ZhTw+XymJNPn8zW5zw8//GB+/vnn5g8//NCOlUW2/v37mz/9J962bZspyZRkzpkzp9HjvvzyywbbDhw4YA4ePNhMTk42Kysr631Okjl69Oh627KyskxJ5oABA8yvv/46uH3v3r1mt27dzK5du5pVVVXB7V6v15Rk5ubmNvoe3G53vf3XrFljSjIzMzPr7X/ttdeaksz58+fX275kyZLg+/Z6vY2+7x/z+XxmUlKSedxxx5klJSXB7dXV1eYFF1xgSjL79+9f75ivvvqqXo215s2bZ0oyn3vuuXrbR48e3eDf58e2bt3aYNvXX39t9unTxzzppJOO+h74ngAAAMfKs9ljaq5M+zy7qbkyPZs94S6pWdnANE2TqWsdVO/evXXnnXc2+rkTTjihwbYuXbpo0qRJ8vl8+vDDD5v9OrNnz1Zqamrw4549e8rtduvAgQMqKSlp9nkefvjheiMoF110kfr371+vlqqqKv3lL39Rr169dNttt9U7fvLkyRo0aFCzX+/VV19VRUWFfve73+nkk08Obo+Li2tyJKpv374NRnkk6eabb5YkrVmzptmvLwUW8vip1NRUXX755fr3v/+tHTt2hHQ+AACAUHm3eWW32eU3/bLb7CraXhTukpqNoNNChiFlZweeo9GQIUMa/aVckvbs2aOcnBydeuqp6ty5c/D+kdrw8PXXXzf7dYYNG9ZgW79+/SRJ3377bbPO0a1bt0Z/6e/Xr1+9c5SUlKiqqkrDhw9v0HDWZrPpnHPOaXbdH3/8sSTp/PPPb/C5UaNGKTa24axP0zS1dOlSXXDBBerevbvsdrtsNpt69OghKbSvmyRt3bpVU6ZM0cCBA5WYmBj8dygoKGjR+QAAAELlHOAMhhy/6Zcj3RHukpqNe3RawDAkt1uy26X8fMnjkVxRNF1RklJSUhrd/s033+jss8/Wzp07de655yojI0PdunWT3W7Xxo0b5fF4VFVV1ezXaWwljNqQ4Pf7m3WO5OTkRrfHxsbWW9SgoqJCktSrV69G92/qPTfG5/M1eS673R4MLz82ffp0LVy4UGlpaXK5XEpNTQ0Grnnz5oX0dduyZYtGjBihiooKOZ1OjR07VklJSYqJiVFRUZHWrl0b0vkAAABawjXIJc9VHhVtL5Ij3RFV9+gQdFrA6w2EHL8/8FxUFH1Bp6lGlUuWLNHOnTt1zz336K677qr3ufvuu08ej6c9ymuR2lC1Z8+eRj9fXl7e7HPVhqvGzuX3+/Wf//xHffv2DW7bs2ePFi1apDPOOEPFxcX1+gqVlZVp3rx5zX5tKTBVb//+/Xr22Wd17bXX1vvc1KlTgyu2AQAAtDXXIFdUBZxaTF1rAaezLuT4/dJPVlaOal9++aUkNbqi19///vf2LickgwYNUkJCgtavX99gtMM0TRUXFzf7XEOGDJHU+HsuLi7W4cOH623bunWrTNNURkZGg+apTX3d7Ha7pMZHtpr6dzBNU++9914z3wUAAEDHRdBpAZcrMF1t+vTonLZ2JP3795ckvfvuu/W2P//883r99dfDUVKzJSQk6IorrlB5ebny8/Prfe6ZZ57R5s2bm30ut9utpKQkLV26VF988UVw+6FDhxqMdEl1X7f333+/3nS6r776SrNmzWr0Nbp37y5J2rVrV5Pn++m/w3333adPP/202e8DAACgo2LqWgu5XNYKOLUmTJig+++/X7fccou8Xq/69++vjz/+WIWFhfrNb36jlStXhrvEI8rLy9OaNWs0c+ZMrV27NthH57XXXtOvfvUrrV69WjExR8/3ycnJevTRRzVp0iSdffbZuuqqq5ScnKzXXntNnTp1qreSnFS3GtrLL7+s4cOH66KLLlJ5eblee+01XXTRRcERmh+78MIL9dJLL+nyyy/Xr3/9ayUmJmrIkCEaO3aspk6dqqeeekqXX365rrzySvXo0UMffPCBNmzYoDFjxmjVqlWt9jUDAACwIkZ0UE+/fv20du1aXXTRRVqzZo2efPJJVVdX680339TYsWPDXd5RpaWlqbi4WL/97W/1/vvvKz8/X3v27NGbb76pE088UVLjCyQ0JisrS6+88opOOukkPf3003r66ad17rnnas2aNY2uWLds2TLddttt2r9/vwoKCvTBBx8oJydHzz//fKPnnzJlimbMmKF9+/bp/vvv1+zZs/Xyyy9Lks4880y9+eabOuuss7Ry5UotXbpU3bp103vvvafhw4e38KsDAADQcdhM0zTDXcTRVFRUKDk5WT6fr8lfUg8ePKht27ZpwIABSkxMbOcKEQ3OO+88FRcXy+fzqUuXLuEup83xPQEAAH7MKDHk3eaVc4AzKhcXqNWcbCAxogML2r17d4Ntzz33nN577z1lZGR0iJADAADwY0aJIfdytwrWFci93C2jJEqbQYaAe3RgOaeffrrOPPNMnXbaacH+P0VFReratasefPDBcJcHAADQ7rzbvMGmn3abXUXbi6J6VKc5GNGB5UydOlV79uzRM888o4ULF6qkpETXXHON1q1bp8GDB4e7PAAAgHbnHOAMhhy/6Zcj3RHuktoc9+gAFsX3BAAA+DGjxFDR9iI50h1RPZrT3Ht0mLoGAAAAdACuQa6oDjihYuoaAAAAAMsh6AAAAACwHIIOAAAAAMsh6AAAAACwHIIOAAAAEEWMEkPZq7M7RNPPY0HQAQAAAKKEUWLIvdytgnUFci93E3aOgKADAAAARAnvNm+w6afdZlfR9qJwlxSxCDoAAABAlHAOcAZDjt/0y5HuCHdJEYugg3bhcDhks9nCXUazLFu2TDabTcuWLQt3KQAAAPW4Brnkucqj6SOny3OVp0M1AA0VQccibDZbSI/WNnfuXNlsNhUVFbX6uaNRUVGRbDab5s6dG+5SAACAxbgGubQgcwEh5yhiw10AWkdubm6Dbfn5+fL5fI1+rr0988wz+v7778NdBgAAADoIgo5FNDZysGzZMvl8vogYVfj5z38e7hIAAADQgTB1rQOqrq7WggULdNZZZ+m4445T165ddf7558swGi5P6PP5NGfOHJ122mnq0qWLkpKSdOKJJyorK0s7duyQFLj/Zt68eZIkp9MZnB6Xnp4ePE9j9+j8+F6YN998U+ecc446d+6sHj16KCsrS//5z38arf/JJ5/UL37xCyUmJiotLU0zZszQwYMHZbPZ5HA4mv11+OabbzR16lSlpKSoc+fOOvvss/XKK680uf/SpUvldruVnp6uxMREde/eXZmZmfJ6vfX2mzt3rpxOpyRp3rx59aYMbt++XZL0xRdfaMaMGTrrrLPUo0cPJSYm6uSTT9bMmTP13XffNfs9AAAAoHGM6HQwVVVV+tWvfqWioiINHTpU1113nQ4dOqRVq1bJ7XaroKBAN998syTJNE1lZmbqH//4h84991z96le/UkxMjHbs2CHDMDRhwgT1799fkyZNkiStXbtWWVlZwYDTrVu3ZtVkGIZWrVqlsWPH6pxzztE777yjZ555Rl9++aXefffdevvOmTNH99xzj1JSUjRlyhTFxcXpxRdf1ObNm0P6Onz//fdyOBz65JNPNGrUKI0ePVq7du3S+PHjdckllzR6zLRp0zRkyBBlZGTo+OOPV2lpqV599VVlZGRo5cqVcrvdkgKhbvv27Xr66ac1evToeuGr9muycuVKLVmyRE6nUw6HQzU1Nfrggw90//33a+3atXrnnXcUFxcX0nsCAADAj5hRwOfzmZJMn8/X5D4//PCD+fnnn5s//PBDO1YW2fr372/+9J/4jjvuMCWZs2fPNmtqaoLbKyoqzOHDh5vx8fFmaWmpaZqm+a9//cuUZI4bN67BuQ8ePGgeOHAg+HFubq4pyfR6vY3WMnr06Aa1PPXUU6YkMzY21nz33XeD2w8fPmw6HA5TkllcXBzcXlJSYtrtdrNv375meXl5vdpPO+00U5I5evToo39hflTvlClT6m1fvXq1KcmUZD711FP1Prd169YG5/n666/NPn36mCeddFK97V6v15Rk5ubmNvr6X331lVlVVdVg+7x580xJ5nPPPdes93EkfE8AABC5PJs95u//9nvTs9kT7lKiTnOygWmaJlPXWsgoMZS9OjuqutHW1NTo8ccf18CBA4NTqmp17dpVc+bMUXV1tVauXFnvuE6dOjU4V0JCgrp06dIqdV1zzTU699xzgx/b7XZlZWVJkj788MPg9hdeeEF+v1+33XabevXqVa/2u+66K6TXfOaZZxQfH6+777673vbMzExddNFFjR4zYMCABttSU1N1+eWX69///ndwKl9z9O3bV/Hx8Q22146mrVmzptnnAgAA0cUoMeRe7lbBugK5l7uj6vfJaMLUtRaovTjtNrvy/5EfNWuYl5SUaP/+/erTp0/wnpof27t3ryQFp4GdeuqpOuOMM/TCCy/oq6++0rhx4+RwODR06FDFxLReRh42bFiDbf369ZMkffvtt8FtH3/8sSTpvPPOa7D/j4PS0VRUVGjbtm067bTT1Lt37wafP//881VYWNhg+9atW5WXl6e3335bpaWlqqqqqvf5r7/+Wv37929WDaZp6qmnntKyZcv06aefyufzqaampt65AACANXm3eYMNP+02u4q2F0XF75LRhqDTAtF6cX7zzTeSpM8++0yfffZZk/tVVlZKkmJjY/X2229r7ty5evnll3XbbbdJko4//njdfPPNuvPOO2W324+5rqSkpAbbYmMDl6bf7w9uq6iokKR6ozm1UlJSmv16RzpPU+fasmWLRowYoYqKCjmdTo0dO1ZJSUmKiYlRUVGR1q5d2yD4HMn06dO1cOFCpaWlyeVyKTU1VQkJCZICCxiEci4AABBdnAOcyv9HfvD3SUe6I9wlWRJBpwWi9eKsDRSXX365XnrppWYd06NHDxUUFOjRRx/V5s2b9fbbb6ugoEC5ubmKi4vTrFmz2rLkemrr37NnT4ORk/Ly8hadpzGNnevhhx/W/v379eyzz+raa6+t97mpU6dq7dq1zX79PXv2aNGiRTrjjDNUXFyszp07Bz9XVlbW6GgbAACwDtcglzxXeVS0vUiOdEdU/ME8GnGPTgvUXpzTR06PmmlrUmAqWlJSkv75z3/q0KFDIR1rs9l06qmnatq0aXrrrbckqd5y1LUjOz8egWltQ4YMkSS99957DT73/vvvN/s8SUlJGjBggLZs2aKysrIGn//73//eYNuXX34pScGV1WqZptloPUf6emzdulWmaSojI6NeyGnqtQEAgPW4Brm0IHNB1PweGY0IOi0UjRdnbGysbrzxRu3YsUO33357o2Hn008/DY50bN++Pdj35cdqRzwSExOD27p37y5J2rVrVxtUHnDVVVcpJiZGDz30kPbt2xfcXllZqfnz54d0rgkTJqi6ulpz5sypt/3NN99s9P6c2hGkny53fd999+nTTz9tsP+Rvh6153r//ffr3Zfz1VdftesIGQAAgJUxda2DmTdvnjZs2KBHH31Uq1at0gUXXKBevXqptLRUn3zyiT7++GMVFxerV69e2rhxo37zm99oxIgRwRv3a3vHxMTEKDs7O3je2kahd9xxhz777DMlJyerW7duwVXEWsOgQYM0c+ZM3XvvvRo8eLCuvPJKxcbGauXKlRo8eLA+/fTTZi+SMGPGDK1cuVKLFy/WZ599pgsuuEC7du3Siy++qDFjxmjVqlX19p86daqeeuopXX755bryyivVo0cPffDBB9qwYUOj+59yyinq06ePli9froSEBPXr1082m0233HJLcKW2l19+WcOHD9dFF12k8vJyvfbaa7rooouCo0cAAABoOUZ0OpiEhAT97W9/05NPPqnevXvr5ZdfVn5+vt555x2lpqbq8ccf1+DBgyVJw4cP1x//+EfZbDatWrVKDz30kIqKipSRkaH33ntPLlfdaNZpp52mp556Sj179lRBQYFmz56tBx98sNXrnz9/vh577DH97Gc/0xNPPKEXX3xRV1xxhR577DFJjS9s0JjjjjtOa9eu1Q033KB///vfys/P1+bNm7VixQpdccUVDfY/88wz9eabb+qss87SypUrtXTpUnXr1k3vvfeehg8f3mB/u92ulStX6pe//KVeeOEFzZkzR7Nnz9b+/fslScuWLdNtt92m/fv3q6CgQB988IFycnL0/PPPH8NXBwAAALVspmma4S7iaCoqKpScnCyfz9fkL7IHDx7Utm3bNGDAgHpTqtAxrFmzRhdffLFmzJih+++/P9zlRAS+JwAAgBU1JxtIjOggyuzdu7fBDf7ffvtt8N6WcePGhaEqAADQUUVjE/mOgnt0EFX+/Oc/68EHH9SFF16oPn36aPfu3Vq9erX27NmjSZMmadSoUeEuEQAAdBDR2kS+oyDoIKqcc845GjZsmNasWaNvvvlGdrtdp556qmbPnq2bbrop3OUBAIAOJFqbyHcUBB1ElREjRsjj8YS7DAAAgKhtIt9REHQAAACAFqhtIl+0vUiOdAejORGGoAMAAAC0kGuQi4AToVh1DQAAAIDlEHQAAAAAWA5BBwAAAIDlEHQAAAAAWA5BBwAAAB2eUWIoe3W2jBIj3KWglRB0AAAA0KEZJYbcy90qWFcg93I3YcciCDoAAADo0LzbvMGmn3abXUXbi8JdEloBQQdtbvv27bLZbJo0aVK97Q6HQzabrc1eNz09Xenp6W12fgAAYA3OAc5gyPGbfjnSHeEuCa2AoGMxtaHix4/4+HilpaXpmmuu0b/+9a9wl9hqJk2aJJvNpu3bt4e7FAAAEMVcg1zyXOXR9JHT5bnKQwNQi4gNdwFoGwMHDtS1114rSfruu+/0wQcf6IUXXtDKlStVWFioc889N8wVSs8884y+//77Njt/YWFhm50bAABYi2uQi4BjMQQdizrxxBM1d+7cetvuuusuzZ8/X3feeaeKiorCUteP/fznP2/T8w8cOLBNzw8AAIDIxdS1DuSWW26RJH344YeSJJvNJofDodLSUk2cOFG9e/dWTExMvRD0zjvvaOzYserZs6cSEhJ00kkn6a677mp0JMbv9+v+++/XiSeeqMTERJ144onKy8tTTU1No/Uc6R4dj8ejSy65RD169FBiYqLS09M1YcIEffrpp5IC9988/fTTkqQBAwYEp+k5HI7gOZq6R6eyslK5ubk65ZRTlJiYqO7du2vMmDF67733Guw7d+5c2Ww2FRUV6fnnn9fQoUPVqVMnpaam6tZbb9UPP/zQ4JiXX35Zo0ePVq9evZSYmKg+ffooIyNDL7/8cqPvFQAAAK2PEZ0O6Mfh4j//+Y9GjRql7t2766qrrtLBgweVlJQkSXr88cc1bdo0devWTWPHjlWvXr30z3/+U/Pnz5fX65XX61V8fHzwXDfccIOWLl2qAQMGaNq0aTp48KAWLFig999/P6T6brvtNi1YsEDdu3fXuHHj1KtXL+3atUtr1qzRsGHDdPrpp+v3v/+9li1bpo8//li33nqrunXrJklHXXzg4MGDuvDCC7Vu3TqdddZZ+v3vf6/y8nKtWLFCb7zxhl544QX99re/bXDcwoULtXr1arndbl144YVavXq1Hn30Ue3bt09//vOfg/s9/vjjuummm5SamqrLLrtMPXr0UFlZmdatW6dXXnlFl19+eUhfCwAAALSQ2QILFy40+/fvbyYkJJgjRoww//GPfzS5b3V1tTlv3jzzhBNOMBMSEswzzjjD/Nvf/hbS6/l8PlOS6fP5mtznhx9+MD///HPzhx9+COncVrNt2zZTkpmZmdngc3PmzDElmU6n0zRN05RkSjInT55sHj58uN6+n332mRkbG2sOGTLE3LdvX73P5eXlmZLMBx98MLjN6/WakswhQ4aY3333XXD7V199Zfbs2dOUZGZlZdU7z+jRo82fXoJ//etfTUnm4MGDG7zuoUOHzLKysuDHWVlZpiRz27ZtjX4t+vfvb/bv37/etnnz5pmSzP/+7/82a2pqgts3bNhgxsfHm926dTMrKiqC23Nzc01JZnJysrl58+bg9u+//948+eSTzZiYGLO0tDS4/ayzzjLj4+PN8vLyBvX89P20Nb4nAACAFTUnG5imaYY8dW3FihXKyclRbm6uNmzYoCFDhigzM1N79uxpdP+77rpLTz75pAoKCvT5559r6tSpuuyyy/TRRx+1IJZFEMOQsrMDzxFoy5Ytmjt3rubOnas//OEPuuCCC3T33XcrMTFR8+fPD+4XHx+vP/3pT7Lb7fWOf/LJJ3X48GEVFBSoR48e9T43Y8YMHX/88XrhhReC25555hlJ0pw5c3TccccFt/ft21e33nprs+t+7LHHJEmPPPJIg9eNjY1VSkpKs8/VmKefflpxcXG677776o1snXnmmcrKytK3336rV199tcFxt956qwYNGhT8uFOnTrr66qtVU1Oj9evX19s3Li5OcXFxDc7x0/cDAABal1FiKHt1Ng0/IakFU9cWLFigKVOmaPLkyZKkJ554QqtWrdLSpUs1c+bMBvs/++yzuvPOO3XppZdKkm688UatWbNGDz30kJ577rljLD9MDENyuyW7XcrPlzweyRVZq3R8+eWXmjdvnqTAL94pKSm65pprNHPmTA0ePDi434ABA9SzZ88Gx3/wwQeSpDfeeKPR1cvi4uK0efPm4Mcff/yxJOn8889vsG9j25qybt06JSQkaPTo0c0+prkqKiq0detWnXrqqerXr1+DzzudTi1evFgbN27UhAkT6n1u2LBhDfavPce3334b3HbVVVdpxowZOv3003XNNdfI6XTqvPPOC04HBAAAbcMoMeRe7pbdZlf+P/JZJhqhBZ3q6mqtX79es2bNCm6LiYlRRkaGiouLGz2mqqpKiYmJ9bZ16tRJ7777bpOvU1VVpaqqquDHFRUVoZTZ9rzeQMjx+wPPRUURF3QyMzO1evXqo+7X1AjJN998I0n1Rn+OxOfzKSYmptHQFMoojM/nU9++fRUT0/rrZNReR03Vk5qaWm+/H2ssqMTGBr59/H5/cNvtt9+uHj166PHHH9dDDz2kBx98ULGxsRozZowefvhhDRgw4JjfBwAAaMi7zRts+Gm32VW0vYig08GF9Nvkvn375Pf7G/yimJKSorKyskaPyczM1IIFC/Tvf/9bNTU1euutt7Ry5Urt3r27ydfJy8tTcnJy8JGWlhZKmW3P6awLOX6/9KOVvqJNU6ue1f5iX1FRIdM0m3zUSk5OVk1Njfbt29fgXOXl5c2up1u3biorK2typbZjUfuemqqn9ho+ltEXm82m3/3ud/rwww+1d+9evfLKK/rNb34jj8ej//qv/6oXigAAQOtxDnAGQ47f9MuR7gh3SQizNl9e+pFHHtFJJ52kU045RfHx8br55ps1efLkI/7FftasWfL5fMHHrl272rrM0Lhcgelq06dH5LS11jBy5EhJdVPYjmbIkCGSpL///e8NPtfYtqaMGDFCVVVVWrt27VH3rb2vqLnhISkpSSeccIK2bNmi0tLSBp+vXVZ76NChza73SHr06KFx48ZpxYoVuvDCC/X5559ry5YtrXJuAABQn2uQS56rPJo+cjrT1iApxKDTs2dP2e32Bn8RLy8vV+/evRs95vjjj9err76qyspK7dixQ5s3b1aXLl10wgknNPk6CQkJSkpKqveIOC6XtGCBJUOOJN10002KjY3VLbfcop07dzb4/LfffltvQYnae1ruvvtuVVZWBreXlpbqkUceafbrTps2TVLg5v/a6XO1Dh8+XO/a6969uySFFISzsrJ06NAhzZo1q96I1L/+9S8tW7ZMycnJGjduXLPP91NFRUX1zitJhw4dCr6Xn07jBAAArcc1yKUFmQsIOZAU4j068fHxGjZsmAoLC4O/DNbU1KiwsFA333zzEY9NTExU3759dejQIb388su68sorW1w02t7pp5+uxx57TDfeeKMGDRqkSy+9VAMHDtSBAwe0detWrV27VpMmTdITTzwhKXAj/+TJk/XUU09p8ODBuuyyy1RVVaUVK1bol7/8pV577bVmve6ll16q22+/XQ8++KBOOukkXXbZZerVq5dKS0tVWFio22+/Xb///e8lSRdeeKEefPBB3XDDDbr88st13HHHqX///g0WEvixGTNmaNWqVXr22We1adMmXXTRRdqzZ49WrFihw4cPa/HixeratWuLv27jxo1TUlKSfvnLX6p///46dOiQ3nrrLX3++ee64oor1L9//xafGwAAAM0X8qprOTk5ysrK0vDhwzVixAjl5+ersrIyuArbxIkT1bdvX+Xl5UmS/vGPf6i0tFRDhw5VaWmp5s6dq5qaGs2YMaN13wla3ZQpUzR06FAtWLBA77zzjv76178qOTlZP//5z5Wdna2srKx6+y9evFgnn3yyFi9erIULF6pfv37KycnRlVde2eygI0kPPPCARo0apYULF+qll17SwYMHlZqaqgsvvFAXX3xxcL9f//rX+tOf/qTFixfroYce0qFDhzR69OgjBp3ExES9/fbbuv/++7VixQo9/PDD6ty5s0aPHq077rhD5513XuhfqB/Jy8vT6tWrtW7dOv31r3/Vcccdp4EDB+rxxx/Xddddd0znBgAAQPPZzJ/Os2mGhQsX6oEHHlBZWZmGDh2qRx99NHhPh8PhUHp6upYtWyZJWrt2rW688UZt3bpVXbp00aWXXqr77rtPffr0afbrVVRUKDk5WT6fr8lpbAcPHtS2bds0YMAApgcB4nsCAABYU3OygdTCoNPeCDpA6PieAAAAVtTcoNPmq64BAAAAoTBKDGWvzpZRYoS7FEQxgg4AAAAihlFiyL3crYJ1BXIvdxN20GIEHQAAAEQM7zZvsOmn3WZX0faicJeEKEXQAQAAQMRwDnAGQ47f9MuR7gh3SYhSIS8vDQAAALQV1yCXPFd5VLS9SI50B80/0WKWCzpRsIgc0C74XgAARCvXIBcBB8fMMlPX7Ha7JOnQoUNhrgSIDIcPH5YkxcZa7u8ZAAAAR2WZoBMXF6eEhAT5fD7+kg0osMa83W4P/hEAAACgI7HUn3p79uyp0tJSffXVV0pOTlZcXJxsNlu4ywLalWmaqqysVEVFhVJTU/keAAAAHZKlgk5tZ9R9+/aptLQ0zNUA4WOz2dStWzclJyeHuxQAAICwsFTQkQJhJykpSYcOHZLf7w93OUBYxMXFMWUNABBWRokh7zavnAOcLCyAsLBc0KkVFxenuLi4cJcBAADQ4RglhtzL3bLb7Mr/R748V3kIO2h3llmMAAAAAJHBu80bbPhpt9lVtL0o3CWhAyLoAAAAoFU5BziDIcdv+uVId4S7JHRAlp26BgAAgPBwDXLJc5VHRduL5Eh3MG0NYWEzo6DpTEVFhZKTk+Xz+YIrqwEAAADoeJqbDZi6BgAAAMByCDoAAAAALIegAwAAAMByCDoAAAAALIegAwAAgCYZJYayV2fLKDHCXQoQEoIOAAAAGmWUGHIvd6tgXYHcy92EHUQVgg4AAAAa5d3mDTb9tNvsKtpeFO6SgGYj6AAAAKBRzgHOYMjxm3450h3hLglotthwFwAAAIDI5Brkkucqj4q2F8mR7pBrkCvcJQHNZjNN0wx3EUfT3O6nAAAAAKytudmAqWsAAAAALIegAwAAAMByCDoAAAAALIegAwAAAMByCDoAAAAdgGFI2dmBZ6AjIOgAAABYnGFIbrdUUBB4JuygIyDoAAAAWJzXK9ntkt8feC4qCndFQNsj6AAAAFic01kXcvx+yeEId0VA24sNdwEAAABoWy6X5PEERnIcjsDHgNURdAAAADoAl4uAg46FqWsAAAAALIegAwAAAMByCDoAAAAALIegAwAAAMByCDoAAABRwjCk7GwafgLNQdABAACIAoYhud1SQUHgmbADHBlBBwAAIAp4vXUNP+32QE8cAE0j6AAAAEQBp7Mu5Pj9gcafAJpGw1AAAIAo4HJJHk9gJMfhoPkncDQEHQAAgCjhchFwgOZi6hoAAAAAyyHoAAAAALAcgg4AAAAAyyHoAAAAALAcgg4AAEA7MwwpO5umn0BbIugAAAC0I8OQ3G6poCDwTNgB2gZBBwAAoB15vXVNP+32QF8cAK2PoAMAANCOnM66kOP3B5p/Amh9NAwFAABoRy6X5PEERnIcDhqAAm2FoAMAANDOXC4CDtDWmLoGAAAAwHIIOgAAAAAsh6ADAAAAwHIIOgAAAAAsh6ADAADQQoYhZWfT9BOIRC0KOosWLVJ6eroSExM1cuRIrVu37oj75+fna9CgQerUqZPS0tKUnZ2tgwcPtqhgAACASGAYktstFRQEngk7QGQJOeisWLFCOTk5ys3N1YYNGzRkyBBlZmZqz549je7//PPPa+bMmcrNzdWmTZu0ZMkSrVixQnfccccxFw8AABAuXm9d00+7PdAXB0DkCDnoLFiwQFOmTNHkyZN12mmn6YknnlDnzp21dOnSRvd///33de655+qaa65Renq6LrnkEl199dVHHQUCAACIZE5nXcjx+wPNPwFEjpCCTnV1tdavX6+MjIy6E8TEKCMjQ8XFxY0ec84552j9+vXBYLN161a9/vrruvTSS5t8naqqKlVUVNR7AAAARBKXS/J4pOnTA880AAUiS2woO+/bt09+v18pKSn1tqekpGjz5s2NHnPNNddo3759Ou+882Sapg4fPqypU6cecepaXl6e5s2bF0ppAAAA7c7lIuAAkarNV10rKirSvffeq8cee0wbNmzQypUrtWrVKt1zzz1NHjNr1iz5fL7gY9euXW1dJgAAAAALCWlEp2fPnrLb7SovL6+3vby8XL179270mNmzZ2vChAm6/vrrJUmDBw9WZWWlbrjhBt15552KiWmYtRISEpSQkBBKaQAAAAAQFNKITnx8vIYNG6bCwsLgtpqaGhUWFmrUqFGNHvP99983CDN2u12SZJpmqPUCAAAAwFGFNKIjSTk5OcrKytLw4cM1YsQI5efnq7KyUpMnT5YkTZw4UX379lVeXp4kaezYsVqwYIHOPPNMjRw5Ulu2bNHs2bM1duzYYOABAAAAgNYUctAZP3689u7dqzlz5qisrExDhw7V6tWrgwsU7Ny5s94Izl133SWbzaa77rpLpaWlOv744zV27FjNnz+/9d4FAABACxlGoCeO08nCAoCV2MwomD9WUVGh5ORk+Xw+JSUlhbscAABgEYYhud11vXBYJhqIfM3NBm2+6hoAAECk8nrrQo7dLhUVhbsiAK2FoAMAADosp7Mu5Pj9ksMR7ooAtJaQ79EBAACwCpcrMF2tqCgQcpi2BlgHQQcAAHRoLhcBB7Aipq4BAAAAsByCDgAAAADLIegAAAAAsByCDgAAAADLIegAAABLMAwpOzvwDAAEHQAAEPUMQ3K7pYKCwDNhBwBBBwAARD2vt67pp90e6IsDoGMj6AAAgKjndNaFHL8/0PwTQMdGw1AAABD1XC7J4wmM5DgcNAAFQNABAAAW4XIRcADUYeoaAAAAAMsh6AAAAACwHIIOAAAAAMsh6AAAAACwHIIOAACIGIYhZWfT8BPAsSPoAACAiGAYktstFRQEngk7AI4FQQcAAEQEr7eu4afdHuiJAwAtRdABAAARwemsCzl+f6DxJwC0FA1DAQBARHC5JI8nMJLjcND8E8CxIegAAICI4XIRcAC0DqauAQAAALAcgg4AAAAAyyHoAAAAALAcgg4AAAAAyyHoAACAVmcYUnY2TT8BhA9BBwAAtCrDkNxuqaAg8EzYARAOBB0AANCqvN66pp92e6AvDgC0N4IOAABoVU5nXcjx+wPNPwGgvdEwFAAAtCqXS/J4AiM5DgcNQAGEB0EHAAC0OpeLgAMgvJi6BgAAAMByCDoAAAAALIegAwAAAMByCDoAAAAALIegAwAAmmQYUnY2TT8BRB+CDgAAaJRhSG63VFAQeCbsAIgmBB0AANAor7eu6afdHuiLAwDRgqADAAAa5XTWhRy/P9D8EwCiBQ1DAQBAo1wuyeMJjOQ4HDQABRBdCDoAAKBJLhcBB0B0YuoaAAAAAMsh6AAAAACwHIIOAAAAAMsh6AAAAACwHIIOAAAWZxhSdjYNPwF0LAQdAAAszDAkt1sqKAg8E3YAdBQEHQAALMzrrWv4abcHeuIAQEdA0AEAwMKczrqQ4/cHGn8CQEdAw1AAACzM5ZI8nsBIjsNB808AHQdBBwAAi3O5CDgAOh6mrgEAAACwHIIOAAAAAMsh6AAAAACwHIIOAAAAAMsh6AAAECUMQ8rOpuknADQHQQcAgChgGJLbLRUUBJ4JOwBwZC0KOosWLVJ6eroSExM1cuRIrVu3rsl9HQ6HbDZbg8eYMWNaXDQAAB2N11vX9NNuD/TFAQA0LeSgs2LFCuXk5Cg3N1cbNmzQkCFDlJmZqT179jS6/8qVK7V79+7g49NPP5Xdbtdvf/vbYy4eAICOwumsCzl+f6D5JwCgaTbTNM1QDhg5cqTOPvtsLVy4UJJUU1OjtLQ03XLLLZo5c+ZRj8/Pz9ecOXO0e/duHXfccc16zYqKCiUnJ8vn8ykpKSmUcgEAsAzDCIzkOBw0AAXQcTU3G8SGctLq6mqtX79es2bNCm6LiYlRRkaGiouLm3WOJUuW6KqrrjpiyKmqqlJVVVXw44qKilDKBADAklwuAg4ANFdIU9f27dsnv9+vlJSUettTUlJUVlZ21OPXrVunTz/9VNdff/0R98vLy1NycnLwkZaWFkqZAAAAADq4dl11bcmSJRo8eLBGjBhxxP1mzZoln88XfOzataudKgQAAABgBSFNXevZs6fsdrvKy8vrbS8vL1fv3r2PeGxlZaWWL1+uu++++6ivk5CQoISEhFBKAwAAAICgkEZ04uPjNWzYMBUWFga31dTUqLCwUKNGjTrisX/5y19UVVWla6+9tmWVAgAAAEAzhTx1LScnR4sXL9bTTz+tTZs26cYbb1RlZaUmT54sSZo4cWK9xQpqLVmyROPGjVOPHj2OvWoAAKKYYUjZ2TT9BIC2FNLUNUkaP3689u7dqzlz5qisrExDhw7V6tWrgwsU7Ny5UzEx9fNTSUmJ3n33Xb355putUzUAAFHKMCS3O9APJz9f8nhYSQ0A2kLIfXTCgT46AACryM6WCgrqmn9Ony4tWBDuqgAgejQ3G7TrqmsAAHR0TmddyPH7A80/AQCtL+SpawAAoOVcrsB0taKiQMhh2hoAtA2CDgAA7czlIuAAQFtj6hoAAAAAyyHoAAAAALAcgg4AAAAAyyHoAAAAALAcgg4AAC1gGIGeOIYR7koAAI0h6AAAECLDkNzuQONPt5uwAwCRiKADAECIvN66hp92e6AnDgAgshB0AAAIkdNZF3L8/kDjTwBAZKFhKAAAIXK5JI8nMJLjcND8EwAiEUEHAIAWcLkIOAAQyZi6BgAAAMByCDoAAAAALIegAwAAAMByCDoAAAAALIegAwDo0AxDys6m6ScAWA1BBwDQYRmG5HZLBQWBZ8IOAFgHQQcA0GF5vXVNP+32QF8cAIA1EHQAAB2W01kXcvz+QPNPAIA10DAUANBhuVySxxMYyXE4aAAKAFZC0AEAdGguFwEHAKyIqWsAAAAALIegAwAAAMByCDoAAAAALIegAwAAAMByCDoAgKhnGFJ2Ng0/AQB1CDoAgKhmGJLbLRUUBJ4JOwAAiaADAIhyXm9dw0+7PdATBwAAgg4AIKo5nXUhx+8PNP4EAICGoQCAqOZySR5PYCTH4aD5JwAggKADAIh6LhcBBwBQH1PXAAAAAFgOQQcAAACA5RB0AAAAAFgOQQcAAACA5RB0AAARwzCk7GyafgIAjh1BBwAQEQxDcrulgoLAM2EHAHAsCDoAgIjg9dY1/bTbA31xAABoKYIOACAiOJ11IcfvDzT/BACgpWgYCgCICC6X5PEERnIcDhqAAgCODUEHABAxXC4CDgCgdTB1DQAAAIDlEHQAAAAAWA5BBwAAAIDlEHQAAAAAWA5BBwDQ6gxDys6m6ScAIHwIOgCAVmUYktstFRQEngk7AIBwIOgAAFqV11vX9NNuD/TFAQCgvRF0AACtyumsCzl+f6D5JwAA7Y2GoQCAVuVySR5PYCTH4aABKAAgPAg6AIBW53IRcAAA4cXUNQAAAACWQ9ABAAAAYDkEHQAAAACWQ9ABAAAAYDkEHQBAowxDys6m4ScAIDoRdAAADRiG5HZLBQWBZ8IOACDaEHQAAA14vXUNP+32QE8cAACiCUEHANCA01kXcvz+QONPAACiSYuCzqJFi5Senq7ExESNHDlS69atO+L+3377raZNm6bU1FQlJCTo5JNP1uuvv96iggEAbc/lkjweafr0wDPNPwEA0SY21ANWrFihnJwcPfHEExo5cqTy8/OVmZmpkpIS9erVq8H+1dXVuvjii9WrVy+99NJL6tu3r3bs2KFu3bq1Rv0AgDbichFwAADRy2aaphnKASNHjtTZZ5+thQsXSpJqamqUlpamW265RTNnzmyw/xNPPKEHHnhAmzdvVlxcXLNeo6qqSlVVVcGPKyoqlJaWJp/Pp6SkpFDKBQAAAGAhFRUVSk5OPmo2CGnqWnV1tdavX6+MjIy6E8TEKCMjQ8XFxY0eYxiGRo0apWnTpiklJUWnn3667r33Xvn9/iZfJy8vT8nJycFHWlpaKGUCAAAA6OBCCjr79u2T3+9XSkpKve0pKSkqKytr9JitW7fqpZdekt/v1+uvv67Zs2froYce0v/8z/80+TqzZs2Sz+cLPnbt2hVKmQAAAAA6uJDv0QlVTU2NevXqpf/93/+V3W7XsGHDVFpaqgceeEC5ubmNHpOQkKCEhIS2Lg0AAACARYUUdHr27Cm73a7y8vJ628vLy9W7d+9Gj0lNTVVcXJzsdntw26mnnqqysjJVV1crPj6+BWUDAJrLMAJ9cZxOFhcAAHQcIU1di4+P17Bhw1RYWBjcVlNTo8LCQo0aNarRY84991xt2bJFNTU1wW1ffPGFUlNTCTkA0MYMQ3K7pYKCwLNhhLsiAADaR8h9dHJycrR48WI9/fTT2rRpk2688UZVVlZq8uTJkqSJEydq1qxZwf1vvPFGffPNN7r11lv1xRdfaNWqVbr33ns1bdq01nsXAIBGeb11TT/tdqmoKNwVAQDQPkK+R2f8+PHau3ev5syZo7KyMg0dOlSrV68OLlCwc+dOxcTU5ae0tDS98cYbys7O1hlnnKG+ffvq1ltv1R//+MfWexcAgEY5nVJ+fl3YcTjCXREAAO0j5D464dDctbIBAA0ZRmAkx+HgHh0AQPRrbjZo81XXAADh5XIRcAAAHU/I9+gAAAAAQKQj6AAAAACwHIIOAAAAAMsh6AAAAACwHIIOAEQJw5Cys2n6CQBAcxB0ACAKGIbkdksFBYFnwg4AAEdG0AGAKOD11jX9tNsDfXEAAEDTCDoAEAWczrqQ4/cHmn8CAICm0TAUAKKAyyV5PIGRHIeDBqAAABwNQQcAooTLRcABAKC5mLoGAAAAwHIIOgAAAAAsh6ADAAAAwHIIOgAAAAAsh6ADAO3IMKTsbBp+AgDQ1gg6ANBODENyu6WCgsAzYQcAgLZD0AGAduL11jX8tNsDPXEAAEDbIOgAQDtxOutCjt8faPwJAADaBg1DAaCduFySxxMYyXE4aP4JAEBbIugAQDtyuQg4AAC0B6auAQAAALAcgg4AAAAAyyHoAAAAALAcgg4AAAAAyyHoAEALGIaUnU3TTwAAIhVBBwBCZBiS2y0VFASeCTsAAEQegg4AhMjrrWv6abcH+uIAAIDIQtABgBA5nXUhx+8PNP8EAACRhYahABAil0vyeAIjOQ4HDUABAIhEBB0AaAGXi4ADAEAkY+oaAAAAAMsh6AAAAACwHIIOAAAAAMsh6AAAAACwHIIOgA7LMKTsbBp+AgBgRQQdAB2SYUhut1RQEHgm7AAAYC0EHQAdktdb1/DTbg/0xAEAANZB0AHQITmddSHH7w80/gQAANZBw1AAHZLLJXk8gZEch4PmnwAAWA1BB0CH5XIRcAAAsCqmrgEAAACwHIIOAAAAAMsh6AAAAACwHIIOAAAAAMsh6ACIeoYhZWfT9BMAANQh6ACIaoYhud1SQUHgmbADAAAkgg6AKOf11jX9tNsDfXEAAAAIOgCimtNZF3L8/kDzTwAAABqGAohqLpfk8QRGchwOGoACAIAAgg6AqOdyEXAAAEB9TF0DAAAAYDkEHQAAAACWQ9ABAAAAYDkEHQAAAACWQ9ABEDEMQ8rOpuknAAA4dgQdABHBMCS3WyooCDwTdgAAwLEg6ACICF5vXdNPuz3QFwcAAKClCDoAIoLTWRdy/P5A808AAICWomEogIjgckkeT2Akx+GgASgAADg2LRrRWbRokdLT05WYmKiRI0dq3bp1Te67bNky2Wy2eo/ExMQWFwzAulwuacECQg4AADh2IQedFStWKCcnR7m5udqwYYOGDBmizMxM7dmzp8ljkpKStHv37uBjx44dx1Q0AAAAABxJyEFnwYIFmjJliiZPnqzTTjtNTzzxhDp37qylS5c2eYzNZlPv3r2Dj5SUlGMqGgAAAACOJKSgU11drfXr1ysjI6PuBDExysjIUHFxcZPHfffdd+rfv7/S0tLkdrv12WefHfF1qqqqVFFRUe8BAAAAAM0VUtDZt2+f/H5/gxGZlJQUlZWVNXrMoEGDtHTpUnk8Hj333HOqqanROeeco6+++qrJ18nLy1NycnLwkZaWFkqZAAAAADq4Nl9eetSoUZo4caKGDh2q0aNHa+XKlTr++OP15JNPNnnMrFmz5PP5go9du3a1dZkAWolhSNnZNPwEAADhFdLy0j179pTdbld5eXm97eXl5erdu3ezzhEXF6czzzxTW7ZsaXKfhIQEJSQkhFIagAhgGJLbHeiFk58fWC6aFdQAAEA4hDSiEx8fr2HDhqmwsDC4raamRoWFhRo1alSzzuH3+/XJJ58oNTU1tEoBRDyvt67hp90e6IkDAAAQDiFPXcvJydHixYv19NNPa9OmTbrxxhtVWVmpyZMnS5ImTpyoWbNmBfe/++679eabb2rr1q3asGGDrr32Wu3YsUPXX399670LABHB6awLOX5/oPEnAABAOIQ0dU2Sxo8fr71792rOnDkqKyvT0KFDtXr16uACBTt37lRMTF1+2r9/v6ZMmaKysjL97Gc/07Bhw/T+++/rtNNOa713ASAiuFyB6WpFRYGQw7Q1AAAQLjbTNM1wF3E0FRUVSk5Ols/nU1JSUrjLAQAAABAmzc0Gbb7qGgAAAAC0N4IOAAAAAMsh6AAAAACwHIIOAAAAAMsh6ABolGFI2dmBZwAAgGhD0AHQgGFIbrdUUBB4JuwAAIBoQ9AB0IDXW9f0024P9MUBAACIJgQdAA04nXUhx+8PNP8EAACIJrHhLgBA5HG5JI8nMJLjcAQ+BgAAiCYEHQCNcrkIOAAAIHoxdQ0AAACA5RB0AAAAAFgOQQcAAACA5RB0AAAAAFgOQQewMMOQsrNp+AkAADoegg5gUYYhud1SQUHgmbADAAA6EoIOYFFeb13DT7s90BMHAACgoyDoABbldNaFHL8/0PgTAACgo6BhKGBRLpfk8QRGchwOmn8CAICOhaADWJjLRcABAAAdE1PXAAAAADQtSpdxJegAAAAAaFwUL+NK0AEAAADQuChexpWgAwAAAKBxUbyMK4sRAFHAMAJ/UHE6WVwAAAC0oyhextVmmqYZ7iKOpqKiQsnJyfL5fEpKSgp3OUC7qp0aW/uHFI8nqv4fAwAAIoVF/nLa3GzA1DUgwkXx1FgAABAponhRgZYi6AARLoqnxgIAgEjRAf9yStABIlzt1Njp05m2BgAAWqgD/uWUe3QAAACAjsAwonJRgZ9qbjZg1TUAAAAgmrR0UQGXK6oDTqiYugYAAABEiw64qEBLEXQAAACAaNEBFxVoKYIOAAAAEC064KICLcU9OkA7skifLgAAEC61y7FaYFGBtsaqa0A7qZ1SW/sHGJaKBgCgA+Ovny3W3GzA1DWgnTClFgAASGJBgXZC0AHaCVNqAQCAJP762U4IOkA7qZ1SO30609YAAOjQ+Otnu+AeHQAAAKC9GQYLCrRQc7MBq64BAAAALdXSRQVcLgJOG2PqGgAAANASLCoQ0Qg6AAAAQEuwqEBEI+gAAAAALcGiAhGNe3SAENHfCwAAC2rJD/jaJVVZVCAiseoaEILaqbi1f7hhmWgAACyAH/BRpbnZgKlrQAiYigsAgAXxA96SCDpACJiKCwCABfED3pK4RwcIAVNxAQCwIH7AWxL36AAAAMAaWDGoQ+AeHQAAAHQcNO/ETxB0AAAAEP1YUAA/QdABAABA9GNBAfwEixEAAAAg+rGgAH6CoIMOi/sVAQCIUC39Ie1y8UMdQay6hg6JBsgAAEQofkjjKFh1DTgC7lcEACBC8UMarYSggw6J+xUBAIhQ/JBGK+EeHXRI3K8IAECE4oc0Wgn36AAAAKD1seoP2gj36AAAACA8ahcUKCgIPBtGuCtCB9SioLNo0SKlp6crMTFRI0eO1Lp165p13PLly2Wz2TRu3LiWvCwAAACiAQsKIAKEHHRWrFihnJwc5ebmasOGDRoyZIgyMzO1Z8+eIx63fft23X777Tr//PNbXCwAAACiAAsKIAKEfI/OyJEjdfbZZ2vhwoWSpJqaGqWlpemWW27RzJkzGz3G7/frggsu0O9+9zv9/e9/17fffqtXX321ydeoqqpSVVVV8OOKigqlpaVxjw4AAEC0MAwWFECbaJN7dKqrq7V+/XplZGTUnSAmRhkZGSouLm7yuLvvvlu9evXSdddd16zXycvLU3JycvCRlpYWSpnoYAxDys5m+i8AAG2ipT9oXS5pwQJCDsImpKCzb98++f1+paSk1NuekpKisrKyRo959913tWTJEi1evLjZrzNr1iz5fL7gY9euXaGUiQ6Eex0BAGhD/KBFFGvTVdcOHDigCRMmaPHixerZs2ezj0tISFBSUlK9B9AY7nUEAKAN8YMWUSykoNOzZ0/Z7XaVl5fX215eXq7evXs32P/LL7/U9u3bNXbsWMXGxio2NlbPPPOMDMNQbGysvvzyy2OrHh0e9zoCANCG+EGLKBYbys7x8fEaNmyYCgsLg0tE19TUqLCwUDfffHOD/U855RR98skn9bbdddddOnDggB555BHuvcExo3kyAABtiB+0iGIhBR1JysnJUVZWloYPH64RI0YoPz9flZWVmjx5siRp4sSJ6tu3r/Ly8pSYmKjTTz+93vHdunWTpAbbgZZyufj/LgAAbYYftIhSIQed8ePHa+/evZozZ47Kyso0dOhQrV69OrhAwc6dOxUT06a3/gAAAADAEYXcRyccmrtWNgAAAABra5M+OgAAAAAQDQg6AAAAACyHoIOI0NKmywAAAEBjCDoIO5ouAwAAoLURdBB2NF0GAABAayPoIOxougwAAIDWFnIfHaC10XQZAAAArY2gg4hA02UAAAC0JqauAQAAALAcgg4AAAAAyyHoAAAAALAcgg4AAAAAyyHooFUZhpSdTdNPAAAAhBdBB63GMCS3WyooCDwTdgAAABAuBB20Gq+3rumn3R7oiwMAAACEA0EHrcbprAs5fn+g+ScAAAAQDjQMRatxuSSPJzCS43DQABQAAADhQ9BBq3K5CDgAAAAIP6auAQAAALAcgg4AAAAAyyHoAAAAALAcgg4AAAAAyyHooAHDkLKzafgJAACA6EXQQT2GIbndUkFB4JmwAwAAgGhE0EE9Xm9dw0+7PdATBwAAAIg2BB3U43TWhRy/P9D4EwAAAIg2NAxFPS6X5PEERnIcDpp/AgAAIDoRdNCAy0XAAQAAQHRj6hoAAAAAyyHoAAAAALAcgg4AAAAAyyHoAAAAALAcgo6FGYaUnU3TTwAAAHQ8BB2LMgzJ7ZYKCgLPhB0AAAB0JAQdi/J665p+2u2BvjgAAABAR0HQsSinsy7k+P2B5p8AAABAR0HDUItyuSSPJzCS43DQABQAAAAdC0HHwlwuAg4AAAA6JqauAQAAALAcgg4AAAAAyyHoAAAAALAcgg4AAAAAyyHoRAHDkLKzafoJAAAANBdBJ8IZhuR2SwUFgWfCDgAAAHB0BJ0I5/XWNf202wN9cQAAAAAcGUEnwjmddSHH7w80/wQAAABwZDQMjXAul+TxBEZyHA4agAIAAADNQdCJAi4XAQcAAAAIBVPXAAAAAFgOQQcAAACA5RB0AAAAAFgOQQcAAACA5RB02olhSNnZNPwEAAAA2gNBpx0YhuR2SwUFgWfCDgAAANC2CDrtwOuta/hptwd64gAAAABoOwSdduB01oUcvz/Q+BMAAABA26FhaDtwuSSPJzCS43DQ/BMAAABoawSdduJyEXAAAACA9sLUNQAAAACWQ9ABAAAAYDktCjqLFi1Senq6EhMTNXLkSK1bt67JfVeuXKnhw4erW7duOu644zR06FA9++yzLS4YAAAAAI4m5KCzYsUK5eTkKDc3Vxs2bNCQIUOUmZmpPXv2NLp/9+7ddeedd6q4uFj/+te/NHnyZE2ePFlvvPHGMRcPAAAAAI2xmaZphnLAyJEjdfbZZ2vhwoWSpJqaGqWlpemWW27RzJkzm3WOs846S2PGjNE999zTrP0rKiqUnJwsn8+npKSkUMptdYYR6IvjdLK4AAAAANDempsNQhrRqa6u1vr165WRkVF3gpgYZWRkqLi4+KjHm6apwsJClZSU6IILLmhyv6qqKlVUVNR7RALDkNxuqaAg8GwY4a4IAAAAQGNCCjr79u2T3+9XSkpKve0pKSkqKytr8jifz6cuXbooPj5eY8aMUUFBgS6++OIm98/Ly1NycnLwkZaWFkqZbcbrrWv6abcH+uIAAAAAiDztsupa165dtXHjRn344YeaP3++cnJyVHSElDBr1iz5fL7gY9euXe1R5lE5nXUhx+8PNP8EAAAAEHlCahjas2dP2e12lZeX19teXl6u3r17N3lcTEyMTjzxREnS0KFDtWnTJuXl5cnRRFJISEhQQkJCKKW1C5dL8ngCIzkOB/foAAAAAJEqpBGd+Ph4DRs2TIWFhcFtNTU1Kiws1KhRo5p9npqaGlVVVYXy0hHD5ZIWLCDkAAAAAJEspBEdScrJyVFWVpaGDx+uESNGKD8/X5WVlZo8ebIkaeLEierbt6/y8vIkBe63GT58uAYOHKiqqiq9/vrrevbZZ/X444+37jsBAAAAgP9fyEFn/Pjx2rt3r+bMmaOysjINHTpUq1evDi5QsHPnTsXE1A0UVVZW6qabbtJXX32lTp066ZRTTtFzzz2n8ePHt967AAAAAIAfCbmPTjhEUh8dAAAAAOHTJn10AAAAACAaEHQAAAAAWA5BBwAAAIDlEHQAAAAAWA5BBwAAAIDlEHQAAAAAWA5BBwAAAIDlEHQAAAAAWA5BBwAAAIDlEHQAAAAAWA5BBwAAAIDlEHQAAAAAWA5BBwAAAIDlEHQAAAAAWA5BBwAAAIDlEHQAAAAAWE5suAtoDtM0JUkVFRVhrgQAAABAONVmgtqM0JSoCDoHDhyQJKWlpYW5EgAAAACR4MCBA0pOTm7y8zbzaFEoAtTU1Ojrr79W165dZbPZwlpLRUWF0tLStGvXLiUlJYW1FkQfrh8cC64ftBTXDo4F1w+ORVtcP6Zp6sCBA+rTp49iYpq+EycqRnRiYmLUr1+/cJdRT1JSEt/saDGuHxwLrh+0FNcOjgXXD45Fa18/RxrJqcViBAAAAAAsh6ADAAAAwHIIOiFKSEhQbm6uEhISwl0KohDXD44F1w9aimsHx4LrB8cinNdPVCxGAAAAAAChYEQHAAAAgOUQdAAAAABYDkEHAAAAgOUQdAAAAABYDkEHAAAAgOUQdBqxaNEipaenKzExUSNHjtS6deuOuP9f/vIXnXLKKUpMTNTgwYP1+uuvt1OliEShXD+LFy/W+eefr5/97Gf62c9+poyMjKNeb7CuUP/fU2v58uWy2WwaN25c2xaIiBbq9fPtt99q2rRpSk1NVUJCgk4++WR+fnVgoV4/+fn5GjRokDp16qS0tDRlZ2fr4MGD7VQtIsU777yjsWPHqk+fPrLZbHr11VePekxRUZHOOussJSQk6MQTT9SyZcvarD6Czk+sWLFCOTk5ys3N1YYNGzRkyBBlZmZqz549je7//vvv6+qrr9Z1112njz76SOPGjdO4ceP06aeftnPliAShXj9FRUW6+uqr5fV6VVxcrLS0NF1yySUqLS1t58oRbqFeO7W2b9+u22+/Xeeff347VYpIFOr1U11drYsvvljbt2/XSy+9pJKSEi1evFh9+/Zt58oRCUK9fp5//nnNnDlTubm52rRpk5YsWaIVK1bojjvuaOfKEW6VlZUaMmSIFi1a1Kz9t23bpjFjxsjpdGrjxo36/e9/r+uvv15vvPFG2xRoop4RI0aY06ZNC37s9/vNPn36mHl5eY3uf+WVV5pjxoypt23kyJHm//t//69N60RkCvX6+anDhw+bXbt2NZ9++um2KhERqiXXzuHDh81zzjnH/L//+z8zKyvLdLvd7VApIlGo18/jjz9unnDCCWZ1dXV7lYgIFur1M23aNPPCCy+sty0nJ8c899xz27RORDZJ5iuvvHLEfWbMmGH+4he/qLdt/PjxZmZmZpvUxIjOj1RXV2v9+vXKyMgIbouJiVFGRoaKi4sbPaa4uLje/pKUmZnZ5P6wrpZcPz/1/fff69ChQ+revXtblYkI1NJr5+6771avXr103XXXtUeZiFAtuX4Mw9CoUaM0bdo0paSk6PTTT9e9994rv9/fXmUjQrTk+jnnnHO0fv364PS2rVu36vXXX9ell17aLjUjerX3782xbXLWKLVv3z75/X6lpKTU256SkqLNmzc3ekxZWVmj+5eVlbVZnYhMLbl+fuqPf/yj+vTp0+B/ArC2llw77777rpYsWaKNGze2Q4WIZC25frZu3aq3335b//3f/63XX39dW7Zs0U033aRDhw4pNze3PcpGhGjJ9XPNNddo3759Ou+882Sapg4fPqypU6cydQ1H1dTvzRUVFfrhhx/UqVOnVn09RnSACHHfffdp+fLleuWVV5SYmBjuchDBDhw4oAkTJmjx4sXq2bNnuMtBFKqpqVGvXr30v//7vxo2bJjGjx+vO++8U0888US4S0MUKCoq0r333qvHHntMGzZs0MqVK7Vq1Srdc8894S4NqIcRnR/p2bOn7Ha7ysvL620vLy9X7969Gz2md+/eIe0P62rJ9VPrwQcf1H333ac1a9bojDPOaMsyEYFCvXa+/PJLbd++XWPHjg1uq6mpkSTFxsaqpKREAwcObNuiETFa8v+e1NRUxcXFyW63B7edeuqpKisrU3V1teLj49u0ZkSOllw/s2fP1oQJE3T99ddLkgYPHqzKykrdcMMNuvPOOxUTw9/R0bimfm9OSkpq9dEciRGdeuLj4zVs2DAVFhYGt9XU1KiwsFCjRo1q9JhRo0bV21+S3nrrrSb3h3W15PqRpD/96U+65557tHr1ag0fPrw9SkWECfXaOeWUU/TJJ59o48aNwYfL5QquYpOWltae5SPMWvL/nnPPPVdbtmwJBmRJ+uKLL5SamkrI6WBacv18//33DcJMbWgO3JMONK7df29ukyUOotjy5cvNhIQEc9myZebnn39u3nDDDWa3bt3MsrIy0zRNc8KECebMmTOD+7/33ntmbGys+eCDD5qbNm0yc3Nzzbi4OPOTTz4J11tAGIV6/dx3331mfHy8+dJLL5m7d+8OPg4cOBCut4AwCfXa+SlWXevYQr1+du7caXbt2tW8+eabzZKSEvO1114ze/XqZf7P//xPuN4CwijU6yc3N9fs2rWr+cILL5hbt24133zzTXPgwIHmlVdeGa63gDA5cOCA+dFHH5kfffSRKclcsGCB+dFHH5k7duwwTdM0Z86caU6YMCG4/9atW83OnTubf/jDH8xNmzaZixYtMu12u7l69eo2qY+g04iCggLz5z//uRkfH2+OGDHC/OCDD4KfGz16tJmVlVVv/xdffNE8+eSTzfj4ePMXv/iFuWrVqnauGJEklOunf//+pqQGj9zc3PYvHGEX6v97foygg1Cvn/fff98cOXKkmZCQYJ5wwgnm/PnzzcOHD7dz1YgUoVw/hw4dMufOnWsOHDjQTExMNNPS0sybbrrJ3L9/f/sXjrDyer2N/h5Te71kZWWZo0ePbnDM0KFDzfj4ePOEE04wn3rqqTarz2aajDECAAAAsBbu0QEAAABgOQQdAAAAAJZD0AEAAABgOQQdAAAAAJZD0AEAAABgOQQdAAAAAJZD0AEAAABgOQQdAAAAAJZD0AEAAABgOQQdAAAAAJZD0AEAAABgOf8f2Jzj1ZAxxOsAAAAASUVORK5CYII=",
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_predictions(predictions=y_preds)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "-8uNtngudXuv"
      },
      "outputs": [],
      "source": [
        "loss_fn = nn.L1Loss()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "7oAJ7clrS7h_"
      },
      "outputs": [],
      "source": [
        "optimizer = torch.optim.SGD(params = model_0.parameters(),lr = 0.01)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "BHbmR_3KsDJ9",
        "outputId": "74a6897f-68aa-4869-d76a-f2b47a025a35"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epoch: 0 | Loss: 0.31288\n",
            "Epoch: 100 | Loss: 0.02446\n",
            "Epoch: 200 | Loss: 0.00893\n",
            "Epoch: 300 | Loss: 0.00893\n",
            "Epoch: 400 | Loss: 0.00893\n",
            "Epoch: 500 | Loss: 0.00893\n",
            "Epoch: 600 | Loss: 0.00893\n",
            "Epoch: 700 | Loss: 0.00893\n",
            "Epoch: 800 | Loss: 0.00893\n",
            "Epoch: 900 | Loss: 0.00893\n"
          ]
        }
      ],
      "source": [
        "torch.manual_seed(42)\n",
        "epochs = 1000\n",
        "for i in range(epochs):\n",
        "  model_0.train() # Put the model in training mode , all the things required for training are set when this is mentioned\n",
        "  y_pred = model_0(X_train) # the forward method in which it is there that how the predictions will be made in model_0 object which is derived from class LinearRegression which has def forward pass fucntion\n",
        "  loss = loss_fn(y_pred,y_train) # The loss is calculated between predicted and actual on training dataset.\n",
        "  optimizer.zero_grad()\n",
        "  loss.backward() # Backpropagation and gradient descent is applied\n",
        "  optimizer.step() # weights and biases gets updated in optimizer , optimizers contain the parameters by the help of which y_preds are calculated\n",
        "  if i % 100 == 0:\n",
        "    print(f\"Epoch: {i} | Loss: {loss:.5f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dZwOK7fdvT3e",
        "outputId": "14cb3fd0-f208-4b6d-bf45-a4be29d2ce58"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Test loss: 0.00845\n"
          ]
        }
      ],
      "source": [
        "# Testing loop\n",
        "model_0.eval()\n",
        "\n",
        "with torch.inference_mode():\n",
        "  y_preds = model_0(X_test)\n",
        "  test_loss = loss_fn(y_preds,y_test)\n",
        "\n",
        "print(f\"Test loss: {test_loss:.5f}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jgU1zXGkxGMr",
        "outputId": "52262555-fd9a-4fd1-a6af-a7e9a1479240"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model_0.state_dict()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "pBh0kbfZxW19",
        "outputId": "e0976094-e9d6-489f-ac37-b78e6e9ab457"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_predictions(predictions=y_preds)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "7k4ILya8yCNP"
      },
      "outputs": [],
      "source": [
        "# Write a full program for a linear regression dataset"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "id": "S_IGuR8FVTgP"
      },
      "outputs": [],
      "source": [
        "W = 2\n",
        "b = 3\n",
        "X = torch.rand(100,1)\n",
        "X = X.squeeze()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "id": "b2yweCOqVqhC"
      },
      "outputs": [],
      "source": [
        "Y = W*X + b"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "YaWKSUEMVr0O"
      },
      "outputs": [],
      "source": [
        "X_train = X[:int(0.8*(X.shape[0]))]\n",
        "Y_train = Y[:int(0.8*(X.shape[0]))]\n",
        "X_test = X[int(0.8*(X.shape[0])):]\n",
        "Y_test = Y[int(0.8*(X.shape[0])):]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IkpnPke-WDKo",
        "outputId": "5d87617d-a6d0-402c-ad08-bd3074a4728c"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "LinearRegressionModel()"
            ]
          },
          "execution_count": 23,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model_1 = LinearRegressionModel()\n",
        "model_1"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "Aks66QvEY_qL"
      },
      "outputs": [],
      "source": [
        "loss_fn_1 = nn.L1Loss()\n",
        "optimizer_1 = torch.optim.SGD(params = model_1.parameters(),lr=0.01)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yu1EJoojW-D7",
        "outputId": "f5b77c75-2123-49c9-ccf7-abb6558dbbbd"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Epochs : 0 , Training Loss : 5.308438301086426 , Testing Loss : 5.116696357727051\n",
            "Epochs : 100 , Training Loss : 4.025923728942871 , Testing Loss : 3.8758842945098877\n",
            "Epochs : 200 , Training Loss : 2.743410587310791 , Testing Loss : 2.6350719928741455\n",
            "Epochs : 300 , Training Loss : 1.4608981609344482 , Testing Loss : 1.3942608833312988\n",
            "Epochs : 400 , Training Loss : 0.17838585376739502 , Testing Loss : 0.15345001220703125\n"
          ]
        }
      ],
      "source": [
        "# Training Loop\n",
        "epochs = 401\n",
        "for i in range(epochs):\n",
        "  model_1.train()\n",
        "  y_pred = model_1(X_train)\n",
        "  loss = loss_fn_1(y_pred,Y_train)\n",
        "  optimizer_1.zero_grad()\n",
        "  loss.backward()\n",
        "  optimizer_1.step()\n",
        "  # Evaluation on test set\n",
        "  with torch.inference_mode():\n",
        "    y_test_pred = model_1(X_test)\n",
        "    test_loss = loss_fn_1(y_test_pred,Y_test)\n",
        "    if i % 100 == 0:\n",
        "      print(f\"Epochs : {i} , Training Loss : {loss} , Testing Loss : {test_loss}\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "id": "7jBsyy7oYKaj"
      },
      "outputs": [],
      "source": [
        "def plot_predictions_1(train_data=X_train,\n",
        "                     train_labels=Y_train,\n",
        "                     test_data=X_test,\n",
        "                     test_labels=Y_test,\n",
        "                     predictions=None):\n",
        "  \"\"\"\n",
        "  Plots training data, test data and compares predictions.\n",
        "  \"\"\"\n",
        "  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",
        "  if predictions is not None:\n",
        "    # Plot the predictions in red (predictions were made on the test data)\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": 27,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 599
        },
        "id": "dwJLlMlrbiUf",
        "outputId": "a4447a82-c196-46c8-9706-787591944be4"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1000x700 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plot_predictions_1(predictions=y_test_pred)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gBpE-0qegAf6",
        "outputId": "4473f00c-507d-45f8-8472-f5670f959b86"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([1.8456])), ('bias', tensor([2.9165]))])"
            ]
          },
          "execution_count": 28,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model_1.state_dict()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "id": "Y2mCMkEegGwS"
      },
      "outputs": [],
      "source": [
        "# Loading and Saving the model"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "H-2xofOLk7RT"
      },
      "source": [
        "The pickle module in Python is a tool for turning Python objects—like lists, dictionaries, custom classes, and more—into a stream of bytes that can be saved to a file. This process is often called \"serialization\" or \"pickling.\" When you pickle an object, you convert it into a format that can be written to a file, which allows you to save the state of the object on your disk.\n",
        "\n",
        "Here's a bit more detail on the two main functions of the pickle module:\n",
        "\n",
        "Pickling: This is the process of converting a Python object into a byte stream. This byte stream can then be stored in a file or sent over a network to another system. When you pickle an object, you preserve its current state, including its values and the relationships between different objects.\n",
        "\n",
        "Unpickling: This is the reverse process, where the byte stream (from a pickle file) is converted back into a Python object. This is like restoring the object's state from the file, bringing it back into your program exactly as it was when it was pickled.\n",
        "\n",
        "The process of pickling and unpickling allows you to save complex data structures easily, pause a program and resume it later, or send Python objects between different programs or machines running Python.\n",
        "\n",
        "However, it's important to be cautious with pickle files from untrusted sources, as unpickling can execute arbitrary code and potentially harm your system."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "skZoObBmlF2P"
      },
      "source": [
        "A byte stream in the context of the pickle module refers to a sequence of bytes, which is essentially a way of storing data that computers can understand and process. In computing, a byte is a unit of digital information that commonly consists of eight bits. A bit is the smallest unit of data in a computer and can have a value of either 0 or 1. So, a byte, consisting of eight bits, can represent a wide range of data.\n",
        "\n",
        "When we talk about a byte stream in relation to pickling in Python, it means that the Python objects (like lists, dictionaries, functions, classes, etc.) are converted into a sequence of bytes. This conversion facilitates various operations, such as:\n",
        "\n",
        "Saving to a file: The byte stream can be written directly to a file on your disk. This file can then be opened later, and the byte stream can be read and converted back into Python objects.\n",
        "\n",
        "Transmitting over a network: The byte stream can also be sent over a network. This is useful in client-server programming when you want to send complex objects from a server to a client or vice versa.\n",
        "\n",
        "This byte stream encapsulates all the necessary information to reconstruct the original Python object, including its type, value, and the relationships it holds with other objects. Thus, when the byte stream is read (or \"unpickled\"), it recreates the original object with all its properties intact in the Python environment."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ih1lTYtsqP-O"
      },
      "source": [
        "**Why state_dict method is reccommended over .save() and .load() method to save and load the models**?\n",
        "This save/load process uses the most intuitive syntax and involves the least amount of code. Saving a model in this way will save the entire module using Python’s pickle module. The disadvantage of this approach is that the serialized data is bound to the specific classes and the exact directory structure used when the model is saved. The reason for this is because pickle does not save the model class itself. Rather, it saves a path to the file containing the class, which is used during load time. Because of this, your code can break in various ways when used in other projects or after refactors."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 45,
      "metadata": {
        "id": "kBbZ4RBPL1Cw"
      },
      "outputs": [],
      "source": [
        "# METHOD 1 (Recommended)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "id": "4o2x0pG2qgBe"
      },
      "outputs": [],
      "source": [
        "from pathlib import Path\n",
        "MODEL_PATH = Path(\"models\")\n",
        "MODEL_PATH.mkdir(parents=True,exist_ok=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "id": "EAcRdrO6G5MO"
      },
      "outputs": [],
      "source": [
        "MODEL_NAME = \"Pytorch_Workfllow_model_1.pth\""
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "id": "iSDnpUwVHlLu"
      },
      "outputs": [],
      "source": [
        "MODEL_SAVE_PATH = MODEL_PATH / MODEL_NAME"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 34,
      "metadata": {
        "id": "qxcSbXZRH-fi"
      },
      "outputs": [],
      "source": [
        "torch.save(model_1.state_dict(),MODEL_SAVE_PATH)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 35,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "wKVnY5wkIpW8",
        "outputId": "1a81a3a3-1dc7-4abb-fbaf-16a436a409bb"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "<All keys matched successfully>"
            ]
          },
          "execution_count": 35,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model_1_loaded = LinearRegressionModel()\n",
        "model_1_loaded.load_state_dict(torch.load(MODEL_SAVE_PATH))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {
        "id": "fvsWiXROL4_S"
      },
      "outputs": [],
      "source": [
        "# METHOD 2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 41,
      "metadata": {
        "id": "lcE1Q7FwKUzb"
      },
      "outputs": [],
      "source": [
        "MODEL_NAME_0 = \"Pytorch_Workfllow_model_0.pth\"\n",
        "MODEL_SAVE_PATH_0 = MODEL_PATH / MODEL_NAME_0\n",
        "torch.save(model_0,MODEL_SAVE_PATH_0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {
        "id": "Bvnl3EEXKWmw"
      },
      "outputs": [],
      "source": [
        "model_0_loaded = LinearRegressionModel()\n",
        "model_0_loaded = torch.load(MODEL_SAVE_PATH_0)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "eq1c5QM6Lt85",
        "outputId": "f9a32d09-9117-4558-8313-01bc83484c67"
      },
      "outputs": [
        {
          "data": {
            "text/plain": [
              "OrderedDict([('weights', tensor([0.6990])), ('bias', tensor([0.3093]))])"
            ]
          },
          "execution_count": 43,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "model_0_loaded.state_dict()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "etxtLQPmV5Eu"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}