4_1_Simple_Neural_Network_for_XOR.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E8QVFt12PMSr"
      },
      "source": [
        "<center>\n",
        "    <img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-DL0110EN-SkillsNetwork/Template/module%201/images/IDSNlogo.png\" width=\"300\" alt=\"cognitiveclass.ai logo\"  />\n",
        "</center>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "c1J8Bq_oPMSs"
      },
      "source": [
        "<h1>Practice: Neural Networks with One Hidden Layer: Noisy XOR</h1>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hymROnFAPMSt"
      },
      "source": [
        "<h2>Objective</h2><p>After completing this lab you will be able to:</p> \n",
        "<ul><li> Create a neural network model with multiple neurons to model a simple function.</li></ul>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "48LMhtJgPMSt"
      },
      "source": [
        "<h2>Table of Contents</h2>\n",
        "<p>In this lab, you will see how many neurons it takes to classify noisy XOR data with one hidden layer neural network.</p>\n",
        "\n",
        "<ul>\n",
        "    <li><a href=\"https://#Model\">Neural Network Module and Training Function</a></li>\n",
        "    <li><a href=\"https://#Makeup_Data\">Make Some Data</a></li>\n",
        "    <li><a href=\"https://#One\">One Neuron</a></li>\n",
        "    <li><a href=\"https://#Two\">Two Neurons</a></li>\n",
        "    <li><a href=\"https://#Three\">Three Neurons</a></li>\n",
        "</ul>\n",
        "<p>Estimated Time Needed: <strong>25 min</strong></p>\n",
        "<hr>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KYWKYcmdPMSt"
      },
      "source": [
        "<h2>Preparation</h2>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YVRtp1dBPMSu"
      },
      "source": [
        "We'll need the following libraries\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "FBlCuWrCPMSu"
      },
      "outputs": [],
      "source": [
        "# Import the libraries we need for this lab\n",
        "\n",
        "# Allows us to use arrays to manipulate and store data\n",
        "import numpy as np\n",
        "# PyTorch Library\n",
        "import torch\n",
        "# PyTorch Neural Network\n",
        "import torch.nn as nn\n",
        "# Allows us to use activation functions\n",
        "import torch.nn.functional as F\n",
        "# Used to graph data and loss curves\n",
        "import matplotlib.pyplot as plt \n",
        "from matplotlib.colors import ListedColormap\n",
        "# Used to help create the dataset and perform mini-batch\n",
        "from torch.utils.data import Dataset, DataLoader"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QmI-5KNQPMSv"
      },
      "source": [
        "Use the following function to plot the data:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "9APkwD1APMSv"
      },
      "outputs": [],
      "source": [
        "# Plot the data\n",
        "\n",
        "def plot_decision_regions_2class(model,data_set):\n",
        "    cmap_light = ListedColormap(['#FFAAAA', '#AAFFAA', '#00AAFF'])\n",
        "    cmap_bold = ListedColormap(['#FF0000', '#00FF00', '#00AAFF'])\n",
        "    X = data_set.x.numpy()\n",
        "    y = data_set.y.numpy()\n",
        "    h = .02\n",
        "    x_min, x_max = X[:, 0].min() - 0.1 , X[:, 0].max() + 0.1 \n",
        "    y_min, y_max = X[:, 1].min() - 0.1 , X[:, 1].max() + 0.1 \n",
        "    xx, yy = np.meshgrid(np.arange(x_min, x_max, h),np.arange(y_min, y_max, h))\n",
        "    XX = torch.Tensor(np.c_[xx.ravel(), yy.ravel()])\n",
        "\n",
        "    yhat = np.logical_not((model(XX)[:, 0] > 0.5).numpy()).reshape(xx.shape)\n",
        "    plt.pcolormesh(xx, yy, yhat, cmap=cmap_light, shading='auto')\n",
        "    plt.plot(X[y[:, 0] == 0, 0], X[y[:, 0] == 0, 1], 'o', label='y=0')\n",
        "    plt.plot(X[y[:, 0] == 1, 0], X[y[:, 0] == 1, 1], 'ro', label='y=1')\n",
        "    plt.title(\"decision region\")\n",
        "    plt.legend()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sWNrzHH1PMSv"
      },
      "source": [
        "Use the following function to calculate accuracy:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "u7JMTazdPMSv"
      },
      "outputs": [],
      "source": [
        "# Calculate the accuracy\n",
        "\n",
        "def accuracy(model, data_set):\n",
        "    # Rounds prediction to nearest integer 0 or 1\n",
        "    # Checks if prediction matches the actual values and returns accuracy rate\n",
        "    return np.mean(data_set.y.view(-1).numpy() == (model(data_set.x)[:, 0] > 0.5).numpy())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gMxftjkRPMSw"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1gxujbOaPMSw"
      },
      "source": [
        "<h2 id=\"Model\">Neural Network Module and Training Function</h2> \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Zp-EcuRsPMSw"
      },
      "source": [
        "Define the neural network module or class:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "CV5YcUhdPMSw"
      },
      "outputs": [],
      "source": [
        "# Define the class Net with one hidden layer \n",
        "\n",
        "class Net(nn.Module):\n",
        "    \n",
        "    # Constructor\n",
        "    def __init__(self, D_in, H, D_out):\n",
        "        super(Net, self).__init__()\n",
        "        # D_in is the input size of the first layer (size of input layer)\n",
        "        # H is the outpout size of the first layer and the input size of the second layer (size of hidden layer)\n",
        "        # D_out is the output size of the second layer (size of output layer)\n",
        "        self.linear1 = nn.Linear(D_in, H)\n",
        "        self.linear2 = nn.Linear(H, D_out)\n",
        "\n",
        "    # Prediction    \n",
        "    def forward(self, x):\n",
        "        # Puts x through first layer then sigmoid function\n",
        "        x = torch.sigmoid(self.linear1(x)) \n",
        "        # Puts result of previous line through second layer then sigmoid function\n",
        "        x = torch.sigmoid(self.linear2(x))\n",
        "        # Output is a number between 0 and 1 due to the sigmoid function. Whichever the output is closer to, 0 or 1, is the class prediction\n",
        "        return x"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mIhAlPREPMSw"
      },
      "source": [
        "Define a function to train the model:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "8uqN8R-vPMSx"
      },
      "outputs": [],
      "source": [
        "# Function to Train the Model\n",
        "\n",
        "def train(data_set, model, criterion, train_loader, optimizer, epochs=5):\n",
        "    # Lists to keep track of cost and accuracy\n",
        "    COST = []\n",
        "    ACC = []\n",
        "    # Number of times we train on the entire dataset\n",
        "    for epoch in range(epochs):\n",
        "        # Total loss over epoch\n",
        "        total=0\n",
        "        # For batch in train laoder\n",
        "        for x, y in train_loader:\n",
        "            # Resets the calculated gradient value, this must be done each time as it accumulates if we do not reset\n",
        "            optimizer.zero_grad()\n",
        "            # Makes a prediction based on X value\n",
        "            yhat = model(x)\n",
        "            # Measures the loss between prediction and acutal Y value\n",
        "            loss = criterion(yhat, y)\n",
        "            # Calculates the gradient value with respect to each weight and bias\n",
        "            loss.backward()\n",
        "            # Updates the weight and bias according to calculated gradient value\n",
        "            optimizer.step()\n",
        "            # Cumulates loss \n",
        "            total+=loss.item()\n",
        "        # Saves cost and accuracy\n",
        "        ACC.append(accuracy(model, data_set))\n",
        "        COST.append(total)\n",
        "        \n",
        "    # Prints Cost vs Epoch graph\n",
        "    fig, ax1 = plt.subplots()\n",
        "    color = 'tab:red'\n",
        "    ax1.plot(COST, color=color)\n",
        "    ax1.set_xlabel('epoch', color=color)\n",
        "    ax1.set_ylabel('total loss', color=color)\n",
        "    ax1.tick_params(axis='y', color=color)\n",
        "    \n",
        "    # Prints Accuracy vs Epoch graph\n",
        "    ax2 = ax1.twinx()  \n",
        "    color = 'tab:blue'\n",
        "    ax2.set_ylabel('accuracy', color=color)  # we already handled the x-label with ax1\n",
        "    ax2.plot(ACC, color=color)\n",
        "    ax2.tick_params(axis='y', color=color)\n",
        "    fig.tight_layout()  # otherwise the right y-label is slightly clipped\n",
        "    \n",
        "    plt.show()\n",
        "\n",
        "    return COST"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UJ3u3pNjPMSx"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p1AU5csxPMSx"
      },
      "source": [
        "<h2 id=\"Makeup_Data\">Make Some Data</h2> \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Oh8X7jXrPMSx"
      },
      "source": [
        "Dataset class:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "XPRaWgaDPMSy"
      },
      "outputs": [],
      "source": [
        "# Define the class XOR_Data\n",
        "\n",
        "class XOR_Data(Dataset):\n",
        "    \n",
        "    # Constructor\n",
        "    # N_s is the size of the dataset\n",
        "    def __init__(self, N_s=100):\n",
        "        # Create a N_s by 2 array for the X values representing the coordinates\n",
        "        self.x = torch.zeros((N_s, 2))\n",
        "        # Create a N_s by 1 array for the class the X value belongs to\n",
        "        self.y = torch.zeros((N_s, 1))\n",
        "        # Split the dataset into 4 sections\n",
        "        for i in range(N_s // 4):\n",
        "            # Create data centered around (0,0) of class 0\n",
        "            self.x[i, :] = torch.Tensor([0.0, 0.0]) \n",
        "            self.y[i, 0] = torch.Tensor([0.0])\n",
        "\n",
        "            # Create data centered around (0,1) of class 1\n",
        "            self.x[i + N_s // 4, :] = torch.Tensor([0.0, 1.0])\n",
        "            self.y[i + N_s // 4, 0] = torch.Tensor([1.0])\n",
        "    \n",
        "            # Create data centered around (1,0) of class 1\n",
        "            self.x[i + N_s // 2, :] = torch.Tensor([1.0, 0.0])\n",
        "            self.y[i + N_s // 2, 0] = torch.Tensor([1.0])\n",
        "    \n",
        "            # Create data centered around (1,1) of class 0\n",
        "            self.x[i + 3 * N_s // 4, :] = torch.Tensor([1.0, 1.0])\n",
        "            self.y[i + 3 * N_s // 4, 0] = torch.Tensor([0.0])\n",
        "\n",
        "            # Add some noise to the X values to make them different\n",
        "            self.x = self.x + 0.01 * torch.randn((N_s, 2))\n",
        "        self.len = N_s\n",
        "\n",
        "    # Getter\n",
        "    def __getitem__(self, index):    \n",
        "        return self.x[index],self.y[index]\n",
        "    \n",
        "    # Get Length\n",
        "    def __len__(self):\n",
        "        return self.len\n",
        "    \n",
        "    # Plot the data\n",
        "    def plot_stuff(self):\n",
        "        plt.plot(self.x[self.y[:, 0] == 0, 0].numpy(), self.x[self.y[:, 0] == 0, 1].numpy(), 'o', label=\"y=0\")\n",
        "        plt.plot(self.x[self.y[:, 0] == 1, 0].numpy(), self.x[self.y[:, 0] == 1, 1].numpy(), 'ro', label=\"y=1\")\n",
        "        plt.legend()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VUAcZ2d8PMSy"
      },
      "source": [
        "Dataset object:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 265
        },
        "id": "hCn3rTxePMSy",
        "outputId": "f489b68e-1895-48db-b28a-bfe59c4caf26"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Create dataset object\n",
        "\n",
        "data_set = XOR_Data()\n",
        "data_set.plot_stuff()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f-dpFobAPMSy"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2EUDw7o1PMSy"
      },
      "source": [
        "<h2 id=\"One\">One Neuron</h2> \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UhZdNichPMSy"
      },
      "source": [
        "<h3>Try</h3>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pPtuxOMTPMSz"
      },
      "source": [
        "Create a neural network <code>model</code> with one neuron in the hidden layer. Then, use the following code to train it:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "id": "-hKLkJ16PMSz"
      },
      "outputs": [],
      "source": [
        "# Practice: create a model with one neuron\n",
        "# Type your code here\n",
        "model = Net(2, 1, 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S0f1Z2NTPMSz"
      },
      "source": [
        "## Double-click <b>here</b> for the solution.\n",
        "\n",
        "<!-- \n",
        "model = Net(2, 1, 1)\n",
        "-->\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 561
        },
        "id": "T80hE8AxPMSz",
        "outputId": "7aba1db1-1fc7-4fb0-8256-7550fe45fb98"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Train the model\n",
        "\n",
        "learning_rate = 0.1\n",
        "# We create a criterion which will measure loss\n",
        "criterion = nn.BCELoss()\n",
        "# Create an optimizer that updates model parameters using the learning rate and gradient\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
        "# Create a Data Loader for the training data with a batch size of 1 \n",
        "train_loader = DataLoader(dataset=data_set, batch_size=1)\n",
        "# Using the training function train the model on 500 epochs\n",
        "LOSS12 = train(data_set, model, criterion, train_loader, optimizer, epochs=500)\n",
        "# Plot the data with decision boundaries\n",
        "plot_decision_regions_2class(model, data_set)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "INS6T6ogPMSz"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E5yS7UcRPMSz"
      },
      "source": [
        "<h2 id=\"Two\">Two Neurons</h2> \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fFvADNnyPMSz"
      },
      "source": [
        "<h3>Try</h3>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GwY3KeLuPMSz"
      },
      "source": [
        "Create a neural network <code>model</code> with two neurons in the hidden layer. Then, use the following code to train it:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "BWaF4vYXPMS0"
      },
      "outputs": [],
      "source": [
        "# Practice: create a model with two neuron\n",
        "# Type your code here\n",
        "model = Net(2, 2, 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xnyVXcDwPMS0"
      },
      "source": [
        "Double-click <b>here</b> for the solution.\n",
        "\n",
        "<!-- \n",
        "model = Net(2, 2, 1)\n",
        "-->\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "gV0__UMjPMS0",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 561
        },
        "outputId": "5b0a59a3-85e7-4b19-83ce-dc92abe2fd27"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Train the model\n",
        "\n",
        "learning_rate = 0.1\n",
        "# We create a criterion which will measure loss\n",
        "criterion = nn.BCELoss()\n",
        "# Create an optimizer with the model parameters and learning rate\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
        "# Create a Data Loader for the training data with a batch size of 1 \n",
        "train_loader = DataLoader(dataset=data_set, batch_size=1)\n",
        "# Using the training function train the model on 500 epochs\n",
        "LOSS12 = train(data_set, model, criterion, train_loader, optimizer, epochs=500)\n",
        "# Plot the data with decision boundaries\n",
        "plot_decision_regions_2class(model, data_set)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Z2z2VYU2PMS0"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dZ_3Vb5MPMS0"
      },
      "source": [
        "<h2 id=\"Three\">Three Neurons</h2> \n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3Vv3JgOHPMS0"
      },
      "source": [
        "<h3>Try</h3>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "lRRKfnVmPMS0"
      },
      "source": [
        "Create a neural network <code>model</code> with three neurons in the hidden layer. Then, use the following code to train it:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "Y-r6K29-PMS0"
      },
      "outputs": [],
      "source": [
        "# Practice: create a model with two neuron\n",
        "# Type your code here\n",
        "model = Net(2, 3, 1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "icKJPmf-PMS1"
      },
      "source": [
        "Double-click <b>here</b> for the solution.\n",
        "\n",
        "<!-- \n",
        "model = Net(2, 3, 1)\n",
        "-->\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "phrTxiGjPMS1",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 561
        },
        "outputId": "54926131-a835-4248-9eeb-0b520c9e74d7"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de5wkZX3v8c+vu+e2y17Y2Qt7AWYXFqaXqwa5RD1BBYWMAUREMFFIUDSKgPchJ1EPh7wyJEeMOSHqqihGBAXlsGEQREQIaoAlIrceYFkGd5a9sezu7HWmL7/zR1UPvcNcemaq5tL9fb9e/Zqqp56q+tWw9G+ep556ytwdERGRySYx0QGIiIgMRAlKREQmJSUoERGZlJSgRERkUlKCEhGRSSk10QGUI5FIeENDw0SHISIy5e3Zs8fdfUo0TqZEgmpoaGD37t0THYaIyJRnZnsnOoZyTYksKiIi1UcJSkREJiUlKBERmZSUoEREZFJSghIRkUlJCUpERCYlJSgREeljZjeY2WYze2qQ7WZm/2Jma8zsCTN7Y1yxxJqgzGy2md1mZh1mljGzU8xsjpnda2bPhz8PjDMGEREZke8BZwyx/Uxgefi5FPh6XIHE/aDu14C73f08M6sFpgF/A9zn7m1m1gq0Al+IOY79FHp72fb975Pf0c2cv7yY1Jw5Yz7mnt4c17Rn2LUvF0GEIiKDu+7840gl42lfuPuDZtY0RJWzge978DLB/wobIgvdfUPUscSWoMxsFvA/gIsB3L0X6DWzs4FTw2o3Ar9inBPUhqv+hu72dgB2//a3NN38Q6ymZkzHfLJrBz98+A8cNLOehtpkFGGKiAyoMIb3zCYaZqaaWttXlxSt7GxrWTmCQywG1pWsd4VlUydBAUuBLcB3zew44DHgCmBBSabdCCwYaOdMc/pSguYjnouuVbLrPx+iu72duZd/krqmJtZ/+jPsWPUfzH7vuWM6bk+uAMC/fuANnNA09haZiEgcCnu7c51tLSdMdBzliPMeVAp4I/B1d38DsJugO69P2EQc8G+BdEdmZbojc0K6I3OCpaLLo69+9wZSixYy98MfZsaZZ1LX3My2m24a83F7wwRVl1LrSUQq2nrg4JL1JWFZ5OJMUF1Al7s/HK7fRpCwNpnZQoDw5+YYY9hP77p17P7Nb5l93nlYbS1mxqyzz2bfM8/Q29k5pmMXW1B1NRoYKSIVbRXwoXA038nAjjjuP0GMCcrdNwLrzOzIsOgdwDMEF3dRWHYRcEdcMfS3/Sc/gUSC2ee+1p03852nA7DrwQfHdOyeXB6AupQSlIhMXWZ2M/Bb4Egz6zKzS8zsY2b2sbDKXcBaYA3wLeDjccUS9yi+TwI3hSP41gJ/SZAUf2xmlwAvAefHHAMQ3Mfa8dPbOeCtb6XmoIP6ymsWL6bm0EPY/V8PM+dDHxr18YstqFolKBGZwtz9wmG2O/CJ8Ygl1gTl7o8DA92Me0ec5x3IrgcfJLd5M7O/+Hev2zb9xJPovvtuvFDAEqNLMLoHJSISrar5c3/7rbeRnDeXA/7kT163reH44yjs3En2D38Y9fHVxSciEq2q+DbNbtrErgceYPY57xnweaf6o44CYO+TA87sUZaebLEFVRW/UhGR2FXFt+mO22+HQoHZ5713wO11hx2G1dWx7+mnR32OnlyBhBHb090iItWm4r9NvVBg+20/YdpJJ1F76KED1rGaGmqXLaNnzZpRn6c3X9D9JxGRCFV8gtrzX/9FtquL2e9735D16g4/nJ4XXhj1eXqyeT0DJSISoYr+Ru158UU2X/dVkrNmMeP004asW3f44eQ2bCC/a9fozpUrUKvuPRGRyFT0N+rOe37OvmeeofGjHyVRVzdk3brDlgHQ+2LnqM7VkyuoBSUiEqG4H9SdULPffz6z33suqXnzhq1bs2QJANn1XTQcc/SIz9Wb0z0oEZEoVXSCSh1Y/rsQ+xJUV9eoztWTy2uIuYhIhPSNGkoecADJWbPoHXWCKmiaIxGRCOkbtUTNkiVku0Y3a3xPtqAWlIhIhPSNWiJIUKNsQek5KBGRSClBlahZspjs+vV4oTDifXuyugclIhIlfaOWqF2yBM9myW3ZMuJ9e3UPSkQkUvpGLVGzeDEwupF8uYKTSljUIYmIVC0lqBJjGWqeLzjJUb5LSkREXk/fqCVqFi4EILtx04j3DRJU1BGJiFQvfaWWSDQ0kJgxg9zmzSPeN+9OUl18IiKRUYLqJzV//qgSVKGgBCUiEiUlqH5S8+eNahRfruAkTQlKRKY2MzvDzJ41szVm1jrA9kPN7D4ze8LMfmVmS+KKRQmqn5oxtKASakGJyBRmZkngeuBMYAVwoZmt6Fft/wDfd/djgauBf4grHiWoflLz55PdsgV3H9F+edcwcxGZ8k4E1rj7WnfvBW4Bzu5XZwXwy3D5/gG2R6aiZzMfjdS8+ZDNkt++fUSzoefUghKRKSDRMDPV1Nq+uqRoZWdby8pweTGwrmRbF3BSv0P8HjgX+BrwHmCGmTW6+9aoY1WC6ic1fz4Auc2bR5SgCnpQV0SmgMLe7lxnW8sJYzjEZ4F/NbOLgQeB9UA+itj6U4LqpzRBceSRZe+nQRIiUgHWAweXrC8Jy/q4+8sELSjM7ADgve6+PY5gdA+qn/0SVJkKheB+lbr4RGSKexRYbmZLzawWuABYVVrBzOaaWTF3XAXcEFcwsSYoM+s0syfN7HEzWx2WzTGze83s+fBn+f1o4yA1P3g9/EgSVD4cUKEuPhGZytw9B1wG3ANkgB+7+9NmdrWZnRVWOxV41syeAxYAfx9XPOPRxfc2d3+lZL0VuM/d28Ix9q3AF8YhjrIkamtJzppFdiQJSi0oEakQ7n4XcFe/si+WLN8G3DYesUxEF9/ZwI3h8o3AORMQw5CC2STKf1i3mKDUghIRiU7cCcqBn5vZY2Z2aVi2wN03hMsbCZqIk0pq/vwRzSZR7OJLaJCEiEhk4u7ie4u7rzez+cC9ZtZRutHd3cwGfCI205y+FLgUwHO5mMPcX2r+fHpeeKHs+vl8cAmai09EJDqxJih3Xx/+3GxmtxM8pbzJzBa6+wYzWwgMeLMn3ZFZCawEsOnTRzatwxgVW1BeKGBlvONJgyRERKIXWxefmU03sxnFZeCdwFMEQxYvCqtdBNwRVwyjlZo/D/J58q++WlZ9DZIQEYlenC2oBcDtFtyXSQE/dPe7zexR4MdmdgnwEnB+jDGMyn6zScydO2x9DZIQEYlebAnK3dcCxw1QvhV4R1znjUJNmKCymzZRv6L/RL6v19eC0iAJEZHIaCaJAfS1oMocyVdMUBokISISHSWoAaTmzgUzcpvKe1i3OEhCCUpEJDpKUAOwmhqSjY1lT3dUUAtKRCRySlCDSM2fV3aCyhUTlO5BiYhERglqEDXzF5Q9H5/uQYmIRE8JahDBfHxldvHpHpSISOSUoAaRmj+f/NateDY7bN2cWlAiIpFTghpE33uhXnllmJoaJCEiEgclqEHULAgmWc9t2jRsXQ2SEBGJnhLUIIoP65YzUEItKBGR6ClBDeK1+fiGn01CD+qKiERPCWoQyQMPxGpqyG3aOGxdDZIQEYmeEtQgLJEgtXAh2fUvD1tXXXwiItFTghpCzaJFZF8ePkFpNnMRkegpQQ1hpAkqlVSCEpGpzczOMLNnzWyNmbUOsP0QM7vfzH5nZk+Y2Z/GFYsS1BBqFi0KXv3e2ztkvb5BEmpBicgUZmZJ4HrgTGAFcKGZ9X8p3t8CP3b3NwAXAP8WVzxKUEOoWbQI3MluHHqghObiE5EKcSKwxt3XunsvcAtwdr86DswMl2cBw3czjVKcr3yf8moWLQIg+/LL1B5yyKD1lKBEZKpINMxMNbW2ry4pWtnZ1rIyXF4MrCvZ1gWc1O8QXwZ+bmafBKYDp8UVqxLUEGoWhwlqmJF8GiQhIlNFYW93rrOt5YQxHOJC4Hvu/hUzOwX4dzM72t0LEYXYR118Q6hZsADMhh0ooUESIlIh1gMHl6wvCctKXQL8GMDdfwvUA3PjCEYJaghWW0tq3rzhE5QGSYhIZXgUWG5mS82slmAQxKp+df4AvAPAzNIECWr4KXdGQQlqGDWLF5Pt6hqyjh7UFZFK4O454DLgHiBDMFrvaTO72szOCqt9BviImf0euBm42D38Kz1iugc1jNpDD2X3b34zZB1NdSQilcLd7wLu6lf2xZLlZ4A3j0csakENo7apidzmzRR27x60Tt8gCSUoEZHIKEENo7apCYDel14atE7fIAklKBGRyChBDaN26VIAejs7B62TzQejK1MJ/TpFRKKib9Rh1B4aPKDb8+KLg9bZvLOHmfUpalP6dYqIRCX2b1QzS4aTCt4Zri81s4fDiQh/FA5lnLQS9fWkFi2kt3PwLr6NO/Zx0Kz6cYxKRKTyjcef/FcQDFcsuhb4qrsfDmwjeOhrUqtrWjpkF9+m7n0smKkEJSISpVgTlJktAVqAb4frBrwduC2sciNwTpwxRKG2qYneF19ksKH+G7v3cZASlIhIpOJ+Duqfgc8DM8L1RmB7+DAYBBMRLh5ox0xz+lLgUgDP5QaqMm5qDz+Mwq5drFuzjtU798/p7rBlZ4+6+EREIhZbgjKzdwOb3f0xMzt1pPunOzIrgZUANn16LE8pl6t++XIAvnRnhvs3DZwsD59/wHiGJCJS8eJsQb0ZOCt822I9wftDvgbMNrNU2IoaaCLCSadu+XIcePyVXlqOWcznzzhyv+2pZIJFakGJiEQqtgTl7lcBVwGELajPuvufm9mtwHkEL8K6CLgjrhiikpw9m60HH862fIKTD2vk0MbpEx2SiEjFm4gHd74AfNrM1hDck/rOBMQwYhsPOwaA5oNmDFNTRESiMC6Txbr7r4BfhctrCV4rPKX44iWwGxr0zicRkXGhqQ/KtTB4uy6bN05sHCIiVUIJqlzzDwLA1/1hggMREakOSlBl8rnzgp8vDT4nn4iIREcJqky5ZHC7rrB27QRHIiJSHZSgypTNBa/UKKxdM8GRiIhUByWoMmXzwWQW/lInhZ6eCY5GRKTyKUGVqbf4UsJcL73q5hMRiZ0SVJn63ppbKNDz/PMTHI2ISDzM7AwzezZ8Z1/rANu/amaPh5/nzGx7XLGMy4O6lSCbL5BKGImalBKUiFQkM0sC1wOnE7xt4lEzW+XuzxTruPunSup/EnhDXPEMm6Ayzen3AXenOzI7M83pvwXeCFyT7sj8d1xBTUbZvFOTTFC3bBn7nntuosMREYnDicCacMYfzOwW4GzgmUHqXwh8aagDNrW2/5RgSrufdba1FEYSTDktqL9Ld2RuzTSn3wKcBvwT8HXgpJGcaKrrzRWoSRp1y5ez578fm+hwRERGJdEwM9XU2r66pGhlZ1vLynB5MbCuZFsXg3zXm9mhwFLgl8Oc8t+AvwT+pam1/Vbgu51tLc+WE2s5CSof/mwBVqY7Mu2Z5vQ15Ry8kmTzBWpTCeqWL6f7zjvJ79xJcoYmjhWRqaWwtzvX2dZyQgSHugC4zd3zQ1XqbGv5BfCLptb2WQQtrl80tbavA74F/KCzrSU72L7lDJJYn2lOfxN4P3BXpjldV+Z+FSWbLwRdfEcELy/seV7PQ4lIxVkPHFyyPtQ7+y4Abi7noE2t7Y3AxcCHgd8RvBvwjcC9Q+1XTqI5H7gHeFe6I7MdmAN8rpygKknfPajlRwBooISIVKJHgeVmttTMagmS0Kr+lcysGTgQ+O1wB2xqbb8d+E9gGvBnnW0tZ3W2tfyos63lk8CQryIvp4tvIdCe7sj0ZJrTpwLHAt8vY7+K0psP7kHVLFpIYto0ejRQQkQqjLvnzOwygkZJErjB3Z82s6uB1e5eTFYXALe4u5dx2H/pbGu5f6ANw3U1ltOC+gmQzzSnDwdWEjT/fljGfhUlmwu6+CyRoPbww+l9UQ/rikjlcfe73P0Idz/M3f8+LPtiSXLC3b/s7q97RmoQK5pa22cXV5pa2w9sam3/eDk7lpOgCumOTA44F/i/6Y7M5whaVVWlOEgCoHbJYnq7BuuWFRGREh/pbGvpe5i3s61lG/CRcnYsJ0FlM83pC4EPAXeGZTUjDnGKK96DAqhZvJjshg14fsjBKyIiAsmm1va+V5E3tbYngdpydiznHtRfAh8D/j7dkXkx05xeCvz7qMKcwor3oABqFi+BbJbc5s3ULKy6xqSIyEjcDfyoqbX9m+H6R8OyYQ3bgkp3ZJ4BPgs8mWlOHw10pTsy14420qmqOMwcghYUQHa9uvlERIbxBeB+4K/Dz33A58vZsZypjk4FbgQ6AQMOzjSnL0p3ZB4cZbBTUjZfoLaYoJYECaq3q4tpJ0TxvJuISGUKpzf6evgZkXK6+L4CvDPdkXkWINOcPoLg4aw/GunJprJsruQe1KJFQZlaUCIiQ2pqbV8O/AOwAqgvlne2tSwbbt9yBknUFJMTQLoj8xxVOUiiQE04ii9RV0dq/nyyGsknIjKc7xK0nnLA2wieo/1BOTuW04JanWlOf7vkgH8OrB6ifkUqHSQB4Ug+taBERIbT0NnWcl9Ta7t1trW8BHy5qbX9MeCLw+1YToL6a+ATwOXh+n8SzE5bVbL5AjWJ1xqcNUuWsPcxzWouIjKMnqbW9gTwfFNr+2UEc/sNOcVR0bAJKt2R6QGuCz9VK5d3UqUtqIMOonvzZrxQwBJVN3euiEi5riCYh+9y4H8TdPNdVM6OgyaoTHP6SWDQeZbSHZljRxbj1JYrOKnEawkqNW8e5HLkt28nNWfOBEYmIjI5hQ/lvr+zreWzwC6C52rLNlQL6t1jCczM6oEHgbrwPLe5+5fMbClwC9AIPAZ80N17x3Ku8VAoOMmSllJq/jwAclu2KEGJiAygs60l39Ta/pbR7j9ogkp3ZF4a7UFDPcDb3X2XmdUAD5nZz4BPA19191vM7BvAJYxifPx4yxX27+JLzQsT1OYtcOSRExWWiMhk97um1vZVwK3A7mJhZ1vLT4fbMbabJx7YFa7WhB8H3g7cFpbfCJwTVwxRyhecZP8uPoIWlIiIDKoe2Erw3f9n4aesHrpyRvGNmpklCbrxDgeuB14Atrt7LqzSBSweaN9Mc/pS4FIAz+UGqjKucoXC6+9BoQQlIjKUzraWEd13KhVrggrfVX+8mc0Gbgeay9033ZFZSfD+KWz69HJeihWbQsEpOPu1oBINDSQOOEAJSkRkCE2t7d9lgAF3nW0tfzXcvqMZxWeAj2QUn7tvN7P7gVOA2WaWCltRQ73vftLIhy+NTJrtV56aN08JSkRkaHeWLNcD7wFeLmfHOEfxzQOyYXJqAE4HriWY1fY8gpF8FwF3jOU84yFfCBNUUglKRGQkOttaflK63tTafjPwUDn7xjmKbyFwY3gfKgH82N3vNLNngFvM7Brgd8B3xnie2BUTVOk9KAgS1N4nnpiIkEREpqrlwPxyKpbzuo2Tgf8LpAnegpgEdqc7MjOH2s/dnwDeMED5WuDEcoKbLHLFFlS/GSOKLSh3x/p1/4mICDS1tu9k/9tFGwneETWscgZJ/CtwAcEY9hMIXv1+xAhjnNKGakH5vn0Udu0iOWPGRIQmIhIpMzsD+BpBY+Tb7t42QJ3zgS8TJJ7fu/sHBjteZ1vLqL8cy3oOKt2RWQMk0x2ZfLoj813gjNGecCrKFQrA/qP4YP/ZJEREprrwlsz1wJkE72+60MxW9KuzHLgKeLO7HwVcOdQxm1rb39PU2j6rZH12U2t7Wc+/lpOg9mSa07XA45nm9D9mmtOfKnO/itE3SKJ/gpo7N9i+deu4xyQiEoMTgTXuvjacgu4W4Ox+dT4CXO/u2wDcffMwx/xSZ1vLjuJKZ1vLduBL5QRTThffBwkS0mXAp4CDgXPLOXilyOUHTlDJOY3B9q2vjntMIiKjkWiYmWpqbS99p9/KzraWleHyYmBdybYu4KR+hzgCwMx+TdAN+GV3v3uoUw5QVtYzuOVUOifdkfkasA/4XwCZ5vQVBH2UVWHQe1CNwSSxuVfVghKRqaGwtzvX2dZywhgOkSIYiXcqwbOsD5rZMe6+fZD6q5ta268j6DqE4P2CZb1Mr5yuuoHe23FxOQevFH0P6vZvQc2eDWbk1YISkcqwnqCXrGigyRS6gFXunnX3F4HnCBLWYD4J9AI/Iugy3EeQpIY11EwSFwIfAJZmmtOrSjbNBKrqG/m1FtT++dxSKZKzZ6sFJSKV4lFgefhapPUEI7j7j9D7f8CFwHfNbC5Bl9/awQ7Y2dayG2gdTTBDdfH9BtgAzAW+UlK+E6iqp1MHuwcFkGycoxaUiFQEd8+Z2WXAPQT3l25w96fN7GpgtbuvCre9M5x0IQ98zt0H/Su9qbX9XuB94eAImlrbDwRu6Wxreddw8Qw3k8RLwCmZ5vQC4E3hpky6IzPx04uPo8HuQQGk5jSS0yg+EakQ7n4XcFe/si+WLDvBe/0+XeYh5xaTE0BnW8u2ptb2smaSGPYeVKY5/T7gEeB9wPnAw5nm9HllBlYRBnsOCiA1t1HDzEVEBldoam0/pLjS1NrexMATkb9OOaP4/hZ4U7ojsxkg05yeB/yC1146WPEGew4KgqHmuVfVxSciMoj/CTzU1Nr+AMHbMN5K+K6/4ZQzii9RTE6hrWXuVzFyQ3XxNc6h0N2N9/aOd1giIpNeZ1vL3QTT5D0L3Ax8Bthbzr7ltKDuzjSn7wkPDPB+4GejiHPKKgzTggLIbdtGzYIF4xqXiMhk19Ta/mHgCoIh648DJwO/JXgF/JCGbQmlOzKfA74JHBt+VqY7Mp8fS8BTTV8LKjlwCwo03ZGIyCCuIBhk91JnW8vbCN5yMdhDvfspZ5DEtemOzE/THZlPh5/bM83pa8cW79SSH+R1G6DpjkREhrGvs61lH0BTa3tdZ1tLB3BkOTuWcy/p9AHKzhxBcFPecPegAPJ6WFdEZCBdTa3tswke8L23qbX9DoJHmIY11EwSfw18HFiWaU6XPpg7A/j1GIKdcvLhMPPEAC8lTDaGLahXlKBERPrrbGt5T7j45abW9vuBWcBQk8v2GWqQxA8JBkP8A/tPU7Ez3ZGpqv6soe5BJaZPx2prNd2RiMgwOttaHhhJ/aFmktgB7CCYc6mqDfUclJmRbGzUdEciIhGrqueZRmuoqY4AUo2NakGJiERMCaoMuSFaUKAJY0VE4qAEVYbBXrdRlNJ0RyIikVOCKkOxBTVIfiLVOIf81q24lzX/oYiIlEEJqgz5fDDMfLAWVHJOI97bS2H37vEMS0SkoilBlWG4e1Ca7khEJHpKUGUYbhTfa9MdKUGJiEQltgRlZgeb2f1m9oyZPW1mV4Tlc8zsXjN7Pvx5YFwxRCXv5bWglKBERKITZwsqB3zG3VcQTK/+CTNbQTArxX3uvhy4j/1nqZiU8vlhWlDhdEcaai4iEp3YEpS7b3D3/w6XdwIZYDFwNnBjWO1G4Jy4YojKsPegDgwagXpYV0QkOuNyD8rMmgjeAfIwsMDdN4SbNgIDvuUv05y+NNOcXp1pTq/2XG48whxUb75AMmHYAJPFAlhtLYlZs9SCEpEpz8zOMLNnzWyNmb2uh8vMLjazLWb2ePj5cFyxlPNG3TExswOAnwBXunt36Ze8u7uZDfjwULojsxJYCWDTp0/oA0bPb9rJ0rnTh6yTmjNHLSgRmdLMLAlcT/CapS7gUTNb5e7P9Kv6I3e/LO54Yk1QZlZDkJxucvefhsWbzGyhu28ws4XA5rjOv7c3z75sfsBtdTUJptWmyBec7r3ZIY/z+Lod/MkR84aso+mORKQCnAiscfe1AGZ2C8Ftmf4JalzElqAsaCp9B8i4+3Ulm1YBFwFt4c874orhhl+/yD/d8+yA21IJ4xef/hOuaX+GX2SGz5HHHzxryO2pOY30rH1hVHGKiEwSi4F1JetdwEkD1Huvmf0P4DngU+6+boA6YxZnC+rNwAeBJ83s8bDsbwgS04/N7BKCtyqeH1cAb10+l+m1ydeVb+zu4RsPvMBzm3bStW0vzQfN4II3HTzocWpSCc45fvGQ50o2ziH/yCNjjllEJE6Jhpmpptb21SVFKzvbWlaO4BD/Adzs7j1m9lGCwW5vjzTIUGwJyt0fAgYeVQDviOu8pY5dMptjl8x+Xfnm7n1844EX2NS9j3zBWb7gAC5+89IxnSs1p5H89u14LoelYr+1JyIyKoW93bnOtpYTBtm8Hij9a31JWNbH3Utvtn8b+MdoI3xNVc4k0XhAHcmEsTFMUMnBZoEdgWRxuqNt28Z8LBGRCfIosNzMlppZLXABwW2ZPuHYgaKzCB4hikVV/qmfTBjzZ9SxcUcPuYIzwJvcRyxVnO7o1VdJzRt6QIWIyGTk7jkzuwy4B0gCN7j702Z2NbDa3VcBl5vZWQSTMbwKXBxXPFWZoAAWzKzv6+KLogWVmlucTUJDzUVk6nL3u4C7+pV9sWT5KuCq8YilKrv4AObPqGPLzh7yBR90CqOReG3CWA01FxGJQtUmqNpUgmyhQN6dRAQJqu+VG3pYV0QkElWboBJmFAoeWQsqMXMmpFJqQYmIRKRqE1QyYRQccuE8e2NlZpruSEQkQlWboMyCFxEWfPBZykcq2dhI/hUlKBGRKFRtgkqaUXAnVyhE0sUHxQlj1cUnIhKF6k1QiSBBFQpEMkgCwumOXnklkmOJiFS7qk1QZka+QKQtqJoFB5HdvBnPDzyDuoiIlK9qE1QyQdCC8mBEXxRqFi+CXI7cli2RHE9EpJpVbYJKmJHNFQCia0EtDmY8z778ciTHExGpZlWdoHryQYJKRjEZH1CzaBEA2fVKUCIiY1XVCSpbTFBRdfEtDCb5VQtKRGTsqjZBJRPgXlyOJkElpk0jeeCBZNevH76yiIgMqWoTVOnQ8qjuQUHQzacWlIjI2FVvgirp1ouqBQVKUCIiUanaBJXcL0FF92soJigv9h+KiMioVG2CKm00JSP8LdQsXozv20deUx6JiIxJ9SaoREwtqEMOBqD3pZciO6aISDWq2gRV2sUX5SCJusMOA6DnhRciO6aISDWq2gRV2oKKarJYCO5BWV0dvS+sjeyYIiLVqHoTVEwtKEsmqcHhUVsAABDwSURBVF26lJ61akGJiIxFFSeo0uXoEhRA3bJlakGJyJRkZmeY2bNmtsbMWoeo914zczM7Ia5YqjZBJWN6UBeg9rBlZF9+mcLevZEeV0QkTmaWBK4HzgRWABea2YoB6s0ArgAejjOeqk1QVvocVESTxRbVHXYYuNP74ouRHldEJGYnAmvcfa279wK3AGcPUO9/A9cC++IMJhXXgc3sBuDdwGZ3PzosmwP8CGgCOoHz3X1bXDEMpTQnRTVZbFHtsmUA9KxZQ/2K1/3xISIyYRINM1NNre2rS4pWdra1rAyXFwPrSrZ1ASeV7m9mbwQOdvd2M/tcnLHGlqCA7wH/Cny/pKwVuM/d28K+zVbgCzHGMKg4u/jqli3D6uvZ9/TTzDrrrEiPLSIyFoW93bnOtpZR3TcyswRwHXBxpEENIrYuPnd/EOg/ncLZwI3h8o3AOXGdfzilXXxRDjMHsFSK+qOOYu/vn4j0uCIiMVsPHFyyviQsK5oBHA38ysw6gZOBVXENlIizBTWQBe6+IVzeCCwYrGKmOX0pcCmA53KRBxJnCwqg4Zhj2PbDH+LZLFZTE/nxRURi8Ciw3MyWEiSmC4APFDe6+w5gbnHdzH4FfNbdVxODCRsk4cFsqoPOqJruyKxMd2ROSHdkTrBU9Hl0/7n4YkhQxx6D9/ay77nnIj+2iEgc3D0HXAbcA2SAH7v702Z2tZmN+/2K8W5BbTKzhe6+wcwWApvH+fx94nrdRlH9sccBsO/JJ2k46qjIjy8iEgd3vwu4q1/ZFwepe2qcsYx3C2oVcFG4fBFwxzifv08yEW+Cqlm8iGRjI3t/97vIjy0iUg1iS1BmdjPwW+BIM+sys0uANuB0M3seOC1cnxBxt6DMjOknncSu3/xG74YSERmF2Lr43P3CQTa9I65zjkRcr3wvNf0tb6H7rrvoee456o88MpZziIhUqqqdSWL/QRLx/Bqmv/mPAdj90K9jOb6ISCWr2gS13yvfI55JoqhmwQLqli9n10P/GcvxRUQqWdUmqDjn4it1wKmnsueRR8npFfAiIiNStQlqv1F8MbWgAGa++92Qz9P9s5/Fdg4RkUpUxQmqdDm+BFV/5BHUHXEE3av+I7ZziIhUoqpNUBbzMPNSs876M/b+/vf0rFkT63lERCpJ1Sao0m692lS8v4ZZ556L1dXx6o3fH76yiIgAVZygSh/UrYlxkARAas4cZp19NjvuuIPc1q2xnktEpFJUb4IqufLaZPy/hjkXX4Tncmz91rdjP5eISCWo2gRV2sVnMY7iK6pbtoxZ576HV2+6id5164bfQUSkylVtgor6JYXlmPfJy7FUio3XXKP5+UREhlG9CWocWk391SyYz/xPXcnuBx5kx09vH/fzi4hMJVWcoCbmvAf+xV8w7U1vYuM117Dv2WcnJggRkSmgahNU3M8+DcYSCRZ95f+QPOAAuj7+CbKbNk1IHCIik13VJqiJ6OIrqpk/nyX/dj357dv5w4cuIrtpwl4sLCIyaSlBTZCGY47h4G99i9yWLbz0wQ/S8/zzExqPiMhkU7UJaqK6+EpNe+MbOOSG71DYs4fO919A9913T3RIIiKTRtUmqEmQnwBoOP54lt52K7WHH876Kz9F15WfIrdly0SHJSJVyszOMLNnzWyNmbUOsP1jZvakmT1uZg+Z2Yq4YqneBDVZMhRQc9BBNN30A+ZdeSW77ruPNe86g83//M/kd+6c6NBEpIqYWRK4HjgTWAFcOEAC+qG7H+PuxwP/CFwXVzzVm6Am+B5Uf1ZTw9yPfZRl/7GKGaeeytZvfJM17ziNTW3X0vvSSxMdnohUhxOBNe6+1t17gVuAs0sruHt3yep0ILZZB1JxHXiyi/MlhWNR29TE4uu+QuNHPswrK1fy6g9+wKvf+x7TTjyRmWeewYzTTyc1d+5EhykiU1SiYWaqqbV9dUnRys62lpXh8mKgdC62LuCk/scws08AnwZqgbfHFatNhSl3pk+f7rt37470mF3b9vCWa+8HoLOtJdJjRym7aTPbb7uV7va76F27FhIJGo47jumnnML0U06m4bjjsNraiQ5TRKYIM9vj7tMH2XYecIa7fzhc/yBwkrtfNkj9DwDvcveLYom1WhPUy9v38sdtvwQmd4Iqcnd6nn+enXffza6Hfs2+p56CQgFraKD+qBU0HHU09UcfTf3RR1F76KFYomp7b0VkCMMkqFOAL7v7u8L1qwDc/R8GqZ8Atrn7rDhird4uvkk0SKIcZkb9EUdQf8QRzLv8cvLd3ex55BF2P/wI+558km233IL39AR16+upbWqibtlSapcuo3bZUmoPOYSahQtJNjaOy+ztIjIlPQosN7OlwHrgAuADpRXMbLm7Fx/cbAFie4izahNU8Tt6qiWqouTMmcw47TRmnHYaAJ7L0fPCC+x76il6nl9Dz4tr2fvkU3T/7G4oaSVbbS01CxeSWrSQmkWLqFmwgGRjI6nwk2ycS6pxDomZM5XIRKqMu+fM7DLgHiAJ3ODuT5vZ1cBqd18FXGZmpwFZYBsQS/ceVHEX39ZdPfzRNb+gNpngub8/M9JjTyaFffvofeklsuvXk13/MtkNG8hueJncyxvIvvwyuVde2S+B9ampITVnDsmZM0nMnEly5kySM2eQmDEzLJtBckbJz+nTSDQ0kJg2DWtoIDF9OlZToyQnMskM1cU32VRtC6o4zHyqtqDKlaivp/7II6k/8sgBt3s+T37bNnJbXyX/6lZyr2zt+5l7dSuF7p3ku7vJbtpIz3PPkd+5k8LOnQMntf6SSRLTShLXtIZwfRqJ+jqstg6rq8PqakkUl2trg/W617Yn6mpf21Zbsp5KQSoVJMLSn6kUFJd1L05kypqQBGVmZwBfI2hCftvd28Y7hmKCSiUrO0ENx5JJUnPnjmjouhcKFHbtIt+9k0L3juDn3j0U9uzB9+6lsGcPhT3hz717Kezdg5eU5bdtI9fTQ6G3B+/pxXt68N5eCr29kM1Ge4GJxH7Ji5IkViynJoWlSsuTkEhiySQkk1gysf96IhGWJyGZwBIl5alkuB6W919PJrBk6nXrr50jAYkEWAISFhxz0GUDS2AJ69undJmEBS3YAbb1LScSQZ2B6hW3hctgg25TS1niMO4JquRJ5dMJxtg/amar3P2Z8YwjVygAkKrwFlQcLJEIu/xmEjw2ER3P5/HeIGkVenrxbJjAenoo9IQJrTdYJpfDczk8m8NzWTyb7VcWlJPL4dlsSdnQ5b6nFy8UIJ/H8/ngZ3G9UAj2K10frF4+H+nvZtIrJrqSj422vC8BGxgYr687qvIwqY/5OAOUW8LgdeWE12Wv3fi2/svFxXD/MuosurYt+OOqwk1EC6rvSWUAMys+qTyuCWr2tFpOXjaHy962fDxPK8OwZBJraICGBpITHcwYuTsMkMg8n4dC4bWfuTwUXiunUMALDni4XICCg5dsG2jZva9e6T6D7u8+aL2+5UIhXPegW3fQevng/O7BvALFZYKf3r883DZkeWGguqM4zkDlpccOP84Ij++Oe6GvvPjfOzjO6+sSHOm1eRdKyvdbLp4vWBy4zhQYOxCFiUhQZT2pnGlOXwpcCsEItaglE8Ytl54S+XFFiswMit2CEx2MyBQ0aQdJpDsyK4GVADZ9enX8uSAiIn0mYojTeuDgkvUlYZmIiEifiUhQfU8qm1ktwZPKqyYgDhERmcTGvYtvsCeVxzsOERGZ3Kp2JgkRkWo0lWaS0GP2IiIyKSlBiYjIpKQEJSIik5ISlIiITEpTYpCEmRWAvaPcPQVEPxXF5Kfrri667uoylutucPcp0TiZEglqLMxstbufMNFxjDddd3XRdVeXarnuKZFFRUSk+ihBiYjIpFQNCWrlRAcwQXTd1UXXXV2q4ror/h6UiIhMTdXQghIRkSlICUpERCalik5QZnaGmT1rZmvMrHWi44mSmd1gZpvN7KmSsjlmdq+ZPR/+PDAsNzP7l/D38ISZvXHiIh89MzvYzO43s2fM7GkzuyIsr/TrrjezR8zs9+F1/6+wfKmZPRxe34/C19dgZnXh+ppwe9NExj9WZpY0s9+Z2Z3hesVft5l1mtmTZva4ma0Oyyr63/lAKjZBmVkSuB44E1gBXGhmKyY2qkh9DzijX1krcJ+7LwfuC9ch+B0sDz+XAl8fpxijlgM+4+4rgJOBT4T/TSv9unuAt7v7ccDxwBlmdjJwLfBVdz8c2AZcEta/BNgWln81rDeVXQFkStar5brf5u7HlzzvVOn/zl/P3SvyA5wC3FOyfhVw1UTHFfE1NgFPlaw/CywMlxcCz4bL3wQuHKjeVP4AdwCnV9N1A9OA/wZOAl4BUmF53793gnetnRIup8J6NtGxj/J6lxB8Gb8duBOwKrnuTmBuv7Kq+Xde/FRsCwpYDKwrWe8KyyrZAnffEC5vBBaEyxX3uwi7b94APEwVXHfYzfU4sBm4F3gB2O7uxeluSq+t77rD7TuAxvGNODL/DHweKITrjVTHdTvwczN7zMwuDcsq/t95f+P+Rl0ZH+7uZlaRzxCY2QHAT4Ar3b3bzPq2Vep1u3seON7MZgO3A80THFLszOzdwGZ3f8zMTp3oeMbZW9x9vZnNB+41s47SjZX677y/Sm5BrQcOLllfEpZVsk1mthAg/Lk5LK+Y34WZ1RAkp5vc/adhccVfd5G7bwfuJ+jamm1mxT8yS6+t77rD7bOAreMcahTeDJxlZp3ALQTdfF+j8q8bd18f/txM8AfJiVTRv/OiSk5QjwLLwxE/tcAFwKoJjiluq4CLwuWLCO7RFMs/FI72ORnYUdJVMGVY0FT6DpBx9+tKNlX6dc8LW06YWQPBfbcMQaI6L6zW/7qLv4/zgF96eHNiKnH3q9x9ibs3Efz/+0t3/3Mq/LrNbLqZzSguA+8EnqLC/50PaKJvgsX5Af4UeI6gv/5/TnQ8EV/bzcAGIEvQ53wJQX/7fcDzwC+AOWFdIxjR+ALwJHDCRMc/ymt+C0Hf/BPA4+HnT6vguo8Ffhde91PAF8PyZcAjwBrgVqAuLK8P19eE25dN9DVE8Ds4FbizGq47vL7fh5+ni99dlf7vfKCPpjoSEZFJqZK7+EREZApTghIRkUlJCUpERCYlJSgREZmUlKBERGRSUoISGSeZ5vSpmeb0nRMdh8hUoQQlIiKTkp6DEukn05z+C+ByoJZgMtqPE0w8+i2Cp/o3AhekOzJbMs3p44FvEMwy/gLwV+mOzLZMc/rwsHwekAfeRzAdzZcJZtk+GngM+It0R0b/E4oMQC0okRKZ5nQaeD/w5nRH5niC5PLnwHRgdbojcxTwAPClcJfvA19Id2SOJXiKv1h+E3B9uiNzHPDHBLN+QDAD+5UE7yhbRjDfnIgMQLOZi+zvHcAfAY9mmtMADQSTchaAH4V1fgD8NNOcngXMTndkHgjLbwRuzTSnZwCL0x2Z2wHSHZl9AOHxHkl3ZLrC9ccJ3un1UPyXJTL1KEGJ7M+AG9MdmatKCzPN6b/rV2+03XI9Jct59P+gyKDUxSeyv/uA8zLN6fkAmeb0nExz+lCC/1eKM2h/AHgo3ZHZAWzLNKffGpZ/EHgg3ZHZCXRlmtPnhMeoyzSnp43rVYhUACUokRLpjswzwN8CP880p58geHvtQmA3cGKmOf0UwXuJrg53uQj4p7Du8SXlHwQuD8t/Axw0flchUhk0ik+kDJnm9K50R+aAiY5DpJqoBSUiIpOSWlAiIjIpqQUlIiKTkhKUiIhMSkpQIiIyKSlBiYjIpKQEJSIik9L/B2oBepbDS6efAAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Train the model\n",
        "\n",
        "learning_rate = 0.1\n",
        "# We create a criterion which will measure loss\n",
        "criterion = nn.BCELoss()\n",
        "# Create an optimizer with the model parameters and learning rate\n",
        "optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)\n",
        "# Create a Data Loader for the training data with a batch size of 1 \n",
        "train_loader = DataLoader(dataset=data_set, batch_size=1)\n",
        "# Using the training function train the model on 500 epochs\n",
        "LOSS12 = train(data_set, model, criterion, train_loader, optimizer, epochs=500)\n",
        "# Plot the data with decision boundaries\n",
        "plot_decision_regions_2class(model, data_set)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wnzbRWS2PMS1"
      },
      "source": [
        "<a href=\"https://dataplatform.cloud.ibm.com/registration/stepone?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkCV0101ENCoursera25797139-2021-01-01&context=cpdaas&apps=data_science_experience%2Cwatson_machine_learning\"><img src=\"https://cf-courses-data.s3.us.cloud-object-storage.appdomain.cloud/IBMDeveloperSkillsNetwork-DL0110EN-SkillsNetwork/Template/module%201/images/Watson_Studio.png\"/></a>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cLXK_xjgPMS1"
      },
      "source": [
        "<!--Empty Space for separating topics-->\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UKxtOWOVPMS1"
      },
      "source": [
        "<h2>About the Authors:</h2> \n",
        "\n",
        "<a href=\"https://www.linkedin.com/in/joseph-s-50398b136/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkCV0101ENCoursera25797139-2021-01-01\">Joseph Santarcangelo</a> has a PhD in Electrical Engineering, his research focused on using machine learning, signal processing, and computer vision to determine how videos impact human cognition. Joseph has been working for IBM since he completed his PhD.\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ad4frt9DPMS1"
      },
      "source": [
        "Other contributors: <a href=\"https://www.linkedin.com/in/michelleccarey/?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkCV0101ENCoursera25797139-2021-01-01\">Michelle Carey</a>, <a href=\"https://www.linkedin.com/in/jiahui-mavis-zhou-a4537814a?utm_medium=Exinfluencer&utm_source=Exinfluencer&utm_content=000026UJ&utm_term=10006555&utm_id=NA-SkillsNetwork-Channel-SkillsNetworkCoursesIBMDeveloperSkillsNetworkCV0101ENCoursera25797139-2021-01-01\">Mavis Zhou</a>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rfg-LnbOPMS1"
      },
      "source": [
        "## Change Log\n",
        "\n",
        "| Date (YYYY-MM-DD) | Version | Changed By | Change Description                                          |\n",
        "| ----------------- | ------- | ---------- | ----------------------------------------------------------- |\n",
        "| 2020-09-23        | 2.0     | Shubham    | Migrated Lab to Markdown and added to course repo in GitLab |\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IyidngdyPMS2"
      },
      "source": [
        "<hr>\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7Umh7c5WPMS2"
      },
      "source": [
        "## <h3 align=\"center\"> © IBM Corporation 2020. All rights reserved. <h3/>\n"
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.0"
    },
    "colab": {
      "name": "4.1.Simple Neural Network for XOR.ipynb",
      "provenance": [],
      "collapsed_sections": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}