From 951a917224f7853f6755cddafa24b24abb9946e7 Mon Sep 17 00:00:00 2001 From: Ethan M Date: Wed, 13 Dec 2023 17:26:10 -0800 Subject: [PATCH 1/2] Add forward-forward tutorial --- docs/tutorials/tutorials.rst | 6 +- examples/tutorial_forward_forward.ipynb | 1224 +++++++++++++++++++++++ 2 files changed, 1229 insertions(+), 1 deletion(-) create mode 100644 examples/tutorial_forward_forward.ipynb diff --git a/docs/tutorials/tutorials.rst b/docs/tutorials/tutorials.rst index 9043367b..321d7bd4 100644 --- a/docs/tutorials/tutorials.rst +++ b/docs/tutorials/tutorials.rst @@ -81,6 +81,10 @@ The tutorial consists of a series of Google Colab notebooks. Static non-editable * - `Accelerating snnTorch on IPUs `_ - — - + + * - `The Forward Forward Algorithm `_ + - .. image:: https://colab.research.google.com/assets/colab-badge.svg + :alt: Open In Colab + :target: https://colab.research.google.com/github/jeshraghian/snntorch/blob/master/examples/tutorial_forward_forward.ipynb Future tutorials on spiking neurons and training are under development. \ No newline at end of file diff --git a/examples/tutorial_forward_forward.ipynb b/examples/tutorial_forward_forward.ipynb new file mode 100644 index 00000000..eca75eb1 --- /dev/null +++ b/examples/tutorial_forward_forward.ipynb @@ -0,0 +1,1224 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "47d5313e-c29d-4581-a9c7-a45122337069", + "metadata": { + "id": "47d5313e-c29d-4581-a9c7-a45122337069" + }, + "source": [ + "[](https://github.com/jeshraghian/snntorch/)\n", + "\n", + "# The Forward-Forward Algorithm\n", + "### Tutorial written by Ethan Mulle and Abhinandan Singh\n" + ] + }, + { + "cell_type": "markdown", + "id": "oll2NNFeG1NG", + "metadata": { + "id": "oll2NNFeG1NG" + }, + "source": [ + "The following tutorial introduces how to implement the Forward-Forward algorithm proposed by Geoffrey Hinton into a spiking neural network (SNN).\n", + "> [Geoffrey Hinton. The Forward-Forward Algorithm: Some Preliminary\n", + "Investigations. 2022. arXiv: 2212.13345 [cs.LG].](https://arxiv.org/abs/2212.13345) \n", + "\n", + "For a comprehensive overview on how SNNs work, and what is going on under the hood, [then you might be interested in the snnTorch tutorial series available here.](https://snntorch.readthedocs.io/en/latest/tutorials/index.html)\n", + "The snnTorch tutorial series is based on the following paper. If you find these resources or code useful in your work, please consider citing the following source:\n", + "\n", + "> [Jason K. Eshraghian, Max Ward, Emre Neftci, Xinxin Wang, Gregor Lenz, Girish Dwivedi, Mohammed Bennamoun, Doo Seok Jeong, and Wei D. Lu. \"Training Spiking Neural Networks Using Lessons From Deep Learning\". Proceedings of the IEEE, 111(9) September 2023.](https://ieeexplore.ieee.org/abstract/document/10242251) " + ] + }, + { + "cell_type": "markdown", + "source": [ + "- Run the below two cells to install snnTorch and then import PyTorch and snnTorch for use." + ], + "metadata": { + "id": "ELOnnEYi4YY8" + }, + "id": "ELOnnEYi4YY8" + }, + { + "cell_type": "code", + "execution_count": null, + "id": "hDnIEHOKB8LD", + "metadata": { + "id": "hDnIEHOKB8LD", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "8914c89f-07eb-4c55-fa26-023f6fbd6ac2" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/109.0 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m109.0/109.0 kB\u001b[0m \u001b[31m3.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25h" + ] + } + ], + "source": [ + "!pip install snntorch --quiet" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "WL487gZW1Agy", + "metadata": { + "id": "WL487gZW1Agy" + }, + "outputs": [], + "source": [ + "import torch, torch.nn as nn\n", + "import snntorch as snn\n", + "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")" + ] + }, + { + "cell_type": "markdown", + "id": "EYf13Gtx1OCj", + "metadata": { + "id": "EYf13Gtx1OCj" + }, + "source": [ + "## 1. The MNIST Dataset\n", + "For this tutorial, we will be using the MNIST dataset. MNIST is a dataset of 60,000 images in the training set and 10,000 images in the test set of grayscale handwritten numerical digits. The goal is to classify the digit written in each image between 0-9.\n", + "\n", + "\n", + "* The spatial dimensions of MNIST are $28\\times 28$\n", + "* The image is grayscale so the channel size is $1$\n", + "* There are no time-varying components, so there is no sequence length\n", + "\n", + "\n", + "### 1.1 Dataloading\n", + "\n", + "- Set up data loaders for the MNIST training and test datasets.\n", + "\n", + "- Define a data transformation pipeline, and iterate over the first batch of the training loader to inspect the size of the data.\n", + "\n", + "- The transformations include converting images to grayscale, transforming them to tensors, normalizing pixel values, and flattening the tensors." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3GdglZjK04cb", + "metadata": { + "id": "3GdglZjK04cb", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "bdc684d2-4feb-458a-c2f2-2525121756d3" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", + "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 9912422/9912422 [00:00<00:00, 154424511.55it/s]" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", + "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 28881/28881 [00:00<00:00, 38201101.81it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 1648877/1648877 [00:00<00:00, 48104859.92it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n", + "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "100%|██████████| 4542/4542 [00:00<00:00, 24613086.26it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n", + "\n", + "torch.Size([50000, 784])\n" + ] + } + ], + "source": [ + "from torchvision.datasets import MNIST\n", + "from torchvision.transforms import Compose, Grayscale, ToTensor, Normalize, Lambda\n", + "from torch.utils.data import DataLoader\n", + "\n", + "# **DATA TRANFORMATION FUNCTION**\n", + "# defines a data transformation pipeline using the 'Compose' class.\n", + "# the pipeline includes converting images to grayscale, transforming them to tensors, normalizing pixel values, and flattening the tensors.\n", + "transform = Compose([\n", + " Grayscale(),\n", + " ToTensor(),\n", + " Normalize((0,), (1,)),\n", + " Lambda(lambda x: torch.flatten(x))])\n", + "\n", + "\n", + "# **LOAD AND TRANFORM TRAIN DATA**\n", + "mnist_train = MNIST('./data/', train=True, download=True, transform=transform)\n", + " # loads the MNIST training dataset with specified transformations.\n", + "train_loader = DataLoader(mnist_train, batch_size=50000, shuffle=True)\n", + " # creates a DataLoader for the training dataset with a batch size of 50000 and shuffling enabled.\n", + "\n", + "# **LOAD AND TRANFORM TEST DATA**\n", + "mnist_test = MNIST('./data/', train=False, download=True, transform=transform)\n", + " # loads the MNIST test dataset with the same transformations as the training dataset.\n", + "test_loader = DataLoader(mnist_train, batch_size=10000, shuffle=False)\n", + " # creates a DataLoader for the test dataset with a batch size of 10000.\n", + "\n", + "# **ITERATE OVER TRAIN LOADER**\n", + "for data, label in iter(train_loader):\n", + "# initiates a loop to iterate over batches from the training loader.\n", + " print(data.size())\n", + " # prints the size of the first batch of data.\n", + " break" + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 2. Forward-Forward Algorithm Theory\n", + "The Forward-Forward algorithm is a learning procedure inspired by Boltzmann machines and Noise Contrastive Estimation. The algorithm is illustrated in the figure below. It works by replacing the forward and backward passes of backpropagation with two forward passes - the positive pass and the negative pass. These passes operate in exactly the same way as each other, however, the positive pass works on real data to adjust the weights to increase the goodness in each layer, while the negative pass works on \"bad\" generated data to adjust the weights to decrease the goodness in each layer. As such, each layer has its own objective function that is locally updated in contrast to backpropagation which has a global objective function that is optimized.\n", + "\n", + "![](https://drive.google.com/uc?export=view&id=1cYmOJ1goT4-Yb0ftucAwYYhYTfmesXZ6)" + ], + "metadata": { + "id": "XOT9ESAC5d1G" + }, + "id": "XOT9ESAC5d1G" + }, + { + "cell_type": "markdown", + "source": [ + "Goodness can be measured through a metric such as the sum of the squared neural activities. The aim of learning the the Forward-Forward algorithm is then to make the goodness be well above some threshold value for real data and well below that value for negative data. In practice, the aim is to correctly classify input vectors as positive data or negative data when the probability that an input vector is real is given by applying the logistic function, $\\sigma$ to the goodness minus some threshold, $\\theta$\n", + "\\begin{equation}\n", + " p(positive) = \\sigma \\left(\\sum_j y_j^2 - \\theta \\right)\n", + "\\end{equation}\n", + "where $y_j$ is the activity of hidden unit $j$ before layer normalization." + ], + "metadata": { + "id": "B1B_tzLsihYM" + }, + "id": "B1B_tzLsihYM" + }, + { + "cell_type": "markdown", + "source": [ + "## 3. Implementation\n", + "We follow and modify the Forward-Forward algorithm implementation found here:\n", + "> [Mohammad Pezeshki. pytorch_forward_forward. Github Repo January 2023.](https://github.com/mpezeshki/pytorch_forward_forward) \n", + "\n", + "To do so, we must define both a layer and a network class." + ], + "metadata": { + "id": "GB77EmhgfaN0" + }, + "id": "GB77EmhgfaN0" + }, + { + "cell_type": "markdown", + "source": [ + "### 3.1 Defining the Layer Class\n", + "- Define 'LeakyLayer' class is a custom linear layer with additional attributes related to leaky integrate and fire, an Adam optimizer, a threshold value, and the number of training epochs. The class is designed to be used as a layer in a neural network.\n", + "\n", + "- The 'forward' method defines the computations for a forward pass through the 'LeakyLayer'. It involves initializing the membrane potential, normalizing the input, computing the weighted input, passing it through a leaky integrate-and-fire neuron, and returning the resulting membrane potential\n", + "\n", + "- The 'train' method performs a training loop over a specified number of epochs. It computes the goodness for positive and negative data, calculates the loss based on these goodness values, locally backpropagates the gradients, and updates the parameters using the optimizer. The method returns the membrane potentials for positive and negative data after training. The goal is to encourage positive goodness to be above the threshold and negative goodness to be below the threshold." + ], + "metadata": { + "id": "4D_1BCXKkRbe" + }, + "id": "4D_1BCXKkRbe" + }, + { + "cell_type": "code", + "source": [ + "from tqdm import tqdm\n", + "from torch.optim import Adam\n", + "import torch.nn.functional as F\n", + "\n", + "# **CLASS DEFINITION**\n", + "class LeakyLayer(nn.Linear):\n", + "# defining a class named LeakyLayer that inherits from \"nn.Linear\"\n", + "# 'LeakyLayer' is a custom linear layer.\n", + "\n", + "# **CONSTRUCTOR**\n", + " def __init__(self, in_features, out_features, activation, bias=False):\n", + " # define the constructor method for the 'LeakyLayer' class.\n", + " super().__init__(in_features, out_features, bias=bias)\n", + " # calls the constructor of the parent class ('nn.Linear') to initialize the linear layer with specified input and output features.\n", + " if activation == \"lif\":\n", + " self.activation = snn.Leaky(beta=0.8)\n", + " self.lif = True\n", + " else:\n", + " self.activation = nn.ReLU()\n", + " self.lif = False\n", + " # decay rate = 0.8\n", + " self.opt = Adam(self.parameters(), lr=0.03)\n", + " # initializes an Adam optimizer for the parameters of the 'LeakyLayer' with a learning rate of 0.03\n", + " self.threshold = 5.0\n", + " # set the threshold value to 5.0\n", + " self.num_epochs = 1000\n", + " # specifies the number of epochs for training (1000 in this case).\n", + "\n", + "\n", + "\n", + "# **FORWARD METHOD**\n", + " def forward(self, x):\n", + " # define the forward method of the 'LeakyLayer' class.\n", + " # this method specifies the computation that occurs during the forward pass of the neural network.\n", + " if self.lif == True:\n", + " mem = self.activation.init_leaky()\n", + " # initialize the membrane potential\n", + "\n", + " # **NORMALIZE INPUT**\n", + " x_direction = x / (torch.norm(x, p=2, dim=1, keepdim=True) + 1e-4)\n", + " # computes the Euclidean norm along dimension 1 of the input tensor 'x'\n", + " # normalizes the input tensor x by dividing it by its L2 norm\n", + " # '1e-4' is added to the denominator to prevent division by zero\n", + "\n", + " # **COMPUTE WEIGHTED INPUT**\n", + " weighted_input = torch.mm(x_direction, self.weight.T.to(device))\n", + " # matrix multiplication between the normalized input 'x_direction' and the transpose (T) of the weight matrix (self.weight)\n", + " # The result is the weighted input to the neurons\n", + "\n", + " # **PASS THROUGH LIF NEURON**\n", + " if self.lif == True:\n", + " spk, potential = self.activation(weighted_input, mem)\n", + " else:\n", + " potential = self.activation(weighted_input)\n", + " # passes the weighted input and the current membrane potential through the leaky integrate-and-fire (LIF) neuron model\n", + " # returns spike value and updated membrane potential\n", + "\n", + " # **RETURN MEMBRANE POTENTIAL**\n", + " return potential\n", + " # forward method returns the updated membrane potential (potential)\n", + " # this membrame potential can be used in subsequent layers (or as the final output of the last layer)\n", + "\n", + "\n", + "\n", + "# **TRAIN METHOD**\n", + " def train(self, x_pos, x_neg):\n", + " # define the 'train' method of the 'LeakyLayer' class.\n", + " # this method is responsible for training the layer using positive ('x_pos') and negative ('x_neg') examples.\n", + "\n", + " # **TRAINING LOOP**\n", + " for _ in tqdm(range(self.num_epochs), desc=\"Training LeakyLayer\"):\n", + " # runs the loop for number of epochs = 1000\n", + "\n", + " # **COMPUTE GOODNESS**\n", + " g_pos = self.forward(x_pos).pow(2).mean(1)\n", + " g_neg = self.forward(x_neg).pow(2).mean(1)\n", + " # Computes the goodness (g_pos and g_neg) for the positive and negative data\n", + " # by performing the forward pass, squaring the results, and then computing the mean along dimension 1.\n", + "\n", + " # **COMPUTE LOSS**\n", + " loss = F.softplus(torch.cat([-g_pos + self.threshold, g_neg - self.threshold])).mean()\n", + " # Constructs a tensor by concatenating the positive and negative differences with a threshold\n", + " # Applies the softplus activation function: log(1 + exp(x))\n", + " # Computes the mean of the resulting tensor. This is the final scalar value representing the loss\n", + "\n", + " # **ZERO THE GRADIENTS**\n", + " self.opt.zero_grad()\n", + " # Zeros the gradients of the model parameters\n", + "\n", + " # **LOCAL BACKWARD PASS**\n", + " loss.backward()\n", + " # Computes the gradients of the loss with respect to the model parameters\n", + "\n", + " # **PARAMETERS UPDATE**\n", + " self.opt.step()\n", + " # Updates the model parameters using the optimizer (Adam optimizer in this case)\n", + "\n", + " # **RETURN ACTIVATIONS & DETACH**\n", + " return self.forward(x_pos).detach(), self.forward(x_neg).detach()\n", + " # returns the final membrane potentials (activations) for positive and negative examples after training.\n", + " # the '.detach()' method is used to detach the returned tensors from the computation graph,\n", + " # indicating that these are the final results and should not be used for further gradient computation during backpropagation" + ], + "metadata": { + "id": "EqjAjimIkZLu" + }, + "id": "EqjAjimIkZLu", + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "### 3.2 Defining the Network Class\n", + "\n", + "- The 'Net' class is defined as a neural network with a constructor that takes a list of dimensions. It initializes a ModuleList ('self.layers') containing instances of the 'LeakyLayer' class, which represents the layers of the neural network. The use of 'nn.Module' as a base class allows PyTorch to track the network's architecture and parameters.\n", + "\n", + "- The 'predict' method overlays label information onto the input, passes it through each layer of the neural network, computes goodness values at each layer, accumulates them for each label, and returns the predicted labels based on the maximum goodness.\n", + "\n", + "- The 'train' method iterates over the layers of the neural network, prints information about the current layer being trained, and updates the input tensors ('h_pos' and 'h_neg') by calling the 'train' method of each layer. This allows the layers to learn and adapt their parameters during the training process." + ], + "metadata": { + "id": "Shh0lapBkZxO" + }, + "id": "Shh0lapBkZxO" + }, + { + "cell_type": "code", + "source": [ + "# **CLASS DEFINITON**\n", + "class Net(nn.Module):\n", + " # define a new class named 'Net'.\n", + " # this will be a network and inherits from 'nn.Module'\n", + "\n", + " # **CONSTRUCTOR METHOD**\n", + " def __init__(self, dims, activation):\n", + " # defines the constructor method for the 'Net' class.\n", + " # this method is called when an instance of the class is created.\n", + " # 'self' is a reference to the instance of the class.\n", + " # 'dims' represents dimensions of the neura network layer.\n", + "\n", + " # **CALL TO PARENT CLASS CONSTRUCTOR**\n", + " super().__init__()\n", + " # calls the constructor of the parent class ('nn.Module')\n", + "\n", + " # **MODULE LIST FOR LAYERS**\n", + " self.layers = nn.ModuleList([\n", + " LeakyLayer(dims[d], dims[d + 1], activation) for d in range(len(dims) - 1)\n", + " ])\n", + " # creates instances of the 'LeakyLayer' class for each pair of consecutive dimensions in the 'dims' list.\n", + " # it iterates over the range of 'len(dims) - 1' to ensure that there are enough dimensions for input and output for each layer.\n", + "\n", + "\n", + " # **PREDICTION METHOD**\n", + " def predict(self, x):\n", + " # intended for making predictions using the neural network.\n", + " # parameter 'self' is a reference to the instance of the class.\n", + " # parameter 'x' is input data 'x' for which predictions are to be made.\n", + " goodness_per_label = []\n", + " # initializes an empty list to store the goodness values for each label.\n", + "\n", + " # **LOOP OVER LABELS**\n", + " for label in range(10):\n", + " # initiates a loop that iterates over each label from 0 to 9.\n", + "\n", + " # **OVERLAY FUNCTION**\n", + " h = overlay_y_on_x(x, label)\n", + " # Calls a function 'overlay_y_on_x' to overlay label information onto the input data 'x'.\n", + " # The resulting tensor is assigned to 'h'.\n", + " goodness = []\n", + "\n", + " # **INNER LOOP OVER LAYERS**\n", + " for layer in self.layers:\n", + " # initiates an inner loop over the layers (self.layers) of the neural network\n", + " h = layer(h)\n", + " # for each layer, applies the layer to the input tensor 'h'\n", + " goodness.append(h.pow(2).mean(1))\n", + " # computes the goodness for each layer by squaring the values, taking the mean along dimension 1, and appending it to the 'goodness' list.\n", + "\n", + " # **ACCUMULATION**\n", + " goodness_per_label.append(sum(goodness).unsqueeze(1))\n", + " # computes the sum of goodness values across all layers for a specific label.\n", + " # The resulting tensor is then unsqueezed along dimension 1 and appended to the 'goodness_per_label' list\n", + "\n", + " # **REASSIGN**\n", + " goodness_per_label = torch.cat(goodness_per_label, 1)\n", + " # concatenates the tensors in 'goodness_per_label' along dimension 1.\n", + " # the result is reassigned to 'goodness_per_label'.\n", + "\n", + " # **RETURN PREDICTIONS**\n", + " return goodness_per_label.argmax(1)\n", + " # returns the index of the maximum value along dimension 1 of the concatenated goodness tensor.\n", + " # this effectively returns the predicted label for each input.\n", + "\n", + "\n", + " # **TRAINING METHOD**\n", + " def train(self, x_pos, x_neg):\n", + " # defines a method named train within the class.\n", + " # this method is intended for training the neural network.\n", + " # parameter 'self' is a reference to the instance of the class.\n", + " # parameters 'x_pos' and 'x_neg' represent the positive and negative examples for training.\n", + "\n", + " # **INITIALIZATION**\n", + " h_pos, h_neg = x_pos, x_neg\n", + " # initializes two tensors, 'h_pos' and 'h_neg', with the values of the positive and negative examples ('x_pos' and 'x_neg'), respectively.\n", + "\n", + " # **LOOP OVER LAYERS**\n", + " for i, layer in enumerate(self.layers):\n", + " # initiates a loop that iterates over the layers (self.layers) of the neural network.\n", + " # 'i' is the index of the current layer.\n", + " print('Training layer', i, '...')\n", + " # prints information about the training progress.\n", + " # displays the current layer being trained.\n", + "\n", + " # **LAYER TRAINING**\n", + " h_pos, h_neg = layer.train(h_pos, h_neg)\n", + " # updates the values of h_pos and h_neg with the results obtained after training the current layer" + ], + "metadata": { + "id": "5qkfsA69aEcQ" + }, + "id": "5qkfsA69aEcQ", + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "## 4. Training the Network\n", + "\n", + "- The 'overlay_y_on_x' function takes an input tensor 'x' and a label 'y', creates a copy of 'x', zeros out the first 10 pixels, and replaces them with a one-hot-encoded representation of the label 'y'. The resulting tensor is then returned. This function is used for preparing input data for training in the neural network\n", + "\n", + "- The 'visualize_sample' function takes an input data tensor, selects a specific example at the given index, reshapes it into a 28x28 matrix, and then displays the reshaped image using Matplotlib. The 'name' parameter can be used to provide a title for the plot, and the 'idx' parameter determines which example from the data is visualized.\n", + "\n", + "- Sets a random seed, creates a neural network, loads and preprocesses data, generates positive and negative examples, visualizes samples, trains the neural network, and evaluates the training error. The 'Net' class is responsible for the neural network architecture and training logic, while helper functions like 'overlay_y_on_x' and 'visualize_sample' contribute to data manipulation and visualization.\n", + "- Your should obtain an error of about 14%." + ], + "metadata": { + "id": "lY2WozWrkwBp" + }, + "id": "lY2WozWrkwBp" + }, + { + "cell_type": "code", + "source": [ + "import matplotlib.pyplot as plt\n", + "# for creating plots and visualizations\n", + "\n", + "def overlay_y_on_x(x, y):\n", + "# defines a function named 'overlay_y_on_x'\n", + "# overlays a one-hot-encoded label 'y' on the input data 'x'\n", + " \"\"\"Replace the first 10 pixels of data [x] with one-hot-encoded label [y]\"\"\"\n", + " # **CLONE INPUT TENSOR**\n", + " x_ = x.clone()\n", + " # creates a copy ('x_') of the input tensor 'x' to avoid modifying the original tensor.\n", + "\n", + " # **ZERO OUT FIRST 10 PIXELS**\n", + " x_[:, :10] *= 0.0\n", + " # zeros out the first 10 pixels of each example in the input tensor 'x_'.\n", + " # this effectively removes the existing information in these pixels.\n", + "\n", + " # **ONE-HOT ENCODING**\n", + " x_[range(x.shape[0]), y] = x.max()\n", + " # generates a range of indices corresponding to the number of examples in the input tensor 'x'.\n", + " # selects the elements in 'x_' at positions specified by the label 'y' for each example.\n", + " # this performs a one-hot encoding, setting the value at the position of the label to the maximum value in the original input tensor 'x'.\n", + " # this step replaces the zeros in the first 10 pixels with the maximum value in the corresponding column of the original input tensor for the specified label.\n", + " return x_\n", + " # returns the modified tensor x_, where the first 10 pixels have been replaced with the one-hot-encoded label\n", + "\n", + "\n", + "# **FUNCTION DEFINITION**\n", + "def visualize_sample(data, name='', idx=0):\n", + " # defines a function named 'visualize_sample'.\n", + " # this function is designed to visualize a sample from the input data.\n", + "\n", + " # **RESHAPE AND MOVE TO CPU**\n", + " reshaped = data[idx].cpu().reshape(28, 28)\n", + " # selects the example at index 'idx' from the input data tensor data.\n", + " # moves the selected example to the CPU. This is relevant if the data is initially on a GPU.\n", + " # reshapes the example into a 28x28 matrix (as the data represents images with a shape of 28x28 pixels).\n", + " # the resulting matrix is assigned to the variable 'reshaped'.\n", + "\n", + " # **SET FIGURE SIZE**\n", + " plt.figure(figsize = (4, 4))\n", + " # initializes a new figure with a specified size of 4x4 inches.\n", + " # sets up the plotting environment for the image visualization.\n", + "\n", + " # **SET PLOT TITLE**\n", + " plt.title(name)\n", + " # sets the title of the plot to the value of the 'name' parameter.\n", + "\n", + " # **DISPLAY IMAGE**\n", + " plt.imshow(reshaped, cmap=\"gray\")\n", + " # displays the reshaped image using the 'imshow' function from Matplotlib.\n", + " # 'cmap=\"gray\"' argument specifies a grayscale color map for displaying the image\n", + "\n", + " # **SHOW PLOT**\n", + " plt.show()\n", + " # displays the plot with the visualized image.\n", + "\n", + "\n", + "# **SET RANDOM SEED**\n", + "torch.manual_seed(1234)\n", + " # sets the random seed for PyTorch operations (ensures reproducibility).\n", + "\n", + "# **CREATE NEURAL NETWORK**\n", + "net = Net([784, 500, 500],\"lif\")\n", + " # creates an instance of the 'Net' class with a neural network architecture defined by the list [784, 500, 500].\n", + " # this architecture has an input layer with 784 neurons, followed by two hidden layers with 500 neurons each.\n", + "\n", + "# **LOAD AND PRE-PROCESS DATA**\n", + "x, y = next(iter(train_loader))\n", + " # loads a batch of training data ('x' and corresponding labels 'y') using the 'train_loader'.\n", + "x, y = x.to(device), y.to(device)\n", + " # moves the data to the specified device.\n", + "\n", + "# **OVERLAY LABELS OVER DATA**\n", + "x_pos = overlay_y_on_x(x, y)\n", + " # generates positive examples ('x_pos') by overlaying one-hot-encoded labels on the input data.\n", + "rnd = torch.randperm(x.size(0))\n", + " # generates a random permutation of indices.\n", + "x_neg = overlay_y_on_x(x, y[rnd])\n", + " # generates negative examples ('x_neg') by overlaying one-hot-encoded labels on the input data using the randomly permuted labels.\n", + "for data, name in zip([x, x_pos, x_neg], ['orig', 'pos', 'neg']):\n", + " # **VISUALIZE SAMPLES**\n", + " visualize_sample(data, name)\n", + " # displays original ('x'), positive ('x_pos'), and negative ('x_neg') examples.\n", + "\n", + "# **TRAIN THE NEURAL NETWORK**\n", + "net.train(x_pos, x_neg)\n", + " # calls the 'train' method of the neural network ('net') with positive and negative examples for training.\n", + "\n", + "# **EVALUATE TRAINING ERROR**\n", + "print('train error:', 100*(1.0 - net.predict(x).eq(y).float().mean().item()),'%')\n", + " # performs predictions on the original data ('x') using the trained network, calculates the error rate, and prints it" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "ym6ZuGxRkyji", + "outputId": "c708d241-1fd4-4091-837f-ec19282b9873" + }, + "id": "ym6ZuGxRkyji", + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Training layer 0 ...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Training LeakyLayer: 100%|██████████| 1000/1000 [01:17<00:00, 12.95it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Training layer 1 ...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Training LeakyLayer: 100%|██████████| 1000/1000 [00:57<00:00, 17.36it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "train error: 14.010000228881836 %\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 5. Testing the Network\n", + "\n", + "- Load the test data, move it to the appropriate device, use the trained neural network to make predictions on the test set, calculate the error rate, and print the test error. The error rate is calculated as the fraction of incorrectly predicted examples in the test set.\n", + "- You should obtain an error of about 13.5%" + ], + "metadata": { + "id": "LTJonZ4elIXf" + }, + "id": "LTJonZ4elIXf" + }, + { + "cell_type": "code", + "source": [ + "# **LOAD AND PRE-PROCESS TEST DATA**\n", + "x_te, y_te = next(iter(test_loader))\n", + " # loads a batch of test data ('x_te' and corresponding labels 'y_te') using the 'test_loader'.\n", + "x_te, y_te = x_te.to(device), y_te.to(device)\n", + " # moves the test data to the specified device.\n", + "\n", + "# **EVALUATE TEST ERROR**\n", + "print('test error:', 100*(1.0 - net.predict(x_te).eq(y_te).float().mean().item()), '%')\n", + " # performs predictions on the test data ('x_te') using the trained network ('net'), calculates the error rate, and prints it." + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "74rCTBPRlK1u", + "outputId": "4620e93a-11cc-4ea0-a602-0df1a14c8697" + }, + "id": "74rCTBPRlK1u", + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "test error: 13.49000334739685 %\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## 6. Plotting the Loss of Each Layer\n", + "- The previous Layer and Network code is redefined here, slightly modified to allow for the tracking and plotting of each layer's loss over the given amount of epochs.\n", + "- This consumes a lot of GPU RAM, so the size of the model and number of epochs has been greatly reduced.\n", + "- The resulting model is quite inaccurate (~89% test error), but provides a good visualization of how each layer's loss decreases over time." + ], + "metadata": { + "id": "43Tf1Hpfkn7m" + }, + "id": "43Tf1Hpfkn7m" + }, + { + "cell_type": "code", + "source": [ + "from tqdm import tqdm\n", + "from torch.optim import Adam\n", + "import matplotlib.pyplot as plt\n", + "import torch.nn.functional as F\n", + "\n", + "def overlay_y_on_x(x, y):\n", + " x_ = x.clone()\n", + " x_[:, :10] *= 0.0\n", + " x_[range(x.shape[0]), y] = x.max()\n", + " return x_\n", + "\n", + "\n", + "class LeakyLayer(nn.Linear):\n", + " def __init__(self, in_features, out_features, bias=False):\n", + " super().__init__(in_features, out_features, bias=bias)\n", + " self.lif = snn.Leaky(beta=0.8)\n", + " self.opt = Adam(self.parameters(), lr=0.03)\n", + " self.threshold = 5.0\n", + " self.num_epochs = 100\n", + "\n", + " def forward(self, x):\n", + " mem = self.lif.init_leaky()\n", + " x_direction = x / (torch.norm(x, p=2, dim=1, keepdim=True) + 1e-4)\n", + " weighted_input = torch.mm(x_direction, self.weight.T.to(device))\n", + " spk, potential = self.lif(weighted_input, mem)\n", + " return potential\n", + "\n", + " def train(self, x_pos, x_neg):\n", + " tot_loss = []\n", + " for _ in tqdm(range(self.num_epochs), desc=\"Training LeakyLayer\"):\n", + " g_pos = self.forward(x_pos).pow(2).mean(1)\n", + " g_neg = self.forward(x_neg).pow(2).mean(1)\n", + " loss = F.softplus(torch.cat([-g_pos + self.threshold, g_neg - self.threshold])).mean()\n", + " self.opt.zero_grad()\n", + " loss.backward()\n", + " self.opt.step()\n", + " tot_loss.append(loss)\n", + " return self.forward(x_pos).detach(), self.forward(x_neg).detach(), tot_loss\n", + "\n", + "class Net(nn.Module):\n", + " def __init__(self, dims):\n", + " super().__init__()\n", + " self.layers = nn.ModuleList([\n", + " LeakyLayer(dims[d], dims[d + 1]) for d in range(len(dims) - 1)\n", + " ])\n", + "\n", + " def predict(self, x):\n", + " goodness_per_label = []\n", + " for label in range(10):\n", + " h = overlay_y_on_x(x, label)\n", + " goodness = []\n", + " for layer in self.layers:\n", + " h = layer(h)\n", + " goodness.append(h.pow(2).mean(1))\n", + " goodness_per_label.append(sum(goodness).unsqueeze(1))\n", + " goodness_per_label = torch.cat(goodness_per_label, 1)\n", + " return goodness_per_label.argmax(1)\n", + "\n", + " def train(self, x_pos, x_neg):\n", + " h_pos, h_neg = x_pos, x_neg\n", + " layer_losses = []\n", + " for i, layer in enumerate(self.layers):\n", + " print('Training layer', i, '...')\n", + " h_pos, h_neg, tot_loss = layer.train(h_pos, h_neg)\n", + " layer_losses.append(tot_loss)\n", + " return torch.Tensor(layer_losses)\n", + "\n", + "def visualize_sample(data, name='', idx=0):\n", + " reshaped = data[idx].cpu().reshape(28, 28)\n", + " plt.figure(figsize = (4, 4))\n", + " plt.title(name)\n", + " plt.imshow(reshaped, cmap=\"gray\")\n", + " plt.show()\n", + "\n", + "\n", + "torch.manual_seed(1234)\n", + "\n", + "net = Net([784, 50, 50])\n", + "x, y = next(iter(train_loader))\n", + "x, y = x.to(device), y.to(device)\n", + "x_pos = overlay_y_on_x(x, y)\n", + "rnd = torch.randperm(x.size(0))\n", + "x_neg = overlay_y_on_x(x, y[rnd])\n", + "\n", + "for data, name in zip([x, x_pos, x_neg], ['orig', 'pos', 'neg']):\n", + " visualize_sample(data, name)\n", + "\n", + "layer_losses = net.train(x_pos, x_neg)\n", + "\n", + "print('train error:', 1.0 - net.predict(x).eq(y).float().mean().item())\n", + "\n", + "x_te, y_te = next(iter(test_loader))\n", + "x_te, y_te = x_te.to(device), y_te.to(device)\n", + "\n", + "print('test error:', 1.0 - net.predict(x_te).eq(y_te).float().mean().item())" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "F_3gmsPbe5-9", + "outputId": "d0ef4339-3a64-4ef2-c998-5973dd66d520" + }, + "id": "F_3gmsPbe5-9", + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Training layer 0 ...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Training LeakyLayer: 100%|██████████| 100/100 [00:01<00:00, 71.58it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Training layer 1 ...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Training LeakyLayer: 100%|██████████| 100/100 [00:00<00:00, 203.41it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "train error: 0.8875799998641014\n", + "test error: 0.8872999995946884\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "plt.plot(layer_losses[0,:], label=\"Layer 1 Loss\")\n", + "plt.plot(layer_losses[1,:], label=\"Layer 2 Loss\")\n", + "plt.xlabel(\"Epoch\")\n", + "plt.ylabel(\"Loss\")\n", + "plt.legend()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "cN7wLeKGgXq3", + "outputId": "c8c447af-8c40-4dce-d502-e9fbc43ea0b3" + }, + "id": "cN7wLeKGgXq3", + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Train the Network using ReLU instead of LIF Activation\n", + "\n", + "* To compare, we can also train and test the same network architecture on the same data, except now using ReLU as the activation function instead of LIF.\n", + "* Running this cell provides a training error and a test error of approximately 10% each.\n", + "\n", + "\n" + ], + "metadata": { + "id": "E0ncALQA5T7N" + }, + "id": "E0ncALQA5T7N" + }, + { + "cell_type": "code", + "source": [ + "# **CREATE NEURAL NETWORK**\n", + "net = Net([784, 500, 500],\"relu\")\n", + " # creates an instance of the 'Net' class with a neural network architecture defined by the list [784, 500, 500].\n", + " # this architecture has an input layer with 784 neurons, followed by two hidden layers with 500 neurons each.\n", + "\n", + "# **LOAD AND PRE-PROCESS DATA**\n", + "x, y = next(iter(train_loader))\n", + " # loads a batch of training data ('x' and corresponding labels 'y') using the 'train_loader'.\n", + "x, y = x.to(device), y.to(device)\n", + " # moves the data to the specified device.\n", + "\n", + "# **OVERLAY LABELS OVER DATA**\n", + "x_pos = overlay_y_on_x(x, y)\n", + " # generates positive examples ('x_pos') by overlaying one-hot-encoded labels on the input data.\n", + "rnd = torch.randperm(x.size(0))\n", + " # generates a random permutation of indices.\n", + "x_neg = overlay_y_on_x(x, y[rnd])\n", + " # generates negative examples ('x_neg') by overlaying one-hot-encoded labels on the input data using the randomly permuted labels.\n", + "for data, name in zip([x, x_pos, x_neg], ['orig', 'pos', 'neg']):\n", + " # **VISUALIZE SAMPLES**\n", + " visualize_sample(data, name)\n", + " # displays original ('x'), positive ('x_pos'), and negative ('x_neg') examples.\n", + "\n", + "# **TRAIN THE NEURAL NETWORK**\n", + "net.train(x_pos, x_neg)\n", + " # calls the 'train' method of the neural network ('net') with positive and negative examples for training.\n", + "\n", + "# **EVALUATE TRAINING ERROR**\n", + "print('train error:', 100*(1.0 - net.predict(x).eq(y).float().mean().item()),'%')\n", + " # performs predictions on the original data ('x') using the trained network, calculates the error rate, and prints it\n", + "\n", + "# **LOAD AND PRE-PROCESS TEST DATA**\n", + "x_te, y_te = next(iter(test_loader))\n", + " # loads a batch of test data ('x_te' and corresponding labels 'y_te') using the 'test_loader'.\n", + "x_te, y_te = x_te.to(device), y_te.to(device)\n", + " # moves the test data to the specified device.\n", + "\n", + "# **EVALUATE TEST ERROR**\n", + "print('test error:', 100*(1.0 - net.predict(x_te).eq(y_te).float().mean().item()),'%')\n", + " # performs predictions on the test data ('x_te') using the trained network ('net'), calculates the error rate, and prints it." + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "Y40FBDxD5Pf5", + "outputId": "bc984b64-ad95-4474-d0de-cda05904950c" + }, + "id": "Y40FBDxD5Pf5", + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Training layer 0 ...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Training LeakyLayer: 100%|██████████| 1000/1000 [01:00<00:00, 16.45it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Training layer 1 ...\n" + ] + }, + { + "output_type": "stream", + "name": "stderr", + "text": [ + "Training LeakyLayer: 100%|██████████| 1000/1000 [00:40<00:00, 24.70it/s]\n" + ] + }, + { + "output_type": "stream", + "name": "stdout", + "text": [ + "train error: 10.252004861831665 %\n", + "test error: 10.019999742507935 %\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "# Comparison to ANNs and SNNs using Backpropagation\n", + "As shown in [this Keras example](https://www.tensorflow.org/datasets/keras_example), a standard artificial neural network using backpropagation with similar architecure and hyperparameters attains a test set error of about 2.50%.\n", + "\n", + "As shown in [the snnTorch Tutorial 5 documentation](https://snntorch.readthedocs.io/en/latest/tutorials/tutorial_5.html), a spiking neural network using backpropagation with the same architecture and similar set hyperparameters attains a test set error of about 6.13%." + ], + "metadata": { + "id": "Oa2jm154zvGH" + }, + "id": "Oa2jm154zvGH" + }, + { + "cell_type": "markdown", + "id": "-iSGTq0Q3Lcm", + "metadata": { + "id": "-iSGTq0Q3Lcm" + }, + "source": [ + "# Conclusion\n", + "- We have trained a spiking neural network and standard artificial neural network to classify the MNIST dataset using the Forward-Forward algorithm instead of backpropagation.\n", + "- Overall, the Forward-Forward algorithm appears to be a viable method for training neural networks, though it is less performant than using backpropagation.\n", + "- The spiking neural network using the Forward-Forward algorithm is less performant than the artifical neural network with ReLU using it. Both perform worse than a spiking neural network or artificial neural network using backpropagation.\n" + ] + }, + { + "cell_type": "markdown", + "source": [ + "# References\n", + "> [Geoffrey Hinton. The Forward-Forward Algorithm: Some Preliminary\n", + "Investigations. 2022. arXiv: 2212.13345 [cs.LG].](https://arxiv.org/abs/2212.13345) \n", + "\n", + "> [Mohammad Pezeshki. pytorch_forward_forward. Github Repo January 2023.](https://github.com/mpezeshki/pytorch_forward_forward) " + ], + "metadata": { + "id": "0aIXWPOHkiD1" + }, + "id": "0aIXWPOHkiD1" + }, + { + "cell_type": "markdown", + "source": [ + "# Group Work Statement\n", + "\n", + "We contributed approximately equally to the completion of the project.\n", + "\n", + "Ethan worked on implementing the code, algorithm theory section, and conclusion section for the Forward-Forward algorithm and its testing.\n", + "\n", + "Abhinandan worked on revising and documenting the code, as well as wrote the text for all of the other sections.\n", + "\n", + "We both revised the code and text to make them clear and concise." + ], + "metadata": { + "id": "NQGromWnkSHk" + }, + "id": "NQGromWnkSHk" + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "_HxW09hNgBO-" + }, + "id": "_HxW09hNgBO-", + "execution_count": null, + "outputs": [] + } + ], + "metadata": { + "accelerator": "GPU", + "colab": { + "provenance": [], + "gpuType": "T4", + "toc_visible": true + }, + "kernelspec": { + "display_name": "Python 3", + "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.9.13" + }, + "vscode": { + "interpreter": { + "hash": "c8b87b4648a8d1ba1118329c37c7c28a2ff48490805f0e62ea19d4b1b49e5656" + } + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file From 8966137664c4374f3367faf6ae4e13e08b1a2014 Mon Sep 17 00:00:00 2001 From: Ethan M Date: Wed, 13 Dec 2023 17:34:54 -0800 Subject: [PATCH 2/2] Revise notebook documentation --- examples/tutorial_forward_forward.ipynb | 652 ++++++++++++------------ 1 file changed, 317 insertions(+), 335 deletions(-) diff --git a/examples/tutorial_forward_forward.ipynb b/examples/tutorial_forward_forward.ipynb index eca75eb1..ae9fd60a 100644 --- a/examples/tutorial_forward_forward.ipynb +++ b/examples/tutorial_forward_forward.ipynb @@ -32,29 +32,29 @@ }, { "cell_type": "markdown", - "source": [ - "- Run the below two cells to install snnTorch and then import PyTorch and snnTorch for use." - ], + "id": "ELOnnEYi4YY8", "metadata": { "id": "ELOnnEYi4YY8" }, - "id": "ELOnnEYi4YY8" + "source": [ + "- Run the below two cells to install snnTorch and then import PyTorch and snnTorch for use." + ] }, { "cell_type": "code", "execution_count": null, "id": "hDnIEHOKB8LD", "metadata": { - "id": "hDnIEHOKB8LD", "colab": { "base_uri": "https://localhost:8080/" }, + "id": "hDnIEHOKB8LD", "outputId": "8914c89f-07eb-4c55-fa26-023f6fbd6ac2" }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\u001b[?25l \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m0.0/109.0 kB\u001b[0m \u001b[31m?\u001b[0m eta \u001b[36m-:--:--\u001b[0m\r\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m109.0/109.0 kB\u001b[0m \u001b[31m3.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", "\u001b[?25h" @@ -109,45 +109,45 @@ "execution_count": null, "id": "3GdglZjK04cb", "metadata": { - "id": "3GdglZjK04cb", "colab": { "base_uri": "https://localhost:8080/" }, + "id": "3GdglZjK04cb", "outputId": "bdc684d2-4feb-458a-c2f2-2525121756d3" }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz\n" ] }, { - "output_type": "stream", "name": "stderr", + "output_type": "stream", "text": [ "100%|██████████| 9912422/9912422 [00:00<00:00, 154424511.55it/s]" ] }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw\n" ] }, { - "output_type": "stream", "name": "stderr", + "output_type": "stream", "text": [ "\n" ] }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "\n", "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", @@ -155,15 +155,15 @@ ] }, { - "output_type": "stream", "name": "stderr", + "output_type": "stream", "text": [ "100%|██████████| 28881/28881 [00:00<00:00, 38201101.81it/s]\n" ] }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw\n", "\n", @@ -172,15 +172,15 @@ ] }, { - "output_type": "stream", "name": "stderr", + "output_type": "stream", "text": [ "100%|██████████| 1648877/1648877 [00:00<00:00, 48104859.92it/s]\n" ] }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw\n", "\n", @@ -189,15 +189,15 @@ ] }, { - "output_type": "stream", "name": "stderr", + "output_type": "stream", "text": [ "100%|██████████| 4542/4542 [00:00<00:00, 24613086.26it/s]\n" ] }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n", "\n", @@ -242,47 +242,51 @@ }, { "cell_type": "markdown", + "id": "XOT9ESAC5d1G", + "metadata": { + "id": "XOT9ESAC5d1G" + }, "source": [ "## 2. Forward-Forward Algorithm Theory\n", "The Forward-Forward algorithm is a learning procedure inspired by Boltzmann machines and Noise Contrastive Estimation. The algorithm is illustrated in the figure below. It works by replacing the forward and backward passes of backpropagation with two forward passes - the positive pass and the negative pass. These passes operate in exactly the same way as each other, however, the positive pass works on real data to adjust the weights to increase the goodness in each layer, while the negative pass works on \"bad\" generated data to adjust the weights to decrease the goodness in each layer. As such, each layer has its own objective function that is locally updated in contrast to backpropagation which has a global objective function that is optimized.\n", "\n", "![](https://drive.google.com/uc?export=view&id=1cYmOJ1goT4-Yb0ftucAwYYhYTfmesXZ6)" - ], - "metadata": { - "id": "XOT9ESAC5d1G" - }, - "id": "XOT9ESAC5d1G" + ] }, { "cell_type": "markdown", + "id": "B1B_tzLsihYM", + "metadata": { + "id": "B1B_tzLsihYM" + }, "source": [ "Goodness can be measured through a metric such as the sum of the squared neural activities. The aim of learning the the Forward-Forward algorithm is then to make the goodness be well above some threshold value for real data and well below that value for negative data. In practice, the aim is to correctly classify input vectors as positive data or negative data when the probability that an input vector is real is given by applying the logistic function, $\\sigma$ to the goodness minus some threshold, $\\theta$\n", "\\begin{equation}\n", " p(positive) = \\sigma \\left(\\sum_j y_j^2 - \\theta \\right)\n", "\\end{equation}\n", "where $y_j$ is the activity of hidden unit $j$ before layer normalization." - ], - "metadata": { - "id": "B1B_tzLsihYM" - }, - "id": "B1B_tzLsihYM" + ] }, { "cell_type": "markdown", + "id": "GB77EmhgfaN0", + "metadata": { + "id": "GB77EmhgfaN0" + }, "source": [ "## 3. Implementation\n", "We follow and modify the Forward-Forward algorithm implementation found here:\n", "> [Mohammad Pezeshki. pytorch_forward_forward. Github Repo January 2023.](https://github.com/mpezeshki/pytorch_forward_forward) \n", "\n", "To do so, we must define both a layer and a network class." - ], - "metadata": { - "id": "GB77EmhgfaN0" - }, - "id": "GB77EmhgfaN0" + ] }, { "cell_type": "markdown", + "id": "4D_1BCXKkRbe", + "metadata": { + "id": "4D_1BCXKkRbe" + }, "source": [ "### 3.1 Defining the Layer Class\n", "- Define 'LeakyLayer' class is a custom linear layer with additional attributes related to leaky integrate and fire, an Adam optimizer, a threshold value, and the number of training epochs. The class is designed to be used as a layer in a neural network.\n", @@ -290,14 +294,16 @@ "- The 'forward' method defines the computations for a forward pass through the 'LeakyLayer'. It involves initializing the membrane potential, normalizing the input, computing the weighted input, passing it through a leaky integrate-and-fire neuron, and returning the resulting membrane potential\n", "\n", "- The 'train' method performs a training loop over a specified number of epochs. It computes the goodness for positive and negative data, calculates the loss based on these goodness values, locally backpropagates the gradients, and updates the parameters using the optimizer. The method returns the membrane potentials for positive and negative data after training. The goal is to encourage positive goodness to be above the threshold and negative goodness to be below the threshold." - ], - "metadata": { - "id": "4D_1BCXKkRbe" - }, - "id": "4D_1BCXKkRbe" + ] }, { "cell_type": "code", + "execution_count": null, + "id": "EqjAjimIkZLu", + "metadata": { + "id": "EqjAjimIkZLu" + }, + "outputs": [], "source": [ "from tqdm import tqdm\n", "from torch.optim import Adam\n", @@ -401,16 +407,14 @@ " # returns the final membrane potentials (activations) for positive and negative examples after training.\n", " # the '.detach()' method is used to detach the returned tensors from the computation graph,\n", " # indicating that these are the final results and should not be used for further gradient computation during backpropagation" - ], - "metadata": { - "id": "EqjAjimIkZLu" - }, - "id": "EqjAjimIkZLu", - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "markdown", + "id": "Shh0lapBkZxO", + "metadata": { + "id": "Shh0lapBkZxO" + }, "source": [ "### 3.2 Defining the Network Class\n", "\n", @@ -419,14 +423,16 @@ "- The 'predict' method overlays label information onto the input, passes it through each layer of the neural network, computes goodness values at each layer, accumulates them for each label, and returns the predicted labels based on the maximum goodness.\n", "\n", "- The 'train' method iterates over the layers of the neural network, prints information about the current layer being trained, and updates the input tensors ('h_pos' and 'h_neg') by calling the 'train' method of each layer. This allows the layers to learn and adapt their parameters during the training process." - ], - "metadata": { - "id": "Shh0lapBkZxO" - }, - "id": "Shh0lapBkZxO" + ] }, { "cell_type": "code", + "execution_count": null, + "id": "5qkfsA69aEcQ", + "metadata": { + "id": "5qkfsA69aEcQ" + }, + "outputs": [], "source": [ "# **CLASS DEFINITON**\n", "class Net(nn.Module):\n", @@ -516,16 +522,14 @@ " # **LAYER TRAINING**\n", " h_pos, h_neg = layer.train(h_pos, h_neg)\n", " # updates the values of h_pos and h_neg with the results obtained after training the current layer" - ], - "metadata": { - "id": "5qkfsA69aEcQ" - }, - "id": "5qkfsA69aEcQ", - "execution_count": null, - "outputs": [] + ] }, { "cell_type": "markdown", + "id": "lY2WozWrkwBp", + "metadata": { + "id": "lY2WozWrkwBp" + }, "source": [ "## 4. Training the Network\n", "\n", @@ -535,14 +539,87 @@ "\n", "- Sets a random seed, creates a neural network, loads and preprocesses data, generates positive and negative examples, visualizes samples, trains the neural network, and evaluates the training error. The 'Net' class is responsible for the neural network architecture and training logic, while helper functions like 'overlay_y_on_x' and 'visualize_sample' contribute to data manipulation and visualization.\n", "- Your should obtain an error of about 14%." - ], - "metadata": { - "id": "lY2WozWrkwBp" - }, - "id": "lY2WozWrkwBp" + ] }, { "cell_type": "code", + "execution_count": null, + "id": "ym6ZuGxRkyji", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 1000 + }, + "id": "ym6ZuGxRkyji", + "outputId": "c708d241-1fd4-4091-837f-ec19282b9873" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training layer 0 ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training LeakyLayer: 100%|██████████| 1000/1000 [01:17<00:00, 12.95it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training layer 1 ...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training LeakyLayer: 100%|██████████| 1000/1000 [00:57<00:00, 17.36it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train error: 14.010000228881836 %\n" + ] + } + ], "source": [ "import matplotlib.pyplot as plt\n", "# for creating plots and visualizations\n", @@ -635,145 +712,146 @@ "# **EVALUATE TRAINING ERROR**\n", "print('train error:', 100*(1.0 - net.predict(x).eq(y).float().mean().item()),'%')\n", " # performs predictions on the original data ('x') using the trained network, calculates the error rate, and prints it" + ] + }, + { + "cell_type": "markdown", + "id": "LTJonZ4elIXf", + "metadata": { + "id": "LTJonZ4elIXf" + }, + "source": [ + "## 5. Testing the Network\n", + "\n", + "- Load the test data, move it to the appropriate device, use the trained neural network to make predictions on the test set, calculate the error rate, and print the test error. The error rate is calculated as the fraction of incorrectly predicted examples in the test set.\n", + "- You should obtain an error of about 13.5%" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "74rCTBPRlK1u", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "74rCTBPRlK1u", + "outputId": "4620e93a-11cc-4ea0-a602-0df1a14c8697" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "test error: 13.49000334739685 %\n" + ] + } ], + "source": [ + "# **LOAD AND PRE-PROCESS TEST DATA**\n", + "x_te, y_te = next(iter(test_loader))\n", + " # loads a batch of test data ('x_te' and corresponding labels 'y_te') using the 'test_loader'.\n", + "x_te, y_te = x_te.to(device), y_te.to(device)\n", + " # moves the test data to the specified device.\n", + "\n", + "# **EVALUATE TEST ERROR**\n", + "print('test error:', 100*(1.0 - net.predict(x_te).eq(y_te).float().mean().item()), '%')\n", + " # performs predictions on the test data ('x_te') using the trained network ('net'), calculates the error rate, and prints it." + ] + }, + { + "cell_type": "markdown", + "id": "43Tf1Hpfkn7m", + "metadata": { + "id": "43Tf1Hpfkn7m" + }, + "source": [ + "## 6. Plotting the Loss of Each Layer\n", + "- The previous Layer and Network code is redefined here, slightly modified to allow for the tracking and plotting of each layer's loss over the given amount of epochs.\n", + "- This consumes a lot of GPU RAM, so the size of the model and number of epochs has been greatly reduced.\n", + "- The resulting model is quite inaccurate (~89% test error), but provides a good visualization of how each layer's loss decreases over time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "F_3gmsPbe5-9", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, - "id": "ym6ZuGxRkyji", - "outputId": "c708d241-1fd4-4091-837f-ec19282b9873" + "id": "F_3gmsPbe5-9", + "outputId": "d0ef4339-3a64-4ef2-c998-5973dd66d520" }, - "id": "ym6ZuGxRkyji", - "execution_count": null, "outputs": [ { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWMAAAF2CAYAAAC72fnJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAc3klEQVR4nO3de3BU5f3H8U8CZEFNNoaQy0oCISh05OKIEDMgYMlAYqvcHK9/QFUYNbEiWG2sAql20qEdy+ig9ibgVKRFuVRqmXJLqG2CDUopKhmSiRIlCZeSDQkmRPL8/nDcnwspORt32Seb92vmmck555uz3zOHfDyePZcoY4wRACCsosPdAACAMAYAKxDGAGABwhgALEAYA4AFCGMAsABhDAAWIIwBwAKEMQBYgDAGAAsQxgBgAcIYACxAGAOABQhjRITly5crKipKhw4d0h133KG4uDgNHDhQjz76qFpbW311X375pZ599lllZmbK5XJp6NCheuqpp9TW1ua3voqKCs2YMUOJiYkaMGCAMjIydN99913qzUIv0jfcDQDBdMcdd2jo0KEqLi5WeXm5XnjhBZ06dUqvvfaaJOmBBx7Q2rVrdfvtt2vJkiXau3eviouL9fHHH2vTpk2SpGPHjmn69OkaNGiQfvzjHys+Pl6ffPKJNm7cGM5NQ6QzQARYtmyZkWRuu+02v/kPP/ywkWT+/e9/m/379xtJ5oEHHvCrefzxx40ks2vXLmOMMZs2bTKSzL/+9a9L1j/AaQpElPz8fL/pRx55RJL0zjvv6J133pEkLV682K9myZIlkqS//OUvkqT4+HhJ0tatW9Xe3h7KdgEfwhgR5eqrr/abzszMVHR0tD755BN9+umnio6O1vDhw/1qUlJSFB8fr08//VSSNGXKFM2dO1dFRUVKTEzUzJkztXr16gvOKwPBRBgjokVFRTmad/7yN998U2VlZSooKNDnn3+u++67T+PGjVNzc3OoWkUvRxgjohw+fNhvuqqqSh0dHRo6dKiGDBmijo6OC2oaGhrU2NioIUOG+M2/8cYb9bOf/UwVFRV6/fXX9eGHH2r9+vUh3wb0ToQxIsqqVav8pl988UVJUl5enm655RZJ0sqVK/1qnn/+eUnS9773PUnSqVOnZM57T+91110nSZyqQMhwaRsiSk1NjW677Tbl5uaqrKxMf/jDH3TPPfdo7NixkqR58+bpN7/5jRobGzVlyhS99957Wrt2rWbNmqWbb75ZkrR27Vq99NJLmj17tjIzM3X69Gn99re/VVxcnC/QgaAL9+UcQDB8fWnbRx99ZG6//XYTGxtrrrzySlNQUGC++OILX117e7spKioyGRkZpl+/fiYtLc0UFhaa1tZWX837779v7r77bpOenm5cLpdJSkoy3//+901FRUU4Ng29RJQx5/3/GNADLV++XEVFRTp+/LgSExPD3Q4QMM4ZA4AFCGMAsABhDAAW4JwxAFiAI2MAsABhDAAWsO6mj46ODh09elSxsbFdPkMAAGxmjNHp06fl8XgUHX3xY1/rwvjo0aNKS0sLdxsAEDS1tbUaPHjwRWtCdppi1apVGjp0qPr376+srCy99957jn4vNjY2VC2hG7xer+MBoHOOci0Ut/WtX7/exMTEmFdffdV8+OGHZsGCBSY+Pt40NDR0+bter9dIYlgyAhHuXhkMW4fX6+367yegvzaHJkyYYPLz833T586dMx6PxxQXF3f5u4SxXSMQ4e6VwbB1OAnjoJ+mOHv2rPbt26ecnBzfvOjoaOXk5KisrCzYHwcAESHoX+CdOHFC586dU3Jyst/85ORkHTp06IL6trY2v2fENjU1BbslALBe2K8zLi4ultvt9g2upADQGwU9jBMTE9WnTx81NDT4zW9oaFBKSsoF9YWFhX7fyNfW1ga7JQCwXtDDOCYmRuPGjdPOnTt98zo6OrRz505lZ2dfUO9yuRQXF+c3AKC3CclNH4sXL9a8efN0ww03aMKECVq5cqVaWlr0gx/8IBQfBwA9XkjC+M4779Tx48e1dOlS1dfX67rrrtO2bdsu+FIPAPAV6x6h2dTUJLfbHe42ACBovF5vl6dgw341BQCAMAYAKxDGAGABwhgALEAYA4AFCGMAsABhDAAWIIwBwAKEMQBYgDAGAAsQxgBgAcIYACxAGAOABQhjALAAYQwAFiCMAcAChDEAWIAwBgALEMYAYAHCGAAsQBgDgAUIYwCwAGEMABYgjAHAAoQxAFiAMAYACxDGAGABwhgALEAYA4AFCGMAsABhDAAWIIwBwAKEMQBYgDAGAAsQxgBgAcIYACxAGAOABQhjALAAYQwAFiCMAcAChDEAWIAwBgALEMYAYAHCGAAsEPQwXr58uaKiovzGyJEjg/0xABBR+oZipddee6127Njx/x/SNyQfAwARIyQp2bdvX6WkpIRi1QAQkUJyzvjw4cPyeDwaNmyY7r33Xh05ciQUHwMAESPKGGOCucK//vWvam5u1ogRI1RXV6eioiJ9/vnnOnjwoGJjYy+ob2trU1tbm2+6qalJaWlpwWwJAMLK6/UqLi7u4kUmxE6dOmXi4uLM7373u06XL1u2zEhiMBiMiB1er7fLrAz5pW3x8fG65pprVFVV1enywsJCeb1e36itrQ11SwBgnZCHcXNzs6qrq5WamtrpcpfLpbi4OL8BAL1N0MP48ccfV2lpqT755BP985//1OzZs9WnTx/dfffdwf4oAIgYQb+07bPPPtPdd9+tkydPatCgQZo0aZLKy8s1aNCgYH8UAESMoF9N8W01NTXJ7XaHuw0ACBonV1PwbAoAsABhDAAWIIwBwAKEMQBYgDAGAAsQxgBgAcIYACxAGAOABQhjALAAYQwAFiCMAcAChDEAWIAwBgALEMYAYAHCGAAsQBgDgAUIYwCwAGEMABYgjAHAAoQxAFiAMAYAC/QNdwOIHPHx8Y5rJ02a5Lh26dKljmvHjx/vuPbNN990XFtdXe24NlTeffddx7U7duxwXNva2tqddhBkHBkDgAUIYwCwAGEMABYgjAHAAoQxAFiAMAYACxDGAGABwhgALEAYA4AFCGMAsECUMcaEu4lvampqktvtDncbEW3UqFGOa3/4wx86rr3rrrsc115++eWOaxG4bdu2Oa4N5Nbp6Gjnx2+vvvqq49pTp045ru2JvF6v4uLiLlrDkTEAWIAwBgALEMYAYAHCGAAsQBgDgAUIYwCwAGEMABYgjAHAAoQxAFiAMAYAC3A7dISYPHmy49rnnnvOce3EiRO7006vduLECce1gbyZOZBbkT0ej+PaQBw/ftxx7bFjxxzXbtiwwXFtcXGx49ovv/zScW0oheR26D179ujWW2+Vx+NRVFSUNm/e7LfcGKOlS5cqNTVVAwYMUE5Ojg4fPhzoxwBArxJwGLe0tGjs2LFatWpVp8tXrFihF154Qa+88or27t2ryy+/XDNmzAjoCAAAepu+gf5CXl6e8vLyOl1mjNHKlSv19NNPa+bMmZKk1157TcnJydq8eXNAT/UCgN4kqF/g1dTUqL6+Xjk5Ob55brdbWVlZKisrC+ZHAUBECfjI+GLq6+slScnJyX7zk5OTfcvO19bWpra2Nt90U1NTMFsCgB4h7Je2FRcXy+12+0ZaWlq4WwKASy6oYZySkiJJamho8Jvf0NDgW3a+wsJCeb1e36itrQ1mSwDQIwQ1jDMyMpSSkqKdO3f65jU1NWnv3r3Kzs7u9HdcLpfi4uL8BgD0NgGfM25ublZVVZVvuqamRvv371dCQoLS09O1aNEiPffcc7r66quVkZGhZ555Rh6PR7NmzQpm3wAQUQIO44qKCt18882+6cWLF0uS5s2bpzVr1uiJJ55QS0uLFi5cqMbGRk2aNEnbtm1T//79g9c1AEQYboe22KRJkxzXvvXWW45rExMTu9NOl44cOeK49uOPP3Zcu3v3bse1FRUVjmtDpa6uznHtmTNnHNcGcjt0RkaG49pA3H777SHp4aabbnJcm56e7rjWlrdO83ZoAOghCGMAsABhDAAWIIwBwAKEMQBYgDAGAAsQxgBgAcIYACxAGAOABQhjALAAt0NfYoFs2zcfyNSVhISE7rTTpW3btjmuXbJkiePaQ4cOdaedXu3FF190XHvy5EnHtcuXL+9GN8E1cuRIx7WB/F1E9NuhAQDBRxgDgAUIYwCwAGEMABYgjAHAAoQxAFiAMAYACxDGAGABwhgALEAYA4AF+oa7gd6mT58+jmtDdYtzaWmp49rZs2c7rj179mx32gmb66+/3nFtIG86/slPfuK4duDAgY5rBw8e7Lj23Llzjmvff/99x7V//vOfHdcGgtvjOTIGACsQxgBgAcIYACxAGAOABQhjALAAYQwAFiCMAcAChDEAWIAwBgALEMYAYAHeDn2JBXKL8/Hjx0PSQyC3yra1tYWkBxv069fPcW0gt7FHR/esY5yKigrHtVlZWSHsJHLxdmgA6CEIYwCwAGEMABYgjAHAAoQxAFiAMAYACxDGAGABwhgALEAYA4AFCGMAsABvh77Ezpw547j2b3/7m+PaKVOmOK51uVyOay+77DLHtfjKiRMnHNcGcmt6cnJyd9rp0p49e0KyXgQm4CPjPXv26NZbb5XH41FUVJQ2b97st3z+/PmKioryG7m5ucHqFwAiUsBh3NLSorFjx2rVqlX/syY3N1d1dXW+8cYbb3yrJgEg0gV8miIvL095eXkXrXG5XEpJSel2UwDQ24TkC7ySkhIlJSVpxIgReuihh3Ty5MlQfAwARIygf4GXm5urOXPmKCMjQ9XV1XrqqaeUl5ensrKyTp8J29bW5vfM3KampmC3BADWC3oY33XXXb6fR48erTFjxigzM1MlJSWaNm3aBfXFxcUqKioKdhsA0KOE/DrjYcOGKTExUVVVVZ0uLywslNfr9Y3a2tpQtwQA1gn5dcafffaZTp48qdTU1E6Xu1yugK57BYBIFHAYNzc3+x3l1tTUaP/+/UpISFBCQoKKioo0d+5cpaSkqLq6Wk888YSGDx+uGTNmBLVxAIgkAYdxRUWFbr75Zt/04sWLJUnz5s3Tyy+/rAMHDmjt2rVqbGyUx+PR9OnT9eyzz3L0CwAXwduhI8TUqVMd1z7xxBOOa9PS0hzXJiYmOq4NRCC3Fwdi48aNjmurq6sd127ZssVxbd++zo+Hjh49GpL13nvvvY5r169f77gW/4+3QwNAD0EYA4AFCGMAsABhDAAWIIwBwAKEMQBYgDAGAAsQxgBgAcIYACxAGAOABXg7dIQoKSkJSW0ghg8fHpL1/q/Hr0aCX/7yl45rA7nFOZBbyP/+9787rkXocGQMABYgjAHAAoQxAFiAMAYACxDGAGABwhgALEAYA4AFCGMAsABhDAAWIIwBwALcDo2gieTblkMlkDczB+I///mP49rPP/88JD0gMBwZA4AFCGMAsABhDAAWIIwBwAKEMQBYgDAGAAsQxgBgAcIYACxAGAOABQhjALAAt0MDQRbIW7L79+8fkh7eeuutkKwXocORMQBYgDAGAAsQxgBgAcIYACxAGAOABQhjALAAYQwAFiCMAcAChDEAWIAwBgALcDs0EGQTJ050XBsXF+e4tr293XHtgQMHHNfCDgEdGRcXF2v8+PGKjY1VUlKSZs2apcrKSr+a1tZW5efna+DAgbriiis0d+5cNTQ0BLVpAIg0AYVxaWmp8vPzVV5eru3bt6u9vV3Tp09XS0uLr+axxx7T22+/rQ0bNqi0tFRHjx7VnDlzgt44AESSgE5TbNu2zW96zZo1SkpK0r59+zR58mR5vV79/ve/17p16/Td735XkrR69Wp95zvfUXl5uW688cbgdQ4AEeRbfYHn9XolSQkJCZKkffv2qb29XTk5Ob6akSNHKj09XWVlZd/mowAgonX7C7yOjg4tWrRIEydO1KhRoyRJ9fX1iomJUXx8vF9tcnKy6uvrO11PW1ub2trafNNNTU3dbQkAeqxuHxnn5+fr4MGDWr9+/bdqoLi4WG632zfS0tK+1foAoCfqVhgXFBRo69at2r17twYPHuybn5KSorNnz6qxsdGvvqGhQSkpKZ2uq7CwUF6v1zdqa2u70xIA9GgBhbExRgUFBdq0aZN27dqljIwMv+Xjxo1Tv379tHPnTt+8yspKHTlyRNnZ2Z2u0+VyKS4uzm8AQG8T0Dnj/Px8rVu3Tlu2bFFsbKzvPLDb7daAAQPkdrt1//33a/HixUpISFBcXJweeeQRZWdncyUFAFxEQGH88ssvS5KmTp3qN3/16tWaP3++JOlXv/qVoqOjNXfuXLW1tWnGjBl66aWXgtIsAESqKGOMCXcT39TU1CS32x3uNoBuW7BggePaV155xXFtc3Oz41r+huzi9Xq7PAXLg4IAwAKEMQBYgDAGAAsQxgBgAcIYACxAGAOABQhjALAAYQwAFiCMAcAChDEAWIC3QwNBtmjRopCsd/v27SFZL+zAkTEAWIAwBgALEMYAYAHCGAAsQBgDgAUIYwCwAGEMABYgjAHAAoQxAFiAMAYAC3A7NODAuHHjHNd6PJ6Q9LB///6QrBd24MgYACxAGAOABQhjALAAYQwAFiCMAcAChDEAWIAwBgALEMYAYAHCGAAsQBgDgAW4HRpw4KqrrnJcGxcXF8JOEKk4MgYACxDGAGABwhgALEAYA4AFCGMAsABhDAAWIIwBwAKEMQBYgDAGAAsQxgBgAcIYACwQUBgXFxdr/Pjxio2NVVJSkmbNmqXKykq/mqlTpyoqKspvPPjgg0FtGgAiTUBhXFpaqvz8fJWXl2v79u1qb2/X9OnT1dLS4le3YMEC1dXV+caKFSuC2jQARJqAntq2bds2v+k1a9YoKSlJ+/bt0+TJk33zL7vsMqWkpASnQwDoBb7VOWOv1ytJSkhI8Jv/+uuvKzExUaNGjVJhYaHOnDnzbT4GACJet59n3NHRoUWLFmnixIkaNWqUb/4999yjIUOGyOPx6MCBA3ryySdVWVmpjRs3drqetrY2tbW1+aabmpq62xIA9FjdDuP8/HwdPHhQ7777rt/8hQsX+n4ePXq0UlNTNW3aNFVXVyszM/OC9RQXF6uoqKi7bQBAROjWaYqCggJt3bpVu3fv1uDBgy9am5WVJUmqqqrqdHlhYaG8Xq9v1NbWdqclAOjRAjoyNsbokUce0aZNm1RSUqKMjIwuf2f//v2SpNTU1E6Xu1wuuVyuQNoAgIgTUBjn5+dr3bp12rJli2JjY1VfXy9JcrvdGjBggKqrq7Vu3TrdcsstGjhwoA4cOKDHHntMkydP1pgxY0KyAQAQCQIK45dfflnSVzd2fNPq1as1f/58xcTEaMeOHVq5cqVaWlqUlpamuXPn6umnnw5awwAQiQI+TXExaWlpKi0t/VYNAejcr3/963C3gBDi2RQAYAHCGAAsQBgDgAUIYwCwAGEMABYgjAHAAoQxAFiAMAYACxDGAGABwhgALNDt5xkDvcn5rxy7mMOHDzuu/fptOU7897//dVyLnocjYwCwAGEMABYgjAHAAoQxAFiAMAYACxDGAGABwhgALEAYA4AFCGMAsIB1d+B19dJTIBwC+XfZ3Nwcklr+NnouJ/vOujA+ffp0uFsALtDe3u649oYbbghhJ+iJTp8+LbfbfdGaKGPZf247Ojp09OhRxcbGKioqyje/qalJaWlpqq2tVVxcXBg7DD62rWdi23qmS7ltxhidPn1aHo9H0dEXPyts3ZFxdHS0Bg8e/D+Xx8XFRdw/jq+xbT0T29YzXapt6+qI+Gt8gQcAFiCMAcACPSaMXS6Xli1bJpfLFe5Wgo5t65nYtp7J1m2z7gs8AOiNesyRMQBEMsIYACxAGAOABQhjALBAjwjjVatWaejQoerfv7+ysrL03nvvhbuloFi+fLmioqL8xsiRI8PdVrfs2bNHt956qzwej6KiorR582a/5cYYLV26VKmpqRowYIBycnICeotyOHW1bfPnz79gP+bm5oan2QAUFxdr/Pjxio2NVVJSkmbNmqXKykq/mtbWVuXn52vgwIG64oorNHfuXDU0NISpY+ecbNvUqVMv2G8PPvhgmDruAWH8xz/+UYsXL9ayZcv0/vvva+zYsZoxY4aOHTsW7taC4tprr1VdXZ1vvPvuu+FuqVtaWlo0duxYrVq1qtPlK1as0AsvvKBXXnlFe/fu1eWXX64ZM2aotbX1EncauK62TZJyc3P99uMbb7xxCTvsntLSUuXn56u8vFzbt29Xe3u7pk+frpaWFl/NY489prffflsbNmxQaWmpjh49qjlz5oSxa2ecbJskLViwwG+/rVixIkwdSzKWmzBhgsnPz/dNnzt3zng8HlNcXBzGroJj2bJlZuzYseFuI+gkmU2bNvmmOzo6TEpKivnFL37hm9fY2GhcLpd54403wtBh952/bcYYM2/ePDNz5syw9BNMx44dM5JMaWmpMearfdSvXz+zYcMGX83HH39sJJmysrJwtdkt52+bMcZMmTLFPProo+Fr6jxWHxmfPXtW+/btU05Ojm9edHS0cnJyVFZWFsbOgufw4cPyeDwaNmyY7r33Xh05ciTcLQVdTU2N6uvr/faj2+1WVlZWxOzHkpISJSUlacSIEXrooYd08uTJcLcUMK/XK0lKSEiQJO3bt0/t7e1++23kyJFKT0/vcfvt/G372uuvv67ExESNGjVKhYWFOnPmTDjak2Thg4K+6cSJEzp37pySk5P95icnJ+vQoUNh6ip4srKytGbNGo0YMUJ1dXUqKirSTTfdpIMHDyo2Njbc7QVNfX29JHW6H79e1pPl5uZqzpw5ysjIUHV1tZ566inl5eWprKxMffr0CXd7jnR0dGjRokWaOHGiRo0aJemr/RYTE6P4+Hi/2p623zrbNkm65557NGTIEHk8Hh04cEBPPvmkKisrtXHjxrD0aXUYR7q8vDzfz2PGjFFWVpaGDBmiP/3pT7r//vvD2BkCcdddd/l+Hj16tMaMGaPMzEyVlJRo2rRpYezMufz8fB08eLDHfmdxMf9r2xYuXOj7efTo0UpNTdW0adNUXV2tzMzMS92m3V/gJSYmqk+fPhd8e9vQ0KCUlJQwdRU68fHxuuaaa1RVVRXuVoLq633VW/bjsGHDlJiY2GP2Y0FBgbZu3ardu3f7Pb42JSVFZ8+eVWNjo199T9pv/2vbOpOVlSVJYdtvVodxTEyMxo0bp507d/rmdXR0aOfOncrOzg5jZ6HR3Nys6upqpaamhruVoMrIyFBKSorffmxqatLevXsjcj9+9tlnOnnypPX70RijgoICbdq0Sbt27VJGRobf8nHjxqlfv35++62yslJHjhyxfr91tW2d2b9/vySFb7+F+xvErqxfv964XC6zZs0a89FHH5mFCxea+Ph4U19fH+7WvrUlS5aYkpISU1NTY/7xj3+YnJwck5iYaI4dOxbu1gJ2+vRp88EHH5gPPvjASDLPP/+8+eCDD8ynn35qjDHm5z//uYmPjzdbtmwxBw4cMDNnzjQZGRnmiy++CHPnXbvYtp0+fdo8/vjjpqyszNTU1JgdO3aY66+/3lx99dWmtbU13K1f1EMPPWTcbrcpKSkxdXV1vnHmzBlfzYMPPmjS09PNrl27TEVFhcnOzjbZ2dlh7NqZrratqqrK/PSnPzUVFRWmpqbGbNmyxQwbNsxMnjw5bD1bH8bGGPPiiy+a9PR0ExMTYyZMmGDKy8vD3VJQ3HnnnSY1NdXExMSYq666ytx5552mqqoq3G11y+7du42kC8a8efOMMV9d3vbMM8+Y5ORk43K5zLRp00xlZWV4m3boYtt25swZM336dDNo0CDTr18/M2TIELNgwYIecbDQ2TZJMqtXr/bVfPHFF+bhhx82V155pbnsssvM7NmzTV1dXfiadqirbTty5IiZPHmySUhIMC6XywwfPtz86Ec/Ml6vN2w98whNALCA1eeMAaC3IIwBwAKEMQBYgDAGAAsQxgBgAcIYACxAGAOABQhjALAAYQwAFiCMAcAChDEAWIAwBgAL/B9HG1CMkQW9pgAAAABJRU5ErkJggg==\n" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Training layer 0 ...\n" ] }, { - "output_type": "stream", "name": "stderr", + "output_type": "stream", "text": [ - "Training LeakyLayer: 100%|██████████| 1000/1000 [01:17<00:00, 12.95it/s]\n" + "Training LeakyLayer: 100%|██████████| 100/100 [00:01<00:00, 71.58it/s]\n" ] }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Training layer 1 ...\n" ] }, { - "output_type": "stream", "name": "stderr", + "output_type": "stream", "text": [ - "Training LeakyLayer: 100%|██████████| 1000/1000 [00:57<00:00, 17.36it/s]\n" + "Training LeakyLayer: 100%|██████████| 100/100 [00:00<00:00, 203.41it/s]\n" ] }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "train error: 14.010000228881836 %\n" - ] - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "## 5. Testing the Network\n", - "\n", - "- Load the test data, move it to the appropriate device, use the trained neural network to make predictions on the test set, calculate the error rate, and print the test error. The error rate is calculated as the fraction of incorrectly predicted examples in the test set.\n", - "- You should obtain an error of about 13.5%" - ], - "metadata": { - "id": "LTJonZ4elIXf" - }, - "id": "LTJonZ4elIXf" - }, - { - "cell_type": "code", - "source": [ - "# **LOAD AND PRE-PROCESS TEST DATA**\n", - "x_te, y_te = next(iter(test_loader))\n", - " # loads a batch of test data ('x_te' and corresponding labels 'y_te') using the 'test_loader'.\n", - "x_te, y_te = x_te.to(device), y_te.to(device)\n", - " # moves the test data to the specified device.\n", - "\n", - "# **EVALUATE TEST ERROR**\n", - "print('test error:', 100*(1.0 - net.predict(x_te).eq(y_te).float().mean().item()), '%')\n", - " # performs predictions on the test data ('x_te') using the trained network ('net'), calculates the error rate, and prints it." - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "74rCTBPRlK1u", - "outputId": "4620e93a-11cc-4ea0-a602-0df1a14c8697" - }, - "id": "74rCTBPRlK1u", - "execution_count": null, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "test error: 13.49000334739685 %\n" + "train error: 0.8875799998641014\n", + "test error: 0.8872999995946884\n" ] } - ] - }, - { - "cell_type": "markdown", - "source": [ - "## 6. Plotting the Loss of Each Layer\n", - "- The previous Layer and Network code is redefined here, slightly modified to allow for the tracking and plotting of each layer's loss over the given amount of epochs.\n", - "- This consumes a lot of GPU RAM, so the size of the model and number of epochs has been greatly reduced.\n", - "- The resulting model is quite inaccurate (~89% test error), but provides a good visualization of how each layer's loss decreases over time." ], - "metadata": { - "id": "43Tf1Hpfkn7m" - }, - "id": "43Tf1Hpfkn7m" - }, - { - "cell_type": "code", "source": [ "from tqdm import tqdm\n", "from torch.optim import Adam\n", @@ -870,136 +948,136 @@ "x_te, y_te = x_te.to(device), y_te.to(device)\n", "\n", "print('test error:', 1.0 - net.predict(x_te).eq(y_te).float().mean().item())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cN7wLeKGgXq3", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 449 + }, + "id": "cN7wLeKGgXq3", + "outputId": "c8c447af-8c40-4dce-d502-e9fbc43ea0b3" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } ], + "source": [ + "plt.plot(layer_losses[0,:], label=\"Layer 1 Loss\")\n", + "plt.plot(layer_losses[1,:], label=\"Layer 2 Loss\")\n", + "plt.xlabel(\"Epoch\")\n", + "plt.ylabel(\"Loss\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "E0ncALQA5T7N", + "metadata": { + "id": "E0ncALQA5T7N" + }, + "source": [ + "# Train the Network using ReLU instead of LIF Activation\n", + "\n", + "* To compare, we can also train and test the same network architecture on the same data, except now using ReLU as the activation function instead of LIF.\n", + "* Running this cell provides a training error and a test error of approximately 10% each.\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "Y40FBDxD5Pf5", "metadata": { "colab": { "base_uri": "https://localhost:8080/", "height": 1000 }, - "id": "F_3gmsPbe5-9", - "outputId": "d0ef4339-3a64-4ef2-c998-5973dd66d520" + "id": "Y40FBDxD5Pf5", + "outputId": "bc984b64-ad95-4474-d0de-cda05904950c" }, - "id": "F_3gmsPbe5-9", - "execution_count": null, "outputs": [ { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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\n" + ] }, - "metadata": {} + "metadata": {}, + "output_type": "display_data" }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Training layer 0 ...\n" ] }, { - "output_type": "stream", "name": "stderr", + "output_type": "stream", "text": [ - "Training LeakyLayer: 100%|██████████| 100/100 [00:01<00:00, 71.58it/s]\n" + "Training LeakyLayer: 100%|██████████| 1000/1000 [01:00<00:00, 16.45it/s]\n" ] }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "Training layer 1 ...\n" ] }, { - "output_type": "stream", "name": "stderr", + "output_type": "stream", "text": [ - "Training LeakyLayer: 100%|██████████| 100/100 [00:00<00:00, 203.41it/s]\n" + "Training LeakyLayer: 100%|██████████| 1000/1000 [00:40<00:00, 24.70it/s]\n" ] }, { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "train error: 0.8875799998641014\n", - "test error: 0.8872999995946884\n" + "train error: 10.252004861831665 %\n", + "test error: 10.019999742507935 %\n" ] } - ] - }, - { - "cell_type": "code", - "source": [ - "plt.plot(layer_losses[0,:], label=\"Layer 1 Loss\")\n", - "plt.plot(layer_losses[1,:], label=\"Layer 2 Loss\")\n", - "plt.xlabel(\"Epoch\")\n", - "plt.ylabel(\"Loss\")\n", - "plt.legend()\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 449 - }, - "id": "cN7wLeKGgXq3", - "outputId": "c8c447af-8c40-4dce-d502-e9fbc43ea0b3" - }, - "id": "cN7wLeKGgXq3", - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABuj0lEQVR4nO3dd3zU9eHH8dfdZYfskAVhIyBLBEFALf5AhqPg1qKglVoVWpEqlTqqdeAuahGcoHUgLupAFFBAFBBQBGTIToCEnb3vvr8/vrlLjux5ueT9fDzucXff+47PfUm9dz/TYhiGgYiIiEgLYvV0AUREREQamwKQiIiItDgKQCIiItLiKACJiIhIi6MAJCIiIi2OApCIiIi0OApAIiIi0uL4eLoATZHD4eDw4cOEhIRgsVg8XRwRERGpBsMwyMzMJCEhAau18joeBaByHD58mMTERE8XQ0RERGohOTmZtm3bVrqPAlA5QkJCAPMGhoaGerg0IiIiUh0ZGRkkJia6fscrowBUDmezV2hoqAKQiIiIl6lO9xV1ghYREZEWRwFIREREWhwFIBEREWlx1AdIRESaJLvdTmFhoaeLIU2Ir68vNputXs6lACQiIk2KYRikpqaSlpbm6aJIExQeHk5cXFyd5+lTABIRkSbFGX5iYmIICgrShLQCmME4JyeHo0ePAhAfH1+n8ykAiYhIk2G3213hJyoqytPFkSYmMDAQgKNHjxITE1On5jB1ghYRkSbD2ecnKCjIwyWRpsr5t1HX/mEKQCIi0uSo2UsqUl9/GwpAIiIi0uIoAImIiEiLowAkIiIiLY5HA9DMmTM555xzCAkJISYmhnHjxrFz585Kj5k/fz4Wi8XtERAQ4LaPYRg8+OCDxMfHExgYyIgRI9i1a1dDfpVqW787hcw8TewlItLc3HTTTYwbN87TxaiWlJQU/vCHP3DGGWdgtVqZOnVqlcfs378fi8XCpk2bGrx8jcGjAWjlypVMnjyZtWvXsnTpUgoLCxk5ciTZ2dmVHhcaGkpKSorrceDAAbfPn3rqKV544QXmzp3LunXrCA4OZtSoUeTl5TXk16nSvIUfEffW+XzxyTseLYeIiLQMBQUF5W7Pz8+ndevW3H///fTt27eRS9U0eDQALVmyhJtuuomePXvSt29f5s+fT1JSEhs3bqz0OIvFQlxcnOsRGxvr+swwDGbNmsX999/P2LFj6dOnD2+99RaHDx9m0aJF5Z4vPz+fjIwMt0dDGJG/jETrMUbtuJ9D+yqv6RIREZNhGOQUFHnkYRhGvX2P5557jt69exMcHExiYiJ33HEHWVlZAGRnZxMaGsqHH37odsyiRYsIDg4mMzMTgOTkZK655hrCw8OJjIxk7Nix7N+/37W/sxbqscceIyEhgW7dupVblg4dOvD8888zYcIEwsLC6uX75efn89e//pWYmBgCAgI477zzWL9+vevzU6dOMX78eFq3bk1gYCBdu3Zl3rx5gBnUpkyZQnx8PAEBAbRv356ZM2fWS7kq0qQmQkxPTwcgMjKy0v2ysrJo3749DoeDs88+m8cff5yePXsCsG/fPlJTUxkxYoRr/7CwMAYNGsSaNWu47rrrypxv5syZPPzww/X4TcrX9rrn2PvUejoV7iJ9wY1wz3fg49/g1xUR8Wa5hXbOfPArj1x7279GEeRXPz+VVquVF154gY4dO7J3717uuOMOpk+fzksvvURwcDDXXXcd8+bN46qrrnId43wfEhJCYWEho0aNYvDgwXz33Xf4+Pjw6KOPMnr0aDZv3oyfnx8Ay5cvJzQ0lKVLl9ZLuatr+vTpfPTRR7z55pu0b9+ep556ilGjRrF7924iIyN54IEH2LZtG19++SXR0dHs3r2b3NxcAF544QU+/fRTFi5cSLt27UhOTiY5OblBy9tkApDD4WDq1KkMHTqUXr16Vbhft27deOONN+jTpw/p6ek888wzDBkyhF9//ZW2bduSmpoK4FYr5Hzv/Ox0M2bMYNq0aa73GRkZJCYm1sO3cmfxDcS4+k1OvTOSDvk7ObJwKrF/mFPv1xERkaandD+bDh068Oijj3Lbbbfx0ksvATBp0iSGDBlCSkoK8fHxHD16lMWLF7Ns2TIA3n//fRwOB6+99pprLpx58+YRHh7OihUrGDlyJADBwcG89tprrkDUGLKzs5kzZw7z589nzJgxALz66qssXbqU119/nXvuuYekpCT69evHgAEDXPfAKSkpia5du3LeeedhsVho3759g5e5yQSgyZMns3XrVlavXl3pfoMHD2bw4MGu90OGDKFHjx68/PLLPPLII7W6tr+/P/7+jVMT0/mMnszr9BAT995D7G/v4vj5fKz9/tAo1xYR8UaBvja2/WuUx65dX5YtW8bMmTPZsWMHGRkZFBUVkZeXR05ODkFBQQwcOJCePXvy5ptvcu+99/L222/Tvn17LrjgAgB++eUXdu/eTUhIiNt58/Ly2LNnj+t97969GzX8AOzZs4fCwkKGDh3q2ubr68vAgQPZvn07ALfffjtXXnklP/30EyNHjmTcuHEMGTIEMJvuLrroIrp168bo0aO59NJLXYGuoTSJYfBTpkzh888/59tvv6Vt27Y1OtbX15d+/fqxe/duAOLi4gA4cuSI235HjhxxfeZpl105gTmYVZyOz+6C1K0eLpGISNNlsVgI8vPxyKO+Zh3ev38/l156KX369OGjjz5i48aNzJ49G3DvqDxp0iTmz58PmLU7N998s6sMWVlZ9O/fn02bNrk9fvvtN/7wh5L/Ix0cHFwvZa5vY8aM4cCBA9x1110cPnyY4cOHc/fddwNw9tlns2/fPh555BFyc3O55ppr3JoCG4JHA5BhGEyZMoVPPvmEb775ho4dO9b4HHa7nS1btrhWhe3YsSNxcXEsX77ctU9GRgbr1q1zqznypOhW/vhc+HdW2Pvi48jDseAGKMjxdLFERKSBbNy4EYfDwbPPPsu5557LGWecweHDh8vsd8MNN3DgwAFeeOEFtm3bxsSJE12fnX322ezatYuYmBi6dOni9qivjsy11blzZ/z8/Pj+++9d2woLC1m/fj1nnnmma1vr1q2ZOHEib7/9NrNmzeKVV15xfRYaGsq1117Lq6++yvvvv89HH33EyZMnG6zMHm0Cmzx5Mu+++y7/+9//CAkJcfXRCQsLc634OmHCBNq0aePqDf6vf/2Lc889ly5dupCWlsbTTz/NgQMHmDRpEmD+P4WpU6fy6KOP0rVrVzp27MgDDzxAQkJCk5qf4abzOnHlur/RLWcq8Wn74NePod8Nni6WiIjUQXp6epl5cqKioujSpQuFhYW8+OKLXHbZZXz//ffMnTu3zPERERFcccUV3HPPPYwcOdKtVWT8+PE8/fTTjB07ln/961+0bduWAwcO8PHHHzN9+vQat6A4y5mVlcWxY8fYtGkTfn5+boGlPOXN19ezZ09uv/127rnnHiIjI2nXrh1PPfUUOTk53HLLLQA8+OCD9O/fn549e5Kfn8/nn39Ojx49AHOEXHx8PP369cNqtfLBBx8QFxdHeHh4jb5TjRgeBJT7mDdvnmuf3/3ud8bEiRNd76dOnWq0a9fO8PPzM2JjY42LL77Y+Omnn9zO63A4jAceeMCIjY01/P39jeHDhxs7d+6sdrnS09MNwEhPT6/rV6zUl1sOGzP/cath/DPUKJgzrEGvJSLiDXJzc41t27YZubm5ni5KjU2cOLHc37RbbrnFMAzDeO6554z4+HgjMDDQGDVqlPHWW28ZgHHq1Cm38yxfvtwAjIULF5a5RkpKijFhwgQjOjra8Pf3Nzp16mT86U9/cv1eTZw40Rg7dmy1ylteWdu3b1/h/vv27avwdzs5OdnIzc01/vKXv7jKNnToUOPHH390Hf/II48YPXr0MAIDA43IyEhj7Nixxt69ew3DMIxXXnnFOOuss4zg4GAjNDTUGD58eJnfdqfK/kZq8vttKb4JUkpGRgZhYWGkp6cTGhraYNcxDINrn/uMtzNuws9ihz+vgviWOSGViAiYHXr37dtHx44dy8zy31L897//dfWTaezOzN6gsr+Rmvx+N4lO0C2VxWKh5xmd+cpxjrlhwzzPFkhERDwmJyeHPXv28MQTT/DnP/9Z4aeBKQB52KCOUbxjL560ccsHkJ/p2QKJiIhHPPXUU3Tv3p24uDhmzJjh6eI0ewpAHjawYyRrHT3Y44iHgizYvNDTRRIREQ946KGHKCwsZPny5bRq1crTxWn2FIA8LDLYjzNiQ0pqgTbMA3XLEhERaVAKQE3AoI5RfGQ/nyKLHxzZAocqXwxWRERE6kYBqAkY1CmSdFqxwvc8c8OGNzxbIBERkWZOAagJGNgxEoCXssz1Xtj6MeSe8mCJREREmjcFoCYgJiSATtHB/OToSmZYNyjKhV/e93SxREREmi0FoCZiUKdIwMLqsEvNDVs/9Gh5REREmjMFoCZiUMcoAD7M7GVuOPST5gQSEfEiN910U5Nac7IyH3/8MRdddBGtW7cmNDSUwYMH89VXX1V6zIoVK7BYLKSlpTVOIRuYAlATYdYAwbep/jjCO4JhhwNrPFwqERHxZgUFBeVuX7VqFRdddBGLFy9m48aNXHjhhVx22WX8/PPPjVxCz1EAaiLiwwJpFxmEw4DUqIHmxn0rPVsoERGpN8899xy9e/cmODiYxMRE7rjjDrKysgDIzs4mNDSUDz907/6waNEigoODycw0WwSSk5O55pprCA8PJzIykrFjx7J//37X/s5aqMcee4yEhAS6detWbllmzZrF9OnTOeecc+jatSuPP/44Xbt25bPPPqv19zt16hQTJkwgIiKCoKAgxowZw65du1yfHzhwgMsuu4yIiAiCg4Pp2bMnixcvdh07fvx4WrduTWBgIF27dmXevIZdHkoBqAlxjgZbbyluBlMAEhExJ4ctyPbMox4nprVarbzwwgv8+uuvvPnmm3zzzTdMnz4dgODgYK677royP/rz5s3jqquuIiQkhMLCQkaNGkVISAjfffcd33//Pa1atWL06NFuNT3Lly9n586dLF26lM8//7xaZXM4HGRmZhIZGVnr73fTTTexYcMGPv30U9asWYNhGFx88cUUFhYCMHnyZPLz81m1ahVbtmzhySefdM14/cADD7Bt2za+/PJLtm/fzpw5c4iOjq51WarDp0HPLjUyqGMkH248yCdpnRgLkLoFck5CUO3/IEVEvF5hDjye4Jlr/+Mw+AXXy6mmTp3qet2hQwceffRRbrvtNl566SUAJk2axJAhQ0hJSSE+Pp6jR4+yePFili1bBsD777+Pw+Hgtddew2KxAGZACg8PZ8WKFYwcORIww9Rrr71Wo8VUn3nmGbKysrjmmmtq9d127drFp59+yvfff8+QIUMAeOedd0hMTGTRokVcffXVJCUlceWVV9K7d28AOnXq5Do+KSmJfv36MWDAANf9aWiqAWpCzu1kdoRefdiKI7q7uXH/dx4skYiI1Jdly5YxfPhw2rRpQ0hICDfeeCMnTpwgJycHgIEDB9KzZ0/efPNNAN5++23at2/PBReYc8T98ssv7N69m5CQEFq1akWrVq2IjIwkLy+PPXv2uK7Tu3fvGoWfd999l4cffpiFCxcSExNTq++2fft2fHx8GDRokGtbVFQU3bp1Y/v27QD89a9/5dFHH2Xo0KH885//ZPPmza59b7/9dhYsWMBZZ53F9OnT+eGHH2pVjppQDVAT0jYikISwAA6n55EaNZCE4ztg3yo4c6yniyYi4jm+QWZNjKeuXQ/279/PpZdeyu23385jjz1GZGQkq1ev5pZbbqGgoICgIPM6kyZNYvbs2dx7773MmzePm2++2VXbk5WVRf/+/XnnnXfKnL9169au18HB1a+xWrBgAZMmTeKDDz5gxIgRdfyWlZs0aRKjRo3iiy++4Ouvv2bmzJk8++yz/OUvf2HMmDEcOHCAxYsXs3TpUoYPH87kyZN55plnGqw8qgFqQiwWC4OKa4HW4+wHtMqDJRIRaQIsFrMZyhOP4vBRVxs3bsThcPDss89y7rnncsYZZ3D4cNlQd8MNN3DgwAFeeOEFtm3bxsSJE12fnX322ezatYuYmBi6dOni9ggLC6txmd577z1uvvlm3nvvPS655JI6fb8ePXpQVFTEunXrXNtOnDjBzp07OfPMM13bEhMTue222/j444/529/+xquvvur6rHXr1kycOJG3336bWbNm8corr9SpTFVRDVATc06HSD75+RBfZHZmLBY4/htkpEBovKeLJiIiVUhPT2fTpk1u26KioujSpQuFhYW8+OKLXHbZZXz//ffMnTu3zPERERFcccUV3HPPPYwcOZK2bdu6Phs/fjxPP/00Y8eO5V//+hdt27blwIEDfPzxx0yfPt1t36q8++67TJw4keeff55BgwaRmpoKQGBgYJVhasuWLYSEhLjeWywW+vbty9ixY/nTn/7Eyy+/TEhICPfeey9t2rRh7FizFWPq1KmMGTOGM844g1OnTvHtt9/So0cPAB588EH69+9Pz549yc/P5/PPP3d91lBUA9TEdIkxe8RvO2WF+L7mRvUDEhHxCitWrKBfv35uj4cffpi+ffvy3HPP8eSTT9KrVy/eeecdZs6cWe45nM1if/zjH922BwUFsWrVKtq1a8cVV1xBjx49uOWWW8jLyyM0NLRG5XzllVcoKipi8uTJxMfHux533nlnlcdecMEFbt+vf//+gNkhu3///lx66aUMHjwYwzBYvHgxvr6+ANjtdiZPnkyPHj0YPXo0Z5xxhqsDuJ+fHzNmzKBPnz5ccMEF2Gw2FixYUKPvVFMWw6jHMX7NREZGBmFhYaSnp9f4j6qujmbkMfDx5VgtsGvYGmxrXoR+N8DY2Y1aDhERT8jLy2Pfvn107NiRgIAATxfHI/773/9y1113cfjw4Rp1Zm4pKvsbqcnvt2qAmpjWIf4E+tpwGHAs+lxzo/oBiYg0ezk5OezZs4cnnniCP//5zwo/DUwBqImxWCy0izRHA+zy7wlWH0hLglP7PVswERFpUE899RTdu3cnLi6OGTNmeLo4zZ4CUBPULsoMQPsyLdDGnBRKtUAiIs3bQw89RGFhIcuXL3fNkCwNRwGoCWpfXAN04EQOdDQnwFIAEhERqT8KQE1Q+6gKApD6q4tIC6HxOVKR+vrbUABqgtpFmbN4Jp3MhrbngE8AZB0x5wQSEWnGnEOmnctDiJzO+bfh/FupLU2E2AQ5m8CSTuZg+PhjadMfDnwPhzZC624eLp2ISMOx2WyEh4dz9OhRwJz7xlJPszGLdzMMg5ycHI4ePUp4eDg2m61O51MAaoLaRARis1rIK3RwNDOf2Lg+ZgBK3eLpoomINLi4uDgAVwgSKS08PNz1N1IXCkBNkK/NSkJ4AMknczlwIofYuN7mBwpAItICWCwW4uPjiYmJobCw0NPFkSbE19e3zjU/TgpATVT7yGCST+ay/0Q2A9s4A9BmsyO0qoNFpAWw2Wz19mMncjp1gm6inHMBJZ3IgdbdweoLeemQnuzhkomIiHg/BaAmyjUX0Mkc8PEzQxCoGUxERKQeKAA1Ue1dNUDZ5gZXP6CtHiqRiIhI86EA1ES1izTnAjpwsngujLhS/YBERESkThSAmihnH6C0nELScwshrpf5gZrARERE6syjAWjmzJmcc845hISEEBMTw7hx49i5c2elx7z66qucf/75REREEBERwYgRI/jxxx/d9rnpppuwWCxuj9GjRzfkV6l3rfx9iG7lBxR3hI4tDkBpByA3zXMFExERaQY8GoBWrlzJ5MmTWbt2LUuXLqWwsJCRI0eSnZ1d4TErVqzg+uuv59tvv2XNmjUkJiYycuRIDh065Lbf6NGjSUlJcT3ee++9hv469a6dqyN0NgRFQlii+cGRXz1YKhEREe/n0XmAlixZ4vZ+/vz5xMTEsHHjRi644IJyj3nnnXfc3r/22mt89NFHLF++nAkTJri2+/v718tMkZ7UPiqYn5LSzEVRwewHlJ5sNoN1GOrZwomIiHixJtUHKD09HYDIyMhqH5OTk0NhYWGZY1asWEFMTAzdunXj9ttv58SJExWeIz8/n4yMDLdHU+CsAUo6cXpHaPUDEhERqYsmE4AcDgdTp05l6NCh9OrVq9rH/f3vfychIYERI0a4to0ePZq33nqL5cuX8+STT7Jy5UrGjBmD3W4v9xwzZ84kLCzM9UhMTKzz96kPzqHwB06ePhReI8FERETqoskshTF58mS2bt3K6tWrq33ME088wYIFC1ixYgUBAQGu7dddd53rde/evenTpw+dO3dmxYoVDB8+vMx5ZsyYwbRp01zvMzIymkQIah9VQQ3QsR1gLwSbr4dKJiIi4t2aRA3QlClT+Pzzz/n2229p27ZttY555plneOKJJ/j666/p06dPpft26tSJ6Ohodu/eXe7n/v7+hIaGuj2aAudcQCkZeeQX2SG8PfiHgr0Ajv/m4dKJiIh4L48GIMMwmDJlCp988gnffPMNHTt2rNZxTz31FI888ghLlixhwIABVe5/8OBBTpw4QXx8fF2L3KiiW/kR5GfDMCD5ZK65CKr6AYmIiNSZRwPQ5MmTefvtt3n33XcJCQkhNTWV1NRUcnNzXftMmDCBGTNmuN4/+eSTPPDAA7zxxht06NDBdUxWVhYAWVlZ3HPPPaxdu5b9+/ezfPlyxo4dS5cuXRg1alSjf8e6sFgstI8ya4GSnP2AYjUhooiISF15NADNmTOH9PR0hg0bRnx8vOvx/vvvu/ZJSkoiJSXF7ZiCggKuuuoqt2OeeeYZAGw2G5s3b+b3v/89Z5xxBrfccgv9+/fnu+++w9/fv9G/Y125FkUtMxJMHaFFRERqy6OdoA3DqHKfFStWuL3fv39/pfsHBgby1Vdf1aFUTYtrJFh5Q+ENw2wWExERkRppEp2gpWLONcGSnIuitu4OVh/IPQUZhyo5UkRERCqiANTEtXeuCn+iuA+QbwBEdzNfp271UKlERES8mwJQE+dsAks+lYvDUdxkqJFgIiIidaIA1MTFhwXgY7VQUOQgNSPP3KiO0CIiInWiANTE+distI0IBEp3hC4eCq9V4UVERGpFAcgLxIeZAehoZnENUFRX8zntgLkkhoiIiNSIApAXaB1izl90LDPf3BASDz6B4CiCtCQPlkxERMQ7KQB5AVcAyioOQFYrRHYyX5/Y46FSiYiIeC8FIC8Q3eq0GiCAqM7m80kFIBERkZpSAPICZZrAoCQAnSh/hXsRERGpmAKQFyg3AEU6A5BqgERERGpKAcgLtC5uAjueVboGqIv5rCYwERGRGlMA8gLOGqAT2QUU2R3mRmcTWFoyFOVXcKSIiIiURwHIC0QG+2G1mIu/n8wuMDcGtwa/EMCAk/s8Wj4RERFvowDkBWxWC1HFzWBHnf2ALBaNBBMREaklBSAv4ewHdCyrvJFgCkAiIiI1oQDkJSofCaah8CIiIjWhAOQlnAHoeHk1QCf3eqBEIiIi3ksByEuUPxli8VB4NYGJiIjUiAKQl2hd3nIYzvXAMg9DQbYHSiUiIuKdFIC8RLk1QEGREBhhvlYzmIiISLUpAHmJMivCO6kZTEREpMYUgLxEuSvCg0aCiYiI1IICkJdw1gBl5hWRV2gv+UAjwURERGpMAchLhAb44Odj/nOV2xFaTWAiIiLVpgDkJSwWSwWzQWtVeBERkZpSAPIi5c8FVNwEln0M8tI9UCoRERHvowDkRcoNQP4hEBxjvlYzmIiISLUoAHmRcgMQlGoGU0doERGR6lAA8iLOPkDHy8wF5OwIraHwIiIi1aEA5EUqrAFyzQWkJjAREZHqUADyIhXPBu2cC0gBSEREpDoUgLxIlX2ATuwGw2jkUomIiHgfBSAvUnpFeKN00InoaD7npUPOSQ+UTERExLsoAHkRZw1QfpGDzPyikg/8giC0jflazWAiIiJV8mgAmjlzJueccw4hISHExMQwbtw4du7cWeVxH3zwAd27dycgIIDevXuzePFit88Nw+DBBx8kPj6ewMBARowYwa5duxrqazSaAF8bIQE+QHnNYOoILSIiUl0eDUArV65k8uTJrF27lqVLl1JYWMjIkSPJzs6u8JgffviB66+/nltuuYWff/6ZcePGMW7cOLZu3era56mnnuKFF15g7ty5rFu3juDgYEaNGkVeXl5jfK0G1bqiVeHD25vPaUmNXCIRERHvYzGMptNr9tixY8TExLBy5UouuOCCcve59tpryc7O5vPPP3dtO/fccznrrLOYO3cuhmGQkJDA3/72N+6++24A0tPTiY2NZf78+Vx33XVVliMjI4OwsDDS09MJDQ2tny9XT655eQ0/7jvJi9f347K+CSUfrHgSVjwO/W6Esf/xXAFFREQ8pCa/302qD1B6urmWVWRkZIX7rFmzhhEjRrhtGzVqFGvWrAFg3759pKamuu0TFhbGoEGDXPucLj8/n4yMDLdHU1XhSLDwRPM5PbmRSyQiIuJ9mkwAcjgcTJ06laFDh9KrV68K90tNTSU2NtZtW2xsLKmpqa7Pndsq2ud0M2fOJCwszPVITEysy1dpUOWuCA8Q1tZ8Tj/YyCUSERHxPk0mAE2ePJmtW7eyYMGCRr/2jBkzSE9Pdz2Sk5tuLUqFNUBhzhqgg5oLSEREpApNIgBNmTKFzz//nG+//Za2bdtWum9cXBxHjhxx23bkyBHi4uJcnzu3VbTP6fz9/QkNDXV7NFXOAFRmPbDQNoAFivIg+1jjF0xERMSLeDQAGYbBlClT+OSTT/jmm2/o2LFjlccMHjyY5cuXu21bunQpgwcPBqBjx47ExcW57ZORkcG6detc+3izCmuAfPwgpDjgqR+QiIhIpTwagCZPnszbb7/Nu+++S0hICKmpqaSmppKbm+vaZ8KECcyYMcP1/s4772TJkiU8++yz7Nixg4ceeogNGzYwZcoUACwWC1OnTuXRRx/l008/ZcuWLUyYMIGEhATGjRvX2F+x3lU4DB5KmsHSFIBEREQq4+PJi8+ZMweAYcOGuW2fN28eN910EwBJSUlYrSU5bciQIbz77rvcf//9/OMf/6Br164sWrTIreP09OnTyc7O5tZbbyUtLY3zzjuPJUuWEBAQ0ODfqaHFFNcAncguwO4wsFktJR+GtYWDP6ojtIiISBWa1DxATUVTngeoyO6g6/1fYhiw4f4RRBfXCAGw9EH4/nkYdBuMedJzhRQREfEAr50HSKrmY7MSFewHVDISTE1gIiIilVIA8kLRFfUDCtNkiCIiItWhAOSFNBu0iIhI3SgAeSFXACozG3RxAMo9BflZjVwqERER76EA5IUqHAofEAr+YeZrjQQTERGpkAKQF6qwCQzUDCYiIlINCkBeqMLlMKDUoqgKQCIiIhVRAPJCFY4CAw2FFxERqQYFIC8UEWTOA3Qqp7Dsh+GlVoUXERGRcikAeaGIYF8A0nMLKDORt5rAREREqqQA5IXCA80aoEK7QXaB3f3DsHbms5rAREREKqQA5IUC/Wz4+5j/dGk5Be4fOpvAMg+DvaiRSyYiIuIdFIC8VHiQ2QyWdno/oOAYsPmB4TBDkIiIiJShAOSlnB2hywQgqxVC25iv1QwmIiJSLgUgLxUWaNYAnTq9CQxKdYTWSDAREZHyKAB5KVcNUG55Q+GLO0KnJzViiURERLyHApCXcvUByi6vBkhzAYmIiFRGAchLhVc2GaKzCUx9gERERMqlAOSlXDVAueXUAGlBVBERkUopAHmpiIqGwYN7E9jpM0WLiIiIApC3Cgt0DoMvpwbIOQy+MAdyTjZiqURERLyDApCXqrQGyDcAWsWar9UMJiIiUoYCkJcKr2wYPGhRVBERkUooAHmpkhqgAhyOcvr5OPsBaSSYiIhIGQpAXiqsOAA5DMjML2fR03DNBSQiIlIRBSAv5e9jI8jPBlTQEdo1EkyzQYuIiJxOAciLVbggKmg2aBERkUooAHmxai2Iqj5AIiIiZSgAebGIYDMApZc3EswZgHKOQ1F+I5ZKRESk6VMA8mLhxZMhnipvQdTACLCZn5N1pBFLJSIi0vQpAHkx53pg5S6IarFASJz5OjO1EUslIiLS9CkAeTFnACq3CQwgJN58zkxppBKJiIh4BwUgL+YcBVZuJ2goqQHKUAASEREpTQHIizlHgZU7DB4gJMF8Vg2QiIiIGwUgL1YyD1AVNUDqAyQiIuJGAciLOfsAVbggqvoAiYiIlMujAWjVqlVcdtllJCQkYLFYWLRoUaX733TTTVgsljKPnj17uvZ56KGHynzevXv3Bv4mnuFcEb7cYfCgGiAREZEKeDQAZWdn07dvX2bPnl2t/Z9//nlSUlJcj+TkZCIjI7n66qvd9uvZs6fbfqtXr26I4nucswYoI68Ie3krwqsGSEREpFw+nrz4mDFjGDNmTLX3DwsLIywszPV+0aJFnDp1iptvvtltPx8fH+Li4uqtnE1VeHEnaDCHwkcG+7nv4KwBys+A/Czwb9WIpRMREWm6vLoP0Ouvv86IESNo37692/Zdu3aRkJBAp06dGD9+PElJla+Inp+fT0ZGhtvDG/jYrIT4mxm23I7QAaHgVxx6NBu0iIiIi9cGoMOHD/Pll18yadIkt+2DBg1i/vz5LFmyhDlz5rBv3z7OP/98MjMzKzzXzJkzXbVLYWFhJCYmNnTx6014cCWzQUOpfkBqBhMREXHy2gD05ptvEh4ezrhx49y2jxkzhquvvpo+ffowatQoFi9eTFpaGgsXLqzwXDNmzCA9Pd31SE72nhXUneuBpedW1BHa2Q9IHaFFREScPNoHqLYMw+CNN97gxhtvxM/Pr9J9w8PDOeOMM9i9e3eF+/j7++Pv71/fxWwUrvXAsquoAco43EglEhERafq8sgZo5cqV7N69m1tuuaXKfbOystizZw/x8fGNULLG5xwKX/FcQBoKLyIicjqPBqCsrCw2bdrEpk2bANi3bx+bNm1ydVqeMWMGEyZMKHPc66+/zqBBg+jVq1eZz+6++25WrlzJ/v37+eGHH7j88sux2Wxcf/31DfpdPCXCORlihbNBazkMERGR03m0CWzDhg1ceOGFrvfTpk0DYOLEicyfP5+UlJQyI7jS09P56KOPeP7558s958GDB7n++us5ceIErVu35rzzzmPt2rW0bt264b6IB4VXd0FU1QCJiIi4eDQADRs2DMMoZwK/YvPnzy+zLSwsjJycnAqPWbBgQX0UzWuEV7kgqiZDFBEROZ1X9gGSEhHBVQWgUjVAlYRNERGRlkQByMs5h8GnVTgMvjgAFeVCXlrjFEpERKSJUwDyclUOg/cNhIBw87X6AYmIiAAKQF7P2Qk6vaJh8AChGgkmIiJSmgKQl3MOg8/KL6KgyFH+ThoJJiIi4kYByMuFBPhisZivK6wF0kgwERERNwpAXs5mtRAWWNVkiM7lMBSAREREQAGoWXDNBaQaIBERkWpRAGoGXLNBZ2tFeBERkeqoVQBKTk7m4MGDrvc//vgjU6dO5ZVXXqm3gkn1OYfCV10DpAAkIiICtQxAf/jDH/j2228BSE1N5aKLLuLHH3/kvvvu41//+le9FlCqFuFcEb6qPkBZqeCoYKSYiIhIC1KrALR161YGDhwIwMKFC+nVqxc//PAD77zzTrnrd0nDCqtqPbBWMYAFHEWQc7zxCiYiItJE1SoAFRYW4u/vD8CyZcv4/e9/D0D37t1JSVFH28YW4VoRvoIAZPOF4Nbma3WEFhERqV0A6tmzJ3PnzuW7775j6dKljB49GoDDhw8TFRVVrwWUqrn6AFXUBAaaDFFERKSUWgWgJ598kpdffplhw4Zx/fXX07dvXwA+/fRTV9OYNJ6SAKTlMERERKrDpzYHDRs2jOPHj5ORkUFERIRr+6233kpQUFC9FU6qxzUMXjVAIiIi1VKrGqDc3Fzy8/Nd4efAgQPMmjWLnTt3EhMTU68FlKo51wOrdEFUTYYoIiLiUqsANHbsWN566y0A0tLSGDRoEM8++yzjxo1jzpw59VpAqVpETWqAtByGiIhI7QLQTz/9xPnnnw/Ahx9+SGxsLAcOHOCtt97ihRdeqNcCStXCimuA8god5BXay99JNUAiIiIutQpAOTk5hISEAPD1119zxRVXYLVaOffcczlw4EC9FlCqFuLvg81qLglfYUdozQYtIiLiUqsA1KVLFxYtWkRycjJfffUVI0eOBODo0aOEhobWawGlahaLpdSCqFWsB5Z9DOyV9BUSERFpAWoVgB588EHuvvtuOnTowMCBAxk8eDBg1gb169evXgso1eMcCn8qu4JwExQFVh/AgKyjjVcwERGRJqhWw+CvuuoqzjvvPFJSUlxzAAEMHz6cyy+/vN4KJ9VnDoXPJr2iGiCrFVrFQcZBsx9QWJtGLZ+IiEhTUqsABBAXF0dcXJxrVfi2bdtqEkQPcjaBVbgcBpgjwZwBSEREpAWrVROYw+HgX//6F2FhYbRv35727dsTHh7OI488gkOrjXuEc0HUyucC0mSIIiIiUMsaoPvuu4/XX3+dJ554gqFDhwKwevVqHnroIfLy8njsscfqtZBStdDiAJShyRBFRESqVKsA9Oabb/Laa6+5VoEH6NOnD23atOGOO+5QAPKAatUAtYo1n9UJWkREWrhaNYGdPHmS7t27l9nevXt3Tp48WedCSc1VLwC1Np8VgEREpIWrVQDq27cv//nPf8ps/89//kOfPn3qXCipudCa1ABlKwCJiEjLVqsmsKeeeopLLrmEZcuWueYAWrNmDcnJySxevLheCyjV46wBysgrqninVsUL1aoGSEREWrha1QD97ne/47fffuPyyy8nLS2NtLQ0rrjiCn799Vf++9//1ncZpRrCqtMJOrhUADKMRiiViIhI01TreYASEhLKdHb+5ZdfeP3113nllVfqXDCpmer1ASoOQI5CyD0FQZGNUDIREZGmp1Y1QNL0lA5ARkW1Oz7+EBBmvlYzmIiItGAKQM1EaKBZmWd3GGQX2CveUR2hRUREFICai0BfG742C1BFPyDNBSQiIlKzPkBXXHFFpZ+npaXV6OKrVq3i6aefZuPGjaSkpPDJJ58wbty4CvdfsWIFF154YZntKSkpxMXFud7Pnj2bp59+mtTUVPr27cuLL77Y7Ncps1gshAX6cjyrgPTcQhLCA8vfMVhzAYmIiNQoAIWFhVX5+YQJE6p9vuzsbPr27csf//jHKsNVaTt37iQ0NNT1PiYmxvX6/fffZ9q0acydO5dBgwYxa9YsRo0axc6dO932a45CSwWgCrlqgI40TqFERESaoBoFoHnz5tXrxceMGcOYMWNqfFxMTAzh4eHlfvbcc8/xpz/9iZtvvhmAuXPn8sUXX/DGG29w77331qW4TV5oQA1mg84+1gglEhERaZq8sg/QWWedRXx8PBdddBHff/+9a3tBQQEbN25kxIgRrm1Wq5URI0awZs2aCs+Xn59PRkaG28Mb1Ww9MNUAiYhIy+VVASg+Pp65c+fy0Ucf8dFHH5GYmMiwYcP46aefADh+/Dh2u53Y2Fi342JjY0lNTa3wvDNnziQsLMz1SExMbNDv0VBqNhmiApCIiLRctZ4I0RO6detGt27dXO+HDBnCnj17+Pe//12nGahnzJjBtGnTXO8zMjK8MgRVKwC5lsNQE5iIiLRcXhWAyjNw4EBWr14NQHR0NDabjSNH3Gs3jhw54jZK7HT+/v74+/s3aDkbQ42awLKPgcMBVq+qBBQREakXXv/rt2nTJuLj4wHw8/Ojf//+LF++3PW5w+Fg+fLlrkVbmzPnZIiVBqDgaPPZsEPuyUYolYiISNPj0RqgrKwsdu/e7Xq/b98+Nm3aRGRkJO3atWPGjBkcOnSIt956C4BZs2bRsWNHevbsSV5eHq+99hrffPMNX3/9tesc06ZNY+LEiQwYMICBAwcya9YssrOzXaPCmrNqrQhv84WgKMg5YfYDcgYiERGRFsSjAWjDhg1uExs6++FMnDiR+fPnk5KSQlJSkuvzgoIC/va3v3Ho0CGCgoLo06cPy5YtczvHtddey7Fjx3jwwQdJTU3lrLPOYsmSJWU6RjdH1WoCA7MjdM4JczLE2J6NUDIREZGmxWJUuHJmy5WRkUFYWBjp6eluEy42dT/sOc4fXl1Hl5hWLJv2u4p3fPP3sG8lXP4K9L228QooIiLSgGry++31fYCkRLUmQgTNBSQiIi2eAlAzUu0mMOdQeK0ILyIiLZQCUDMSFmQGoIIiB3mF9op3dM0FpAAkIiItkwJQM9LKzwerxXxdvdmgFYBERKRlUgBqRqxWC6HVmgxRAUhERFo2BaBmpnorwqsPkIiItGwKQM1MyWSI1VkO4zjYK5k0UUREpJlSAGpmqjUSLCgKLFbAgJzjjVMwERGRJkQBqJlxBaCcSgKQ1QZBxUtgqB+QiIi0QApAzUzJgqhVNG25JkNUABIRkZZHAaiZqdYoMIBWrc1ndYQWEZEWSAGomalWJ2jQchgiItKiKQA1MzVeDiPrWAOXSEREpOlRAGpmqh2AXLNBqwZIRERaHgWgZsY5EWKlS2GAmsBERKRFUwBqZlx9gKrdCVpNYCIi0vIoADUz1e8DpBogERFpuRSAmhlnAMousFNod1S8o7MPUO4pKCpohJKJiIg0HQpAzUxIgI/rdaXNYIERYC3eV81gIiLSwigANTM+Niut/J2zQVe2HIa1pBZIkyGKiEgLowDUDJVMhljVchjFHaG1HIaIiLQwCkDNUPWXw1BHaBERaZkUgJqhsMBqNIFBqckQVQMkIiItiwJQM+ScDLH6y2EoAImISMuiANQMVX8yRHWCFhGRlkkBqBmqcQBSDZCIiLQwCkDNkGaDFhERqZwCUDNU7VFgrk7QmghRRERaFgWgZqj6NUDFASg/HQpzG7hUIiIiTYcCUDNUMhFiFQEoIAxsfuZrLYchIiItiAJQM1TtJjCLRc1gIiLSIikANUOuiRBzqghAULIchobCi4hIC6IA1Aw5a4Ay84twOIzKd9Zs0CIi0gIpADVDzj5AhgGZ1V0QtZIaoIOncvj1cHp9FU9ERMTjFICaIX8fGwG+5j9tlR2hq+gDZBgGN7y2jktfXM2aPSfqs5giIiIeowDUTNV4KHwFNUCH0/PYfyIHw4AZH28mr9Ben8UUERHxCI8GoFWrVnHZZZeRkJCAxWJh0aJFle7/8ccfc9FFF9G6dWtCQ0MZPHgwX331lds+Dz30EBaLxe3RvXv3BvwWTVO1F0QNLm4Cq6AP0JaDaa7X+0/kMGvZrvoonoiIiEd5NABlZ2fTt29fZs+eXa39V61axUUXXcTixYvZuHEjF154IZdddhk///yz2349e/YkJSXF9Vi9enVDFL9Jq3ENUAUB6JeDZt+fTq2DAXj1u71sPaT+QCIi4t18PHnxMWPGMGbMmGrvP2vWLLf3jz/+OP/73//47LPP6Nevn2u7j48PcXFx9VVMr1TtBVGDK28C21xcA/Sn8zuxetdxvtiSwt8/2sz/Jg/Fx6YWVBER8U5e/QvmcDjIzMwkMjLSbfuuXbtISEigU6dOjB8/nqSkpErPk5+fT0ZGhtvD29W4BigvHYry3T4yDIPNxTVAvduE8dDvexIW6MuvhzN49bt99V5mERGRxuLVAeiZZ54hKyuLa665xrVt0KBBzJ8/nyVLljBnzhz27dvH+eefT2ZmZoXnmTlzJmFhYa5HYmJiYxS/QVV7NuiAcLAWVwSethzG/hM5ZOYV4edjpVtcCK1D/Ln/kh4AzFr2G/uOZ9d3sUVERBqF1wagd999l4cffpiFCxcSExPj2j5mzBiuvvpq+vTpw6hRo1i8eDFpaWksXLiwwnPNmDGD9PR01yM5ObkxvkKDqnYAslor7AjtbP46Mz4U3+Lmrqv6t+X8rtHkFzn499Lf6rXMIiIijcUrA9CCBQuYNGkSCxcuZMSIEZXuGx4ezhlnnMHu3bsr3Mff35/Q0FC3h7erdhMYlBoK714D5Gz+6ts2zLXNYrFw+7DOAGxKTqt7QUVERDzA6wLQe++9x80338x7773HJZdcUuX+WVlZ7Nmzh/j4+EYoXdNRsiJ8FTNBQ4XLYThrgPq0DXfb3iPODIhJJ3PIyq/G+UVERJoYjwagrKwsNm3axKZNmwDYt28fmzZtcnVanjFjBhMmTHDt/+677zJhwgSeffZZBg0aRGpqKqmpqaSnlwzLvvvuu1m5ciX79+/nhx9+4PLLL8dms3H99dc36nfztNrVAJUEILvDYOshszN4n1I1QAARwX7EhQYAsDO14r5VIiIiTZVHA9CGDRvo16+fawj7tGnT6NevHw8++CAAKSkpbiO4XnnlFYqKipg8eTLx8fGux5133una5+DBg1x//fV069aNa665hqioKNauXUvr1q0b98t5WGiA2bG5ymHwUKoPUEkT2O6jWeQW2gn2s9Gpdasyh3SPDwFgR6r3j5gTEZGWx6PzAA0bNgzDqHi18vnz57u9X7FiRZXnXLBgQR1L1TyEBdWtBuiX4uavnm3CsFktZQ7pFhfCip3H2JGiGiAREfE+XtcHSKonMsgPgLScAuyOikMmUG4foC3ldIAuzdkPSDVAIiLijRSAmqnIYDMAOQw4lVNQ+c6tipvASo0Cq6gDtJOrCSwls9JaPBERkaZIAaiZ8rFZiShuBjuelV/5zqfVABUUOdhe3LR1egdop07RrfC1WcjML+JQWm79FFpERKSRKAA1Y9Gt/AE4nllVDVBxAMo9CfZCdqZmUmB3EBboS7vIoHIP8fOx0rm4c7T6AYmIiLdRAGrGXAGoqhqgwEiw2MzX2cddHaD7tA3DYinbAdqpR7zZD2jnEQUgERHxLgpAzVh0SDUDkNUKwdHm66wjrg7QFTV/OXWPM/sBbU9RR2gREfEuCkDNWHQrsyP0saoCEJT0A8o+VqoGKLzSQ7rHO0eCqQZIRES8iwJQM+ZsAjuRVUUfIHCNBCtIT2XX0Syg+jVAe49lkVdor0NJRUREGpcCUDPWurp9gMBVA3Q0JRm7w6B1iL9ruYuKxIT4ExHki8MwZ44WERHxFgpAzVh0iNkEVq0AVFwDlH7sEAB92lTeARrMleG7F0+IqH5AIiLiTRSAmrGo4GoOgwdXDZC9eC6gLjFl1/8qT8maYOoHJCIi3kMBqBlzjgI7kZ1f9WzNxXMB+eYeB6BNRGC1rqElMURExBspADVjUcXLYRTajaoXRS1eET6w4AQAbcKrF4CcNUDbtSSGiIh4EQWgZizA10ZIgA9QjX5ArWIBCLWfAiChmgGoa0wIVguczC6o3nB7ERGRJkABqJkrGQlWveUwwo1MbNirHYAC/Wx0iA4GYKf6AYmIiJdQAGrmqr0cRlAUhsWK1WLQ1j+X0OKao+pwzgekNcFERMRbKAA1c66h8JlVLYdho9A/AoAeIblVDoEvzTUUXh2hRUTESygANXPR1W0CA3J8IwHoEpRTo2uoBkhERLyNAlAz55oLqBodlNOtZg1Qe//sGl3DuSr87qNZFNodNSyhiIhI41MAauZqMhv0ccy1vxJ8a1aT0yY8kFb+PhTYHew9VrPwJCIi4gkKQM2cswnsWDWawFKLzKasGGvN+vJYrRbOiDVnjv7tiJrBRESk6VMAauZcfYCq6gQNJBWYISbCSKvxdZxLZ2hRVBER8QYKQM2ccx6gqpbDcDgM9uUGAdCq8GSNr+MKQMcUgEREpOlTAGrmnH2A8godZBfYK9zveFY+RxxmHyD/vOM1vo4zAO1RDZCIiHgBBaBmLsjPhyA/G1B5M9ihtFyOG2YAsmQfq/F1urQ2+w/tPZ6N3aE1wUREpGlTAGoBqjMb9OG0PI4VByByjoOj4tqi8rSJCMTfx0pBkYPkk1XMI2QvgsObYN0r8Mlt8NN/a3QtERGRuqr+egfitaJa+ZF0MqfSAHQoLYeTmLU4GA7IOQmtWlf7GjarhU6tW7E9JYPdR7Nc64O5SVoH3z4GBzdAYanh8ls+gO6XQFBkta8nIiJSF6oBagGqMxT+cFoeRfiQ41NcC5R9tMbXqbIj9LKHYN9KM/z4h0Ln4RDaFhxFsOOLGl9PRESkthSAWoDqDIU/lJYLQEFAtLkhqxYBqLUZgHYdKScAFRXAoY3m6wn/g7/vhxs/hgE3m9t+/bjG1xMREaktBaAWoHUrcyTYiezK+gCZAcgIKm72qk1H6MpqgFI3gz0fgqKg4+/AanbMpufl5vPelZB9osbXFBERqQ0FoBYgOsRZA1RZE5gZgGyhMeaG2tQAlRoKX2bOoeR15nPiICi90nxUZ4jrA4YddnxW42uKiIjUhgJQC1DVKLCcgiJO5RQCEBAeb26sRR+gDtFB2KwWsvKLOJJx2rVcAWhg2QN7XWE+b1UzmIiINA4FoBagqgDkrP0JCfDBzxmAMo/U+Dr+PjbaR5qzSbstiWEY5ggwMGuATnfmOPN5/3eQVfOmNxERkZpSAGoBols5V4QvvwnsUFoeYK7qTogzAKXU6lqdXWuClVoUNS0JslLB6gMJ/coeFNnR3G44YPuntbquiIhITSgAtQDOPkBZ+UXkFZad4NBZA5RQOgBlHK7VtcrtCJ38o/kc3xd8A8s/sGdxM9ivn9TquiIiIjXh0QC0atUqLrvsMhISErBYLCxatKjKY1asWMHZZ5+Nv78/Xbp0Yf78+WX2mT17Nh06dCAgIIBBgwbx448/1n/hvUiIvw9+NvOf+lg5Q+FLAlAAhLYxN9ayBsg5FN6tCczV/+fcig/sOc583r+6Vs1vIiIiNeHRAJSdnU3fvn2ZPXt2tfbft28fl1xyCRdeeCGbNm1i6tSpTJo0ia+++sq1z/vvv8+0adP45z//yU8//UTfvn0ZNWoUR4/WvFNvc2GxWEo1g5UNQIdOmQGoTXgQhBbXABVkQV5Gja/lqgE6Wmqm58o6QDuFt4M2AwADtv2vxtcVERGpCY8GoDFjxvDoo49y+eWXV2v/uXPn0rFjR5599ll69OjBlClTuOqqq/j3v//t2ue5557jT3/6EzfffDNnnnkmc+fOJSgoiDfeeKOhvoZXcDaDnSinH9Ch0jVAfsHgXzwbdC1qgZx9gI5n5ZOeUwj5mXBkq/lheR2gS+ulZjAREWkcXtUHaM2aNYwYMcJt26hRo1izZg0ABQUFbNy40W0fq9XKiBEjXPuUJz8/n4yMDLdHc1PZSLDD6c4aoOL+Oc5aoIxDNb5OK38f4sMCANh9LNOc/dlwQFi7kvNW5Myx5nPSmlr3QRIREakOrwpAqampxMbGum2LjY0lIyOD3Nxcjh8/jt1uL3ef1NTUCs87c+ZMwsLCXI/ExMQGKb8nVdQEZncYpKabo8ASXAEowXzOqGU/oJhSS2I4O0BX1vzlFNa2uJbIgO2f1+raIiIi1eFVAaihzJgxg/T0dNcjOTnZ00WqdyU1QO5NYMez8im0G9isFmKKm8kIKQ5AmbWrhelcuiN0ciXz/5Sn60jz+cD3tbq2iIhIdfh4ugA1ERcXx5Ej7iOEjhw5QmhoKIGBgdhsNmw2W7n7xMXFVXhef39//P39G6TMTUXJivDuNUDO/j9xoQH4FI8UK2kCq1sN0J6jGXBkvbmxXTUDkLOm6OD6CnfZfDCNp5bspGebUC7rk0DPhFAspZfXEBERqYJX1QANHjyY5cuXu21bunQpgwcPBsDPz4/+/fu77eNwOFi+fLlrn5aqZD2w0wLQqdP6/0Cd5wLqWhyAio5sh/x08A2GmJ7VOzjhbLBYzf5H6WX7IB08lcMf569n9e7jvLxyL5e+uJoRz61k1rLfSD6ZU6vyiohIy+PRAJSVlcWmTZvYtGkTYA5z37RpE0lJSYDZNDVhwgTX/rfddht79+5l+vTp7Nixg5deeomFCxdy1113ufaZNm0ar776Km+++Sbbt2/n9ttvJzs7m5tvvrlRv1tTEx1cfh8gtzmAnELr1gTmrAFKzNpibmjbH2zVrGz0bwWxxWHpoPv8TVn5RUx6cwPHswroFhvCmF5x+PlY2XMsm1nLdjFq1ir3GahFREQq4NEmsA0bNnDhhRe63k+bNg2AiRMnMn/+fFJSUlxhCKBjx4588cUX3HXXXTz//PO0bduW1157jVGjRrn2ufbaazl27BgPPvggqampnHXWWSxZsqRMx+iWxjUMPtu9D5DbLNBOdewEHdXKn4ggX84u3GVuqG7/H6e2AyF1CySvh57mFAl2h8HUBT+zIzWT6Fb+vHHzObQJDyQzr5Cvfz3C66v3sS0lg/s+2cqCW89Vk5iIiFTKowFo2LBhGIZR4eflzfI8bNgwfv7550rPO2XKFKZMmVLX4jUrzj5AaTmFFNod+Bb393GuA+YWgJydoLOPQVEB+PjV+HpdYlpx9uHfzDc1DUCJA2HD6241QE8u2cGy7Ufx87HyyoT+ria7kABfruzflkGdIrnouVWs23eSDzce5OoBzW8kn4iI1B+v6gMktRce6IvNataKlJ4M0VkD1CaiVAAKigKrL2CYi5jWQt/IQjpZi49tO6BmB7c9x3xO+QWK8lm4PplXVu0F4Omr+nB2u4iyh0QEMXVEVwAeX7ydk9nlL/wqIiICCkAthtVqIeq0fkB5hXYOnjI7Drt1grZaS3WErl0z2AA/s+kyxbcdBJYNLJWK7GSGMHsBp/as5/7/mTNJ/3V4V8ae1abCw/54Xke6x4VwKqeQmYu316rcIiLSMigAtSDOZrAjGXks3JDMhc+sICOvCJvV4h6AoO4doW3mVAS7HAk1P9hiMfsBAVvXLqWgyEHfxHCmDu9a6WG+NiuPXd4LgA82HmTd3hM1v7aIiLQICkAtiLMj9J0LNjH9w82kpOeREBbA89edRbD/ad3B6jgXUKJhHrctv7VrpumancBsBivYb06kePOQDlitVXds7t8+kusHtgPgvkVbKShy1PzaIiLS7CkAtSDO5TCy8osIC/Tlvot78M3dw7i0Tzm1NM6O0LVYDwzAP30fAPuMONbsPV7zExTXAJ3p2El0K38u7l3FOmKl3Du6O9Gt/Nh9NIvXVu+t+bVFRKTZUwBqQS7uFU+b8EBuH9aZVdMv5E8XdCLA11b+zs4aoFqsCA/AyT0A7HfE8cPuWjRFtTkbO1biLSe59Sw//Hyq/6caFuTLjDE9AHh11V5yC+w1v76IiDRrCkAtyIgzY/n+3v/j76O7ExboW/nOdZkLqKgA0sxO0GYNUM0D0K/Hi9juMJuyromteRnG9WtDYmQgp3IK+XBj81vbTURE6kYBSMpXlwVR05LAcGD4BnHSGsHBU7k1XqbizR/285PD7PQcfmJTjYtgs1qYdF4nAF5bvQ+7o+L5pkREpOVRAJLyle4EXclkleUqbv6yRHaiT9twANbsqX4t0KnsAv636bArAJH8Y+UHVODqAW0JD/LlwIkclm6r3XxGIiLSPCkASfmc8wDZ8yHnZM2OPWEGICI7MaRzNECNmsEWrE8mv8hBZuuzzQ0pv0BhzUeSBfn5cOO57QFcEymKiIiAApBUxMcfgszwUuNmsOIaIKI6M7hzFGDWAFW27IlTkd3B22sPADDqvEEQ3BochWYIqoUJgzvgZ7PyU1IaG/bXMMiJiEizpQAkFavtXECuGqDO9G8fgZ/NSmpGHvuOZ1d56LLtRzmUlktEkC+/P6uNazj86SvDV1frEH+uONucPVq1QCIi4qQAJBWrbUfoUjVAAb42+rULB6puBjMMg1e/M0PKdQPbmUP0iydErG0/IIBJ53cEYOn2I+w9llXr84iISPPh0dXgpYlz1QDVIAAV5UP6QfN1ZGcABneOYt2+k6zZc4Lxg9pXeOi6fSfZeOAUfjYrNw/pYG501QCtNztjW6qeDfp0XWJCGN49huU7jvLa6n08fnnvGp+jMoZhsGjTIdbvP0VeoZ38Igf5hQ5sVrhpSEdXM6CIiDQdCkBSMdds0DUIQKf2g+EAv1bQKgaAIZ2jmbVsF2v3mv2ALBWEmNnf7gbM0VsxoQHmxoR+YPUxJ2RMS4KIigNUZW69oBPLdxzlo40HmXbRGa510erKMAyeWLKDl1eW37y2fPtRHru8F9ee065ericiIvVDTWBSMdeCqDXoA3SyOAhEdnTV1vRNDCPA18rxrAJ2HS2/CWrzwTS+23Ucm9XCbb/rXPKBXxDE9zVfJ6+r6TdwGdgxkr6J4eQXOXjp2z21Pk9phmHwr8+3ucLPjee2594x3XnosjOZeUVvLukTT5HD4O8fbeGJL3fg0FxEIiJNhgKQVKw2naBLdYB28vexMaB9JFDxfEDOUDK2bwKJkUHuH7YbbD4nra1+OU5jsVj420VnAPD22gMcPFWziRlP53AY3L9oK/O+3w/AY5f34pFxvbjtd525aWhHrh/Yjv9c3487i1ewn7tyD5Pf/UnLcoiINBEKQFKx2iyIWqoDdGnOfjA/7Cm7MOquI5ks+dWcqPD2YZ3LfE7iIPO5DgEI4Pyu0QzuFEWB3cGsZbtqfR67w+DvH23mnXVJWCzw1FV9yu3bZLFYuOuiM/j3tX3xs1n5cmsq17+6lsy8wrp8DRERqQcKQFIxZw1QXhoU5lbvmHJqgKAkAK3bd7JMU9CcFeYxo3rG0jU2pOw5251rPh/dBrmnqleOclgsFqaP7gbAxz8dZNeRzFqd5+HPfuWDjQexWS3MuvYsrhmQWOn+l/dry9uTBhEe5Mum5DT+8t7PFNkdtbq2iIjUDwUgqVhAOPgWN0dVtyO0sw/QaTVAvduEEexnIy2nkPfWJ5FTUARA8skc/veLee7JF3Yp/5ytYooDlQHJ62v4Jdz1axfBqJ6xOAx45uudNT7+gw3JvLXGnKjx+evOYuxZbap13MCOkbx580ACfK2s2HmMR7/YXuNri4hI/VEAkopZLCVLYlSnI3RhXpkh8E6+NitDupgzS9/3yVb6P7KMKe/+xD8//RW7w+D8rtGudcPK5ewHlFy3ZjCAu0d2w2qBr349ws9J1a9R2noonfsWbQVg6oiuXNonoUbX7ZsYzr+vOQuA+T/sZ/73+2p0vIiI1B8FIKlcaA2Gwp/aBxjgFwLB0WU+fmxcL24f1pnEyEByC+18vjmFb3YcBSqp/XFqVz/9gAC6xoZwxdltAXhqyc5qLdFxKruAP/93IwVFDoZ3j+Gv/9e1Vtce0zuev4/uDsC/Pt/Gt8XfX0REGpfmAZLKhdRgMkRn/5+oTuVOWBgTGsDfR3dn+qhubD6YzuebD7Ns+1H6tQtnUMfIys/trAE6tNGcbNGnbvP4TB3RlU83HWbN3hOs3n2c87u2rnBfu8Pgrwt+5lBaLu2jgnju2rOwWms+IaPTbb/rxL7jWSzccJAp7/7EwtsG0zMhrNbnK13OrYfS+X7PcdbsOcHO1EziwwLoEB1Mx+LH2e0iyo6yExFpgRSApHI1mQvoZPkdoE9nsVjomxhO38Rw7rvkzOqVI6oLBEVBzglzYdTEgdU7rgJtI4K44dz2vPH9Pu7+4Bdm/+FsBnQoG8IMexFfv/005+/bwjA/K+O6JhL2/SoICIV+N5Zb01UVi8XCo+N6k3wylzV7T3DdK2t5afzZlYawyvx6OJ05K/aw8rdjZOYVuX12NDOfXw6ml7o2jOkVxx3DutCrTd1Dl4iIt1IAksrVpAmsgg7Q9cJiMWuBdnxuNoPVMQAB/OX/urDyt6PsOZbNta+s5d7R3Zl0fkfXTNXb9h0kb8FNjMlfX/K/lE2lTrDuZbjqDWg/pMbX9vOxMveG/kx6az3r95/ipnnrefj3Pbnh3OrPdP3r4XReWL6Lr3494toWEuDDuZ2iGNo5it5twzmWmce+4znsO57FrqNZ/JyUxuItqSzeksr5XaO5fVhnBneKqnB2bhGR5koBSCpXmyawKmqAai1xUEkAGvrXOp8uItiP/005jxkfb+GzXw7z2OLt/Lj/JH8f3Y0Pl63mih1/42zrIfIMX3YnXkWvdtHmemSGA3Yvg+O/wfxLYfgDMOROsNasS11YkC9vTxrEjI+28PHPh7h/0Vb2Hsvmvkt6YKugic0wDDYcOMVr3+11BR+LBX7fN4GbhnSgT9vwCo8F2J6Swcsr9/DZ5hS+23Wc73Yd59xOkcwY04O+ieE1Kr+IiDezGNXpAdrCZGRkEBYWRnp6OqGhoZ4ujmcd3ACvDYfQNjBtW+X7PnemOWniLUvrpYamjOT18PoICIyE6XtrtTBqeQzD4O11STzy2TYK7A7OtW7jJd9ZRFqySPOJpuDqt4npNtj9oPws+Pwu2LLQfN91FFw+F4Kq6MtUwfVfWrGHp78yh+UP7hTF6F5xdI8LoXtcKGFBvuw5lsWinw/xyc+HOHjKnJPJYoHL+iTw1+Fd6BJTzvxJlUg6kcOr3+3l/Q3JFBSZcxJd0ieee0Z2o0N0cI2/Q2l5hXZ+SjrFjpRMsvKLyM4vIiu/iJwCO5HBfpwZH0qP+FC6xLTCz0fjMESk/tTk91sBqBwKQKWkH4J/nwkWGzxwDKy28vcryIHHi2uL7tkLwQ2wAnpRATyRCEV5MHk9tD6jXk+/+WAaH775Ag8UzMLXYic7ui/BE94vmRDydIYBP70Ji6eDPR8iOsKfvqlVCAJYvCWFu97fRH6R+ySJ0a38OJ5V4Hof7Gfj4t7x3HpBp/InjqyBQ2m5PPv1Tj75+RCGAT5WC1cPSOSKs9vQv11EtTp7FxQ5+OVgGmv2nGDNnhNsTDrlClWV8bVZOCM2hPO6RnNhtxj6t4/A16ZAJCK1pwBURwpApdiL4NHWZrPPtB0Vh4Ejv8KcIeAfBvceqLfamTLmXQIHVsPvX4SzJ9TvudOSMF46F0tBNkavK7GMnQ2+gVUfl7IZFoyH9CTo/H8w/sOKg2IVfjuSyaebDrMjNYPtKZkcSjNre2xWCxd0jebys9tyUY9YAv1qd/6KbDucwZNLdrDyt2OubXGhAVzcO55L+sQRHxaIAa4pA1LT81i79wRr955kw4GT5BW6B56YEH/ObhdBRLAvwX4+BPv7EOxvIyU9j22HM9iWklGmw3aIvw/ndY1mSJdo+rYNo3tcaI1qiAqKHKSm53E4PZeU9FxOZhdSZHdQ5DAoshvYHQ5CA32JCQ0gNsSf2NAA4sICCPCt33spIp6jAFRHCkCneb4vnNoPN3wMXYaXv8+2T2HhjZDQD25d0XBlWf4IfPcMnDUexr1Uf+c1DHj7StizHBLPhZu/rFmfntSt8PpFUJgD5/8Nhj9YL8XKyCtkz9EsEiODiG5Vt6H/1bF27wkWbkhm6a9HyMwvqvqAYpHBfpzbKZLBnaMZ0jmKTtHBlXasNgyDg6dy+SnpFCt3HmPlb8c4kV3gto+fzUr3+BB6JoQSGuiLv48Nfx8rfjYr+UV2UjPySE3P50hGHqkZeRzPyqc2/zVrEx5I55hWdGndis4xwXSMCqZtRBDx4QG1rpEqtDsoLLXciQULFgv4+1jV4VykAdXk91udoKVqieeaAShpbcUBqJpD4OvMuS5Y0pr6Pe8v75nhx+YPY/9T4w7NxPUya6U+ugW+e9YMgj0uq3OxQgN86dcuos7nqa5zO0Vxbqco8ovsrPrtOF9sPsy3O4+RW2iuYm/BrNxr5e/LwI4Rrv27xrSq0Q+7xWIhMTKIxMggxp7VBofDYMuhdL7deZSfktLYfDCNtJxCNh9MZ3OpYfxV8fOxkhAWQEJ4IFGt/PG1WfCxWvCxWbFaID23iCMZeRzNyONIRj65hXYOpeVyKC2XVaVqvwCsFrMWLD48kCA/mxnAfK0E+NgwDIOcAjvZBUXkFtjJKbC79Xc6vRnTycdqITTQl7BAX0IDfYkI8iUq2J/oED+ii5/DAn0JCfAlJMCHkABfgv1sWCwWrBawWixYLRbshkFhkRmyCuwOCotruOwOKHI4cDjMfydfmxVfmwVfmxU/HyuBfjaC/Xwq7Sgv0lIoAEnV2p0LmxdUHjpOlL8KfL1rew5gMYfcZx011wmrq8wjsGSG+XrYvRBdu1me6X0VHPoJ1s6GT26H6G713k+psfj72LjozFguOjO2Ua5ntZbMDQUlNUS/HExjZ2omOQV2Cooc5sPuwMdqIS4swGzGCjWf48MDiAr2q3YQMwyDUzmF7DmWxe6jWew5msXuY1kknczh4KlcCoocHE7P43B6Xr19zyKHwcnsAk6eVtvV2AJ9bQT7+9DK31bcPOlDSPFzgK8Zlvx9bPj5WPG1WqA4gDlrsqB4QCQlVW42iwWr1QxoNqsZvpy1dv6+5utAXxsBvlYCfG0E+hV/Vhws/WxW1ZBJo1IAkqo557k5uMHsiOzjV3Yf5xxADV0DFBgOsT3hyFazRurM39f9nIv/Zq54H98XhtRxeP1FD5sTNR5YDe+PNztF+9eto3JLVLqG6NI+DXeNyGA/IoMjOee0STAdDoPj2fkcPJXLkfQ88ors5BU6yC+0k1fkwGqBQD8fgnxtBPmZP+YhAT7FocJ8lO6/ZBjgMAyy8otIzy0kPaeQ9NxC0nIKOZ6dz/HMAk5k53M8K5+M3CIy8wrJzCsiM6+IAnvFHcptVotZw2O1YrNZXCHEZrFgYPZ9KrA7XM92hxlYcgvt5BbaOZ7VMPe2LmzF5bdZzYfVgitYmTWQ5jZb8TarFXysJTVdPjYrfjYLfsXNpX4+Vvx8bK7X/j5W12c+xcfYrMU1hVYLNpu1+Ppgs1pdzz7F5bFZLPjYLMXHW12v/Xysrpo2X5sFf5sNX5/iMlktCnZNkAKQVC36DHPoee7J4lmYz3H/vCDHXKICIK53w5en3blmANr/Xd0D0K+LYPtnYPWBsbPBVsf/Sdh84ep58PLvzHmCPr8LrnytbueURme1WogJCSAmJKBezxsS4Et8WDU61pdSZHfgKA5QYC55YgYfa42asgzDIL/IQXZ+Edn5ZvNdVnGTXXbxIzPPbL5z1rTlFzoocjhcAc7sCF8yxsHZJGp+bgZHu2HgcJiBK7+o+FEcHPML7eQVh6/cArvr89LsDgM7BthrdJuaPGfg8rGa4czHWvK+9L+nj81aapulTLjzLQ5cvs6Hz2nvbSXnLzmu5Dw+NrNWz3ku31JB0NdqdYW20q+ba4BTAJKqOWdh3vmF2Qx2egDa/505ND0sEWJ6NHx5uo6E9a/B1o9h1ONm6KiNnJOw+G7z9Xl31V94axUD17wJb4yGLR/AGaPN5jGRWvCpp6kBLBYLAb42AnxtRLWql1PWC8MwKLQb5BeZgcjhMChyGNhLPYNRErIMw3w4wG6Yn9sdBkXF/aGK7Iarb5QrzBUHrUJ7SbgrKH5fZDcodJjPRQ5H8fnM6xQ5zDDnvIbdMFwjC0sfW1hkuM6dX/x8ugK7gwIvDnV+pWq3nGGrzPvSYcp2+r7OMFUS2gZ2jKz1EkD1QQFIqqfduSUB6PRZmH9bYj53Hdlww99L6zwcgmMg+yjsWgrdL67deVY+BdnHzL46F9xTv2VMHAgX3A0rn4Qvppn3L6xt/V5DpBmwWCz4+Zi1Fs2lsdgoDmaFxU2Pp4ct5+siR0mgsheHKudxZgA0O7gXFY8qLCwOd0UOw3XOgqLi93YHhUXOTvGl9i11TNFp5ygpR8l5nM2lpysoDpX16Y5hnRWAZs+ezdNPP01qaip9+/blxRdfZODA8mcSHjZsGCtXriyz/eKLL+aLL74A4KabbuLNN990+3zUqFEsWbKk/gvfUjhXY09aCw5HySgpw4DfvjZfnzG6ccpi84E+18Ca/8Cmd2oXgI7vgvWvmq/HPFnn1eXLdcE9ZkA7/BMsuh1u/F/NR5eJiNexFPcT8rFBIN43z5RRXPtVaDdrt0pClTPMldSyuYW7UqMSnaGtwBXESl47RzCe3YgjXMvj8QD0/vvvM23aNObOncugQYOYNWsWo0aNYufOncTElB3h8/HHH1NQUDKC4sSJE/Tt25err77abb/Ro0czb94813t//4afQ6VZi+8LPoFmP6Djv0FMd3P7kV8h46D5WcfzG688Z/3BDEC/fQXZJ2o+8/TX94OjCM4YA50vbJgy2nzhilfh5fNh3ypYNwcGT26Ya4mI1BOLxeJqvqKcMS/Nhcf/7+hzzz3Hn/70J26++WbOPPNM5s6dS1BQEG+88Ua5+0dGRhIXF+d6LF26lKCgoDIByN/f322/iAjPJk2v5+MHbQeYr0sPh3c2f3X6XfVmTa4vsT0h/ixwFMLWD2t27J5vzHJbfWDkow1SPJfoLiXXWPYwHKliPbX64nDAsd/MgHpkm/k4uh3yMhrn+iIiTZxHA1BBQQEbN25kxIgRrm1Wq5URI0awZk31Jrp7/fXXue666wgOdl/AccWKFcTExNCtWzduv/12Tpw4UeE58vPzycjIcHtIOUo3gzntcjZ/jWr88pw13nze9E71j7EXwVf3ma8H3moGlIY24I/mYqn2fPj4VijMbbhr2QvhlwXw0rkw+xxzeZI5g83HS+fCM2fAZ1PNcCQi0oJ5NAAdP34cu91ObKz7ZGuxsbGkpqZWefyPP/7I1q1bmTRpktv20aNH89Zbb7F8+XKefPJJVq5cyZgxY7Dby++CP3PmTMLCwlyPxMTE2n+p5sw1C/MP5nP2CUj+0Xzd1QMBqPdVYPU1h+Yf+bV6x/z8FhzdBoER8LvpDVs+J4vFnCU6KAqObIH/TaZWazZUpjAP1r8OL54Nn/wZju8EnwAIbg1B0eYjIByKcmHjPDMcvXM17Pm2/ssiIuIFPN4HqC5ef/11evfuXabD9HXXXed63bt3b/r06UPnzp1ZsWIFw4eXXcphxowZTJs2zfU+IyNDIag8bc8BixXSksxV4vevBgxz+HhYm8YvT1AkdBttzuOz6V0Y9Vjl++elwzfF+wybYYagxhISC1e/Cf8dB1s/gtbd6y+AHfjBrFlKTzbfB0WbfY3OmQQBpdbCMQxz3zWzYedis/Zu19fQ6UK47HmIaF8/5RER8QIerQGKjo7GZrNx5MgRt+1HjhwhLi6u0mOzs7NZsGABt9xyS5XX6dSpE9HR0ezevbvcz/39/QkNDXV7SDkCQkvmyklaU2r4uwdqf5yczWCbF5rNP5VZ8STkHDcndhzwx4Yv2+k6ng+XPGe+/vYxcxLGunA4YNUzMP9SM/yEtoExT8HULXD+NPfwA2ZNVIehcP278JeNMPDPZi3R3m/hpcGw7mVwePFEJSIiNeDRAOTn50f//v1Zvny5a5vD4WD58uUMHjy40mM/+OAD8vPzueGGG6q8zsGDBzlx4gTx8fF1LnOL5+wHtP872F3879ZYw9/L02WEWeORfbSkPOX5+W1zjS6AkY/VfvLEuuo/Ec69w3z9yW1w+OfanSfrGLxzJXzzCBh26Hs9TP4RBv0Z/IKqPj6qM1z8FNz2PbQfCoXZ8OV0mDcGju2sXZlERLyIxTA82wHg/fffZ+LEibz88ssMHDiQWbNmsXDhQnbs2EFsbCwTJkygTZs2zJw50+24888/nzZt2rBgwQK37VlZWTz88MNceeWVxMXFsWfPHqZPn05mZiZbtmyp1nD4jIwMwsLCSE9PV23Q6X5dBB9MNIe9F+Wa4ePu38DqwbkulvzDDDc9fg/X/rfs57uWwrvXmkHhvGkw4p+NX8bS7EXw3nWweymExJvrhYUmVP/43cth0R2QlWr+O1zyLPQbX/vyOBxmv6Cl/4SCTLNf1aA/m/MYBYbX/rzlXstuzsGU8gukbjZf2/PNe+IoNGvxAsIgqov5iO4CUV0hvF3jTLIpIl6tJr/fHu8DdO2113Ls2DEefPBBUlNTOeuss1iyZImrY3RSUhLW0yaP27lzJ6tXr+brr78ucz6bzcbmzZt58803SUtLIyEhgZEjR/LII49oLqD64OwIXVQ8kqnrRZ4NP2DOCbR2Nuz8Er57DgbdVlILcmgjLJxQUksy/EHPlhXMiRyveh1eHwnHdsDLF8ComWan7sp+5DMOw1f/gF8/Md+37g5Xz6/78iNWK5xzizmS74u/mU2ba/4Dv7wHF94HZ0+s/RpphmGu27bra9i1zKzxKqrGKLi937q/D44xm+/aD4UO55nfXYFIROrA4zVATZFqgKrw/Flwap/5+ur50PNyT5bG9N71ZsdegFaxZu1Fxwtg3sVmv5/O/wd/WOi5pq/ynNpv1kwd22G+73QhXPocRHZy389eBD++DN8+DgVZZkf0gbeaYc4vuMxp62zXMjNoHS9uCos50wyVXUdCaDWakTOPwIHvYe8Ks/Yt87D7577BZl+y+D5mePNrZc7JZPUx/31yTsCJ3Wbt0Ik9cHIP2AvczxEUZTbHth9iPsf1qftCtrmn4NQByDpiLpGSfQyyj5vbXSuAWswVQP1aQXDx6Lrg1uYjNMGs0atrOUSk1mry+60AVA4FoCosusOce8fqA9P3mk0Wnuaww5YP4dtHzVFqgPlLZZg/jjcvBv8muNJQUQH88DysfNpsCvIJgLMnABZz1u2cE2YISDtg7t/2HLMjdXyfhi2XvRA2zjc7a+eeKtke19vs9N72HDAcZpmLCsw+RId/NkeZnThtsIFvEHT8HZwxEjqcD5Gda7YkSGGeWZN34Htz5GHyj2VrkfxaQetu5rmjOpvPoQnFwcpmhkaL1bynmUfM5sPMI2Y4O7XffOSl1/JmlWKxQkiCue5baLwZxoNbmwvkBseYgdUnwFx6xSfALFtRvhnw7AXm64JsyM+E/PTi50xzW0FW8XO2uZ/Dbs5mbtjNfwurrzlhqa344RtoXs+v1WnPpR6+QcX7+5YcB8VTIxjms2E3/x7shSXltBcWN10WlHxm2M0yGQ7z4bwfrvtvK76Or1lWm58ZFm1+xe+LHxZb8TE2M3RarGZZXOXCPL/DXuqaxdd1OEpeO8vg/C5mgUoFWWup8lmKr3daeS3WkppG13EW97KYb4rvlVHq2ob7fazwb6b4vM7XFmvJdSzWUvucVv4ySl/ntPtVpryVKF2zenrZSj6o+Bi3a5VTjtICwszRvPVIAaiOFICq8Mv78MmtZq3KjZ94ujTuigrMH+5VT5sdo8Pbwy1LzWHoTdmJPfD5XbCv7Dp3gDlkf8TD0O/Gxl1PLPcUrH8Ndi4xQwjV+c+FBeJ6QfvzoOsI89k3oP7KVFRg9iE68L0ZuJLWmmGhPgTHmMHJWasTHG32g7JY3X/MCrJLaoiyj5l/axmHzUAiItXTAH0yFYDqSAGoCg4HbPnAHNZdk867jakg2+wT1OH8ph9+nAwDfv3YrOUICDf/n1FQlPlIHNi48xaVJ+sY7Flurr92Yrf5/9x9/Eueo7uaYafdoMYtq8Nurk93fJdZrpN74MResynLsBfXChTXDASEm38PreLM55B4iOhgPsLb1a1J0eEwg1D6QXNagsxUswxZx0qa1QpzoSjPrMEpyjPL7uMHNv+SZ/9WZm2lfwj4h5o1N/6timtwWpn922z+Zk2Fs4YLixm+StckFeWV1BrlZ7nXIBXmmO8Lc0vV4hSUmkqiuKkPi3n+0rVEp9c0OWt0nLU2VmtJzYXDXlKL5LCXdHR31SA5O78XmK/tBSX/Vq5/N0f5tSSu2prTaoxK1/i51V4U1wgbDveaGufDVZNknFajVE5tTpkaGU6ruSldW3T6cyluNUSnPZepPSq17fRzlFc7U14ZXZ+VPp6yb8qtwamoNsc47YTOS52+rZx9hvwFLpxRdnsdKADVkQKQiIiI96nJ77fHF0MVERERaWwKQCIiItLiKACJiIhIi6MAJCIiIi2OApCIiIi0OApAIiIi0uIoAImIiEiLowAkIiIiLY4CkIiIiLQ4CkAiIiLS4igAiYiISIujACQiIiItjgKQiIiItDgKQCIiItLi+Hi6AE2RYRgAZGRkeLgkIiIiUl3O323n73hlFIDKkZmZCUBiYqKHSyIiIiI1lZmZSVhYWKX7WIzqxKQWxuFwcPjwYUJCQrBYLPV67oyMDBITE0lOTiY0NLRezy3udK8bj+5149G9bjy6142nvu61YRhkZmaSkJCA1Vp5Lx/VAJXDarXStm3bBr1GaGio/gfVSHSvG4/udePRvW48uteNpz7udVU1P07qBC0iIiItjgKQiIiItDgKQI3M39+ff/7zn/j7+3u6KM2e7nXj0b1uPLrXjUf3uvF44l6rE7SIiIi0OKoBEhERkRZHAUhERERaHAUgERERaXEUgERERKTFUQBqRLNnz6ZDhw4EBAQwaNAgfvzxR08XyevNnDmTc845h5CQEGJiYhg3bhw7d+502ycvL4/JkycTFRVFq1atuPLKKzly5IiHStx8PPHEE1gsFqZOnerapntdfw4dOsQNN9xAVFQUgYGB9O7dmw0bNrg+NwyDBx98kPj4eAIDAxkxYgS7du3yYIm9k91u54EHHqBjx44EBgbSuXNnHnnkEbe1pHSva2fVqlVcdtllJCQkYLFYWLRokdvn1bmvJ0+eZPz48YSGhhIeHs4tt9xCVlZWvZRPAaiRvP/++0ybNo1//vOf/PTTT/Tt25dRo0Zx9OhRTxfNq61cuZLJkyezdu1ali5dSmFhISNHjiQ7O9u1z1133cVnn33GBx98wMqVKzl8+DBXXHGFB0vt/davX8/LL79Mnz593LbrXtePU6dOMXToUHx9ffnyyy/Ztm0bzz77LBEREa59nnrqKV544QXmzp3LunXrCA4OZtSoUeTl5Xmw5N7nySefZM6cOfznP/9h+/btPPnkkzz11FO8+OKLrn10r2snOzubvn37Mnv27HI/r859HT9+PL/++itLly7l888/Z9WqVdx66631U0BDGsXAgQONyZMnu97b7XYjISHBmDlzpgdL1fwcPXrUAIyVK1cahmEYaWlphq+vr/HBBx+49tm+fbsBGGvWrPFUMb1aZmam0bVrV2Pp0qXG7373O+POO+80DEP3uj79/e9/N84777wKP3c4HEZcXJzx9NNPu7alpaUZ/v7+xnvvvdcYRWw2LrnkEuOPf/yj27YrrrjCGD9+vGEYutf1BTA++eQT1/vq3Ndt27YZgLF+/XrXPl9++aVhsViMQ4cO1blMqgFqBAUFBWzcuJERI0a4tlmtVkaMGMGaNWs8WLLmJz09HYDIyEgANm7cSGFhodu97969O+3atdO9r6XJkydzySWXuN1T0L2uT59++ikDBgzg6quvJiYmhn79+vHqq6+6Pt+3bx+pqalu9zosLIxBgwbpXtfQkCFDWL58Ob/99hsAv/zyC6tXr2bMmDGA7nVDqc59XbNmDeHh4QwYMMC1z4gRI7Baraxbt67OZdBiqI3g+PHj2O12YmNj3bbHxsayY8cOD5Wq+XE4HEydOpWhQ4fSq1cvAFJTU/Hz8yM8PNxt39jYWFJTUz1QSu+2YMECfvrpJ9avX1/mM93r+rN3717mzJnDtGnT+Mc//sH69ev561//ip+fHxMnTnTdz/L+m6J7XTP33nsvGRkZdO/eHZvNht1u57HHHmP8+PEAutcNpDr3NTU1lZiYGLfPfXx8iIyMrJd7rwAkzcbkyZPZunUrq1ev9nRRmqXk5GTuvPNOli5dSkBAgKeL06w5HA4GDBjA448/DkC/fv3YunUrc+fOZeLEiR4uXfOycOFC3nnnHd5991169uzJpk2bmDp1KgkJCbrXzZyawBpBdHQ0NputzGiYI0eOEBcX56FSNS9Tpkzh888/59tvv6Vt27au7XFxcRQUFJCWlua2v+59zW3cuJGjR49y9tln4+Pjg4+PDytXruSFF17Ax8eH2NhY3et6Eh8fz5lnnum2rUePHiQlJQG47qf+m1J399xzD/feey/XXXcdvXv35sYbb+Suu+5i5syZgO51Q6nOfY2LiyszUKioqIiTJ0/Wy71XAGoEfn5+9O/fn+XLl7u2ORwOli9fzuDBgz1YMu9nGAZTpkzhk08+4ZtvvqFjx45un/fv3x9fX1+3e79z506SkpJ072to+PDhbNmyhU2bNrkeAwYMYPz48a7Xutf1Y+jQoWWmc/jtt99o3749AB07diQuLs7tXmdkZLBu3Trd6xrKycnBanX/KbTZbDgcDkD3uqFU574OHjyYtLQ0Nm7c6Nrnm2++weFwMGjQoLoXos7dqKVaFixYYPj7+xvz5883tm3bZtx6661GeHi4kZqa6umiebXbb7/dCAsLM1asWGGkpKS4Hjk5Oa59brvtNqNdu3bGN998Y2zYsMEYPHiwMXjwYA+WuvkoPQrMMHSv68uPP/5o+Pj4GI899pixa9cu45133jGCgoKMt99+27XPE088YYSHhxv/+9//jM2bNxtjx441OnbsaOTm5nqw5N5n4sSJRps2bYzPP//c2Ldvn/Hxxx8b0dHRxvTp01376F7XTmZmpvHzzz8bP//8swEYzz33nPHzzz8bBw4cMAyjevd19OjRRr9+/Yx169YZq1evNrp27Wpcf/319VI+BaBG9OKLLxrt2rUz/Pz8jIEDBxpr1671dJG8HlDuY968ea59cnNzjTvuuMOIiIgwgoKCjMsvv9xISUnxXKGbkdMDkO51/fnss8+MXr16Gf7+/kb37t2NV155xe1zh8NhPPDAA0ZsbKzh7+9vDB8+3Ni5c6eHSuu9MjIyjDvvvNNo166dERAQYHTq1Mm47777jPz8fNc+ute18+2335b73+eJEycahlG9+3rixAnj+uuvN1q1amWEhoYaN998s5GZmVkv5bMYRqnpLkVERERaAPUBEhERkRZHAUhERERaHAUgERERaXEUgERERKTFUQASERGRFkcBSERERFocBSARERFpcRSAREREpMVRABIRqQaLxcKiRYs8XQwRqScKQCLS5N10001YLJYyj9GjR3u6aCLipXw8XQARkeoYPXo08+bNc9vm7+/vodKIiLdTDZCIeAV/f3/i4uLcHhEREYDZPDVnzhzGjBlDYGAgnTp14sMPP3Q7fsuWLfzf//0fgYGBREVFceutt5KVleW2zxtvvEHPnj3x9/cnPj6eKVOmuH1+/PhxLr/8coKCgujatSuffvppw35pEWkwCkAi0iw88MADXHnllfzyyy+MHz+e6667ju3btwOQnZ3NqFGjiIiIYP369XzwwQcsW7bMLeDMmTOHyZMnc+utt7JlyxY+/fRTunTp4naNhx9+mGuuuYbNmzdz8cUXM378eE6ePNmo31NE6km9rCkvItKAJk6caNhsNiM4ONjt8dhjjxmGYRiAcdttt7kdM2jQIOP22283DMMwXnnlFSMiIsLIyspyff7FF18YVqvVSE1NNQzDMBISEoz77ruvwjIAxv333+96n5WVZQDGl19+WW/fU0Qaj/oAiYhXuPDCC5kzZ47btsjISNfrwYMHu302ePBgNm3aBMD27dvp27cvwcHBrs+HDh2Kw+Fg586dWCwWDh8+zPDhwystQ58+fVyvg4ODCQ0N5ejRo7X9SiLiQQpAIuIVgoODyzRJ1ZfAwMBq7efr6+v23mKx4HA4GqJIItLA1AdIRJqFtWvXlnnfo0cPAHr06MEvv/xCdna26/Pvv/8eq9VKt27dCAkJoUOHDixfvrxRyywinqMaIBHxCvn5+aSmprpt8/HxITo6GoAPPviAAQMGcN555/HOO+/w448/8vrrrwMwfvx4/vnPfzJx4kQeeughjh07xl/+8hduvPFGYmNjAXjooYe47bbbiImJYcyYMWRmZvL999/zl7/8pXG/qIg0CgUgEfEKS5YsIT4+3m1bt27d2LFjB2CO0FqwYAF33HEH8fHxvPfee5x55pkABAUF8dVXX3HnnXdyzjnnEBQUxJVXXslzzz3nOtfEiRPJy8vj3//+N3fffTfR0dFcddVVjfcFRaRRWQzDMDxdCBGRurBYLHzyySeMGzfO00URES+hPkAiIiLS4igAiYiISIujPkAi4vXUki8iNaUaIBEREWlxFIBERESkxVEAEhERkRZHAUhERERaHAUgERERaXEUgERERKTFUQASERGRFkcBSERERFqc/weWPqlW0L+IhQAAAABJRU5ErkJggg==\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "markdown", - "source": [ - "# Train the Network using ReLU instead of LIF Activation\n", - "\n", - "* To compare, we can also train and test the same network architecture on the same data, except now using ReLU as the activation function instead of LIF.\n", - "* Running this cell provides a training error and a test error of approximately 10% each.\n", - "\n", - "\n" ], - "metadata": { - "id": "E0ncALQA5T7N" - }, - "id": "E0ncALQA5T7N" - }, - { - "cell_type": "code", "source": [ "# **CREATE NEURAL NETWORK**\n", "net = Net([784, 500, 500],\"relu\")\n", @@ -1041,98 +1119,20 @@ "# **EVALUATE TEST ERROR**\n", "print('test error:', 100*(1.0 - net.predict(x_te).eq(y_te).float().mean().item()),'%')\n", " # performs predictions on the test data ('x_te') using the trained network ('net'), calculates the error rate, and prints it." - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 1000 - }, - "id": "Y40FBDxD5Pf5", - "outputId": "bc984b64-ad95-4474-d0de-cda05904950c" - }, - "id": "Y40FBDxD5Pf5", - "execution_count": null, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWMAAAF2CAYAAAC72fnJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAcxklEQVR4nO3df2xV9f3H8del0EvR9tZS+msUKL+d/FiGUAmKKBXoEkahEVA3QR0EV5iAqKtRoV81VXRqXBAyf9CZiU4zgekiGVRa5tZiqBJkmx1tipTRllHhXii2IP18/zC780KFc+Fe7qe3z0dyEu45r977PjvLK8dz77nXZYwxAgBEVLdIDwAAoIwBwAqUMQBYgDIGAAtQxgBgAcoYACxAGQOABShjALAAZQwAFqCMAcAClDEAWIAyBgALUMYAYAHKGJ3eqlWr5HK5VFNTo/nz5ysxMVEej0d33XWXTp48GZD93e9+pzFjxiguLk5JSUmaO3eu6uvrz3nONWvWaODAgYqLi9O4ceP0l7/8RZMmTdKkSZMu016hq6GMETVmz56t48ePq7i4WLNnz1ZJSYmKior825988kndeeedGjJkiJ577jktXbpUpaWlmjhxoo4dO+bPrV27VosXL1bfvn21evVq3XDDDcrLy9PBgwcjsFfoMgzQya1cudJIMnfffXfA+pkzZ5revXsbY4zZv3+/iYmJMU8++WRA5rPPPjPdu3f3r29razO9e/c2Y8eONadPn/bnSkpKjCRz4403hndn0GVxZoyosWjRooDHN9xwg5qbm+Xz+fTuu++qvb1ds2fP1pEjR/xLWlqahgwZou3bt0uSdu3apebmZi1YsEDdu3f3P9cdd9yhq6666rLuD7qW7heOAJ1Dv379Ah7/tzyPHj2qffv2yRijIUOGdPi3PXr0kCR98cUXkqTBgwcHbO/evbsGDBgQ4omB/6GMETViYmI6XG+MUXt7u1wulz744IMOc1deeWW4xwPOizJGlzBo0CAZY5SVlaWhQ4d+Z65///6SpJqaGt10003+9V9//bX279+vUaNGhX1WdE1cM0aXMGvWLMXExKioqEjmrN/gNcaoublZknTttdeqd+/eevnll/X111/7M2+88YaOHj16WWdG18KZMbqEQYMG6YknnlBhYaH279+vvLw8xcfHq66uThs3btTChQu1YsUKxcbGatWqVVqyZIluvvlmzZ49W/v371dJSYkGDRokl8sV6V1BlKKM0WX88pe/1NChQ/X888/7P3+cmZmpKVOm6Mc//rE/t3jxYhlj9Ktf/UorVqzQ6NGj9cc//lG/+MUv1LNnz0iNjyjnMmf/NxuAc7S3t6tPnz6aNWuWXn755UiPgyjENWPgLK2tredcV3799df15Zdfcjs0woYzY+AsZWVlWrZsmW699Vb17t1bn3zyiV599VVdffXVqqqqUmxsbKRHRBTimjFwlgEDBigzM1MvvviivvzySyUlJenOO+/UU089RREjbDgzBgALcM0YACxAGQOABay7Ztze3q5Dhw4pPj6eD9gD6NSMMTp+/LgyMjLUrdv5z32tK+NDhw4pMzMz0mMAQMjU19erb9++582E7TLFmjVrNGDAAPXs2VPZ2dn6+OOPHf1dfHx8uEYKG6/X63gB0PU46rVwfGP9W2+9ZWJjY81rr71m/v73v5sFCxaYxMRE09TUdMG/9Xq9RlKnWoIR6VlZWFgu/+L1ei/cDUE1iUPjxo0zBQUF/sdnzpwxGRkZpri4+IJ/SxmzsLBE2+KkjEN+meLUqVOqqqpSTk6Of123bt2Uk5OjioqKUL8cAESFkL+Bd+TIEZ05c0apqakB61NTU/X555+fk29ra1NbW5v/sc/nC/VIAGC9iH/OuLi4WB6Px7/wSQoAXVHIyzg5OVkxMTFqamoKWN/U1KS0tLRz8oWFhQGfNqivrw/1SABgvZCXcWxsrMaMGaPS0lL/uvb2dpWWlmr8+PHn5N1utxISEgIWAOhqwnLTx/LlyzVv3jxde+21GjdunF544QW1tLTorrvuCsfLAUCnF5YynjNnjv7zn//oscceU2Njo37wgx9oy5Yt57ypBwD4hnVfoenz+eTxeCI9BgCEjNfrveAl2Ih/mgIAQBkDgBUoYwCwAGUMABagjAHAApQxAFiAMgYAC1DGAGAByhgALEAZA4AFKGMAsABlDAAWoIwBwAKUMQBYgDIGAAtQxgBgAcoYACxAGQOABShjALAAZQwAFqCMAcAClDEAWIAyBgALUMYAYAHKGAAsQBkDgAUoYwCwAGUMABagjAHAApQxAFiAMgYAC1DGAGAByhgALEAZA4AFKGMAsABlDAAWoIwBwAKUMQBYgDIGAAtQxgBgAcoYACxAGQOABShjALAAZQwAFgh5Ga9atUoulytgGT58eKhfBgCiSvdwPOk111yjbdu2/e9FuoflZQAgaoSlJbt37660tLRwPDUARKWwXDPet2+fMjIyNHDgQN1xxx06cOBAOF4GAKKGyxhjQvmEH3zwgU6cOKFhw4apoaFBRUVF+ve//629e/cqPj7+nHxbW5va2tr8j30+nzIzM0M5EgBElNfrVUJCwvlDJsyOHj1qEhISzCuvvNLh9pUrVxpJLCwsLFG7eL3eC3Zl2D/alpiYqKFDh6qmpqbD7YWFhfJ6vf6lvr4+3CMBgHXCXsYnTpxQbW2t0tPTO9zudruVkJAQsABAVxPyMl6xYoXKy8u1f/9+/e1vf9PMmTMVExOj2267LdQvBQBRI+QfbTt48KBuu+02NTc3q0+fPrr++utVWVmpPn36hPqlACBqhPzTFJfK5/PJ4/FEegzgorlcLsfZW265xXF2woQJYcnefPPNjrOHDx92nB06dKjjrM/nc5ztjJx8moLvpgAAC1DGAGAByhgALEAZA4AFKGMAsABlDAAWoIwBwAKUMQBYgDIGAAtQxgBgAX6cDtbr0aOH42wwt+Bed911YZkhPz/fcfb73/++42y4fsosmG9ECOY7ZoL532H9+vWOs9GKM2MAsABlDAAWoIwBwAKUMQBYgDIGAAtQxgBgAcoYACxAGQOABShjALAAZQwAFuB2aITM8OHDHWcnT57sODtv3jzH2TFjxjjOBvMrzs3NzY6z27Ztc5x9+umnHWc/++wzx9khQ4Y4zq5du9ZxNhitra1hed5oxZkxAFiAMgYAC1DGAGAByhgALEAZA4AFKGMAsABlDAAWoIwBwAKUMQBYgDIGAAtwO3QXFMytyCtWrHCcvfHGGx1n3W634+yRI0ccZ99++23H2T/84Q+Os6WlpY6zR48edZwNl5SUlLA878mTJx1n//SnP4VlhmjFmTEAWIAyBgALUMYAYAHKGAAsQBkDgAUoYwCwAGUMABagjAHAApQxAFiAMgYAC3A7dJT46U9/6jj70ksvOc726tXLcbampsZx9pVXXnGcfe211xxng/kV584mmFvIH3jggbDMcOeddzrO+ny+sMwQrYI+M96xY4emT5+ujIwMuVwubdq0KWC7MUaPPfaY0tPTFRcXp5ycHO3bty9U8wJAVAq6jFtaWjR69GitWbOmw+2rV6/Wiy++qHXr1mnnzp264oorNHXqVLW2tl7ysAAQrYK+TJGbm6vc3NwOtxlj9MILL+iRRx7RjBkzJEmvv/66UlNTtWnTJs2dO/fSpgWAKBXSN/Dq6urU2NionJwc/zqPx6Ps7GxVVFSE8qUAIKqE9A28xsZGSVJqamrA+tTUVP+2s7W1tamtrc3/mIv+ALqiiH+0rbi4WB6Px79kZmZGeiQAuOxCWsZpaWmSpKampoD1TU1N/m1nKywslNfr9S/19fWhHAkAOoWQlnFWVpbS0tICfqLG5/Np586dGj9+fId/43a7lZCQELAAQFcT9DXjEydOBHy4v66uTrt371ZSUpL69eunpUuX6oknntCQIUOUlZWlRx99VBkZGcrLywvl3AAQVYIu4127dummm27yP16+fLkkad68eSopKdGDDz6olpYWLVy4UMeOHdP111+vLVu2qGfPnqGbGgCijMsYYyI9xLf5fD55PJ5Ij9HpXHfddY6zwfw69NatWx1nd+/e7Th76tQpx9loFswtzr/5zW8cZ3/yk584zu7YscNxdvr06Y6zJ06ccJyNdl6v94KXYCP+aQoAAGUMAFagjAHAApQxAFiAMgYAC1DGAGAByhgALEAZA4AFKGMAsABlDAAW4HZoIIK+67ckO7Jo0SLH2T179jjOTpo0yXHW6/U6zuJ/uB0aADoJyhgALEAZA4AFKGMAsABlDAAWoIwBwAKUMQBYgDIGAAtQxgBgAcoYACzQPdIDANHmwQcfdJy95557HGdbWlocZ+fMmeM4yy3OduDMGAAsQBkDgAUoYwCwAGUMABagjAHAApQxAFiAMgYAC1DGAGAByhgALEAZA4AFuB0acOCBBx5wnH388ccdZ0+dOuU4e+uttzrO/utf/3KchR04MwYAC1DGAGAByhgALEAZA4AFKGMAsABlDAAWoIwBwAKUMQBYgDIGAAtQxgBgAW6HRpf17LPPOs7ed999jrPB3OKcn5/vOPvnP//ZcRadT9Bnxjt27ND06dOVkZEhl8ulTZs2BWyfP3++XC5XwDJt2rRQzQsAUSnoMm5padHo0aO1Zs2a78xMmzZNDQ0N/uXNN9+8pCEBINoFfZkiNzdXubm558243W6lpaVd9FAA0NWE5Q28srIypaSkaNiwYbr33nvV3NwcjpcBgKgR8jfwpk2bplmzZikrK0u1tbV6+OGHlZubq4qKCsXExJyTb2trU1tbm/+xz+cL9UgAYL2Ql/HcuXP9/x45cqRGjRqlQYMGqaysTJMnTz4nX1xcrKKiolCPAQCdStg/Zzxw4EAlJyerpqamw+2FhYXyer3+pb6+PtwjAYB1wv4544MHD6q5uVnp6ekdbne73XK73eEeAwCsFnQZnzhxIuAst66uTrt371ZSUpKSkpJUVFSk/Px8paWlqba2Vg8++KAGDx6sqVOnhnRwAIgmQZfxrl27dNNNN/kfL1++XJI0b948rV27Vnv27NFvf/tbHTt2TBkZGZoyZYoef/xxzn4B4DxcxhgT6SG+zefzyePxRHoMdFLB3OJ8//33O86ePHnScTYvL89xduvWrY6z6Ly8Xq8SEhLOm+GLggDAApQxAFiAMgYAC1DGAGAByhgALEAZA4AFKGMAsABlDAAWoIwBwAKUMQBYgF+HhvVuu+02x9lgfsWZW5xhE86MAcAClDEAWIAyBgALUMYAYAHKGAAsQBkDgAUoYwCwAGUMABagjAHAApQxAFiA26ERMrGxsY6zwfwy86pVqxxnfT6f4+zcuXMdZ7nFGeHGmTEAWIAyBgALUMYAYAHKGAAsQBkDgAUoYwCwAGUMABagjAHAApQxAFiAMgYAC3A7NM4rNTXVcXbNmjWOszNnzryYcS7o7rvvdpzlFmfYhDNjALAAZQwAFqCMAcAClDEAWIAyBgALUMYAYAHKGAAsQBkDgAUoYwCwAGUMABbgduguaODAgY6zzz77rOPsjBkzHGdbWlocZ9etW+c4+9577znOAjYJ6sy4uLhYY8eOVXx8vFJSUpSXl6fq6uqATGtrqwoKCtS7d29deeWVys/PV1NTU0iHBoBoE1QZl5eXq6CgQJWVldq6datOnz6tKVOmBJzlLFu2TO+9957eeecdlZeX69ChQ5o1a1bIBweAaBLUZYotW7YEPC4pKVFKSoqqqqo0ceJEeb1evfrqq9qwYYNuvvlmSdL69et19dVXq7KyUtddd13oJgeAKHJJb+B5vV5JUlJSkiSpqqpKp0+fVk5Ojj8zfPhw9evXTxUVFZfyUgAQ1S76Dbz29nYtXbpUEyZM0IgRIyRJjY2Nio2NVWJiYkA2NTVVjY2NHT5PW1ub2tra/I99Pt/FjgQAndZFnxkXFBRo7969euutty5pgOLiYnk8Hv+SmZl5Sc8HAJ3RRZXx4sWL9f7772v79u3q27evf31aWppOnTqlY8eOBeSbmpqUlpbW4XMVFhbK6/X6l/r6+osZCQA6taDK2BijxYsXa+PGjfrwww+VlZUVsH3MmDHq0aOHSktL/euqq6t14MABjR8/vsPndLvdSkhICFgAoKsJ6ppxQUGBNmzYoM2bNys+Pt5/Hdjj8SguLk4ej0f33HOPli9frqSkJCUkJGjJkiUaP348n6QAgPMIqozXrl0rSZo0aVLA+vXr12v+/PmSpOeff17dunVTfn6+2traNHXqVL300kshGRYAopXLGGMiPcS3+Xw+eTyeSI/R6Vx11VWOs5WVlY6zgwcPdpwN5hbnZ555xnH28ccfd5wFbOT1ei94CZYvCgIAC1DGAGAByhgALEAZA4AFKGMAsABlDAAWoIwBwAKUMQBYgDIGAAtQxgBgAX4d2mLBfIPd008/7TgbrlucZ8+e7Th79k94AV0dZ8YAYAHKGAAsQBkDgAUoYwCwAGUMABagjAHAApQxAFiAMgYAC1DGAGAByhgALMDt0JdZr169HGfffvttx9lbbrnFcZZbnAH7cGYMABagjAHAApQxAFiAMgYAC1DGAGAByhgALEAZA4AFKGMAsABlDAAWoIwBwALcDn2ZlZSUOM4Gc4vztm3bHGd/9rOfOc7W19c7zgK4eJwZA4AFKGMAsABlDAAWoIwBwAKUMQBYgDIGAAtQxgBgAcoYACxAGQOABShjALAAt0NfZnFxcY6z69atc5xdsmSJ42x7e7vjLIDLI6gz4+LiYo0dO1bx8fFKSUlRXl6eqqurAzKTJk2Sy+UKWBYtWhTSoQEg2gRVxuXl5SooKFBlZaW2bt2q06dPa8qUKWppaQnILViwQA0NDf5l9erVIR0aAKJNUJcptmzZEvC4pKREKSkpqqqq0sSJE/3re/XqpbS0tNBMCABdwCW9gef1eiVJSUlJAevfeOMNJScna8SIESosLNTJkycv5WUAIOpd9Bt47e3tWrp0qSZMmKARI0b4199+++3q37+/MjIytGfPHj300EOqrq7Wu+++2+HztLW1qa2tzf/Y5/Nd7EgA0GlddBkXFBRo7969+uijjwLWL1y40P/vkSNHKj09XZMnT1Ztba0GDRp0zvMUFxerqKjoYscAgKhwUZcpFi9erPfff1/bt29X3759z5vNzs6WJNXU1HS4vbCwUF6v17/wyxIAuqKgzoyNMVqyZIk2btyosrIyZWVlXfBvdu/eLUlKT0/vcLvb7Zbb7Q5mDACIOkGVcUFBgTZs2KDNmzcrPj5ejY2NkiSPx6O4uDjV1tZqw4YN+tGPfqTevXtrz549WrZsmSZOnKhRo0aFZQcAIBoEVcZr166V9M2NHd+2fv16zZ8/X7Gxsdq2bZteeOEFtbS0KDMzU/n5+XrkkUdCNjAARCOXMcZEeohv8/l88ng8kR4DAELG6/UqISHhvBm+KAgALEAZA4AFKGMAsABlDAAWoIwBwAKUMQBYgDIGAAtQxgBgAcoYACxAGQOABShjALAAZQwAFqCMAcAClDEAWIAyBgALUMYAYAHKGAAsQBkDgAUoYwCwAGUMABawrowt+31UALhkTnrNujI+fvx4pEcAgJBy0msuY9mpaHt7uw4dOqT4+Hi5XC7/ep/Pp8zMTNXX11/wJ687G/atc2LfOqfLuW/GGB0/flwZGRnq1u38577dwzrJRejWrZv69u37ndsTEhKi7v8c/8W+dU7sW+d0ufbN4/E4yll3mQIAuiLKGAAs0GnK2O12a+XKlXK73ZEeJeTYt86JfeucbN03697AA4CuqNOcGQNANKOMAcAClDEAWIAyBgALdIoyXrNmjQYMGKCePXsqOztbH3/8caRHColVq1bJ5XIFLMOHD4/0WBdlx44dmj59ujIyMuRyubRp06aA7cYYPfbYY0pPT1dcXJxycnK0b9++yAwbpAvt2/z58885jtOmTYvMsEEoLi7W2LFjFR8fr5SUFOXl5am6ujog09raqoKCAvXu3VtXXnml8vPz1dTUFKGJnXOyb5MmTTrnuC1atChCE3eCMv7973+v5cuXa+XKlfrkk080evRoTZ06VYcPH470aCFxzTXXqKGhwb989NFHkR7porS0tGj06NFas2ZNh9tXr16tF198UevWrdPOnTt1xRVXaOrUqWptbb3MkwbvQvsmSdOmTQs4jm+++eZlnPDilJeXq6CgQJWVldq6datOnz6tKVOmqKWlxZ9ZtmyZ3nvvPb3zzjsqLy/XoUOHNGvWrAhO7YyTfZOkBQsWBBy31atXR2hiScZy48aNMwUFBf7HZ86cMRkZGaa4uDiCU4XGypUrzejRoyM9RshJMhs3bvQ/bm9vN2lpaeaZZ57xrzt27Jhxu93mzTffjMCEF+/sfTPGmHnz5pkZM2ZEZJ5QOnz4sJFkysvLjTHfHKMePXqYd955x5/55z//aSSZioqKSI15Uc7eN2OMufHGG819990XuaHOYvWZ8alTp1RVVaWcnBz/um7duiknJ0cVFRURnCx09u3bp4yMDA0cOFB33HGHDhw4EOmRQq6urk6NjY0Bx9Hj8Sg7OztqjmNZWZlSUlI0bNgw3XvvvWpubo70SEHzer2SpKSkJElSVVWVTp8+HXDchg8frn79+nW643b2vv3XG2+8oeTkZI0YMUKFhYU6efJkJMaTZOEXBX3bkSNHdObMGaWmpgasT01N1eeffx6hqUInOztbJSUlGjZsmBoaGlRUVKQbbrhBe/fuVXx8fKTHC5nGxkZJ6vA4/ndbZzZt2jTNmjVLWVlZqq2t1cMPP6zc3FxVVFQoJiYm0uM50t7erqVLl2rChAkaMWKEpG+OW2xsrBITEwOyne24dbRvknT77berf//+ysjI0J49e/TQQw+purpa7777bkTmtLqMo11ubq7/36NGjVJ2drb69++vt99+W/fcc08EJ0Mw5s6d6//3yJEjNWrUKA0aNEhlZWWaPHlyBCdzrqCgQHv37u2071mcz3ft28KFC/3/HjlypNLT0zV58mTV1tZq0KBBl3tMu9/AS05OVkxMzDnv3jY1NSktLS1CU4VPYmKihg4dqpqamkiPElL/PVZd5TgOHDhQycnJneY4Ll68WO+//762b98e8PW1aWlpOnXqlI4dOxaQ70zH7bv2rSPZ2dmSFLHjZnUZx8bGasyYMSotLfWva29vV2lpqcaPHx/BycLjxIkTqq2tVXp6eqRHCamsrCylpaUFHEefz6edO3dG5XE8ePCgmpubrT+OxhgtXrxYGzdu1IcffqisrKyA7WPGjFGPHj0Cjlt1dbUOHDhg/XG70L51ZPfu3ZIUueMW6XcQL+Stt94ybrfblJSUmH/84x9m4cKFJjEx0TQ2NkZ6tEt2//33m7KyMlNXV2f++te/mpycHJOcnGwOHz4c6dGCdvz4cfPpp5+aTz/91Egyzz33nPn000/NF198YYwx5qmnnjKJiYlm8+bNZs+ePWbGjBkmKyvLfPXVVxGe/MLOt2/Hjx83K1asMBUVFaaurs5s27bN/PCHPzRDhgwxra2tkR79vO69917j8XhMWVmZaWho8C8nT570ZxYtWmT69etnPvzwQ7Nr1y4zfvx4M378+AhO7cyF9q2mpsb83//9n9m1a5epq6szmzdvNgMHDjQTJ06M2MzWl7Exxvz61782/fr1M7GxsWbcuHGmsrIy0iOFxJw5c0x6erqJjY013/ve98ycOXNMTU1NpMe6KNu3bzeSzlnmzZtnjPnm422PPvqoSU1NNW6320yePNlUV1dHdmiHzrdvJ0+eNFOmTDF9+vQxPXr0MP379zcLFizoFCcLHe2TJLN+/Xp/5quvvjI///nPzVVXXWV69eplZs6caRoaGiI3tEMX2rcDBw6YiRMnmqSkJON2u83gwYPNAw88YLxeb8Rm5is0AcACVl8zBoCugjIGAAtQxgBgAcoYACxAGQOABShjALAAZQwAFqCMAcAClDEAWIAyBgALUMYAYAHKGAAs8P/1CdxPSmKCEAAAAABJRU5ErkJggg==\n" - }, - "metadata": {} - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Training layer 0 ...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Training LeakyLayer: 100%|██████████| 1000/1000 [01:00<00:00, 16.45it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Training layer 1 ...\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Training LeakyLayer: 100%|██████████| 1000/1000 [00:40<00:00, 24.70it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "train error: 10.252004861831665 %\n", - "test error: 10.019999742507935 %\n" - ] - } ] }, { "cell_type": "markdown", + "id": "Oa2jm154zvGH", + "metadata": { + "id": "Oa2jm154zvGH" + }, "source": [ "# Comparison to ANNs and SNNs using Backpropagation\n", "As shown in [this Keras example](https://www.tensorflow.org/datasets/keras_example), a standard artificial neural network using backpropagation with similar architecure and hyperparameters attains a test set error of about 2.50%.\n", "\n", "As shown in [the snnTorch Tutorial 5 documentation](https://snntorch.readthedocs.io/en/latest/tutorials/tutorial_5.html), a spiking neural network using backpropagation with the same architecture and similar set hyperparameters attains a test set error of about 6.13%." - ], - "metadata": { - "id": "Oa2jm154zvGH" - }, - "id": "Oa2jm154zvGH" + ] }, { "cell_type": "markdown", @@ -1149,52 +1149,34 @@ }, { "cell_type": "markdown", + "id": "0aIXWPOHkiD1", + "metadata": { + "id": "0aIXWPOHkiD1" + }, "source": [ "# References\n", "> [Geoffrey Hinton. The Forward-Forward Algorithm: Some Preliminary\n", "Investigations. 2022. arXiv: 2212.13345 [cs.LG].](https://arxiv.org/abs/2212.13345) \n", "\n", "> [Mohammad Pezeshki. pytorch_forward_forward. Github Repo January 2023.](https://github.com/mpezeshki/pytorch_forward_forward) " - ], - "metadata": { - "id": "0aIXWPOHkiD1" - }, - "id": "0aIXWPOHkiD1" - }, - { - "cell_type": "markdown", - "source": [ - "# Group Work Statement\n", - "\n", - "We contributed approximately equally to the completion of the project.\n", - "\n", - "Ethan worked on implementing the code, algorithm theory section, and conclusion section for the Forward-Forward algorithm and its testing.\n", - "\n", - "Abhinandan worked on revising and documenting the code, as well as wrote the text for all of the other sections.\n", - "\n", - "We both revised the code and text to make them clear and concise." - ], - "metadata": { - "id": "NQGromWnkSHk" - }, - "id": "NQGromWnkSHk" + ] }, { "cell_type": "code", - "source": [], + "execution_count": null, + "id": "_HxW09hNgBO-", "metadata": { "id": "_HxW09hNgBO-" }, - "id": "_HxW09hNgBO-", - "execution_count": null, - "outputs": [] + "outputs": [], + "source": [] } ], "metadata": { "accelerator": "GPU", "colab": { - "provenance": [], "gpuType": "T4", + "provenance": [], "toc_visible": true }, "kernelspec": { @@ -1221,4 +1203,4 @@ }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +}