From 0d8c39a896b411c6cd72f6574a6f745d09663e63 Mon Sep 17 00:00:00 2001 From: John Dailey Date: Wed, 22 Jul 2020 23:15:08 -0400 Subject: [PATCH] Assignment Complete --- .../LS_DS_421_Intro_to_NN_Assignment.ipynb | 475 ++++++++++++++++-- .../LS_DS_421_Intro_to_NN_Lecture.ipynb | 224 +++++---- 2 files changed, 561 insertions(+), 138 deletions(-) diff --git a/module1-Intro-to-Neural-Networks/LS_DS_421_Intro_to_NN_Assignment.ipynb b/module1-Intro-to-Neural-Networks/LS_DS_421_Intro_to_NN_Assignment.ipynb index 9e13eca32..a4b4e78b3 100644 --- a/module1-Intro-to-Neural-Networks/LS_DS_421_Intro_to_NN_Assignment.ipynb +++ b/module1-Intro-to-Neural-Networks/LS_DS_421_Intro_to_NN_Assignment.ipynb @@ -26,14 +26,14 @@ "## Define the Following:\n", "You can add image, diagrams, whatever you need to ensure that you understand the concepts below.\n", "\n", - "### Input Layer:\n", - "### Hidden Layer:\n", - "### Output Layer:\n", - "### Neuron:\n", - "### Weight:\n", - "### Activation Function:\n", - "### Node Map:\n", - "### Perceptron:\n" + "### Input Layer: the neural netork layer of nodes/neurons where the data enters the neural network\n", + "### Hidden Layer: the middle layer(s) where the data is being summed and then processed by a function in each node/neuron of the layer\n", + "### Output Layer: the last layer where the data is output to nodes/neurons after being processed, as a prediction\n", + "### Neuron: each node of the neural network takes an input, multiplies the input by its weights, sums the product, and then this sum is processed in the activation function which will be passed on to the other neurons in the next layer, which could be another layer in the hidden layer, or the final outer layer\n", + "### Weight: represents the strength of a connection between two nodes/neurons. Greater magnitude in weight means a greater influence. A weight decreases the importance of the input value.\n", + "### Activation Function: mathematical equations that determine the output of a neural network. The function is attached to each neuron in the network, and determines whether it should be activated (“fired”) or not, based on whether each neuron's input is relevant for the model's prediction\n", + "### Node Map: a chart demonstrating the connections of the input layer, (hidden layer), and output layer of a neural network\n", + "### Perceptron: the simplest and oldest model of a neuron, which takes inputs, sums the inputs, applies an activation function and passes the product to the output layer, while there is no hidden layer\n" ] }, { @@ -55,7 +55,7 @@ "id": "PlSwIJMC0A8F" }, "source": [ - "#### Your Answer Here" + "#### Information flows into a neural network through the input layer. The input layer is the first layer, there can be multiple \"hidden layers\" in the middle of the network where the inputs are being processed, and then the last layer is the output layer where predictions are being output. Each layer in the neural nework consists of nodes which are called neurons. The bias neuron is a special neuron added to each layer in the neural network, which simply stores the value of 1 to provide a bias as a parameter to adjust the output along with the weighted sum of the inputs to the neuron. Bias helps fit best for the given data. A weight represents the strength of a connection between two nodes/neurons. Greater magnitude in weight means a greater influence. A weight decreases the importance of the input value. Weight is also the parameter within a neural network that transforms input data within the network's hidden layers. The weights and bias are possibly the most important concept of a neural network. When the inputs are transmitted between neurons, the weights are applied to the inputs and passed into an activation function along with the bias. The neurons have activation functions which are mathematical equations that determine the output of a neural network. The function is attached to each neuron in the network, and determines whether it should be activated (“fired”) or not, based on whether each neuron's input is relevant for the model's prediction. The output layer produces the results for the given inputs and processes in the previous layers so it consists of the predictions made by all of the previous computations." ] }, { @@ -77,11 +77,15 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ + "# Establish the training data\n", + "\n", "import pandas as pd\n", + "import numpy as np\n", + "\n", "data = { 'x1': [0,1,0,1],\n", " 'x2': [0,0,1,1],\n", " 'y': [1,1,1,0]\n", @@ -93,23 +97,253 @@ { "cell_type": "code", "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Use x1 and x2 as inputs, plus a column of 1's for a bias\n", + "\n", + "inputs = np.array([\n", + " [0,0,1],\n", + " [1,0,1],\n", + " [0,1,1],\n", + " [1,1,1]\n", + "])\n", + "\n", + "# Use y as correct outputs\n", + "\n", + "correct_outputs = [[1],[1],[1],[0]]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Sigmoid activation function and its derivative for updating weights\n", + "\n", + "def sigmoid(x):\n", + " return 1/(1+np.exp(-x))\n", + "\n", + "def sigmoid_derivative(x):\n", + " sx = sigmoid(x)\n", + " return sx*(1-sx)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, "metadata": { "colab": {}, "colab_type": "code", "id": "Sgh7VFGwnXGH" }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.8740682 ],\n", + " [0.60275303],\n", + " [0.03431834]])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "##### Your Code Here #####\n", - "\n" + "# Initialize random weights\n", + "\n", + "weights = np.random.random((3,1))\n", + "weights" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.03431834],\n", + " [0.90838654],\n", + " [0.63707137],\n", + " [1.51113957]])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Calculate weighted sum of inputs and weights\n", + "\n", + "weighted_sum = np.dot(inputs, weights)\n", + "weighted_sum" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.50857874],\n", + " [0.71266989],\n", + " [0.65409114],\n", + " [0.81923003]])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Output the activated value for the end of 1 training epoch\n", + "\n", + "activated_outputs = sigmoid(weighted_sum)\n", + "activated_outputs" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.49142126],\n", + " [ 0.28733011],\n", + " [ 0.34590886],\n", + " [-0.81923003]])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Take difference of output and true values to calculate error\n", + "\n", + "error = correct_outputs - activated_outputs\n", + "error" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 0.12281915],\n", + " [ 0.05883702],\n", + " [ 0.07826393],\n", + " [-0.12132157]])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Gradient deccent/backprop\n", + "\n", + "adjustments = error*sigmoid_derivative(weighted_sum)\n", + "adjustments" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[0.81158365],\n", + " [0.55969539],\n", + " [0.17291687]])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "weights = weights + np.dot(inputs.T, adjustments)\n", + "weights" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Weights after training\n", + "[[-8.74361073]\n", + " [-8.74361073]\n", + " [13.20116352]]\n", + "Output after training\n", + "[[0.99999815]\n", + " [0.98854182]\n", + " [0.98854182]\n", + " [0.01357266]]\n" + ] + } + ], + "source": [ + "# Put it all together\n", + "\n", + "# Steps we've already done:\n", + "# 1. Randomly Initialized Weights already. Those are in memory as \"weights\"\n", + "# 2. We've already got input data & correct_outputs\n", + "\n", + "\n", + "# Update our weights 10,000 times - (fingers crossed that this process reduces error)\n", + "\n", + "for iteration in range(10000):\n", + " \n", + " # Weighted sum of inputs / weights\n", + " \n", + " weighted_sum = np.dot(inputs, weights)\n", + " \n", + " # Activate!\n", + " \n", + " activated_output = sigmoid(weighted_sum)\n", + " \n", + " # Calc error\n", + " \n", + " error = correct_outputs - activated_output\n", + " \n", + " adjustments = error * sigmoid_derivative(weighted_sum)\n", + " \n", + " # Update the Weights\n", + " \n", + " weights += np.dot(inputs.T, adjustments)\n", + " #weights = weights + weights + np.dot(inputs.T, adjustments) # alternate way of writing weights\n", + " \n", + "print(\"Weights after training\")\n", + "print(weights)\n", + "\n", + "print(\"Output after training\")\n", + "print(activated_output)\n" + ] }, { "cell_type": "markdown", @@ -126,7 +360,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -242,12 +476,14 @@ "4 2.288 33 1 " ] }, - "execution_count": 4, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ + "# Import diabetes data\n", + "\n", "diabetes = pd.read_csv('https://raw.githubusercontent.com/ryanleeallred/datasets/master/diabetes.csv')\n", "diabetes.head()" ] @@ -261,20 +497,60 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ + "# Imports for preprocessing\n", + "\n", "from sklearn.preprocessing import MinMaxScaler, Normalizer\n", "\n", - "feats = list(diabetes)[:-1]\n", + "# Instantiate features and target\n", + "\n", + "features = list(diabetes)[:-1]\n", + "target = list(diabetes)[-1]\n", + "\n", + "# Create numpy arrays for neural network\n", + "\n", + "X = diabetes[features].to_numpy()\n", + "y = diabetes[target].to_numpy()\n", "\n", - "X = ..." + "# Bias - 0 from lecture, could also try 1\n", + "\n", + "diabetes['bias'] = np.zeros(diabetes.shape[0])\n", + "\n", + "# Weights - this will take a little bit longer, but good starting point\n", + "\n", + "y = y * 2 - 1" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "# Scale the data for the neural network, for comparison\n", + "\n", + "scaler = MinMaxScaler()\n", + "X_scaled = scaler.fit_transform(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "# Normalize the data for the neural network, for comparison\n", + "\n", + "normalize = Normalizer()\n", + "X_normalized = normalize.fit_transform(X)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, "metadata": { "colab": {}, "colab_type": "code", @@ -282,41 +558,156 @@ }, "outputs": [], "source": [ - "##### Update this Class #####\n", + "# Perceptron Class\n", "\n", "class Perceptron:\n", " \n", - " def __init__(self, niter = 10):\n", + " def __init__(self, rate = 0.01, niter = 10):\n", + " self.rate = rate\n", " self.niter = niter\n", " \n", " def __sigmoid(self, x):\n", - " return None\n", + " return 1/(1+np,exp(-x))\n", " \n", " def __sigmoid_derivative(self, x):\n", - " return None\n", + " sx = self.__sigmoid(X)\n", + " return sx*(1-sx)\n", "\n", " def fit(self, X, y):\n", - " \"\"\"Fit training data\n", - " X : Training vectors, X.shape : [#samples, #features]\n", - " y : Target values, y.shape : [#samples]\n", - " \"\"\"\n", + " \"\"\"Fit training data\n", + " X : Training vectors, X.shape : [#samples, #features]\n", + " y : Target values, y.shape : [#samples]\n", + " \"\"\"\n", "\n", " # Randomly Initialize Weights\n", - " weights = ...\n", + " #weights = ...\n", + " self.weight = np.random.random(1 + X.shape[1]) # could be random.zeros but it goes much slower\n", "\n", + " self.errors = [] # Number of misclassifications\n", + " \n", " for i in range(self.niter):\n", + " err = 0\n", + " for xi, target in zip(X, y):\n", + " predictions = self.predict(xi)\n", + " delta_w = self.rate * (target - predictions) #self.predict(xi) was replaced with predictions\n", " # Weighted sum of inputs / weights\n", + " self.weight[1:] += delta_w * xi\n", + " self.weight[0] += delta_w\n", + " if delta_w != 0.0:\n", + " #err += int(delta_w != 0.0) # replaced this with if statement just above and just below, for better readability\n", + " err = err + 1\n", + " # Calc error\n", + " self.errors.append(err)\n", + " return self\n", + " \n", + " # Update the Weights\n", + " \n", + " def net_input(self, X):\n", + " \"\"\"Calculate net input\"\"\"\n", + " return np.dot(X, self.weight[1:]) + self.weight[0]\n", + " \n", + " # Activate!\n", + " \n", + " def predict(self, X):\n", + " \"\"\"Return class label after unit step\"\"\"\n", + " \"\"\"Defalt Step Function\"\"\"\n", + " return np.where(self.net_input(X) >= 0.0, 1, -1) # if greater than 0, output 1, and if not greater than 0, output -1\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", "\n", - " # Activate!\n", + "# Perceptron fit to scaled data, which has the lowest number of misclassifications from start to finish.\n", "\n", - " # Cac error\n", + "pn = Perceptron(0.1, 10)\n", + "pn.fit(X_scaled, y)\n", + "plt.plot(range(1, len(pn.errors) + 1), pn.errors, marker='o')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Number of misclassifications')\n", + "plt.show;\n", "\n", - " # Update the Weights\n", + "# As the model learns the proper weight, the number of misclassifications goes down. " + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEGCAYAAACKB4k+AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXhdZbX48e/KPDdNk05J56QFSqGhZU6BIlgEhQLlol69TjggKqK/qjghisK1ildAUUSUqzhRShkEChcKtBRoQ+cp6ZQOKUnTIc1Jmjnr98fZJ6Qhw06bc/YZ1ud59pOTnTOsJG3es993vWuJqmKMMcYAxHkdgDHGmPBhg4IxxphONigYY4zpZIOCMcaYTjYoGGOM6ZTgdQAnIzc3V8ePH+91GMYYE1Heeeedg6qa19PXInpQGD9+PKWlpV6HYYwxEUVEdvf2NZs+MsYY08kGBWOMMZ1sUDDGGNPJBgVjjDGdbFAwxhjTKaKzj4wxJtYsXlPJgiVl7K9tZHR2KvPnTGFucf6gPb8NCsYYEyEWr6nk9kUbaGxtB6CytpHbF20AGLSBwaaPjDEmQixYUtY5IAQ0trazYEnZoL2GDQrGGBMh9tc2Duj8ibBBwRhjIsTo7NQBnT8RNigYY0yEmD9nConxcty51MR45s+ZMmivYYOCMcZEiLnF+cwqzAVAgPzsVO6+bpplHxljTKzqAE4dlcXzt84KyvPblYIxxkSQ8iofU0ZkBO35gzYoiEiKiKwUkXUisklE7nTO/9E5t15EFopIhnP+0yJSIyJrneOmYMVmjDGRyNfUyv6jTRSNyAzaawRz+qgZuFRV60UkEVguIs8Dt6lqHYCI3At8BbjHecw/VfUrQYzJGGMiVnl1PQBTInFQUFUF6p1PE51DuwwIAqQCGqwYjDEmmpRX+wCYMjJ4g0JQ1xREJF5E1gIHgJdU9W3n/J+AKuAU4P4uD7m+y7TSmF6e8wsiUioipTU1NcEM3xhjwkpZlY+0pHjyB3FfQndBHRRUtV1VpwMFwDkicrpz/jPAaGALcKNz92eA8ap6BvAS8Ggvz/mQqs5U1Zl5eT22GDXGmKhUXu2jaEQmcXHS/51PUEiyj1S1FlgKXNHlXDvwD+B65/NDqtrsfPlhYEYoYjPGmEhRXl3P5OHByzyC4GYf5YlItnM7FbgcKBORQuecAFcDW53PR3V5+NX4ryKMMcYAh+qbOVjfHNT1BAhu9tEo4FERicc/+PwL+DewTESy8G/IWwfc7Nz/ayJyNdAGHAY+HcTYjDEmogQyjyYHMfMIgpt9tB4o7uFLF/Zy/9uB24MVjzHGRLJQZB6BlbkwxvQi2B2+zMCUVfsYkprI8MzkoL6ODQrGmPcJRYcvMzDbqn1MHpGBfzk2eKz2kTHmfULR4cu4p6qUVfmCvp4ANigYY3oQig5fxr3qumbqmtqCvp4ANigYY3oQig5fxr0yZ5HZrhSMMZ6YP2cKKYnH/3kY7A5fxr3yKhsUjDEemlucz5cunnTcuZ9cM9UWmT1SXu0jNyOZnPSkoL+WDQrGmB6lJcUD8N/XTwNg9FCbOvJKebWPKSODW94iwAYFY0yPVlUcYUJuOledMZqEOGH5toNehxSTOjrUX/MoBFNHYIOCMaYHqkppxWFmjhtKRnICxWOzWb7dBgUv7DvSSGNre1Ab63Rlg4Ix5n121NRz5FgrZ4/PAeDCwlw2VB7lSEOLx5HFnkDmUTBbcHZlg4Ix5n1WVRwB4OwJ/kFhVlEuqrBixyEvw4pJ5Z3pqLamYIzxyKqKw+RmJDF+WBoAZxZkk5mcYFNIHiiv9pGfnUpmSmJIXs8GBWPM+5RWHGHmuJzOOjsJ8XGcN2kYy7dbC9xQ85e3CM1VArgYFERkkogkO7cvEZGvBZrnGGOiT3VdE3sOH2Pm+KHHnZ9VlMvew43sPtTgUWSxp7W9g501DUwOQXmLADdXCk8A7U7HtIeAMcDfghqVMcYzqyoOA3COs54QUFKYC8AyS00Nmd2HGmhp72Dy8PAaFDpUtQ24FrhfVefj76pmjIlCpRVHSEuK57RRWcedn5CbzughKbZfIYQC3dZCUQgvwM2g0CoiHwM+BTzrnAvNiocxJuRWVRymeGw2CfHH/3kQEUqKclmx4yDtHepRdLGlrMqHCBQOD6M1BeAzwPnAT1V1l4hMAP4S3LCMMV7wNbWy5d06Zo7L6fHrJUV51DW1saHyaIgji03l1T7GD0snJTE+ZK/Zb+c1Vd0MfK3L57uA/w5mUMYYb6zeU0uH0rlprbsLJw0DYPm2GqaPsXyTYCurDm3mEbjLPrpQRF4SkXIR2Skiu0RkZyiCM8aEVmnFYeLjhOKxPf/BH5aRzNTRWbbYHAJNre1UHGwIWc2jADc9mv8I3Aa8A7T3c19jTARbVXGYqaOzSE/u/U9DSVEujyzfRUNzW5/3MydnZ00DHRqaHgpduVlTOKqqz6vqAVU9FDiCHpkxJqRa2jpYu7e21/WEgJLCXFrblZW7DocostgUKG8RyswjcDcoLBWRBSJyvoicFTiCHpkxJqQ27j9KU2sHZ3fbtNbd2eNzSEqIs5IXQVZW7SMxXhg/LD2kr+vm2u9c5+PMLucUuHTwwzHGeKXU2bQ2s5dF5oCUxHjOGZ9j+xWCrLzKx8TcDJISQluNyE320exQBGKM8VagqU5eZnK/9y0pyuWe57dyoK6J4VkpIYgu9pRV+zzJ8HKTfTRERO4VkVLn+KWIDAlFcMaY0OjaVMeNQMkLm0IKjobmNvYdaQxZY52u3FyXPAL4gP9wjjrgT8EMyhgTWt2b6vTntFFZ5KQn2RRSkGw74C9vEcpCeAFu1hQmqer1XT6/U0TWBisgY0zoBZrqdK+M2pu4OOGCScNYvv0gqtpZYtsMjvIqJ/MoTK8UGkWkJPCJiFwINAYvJGNMqAWa6kzIdZ/pMqsolwO+5s53tWbwlFX7SEmMY0xOWshf282Vws3Ao846ggCHgU8HMyhjTGh1b6rjRklRHuAvpR3qDVbRrrzaR+HwDOLjQn8F1u+VgqquVdUzgTOAaaparKrrgh+aMSYUemuq05/87FQm5qazfJt1Yxts5dU+zwbaXq8UROQTqvpXEflGt/MAqOq9QY7NGBMCgaY6bheZuyopymXhO/toaesIeT59tKo91kJ1XbMn6wnQ95VCYHIxs4cjtGX7jDFBU1pxhNTEeE4bndX/nbu5sDCXYy3trN5zJAiRxaZAYx0vMo+gjysFVf29c/P/VPWNrl9zFpuNMVFgVcVhzhqXTWL8wN/pnz9pGPFxwvJtBzlv4rAgRBd7yqq9yzwCd9lH97s8Z4yJMP011elPVkoiZxYMsU1sg6i8ykdmcgKjhnizU7yvNYXzgQuAvG7rCllAv22ARCQFeB1Idl5noareISJ/xF9HSYBy4NOqWi8iycD/AjOAQ8CNqlpxQt+ViTiL11SyYEkZ+2sbGZ2dyvw5U5hbnO91WFGvv6Y6bpQU5fHAK9s4eqyVIWnWqfdklVf7KBqR4dnej76uFJLwrx0kcPx6Qh0wz8VzNwOXOplL04ErROQ84DZVPVNVzwD2AF9x7v854IiqFgK/wrq7xYzFayq5fdEGKmsbUaCytpHbF21g8ZpKr0OLev011XFjVlEuHQpv7rSrhZOlqpRX+0JeLrurvtYUXgNeE5E/q+rugT6xqioQ2NWS6ByqqnUA4h8GU/FXXAW4BviRc3sh8ICIiPM8JootWFJGY+vx/ZsaW9tZsKTMrhaCzE1Tnf5MH5NNelI8y7Yd5IrTRw1idLGnpr6ZI8daPd334WZN4ZjTT+E5EXklcLh5chGJd0piHABeUtW3nfN/AqqAU3hvfSIf2Augqm3AUeB9K1ci8oVAcb6aGsuPjgb7a3veIN/beTM43DbV6U9ifBznTRxm6wqDoLzK/z7aq0VmcDcoPAZsBSYAdwIVwCo3T66q7ao6HSgAzhGR053znwFGA1uAGwcSsKo+pKozVXVmXl7eQB5qwtTwrJ5LNY/OTg1xJLFlk8umOm6UFOWy+9Ax9h4+NgiRxa5A5lFRmA8Kw1T1j0Crqr6mqp9lgA12VLUWWApc0eVcO/APIFBsrxIYAyAiCcAQ/AvOJoo1tbYT38OCWmpiPPPnTPEgotgR2LQ2YxAGhVlFVkp7MGyr9pGTnkRuRpJnMbgZFFqdj++KyFUiUgz0e70pInkiku3cTgUuB8pEpNA5J8DV+K9CAJ4GPuXcnge8YusJ0e+uf29m/9Embpo1gXznyiBO4K65U209IchWVRxh/LA0hmeefOrjpLwMRmalWCntk1RW7WOyh5lH4K4g3l1OMbxv4p//zwJuc/G4UfgL6cXjH3z+BfwbWCYiWfhTUtfhL7gH8EfgLyKyHX/RvY8O5BsxkeeZdfv561t7+OJFE7n9ylP5/lWn8crWaj7751IyUyy1MZgCTXUuO3XEoDyfiFBSlMv/bammvUM9KeQW6VSV8iof82YUeBqHm3aczzo3jwKuW3Oq6nqguIcv9bgbWlWbgBvcPr+JbDtr6vnOE+uZMW4o/6/LNNFFRXnkZiSz8J19fHDqSA8jjG47ahoG1FTHjVlOHaRN+49yRkHo20hGusraRhpa2j0rbxHgph3no4FpIOfzoSLySHDDMtGsqbWdLz+2mqSEOO7/WPFx5RUS4uO47qx8Xtl6gIP1zR5GGd0C6wkDrYzalwsm+dcVltkU0gnZFqh55HEZcjdrCmc4C8UAqOoRer4CMMaVO5/ZzNYqH/feOL3HDKN5Mwpo61CeWrvfg+hiw4k01elPXmYyp4zM5A1bbD4hgcyjycPDf1CIE5HOtxMikoO7tQhj3ueptZX8feUebr5kErOnDO/xPpNHZHJmwRAWvrMvxNHFjhNpquPGrKJcSiuO0NjS3v+dzXHKq3yMzErxvFSIm0Hhl8CbIvITEbkLWAH8PLhhmWi0/UA9ty/awNnjh/LNyyf3ed95MwrY8m4dGyuPhii62HGiTXXcKCnKo6W9g5XO9JRxr6za5/l6ArjrvPa/wHVANf5dyNep6l+CHZiJLo0t7dzy2GpSEuO5/2NnkdBPmearz8wnKT7OrhaC4GSa6vTnnPE5JMXHWTe2AWrvULYfqGfKCO9b1fT6P9NJGw1MF1UBf3OOKuecMa796OlNlFX7+NWN0xnpoiTwkLRELp86gqfWVtLS1hGCCGPHyTTV6U9qUjwzxw+1xeYB2nP4GM1tHZ7uZA7o6+3a35yP7wClXY7A58a4smj1Pv5ZupdbZk/i4snuS5PMm1HAkWOtvLK1OojRxZ5VFYcpHntiTXXcuLAwl61VPmp8lj3mVlmVt411uurrX8U9zsdTVXVil2OCqk4MRXAm8m0/4ON7T27k3Ak53HZZ3+sI3V1UlMeIrGSbQhpEgaY6wZg6CgiUvFixw64W3CrvrHkUxtNHwK+djytCEYiJPsda2vjyY6tJS4rnvo8V97uO0F18nHBtcQFLy2rsXecgWTMITXX6M3X0ELLTEm0KaQDKqn2MzUkjLcn7xM6+/pe2ishDQIGI3Nf9CFWAJnL98KlNbDtQz/98dDojsk6svs68GQW0d6g13Bkkq5ymOtNPoqlOf+LjhAsn5bJ820GsfJk75VU+zzetBfQ1KHwYeAVoxL+O0P0wplePl+5l4Tv7+OrsQmYVnXiJ88LhGRSPzWbhO/vsD8wgWFVxmNNGZZFxEk113CgpyqWqrokdNfX93znGtbR1sOtgA5PDYOoI+u68dhD4h4hsUdV1IYzJRLjyah8/eGoj508cxq0DXEfoybwZBXzvyY1srKxjWsGQQYgwNgWa6nz8nHFBf62SwvdKXhR6vEM33O062EBbh3ragrOrvlJSv+XcvMmmj4xbDc3+dYSM5ER+/bHpg1It88NnjCY5IY7H39k7CBHGrsFsqtOfMTlpjBuWZiUvXOgsbxEB00dbnI+BNFSbPjJ9UlV+sHgjO2rq+fVHpw9KnX6AIamJzJk6kqfW7qe5zconnKjBbKrjRklhLm/tPExru+0z6Ut5lY/4OGFi3uDVoToZvQ4KqvqM8/HRwAH8BXjSuW3McR4v3ceiNZXc+oEiLnSmDwbLvBkFHG1s5eUtBwb1eWPJYDbVcWNWUS71zW2s3Vvb/51jWFm1jwm56SQnxHsdCuCudPbfRCRLRNKBjcBmEZkf/NBMJNlaVccPntpISWEuX720aNCf/8LCXEYNSeHxUptCOhGBpjozg5iK2t35k3KJEyul3Z9tTre1cOEmcfw0Va0D5gLPAxOATwY1KhNR6p11hKzURH514+CsI3QXHydcd1Y+r5XXcKCuadCfP9oFmuqcE8JBYUhqImcUZFsdpD40trSz+/CxsFlPAHeDQqKIJOIfFJ5W1VbAcgMN4H8H+r0nN1BxsIH7PlpMXmZy0F7r+rMK6FBYZHsWBqw0CE113CgpzGXdvqPUNbX2f+cYtP1AParhUd4iwM2g8HugAkgHXheRcUBdMIMykeMfq/by1Nr93HbZZM6fNCyorzUxL4OZ44banoUTsLLiMMPSB7epjhslRbm0dyhv7TgU0teNFJ2ZR2GSjgruSmffp6r5qnql+u1mAL2aTfTavL+OO57exKyiXG6ZXRiS15w3o4DtB+pZt8/6LAxEacURZo4fOuhNdfpz1tihpCXFs9xSU3tUXu0jKSGOcTlpXofSyc1C863OQrOIyB9FZDVwaQhiM2GsvrmNW/62mqFp/nWEuCCsI/TkqjNGkZIYZwvOAxBoqhPMeke9SUqI49wJOSy3xeYelVf7mJSXMeC6YMHkJpLPOgvNHwSG4l9kvqfvh5hopqrcvmgDuw/51xFyM4K3jtBdZkoiHzp9FE+v209Tq+1ZcKO04ggQ3CJ4fSkpymPnwQYqaxs9ef1wVl7lC4vGOl25GRQCbwGvBP6iqpu6nDMx6LG39/DMuv1884NTOHdicNcRejJvRgG+pjZe2mx9FtxYVXE4aE113AiU0rYspOPVNbWy/2hTWK0ngLtB4R0ReRH/oLBERDIB26IYozZWHuXHz27m4sl53HzxJE9iOH/iMPKzU3nc+iy4EuymOv0pGp7B8Mxk26/Qzbbq8Gms05WbfyWfA74DnK2qx4Ak4DNBjcqEJV9TK7f8bTU5aUkhXUfoLi5OuP6sfJZvq6HqqO1Z6EugqU4oN611JyKUFOayYschOjosayygrMpfQTac9iiAu+yjDmAXMFlELgKmAsErxm7CkqrynSc2sO9IIw98vJic9CRP47l+RmDPgl0t9CXQVCeUm9Z6UlKUy+GGFja/a9nsAeXVPtKS4snPTvU6lOO4yT66CXgdWALc6Xz8UXDDMuHmL2/t5t8b3mX+nCmevusMGDcsnXPG57Cw1PYs9KU0BE113AiU0rbU1PeUV/soGpHp2RV3b9xMH90KnA3sVtXZQDFgFa5iyIZ9R7nr2S1cespwvjArfNpzz5tZwM6DDazeY/8ce7MyRE11+jM8K4UpIzItNbWL8urwyzwCd4NCk6o2AYhIsqpuBaYENywTLuqcdYTcjCR+ecOZYfWu5sppo0hNjGehLTj3KNBUJ9SlLXpTUpTLyorDlkoMHKxv5mB9S9itJ4C7QWGfiGQDi4GXROQpYHdwwzLhQFX51uPr2V/byP0fP4uhHq8jdJeRnMCHpo3k2XX7aWyxPzTdBZrqeL2eEFBSmEtLW0fnvolYVh7IPAqzdFRwt9B8rarWquqPgB8Af8RfHM9EuUdXVPDCpiq+fcUpzBgXHu82u7thxhh8zW28uLnK61DCTuCPb6ia6vTn3Ik5JMYLy7bbfoVt1eGZeQR9t+PM6X4AG4DlQPhNhJlBtW5vLT99bguXnTqcm2ZN8DqcXp07IYeCoak8XmpTSN2trDgc0qY6/UlLSuCssUNtXQF/IbwhqYkMD2JV4RPV15XCO7y/FWdpl48mSh095l9HGJ6Zwi9uODPkRdQGwr9noYA3dhy0MgpdeNFUx41ZRbls2l/Hofpmr0PxlL+8RWZY/t/qqx3nBFWd6Hyc0O3z8ElBMYNKVfl/C9dRXdfEAx8vJjstvNYRejJvRgGq8ORqu1oICDTVOTtMpo4CSoryAHgjhktpqypl1T4mjwzPCRc3+xSuFZEhXT7PFhFbU4hSj7xRwUubq/nOh06leGx4/UHpzZicNM6bmGN9FroINNXxqgheb6blDyErJSGm6yBV1TXha2oLy/UEcJd9dIeqdhavV9Va4I7ghWS8smbPEe5+bgsfPG0En71wvNfhDMi8GWOoOHSM0t2W2QLeNdXpT3yccMGkXJZvOxizA3h5GC8yg7tBoaf79LsTRkRSRGSliKwTkU0icqdz/jERKRORjSLyiNPqExG5RESOisha5/jhwL4VcyIWr6nkwnteYcJ3/s28B98kMyWBBfPCex2hJ1dOG0l6UjwLbcEZ8K6pjhslRbnsP9rEroMNXofiifIqp9taBA8KpSJyr4hMco5f4V9s7k8zcKmqnglMB64QkfOAx4BTgGlAKnBTl8csU9XpzvHjgX0rZqAWr6nk9kUbqKxtRIF2VY61tLO07IDXoQ1YWlICV04bxbPr93Ospc3rcDzlZVMdNzpLacdoyYuyah95mcme1w/rjZtB4atAC/BP52gCbunvQU7rznrn00TnUFV9zvmaAiuBghOK3Jy0BUvKaOy2u7S5rYMFS8o8iujkzJtRQENLOy9sjO09C4H9CeGWeRQwblg6Y3JSY7aUtr+8RXheJYC7zWsNqvodVZ0JnAvcraqurvtEJF5E1gIHgJdU9e0uX0vE38XthS4POd+ZbnpeRKb28pxfEJFSESmtqYndxarBsL+XFM7ezoe7cybkMDYnLebLXgSa6kz1qKmOGyWFeby14xBt7bHVmqWjQ9lWXU9RGNY8CnCTffQ3p0dzOv7Na5tFZL6bJ1fVdlWdjv9q4BwROb3Ll38LvK6qy5zPVwPjnOmm+/GX1ejpOR9S1ZmqOjMvL89NGKYXo3sp2dvb+XAnIsybUcCKHYfYe/iY1+F4xuumOm6UFObia25j3b7YKma470gjja3tkX2lAJzm9GieCzwPTMD/Dt81J2NpKXAFgIjcAeQB3+hyn7rAdJOqPgckikjuQF7HDMxtlxW971xqYjzz50RuvcPrZxQgAotWV3odiifCoamOGxdMGoYILN8WW/sVypyaR+HWgrMrN4NCojPVMxd4WlVbgX5zyUQkzymkh4ikApcDW53+DHOAjzkNfAL3HylOqoSInOPEFlv/YkKs3UkJHJaehAD52ancfd005hbnexvYScjPTuWCScNYuHpvTHb5CjTVCbdNa90NTU9iWv4QlsdYHaRAIbyi4eE7feSmyPrvgQpgHfC6iIwD3LRPGgU8KiLx+P/A/0tVnxWRNvxVVt90xoBFTqbRPOBm5+uNwEc1VhOZQ6C9Q/n9azs5PT+LZ75SEpapiydq3owCbvvnOlZWHOa8icO8DiekAk11ImHjYUlhLg+9vpP65jbP+z2ESlmVj/zsVDJTEr0OpVduFprvU9V8Vb3SSRraDcx28bj1qlqsqmeo6umBFFNVTVDVSd1TT1X1AVWdqqpnqup5qrripL8706slm6rYebCBmy8ujKoBAeCKqaPISE6IyQXncGmq40ZJUS5tHcpbMVTyorzax+QwXmSGPq4UROQTqvpXEflGL3e5N0gxBdXiNZUsWFLG/tpGRmenMn/OlIieLjkRqsqDr+5gQm46V5w+0utwBl1qUjwfPmMUT6/bz51XTyU9Av5ADoZAU52PnTPW61BcmTFuKCmJcSzffpDLThvhdThB19rewc6aBi6eEt4JMn1dKQT2x2f2ckSc7pu1KmsbuX3RBhavia1FyeXbD7Kh8ihfvGgi8WHUSW0wzZtRwLGWdp7b8K7XoYRMoKlOuG5a6y45IZ5zJgyLmU1suw810NLeEdaZR9DHlYKq/t75eGfowgmunjZrNba2s2BJWUxdLTz46g5GZCVz7VnR+z3PGDeUCbnpLHxnHzfMHON1OCHx3qa18F9PCJhVmMtPn9vCu0cbGTUkMlOh3SqrCu+aRwFu9ilMcMpcLBKRpwNHKIIbbNG2WetErN1by4odh7ipZCLJCfFehxM0gT0Lb+86zJ5DsbFnYVWYNdVxoyRQ8iIGdjeXVfuIEygM48wjcJeSuhh/9tH9wC+7HBEn2jZrnYgHX93OkNREPnZuZMw7n4xri/MRgYUx0GdBVSndfSTs9yd0d8rITHIzkmNiCqm8yse4YemkJIb3mzE3g0KTk4G0VFVfCxxBjywI5s+ZQmq3X0h8nET0Zq2B2H7Ax5JN1Xzq/HERkZ1yskZnp1JSmMsT7+yL+j0LO2oaONzQEvb7E7oTEUoKh/HG9oNR/zsqPxD+mUfgblD4tYjcISLni8hZgSPokQXB3OJ87r5uGvnZqQiQlhRPR4dSPDbb69BC4nev7SQlMY5PXTDe61BCZt6MAiprG3lrZ3SnPQaa6kTalQL4u7EdrG9hq1NSOho1tbZTcbAh7BeZwd3mtWn4y1pcCgR2IKvzecSZW5zfuah8oK6Jixe8yi9eLOf+jxV7HFlw7a9tZPGaSj5x3jiGZYRfs/BgmTN1JJkp/j0LFxRGb9WUVRVHGJaexMQwa6rjRonze3lj+0FOC+MifidjR009HRre5S0C3Fwp3ABMVNWLVXW2c0TkgNDd8KwUbpo1gWfW7Wdj5dH+HxDB/rBsJwCfvyi22munJMbzkTNH89zGd/E1tXodTtCsqjgctk11+jNySAqFwzNYFsXrCoHyFpFwpeBmUNgIRO38yhcumsjQtET++4WtXocSNIcbWvjHyr1cMz2f/BhaVA+YN6OAptaOqN2zEO5NddwoKcxl5a5DNHVLGY8WZVX1JMYL4yPgSs7NoJCNv5DdkkhPSe1JZkoiX7m0iGXbDkZtWtyfV1TQ2NrOly6OrauEgOIx2UzMS4/ashfh3lTHjVlFuTS1drA6Sntsb6v2MTE3I6zLmQe4ifAO4FrgZ0R4SmpvPnHeWPKzU/nvF7ZGXQZEQ3Mbj66o4IOnjaAoAi5dg0FEuGHGGFZVHKEiCvsCR0JTnf6cO3EYCXEStVNIZdW+iDw6uwMAAB3VSURBVFhPAHcF8V7r6QhFcKGSnBDPNz84mQ2VR/l3lE0x/H3lHo42tvKlSyZ5HYqnri3OJ06IyquF0t3h31SnPxnJCRSPzY7Kq/X65jb2HWlkSgSko4K7K4WYcM30fE4ZmckvXiyjpS06WgQ2t7Xzh2U7OW9iDmdFQCnlYBo5JIVZRXk8sXof7VF0NehramXz/vBvquNGSWEeG/cf5UhDi9ehDKptgcY6EXKlboOCIz5O+PYVp7D70DH+uWqP1+EMisVrKqmua+bLlxR6HUpYuGFmAe8ebeLNKCrVHClNddwoKcpFFVZE0e8HYFt1ZNQ8Cuh1UBCRl52P/x26cLx1yZQ8zp2Qw69f3kZDc5vX4ZyUQBOdqaOzmFUUvfn5A3HZqSPISkng8Xf2eh3KoCmtOEycEBFNdfpzZsEQMlMSoq4bW1m1j5TEOMbkpHkdiit9XSmMEpELgKtFpLjrbuZI3dHcHxHhOx86hYP1LTy8bJfX4ZyUF50mOl++JPqa6JyolMR4rpmezwsbq6iLkj0LqyqOMHX0kKgoW5IQH8f5E4exbNtBoqnpYnm1j6LhmRFTpr6vQeGHwA+AAvwNdbpmHv0i+KF5o3jsUK6YOpKHXt/Bofpmr8M5IarKb6O4ic7JmDejgOa2Dv69PvITClraOliz90hElcruz6yiXPYdaWR3FFW2LavyRczUEfQxKKjqQlX9EPDzLjuZo2pHc2/mXzGFprYO7n9lu9ehnJA3th+K+iY6J+qMgiEUDc/g8dLIn0KKtKY6blzolLyIlqqptcdaOOBrZsrIyMg8AncpqT8RkatF5BfO8eFQBOalSXkZ/MfMMTz29u6IrMX/21e3MzwzupvonCgR4YaZBazeU8uOmnqvwzkpnZvWxkXPlcKE3HTys1OjJjW13FlkjqQ9Qm6a7NwN3Apsdo5bReRnwQ7Ma1+/rIj4OOHel8q8DmVAOpvozJoQ1U10Tsbc6fnEx0nE71lYVXGYccPSGJ4VOU11+uMvpZ3Lih0HoyJ1uCyCah4FuElJvQq4XFUfUdVHgCuAqL9aGJGVwmcvnMDitZFVLO/BV7eTlZLAx88d53UoYWt4VgoXT85jUQTvWQg01YmmqaOAkqJc6praWL+v1utQTlp5lY/M5ARGDYmcgdvtPoWuBfGGBCOQcPTFiyeRnZbIz5dExtVCZxOdC8ZHRTZKMN0wo4DquuaInbuO1KY6blxYmItIdLToDJS3iKQMQDeDwt3AGhH5s4g8CrwD/DS4YYWHIamJ3HJJIa+X17AiAv54/N5povPpGGqic6IuPXU42WmJEbvgHMlNdfqTk57E1NFZEV8HSVUpr46szCNwt9D8d+A8YBHwBHC+qv4z2IGFi0+eP47RQ1K454WtYZ07vb+2kSfXVPLRs8fGVBOdE5WcEM81Z47mxc3VHD0WeXsWIrmpjhsXFuayZs+RiN5EWlPfTO2x1ohowdmVq+kjVX1XVZ92jqpgBxVOUhLjue3yyazfd5TnNoTvtx7YbHfTrAkeRxI5bpg5hpa2Dp5Zv9/rUAasdHfkNtVxY1ZhHq3tyspdh70O5YSVV/kzjyJpkRms9pEr151VwOQRGfzixTJa28OvWN7hhhb+vnIPV08fTcHQyNhKHw6mjs7ilJGZPB5hWUgH6prYfSiym+r0Z+b4oSQnxLEsgtcVAplHkVIyO8AGBRcCxfJ2HWzgn6vCbw76UaeJzs0Xx3Z57IESEebNKGDd3trOSpaRYFUUNNXpT0piPOdMyInoOkjlVT6GpSeRG2HTuX0OCiISLyLR26dyAC49ZThnjx/Kr1/exrGW8JnnbGhu488rKrg8hpvonIy5xfkkxAkLV0fO1cKqisOkJMZFdFMdN0oKcymvrqe6rsnrUE5IWQQuMkM/g4KqtgNlIjI2RPGErUCxvBpfM48sD59ieYEmOjfHeBOdE5WbkcwlU4azaHUlbWE4NdiT0t2HKR4zNKKb6rhR4lT3jcTUVFVlW7Uv4haZwd300VBgk4i8HI09mgdixrgcPnjaCH732k4Oh0EjkOa2dh5etsua6JykeTMKqPE1R8T8daCpztkTonfqKODUkVkMS0/ijQhMTa2sbaShpT3i1hPA3aDwA/w7mH9MlPZoHohvXTGFYy1tPBAGxfKeWrOfqrombrYmOifl0lOGk5OeFBFlL6KpqU5/4uKECwpzWb498kppl0dgeYsAVz2agQog0bm9Clgd5LjCVuHwTG6YMYa/vrWbvYe9K5bX3qH87vUdTB2dxUXWROekJCXEcc300by0uZraY95fAfYlmprquDGrMJcDvubOwnKRoqwq8grhBbgpiPd5YCHwe+dUPrA4mEGFu69fXoQI/Oqlcs9ieHFTFTtrGrj5kklRm6seSvNmFNDS3sHT68J7z8KqiiOcNjorZsqYBNYVlm2LrCyk8mofo4akMCQ10etQBszN9NEtwIVAHYCqbgOGBzOocDdqSCqfvnA8T66tZMu7dSF/fVXlwdd2MH5YGh86fVTIXz8aTR09hNNGZfF4afhOIbW2+5vqRPP+hO5GZ6cyMS894mpUlVf7IvIqAdwNCs2q2nlNLSIJQGRN8AXBly8uJDM5gZ+/EPqM3Te2H2L9vqN88eJJ1kRnEM2bUcCGyqNsrQr9QO/Gxsroa6rjRklhLm/vPExLW2Rkh7V3KNsO1DMlAjOPwN2g8JqIfBdIFZHLgceBZ/p7kIikiMhKEVknIptE5E7n/GMiUiYiG0XkERFJdM6LiNwnIttFZH2494EekpbIl2cXsrSshrd2Hgrpaz/4mr+JznXWRGdQXTN9NALMe3AFE77zby685xUWr6n0OqxO0dhUx43EOKGxtZ0p338+7H4nPdl9qIGWto6I3KMA7gaF7wA1wAbgi8BzwPddPK4ZuFRVzwSmA1eIyHnAY8ApwDQgFbjJuf+HgCLn+ALwoPtvwxufvmA8I7NSuOf50BXLW7e3lje2WxOdYFi27SAiUN/cjuJPK7x90Yaw+SMUjU11+rN4TSWPrdwDEJa/k550Zh5FYDoquMs+6gAeBX4C3Ak8qi7+AqpfIGUg0TlUVZ9zvqbASqDAuc81wP86X3oLyBaRsJ4wT0mM5xuXT2bt3lqWbApNsbwHX91hTXSCZMGSMrr33GlsbWdBGPTTCDTVmTkutqaOFiwpo6n1+GmjcPmd9Kasqh4RKBwepdNHInIVsAO4D3gA2C4iH3Lz5E6ZjLXAAeAlVX27y9cSgU8CLzin8oGuhYX2Oee6P+cXRKRUREprarzPSLjurHwKh2fw8yVlQd8Ru/1APUs2V1kTnSDZX9s4oPOhFGiqc86E2Jo6CuffSW/KD/gYMzSNtKTI/D/qZvrol8BsVb1EVS8GZgO/cvPkqtquqtPxXw2cIyKnd/nyb4HXVXXZQAJW1YdUdaaqzszLyxvIQ4MiIT6Ob82Zws6ahqBX2/z9aztITrAmOsEyOju1x/PxccLSrQc83UAVzU11+tLb76S38+GgvCoyax4FuBkUfKradfvuTmBAJSVVtRZYir+/MyJyB5AHfKPL3SqBMV0+L3DOhb3LTxvBjHFD+dVL5TS2tAflNfbXNrJ4rTXRCab5c6aQmnj8Ok1ivJCVmsBn/ryKG3//Vucf51BbVXGEnChuqtObnn4n8XHC/DlTPIqob81t7ew62MCUkZE5dQR9DAoicp2IXAeUishzIvJpEfkU/syjVf09sYjkiUi2czsVuBzYKiI3AXOAjznrFQFPA//lZCGdBxxV1XdP/FsLnUCxvAO+Zh55IzjF8h5etgtVa6ITTHOL87n7umnkZ6ciQH52Kgvmnclbt1/GT+aezq5DDcz73Zvc9OiqkKetlu4+zMxx0dtUpzfdfycZyfG0dygFQ8PzSmHXwQbaOjSirxT6mvT6SJfb1cDFzu0a/FlD/RkFPCoi8fgHn3+p6rMi0gbsBt50/oEvUtUf489quhLYDhwDPjOQb8RrZ4/P4bJTh/O713bw8XPGMjQ9adCe+4g10QmZucX5zC1+f6rvJ88bx/Vn5fOnNyr43Ws7+NCvl3Ht9Hxuu3wyY3KC+zsJNNX5RIwmF3T9nTQ0t/HBX73Od5/cwLNfnUVSQnhVii2riuzMI+hjUFDVk/qjrKrrgeIezvf4mk420i0n85pemz/nFD7069f57avb+d5Vpw3a8/7ZaaLzJWui46m0pARumV3If547lgdf28Gf36jgmfX7+c9zx3HL7ELyMoMzrRdoqhMLlVH7k56cwI+vmcrnHi3lD8t2csvs8CoGua26nvg4YUIET/O5yT6aICL3isiiWC+d3Z8pIzO57qwCHl2xm8pByo5oaG7j0TcruOzUERF9SRpNstOSuP1Dp/La/NnMmzGGv7y1m4sXLOXeF8vwNbUO+uvFSlMdtz5w6giunDaS+17eRsXBBq/DOU5ZtY8JuekRvYfIzbXXYvxVUu/HSmf367bLJ8MgFsv7+8o91B5r5cuz7Soh3IwcksLd103jpdsuYvYpw7nvle1c9POlPLxsJ02tg5dwECtNdQbijo9MJSk+ju8v3hhWZbXLq30RWS67Kzf/yppU9T5VXaqqrwWOoEcWofKzU/nU+eN4YvW+k16MbGnr4OFluzh3gjXRCWcT8zL4zcfP4pmvlHB6/hDu+vcWLv3Fq/xr1d6T3rtS39zmb6oTA/0TBmJEVgrfumIKy7cf5Km14VHZ9lhLG3sOH4v4K3o3g8KvReQOETlfRM4KHEGPLIJ9+ZJCMpITWPDCye26XLymkqq6Jr4cZvOmpmfTCobwl8+dy99uOpe8rBS+9cR65vzP67yw8d0Tfje7evcRf1MdW094n/88dxzFY7P5ybObw6IPxvYD9agS0emo4G5QmAZ8HriH96aOfhHMoCLd0PQkbr5kEi9vPcDKXSeW125NdCLXBYW5LP7yBfzuEzMA+NJfVzP3tytYcQLln2Otqc5AxMUJd183jaONrfzsuS1eh9PZCChSS2YHuBkUbgAmqurFqjrbOS4NdmCR7jMXTGBEVjL3PL/lhN4lvrTZmuhEMhHhitNHsuTrF/HzeWdQU9fExx9+m0/+8W027Dvq+nliranOQJ0yMoubZk3kX6X7Ql6tuLvyah9JCXGMC3KKcrC5GRQ2AtnBDiTapCbF8/XLJrN6Ty0vbq4e0GNVld++uoNx1kQn4iXEx/EfM8fwyv+7hO9fdSobK4/ykQeWc8vfVrOzpu8Wk4GmOrFWBG+gbv1AEWNyUvnukxtobgtORQE3yqp8FOZlkBDhCQFuos/GvxN5iaWkDswNMwqYmJfOggEWy1uxw2mic5E10YkWKYnx3DRrIq9/azZf+0ARS7ce4PJfvc7tizZQdbSpx8fEalOdgUpNiueuudPYWdPA717d6Vkc5dW+iN60FuDmmvSOoEcRpQLF8r7019U8sXofN5491tXjfvuqv4nO9TOsiU60yUxJ5BuXT+a/zh/HA69s57G3d7No9T4+fcF4br5kEtlp7+2EDzTVscyj/l08OY+rzxzNb5Zu58NnjmJSXmgXe482tvLu0aaIzzwCd/0UXuvpCEVw0WDO1JFMH5PNr17a5ip3PdBE53Ml1kQnmuVmJPOjq6fyyjcv4appo3ho2U5m/Xwpv1m6nWMtbSxeU8kvX/Rnr1372xVh3VQmXPzgw6eRkhjH957cEPK9C9sP+MtbTI7QFpxdudnR7BOROudoEpF2EQnPJrZhKFAsr6quiT+vqOj3/u810XF3VWEi25icNO69cTrP3zqLcycMY8GSMs796f8xf+E6mpyexJHQbSwc5GUmc/uVp/LWzsMsDHIZ++7KqvzrQ7FypZCpqlmqmoW/EN71+HshGJfOmziM2VPy+O3S7X3mUwea6PzX+ePJTEkMYYTGa6eMzOLhT83kiZvPp7lNaW0//p1uuHcbCxc3zhzD2eOH8tPntnCovjlkr1te7SM9KZ78MO7z4NaAlsmdVpmL8Ze+NgPwrStOwdfcxoOv7uj1PoEmOp+5cHzoAjNhZca4HFp7SUoI525j4SIuTvjZtdNoaG7jpyHcu1BW5aNoRCZxUZAY4mb66LouxzwRuQfoOV3C9OrUUVlcOz2fP62o6PE/d6CJzo0zx1gTnRgXid3GwknRiEy+dPEkFq2u5I0T2DB4IqKh5lGAmyuFj3Q55uDvunZNMIOKVrddPhkU/uf/3l8s74/Ld9Gh8PmLJnoQmQknPXUbS02MD9tuY+HoltmFjB+Wxvee3DCoxQl7crC+mUMNLRRFwSIzuFtT+EyX4/Oq+lNVPRCK4KLNmJw0Pnn+OBa+s49t1e91NA000bnmTGuiY3ruAHf3ddN6bP5jepaSGM9Pr51GxaFj/Gbp9v4fcBLKqyO/sU5Xve5TEJEf9vE4VdWfBCGeqHfL7EL+tWovP19Sxh/+ayYAj75ZwbGWdr50iZXHNn69dYAz7l1YmMt1xfn87rUdXH3m6KDVJCoPdFuLgemjhh4OgM8B3w5yXFErJz2JL148kZc2V1NacZiG5jb+vMKa6BgTDN+76lQykhP47pMb6OgIzt6Fsup6stMSg9Z5L9R6HRRU9ZeBA3gIfzrqZ4B/ADbxfRI+WzKBzOR4Pv6Ht5l6xxJqj7VaVy1jgmBYRjLfvfJUVlUc4Z+le4PyGuXVPiYPz4yawpV9rimISI6I3AWsxz/VdJaqftvWFE7Oi5uqaWrroKVL6uFDr++0zUnGBMG8GQWcNzGHu5/bQo1vcPcuqKp/UIjwHgpd9TooiMgCYBX+bKNpqvojVT0Sssii2IIlZbY5yZgQERF+eu00mlo7+Mmzmwf1uavqmvA1tUXNegL0faXwTWA08H1gf5dSFz4rc3FyetuEZJuTjAmOSXkZfHn2JJ5et59XywZvoqOsKlDzKAYGBVWNU9XUrmUunCPTKXlhTpBtTjIm9G6+ZBIT89L5wVMbaWwZnL0LgXTUmBgUTPDY5iRjQi85IZ6fXTuNvYcb+fXL2wblOcuq6snLTGZoelL/d44QNih4wDYnGeON8yYO4z9mFvDwsp1srTr5WfBtB6KnvEWANX71iG1OMsYb373yVF7ecoDbF23giS9dcMJF7Do6/JlHHz9n3CBH6C27UjDGxJTstCS+/+FTWbOnlsfe3n3Cz7P3yDGaWjuYEkXpqGCDgjEmBs2dnk9JYS4/f6GM6roTK/ocjZlHYIOCMSYGiQh3zT2dlvYO7nxm0wk9x7YD/m5rwaqp5BUbFIwxMWl8bjpf+0ARz22o4uUt1QN+fFmVj/zsVDKSo2tp1gYFY0zM+vysiUwekcEPn9pEQ3PbgB5bXu2LmnLZXdmgYIyJWUkJcfzs2mlU1jb22PyqN63tHeyoqY+69QSwQcEYE+Nmjs/h4+eO5ZE3KthYedTVYyoONtDarlGXeQQ2KBhjDN+ecwpD05L47pMbaHfRd6G82llkHm5XCsYYE3WGpCVyx0dOY/2+o/zvmxX93r+s2kecQOFwu1Iwxpio9OEzRnHx5Dx+saSs34rF5VU+xg9LJ6VbDbNoELRBQURSRGSliKwTkU0icqdz/isisl1EVERyu9z/EhE5KiJrnaOvHtHGGDOoAnsX2lX50dN9710or/ZF5SIzBPdKoRm4VFXPBKYDV4jIecAbwGVAT/vLl6nqdOf4cRBjM8aY9xmTk8bXL5vMi5urWbKpqsf7NLW2U3GogclRmI4KQRwU1K/e+TTROVRV16hqRbBe1xhjTsbnSiZwyshM7nhqE76m1vd9fUdNPR0Kk0dE33oCBHlNQUTiRWQtcAB4SVXf7uch5zvTTc+LyNRenvMLIlIqIqU1NTWDHrMxJrYlxsdx93XTqPY18csX3793IdBYJ9pKZgcEdVBQ1XZVnQ4UAOeIyOl93H01MM6ZbrofWNzLcz6kqjNVdWZeXt7gB22MiXnFY4fyyfPG8eibFazbW3vc18qq6kmMF8bnpnsTXJCFJPtIVWuBpcAVfdynLjDdpKrPAYldF6KNMSaU/t+cKQzPTOb2RRtoa+/oPF9e7WNSXgaJ8dGZvBnM7KM8Ecl2bqcClwNb+7j/SBER5/Y5TmyHghWfMcb0JSslkR99ZCqb363jT29UdJ4vq4rezCMI7pXCKGCpiKwHVuFfU3hWRL4mIvvwTymtF5GHnfvPAzaKyDrgPuCjqtr/1kJjjAmSK04fyWWnDufel8rZe/gY9c1tVNY2Ru0iMwSxHaeqrgeKezh/H/4/+t3PPwA8EKx4jDFmoESEO685ncvvfY0fPrWRr36gCIi+xjpdRVchcGOMGWT52al84/LJ3PXvLazY4Z/R/sFTGznW0h6Vfdajc6XEGGMGUU5aIiLQ3OZfcK6ua+b2RRtYvKbS48gGnw0KxhjTj1++tI3uK5yNre0sWFLmTUBBZIOCMcb0o7cCef0VzotENigYY0w/RmenDuh8JLNBwRhj+jF/zhRSu5XJTk2MZ/6cKR5FFDyWfWSMMf0IZBktcHotjM5OZf6cKVGZfWSDgjHGuDC3OD8qB4HubPrIGGNMJxsUjDHGdLJBwRhjTCcbFIwxxnSyQcEYY0wnieTq1CJSA+z2Oo6TlAsc9DqIMGI/j+PZz+M99rM43sn8PMapao+tKyN6UIgGIlKqqjO9jiNc2M/jePbzeI/9LI4XrJ+HTR8ZY4zpZIOCMcaYTjYoeO8hrwMIM/bzOJ79PN5jP4vjBeXnYWsKxhhjOtmVgjHGmE42KBhjjOlkg4JHRGSMiCwVkc0isklEbvU6Jq+JSLyIrBGRZ72OxWsiki0iC0Vkq4hsEZHzvY7JSyJym/P/ZKOI/F1EUryOKZRE5BEROSAiG7ucyxGRl0Rkm/Nx6GC8lg0K3mkDvqmqpwHnAbeIyGkex+S1W4EtXgcRJn4NvKCqpwBnEsM/FxHJB74GzFTV04F44KPeRhVyfwau6HbuO8DLqloEvOx8ftJsUPCIqr6rqqud2z78/+mjv1h7L0SkALgKeNjrWLwmIkOAi4A/Aqhqi6rWehuV5xKAVBFJANKA/R7HE1Kq+jpwuNvpa4BHnduPAnMH47VsUAgDIjIeKAbe9jYST/0P8C2gw+tAwsAEoAb4kzOd9rCIpHsdlFdUtRL4BbAHeBc4qqovehtVWBihqu86t6uAEYPxpDYoeExEMoAngK+rap3X8XhBRD4MHFDVd7yOJUwkAGcBD6pqMdDAIE0NRCJnrvwa/IPlaCBdRD7hbVThRf17CwZlf4ENCh4SkUT8A8JjqrrI63g8dCFwtYhUAP8ALhWRv3obkqf2AftUNXDluBD/IBGrLgN2qWqNqrYCi4ALPI4pHFSLyCgA5+OBwXhSGxQ8IiKCf854i6re63U8XlLV21W1QFXH419AfEVVY/adoKpWAXtFZIpz6gPAZg9D8toe4DwRSXP+33yAGF547+Jp4FPO7U8BTw3Gk9qg4J0LgU/if1e81jmu9DooEza+CjwmIuuB6cDPPI7HM84V00JgNbAB/9+tmCp5ISJ/B94EpojIPhH5HHAPcLmIbMN/NXXPoLyWlbkwxhgTYFcKxhhjOtmgYIwxppMNCsYYYzrZoGCMMaaTDQrGGGM62aBgTA9EpL1LqvBaERm0HcUiMr5rtUtjwkmC1wEYE6YaVXW610EYE2p2pWDMAIhIhYj8XEQ2iMhKESl0zo8XkVdEZL2IvCwiY53zI0TkSRFZ5xyB8gzxIvIHp0fAiyKS6tz/a06PjfUi8g+Pvk0Tw2xQMKZnqd2mj27s8rWjqjoNeAB/dVeA+4FHVfUM4DHgPuf8fcBrqnom/vpFm5zzRcBvVHUqUAtc75z/DlDsPM+XgvXNGdMb29FsTA9EpF5VM3o4XwFcqqo7nYKGVao6TEQOAqNUtdU5/66q5opIDVCgqs1dnmM88JLTHAUR+TaQqKp3icgLQD2wGFisqvVB/laNOY5dKRgzcNrL7YFo7nK7nffW964CfoP/qmKV01TGmJCxQcGYgbuxy8c3ndsreK9F5H8Cy5zbLwM3Q2cP6iG9PamIxAFjVHUp8G1gCPC+qxVjgsnehRjTs1QRWdvl8xdUNZCWOtSpXtoMfMw591X8ndLm4++a9hnn/K3AQ05Vy3b8A8S79Cwe+KszcAhwn7XhNKFmawrGDICzpjBTVQ96HYsxwWDTR8YYYzrZlYIxxphOdqVgjDGmkw0KxhhjOtmgYIwxppMNCsYYYzrZoGCMMabT/wdwAX6Jzd/jiQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Perceptron fit to normalized data\n", "\n", + "pn = Perceptron(0.1, 10)\n", + "pn.fit(X_normalized, y)\n", + "plt.plot(range(1, len(pn.errors) + 1), pn.errors, marker='o')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Number of misclassifications')\n", + "plt.show;\n", "\n", - " def predict(self, X):\n", - " \"\"\"Return class label after unit step\"\"\"\n", - " return None" + "# As the model learns the proper weight, the number of misclassifications goes down. " + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Perceptron fit to original X data\n", + "\n", + "pn = Perceptron(0.1, 10)\n", + "pn.fit(X, y)\n", + "plt.plot(range(1, len(pn.errors) + 1), pn.errors, marker='o')\n", + "plt.xlabel('Epochs')\n", + "plt.ylabel('Number of misclassifications')\n", + "plt.show;\n", + "\n", + "# As the model learns the proper weight, the number of misclassifications goes down. " ] }, { @@ -328,7 +719,13 @@ "source": [ "## Stretch Goals:\n", "\n", - "- Research \"backpropagation\" to learn how weights get updated in neural networks (tomorrow's lecture). \n", + "- Research \"backpropagation\" to learn how weights get updated in neural networks (tomorrow's lecture). - \n", + "\n", + "Backpropagation is basically calculating backwards to improve the model. I watched the 3brown1blue at the beginning of this unit. The past is no predictor of the future, the caveat and disclaimer in predictive modeling. However, once epochs have been completed, like in elementary math, it is possible to go back, check the work, and make improvements if needed. In this case, the computer makes correct calculations, but they can also be improved upon in another experiment. In summary, backpropagation is the backward propagation of errors and the method calculates the gradient of the error function with respect to the neural network's weights.\n", + "\n", + "Thanks to brilliant.org for helping me summarize my paraphrase concisely.\n", + "(https://brilliant.org/wiki/backpropagation/#:~:text=Backpropagation%2C%20short%20for%20%22backward%20propagation,to%20the%20neural%20network's%20weights)\n", + "\n", "- Implement a multi-layer perceptron. (for non-linearly separable classes)\n", "- Try and implement your own backpropagation algorithm.\n", "- What are the pros and cons of the different activation functions? How should you decide between them for the different layers of a neural network?" @@ -357,7 +754,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.8.2" } }, "nbformat": 4, diff --git a/module1-Intro-to-Neural-Networks/LS_DS_421_Intro_to_NN_Lecture.ipynb b/module1-Intro-to-Neural-Networks/LS_DS_421_Intro_to_NN_Lecture.ipynb index 21ca563bd..e572ef49a 100644 --- a/module1-Intro-to-Neural-Networks/LS_DS_421_Intro_to_NN_Lecture.ipynb +++ b/module1-Intro-to-Neural-Networks/LS_DS_421_Intro_to_NN_Lecture.ipynb @@ -781,7 +781,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 4, "metadata": { "colab": {}, "colab_type": "code", @@ -791,7 +791,16 @@ "source": [ "import numpy as np\n", "\n", - "np.random.seed(812)" + "np.random.seed(812)\n", + "\n", + "inputs = np.array([\n", + " [0, 0, 1],\n", + " [1, 1, 1],\n", + " [1, 0, 1],\n", + " [0, 1, 1]\n", + "])\n", + "\n", + "correct_outputs = [[0], [1], [1], [0]]" ] }, { @@ -806,10 +815,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def sigmoid(x):\n", + " return 1/(1+np.exp(-x))\n", + "\n", + "def sigmoid_derivative(x):\n", + " sx = sigmoid(x)\n", + " return sx*(1-sx)" + ] }, { "cell_type": "markdown", @@ -836,30 +852,26 @@ }, { "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 17, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[-0.34681658],\n", - " [ 0.18690004],\n", - " [-0.48861089]])" + "array([[0.5049808 ],\n", + " [0.60592761],\n", + " [0.45748719]])" ] }, - "execution_count": 17, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], - "source": [] + "source": [ + "weights = np.random.random((3,1))\n", + "weights" + ] }, { "cell_type": "markdown", @@ -873,7 +885,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 8, "metadata": { "colab": {}, "colab_type": "code", @@ -883,18 +895,21 @@ { "data": { "text/plain": [ - "array([[-0.48861089],\n", - " [-0.64852743],\n", - " [-0.83542747],\n", - " [-0.30171084]])" + "array([[0.45748719],\n", + " [1.5683956 ],\n", + " [0.96246799],\n", + " [1.06341479]])" ] }, - "execution_count": 18, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], - "source": [] + "source": [ + "weighted_sum = np.dot(inputs, weights)\n", + "weighted_sum" + ] }, { "cell_type": "markdown", @@ -908,7 +923,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 10, "metadata": { "colab": {}, "colab_type": "code", @@ -918,18 +933,21 @@ { "data": { "text/plain": [ - "array([[0.38022086],\n", - " [0.34332146],\n", - " [0.30249868],\n", - " [0.42513931]])" + "array([[0.6124179 ],\n", + " [0.82755477],\n", + " [0.72361567],\n", + " [0.74334258]])" ] }, - "execution_count": 20, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], - "source": [] + "source": [ + "activated_outputs = sigmoid(weighted_sum)\n", + "activated_outputs" + ] }, { "cell_type": "markdown", @@ -943,7 +961,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 11, "metadata": { "colab": {}, "colab_type": "code", @@ -953,18 +971,21 @@ { "data": { "text/plain": [ - "array([[-0.38022086],\n", - " [ 0.65667854],\n", - " [ 0.69750132],\n", - " [-0.42513931]])" + "array([[-0.6124179 ],\n", + " [ 0.17244523],\n", + " [ 0.27638433],\n", + " [-0.74334258]])" ] }, - "execution_count": 30, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], - "source": [] + "source": [ + "error = correct_outputs - activated_outputs\n", + "error" + ] }, { "cell_type": "markdown", @@ -975,28 +996,31 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([[-0.09170084],\n", - " [ 0.15942546],\n", - " [ 0.17044631],\n", - " [-0.10162331]])" + "array([[-0.14536487],\n", + " [ 0.02460929],\n", + " [ 0.05527577],\n", + " [-0.14181816]])" ] }, - "execution_count": 31, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], - "source": [] + "source": [ + "adjustments = error*sigmoid_derivative(weighted_sum)\n", + "adjustments" + ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 14, "metadata": { "colab": {}, "colab_type": "code", @@ -1006,17 +1030,20 @@ { "data": { "text/plain": [ - "array([[-0.01694481],\n", - " [ 0.24470219],\n", - " [-0.35206327]])" + "array([[0.58486587],\n", + " [0.48871874],\n", + " [0.25018922]])" ] }, - "execution_count": 32, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], - "source": [] + "source": [ + "weights = weights + np.dot(inputs.T, adjustments)\n", + "weights" + ] }, { "cell_type": "markdown", @@ -1030,7 +1057,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 16, "metadata": { "colab": {}, "colab_type": "code", @@ -1042,14 +1069,14 @@ "output_type": "stream", "text": [ "Weights after training\n", - "[[15.03816068]\n", - " [-0.40646344]\n", - " [-7.23295871]]\n", + "[[ 9.67298441]\n", + " [-0.20821636]\n", + " [-4.62940995]]\n", "Output after training\n", - "[[7.21931269e-04]\n", - " [9.99388289e-01]\n", - " [9.99592516e-01]\n", - " [4.80923197e-04]]\n" + "[[0.00966666]\n", + " [0.99211836]\n", + " [0.99359037]\n", + " [0.00786392]]\n" ] } ], @@ -1071,10 +1098,11 @@ " # Cac error\n", " error = correct_outputs - activated_output\n", " \n", - " adjustments = error * sigmoid_derivate(weighted_sum)\n", + " adjustments = error * sigmoid_derivative(weighted_sum)\n", " \n", " # Update the Weights\n", " weights += np.dot(inputs.T, adjustments)\n", + " #weights = weights + weights + np.dot(inputs.T, adjustments) # alternate way of writing weights\n", " \n", "print(\"Weights after training\")\n", "print(weights)\n", @@ -1102,7 +1130,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 4, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1195,7 +1223,7 @@ "149 5.9 3.0 5.1 1.8 Iris-virginica" ] }, - "execution_count": 35, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -1213,7 +1241,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 5, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1259,7 +1287,7 @@ " dtype=object)" ] }, - "execution_count": 36, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -1271,7 +1299,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1293,7 +1321,7 @@ " 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1])" ] }, - "execution_count": 37, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -1305,16 +1333,7 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "y" - ] - }, - { - "cell_type": "code", - "execution_count": 38, + "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1430,7 +1449,7 @@ " [5.7, 4.1]])" ] }, - "execution_count": 38, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -1442,7 +1461,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1455,7 +1474,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1477,7 +1496,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 12, "metadata": { "colab": {}, "colab_type": "code", @@ -1491,14 +1510,14 @@ " self.rate = rate\n", " self.niter = niter\n", " \n", - " def fit(self, X, y):\n", + " def fit(self, X, y): # called fit to be consistent with sklearn API\n", " \"\"\"Fit training data\n", " X : Training vectors, X.shape : [#samples, #features]\n", " y : Target values, y.shape : [#samples]\n", " \"\"\"\n", "\n", " # weights\n", - " self.weight = np.zeros(1 + X.shape[1])\n", + " self.weight = np.random.random(1 + X.shape[1]) # could be random.zero but it goes much slower\n", "\n", " # Number of misclassifications\n", " self.errors = [] # Number of misclassifications\n", @@ -1506,10 +1525,13 @@ " for i in range(self.niter):\n", " err = 0\n", " for xi, target in zip(X, y):\n", - " delta_w = self.rate * (target - self.predict(xi))\n", + " predictions = self.predict(xi)\n", + " delta_w = self.rate * (target - predictions) #self.predict(xi) was replaced with predictions\n", " self.weight[1:] += delta_w * xi\n", " self.weight[0] += delta_w\n", - " err += int(delta_w != 0.0)\n", + " if delta_w != 0.0:\n", + " #err += int(delta_w != 0.0) # replaced this with if statement just above and just below, for better readability and understanding\n", + " err = err + 1\n", " self.errors.append(err)\n", " return self\n", "\n", @@ -1520,12 +1542,12 @@ " def predict(self, X):\n", " \"\"\"Return class label after unit step\"\"\"\n", " \"\"\" Default Step Function\"\"\"\n", - " return np.where(self.net_input(X) >= 0.0, 1, -1)" + " return np.where(self.net_input(X) >= 0.0, 1, -1) # if greater than 0, output 1, and if not greater than 0, output -1" ] }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 13, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1538,7 +1560,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deXhV5bn38e+dARLCEOYZEiDBWdGIKCqzWu1Ra7XVU1u11uk4IPr6Hu11Xjuc9tQeCzi2Sp1r1baWUmu1GAERZyOKOBFmGSWAzAGScL9/7BUNIcMCsvfayf59rmtde++1117rl63kzrOetZ7H3B0REUldaVEHEBGRaKkQiIikOBUCEZEUp0IgIpLiVAhERFJcRtQB9leXLl08Ly8v6hgiIs3Ke++9t97du9b1XrMrBHl5eZSUlEQdQ0SkWTGz5fW9p1NDIiIpToVARCTFqRCIiKQ4FQIRkRSnQiAikuLidtWQmWUBrwKtg+M86+4/qbVNa+AJ4DhgA/Bdd18Wr0wSM+39Vdw5fQGrN5XTKzebW04fzLlDekcdS0QiEs8WwS5gtLsfDRwDnGFmw2ptcznwpbsPAiYDv45jHiFWBG6bOp9Vm8pxYNWmcm6bOp9p76+KOpqIRCRuhcBjtgUvM4Ol9pjX5wCPB8+fBcaYmcUrk8Cd0xdQXlG117ryiirunL4gokQiErW49hGYWbqZfQCsA4rd/e1am/QGVgC4eyWwGehcx36uNLMSMyspKyuLZ+QWb/Wm8v1aLyItX1wLgbtXufsxQB9gqJkdUWuTuv7632emHHef4u5F7l7UtWudd0hLSL1ys/drvYi0fAm5asjdNwGvAGfUemsl0BfAzDKADsDGRGRKVePHDNpnXVZGGrecPjiCNCKSDOJWCMysq5nlBs+zgbHAZ7U2ew64JHh+PjDTNXdmXG3YXgFAl7atvmqOHZ/fSVcNiaSweA461xN43MzSiRWcP7v782b2c6DE3Z8DHgb+YGaLiLUELoxjnpS3dWcFD766mJGDu/LYZUMBuPWvHzJ17qqvLiUVkdQTt0Lg7h8CQ+pYf3uN5zuBC+KVQfb26OvL2LSjgpvGFX617rrRg/jr3JXcN2sR//OtIyNMJyJR0Z3FKWLzjgp+P2cJ4w7rzlF9cr9a36djGy48vh9/fncFn2/YEWFCEYmKCkGK+P2cJWzdWblXa6DadaMHkZ5m3DNzYQTJRCRqKgQpYMO2XTzy+lLOOqonh/Zsv8/73dtncfGw/kydu5IlZdvq2IOItGQqBCngwVeXsLOiigljC+rd5pqRA2mdkc5dL6tVIJJqVAhauHVbdvLEm8s495jeDOrWrt7turRtzaXD8/jHh6tZsHZr4gKKSORUCFq4376ymIoq54Yx9bcGql15ygByWmUwubg0AclEJFmoELRgqzeV89Tbn3PBcX3I65LT6PYdc1px+cn5/OvjtXy0anMCEopIMlAhaMHunbkIx7lu9L7DStTn8lPy6ZCdqVaBSApRIWihPt+wg7+UrOCiof3o07FN6M+1z8rkylMHMOOzdcz9/Ms4JhSRZKFC0ELdM3Mh6WnGtaPCtwaqXXpSHp1zWqlVIJIiVAhaoMVl25g6dyUXD+tP9/ZZ+/35nNYZXD1iIHMWruftJRvikFBEkokKQQt098sLaZ2RzjUjBx7wPi4e1p9u7VozsbgUDQgr0rKpELQwC9Zu5R8frubS4Xl0adv6gPeT3Sqda0cN4p2lG3l9kVoFIi2ZCkELM7m4lLatMrjq1AEHva8Lh/alV4csfvPSArUKRFowFYIW5KNVm/nXx2v54cn55LZpddD7a52RzvVjCvhgxSZmLVjXBAlFJBmpELQgk4pL6ZCdyeWn5DfZPs8/rg/9OrVh4kvqKxBpqVQIWoi5n3/JzM/WceWpA2ifldlk+81MT2P8mAI+Xr2F6R+vbbL9ikjyUCFoISYXl9I5pxWXnpTX5Ps+d0hvBnTNYVJxKVV71CoQaWlUCFqAt5dsYM7C9VwzciA5rZt+9tH0NGPC2EJKv9jG8x+ubvL9i0i0VAiaOXdn4kuldGvXmouH9Y/bcc46sieH9GjH3S8vpLJqT9yOIyKJp0LQzL22aD3vLNvItaMGkZWZHrfjpKUZN44tZMn67Uz7QK0CkZZEhaAZq24N9OqQxYVD+8b9eKcf3p0jerfn7hmlVKhVINJiqBA0Y7MWrOODFZu4fkwBrTPi1xqoZmbcPG4wKzaW85eSlXE/nogkRqOFwMwGmlnr4PlIM7vBzHLjH00aUt0a6NepDecf1ydhxx05uCvH9svl3pkL2VlRlbDjikj8hGkR/BWoMrNBwMNAPvBUYx8ys75mNsvMPjWzj81sfB3bjDSzzWb2QbDcvt8/QYqa/vFaPl69hfFjCshMT1zDzsy4+bTBrNm8k2fe+TxhxxWR+AnzG2SPu1cC3wLucvcJQM8Qn6sEbnb3Q4FhwLVmdlgd281x92OC5eehk6ewqj3OpOJSBnTN4dwhvRN+/JMGduaE/E7c/8piynerVSDS3IUpBBVmdhFwCfB8sK7RW1fdfY27zw2ebwU+BRL/W6sFev7D1ZR+sY0JYwtJT7OEH7+6VVC2dRd/eGtZwo8vIk0rTCG4DDgR+KW7LzWzfODJ/TmImeUBQ4C363j7RDObZ2Yvmtnh9Xz+SjMrMbOSsrKy/Tl0i1NZtYe7X17IIT3acdaRYRpm8TE0vxOnFHThgdlL2LarMrIcInLwGi0E7v6Ju9/g7k8Hr5e6+x1hD2BmbYn1M9zo7ltqvT0X6O/uRwP3AtPqyTDF3Yvcvahr165hD90i/e39VSxZv50J4wpJi6A1UNPNpw1m4/bdPP7GskhziMjBCXPV0HAzKzazUjNbYmZLzWxJmJ2bWSaxIvBHd59a+3133+Lu24LnLwCZZtZlP3+GlLG7cg/3zFzIkb07cNph3aOOwzF9cxl7aDcenL2YzeUVUccRkQMU5tTQw8Ak4GTgeKAoeGyQmVnw2U/dfVI92/QItsPMhgZ5NB1WPf7y3gpWbCznpnGFBF9b5CaMK2TLzkoefm1p1FFE5ACFGaFss7u/eAD7Hg58H5hvZh8E634M9ANw9weA84FrzKwSKAcudA16X6edFVXcN3MRx/bLZeTg5Dk9dnivDpx5ZA8eeW0pl52UR8ecg58QR0QSK0whmGVmdwJTgV3VK6uvCKqPu78GNPhnq7vfB9wXIkPKe+adz1mzeSe/ueDopGkNVLtxbCEvfrSWB19dwq3fOCTqOCKyn8IUghOCx6Ia6xwY3fRxpC7lu6u4b9Zihg3oxEkDO0cdZx+F3dtxztG9ePyNZVx+cj5d27WOOpKI7IcwVw2NqmNREUigP7y1jPXbdnHzaYOTrjVQbfzYQnZX7eF3ryyOOoqI7KcwVw11MLNJ1dfxm9lEM+uQiHAC23ZV8rtXFnNKQReOz+sUdZx65XfJ4bwhvXny7eWs3bwz6jgish/CXDX0CLAV+E6wbAEejWco+dpjry/lyx0V3Hza4KijNOqGMQW4O/fPWhR1FBHZD2EKwUB3/4m7LwmWnwED4h1MYHN5BVNeXcLYQ7txTN/kH/C1b6c2fKeoL8+8+zkrv9wRdRwRCSlMISg3s5OrX5jZcGKXekqcPTxnCVt2VjJhXGHUUUK7bvQgzIx7Z6hVINJchCkE1wD3m9kyM1tO7HLPq+MbSzZu380jry/jzCN7cHiv5tMl07NDNt87oR/Pzl3JsvXbo44jIiGEuWrog2AsoKOAI919iLvPi3+01Pbgq4vZvruSG8c2n9ZAtWtGDiQz3bh7xsKoo4hICPXeR2BmF7v7k2Z2U631ANQ3bIQcvLKtu3jijeWcc3QvCru3izrOfuvWLotLTspjyqtL+I+RAylohj+DSCppqEWQEzy2q2NpG+dcKe13ryxmd9UexjfD1kC1q04dSJvMdO56Wa0CkWRXb4vA3R8Mnr7s7q/XfC/oMJY4WLO5nCffXs63j+1Nfpecxj+QpDrltOLyk/O5Z+Yirl29hcN6tY86kojUI0xn8b0h10kTuH/WItyd60cXRB3loF1+ygDaZ2Uwqbg06igi0oCG+ghOBE4CutbqJ2gPpMc7WCpasXEHf3p3Bd8p6kvfTm2ijnPQOmRncsUpA5hYXMq8FZs4uhncCyGSihpqEbQi1heQwd79A1uIDR8tTezemQsxM64bPSjqKE3mspPz6dgmU60CkSTWUB/BbGC2mT3m7ssTmCklLV2/nb/OXcUPTuxPzw7ZUcdpMm1bZ3D1iIH86sXPKFm2kaIkHi9JJFWF6SPYYWZ3mtkLZjazeol7shRz98ulZKYb14wcGHWUJveDE/Po0rY1E19Sq0AkGYUpBH8EPgPygZ8By4B345gp5Sz8Yit/n7eaS07Ko1u7rKjjNLnsVulcO2ogby7ZwBuL1kcdR0RqCVMIOrv7w0CFu8929x8Cw+KcK6VMfrmUNpnpXHVqy2sNVLtoaD96dshiYnEpmo1UJLmEKQQVweMaMzvLzIYAfeKYKaV8vHozL8xfy+Un59OpBc/3m5WZznWjB/He8i+ZXVoWdRwRqSFMIfhFMBHNzcD/AR4CJsQ1VQqZXLyQ9lkZXH5Kyx/Z+4Lj+tKnYzaT1CoQSSphBp173t03u/tHwTSVx7n7c4kI19J9sGITL3/6BVecMoAO2ZlRx4m7Vhlp3DCmgA9Xbqb4ky+ijiMigTBTVT5uZrk1Xnc0s0fiGys1TCoupWObTC47OT/qKAlz3pDY0BmTikvZs0etApFkEObU0FHuvqn6hbt/CQyJX6TU8O6yjbxaWsbVIwbStnW9t3O0OBnpadw4toDP1m7lhY/WRB1HRAhXCNLMrGP1CzPrRAM3okk4E19aQJe2rfnBiXlRR0m4bx7Vi8LubZlcXEqVWgUikQvzC30i8IaZPRu8vgD4ZWMfMrO+wBNAD2APMMXd7661jQF3A2cCO4BL3X1u+PjhTHt/FXdOX8DqTeX0ys3mltMHc+6Q3k19mNA5Vm2KzfR53pBeZLdKvWGb0tOMCWMLueaPcyn6RTGbdlRE+t9FJNU1Wgjc/QkzKwFGAwac5+6fhNh3JXCzu881s3bAe2ZWXOuz3wAKguUE4HfBY5OZ9v4qbps6n/KKKgBWbSrntqnzARL6S6d2DoAXPlrLqYWrUvKX387dVRjw5Y7Y1clR/XcRkYZHH23v7luCU0FrgadqvNfJ3Tc2tGN3XwOsCZ5vNbNPgd5AzUJwDvCEx64lfMvMcs2sZ/DZJnHn9AV7/fIFKK+o4sd/m8/rCbzL9Z/z1+yTY2fFHu6cviAlf/H9priU2ieFyiuqUvb7EIlSQy2Cp4BvAu/BXv9mLXgd+sJ3M8sj1sH8dq23egMrarxeGazbqxCY2ZXAlQD9+vULe1gAVgenYWrbsbsqoYVgx+6qOtfXl6+lq+/nTtXvQyRKDRWCO4LHQ91954EewMzaAn8FbnT3LbXfruMj+/QeuvsUYApAUVHRfvUu9srN/uqcfE29c7N5/dbR+7OrgzL8jpl15uiV23JGGt0f9f13SdXvQyRKDV01VN2x+8aB7tzMMokVgT+6+9Q6NlkJ9K3xug+w+kCPV5dbTh9MdubeHbLZmenccvrgpjxMs8mRLOr6PrIy01L2+xCJUkMtggozexToY2b31H7T3W9oaMfBFUEPA5+6+6R6NnsOuM7MniHWSby5KfsH4OuOx6ivGkqWHMmi9vfhwBmH90jZ70MkSlbfmC9m1gUYC/wauL32++7+eIM7NjsZmAPMJ3b5KMCPgX7B5x8IisV9wBnELh+9zN1LGtpvUVGRl5Q0uIk0Qxc/9Dafrd3C7FtGkZNCN9iJJIqZvefuRXW919AMZeuBZ8zsU3eft78HdffXqLsPoOY2Dly7v/uWluem0wo577dv8Piby/iPkS1nqk6R5qChy0f/r7v/L/AjM6urA7fBU0Mi++PYfh0ZfUg3Hpy9hIuH9ad9VssfhE8kWTTUWfxp8FhC7BLS2otIk7ppXCGbyyt45LWlUUcRSSkNnRr6R/D4VV+AmaUBbeu4DFTkoB3RuwOnH96dh+cs5dKT8sht03In6hFJJmGGoX7KzNqbWQ6xu4IXmNkt8Y8mqWjCuEK27a7k93OWRB1FJGWEGX30sKAFcC7wArGrfr4f11SSsg7p0Z5vHtWLR19fxoZtu6KOI5ISwhSCzODGsHOBv7t7BXXc/SvSVG4cW8DOiioemL046igiKSFMIXgQWAbkAK+aWX9AfQQSNwO7tuVbQ/rwxJvLWbflgEc3EZGQwsxZfI+793b3Mz1mOTAqAdkkhY0fU0DVHuf+WYuijiLS4oXpLB4fdBabmT1sZnOJzU0gEjf9OrfhgqK+PP3OijoHpxORphPm1NAPg87i04CuwGV8PTKpSNxcPzp2h/F9MxdGnESkZQtTCKqHiTgTeDQYbqLBoSNEmkKv3GwuGtqXv5Ss5PMNO6KOI9JihSkE75nZS8QKwfRg2sk9jXxGpElcO2oQ6WnG3TPUKhCJlzCF4HLgVuB4d98BtCJ2ekgk7rq1z+IHJ/bnb++vZNG6bVHHEWmRwlw1tAdYChSa2anA4UBuvIOJVLt6xECyMtPVKhCJkzBXDf0IeBWYDvwsePxpfGOJfK1z29ZcNjyPf8xbzWdrdQuLSFMLc2poPHA8sNzdRxGbhL4srqlEarnilAG0a53B5OLSqKOItDhhCsHO6snrzay1u38GaGJZSajcNq340SkDmP7xF8xfuTnqOCItSphCsNLMcoFpQLGZ/Z0mnmBeJIwfnpxHbptMJhUviDqKSIsSprP4W+6+yd1/Cvw/YhPSnxvvYCK1tcvK5MpTBzBrQRnvLf8y6jgiLUa9hcDMOtVeiE1E/xrQNmEJRWq49KQ8urRtpVaBSBOqd4YyYtNROnvfRVz92oEBccwlUqc2rTK4esRAfvHPT3lryQaGDegcdSSRZq/eFoG757v7gOAxv9ZrFQGJzMXD+tO9fWsmvVSKu6bGEDlYYe4j+JaZdajxOtfM1EcgkcnKTOe6UYN4Z9lG5ixcH3UckWYvzFVDP3H3r67Xc/dNwE/iF0mkcd85vi+9c7OZWKxWgcjBClMI6tqmob4FAMzsETNbZ2Yf1fP+SDPbbGYfBMvtIbKIANA6I50bxgxi3opNzPh0XdRxRJq1MIWgxMwmmdlAMxtgZpOJdSQ35jHgjEa2mePuxwTLz0PsU+Qr5x3bh/6d2zCpuJQ9e9QqEDlQYQrB9cBu4E/AX4CdwLWNfcjdXwU2HlQ6kQZkpqdx49gCPlmzhekfr406jkizFeaGsu3ufqu7FwFDgV+5+/YmOv6JZjbPzF40s8Pr28jMrjSzEjMrKSvTMEfytbOP7s2gbm2ZVFxKlVoFIgckzFVDTwVzFucAHwMLzOyWJjj2XKC/ux8N3EtsCIs6ufsUdy9y96KuXbs2waGlpUhPM24cW8DCddt4/kONfCJyIMKcGjosmLP4XOAFoB/w/YM9sLtvcfdtwfMXgEwz63Kw+5XUc+YRPTmkRzvuenkhlVWaPE9kf4UpBJlmlkmsEPzd3SuI3Vl8UMysh5lZ8HxokGXDwe5XUk9amnHTuEKWrt/O1PdXRR1HpNkJUwgeBJYBOcCrZtYfaHR2EDN7GngTGGxmK83scjO72syuDjY5H/jIzOYB9wAXui4IlwM07rDuHNWnA/fMWMjuSrUKRPaHHcjvXjPLcPfKOORpVFFRkZeUlERxaElyryxYx6WPvssvzj2Ci4f1jzqOSFIxs/eCi372Ue+NYWZ2sbs/aWY31bPJpCZJJ9JERhR25bj+Hblv5iLOP64PWZnpUUcSaRYaOjWUEzy2q2cRSSpmxs2nFbJ2y06eevvzqOOINBv1tgjc/cHg8WeJiyNycE4a2IUTB3Tmt68s5qKh/chupVaBSGPC3EeQHwwxMdXMnqteEhFO5EDcfFoh67ft4ok3l0UdRaRZaHTwOGI3ej0M/APQ5RiS9IryOjGisCsPzF7M94b1p23rMP+bi6SuMJeP7nT3e9x9lrvPrl7inkzkINw0rpAvd1Tw6GtLo44ikvTCFIK7zewnZnaimR1bvcQ9mchBOLpvLuMO686UOUvYvKMi6jgiSS1MITgSuAK4A5gYLL+JZyiRpnDTuEK27qzkodeWRB1FJKmFOXn6LWCAu++OdxiRpnRoz/acdWRPHnltKZcNz6dTTquoI4kkpTAtgnlAbryDiMTDhHEFlFdU8eDsxVFHEUlaYQpBd+AzM5uuy0eluRnUrR3nHNObx99cxrqtO6OOI5KUwpwa0kT10qyNH1PAc/NW89tZi/np2fXOfySSshotBLpUVJq7vC45nH9sH556+3OuGjGAnh2yo44kklTCnBoSafauHzMIx7lv5qKoo4gkHRUCSQl9OrbhwuP78ad3V7Bi446o44gklXoLgZnNCB5/nbg4IvFz7ahBpKUZ98xYGHUUkaTSUIugp5mNAM42syE17yrWncXSHPXokMXFJ/Tnr3NXsqRsW9RxRJJGQ4XgduBWoA+xSWgmojuLpZm7ZuRAWmekc7daBSJfqbcQuPuz7v4N4H/dfVStZXQCM4o0ma7tWnPJSXk8N281pV9sjTqOSFJotLPY3f/bzM42s98EyzcTEUwkXq46dQA5rTKYXFwadRSRpBBmYppfAeOBT4JlfLBOpFnqmNOKH56cz4sfreWjVZujjiMSuTCXj54FjHP3R9z9EeCMYJ1Is3X5yfm0z1KrQATC30dQc9C5DvEIIpJIHbIzuWrEQGZ8to73P/8y6jgikQpTCH4FvG9mj5nZ48B7wP/EN5ZI/F16Uh6dcloxSa0CSXFhOoufBoYBU4PlRHd/prHPmdkjZrbOzD6q530zs3vMbJGZfah7EyTRclpncPWIAcxZuJ6iXxSTf+s/GX7HTKa9vyrqaCIJFerUkLuvcffn3P3v7r425L4fI9afUJ9vAAXBciXwu5D7FWkyudmxyWrWb9uNA6s2lXPb1PkqBpJS4jbWkLu/CmxsYJNzgCc85i0g18x6xiuPSF3qurGsvKKKO6cviCCNSDSiHHSuN7CixuuVwbp9mNmVZlZiZiVlZWUJCSepYfWm8v1aL9ISNVgIzCytvnP8TcDqWOd1bejuU9y9yN2LunbtGqc4kop65dY9N0F960VaogYLgbvvAeaZWb84HHsl0LfG6z7A6jgcR6Ret5w+mOzM9L3WZWemccvpgyNKJJJ4Yaaq7Al8bGbvANurV7r72Qd57OeA68zsGeAEYLO7rznIfYrsl3OHxM5G3jl9AauC00EXDu331XqRVBCmEPzsQHZsZk8DI4EuZraS2NzHmQDu/gDwAnAmsAjYAVx2IMcROVjnDunNuUN6U1m1h9Mmv8obizawZ4+TllbX2UuRlifUnMVm1h8ocPeXzawNkB7icxc18r4D14ZOKhJnGelp3DiukBuefp/n56/h7KN7RR1JJCHCDDp3BfAs8GCwqjcwLZ6hRKLyzSN7Mrh7O+56uZTKqj1RxxFJiDCXj14LDAe2ALj7QqBbPEOJRCUtzZgwroAlZduZ9oGuXZDUEKYQ7HL33dUvzCyDei7zFGkJTj+8B4f3as/dM0qpUKtAUkCYQjDbzH4MZJvZOOAvwD/iG0skOmbGzacVsmJjOX8pWRl1HJG4C1MIbgXKgPnAVcSu9vmveIYSidqowd0Y0i+X+2YuZFdlVdRxROIqzOije4DHgf8mdinp48EVPyItlplx87jBrN68k2feWdH4B0SasTBXDZ0FLAbuAe4DFpnZN+IdTCRqwwd1Zmh+J+6btYjy3WoVSMsV5tTQRGCUu4909xHAKGByfGOJRC/WKiikbOsunnxredRxROImTCFY5+6LarxeAqyLUx6RpHLCgM6cUtCF381ezLZdlVHHEYmLeguBmZ1nZucRG2foBTO71MwuIXbF0LsJSygSsZvGFbJx+24ef2NZ1FFE4qKhFsG/BUsW8AUwgtjYQWVAx7gnE0kSQ/p1ZMwh3Xhw9mI2l1dEHUekydU71pC7axA4kcCEcYV8897XePi1pdw0rjDqOCJNqtFB58wsH7geyKu5fRMMQy3SbBzRuwPfOKIHj7y2lMtOyqNjTquoI4k0mTCdxdOAZcC9xK4gql5EUsqEcYVs313JlDlLoo4i0qTCzEew093viXsSkSRX2L0dZx/di8deX8YPh+fTtV3rqCOJNIkwLYK7zewnZnaimR1bvcQ9mUgSGj+mgF2VVTwwe3HUUUSaTJgWwZHA94HRQPVQjB68FkkpA7q25bxj+/CHt5ZzxSkD6NEhK+pIIgctTIvgW8AAdx/h7qOCRUVAUtb4MQXs2ePcP2tR4xuLNANhCsE8IDfeQUSai76d2vCd4/vyzLufs/LLHVHHETloYQpBd+AzM5tuZs9VL/EOJpLMrh89CDPj3hlqFUjzF6aP4CdxTyHSzPTskM2/D+3HH95azjUjB5LXJSfqSCIHLMx8BLPrWhIRTiSZ/ceogWSmG3fPWBh1FJGDEmY+gq1mtiVYdppZlZltSUQ4kWTWrV0Wl5yYx7QPVrFo3dao44gcsDAtgnbu3j5YsoBvE5ugRiTlXTViIG0y05n8sloF0nyF6Szei7tPI+Q9BGZ2hpktMLNFZnZrHe9famZlZvZBsPxof/OIRKlTTit+eHI+//xwDZ+sVkNZmqcwp4bOq7Gcb2Z3ELuhrLHPpQP3A98ADgMuMrPD6tj0T+5+TLA8tL8/gEjUfnTyANplZTD55dKoo4gckDAtgn+rsZwObAXOCfG5ocAid1/i7ruBZ0J+TqRZ6dAmkytOGUDxJ18wb8WmqOOI7LcwfQSX1ViucPdfunuYqSp7AytqvF4ZrKvt22b2oZk9a2Z969qRmV1pZiVmVlJWVhbi0CKJddnwPDq2yWRSsVoF0vzUex+Bmd3ewOfc3f+7kX1bXZ+r9fofwNPuvsvMrgYep47+B3efAkwBKCoqavS0lEiitcvK5KoRA7njxc8oWbaRorxOUUcSCa2hFsH2OhaAy4H/DLHvlUDNv/D7AKtrbuDuG9x9V/Dy98BxIfYrkpR+cGJ/urRtzcSX1CqQ5qXeQuDuE6sXYn+NZwOXEeL7FLUAAAnDSURBVDvXPyDEvt8FCsws38xaARcCew1NYWY9a7w8G/h0P/OLJI02rTL4j5EDeXPJBt5YtD7qOCKhNdhHYGadzOwXwIfETiMd6+7/GaaPwN0rgeuA6cR+wf/Z3T82s5+bWfU0lzeY2cdmNg+4Abj0IH4Wkcj9+wn96NE+i4nFpbjrLKY0Dw31EdwJnEesNXCku2/b3527+wvAC7XW3V7j+W3Abfu7X5FklZWZznWjB/Ff0z5idmkZIwd3izqSSKMaahHcDPQC/gtYXWOYia0aYkKkft8p6kufjtlMUqtAmomG+gjS3D271hAT7atfJzKkSHPSKiONG8YU8OHKzRR/8kXUcUQatd9DTIhI484b0pv8LjlMKi5lzx61CiS5qRCIxEFGehrjxxTw2dqtvPjR2qjjiDRIhUAkTv7t6F4UdGvL5JdLqVKrQJKYCoFInKSnGRPGFbJo3Taem7cq6jgi9VIhEImjMw7vwWE923PXywupqNoTdRyROqkQiMRRWppx07hClm/YwdS5K6OOI1InFQKROBtzaDeO7pvLPTMWsauyKuo4IvtQIRCJMzPj5nGFrNpUzp/fXdH4B0QSTIVAJAFOKejC8XkduW/WInZWqFUgyUWFQCQBzIybTxvMF1t28eRby6OOI7IXFQKRBBk2oDPDB3XmgdmL2bG7Muo4Il9RIRBJoJvGDWb9tt08/oZaBZI8VAhEEui4/h0ZNbgrD766mK07K6KOIwKoEIgk3E3jBrNpRwWPvLYs6igigAqBSMId2acDpx/enYfmLGHTjt1RxxFRIRCJwoRxhWzbXcnv5yyJOoqICoFIFA7p0Z6zjuzJo68vY8O2XVHHkRSnQiASkRvHFrKzoooHZi+OOoqkOBUCkYgM6taWc4f05ok3l7Nuy86o40gKUyEQidD4MQVU7XF++4paBRIdFQKRCPXvnMMFRX146u3PWbWpPOo4kqJUCEQidt3oAgDum7ko4iSSqjLiuXMzOwO4G0gHHnL3O2q93xp4AjgO2AB8192XxTOTSLLpnZvNRUP78sSby5n52Res27KLXrnZ3HL6YM4d0juhWaa9v4o7py9g9abyyDIoR+JzxK0QmFk6cD8wDlgJvGtmz7n7JzU2uxz40t0HmdmFwK+B78Yrk0iyGtg1Bwe+2BK7lHTVpnJumzofIGG/eKa9v4rbps6nPBgmO4oMyhFNDnP3JtnRPjs2OxH4qbufHry+DcDdf1Vjm+nBNm+aWQawFujqDYQqKirykpKSuGQWicrwO2bW2UeQkWbkd8lJSIal67dTuWfff3qJzKAc4XP0zs3m9VtHh96Pmb3n7kV1vRfPU0O9gZrTMa0ETqhvG3evNLPNQGdgfc2NzOxK4EqAfv36xSuvSGRW19NRXLnHKejeNiEZFq7bFnkG5Qifo77/Zw5EPAuB1bGudlkLsw3uPgWYArEWwcFHE0kuvXKz62wR9M7N5rffOy4hGeprlSQyg3KEz9ErN7vJjhHPq4ZWAn1rvO4DrK5vm+DUUAdgYxwziSSlW04fTHZm+l7rsjPTueX0wSmVQTmiyRHPFsG7QIGZ5QOrgAuBf6+1zXPAJcCbwPnAzIb6B0RaqupOvyivUEmGDMoRTY64dRYDmNmZwF3ELh99xN1/aWY/B0rc/TkzywL+AAwh1hK40N0bHI5RncUiIvsvqs5i3P0F4IVa626v8XwncEE8M4iISMN0Z7GISIpTIRARSXEqBCIiKU6FQEQkxcX1qqF4MLMyYHnUOQ5SF2rdPZ3i9H3sTd/H1/Rd7O1gvo/+7t61rjeaXSFoCcyspL7LuFKRvo+96fv4mr6LvcXr+9CpIRGRFKdCICKS4lQIojEl6gBJRt/H3vR9fE3fxd7i8n2oj0BEJMWpRSAikuJUCEREUpwKQQKZWV8zm2Vmn5rZx2Y2PupMUTOzdDN738yejzpL1Mws18yeNbPPgv9HTow6U5TMbELw7+QjM3s6GK04ZZjZI2a2zsw+qrGuk5kVm9nC4LFjUxxLhSCxKoGb3f1QYBhwrZkdFnGmqI0HPo06RJK4G/iXux8CHE0Kfy9m1hu4AShy9yOIDWV/YbSpEu4x4Ixa624FZrh7ATAjeH3QVAgSyN3XuPvc4PlWYv/QEzvLRRIxsz7AWcBDUWeJmpm1B04FHgZw993uvinaVJHLALKD2QvbsO8Mhy2au7/KvjM2ngM8Hjx/HDi3KY6lQhARM8sjNiHP29EmidRdwP8F9kQdJAkMAMqAR4NTZQ+ZWU7UoaLi7quA3wCfA2uAze7+UrSpkkJ3d18DsT8sgW5NsVMVggiYWVvgr8CN7r4l6jxRMLNvAuvc/b2osySJDOBY4HfuPgTYThM1+5uj4Nz3OUA+0AvIMbOLo03VcqkQJJiZZRIrAn9096lR54nQcOBsM1sGPAOMNrMno40UqZXASnevbiE+S6wwpKqxwFJ3L3P3CmAqcFLEmZLBF2bWEyB4XNcUO1UhSCAzM2LngD9190lR54mSu9/m7n3cPY9YJ+BMd0/Zv/jcfS2wwswGB6vGAJ9EGClqnwPDzKxN8O9mDCnceV7Dc8AlwfNLgL83xU7jOmex7GM48H1gvpl9EKz7cTC3s8j1wB/NrBWwBLgs4jyRcfe3zexZYC6xq+3eJ8WGmzCzp4GRQBczWwn8BLgD+LOZXU6sWDbJnO8aYkJEJMXp1JCISIpTIRARSXEqBCIiKU6FQEQkxakQiIikOBUCkYCZVZnZBzWWJruz18zyao4iKZJMdB+ByNfK3f2YqEOIJJpaBCKNMLNlZvZrM3snWAYF6/ub2Qwz+zB47Bes725mfzOzecFSPTRCupn9Phhj/yUzyw62v8HMPgn280xEP6akMBUCka9l1zo19N0a721x96HAfcRGTSV4/oS7HwX8EbgnWH8PMNvdjyY2XtDHwfoC4H53PxzYBHw7WH8rMCTYz9Xx+uFE6qM7i0UCZrbN3dvWsX4ZMNrdlwSDBq51985mth7o6e4Vwfo17t7FzMqAPu6+q8Y+8oDiYEIRzOw/gUx3/4WZ/QvYBkwDprn7tjj/qCJ7UYtAJByv53l929RlV43nVXzdR3cWcD9wHPBeMBGLSMKoEIiE890aj28Gz9/g6+kTvwe8FjyfAVwDX83J3L6+nZpZGtDX3WcRm6QnF9inVSIST/rLQ+Rr2TVGhYXY/MHVl5C2NrO3if3xdFGw7gbgETO7hdjsYtWjhY4HpgQjRFYRKwpr6jlmOvCkmXUADJisKSol0dRHINKIoI+gyN3XR51FJB50akhEJMWpRSAikuLUIhARSXEqBCIiKU6FQEQkxakQiIikOBUCEZEU9/8BhzRkowXfsHQAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1555,12 +1577,14 @@ "plt.plot(range(1, len(pn.errors) + 1), pn.errors, marker='o')\n", "plt.xlabel('Epochs')\n", "plt.ylabel('Number of misclassifications')\n", - "plt.show()" + "plt.show()\n", + "\n", + "# As the model learns the proper weight, the number of misclassifications goes down." ] }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 14, "metadata": { "colab": {}, "colab_type": "code", @@ -1576,9 +1600,9 @@ " cmap = ListedColormap(colors[:len(np.unique(y))])\n", "\n", " # plot the decision surface\n", - " x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1\n", + " x1_min, x1_max = X[:, 0].min() - 1, X[:, 0].max() + 1 # creates grid with minimum and maximum values\n", " x2_min, x2_max = X[:, 1].min() - 1, X[:, 1].max() + 1\n", - " xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution),\n", + " xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), # takes values from grid to make predictions in entire range\n", " np.arange(x2_min, x2_max, resolution))\n", " Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)\n", " Z = Z.reshape(xx1.shape)\n", @@ -1595,7 +1619,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 15, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1610,13 +1634,13 @@ "name": "stderr", "output_type": "stream", "text": [ - "'c' argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with 'x' & 'y'. Please use a 2-D array with a single row if you really want to specify the same RGB or RGBA value for all points.\n", - "'c' argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with 'x' & 'y'. Please use a 2-D array with a single row if you really want to specify the same RGB or RGBA value for all points.\n" + "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n", + "*c* argument looks like a single numeric RGB or RGBA sequence, which should be avoided as value-mapping will have precedence in case its length matches with *x* & *y*. Please use the *color* keyword-argument or provide a 2-D array with a single row if you intend to specify the same RGB or RGBA value for all points.\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1632,7 +1656,9 @@ "plt.xlabel('sepal length [cm]')\n", "plt.ylabel('petal length [cm]')\n", "plt.legend(loc='upper left')\n", - "plt.show()" + "plt.show()\n", + "\n", + "# Precision boundary learned by the perceptron, for classification" ] }, { @@ -1682,9 +1708,9 @@ "version": "0.3.2" }, "kernelspec": { - "display_name": "U4-S2-NNF (Python 3.7)", + "display_name": "Python 3", "language": "python", - "name": "u4-s2-nnf" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -1696,7 +1722,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.3" + "version": "3.8.2" }, "toc-autonumbering": false, "toc-showcode": false,