Saddle_Point_in_ML_and_DL.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "V28",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "TPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/dsinsight/Saddle-point-blog/blob/main/Saddle_Point_in_ML_and_DL.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "\n",
        "# Load CIFAR-10 dataset\n",
        "transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])\n",
        "trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=100, shuffle=True)\n",
        "\n",
        "# Define a simple neural network\n",
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.fc1 = nn.Linear(32*32*3, 128)\n",
        "        self.fc2 = nn.Linear(128, 10)\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = x.view(-1, 32*32*3)\n",
        "        x = torch.relu(self.fc1(x))\n",
        "        x = self.fc2(x)\n",
        "        return x\n",
        "\n",
        "# Initialize the model, loss function, and optimizer\n",
        "net = Net()\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)\n",
        "\n",
        "# Training loop\n",
        "for epoch in range(10):\n",
        "    running_loss = 0.0\n",
        "    for i, data in enumerate(trainloader, 0):\n",
        "        inputs, labels = data\n",
        "        optimizer.zero_grad()\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        running_loss += loss.item()\n",
        "    print(f'Epoch {epoch+1}, Loss: {running_loss / len(trainloader)}')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZYZhZharIvvV",
        "outputId": "cd8a43eb-8893-43c3-c80a-471bc578f171"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Downloading https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz to ./data/cifar-10-python.tar.gz\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "100%|██████████| 170498071/170498071 [00:04<00:00, 41434046.99it/s]\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Extracting ./data/cifar-10-python.tar.gz to ./data\n",
            "Epoch 1, Loss: 1.959870234489441\n",
            "Epoch 2, Loss: 1.7398568305969238\n",
            "Epoch 3, Loss: 1.6573762373924255\n",
            "Epoch 4, Loss: 1.603873552083969\n",
            "Epoch 5, Loss: 1.5639482862949372\n",
            "Epoch 6, Loss: 1.532483897447586\n",
            "Epoch 7, Loss: 1.5047956569194794\n",
            "Epoch 8, Loss: 1.4802627990245818\n",
            "Epoch 9, Loss: 1.4583385684490204\n",
            "Epoch 10, Loss: 1.4369648561477661\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Replacing SGD with Adam**\n",
        "\n",
        "**Import Necessary Libraries**\n",
        "\n",
        "First import the torch.optim module from the PyTorch library, which contains various optimization algorithms for training neural networks.\n",
        "\n",
        "**Replace SGD with Adam Optimizer**\n",
        "\n",
        "**Purpose:** After importing libraries we initializes an Adam optimizer for the neural network model represented by net.\n",
        "\n",
        "**Parameters:**\n",
        "- **net.parameters():** Retrieves the parameters of the model that will be updated during training.\n",
        "- **lr=0.001:** Sets the learning rate to 0.001, which controls how much to change the model parameters during training.\n",
        "\n",
        "**Training Loop with Adam Optimizer**\n",
        "\n",
        "**Breakdown of the Training Loop**\n",
        "\n",
        "- **Outer Loop:** Iterates through a specified number of epochs (10 in this case).\n",
        "- **Inner Loop:** Iterates through batches of data provided by trainloader.\n",
        "  - **inputs, labels = data:** Unpacks the input features and corresponding labels from the data.\n",
        "  - **optimizer.zero_grad():** Clears the old gradients, which is necessary for the optimizer to avoid accumulating gradients from previous iterations.\n",
        "  - **outputs = net(inputs):** Passes the input data through the model to get the predicted outputs.\n",
        "  - **loss = criterion(outputs, labels):** Computes the loss using a defined loss function (criterion), which compares the predicted outputs with the true labels.\n",
        "  - **loss.backward():** Computes the gradients of the loss with respect to the model parameters.\n",
        "  - **optimizer.step():** Updates the model parameters using the calculated gradients.\n",
        "  - **running_loss += loss.item():** Accumulates the loss for the current epoch.\n",
        "  - **Print Statement:** At the end of each epoch, it prints the average loss over the training data for that epoch."
      ],
      "metadata": {
        "id": "Ab0ka3d3T8F8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Import necessary libraries\n",
        "import torch.optim as optim\n",
        "\n",
        "# Replace SGD with Adam optimizer\n",
        "optimizer = optim.Adam(net.parameters(), lr=0.001)  # Use the Adam optimizer\n",
        "\n",
        "# Training loop with Adam optimizer\n",
        "for epoch in range(10):\n",
        "    running_loss = 0.0\n",
        "    for i, data in enumerate(trainloader, 0):\n",
        "        inputs, labels = data\n",
        "        optimizer.zero_grad()\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        running_loss += loss.item()\n",
        "    print(f'Epoch {epoch+1}, Loss: {running_loss / len(trainloader)}')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OeBQXZhVLWsI",
        "outputId": "16a0b8da-82a6-4f89-8557-7d6cee58b6c5"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1, Loss: 1.5803176786899567\n",
            "Epoch 2, Loss: 1.4186463229656219\n",
            "Epoch 3, Loss: 1.3404061582088471\n",
            "Epoch 4, Loss: 1.2757435414791107\n",
            "Epoch 5, Loss: 1.2364657318592072\n",
            "Epoch 6, Loss: 1.197357409119606\n",
            "Epoch 7, Loss: 1.1652598834037782\n",
            "Epoch 8, Loss: 1.1321693431138993\n",
            "Epoch 9, Loss: 1.098507237792015\n",
            "Epoch 10, Loss: 1.0664558881521224\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Using SGD with Momentum**\n",
        "\n",
        "**Optimizer Initialization:**\n",
        "\n",
        "  - **optim.SGD:** This initializes an SGD optimizer from the PyTorch library, designed to optimize the parameters of the net (the neural network).\n",
        "  - **net.parameters():** This retrieves the parameters (weights and biases) of the network to be updated during training.\n",
        "lr=0.001: Sets the learning rate to 0.001, determining the step size for each update during optimization.\n",
        "  - **momentum=0.9:** Momentum is a technique that helps accelerate SGD in the relevant direction and dampens oscillations. A momentum of 0.9 means that 90% of the previous update's velocity will be retained.\n",
        "\n",
        "**Training Loop:**\n",
        "\n",
        "  - **for epoch in range(10):** This outer loop runs for 10 epochs, indicating that the entire dataset will be passed through the network 10 times.\n",
        "  - **running_loss = 0.0:** Initializes a variable to keep track of the cumulative loss for the epoch.\n",
        "  - **for i, data in enumerate(trainloader, 0):** This inner loop iterates over the training data provided by trainloader. Each batch of data consists of inputs (the features) and labels (the target outputs).\n",
        "  - **optimizer.zero_grad():** Resets the gradients of all optimized parameters before the backward pass.\n",
        "  - **outputs = net(inputs):** Passes the input batch through the network to get predictions.\n",
        "  - **loss = criterion(outputs, labels):** Computes the loss (or error) between the predicted outputs and the true labels using a specified loss function (criterion).\n",
        "  - **loss.backward():** Computes the gradient of the loss with respect to the parameters (weights) by backpropagation.\n",
        "  - **optimizer.step():** Updates the network parameters based on the computed gradients and the optimizer's strategy (including momentum).\n",
        "  - **running_loss += loss.item():** Accumulates the loss for the current epoch.\n",
        "\n",
        "**Loss Printing:**\n",
        "\n",
        "  - **print(f'Epoch {epoch+1}, Loss: {running_loss / len(trainloader)}'):** At the end of each epoch, the average loss for that epoch is printed. This helps monitor the training process.\n"
      ],
      "metadata": {
        "id": "lQHkGqBFV6zm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Using SGD with momentum\n",
        "optimizer = optim.SGD(net.parameters(), lr=0.001, momentum=0.9)\n",
        "\n",
        "# Training loop with momentum\n",
        "for epoch in range(10):\n",
        "    running_loss = 0.0\n",
        "    for i, data in enumerate(trainloader, 0):\n",
        "        inputs, labels = data\n",
        "        optimizer.zero_grad()\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        running_loss += loss.item()\n",
        "    print(f'Epoch {epoch+1}, Loss: {running_loss / len(trainloader)}')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KmgRdV-GMIJj",
        "outputId": "08ed55d3-885a-44db-fa8b-746e5ffe07fc"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1, Loss: 0.922934067606926\n",
            "Epoch 2, Loss: 0.887342477440834\n",
            "Epoch 3, Loss: 0.871238625049591\n",
            "Epoch 4, Loss: 0.8599994453191757\n",
            "Epoch 5, Loss: 0.8526569473743438\n",
            "Epoch 6, Loss: 0.8446825994253159\n",
            "Epoch 7, Loss: 0.839031252861023\n",
            "Epoch 8, Loss: 0.8340681928396225\n",
            "Epoch 9, Loss: 0.8287115931510926\n",
            "Epoch 10, Loss: 0.8242433732748031\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Visualizing Before and After Effects of Saddle Point Optimization**\n",
        "\n",
        "## **Before (Using Original SGD without Momentum)**\n",
        "\n",
        "### Explanation of the Code:\n",
        "\n",
        "**Importing Libraries**: First import `matplotlib.pyplot`, a Python library used for plotting graphs and visualizing data.\n",
        "\n",
        "**SGD Optimization Loop**: The code captures the average loss during each training epoch using Stochastic Gradient Descent (SGD) without momentum.\n",
        "   \n",
        "  - **Initialization**:\n",
        "   - **`losses_sgd`:** An empty list to store the average loss for each epoch.\n",
        "    - **`optimizer`:** Initializes the SGD optimizer with a learning rate (`lr`) of 0.001, and optimizes the parameters of a neural network model (`net.parameters()`).\n",
        "\n",
        "  - **Training Loop**:\n",
        "     \n",
        "    - The training loop runs for 10 epochs, where each epoch involves iterating over a `trainloader` (data loader for mini-batch training).\n",
        "    - For each batch:\n",
        "      - The optimizer gradient is reset (`optimizer.zero_grad()`).\n",
        "      - The network (`net`) processes the inputs to generate predictions (`outputs = net(inputs)`).\n",
        "      - A loss value is calculated between predictions and actual labels using a predefined loss function (`criterion(outputs, labels)`).\n",
        "      - Backpropagation is performed to compute gradients (`loss.backward()`), and the optimizer updates the model parameters (`optimizer.step()`).\n",
        "      - `running_loss` accumulates the total loss for the current epoch.\n",
        "      - After processing all mini-batches, the average loss for the epoch (`avg_loss`) is calculated by dividing `running_loss` by the number of batches (`len(trainloader)`). This average loss is added to `losses_sgd`.\n",
        "\n",
        "**Plotting Loss**:\n",
        "\n",
        "  - After training, the average loss per epoch (`losses_sgd`) is plotted against the number of epochs (1 to 10).\n",
        "  - The graph shows how the loss decreases over time during training with SGD.\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "eLxnzxqldij8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Original SGD without momentum, capturing loss\n",
        "losses_sgd = []\n",
        "optimizer = optim.SGD(net.parameters(), lr=0.001)\n",
        "\n",
        "for epoch in range(10):\n",
        "    running_loss = 0.0\n",
        "    for i, data in enumerate(trainloader, 0):\n",
        "        inputs, labels = data\n",
        "        optimizer.zero_grad()\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        running_loss += loss.item()\n",
        "    avg_loss = running_loss / len(trainloader)\n",
        "    losses_sgd.append(avg_loss)\n",
        "    print(f'Epoch {epoch+1}, Loss: {avg_loss}')\n",
        "\n",
        "# Plot loss for SGD\n",
        "plt.plot(range(1, 11), losses_sgd, label='SGD')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Loss Before Optimization (SGD)')\n",
        "plt.legend()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 651
        },
        "id": "Yle4KrPNNEx3",
        "outputId": "bbb3a416-6920-4c72-96d1-eb52252db717"
      },
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1, Loss: 0.8071446799039841\n",
            "Epoch 2, Loss: 0.8053289699554443\n",
            "Epoch 3, Loss: 0.8045670039653778\n",
            "Epoch 4, Loss: 0.8039614186286926\n",
            "Epoch 5, Loss: 0.8034007558822632\n",
            "Epoch 6, Loss: 0.8029953508973121\n",
            "Epoch 7, Loss: 0.8026332204341888\n",
            "Epoch 8, Loss: 0.8021223082542419\n",
            "Epoch 9, Loss: 0.8018776448965073\n",
            "Epoch 10, Loss: 0.8013610126972198\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkgAAAHHCAYAAABEEKc/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABlNElEQVR4nO3deViUVf8G8Htm2HeVXVEQF8QFVxBcwBXNSMteM03N3LdSy35abmlKWSlvuWWp5ZZamlpuueEGioK7uLAICLKJgIBsM+f3Bzpvg6iAjA/L/bmuua545pkz32eYmNtzzpwjE0IIEBEREZGaXOoCiIiIiCobBiQiIiKiYhiQiIiIiIphQCIiIiIqhgGJiIiIqBgGJCIiIqJiGJCIiIiIimFAIiIiIiqGAYmIiIioGAYkItJQWFiITz/9FA4ODpDL5RgwYIDUJUnK0dER77//foW2KZPJMH/+/AptszI/7xMTJ05Er169JHv+FykoKICDgwNWrlwpdSlUCTAgERXzyy+/QCaT4fz581KX8lzz58+HTCZT3+RyOezs7PD666/jzJkz5W533bp1+Oabb/D222/j119/xbRp0yqw6pdTUFCA77//Hh06dICpqSlMTEzQoUMHfP/99ygoKCh3u0FBQZg/fz7S09MrrliJ7Nu3T9IQ9CzR0dH4+eef8dlnn2kcT0lJwUcffQQXFxcYGhrC2toa7u7u+L//+z9kZWU91c7JkycxaNAg1K1bF3p6ejA3N4eHhwcWLFiApKQkjXN9fHw0/v8wMzND06ZNMWzYMBw6dOiptnV1dTF9+nQsWrQIubm5FfsCUJUj415sRJp++eUXjBw5EufOnUP79u2lLueZ5s+fjy+++AKrVq2CiYkJVCoV4uLi8NNPPyEhIQEhISFo3bp1mdsdPHgwTp06hbt371Z80S8hOzsb/fr1w/Hjx/H666+jT58+kMvlOHDgAPbs2QNvb2/s3bsXxsbGZW7722+/xYwZMxAdHQ1HR0eN+/Ly8iCXy6Grq1tBVwLk5uZCR0cHOjo6FdbmE5MnT8aKFStQ0p92bT7vi0ydOhX79+/HzZs31cfS0tLQpk0bZGZm4oMPPoCLiwvu37+Py5cv4++//8bly5c1fh9z587FwoUL0bBhQwwePBgNGzZEbm4uQkNDsWPHDlhaWiIyMlJ9vo+PDyIjI+Hv7w+g6D0UERGBnTt3IioqCoMGDcKmTZs0frfp6emwsbHBqlWr8MEHH2j/haHKSxCRhvXr1wsA4ty5c1KX8lzz5s0TAERKSorG8atXrwoA4rPPPitXu926dRPNmzeviBKFEEIolUrx6NGjl25n7NixAoD44Ycfnrpv+fLlAoAYP358udr+5ptvBAARHR39klVKb9KkSaKy/WnPz88XlpaWYvbs2RrHlyxZIgCI06dPP/WYjIwMjffN1q1bBQAxaNAgkZeX99T56enpYt68eRrHvL29S3wvFxYWiokTJwoA4tNPP33q/tdff1106dKltJdH1VTl+r+IqBIobUAKCwsTffr0EaampsLY2Fh0795dBAcHa5yTn58v5s+fLxo1aiT09fVF7dq1RadOncQ///yjPufevXvi/fffF3Xr1hV6enrC1tZWvPHGGy/8sH5WQEpNTRUAxNy5czWO5+bmirlz5wpnZ2ehp6cn6tWrJ2bMmCFyc3OFEEJER0cLAE/djh07JoQQIisrS0yfPl3Uq1dP6OnpiSZNmohvvvlGqFQqjecBICZNmiQ2bdokXF1dhY6Ojvjzzz+FEELcvXtXjBw5UlhbWws9PT3h6uoq1q5d+9zrFEKIuLg4oVAoRPfu3Z95Trdu3YSOjo6Ii4srsZYmTZoIfX190bZtW3H8+PGnXsfityevf4MGDcSIESPU5z95f5w8eVJMmTJFWFpaCnNzczF27FiRl5cnHjx4IIYNGyYsLCyEhYWFmDFjRomv0ZMP82e97k9uT5w4cUK8/fbbwsHBQf37mzp1qsjJyVGfM2LEiOe28e/nfaI07+Mn13zq1Ckxbdo0YWlpKYyMjMSAAQNEcnLyM38nTxw9elQAEIGBgRrHx40bJxQKhVAqlS9so0mTJsLS0lI8fPjwhec+8ayAJERRSHJ1dRVGRkYiPT1d477//ve/QiaTifv375f6uaj6efX9rETVwLVr19ClSxeYmZnh008/ha6uLn788Uf4+Pjg+PHj8PDwAFA0DObv74/Ro0fD3d0dmZmZOH/+PMLCwtSTVQcOHIhr165hypQpcHR0RHJyMg4dOoTY2NinhntKkpaWBgBQqVSIj4/HwoULYWBggEGDBqnPUalUeOONN3Dq1CmMHTsWzZo1w5UrV7Bs2TLcunULu3btgpWVFTZu3IhFixYhKytLPSzRrFkzCCHwxhtv4NixYxg1ahRat26NgwcPYsaMGYiPj8eyZcs0ajp69Ci2b9+OyZMnw9LSEo6OjkhKSkLHjh0hk8kwefJkWFlZYf/+/Rg1ahQyMzMxderUZ17j/v37oVQqMXz48GeeM3z4cBw7dgwHDhzA6NGj1cePHz+Obdu24cMPP4S+vj5WrlyJPn36ICQkBC1atMBbb72FW7du4bfffsOyZctgaWkJALCysnru6z5lyhTY2triiy++wJkzZ7BmzRpYWFggKCgI9evXx+LFi7Fv3z588803aNGixTNrf/K6/1tBQQGmTZsGPT099bHff/8dOTk5mDBhAurUqYOQkBD88MMPuHv3Ln7//XcAwLhx45CQkIBDhw491WZJSvs+/vc116pVC/PmzcOdO3cQEBCAyZMnY9u2bc99nqCgIMhkMrRp00bjeIMGDaBUKrFx40aMGDHimY+/desWbt26hdGjR8PExOSF11UaCoUC7777LubMmYNTp06hX79+6vvatWsHIQSCgoLw+uuvV8jzURUkdUIjqmxK04M0YMAAoaenJyIjI9XHEhIShKmpqejatav6mJubm+jXr98z23nw4IEAIL755psy1/msng8LCwtx4MABjXM3btwo5HK5OHnypMbx1atXPzXEUdK/unft2iUAiC+//FLj+Ntvvy1kMpmIiIhQHwMg5HK5uHbtmsa5o0aNEnZ2diI1NVXj+ODBg4W5ublGT0hxU6dOFQDEhQsXnnlOWFiYACCmT5+uUQsAcf78efWxmJgYYWBgIN588031secNsT2rB8nX11ejZ8jT01PIZDKNYb7CwkJRr1494e3trdEmSujJ+beJEycKhUIhjh49qj5W0uvj7+8vZDKZiImJUR973hBb8ect7fv4yTX37NlT45qnTZsmFArFUz0wxb333nuiTp06Tx1PTEwUVlZWAoBwcXER48ePF1u2bHmqvd27dwsAIiAgQOO4SqUSKSkpGreCggL1/c/rQRJCiD///FMAEP/97381jickJAgA4uuvv37udVH1xm+xEZWRUqnEP//8gwEDBqBhw4bq43Z2dhgyZAhOnTqFzMxMAICFhQWuXbuG27dvl9iWoaEh9PT0EBgYiAcPHpSrnh07duDQoUP4559/sH79ejRp0gQDBw5EUFCQ+pzff/8dzZo1g4uLC1JTU9W37t27AwCOHTv23OfYt28fFAoFPvzwQ43jH3/8MYQQ2L9/v8Zxb29vuLq6qn8WQmDHjh3w8/ODEEKjBl9fX2RkZCAsLOyZz//w4UMAgKmp6TPPeXLfk9f+CU9PT7Rr1079c/369dG/f38cPHgQSqXyudf9PKNGjYJMJlP/7OHhASEERo0apT6mUCjQvn17REVFlbrdDRs2YOXKlViyZAm6deumPm5oaKj+7+zsbKSmpsLLywtCCFy4cKHM9ZflffzE2LFjNa65S5cuUCqViImJee5z3b9/H7Vq1XrquI2NDS5duoTx48fjwYMHWL16NYYMGQJra2ssXLhQPdH8SR3Fe48yMjJgZWWlcbt48WKpX4Mn7T15fz3xpNbU1NRSt0XVDwMSURmlpKQgJycHTZs2feq+Zs2aqb9NBgALFixAeno6mjRpgpYtW2LGjBm4fPmy+nx9fX18/fXX2L9/P2xsbNC1a1csWbIEiYmJpa6na9eu6NmzJ3r16oX3338fR44cgampKaZMmaI+5/bt27h27dpTHyZNmjQBACQnJz/3OWJiYmBvb/9UQGnWrJn6/n9zcnLS+DklJQXp6elYs2bNUzWMHDnyhTU8ed7iH2T/9qwQ1bhx46fObdKkCXJycpCSkvLM9l6kfv36Gj+bm5sDABwcHJ46Xtrwe/HiRYwfPx7vvvsupk+frnFfbGws3n//fdSuXRsmJiawsrKCt7c3gKKgUFZleR8/UfyanwSJ0lzfk7BTnJ2dHVatWoV79+7h5s2b+P7772FlZYW5c+di7dq1AP73Oy3+tX8TExMcOnQIhw4dwowZM15YQ3FP2iv+nnlS67/DINU8nINEpEVdu3ZFZGQkdu/ejX/++Qc///wzli1bhtWrV6vnyUydOhV+fn7YtWsXDh48iDlz5sDf3x9Hjx59as5GaZiYmMDDwwO7d+9GdnY2jI2NoVKp0LJlSyxdurTExxT/UH9Z/+7tAIrmQAHAe++998y5Jq1atXpme0+C2OXLl5+5dMGT4PnvnittUigUpT7+rHDwbw8ePMDAgQPRpEkT/Pzzzxr3KZVK9OrVC2lpafi///s/uLi4wNjYGPHx8Xj//ffVr6+2PeuaX3R9derUeWGIkslkaNKkCZo0aYJ+/fqhcePG2Lx5M0aPHg0XFxcAwNWrVzUeo6Ojg549ewJAuZaleNJeo0aNNI4/qfXJfDSqmRiQiMrIysoKRkZGGuu5PHHjxg3I5XKNwFG7dm2MHDkSI0eORFZWFrp27Yr58+drTCR2dnbGxx9/jI8//hi3b99G69at8d1332HTpk3lqrGwsBBA0b+QjY2N4ezsjEuXLqFHjx7l+ldxgwYNcPjwYTx8+FDjX9s3btxQ3/88VlZWMDU1hVKpVH+glUXfvn2hUCiwcePGZ0523rBhA3R0dNCnTx+N4yUNb966dQtGRkbqidhS9xSoVCoMHToU6enpOHz4MIyMjDTuv3LlCm7duoVff/1V4/pLWuywtNdS1vfxy3BxccHmzZuRkZGh7ml7noYNG6JWrVq4d+8eAKBp06Zo3Lgxdu3ahYCAgHKtdVWcUqnEli1bYGRkhM6dO2vcFx0dDeB/wZxqJg6xEZWRQqFA7969sXv3bty5c0d9PCkpCVu2bEHnzp1hZmYGoGjuxb+ZmJigUaNGyMvLAwDk5OQ8tWKvs7MzTE1N1eeUVVpaGoKCgmBrawtra2sAwKBBgxAfH4+ffvrpqfMfPXqE7Ozs57b52muvQalUYvny5RrHly1bBplMhr59+z738QqFAgMHDsSOHTue6gUA8MKhLgcHB4wcORKHDx/GqlWrnrp/9erVOHr0KEaNGoV69epp3BccHKwxvykuLg67d+9G79691T0iTz5wpVpJ+4svvsDBgwfx22+/PTU8Cfyv5+bfPTVCCPz3v/996tzSXktZ3scvy9PTE0IIhIaGahw/e/Zsie+9kJAQ3L9/X2P4b/78+UhNTcWYMWNKXDW9NL10TyiVSnz44YcIDw/Hhx9++NR1hoaGQiaTwdPTs9RtUvXDHiSiZ1i3bh0OHDjw1PGPPvoIX375JQ4dOoTOnTtj4sSJ0NHRwY8//oi8vDwsWbJEfa6rqyt8fHzQrl071K5dG+fPn8cff/yByZMnAyjqyejRowcGDRoEV1dX6Ojo4M8//0RSUhIGDx5cqjr/+OMPmJiYQAiBhIQErF27Vj3h9UlvwrBhw7B9+3aMHz8ex44dQ6dOnaBUKnHjxg1s374dBw8efO6q4X5+fujWrRs+//xz3LlzB25ubvjnn3+we/duTJ06Fc7Ozi+s86uvvsKxY8fg4eGBMWPGwNXVFWlpaQgLC8Phw4fVyxU8y7Jly3Djxg1MnDgRBw4cUPcUHTx4ELt374a3tze+++67px7XokUL+Pr6anzNHygKJU88mcT9+eefY/DgwdDV1YWfn1+F9FS8yJUrV7Bw4UJ07doVycnJT/Uavvfee3BxcYGzszM++eQTxMfHw8zMDDt27Chx2OrJtXz44Yfw9fWFQqF45nuptO/jl9W5c2fUqVMHhw8fVn8xAAA2btyIzZs3480330S7du2gp6eH8PBwrFu3DgYGBhrbkgwZMgRXr16Fv78/QkJCMHjwYDg5OSE7OxtXr17Fb7/9BlNT06cmg2dkZKhf05ycHPVK2pGRkRg8eDAWLlz4VL2HDh1Cp06dUKdOnQp7DagKkuCbc0SV2pOvND/r9mQhwrCwMOHr6ytMTEyEkZGR6NatmwgKCtJo68svvxTu7u7CwsJCGBoaChcXF7Fo0SKRn58vhCha1HHSpEnCxcVFGBsbC3Nzc+Hh4SG2b9/+wjpL+pq/sbGx8PT0LPHx+fn54uuvvxbNmzcX+vr6olatWqJdu3biiy++EBkZGerznvXV6IcPH4pp06YJe3t7oaurKxo3bvzchSJLkpSUJCZNmiQcHByErq6usLW1FT169BBr1qx54fUKIUReXp5YtmyZaNeunTA2NhZGRkaibdu2IiAgQP2allTLpk2bROPGjYW+vr5o06aNevHLf1u4cKGoW7eukMvlpVoosvgyEM9auHPEiBHC2Nj4qbqefN3+2LFjpVoo8vr166Jnz57CxMREWFpaijFjxohLly4JAGL9+vXq8woLC8WUKVOElZWVkMlkpVoo8kXv42dd85PaS3o9i/vwww9Fo0aNNI5dvnxZzJgxQ7Rt21bUrl1b6OjoCDs7O/Gf//xHhIWFldhOYGCgePvtt4WdnZ3Q1dUVZmZmon379mLevHni3r17Gud6e3trvJYmJiaicePG4r333tNYrPXf0tPThZ6envj5559feE1UvXEvNiKqtmQyGSZNmvTU0CC9elFRUXBxccH+/fvRo0cPqct5poCAACxZsgSRkZFPfdmAahbOQSIiIq1r2LAhRo0aha+++krqUp6poKAAS5cuxezZsxmOiHOQiIjo1Shpgn1loquri9jYWKnLoEqCPUhERERExbAHiYiqLU6xJKLyYg8SERERUTEMSERERETFcIitnFQqFRISEmBqair5NgVERERUOkIIPHz4EPb29pDLn91PxIBUTgkJCRW+wScRERG9GnFxcU9tTfRvDEjl9GTDzri4uArbr4iIiIi0KzMzEw4ODhobb5eEAamcngyrmZmZMSARERFVMS+aHsNJ2kRERETFMCARERERFcOARERERFQM5yARERFVUiqVCvn5+VKXUaXo6upCoVC8dDsMSERERJVQfn4+oqOjoVKppC6lyrGwsICtre1LrVPIgERERFTJCCFw7949KBQKODg4PHdBQ/ofIQRycnKQnJwMALCzsyt3WwxIRERElUxhYSFycnJgb28PIyMjqcupUgwNDQEAycnJsLa2LvdwGyMpERFRJaNUKgEAenp6EldSNT0JlQUFBeVugwGJiIiokuJen+VTEa8bAxIRERFRMQxIRERERMUwIBEREVGFSUlJwYQJE1C/fn3o6+vD1tYWvr6+OH36tPqcCxcu4J133oGdnR309fXRoEEDvP766/jrr78ghAAA3LlzBzKZTH0zNTVF8+bNMWnSJNy+fVvr18GAVMkIIRAUmYrcAqXUpRAREZXZwIEDceHCBfz666+4desW9uzZAx8fH9y/fx8AsHv3bnTs2BFZWVn49ddfER4ejgMHDuDNN9/E7NmzkZGRodHe4cOHce/ePVy6dAmLFy9GeHg43NzccOTIEa1eh0w8iWpUJpmZmTA3N0dGRgbMzMwqrN0Jm0Kx/2oiFr/ZEkM86ldYu0REVHXk5uYiOjoaTk5OMDAwkLqcUktPT0etWrUQGBgIb2/vp+7Pzs5GgwYN0LVrV+zcubPENoQQkMlkuHPnDpycnHDhwgW0bt1afb9KpUKPHj0QHR2NyMjIEr/G/7zXr7Sf3+xBqmTaO9YGAKw+HolCJVdPJSKixwsg5hdKcitLP4qJiQlMTEywa9cu5OXlPXX/P//8g/v37+PTTz99Zhsv+gaaXC7HRx99hJiYGISGhpa6trLiQpGVzLvuDlh+9DZi03Kw98o99G9dV+qSiIhIYo8KlHCde1CS576+wBdGeqWLCzo6Ovjll18wZswYrF69Gm3btoW3tzcGDx6MVq1a4datWwCApk2bqh9z7tw5dOvWTf3z1q1b8frrrz/3eVxcXAAUzVNyd3cv6yWVCnuQKhkjPR180MkJALAqMLJMyZ2IiEhqAwcOREJCAvbs2YM+ffogMDAQbdu2xS+//FLi+a1atcLFixdx8eJFZGdno7Cw8IXP8eSzUZvrRLEHqRIa7umI1ccjcSPxIY7eSEaPZjZSl0RERBIy1FXg+gJfyZ67rAwMDNCrVy/06tULc+bMwejRozFv3jwsW7YMAHDz5k107NgRAKCvr49GjRqVqf3w8HAAgJOTU5lrK61K0YO0YsUKODo6wsDAAB4eHggJCXnu+QEBAWjatCkMDQ3h4OCAadOmITc3t9RtFv/q4L9vv//+u1ausSzMjXTxnmcDAMDyYxHsRSIiquFkMhmM9HQkuVVEL42rqyuys7PRu3dv1K5dG19//XW521KpVPj+++/h5OSENm3avHRtzyJ5QNq2bRumT5+OefPmISwsDG5ubvD19VXvxFvcli1bMHPmTMybNw/h4eFYu3Yttm3bhs8++6zUbTo4OODevXsaty+++AImJibo27fvK7nuFxnV2Ql6OnJciE3Hmag0qcshIiJ6ofv376N79+7YtGkTLl++jOjoaPz+++9YsmQJ+vfvDxMTE/z888/Yu3cv+vXrh4MHDyIqKgqXL1/GkiVLAOCpb6Xdv38fiYmJiIqKwp49e9CzZ0+EhIRg7dq15d6ItlSExNzd3cWkSZPUPyuVSmFvby/8/f1LPH/SpEmie/fuGsemT58uOnXqVO42hRCidevW4oMPPih13RkZGQKAyMjIKPVjyurzPy+LBv/3t3jv5zNaew4iIqp8Hj16JK5fvy4ePXokdSllkpubK2bOnCnatm0rzM3NhZGRkWjatKmYPXu2yMnJUZ937tw58fbbbwtra2uho6Mj6tSpI3x9fcXWrVuFSqUSQggRHR0tAKhvRkZGolmzZmLixIni9u3bz63jea9faT+/JZ2DlJ+fj9DQUMyaNUt9TC6Xo2fPnggODi7xMV5eXti0aRNCQkLg7u6OqKgo7Nu3D8OGDSt3m6Ghobh48SJWrFjxzFrz8vI0vrKYmZlZpmstj3FdnfFbSBxO3k7FlbsZaFnPXOvPSUREVF76+vrw9/eHv7//c89r3779C6e0ODo6SjrFRNIhttTUVCiVStjYaE5CtrGxQWJiYomPGTJkCBYsWIDOnTtDV1cXzs7O8PHxUQ+xlafNtWvXolmzZvDy8npmrf7+/jA3N1ffHBwcynKp5eJQ2whvuNkDAFYGRmj9+YiIiKiI5HOQyiowMBCLFy/GypUrERYWhp07d2Lv3r1YuHBhudp79OgRtmzZglGjRj33vFmzZiEjI0N9i4uLK9fzldUEH2cAwIFriYhIfvhKnpOIiKimk3SIzdLSEgqFAklJSRrHk5KSYGtrW+Jj5syZg2HDhmH06NEAgJYtWyI7Oxtjx47F559/XuY2//jjD+Tk5GD48OHPrVVfXx/6+vplubwK0cTGFL1cbXDoehJWBUbhu0Fur7wGIiKimkbSHiQ9PT20a9dOY8M5lUqFI0eOwNPTs8TH5OTkQC7XLPvJLHYhRJnbXLt2Ld544w1YWVlVxCVpxcTHvUi7L8bj7oMciashIiKq/iQfYps+fTp++ukn9Y6+EyZMQHZ2NkaOHAkAGD58uMaEaz8/P6xatQpbt25FdHQ0Dh06hDlz5sDPz08dlF7U5hMRERE4ceKEujeqsmpTvxY6NaqDQpXATyeipC6HiIheESknKVdlFfG6Sb6S9jvvvIOUlBTMnTsXiYmJaN26NQ4cOKCeZB0bG6vRYzR79mzIZDLMnj0b8fHxsLKygp+fHxYtWlTqNp9Yt24d6tWrh969e7+ai30JE30a4XTEfWw9F4cpPRrD0uTVD/cREdGr8eQf/Pn5+TA0NJS4mqonJ6dotEVXV7fcbcgE42m5ZGZmwtzcHBkZGTAzM9P68wkhMGBlEC7FpWOijzM+7eOi9eckIiJpCCEQGxuLgoIC2NvbPzW1hEomhEBOTg6Sk5NhYWEBOzu7p84p7ee35D1IVDoymQwTfZwxbmMoNgbHYLyPM8wMyp+MiYio8pLJZLCzs0N0dDRiYmKkLqfKsbCweOaXvUqLAakK6dXMBo2tTXA7OQsbg2MwqVvZNvcjIqKqQ09PD40bN0Z+fr7UpVQpurq6FbIFCQNSFSKXyzCxmzOmbbuEdaei8UEnJxjqaXEfGiIikpRcLoeBgYHUZdRIHNSsYvxa2aNeLUPcz87H9vOvZrFKIiKimoYBqYrRUcgxzrtoXaQ1J6JQoFRJXBEREVH1w4BUBf2nXT1YmugjPv0Rdl9MkLocIiKiaocBqQoy0FVgdBcnAEWb2CpVXKmBiIioIjEgVVFDPerDzEAHUSnZ+OdaotTlEBERVSsMSFWUqYEuRng5AgBWBkZyOXoiIqIKxIBUhY3s5ARDXQWuxGfg5O1UqcshIiKqNhiQqrDaxnoY7O4AoGguEhEREVUMBqQqbkyXhtBVyHAmKg2hMWlSl0NERFQtMCBVcfYWhnirTT0AwMpjkRJXQ0REVD0wIFUD47wbQiYDjtxIRvi9TKnLISIiqvIYkKqBhlYmeK2lHQBgVSB7kYiIiF4WA1I1MeHx9iN/X05AzP1siashIiKq2hiQqokWdc3h09QKKgGsPh4ldTlERERVGgNSNTKpWyMAwI7Qu0jKzJW4GiIioqqLAaka6eBYGx0cayFfqcLPJ9mLREREVF4MSNXMxMe9SJvPxuJBdr7E1RAREVVNDEjVjE8TK7jamSEnX4lfg+9IXQ4REVGVxIBUzchkMkzsVvSNtvWn7yArr1DiioiIiKoeBqRqqG8LOzhZGiPjUQF+OxsrdTlERERVDgNSNaSQyzDeuyEA4KeTUcgrVEpcERERUdXCgFRNvdmmHuzMDZD8MA87QuOlLoeIiKhKYUCqpvR05BjdpagX6ccTkShUqiSuiIiIqOpgQKrG3nV3QC0jXcTcz8HeK/ekLoeIiKjKYECqxoz0dPBBJycARZvYCiEkroiIiKhqYECq5oZ7OsJYT4EbiQ9x9Eay1OUQERFVCQxI1Zy5kS7e82wAAFhxLIK9SERERKXAgFQDjOrsBD0dOcJi03E2Ok3qcoiIiCo9BqQawNrUAIPa1wNQ1ItEREREz8eAVEOM6+oMhVyGk7dTceVuhtTlEBERVWoMSDWEQ20jvOFmDwBYGcheJCIioudhQKpBJvgUbWJ74FoiIpKzJK6GiIio8mJAqkGa2Jiil6sNhABWH4+UuhwiIqJKiwGphpn4uBdp14V43H2QI3E1RERElRMDUg3Tpn4tdGpUB4UqgZ9OREldDhERUaXEgFQDTfRpBADYei4OqVl5EldDRERU+TAg1UBeznXg5mCBvEIV1p2KlrocIiKiSocBqQaSyWSY9Hgu0sbgGGTmFkhcERERUeXCgFRD9Wxmg8bWJniYV4iNwTFSl0NERFSpMCDVUHK5DBO7FfUirTsVjUf5SokrIiIiqjwYkGowv1b2qFfLEPez87H9fJzU5RAREVUaDEg1mI5CjnHeRb1Ia05EoUCpkrgiIiKiyoEBqYb7T7t6sDTRR3z6I+y+mCB1OURERJUCA1INZ6CrwOguTgCAVYERUKmExBURERFJT/KAtGLFCjg6OsLAwAAeHh4ICQl57vkBAQFo2rQpDA0N4eDggGnTpiE3N7fMbQYHB6N79+4wNjaGmZkZunbtikePHlXotVUVQz3qw8xAB5Ep2fjneqLU5RAREUlO0oC0bds2TJ8+HfPmzUNYWBjc3Nzg6+uL5OTkEs/fsmULZs6ciXnz5iE8PBxr167Ftm3b8Nlnn5WpzeDgYPTp0we9e/dGSEgIzp07h8mTJ0MulzwvSsLUQBcjvBwBACuORUII9iIREVHNJhMSfhp6eHigQ4cOWL58OQBApVLBwcEBU6ZMwcyZM586f/LkyQgPD8eRI0fUxz7++GOcPXsWp06dKnWbHTt2RK9evbBw4cJy156ZmQlzc3NkZGTAzMys3O1UFmnZ+ej01VE8KlBiwwfu6NrESuqSiIiIKlxpP78l6zLJz89HaGgoevbs+b9i5HL07NkTwcHBJT7Gy8sLoaGh6iGzqKgo7Nu3D6+99lqp20xOTsbZs2dhbW0NLy8v2NjYwNvbWx2wniUvLw+ZmZkat+qktrEe3nWvDwBYGRghcTVERETSkiwgpaamQqlUwsbGRuO4jY0NEhNLngczZMgQLFiwAJ07d4auri6cnZ3h4+OjHmIrTZtRUUU72M+fPx9jxozBgQMH0LZtW/To0QO3b99+Zr3+/v4wNzdX3xwcHMp97ZXVmK5O0FXIcCYqDaExD6Quh4iISDJVatJNYGAgFi9ejJUrVyIsLAw7d+7E3r17yzRUplIVrfUzbtw4jBw5Em3atMGyZcvQtGlTrFu37pmPmzVrFjIyMtS3uLjqt7Cinbkh3mpTD0DRN9qIiIhqKh2pntjS0hIKhQJJSUkax5OSkmBra1viY+bMmYNhw4Zh9OjRAICWLVsiOzsbY8eOxeeff16qNu3s7AAArq6uGuc0a9YMsbGxz6xXX18f+vr6ZbvIKmicd0NsD43D4fBkhN/LRDO7qj+/ioiIqKwk60HS09NDu3btNCZcq1QqHDlyBJ6eniU+Jicn56lvmikUCgCAEKJUbTo6OsLe3h43b97UaOfWrVto0KBBhVxbVdbQygSvtSwKkasCIyWuhoiISBqS9SABwPTp0zFixAi0b98e7u7uCAgIQHZ2NkaOHAkAGD58OOrWrQt/f38AgJ+fH5YuXYo2bdrAw8MDERERmDNnDvz8/NRB6UVtymQyzJgxA/PmzYObmxtat26NX3/9FTdu3MAff/whzQtRyUz0ccbey/fw9+UEfNy7CRrUMZa6JCIioldK0oD0zjvvICUlBXPnzkViYiJat26NAwcOqCdZx8bGavQYzZ49GzKZDLNnz0Z8fDysrKzg5+eHRYsWlbpNAJg6dSpyc3Mxbdo0pKWlwc3NDYcOHYKzs/Oru/hKrLm9OXyaWiHwZgpWH4+C/1stpS6JiIjolZJ0HaSqrLqtg1TcuTtp+M/qYOgp5Dj5f91gY2YgdUlEREQvrdKvg0SVWwfH2ujgWAv5ShV+PhkldTlERESvFAMSPdPEbo0AAJvPxuJBdr7E1RAREb06DEj0TD5NrOBqZ4acfCV+Db4jdTlERESvDAMSPZNMJsPEbkUT19efvoPsvEKJKyIiIno1GJDoufq2sIOTpTEyHhXgt5BnL6RJRERUnTAg0XMp5DKM924IAFhzIgp5hUqJKyIiItI+BiR6oTfb1IOduQGSH+ZhR2i81OUQERFpHQMSvZCejhxjuhT1Iv14IhKFSpXEFREREWkXAxKVymB3B9Qy0kXM/RzsvXJP6nKIiIi0igGJSsVITwcfdHICULSJLRdgJyKi6owBiUptuKcjjPUUuJH4EEdvJEtdDhERkdYwIFGpmRvp4j3PBgCAFcci2ItERETVFgMSlcmozk7Q05EjLDYdZ6PTpC6HiIhIKxiQqEysTQ0wqH09AEW9SERERNURAxKV2biuzlDIZTh5OxVX7mZIXQ4REVGFY0CiMnOobYQ33OwBACsD2YtERETVDwMSlcsEn6JNbA9cS0REcpbE1RAREVUsBiQqlyY2pujtagMhgNXHI6Uuh4iIqEIxIFG5TezWCACw60I84tMfSVwNERFRxWFAonJr7WCBTo3qoFAl8NOJKKnLISIiqjAMSPRSJvoU9SL9FhKL1Kw8iashIiKqGAxI9FK8nOvAzcECeYUqrD8dLXU5REREFYIBiV6KTCbDpMffaNsQFIPM3AKJKyIiInp5DEj00no2s0FjaxM8zCvExuAYqcshIiJ6aQxI9NLkchkmdivqRVp3KhqP8pUSV0RERPRyGJCoQvi1ske9Woa4n52P7efjpC6HiIjopTAgUYXQUcgxzruoF2nNiSgUKFUSV0RERFR+DEhUYf7Trh4sTfQRn/4Iuy8mSF0OERFRuTEgUYUx0FVgdBcnAMCqwAioVELiioiIiMqHAYkq1FCP+jAz0EFkSjb+uZ4odTlERETlwoBEFcrUQBcjvBwBACuORUII9iIREVHVw4BEFW5kJycY6ipwJT4DgTdTpC6HiIiozBiQqMLVNtbDu+71AQCTtoQh8GayxBURERGVDQMSacX03k3QqVEd5OQrMerX89h+jmsjERFR1cGARFphoq+D9e+74802daFUCXy64zICDt/inCQiIqoSGJBIa/R05Fg6yA0TH29mG3D4NmbuuMJFJImIqNJjQCKtkslk+LSPCxYOaAG5DNh2Pg5jNpxHdl6h1KURERE9EwMSvRLDOjbAj8Paw0BXjsCbKXhnTTCSH+ZKXRYREVGJGJDolenlaoPfxnREbWM9XI3PxFsrgxCZkiV1WURERE9hQKJXqk39Wtg5wQsN6hjh7oNHGLgqCOfvpEldFhERkQYGJHrlHC2NsWOCF9wcLJCeU4ChP5/Fgav3pC6LiIhIjQGJJGFpoo/fxnigZzNr5BWqMGFzGH45HS11WURERAAYkEhCRno6WP1eOwz1qA8hgPl/XcfifeFQqbhWEhERSYsBiSSlo5DjywEtMMO3KQBgzYkofLTtIvIKlRJXRkRENRkDEklOJpNhUrdGWDrIDTpyGf66lIDha0OQ8ahA6tKIiKiGYkCiSuOttvXwy0h3mOjr4Gx0Gv6zOgjx6Y+kLouIiGogBiSqVDo3tsT2cZ6wMdPHraQsvLXyNK4nZEpdFhER1TCVIiCtWLECjo6OMDAwgIeHB0JCQp57fkBAAJo2bQpDQ0M4ODhg2rRpyM3VXJX5RW36+PhAJpNp3MaPH1/h10Zl52pvhp0TO6GxtQmSMvMw6MdgnLqdKnVZRERUg0gekLZt24bp06dj3rx5CAsLg5ubG3x9fZGcnFzi+Vu2bMHMmTMxb948hIeHY+3atdi2bRs+++yzMrc5ZswY3Lt3T31bsmSJVq+VSq+uhSH+GO8FD6fayMorxPvrQ7Az7K7UZRERUQ0heUBaunQpxowZg5EjR8LV1RWrV6+GkZER1q1bV+L5QUFB6NSpE4YMGQJHR0f07t0b7777rkYPUWnbNDIygq2trfpmZmam1WulsjE30sWGUe7wc7NHoUpg+vZLWHEsAkJwGQAiItIuSQNSfn4+QkND0bNnT/UxuVyOnj17Ijg4uMTHeHl5ITQ0VB2IoqKisG/fPrz22mtlbnPz5s2wtLREixYtMGvWLOTk5FT0JdJL0tdR4L/vtMa4rg0BAN8cvInZu66iUKmSuDIiIqrOdKR88tTUVCiVStjY2Ggct7GxwY0bN0p8zJAhQ5CamorOnTtDCIHCwkKMHz9ePcRW2jaHDBmCBg0awN7eHpcvX8b//d//4ebNm9i5c2eJz5uXl4e8vDz1z5mZnDj8qsjlMsx6rRnszA3wxd/XsflsLJIyc/H9u21gpCfpW5iIiKopyYfYyiowMBCLFy/GypUrERYWhp07d2Lv3r1YuHBhmdoZO3YsfH190bJlSwwdOhQbNmzAn3/+icjIyBLP9/f3h7m5ufrm4OBQEZdDZfB+JyesGtoW+jpyHA5Pxrs/nUVqVt6LH0hERFRGkgYkS0tLKBQKJCUlaRxPSkqCra1tiY+ZM2cOhg0bhtGjR6Nly5Z48803sXjxYvj7+0OlUpWrTQDw8PAAAERERJR4/6xZs5CRkaG+xcXFleVSqYL0aWGHzaM9YGGki0tx6Ri4Kgh3UrOlLouIiKoZSQOSnp4e2rVrhyNHjqiPqVQqHDlyBJ6eniU+JicnB3K5ZtkKhQIAIIQoV5sAcPHiRQCAnZ1diffr6+vDzMxM40bSaO9YGzsmeKFeLUPE3M/BW6uCcCH2gdRlERFRNSL5ENv06dPx008/4ddff0V4eDgmTJiA7OxsjBw5EgAwfPhwzJo1S32+n58fVq1aha1btyI6OhqHDh3CnDlz4Ofnpw5KL2ozMjISCxcuRGhoKO7cuYM9e/Zg+PDh6Nq1K1q1avXqXwQqM2crE+yc6IWWdc2Rlp2Pd386g0PXk178QCIiolKQfIbrO++8g5SUFMydOxeJiYlo3bo1Dhw4oJ5kHRsbq9FjNHv2bMhkMsyePRvx8fGwsrKCn58fFi1aVOo29fT0cPjwYQQEBCA7OxsODg4YOHAgZs+e/Wovnl6KtakBto7tiImbw3D8VgrGbTyPBf1b4L2ODaQujYiIqjiZ4KIy5ZKZmQlzc3NkZGRwuE1iBUoVZv95FdvOF80Lm+jjjBm+TSGTySSujIiIKpvSfn5LPsRG9LJ0FXJ8NbAlpvVsAgBYGRiJ6dsvIb+QayUREVH5MCBRtSCTyfBRz8ZY8nYrKOQy/HkhHiN/CUFmboHUpRERURXEgETVyqD2Dlg7oj2M9BQ4HXEfg1YHIzEj98UPJCIi+hcGJKp2fJpaY/s4T1ia6ONG4kO8ufI0biY+lLosIiKqQhiQqFpqUdccf070QkMrY9zLyMXbq4MQHHlf6rKIiKiKYECiasuhthF2TvBC+wa18DC3ECPWhWDPpQSpyyIioiqAAYmqNQsjPWwa7YG+LWyRr1Thw98uYM2JSHB1CyIieh4GJKr2DHQVWD6kLUZ2cgQALN53A1/8dR1KFUMSERGVjAGJagSFXIZ5fs0xu18zAMAvQXcwcXMocguUEldGRESVEQMS1SijuzTE8iFtoKeQ4+C1JAz56QweZOdLXRYREVUyDEhU47zeyh4bR7nDzEAHYbHpGLgqCHFpOVKXRURElQgDEtVIHg3rYMcEL9S1MERUajbeXHkal++mS10WERFVEgxIVGM1tjHFzoleaGZnhtSsfAxecwbHbiRLXRYREVUCDEhUo9mYGWD7uI7o0tgSOflKjN5wHltDYqUui4iIJMaARDWeqYEu1o7ogLfa1oVSJTBz5xUsPXSLayUREdVgDEhEAPR05PjuP26Y0r0RAOD7I7fx6R+XUaBUSVwZERFJgQGJ6DGZTIaPezfF4jdbQi4Dfg+9i1G/nkdWXqHUpRER0SvGgERUzBCP+vhpeHsY6ipw4lYK3vkxGEmZuVKXRURErxADElEJejSzwW9jO6KOsR6uJWSi739P4p9riVKXRURErwgDEtEztHawwM6JXnCxNUVadj7GbgzFrJ2Xkc0hNyKiao8Bieg5GtQxxu7JnTC2a0PIZMBvIXHo9/1JXIh9IHVpRESkRQxIRC+gr6PAZ681w+bRHrAzN8Cd+zl4e3UwAg7fQiG/5UZEVC0xIBGVkpezJQ581BVvuNlDqRIIOHwbb68Oxp3UbKlLIyKiCsaARFQG5ka6+P7dNvjv4NYwNdDBxbh0vPb9SWwNieXCkkRE1QgDElE59G9dFwemdoWHU23k5Csxc+cVjN0YivtZeVKXRkREFaBcASkuLg53795V/xwSEoKpU6dizZo1FVYYUWVX18IQW8Z0xKy+LtBVyHDoehJ8A07i2E1ueEtEVNWVKyANGTIEx44dAwAkJiaiV69eCAkJweeff44FCxZUaIFElZlCLsM4b2fsmtQJja1NkJqVh5Hrz2HOrqt4lK+UujwiIiqncgWkq1evwt3dHQCwfft2tGjRAkFBQdi8eTN++eWXiqyPqEpobm+Ov6Z0xshOjgCAjWdi0O+Hk7hyN0PawoiIqFzKFZAKCgqgr68PADh8+DDeeOMNAICLiwvu3btXcdURVSEGugrM82uODR+4w9pUH1Ep2Xhz5WmsOBYBpYoTuImIqpJyBaTmzZtj9erVOHnyJA4dOoQ+ffoAABISElCnTp0KLZCoqunaxAoHp3ZF3xa2KFQJfHPwJgavCUZcWo7UpRERUSmVKyB9/fXX+PHHH+Hj44N3330Xbm5uAIA9e/aoh96IarJaxnpYObQtvv2PG0z0dXDuzgP0/e9J7Ai9y+UAiIiqAJko519rpVKJzMxM1KpVS33szp07MDIygrW1dYUVWFllZmbC3NwcGRkZMDMzk7ocqsTi0nIwbdtFnI8p2p6kX0s7LHqzBSyM9CSujIio5int53e5epAePXqEvLw8dTiKiYlBQEAAbt68WSPCEVFZONQ2wrZxnpjh2xQ6chn2XrkH34ATOHk7RerSiIjoGcoVkPr3748NGzYAANLT0+Hh4YHvvvsOAwYMwKpVqyq0QKLqQCGXYVK3Rtg50QsNLY2RlJmHYWtDsOCv68gt4HIARESVTbkCUlhYGLp06QIA+OOPP2BjY4OYmBhs2LAB33//fYUWSFSdtKpngb8/7Iz3OtYHAKw7HY03lp/C9YRMiSsjIqJ/K1dAysnJgampKQDgn3/+wVtvvQW5XI6OHTsiJiamQgskqm6M9HTw5YCWWPd+e1ia6OFWUhYGrDiNNScioeJyAERElUK5AlKjRo2wa9cuxMXF4eDBg+jduzcAIDk5mROWiUqpu4sNDkztip7NbJCvVGHxvhsY+vNZJKQ/kro0IqIar1wBae7cufjkk0/g6OgId3d3eHp6AijqTWrTpk2FFkhUnVma6OOn4e3g/1ZLGOoqEBx1H74BJ7DnUoLUpRER1Wjl/pp/YmIi7t27Bzc3N8jlRTkrJCQEZmZmcHFxqdAiKyN+zZ8qWnRqNqZuu4hLcekAgP6t7bGgfwuYG+pKWxgRUTVS2s/vcgekJ+7evQsAqFev3ss0U+UwIJE2FChVWH40Assfb09ib26A7wa1hqczV6gnIqoIWl0HSaVSYcGCBTA3N0eDBg3QoEEDWFhYYOHChVCpVOUumqim01XIMa1XE2wf54kGdYyQkJGLIT+fgf/+cOQVcjkAIqJXpVwB6fPPP8fy5cvx1Vdf4cKFC7hw4QIWL16MH374AXPmzKnoGolqnHYNamHfh10wuIMDhAB+PB6FASuCcCvpodSlERHVCOUaYrO3t8fq1avxxhtvaBzfvXs3Jk6ciPj4+AorsLLiEBu9KgevJWLWzitIy86Hno4cs/q6YISnI+RymdSlERFVOVodYktLSytxIraLiwvS0tLK0yQRPYNvc1scmNoFPk2tkF+owhd/XceI9SFIysyVujQiomqrXAHJzc0Ny5cvf+r48uXL0apVq5cuiog0WZsaYP37HbCwf3Po68hx8nYqfANOYP+Ve1KXRkRULZVriO348ePo168f6tevr14DKTg4GHFxcdi3b596G5LqjENsJJWI5IeYuu0irsYXbU/ydrt6mOfnClMDLgdARPQiWh1i8/b2xq1bt/Dmm28iPT0d6enpeOutt3Dt2jVs3Lix3EUT0Ys1sjbFzgmdMNHHGTIZ8EfoXbz2/Umcv8PhbSKiilKugAQUTdRetGgRduzYgR07duDLL7/EgwcPsHbt2jK3tWLFCjg6OsLAwAAeHh4ICQl57vkBAQFo2rQpDA0N4eDggGnTpiE3V3M+RmnbFEKgb9++kMlk2LVrV5lrJ5KCno4cn/ZxwbaxnqhrYYi4tEcY9GMwvj14EwVKLrVBRPSyyh2QKsq2bdswffp0zJs3D2FhYXBzc4Ovry+Sk5NLPH/Lli2YOXMm5s2bh/DwcKxduxbbtm3DZ599Vq42AwICIJPx20BUNbk71cb+qV3wVtu6UAlg+bEIDFwVhMiULKlLIyKq0iQPSEuXLsWYMWMwcuRIuLq6YvXq1TAyMsK6detKPD8oKAidOnXCkCFD4OjoiN69e+Pdd9/V6CEqbZsXL17Ed99998znIqoKzAx0sXRQa6wY0hbmhrq4fDcD/b4/iY1nYvCSC+UTEdVYkgak/Px8hIaGomfPnupjcrkcPXv2RHBwcImP8fLyQmhoqDoQRUVFYd++fXjttdfK1GZOTg6GDBmCFStWwNbWVhuXR/RK9Wtlh4NTu6JzI0vkFqgwZ9dVjPr1PFIe5kldGhFRlaNTlpPfeuut596fnp5epidPTU2FUqmEjY2NxnEbGxvcuHGjxMcMGTIEqamp6Ny5M4QQKCwsxPjx49VDbKVtc9q0afDy8kL//v1LVWteXh7y8v73QZOZmVmqxxG9SrbmBtjwgTvWB93B1wdu4OiNZPQJOIGvBrZCL1ebFzdAREQAytiDZG5u/txbgwYNMHz4cG3VCgAIDAzE4sWLsXLlSoSFhWHnzp3Yu3cvFi5cWOo29uzZg6NHjyIgIKDUj/H399e4VgcHh3JUT6R9crkMozo74a/JneFia4r72fkYs+E8Zu28jOy8QqnLIyKqEsrUg7R+/foKfXJLS0soFAokJSVpHE9KSnrmsNecOXMwbNgwjB49GgDQsmVLZGdnY+zYsfj8889L1ebRo0cRGRkJCwsLjXMGDhyILl26IDAw8KnnnTVrFqZPn67+OTMzkyGJKrWmtqbYPbkTvvvnFn46GYXfQuJwKiIVX73VCp0aWUpdHhFRpSbpHCQ9PT20a9cOR44cUR9TqVQ4cuSIegHK4nJyciCXa5atUCgAFH1lvzRtzpw5E5cvX8bFixfVNwBYtmzZM0Ogvr4+zMzMNG5ElZ2+jgKfvdYMm0d7wN7cAHFpjzD057OYueMyMh4VSF0eEVGlVaYeJG2YPn06RowYgfbt28Pd3R0BAQHIzs7GyJEjAQDDhw9H3bp14e/vDwDw8/PD0qVL0aZNG3h4eCAiIgJz5syBn5+fOii9qE1bW9sSe6jq168PJyenV3TlRK+Ol7Ml/pnujSUHbmBDcAy2novDsZvJ+HJAS85NIiIqgeQB6Z133kFKSgrmzp2LxMREtG7dGgcOHFBPso6NjdXoMZo9ezZkMhlmz56N+Ph4WFlZwc/PD4sWLSp1m0Q1kYm+Dhb0b4HXW9nj/3ZcRnRqNsZsOI/XW9lh/hvNYWmiL3WJRESVRrn2YiPuxUZVW26BEgGHb+Onk1FQqgRqGelinl9z9G9tz4VTiaha0+pebERUtRnoKjCzrwt2TeyEZnZmeJBTgKnbLmLUr+eRkP5I6vKIiCTHgERUg7WsZ449kzvhk95NoKeQ4+iNZPRedgKbzsRApWLnMhHVXAxIRDWcrkKOyd0bY++HndGmvgWy8goxe9dVvPvTGUSnZktdHhGRJBiQiAgA0NjGFH+M98Lc111hqKvA2eg09Ak4gTUnIlGoVEldHhHRK8WARERqCrkMH3R2wj/TivZ0yytUYfG+G3hrVRDC73F7HSKqORiQiOgpDrWNsHGUO5YMbAVTAx1cvpsBvx9OYemhW8grVEpdHhGR1jEgEVGJZDIZBnVwwOHp3ujtaoNClcD3R27D74dTuBD7QOryiIi0igGJiJ7LxswAPw5rhxVD2sLSRA+3krLw1qogLPz7OnLyufktEVVPDEhE9EIymQz9Wtnh0DRvvNWmLoQA1p6KRp+AkwiKSJW6PCKiCseARESlVstYD0vfaY31IzvA3twAsWk5GPJ489vMXG5+S0TVBwMSEZVZt6bWODitK4Z1bAAA2HouDr2WHsfh60kSV0ZEVDEYkIioXEwNdLFwQAtsG9sRTpbGSMrMw+gN5zHltwu4n5UndXlERC+FAYmIXopHwzrY/1EXjPNuCLkM+OtSAnouPY7dF+PBvbCJqKpiQCKil2agq8Csvs2wa1InuNia4kFOAT7aWrT57b0Mbn5LRFUPAxIRVZhW9Szw15TO+LjX/za/7bX0BDaf5ea3RFS1MCARUYXSVcgxpYfm5ref/3kVQ34+gzvc/JaIqggGJCLSiuKb356JSoMvN78loiqCAYmItObJ5rcHp3ZFp0Z11JvfDlwVhBuJ3PyWiCovBiQi0rr6dYywaZSHevPbS483v1126BbyC9mbRESVDwMSEb0S/978tperDQqUAv89chuv/3ASF+PSpS6PiEgDAxIRvVI2ZgZYM6wdlg9pgzrGjze/XXkaX/59HY/ylVKXR0QEgAGJiCQgk8nweit7HJ7ujTfb1IVKAD+fioZvwAkERXLzWyKSHgMSEUmmlrEelr3TGuvf7wC7J5vf/nQWs3Ze4ea3RCQpBiQiklw3F2v8M60r3utYHwDwW0gsN78lIkkxIBFRpWBqoIsvB7TEtrEd4VjHSL357Yfc/JaIJMCARESVikfDOjgwtat689s9lxLQa9kJbn5LRK8UAxIRVTrFN79Ny87HR1svYjQ3vyWiV4QBiYgqrVb1LLBn8v82vz1yIxm9l57A2lPRXBKAiLRKJthnXS6ZmZkwNzdHRkYGzMzMpC6HqNq7nfQQn+64jAux6QCA2sZ6GOnliOGejjA30pW2OCKqMkr7+c2AVE4MSESvnlIlsO1cHFYdj0BcWtFQm7GeAkM7NsCozk6wMTOQuEIiquwYkLSMAYlIOoVKFfZeuYdVgZG4kfgQAKCnkOOttnUxztsZTpbGEldIRJUVA5KWMSARSU8IgcCbKVgZGIFzdx4AAGQy4LUWdpjg44wWdc0lrpCIKhsGJC1jQCKqXM7dScPqwEgcuZGsPtalsSUm+DjDs2EdyGQyCasjosqCAUnLGJCIKqcbiZlYHRiJvy7fg1JV9OettYMFJvg4o1czG8jlDEpENRkDkpYxIBFVbnFpOVhzIgrbz8chr1AFAGhkbYLx3s7o39oeugquckJUEzEgaRkDElHVkPIwD78ERWNDcAwe5hYCAOzNDTC6S0MMdneAkZ6OxBUS0avEgKRlDEhEVUtmbgG2nI3F2lPRSHlYtLdbLSNdvO/lhBFeDWBhpCdxhUT0KjAgaRkDElHVlFugxM6wePx4IhIx93MAAEZ6Cgxxr49RXZxgZ24ocYVEpE0MSFrGgERUtRUqVdh/NRErAyMRfi8TAKCrkOHNNkVrKTlbmUhcIRFpAwOSljEgEVUPQggcv5WCVYGROBudBqBoLaU+zW0xwccZrepZSFsgEVUoBiQtY0Aiqn5CYx5gVWAkDocnqY91blS0lpKXM9dSIqoOGJC0jAGJqPq6lfQQqwMjsftSgnotJbd65pjg44zerrZcS4moCmNA0jIGJKLq7+6DHPx0Igpbz/1vLaWGVsYY39UZA9rUhZ4O11IiqmoYkLSMAYmo5kjNysOvQXfwa9AdZD5eS8nWzACjuzjhXff6MNbnWkpEVQUDkpYxIBHVPA9zC/BbSCx+PhmN5MdrKVkY6WKEpyPe93JELWOupURU2TEgaRkDElHNlVf4eC2l45G483gtJUNdBd51r4/RXZxgb8G1lIgqKwYkLWNAIiKlSuDA1USsDIzAtYSitZR05DIMaFMX472d0ciaaykRVTal/fyuFDMMV6xYAUdHRxgYGMDDwwMhISHPPT8gIABNmzaFoaEhHBwcMG3aNOTm5papzXHjxsHZ2RmGhoawsrJC//79cePGjQq/NiKqvhRyGfq1ssPfUzpjwwfu8GxYB4UqgT9C76LXsuMYt/E8LsalS10mEZWD5AFp27ZtmD59OubNm4ewsDC4ubnB19cXycnJJZ6/ZcsWzJw5E/PmzUN4eDjWrl2Lbdu24bPPPitTm+3atcP69esRHh6OgwcPQgiB3r17Q6lUav2aiah6kclk6NrECr+N7YidE73Q29UGQgAHryVhwIrTGPLTGZy8nQJ22BNVHZIPsXl4eKBDhw5Yvnw5AEClUsHBwQFTpkzBzJkznzp/8uTJCA8Px5EjR9THPv74Y5w9exanTp0qV5sAcPnyZbi5uSEiIgLOzs4vrJtDbET0PBHJD7EqMAq7L8aj8PFaSi3rFq2l5NvcFgqupUQkiSoxxJafn4/Q0FD07NlTfUwul6Nnz54IDg4u8TFeXl4IDQ1VD5lFRUVh3759eO2118rdZnZ2NtavXw8nJyc4ODhU1OURUQ3WyNoU3w1yw/FPu2FkJ0cY6ipwJT4DEzeHoefS49gaEou8QvZYE1VWkgak1NRUKJVK2NjYaBy3sbFBYmJiiY8ZMmQIFixYgM6dO0NXVxfOzs7w8fFRD7GVpc2VK1fCxMQEJiYm2L9/Pw4dOgQ9vZK/ppuXl4fMzEyNGxHRi9S1MMQ8v+Y4PbM7PuzRGOaGuohOzcbMnVfQ6atjWPrPTSRm5L64ISJ6pSSfg1RWgYGBWLx4MVauXImwsDDs3LkTe/fuxcKFC8vc1tChQ3HhwgUcP34cTZo0waBBg56a7P2Ev78/zM3N1Tf2NBFRWdQ21sP0Xk0QNLM7ZvdrBlszA6Rm5eH7oxHo9PVRTNwcijNR9zlPiaiSkHQOUn5+PoyMjPDHH39gwIAB6uMjRoxAeno6du/e/dRjunTpgo4dO+Kbb75RH9u0aRPGjh2LrKwsFBYWlrnNJ7XUqlULP//8M959992n7s/Ly0NeXp7658zMTDg4OHAOEhGVS4FShYPXErEhKAYhd9LUx5vamGKYZwO82aYuV+gm0oIqMQdJT08P7dq105hwrVKpcOTIEXh6epb4mJycHMjlmmUrFAoAgBCiXG0+eawQQiME/Zu+vj7MzMw0bkRE5aWrkOP1VvbYPt4T+z/qgnfd68NQV4GbSQ8xe9dVdFx8BPP3XENkSpbUpRLVSJL/82T69OkYMWIE2rdvD3d3dwQEBCA7OxsjR44EAAwfPhx169aFv78/AMDPzw9Lly5FmzZt4OHhgYiICMyZMwd+fn7qoPSiNqOiorBt2zb07t0bVlZWuHv3Lr766isYGhqqJ3sTEb0qzezM4P9WS8zs64IdoXex8UwMolOz8UvQHfwSdAddGltiuKcjurtY89tvRK+I5AHpnXfeQUpKCubOnYvExES0bt0aBw4cUE+yjo2N1egxmj17NmQyGWbPno34+HhYWVnBz88PixYtKnWbBgYGOHnyJAICAvDgwQPY2Niga9euCAoKgrW19at9AYiIHjM31MUHnZ3wvpcjTkWkYkPwHRy5kYyTt1Nx8nYq6loYYmjH+hjcoT5qc983Iq2SfB2kqorrIBHRqxCXloNNZ2Ow7Vwc0nMKAAB6OnK83soOIzwd4eZgIW2BRFUM92LTMgYkInqVcguU+OtSAjYEx+BKfIb6uFs9cwz3dES/VnYw0FVIWCFR1cCApGUMSEQkBSEELsalY2NwDP6+fA/5ShWAomUE3unggKEe9VGvlpHEVRJVXgxIWsaARERSS83Kw7Zzcdh8JgYJjxeblMuAHs1sMMLTEZ0a1YFMxkndRP/GgKRlDEhEVFkUKlU4ciMZG4Lv4HTEffXxhlbGGN6xAd5qVw9mBroSVkhUeTAgaRkDEhFVRhHJD7ExOAY7wuKRlVcIADDSU+DNNnUx3NMRTW1NJa6QSFoMSFrGgERElVlWXiH+DLuLDcExuJ38v8UmPZxqY4SXI3q52kBXUeV2myJ6aQxIWsaARERVgRACwVH3sTE4Bv9cT4JSVfQn39bMAEM86mOwuwOsTQ0krpLo1WFA0jIGJCKqau5lPMKWs7H4LSQWqVn5AABdhQx9W9hhhFcDtK1fi5O6qdpjQNIyBiQiqqryCpU4cDURG4JjEBrzQH3c1c4MI7wa4A23ujDU45pKVD0xIGkZAxIRVQdX4zOwMTgGuy7GI6+waE0lc0Nd/KddPQzzbIAGdYwlrpCoYjEgaRkDEhFVJ+k5+dh+Pg6bzsQiNi0HACCTAT5NrDDc0xHeTawg50a5VA0wIGkZAxIRVUcqlcDxWyn4NfgOAm+mqI83qGOE9zwa4D/t68HCiBvlUtXFgKRlDEhEVN3dSc3GpjMx2H4+Dpm5RWsqGejK0d+tLoZ5NkCLuuYSV0hUdgxIWsaAREQ1xaN8JXZfjMevwTEIv5epPt6uQS0M92yAvi3soKfDNZWoamBA0jIGJCKqaYQQCI15gA3BMdh35R4KH6+pZGdugFmvNYNfKzsuE0CVHgOSljEgEVFNlvwwF1tD4rD5bAySMvMAFK3S/UX/5nCx5d9EqrwYkLSMAYmICMgtUGLNiSisDIxAboEKCrkMwzo2wLReTWBuyA1yqfJhQNIyBiQiov+5+yAHi/aGY//VRABAHWM9/F9fF7zdth6XB6BKhQFJyxiQiIiedvJ2CubvuYbIlGwAQGsHCyzo3xyt6llIWxjRYwxIWsaARERUsvxCFX4NuoP/HrmNrLxCyGTA4A4OmOHrgtrGXEOJpMWApGUMSEREz5ecmYuv9t/AzgvxAAAzAx184tsUQ9zrQ0fBZQFIGgxIWsaARERUOufvpGHu7mu4/ngNJRdbUyzo3wLuTrUlroxqIgYkLWNAIiIqPaVKYEtILL49eBMZjwoAAANa22PWa81gY2YgcXVUk5T285t9nEREpHVPvv5/7BMfvOteHzIZsOtiArp/G4gfj0civ1AldYlEGtiDVE7sQSIiKr8rdzMwd89VXIhNBwA0tDLGfL/m6NrEStrCqNrjEJuWMSAREb0clUpgR9hdfH3gBlKz8gEAvs1tMLufKxxqG0lcHVVXDEhaxoBERFQxMnMLEHDoNn4NvgOlSkBfR46JPo0wzrshDHQVUpdH1QwDkpYxIBERVaybiQ8xf881BEfdBwDUq2WIua+7operDTfBpQrDgKRlDEhERBVPCIG9V+5h0d5w3MvIBQB4N7HCPD9XNLQykbg6qg4YkLSMAYmISHty8gux4lgEfjoRjXylCroKGUZ1bogp3RvBWF9H6vKoCmNA0jIGJCIi7buTmo0v/rqGYzdTAAA2Zvr47LVmeMPNnsNuVC4MSFrGgERE9OocCU/CF39dR2xaDgDA3ak2vnijOZrZ8e8vlQ0DkpYxIBERvVq5BUr8dCIKKwIjkFugglwGDPd0xLReTWBuqCt1eVRFMCBpGQMSEZE04tMfYdHe69h3JREAUMdYD//XxwVvt6sHuZzDbvR8DEhaxoBERCSt0xGpmLfnGiKSswAAbg4WWPBGc7g5WEhbGFVqDEhaxoBERCS9AqUKvwbdQcDh28jKK4RMBrzT3gEzfJuijom+1OVRJcTNaomIqNrTVcgxuktDHP3EG2+1rQshgK3n4tDt20D8GnQHhUpugkvlwx6kcmIPEhFR5RMak4a5u6/hWkImAMDF1hQL+reAu1NtiSujyoJDbFrGgEREVDkpVQK/hcTi239uIj2nAADQv7U9PnutGWzMDCSujqTGITYiIqqRFHIZ3uvYAMc+9sFQj/qQyYDdFxPQ/dtArD4eifxCDrvRi7EHqZzYg0REVDVcjc/A3N1XERabDgBoaGmMeW80h3cTK2kLI0lwiE3LGJCIiKoOlUrgzwvx8N9/A6lZeQCA3q42mPO6KxxqG0lcHb1KDEhaxoBERFT1ZOYW4L+Hb+OXoDtQqgT0deSY4OOM8d7OMNBVSF0evQIMSFrGgEREVHXdSnqI+XuuISjyPgCgXi1DfNrHBb2a2cBQj0GpOmNA0jIGJCKiqk0IgX1XErFo73UkZOQCAPR05PBwqg3vJlbwaWoNZytjyGTcvqQ6YUDSMgYkIqLqISe/EKuPR2FH6F3Epz/SuK9eLUN1WPJyrgNjfR2JqqSKwoCkZQxIRETVixACkSnZCLyZjOO3UnA2Ok1jSQBdhQwdHGvDp6kVvJtYo4mNCXuXqiAGJC1jQCIiqt5y8gtxJuo+jt9MQeCtFMTcz9G4387c4HHvkhU6NbKEqYGuRJVSWVSphSJXrFgBR0dHGBgYwMPDAyEhIc89PyAgAE2bNoWhoSEcHBwwbdo05ObmlrrNtLQ0TJkyRd1G/fr18eGHHyIjI0Mr10dERFWPkZ4OurvY4Iv+LXB8Rjcc+8QH8/1c4dPUCvo6ctzLyMXWc3EYvykMbRYcwqAfg7EyMALXEjLAvoeqT/LB1G3btmH69OlYvXo1PDw8EBAQAF9fX9y8eRPW1tZPnb9lyxbMnDkT69atg5eXF27duoX3338fMpkMS5cuLVWbCQkJSEhIwLfffgtXV1fExMRg/PjxSEhIwB9//PGqXwIiIqoCnCyN4WTphPc7OSG3QImz0WlFw3E3UxCVmo2Q6DSERKdhyYGbsDbVh3cTK3g3tUKXRlYwN2LvUlUj+RCbh4cHOnTogOXLlwMAVCoVHBwcMGXKFMycOfOp8ydPnozw8HAcOXJEfezjjz/G2bNncerUqXK1CQC///473nvvPWRnZ0NH58W5kUNsRET0ROz9HBy/lYzAmykIiryPRwVK9X1yGdC2fi31ZO/m9maQyzl3SSql/fyWtAcpPz8foaGhmDVrlvqYXC5Hz549ERwcXOJjvLy8sGnTJoSEhMDd3R1RUVHYt28fhg0bVu42AahfqGeFo7y8POTl5al/zszMLNO1EhFR9VW/jhGGeTpimKcj8gqVOBf9QD3Z+3ZyFs7HPMD5mAf47tAtWJrooWvjx71Lja1Q21hP6vKpBJIGpNTUVCiVStjY2Ggct7GxwY0bN0p8zJAhQ5CamorOnTtDCIHCwkKMHz8en332WbnbTE1NxcKFCzF27Nhn1urv748vvviiLJdHREQ1kL6OAp0bW6JzY0vMBnD3QQ6O30rB8ZspOB2RitSsfOy8EI+dF+IhkwFu9SwefzPOCq3qWUDB3qVKQfI5SGUVGBiIxYsXY+XKlfDw8EBERAQ++ugjLFy4EHPmzClze5mZmejXrx9cXV0xf/78Z543a9YsTJ8+XeNxDg4O5bkEIiKqQerVMsJQjwYY6tEA+YUqnI9JUwemG4kPcTEuHRfj0hFw+DZqGemiS+Oib8Z1bWIFSxN9qcuvsSQNSJaWllAoFEhKStI4npSUBFtb2xIfM2fOHAwbNgyjR48GALRs2RLZ2dkYO3YsPv/88zK1+fDhQ/Tp0wempqb4888/oav77El0+vr60NfnG5WIiMpPT0cOL2dLeDlbYlbfZkjMyFXPXTp1OxUPcgqw51IC9lxKAAC0rGsOn6ZFgcmtngV0FJXiy+c1gqQBSU9PD+3atcORI0cwYMAAAEUTqo8cOYLJkyeX+JicnBzI5ZpvEIWiaN8cIUSp28zMzISvry/09fWxZ88eGBgYVPwFEhERPYetuQHe6VAf73SojwKlChdi09Vzl64lZOJKfAauxGfgh6MRMDfURefGlvBpUjQcZ23Gzy1tknyIbfr06RgxYgTat28Pd3d3BAQEIDs7GyNHjgQADB8+HHXr1oW/vz8AwM/PD0uXLkWbNm3UQ2xz5syBn5+fOii9qM3MzEz07t0bOTk52LRpEzIzM9WTrq2srNTtEBERvSq6CjncnWrD3ak2Pu3jguTMXJy4nYrAm8k4eTsVGY8KsPfyPey9fA8A4GpnBu+mVvBpYoW2DWpBl71LFUrygPTOO+8gJSUFc+fORWJiIlq3bo0DBw6oJ1nHxsZq9BjNnj0bMpkMs2fPRnx8PKysrODn54dFixaVus2wsDCcPXsWANCoUSONeqKjo+Ho6KjlqyYiIno+azMDvN2uHt5uVw+FShUu3c3A8ZvJCLyVgst3M3D9Xiau38vEqsBImOrroFMjy8fDcdawNWfv0suSfB2kqorrIBERkVRSs/Jw8nYKAm+m4MStFDzIKVDfp5DLMNyzAab1agIzbn/yFO7FpmUMSEREVBkoVQJX4jMQeDMZx26m4FJcOgDA0kQfs/q64K22dbmp7r8wIGkZAxIREVVGJ26lYP6ea4hKzQYAdHCshS/eaAFXe35WAQxIWseARERElVVeoRJrT0XjhyMReFSghFwGDPd0xLReTWBuWLOH3Ur7+c0p70RERNWMvo4CE30a4cjH3nitpS1UAvgl6A56fBeIP0LvQqVi38iLsAepnNiDREREVcXJ2ymYt+caolKKht3aN6iFBf1r5rAbh9i0jAGJiIiqkvxCVdGw29HbyMmvucNuHGIjIiIiNT0dOSb4OOPIx97o18pOY9jt9/NxHHYrhj1I5cQeJCIiqspO3U7FvD1XEfl42K1tfQss6N8CLeqaS1yZdnGITcsYkIiIqKrLL1Rh3elofH/kf8Nu73VsgI97NYW5UfUcduMQGxERET2Xno4c472Lht1efzzstiE4Bt2/C8T2Gj7sxh6kcmIPEhERVTenI1Ixb881RCRnAQDa1LfAwmo27MYhNi1jQCIiouoov1CF9aej8d9/DbsN9WiAT3pXj2E3DrERERFRmenpyDHO2xlHP/aBn5s9VALYeCYG3b4LxPZzNWfYjT1I5cQeJCIiqgmCIlMxd/f/ht1aO1jgywFVd9iNQ2xaxoBEREQ1RYFShV9O30HA4VvIzldCJgOGetTHJ72bwsJIT+ryyoRDbERERFQhdBVyjOnaEEc/8cEbbvYQAth0JhbdvzuOrSGx1XLYjT1I5cQeJCIiqqmCI+9j7u6ruP2vYbeF/VugZb3KP+zGITYtY0AiIqKarECpwq9BdxBw+Day8gohkwFD3Otjhm/lHnbjEBsRERFpja5CjtFdGuLIx97o37po2G3z2Vh0+zYQv1WDYTf2IJUTe5CIiIj+50xU0bDbraSiYTc3Bwss7N8crepZSFtYMRxi0zIGJCIiIk0lDbu9614fM3o3RS3jyjHsxiE2IiIieqWeDLsd/dgbb7apCyGALWdj0e27QGw5GwtlFRp2Yw9SObEHiYiI6PnORt3HvD3XcCPxIQCgVT1zLOzfAm4OFpLVxCE2LWNAIiIierFCpQobgmOw7NAtPHw87Da4gwNm+LqgtgTDbhxiIyIiIsnpKOT4oLMTjnzijbceD7v9FhKH7t8FYvPZmEo77MYepHJiDxIREVHZhUSnYe7uq+pht5Z1zbFwQAu0fkXDbhxi0zIGJCIiovIpVKqw8UwMlv7zv2G3d9o74NM+2h924xAbERERVUo6CjlGdno87Na2aNht67k4dPs2EJvOVI5hN/YglRN7kIiIiCrGuTtpmLPrf8NuLeqaYWH/FmhTv1aFPxd7kIiIiKhK6OBYG39P6Yz5fq4wNdDB1fhMvLkyCCuORUhWEwMSERERSU5HIcf7nZxw9GMfDGxbDzIZ0LFhbcnq4RBbOXGIjYiISHvupGbD0dK4wtvlEBsRERFVWdoIR2XBgERERERUDAMSERERUTEMSERERETFMCARERERFcOARERERFQMAxIRERFRMQxIRERERMUwIBEREREVw4BEREREVAwDEhEREVExDEhERERExTAgERERERXDgERERERUjI7UBVRVQggAQGZmpsSVEBERUWk9+dx+8jn+LAxI5fTw4UMAgIODg8SVEBERUVk9fPgQ5ubmz7xfJl4UoahEKpUKCQkJMDU1hUwmk7qcSikzMxMODg6Ii4uDmZmZ1OXUePx9VC78fVQu/H1ULtr8fQgh8PDhQ9jb20Muf/ZMI/YglZNcLke9evWkLqNKMDMz4x+cSoS/j8qFv4/Khb+PykVbv4/n9Rw9wUnaRERERMUwIBEREREVw4BEWqOvr4958+ZBX19f6lII/H1UNvx9VC78fVQuleH3wUnaRERERMWwB4mIiIioGAYkIiIiomIYkIiIiIiKYUAiIiIiKoYBiSqUv78/OnToAFNTU1hbW2PAgAG4efOm1GXRY1999RVkMhmmTp0qdSk1Wnx8PN577z3UqVMHhoaGaNmyJc6fPy91WTWSUqnEnDlz4OTkBENDQzg7O2PhwoUv3KeLKsaJEyfg5+cHe3t7yGQy7Nq1S+N+IQTmzp0LOzs7GBoaomfPnrh9+/YrqY0BiSrU8ePHMWnSJJw5cwaHDh1CQUEBevfujezsbKlLq/HOnTuHH3/8Ea1atZK6lBrtwYMH6NSpE3R1dbF//35cv34d3333HWrVqiV1aTXS119/jVWrVmH58uUIDw/H119/jSVLluCHH36QurQaITs7G25ublixYkWJ9y9ZsgTff/89Vq9ejbNnz8LY2Bi+vr7Izc3Vem38mj9pVUpKCqytrXH8+HF07dpV6nJqrKysLLRt2xYrV67El19+idatWyMgIEDqsmqkmTNn4vTp0zh58qTUpRCA119/HTY2Nli7dq362MCBA2FoaIhNmzZJWFnNI5PJ8Oeff2LAgAEAinqP7O3t8fHHH+OTTz4BAGRkZMDGxga//PILBg8erNV62INEWpWRkQEAqF27tsSV1GyTJk1Cv3790LNnT6lLqfH27NmD9u3b4z//+Q+sra3Rpk0b/PTTT1KXVWN5eXnhyJEjuHXrFgDg0qVLOHXqFPr27StxZRQdHY3ExESNv1vm5ubw8PBAcHCw1p+fm9WS1qhUKkydOhWdOnVCixYtpC6nxtq6dSvCwsJw7tw5qUshAFFRUVi1ahWmT5+Ozz77DOfOncOHH34IPT09jBgxQuryapyZM2ciMzMTLi4uUCgUUCqVWLRoEYYOHSp1aTVeYmIiAMDGxkbjuI2Njfo+bWJAIq2ZNGkSrl69ilOnTkldSo0VFxeHjz76CIcOHYKBgYHU5RCK/uHQvn17LF68GADQpk0bXL16FatXr2ZAksD27duxefNmbNmyBc2bN8fFixcxdepU2Nvb8/dRw3GIjbRi8uTJ+Pvvv3Hs2DHUq1dP6nJqrNDQUCQnJ6Nt27bQ0dGBjo4Ojh8/ju+//x46OjpQKpVSl1jj2NnZwdXVVeNYs2bNEBsbK1FFNduMGTMwc+ZMDB48GC1btsSwYcMwbdo0+Pv7S11ajWdrawsASEpK0jielJSkvk+bGJCoQgkhMHnyZPz55584evQonJycpC6pRuvRoweuXLmCixcvqm/t27fH0KFDcfHiRSgUCqlLrHE6der01NIXt27dQoMGDSSqqGbLycmBXK75UahQKKBSqSSqiJ5wcnKCra0tjhw5oj6WmZmJs2fPwtPTU+vPzyE2qlCTJk3Cli1bsHv3bpiamqrHic3NzWFoaChxdTWPqanpU/O/jI2NUadOHc4Lk8i0adPg5eWFxYsXY9CgQQgJCcGaNWuwZs0aqUurkfz8/LBo0SLUr18fzZs3x4ULF7B06VJ88MEHUpdWI2RlZSEiIkL9c3R0NC5evIjatWujfv36mDp1Kr788ks0btwYTk5OmDNnDuzt7dXfdNMqQVSBAJR4W79+vdSl0WPe3t7io48+krqMGu2vv/4SLVq0EPr6+sLFxUWsWbNG6pJqrMzMTPHRRx+J+vXrCwMDA9GwYUPx+eefi7y8PKlLqxGOHTtW4mfGiBEjhBBCqFQqMWfOHGFjYyP09fVFjx49xM2bN19JbVwHiYiIiKgYzkEiIiIiKoYBiYiIiKgYBiQiIiKiYhiQiIiIiIphQCIiIiIqhgGJiIiIqBgGJCIiIqJiGJCIiMpJJpNh165dUpdBRFrAgEREVdL7778PmUz21K1Pnz5Sl0ZE1QD3YiOiKqtPnz5Yv369xjF9fX2JqiGi6oQ9SERUZenr68PW1lbjVqtWLQBFw1+rVq1C3759YWhoiIYNG+KPP/7QePyVK1fQvXt3GBoaok6dOhg7diyysrI0zlm3bh2aN28OfX192NnZYfLkyRr3p6am4s0334SRkREaN26MPXv2qO978OABhg4dCisrKxgaGqJx48ZPBToiqpwYkIio2pozZw4GDhyIS5cuYejQoRg8eDDCw8MBANnZ2fD19UWtWrVw7tw5/P777zh8+LBGAFq1ahUmTZqEsWPH4sqVK9izZw8aNWqk8RxffPEFBg0ahMuXL+O1117D0KFDkZaWpn7+69evY//+/QgPD8eqVatgaWn56l4AIiq/V7IlLhFRBRsxYoRQKBTC2NhY47Zo0SIhhBAAxPjx4zUe4+HhISZMmCCEEGLNmjWiVq1aIisrS33/3r17hVwuF4mJiUIIIezt7cXnn3/+zBoAiNmzZ6t/zsrKEgDE/v37hRBC+Pn5iZEjR1bMBRPRK8U5SERUZXXr1g2rVq3SOFa7dm31f3t6emrc5+npiYsXLwIAwsPD4ebmBmNjY/X9nTp1gkqlws2bNyGTyZCQkIAePXo8t4ZWrVqp/9vY2BhmZmZITk4GAEyYMAEDBw5EWFgYevfujQEDBsDLy6tc10pErxYDEhFVWcbGxk8NeVUUQ0PDUp2nq6ur8bNMJoNKpQIA9O3bFzExMdi3bx8OHTqEHj16YNKkSfj2228rvF4iqlicg0RE1daZM2ee+rlZs2YAgGbNmuHSpUvIzs5W33/69GnI5XI0bdoUpqamcHR0xJEjR16qBisrK4wYMQKbNm1CQEAA1qxZ81LtEdGrwR4kIqqy8vLykJiYqHFMR0dHPRH6999/R/v27dG5c2ds3rwZISEhWLt2LQBg6NChmDdvHkaMGIH58+cjJSUFU6ZMwbBhw2BjYwMAmD9/PsaPHw9ra2v07dsXDx8+xOnTpzFlypRS1Td37ly0a9cOzZs3R15eHv7++291QCOiyo0BiYiqrAMHDsDOzk7jWNOmTXHjxg0ARd8w27p1KyZOnAg7Ozv89ttvcHV1BQAYGRnh4MGD+Oijj9ChQwcYGRlh4MCBWLp0qbqtESNGIDc3F8uWLcMnn3wCS0tLvP3226WuT09PD7NmzcKdO3dgaGiILl26YOvWrRVw5USkbTIhhJC6CCKiiiaTyfDnn39iwIABUpdCRFUQ5yARERERFcOARERERFQM5yARUbXE2QNE9DLYg0RERERUDAMSERERUTEMSERERETFMCARERERFcOARERERFQMAxIRERFRMQxIRERERMUwIBEREREVw4BEREREVMz/A+O00SqpVvTeAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **After (Using Adam Optimizer or SGD with Momentum)**\n",
        "\n",
        "**Adam Optimizer Initialization:** The Adam optimizer is initialized with the neural network parameters (`net.parameters()`) and a learning rate (`lr=0.001`).\n",
        "\n",
        "**Training Loop:** The loop runs for 10 epochs, where an epoch refers to one full pass over the training dataset.\n",
        "   \n",
        "   - **Epoch Loop:** The outer loop iterates over 10 epochs.\n",
        "\n",
        "   - **Batch Loop:** The inner loop iterates over batches of data from the `trainloader`. Each batch contains a set of inputs (`inputs`) and corresponding labels (`labels`).\n",
        "\n",
        "   - **Forward Pass:** The inputs are passed through the network (`net`) to get the predicted outputs (`outputs`).\n",
        "\n",
        "   - **Loss Calculation:** The loss between the predicted outputs and the actual labels is computed using the predefined loss function (`criterion`).\n",
        "\n",
        "   - **Backpropagation and Optimization:**  \n",
        "    - `loss.backward()` computes the gradient of the loss with respect to the model parameters.\n",
        "     - `optimizer.step()` updates the model parameters based on the gradients and the Adam optimization algorithm.\n",
        "\n",
        "   - **Loss Accumulation:** The loss for each batch is accumulated over the entire epoch.\n",
        "\n",
        "   - **Average Loss Calculation:** The average loss for each epoch is calculated and stored in the `losses_adam` list.\n",
        "\n",
        "**Plotting the Loss:** After training, the code plots the loss for for each epoch using Matplotlib. This line generates a graph of the loss across 10 epochs."
      ],
      "metadata": {
        "id": "fhfj9ilijhRQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Adam optimizer, capturing loss\n",
        "losses_adam = []\n",
        "optimizer = optim.Adam(net.parameters(), lr=0.001)\n",
        "\n",
        "for epoch in range(10):\n",
        "    running_loss = 0.0\n",
        "    for i, data in enumerate(trainloader, 0):\n",
        "        inputs, labels = data\n",
        "        optimizer.zero_grad()\n",
        "        outputs = net(inputs)\n",
        "        loss = criterion(outputs, labels)\n",
        "        loss.backward()\n",
        "        optimizer.step()\n",
        "        running_loss += loss.item()\n",
        "    avg_loss = running_loss / len(trainloader)\n",
        "    losses_adam.append(avg_loss)\n",
        "    print(f'Epoch {epoch+1}, Loss: {avg_loss}')\n",
        "\n",
        "# Plot loss for Adam\n",
        "plt.plot(range(1, 11), losses_adam, label='Adam', color='green')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Loss After Optimization (Adam)')\n",
        "plt.legend()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 651
        },
        "id": "RWLYmY1WN1xD",
        "outputId": "7133c06a-7375-4b50-aae1-e1bced6e7077"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1, Loss: 1.038308641910553\n",
            "Epoch 2, Loss: 0.9993563054800033\n",
            "Epoch 3, Loss: 0.9606791644096374\n",
            "Epoch 4, Loss: 0.9409018951654434\n",
            "Epoch 5, Loss: 0.9268458477258682\n",
            "Epoch 6, Loss: 0.9065835143327713\n",
            "Epoch 7, Loss: 0.885388695716858\n",
            "Epoch 8, Loss: 0.8763056117296218\n",
            "Epoch 9, Loss: 0.8524376670122147\n",
            "Epoch 10, Loss: 0.8380806605815887\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Comparison Plot (Before and After Optimization)**\n",
        "\n",
        "The code provided is for generating a comparison plot of loss values between two optimization algorithms, Stochastic Gradient Descent (SGD) and Adam.\n",
        "\n",
        "  - **plt.plot(range(1, 11), losses_sgd, label='SGD', color='red'):** This line creates a line plot for the loss values (losses_sgd) obtained using the SGD optimizer.\n",
        "    - **range(1, 11)** represents the x-axis values (1 to 10 epochs).\n",
        "    - **losses_sgd** is an array or list containing the loss values over these 10 epochs.\n",
        "    - The label **'SGD'** is used to identify the line in the legend. The line color is set to red.\n",
        "\n",
        "  - **plt.plot(range(1, 11), losses_adam, label='Adam', color='green'):** This line creates another line plot for the loss values (losses_adam) using the Adam optimizer.\n",
        "    - **range(1, 11)** again represents the epochs (same x-axis).\n",
        "    - **losses_adam** is an array or list containing the loss values for the Adam optimizer. The line color is green, and the label is 'Adam'.\n",
        "\n",
        "  - **plt.xlabel('Epochs'):** Sets the label for the x-axis as \"Epochs\" (the number of training iterations).\n",
        "\n",
        "  - **plt.ylabel('Loss'):** Sets the label for the y-axis as \"Loss\", which represents the error or the loss function values.\n",
        "\n",
        "  - **plt.title('Loss Comparison: SGD vs Adam'):** Gives the plot a title, \"Loss Comparison: SGD vs Adam\", to describe what the graph shows.\n",
        "\n",
        "  - **plt.legend():** Adds a legend to the plot that labels each line according to the specified labels ('SGD' and 'Adam').\n",
        "\n",
        "  - **plt.show():** Displays the plot with the provided data and configurations."
      ],
      "metadata": {
        "id": "79OIe2IGnFxd"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Comparison Plot: SGD vs Adam\n",
        "plt.plot(range(1, 11), losses_sgd, label='SGD', color='red')\n",
        "plt.plot(range(1, 11), losses_adam, label='Adam', color='green')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Loss Comparison: SGD vs Adam')\n",
        "plt.legend()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "O3UNiaLROnDd",
        "outputId": "65e979d3-3ce8-463f-8383-f60f3f29d91d"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# **Strategies to Improve Saddle Point Handling**\n",
        "\n",
        "## **Learning Rate Scheduling**\n",
        "\n",
        "\n",
        "#### **1. Importing `matplotlib` for plotting:** This imports the **`matplotlib`** library, specifically its `pyplot` module, which is used to create various types of plots such as line plots, bar plots, etc.\n",
        "\n",
        "#### **2. Initializing the Learning Rate Scheduler:** This sets up a learning rate scheduler using `StepLR`. It reduces the learning rate by a factor of **`gamma`** (0.1) every **`step_size`** (5) epochs. Adjusting the learning rate during training can help improve the model's performance, especially after it plateaus.\n",
        "\n",
        "#### **3. Initializing `epoch_losses` List:** This initializes an empty list to store the average loss for each epoch. We store the average loss for each epoch so that it can be used to plot the loss curve later.\n",
        "\n",
        "#### **4. Main Training Loop (over 10 epochs):** This is the main training loop that trains the model over 10 epochs.\n",
        "  - **`running_loss = 0.0`**: Resets the running loss at the start of each epoch.\n",
        "  - **Inner loop**: Loops over each batch in the training dataset (`trainloader`).\n",
        "    - **`inputs, labels = data`**: Extracts input data and corresponding labels from the batch.\n",
        "    - **`optimizer.zero_grad()`**: Resets the gradients to zero for each batch before backpropagation.\n",
        "    - **`outputs = net(inputs)`**: Performs a forward pass through the neural network `net` to get predictions.\n",
        "    - **`loss = criterion(outputs, labels)`**: Calculates the loss using the specified loss function (`criterion`), comparing predictions and actual labels.\n",
        "    - **`loss.backward()`**: Backpropagates the loss to compute gradients for the model’s parameters.\n",
        "    - **`optimizer.step()`**: Updates the model parameters using the computed gradients.\n",
        "    - **`running_loss += loss.item()`**: Accumulates the loss for each batch in the `running_loss` variable.\n",
        "\n",
        "  - This block is where the training happens. It updates the model's weights and calculates the total loss for each epoch.\n",
        "\n",
        "#### **5. Learning Rate Scheduler Step:** This updates the learning rate after each epoch according to the scheduler's rules (in this case, reducing the learning rate by a factor of 0.1 every 5 epochs). Adjusting the learning rate during training can help the model converge better, especially when the loss plateaus or oscillates.\n",
        "\n",
        "#### **6. Calculating and Storing the Average Loss for Each Epoch:**\n",
        "  - **`avg_loss = running_loss / len(trainloader)`**: Computes the average loss for the current epoch by dividing the total accumulated loss (`running_loss`) by the number of batches in the training set (`len(trainloader)`).\n",
        "  - **`epoch_losses.append(avg_loss)`**: Adds the calculated average loss to the `epoch_losses` list.\n",
        "  - This allows you to track the average loss across epochs for later analysis and visualization.\n",
        "\n",
        "#### **7. Printing the Average Loss per Epoch:** This prints the average loss for the current epoch. It provides real-time feedback on the model’s performance during training, allowing you to monitor how the loss is decreasing across epochs.\n",
        "#### **8. Plotting the Loss Curve After Training:** This block plots the loss values stored in `epoch_losses` against the epoch numbers.\n",
        "  - **`plt.plot(range(1, 11), epoch_losses)`**: Creates a line plot with epoch numbers on the x-axis (from 1 to 10) and average loss values on the y-axis.\n",
        "  - **`marker='o'`**: Adds markers to each data point to make the plot more readable.\n",
        "  - **`color='b'`**: Specifies blue color for the line.\n",
        "  - **`plt.title('Training Loss per Epoch')`**: Adds a title to the plot.\n",
        "  - **`plt.xlabel('Epoch')` and `plt.ylabel('Loss')`**: Label the x and y axes.\n",
        "  - **`plt.grid(True)`**: Adds grid lines to the plot.\n",
        "  - **`plt.legend()`**: Adds a legend to the plot, labeling the line as \"Loss\".\n",
        "  - **`plt.show()`**: Displays the plot on the screen.\n",
        "  \n",
        "- This visualization helps you assess whether the training process is working correctly. If the loss is decreasing, the model is learning. If it plateaus or increases, there may be issues to investigate (e.g., learning rate, model architecture, etc.).\n"
      ],
      "metadata": {
        "id": "nu8rP_tprrra"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Initialize the learning rate scheduler\n",
        "scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1)\n",
        "\n",
        "# List to store the loss at each epoch\n",
        "epoch_losses = []\n",
        "\n",
        "for epoch in range(10):\n",
        "    running_loss = 0.0  # Initialize running_loss at the start of each epoch\n",
        "    for i, data in enumerate(trainloader, 0):\n",
        "        inputs, labels = data\n",
        "\n",
        "        optimizer.zero_grad()  # Reset gradients\n",
        "\n",
        "        outputs = net(inputs)  # Forward pass\n",
        "        loss = criterion(outputs, labels)  # Calculate loss\n",
        "\n",
        "        loss.backward()  # Backpropagate the loss\n",
        "        optimizer.step()  # Update model parameters\n",
        "\n",
        "        running_loss += loss.item()  # Accumulate the loss (convert tensor to a Python number)\n",
        "\n",
        "    scheduler.step()  # Adjust learning rate after every epoch\n",
        "\n",
        "    # Compute average loss for this epoch\n",
        "    avg_loss = running_loss / len(trainloader)\n",
        "    epoch_losses.append(avg_loss)  # Store the average loss for this epoch\n",
        "\n",
        "    # Print the average loss for this epoch\n",
        "    print(f'Epoch {epoch+1}, Loss: {avg_loss}')\n",
        "\n",
        "# Plotting the loss curve\n",
        "plt.plot(range(1, 11), epoch_losses, marker='o', color='b', label='Loss')\n",
        "plt.title('Training Loss per Epoch')\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Loss')\n",
        "plt.grid(True)\n",
        "plt.legend()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 651
        },
        "id": "E0MW8RpnG5hh",
        "outputId": "7f924cc3-40b6-410e-fea9-8af6bb9c0328"
      },
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Epoch 1, Loss: 0.7405920437574387\n",
            "Epoch 2, Loss: 0.736799397945404\n",
            "Epoch 3, Loss: 0.711026372551918\n",
            "Epoch 4, Loss: 0.7054688773751259\n",
            "Epoch 5, Loss: 0.6827691122293472\n",
            "Epoch 6, Loss: 0.5176242384314537\n",
            "Epoch 7, Loss: 0.48635926461219786\n",
            "Epoch 8, Loss: 0.47831941479444506\n",
            "Epoch 9, Loss: 0.47204986268281934\n",
            "Epoch 10, Loss: 0.4663036950826645\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## **Weight Initialization**\n",
        "\n",
        "####**Network Architecture:** The model uses two convolutional layers followed by max pooling, which is a standard architecture for image classification tasks. The fully connected layers are used to map the features extracted by the convolutional layers to the output classes.\n",
        "\n",
        "####**He Initialization:** The weights of the convolutional and fully connected layers are initialized using He initialization, which helps improve training performance.\n",
        "\n",
        "####**CIFAR-10 Dataset:** The dataset is loaded using the torchvision.datasets.CIFAR10 class, with normalization applied to improve training stability.\n",
        "\n",
        "####**Training Loop:** The model is trained for 10 epochs, and the average loss is printed for each epoch. The loss history is stored for visualization.\n",
        "\n",
        "####**Visualization:** The loss history is plotted to observe the training process and convergence behavior."
      ],
      "metadata": {
        "id": "AwO5VvzI8mcT"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import torch\n",
        "import torch.nn as nn\n",
        "import torch.optim as optim\n",
        "import torchvision\n",
        "import torchvision.transforms as transforms\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Define the neural network architecture\n",
        "class Net(nn.Module):\n",
        "    def __init__(self):\n",
        "        super(Net, self).__init__()\n",
        "        self.conv1 = nn.Conv2d(3, 32, 3, padding=1)  # Convolutional layer 1\n",
        "        self.conv2 = nn.Conv2d(32, 64, 3, padding=1)  # Convolutional layer 2\n",
        "        self.fc1 = nn.Linear(64 * 8 * 8, 128)         # Fully connected layer 1\n",
        "        self.fc2 = nn.Linear(128, 10)                  # Output layer\n",
        "\n",
        "        # Apply He initialization\n",
        "        nn.init.kaiming_uniform_(self.conv1.weight, nonlinearity='relu')\n",
        "        nn.init.kaiming_uniform_(self.conv2.weight, nonlinearity='relu')\n",
        "        nn.init.kaiming_uniform_(self.fc1.weight, nonlinearity='relu')\n",
        "\n",
        "    def forward(self, x):\n",
        "        x = torch.relu(self.conv1(x))  # First convolutional layer with ReLU activation\n",
        "        x = nn.MaxPool2d(2)(x)         # Max pooling\n",
        "        x = torch.relu(self.conv2(x))  # Second convolutional layer with ReLU activation\n",
        "        x = nn.MaxPool2d(2)(x)         # Max pooling\n",
        "        x = x.view(-1, 64 * 8 * 8)     # Flatten the input\n",
        "        x = torch.relu(self.fc1(x))     # Fully connected layer with ReLU activation\n",
        "        x = self.fc2(x)                 # Output layer\n",
        "        return x\n",
        "\n",
        "# Load CIFAR-10 dataset\n",
        "transform = transforms.Compose([\n",
        "    transforms.ToTensor(),\n",
        "    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # Normalize images\n",
        "])\n",
        "\n",
        "trainset = torchvision.datasets.CIFAR10(root='./data', train=True, download=True, transform=transform)\n",
        "trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)\n",
        "\n",
        "# Initialize the model, loss function, and optimizer\n",
        "net = Net()\n",
        "criterion = nn.CrossEntropyLoss()\n",
        "optimizer = optim.Adam(net.parameters(), lr=0.001)\n",
        "\n",
        "# Define a function to train the model and store the loss history\n",
        "def train_model(optimizer, optimizer_name):\n",
        "    loss_history = []\n",
        "\n",
        "    # Training loop\n",
        "    for epoch in range(10):\n",
        "        running_loss = 0.0\n",
        "        for i, data in enumerate(trainloader, 0):\n",
        "            inputs, labels = data\n",
        "            optimizer.zero_grad()  # Clear the gradients\n",
        "            outputs = net(inputs)  # Forward pass\n",
        "            loss = criterion(outputs, labels)  # Compute loss\n",
        "            loss.backward()  # Backward pass\n",
        "            optimizer.step()  # Update weights\n",
        "            running_loss += loss.item()  # Accumulate loss\n",
        "        avg_loss = running_loss / len(trainloader)\n",
        "        loss_history.append(avg_loss)\n",
        "        print(f'{optimizer_name} - Epoch {epoch+1}, Loss: {avg_loss:.4f}')\n",
        "\n",
        "    return loss_history\n",
        "\n",
        "# Train the model using Adam optimizer with He initialization\n",
        "adam_loss_history = train_model(optimizer, \"Adam\")\n",
        "\n",
        "# Plot the loss history for visualization\n",
        "plt.plot(range(1, 11), adam_loss_history, label='Adam Loss (He Initialization)')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.title('Loss History with Adam Optimizer and He Initialization on CIFAR-10')\n",
        "plt.legend()\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 669
        },
        "id": "gH1IjiKCL8F_",
        "outputId": "35bb0cd9-5649-4f2e-f475-c24f03587717"
      },
      "execution_count": 11,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Files already downloaded and verified\n",
            "Adam - Epoch 1, Loss: 1.2803\n",
            "Adam - Epoch 2, Loss: 0.9186\n",
            "Adam - Epoch 3, Loss: 0.7658\n",
            "Adam - Epoch 4, Loss: 0.6414\n",
            "Adam - Epoch 5, Loss: 0.5304\n",
            "Adam - Epoch 6, Loss: 0.4308\n",
            "Adam - Epoch 7, Loss: 0.3366\n",
            "Adam - Epoch 8, Loss: 0.2578\n",
            "Adam - Epoch 9, Loss: 0.1920\n",
            "Adam - Epoch 10, Loss: 0.1493\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}