diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 000000000..dfe077042 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,2 @@ +# Auto detect text files and perform LF normalization +* text=auto diff --git a/.ipynb_checkpoints/Python Numpy Tutorial-checkpoint.ipynb b/.ipynb_checkpoints/Python Numpy Tutorial-checkpoint.ipynb new file mode 100644 index 000000000..f01ebf660 --- /dev/null +++ b/.ipynb_checkpoints/Python Numpy Tutorial-checkpoint.ipynb @@ -0,0 +1,498 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'python' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mpython\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mversion\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mNameError\u001b[0m: name 'python' is not defined" + ] + } + ], + "source": [ + "python --version" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "2.5 3.5 5.0 6.25\n" + ] + } + ], + "source": [ + "y = 2.5\n", + "print(type(y)) # Prints \"\"\n", + "print(y, y + 1, y * 2, y ** 2) # Prints \"2.5 3.5 5.0 6.25\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5 3.5 5.0 6.25\n" + ] + } + ], + "source": [ + "print(y,y + 1,y * 2, y ** 2) " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5 3\n" + ] + } + ], + "source": [ + "a = 5\n", + "A = 3\n", + "print(a, A)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello\n", + "HELLO\n", + " hello\n", + " hello \n", + "he(ell)(ell)o\n", + "world\n" + ] + } + ], + "source": [ + "s = \"hello\"\n", + "print(s.capitalize()) # Capitalize a string; prints \"Hello\"\n", + "print(s.upper()) # Convert a string to uppercase; prints \"HELLO\"\n", + "print(s.rjust(7)) # Right-justify a string, padding with spaces; prints \" hello\"\n", + "print(s.center(7)) # Center a string, padding with spaces; prints \" hello \"\n", + "print(s.replace('l', '(ell)')) # Replace all instances of one substring with another;\n", + " # prints \"he(ell)(ell)o\"\n", + "print(' world '.strip()) # Strip leading and trailing whitespace; prints \"world\"" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3, 1, 2] 2\n", + "2\n", + "1\n" + ] + } + ], + "source": [ + "xs = [3, 1, 2] # Create a list\n", + "print(xs, xs[2]) # Prints \"[3, 1, 2] 2\"\n", + "print(xs[-1]) \n", + "print(xs[-2])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'dog' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0md\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;34m'cat'\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m'cute'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdog\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m'furry'\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mNameError\u001b[0m: name 'dog' is not defined" + ] + } + ], + "source": [ + "d = {'cat': 'cute', dog: 'furry'} \n", + "print(d[\"cat\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cute\n", + "True\n", + "wet\n", + "N\n", + "wet\n", + "N/A\n" + ] + } + ], + "source": [ + "d = {'cat': 'cute', 'dog': 'furry'} # Create a new dictionary with some data\n", + "print(d['cat']) # Get an entry from a dictionary; prints \"cute\"\n", + "print('cat' in d) # Check if a dictionary has a given key; prints \"True\"\n", + "d['fish'] = 'wet' # Set an entry in a dictionary\n", + "print(d['fish']) # Prints \"wet\"\n", + "# print(d['monkey']) # KeyError: 'monkey' not a key of d\n", + "print(d.get('monkey', 'N')) # Get an element with a default; prints \"N/A\"\n", + "print(d.get('fish', 'N/A')) # Get an element with a default; prints \"wet\"\n", + "del d['fish'] # Remove an element from a dictionary\n", + "print(d.get('fish', 'N/A')) # \"fish\" is no longer a key; prints \"N/A\"" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#1: fish\n", + "#2: dog\n", + "#3: cat\n" + ] + } + ], + "source": [ + "animals = {'cat', 'dog', 'fish'}\n", + "for idx, animal in enumerate(animals):\n", + " print('#%d: %s' % (idx + 1, animal))\n", + "# Prints \"#1: fish\", \"#2: dog\", \"#3: cat\"" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{0, 1, 2, 3, 4, 5}\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "nums = {int(sqrt(x)) for x in range(30)}\n", + "print(nums) # Prints \"{0, 1, 2, 3, 4, 5}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0.00911691 -0.35159179]\n", + " [-0.91385663 -0.79634708]]\n", + "[[0.75842822 0.74655272]\n", + " [0.31028694 0.84383828]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "print(np.random.randn(2,2))\n", + "# e = np.random.random((2,2)) # Create an array filled with random values\n", + "# print(e)\n", + "print(np.random.random((2,2)))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2]\n", + " [3 4]]\n", + "[[1 3]\n", + " [2 4]]\n", + "[1 2 3]\n", + "[1 2 3]\n", + "[[1 2 3]]\n", + "[[1]\n", + " [2]\n", + " [3]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "x = np.array([[1,2], [3,4]])\n", + "print(x) # Prints \"[[1 2]\n", + " # [3 4]]\"\n", + "print(x.T) # Prints \"[[1 3]\n", + " # [2 4]]\"\n", + "\n", + "# Note that taking the transpose of a rank 1 array does nothing:\n", + "v = np.array([1,2,3])\n", + "print(v) # Prints \"[1 2 3]\"\n", + "print(v.T) # Prints \"[1 2 3]\"\n", + "v = np.array([[1,2,3]])\n", + "print(v) # Prints \"[[1 2 3]]\"\n", + "print(v.T) # Prints \"[[1]\n", + " # [2]\n", + " # [3]]\"" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1],\n", + " [2],\n", + " [3]])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v = np.array([1,2,3]) # v has shape (3,)\n", + "v.reshape((3,1))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0 1]\n", + " [1 0]\n", + " [2 0]]\n", + "[[0. 1.41421356 2.23606798]\n", + " [1.41421356 0. 1. ]\n", + " [2.23606798 1. 0. ]]\n", + "[1.41421356 2.23606798 1. ]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from scipy.spatial.distance import pdist, squareform\n", + "\n", + "# Create the following array where each row is a point in 2D space:\n", + "# [[0 1]\n", + "# [1 0]\n", + "# [2 0]]\n", + "x = np.array([[0, 1], [1, 0], [2, 0]])\n", + "print(x)\n", + "\n", + "# Compute the Euclidean distance between all rows of x.\n", + "# d[i, j] is the Euclidean distance between x[i, :] and x[j, :],\n", + "# and d is the following array:\n", + "# [[ 0. 1.41421356 2.23606798]\n", + "# [ 1.41421356 0. 1. ]\n", + "# [ 2.23606798 1. 0. ]]\n", + "d = squareform(pdist(x, 'euclidean'))\n", + "print(d)\n", + "d = (pdist(x, 'euclidean'))\n", + "print(d)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(95,)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Compute the x and y coordinates for points on a sine curve\n", + "x = np.arange(0, 3 * np.pi, 0.1)\n", + "print(x.shape)\n", + "y = np.sin(x)\n", + "\n", + "# Plot the points using matplotlib\n", + "plt.plot(x, y)\n", + "plt.show() # You must call plt.show() to make graphics appear." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Compute the x and y coordinates for points on sine and cosine curves\n", + "x = np.arange(0, 3 * np.pi, 0.1)\n", + "y_sin = np.sin(x)\n", + "y_cos = np.cos(x)\n", + "\n", + "# Plot the points using matplotlib\n", + "plt.plot(x, y_sin)\n", + "plt.plot(x, y_cos)\n", + "plt.xlabel('x axis label')\n", + "plt.ylabel('y axis label')\n", + "plt.title('Sine and Cosine')\n", + "plt.legend(['Sine', 'Cosine'])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Set up a subplot grid that has height 2 and width 1,\n", + "# and set the first such subplot as active.\n", + "plt.subplot(2, 1, 1)\n", + "\n", + "# Make the first plot\n", + "plt.plot(x, y_sin)\n", + "plt.title('Sine')\n", + "\n", + "# Set the second subplot as active, and make the second plot.\n", + "plt.subplot(2, 1, 2)\n", + "plt.plot(x, y_cos)\n", + "plt.title('Cosine')\n", + "\n", + "# Show the figure.\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/.ipynb_checkpoints/pytorch_tutorial-checkpoint.ipynb b/.ipynb_checkpoints/pytorch_tutorial-checkpoint.ipynb new file mode 100644 index 000000000..2b4787440 --- /dev/null +++ b/.ipynb_checkpoints/pytorch_tutorial-checkpoint.ipynb @@ -0,0 +1,922 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Training an MNIST Classifier\n", + "=====\n", + "## Custom Dataset, Model Checkpointing, and Fine-tune" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import torch.nn.functional as F\n", + "import torchvision\n", + "import torchvision.transforms as transforms\n", + "from torch.utils.data import Dataset, DataLoader\n", + "import glob\n", + "import os.path as osp\n", + "import numpy as np\n", + "from PIL import Image" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Custom Dataset\n", + "PyTorch has many built-in datasets such as MNIST and CIFAR. In this tutorial, we demonstrate how to write your own dataset by implementing a custom MNIST dataset class. Use [this link](https://github.com/myleott/mnist_png/blob/master/mnist_png.tar.gz?raw=true) to download the mnist png dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class MNIST(Dataset):\n", + " \"\"\"\n", + " A customized data loader for MNIST.\n", + " \"\"\"\n", + " def __init__(self,\n", + " root,\n", + " transform=None,\n", + " preload=False):\n", + " \"\"\" Intialize the MNIST dataset\n", + " \n", + " Args:\n", + " - root: root directory of the dataset\n", + " - tranform: a custom tranform function\n", + " - preload: if preload the dataset into memory\n", + " \"\"\"\n", + " self.images = None\n", + " self.labels = None\n", + " self.filenames = []\n", + " self.root = root\n", + " self.transform = transform\n", + "\n", + " # read filenames\n", + " for i in range(10):\n", + " filenames = glob.glob(osp.join(root, str(i), '*.png'))\n", + " for fn in filenames:\n", + " self.filenames.append((fn, i)) # (filename, label) pair\n", + " \n", + " # if preload dataset into memory\n", + " if preload:\n", + " self._preload()\n", + " \n", + " self.len = len(self.filenames)\n", + " \n", + " def _preload(self):\n", + " \"\"\"\n", + " Preload dataset to memory\n", + " \"\"\"\n", + " self.labels = []\n", + " self.images = []\n", + " for image_fn, label in self.filenames: \n", + " # load images\n", + " image = Image.open(image_fn)\n", + " # avoid too many opened files bug\n", + " self.images.append(image.copy())\n", + " image.close()\n", + " self.labels.append(label)\n", + "\n", + " def __getitem__(self, index):\n", + " \"\"\" Get a sample from the dataset\n", + " \"\"\"\n", + " if self.images is not None:\n", + " # If dataset is preloaded\n", + " image = self.images[index]\n", + " label = self.labels[index]\n", + " else:\n", + " # If on-demand data loading\n", + " image_fn, label = self.filenames[index]\n", + " image = Image.open(image_fn)\n", + " \n", + " # May use transform function to transform samples\n", + " # e.g., random crop, whitening\n", + " if self.transform is not None:\n", + " image = self.transform(image)\n", + " # return image and label\n", + " return image, label\n", + "\n", + " def __len__(self):\n", + " \"\"\"\n", + " Total number of samples in the dataset\n", + " \"\"\"\n", + " return self.len" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Create the MNIST dataset. \n", + "# transforms.ToTensor() automatically converts PIL images to\n", + "# torch tensors with range [0, 1]\n", + "trainset = MNIST(\n", + " root='mnist_png/training',\n", + " preload=True, transform=transforms.ToTensor(),\n", + ")\n", + "# Use the torch dataloader to iterate through the dataset\n", + "trainset_loader = DataLoader(trainset, batch_size=64, shuffle=True, num_workers=0) #127:num_workers=1，修改为num_workers=0\n", + "\n", + "# load the testset\n", + "testset = MNIST(\n", + " root='mnist_png/testing',\n", + " preload=True, transform=transforms.ToTensor(),\n", + ")\n", + "# Use the torch dataloader to iterate through the dataset\n", + "testset_loader = DataLoader(testset, batch_size=1000, shuffle=False, num_workers=0)#127:num_workers=1，修改为num_workers=0" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "60000\n", + "10000\n" + ] + } + ], + "source": [ + "print(len(trainset))\n", + "print(len(testset))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor(9) tensor(4) tensor(8) tensor(2) tensor(1) tensor(1) tensor(7) tensor(6) tensor(8) tensor(7) tensor(3) tensor(3) tensor(9) tensor(8) tensor(0) tensor(9)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQUAAAD8CAYAAAB+fLH0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvIxREBQAAIABJREFUeJzsXXdYFUf7fa+AiIAFRbEQTaLYK/aYWKMxsRcSYzSfJRg1dqNRY+xRY7B/xkISo1GxxBK7RrESFSsICgqIiEiz0MvOnt8fuPu7Cxe8ZRbykT3Pc5577+7emd2d2bNT3nlfHQDSoEGDBgklivoENGjQ8M+CJgoaNGhQQBMFDRo0KKCJggYNGhTQREGDBg0KaKKgQYMGBVQTBZ1O94FOpwvR6XQPdDrdN2rlo0GDBr7QqWGnoNPprIgolIjeJ6LHRORPRIMBBHPPTIMGDVyhVkuhFRE9ABAOIIuIfIioj0p5adCggSOsVUq3GhFF6f1+TESt8ztYp9NpZpUaNKiPBADOrztILVHQGdimePB1Op0nEXmqlL8GDRryItKYg9QShcdE5Kr3uzoRPdE/AMAmItpEpLUUNGj4J0GtMQV/Iqqt0+ne1Ol0JYnoEyL6U6W8NGjQwBGqiAIAgYi+IqITRHSXiHYDCFIjLw0a/m24efMmiaJIDRs2VCcDAEVOyhlv0PiKU6dORXR0NDIzM+Ht7Q0bGxuL05w9ezZiYmIgCAIEQQBjDIIgIDMzE2vWrCnya1abw4YNw507d8AYQ4cOHYr8fMyhk5MTgoOD8fHHH5ubxjWjnseiFgRNFJS0sbGBKIq4ffs2tmzZgszMTOzevduiNL/55hukpaXJgqAvChKXLFkCNzc3Va+tZcuWSEpKQosWLQr1ng4bNgzp6enyta5atarIy9lU6nQ6TJo0CYwxS9L5d4hCmTJl8N///hcSRFHEhg0bYGtry7VQjh07hmPHjnFPNzd/++03DB8+HEQER0dHJCYmIj4+Hs7OzmanmVsADIkCYwwHDx5EpUqVVLu2RYsWQRRFLFiwQNV7mJvz589XXGu9evUKNX8erFWrFhhjuHPnjiXpFH9RGDVqFG7fvg3GWB7OmjWLa6FI6ZYrV061gh86dCgyMjLk39bW1li+fDlEUcTkyZMtOvfcojBp0iQkJibmEYmoqCg0adJElesrbFHQ6XTQ6XR5rt/UdDZt2qR46YiiCC8vLyxdulRmhw4dMHDgQDg5OSno4OBg8XXUqFED9+7dA2MMnTt3tiSt4isKJUqUQN++feUH9dy5c5g6dSpq1qyJixcvgjGG9evXc6tcHTp0kPNq3ry5apU4PDwcv/32m2Jb165dIYqiRV0ILy8vvHz5Etu3b8/zwEuVDYB8jQMHDlTl+gpbFGrXrq0QvH379uG9994zOZ1NmzYZfPEYw7CwMItaeUQ53R/GGH799VeULFnSkrSKpyiUKFECCxYskG/64sWLFU16qQB5iELJkiUxcuRIpKenIy0tDdnZ2YiJiUGjRo24V+D69esjMzMTHTt2VGyvV68eRFHEypUrLUrfxcXFYIVycnLC2LFjFW/T27dvc78+ov8Xhf/+979cBk9fx99++00WhZiYGLi7u5uVzvz585GUlITLly/j8uXLCA8PhyAIePLkiVHC8Pbbb1t0HX///TfS09NRp04dS+9J8RSFuXPnyjd79OjRKFOmjGJ/SkoKF1EoV64cVq9eLef14Ycf4vLly2CM4fr16yhdujTXCvz5559DFEW4uLjI25o0aYLg4GCkpaXho48+UvUBkiq6VNmrVKnCPY/27dvLze833nhD1eshIjx9+lQWhV9++cXsdOzs7BSCUq1aNXTo0AG1atVCp06d0KlTJwwYMACdOnVCjx49FIJw6dIli+5l/fr18fz5cyQlJfG4J8VLFEqUKIG5c+ciOzsbjDEEBQUp9ltZWeHHH3+UK4El02zdu3dHcHCwXLDr169H/fr18fLlSzDGcOvWLS59RX0uXLhQFoXOnTtjxIgRSE9PR3p6OiZOnKj6A+Tm5oa4uDjFmAPvPPr161dootChQwf5Wnx9fVG2bFnV7yERwcHBQa43ly9ftvjlsWHDBjDGsHr1ah7nV7xEoWHDhvLNvnr1qqKZXbVqVYwYMULev2bNGpQvX97km2ZjY4MtW7YgNTVVTktq6lavXh1RUVFgjOH8+fPcK5MkCkFBQfKDI4oiNm3aVCiVmYgQGRmpqiiUL18eoiji+fPnqFq1qmrX0aFDBwDqj5EY4s6dO+V8f/jhBy7pAUC3bt14nF/xEoWffvoJjDFkZGSgXbt2aNWqFdauXYvMzExFc+3DDz8064blnsW4f/8+RowYgaFDh2Lo0KE4ePAgHjx4oDgmJiZG8Xv27NkWFdoHH3yAEydOQBAEeHl5QRAEpKeno3v37oVSoSVRSEpKMvs+FsTCGGjUby1euHChUO4bEaFTp05ITk4GYwzZ2dno27evxWlWrlwZjDFs375dsb1MmTKYN28eAgICZA4ePNiYNIuXKMybN++1Azo+Pj6wtrY2qwD03yzm8tChQxZVgiZNmiA9PR39+vUDEWH69OkQRRFhYWGqV+rBgwfLBk4RERHc069UqRJCQ0NVFYX69esjLCxMFoUaNWqoft8kSi+M7OxsLFq0iEua+YnCpUuX8tS9rKwsY2Y5ipcoVK9eHb6+vvJNOHr0qOLNfePGDYv6b9HR0QU+8Hfv3sX58+eRlZWlaB56eHjItKQC2NjY4ODBgxBFUd4mNbctNV4iIpQuXRqurq4yc++/efOm3HWIiopSHOvq6gpHR0eL8q9Zs6bcJVJLFJYsWSKXDXIqVqFRyjc4OJhbmoZEoXz58oiNjcUnn3wiU5qGN8LwrHiJgvTglCtXDuXKlYO1tTUyMjLAGENsbCyaNWtmUQFUr14dc+fOhbe3N7y9vdGzZ080bdpUppOTE4gIz549kysAzxmIb7/9FqIoYvPmzfI2a2tr+Pv7QxRFi69v27ZtCgMeLy8v/PjjjzL1pyQNWT1aOsYgiUJcXJwqBmA1a9ZEVFSUfL7h4eHc88iPjRs3BmMMO3bsMCi45tKQKPz+++/4/vvv5d9t27ZFfHz8v1cU9Ons7Cw/nCNHjiyUwu/Tp488+7F7926UKFGCW9rSAKP+lCQR4fTp0xBFET179jQ7bSBv1yj3ttcdw0sUYmJiuJeLTqdDYGCgQtDmzJlTKHWib9++CA8PB2MM9evX55p2iRIl8Mcff+DmzZvy7MmSJUvk2aiWLVvC19cXUVFRGDZsmDH1sXiLgjTGsGzZMlhZWRVKBSAiBAQEqNJSMCQK1tbWuHLlChITE/OIhSl8XSvA0G+1WgpqiYL+efv4+BRKXbC3t8eVK1fAGMPUqVNVqYcjR44EYwxXrlxBo0aN8Omnn8LPzw+bN29GYmIiHjx4gN69exubXvEVhTFjxiA7OxsZGRlo2rRpoVQAifrWlGqLgjSvb+lAo6mi8ODBA8W21NRUS5brguj/RSE7O5vrdGe5cuUUY01SK07temBtba0Y8KtYsaIq+ZQtWxaHDh2S84mMjIQoirLtQs2aNU1Jr3iKgpWVFY4ePQrGciwa1S783HRwcMDx48cRFhaG1q1bc0v37NmzEEURjRs3xurVqxETE8PNeGngwIEIDQ3NVwQSEhIQGRmJiIgITJkyBbVr18bAgQMxcOBALFiwADNnzrT4+mrWrAkgZ0HR3Llzud03aX1DbqpdDypWrKiYvla7zi1evBgrV66Er68v5s+fjzfffNOcdRDFUxT0TY/VLvjCZJcuXZCSkoLU1FSIoggAiIyMxIQJE7ik7+bmhkmTJuH69esKUZg0aZKqi7wkqtV9yC0KaWlp3KYE82PFihVx7do1uR5+/fXXRV5/jGTxEoUaNWrIo6wvXrxQfS2ARr50dHTEqFGjCmXNg9qU1sAwxjBjxowiPx8TWLxEoUqVKjh8+DAYs2xxi0aNlrB+/frytHRsbKzF9huFzOIlCho1/lO4a9cuZGRkqOpwRyUaJQqqxJI0FVrcBw0aCgXXAbR43UFaKHoNGjQooImCBg0aFNBEQYMGDQpooqBBgwYFNFHQoEGDAsVGFMaPH0/Pnj2jQ4cOUcWKFYv6dP4RsLW1paVLlxIASkpKogULFtCCBQvozp079OTJE1qwYAHZ2tpSiRLFphoUOlavXk0BAQFUpUoVWrduHa1bt4569+5NVapUKepTMx9FbaNgqZ1C69atcfPmTYVfw/bt2xf1fPA/gvqLtwri1q1bMWLECDg6OnJdDl6cWbZsWWzfvl326XH16lXFPY2KisIHH3zAJS8bGxsMHjwY3t7emDFjBkRRREREhDnpF3/jpTZt2uDZs2cQRRH379+Hp6cnVq5ciQYNGhR5pTGWffr0gZeXF4YMGQIvLy/Zpt7f399iazlJFARBQHx8vMz09PR8BeKXX35Rzalq69atERISgqVLl6J79+5o27Ytt7SrVauGt956C56enli1ahVWrVqFgwcPYtWqVRZ7rcpNOzs7nDt3Tr63Q4YMQWxsLIYMGQJnZ2ds3boVWVlZiI2NtThEXadOnRASEoLnz59jxYoVWLJkCVq2bIk6derIjn9MYPEXhUePHkEURdy8eROVK1fmVuifffYZAGDHjh3w8vJC/fr1ZbdkK1asgJeXFw4dOgRRFPMEbzGV06ZNy3f1oiWh4ohyvPIkJSUhISEB9vb28vZu3bphzJgxGDNmjEFhuHPnDqpVq8btfkoRvbKysiCKIrZv3w4fHx+kp6fj888/tyjtt99+G8uXL0diYmK+Qufn58ftWogI48aNk5cvDxkyBESEEydOKI6ZOnUqgJxFbbljkxhDR0dH9OnTB6IoIj09Ha1ateJx7sVfFERRRHR0NFdBIMoJs6ZfqaQKkPs7Y8xYL7r50tbWFv369YOPjw+6du2KNm3a4PHjxxAEgUtAlnfffReMMRw+fNjg/pEjR+LChQt4+vSp4rrWrVvH7X5KIf4CAgLQu3dvODg4oE+fPmCMKdzPmcPFixe/tnu0bt06jBo1CqNGjYKdnZ3F13PhwgWIoojQ0FA5/oeht/asWbPAGMPGjRtNSr9BgwY4e/asXN9WrFiRb92ZOnUqWrZsaWza/w5RyB17UZ/NmjUzK8Rb7nBgBYkCrwdHoqOjIwRBwE8//cQlPRsbGwwdOvS1sQ/69euniih069YNWVlZePHiBd599115e8mSJREfH49bt25ZlP7z58/lcxYEAdOmTcOJEycU2/XDAOR+o5vK/v37y0vAX9eaqlWrFlJSUiCKIgYNGmRU+qVKlcKxY8fAWE4U8P/85z/5eqWuW7cuGGNYsmSJsef/7xCFXr16GXwQ5s2bh4yMDLz11lsmpenu7p7nwc9PFNRw8vLll18iJSWlUJeGv/3229izZ498XQkJCWYFYjXEmJgYpKam5glmUqNGDTniliX+J/XPOysrCyNHjswz6KdPS8Ov7dq1C4wxHDhwwKjjJ02aBMaMD0gzffp0xMfHG/32v3jxIm7fvm1sC+jfIQq5g2727dtXno04duyYRRXAzc0NU6ZMkeno6IgVK1ZAFEWcP3+e+7LZnj17gjGGU6dOoW3btjLd3Ny45qPPgQMHIiEhQfHgzJ8/n0vaI0eOBAAEBgYqttvY2MDb21ueLbLk+j7++GNEREQozv/Bgwe4cuUKtm/frvB9cPz4cVy8eNHsvFxdXeVBWmMf2gYNGiA5ORlDhw416vitW7di3759Rp/T+vXrIYoiZs2aZczx/y5RqFy5Mry9vZGeno64uDiMGzeOexBYIkJISAhevnyJhg0bck97/fr1ioFG6XtcXBw3D0wS7e3tMXDgwDxvUl79biLCiBEjIIqionnr6OgoX2dWVhYX3xh16tSRPSpLTElJwaxZs+TAuatXr4aNjY1FdUKKaH706FGT/hcbG4szZ84YdeyjR49MEoU33ngjzz0ugP8OUZCYmZmJpUuXqiIEEoODgyGKIoYPH65aHobo5+dn8fjFO++8Y5TNQkxMDM6ePYt+/fpZHC6+UaNGskOS9PR0ZGdnK7pfvGcFrKys0LlzZ0WXQqKRb9J82bx5c6SlpSElJcXk0PJxcXFGi8KzZ89MEgUiwr179xAbG2vMseqLAhE9JKJAIrolZUhETkR0iojuv/osr4YoSH1/URRx584drnPehti0aVMkJSXh8OHDaNWqFby8vFC9enVV8yT6/2jQUVFRFqUzefJkMMYQEhIiPygFTeMxxrB27VrUrVvXonzfeecdbN68GREREdi6dSv+85//4MSJE2CMoU+fPtzvV8WKFeHv75/nWtLS0vD999+b/dLYvn07GGMmO9Ht1KkTMjIyjP7f5s2bce7cOaMFecCAAQCAuLg4Y44vNFGomGvbD0T0zavv3xDRMp6iUKpUKSxYsACZmZkQRRGHDx/m1tzNj40aNZLf1vpvumnTpqmab+nSpbF3714IgoDly5dblJaNjQ2aNWuGKlWqoFmzZmjWrBnc3NywcuVK7N27V8GUlBRFy4HnNQ0fPhzPnz/H9evXUapUKa5plyhRAj4+PvLLgijH5iQuLk7eZkQUpTysVKmS3D0xJYK1tbU1Vq5cadL/JkyYAMZyop1L052GWKZMGbz99tsIDw9HWloasrKy0Llz59elX2SiEEJEVV59r0JEIbxEoVSpUti7d6+i26B2JCA3NzfFFKW+KJgQhMMsurq6yuMLn376qap56fPjjz9GamqqKtOu27ZtA2MMO3fu5H7e9erVU7RypO1t2rSRt5sjCg0aNJD/b4oodOvWDYwxBAUFGd2qLFmypDzDERERgR9++AFDhw5Fnz59MGzYMOzfvx/79+9HdHQ0Xrx4gVGjRsHb29vY+lgoohBBRDeI6DoReb7a9iLXMc95iEKdOnXkWYWkpCTZquydd95R9QGRxhEMiYKa3QdHR0fZ5Nnb21vVa8zN2rVrK2Jm8kybs4WegkFBQfLDpB+cRYrJyBjDlClTTE7X1tZWjgRlrCg0atRI7p6ZOrtSq1Yt7Nq1C9HR0YiOjsa9e/fkVlt0dDR8fHzw9ddfy0Z7/zRRqPrqsxIR3Sai98hIUSAiTyK69oqvvVFSZJzw8HC8/fbbsLa2NjglqRZFUcS8efNARKhatSoXa8P82L9/f9y4cQOMMZw+fRoVKlQolGscMGAAbty4IbvS5y0Ktra2ivvIk6VKlUJcXJxBGwIrKyscPHgQjDEsXLjQrPT37dsHURSNGjBs06YNEhMTkZGRYdGgdOXKlVG5cmXY2NigXbt2qFatmkHrXUkUpk6d+ro0C3f2gYjmEdE0UqH70K5dOwiCAFEU5YGvzz//HAkJCRbFWDSlMqvdMtDnixcvIAgCzp8/z10QypUrh7Fjx2Ls2LFYvHix/P3GjRsKyz+Jlq5N0GevXr0QExOjSpkNHjxYPucvv/xSsa9JkybyPnNFoW3btkhPT8ezZ8/QpUuXfI9buHAhYmNjwRgrtFmq4cOHQxRF7N+//3XHqisKRGRPRI563/2I6AMiWk7KgcYfLBWFr776Sh5DaN26NcaPH4/09HSLFwwZS1dX10IThZ49e8pmzpYaR7Vr1w4zZsxAQkKCTP1uwev4+eef45WnbS6Mj483xSTX5GtNS0sDYwxjxoxR7NOfojTH7F2iFHckNTUVe/fuxbx58zBv3jwMHDgQq1evRmxsrGxf4uvrWyh1kygn+lZUVBQOHz78uqXvqovCW5TTZbhNREFENPvV9gpEdJpypiRPE5GTpaLg7u4utxT0ac6gkTmcP3++6qJQunRpzJs3DwAwatQoLmn65gq8agw3bNiAjz/+GA4ODlwFoXbt2khOTpZXFapBaVFXUFAQZs2ahVmzZsnjDNnZ2bh27ZpitaipbNGihZxHfqbwYWFh+Oabb8xaGWkJp0+fDsYYmjVrVtBxxd94qbDo5eWFuLg47iLk5uaGESNGIC4uDoIgIDg4WNWxiqJihQoVZPNgNfOxsrLC4sWLERAQoJhWVXvq+J9ABwcHnDt3DsOGDSvoOE0UeNHLy4vbAiF9SgZFUVFRGD16NMqWLVvk16pWhT1x4gQSExMLJb+yZcuiV69eOHDgAFq0aKF5k/p/aqLAi15eXkV+Dho1cqAWNk6DBg0KaGHjNGjQYDo0UdCgQYMCmiho0KBBAU0UNGjQoIAmCho0aFBAEwUOmDdvHv0TZnE0/LtQvXp1unbtGgGgkJAQql27Npd0NVGwEB07dqQOHToU9WmYhX379tHQoUMLLT8HBwc6fPgwiaJIoijS/fv36enTp5SdnU09evTgnp+Xl5di/t3Pz4+mTJnCPR8PDw9ydXWlQYMGUdu2beVtgwYNIg8PD7p06RL5+flxy+/NN9+kWbNm0alTp8jJyYmio6OpVq1adODAAT4ZFLXhkiXGSwsWLEBkZCT0MXr0aK42+wWxY8eOirwLI09etLOzw7179/Drr7+qnlepUqXw9ddfIy4uDrt27cLUqVPRokUL2NjYwNHRESdPnsStW7cs9gmpzylTpiA/WJrurl274OPjg127dskOXC5duoTs7GxERkbCx8dHXm+h/8nr2sLCwuQ1HrVq1UKzZs0QExODrKwsrFmzpqCwf8XbotHOzi7fRT2FsWTV19dXUdF4rYqzs7PDpk2bEB8fLy/8ioqKwtixY7m6em/dujUYYwrX4w0aNMCtW7ewdOlSbvnUqVMHAQEBSE9Px8iRIw0e8/XXX0MURW6LiPz8/AAAu3fvhoeHh4KW+PIEAMZYnk+pnPQXRhn6tPS6HBwcZHd5Hh4eChGVHLEwxnDhwoX80ih+omBlZYXatWtj5cqVuH//PjIzM3HlyhVMnDgREydOxIMHD8AYw6ZNm7hVakOUVjNKsNRpiJWVFd577z2sXLlSUbi5+eLFi3wfLFMpOXHRF4WhQ4dCFEXcuHGDSx5t27ZFWFgYLl68WKAD2G3btuG7777j0sLbvXs3lxaBIRp6+0ufhrb98MMPGDhwIAYMGGCSG7f8KAn5F198kWeffr35+++/80uj+ImCfkDUjIyMPN6Aa9WqhcDAQPTp0wcfffQR/vvf/3KvGLm7DJa2EEqWLIktW7YoHv4zZ87g1KlTGDx4MEaOHKnY95pVcEYzJiYGoigqImidOHFCDthrafoVK1ZEYGAgjh07VqAH5YYNG+LMmTNcXPPrdxlcXV25l33btm3h4+MjO/HVbymo7U184cKFsvNYQ/v/daJgZWWFMWPG4O7du7IgzJgxw+CxDg4O+PHHH+WlszwLhrcgEJEc0pyxnNgI3377rfzGdHR0lFdSStT3PWjJdeTu537wwQdIT0+HKIpcfEKOHj0aCQkJqFWrlqJspk+fjuPHj8u8d+8eAgMDLQ7ZTpQTSAXI6TbwLPfcrF69Oi5evKhoFURGRqJNmzbc83J0dMSuXbsgCAKSk5PzDWjcvHlzWTT+FaJQoUIFRQshP0H48MMPceHCBflYnkt11RAEIsL9+/dlbz59+/aVt7/55pt4+PChQhD8/PxQsmRJi/OU4hvqi8LPP/8MxhjCw8O5vGWvXbumaKk5OTkhPDw8j6McKbqRra2tRfm5urrKZcOrzF9HqeWwa9cueeyAd4vhp59+AmMMDx8+hKenZ4HHNmvWDOHh4QU56SmeomBoEMXR0REDBw5URBpmjGHmzJncCic3OnbsyCVdSRSeP3+O+fPnY/78+Th9+nSea3n58iUaN27MJc/o6GgwlhNIlojQtWtXvHjxAowxbtGuDxw4AD8/P3Tq1AlDhw7F5cuXIYoifH198e2332Ly5Mnw9fWFKIrYtWuXxflJovDo0SNuZW4KpVYDzxZDs2bN5BeDKYOwBYypFR9RkAJqREdHo2nTpihdujTatGmDtWvX5gmOyliOK2yeDk+lmQZfX19uYiCxbNmyWLlyJYKCghAUFAQ/Pz9MmTIFb731lhyV6O7du1yvJz+X9fq/MzIyMGLECLPzGDlyJCIiIrB27VpMnjwZY8aMwRdffIExY8agfv36GD9+PCZPngxPT0+UL1+ey3W1bdtWIdxSdwJAofjEkKYnLRUHKQAvYwzjxo0z6b+lS5fGb7/9lt/+4icKjDEkJyfLAz2MMdy4cQOTJ0+W3368Zx/UaB0YQ2tra9kf4Jo1a7imLc2p68d2zM7Oxrx589C4cWM0btwY9evXNzv9rVu3Ijk5Ge3bt1dsr1ixYkEVlhtzTz1KKIxya9u2rRyOwNwZB33v0++++65JdebQoUP/jjGFZs2aGZyeGzZsGMqWLYvx48fL248ePcptPl/fFqEwBYEo58GSBrBMDWhqDDt06IAOHTrIorB161Yu6U6fPh0xMTGoWbOmwf3Z2dlo3rx5od1HqfVQmN0KyXjJ3LD3krv6+fPnmzTW4u7uDsYKDB5UfETBxsYGrVu3RuvWrTFt2jS0bt1aDgU/ZMgQvHz5Eowx+Pr6omXLllwKNrctQmFVKKIcIyJp9sSSJrwxlAb79Ac5zWWpUqXw6NEjDBo0KN9jfH19ubd8CqJkt8A7wnVB1B94NPW/Xbt2lbvEpgpCREQEDh8+XJCvz+IjCvnx008/RVJSEhjLcX7Ka24690yDGhGNCuKdO3fAGMPGjRtVdeY6ePBgiKKILVu2wNra2uL0ypYt+1rX++3bt0dqaiqcnZ1Vv48eHh5yGVpSN9q2bWvS+IC+mbOpeX3xxRdyq9dYUWjVqhViY2ORmZn5ukjexV8UJEF4/PgxtxZCbkEo7FYCEcn9/RYtWqiaz82bN5Geno7atWtzSc/W1hYRERF5grHkpp+fH44ePar6fZRg6SAjAJOiflvSUjBVFNzd3REbG4utW7cqbELyYfEWBanf9fjxY7OChhriP0EQHBwcwFhOUBE18ylfvjwePnyI6dOnc033448/RkJCAjp06JDvMVITWc0YmdIUJY9ug/TWN7ae8WopjB07Nt/j+vbti61bt+LWrVv47LPPjJ2yLL6i8MknnyAlJQXR0dHc3qaGBKGwBxeJCHXr1jV51Nkcjh07FqIoomvXrtzTXrBgAdLS0rBq1ap8K2tCQgLWrVvHPW9XV1fZ3NmrjTq8AAAgAElEQVTPz49Ll1Ka7RJFEcuXL8egQYMU4ybS70GDBikWQJkz+9CuXTvExMSAMYbLly9j/PjxGD9+PEqWLIkyZcrIv+fOnYvVq1ejadOmpqRfPEXBw8MDqampYIzB3d2dW2XivcjJXE6cOBGhoaGqB4YpyI7eUtra2uI///kPIiIicODAAfTo0SNPWX3//fc4duwYtzx3794NLy8vhW0CrzEmQ2bN2dnZ8hLq/BZEDRgwwKz8OnbsiCdPnihm2wIDAxEcHCzbkIwePdqctIuPKNjZ2cHX11cRFdnDw0PVh6YoOGjQIDDGuAz6FcRu3brlMXNWm9WrV8fMmTPl2Y5Dhw5xjbolLZdW20ipTZs2WL58ucFVktKqyMKKTm4Gi4codO3aFefPn5dvfHx8PJo2bVosQ4Ft27atUERB47+WWoSo/zUMGjSIfHx8qGTJksQYK+rT0VD8YFSEKE0UNGj490ALG6dBgwbToYmCBg0aFNBEQYMGDQpooqBBgwYFNFH4h8DFxYUYY/T+++8X9alo+JdDEwUjYG9vT8HBwcQYI1EUFZ9xcXH0xhtvWJR+zZo1ac2aNfRPmAnSYBysra3Jx8eH0tLSSBRFSklJoZSUFBIEgTIyMqhdu3ZFfYpm47WioNPpftHpdHE6ne6O3jYnnU53SqfT3X/1Wf7Vdp1Op1uj0+ke6HS6AJ1O11ytE69atSrt2LGDGGPEGCMvLy/y8vKili1bUrly5bjmtXXrVqpTpw4BoPj4eNq0aRNt3LiR4uPjuTzIAwcOpAEDBnA4038+OnbsqG+0VuSwsrIy+T/29va0Z88e8vDwoGfPnpGPjw85ODiQg4MDjRw5kkqUKEFjx45V4WwLCUZYG75HRM2J6I7eth+I6JtX378homWvvn9IRMeISEdEbYjoCg8z59zs378/kpOTIQiCTMaY/P3u3bsGA2aYS1EUkZKSgn79+uXZx8M1+bRp08AYQ0BAABdvzf9k6q8xUTOfkiVLFmgKX6JECXTq1Ak7d+40KV1bW1vs378foiji7t27BoPcxMfH4/fff+d6Pfb29nB3d8cHH3wAd3d3LFq0CBs2bMCGDRvkRVj9+/d/XTr8zJyJqCYpRSGEiKq8+l6FiEJefd9IRIMNHcdLFCpUqIC7d+8qBCG3KAiCgMjISG4FwhjDrFmzVKm8dnZ2iI2NRVJS0mv9Ijo6OsLFxcWodfZr167FjRs3MG/evIJiCxY69V3cqZnP8OHDceDAgXz3T58+HYwxTJw40aR0p06dClEU8ejRI1hZWRk8Jj4+HkuWLOF2Ldu2bUNQUJBcz6W6Ln3GxsaiW7duxqSlqii8yLX/+avPw0TUXm/7aSJqwUsUHB0dcf78efnBr169usy6deti+/bt8r6srCx89NFHXAqFRxzA/DhlyhQIgoAnT54UeFyDBg1w584dCIKAkydPGlV59b1bS8FX1q5di549e8qUtvfr1w89e/bk5kY+P+pDrTymTZuG7OzsfAOnSP4vExMTTQ5V9/333yMgIAC9e/c2uF9a1NapUydu13Ps2DHExcVh0qRJmD17Nvz9/eHv7w9PT8/XxoLIxSIRhSOUVxTc80nTk4iuvWKBF1O6dGm4urrC0dER27Ztw+TJkw068bC1tcW1a9fAGOPmqLN///6qria8efMmBEHA1KlTDe6vUKECJk2ahLS0NEVr6HXp2tjYYN68eYqVpcbw5cuXWLdunWoLziSo4auiZMmSGDNmDFJTU5GRkZFnv5WVFcaPH4+UlBQ8e/bMLBfsLi4u+S5Ya9GiBeLi4pCcnIwGDRpwuSZnZ2f4+/uDMcbD4W3x6T5s2bIFgiDg559/ztdbT4UKFXDq1Cn5oVm/fr3FBVKjRg3Exsbi4cOH3CswUY7vv5SUFAQEBBjc3759e/z1118Gu0jG5uHk5ARPT0+MGzcOAQEBr6UkPkeOHEHlypW5X7NarQRra2scP34cjDE8efLE4Jv8r7/+ksWP57JtIsJXX32FhIQEJCUloUuXLtzSlcIGcvI9oaooLCflQOMPr75/RMqBxqtGpl/gxfTr1w/JyclyYJQJEyYoApK6ubnh2rVr8gPz+++/o0qVKhbfRHd3dwiCgIiICGMGcUxipUqVcP36dQiCgGXLlhk85rffflOMk5w5cwa//PKLSaJgKhcsWCA/OLx8N0qUvFvxdmBjZWWF27dvy+fdvXv3PMd8/fXXckuoQ4cOXCJcS6xcuTJEUURqaqqxfXujuWHDBgiCwMsTFx9RIKKdRBRDRNlE9JiIRhJRBcrpGtx/9en06lgdEf2XiMKIKJCMGE8wRhSICHPmzFG8Kf/8808Q5fhqjIyMlPfNnTuXm9ciSaUlxyBBQUFcZhuIlAE/DI19DB8+XN5/9uxZ2NvbK/7Hs+Lp097eHllZWWCM4ZNPPuGatjTzwFMUypYtixMnToCxnNB7n332maJ5X7FiRfj4+Mjeun799Vf5XvLi8uXL5Rkq3t2iDRs2GDuzYAyLh5OV3GzTpg3OnDmjeIMePHhQlQdEmuqRhKB///6yOFjiotzW1hYnT56EIAho1KiRwWOkgDdSP7JmzZrYvXs3BEHA1atXVbleIsKXX36pWktBmnngld7u3bsNjonExMQgJiYGiYmJchneunUL69evtyjy1esoBdd5/PgxypUrx60OxsbG8jrH4ikKRDnjBytXrpRF4dNPP1WlkCdNmpRnymrhwoUQBAH+/v5mh4V3cXGRz92QKHz++edySDwiwltvvYXQ0FDZ85SaDmWlGIZ37tzh7m2ZdyvBzc0NPj4+sghIFARBbt0ByBPlOj4+Hm+99Rb3e2dtbY01a9ZAFEUusw/SIDevoL9UnEWBKKdpLz1Ypvjkt5TSaLAoili4cKFZaUiiEBYWZnDsQzJmysjIwJMnT/Ds2TN5oHHjxo2qXdukSZPw7NkzpKWl4Z133uGatjSeUBhl1KpVK3mMwdfXFwsWLMCECRMwZswYLFiwAOPGjUOpUqVUybtatWpISkoyu27oU2qZMsbw2Wefwd3dHe7u7pZ0YYuvKJQuXRqHDh1SNBsLijPAm++++648hmHO/11cXOTz7tSpExwdHUGUM43o4uKCI0eOAECepvEvv/yi2jWVLl0aV69elWceeKfPu+tQEKXxmFu3bikGpAuL8fHx+OOPP7gMZu7du1cx88RYTpBlM2N/Fl9RkKYoZ82aJbcWfvjhh0Ir9Pfee8/sCEBEOVaM+kZYgYGB2Lp1K/788898LTR//vlnVa9Jms5LTU3lPhBHlNN1KAxRqFChghxb1MHBodDqhD7j4+MhiiIXQXJ2dpaNlI4dOya3Us0cfCyeoqBv5uzo6Ijbt29DEAScOnWqUAq8Xr16iIiIAGMMCxYsMDud+fPnF2imLb3pRo0ahffff1/VNRFDhgyRZxy+++47VfIoDFGoV68ejhw5gszMTISGhhZKfTDE+Ph4JCUlqdZFkca1IiIiTB3XKp6iMG7cOIUBz6VLlyAIAiZPnmzxzba3t89X3Vu0aIFFixYByGnWWzLQSER44403cOLECYOiEBAQgMaNG6N8+fKqV+DKlSvj4cOH8nSdWhVZbVGwtrbGzZs3wRhDZmYmN4tCIsKZM2fQvn17o47t1KkTkpKScPnyZdVc9derVw/JyckQRdFUK8fiJwrW1taKsQR9s2Ye0aIWLVpk8CbPnj1b0afbs2ePRYIg0dbWFl9//TWWLVuGK1euQBAE+Pj4FGqzd+7cuWAsJ2q3m5ubavmoLQpTpkyR6wXPxWvjxo2DKIq4f/8+Ll68iNTUVJlr167F6tWrZcbFxUEQBADAmjVrVC03M02fi58oVKpUSb7xkimzIAiIioricqOlJdnnzp3DuXPn5FYBADx8+BBbt27lZrz0T6H0IOVnL8GLaovCmjVr5Gv5/PPPuaVbvXr1PFOa0rLpCxcu4OLFi4rtERER8PT0NDbgq9lcsWIFAGiiIHHt2rWyMPC0YPy38fLly7IfB7XD3gOAr69vkV9zcaD+y0oTBY1cKYkCY6xIpu40mkfJt8LChQtNLTejRMGaNPxrERAQQNWrVycPDw/KyMgo6tPRYCQaNGigavpa2DgNGv490MLGadCgwXRooqBBgwYFNFHQoEGDApooaNCgQQFNFDRo0KCAJgoaNGhQQBMFI+Hi4kIPHz6ky5cvq56XKIrUs2dP1fNZsmQJCYJAgiAQY4wEQaAbN25QjRo1VM+7OKNWrVq0bds2EkVR5pUrV7jmYW1tTQ0aNKAFCxZQQEAAzZkzh1/iRW3N+L9i0di0aVNkZGRgzpw5qucliiKePHmC6tWrq5bHmDFj5EVeMTExilWagYGBFvmg/LfS2dkZ48aNUzj7lcjLDV2tWrUwaNAgRTiD58+fY9KkScb8v/ibOS9btgynT59W3PywsDBUq1aNe4G3bt0aoigWmiiIoqja4itnZ2fcuHFDjh7VuHHjPP4cbt68yWUlKFFO3EY3NzcsXboUQI7PxMWLF3Nzbpofb9y4gQMHDqBKlSoYNWoUl1gg+bFNmza4cOFCHjHw9/fHvXv3DMYhNYaxsbHYuHEjlixZgqdPn+Lly5d5QiaOHTvW2PSKtyiMHTtWVuTcbstWrFjBvdA//fRTiKLIdZ1+flRTFGrWrInAwEB5GbiUh6+vbx4nL4cOHbI4PycnJ0yaNEkum9DQUEycOBFZWVmqBdmRKDm/bdu2LdLT03Hp0iVV8ilbtixCQkLyCMKzZ8/QuHFjVKpUyey0V69ejYCAAKSnp+P06dM4ffo0fvzxR7mcNm/ebEp6xVcUevTogfj4eDkaUL9+/fDFF1+gVq1a6Nq1K2bPns294Ldt2wZRFFV/u9nb20MURYSHh8PFxYV7+lOnTlU8+NL23r1749ChQ7I3ZB6iULlyZdnxSWpqKqZPnw4igqenpxw/s1WrVqqscv3qq6/AGMPKlSsxYMAAZGdnY9OmTaqU16RJk2QhuHnzJkaMGAFRFJGZmQkfHx+L8yhTpozC10VkZCRSUlLQq1cvo4IN67F4ioKDgwNCQkLAGMOyZcvkJq6rqyv3yEP6LCxRcHFxgSiKqrhxL1euHMLDw2VR2L9/f55jjhw5wkUUunTpgnv37oExhqtXr6JVq1YgInTv3h0ZGRmqOqRt2bIlsrKy8M4778DOzg5btmxBVlYW+vbty/2eDhgwQBaE69evo3z58ujatau87cGDB1yilUn89ttvce3aNdjZ2Znz/+IpCtu2bZMrk34lePLkCcLDw1XzC1DYosDbxbpOp8vTRTAUT5GXKEhRm7Zv364YtJRcv40dOxY7d+6U3Zfzus5SpUohNDRUjiDWpUsXCIKgiifs7t274/r16xBFEatWrYKTkxOIciJTi6KIp0+fcotJUqpUKWzevBlJSUmWBLQpfqLw5ptvAgBCQ0PlkOlNmjTBy5cvZWW2xJlqQbx16xYyMzNVd+iipijkHnsxdNzRo0dlBx6HDx82Ky8fHx9kZGTg1q1bsLW1RenSpTF37lxERkZi9OjRcHV1hU6nw7p16xAbG8t17GTEiBEIDQ2VPR9JosA7FmjXrl1x8+ZNud7pjxvcuHEDoiji4cOHqFq1qsV5lSpVSnb0O3PmTEvqYPEThYoVK0IURfTv3x8VK1bEwYMHkZ6eLlfyzMxMrq649CmKorm+9k2ii4sLAHAXhTlz5sgthJcvX+bbCuDRUpAq8N9//41nz54hOTkZjx8/xvz58+Vjjh07hszMTPj7+3O9zn379smDbyVKlJBD7fF0ItOhQwcEBATIghAZGSnv69u3ryyqPCI72dvbY+7cuYoW3sOHD7FlyxZzpo2LnygQEQ4cOKB420mzD4mJiaa6pjKJoijK/WI1qYYofPPNN4pKld+A2+bNm+VjfH19VWsVLVq0CIwxXLt2jWu6fn5+ePnypfz74MGD8vVMmzaNSx579uyRxSB3yMJGjRohKSkJoihi3759Ft+/9957D0CO67Xg4GDFvs6dO4Mxhtu3b8vdFiNYPEXB2dkZ3t7e2Lp1qzzKyznenkGGhoZyj61oiGp0H6QugT6/+uorxTFNmjRBbGxsgV0LHuzSpQvS09ORnZ1t9ty9IVapUgXh4eHIzs7Gxo0bMXHiRNn2Yvr06ShRooTFefz888/IzMyURWHQoEGK/R9//LEcx3LXrl0W59e9e3eEhoZi48aNqFmzpmJfyZIlsWnTJs1OITenT58OIMcY5v3331etIhPl+DNUM32JDg4OEEUR33zzDbc0pS6BxEOHDslvMWdnZ5w8eRKxsbGKuBNqXd+CBQvAGMP169e5plulShU5SI9EANi7dy+X9F1cXHD37l1ZEFatWgUrKyt5v7W1NYKDgyGKIpKTk7m1Kh0cHGBjY2NwX8eOHU0dRC3+ohAeHg5RFDF9+nRFAfHmihUrCk0UiAgAcPLkyXwrg6nMLQrdu3eX95UsWRJbtmyR36ppaWlcZwNy8/Hjx2CMqTI9OHLkSJw8eRInT57EjRs38OTJE1SuXNnidK2srDBx4kRZEFJSUvIMIH722Wfy/u3btxdKPXF2dkZkZCQCAwON/U/xFgV3d3cwxrB3716LLMaM4cWLFzF37txCKWgi/haNI0aMyHdMQRpvkERh0aJFql6b9BbnJXj5sWHDhoqBTUtYs2ZN3Lp1S2GglDuugzQTERsba3Q0KUvZqlUrpKWlYefOncb+p/iKgr29Pa5cuYIXL16oHq+AKMek+ujRo4VS0ET/Lwq8hMjZ2Vm2LMzdvNb/Hh4ermqwGysrK9nojEdE5oK4ZMkSfPHFF1zScnd3V5gvP3nyBH369EHnzp3RuXNneHh4yNtN6N9bRGtrayxfvhyMMYwbN87Y/xVfUTh48CAYY/jggw8KpQDq1KlTqN2HJ0+eQBRF/Prrr9zS/PLLL/MspNFfBBUeHq56lKj27dvDz89P9RgTrq6uePLkCbf0SpcurWgpGGJ0dHSewVs1r09aJXn06FFTFgAWT1Ho27cv0tPTIYpioRSAxMIUhYULF3IXBZ1Oh8WLFyM9PV0hCmlpaVi0aFGhhMNr3769KpaFudmoUSM5ADEPWllZoXPnzgWKAs8Wa8WKFfHbb7+hTp068nRjiRIlUKlSJUyYMAHPnz9HdnY2rl+/bqqtQvEThbp16+L27dtgjCkMRgqDERERXAatjGHNmjURFRXFVRQkfv/99wpRUHNQMTc//fRTfPjhh6rnM2LECGRmZnJN08rKCvXr18fDhw8VdgpLlizBkiVLuOZVrlw5eWHa8+fPsWvXLhw4cEAut40bN6JXr17mpM1HFIjoFyKKI6I7etvmEVE0Ed16xQ/19s0kogdEFEJE3XmJQqlSpbBjxw6IoohFixapFjJdo3rs2bOn6i0Sa2tr7NmzRzaD16ggt7BxW4hoHRFtzbV9JYAf9TfodLr6RPQJETUgoqpE9JdOp3MDwIzIp0CIokgHDhwgV1dXWrp0qRbm7H8QL168UD0PURTp1q1bFBAQoHpexRVGhY3T6XQ1iegwgIavfs8johQDojCTiAjAkle/TxDRPAB/vyb915+EBg0aLIXqYeO+0ul0ATqd7hedTlf+1bZqRBSld8zjV9s0aNDwPwJzReEnInqbiJoSUQwReb3arjNwrMFWgE6n89TpdNd0Ot01M89BgwYNKsAsUQAQC4ABEIloMxG1erXrMRG56h1anYie5JPGJgAtjGnOaNCgofBglijodLoqej/7EdGdV9//JKJPdDqdrU6ne5OIahPRVctOUYMGDYWJ14qCTqfbSUR/E1EdnU73WKfTjSSiH3Q6XaBOpwsgok5ENJmICEAQEe0momAiOk5E43jMPPwb4ebmRmfPnqUnT55QcnIyeXh4FPUp/U+hQ4cOFBgYqAW2MQdFbbhkivHSv4X16tVDcnKywtZebd+QxYk9evRAYmIiBEHAhQsXivx8/kEsfhaNRcn+/fvD399fXi/AGMOQIUNUyUsSg9OnT6Nu3bp5HGyozQkTJmD37t2qxdBQi+PHj1es7fjqq69Qo0aNQsu/Zs2aWL9+vcJiVA2r1Dlz5oAxhqioKFOduGqiwJOShyf9z6CgIO7h1d58801ZFNq0aVPo1/ntt98iPT0dx48fR69eveDg4FDk994YdujQQSEIp0+fLtT8e/bsiejoaMU53Lhxg6t3KYmMMWRnZyM7O9tU0S6eotCpUydcvHgRcXFxWLlyJfr374+33noLb731FipUqCB/5/l2nT17tqKFoP/J+006dOhQiKKIEydOcHEhZiw9PDwQHx+P9PR0pKWlqeIVu27dukhMTMSzZ8+wbt06boJjb2+P/fv3G/QsVVjMzMxUrDq9evUqOnTooEpe+qLw4MEDuLu7G/vf4iUKJUuWxJAhQ5CQkJDv8t/79+/L3zMzM7m4aOvfv7/85s7dUmCMIS4uzpRCKZAdO3ZESkqKasFgCqJ++L1ly5ZxTbts2bKYOXMmMjIy4OPjg88//xyMMW6trNq1a+frWUptlitXDvPmzcvjn+LHH39ULU+tpfCKnTt3VhR8fHw8Xrx4AcYYjh07hvj4+Dz+AtasWWPRzXd2dpb9/i1cuFAhQkFBQfLvs2fPWlzQTk5OuHjxohyh2AQPvRZz1qxZsiisXLnS1FBk+bJs2bLYtGkTnj17hrS0NHz//fcgyvFPkZGRgQEDBnDJp6hEoWrVqtixY4fCJ0VcXBwEQVDVJZsmCkSws7NTRDdKTExEixYtYGdnh9KlS8PKygp2dnZwcHCQl5hmZ2dbHJ1HelBSUlJkgRBFUR5gXLFihXyMoWhLxrJMmTI4f/683CJRsyLnnsWYO3eu3DpJTk7m9kBNnjwZjx49AmMMf/zxR57xkd9//x3Pnj3j4kpv5MiR8hva3AA2ptLV1RUBAQHySyI4OBhVqlRB//795XqqH/+RFydMmCC3SO7du2fq/4uPKHz77bd5RpUNHde9e3dFwBNLbr7+OMKsWbNARNi6dSsYY3J8CU9PTy5jC5988oksCElJSapV5NatWyMoKAh9+vTBG2+8AVtbW/lhSkhIwLBhw7jkU6tWLSQlJeHo0aP5uqpv3rw5UlNTLY7/6ezsjCtXrsjl3rp1a8X+li1bYvPmzQgNDUVISAguXryIHj16WJRn1apVERAQoGg5Vq9eHUQ5MxCPHz+GIAiYPHky1/JzdnbGmTNn5JbCpEmTTE2j+IjC7du35UJftWpVvk4/R40a9dqAJ8bwgw8+kMcNcrsIF0VREWNCailYEulIcg2eO23e1A+kc+TIEaxZs0b+zSvmIVFOlCZDcRFy8969exBF0SJHp8OGDZPLfN++fQpXb71798bTp0/zjD0JgoAxY8aYlZ+rq6scOFd6OHMH6vXz8wNjDFOmTOFafrVr10Z2drYcbf2NN94wNY3iIwrS/HNYWBhcXV3z7LeyssLo0aNlV2M7duyAvb29WTe+Xr16cgyE2NjYPDe+efPm8rZ69erlaU2YyqZNmyItLQ2iKOLx48cGm5wtW7bEn3/+iaysLBw+fNjsZmndunXx/PnzPA5ceQd/GTRoEBhjGDhw4GvvdWRkJKKiojB//nyzBh5DQkLkB33lypWKffkNSAuCgJs3b8oRy02hl5eXIp05c+Yo9ru5ucnjCrxbClOnTpVFwQRnrfosPqJQEO3t7RXdC0vCg/Xv3x/JyclgjOHOnTsFHjt79mz5WHOn75o2bYrs7GyIooi0tDT07NlT3le1alX89NNP8n59Wtrk1u+DM8awbt06rpWXKMdT1sSJE3Hv3j0AwObNm1GyZMl8jy9btiwGDhxo8rUZEoXffvtNtlXILeo2Njb49ddfwRgzuasmRTwXBAEHDx40GGtk3Lhx8vk4OjpyvaehoaHyLIeZTmL/HaKgHy/wxIkTFs19BwcHywOLBRmdzJ49W+42HDt2zOz8vLy85Af9yJEj8vZRo0bhxYsX8r7Lly9jy5Yt8u9atWpZVLlyi4KaYeKcnJzQvn17REVFqRKg15AoSMFv9EVWYrVq1RAWFgbGmMnjTo8ePYIoirh06ZLB/fpdizNnzqhyrVpL4TX87rvvAPz/3LAlrsP1uwIFjQ9s27ZNbiHs2bPHrCaoxEWLFskP+qlTp+Ds7AxnZ+c8LYOXL1/KHqzPnTsHa2trs/O0tbWVB1H1qbY5cK1atRAZGcltulP/QZFE4fr163jvvfcQFhYGQRDw9ttv5zleP/iNKVG127ZtK5f7zJkzDR6jPz3ZqVMnrtc5Z84cpKWlITs7G2fOnDHXOKv4i8KDBw/kB3nTpk0WhY7z9/cvcNDQ3d0d586dUxxjiSAQ5QwcFeQ23BC//vpri/KsUqUKzp49C8YYUlNTZVG4ePEi10psiPXq1TN77CU/1q9fH+Hh4QWOk3To0AETJkxQBNAFgBkzZhidz+zZsyEIAmJiYgwGGv7uu+/kuvjw4UPuwYhXrVol2yaMHj3a3HSKvyhIhXzp0iWLvTvrL3YyVHGlwUdpvMFSQSDKsdJcs2ZNvgKQmZmJlJQU/PXXX/jxxx8xePBgLqbBUvdBXxQ++ugjrpU4P3p7e3NPc/ny5XkM1wRBQEhICEJCQpCYmKgYaAwICMCMGTNMCl136dIlCIKQZ6aBKGf8R9/Mefr06dyvUV8ULEineItCy5YtIQgCHj16xMVtuL+/P4CcrkiLFi3g7u6OFi1aKJr4sbGx6N+/P/cC9/DwwLBhw3DixAkEBgbK+Y0fP557XkSFO6aQm8nJydwje9nb22PTpk1yrARDlMYQLly4YFZXacmSJXKXw9XVVeZnn30mjyM8f/7coGhYyh49evAqq+IrClZWVvICmI8//pjLjc+9LDr35969e82ZFzaZUij64OBg7v1SiV27ds0Ttl3t65J4584drF+/XpW0mzRpgnXr1hkUBV9fX3MDqIAox8w+LbpNFh8AABtSSURBVC0tz9Sm/m81LBiJckRBaiVoLYV8KEVRDg4O5nbjjx07JrcUpE8ehkn/VHp7e4Mxhj///NOiaVxTOW7cOAQFBRX59ZvDU6dOGRSF2NhYVZe5P378WBOFgti0aVPZSs1EBxMFsmLFipg0aRKePn0qzyz89NNPmDhxIpfxg38aa9WqhR49ehSqIBDliMLrbED+qXR0dIS/v79CFM6cOZOvKTcv7t+/XxOFgujn5wdByImxV9SVRKNp9Pb2xosXLyy2s9BoNo0SBUuCwRQJdu/eTenp6RQZGVnUp6LBRMTHx9ORI0fowYMHRX0qGgqAUWHjVD8JLWycBg2FAdXDxmnQoKEYQhMFDRo0KKCJggYNGhTQREGDBg0KaKKgQYMGBTRR+AegWrVqtHPnTmKMEWOMJkyYQDY2NkV9Whr+4XB3d6e1a9fSuXPnqEmTJtzS/Z8Whffee4/Gjh1LY8aMoStXrhBjjG7fvk2zZ8+mffv2UdeuXYv6FF+LM2fOUEhICCUlJVG3bt2oSZMmtGLFCkpPT6eGDRtyz8/Z2ZlWrFhBjDESBIEEQZC/9+vXj3t+RYnExET5GgVBoMDAwELL28XFha5du0aMMVq7di3XtBs3bkz3798nf39/evfdd8nf35/s7e35ZVDU1oymWjTq848//shji67Pu3fvqmIZtnHjRm72+5Kbev1tixYtkn1E1q1bl+u5S96lpFWfnp6e8PT0LDRT7ubNm2PhwoV4+fIlrl27hl69euGVnQpX2tnZQRAELF26FN999x2ePn2KrKwsTJw4sVCus1y5ckhISABjDD///DPXtKVVtCkpKabWj+Jp5iyxbNmyBh1y8hIFJyenfJfYhoWF4fnz56rFWaxWrRpu3rwJxhi++OILrmnrB7Xp1q1boTwgEps0aQJRFJGVlSULkyiKqtzHsWPH4uLFi7Knpx9//BGMMTx8+BBlypQplGtNTk7GkydPuJp1Ozo6QhRFZGRkwMPDw9T/F08zZwkbNmyQv584ccLgMf7+/malrdPp6OjRoxQcHEzvvvuuYl/VqlXJ2dmZypYtS126dDEr/dchOjqatmzZQkREgwYN4pr2nDlz6ObNm6TT6SghIYFr2gWhadOmdPz4cbpw4QL16tWLPD096Y8//lAtvzt37tDx48cpMzOTiIjCw8OJiKh69epka2urWr4SrKysSKfTkSiK8jnwgKenJxERJSQk0O7du7mlq0BRtxLMaSn07dtXjvDbo0cPODg4YP78+XlaCub6HRw5ciREUcSLFy/g4uKi2Dd8+HDZb2L58uVVe9NMnDgRjDGcPn2ae6BZyXeEFNSGBws6x4kTJyI6Ohrp6emK7TNmzFCtpUCU0+LS/y0thefh98DOzg4LFy5E5cqV8+yrUqUK/v77b2RmZqJv375cr+ns2bMQRRFt27Y15//Ft/vQt29fpKWlYdu2bWjYsCFKlSolN4sFQUBcXBw++eQTsx2c3r59O1+vvUeOHJHD0KtRkSU2aNBA7ho1bNiQa9pSuDueomBvb48WLVoottna2mLmzJl4/Pgx0tLSMHz4cHmfo6Mj4uLiuIqCq6srli1bhjNnzhj0phwaGgpBEPDdd99ZnNfkyZMRFxdncPn+qFGjkJmZieTkZNjZ2XG7x2PGjEFWVhaOHTtmbt0uvqLwwQcfIDU1FYIgoE2bNti6dauiheDt7W2R04t3330XiYmJePDggWK7g4MDnj59ClEUsXz5cm6FbYj9+/eXHbzwfpOuWLFCDprr7++PY8eO4d133+V+De+//748brBz507FvkOHDkEURfz9998FxoMwlkOHDsXz588V9SD3MVKdsdSHYuvWrXH16lUwxvK4zCtTpowciYunazZra2v8/fffEEURtWvXNjed4isKpUqVkiuAVNAS9+7di6ZNm1pcCIcPH0Zqaqri7aZfyV8X/cgSdu3aFSdPngRjDCdPnuSatr29PYKCghSh56XvcXFxcHd355aXFD4uKChIEf2pfPnyePLkCbeBxmrVqsmtgPT0dJw6dSqPKHTv3l1ueZkTiUqfgwcPBmMML168QOPGjRX72rZtK99Xni2xHj168AhAXHxFgYiwfv16xexDZmYmbt68mWcMwFy2adMGoigiNTUVNWrUQLly5bBx40aIoogHDx5wcRabH+3t7REZGQkAecKSWUp3d3fFfZs4cSL27t0rb3v69Ck357SSKCxcuFDe5uTkhO+++w6iKAIAnj59alG8DiLC+fPn5etp3bo1+vXrl0cUxo4dC8YYQkJCLBKhHj164Pbt28jMzDToIv7IkSNgjGHHjh3cWnh2dnZyV8vCAMR8RIGIXInIl4juElEQEU18td2JiE4R0f1Xn+VfbdcR0RoiekBEAUTUnJcoLF26NI8XYgCKSseTdnZ22LVrFwRBkFV6x44dXPuJEitVqoRly5YhMzMzj1PQP/74A0OGDOGST+nSpdG8eXODdgmlS5fGnTt3wBjD2bNnLc7Lzc0NCQkJ+bqw5xGuTiqfwMDAAu9tZGQkGGPw8fExOQ8nJyd06dIFQUFBcr3LysrCwYMH8Z///AddunQBUU60MsYY7t69y20QumLFivDz88v3HoaFhaFPnz7GpsdNFKrQqwebiByJKJSI6hPRD0T0zavt3xDRslffPySiY5QjDm2I6AoPURg5cqQcQDa3l14nJycuBZAfa9WqhYiICIiiiKVLl3JP38HBATNnzoQgCDh06BAePnwIQRDw559/4tKlS8jMzER2djZCQ0MNBtjlyXr16sndidmzZ1ucXsOGDbFx40acPHkSJ0+elCvz48ePLe7m2dvbIzAwEIIg4MGDB3lmGyR27NhRFllzfFJ26dLFYLAZfQYEBMjenh88eIBKlSpxKY/du3fnEQJvb294e3sjLCwMoiji5s2bxqanTveBiA4S0ftEFEJEVfSEI+TV941ENFjvePk4c0Vh3LhxuH79ukIMkpOTC00UiAiMMYSHh6vidt3b2xuCIGD37t0oVaqUfI116tQBEWHatGl49OgRBEHA6tWrTQpiYg6l7oQaXqylim3mlJqCn332mXyv8pv6q1mzJjZv3izXmSZNmpicz4QJE/DXX39h0qRJKF26NJo1a4aZM2fC09MTQ4cOxcyZM2VxePr0KYYPH25RtDJ9enh4yPfs4sWLcuQpFxcXBAcHQxRFUywm+YsCEdUkokdEVIaIXuTa9/zV52Eiaq+3/TQRtTBXFFxdXRWCsHPnTixatAg7d+6EIAhYvHixwblinixRogREUVQlXkGfPn2QlZWF27dvw8HBAQ0aNDDovr5x48byPWjfvr1ZefXv39+oB33Dhg2quLb/4osvIIoiDh06xGXGYe7cufnONBDltPAOHTokH2MotiQvSqKgPzDNg/3795dFQfIa7eLigtu3bwMATp06Zcr0JF+LRp1O50BEfxDRJABJBR1qYBsMpOep0+mu6XS6awXlKwgCZWVlyb+trKzo77//puTkZCLKsVyLjY015hLMRunSpen58+fcF7YQEc2cOZNKlChBq1atooyMDDp8+DDdv38/z2KuO3fu0KxZs0gURerevbvZeRmLV2LNDe3ataNVq1bRo0ePaNasWYoyNRc6nU6mIWzfvp0+/PBDSk9PpwEDBlBYWJjFeRpCnTp1KDY2lubMmUNbt25VJQ99+Pv7U6NGjSgmJoamTZtGgiDwzcDIFoINEZ0goimGugWkYvehd+/eim6D1PeWjJQK+i8vvv/++zh+/Lgqad++fRuCIOCvv/7CX3/9BUEQ8P777+d7vJ+fH/z8/MzKSwqN171793yPqVevnrxoitcsROXKleXBskaNGnG7d/otBf31BZUqVcKgQYPkfRs3blStblhbW2P69OkIDAzkHlSWKMcmJzs7W44atm7dOoiiiGfPnpkT8YrbQKOOiLYS0apc25eTcqDxh1ffPyLlQONVI/LI90IMmS9LtCD6rkm8fPkyevfurUraUvg7Yxdx/f7778jMzDQrr1mzZsn93hUrVuSZgZg9e7Ycbn3Pnj3crnHv3r085tjzcMaMGfJ9S0pKwtOnT/H06VMkJibK2/fs2SMvilKDHTt2xPPnz9GxY0fV8sg9++Dn52eulSs3UWj/KsEAIrr1ih8SUQXKGS+4/+rTSU9E/ktEYUQUSK8ZT3idKKxduzZfUeDRL30d27Vrh4yMDNUG9xwdHXHhwgU8fvwYX3755WunshwcHDBv3jyz85OWmxsyXpI+DQmGOXR2dsbixYuRkZEBURTx/fffc713tra22L17d76rZQcOHKiqIBAR/vrrL9VjcVauXBlr1qxBdHQ0Nm3aZEmE9eJhvLRs2TIkJCTkKfCCmtg8efr06UINwKo2JTuFn376CWfPnlU8UD/99BPX5dRjx46V324PHz40e4FaQbS3t4eHhwfWrl2LtWvXwtfXF76+vli7dq3q97JixYoICQn5X6ofxUMUipo+Pj44cOBAkZ/H/yL379+PqKgo1KlTh/tKT41m0ShR0CJEadDw74EWIUqDBg2mQxMFDRo0KKCJggYNGhTQREGDBg0KaKKgQYMGBTRR0KBBgwKaKGjQoEGB/ylRqFmzJoWFhdGLFy9IEATy9vamN998k3s+b7/9Nh0+fJguXLggx3c0xJ07d1KpUqW451+c4ebmRunp6fTy5UuaPXs2BQYGEmOMez67d++mR48ecU+3qPHixQsSRTEP27Ztyy+TorZmNNWisWTJknBxccGcOXPkSDlr1qzhsg7C1tYW48aNQ1hYmEHvOpmZmbKtu8SDBw8WSsQh3qxQoQJ69uwJxhh27dr1f+1dfVBU5R5+3g0lxxjBtS7gbUBv7TjiH1e7pqCVU4P3kjNRY5EEKKWS2XUUBww/phiYpsGvP6o7flAOlKUyYw2QWLe5lVFyJRFDzA+Ey2jYGKiJuxLSnuf+sbunXdhVYM/Zs9D7zPxmz757zvs+5933POf9OOf348aNG3X3SwGApaWltFqtnDhxIgHwyy+/pNVq1bycsrIylpWVGV7P/tqcOXO4Z88ehoeHMyYmhjabzatbtn46rRn+jzk/+eST/OCDD6goCo8dO+a370SLxeLT3daePXs4Y8YM3nPPPZw5cyYLCgrY1dVFu93Oo0ePcv78+Zo1BIvFwg0bNrC2ttbjjyfJtWvX+hV7cdSoUSwoKPD6PsmJEyc0cyPmy+x2u/pCV0REBFtbW7lw4ULNyykrKyMdjSsgFhISwqioKKalpbGxsZE7d+7UJN8VK1ZQURRWV1cTAEtKSlhQUMClS5dy6dKlnDNnDsPCwvrbJoa/KADgiBEj+M4771BRFCYkJPj1B3zyySdeBaG5udnr/q+++qq6z/LlyzVpBLNmzfLKwb2HMtg3NkNDQ1XXZC47ePAga2tr1e/Hjh1jVFSUbhfPxYsX1e3Dhw+zrq5Ol3L8FQUhBKdOncq0tDRGRER4taSkJC5evJivv/46T58+rfZcFUVhbm6u3+dw1113qfm6fGhER0f7k+cfQxQAMCsrizabzS8HHitWrGBnZ2efi/H8+fM+8508ebK6nz+vBZtMJsbHx/PAgQO8ceMGL1y4wE2bNtFisTA2NpaxsbGMiYlRy3rwwQcHVc6aNWvUi//s2bNqwJywsDDu379ffWMyPT1ds4vT3cLCwtReQkFBATs7O/vETdDKtmzZ4pcojBgxgnV1dbx69apPT8o3btxgW1sb29ra+NZbbzE5OZlvv/02u7q6OGbMGL/PISoqioqi8NSpU1r5DvljiMIjjzzCzs7OgXi09Wru/gXcBeFWwVHMZrMatMWf12eXLFmi5nHu3DmvEYDeeOMNdZ/s7OwBlzF9+nTV2e3evXv7+CvMyMjQXRTmzp3LKVOmMC0tjYqiMDU1VZdyAO2GD5GRkYyPj1ctOTmZOTk5jI+P7/M/hYaGsr6+ntu2bdPkHFwu93fv3q2Jo1v8EUTBbDbz22+/ZVtbG+Pi4vyqMG+iUFpaetvjCgsL/RKF1atX8/Lly7x58yaXL1/u8w5z+vRptZwB+Pkn4JhHuHTpEkn6FM9ly5apfhX0in61bNkyRkZGqpObejrJcYmC3i7x3e25556joijMyMjQLM+qqirabLY+YfcGacNfFPLz83nz5k2uXLnS7woj2WdVITw8/LbH+SMKd955J2tqami32/n555/73M/9Lm632wcc2m316tVqFK3eY93eE4/uY36t7b333qOiKNy3b59uZbifM0lu2bJF97Lc24KiKJpFKQPAbdu2UVEUNjU1saKighUVFf7MnQ1/UVAUhbt27dKk8t17Cs3Nzf12m+0uCs8+++yAG67r2NzcXE6dOtUj1Fh0dDTnzZvH9vZ2db99+/YN2GFJfX29zwu+98SjnqJQUVHB3bt3qz0E17KkHpaSkkKSAV2WLCws5LVr1zR14GqxWNjd3e0xl9Hd3c3W1lY+88wzA81veItCenq6ppGS3UWhd7Tp2zUE13GDGSNnZmZ6neDsbS0tLYP2N+gShZ6eHr777rvMyclhQ0MDf/nllz7LknrNKbjueFarlSUlJbqucAC/i0JKSoqu5bjbyZMnmZeXp0veoaGhfOqpp7hkyRJu3ryZTU1NVBRloPMX/RKFEAxRHD16FAsWLEB1dbXRVPxCSUkJvvjiCzz66KN48cUX1fS4uDiMHj0aANDR0YH8/Hx0d3cPqozPPvsMU6ZMQUhICDIzMz1+++2337Bjxw60trZi06ZNMJn0eci1tbUVAHDw4ME+HIYDJk2ahEmTJqGnp0eX/Lu7u/Hxxx+r31977TV8/fXXiIuLQ0hIiKaxH4asKDQ1NWHdunUIDw/H9u3b0d7ejsuXLw86v6qqKiQlJQ3oGLPZjBkzZgy6TBfOnz+PkpISlJSUAHAIQk1Njfr75s2b/QoykpeXB5J4/vnnMW7cOFitVuTn56OjowNXr17FgQMHkJGRAZJQFMXf0/HAqFGjsHbtWuTm5uLIkSNoaWnRNP9gQUJCAkwmk+b15ws2mw12ux3x8fEwm83aBkQyeujgz5xCZWWlOs5qaWnhN998Q4vFMqi8xo4dq4Y07+rqYl1dnRqmy5uZzWZWVVV5dPHnzZunSVdxzZo1ap5bt27VLC6hxWJhYmIip02b1uc3PZYkx4wZww8//JB2uyPac0REBE+ePKlL97q3BXr4sGHDBiqKwgkTJgSkvPj4eHZ0dLCtra1fE+JOG95zCu4WExPD9evXU1EULl68eND5ZGZmelzkbW1tXoUhLCzM4/kEf59T6G3uTzEGaklND1EoLS1VBcE1+abnRKa7BVoUPv30U166dEmXKFG9bfz48Tx06JB6QxzAaoe2sSSDFSaTCWazGdOnTwcA/Prrr4POa//+/Th8+LAapzIyMhLl5eWorKxEQkICEhISsG7dOjQ2NuKxxx7zOFarbnF2djYAoLm5GU888QQuXLigSb6BxuzZs7Fw4ULU1tbipZdeUod2o0ePRmJiYsB4BKr+7r77bpw5c8avIaw7nn76aWzdutUjzWQyITIyEsePH8dDDz0EAKipqcGVK1c0KVOF0b0Ef3oKWVlZrKqqUhWzuLhYEyXOysq67WpAb/P33QeTycTExET29PTwu+++C+hDN4Cjp2C320lSk55CRkYGFUVhYWGhR3p9fT23b9+u+/m4egqBqj+r1cr169drll96ejptNhvff/991b766iuPpcmenh6+8MILA8l3eA0fXn75ZRYVFbGoqIh1dXVsb28nSba3t/PNN99kdHS0ZqHdTCYTFy1axEOHDt1WDH744Qfed999focny87O1nwYMhDTevgQERFBm81Gq9XK+vp6fvTRR8zJyaHNZuMrr7yi+/m4Hl4KVP0piqKpKISGhnLXrl0+37vYsWMHx48fP9B8h5cozJ8/n5WVlSwrK2NxcTGLi4s5a9YsxsbG6vZHjx07lqmpqayuru4jBhUVFUxNTfX78WoAXLVqFbu7u2m321lUVBSwhuxueswpJCYmsry8XK0zRVFYW1sbkHF3SkpKQB9c0loUAIfvkEWLFrG8vFwVg5qaGmZkZAz2Bji8RGE42siRI9UL5vr164ZyeeCBB1hUVMTr1697XZ2QdmvTQxR0MCkKwW4hISFsaGhgU1OTpi/RSAu8XblyRdPgvDqZjCUpISHhARlLUkJCYuCQoiAhIeGBYHn3oQOAzfk5lDAOkrPeGGp8geDlHNOfnYJiTgEAhBBH+zPeCSZIzvpjqPEFhiZnd8jhg4SEhAekKEhISHggmERhp9EEBgHJWX8MNb7A0OSsImjmFCQkJIIDwdRTkJCQCAIYLgpCiH8IIc4IIc4JIfKM5uMLQohWIcQJIcRxIcRRZ9pYIcTnQogm52eEwRx3CSF+FkI0uqV55SgceNNZ7w1CiGlBxDlfCNHmrOvjQojH3X5b6+R8Rgjxd4M43yuE+FIIcUoIcVIIsdKZHtR13W8Y/M7DHQCaAUwEMBLA9wAmG/0uhg+urQDG9UrbCCDPuZ0HoMhgjg8DmAag8XYcATwO4CAAAWAmgCNBxDkfQI6XfSc720gogAnOtnOHAZyjAExzbocBOOvkFtR13V8zuqfwIIBzJFtI3gSwF0CywZwGgmQApc7tUgBPGsgFJL8G0NsNjy+OyQDeowP/BRAuhIgKDNPf4YOzLyQD2Euym+T/AJyDow0FFCR/InnMuX0dwCkA4xHkdd1fGC0K4wG4+8v60ZkWjCCAfwsh6oQQWc60P5H8CXA0FAD3GMbON3xxDPa6/6ezq73LbVgWdJyFELEApgI4gqFb1x4wWhSEl7RgXQ6ZRXIagCQALwshHjaakJ8I5rrfBuAvAP4K4CcAW5zpQcVZCHEXgP0AVpHsvNWuXtKCpa77wGhR+BHAvW7f/wzgokFcbgmSF52fPwP4GI5u6yVXN9D5+bNxDH3CF8egrXuSl0jaSSoAivH7ECFoOAshRsAhCB+Q/MiZPOTq2huMFoXvANwvhJgghBgJYAGACoM59YEQYrQQIsy1DWAugEY4uC5y7rYIQLkxDG8JXxwrACx0zozPBHDN1fU1Gr3G20/BUdeAg/MCIUSoEGICgPsB1BrATwB4F8Apku4ul4dcXXuF0TOdcMzMnoVjJnm90Xx8cJwIx6z39wBOungCMAP4D4Am5+dYg3nugaO73QPH3WmxL45wdGn/5az3EwD+FkSc33dyaoDjgopy23+9k/MZAEkGcZ4NR/e/AcBxpz0e7HXdX5NPNEpISHjA6OGDhIREkEGKgoSEhAekKEhISHhAioKEhIQHpChISEh4QIqChISEB6QoSEhIeECKgoSEhAf+D61cF6aQlXMwAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# functions to show an image\n", + "def imshow(img):\n", + " npimg = img.numpy()\n", + " plt.imshow(np.transpose(npimg, (1, 2, 0)))\n", + "\n", + "# get some random training images\n", + "dataiter = iter(trainset_loader)\n", + "images, labels = dataiter.next()\n", + "\n", + "# show images\n", + "imshow(torchvision.utils.make_grid(images))\n", + "# print labels\n", + "print(' '.join('%5s' % labels[j] for j in range(16)))" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cuda\n" + ] + } + ], + "source": [ + "# Use GPU if available, otherwise stick with cpu\n", + "use_cuda = torch.cuda.is_available()\n", + "# print(use_cuda)\n", + "torch.manual_seed(123)\n", + "device = torch.device(\"cuda\" if use_cuda else \"cpu\") #cuda修改为\"cuda\"\n", + "print(device)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define a Conv Net\n" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "class Net(nn.Module):\n", + " def __init__(self):\n", + " super(Net, self).__init__()\n", + " self.conv1 = nn.Conv2d(1, 10, kernel_size=5)\n", + " self.conv2 = nn.Conv2d(10, 20, kernel_size=5)\n", + " self.conv2_drop = nn.Dropout2d()\n", + " self.fc1 = nn.Linear(320, 50)\n", + " self.fc2 = nn.Linear(50, 10)\n", + "\n", + " def forward(self, x):\n", + " x = F.relu(F.max_pool2d(self.conv1(x), 2))\n", + " x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))\n", + " x = x.view(-1, 320)\n", + " x = F.relu(self.fc1(x))\n", + " x = F.dropout(x, training=self.training)\n", + " x = self.fc2(x)\n", + " return F.log_softmax(x, dim=1)\n", + "\n", + "model = Net().to(device)\n", + "optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train the network" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "def train(epoch, log_interval=100):\n", + " model.train() # set training mode\n", + " iteration = 0\n", + " for ep in range(epoch):\n", + " for batch_idx, (data, target) in enumerate(trainset_loader):\n", + " data, target = data.to(device), target.to(device)\n", + " optimizer.zero_grad()\n", + " output = model(data)\n", + " loss = F.nll_loss(output, target)\n", + " loss.backward()\n", + " optimizer.step()\n", + " if iteration % log_interval == 0:\n", + " print('Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f}'.format(\n", + " ep, batch_idx * len(data), len(trainset_loader.dataset),\n", + " 100. * batch_idx / len(trainset_loader), loss.item()))\n", + " iteration += 1\n", + " test()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "def test():\n", + " model.eval() # set evaluation mode\n", + " test_loss = 0\n", + " correct = 0\n", + " with torch.no_grad():\n", + " for data, target in testset_loader:\n", + " data, target = data.to(device), target.to(device)\n", + " output = model(data)\n", + " test_loss += F.nll_loss(output, target, size_average=False).item() # sum up batch loss\n", + " pred = output.max(1, keepdim=True)[1] # get the index of the max log-probability\n", + " correct += pred.eq(target.view_as(pred)).sum().item()\n", + "\n", + " test_loss /= len(testset_loader.dataset)\n", + " print('\\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\\n'.format(\n", + " test_loss, correct, len(testset_loader.dataset),\n", + " 100. * correct / len(testset_loader.dataset)))" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.290237\n", + "Train Epoch: 0 [6400/60000 (11%)]\tLoss: 2.279487\n", + "Train Epoch: 0 [12800/60000 (21%)]\tLoss: 2.306477\n", + "Train Epoch: 0 [19200/60000 (32%)]\tLoss: 2.285570\n", + "Train Epoch: 0 [25600/60000 (43%)]\tLoss: 2.263388\n", + "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 2.268107\n", + "Train Epoch: 0 [38400/60000 (64%)]\tLoss: 2.152959\n", + "Train Epoch: 0 [44800/60000 (75%)]\tLoss: 2.045983\n", + "Train Epoch: 0 [51200/60000 (85%)]\tLoss: 1.678735\n", + "Train Epoch: 0 [57600/60000 (96%)]\tLoss: 1.234961\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\S5C\\Anaconda3\\envs\\cs231n\\lib\\site-packages\\torch\\nn\\functional.py:52: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.\n", + " warnings.warn(warning.format(ret))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Test set: Average loss: 0.9647, Accuracy: 7910/10000 (79%)\n", + "\n", + "Train Epoch: 1 [3968/60000 (7%)]\tLoss: 0.610095\n", + "Train Epoch: 1 [10368/60000 (17%)]\tLoss: 0.502775\n", + "Train Epoch: 1 [16768/60000 (28%)]\tLoss: 0.451482\n", + "Train Epoch: 1 [23168/60000 (39%)]\tLoss: 0.446936\n", + "Train Epoch: 1 [29568/60000 (49%)]\tLoss: 0.382422\n", + "Train Epoch: 1 [35968/60000 (60%)]\tLoss: 0.474024\n", + "Train Epoch: 1 [42368/60000 (71%)]\tLoss: 0.265747\n", + "Train Epoch: 1 [48768/60000 (81%)]\tLoss: 0.440694\n", + "Train Epoch: 1 [55168/60000 (92%)]\tLoss: 0.272903\n", + "\n", + "Test set: Average loss: 0.2565, Accuracy: 9221/10000 (92%)\n", + "\n", + "Train Epoch: 2 [1536/60000 (3%)]\tLoss: 0.332854\n", + "Train Epoch: 2 [7936/60000 (13%)]\tLoss: 0.272117\n", + "Train Epoch: 2 [14336/60000 (24%)]\tLoss: 0.226856\n", + "Train Epoch: 2 [20736/60000 (35%)]\tLoss: 0.296948\n", + "Train Epoch: 2 [27136/60000 (45%)]\tLoss: 0.168455\n", + "Train Epoch: 2 [33536/60000 (56%)]\tLoss: 0.114530\n", + "Train Epoch: 2 [39936/60000 (67%)]\tLoss: 0.190551\n", + "Train Epoch: 2 [46336/60000 (77%)]\tLoss: 0.074420\n", + "Train Epoch: 2 [52736/60000 (88%)]\tLoss: 0.122026\n", + "Train Epoch: 2 [59136/60000 (99%)]\tLoss: 0.212592\n", + "\n", + "Test set: Average loss: 0.1509, Accuracy: 9560/10000 (96%)\n", + "\n", + "Train Epoch: 3 [5504/60000 (9%)]\tLoss: 0.197020\n", + "Train Epoch: 3 [11904/60000 (20%)]\tLoss: 0.051037\n", + "Train Epoch: 3 [18304/60000 (30%)]\tLoss: 0.208621\n", + "Train Epoch: 3 [24704/60000 (41%)]\tLoss: 0.192203\n", + "Train Epoch: 3 [31104/60000 (52%)]\tLoss: 0.060189\n", + "Train Epoch: 3 [37504/60000 (62%)]\tLoss: 0.181853\n", + "Train Epoch: 3 [43904/60000 (73%)]\tLoss: 0.034382\n", + "Train Epoch: 3 [50304/60000 (84%)]\tLoss: 0.065388\n", + "Train Epoch: 3 [56704/60000 (94%)]\tLoss: 0.120279\n", + "\n", + "Test set: Average loss: 0.1117, Accuracy: 9674/10000 (97%)\n", + "\n", + "Train Epoch: 4 [3072/60000 (5%)]\tLoss: 0.155196\n", + "Train Epoch: 4 [9472/60000 (16%)]\tLoss: 0.171064\n", + "Train Epoch: 4 [15872/60000 (26%)]\tLoss: 0.225294\n", + "Train Epoch: 4 [22272/60000 (37%)]\tLoss: 0.229500\n", + "Train Epoch: 4 [28672/60000 (48%)]\tLoss: 0.120323\n", + "Train Epoch: 4 [35072/60000 (58%)]\tLoss: 0.155583\n", + "Train Epoch: 4 [41472/60000 (69%)]\tLoss: 0.272146\n", + "Train Epoch: 4 [47872/60000 (80%)]\tLoss: 0.113681\n", + "Train Epoch: 4 [54272/60000 (90%)]\tLoss: 0.175139\n", + "\n", + "Test set: Average loss: 0.0938, Accuracy: 9727/10000 (97%)\n", + "\n" + ] + } + ], + "source": [ + "train(5) # train 5 epochs should get you to about 97% accuracy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Save the model (model checkpointing)\n", + "\n", + "Now we have a model! Obviously we do not want to retrain the model everytime we want to use it. Plus if you are training a super big model, you probably want to save checkpoint periodically so that you can always fall back to the last checkpoint in case something bad happened or you simply want to test models at different training iterations.\n", + "\n", + "Model checkpointing is fairly simple in PyTorch. First, we define a helper function that can save a model to the disk" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "def save_checkpoint(checkpoint_path, model, optimizer):\n", + " state = {'state_dict': model.state_dict(),\n", + " 'optimizer' : optimizer.state_dict()}\n", + " torch.save(state, checkpoint_path)\n", + " print('model saved to %s' % checkpoint_path)\n", + " \n", + "def load_checkpoint(checkpoint_path, model, optimizer):\n", + " state = torch.load(checkpoint_path)\n", + " model.load_state_dict(state['state_dict'])\n", + " optimizer.load_state_dict(state['optimizer'])\n", + " print('model loaded from %s' % checkpoint_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\S5C\\Anaconda3\\envs\\cs231n\\lib\\site-packages\\torch\\nn\\functional.py:52: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.\n", + " warnings.warn(warning.format(ret))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Test set: Average loss: 2.3043, Accuracy: 920/10000 (9%)\n", + "\n" + ] + } + ], + "source": [ + "# create a brand new model\n", + "model = Net().to(device)\n", + "optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n", + "test()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define a training loop with model checkpointing" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "def train_save(epoch, save_interval, log_interval=100):\n", + " model.train() # set training mode\n", + " iteration = 0\n", + " for ep in range(epoch):\n", + " for batch_idx, (data, target) in enumerate(trainset_loader):\n", + " data, target = data.to(device), target.to(device)\n", + " optimizer.zero_grad()\n", + " output = model(data)\n", + " loss = F.nll_loss(output, target)\n", + " loss.backward()\n", + " optimizer.step()\n", + " if iteration % log_interval == 0:\n", + " print('Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f}'.format(\n", + " ep, batch_idx * len(data), len(trainset_loader.dataset),\n", + " 100. * batch_idx / len(trainset_loader), loss.item()))\n", + " if iteration % save_interval == 0 and iteration > 0:\n", + " save_checkpoint('mnist-%i.pth' % iteration, model, optimizer)\n", + " iteration += 1\n", + " test()\n", + " \n", + " # save the final model\n", + " save_checkpoint('mnist-%i.pth' % iteration, model, optimizer)" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Epoch: 0 [0/60000 (0%)]\tLoss: 2.330722\n", + "Train Epoch: 0 [6400/60000 (11%)]\tLoss: 2.326233\n", + "Train Epoch: 0 [12800/60000 (21%)]\tLoss: 2.294042\n", + "Train Epoch: 0 [19200/60000 (32%)]\tLoss: 2.270671\n", + "Train Epoch: 0 [25600/60000 (43%)]\tLoss: 2.273622\n", + "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 2.219109\n", + "model saved to mnist-500.pth\n", + "Train Epoch: 0 [38400/60000 (64%)]\tLoss: 2.088969\n", + "Train Epoch: 0 [44800/60000 (75%)]\tLoss: 1.871806\n", + "Train Epoch: 0 [51200/60000 (85%)]\tLoss: 1.651790\n", + "Train Epoch: 0 [57600/60000 (96%)]\tLoss: 1.297873\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\S5C\\Anaconda3\\envs\\cs231n\\lib\\site-packages\\torch\\nn\\functional.py:52: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.\n", + " warnings.warn(warning.format(ret))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Test set: Average loss: 0.8638, Accuracy: 7980/10000 (80%)\n", + "\n", + "Train Epoch: 1 [3968/60000 (7%)]\tLoss: 0.747120\n", + "model saved to mnist-1000.pth\n", + "Train Epoch: 1 [10368/60000 (17%)]\tLoss: 0.440646\n", + "Train Epoch: 1 [16768/60000 (28%)]\tLoss: 0.391530\n", + "Train Epoch: 1 [23168/60000 (39%)]\tLoss: 0.212344\n", + "Train Epoch: 1 [29568/60000 (49%)]\tLoss: 0.506478\n", + "Train Epoch: 1 [35968/60000 (60%)]\tLoss: 0.291581\n", + "model saved to mnist-1500.pth\n", + "Train Epoch: 1 [42368/60000 (71%)]\tLoss: 0.205183\n", + "Train Epoch: 1 [48768/60000 (81%)]\tLoss: 0.214830\n", + "Train Epoch: 1 [55168/60000 (92%)]\tLoss: 0.271816\n", + "\n", + "Test set: Average loss: 0.2305, Accuracy: 9337/10000 (93%)\n", + "\n", + "Train Epoch: 2 [1536/60000 (3%)]\tLoss: 0.267834\n", + "Train Epoch: 2 [7936/60000 (13%)]\tLoss: 0.192830\n", + "model saved to mnist-2000.pth\n", + "Train Epoch: 2 [14336/60000 (24%)]\tLoss: 0.155319\n", + "Train Epoch: 2 [20736/60000 (35%)]\tLoss: 0.191618\n", + "Train Epoch: 2 [27136/60000 (45%)]\tLoss: 0.156086\n", + "Train Epoch: 2 [33536/60000 (56%)]\tLoss: 0.312420\n", + "Train Epoch: 2 [39936/60000 (67%)]\tLoss: 0.144673\n", + "model saved to mnist-2500.pth\n", + "Train Epoch: 2 [46336/60000 (77%)]\tLoss: 0.319915\n", + "Train Epoch: 2 [52736/60000 (88%)]\tLoss: 0.143919\n", + "Train Epoch: 2 [59136/60000 (99%)]\tLoss: 0.278233\n", + "\n", + "Test set: Average loss: 0.1561, Accuracy: 9547/10000 (95%)\n", + "\n", + "Train Epoch: 3 [5504/60000 (9%)]\tLoss: 0.085018\n", + "Train Epoch: 3 [11904/60000 (20%)]\tLoss: 0.153313\n", + "model saved to mnist-3000.pth\n", + "Train Epoch: 3 [18304/60000 (30%)]\tLoss: 0.256529\n", + "Train Epoch: 3 [24704/60000 (41%)]\tLoss: 0.074828\n", + "Train Epoch: 3 [31104/60000 (52%)]\tLoss: 0.203295\n", + "Train Epoch: 3 [37504/60000 (62%)]\tLoss: 0.080737\n", + "Train Epoch: 3 [43904/60000 (73%)]\tLoss: 0.210619\n", + "model saved to mnist-3500.pth\n", + "Train Epoch: 3 [50304/60000 (84%)]\tLoss: 0.136949\n", + "Train Epoch: 3 [56704/60000 (94%)]\tLoss: 0.118183\n", + "\n", + "Test set: Average loss: 0.1273, Accuracy: 9600/10000 (96%)\n", + "\n", + "Train Epoch: 4 [3072/60000 (5%)]\tLoss: 0.062027\n", + "Train Epoch: 4 [9472/60000 (16%)]\tLoss: 0.057842\n", + "Train Epoch: 4 [15872/60000 (26%)]\tLoss: 0.161355\n", + "model saved to mnist-4000.pth\n", + "Train Epoch: 4 [22272/60000 (37%)]\tLoss: 0.091386\n", + "Train Epoch: 4 [28672/60000 (48%)]\tLoss: 0.259248\n", + "Train Epoch: 4 [35072/60000 (58%)]\tLoss: 0.071144\n", + "Train Epoch: 4 [41472/60000 (69%)]\tLoss: 0.044133\n", + "Train Epoch: 4 [47872/60000 (80%)]\tLoss: 0.136877\n", + "model saved to mnist-4500.pth\n", + "Train Epoch: 4 [54272/60000 (90%)]\tLoss: 0.147086\n", + "\n", + "Test set: Average loss: 0.0994, Accuracy: 9693/10000 (97%)\n", + "\n", + "model saved to mnist-4690.pth\n" + ] + } + ], + "source": [ + "train_save(5, 500, 100)" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model loaded from mnist-4690.pth\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\S5C\\Anaconda3\\envs\\cs231n\\lib\\site-packages\\torch\\nn\\functional.py:52: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.\n", + " warnings.warn(warning.format(ret))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Test set: Average loss: 0.0994, Accuracy: 9693/10000 (97%)\n", + "\n" + ] + } + ], + "source": [ + "# create a new model\n", + "model = Net().to(device)\n", + "optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n", + "# load from the final checkpoint\n", + "load_checkpoint('mnist-4690.pth', model, optimizer)\n", + "# should give you the final model accuracy\n", + "test()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Fine-tune a model\n", + "\n", + "Sometimes you want to fine-tune a pretrained model instead of training a model from scratch. For example, if you want to train a model on a new dataset that contains natural images. To achieve the best performance, you can start with a model that's fully trained on ImageNet and fine-tune the model.\n", + "\n", + "Finetuning a model in PyTorch is super easy! First, let's find out what we saved in a checkpoint" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "odict_keys(['conv1.weight', 'conv1.bias', 'conv2.weight', 'conv2.bias', 'fc1.weight', 'fc1.bias', 'fc2.weight', 'fc2.bias'])\n" + ] + } + ], + "source": [ + "# What's in a state dict?\n", + "print(model.state_dict().keys())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Finetune the fc layers\n", + "\n", + "Now say we want to load the conv layers from the checkpoint and train the fc layers. We can simply load a subset of the state dict with the selected names" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [], + "source": [ + "checkpoint = torch.load('mnist-4690.pth')\n", + "states_to_load = {}\n", + "for name, param in checkpoint['state_dict'].items():\n", + " if name.startswith('conv'):\n", + " states_to_load[name] = param\n", + "\n", + "# Construct a new state dict in which the layers we want\n", + "# to import from the checkpoint is update with the parameters\n", + "# from the checkpoint\n", + "\n", + "# model_state = model.state_dict()\n", + "# print(model_state)\n", + "# print(\"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\")\n", + "# print(\"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\")\n", + "# print(\"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\")\n", + "# model_state.update(states_to_load)\n", + "# print(model_state)\n", + " \n", + "model = Net().to(device)\n", + "\n", + "# print(model_state)\n", + "model_state = model.state_dict()\n", + "model_state.update(states_to_load)\n", + "# print(\"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\")\n", + "# print(\"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\")\n", + "# print(\"@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\")\n", + "# print(model_state)\n", + "\n", + "model.load_state_dict(model_state)\n", + "optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Epoch: 0 [0/60000 (0%)]\tLoss: 3.140968\n", + "Train Epoch: 0 [6400/60000 (11%)]\tLoss: 1.328379\n", + "Train Epoch: 0 [12800/60000 (21%)]\tLoss: 1.113234\n", + "Train Epoch: 0 [19200/60000 (32%)]\tLoss: 0.754136\n", + "Train Epoch: 0 [25600/60000 (43%)]\tLoss: 0.592636\n", + "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 0.732576\n", + "Train Epoch: 0 [38400/60000 (64%)]\tLoss: 0.592743\n", + "Train Epoch: 0 [44800/60000 (75%)]\tLoss: 0.686322\n", + "Train Epoch: 0 [51200/60000 (85%)]\tLoss: 0.627994\n", + "Train Epoch: 0 [57600/60000 (96%)]\tLoss: 0.584201\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\S5C\\Anaconda3\\envs\\cs231n\\lib\\site-packages\\torch\\nn\\functional.py:52: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.\n", + " warnings.warn(warning.format(ret))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Test set: Average loss: 0.2296, Accuracy: 9373/10000 (94%)\n", + "\n" + ] + } + ], + "source": [ + "train(1) # training 1 epoch will get you to 93%!" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "outputs": [], + "source": [ + "# print(model_state)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Import pretrained weights in a different model\n", + "\n", + "We can even use the pretrained conv layers in a different model." + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [], + "source": [ + "class SmallNet(nn.Module):\n", + " def __init__(self):\n", + " super(SmallNet, self).__init__()\n", + " self.conv1 = nn.Conv2d(1, 10, kernel_size=5)\n", + " self.conv2 = nn.Conv2d(10, 20, kernel_size=5)\n", + " self.conv2_drop = nn.Dropout2d()\n", + " self.fc1 = nn.Linear(320, 10)\n", + "\n", + " def forward(self, x):\n", + " x = F.relu(F.max_pool2d(self.conv1(x), 2))\n", + " x = F.relu(F.max_pool2d(self.conv2_drop(self.conv2(x)), 2))\n", + " x = x.view(-1, 320)\n", + " x = self.fc1(x)\n", + " return F.log_softmax(x, dim=1)\n", + "\n", + "model = SmallNet().to(device)\n", + "optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [], + "source": [ + "checkpoint = torch.load('mnist-4690.pth')\n", + "states_to_load = {}\n", + "for name, param in checkpoint['state_dict'].items():\n", + " if name.startswith('conv'):\n", + " states_to_load[name] = param\n", + "\n", + "# Construct a new state dict in which the layers we want\n", + "# to import from the checkpoint is update with the parameters\n", + "# from the checkpoint\n", + "model_state = model.state_dict()\n", + "model_state.update(states_to_load)\n", + " \n", + "model.load_state_dict(model_state)" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Epoch: 0 [0/60000 (0%)]\tLoss: 4.571345\n", + "Train Epoch: 0 [6400/60000 (11%)]\tLoss: 0.437767\n", + "Train Epoch: 0 [12800/60000 (21%)]\tLoss: 0.487225\n", + "Train Epoch: 0 [19200/60000 (32%)]\tLoss: 0.322790\n", + "Train Epoch: 0 [25600/60000 (43%)]\tLoss: 0.226269\n", + "Train Epoch: 0 [32000/60000 (53%)]\tLoss: 0.478504\n", + "Train Epoch: 0 [38400/60000 (64%)]\tLoss: 0.475812\n", + "Train Epoch: 0 [44800/60000 (75%)]\tLoss: 0.300295\n", + "Train Epoch: 0 [51200/60000 (85%)]\tLoss: 0.453170\n", + "Train Epoch: 0 [57600/60000 (96%)]\tLoss: 0.200097\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\S5C\\Anaconda3\\envs\\cs231n\\lib\\site-packages\\torch\\nn\\functional.py:52: UserWarning: size_average and reduce args will be deprecated, please use reduction='sum' instead.\n", + " warnings.warn(warning.format(ret))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Test set: Average loss: 0.1481, Accuracy: 9567/10000 (96%)\n", + "\n" + ] + } + ], + "source": [ + "train(1) # training 1 epoch will get you to 93%!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/Python Numpy Tutorial.ipynb b/Python Numpy Tutorial.ipynb new file mode 100644 index 000000000..f01ebf660 --- /dev/null +++ b/Python Numpy Tutorial.ipynb @@ -0,0 +1,498 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'python' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mpython\u001b[0m \u001b[1;33m-\u001b[0m\u001b[1;33m-\u001b[0m\u001b[0mversion\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mNameError\u001b[0m: name 'python' is not defined" + ] + } + ], + "source": [ + "python --version" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "2.5 3.5 5.0 6.25\n" + ] + } + ], + "source": [ + "y = 2.5\n", + "print(type(y)) # Prints \"\"\n", + "print(y, y + 1, y * 2, y ** 2) # Prints \"2.5 3.5 5.0 6.25\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5 3.5 5.0 6.25\n" + ] + } + ], + "source": [ + "print(y,y + 1,y * 2, y ** 2) " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5 3\n" + ] + } + ], + "source": [ + "a = 5\n", + "A = 3\n", + "print(a, A)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello\n", + "HELLO\n", + " hello\n", + " hello \n", + "he(ell)(ell)o\n", + "world\n" + ] + } + ], + "source": [ + "s = \"hello\"\n", + "print(s.capitalize()) # Capitalize a string; prints \"Hello\"\n", + "print(s.upper()) # Convert a string to uppercase; prints \"HELLO\"\n", + "print(s.rjust(7)) # Right-justify a string, padding with spaces; prints \" hello\"\n", + "print(s.center(7)) # Center a string, padding with spaces; prints \" hello \"\n", + "print(s.replace('l', '(ell)')) # Replace all instances of one substring with another;\n", + " # prints \"he(ell)(ell)o\"\n", + "print(' world '.strip()) # Strip leading and trailing whitespace; prints \"world\"" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3, 1, 2] 2\n", + "2\n", + "1\n" + ] + } + ], + "source": [ + "xs = [3, 1, 2] # Create a list\n", + "print(xs, xs[2]) # Prints \"[3, 1, 2] 2\"\n", + "print(xs[-1]) \n", + "print(xs[-2])" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'dog' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0md\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;34m'cat'\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m'cute'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdog\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;34m'furry'\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[1;31mNameError\u001b[0m: name 'dog' is not defined" + ] + } + ], + "source": [ + "d = {'cat': 'cute', dog: 'furry'} \n", + "print(d[\"cat\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cute\n", + "True\n", + "wet\n", + "N\n", + "wet\n", + "N/A\n" + ] + } + ], + "source": [ + "d = {'cat': 'cute', 'dog': 'furry'} # Create a new dictionary with some data\n", + "print(d['cat']) # Get an entry from a dictionary; prints \"cute\"\n", + "print('cat' in d) # Check if a dictionary has a given key; prints \"True\"\n", + "d['fish'] = 'wet' # Set an entry in a dictionary\n", + "print(d['fish']) # Prints \"wet\"\n", + "# print(d['monkey']) # KeyError: 'monkey' not a key of d\n", + "print(d.get('monkey', 'N')) # Get an element with a default; prints \"N/A\"\n", + "print(d.get('fish', 'N/A')) # Get an element with a default; prints \"wet\"\n", + "del d['fish'] # Remove an element from a dictionary\n", + "print(d.get('fish', 'N/A')) # \"fish\" is no longer a key; prints \"N/A\"" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "#1: fish\n", + "#2: dog\n", + "#3: cat\n" + ] + } + ], + "source": [ + "animals = {'cat', 'dog', 'fish'}\n", + "for idx, animal in enumerate(animals):\n", + " print('#%d: %s' % (idx + 1, animal))\n", + "# Prints \"#1: fish\", \"#2: dog\", \"#3: cat\"" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{0, 1, 2, 3, 4, 5}\n" + ] + } + ], + "source": [ + "from math import sqrt\n", + "nums = {int(sqrt(x)) for x in range(30)}\n", + "print(nums) # Prints \"{0, 1, 2, 3, 4, 5}\"" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0.00911691 -0.35159179]\n", + " [-0.91385663 -0.79634708]]\n", + "[[0.75842822 0.74655272]\n", + " [0.31028694 0.84383828]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "print(np.random.randn(2,2))\n", + "# e = np.random.random((2,2)) # Create an array filled with random values\n", + "# print(e)\n", + "print(np.random.random((2,2)))" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1 2]\n", + " [3 4]]\n", + "[[1 3]\n", + " [2 4]]\n", + "[1 2 3]\n", + "[1 2 3]\n", + "[[1 2 3]]\n", + "[[1]\n", + " [2]\n", + " [3]]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "x = np.array([[1,2], [3,4]])\n", + "print(x) # Prints \"[[1 2]\n", + " # [3 4]]\"\n", + "print(x.T) # Prints \"[[1 3]\n", + " # [2 4]]\"\n", + "\n", + "# Note that taking the transpose of a rank 1 array does nothing:\n", + "v = np.array([1,2,3])\n", + "print(v) # Prints \"[1 2 3]\"\n", + "print(v.T) # Prints \"[1 2 3]\"\n", + "v = np.array([[1,2,3]])\n", + "print(v) # Prints \"[[1 2 3]]\"\n", + "print(v.T) # Prints \"[[1]\n", + " # [2]\n", + " # [3]]\"" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1],\n", + " [2],\n", + " [3]])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v = np.array([1,2,3]) # v has shape (3,)\n", + "v.reshape((3,1))" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0 1]\n", + " [1 0]\n", + " [2 0]]\n", + "[[0. 1.41421356 2.23606798]\n", + " [1.41421356 0. 1. ]\n", + " [2.23606798 1. 0. ]]\n", + "[1.41421356 2.23606798 1. ]\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "from scipy.spatial.distance import pdist, squareform\n", + "\n", + "# Create the following array where each row is a point in 2D space:\n", + "# [[0 1]\n", + "# [1 0]\n", + "# [2 0]]\n", + "x = np.array([[0, 1], [1, 0], [2, 0]])\n", + "print(x)\n", + "\n", + "# Compute the Euclidean distance between all rows of x.\n", + "# d[i, j] is the Euclidean distance between x[i, :] and x[j, :],\n", + "# and d is the following array:\n", + "# [[ 0. 1.41421356 2.23606798]\n", + "# [ 1.41421356 0. 1. ]\n", + "# [ 2.23606798 1. 0. ]]\n", + "d = squareform(pdist(x, 'euclidean'))\n", + "print(d)\n", + "d = (pdist(x, 'euclidean'))\n", + "print(d)" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(95,)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Compute the x and y coordinates for points on a sine curve\n", + "x = np.arange(0, 3 * np.pi, 0.1)\n", + "print(x.shape)\n", + "y = np.sin(x)\n", + "\n", + "# Plot the points using matplotlib\n", + "plt.plot(x, y)\n", + "plt.show() # You must call plt.show() to make graphics appear." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Compute the x and y coordinates for points on sine and cosine curves\n", + "x = np.arange(0, 3 * np.pi, 0.1)\n", + "y_sin = np.sin(x)\n", + "y_cos = np.cos(x)\n", + "\n", + "# Plot the points using matplotlib\n", + "plt.plot(x, y_sin)\n", + "plt.plot(x, y_cos)\n", + "plt.xlabel('x axis label')\n", + "plt.ylabel('y axis label')\n", + "plt.title('Sine and Cosine')\n", + "plt.legend(['Sine', 'Cosine'])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Set up a subplot grid that has height 2 and width 1,\n", + "# and set the first such subplot as active.\n", + "plt.subplot(2, 1, 1)\n", + "\n", + "# Make the first plot\n", + "plt.plot(x, y_sin)\n", + "plt.title('Sine')\n", + "\n", + "# Set the second subplot as active, and make the second plot.\n", + "plt.subplot(2, 1, 2)\n", + "plt.plot(x, y_cos)\n", + "plt.title('Cosine')\n", + "\n", + "# Show the figure.\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/README.md b/README.md new file mode 100644 index 000000000..c89c0d486 --- /dev/null +++ b/README.md @@ -0,0 +1 @@ +# CS231n-Spring-2018 diff --git a/assignment1/.gitignore b/assignment1/.gitignore new file mode 100644 index 000000000..b0611d380 --- /dev/null +++ b/assignment1/.gitignore @@ -0,0 +1,3 @@ +*.swp +*.pyc +.env/* diff --git a/assignment1/.ipynb_checkpoints/features-checkpoint.ipynb b/assignment1/.ipynb_checkpoints/features-checkpoint.ipynb new file mode 100644 index 000000000..4ee38fa29 --- /dev/null +++ b/assignment1/.ipynb_checkpoints/features-checkpoint.ipynb @@ -0,0 +1,561 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Image features exercise\n", + "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n", + "\n", + "We have seen that we can achieve reasonable performance on an image classification task by training a linear classifier on the pixels of the input image. In this exercise we will show that we can improve our classification performance by training linear classifiers not on raw pixels but on features that are computed from the raw pixels.\n", + "\n", + "All of your work for this exercise will be done in this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "import random\n", + "import numpy as np\n", + "from cs231n.data_utils import load_CIFAR10\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "# for auto-reloading extenrnal modules\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load data\n", + "Similar to previous exercises, we will load CIFAR-10 data from disk." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from cs231n.features import color_histogram_hsv, hog_feature\n", + "\n", + "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n", + " # Load the raw CIFAR-10 data\n", + " cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n", + "\n", + " X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n", + " \n", + " # Subsample the data\n", + " mask = list(range(num_training, num_training + num_validation))\n", + " X_val = X_train[mask]\n", + " y_val = y_train[mask]\n", + " mask = list(range(num_training))\n", + " X_train = X_train[mask]\n", + " y_train = y_train[mask]\n", + " mask = list(range(num_test))\n", + " X_test = X_test[mask]\n", + " y_test = y_test[mask]\n", + " \n", + " return X_train, y_train, X_val, y_val, X_test, y_test\n", + "\n", + "# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n", + "try:\n", + " del X_train, y_train\n", + " del X_test, y_test\n", + " print('Clear previously loaded data.')\n", + "except:\n", + " pass\n", + "\n", + "X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extract Features\n", + "For each image we will compute a Histogram of Oriented\n", + "Gradients (HOG) as well as a color histogram using the hue channel in HSV\n", + "color space. We form our final feature vector for each image by concatenating\n", + "the HOG and color histogram feature vectors.\n", + "\n", + "Roughly speaking, HOG should capture the texture of the image while ignoring\n", + "color information, and the color histogram represents the color of the input\n", + "image while ignoring texture. As a result, we expect that using both together\n", + "ought to work better than using either alone. Verifying this assumption would\n", + "be a good thing to try for your interests.\n", + "\n", + "The `hog_feature` and `color_histogram_hsv` functions both operate on a single\n", + "image and return a feature vector for that image. The extract_features\n", + "function takes a set of images and a list of feature functions and evaluates\n", + "each feature function on each image, storing the results in a matrix where\n", + "each column is the concatenation of all feature vectors for a single image." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done extracting features for 1000 / 49000 images\n", + "Done extracting features for 2000 / 49000 images\n", + "Done extracting features for 3000 / 49000 images\n", + "Done extracting features for 4000 / 49000 images\n", + "Done extracting features for 5000 / 49000 images\n", + "Done extracting features for 6000 / 49000 images\n", + "Done extracting features for 7000 / 49000 images\n", + "Done extracting features for 8000 / 49000 images\n", + "Done extracting features for 9000 / 49000 images\n", + "Done extracting features for 10000 / 49000 images\n", + "Done extracting features for 11000 / 49000 images\n", + "Done extracting features for 12000 / 49000 images\n", + "Done extracting features for 13000 / 49000 images\n", + "Done extracting features for 14000 / 49000 images\n", + "Done extracting features for 15000 / 49000 images\n", + "Done extracting features for 16000 / 49000 images\n", + "Done extracting features for 17000 / 49000 images\n", + "Done extracting features for 18000 / 49000 images\n", + "Done extracting features for 19000 / 49000 images\n", + "Done extracting features for 20000 / 49000 images\n", + "Done extracting features for 21000 / 49000 images\n", + "Done extracting features for 22000 / 49000 images\n", + "Done extracting features for 23000 / 49000 images\n", + "Done extracting features for 24000 / 49000 images\n", + "Done extracting features for 25000 / 49000 images\n", + "Done extracting features for 26000 / 49000 images\n", + "Done extracting features for 27000 / 49000 images\n", + "Done extracting features for 28000 / 49000 images\n", + "Done extracting features for 29000 / 49000 images\n", + "Done extracting features for 30000 / 49000 images\n", + "Done extracting features for 31000 / 49000 images\n", + "Done extracting features for 32000 / 49000 images\n", + "Done extracting features for 33000 / 49000 images\n", + "Done extracting features for 34000 / 49000 images\n", + "Done extracting features for 35000 / 49000 images\n", + "Done extracting features for 36000 / 49000 images\n", + "Done extracting features for 37000 / 49000 images\n", + "Done extracting features for 38000 / 49000 images\n", + "Done extracting features for 39000 / 49000 images\n", + "Done extracting features for 40000 / 49000 images\n", + "Done extracting features for 41000 / 49000 images\n", + "Done extracting features for 42000 / 49000 images\n", + "Done extracting features for 43000 / 49000 images\n", + "Done extracting features for 44000 / 49000 images\n", + "Done extracting features for 45000 / 49000 images\n", + "Done extracting features for 46000 / 49000 images\n", + "Done extracting features for 47000 / 49000 images\n", + "Done extracting features for 48000 / 49000 images\n" + ] + } + ], + "source": [ + "from cs231n.features import *\n", + "\n", + "num_color_bins = 10 # Number of bins in the color histogram\n", + "feature_fns = [hog_feature, lambda img: color_histogram_hsv(img, nbin=num_color_bins)]\n", + "X_train_feats = extract_features(X_train, feature_fns, verbose=True)\n", + "X_val_feats = extract_features(X_val, feature_fns)\n", + "X_test_feats = extract_features(X_test, feature_fns)\n", + "\n", + "# Preprocessing: Subtract the mean feature\n", + "\n", + "mean_feat = np.mean(X_train_feats, axis=0, keepdims=True)\n", + "X_train_feats -= mean_feat\n", + "X_val_feats -= mean_feat\n", + "X_test_feats -= mean_feat\n", + "\n", + "# Preprocessing: Divide by standard deviation. This ensures that each feature\n", + "# has roughly the same scale.\n", + "std_feat = np.std(X_train_feats, axis=0, keepdims=True)\n", + "X_train_feats /= std_feat\n", + "X_val_feats /= std_feat\n", + "X_test_feats /= std_feat\n", + "\n", + "# Preprocessing: Add a bias dimension\n", + "X_train_feats = np.hstack([X_train_feats, np.ones((X_train_feats.shape[0], 1))])\n", + "X_val_feats = np.hstack([X_val_feats, np.ones((X_val_feats.shape[0], 1))])\n", + "X_test_feats = np.hstack([X_test_feats, np.ones((X_test_feats.shape[0], 1))])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(49000, 155)\n" + ] + } + ], + "source": [ + "print(X_train_feats.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train SVM on features\n", + "Using the multiclass SVM code developed earlier in the assignment, train SVMs on top of the features extracted above; this should achieve better results than training SVMs directly on top of raw pixels." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "lr 3.000000e-08 reg 4.000000e+05 train accuracy: 0.093327 val accuracy: 0.099000\n", + "lr 3.000000e-08 reg 4.500000e+05 train accuracy: 0.097224 val accuracy: 0.100000\n", + "lr 3.000000e-08 reg 5.000000e+05 train accuracy: 0.122204 val accuracy: 0.132000\n", + "lr 3.000000e-08 reg 5.500000e+05 train accuracy: 0.109612 val accuracy: 0.115000\n", + "lr 3.000000e-08 reg 6.000000e+06 train accuracy: 0.376898 val accuracy: 0.372000\n", + "lr 6.000000e-08 reg 4.000000e+05 train accuracy: 0.098184 val accuracy: 0.085000\n", + "lr 6.000000e-08 reg 4.500000e+05 train accuracy: 0.107837 val accuracy: 0.117000\n", + "lr 6.000000e-08 reg 5.000000e+05 train accuracy: 0.118306 val accuracy: 0.101000\n", + "lr 6.000000e-08 reg 5.500000e+05 train accuracy: 0.200449 val accuracy: 0.231000\n", + "lr 6.000000e-08 reg 6.000000e+06 train accuracy: 0.317000 val accuracy: 0.315000\n", + "lr 7.000000e-08 reg 4.000000e+05 train accuracy: 0.145939 val accuracy: 0.138000\n", + "lr 7.000000e-08 reg 4.500000e+05 train accuracy: 0.168735 val accuracy: 0.148000\n", + "lr 7.000000e-08 reg 5.000000e+05 train accuracy: 0.228000 val accuracy: 0.215000\n", + "lr 7.000000e-08 reg 5.500000e+05 train accuracy: 0.317286 val accuracy: 0.311000\n", + "lr 7.000000e-08 reg 6.000000e+06 train accuracy: 0.343224 val accuracy: 0.361000\n", + "lr 8.000000e-08 reg 4.000000e+05 train accuracy: 0.197816 val accuracy: 0.213000\n", + "lr 8.000000e-08 reg 4.500000e+05 train accuracy: 0.271082 val accuracy: 0.258000\n", + "lr 8.000000e-08 reg 5.000000e+05 train accuracy: 0.358286 val accuracy: 0.356000\n", + "lr 8.000000e-08 reg 5.500000e+05 train accuracy: 0.392082 val accuracy: 0.404000\n", + "lr 8.000000e-08 reg 6.000000e+06 train accuracy: 0.310878 val accuracy: 0.294000\n", + "lr 9.000000e-08 reg 4.000000e+05 train accuracy: 0.277102 val accuracy: 0.293000\n", + "lr 9.000000e-08 reg 4.500000e+05 train accuracy: 0.357796 val accuracy: 0.327000\n", + "lr 9.000000e-08 reg 5.000000e+05 train accuracy: 0.387388 val accuracy: 0.396000\n", + "lr 9.000000e-08 reg 5.500000e+05 train accuracy: 0.405796 val accuracy: 0.398000\n", + "lr 9.000000e-08 reg 6.000000e+06 train accuracy: 0.323857 val accuracy: 0.334000\n", + "lr 1.000000e-07 reg 4.000000e+05 train accuracy: 0.366143 val accuracy: 0.379000\n", + "lr 1.000000e-07 reg 4.500000e+05 train accuracy: 0.393347 val accuracy: 0.410000\n", + "lr 1.000000e-07 reg 5.000000e+05 train accuracy: 0.411776 val accuracy: 0.405000\n", + "lr 1.000000e-07 reg 5.500000e+05 train accuracy: 0.408776 val accuracy: 0.404000\n", + "lr 1.000000e-07 reg 6.000000e+06 train accuracy: 0.311245 val accuracy: 0.314000\n", + "lr 1.100000e-07 reg 4.000000e+05 train accuracy: 0.383653 val accuracy: 0.362000\n", + "lr 1.100000e-07 reg 4.500000e+05 train accuracy: 0.397612 val accuracy: 0.418000\n", + "lr 1.100000e-07 reg 5.000000e+05 train accuracy: 0.398878 val accuracy: 0.393000\n", + "lr 1.100000e-07 reg 5.500000e+05 train accuracy: 0.402265 val accuracy: 0.382000\n", + "lr 1.100000e-07 reg 6.000000e+06 train accuracy: 0.269490 val accuracy: 0.244000\n", + "lr 1.200000e-07 reg 4.000000e+05 train accuracy: 0.398429 val accuracy: 0.385000\n", + "lr 1.200000e-07 reg 4.500000e+05 train accuracy: 0.404388 val accuracy: 0.391000\n", + "lr 1.200000e-07 reg 5.000000e+05 train accuracy: 0.404673 val accuracy: 0.401000\n", + "lr 1.200000e-07 reg 5.500000e+05 train accuracy: 0.403000 val accuracy: 0.405000\n", + "lr 1.200000e-07 reg 6.000000e+06 train accuracy: 0.277857 val accuracy: 0.275000\n", + "lr 1.300000e-07 reg 4.000000e+05 train accuracy: 0.403735 val accuracy: 0.420000\n", + "lr 1.300000e-07 reg 4.500000e+05 train accuracy: 0.403531 val accuracy: 0.405000\n", + "lr 1.300000e-07 reg 5.000000e+05 train accuracy: 0.405327 val accuracy: 0.407000\n", + "lr 1.300000e-07 reg 5.500000e+05 train accuracy: 0.414898 val accuracy: 0.407000\n", + "lr 1.300000e-07 reg 6.000000e+06 train accuracy: 0.275551 val accuracy: 0.278000\n", + "lr 1.600000e-07 reg 4.000000e+05 train accuracy: 0.404245 val accuracy: 0.405000\n", + "lr 1.600000e-07 reg 4.500000e+05 train accuracy: 0.391551 val accuracy: 0.392000\n", + "lr 1.600000e-07 reg 5.000000e+05 train accuracy: 0.399082 val accuracy: 0.396000\n", + "lr 1.600000e-07 reg 5.500000e+05 train accuracy: 0.395796 val accuracy: 0.399000\n", + "lr 1.600000e-07 reg 6.000000e+06 train accuracy: 0.127694 val accuracy: 0.128000\n", + "best validation accuracy achieved during cross-validation: 0.420000\n" + ] + } + ], + "source": [ + "# Use the validation set to tune the learning rate and regularization strength\n", + "\n", + "from cs231n.classifiers.linear_classifier import LinearSVM\n", + "\n", + "learning_rates = [0.3e-7, 0.6e-7, 0.7e-7, 0.8e-7, 0.9e-7, 1e-7, 1.1e-7, 1.2e-7, 1.3e-7, 1.6e-7, ]\n", + "regularization_strengths = [4e5, 4.5e5, 5e5, 5.5e5, 6e6]\n", + "\n", + "results = {}\n", + "best_val = -1\n", + "best_svm = None\n", + "\n", + "################################################################################\n", + "# TODO: #\n", + "# Use the validation set to set the learning rate and regularization strength. #\n", + "# This should be identical to the validation that you did for the SVM; save #\n", + "# the best trained classifer in best_svm. You might also want to play #\n", + "# with different numbers of bins in the color histogram. If you are careful #\n", + "# you should be able to get accuracy of near 0.44 on the validation set. #\n", + "################################################################################\n", + "for lr in learning_rates :\n", + " for reg in regularization_strengths :\n", + " svm = LinearSVM()\n", + " svm.train(X_train_feats, y_train, learning_rate=lr, reg=reg, num_iters=100,\n", + " batch_size=200, verbose=False)\n", + " X_train_feats_acc = (svm.predict(X_train_feats) == y_train).mean()\n", + " X_val_feats_acc = (svm.predict(X_val_feats) == y_val).mean()\n", + " results[(lr, reg)] = X_train_feats_acc, X_val_feats_acc \n", + "# print(\"X_train_feats_acc\", X_train_feats_acc)\n", + "# print(\"X_val_feats_acc\", X_val_feats_acc)\n", + " if X_val_feats_acc > best_val :\n", + " best_val = X_val_feats_acc\n", + " best_svm = svm\n", + "################################################################################\n", + "# END OF YOUR CODE #\n", + "################################################################################\n", + "\n", + "# Print out results.\n", + "for lr, reg in sorted(results):\n", + " train_accuracy, val_accuracy = results[(lr, reg)]\n", + " print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n", + " lr, reg, train_accuracy, val_accuracy))\n", + " \n", + "print('best validation accuracy achieved during cross-validation: %f' % best_val)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.405\n" + ] + } + ], + "source": [ + "# Evaluate your trained SVM on the test set\n", + "y_test_pred = best_svm.predict(X_test_feats)\n", + "test_accuracy = np.mean(y_test == y_test_pred)\n", + "print(test_accuracy)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# An important way to gain intuition about how an algorithm works is to\n", + "# visualize the mistakes that it makes. In this visualization, we show examples\n", + "# of images that are misclassified by our current system. The first column\n", + "# shows images that our system labeled as \"plane\" but whose true label is\n", + "# something other than \"plane\".\n", + "\n", + "examples_per_class = 8\n", + "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n", + "for cls, cls_name in enumerate(classes):\n", + " idxs = np.where((y_test != cls) & (y_test_pred == cls))[0]\n", + "# print(np.where((y_test != cls) & (y_test_pred == cls)).shape)\n", + "# print(type(np.where((y_test != cls) & (y_test_pred == cls)))) #\n", + "# print(np.where((y_test != cls) & (y_test_pred == cls)))\n", + "# print(idxs.shape)\n", + " idxs = np.random.choice(idxs, examples_per_class, replace=False)\n", + " for i, idx in enumerate(idxs):\n", + " plt.subplot(examples_per_class, len(classes), i * len(classes) + cls + 1)\n", + " plt.imshow(X_test[idx].astype('uint8'))\n", + " plt.axis('off')\n", + " if i == 0:\n", + " plt.title(cls_name)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inline question 1:\n", + "Describe the misclassification results that you see. Do they make sense?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Neural Network on image features\n", + "Earlier in this assigment we saw that training a two-layer neural network on raw pixels achieved better classification performance than linear classifiers on raw pixels. In this notebook we have seen that linear classifiers on image features outperform linear classifiers on raw pixels. \n", + "\n", + "For completeness, we should also try training a neural network on image features. This approach should outperform all previous approaches: you should easily be able to achieve over 55% classification accuracy on the test set; our best model achieves about 60% classification accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(49000, 155)\n", + "(49000, 154)\n" + ] + } + ], + "source": [ + "# Preprocessing: Remove the bias dimension\n", + "# Make sure to run this cell only ONCE\n", + "print(X_train_feats.shape)\n", + "X_train_feats = X_train_feats[:, :-1]\n", + "X_val_feats = X_val_feats[:, :-1]\n", + "X_test_feats = X_test_feats[:, :-1]\n", + "\n", + "print(X_train_feats.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "learning_rate: 0.1 reg: 0.0 Tra acc: 0.5083469387755102 Val acc: 0.508\n", + "learning_rate: 0.1 reg: 0.01 Tra acc: 0.4870204081632653 Val acc: 0.476\n", + "learning_rate: 0.1 reg: 0.02 Tra acc: 0.46518367346938777 Val acc: 0.451\n", + "learning_rate: 0.2 reg: 0.0 Tra acc: 0.5458775510204081 Val acc: 0.531\n", + "learning_rate: 0.2 reg: 0.01 Tra acc: 0.5177551020408163 Val acc: 0.506\n", + "learning_rate: 0.2 reg: 0.02 Tra acc: 0.5015102040816326 Val acc: 0.503\n", + "learning_rate: 0.25 reg: 0.0 Tra acc: 0.5627142857142857 Val acc: 0.547\n", + "learning_rate: 0.25 reg: 0.01 Tra acc: 0.5119387755102041 Val acc: 0.501\n", + "learning_rate: 0.25 reg: 0.02 Tra acc: 0.49951020408163266 Val acc: 0.5\n", + "learning_rate: 0.3 reg: 0.0 Tra acc: 0.5730408163265306 Val acc: 0.533\n", + "learning_rate: 0.3 reg: 0.01 Tra acc: 0.5193061224489796 Val acc: 0.497\n", + "learning_rate: 0.3 reg: 0.02 Tra acc: 0.49912244897959185 Val acc: 0.474\n", + "learning_rate: 0.35 reg: 0.0 Tra acc: 0.5868163265306122 Val acc: 0.556\n", + "learning_rate: 0.35 reg: 0.01 Tra acc: 0.5126326530612245 Val acc: 0.503\n", + "learning_rate: 0.35 reg: 0.02 Tra acc: 0.49614285714285716 Val acc: 0.494\n", + "learning_rate: 0.03 reg: 0.0 Tra acc: 0.250469387755102 Val acc: 0.268\n", + "learning_rate: 0.03 reg: 0.01 Tra acc: 0.24840816326530613 Val acc: 0.271\n", + "learning_rate: 0.03 reg: 0.02 Tra acc: 0.220265306122449 Val acc: 0.228\n", + "best_val_acc: 0.556\n" + ] + } + ], + "source": [ + "from cs231n.classifiers.neural_net import TwoLayerNet\n", + "\n", + "input_dim = X_train_feats.shape[1]\n", + "hidden_dim = 500\n", + "num_classes = 10\n", + "\n", + "net = TwoLayerNet(input_dim, hidden_dim, num_classes)\n", + "best_net = None\n", + "\n", + "################################################################################\n", + "# TODO: Train a two-layer neural network on image features. You may want to #\n", + "# cross-validate various parameters as in previous sections. Store your best #\n", + "# model in the best_net variable. #\n", + "################################################################################\n", + "learning_rate = [1e-1, 2.0e-1, 2.5e-1, 3e-1, 3.5e-1,]\n", + "reg = [0.0, 0.01, 0.02]\n", + "best_val_acc = 0\n", + "\n", + "for lr in learning_rate:\n", + " for rg in reg:\n", + " net = TwoLayerNet(input_dim, hidden_dim, num_classes)\n", + " net.train(X_train_feats, y_train, X_val_feats, y_val,\n", + " learning_rate=lr, learning_rate_decay=0.95,\n", + " reg=rg, num_iters=800,\n", + " batch_size=200, verbose=False)\n", + " \n", + " # Predict on the validation set\n", + " val_acc = (net.predict(X_val_feats) == y_val).mean()\n", + " tra_acc = (net.predict(X_train_feats) == y_train).mean()\n", + " print(\"learning_rate:\",lr, \"reg:\",rg, \n", + " 'Tra acc:', tra_acc, 'Val acc:', val_acc)\n", + " if val_acc > best_val_acc :\n", + " best_val_acc = val_acc\n", + " best_net = net\n", + "print('best_val_acc:', best_val_acc)\n", + " \n", + "################################################################################\n", + "# END OF YOUR CODE #\n", + "################################################################################" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.554\n" + ] + } + ], + "source": [ + "# Run your best neural net classifier on the test set. You should be able\n", + "# to get more than 55% accuracy.\n", + "\n", + "test_acc = (best_net.predict(X_test_feats) == y_test).mean()\n", + "print(test_acc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/assignment1/.ipynb_checkpoints/knn-checkpoint.ipynb b/assignment1/.ipynb_checkpoints/knn-checkpoint.ipynb new file mode 100644 index 000000000..a69f46a32 --- /dev/null +++ b/assignment1/.ipynb_checkpoints/knn-checkpoint.ipynb @@ -0,0 +1,933 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# k-Nearest Neighbor (kNN) exercise\n", + "\n", + "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n", + "\n", + "The kNN classifier consists of two stages:\n", + "\n", + "- During training, the classifier takes the training data and simply remembers it\n", + "- During testing, kNN classifies every test image by comparing to all training images and transfering the labels of the k most similar training examples\n", + "- The value of k is cross-validated\n", + "\n", + "In this exercise you will implement these steps and understand the basic Image Classification pipeline, cross-validation, and gain proficiency in writing efficient, vectorized code." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "# Run some setup code for this notebook.\n", + "\n", + "import random\n", + "import numpy as np\n", + "from cs231n.data_utils import load_CIFAR10\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "\n", + "# This is a bit of magic to make matplotlib figures appear inline in the notebook\n", + "# rather than in a new window.\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "# Some more magic so that the notebook will reload external python modules;\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training data shape: (50000, 32, 32, 3)\n", + "Training labels shape: (50000,)\n", + "Test data shape: (10000, 32, 32, 3)\n", + "Test labels shape: (10000,)\n" + ] + } + ], + "source": [ + "# Load the raw CIFAR-10 data.\n", + "cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n", + "\n", + "# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n", + "try:\n", + " del X_train, y_train\n", + " del X_test, y_test\n", + " print('Clear previously loaded data.')\n", + "except:\n", + " pass\n", + "\n", + "X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n", + "\n", + "# As a sanity check, we print out the size of the training and test data.\n", + "print('Training data shape: ', X_train.shape)\n", + "print('Training labels shape: ', y_train.shape)\n", + "print('Test data shape: ', X_test.shape)\n", + "print('Test labels shape: ', y_test.shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 plane\n", + "1 car\n", + "2 bird\n", + "3 cat\n", + "4 deer\n", + "5 dog\n", + "6 frog\n", + "7 horse\n", + "8 ship\n", + "9 truck\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize some examples from the dataset.\n", + "# We show a few examples of training images from each class.\n", + "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n", + "num_classes = len(classes)\n", + "samples_per_class = 7\n", + "for y, cls in enumerate(classes):\n", + " print(y,cls)\n", + "# print((y_train == y).shape)\n", + " idxs = np.flatnonzero(y_train == y)\n", + "# print(idxs)\n", + " idxs = np.random.choice(idxs, samples_per_class, replace=False)\n", + " for i, idx in enumerate(idxs):\n", + " plt_idx = i * num_classes + y + 1\n", + " plt.subplot(samples_per_class, num_classes, plt_idx)\n", + " plt.imshow(X_train[idx].astype('uint8'))\n", + " plt.axis('off')\n", + " if i == 0:\n", + " plt.title(cls)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# num = list(range(5))\n", + "# print(num)\n", + "# test = np.arange(10,20,1)\n", + "# print(test)\n", + "# print(test[[1,2,3]])\n", + "# print(test[num])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5000\n", + "(5000, 32, 32, 3)\n", + "(5000, 32, 32, 3)\n" + ] + } + ], + "source": [ + "# Subsample the data for more efficient code execution in this exercise\n", + "num_training = 5000\n", + "mask = list(range(num_training))\n", + "print(len(mask))\n", + "print(X_train.shape)\n", + "# X_train = X_train[:num_training]\n", + "X_train = X_train[mask]\n", + "y_train = y_train[mask]\n", + "print(X_train.shape)\n", + "\n", + "num_test = 500\n", + "mask = list(range(num_test))\n", + "X_test = X_test[mask]\n", + "y_test = y_test[mask]\n", + "# y_train[[1,2]]\n", + "# print(y_train[[1,2,4999]])\n", + "# print(y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5000, 3072) (500, 3072)\n" + ] + } + ], + "source": [ + "# Reshape the image data into rows\n", + "X_train = np.reshape(X_train, (X_train.shape[0], -1))\n", + "X_test = np.reshape(X_test, (X_test.shape[0], -1))\n", + "print(X_train.shape, X_test.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from cs231n.classifiers import KNearestNeighbor\n", + "\n", + "# Create a kNN classifier instance. \n", + "# Remember that training a kNN classifier is a noop: \n", + "# the Classifier simply remembers the data and does no further processing \n", + "classifier = KNearestNeighbor()\n", + "classifier.train(X_train, y_train)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We would now like to classify the test data with the kNN classifier. Recall that we can break down this process into two steps: \n", + "\n", + "1. First we must compute the distances between all test examples and all train examples. \n", + "2. Given these distances, for each test example we find the k nearest examples and have them vote for the label\n", + "\n", + "Lets begin with computing the distance matrix between all training and test examples. For example, if there are **Ntr** training examples and **Nte** test examples, this stage should result in a **Nte x Ntr** matrix where each element (i,j) is the distance between the i-th test and j-th train example.\n", + "\n", + "First, open `cs231n/classifiers/k_nearest_neighbor.py` and implement the function `compute_distances_two_loops` that uses a (very inefficient) double loop over all pairs of (test, train) examples and computes the distance matrix one element at a time." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(500, 5000)\n" + ] + } + ], + "source": [ + "# Open cs231n/classifiers/k_nearest_neighbor.py and implement\n", + "# compute_distances_two_loops.\n", + "\n", + "# Test your implementation:\n", + "dists = classifier.compute_distances_two_loops(X_test)\n", + "print(dists.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# We can visualize the distance matrix: each row is a single test example and\n", + "# its distances to training examples\n", + "plt.imshow(dists, interpolation='none')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Inline Question #1:** Notice the structured patterns in the distance matrix, where some rows or columns are visible brighter. (Note that with the default color scheme black indicates low distances while white indicates high distances.)\n", + "\n", + "- What in the data is the cause behind the distinctly bright rows?\n", + "- What causes the columns?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Your Answer**: *fill this in.*\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1, 2]]\n", + "[1, 2]\n" + ] + } + ], + "source": [ + "test = []\n", + "test.append([1,2])\n", + "print(test)\n", + "print(test[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# k = 5\n", + "# closest_y = np.array([3, 3, 4, 4, 4])\n", + "# most_common = 0\n", + "# label = closest_y[0]\n", + "# for j in range(k):\n", + "# vote_num = np.sum(closest_y == closest_y[j])\n", + "# print(closest_y == closest_y[j])\n", + "# print(vote_num)\n", + "# if most_common < vote_num :\n", + "# most_common = vote_num\n", + "# label = closest_y[j]\n", + "# y_pred = label\n", + "# print(y_pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Got 137 / 500 correct => accuracy: 0.274000\n" + ] + } + ], + "source": [ + "# Now implement the function predict_labels and run the code below:\n", + "# We use k = 1 (which is Nearest Neighbor).\n", + "y_test_pred = classifier.predict_labels(dists, k=1)\n", + "\n", + "# Compute and print the fraction of correctly predicted examples\n", + "num_correct = np.sum(y_test_pred == y_test)\n", + "accuracy = float(num_correct) / num_test\n", + "print('Got %d / %d correct => accuracy: %f' % (num_correct, num_test, accuracy))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You should expect to see approximately `27%` accuracy. Now lets try out a larger `k`, say `k = 5`:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Got 145 / 500 correct => accuracy: 0.290000\n" + ] + } + ], + "source": [ + "y_test_pred = classifier.predict_labels(dists, k=5)\n", + "# print(y_test_pred)\n", + "num_correct = np.sum(y_test_pred == y_test)\n", + "accuracy = float(num_correct) / num_test\n", + "print('Got %d / %d correct => accuracy: %f' % (num_correct, num_test, accuracy))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# x = np.array([0, 1, 1, 3, 2, 1, 7, 23])\n", + "# print(np.bincount(x))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You should expect to see a slightly better performance than with `k = 1`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Inline Question 2**\n", + "We can also other distance metrics such as L1 distance.\n", + "The performance of a Nearest Neighbor classifier that uses L1 distance will not change if (Select all that apply.):\n", + "1. The data is preprocessed by subtracting the mean.\n", + "2. The data is preprocessed by subtracting the mean and dividing by the standard deviation.\n", + "3. The coordinate axes for the data are rotated.\n", + "4. None of the above.\n", + "\n", + "*Your Answer*:\n", + "\n", + "*Your explanation*:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# x = np.array([[1,2], [3,4]])\n", + "# y = np.array([[2,1], [2,1], [2,1]])\n", + "# print(x, y, x-y)\n", + "# np.dot(x,x)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Difference was: 0.000000\n", + "Good! The distance matrices are the same\n" + ] + } + ], + "source": [ + "# Now lets speed up distance matrix computation by using partial vectorization\n", + "# with one loop. Implement the function compute_distances_one_loop and run the\n", + "# code below:\n", + "dists_one = classifier.compute_distances_one_loop(X_test)\n", + "\n", + "# To ensure that our vectorized implementation is correct, we make sure that it\n", + "# agrees with the naive implementation. There are many ways to decide whether\n", + "# two matrices are similar; one of the simplest is the Frobenius norm. In case\n", + "# you haven't seen it before, the Frobenius norm of two matrices is the square\n", + "# root of the squared sum of differences of all elements; in other words, reshape\n", + "# the matrices into vectors and compute the Euclidean distance between them.\n", + "difference = np.linalg.norm(dists - dists_one, ord='fro')\n", + "print('Difference was: %f' % (difference, ))\n", + "if difference < 0.001:\n", + " print('Good! The distance matrices are the same')\n", + "else:\n", + " print('Uh-oh! The distance matrices are different')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2,) (3, 2)\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[2, 4],\n", + " [2, 6],\n", + " [2, 6]])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ts = np.array([1,2])\n", + "tt = np.array([[1,2,], [1,4], [1,4]])\n", + "print(ts.shape, tt.shape)\n", + "ts + tt" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Difference was: 0.000000\n", + "Good! The distance matrices are the same\n" + ] + } + ], + "source": [ + "# Now implement the fully vectorized version inside compute_distances_no_loops\n", + "# and run the code\n", + "dists_two = classifier.compute_distances_no_loops(X_test)\n", + "\n", + "# check that the distance matrix agrees with the one we computed before:\n", + "difference = np.linalg.norm(dists - dists_two, ord='fro')\n", + "print('Difference was: %f' % (difference, ))\n", + "if difference < 0.001:\n", + " print('Good! The distance matrices are the same')\n", + "else:\n", + " print('Uh-oh! The distance matrices are different')" + ] + }, + { + "cell_type": "code", + "execution_count": 197, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two loop version took 19.860330 seconds\n", + "One loop version took 67.483680 seconds\n", + "No loop version took 0.225398 seconds\n" + ] + } + ], + "source": [ + "# Let's compare how fast the implementations are\n", + "def time_function(f, *args):\n", + " \"\"\"\n", + " Call a function f with args and return the time (in seconds) that it took to execute.\n", + " \"\"\"\n", + " import time\n", + " tic = time.time()\n", + " f(*args)\n", + " toc = time.time()\n", + " return toc - tic\n", + "\n", + "two_loop_time = time_function(classifier.compute_distances_two_loops, X_test)\n", + "print('Two loop version took %f seconds' % two_loop_time)\n", + "\n", + "one_loop_time = time_function(classifier.compute_distances_one_loop, X_test)\n", + "print('One loop version took %f seconds' % one_loop_time)\n", + "\n", + "no_loop_time = time_function(classifier.compute_distances_no_loops, X_test)\n", + "print('No loop version took %f seconds' % no_loop_time)\n", + "\n", + "# you should see significantly faster performance with the fully vectorized implementation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cross-validation\n", + "\n", + "We have implemented the k-Nearest Neighbor classifier but we set the value k = 5 arbitrarily. We will now determine the best value of this hyperparameter with cross-validation." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.17986816 0.87440594 0.0742834 ]\n", + " [0.02535961 0.69783367 0.01798927]]\n", + "[0.17986816 0.87440594 0.0742834 0.02535961 0.69783367 0.01798927]\n", + "[[0.17986816 0.87440594 0.0742834 ]\n", + " [0.02535961 0.69783367 0.01798927]]\n" + ] + } + ], + "source": [ + "# test_temp_y = np.random.random((2,3))\n", + "# print(test_temp_y)\n", + "# test_temp_y1 = np.array([y for x in test_temp_y for y in x])\n", + "# print(test_temp_y1)\n", + "# test_temp_y2 = np.array([y for y in test_temp_y])\n", + "# print(test_temp_y2)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.24447222 0.45677828 0.08571756 0.74106172]\n", + "[[0.24447222]\n", + " [0.45677828]\n", + " [0.08571756]\n", + " [0.74106172]]\n" + ] + } + ], + "source": [ + "# test_temp_y1 = np.random.random((4,))\n", + "# test_temp_y2 = test_temp_y1.reshape((4,1))\n", + "# test_temp_y3 = np.random.random((4,1))\n", + "# print(test_temp_y1)\n", + "# print(test_temp_y2)\n", + "# print(test_temp_y3)" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3, 3, 2)\n", + "(1, 3, 2)\n", + "[[1 2]\n", + " [3 4]\n", + " [3 4]\n", + " [1 2]\n", + " [3 4]\n", + " [3 4]\n", + " [1 2]\n", + " [3 4]\n", + " [3 4]\n", + " [7 8]\n", + " [3 4]\n", + " [7 4]]\n", + "(12, 2)\n" + ] + } + ], + "source": [ + "# a = list([[[1, 2], [3, 4], [3, 4]], [[1, 2], [3, 4], [3, 4]], [[1, 2], [3, 4], [3, 4]]])\n", + "# b = list([[[7, 8], [3, 4], [7, 4]]])\n", + "# print(np.array(a).shape)\n", + "# print(np.array(b).shape)\n", + "# # print(np.concatenate((a, b), axis=0))\n", + "# print(np.concatenate(a[:]+b[:]))\n", + "# print(np.concatenate(a[:]+b[:]).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "k = 1, accuracy = 0.526000\n", + "k = 1, accuracy = 0.514000\n", + "k = 1, accuracy = 0.528000\n", + "k = 1, accuracy = 0.556000\n", + "k = 1, accuracy = 0.532000\n", + "k = 3, accuracy = 0.478000\n", + "k = 3, accuracy = 0.498000\n", + "k = 3, accuracy = 0.480000\n", + "k = 3, accuracy = 0.532000\n", + "k = 3, accuracy = 0.508000\n", + "k = 5, accuracy = 0.496000\n", + "k = 5, accuracy = 0.532000\n", + "k = 5, accuracy = 0.560000\n", + "k = 5, accuracy = 0.584000\n", + "k = 5, accuracy = 0.560000\n", + "k = 8, accuracy = 0.524000\n", + "k = 8, accuracy = 0.564000\n", + "k = 8, accuracy = 0.546000\n", + "k = 8, accuracy = 0.580000\n", + "k = 8, accuracy = 0.546000\n", + "k = 10, accuracy = 0.530000\n", + "k = 10, accuracy = 0.592000\n", + "k = 10, accuracy = 0.552000\n", + "k = 10, accuracy = 0.568000\n", + "k = 10, accuracy = 0.560000\n", + "k = 12, accuracy = 0.520000\n", + "k = 12, accuracy = 0.590000\n", + "k = 12, accuracy = 0.558000\n", + "k = 12, accuracy = 0.566000\n", + "k = 12, accuracy = 0.560000\n", + "k = 15, accuracy = 0.504000\n", + "k = 15, accuracy = 0.578000\n", + "k = 15, accuracy = 0.556000\n", + "k = 15, accuracy = 0.564000\n", + "k = 15, accuracy = 0.548000\n", + "k = 20, accuracy = 0.540000\n", + "k = 20, accuracy = 0.558000\n", + "k = 20, accuracy = 0.558000\n", + "k = 20, accuracy = 0.564000\n", + "k = 20, accuracy = 0.570000\n", + "k = 50, accuracy = 0.542000\n", + "k = 50, accuracy = 0.576000\n", + "k = 50, accuracy = 0.556000\n", + "k = 50, accuracy = 0.538000\n", + "k = 50, accuracy = 0.532000\n", + "k = 100, accuracy = 0.512000\n", + "k = 100, accuracy = 0.540000\n", + "k = 100, accuracy = 0.526000\n", + "k = 100, accuracy = 0.512000\n", + "k = 100, accuracy = 0.526000\n" + ] + } + ], + "source": [ + "num_folds = 5\n", + "k_choices = [1, 3, 5, 8, 10, 12, 15, 20, 50, 100]\n", + "\n", + "X_train_folds = []\n", + "y_train_folds = []\n", + "################################################################################\n", + "# TODO: #\n", + "# Split up the training data into folds. After splitting, X_train_folds and #\n", + "# y_train_folds should each be lists of length num_folds, where #\n", + "# y_train_folds[i] is the label vector for the points in X_train_folds[i]. #\n", + "# Hint: Look up the numpy array_split function. #\n", + "################################################################################\n", + "X_train_folds = np.array_split(X_train, num_folds)\n", + "y_train_folds = np.array_split(y_train, num_folds)\n", + "################################################################################\n", + "# END OF YOUR CODE #\n", + "################################################################################\n", + "\n", + "# A dictionary holding the accuracies for different values of k that we find\n", + "# when running cross-validation. After running cross-validation,\n", + "# k_to_accuracies[k] should be a list of length num_folds giving the different\n", + "# accuracy values that we found when using that value of k.\n", + "k_to_accuracies = {}\n", + "\n", + "\n", + "################################################################################\n", + "# TODO: #\n", + "# Perform k-fold cross validation to find the best value of k. For each #\n", + "# possible value of k, run the k-nearest-neighbor algorithm num_folds times, #\n", + "# where in each case you use all but one of the folds as training data and the #\n", + "# last fold as a validation set. Store the accuracies for all fold and all #\n", + "# values of k in the k_to_accuracies dictionary. #\n", + "################################################################################\n", + "for k in k_choices:\n", + " accuracies = []\n", + " for i in range(num_folds):\n", + " classifier = KNearestNeighbor()\n", + "# classifier.train(np.array(X_train_folds[i+1:]).reshape(4000, -1), np.array(y_train_folds[i+1:]).reshape(4000, ))\n", + "# classifier.train(np.delete(X_train, i:i+np.array(X_train_folds[i]).shape[0], 0), \n", + "# np.delete(y_train, i:i+np.array(y_train_folds[i]).shape[0], 0))\n", + "# print(np.array(X_train_folds[i+1:]).reshape(4000, -1).shape)\n", + "# print(np.array(y_train_folds[i+1:]).shape)\n", + "\n", + " temp_X = X_train_folds[:]\n", + " temp_y = y_train_folds[:]\n", + "# print(type(temp_X)) #\n", + "# print(type(temp_X[0])) #\n", + "# print(np.array(temp_X).shape, np.array(temp_y).shape)\n", + " X_validate_fold = temp_X.pop(i)\n", + " y_validate_fold = temp_y.pop(i)\n", + "# print(np.array(X_validate_fold).shape, np.array(y_validate_fold).shape)\n", + "# print(np.array(temp_X).shape, np.array(temp_y).shape)\n", + "# print(\"f\",np.array(temp_X).shape)\n", + "# print(\"f\",np.array(temp_y).shape)\n", + "\n", + "# temp_X = np.array([y for x in temp_X for y in x])\n", + "# print(temp_X.shape) \n", + "# temp_y = np.array([y for x in temp_y for y in x])\n", + "# print(temp_y.shape)\n", + "# classifier.train(temp_X, temp_y)\n", + " classifier.train(np.array(temp_X).reshape(4000, -1), np.array(temp_y).reshape(4000, ))\n", + "# print(\"@\",np.array(temp_X).reshape(4000, -1).shape)\n", + "# print(\"@\",np.array(temp_y).reshape(4000, -1).shape)\n", + " \n", + " \n", + "# classifier.train(np.concatenate(X_train_folds[0:i]+ X_train_folds[i+1:]), \n", + "# np.concatenate(y_train_folds[0:i]+ y_train_folds[i+1:]))\n", + "# classifier.train(np.concatenate((X_train_folds[0:i], X_train_folds[i+1:]), axis = 0), \n", + "# np.concatenate((y_train_folds[0:i], y_train_folds[i+1:]), axis = 0))\n", + " dists = classifier.compute_distances_no_loops(X_train_folds[i])\n", + "# print(X_train_folds[i].shape)\n", + "# print(dists.shape)\n", + " \n", + " y_train_pred = classifier.predict_labels(dists, k=k)\n", + "# y_train_pred = classifier.predict((X_train_folds[i]), k=k)\n", + " num_correct = np.sum(y_train_pred == y_train_folds[i])\n", + " accuracies.append(float(num_correct) / num_test)\n", + " k_to_accuracies[k] = accuracies\n", + "################################################################################\n", + "# END OF YOUR CODE #\n", + "################################################################################\n", + "\n", + "# Print out the computed accuracies\n", + "for k in sorted(k_to_accuracies):\n", + " for accuracy in k_to_accuracies[k]:\n", + " print('k = %d, accuracy = %f' % (k, accuracy))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot the raw observations\n", + "for k in k_choices:\n", + " accuracies = k_to_accuracies[k]\n", + " plt.scatter([k] * len(accuracies), accuracies)\n", + "\n", + "# plot the trend line with error bars that correspond to standard deviation\n", + "accuracies_mean = np.array([np.mean(v) for k,v in sorted(k_to_accuracies.items())])\n", + "accuracies_std = np.array([np.std(v) for k,v in sorted(k_to_accuracies.items())])\n", + "plt.errorbar(k_choices, accuracies_mean, yerr=accuracies_std)\n", + "plt.title('Cross-validation on k')\n", + "plt.xlabel('k')\n", + "plt.ylabel('Cross-validation accuracy')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.5312 0.4992 0.5464 0.552 0.5604 0.5588 0.55 0.558 0.5488 0.5232]\n", + "10\n", + "Got 141 / 500 correct => accuracy: 0.282000\n" + ] + } + ], + "source": [ + "# Based on the cross-validation results above, choose the best value for k, \n", + "# retrain the classifier using all the training data, and test it on the test\n", + "# data. You should be able to get above 28% accuracy on the test data.\n", + "best_k = k_choices[np.argmax(accuracies_mean)]\n", + "# print(accuracies_mean)\n", + "# print(best_k)\n", + "\n", + "classifier = KNearestNeighbor()\n", + "classifier.train(X_train, y_train)\n", + "y_test_pred = classifier.predict(X_test, k=best_k)\n", + "\n", + "# Compute and display the accuracy\n", + "num_correct = np.sum(y_test_pred == y_test)\n", + "accuracy = float(num_correct) / num_test\n", + "print('Got %d / %d correct => accuracy: %f' % (num_correct, num_test, accuracy))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Inline Question 3**\n", + "Which of the following statements about $k$-Nearest Neighbor ($k$-NN) are true in a classification setting, and for all $k$? Select all that apply.\n", + "1. The training error of a 1-NN will always be better than that of 5-NN.\n", + "2. The test error of a 1-NN will always be better than that of a 5-NN.\n", + "3. The decision boundary of the k-NN classifier is linear.\n", + "4. The time needed to classify a test example with the k-NN classifier grows with the size of the training set.\n", + "5. None of the above.\n", + "\n", + "*Your Answer*:\n", + "\n", + "*Your explanation*:" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/assignment1/.ipynb_checkpoints/softmax-checkpoint.ipynb b/assignment1/.ipynb_checkpoints/softmax-checkpoint.ipynb new file mode 100644 index 000000000..229924f78 --- /dev/null +++ b/assignment1/.ipynb_checkpoints/softmax-checkpoint.ipynb @@ -0,0 +1,391 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Softmax exercise\n", + "\n", + "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n", + "\n", + "This exercise is analogous to the SVM exercise. You will:\n", + "\n", + "- implement a fully-vectorized **loss function** for the Softmax classifier\n", + "- implement the fully-vectorized expression for its **analytic gradient**\n", + "- **check your implementation** with numerical gradient\n", + "- use a validation set to **tune the learning rate and regularization** strength\n", + "- **optimize** the loss function with **SGD**\n", + "- **visualize** the final learned weights\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "import random\n", + "import numpy as np\n", + "from cs231n.data_utils import load_CIFAR10\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "# for auto-reloading extenrnal modules\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train data shape: (49000, 3073)\n", + "Train labels shape: (49000,)\n", + "Validation data shape: (1000, 3073)\n", + "Validation labels shape: (1000,)\n", + "Test data shape: (1000, 3073)\n", + "Test labels shape: (1000,)\n", + "dev data shape: (500, 3073)\n", + "dev labels shape: (500,)\n" + ] + } + ], + "source": [ + "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n", + " \"\"\"\n", + " Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n", + " it for the linear classifier. These are the same steps as we used for the\n", + " SVM, but condensed to a single function. \n", + " \"\"\"\n", + " # Load the raw CIFAR-10 data\n", + " cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n", + " \n", + " X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n", + " \n", + " # subsample the data\n", + " mask = list(range(num_training, num_training + num_validation))\n", + " X_val = X_train[mask]\n", + " y_val = y_train[mask]\n", + " mask = list(range(num_training))\n", + " X_train = X_train[mask]\n", + " y_train = y_train[mask]\n", + " mask = list(range(num_test))\n", + " X_test = X_test[mask]\n", + " y_test = y_test[mask]\n", + " mask = np.random.choice(num_training, num_dev, replace=False)\n", + " X_dev = X_train[mask]\n", + " y_dev = y_train[mask]\n", + " \n", + " # Preprocessing: reshape the image data into rows\n", + " X_train = np.reshape(X_train, (X_train.shape[0], -1))\n", + " X_val = np.reshape(X_val, (X_val.shape[0], -1))\n", + " X_test = np.reshape(X_test, (X_test.shape[0], -1))\n", + " X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n", + " \n", + " # Normalize the data: subtract the mean image\n", + " mean_image = np.mean(X_train, axis = 0)\n", + " X_train -= mean_image\n", + " X_val -= mean_image\n", + " X_test -= mean_image\n", + " X_dev -= mean_image\n", + " \n", + " # add bias dimension and transform into columns\n", + " X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n", + " X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n", + " X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n", + " X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n", + " \n", + " return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n", + "\n", + "\n", + "# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n", + "try:\n", + " del X_train, y_train\n", + " del X_test, y_test\n", + " print('Clear previously loaded data.')\n", + "except:\n", + " pass\n", + "\n", + "# Invoke the above function to get our data.\n", + "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n", + "print('Train data shape: ', X_train.shape)\n", + "print('Train labels shape: ', y_train.shape)\n", + "print('Validation data shape: ', X_val.shape)\n", + "print('Validation labels shape: ', y_val.shape)\n", + "print('Test data shape: ', X_test.shape)\n", + "print('Test labels shape: ', y_test.shape)\n", + "print('dev data shape: ', X_dev.shape)\n", + "print('dev labels shape: ', y_dev.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Softmax Classifier\n", + "\n", + "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss: 2.360768\n", + "sanity check: 2.302585\n" + ] + } + ], + "source": [ + "# First implement the naive softmax loss function with nested loops.\n", + "# Open the file cs231n/classifiers/softmax.py and implement the\n", + "# softmax_loss_naive function.\n", + "\n", + "from cs231n.classifiers.softmax import softmax_loss_naive\n", + "import time\n", + "\n", + "# Generate a random softmax weight matrix and use it to compute the loss.\n", + "W = np.random.randn(3073, 10) * 0.0001\n", + "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n", + "\n", + "# As a rough sanity check, our loss should be something close to -log(0.1).\n", + "print('loss: %f' % loss)\n", + "print('sanity check: %f' % (-np.log(0.1)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inline Question 1:\n", + "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n", + "\n", + "**Your answer:** *Fill this in*\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "numerical: 1.840498 analytic: 1.840498, relative error: 9.463563e-09\n", + "numerical: 1.360287 analytic: 1.360287, relative error: 5.428264e-08\n", + "numerical: 2.471600 analytic: 2.471600, relative error: 6.999345e-09\n", + "numerical: -3.609723 analytic: -3.609723, relative error: 4.592565e-09\n", + "numerical: 0.455820 analytic: 0.455820, relative error: 1.799344e-07\n", + "numerical: -3.553380 analytic: -3.553380, relative error: 2.093326e-09\n", + "numerical: 2.474077 analytic: 2.474077, relative error: 3.668579e-09\n", + "numerical: 1.791949 analytic: 1.791949, relative error: 8.629964e-09\n", + "numerical: -1.208928 analytic: -1.208928, relative error: 2.653493e-08\n", + "numerical: -0.772397 analytic: -0.772397, relative error: 1.595247e-08\n", + "==============\n", + "numerical: -1.915317 analytic: -1.915317, relative error: 1.185577e-08\n", + "numerical: -1.771815 analytic: -1.771815, relative error: 3.182251e-09\n", + "numerical: -0.441094 analytic: -0.441094, relative error: 7.897026e-08\n", + "numerical: -0.083030 analytic: -0.083030, relative error: 7.455856e-08\n", + "numerical: 0.301674 analytic: 0.301674, relative error: 5.518636e-08\n", + "numerical: 1.394915 analytic: 1.394914, relative error: 1.621416e-08\n", + "numerical: 0.653937 analytic: 0.653937, relative error: 2.905406e-08\n", + "numerical: 1.600552 analytic: 1.600552, relative error: 1.438189e-08\n", + "numerical: 1.636157 analytic: 1.636156, relative error: 3.326788e-08\n", + "numerical: 0.167717 analytic: 0.167717, relative error: 1.718313e-07\n" + ] + } + ], + "source": [ + "# Complete the implementation of softmax_loss_naive and implement a (naive)\n", + "# version of the gradient that uses nested loops.\n", + "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n", + "\n", + "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n", + "# The numeric gradient should be close to the analytic gradient.\n", + "from cs231n.gradient_check import grad_check_sparse\n", + "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n", + "grad_numerical = grad_check_sparse(f, W, grad, 10)\n", + "\n", + "print(\"==============\")\n", + "# similar to SVM case, do another gradient check with regularization\n", + "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n", + "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n", + "grad_numerical = grad_check_sparse(f, W, grad, 10)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "naive loss: 2.360768e+00 computed in 0.035903s\n", + "vectorized loss: 2.360768e+00 computed in 0.006986s\n", + "Loss difference: 0.000000\n", + "Gradient difference: 0.000000\n" + ] + } + ], + "source": [ + "# Now that we have a naive implementation of the softmax loss function and its gradient,\n", + "# implement a vectorized version in softmax_loss_vectorized.\n", + "# The two versions should compute the same results, but the vectorized version should be\n", + "# much faster.\n", + "tic = time.time()\n", + "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n", + "toc = time.time()\n", + "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n", + "\n", + "from cs231n.classifiers.softmax import softmax_loss_vectorized\n", + "tic = time.time()\n", + "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n", + "toc = time.time()\n", + "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n", + "\n", + "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n", + "# of the gradient.\n", + "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n", + "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n", + "print('Gradient difference: %f' % grad_difference)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Use the validation set to tune hyperparameters (regularization strength and\n", + "# learning rate). You should experiment with different ranges for the learning\n", + "# rates and regularization strengths; if you are careful you should be able to\n", + "# get a classification accuracy of over 0.35 on the validation set.\n", + "from cs231n.classifiers import Softmax\n", + "results = {}\n", + "best_val = -1\n", + "best_softmax = None\n", + "learning_rates = [1e-7, 5e-7]\n", + "regularization_strengths = [2.5e4, 5e4]\n", + "\n", + "################################################################################\n", + "# TODO: #\n", + "# Use the validation set to set the learning rate and regularization strength. #\n", + "# This should be identical to the validation that you did for the SVM; save #\n", + "# the best trained softmax classifer in best_softmax. #\n", + "################################################################################\n", + "for lr in learning_rates:\n", + " for reg in regularization_strengths:\n", + " softmax = Softmax()\n", + " loss_hist = softmax.train(X_train, y_train, learning_rate=lr, reg=reg, num_iters=1500, verbose=False)\n", + " results[(lr, reg)] = ( np.mean( y_train == softmax.predict(X_train) ), np.mean( y_val == softmax.predict(X_val) ) )\n", + " print(\"(lr, reg)\", lr, reg, \"(y_train_pre, y_val_pre)\",results[(lr, reg)])\n", + "# print(results[(lr, reg)][1])\n", + " if (results[(lr, reg)][1] > best_val) :\n", + " best_val = results[(lr, reg)][1]\n", + " best_softmax = softmax\n", + "################################################################################\n", + "# END OF YOUR CODE #\n", + "################################################################################\n", + " \n", + "# Print out results.\n", + "for lr, reg in sorted(results):\n", + " train_accuracy, val_accuracy = results[(lr, reg)]\n", + " print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n", + " lr, reg, train_accuracy, val_accuracy))\n", + " \n", + "print('best validation accuracy achieved during cross-validation: %f' % best_val)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# evaluate on test set\n", + "# Evaluate the best softmax on test set\n", + "y_test_pred = best_softmax.predict(X_test)\n", + "test_accuracy = np.mean(y_test == y_test_pred)\n", + "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Inline Question** - *True or False*\n", + "\n", + "It's possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n", + "\n", + "*Your answer*:\n", + "\n", + "*Your explanation*:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Visualize the learned weights for each class\n", + "w = best_softmax.W[:-1,:] # strip out the bias\n", + "w = w.reshape(32, 32, 3, 10)\n", + "\n", + "w_min, w_max = np.min(w), np.max(w)\n", + "\n", + "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n", + "for i in range(10):\n", + " plt.subplot(2, 5, i + 1)\n", + " \n", + " # Rescale the weights to be between 0 and 255\n", + " wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n", + " plt.imshow(wimg.astype('uint8'))\n", + " plt.axis('off')\n", + " plt.title(classes[i])" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/assignment1/.ipynb_checkpoints/svm-checkpoint.ipynb b/assignment1/.ipynb_checkpoints/svm-checkpoint.ipynb new file mode 100644 index 000000000..bef86d3be --- /dev/null +++ b/assignment1/.ipynb_checkpoints/svm-checkpoint.ipynb @@ -0,0 +1,934 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multiclass Support Vector Machine exercise\n", + "\n", + "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n", + "\n", + "In this exercise you will:\n", + " \n", + "- implement a fully-vectorized **loss function** for the SVM\n", + "- implement the fully-vectorized expression for its **analytic gradient**\n", + "- **check your implementation** using numerical gradient\n", + "- use a validation set to **tune the learning rate and regularization** strength\n", + "- **optimize** the loss function with **SGD**\n", + "- **visualize** the final learned weights\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "# Run some setup code for this notebook.\n", + "\n", + "import random\n", + "import numpy as np\n", + "from cs231n.data_utils import load_CIFAR10\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "\n", + "# This is a bit of magic to make matplotlib figures appear inline in the\n", + "# notebook rather than in a new window.\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "# Some more magic so that the notebook will reload external python modules;\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## CIFAR-10 Data Loading and Preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training data shape: (50000, 32, 32, 3)\n", + "Training labels shape: (50000,)\n", + "Test data shape: (10000, 32, 32, 3)\n", + "Test labels shape: (10000,)\n" + ] + } + ], + "source": [ + "# Load the raw CIFAR-10 data.\n", + "cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n", + "\n", + "# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n", + "try:\n", + " del X_train, y_train\n", + " del X_test, y_test\n", + " print('Clear previously loaded data.')\n", + "except:\n", + " pass\n", + "\n", + "X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n", + "\n", + "# As a sanity check, we print out the size of the training and test data.\n", + "print('Training data shape: ', X_train.shape)\n", + "print('Training labels shape: ', y_train.shape)\n", + "print('Test data shape: ', X_test.shape)\n", + "print('Test labels shape: ', y_test.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize some examples from the dataset.\n", + "# We show a few examples of training images from each class.\n", + "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n", + "num_classes = len(classes)\n", + "samples_per_class = 7\n", + "for y, cls in enumerate(classes):\n", + " idxs = np.flatnonzero(y_train == y)\n", + " idxs = np.random.choice(idxs, samples_per_class, replace=False)\n", + " for i, idx in enumerate(idxs):\n", + " plt_idx = i * num_classes + y + 1\n", + " plt.subplot(samples_per_class, num_classes, plt_idx)\n", + " plt.imshow(X_train[idx].astype('uint8'))\n", + " plt.axis('off')\n", + " if i == 0:\n", + " plt.title(cls)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train data shape: (49000, 32, 32, 3)\n", + "Train labels shape: (49000,)\n", + "Validation data shape: (1000, 32, 32, 3)\n", + "Validation labels shape: (1000,)\n", + "Test data shape: (1000, 32, 32, 3)\n", + "Test labels shape: (1000,)\n" + ] + } + ], + "source": [ + "# Split the data into train, val, and test sets. In addition we will\n", + "# create a small development set as a subset of the training data;\n", + "# we can use this for development so our code runs faster.\n", + "num_training = 49000\n", + "num_validation = 1000\n", + "num_test = 1000\n", + "num_dev = 500\n", + "\n", + "# Our validation set will be num_validation points from the original\n", + "# training set.\n", + "mask = range(num_training, num_training + num_validation)\n", + "X_val = X_train[mask]\n", + "y_val = y_train[mask]\n", + "# print(y_val)\n", + "# print(y_train[num_training:num_training + num_validation])\n", + "\n", + "# Our training set will be the first num_train points from the original\n", + "# training set.\n", + "mask = range(num_training)\n", + "X_train = X_train[mask]\n", + "y_train = y_train[mask]\n", + "\n", + "# We will also make a development set, which is a small subset of\n", + "# the training set.\n", + "mask = np.random.choice(num_training, num_dev, replace=False)\n", + "X_dev = X_train[mask]\n", + "y_dev = y_train[mask]\n", + "\n", + "# We use the first num_test points of the original test set as our\n", + "# test set.\n", + "mask = range(num_test)\n", + "X_test = X_test[mask]\n", + "y_test = y_test[mask]\n", + "\n", + "print('Train data shape: ', X_train.shape)\n", + "print('Train labels shape: ', y_train.shape)\n", + "print('Validation data shape: ', X_val.shape)\n", + "print('Validation labels shape: ', y_val.shape)\n", + "print('Test data shape: ', X_test.shape)\n", + "print('Test labels shape: ', y_test.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training data shape: (49000, 3072)\n", + "Validation data shape: (1000, 3072)\n", + "Test data shape: (1000, 3072)\n", + "dev data shape: (500, 3072)\n" + ] + } + ], + "source": [ + "# Preprocessing: reshape the image data into rows\n", + "X_train = np.reshape(X_train, (X_train.shape[0], -1))\n", + "X_val = np.reshape(X_val, (X_val.shape[0], -1))\n", + "X_test = np.reshape(X_test, (X_test.shape[0], -1))\n", + "X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n", + "\n", + "# As a sanity check, print out the shapes of the data\n", + "print('Training data shape: ', X_train.shape)\n", + "print('Validation data shape: ', X_val.shape)\n", + "print('Test data shape: ', X_test.shape)\n", + "print('dev data shape: ', X_dev.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[130.64189796 135.98173469 132.47391837 130.05569388 135.34804082\n", + " 131.75402041 130.96055102 136.14328571 132.47636735 131.48467347]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Preprocessing: subtract the mean image\n", + "# first: compute the image mean based on the training data\n", + "mean_image = np.mean(X_train, axis=0)\n", + "print(mean_image[:10]) # print a few of the elements\n", + "plt.figure(figsize=(4,4))\n", + "plt.imshow(mean_image.reshape((32,32,3)).astype('uint8')) # visualize the mean image\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# second: subtract the mean image from train and test data\n", + "X_train -= mean_image\n", + "X_val -= mean_image\n", + "X_test -= mean_image\n", + "X_dev -= mean_image" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(49000, 3073) (1000, 3073) (1000, 3073) (500, 3073)\n" + ] + } + ], + "source": [ + "# third: append the bias dimension of ones (i.e. bias trick) so that our SVM\n", + "# only has to worry about optimizing a single weight matrix W.\n", + "X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n", + "X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n", + "X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n", + "X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n", + "\n", + "print(X_train.shape, X_val.shape, X_test.shape, X_dev.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## SVM Classifier\n", + "\n", + "Your code for this section will all be written inside **cs231n/classifiers/linear_svm.py**. \n", + "\n", + "As you can see, we have prefilled the function `compute_loss_naive` which uses for loops to evaluate the multiclass SVM loss function. " + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss: 8.545906\n" + ] + } + ], + "source": [ + "# Evaluate the naive implementation of the loss we provided for you:\n", + "from cs231n.classifiers.linear_svm import svm_loss_naive\n", + "import time\n", + "\n", + "# generate a random SVM weight matrix of small numbers\n", + "W = np.random.randn(3073, 10) * 0.0001 \n", + "\n", + "loss, grad = svm_loss_naive(W, X_dev, y_dev, 0.000005)\n", + "print('loss: %f' % (loss, ))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `grad` returned from the function above is right now all zero. Derive and implement the gradient for the SVM cost function and implement it inline inside the function `svm_loss_naive`. You will find it helpful to interleave your new code inside the existing function.\n", + "\n", + "To check that you have correctly implemented the gradient correctly, you can numerically estimate the gradient of the loss function and compare the numeric estimate to the gradient that you computed. We have provided code that does this for you:" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "numerical: 3.027074 analytic: 3.027074, relative error: 1.262886e-10\n", + "numerical: 10.533671 analytic: 10.533671, relative error: 9.780302e-12\n", + "numerical: 16.006009 analytic: 16.006009, relative error: 1.788442e-11\n", + "numerical: 13.171008 analytic: 13.171008, relative error: 4.577983e-12\n", + "numerical: 0.618890 analytic: 0.618890, relative error: 9.657097e-10\n", + "numerical: -33.776680 analytic: -33.776680, relative error: 8.236627e-12\n", + "numerical: 11.639214 analytic: 11.639214, relative error: 3.220063e-11\n", + "numerical: 10.899776 analytic: 10.899776, relative error: 1.810145e-11\n", + "numerical: 2.133655 analytic: 2.080314, relative error: 1.265824e-02\n", + "numerical: -3.136638 analytic: -3.136638, relative error: 1.001046e-10\n", + "-----------\n", + "numerical: -2.725699 analytic: -2.725699, relative error: 4.626492e-11\n", + "numerical: 9.305123 analytic: 9.305123, relative error: 5.792794e-12\n", + "numerical: 29.928665 analytic: 29.928665, relative error: 6.097930e-13\n", + "numerical: 4.666315 analytic: 4.525973, relative error: 1.526730e-02\n", + "numerical: -32.922391 analytic: -32.922391, relative error: 8.769666e-12\n", + "numerical: -8.795829 analytic: -8.795829, relative error: 8.514601e-12\n", + "numerical: -4.341290 analytic: -4.378089, relative error: 4.220402e-03\n", + "numerical: 5.861410 analytic: 5.861410, relative error: 2.037273e-11\n", + "numerical: 0.999569 analytic: 1.009625, relative error: 5.005311e-03\n", + "numerical: -8.529687 analytic: -8.529687, relative error: 1.631007e-11\n" + ] + } + ], + "source": [ + "# Once you've implemented the gradient, recompute it with the code below\n", + "# and gradient check it with the function we provided for you\n", + "\n", + "# Compute the loss and its gradient at W.\n", + "loss, grad = svm_loss_naive(W, X_dev, y_dev, 0.0)\n", + "\n", + "# Numerically compute the gradient along several randomly chosen dimensions, and\n", + "# compare them with your analytically computed gradient. The numbers should match\n", + "# almost exactly along all dimensions.\n", + "from cs231n.gradient_check import grad_check_sparse\n", + "f = lambda w: svm_loss_naive(w, X_dev, y_dev, 0.0)[0]\n", + "grad_numerical = grad_check_sparse(f, W, grad)\n", + "\n", + "# do the gradient check once again with regularization turned on\n", + "# you didn't forget the regularization gradient did you?\n", + "print(\"-----------\")\n", + "loss, grad = svm_loss_naive(W, X_dev, y_dev, 5e1)\n", + "f = lambda w: svm_loss_naive(w, X_dev, y_dev, 5e1)[0]\n", + "grad_numerical = grad_check_sparse(f, W, grad)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inline Question 1:\n", + "It is possible that once in a while a dimension in the gradcheck will not match exactly. What could such a discrepancy be caused by? Is it a reason for concern? What is a simple example in one dimension where a gradient check could fail? How would change the margin affect of the frequency of this happening? *Hint: the SVM loss function is not strictly speaking differentiable*\n", + "\n", + "**Your Answer:** *fill this in.*" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "# A = np.random.random((10,10))\n", + "# print(A)\n", + "# print(list(range(10)))\n", + "# B = np.array([1,2,3,4,5,6,7,0,0,0])\n", + "# print(A[list(range(10)),B])" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ True False]\n", + " [False True]]\n", + "[[ True True]\n", + " [False True]]\n", + "[[2 0]\n", + " [0 4]]\n" + ] + } + ], + "source": [ + "# A = np.array([[2,0], [-2,4]])\n", + "# B = A > 0\n", + "# print(B)\n", + "# B[0,1] = 5\n", + "# print(B)\n", + "# C = A * B\n", + "# print(C)" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8.545905804832543\n", + "8.545905804832545\n" + ] + } + ], + "source": [ + "# loss_naive, grad_naive = svm_loss_naive(W, X_dev, y_dev, 0.000005)\n", + "# print(loss_naive)\n", + "# from cs231n.classifiers.linear_svm import svm_loss_vectorized\n", + "# loss_vectorized, _ = svm_loss_vectorized(W, X_dev, y_dev, 0.000005)\n", + "# print(loss_vectorized)" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Naive loss: 8.545906e+00 computed in 0.104720s\n", + "Vectorized loss: 8.545906e+00 computed in 0.002993s\n", + "difference: -0.000000\n" + ] + } + ], + "source": [ + "# Next implement the function svm_loss_vectorized; for now only compute the loss;\n", + "# we will implement the gradient in a moment.\n", + "tic = time.time()\n", + "loss_naive, grad_naive = svm_loss_naive(W, X_dev, y_dev, 0.000005)\n", + "toc = time.time()\n", + "print('Naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n", + "\n", + "from cs231n.classifiers.linear_svm import svm_loss_vectorized\n", + "tic = time.time()\n", + "loss_vectorized, _ = svm_loss_vectorized(W, X_dev, y_dev, 0.000005)\n", + "toc = time.time()\n", + "print('Vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n", + "\n", + "# The losses should match but your vectorized implementation should be much faster.\n", + "print('difference: %f' % (loss_naive - loss_vectorized))" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Naive loss and gradient: computed in 0.092751s\n", + "Vectorized loss and gradient: computed in 0.002992s\n", + "difference: 0.000000\n" + ] + } + ], + "source": [ + "# Complete the implementation of svm_loss_vectorized, and compute the gradient\n", + "# of the loss function in a vectorized way.\n", + "\n", + "# The naive implementation and the vectorized implementation should match, but\n", + "# the vectorized version should still be much faster.\n", + "tic = time.time()\n", + "_, grad_naive = svm_loss_naive(W, X_dev, y_dev, 0.000005)\n", + "toc = time.time()\n", + "# print(grad_naive)\n", + "print('Naive loss and gradient: computed in %fs' % (toc - tic))\n", + "\n", + "tic = time.time()\n", + "_, grad_vectorized = svm_loss_vectorized(W, X_dev, y_dev, 0.000005)\n", + "toc = time.time()\n", + "# print(grad_vectorized)\n", + "print('Vectorized loss and gradient: computed in %fs' % (toc - tic))\n", + "\n", + "# The loss is a single number, so it is easy to compare the values computed\n", + "# by the two implementations. The gradient on the other hand is a matrix, so\n", + "# we use the Frobenius norm to compare them.\n", + "difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n", + "print('difference: %f' % difference)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Stochastic Gradient Descent\n", + "\n", + "We now have vectorized and efficient expressions for the loss, the gradient and our gradient matches the numerical gradient. We are therefore ready to do SGD to minimize the loss." + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iteration 0 / 1500: loss 797.643070\n", + "iteration 100 / 1500: loss 289.536172\n", + "iteration 200 / 1500: loss 108.843714\n", + "iteration 300 / 1500: loss 43.182707\n", + "iteration 400 / 1500: loss 18.855964\n", + "iteration 500 / 1500: loss 11.033021\n", + "iteration 600 / 1500: loss 7.497600\n", + "iteration 700 / 1500: loss 5.664093\n", + "iteration 800 / 1500: loss 5.323653\n", + "iteration 900 / 1500: loss 5.611071\n", + "iteration 1000 / 1500: loss 5.486707\n", + "iteration 1100 / 1500: loss 5.337462\n", + "iteration 1200 / 1500: loss 5.207909\n", + "iteration 1300 / 1500: loss 5.376285\n", + "iteration 1400 / 1500: loss 5.346116\n", + "That took 6.164895s\n" + ] + } + ], + "source": [ + "# In the file linear_classifier.py, implement SGD in the function\n", + "# LinearClassifier.train() and then run it with the code below.\n", + "from cs231n.classifiers import LinearSVM\n", + "svm = LinearSVM()\n", + "tic = time.time()\n", + "loss_hist = svm.train(X_train, y_train, learning_rate=1e-7, reg=2.5e4,\n", + " num_iters=1500, verbose=True)\n", + "toc = time.time()\n", + "print('That took %fs' % (toc - tic))" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1500,)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# A useful debugging strategy is to plot the loss as a function of\n", + "# iteration number:\n", + "print(np.array(loss_hist).shape)\n", + "plt.plot(loss_hist)\n", + "plt.xlabel('Iteration number')\n", + "plt.ylabel('Loss value')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training accuracy: 0.363959\n", + "validation accuracy: 0.376000\n" + ] + } + ], + "source": [ + "# Write the LinearSVM.predict function and evaluate the performance on both the\n", + "# training and validation set\n", + "y_train_pred = svm.predict(X_train)\n", + "print('training accuracy: %f' % (np.mean(y_train == y_train_pred), ))\n", + "y_val_pred = svm.predict(X_val)\n", + "print('validation accuracy: %f' % (np.mean(y_val == y_val_pred), ))" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(lr, reg) 2.5e-08 25000.0 (y_train_pre, y_val_pre) (0.3475714285714286, 0.371)\n", + "(lr, reg) 2.5e-08 30000.0 (y_train_pre, y_val_pre) (0.35877551020408166, 0.36)\n", + "(lr, reg) 2.5e-08 35000.0 (y_train_pre, y_val_pre) (0.3629387755102041, 0.369)\n", + "(lr, reg) 2.5e-08 40000.0 (y_train_pre, y_val_pre) (0.3616122448979592, 0.376)\n", + "(lr, reg) 2.5e-08 45000.0 (y_train_pre, y_val_pre) (0.35928571428571426, 0.382)\n", + "(lr, reg) 3e-08 25000.0 (y_train_pre, y_val_pre) (0.35951020408163264, 0.378)\n", + "(lr, reg) 3e-08 30000.0 (y_train_pre, y_val_pre) (0.36679591836734693, 0.368)\n", + "(lr, reg) 3e-08 35000.0 (y_train_pre, y_val_pre) (0.3618571428571429, 0.371)\n", + "(lr, reg) 3e-08 40000.0 (y_train_pre, y_val_pre) (0.36483673469387756, 0.373)\n", + "(lr, reg) 3e-08 45000.0 (y_train_pre, y_val_pre) (0.35997959183673467, 0.37)\n", + "(lr, reg) 3.5e-08 25000.0 (y_train_pre, y_val_pre) (0.3690204081632653, 0.359)\n", + "(lr, reg) 3.5e-08 30000.0 (y_train_pre, y_val_pre) (0.36642857142857144, 0.38)\n", + "(lr, reg) 3.5e-08 35000.0 (y_train_pre, y_val_pre) (0.3656122448979592, 0.381)\n", + "(lr, reg) 3.5e-08 40000.0 (y_train_pre, y_val_pre) (0.3652244897959184, 0.377)\n", + "(lr, reg) 3.5e-08 45000.0 (y_train_pre, y_val_pre) (0.36287755102040814, 0.382)\n", + "(lr, reg) 4e-08 25000.0 (y_train_pre, y_val_pre) (0.36842857142857144, 0.385)\n", + "(lr, reg) 4e-08 30000.0 (y_train_pre, y_val_pre) (0.37187755102040815, 0.389)\n", + "(lr, reg) 4e-08 35000.0 (y_train_pre, y_val_pre) (0.36579591836734693, 0.376)\n", + "(lr, reg) 4e-08 40000.0 (y_train_pre, y_val_pre) (0.3669183673469388, 0.383)\n", + "(lr, reg) 4e-08 45000.0 (y_train_pre, y_val_pre) (0.3616326530612245, 0.379)\n", + "lr 2.500000e-08 reg 2.500000e+04 train accuracy: 0.347571 val accuracy: 0.371000\n", + "lr 2.500000e-08 reg 3.000000e+04 train accuracy: 0.358776 val accuracy: 0.360000\n", + "lr 2.500000e-08 reg 3.500000e+04 train accuracy: 0.362939 val accuracy: 0.369000\n", + "lr 2.500000e-08 reg 4.000000e+04 train accuracy: 0.361612 val accuracy: 0.376000\n", + "lr 2.500000e-08 reg 4.500000e+04 train accuracy: 0.359286 val accuracy: 0.382000\n", + "lr 3.000000e-08 reg 2.500000e+04 train accuracy: 0.359510 val accuracy: 0.378000\n", + "lr 3.000000e-08 reg 3.000000e+04 train accuracy: 0.366796 val accuracy: 0.368000\n", + "lr 3.000000e-08 reg 3.500000e+04 train accuracy: 0.361857 val accuracy: 0.371000\n", + "lr 3.000000e-08 reg 4.000000e+04 train accuracy: 0.364837 val accuracy: 0.373000\n", + "lr 3.000000e-08 reg 4.500000e+04 train accuracy: 0.359980 val accuracy: 0.370000\n", + "lr 3.500000e-08 reg 2.500000e+04 train accuracy: 0.369020 val accuracy: 0.359000\n", + "lr 3.500000e-08 reg 3.000000e+04 train accuracy: 0.366429 val accuracy: 0.380000\n", + "lr 3.500000e-08 reg 3.500000e+04 train accuracy: 0.365612 val accuracy: 0.381000\n", + "lr 3.500000e-08 reg 4.000000e+04 train accuracy: 0.365224 val accuracy: 0.377000\n", + "lr 3.500000e-08 reg 4.500000e+04 train accuracy: 0.362878 val accuracy: 0.382000\n", + "lr 4.000000e-08 reg 2.500000e+04 train accuracy: 0.368429 val accuracy: 0.385000\n", + "lr 4.000000e-08 reg 3.000000e+04 train accuracy: 0.371878 val accuracy: 0.389000\n", + "lr 4.000000e-08 reg 3.500000e+04 train accuracy: 0.365796 val accuracy: 0.376000\n", + "lr 4.000000e-08 reg 4.000000e+04 train accuracy: 0.366918 val accuracy: 0.383000\n", + "lr 4.000000e-08 reg 4.500000e+04 train accuracy: 0.361633 val accuracy: 0.379000\n", + "best validation accuracy achieved during cross-validation: 0.389000\n" + ] + } + ], + "source": [ + "# Use the validation set to tune hyperparameters (regularization strength and\n", + "# learning rate). You should experiment with different ranges for the learning\n", + "# rates and regularization strengths; if you are careful you should be able to\n", + "# get a classification accuracy of about 0.4 on the validation set.\n", + "learning_rates = [2.5e-8, 3e-8, 3.5e-8, 4.0e-8]\n", + "regularization_strengths = [2.5e4, 3.0e4, 3.5e4, 4e4, 4.5e4]\n", + "\n", + "# results is dictionary mapping tuples of the form\n", + "# (learning_rate, regularization_strength) to tuples of the form\n", + "# (training_accuracy, validation_accuracy). The accuracy is simply the fraction\n", + "# of data points that are correctly classified.\n", + "results = {}\n", + "best_val = -1 # The highest validation accuracy that we have seen so far.\n", + "best_svm = None # The LinearSVM object that achieved the highest validation rate.\n", + "\n", + "################################################################################\n", + "# TODO: #\n", + "# Write code that chooses the best hyperparameters by tuning on the validation #\n", + "# set. For each combination of hyperparameters, train a linear SVM on the #\n", + "# training set, compute its accuracy on the training and validation sets, and #\n", + "# store these numbers in the results dictionary. In addition, store the best #\n", + "# validation accuracy in best_val and the LinearSVM object that achieves this #\n", + "# accuracy in best_svm. #\n", + "# #\n", + "# Hint: You should use a small value for num_iters as you develop your #\n", + "# validation code so that the SVMs don't take much time to train; once you are #\n", + "# confident that your validation code works, you should rerun the validation #\n", + "# code with a larger value for num_iters. #\n", + "################################################################################\n", + "for lr in learning_rates:\n", + " for reg in regularization_strengths:\n", + " svm = LinearSVM()\n", + " loss_hist = svm.train(X_train, y_train, learning_rate=lr, reg=reg,\n", + " num_iters=1500, verbose=False)\n", + " results[(lr, reg)] = ( np.mean( y_train == svm.predict(X_train) ), np.mean( y_val == svm.predict(X_val) ) )\n", + " print(\"(lr, reg)\", lr, reg, \"(y_train_pre, y_val_pre)\",results[(lr, reg)])\n", + "# print(results[(lr, reg)][1])\n", + " if (results[(lr, reg)][1] > best_val) :\n", + " best_val = results[(lr, reg)][1]\n", + " best_svm = svm\n", + " \n", + "################################################################################\n", + "# END OF YOUR CODE #\n", + "################################################################################\n", + " \n", + "# Print out results.\n", + "for lr, reg in sorted(results):\n", + " train_accuracy, val_accuracy = results[(lr, reg)]\n", + " print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n", + " lr, reg, train_accuracy, val_accuracy))\n", + " \n", + "print('best validation accuracy achieved during cross-validation: %f' % best_val)" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{(2.5e-08, 25000.0): (0.3475714285714286, 0.371), (2.5e-08, 30000.0): (0.35877551020408166, 0.36), (2.5e-08, 35000.0): (0.3629387755102041, 0.369), (2.5e-08, 40000.0): (0.3616122448979592, 0.376), (2.5e-08, 45000.0): (0.35928571428571426, 0.382), (3e-08, 25000.0): (0.35951020408163264, 0.378), (3e-08, 30000.0): (0.36679591836734693, 0.368), (3e-08, 35000.0): (0.3618571428571429, 0.371), (3e-08, 40000.0): (0.36483673469387756, 0.373), (3e-08, 45000.0): (0.35997959183673467, 0.37), (3.5e-08, 25000.0): (0.3690204081632653, 0.359), (3.5e-08, 30000.0): (0.36642857142857144, 0.38), (3.5e-08, 35000.0): (0.3656122448979592, 0.381), (3.5e-08, 40000.0): (0.3652244897959184, 0.377), (3.5e-08, 45000.0): (0.36287755102040814, 0.382), (4e-08, 25000.0): (0.36842857142857144, 0.385), (4e-08, 30000.0): (0.37187755102040815, 0.389), (4e-08, 35000.0): (0.36579591836734693, 0.376), (4e-08, 40000.0): (0.3669183673469388, 0.383), (4e-08, 45000.0): (0.3616326530612245, 0.379)}\n", + "[2.5e-08, 2.5e-08, 2.5e-08, 2.5e-08, 2.5e-08, 3e-08, 3e-08, 3e-08, 3e-08, 3e-08, 3.5e-08, 3.5e-08, 3.5e-08, 3.5e-08, 3.5e-08, 4e-08, 4e-08, 4e-08, 4e-08, 4e-08]\n", + "[25000.0, 30000.0, 35000.0, 40000.0, 45000.0, 25000.0, 30000.0, 35000.0, 40000.0, 45000.0, 25000.0, 30000.0, 35000.0, 40000.0, 45000.0, 25000.0, 30000.0, 35000.0, 40000.0, 45000.0]\n" + ] + } + ], + "source": [ + "# import math\n", + "# print(results)\n", + "# x_scatter = [(x[0]) for x in results]\n", + "# y_scatter = [(x[1]) for x in results]\n", + "# print(x_scatter)\n", + "# print(y_scatter)" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the cross-validation results\n", + "import math\n", + "# 取出results中的lr和reg作为坐标轴\n", + "x_scatter = [math.log10(x[0]) for x in results]\n", + "y_scatter = [math.log10(x[1]) for x in results]\n", + "\n", + "# plot training accuracy\n", + "marker_size = 100\n", + "# 取出训练集和测试集的准确率\n", + "colors = [results[x][0] for x in results]\n", + "# print(colors)\n", + "plt.subplot(2, 1, 1)\n", + "plt.scatter(x_scatter, y_scatter, marker_size, c=colors)\n", + "plt.colorbar()\n", + "plt.xlabel('log learning rate')\n", + "plt.ylabel('log regularization strength')\n", + "plt.title('CIFAR-10 training accuracy')\n", + "\n", + "# plot validation accuracy\n", + "colors = [results[x][1] for x in results] # default size of markers is 20\n", + "plt.subplot(2, 1, 2)\n", + "plt.scatter(x_scatter, y_scatter, marker_size, c=colors)\n", + "plt.colorbar()\n", + "plt.xlabel('log learning rate')\n", + "plt.ylabel('log regularization strength')\n", + "plt.title('CIFAR-10 validation accuracy')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "linear SVM on raw pixels final test set accuracy: 0.370000\n" + ] + } + ], + "source": [ + "# Evaluate the best svm on test set\n", + "y_test_pred = best_svm.predict(X_test)\n", + "test_accuracy = np.mean(y_test == y_test_pred)\n", + "print('linear SVM on raw pixels final test set accuracy: %f' % test_accuracy)" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2]\n" + ] + } + ], + "source": [ + "nums = list(range(5))\n", + "print(nums[:-2])" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the learned weights for each class.\n", + "# Depending on your choice of learning rate and regularization strength, these may\n", + "# or may not be nice to look at.\n", + "w = best_svm.W[:-1,:] # strip out the bias\n", + "w = w.reshape(32, 32, 3, 10)\n", + "w_min, w_max = np.min(w), np.max(w)\n", + "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n", + "for i in range(10):\n", + " plt.subplot(2, 5, i + 1)\n", + " \n", + " # Rescale the weights to be between 0 and 255\n", + " wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n", + " plt.imshow(wimg.astype('uint8'))\n", + " plt.axis('off')\n", + " plt.title(classes[i])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inline question 2:\n", + "Describe what your visualized SVM weights look like, and offer a brief explanation for why they look they way that they do.\n", + "\n", + "**Your answer:** *fill this in*" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/assignment1/.ipynb_checkpoints/two_layer_net-checkpoint.ipynb b/assignment1/.ipynb_checkpoints/two_layer_net-checkpoint.ipynb new file mode 100644 index 000000000..344b7df87 --- /dev/null +++ b/assignment1/.ipynb_checkpoints/two_layer_net-checkpoint.ipynb @@ -0,0 +1,820 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Implementing a Neural Network\n", + "In this exercise we will develop a neural network with fully-connected layers to perform classification, and test it out on the CIFAR-10 dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# A bit of setup\n", + "from __future__ import print_function\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from cs231n.classifiers.neural_net import TwoLayerNet\n", + "\n", + "\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "# for auto-reloading external modules\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "def rel_error(x, y):\n", + " \"\"\" returns relative error \"\"\"\n", + " return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use the class `TwoLayerNet` in the file `cs231n/classifiers/neural_net.py` to represent instances of our network. The network parameters are stored in the instance variable `self.params` where keys are string parameter names and values are numpy arrays. Below, we initialize toy data and a toy model that we will use to develop your implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a small net and some toy data to check your implementations.\n", + "# Note that we set the random seed for repeatable experiments.\n", + "\n", + "input_size = 4\n", + "hidden_size = 10\n", + "num_classes = 3\n", + "num_inputs = 5\n", + "\n", + "def init_toy_model():\n", + " np.random.seed(0)\n", + " return TwoLayerNet(input_size, hidden_size, num_classes, std=1e-1)\n", + "\n", + "def init_toy_data():\n", + " np.random.seed(1)\n", + " X = 10 * np.random.randn(num_inputs, input_size)\n", + " y = np.array([0, 1, 2, 2, 1])\n", + " return X, y\n", + "\n", + "net = init_toy_model()\n", + "X, y = init_toy_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Forward pass: compute scores\n", + "Open the file `cs231n/classifiers/neural_net.py` and look at the method `TwoLayerNet.loss`. This function is very similar to the loss functions you have written for the SVM and Softmax exercises: It takes the data and weights and computes the class scores, the loss, and the gradients on the parameters. \n", + "\n", + "Implement the first part of the forward pass which uses the weights and biases to compute the scores for all inputs." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.01828828 0.75014431]\n", + " [0.98886109 0.74816565]]\n", + "[[0.01828828 0.75014431]\n", + " [0.98886109 0.74816565]]\n" + ] + } + ], + "source": [ + "# ta = np.random.random((2,2))\n", + "# print(ta)\n", + "# ra = np.maximum(ta,0)\n", + "# print(ra)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Your scores:\n", + "[[-0.81233741 -1.27654624 -0.70335995]\n", + " [-0.17129677 -1.18803311 -0.47310444]\n", + " [-0.51590475 -1.01354314 -0.8504215 ]\n", + " [-0.15419291 -0.48629638 -0.52901952]\n", + " [-0.00618733 -0.12435261 -0.15226949]]\n", + "\n", + "correct scores:\n", + "[[-0.81233741 -1.27654624 -0.70335995]\n", + " [-0.17129677 -1.18803311 -0.47310444]\n", + " [-0.51590475 -1.01354314 -0.8504215 ]\n", + " [-0.15419291 -0.48629638 -0.52901952]\n", + " [-0.00618733 -0.12435261 -0.15226949]]\n", + "\n", + "Difference between your scores and correct scores:\n", + "3.6802720496109664e-08\n" + ] + } + ], + "source": [ + "scores = net.loss(X)\n", + "print('Your scores:')\n", + "print(scores)\n", + "print()\n", + "print('correct scores:')\n", + "correct_scores = np.asarray([\n", + " [-0.81233741, -1.27654624, -0.70335995],\n", + " [-0.17129677, -1.18803311, -0.47310444],\n", + " [-0.51590475, -1.01354314, -0.8504215 ],\n", + " [-0.15419291, -0.48629638, -0.52901952],\n", + " [-0.00618733, -0.12435261, -0.15226949]])\n", + "print(correct_scores)\n", + "print()\n", + "\n", + "# The difference should be very small. We get < 1e-7\n", + "print('Difference between your scores and correct scores:')\n", + "print(np.sum(np.abs(scores - correct_scores)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Forward pass: compute loss\n", + "In the same function, implement the second part that computes the data and regularizaion loss." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3037878913298204\n", + "Difference between your loss and correct loss:\n", + "1.7963408538435033e-13\n" + ] + } + ], + "source": [ + "loss, _ = net.loss(X, y, reg=0.05)\n", + "correct_loss = 1.30378789133\n", + "print(loss)\n", + "\n", + "# should be very small, we get < 1e-12\n", + "print('Difference between your loss and correct loss:')\n", + "print(np.sum(np.abs(loss - correct_loss)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Backward pass\n", + "Implement the rest of the function. This will compute the gradient of the loss with respect to the variables `W1`, `b1`, `W2`, and `b2`. Now that you (hopefully!) have a correctly implemented forward pass, you can debug your backward pass using a numeric gradient check:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ True True]\n", + " [ True True]]\n" + ] + } + ], + "source": [ + "# ta = np.array([[2,2],[2,2]])\n", + "# print(ta > 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W1 max relative error: 3.561318e-09\n", + "b1 max relative error: 8.372507e-10\n", + "W2 max relative error: 3.440708e-09\n", + "b2 max relative error: 4.447625e-11\n" + ] + } + ], + "source": [ + "from cs231n.gradient_check import eval_numerical_gradient\n", + "\n", + "# Use numeric gradient checking to check your implementation of the backward pass.\n", + "# If your implementation is correct, the difference between the numeric and\n", + "# analytic gradients should be less than 1e-8 for each of W1, W2, b1, and b2.\n", + "\n", + "loss, grads = net.loss(X, y, reg=0.05)\n", + "\n", + "# these should all be less than 1e-8 or so\n", + "for param_name in grads:\n", + " f = lambda W: net.loss(X, y, reg=0.05)[0]\n", + " param_grad_num = eval_numerical_gradient(f, net.params[param_name], verbose=False)\n", + " print('%s max relative error: %e' % (param_name, rel_error(param_grad_num, grads[param_name])))\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 1 2 3]\n", + "[1]\n", + "[0]\n", + "[0]\n", + "[1]\n", + "[2]\n", + "[2]\n", + "[0]\n", + "[0]\n" + ] + } + ], + "source": [ + "# ta = np.array([[1,2],[3,4]])\n", + "# ta = np.arange(4)\n", + "# print(ta)\n", + "# print(ta[np.random.choice(4, 1, replace=False)])\n", + "# print(ta[np.random.choice(4, 1, replace=False)])\n", + "# print(ta[np.random.choice(4, 1, replace=False)])\n", + "# print(ta[np.random.choice(4, 1, replace=False)])\n", + "# print(ta[np.random.choice(4, 1, replace=True)])\n", + "# print(ta[np.random.choice(4, 1, replace=True)])\n", + "# print(ta[np.random.choice(4, 1, replace=True)])\n", + "# print(ta[np.random.choice(4, 1, replace=True)])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train the network\n", + "To train the network we will use stochastic gradient descent (SGD), similar to the SVM and Softmax classifiers. Look at the function `TwoLayerNet.train` and fill in the missing sections to implement the training procedure. This should be very similar to the training procedure you used for the SVM and Softmax classifiers. You will also have to implement `TwoLayerNet.predict`, as the training process periodically performs prediction to keep track of accuracy over time while the network trains.\n", + "\n", + "Once you have implemented the method, run the code below to train a two-layer network on toy data. You should achieve a training loss less than 0.2." + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "Final training loss: 0.017149607938732093\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "net = init_toy_model()\n", + "stats = net.train(X, y, X, y,\n", + " learning_rate=1e-1, reg=5e-6,\n", + " num_iters=100, verbose=False)\n", + "\n", + "print('Final training loss: ', stats['loss_history'][-1])\n", + "\n", + "\n", + "# plot the loss history\n", + "plt.plot(stats['loss_history'])\n", + "plt.xlabel('iteration')\n", + "plt.ylabel('training loss')\n", + "plt.title('Training Loss history')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 1 2 2 1]\n", + "[0 1 2 2 1]\n" + ] + } + ], + "source": [ + "# print(np.argmax(net.predict(X), axis=1))\n", + "print(net.predict(X))\n", + "print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[False True]\n", + " [ True True]]\n", + "[[0 1]]\n", + "[[ True True]\n", + " [False True]]\n" + ] + } + ], + "source": [ + "# ta = np.arange(25).reshape(5,5)\n", + "# print(ta)\n", + "# print((np.argmax(ta, axis=1) == y).mean())\n", + "ta = np.array([-1,3])\n", + "(ta > 0).mean()\n", + "ta = np.arange(4).reshape(2,2)\n", + "bool_ta = (ta > 0)\n", + "bool_tb = ta[0:1,0:2]\n", + "print(bool_ta)\n", + "# print((ta > 0).mean())\n", + "print(bool_tb)\n", + "\n", + "print(bool_ta == bool_tb)\n", + "\n", + "# ta_single = False\n", + "# print(np.array(ta_single))\n", + "# print(np.array(ta_single).mean())\n", + "\n", + "# ta_single = False\n", + "# print(ta_single.mean())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load the data\n", + "Now that you have implemented a two-layer network that passes gradient checks and works on toy data, it's time to load up our favorite CIFAR-10 data so we can use it to train a classifier on a real dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train data shape: (49000, 3072)\n", + "Train labels shape: (49000,)\n", + "Validation data shape: (1000, 3072)\n", + "Validation labels shape: (1000,)\n", + "Test data shape: (1000, 3072)\n", + "Test labels shape: (1000,)\n" + ] + } + ], + "source": [ + "from cs231n.data_utils import load_CIFAR10\n", + "\n", + "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n", + " \"\"\"\n", + " Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n", + " it for the two-layer neural net classifier. These are the same steps as\n", + " we used for the SVM, but condensed to a single function. \n", + " \"\"\"\n", + " # Load the raw CIFAR-10 data\n", + " cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n", + " \n", + " X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n", + " \n", + " # Subsample the data\n", + " mask = list(range(num_training, num_training + num_validation))\n", + " X_val = X_train[mask]\n", + " y_val = y_train[mask]\n", + " mask = list(range(num_training))\n", + " X_train = X_train[mask]\n", + " y_train = y_train[mask]\n", + " mask = list(range(num_test))\n", + " X_test = X_test[mask]\n", + " y_test = y_test[mask]\n", + "\n", + " # Normalize the data: subtract the mean image\n", + " mean_image = np.mean(X_train, axis=0)\n", + " X_train -= mean_image\n", + " X_val -= mean_image\n", + " X_test -= mean_image\n", + "\n", + " # Reshape data to rows\n", + " X_train = X_train.reshape(num_training, -1)\n", + " X_val = X_val.reshape(num_validation, -1)\n", + " X_test = X_test.reshape(num_test, -1)\n", + "\n", + " return X_train, y_train, X_val, y_val, X_test, y_test\n", + "\n", + "\n", + "# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n", + "try:\n", + " del X_train, y_train\n", + " del X_test, y_test\n", + " print('Clear previously loaded data.')\n", + "except:\n", + " pass\n", + "\n", + "# Invoke the above function to get our data.\n", + "X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()\n", + "print('Train data shape: ', X_train.shape)\n", + "print('Train labels shape: ', y_train.shape)\n", + "print('Validation data shape: ', X_val.shape)\n", + "print('Validation labels shape: ', y_val.shape)\n", + "print('Test data shape: ', X_test.shape)\n", + "print('Test labels shape: ', y_test.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train a network\n", + "To train our network we will use SGD. In addition, we will adjust the learning rate with an exponential learning rate schedule as optimization proceeds; after each epoch, we will reduce the learning rate by multiplying it by a decay rate." + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iteration 0 / 1000: loss 2.302954\n", + "iteration 100 / 1000: loss 2.302550\n", + "iteration 200 / 1000: loss 2.297648\n", + "iteration 300 / 1000: loss 2.259602\n", + "iteration 400 / 1000: loss 2.204170\n", + "iteration 500 / 1000: loss 2.118565\n", + "iteration 600 / 1000: loss 2.051535\n", + "iteration 700 / 1000: loss 1.988466\n", + "iteration 800 / 1000: loss 2.006591\n", + "iteration 900 / 1000: loss 1.951473\n", + "Validation accuracy: 0.287\n" + ] + } + ], + "source": [ + "input_size = 32 * 32 * 3\n", + "hidden_size = 50\n", + "num_classes = 10\n", + "net = TwoLayerNet(input_size, hidden_size, num_classes)\n", + "\n", + "# Train the network\n", + "stats = net.train(X_train, y_train, X_val, y_val,\n", + " num_iters=1000, batch_size=200,\n", + " learning_rate=1e-4, learning_rate_decay=0.95,\n", + " reg=0.25, verbose=True)\n", + "\n", + "# Predict on the validation set\n", + "val_acc = (net.predict(X_val) == y_val).mean()\n", + "print('Validation accuracy: ', val_acc)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Debug the training\n", + "With the default parameters we provided above, you should get a validation accuracy of about 0.29 on the validation set. This isn't very good.\n", + "\n", + "One strategy for getting insight into what's wrong is to plot the loss function and the accuracies on the training and validation sets during optimization.\n", + "\n", + "Another strategy is to visualize the weights that were learned in the first layer of the network. In most neural networks trained on visual data, the first layer weights typically show some visible structure when visualized." + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsnWd4HNXVgN+jbjVbxUW2JMu9d7mbXm0CJrSYFkqAUPIFSIMEQggkgZBAAgmE3lsAUwwBU13AvePeJVuyLMuyerGk3fv9uLOr3dWutJJ3Ve/7PPvs7sydmTMzu/fMPefcc0QphcFgMBgMACFtLYDBYDAY2g9GKRgMBoPBiVEKBoPBYHBilILBYDAYnBilYDAYDAYnRikYDAaDwYlRCgZDCxGRa0Xku0bWfyYi17SmTAbDiWKUgqHDIyJZInJmW8vhiVJqtlLqlabaiYgSkcGtIZPB0BRGKRgMHRgRCWtrGQydC6MUDJ0aEblRRPaIyDERWSAifa3lIiL/EJEjIlIiIt+LyGhr3RwR2SYiZSKSKyK/auIYfxeRIhHZLyKzXZYvFpEbrM+DRWSJdayjIvJfa/lSq/kmESkXkR81Jre1TonIbSKyG9gtIk+KyKMeMn0sInec+BU0dDWMUjB0WkTkdOAh4DIgBcgG3rZWnw2cDAwFegA/AgqtdS8AP1VKxQGjgW8aOcxUYCeQDDwCvCAi4qXdg8AXQAKQCvwLQCl1srV+nFIqVin13ybkdnChdeyRwCvA5SISYp13MnAG8FYjchsMXjFKwdCZuRJ4USm1Xil1HPgtMF1EMoBaIA4YDohSartSKs/arhYYKSLxSqkipdT6Ro6RrZR6TillQ3fOKUBvL+1qgf5AX6VUtVLKp4O6CbkdPKSUOqaUqlJKrQZK0IoAYB6wWCmV38gxDAavGKVg6Mz0RT9lA6CUKkePBvoppb4B/g08CeSLyLMiEm81vRiYA2RbJp/pjRzjsMv+K62PsV7a/QYQYLWIbBWR61sit0ubgx7bvAJcZX2+Cnitkf0bDD4xSsHQmTmEfjoHQERigCQgF0Ap9YRSahIwCm1G+rW1fI1Sai7QC/gQeOdEBVFKHVZK3aiU6gv8FHiqkYijRuV27NJjm9eBuSIyDhhhyW0wNBujFAydhXARiXJ5hQFvAteJyHgRiQT+AqxSSmWJyGQRmSoi4UAFUA3YRCRCRK4Uke5KqVqgFLCdqHAicqmIpFpfi9CdumO/+cBAl+Y+5fa1f6VUDrAGPUKYr5SqOlGZDV0ToxQMnYVPgSqX1/1Kqa+B3wPzgTxgENreDhAPPIfuoLPR5pm/W+uuBrJEpBS4mXqzzIkwGVglIuXAAuB2pdR+a939wCsiUiwilzUhd2O8AozBmI4MJ4CYIjsGQ+dARE5Gm5EylFL2tpbH0DExIwWDoRNgmcFuB543CsFwIhilYDB0cERkBFCMDof9ZxuLY+jgGPORwWAwGJyYkYLBYDAYnHS4ZFrJyckqIyOjrcUwGAyGDsW6deuOKqV6NtWuwymFjIwM1q5d29ZiGAwGQ4dCRLKbbmXMRwaDwWBwwSgFg8FgMDjpcOajlvLVtnzu+XBzk+0EnfVYBBz5j10zITs+6vXubUXEuQ0CoSKEiCCC23uI6LYhzu/i3G94aAjhoaLfw0KIsL5HhIUQHqq/iwiRYSFU19koLK9hYM8YYiPDsNkVybGRhIeGMLxPHGGhQlxkOHFRYSggNMRbRmeDwWCop8sohV7xkZw2rFejbRzRuQrl8rl+naJ+Yf1yvVR5Xaaw2fW+7Kp+uc1ev96uFHY72KwDVtXaKK22U1Nnp9Zmp9amnJ9rbNZ7nR17MyOJI0JDqLHZGZvane9zSpg+MIkLJ/RlSO849h4pJzw0hNSEbvSIjmBwr1g2HSxmeEockWGhzTuQwWDo0HQZpTA2tQdjU3u0tRgBwWZX1NrqJ62WVNWSW1zF+uwiUhOiASgoq2bl/mMUlh8nITqCEBE2HizmUHE1ACv2FbJiX6HX/YeGCDZL6/zxglFcMyMjuCdkMBjaDR1u8lpmZqYy0UcnxpGyarbmlrIzv4ySqlqKK2vILa5m6a4Cr+3Hp/XgiinpTB6QyNurD5AUG8Hs0SmkJnTjX9/s4dRhPTlafpy8kmrmTU43ZiqDoR0iIuuUUplNtjNKweBgbdYxFHCsooZjFTW8vjKbrYdKm7WP6QOT2HqohLX3nkVEmIljMBjaC/4qhS5jPjI0TWZGotv3y6ekA1Bda2P47xf6tQ+HSepQcRVxUWEs3HqYK6akuznrDQZD+8UoBUOTRIWHsutPs8kqrGBIr1i25ZVy3hONlRiG29/ewKacEgAmZyQytHec13Y7D5ex43Apc8f387r+/fU57C0o59fnDD+xkzAYDH5hxvcGv4gIC2Fo7zhEhFF9u/PVL05xrhuQHNOgvUMhABwu0c7tmjo7nubKc/65lNvf3ujzuL94ZxNPLtp7ouIbDAY/MSMFQ4sY3CuWL+48mUPFVZw6rBfL9x7liudWeW374xdXM7R3LLvyy/nNucO49dSGpYm355Xy+spsHpw7mhDjqDYY2gwzUjC0mKG94zjVmvsxY1Ay3/7mND6/42RuOXVQg7a78ssBeHPVAQA+3ZzHbW+sd67/8YureWPVAQrKj7eC5AaDwRdmpGAIGGmJeo7EXecOZ/rAJAYkx3DZMyvIs8xHoM1QQ+75lFqbuxmpqKIG0CYmb9jsyoS6GgytgBkpGILCyUN7kpYY3aDz31dQ0WAZQJ01We6kRxax50gZe46Uu03Qq6q1BVdgg8EAGKVgCDLP/XgS183M8Lru7JG9vS6//uW1nPnYEs75x1Lnst9/uIXqWptzRGEwGIKDMR8ZgsqE9AQmpCfw0rKsBusyvEQtARw4VgnAvqMVzmUfbMhl08Fi9h2tIOvh84Iiq8FgMCMFQyvxzk+n88DcUc7vb980jQlpzctF5VASryzP8rreblcNQl4NBkPzMGkuDK1Onc1OWKh+Hrn5tXUs3Hq42fuYkN6Dv10yjsG9YgGtEC55ejkA7986M3DCGgydBJPmwtBucSgEgL9cNIbKWpvPZHy+2HCgmL9/vpOM5BgunNCXR7/YxfoDxYEW1WDochilYGhTEmMiePX6KRworKRP9yiG3vuZ39s6Rhjvrj1IoYsDurS6ltX7jnHDq2tZ+uvTSE+KDrjcBkNnxfgUDO2C9KToFmdVrfYIV53wwJd8sDEXgA0Hi05YNoOhKxE0pSAiaSKySES2i8hWEbndS5srReR767VcRMYFSx5Dx+Ca6f2bvU1FjbtSsNkVYdZEN3sjPrOFWw6zfM/RZh/PYOjMBHOkUAf8Uik1ApgG3CYiIz3a7AdOUUqNBR4Eng2iPIYOQKCqvIVaqbrv/O8mvvDhyL759XVc8Xx9vqYvth5mwwHvI4sbXlnDXxfuCIhsBkN7JmhKQSmVp5Rab30uA7YD/TzaLFdKOf6FK4HUYMlj6BgkxkQEZD/Z1lwHgJteW8dPX1vL0fLjHGtk8ttNr63jh08t97ruq+1H+M9ik63V0PlpFUeziGQAEwDvaTQ1PwG8ehlF5CbgJoD09PQAS2doT8RHhQdkP+uy3Z/4P9+az+db8wEaTH7LL63mqUV7AnJcg6GjE3RHs4jEAvOBO5RSXms7ishpaKVwl7f1SqlnlVKZSqnMnj17Bk9YQ5sTEiJkPXweI1PincvOHKEzsb5541QunVQ/mBzvZfKbY95CYyzYdIjd+WXO71P/8jWvrMj2Sz5fCfsMhs5CUJWCiISjFcIbSqn3fbQZCzwPzFVKFQZTHkPH4a8XjyXJMiWdPbIPWQ+fx4xBydz7g3q3VFR4w5+vP47qn7+1gbNc8ip5Ul1rY/X+Y87vron5fvbmem+b+M1HG3NZm3Ws6YYGQxsRzOgjAV4AtiulHvPRJh14H7haKbUrWLIYOh5jUruz9t4zeeOGqVyaWT866N4tnF+dPRSAe8/zjFsAAlAL+rY31nPZMyvIOlrBz9/awJQ/f+Vc98W2/BPq1G9/eyOXPL2C4kqT2M/QPgnmSGEmcDVwuohstF5zRORmEbnZanMfkAQ8Za03+SsMTkSEmYOTEY+O/menDyHr4fMY3a87639/VoM6C2/eMPWEjvv1jiMAFFXWsGDTIYoqa93W3/Bq836me46U8c2OfLdl4x/48oRkNBiCRdAczUqp74BGH9uUUjcANwRLBkPnJzEmgr1/mcPz3+7jT//bTkp8FDMGJ/PydZO59qU1J7Rvb3UfAHp0087wypo69hwpJz4q3GfGV4AzH9OmKpPd1dARMGkuDJ2C62cOYERKPDMHJwM4y4SCHjm8sfoA//s+r1n7PF7nvbBPVmElkx78khqbnbLqOr2sjTr8tVnHGJ4ST2yk+SsbAoNJc2HoFISEiFMheDJjcDJ3nDGk2fu8+oXVPtcVVtQ4FYIn+wrKKSgLfq3pYxU1XPL0Cu54e0PQj2XoOhilYOi0pCdG0yNam3qCXd/5rMeW8MwSPbnt9EeXcNIj3zRoU2cLbDhrZY1WStsOeY30diOvpIosl6JFBoMvjFIwdFoW/epU1t17FkCLk+35y+4j5Tz0WX0ajOrahgrguMcch2VN5F3675oDrMv2HenkSOvk6Yj3xvSHvuHUvy9usp3BYJSCodMSGiLOEUJqQjQPXTQmqMfrFh7a6PpNOe71Hm59o/E5D3fN38zF/1nhc/1jX5oobkPgMUrB0GW4fEo6F03s13TDFtItonGlcMVz7lleSqpqyS6s4JbX11F+3Lt/AuC0vy+mrLqWXS6zsEHXrYbmTc3oaJUWDa2PUQqGLsXfLxnHrj/NDtr+7fbmdbqn/G0xn205zAcbcik/Xkd2YUO7//6jFTyycCdn/2MpCzYdarC+OUqhtMq38vGXI6XVLLLmcrRHvs8pNsrvBDBKwdClCAmRBv6FVb87w+37CJe8S83hWEUNEx6sn5RWa7Pzq3c3+bXtp9/nMfvxpZzyt8Ve1289VALAzsMNncriYzpQZU0dc//9nXNbgOKqE59JfdULq7ju5TUBd5wHgiW7Crjg38t4faV/uawMDTFKwdAl+fY3p3HrqYPoEx9Fr7hIt3WOBHyeJEQ3ncG1pKp+9vOGA8W8ty7HL3lW7Cvk4LEqQOdeckQWOXDUnw5txrBgfXYxm3JK+Mun253LfIXRNoeswsqA7SvQ7DlSDsDeAhNp1VKMUjB0SdISo/nNucNZ+bszEBEiQuv/CnalOHVYfTbecandGdOvO1//8lSevGIiADMGJTV5jMue8e0kboyR9y1k5H2fe13nLdLIl55wLLe7PNCXVtd6b9wMIq2RVmsrBbtdceOra1m5z3feTEdp1qgmnP4G3/ilFERkkIhEWp9PFZGfi0jDvMUGQwcl0sOk9NyPM52fP/rZLD7+v1kkxkQwZ0wf/nThaP7xo/FBk6Uxt4S3+RbZhZUcdCkq5MCpFFzs6/505F9ty290hBMZpjvc0upaqmtt/PytDeQUNTx+oCmtruXLbfn89LV1Pts4wn4976fBf/y9cvMBm4gMRmc+HQC8GTSpDIZWpmd8vQlJKZw1nj0REa6a1p/e8VGtJZoboSFCSWVtg1HIz7x0zCGWVlCqPly2vAmlUFNn54ZX1/KrdzexfK/3eRSOlOWlVbUs3lnAgk2H+OPH21p0Ps3B4TtprO62IzVJpJe06gb/8PfK2ZVSdcAPgX8qpe4EUoInlsHQurx6/RSSY+tLgfozIcwX/Xp0C4RIXhGBBZty3eo9AGw6WMysvy5yW+ZUCihnuGxjoa8A//yqfu7De+tyeGV5VoM2DtNMaXWds9aEq/ktWCi0MmgssOh4rWOkYMxHLcXfO1krIpcD1wCfWMsCUzfRYGgHpCZEc93MAQD4G8z49S9P8bp8TL/uAZKqIY8s3Empn7b8EKf5qH7k4yvJn4P80vqcTe+vz+UPC7Y2aOMwzZRW1zor0f1vc/OSDTbGS8v2k3H3/6jwUGB1dodSaHqk4K0Ak8E//L1y1wHTgT8rpfaLyADg9eCJZTC0f3w9HYeGBjfPUmmVf85iV5+Cw8HseJLelV/G9rxSHvtyF3P//Z1zm5jIpp+wnUqhqtatKt23uwsAWL3/GM8t3eeXjN54/tv9gA7xdcUxB8TT57LzcBkZd/+PHYdLnefXGiOXzopfV04ptU0p9XOl1FsikgDEKaUeDrJsBkOb4O+8p3CXjse1DGi4H8n3/nbJWH59zrBmywawar+/ld+0HBsOFDtzMTkcsWf/YymzH/+WJ77ezaac+nkM3mZlez6ZO867rLqOGhelcPULq6mutXHZMyv4s0sYrIMdh0vZV1Dutqymzt4g/NYXNksO5TGW+9QapXy6+bCzjcP8t/VQCRl3/4+NB91TjBh842/00WIRiReRRGAT8JKIeC2xaTB0VBw1CaKbSFfhoGdcJCcNSebNG6fyx7mjm3Wsiyamcttpg32aoBrD3w7Om0O2MfPRqn2Fzqd0923qO/5Hv9jpVEqu5iMHt7zuOzLo3H9+y+mPLnFbdtkzKxqE3ypnx+6+fZ2taZ+CYxThOPdvtuuZ16+vzCa3uMr3hgYn/o6xuiulSoGLgJeUUpOAM4MnlsHQ+lwxNZ1fnzOMm04e6FzWmBkiNER47SdTmTHIvY6Dj4JtbjgGE00l0XOQmuCf89rRob6z9iA7D5c1WO+ZqdVBrc3Oj55dic1LPGxVTb0i+dc3e5yfK467jxQAFu0s8Lp/X+m9XRXc4ZJq5j65jCNWLQpPZ7+jo/dUCo6v4tbGvdF763KY+XDDdObNZcGmQwz+3afO+RCtRdbRCqY/9DWHS6qDfix/lUKYiKQAl1HvaDYYOhXhoSHcdtpgZ3TN53eczHd3ndbs/fiT/8jR4flb5+Gj22b61a6yxsbfPt/Bb977nns/3NJgva/OrLLGdydXUVPn1blrs0N1I9s5Ovxam505T3zrXF5YfpxHv9jZ4Dq9siKLTQeLnQ5lz/U2p0/B+/UVqVcGwcrA8cjCHdTZlV9FlBbtOEJZACYLgh7p5JVUs2BTbkD21xj+KoUHgM+BvUqpNSIyENgdPLEMhrZnWJ84ejVjPkKcZX6qs/vfI3kqhdmj+3htlxQb6XW5Jx9uzOXJRXt9rvc1UmgsVHXWXxfx9JKGjmOb3U5FI0rhwieXoZSiykMR3fPBFv71zR6WucyDqLXZ+c9id7ltdsXCLXm8tfqA8zs0Hh2mPMxHwaKp3R8orOS6l9dw9/ubA3I8x6CpNfL8+etoflcpNVYpdYv1fZ9S6uLgimYwdCxW/O4MNt13ts8Edd5wnSR3z5wR/PWSsS3yMzg4Utr4E+xHGw9xv5cw06ZMK39duKPBaMGmaNJJ/Ny3+yipdH9arrC2cR0ILPZidrIpxc2vr+e3Vsdqc44ClLssDh8E0sB81NI+tKSyluteWs2RMndzjb/TVwrK9X3ILQqMH0Occ06Cj7+O5lQR+UBEjohIvojMF5HUYAtnMHQkYiPD6B4d7ozgCQ8Vnr5qolubp66cyNzxfZ3fXUcKN548kPiocAb1jOXTn5/EkF6xzZahuLLpLKgve5mQ5g+eJhOb3U7F8cZt63/5dEeD2c6O/tx1kBTuJYzXl/kIcHOIO30K4upoblQsn+zKL6O0upZ31h5k0c4CnvEyQvIHx32IiwprmSAetLuRAvASsADoC/QDPraWGQwGDxw+iT+cP4pzR6dww6wBznVzxqTw+LwJzu9hId7/giP7xjtnJHsyb3Kaz2Pv8OJcDhSHS92fmosqar3Wd/Bke567k9nu8mTvoM6Ld97mOTJx6em/3Jbv9VjKZTTREs7+x1KufG5VkyMCz7BYBze+upYHP9nmnGMRiMR8Ty3e41ROvo4bSPxVCj2VUi8ppeqs18tAz6Y2Mhi6Io6QVkfUzr0/GOmzbWOOZk+7+Ls3T+fRS8fx5x/6Livq/xyG5pPnEfmyopFspa54+liW79XbfeyiUCq8mKE8FYWvjt71MnmGpPrzZF1TZ2d7XqlToWzOrZ+3cbS8aYeyK19uy+eF7/ZTa2voLF+044hbJJe/uI5W2tNI4aiIXCUiodbrKsC/X4TB0MU4e2RvACYPSGyyra/Ee9DwSXlyRiIXT0rFz4ClBkzOSGjZhhYlfs6k9iTfh5/j/Q31mVi9ZW91VYpfbst3++54Yn7+2338e5EOk33sy118Y1WEa07n+eAn25j9+Lf8d83BBus+2uh9JNTU/h33zhGyuz2vlOteXsMfP27oz2kK1zoerVFRzl+lcD06HPUwkAdcgk59YTAYPJg6MIl9f5nD+LT67PJJMRFe24ZYPby3+RDJPiKOvCXrc0317YsTTdTXVIbV5uI6I9xbnQdXH8b9C7Z6NTE98bX3IEi7UtjtqslcT4AzuWBzIoUcnX5ucRXveFEmNpv7DHKHOemAlxTnTZHg8ttpqa+kOfgbfXRAKXWBUqqnUqqXUupC9EQ2g8HghRCPx/lv7zqN7+8/22vbP14wik9+PqvB8vsaMTt50pRD874fjCTsBPMBPfBJYNNju16hRxbubLD+J6+sdX7OLa5ySwToeGD2lc12x+Ey5j27kqcW+w7PdeAthNjVn7Mmq94k5/CDvL36AAVlx5n58Df8Zv73DaKwHHMtHDO+HSOG8BbcA9cJju3JfOSNXwRMCoOhkxMdEUZ8lPfEwtfMyGBo77gGy0c3I9tqU0ohKjyUKR7mLMe8iraisTkO3rjx1Xol0VTf+MGGXFZnNfSvXPn8St5Ypes3l1bXsju/zOvTt6uuufRpXbvihe/2O5/0n/t2P3/7fEe9PB778PR/OEY5S3YVsHRXffjtop1HePG7hqlF1h8o4l/WKMgt+rYdOZq9EdxUkAaDwS/OGdXbp8JxEBkWwqWT3KPIvSW/60gcPFbp97wBB8v2FHLPB1vYeqiEy59dyVn/WOp3pNKDHiOlWhdz1smPuNey8PQHuWaT/fGLq52fr3tpTYMRWE5RJRc9tZxHv9zVwIfQ3kcKrTGPwmDo0gzv03AE4cpvZw/nmaszie/WhFIID0FEmD6wvra0v4n/WsrfLx0XtH2vyy7ipEcWUVzZMuf3eU98x1YrH5OnUggNaTj90JuD1zUZYGFFjVsbm4f/Y4EPh7UDV9+Hq9KoqLG5jQ5ao9NtdPwoImU+5BAgeOWlDAYDAJ/836xGOwLHk3JTpiBHJTLXJ1bPDKfeiAoPcabdbi4XTejHr97d1KJtW5Naj0RJ3sKEvY0mPMNVXVOI1Lm0Lz9ex8KthxuV4UjpcdISowEocqkj0aB2RltHHyml4pRS8V5ecUqptjVIGgxdgLDQkEadkz3jdIRSSIjw1JUTfbbrn6Q7nFqXzqrAjxh8RwTVZZnNS2DQPym6gbMdaBBOe5YVvtuWNFAKIg0c2Et2NUzD4TknxDV/lEOJFFfWUOuH8nXd1lX/lFXXeZ2HEUyC1rGLSBrwKtAHsAPPKqUe92gjwOPAHKASuFYptT5YMhkMnYUPb5vJ+uwiLhzfz7ns3FF9uPmUQWQdrXB7Mn3p2slOR7bNJdLm/gtG8dgXu5g2KImesZFu6S9evX4KcVFh9E+K4Z21B5sdNePL1L/u3rOY8OCXAESEhZBuPR23JZ4dbVWtjb997h4N5RoJ5QvX8qEOn0JWYSWvrMjy2j6vpD4vkutIxNUM5Tk3pL07mpuiDvilUmoEMA24TUQ8Y+xmA0Os103Af4Ioj8HQaRif1oPrZw1we6INCRHunj2chy8ew4Uu+ZXGucyX+N3sEc7PV07tz7rfn8WTV0zkpCHuNSFOHtqTCekJJMZEcPMpgwI2aSo8rL7LCQ+RFqej8IfLp6S3eNvGssb6wnUCnut5/fMr73Mpso7Wz1lwVwr1bSpq6tzUQHt3NDeKUirP8dSvlCoDtqPzJrkyF3hVaVYCPay6DQaDoYX0iI7gny75lUJdFMeMwcneNmkVs8SPp/d3S3wXHhbidY7A01dNCsjxMvv7N4O7pTO1PXGdz/CsHzWqXRVBTlEVn27O49fvbqLMRSEd90g73uaO5kAhIhnABGCVx6p+gOt0wBxrWZ7H9jehRxKkp7dc+xsMXZHI8Kaf/Zp6Ym9ufQJv5qYH5o52ywWUEB3hdtywEKHOrkiO9T77u7mEecm8Gky+2Oo9SZ8val0U4m1vereaV9Xa3DRBa4wUgq4URCQWmA/cYZX0dFvtZZMGp62UehZ4FiAzM9OEwhoMzSAyrGmlEOWiOFzNTQ6aO5LwDHd9fN54wH2m96vXT+Ff32jTysMXjWHm4GT2FJS7Re6cCL6yzAYLfxMEOvAMW/VGVY37SKo1fApBVQoiEo5WCG8opd730iQHcM0DnAo0nYvXYDD4jWckzQ/GpriZOgBOGdqTB+eO4uJJqURHNOwWGntCnTYwkZX73PfnmTLaNcro7tnDmTEoibTEaK6bOYAvt+Vz+ohe9IqLIi0xms05JQQC19DShOhwilo4pyEYvLP2YINKc96oqnWfp9Aa9qOg+RSsyKIXgO1Kqcd8NFsA/Fg004ASpVSej7YGgyEA/PuKiaz63Zluy0SEq6dneFUI0Lj56OXrpnDLqYMYkBzjXOY5W9q1bsTNpwxibKoejYxIiWfDfWfTK66+7OmYVP/TezSG60hhxW/PCMg+fdFck9dv3vue/Ucrmmy3cl8ha7KKnN/bTeW1FjITuBo4XUQ2Wq85InKziNxstfkU2AfsAZ4Dbg2iPAaDoYV4Rh+9deM0JvVP4H8/n0VUeCh3nTvcbXTQzWOk4K2yWmPEBGC2tWOkkJrQLSDFbhpjREp8s87R37xTnsWEWiN1dtDMR0qp72giP5LSZ3hbsGQwGAyBwZG++fc/GMlFE/qREBPB/Ftm+GzvmabbVzZTX3jmDmoJDl+3Pz6VQBAaIm75kBojMjyEsubV7wE6+OQ1g8HQtsRGhvlVT8Af5k1OJzIslB9O6NdotTiAK6em86tzhgEwLrU7m1rgI3B0fm/eOJUtuSX85dMdjW/gBYf5qCl5A4GIEB4SQjX+pQQ5Wt50LW1vdIroI4PB0DasvffMphv5SWiIcMkk/1JdXD4l3Wmuef2GqRxpwSMbf66sAAAgAElEQVSxw0zSOz6KGYOSG1UKF09MZf76+ipu541J4bLJac6UGqE+6mCfCD2iw92S8YUIhDbDfDQlI9Frau+m6Ogzmg0GQxsSFR4adFu6N1wtRXFR4QzqGdvsfThGCuFNdOjD+8Tx6GXu2Vj/74zBnDK0p3PS3gnWFvJKrzj3qnhC46VVG9DCwcssH5MPA4lRCgaDod3hiHYKD9O95zXT+zvXOQoKzb9lOm/dOA2ARb861RkB5Ih0csyJCA3CfIUhHkWRRBpP2XHXucPdvq/e3/xRAuj0I8HGKAWDwRAQAhkZ49iVo4P/49zRznUf/2wWf790HJP6Jzod4AOSY4izCg2J02ykP3jL1tocEqLDyXr4PLdlD100xu27QKPzIG4+ZeAJyeCgNSbkGaVgMBgCSsMSNS3HNczzjjOHcMbwXmQkx3j1bzhaOhSKI6WGY6Rw7YwMt/ZTMtzLkzq4cqp7Kh1vIwBHSGnf7np+RVN9dXOjr3zRCj5zoxQMBkNguDRTJyfo0z2qiZb+45pD6Y4zh/LCtZN9tu2XoMNgHSGojrBWx4jhD+ePZNMfzna2f+fm6dxy6qAG+zl9eC+37RxK5swRevk9c0YgIuz602zuO38UELhO38GQXt79MIE+jjdM9JHBYAgI18/M4NoZGQENAW1OUrt/XT6BJbsKnBXMHPnmHPKISINJdd6cw442sZFhlFTVOv0bz1/jrpAiXOY/CLDu3jOZ9KevyEiKJquwPi32H873rBjQNM1NQBhIzEjBYDAEBBEJ+JyApqKPXOkRHcFcl6JDjrTcrjJ5zjp2rLtoQv12YdboxOHQbnwiXf26pNhIsh4+z+kMvnB8X344oV8Ds5U/tGXWTzNSMBgM7Y7k2EiOlh8/ISex3cN8BPXmF4ffwDFSSHYJMXWU54y1/AaNzSJ26AtvVp1J/RO4enpGi2Rvw4GCUQoGg6H98dHPZp5wttTIMG0GSo51n1Ow7y9zXCKU9KjANXLKoQzG9OvOjsNlbjUgPHGscXWu+9uhP33VRPYdreCRhTsbrGtL85FRCgaDod3Rr0e3BvmTmsuMQUk8MHcUF010j1RyHX04Prr2wePSevDitZnMGJTMu+tyOMNyMHvDsZ1XK1cTTuFzR6eglOKFb/dTWOGe9sL4FAwGgyHAiAg/np7hfPL3hvNJ36P/Pn14b6LCQ/nurtN43KW0qSeOztufMNz5t8zg8ztObiDjfZYjOj4qjA9u1UkG54xpu6rEZqRgMBi6LLV12n8Q4SOTampCdKPbnzykJ4N7xfLzM4Y0eaxJPmpGx1uT7sanJzAhPYGN951FXFQ4m3NKWL63edXcAoEZKRgMhi5LjeVUjghtWY6o7tHhfPWLUxjWJ67pxj5IteZXDLSKFPWIjiA0RHj9J1NbvM8TwYwUDAZDl8WhFBw5lgJBU5lMX71+CsdcfAhDescx/5bpjOrrXnHuRNNztBSjFAwGQ5elxmE+CkIqVV9durekdpP6e0+54SA5NqLFNRiai1EKBoOhy+KYkxARFsL8W2bwfU5xG0vkzgNzR1FWXce8yWktqkvREoxSMBgMXRbXkcKk/gk+ncFtxY9dJr8lecy3CBbG0WwwGLosQ626CBmWk9dgRgoGg6ELc/3MAUwbmMToft2bbtxFMCMFg8HQZQkJkYArhJTuOsTUUQmuo2FGCgaDwRBAfnryQAYmx3DOqD5tLUqLMErBYDAYAkhYaAiz2zBNxYlizEcGg8FgcGKUgsFgMBiciGrLag4tQEQKgOwWbp4MHA2gOB0Bc85dA3POXYMTOef+SqmG06k96HBK4UQQkbVKqcy2lqM1MefcNTDn3DVojXM25iODwWAwODFKwWAwGAxOuppSeLatBWgDzDl3Dcw5dw2Cfs5dyqdg8I6I3A8MVkpdFaT9bwVuU0otFhEBXgQuBHYDvwSeV0oNC/Ax04FtQHellC2Q++4qiEgWcINS6isv604iCPfN0PZ0tZFCl0VErhCRtSJSLiJ5IvKZiMxqjWMrpUYppRZbX2cBZwGpSqkpSqlvA9GxiEiWiJzpcswDSqlYoxCCg7/3TUTuF5HXW0MmQ2AwSqELICK/AP4J/AXoDaQDTwFz20Cc/kCWUqqiDY7d4RGRLpWFoKudb7tAKdUlXsC5wE5gD3B3W8sTwPNKAxYB24GtwO3W8kTgS2AvUAdcay0X4AnrOnwPTATuB1532ee7wGGgBFgKjHJZNwdtlikDcoFfWcuTgU+AYuAY8C0QYq3LAs4EfgJUAzagHPgjcCqQ43E+7wMFQCHwb2v5IOAba9lR4E1L/k+A1wC7y2sTMARQQDTwX2A/UGTJtwe40eWY9wPvAK9a57UVyGzkmj8OHARKgXXASS7rQoHfWde9zFqfZq0bZd2TY0A+8Dtr+cvAn1z24XlNsoC7gC3WtdsBHAFyrGOUA4esfSdY29xoHcduXfMrgF8D8z3O5V/AP32cZxbwK+s6l1jXMcqHjHdZv4cy9P/sDPR/rgaotWTcZLXtCyyw5PN2L94DXrfkzrfOYT4QBQwANqN/0+8AEdZ2kZZ8e4BVQEZb/zeb8R9+0bqfW1yWOf6/uz3ua4P/r8s211jtdwPXtFietr4grXTRQ60/6UAgAt1pjGxruQJ0bimOHwYQB+wCRgKPAHdbf0wb8IjVZg7wmfXjmmb9ge7HXSlcb+0rEj3C2OiyLg+rEwQSXI79EPA0EG69TqLeZ5UFnGl9vhb4zmV/zs7Fuk+bgH8AMVYnMMtaNxhtdooEelr3cwfwibW+AqtjteS4B60UfmZ9XwJ8gVZ449FK5wyr/f3oDmiOJcNDwMpGrvlVQBI6d9gv0QrU0Vn+Gt1pDbOu8TirbZx17X5pnVccMNXa5mWaVgobLdlvsZZdDgy37vOb1vn/GfgrcClacS63ZLgE2ID+rVQAPax9hKE7o0k+zjMLWI3uxBPRDx43e7lvw9BKsq/1PQMY5HJtX/fY7xL0SDXKx72oRf8G96N/Y5+ileu1aEXwP7Qye9rletwKPG19ngf8t63/m834D5+MfjhzVQqPYD28ov/Hf/X1/7WWJwL7rPcE63NCi+Rp6wvSShd9OvC5y/ffAr9ta7mCdK4foTvPnVYncKX1x99prX8GuNyl/U7g755/XJf1PdCda3fr+wHgp0C8R7sHrGMP9rKPLPxTCtOtDiKsiXNMRSuP3eiRgqAV39ku+1liyf0F2kxms87lqNX+IeBlq/39wFcu+x8JVDXjmhcB41yu51wvbS4HNvjY/mWaVgq3ojtJ8djWcZ83Wtd2J/A5sMzLfU6xOpQbrWU/ALY1cl5ZwFUu3x+hvuN1vW+Drd/YmUC4xz7ux/2BI826F3EuyzzvxVKgH1rRJFrX7hhwjnX/DgNTcPlfW+c83foc5rjPbf1/bMZvKAN3pbATSLE+p9D4/zfFukbPuCx3a9ecV1fxKTh+YA5yrGWdChHJACagn/57K6Xy0OaWRKCX1czbtYh32UeoiDwsIntFpBTdMYA2DwFcjH5ayRaRJSIy3Vr+N/SQ9gsR2Scid7fgFNKAbKVUnZdz6yUib4tILrpzHAI4EuEnUW86cpyTI29xX3QndEwpVYw2gyShU6W4/gYOu3yuBKJ82bNF5Jcisl1ESkSk2JLDcX3S0KMYb+fmbbm/2NEK8yUR2SAii0Xke2Ao+gl+NHqU08s6Vjjef/OvoEc6WO+vNXFcz+sS69lAKbUHuAPdoR+x7lNfH/vri74XZS7LPO/FQaVULvph5QDaXBKD7uhrgBKl1Grc/8fO37X1+3Hc546K4/+L9d7Y/7dfI8ubTVdRCuJlWaeKxRWRWLTd9Q6lVKnLqhVo00i4o6mXzV2vxRXoJ+sz0Z1dhut2Sqk1Sqm56B/ph+jhPEqpMqXUL5VSA4HzgV+IyBnNPI2DQLqPzvghS85fAc9ZcjrOpbFzErRdOlFE4lzWpaNt4M3CCsW8C7gMPTzvge6AHDIcRPs/PPG1HLRJJ9rlu7dE/CFoE8N/0OG8s4D16A6yB9rf4CqDt/qSCn3PxorIaPRI4Q0fMjULpdSbSqlZ6EAChTZjOY7pyiHc7wU0vBdKRBLQv8MBaEVyCD3Cj8Ndkbne5wZiteBU2ju+zjNg599VlEIO+unJQSr6R9YpEJFwtEJ4Qyn1vrU4X0RSlFIl6Kf4KBG5EP3klyEis0XkEfS1cH1qiwOOo0cY0eiIJcdxIkTkShHprpSqRTtabda6H4jIYGsegmN5c8NBV6Pt7g+LSIyIRInITBe5ytE2+guBt9EjoNPRfg/QZgysc8q3PueizQnLgYfRiq4f2undkg4xDu3kLADCROQ+XEZawPPAgyIyRDRjRSQJbebqIyJ3iEikiMSJyFRrm43AHBFJFJE+6KduTwrQ5ppV6A7fhlbY+SJyB3qk0B1txnke3TmfbMkw2Gp7SClVjXbkvgmsVkodaME1cENEhonI6SISiX4AqaL+3uejf28hAEqpg+h78ZB1f8fi/V6cCexXShVYv7XX0WbRGOAtq43r/9j5H7ceKrqjTU4dlXwRSQGw3o9Yy331ZQHr47qKUlgDDBGRASISgXZELWhjmQKC1Qm/AGxXSj3msmoBOhoBdCf/GXAv2sfwAtoBuxv9lFvust2r6OF8LjrKaKXHIa8GsizT0s3UmyKGAF9Z+1oBPKXq5yb4hdJzCs5Hd+4H0D/0H1mr/4h+Uv4Z+g9yD/pP/41S6kq0QvmTZc55DB2xAfCxdR0uR9ug44APgD8opRxtmsPn6Gu5C32dqnEftj+GHj19gVaOLwDdLHPJWdb5HUZf+9OsbV5D+0iyrO3+6+W4RcBBERmmlNqGNhFORXcEF6N9CDOAj5RS76L9FL9DK/zP0T6SPGtfrwBjaNp05C+RaIXrsPf3so4N2jkOUCgi663Pl2MpKXzfiwPANBGJtn7j6dQ/rEy22lyD9mOB++/9EvTvoiOPFFzPx/M8f2wp+2nokWIe+h6fLSIJ1ijrbGtZ82lrB0srOnLmoP/Ie4F72lqeAJ7XLPQw8Xv0E+dG61yTgK/Rnc/XQKLVXoAnreuwmUZCL9v7C+3sdEQfDUQrhj3ojijSWh5lfd9jrR/Y1nKfwPmOB9Za9/pDdJRJs+8zuoOtxCNYoL290A8CO9CmsdfQodd3d7b7jB755KGjrnLQI6eW3NfrrfPfA1zXUnmaTHMhIolKqY48DDMYDBaWGecxtEK4vq3l8RcRmYwe/aUpdye1IcD4M1twlYhsBF4CPlNNaRGDwdAuEZEYtI0/Gz1/pUMgIq+g/Ui3G4UQfPwZKQja6XM9Ojb4v+iY4l3BF89gMBgMrUmzsqSKyGnoKIAYtGPsbqXUiiDJZjAYDIZWxp+RQhI6wuRq9NDzBbQHfDzwrlJqQLCFdCU5OVllZGS05iENBoOhw7Nu3bqjyo8azf74FFagPf8XKqVyXJavFZGnWypgS8nIyGDt2rWtfViDwWDo0IhItj/t/FEKw3w5l5VSf/W23GAwGAwdE38mr30hIj0cX6zJES2bFGEwGAyGZqOUYuW+QvYVlDfd+ATxRyn0VDqRGABKqSLqkzMZDAaDIUhU19p4Z+1B5jzxHfOeXcmLy/YH/Zj+mI9sIpKurBwpIuJIeNVuqK2tJScnh+rq6rYWJehERUWRmppKeHh4040NBkOH5HBJNa+vzObN1Qc4VlHD0N6xPHTRGC4cH/zkzv4ohXuA70RkifX9ZOCm4InUfHJycoiLiyMjIwM9raJzopSisLCQnJwcBgxo1aAvg8EQZJRSbDhYzEvLsvhscx42pThjeG+un5nB9EFJrda3NakUlFILRWQiusqPAHcqpY4GXbJmUF1d3ekVAoCIkJSUREFBQVuLYjAYAkRNnZ1PN+fx0rL9bMopIS4yjGtmZHDN9AzSk6Kb3kGA8bcotg2dmTIKGCkiKKWWBk+s5tPZFYKDrnKeBkNnp6DsOG+uOsDrq7IpKDvOwOQYHpg7iosnphIT6W/XHHiaPLKI3ADcjs7PvRE9YliBzmNvMBgMhmawJbeEF5ft55NNedTY7JwytCfXXZLByUN6EhLS9g99/kQf3Y7OX56tlDoNXe7RL/uFiJwrIjtFZI+38owicrOIbBaRjSLynYiMbJb07YTi4mKeeuqpZm83Z84ciouLm25oMBg6NHU2O//7Po9Ln17OD/71HQu3HGbelDS+/uUpvHL9FE4d1qtdKATwz3xUrZSqFhFEJFIptUNEhjW1kYiEovN+n4XOEb5GRBYoXSDEwZtKqaet9hegU/p2mOyNDhxK4dZbb3VbbrPZCA0N9bndp59+GmzRDAZDG1JUUcNbaw7w2ops8kqqSUvsxr3njeCyyWnER7XPCEJ/lEKONXntQ+BLESnCvzJvU4A9Sql9ACLyNrrmqlMpKPdawjEEINT1jx9vZduh0qYbNoORfeP5w/mjfK6/++672bt3L+PHjyc8PJzY2FhSUlLYuHEj27Zt48ILL+TgwYNUV1dz++23c9NNOnjLkbKjvLyc2bNnM2vWLJYvX06/fv346KOP6NatW0DPw2AwtA47DpfyyvIsPtiQS3WtnRmDknhg7mhOH96L0HYyIvCFP9FHP7Q+3i8ii9C1Txf6se9+uJcpzEGXD3RDRG4DfgFE4MNPISI3YYXBpqen+3Ho1uXhhx9my5YtbNy4kcWLF3PeeeexZcsWZ9joiy++SGJiIlVVVUyePJmLL76YpKQkt33s3r2bt956i+eee47LLruM+fPnc9VVV3k7nMFgaIfY7Iqvt+fz8vIslu8tJDIshIsm9uOaGRkM7xPf9A7aCY0qBatK0/dKqdEASqkljbX33NzLsgYjAaXUk8CTInIFuobwNV7aPAs8C5CZmdnoaKKxJ/rWYsqUKW7zCJ544gk++OADAA4ePMju3bsbKIUBAwYwfvx4ACZNmkRWVlaryWswGFpOSVUt7649yKsrsjlwrJK+3aO469zhzJucRkJMRFuL12waVQpKKbuIbHKd0dwMctBFxR2k0rjZ6W3gP808RrskJibG+Xnx4sV89dVXrFixgujoaE499VSvM68jIyOdn0NDQ6mqqmoVWQ0GQ8vYW1DOK8uzeG9dDpU1NiZnJHD37OGcPbI3YaH+xPC0T/zxKaQAW0VkNVDhWKiUuqCJ7dYAQ0RkAJALzAOucG0gIkOUUrutr+ehi1R3OOLi4igr814lsKSkhISEBKKjo9mxYwcrV65sZekMBkOgsNsVS3cX8NKyLJbsKiAiNITzx/XlupkZjO7Xva3FCwj+KIU/tmTHSqk6EfkZ8DkQCryolNoqIg8Aa5VSC4CficiZQC1QhBfTUUcgKSmJmTNnMnr0aLp160bv3r2d684991yefvppxo4dy7Bhw5g2bVobSmowGFpCxfE65q/P4eXlWewrqKBnXCS/OGsol09Jp2dcZNM7OFHqaiBvI3RLgOQhQT1Us8pxtgcyMzOVZ5Gd7du3M2LEiDaSqPXpaudrMLQVBworeWVFFu+sOUjZ8TrGpXbnupkDmDMmhYiwIJqIaiohdy1kL4fsZXBwDdRVwbRb4dyHWrRLEVmnlMpsqp0/M5rLqHcQRwDhQIVSquO40w2GIGK3K/679iBPLtpD7/goMvsnMMl6JcW2wlOkIaAopVixt5AXl2Xx9Y58QkWYMyaFa2dmMDE9ITgHrS6Bg6u1AsheDrnrwV4LCPQZA5Ouhf4z9CvI+BOSGuf6XUQuRM9BMBi6PHuOlPO79zezOusYE9J7oJTipWVZPLN0HwADk2OY1D+BzIwEJvVPZFDPGJO/qp1SVWPjw425vLwsi535ZSTGRPCz0wZz5dT+9OkeFdiDVRy1RgHL4cByOLwZlB1CwqHvBJh+G/SfCWlToFuPpvcXQJqddUkp9aG3lBUGQ1fieJ2N/yzey1OL9tItIpRHLhnLpZNSERGqa21szi1hbVYR67KP8dX2fN5dp8ubJ0SHW6OIRDIzEhjTrztR4b5nvRuCz6HiKl5dkc3baw5QXFnLiJR4HrlkLBeM6xu4e1OSW28Kyl4OR3fq5WHdIG0ynHKXHgX0y4SI1s+M6oo/5qOLXL6GAJm0syI7BkNrsibrGL99fzN7jpRzwbi+3Hf+SJJdzERR4aFMzkhkckYiMAilFHsLKliXfcxSFEV8tf0IABGhIYzuF09mRqIeURiTU6uglGJtdhEvLdvP51vzUUpxzqg+XDsjgykDEk9sNKcUHNtXPxLIXgbF2XpdZDykT4Pxl+uRQMp4CGtfcxn8GSmc7/K5DshCp6swGLoUJVW1/HXhDt5cdYB+Pbrx0nWTOW1Y05VpRYTBvWIZ3CuWH03WM/ILy4+zLlsriLXZRby8LItnLZPTAIfJyTI7DeoZa0xOAeJ4nY2PN+Xx8vL9bMktpXu3cG44aQBXT+tPakILn9DtdijY7qIElkP5Yb0uOkmPAKbdot97j4aQ9j0y9MencF1rCGIwtFeUUny25TB/WLCVwvLj3HjSAO48ayjRES3PeZ8UG8nZo/pw9qg+gK7FuyW3hLXZRazNKuKbHUd4zzI59YgOZ1J6ApMyEsjsn8jYVGNyai5HSuvLWx4tr2FIr1j+/MPR/HBCv+bfR1sdHN7krgSqrWzH8f1gwEmWU3gmJA+FDqbQ/TEfvQLcrpQqtr4nAI8qpa4PtnCdldjYWMrLy9taDIMfHCqu4r6PtvLV9nxG9Y3nxWsmMyY18JOUosJDycxIJDMjEU7Rimjf0QrWZRWxNvsYa7OL+HqHNjmFhwqj+3W3opy0byLZmJy8svFgMS8v28//NudRZ1ecMbwX184YwMzBzShvWVsNh9bX+wMOroYa6/+bOAhGnK8VQP8Z0CO9wykBT/xRkWMdCgFAKVUkIhOCKJPB0ObY7IrXVmTxt893Yldwz5wRXDczo9XSF4gIg3rGMqhnLJdN1tlijlXUWOamY6zLKuKVFdk89+1+ADKSop0KIrO/Njm1l/z8rU2tTZe3fHl5FhsOFBMbGcZV0/pzzfQMMpJjmt7B8XLIWV0/CshZC7bjel2vUTDu8vrw0Lg+wT2ZNsAfpRAiIglKqSIAEUn0c7u24bO7dXhXIOkzBmY/7HP1XXfdRf/+/Z31FO6//35EhKVLl1JUVERtbS1/+tOfmDvXuGI6AtvzSrn7/c1sOljMyUN78ucLR5OW2LYRIQCJMRGcNbI3Z43UM+aP11kmpyztl1i88wjz12uTU/du4c65Epn9ExiX1qPTm5wKy4/z1uoDvLYym/zS4wxIjuH+80dySWYasY2Vt6w8BgdW1o8E8jaBsoGEQso4mHKjHgmkT4PoxNY7oTbCn879UWC5iLyHjjq6DPhzUKXqYMybN4877rjDqRTeeecdFi5cyJ133kl8fDxHjx5l2rRpXHDBBcZh2I6prrXx+Ne7eW7pPrp3C+fxeeO5YFzfdnvPIsNCmdQ/kUn9E/kp2uS0/2gFa7OLnGanbyyTU1iIMMoyOWX21/6JXnEBjr1vI7YeKuHlZVl8tOkQNXV2ThqSzMMXjeWUoT7KW5YddvcHHNmql4dG6JDQWXfqUUDaFIiMa7h9J8cfR/OrIrIWXetAgIs8qqe1Lxp5og8WEyZM4MiRIxw6dIiCggISEhJISUnhzjvvZOnSpYSEhJCbm0t+fj59+nS+4WZn4LvdR7nnw81kF1Zy6aRUfjdnRIdLeywiDOwZy8CesVyWqU1ORRU1rD9Q5FQUr6/M5oXvtMkpPTHaqSAy+ycypFfHMTnV2ex8tT2fF5dlsXr/MbqFh3JZZirXzshgcC+XjlwpKD7gPkfg2F69LjwG0qfC6B/qkUDfiRDeORTlieCPo3kasFUp9W/re5yITFVKrQq6dB2ISy65hPfee4/Dhw8zb9483njjDQoKCli3bh3h4eFkZGR4TZltaFuOVdTw5/9tZ/76HDKSonnzhqnMGJzc1mIFjISYCM4Y0ZszRmiTU02dnS2HSpwjiaW7C3h/Qy4A8VFhTHSMJPonMj6tB90i2pfJqaSylrfXHODVFdnkFleRmtCNe+aM4LLMNLpHh2slULCrXgFkL4dSbVIjqoceAWRep9/7jIPQ9msJbyv8uSL/ASa6fK/wsqzLM2/ePG688UaOHj3KkiVLeOedd+jVqxfh4eEsWrSI7OzsthbR4IJSig835vLgJ9sprarlttMG8X+nD+n0dveIsBAmpicwMT2BGxmIUorswko9krAm1y3eWQBYJqe+8W4O7F7xbfMkvTu/jJeWZ/HB+lyqam1MG5jIfeeP5MxhyYQWbIXvn7cUwQqoPKo3iu1tOYTv0O89R0BIx61z0Fr4oxREuaRStQrvGPXqwahRoygrK6Nfv36kpKRw5ZVXcv7555OZmcn48eMZPnx4W4tosDhQWMk9H27m291HGZ/Wg4cvHtOhyiUGEhEhIzmGjOQYLpmUCkBxpWVyshzYb6zK5sVl2uSUltiNzP6JznxOQ3vFBc3kZLcrFu08wkvLsvhuz1Eiw0K4eGwvbhpSSkbFStj4GCxYCcetmuw9+sOQs+sjgxIHdvjw0LbAn859n4j8nPqqaLcC+4InUsdl8+b6qKfk5GRWrFjhtZ2Zo9A21NnsvPDdfv7x1S7CQkJ4YO4orpzav90XUm9tekRHcPrw3pw+vN7ktPVQiQ6HzSri291H+cAyOcVFhTExvd55PT6txwlN6gMoq67l3bU5vLIii/zCIk6PPcA7ww4xQW0jfNda2GZVJUweBqMvtuYITIfuqSd0XIPGn7t3M/AEun6yAr4GbgqmUAZDoPk+p5i7529mW14pZ47ozYMXjiKle7e2FqtDEBEWwoT0BCakJ3DDSdr0duBYpXMksS77GI9+WW9yGtk33gqF1Wan3n6anPYfreDtb7eQveEbxtm38ky3vQzttpuQulrI9kghnT4dYnsG8ay7Lv5EHx1Bl9I0GDocFcfrePSLXTolGNwAABirSURBVLy8fD/JsZE8fdVEzhnVp92GmXYERIT+STH0T4rhYsvkVFJZa0U5ab/EW6sP8NKyLABSE7pZI4lEMvsnMLR3nHN0psoL2Lbqcw5t/JqUkvX8RrIJDVGo0DCk90To33YppLsq/kQfRQE/AUYBTpXf3tJcKKW6xB+9o1XKa0sW7TjCvR9uIbe4iqumpfObc4cTHxXe1mJ1SrpHh3Pa8F6cNlwnCKy12dl6qJR1+46wd98eCnZ/y7rv8zgsRxkQVsiwbsX0U/kkHs9hFDCICI4kjKV65CXEDDkZSZ3c5imkuyr+mI9eA3YA5wAPAFcC24MpVHOJioqisLCQpKRm5DPpgCilKCwsJCrKxFI3xpGyah74eBuffJ/H4F6xvHfzdJ1TyBB4aqugJEfPBSg5CMUHoeQg4SU5jC8+yPjSXD07GHTdRqA8rAe5tcmsqulLftyZDJh0FtNmnUF6pDHntQf8UQqDlVKXishcpdQrIvIm8HmwBWsOqamp5OTkUFBQ0NaiBJ2oqChSU41DzRtKKd5Ze5A//2871bV2fnHWUH56ykAiwzp3mGlQqSp26+w9O38qPP5zEqIzhXZPs5y/adAjTb93T4PuqcRGRDMMyKizEREa0qkf5Doi/iiFWuu9WERGA4eBjKBJ1ALCw8MZMGBAW4thaEP2FuiymKv2H2PKgEQeumgMg3rGtrVY7RuloPyI987e8e4I93QQFqWjfLqnQZ/R0D29vtPvkQZxff2eEGaUdfvEn7v3rJUu+15gARAL/D6oUhkMflJTZ+fpJXv59zd7iAoP4eGLxnBZZlqHSdcQVGy1UHqokSf9nPrsnw4iu+vOvUc6ZMx0edK3Ov+Ynib2v5PjT/TR89bHpcDA4IpjMPjPuuxj3D1/M7uPlPODsSncd/7ITpPkzS9qKl06+AMNn/LL8nQxeFdie+uOPmUsDD9Pd/6OJ/8eaRAV+FoRho6FmZls6HCUVtfyyMIdvL5Sl8V88dpM50SrToNSUFXkxaTj0vlXFrpvExIG8X31U/2Ak93t+T3Sta3fJHwzNIFRCoYOxcItedz30VaOlh/nJ7MG8IuzhhLTWK789ordDuX5jdvzazxmvod1q+/k+46v7+yd9vyUdl//19D+6YD/JkNXJK+kij98tJUvtuUzMiWe56/JZGxqO57MVFcDpbm+n/RLc8FW475NtwTdwScNgoGnarOO65N+dJKx5xuCjl9KQURmoCOOnO2VUq8GSSaDwYnNrnhjVTaPLNxJnd3Ob2cP5/pZAwhvpbKYTVJToSt15a7X70VZlj3/MDorjAPRpRu7p0G/iTByrrsDt3tqlyzoYmh/+DOj+TVgELARsGahoACjFAxBZcfhUn77/mY2HCjmpCHJ/PnCMaQnteEs17oayN+ii7jnbtDvBTvqnbnx/XRmzkGne9jz0/S6sMi2k91g8BN/RgqZwEhl8isYWonqWhv//mYPTy/ZS3y3cP75o/HMHd/KZTHtNji621IA6/X74c31Jp/oJF2pa8T5+r3fRIjt1XryGQxBwh+lsAXoA+QFWRaDgeV7j3LPB1vYf7SCiyemcs95I0gMdllMpaA4u77zz90AeRvrHb0RsdB3Aky9WXf+fSdqG7+x7xs6If4ohWRgm4isBpwzXZRSFwRNKkOXo6iihr98up131+XQPymaN26YysxglcUsP+KiANbBoQ314Z2hETpF87jL6xVA8hAT1WPoMvijFO4PthCGrotSigWbDvHAx9sorqrlllMHcfsZASyLWV2iO33XUYCjZq+E6BKNw2bXm4B6jYKwII9MDIZ2jD8zmpeISG9gsrVotVVjwWA4IQ4eq+TeD7ewZFcB49J68PpFYxiRcgJlMWurIO97dz9A4Z769QkDIH0q9L0F+k3Ss3ojYk78RAyGToQ/0UeXAX8DFgMC/EtEfq2Uei/Ishk6KXU2Oy8ty+KxL3cRInD/+SO5enpG88pi2mrhyHZ3BZC/rT5Nc1yKfvofN0+/950A0SZ9tsHQFP6Yj+4BJjtGByLSE/gKMErB0Gy25JZw9/vfsyW3lDNH9OKBuaPp26OJPPp2Oxzb62ICWg+Hv4e6ar0+qoc2/cy6s94PEJ8S/JMxGDoh/iiFEA9zUSHg18whETkXeBwIBZ5XSj3ssf4XwA1AHVAAXK+UyvZn34aORWVNHf/4chcvfLefpNhInrpyIrNHeymLqZSe7euqAA5thOMlen14NKSMg8yfWApggp4bYCKBDIaA4I9SWCginwNvWd9/BHza1EYiEgo8CZwF5ABrRGSBUmqbS7MNQKZSqlJEbgEesfZv6EQs3nmEez7QZTGvmJrOXecOp3s3qyxmRaG7CSh3PVRYzyAh4dB7FIy5uN4RnDzM73z9BoOh+fjjaP61iFwMzET7FJ5VSn3gx76nAHuUUvsARORtYC7gVApKqUUu7VcCVzVDdkM752j5cR78ZBsfbTzEoJ4xvHf9GDLDs2H9U/VKoPiA1VogeSgMPqNeAfQebbJ6GgytjF+PXEqp+cD8Zu67H3DQ5XsOMLWR9j8BPvO2QkRuAm4CSE9Pb6YYhtZGKcX81fv44LOFDLXt5tP0Iwy37yHkzV048wH1SNed/+Qb9HvKOIg6gcgjg8EQEHwqBRH5Tik1S0TKaJDZC6WUauof7M3I6zVVhohchU6ncYq39UqpZ4FnATIzM026jfaG3aZzAOWup3TvKgp2reSCmn1cIjbtTaroqTv+0RfX+wH+v717j66qvhI4/t0kAQKRkBAeyuOGp7yRJCK+8FHaolJ8UaUqRavW0uVop6tjh3aWtrazbO2MYyldAlZ8jbZWRy26VMaifYzKI0EQELWACQIBAgkhPEJee/74HWK43NycYM49N2F/1mLl3HNOuPv+4OSXs3+/s3/dA3owzRjzhTTbKajqBd7Xky3duB0Y2OT1AGBn9EkiMhU3w+kiVT0afdwkGVWo+NRL/7zvngguXQe1hwEQTadMhlI9dA6j8i+iU/98VwHUBoKNaRd8VUlV1dkt7YthNTBcRAYDO4BZwA1Rf89EYBEwzR6IS1IHSo8fCN75vlsRDNwi7v3Gs3vYdTxRnM2y/WcwesxE7p0xlj49bCzAmPbIz5jCmKYvRCQVyG/pm1S1TkTuBJbhkghLVHWjiNwPFKrqUtxDcRnA897UxG1WUykJVO6AwiWw7g9NSkKkQJ/Rx1UFreoxnF/9eStPryihX4+u/Gz2WKaO7mDLYhpziok3pjAP+BGQLiIHju0GavDy+y1R1deImr6qqvc22Z7a2oBNQFRh23uwchFsesWtETD8K3Dena4T6DcOOn++lsGyjbu47/H32F1VzZxzc/nBV88koz0ui2mMOU68MYUHgAdE5AFVnZfAmEwi1R6B9c/DqsVuvYCumTB5rpsVlD34hNN3VVZz39INLNu4m5H9TmPh7HzOGpjEy2IaY1rFz3MK80QkCxgOdG2y/29BBmYCtn8brH4M1jzpxgj6jIbpD8P462IWiWtoUJ5ZtY0HX/+ImvoGfjhtJLddmETLYhpj2oSfgebbgLtxs4fWApOB94BLgw3NtDlVKP67SxF97GX1Rl4Bk+6A3AuanSH0ye4q5r24nqKSCs4f1ot/v2ocuTlWXdSYjshPEvhuXNnsFap6iYiMBH4abFimTdUcgg+eg1WPwp4PIT0bzr/b1Q/qObDZb6uuree3b7tlMTO6pPKfX5/ANXn9E7sspjEmofx0CtWqWi0iiEgXVf1IRM4MPDLzxZV/Cqt/B+8/7Rab6TcOZiyAcTMhLXZl0opDNRSVVFBYUsEbG0op3neYayb258dXjKJXhi08b0xH56dT2C4iPYGXgTdFpIIYD6GZJKEKW9+GlYvhkzfc6mKjZ7gU0aDJx6WIVJVP9x6isKSCouIKCkvK2VJ2CIC0FGFc/0zuv3IsU0b0DuvTGGMSzM9A89Xe5k9E5G0gE3gj0KhM6x2tcs8VrFoMez+Bbjkw5QdQ8C3ocYY7pa6eDTsqKSx2dwJrSirYd6gGgMz0NPIjWVyTN4CCSBYTBvZsuyUxjTHthp+B5snARlWt8pbmPA2YCKwMPDrTsn1bXEew9lk4esDVFbpqIYy5mvKaTl4qaBNFxRV8sKOSmroGAHJ7dePiM/tQkJtFQSSLob0z6NSalc+MMR2Sn/TRI0Bek9eHYuwzidTQAFuWu1lEm9+ETmnomKvYMWI27x4ZTOHmCgqXr2Brk1TQ2P6ZzDk3Qn4km/xIFr1Ps/EBY8yJ/HQKoqqNlUlVtcErdWESrbrS3RGsehTKt1CT3pt1uXfw+/qp/OVDoXz1QWA9PbulkT8oi5n5AyiIZDN+QKalgowxvvj54b5VRO7C3R0AfBfYGlxI5gRlH1P9ziOkrn+O1PrDfJQ2ikV1/8SrFWdTW5HK4JzOXDrSpYEKcrMYkmOpIGPMyfHTKXwHmA/8G249hOV4C96YYKgqW3YfoLTwZfpueooRhwoRTeVPDefyjE6DPhMpmJjNgkgW+ZEscmyqqDGmjfiZfbQHV/baBKS6tp713qygTVtLyP3sJWbWv86FncrYTTYvZd1C5agbGTNiKM/2t1SQMSY48aqk3qOqD4rIb4ixYpqq3hVoZB3Y3oNHKSqpcDODisvZsOMAuQ0l3JyyjF+mvkM6R9mTk0dpwc/oN+lark7tHHbIxphTRLw7hQ+9r4WJCKSjamhQtpQdpLCkgsLiCopKyine51YpS09RbsnZxH9lv0akag2a2hUZ93WYdAd9Th8fcuTGmFNRvE7heuBVoKeq/jpB8bR71bX1rPtsv3tKuKSCNdsq2H+4FoDs7p3Jj2QxZ2IPvnxkGf3/8QxSuR0yB8LUnyB5c6BbdrgfwBhzSovXKeSLSAT4log8hVtgp5GqlgcaWTtRVnWUopLyxqeEN+6spLbeZduG9u7OV0f3I997QGxw3RZk1WJY8QLUVUPuhXDZL2DEZZBis3yNMeGL95NoIa6cxRCgiOM7BfX2n1IaGpTNZQe9DqCcopIKSrxUUOfUTkwYkMmtFwyhIJJFXiSL7O6dob7WrWT2ymK3sllaN5jwDZj0beg7OuRPZIwxx4u38tp8YL6IPKKqcxMYU9I4UlPPuu37GweE12zbT+URlwrq5aWCbjxnEPmRbMb270GX1Cazgg6WwV+fcGsdV+2EnhH4ys9h4k2QnhXOBzLGmBbEm33UQ1UPAD8WkRMS3R0xfbSnqtqrFuqlgnZUUtfgUkHD+mRw2dh+5EeyKMjNJrdXt9jrCuwochVKN74I9TUw5BKY/pBb77iTTSU1xiS3eOmjZ4HpuNSR0sHSRw0Nyj/2HHRpIK8j2FbuUkFdUjsxYUBPbp/ipYIGZZHVPc600Loa+PBPsGoRbF8Nad0hb45LEfUekaBPZIwxX1y89NF07+uJq7e3Q0dq6ln72X43KOyVjT5QXQdAToZLBc2eHCE/N4uxZ2TSOdXH2sNVu6DwcSh6HA7uhuwhMO0XcNYN0DUz4E9kjDFtz0/p7POBtap6SERuwlVHfVhVtwUeXRt6fUMp3//jOgCG98ngivGnkx/JpiCSRaS5VFAsqu5uYOUid3fQUAvDvgzn3AFDvwSdbCF7Y0z75bd09gQRmQDcAzwGPA1cFGRgbW3KiN4submAvEFZ9Ox2Ek8I1x2FDS/CyoVQuha69ICzb4NJt0OvoW0fsDHGhMBPp1CnqioiVwK/VtXHRGRO0IG1tZyMLlw6sm/rv7Fyh5tBVPQEHN4LOSPg8v+ACbOgy2ltHqcxxoTJT6dQJSLzgJuAKSKSAqQFG1bIVN0zBSsXuWcMtAFGTINzvu1mE/lNNRljTDvjp1O4HrgBuFVVd4nIIOBXwYYVktojsP55t7zlrvVusHjyXJcmyu4Q4+3GGBOXn9LZu4CHmrzeBjwVZFAJt38brH4M1jwJRyqg9yiY/jCMvw46dw87OmOMSRg/s48mA78BRgGdgRTgoKq27zmXqlD8d5ci+vg1t+/My90sotwLLUVkjDkl+UkfLcAtsvM8UAB8ExgeZFCBqjkEHzzn1jne86ErOXHeXXD2rdBzUNjRGWNMqHyV5lTVzSKSoqr1wOMi8m7AcbW9/dvcXcH7T0N1JfQbBzMWwLiZkJYednTGGJMU/HQKh0WkM7BWRB4ESoH2l2gvXQcrHoFRX4NzvgODJluKyBhjovjpFGbjxhHuBP4ZGAhcG2RQgRhxGXxvPWT2DzsSY4xJWn5mH5V4m0eAnwYbToBSUq1DMMaYFsQrnb0eVw01JlW1RYSNMaaDiXenMD1hURhjjEkKohr7ZkBEhgF9VfWdqP0XAjtVdUsC4osVVxlQ0uKJseUAe9swnLaSrHFB8sZmcbWOxdU6HTGuiKr2bumkeHcKDwM/irH/iHfsaycZ2Bfi50M1R0QKVbWgLeNpC8kaFyRvbBZX61hcrXMqxxWv+H+uqn4QvVNVC4HcwCIyxhgTmnidQtc4x+xpL2OM6YDidQqrReT26J0icitu3eb2aHHYATQjWeOC5I3N4modi6t1Ttm44g009wVeAmr4vBMowBXFu9qrnmqMMaYDabZTaDxB5BJgrPdyo6q+FXhUxhhjQtFip2CMMebUEW9Mod0SkWki8rGIbBaRf41xvIuIPOcdXykiuUkS180iUiYia70/tyUoriUiskdENjRzXERkvhf3ByKSlyRxXSwilU3a694ExDRQRN4WkU0islFE7o5xTsLby2dcCW8v7327isgqEVnnxXZCuZwwrkmfcYV1TaaIyPsi8mqMY8G2lap2qD+44n1bgCG48Y91wOioc74LLPS2ZwHPJUlcNwMLQmizKUAesKGZ45cDrwMCTAZWJklcFwOvJritTgfyvO3TgE9i/DsmvL18xpXw9vLeV4AMbzsNWAlMjjonjGvST1xhXZPfB56N9e8VdFt1xDuFScBmVd2qqjXAH4Aro865EnjS234B+JJI4HW0/cQVClX9G1Ae55QrgafUWQH0FJHTkyCuhFPVUlVd421XAZuA6EqLCW8vn3GFwmuHg97LNO9PdN464dekz7gSTkQGAFcAv2vmlEDbqiN2Cv2Bz5q83s6JF0fjOapaB1QCvZIgLoBrvZTDCyIyMOCY/PIbexjO9W7/XxeRMYl8Y++2fSLuN8ymQm2vOHFBSO3lpUPWAnuAN1W12TZL4DXpJy5I/DX5MHAP0NDM8UDbqiN2CrF6zOje3885bc3Pe76Ce5J8PPBnPv9tIGxhtJcfa3D1XCbg1hF/OVFvLCIZwP8A31PVA9GHY3xLQtqrhbhCay9VrVfVs4ABwCQRGRt1Siht5iOuhF6TIjId2KOq8Z4FC7StOmKnsB23ENAxA4CdzZ0jIqlAJsGnKVqMS1X3qepR7+WjQH7AMfnlp00TTlUPHLv9V9XXgDQRyQn6fUUkDfeD9xlVfTHGKaG0V0txhdVeUTHsB/4CTIs6FMY12WJcIVyT5wMzRKQYl2K+VET+O+qcQNuqI3YKq4HhIjJY3DKis4ClUecsBeZ42zOBt9QbtQkzrqi88wxcXjgZLAW+6c2qmQxUqmpp2EGJSL9juVQRmYT7/7wv4PcU4DFgk6o+1MxpCW8vP3GF0V7ee/UWkZ7edjowFfgo6rSEX5N+4kr0Namq81R1gKrm4n5GvKWqN0WdFmhb+VmOs11R1ToRuRNYhpvxs0RVN4rI/UChqi7FXTxPi8hmXA87K0niuktEZgB1Xlw3Bx0XgIj8HjczJUdEtgP34QbdUNWFwGu4GTWbgcPALUkS10xgrojU4ar3zkpA534+bona9V4uGlw14UFN4gqjvfzEFUZ7gZsZ9aSIpOA6oj+q6qthX5M+4wrlmoyWyLayh9eMMcY06ojpI2OMMSfJOgVjjDGNrFMwxhjTyDoFY4wxjaxTMMYY08g6BWOiiEh9k6qYayVGRdsv8HfnSjNVX41JBh3uOQVj2sARr/SBMaccu1MwxicRKRaRX3o1+FeJyDBvf0RElntF05aLyCBvf18ReckrQLdORM7z/qoUEXlUXA3///WepjUmKVinYMyJ0qPSR9c3OXZAVScBC3DVLPG2n/KKpj0DzPf2zwf+6hWgywM2evuHA79V1THAfuDagD+PMb7ZE83GRBGRg6qaEWN/MXCpqm71is/tUtVeIrIXOF1Va739paqaIyJlwIAmBdWOlbV+U1WHe69/CKSp6s+D/2TGtMzuFIxpHW1mu7lzYjnaZLseG9szScQ6BWNa5/omX9/ztt/l86JkNwL/520vB+ZC42IuPRIVpDEny35DMeZE6U0qjQK8oarHpqV2EZGVuF+ovuHtuwtYIiL/ApTxeVXUu4HFInIr7o5gLhB6yXFj4rExBWN88sYUClR1b9ixGBMUSx8ZY4xpZHcKxhhjGtmdgjHGmEbWKRhjjGlknYIxxphG1ikYY4xpZJ2CMcaYRv8Pt9YT9I69RWoAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the loss function and train / validation accuracies\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(stats['loss_history'])\n", + "plt.title('Loss history')\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Loss')\n", + "\n", + "plt.subplot(2, 1, 2)\n", + "plt.plot(stats['train_acc_history'], label='train')\n", + "plt.plot(stats['val_acc_history'], label='val')\n", + "plt.title('Classification accuracy history')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Clasification accuracy')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(50, 3, 32, 32)\n", + "(50, 32, 32, 3)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from cs231n.vis_utils import visualize_grid\n", + "\n", + "# Visualize the weights of the network\n", + "\n", + "def show_net_weights(net):\n", + " W1 = net.params['W1']\n", + " print(W1.reshape(32, 32, 3, -1).transpose().shape) \n", + " W1 = W1.reshape(32, 32, 3, -1).transpose(3, 0, 1, 2)\n", + " print(W1.shape)\n", + " plt.imshow(visualize_grid(W1, padding=3).astype('uint8'))\n", + " plt.gca().axis('off')\n", + " plt.show()\n", + "\n", + "show_net_weights(net)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tune your hyperparameters\n", + "\n", + "**What's wrong?**. Looking at the visualizations above, we see that the loss is decreasing more or less linearly, which seems to suggest that the learning rate may be too low. Moreover, there is no gap between the training and validation accuracy, suggesting that the model we used has low capacity, and that we should increase its size. On the other hand, with a very large model we would expect to see more overfitting, which would manifest itself as a very large gap between the training and validation accuracy.\n", + "\n", + "**Tuning**. Tuning the hyperparameters and developing intuition for how they affect the final performance is a large part of using Neural Networks, so we want you to get a lot of practice. Below, you should experiment with different values of the various hyperparameters, including hidden layer size, learning rate, numer of training epochs, and regularization strength. You might also consider tuning the learning rate decay, but you should be able to get good performance using the default value.\n", + "\n", + "**Approximate results**. You should be aim to achieve a classification accuracy of greater than 48% on the validation set. Our best network gets over 52% on the validation set.\n", + "\n", + "**Experiment**: You goal in this exercise is to get as good of a result on CIFAR-10 as you can, with a fully-connected Neural Network. Feel free implement your own techniques (e.g. PCA to reduce dimensionality, or adding dropout, or adding features to the solver, etc.)." + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hidden_size: 70 learning_rate: 0.000325 reg: 0.15 num_iters: 3000 Tra acc: 0.496469387755102 Val acc: 0.485\n", + "hidden_size: 70 learning_rate: 0.000325 reg: 0.15 num_iters: 4000 Tra acc: 0.5178775510204081 Val acc: 0.491\n", + "hidden_size: 70 learning_rate: 0.000325 reg: 0.25 num_iters: 3000 Tra acc: 0.4952244897959184 Val acc: 0.463\n", + "hidden_size: 70 learning_rate: 0.000325 reg: 0.25 num_iters: 4000 Tra acc: 0.5125918367346939 Val acc: 0.488\n", + "hidden_size: 70 learning_rate: 0.000345 reg: 0.15 num_iters: 3000 Tra acc: 0.5026122448979592 Val acc: 0.476\n", + "hidden_size: 70 learning_rate: 0.000345 reg: 0.15 num_iters: 4000 Tra acc: 0.52 Val acc: 0.497\n", + "hidden_size: 70 learning_rate: 0.000345 reg: 0.25 num_iters: 3000 Tra acc: 0.5035306122448979 Val acc: 0.484\n", + "hidden_size: 70 learning_rate: 0.000345 reg: 0.25 num_iters: 4000 Tra acc: 0.5173061224489796 Val acc: 0.488\n", + "best_val_acc: 0.497\n" + ] + } + ], + "source": [ + "best_net = None # store the best model into this \n", + "\n", + "#################################################################################\n", + "# TODO: Tune hyperparameters using the validation set. Store your best trained #\n", + "# model in best_net. #\n", + "# #\n", + "# To help debug your network, it may help to use visualizations similar to the #\n", + "# ones we used above; these visualizations will have significant qualitative #\n", + "# differences from the ones we saw above for the poorly tuned network. #\n", + "# #\n", + "# Tweaking hyperparameters by hand can be fun, but you might find it useful to #\n", + "# write code to sweep through possible combinations of hyperparameters #\n", + "# automatically like we did on the previous exercises. #\n", + "#################################################################################\n", + "input_size = 32 * 32 * 3\n", + "num_classes = 10\n", + "best_val_acc = 0\n", + "\n", + "hidden_size = [70]\n", + "learning_rate = [3.25e-4, 3.45e-4,]\n", + "reg = [0.3, 0.35]\n", + "num_iters = [3000, 4000]\n", + "\n", + "for hs in hidden_size :\n", + " for lr in learning_rate :\n", + " for rg in reg :\n", + " for num in num_iters :\n", + " net = TwoLayerNet(input_size, hs, num_classes)\n", + "\n", + " # Train the network\n", + " stats = net.train(X_train, y_train, X_val, y_val,\n", + " num_iters=num, batch_size=200,\n", + " learning_rate=lr, learning_rate_decay=0.95,\n", + " reg=rg, verbose=False)\n", + "\n", + " # Predict on the validation set\n", + " val_acc = (net.predict(X_val) == y_val).mean()\n", + " tra_acc = (net.predict(X_train) == y_train).mean()\n", + " print(\"hidden_size:\",hs, \"learning_rate:\",lr, \"reg:\",rg, \"num_iters:\",num, \n", + " 'Tra acc:', tra_acc, 'Val acc:', val_acc)\n", + " if val_acc > best_val_acc :\n", + " best_val_acc = val_acc\n", + " best_net = net\n", + "\n", + "print('best_val_acc:', best_val_acc)\n", + " \n", + "# # Plot the loss function and train / validation accuracies\n", + "# plt.subplot(2, 1, 1)\n", + "# plt.plot(stats['loss_history'])\n", + "# plt.title('Loss history')\n", + "# plt.xlabel('Iteration')\n", + "# plt.ylabel('Loss')\n", + "\n", + "# plt.subplot(2, 1, 2)\n", + "# plt.plot(stats['train_acc_history'], label='train')\n", + "# plt.plot(stats['val_acc_history'], label='val')\n", + "# plt.title('Classification accuracy history')\n", + "# plt.xlabel('Epoch')\n", + "# plt.ylabel('Clasification accuracy')\n", + "# plt.legend()\n", + "# plt.show()\n", + "#################################################################################\n", + "# END OF YOUR CODE #\n", + "#################################################################################" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(70, 3, 32, 32)\n", + "(70, 32, 32, 3)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQUAAAD8CAYAAAB+fLH0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsvEmvJUmanvf4PLufebhjTBkZmZGZNXd1sagudgtoDgIX0oLgQoAE/QKttNBC0o4QIEA7LfQHNBMSJAgkQYJsdjeqq7uGzKzIjMiY73zP6Mfn2V2Lgu7N2rBrxyQQz/IsvvfYMfteM/vM7Ahd1/GOd7zjHf8/4r/tL/COd7zjm8U7U3jHO97xW7wzhXe84x2/xTtTeMc73vFbvDOFd7zjHb/FO1N4xzve8Vu8M4V3vOMdv8U7U3jHO97xW7wzhXe84x2/hfxv+wsA/Of/K53UVJRVhiI1lILENlhimQqaoDHrOyTJEsVQaMuWjg2CPqWpRWpVpkgrelqDrjtcrSIMZ4BcyPyjf6AB8D/+T/8Px45Noau8fHOJN7S5Wm3Rcol2rLLJU2TfZ2+wTyZmrGuBbFPgyDaKC1LjUmsFgiLQs1Mc28FNdthDj7/7478HwFf/+D/j7Dwnut4wthWiOEXyDfLGItdcNEelKHLevvkrCCVGh48gaWmsmF2UsFfZzB4NWbc54jLCclTENuDv/A//CoDrL1aEmw1vz17jVy2CLuOZDtH2DK2REZqCqC4YeRaW12O5SvHXK0q5pmcMqMQGUXXoCvCmLk0acufeMfffP8TuDwD4T/7R54x0CalJEbucnVAhtQ2Sq9BvPUbjGdv1Na0o0KYZg6lCS5+kKdBMjTxqKduYuhERTBdFUXCUff6L/1AA4L/+uw4HD99HkQa0ssEmDDENh/FsnyhyOYtPkZqcXOmQsz6N0LI/8iiqgqAoGSodVV1zNLPZ7jZcLXxWmy8w1ZT/9n8JAPjz/+NfsohiBCmjzGtoGuK6JI8yqrahuFxTaRn3HwxJG5e0TtCaCFHqIVp92rVP52l0hc/++A6W0+cnf/AthMEhAH/zh/8xtmPy3oMDFE3AHgzYBVvy4IquVRkNh5ydvqJn2AxmfdyZQ3SxxN9sUAwTYWLhmDpZ0NFJCj1dIloHqGKP/+a/+y8B+K/++/8XRUzpzTzWuxSjSpAckWLtE+crVNXheNinbxt0WkeetCC7FFnNNuoQswBBBs+4gz1xiYOA6d4+f++P3xN+l3z8RpiCnj6haWW6IqVJF0iSjLLdIHmQbCKEoyMcQvrLlu3lW3IihNEBZZPRGQe0rUwoKFzULXWlEOoepWTdxNfKmiruuN5u2V2+oL4UkfUpm7JgfPc76EXJk+uQTVxAvqHdu0PcNswPjymEBMoGp1HYhQXlruOp/5aHewZmU95ovHwx4M2wwJcUDkMTAZXIPMctR6i993i1+jnVTuX6TYV+8AHlRQ89rBnOx9ydwXBvzLWwRW9MLDXD7e0TrhbAvwLgT/78/2K7XXKdu1g9D6oadyyy3TSMXQE6oCsh7XgeR6StTqR0iFGHn1zjCS1Bc4mglDTWhGIZU+1OEOL7N23oZ1+gygdUzYZut2PoeAT+mnyZc1FqpIs+slzxYKCzDF/z6ixkdO8+cdJhey7RtkBsM9bnS2JtRCe69Gfzm/gf/vgfggyKtkcQKRyOW2q9pMl7WHs91KVHpTQYYkXVOdRRy9oTGQgy78kati0zGLqs1hssJ+Vhr+IouMtVcgb8EwAutq+QxwZd1+fu+8c0isjidMkm2CIka7TBFFuQceYmntHRNS5NvUez3aI5CxrdpEpapOGMRtxStQHPntQ3bfhoIuDNTXok5HFGHLzFUDzaNqeSCvbmB1idiaYOMHs6dREx/+iIdi2y3QYIYYGLQ7F+S9vqFI6GIRlsr97eaDj2K8azIZq2oefklLWC1mWUdMS7kvG8QxN9bHlJLZcswx1qp6H0XHojm3hdYg5mtOqK8UzGtiJevfwZ/PF7v1M+fiNMQZEL6p2P1abQxPRcD1NQyeIFUhchJwaaVnB9eUK7XCH2TMLthrpJGR4fo9fg6uBnsEzXIDUY6q0pFtWIVNvhL1c0sUyrCPj5KzaVxXwX8Pr6OYvzV5T9O1gjHX2dYff2qfI1QqNwcX6NN3CQkg1xMiRvC6TiDn391njeBjl53eB1HXFf5OTZBv2qZNdLUMInZOmIZZKRKnvsa3dZnJ0z8lSqLqYTxoRfZQSqzYMjFb8oMSJoxre7OxEQyoK1f01Sb2jkEeJdKGWbINthkiEYOheZjDwA2W9wHKjyhrIT6ayWduFTFBJSIZKGGXZncLG5vO0HIyWv3yCmEZ2/pKlnJKszFEFH1CWqKKE/9ojSgG67Qeh0ujBDkmTSK6jEAKtMkKKEOI2pJA9LCW7i+36foN5wdL+H7DjU3Y5OEOlakUaocfom1DmlapKjE1chSZAymM8RHYu2bIlqhVbpk/sN4bZk4Owz/Nowng4dklKkCVLESYdfJHh7Osqsj9S1aLVKXmRMkFDUjrdRiGdPiIIdZebRH6hoXkVTuuxyEbcv0km3bRiO+1hqR+CvEfMUTZLI5IKmk/CGDpG/pSxyLKNBjlK03gBRthBkD0XVKcoMugQTgZ5jUnsCnmghl/mNxiCLcCSVJKrJNRVZkcjLjLwome49QLE73qzeorUtuixzcrlFRudgOKRWdJSZzcCdsk4C2mSBnsVk9evfOR+/EabQpV9htyXB1YK7s330MmLfVDi694gy2XIdJtStzDoAfycjhjmlm9LUUCpXqLoOggtlRl+uGZs5rXfbkW2dcVFAXxCJbJutn7O52KD14F+8+BKKgr073yGJr4n8FkHtc3r5ObmlU6YV05GKrovImoFQhYwlEXdQ0nP6Nxpue4gu6vx8saJ5e8ZoaLCr1tT+krG6x4//9jEnT84wfvzvET5X6H18wGTcYCkKLzchhZvz5tWOLyuF35/N+PXuGcXT24Hy9qtPmd2f8vi9xwRxjKibLDYrarXm+S6hrx1wNDfIpQIxlfGOa1yhYJeEyOkO0VbQuvvo6opCLXDmQ8rFG1an2xuN1cmnxDV0yxi1hqp8zp53gG3IpFGIpXYUfs3ZF1dcXb7A/ehDZCKEskW2KpyuRlFVDo4m5K9focg50tcWrJ39GEVYsM6HxGHHvUMbzdIpFThdnVNLW3q6TponXC5fM3NHWNoUc+iiKjKiNiUuCqLa5U14yXab8snwAM3bu9EQhYzBYEDbr5neKXGCDr0v00QeF5FEGC9RKonS7ojSlnHmI3cB2lSjbFpoVHTHQm17FEVAlwqE/vlN/CshYyAajG0Vbejy6z99QV3GOPMBNSKK1uPut7/H0fwBmV+jT3v835/9ORcvCq7WSx4oBZum4Tt336NIMuLNCTthwTaobjTuDQskdcfl2y0lLkLZ4k0MTLvCl0ySMOJsJfA3f/IJomRhVBpa1yFqCmfXX7Cn23zhv4JUoDc6osRHbC9+53z8RphC1AYMGwnbVFHJ6cqSrJAoNQFVVVHDCMczqCIJWbUwDQOpb6E2Aq5uIggNfcdBF2tQNMyBTY50E19XbOqg5Yt1jmXpZM0Ov5AYiBbiuubFNuDhoc7jx9/m9MU547096sYkzV4hVjXJVUWy2jEa9kjjDNdWSC2fM6V3o6EpCutlwKgLeeZL6LVCKqp0ox6SC5FuoIzG7N1/xJ6e8PTpZ5S1xHTusHt6RTpXEIWQbG2g9RtsZcrZsX8TP24FlpuUuhciKC1ST0cQffqzGVfZkthp8aWG4OwUq9HJTJ19S8VvttgG5EJNIgZIu5Sh3WOVhgyUGjm91QjUisxPsEQRtQ2QKg1xWyJ4HW1ZUoZXGPv7lGGJbM15b/8YVe7R7EJGqoKfdPQnHmWekc776E7DWXBrOmGSEdUKSRCgKy5gE6crKgrkXoiqVUR5gTIRkMMlpSrS6A3RImPuHuANB+gNxELCrlExHINFLLBv2Tcay7RDLHd0ioL97Bx92ENtZ4RFQcOGulGQhBJFyMllgcV2i4HKvU+mZGVFtatYbBZEwRLyjHIgYSu3CVvqFn7ecTzYw1Fler0FbVgT7WpEVeIsi5gd1WxOAvrzY/qTKVPB4jKL6Dct6W5HlMWs9SEbf8udD/tUSUD1tX64Xp1wLOxhyTmy6JBsFxgPH6CKGn5psl746JMhftpRxdcYZcvVYkPfExnVLXGwpItUck3AL0dIZYRVTX/nfPxGmILadAiiDIpM3iaUmxjLcqmKHm0LQlqStiDkUDUqUVFiFA2mYrF/KJFlIl22QaoK0krA9nTKILqJrykxwkDhoO5RSwFqZhA5fWaTIUVp4IUB0apEOYwZSQVRsMYbC7x9vmVf0lE6iUqs8JMVs6GHbTrkwpZ0dXqjITY7RrszGm2Cq5RkxhQ73jK6bxOFsFqu6CyTyyTE2cvwkiOs44rtSU3qKsTNjlwSUEwRnZwuaJlr86/Fr6CUIBLIlZjSdwmEiiprEfpjGjouT7d4UkdKTryLEIQJ1uwYt8swhxX7mcU21hBNFS0W8Nw5FO2NhiA0NIVKUbYIdUjrR0SqQBXKVJ5Otoqokpr4qqB2JdYvLnHtFCss6D3sI9cVV5uSugxpxIa0UxGV29VOb7xPmZywReV4PiE3UurKoUorevsaUXzBdRYz7ztY/YbxQY3j6fz5py+Im4z3nAGLJEUsLbyhglUPiSuZ56/DG408WCN0Mo7pcBluMNqWxdsVZVUi7R+g2jGdmCNLJT1UWkPAFkEsZ+j+Gt2SyYW7VMGWr85XzHoabaTcxPdcDaGSCfKOosxo6phoF6GI+8zuekiaRT83cEWBA9Fmd7ZFWib0MxO9FqDasssanp5d0JAxksak7Q5N1240giRjm+ywvAOErkW74xGmPjsZKnHKZSTjOTonJxWKUiKaFtqoRBz1kOoSvdygiTWaKKHLO4YCFMbmd87Hb4Qp2CqUYkO8CZjqfeTpkK5o8AxwRY/DucjGD1jVHVPVo6gSuqalChdMeUhjF7y6XtA7GNE1OYvXL+m4HexPNl/iiiZRUJFcLwnzmjDY8dkXa77/wz/iw+EPqIi5+PxTomDJw7symTnC7Gls2grncJ8nf/lT7n70ITtNIkg3HNoqzeBWI92JhJJIUyzZm/V43azI+zmVf4I400gaGWm/h+SI7JkG3VylvVSJjkPiF9dcXEf87XsfI/olTT3iq6vXSOri9kfaLjCnLuLIwDNHvLxMwbLwc4W8EzDHJmGwYLR/xEi2eP7lM86vVxw4EmtPgTcrDqZzrpIdH8kldw4HVFcvuVrczuS7q2uq3KHaBYxGR2j7Cvp1wfHhIbagkzRb/LdrNq+vOdg/5JOHPe6NBmT4DBWTbr/P01/+EvfBmF999hWy2KL2busi+tDAsYf0TRNLa1jHG+QmQlBDDGmDyDWm84qr7Qbn0MTsF/T3JB7Rsb26ZFN/iWZ6hJs1ajdFOtpj8bM32F9bsS3LEEtw6OQSQ4jYPv0FD+5+j1IR2Dz7BXGuUa1PmP3eIZuXv+IqXKM3FoLbx+5S6lRmEX9JJc4ZPIZ+30YSbieYYrsFa0jc5pyd+cwmd7GFGBYl5a9O6cwBayZ4ngZJxZ5eoJ4uEJ5FlP4V7p5Btevo/60fknQbcsvCUEWS8La2c7h/l/6BS8+aARXnO59dVLOJBVQ7RndlHtz7mHUiEtUZ1y+/Yjid8PJFQrdp+eFH++RcU3UCXrbFEgSePP13rKYwUVUK1UTvObimTSuL+OGKYpmQ9zoKBCRdYf/Oh6BoRJVPkvkwtPA8i7gsUC2BrMyQjBKpi1m1twn7rcGERIxphQrZNpFPtkRVxEAdQLtmMDgil22c+yabK5OB53AW+XjOkCz3WTz/S/TekIiOeeLTKlC3Ee0uudE4P1tyOBqQFgXHdzz0q2sWmkirDehZCV0fGErIRsHbzkCpwZRqTFFkf3SEfpSgM0GIdvSPLeSVSHF2O8tmZUuY76g3AcuLlEYWaZqKzGgQK4Uqv4fWGhRJRiRskYwSpUzoZIWiFbEUi6SCnqjS1CFR4CP5NUlyqzF3XTLVoxIKPMPE1Ez07QYnLOiPXRJ+89nhnY8Yjzwk1SGvVOZH+9AUtF1EUoUIqU5VArJIutndxM9FkU7o0woiVbujrSM20RrB6pAlaDyFj44O2AkCAgpDpeNN/BxJ28eZ2jSFxumrSzzjHp0qUNY1w8kUq2luNMKioWgCKkVFUAzqas12+QZBF0niiqo+Q1FrWiHA2JvgCiXZLuT8codkCRi2wCYCycpYBTtG82Ourm/343t3j+hEmW7X4h1b5H6JI+l0iwVNo1BWBlLnEi5V3uYJfU9k/aIkWgekuwpVh+PjByRZiTMf05gVeuZi2rdtqMoUfy0hCiViHdFuc6SuQy9aSrXFlnSefXqJMRoiGzaDroeV6KjpCr0/o7NU7LaPUgVkYkxRlhTK73QaCXxDTOH0yZ9y/4Pv0soZJ7sEoVHJgh0/u9jx4PAhhmuhti6RXjEwLCayybNlhqE5PHv1muvNWw6+9xBXqGjajIMDB/vq1nklT+ag57BOfOLr53gP7vB+tU9wmlIJpyTbFC9aE4c57ekJ1vgI1jW9P/gepb/hT/7ZZ/zkj36PRvPoaui1a8RhhpbcDvjDA5vTNwscoGoqfnJ3wl+0fS6qkEulY3TvMcJhh3BHJzkviL9saa2Akagz/viAI3OE9awmHbh89WSBsJtSG7dHnjtrgFi4CFLKXv8OZeizS5Y8On6fsttnsVtxHebssi2yAiod9+Y6i7RjT7cYPZ7TPHlKrVwynn4Xf3tJNYOD2SfA/wzAyy/+lDsPf4JzoOIO9xB2BZFY8ypPGcU1fcMmtBuCVcfoYE4r2DxbR5yvd+wur0jrDcaoT3DyFXMpBrngV08/ve1o/YjrzRl3egWqLpAFW2orptEETnZXrLdv+MFIRDZbhiOJLC9x6h5bX+TOfI8nryPE2ZRt6mI1HWHaYA/2qcTbpffLi2sePpihmzm57vDFsxPuFTlS5iOIOp09YhXvyP+qIs9XHOz3uRahvfoMeTTBVQ5orJplek1lqLx++Zzrry3YGqnCvT/l/ElO1WTYrshZWHH2OuRhf8wAlc/+t7/AEkccPTKQhwoD5z7tWOVNd4afPUcQ5yy7mjwr6fotQRtCvL7RKKIG07Q4cj8g2gZUss8nfZOfPT+nEwViecoiEZBWa/p6yr39PRb+Bk0ZMDw6ptu+Yr83xdCnvL54g+yH1OHJ75yP3whToImQKJBIOZgeILsu508L0qQj01XcpkVrSjxbRnVFwrUPXQG6xKKI2NUl0yRBGph0os7RyENOs5vwafAVu53GREz5VdXxY1XktWKReRuKrzLcvY5K7ojCiDwseXtyhZaVJJtDZFNEMwz85JK0DPj+SEZpS2bjMap5u9dUswWLX39O/wf3saM+5/2K8VBke71F25/gjzuqViDPQ8RhhXS/ZSyP0dKOTlrRhWsc4xhv0LFcZRS2jLrWb+I7s32G+y6hrDNREwILNlVL40cgXjBQXQJTY2JNCLfXTIYui7Ahvdrhiy76siOKUiyrjx/VvFmFqFWC6YxvNOamzkwv6NBxpxbzey6LoibyJYazKcI6pd4sUboGzapYbM7IxZS0q3np+xT5JdFujW53NFOLPdflYOby4s1vBvzq/IzVizM0R8FTWpZpzcF8RFIvWQYRuSCyTmI8vcRRDgieLjBciTzXuL7cIBQe1AVUERebGscQcMf3qYLbvnbMQ0TJo9h1KIOATm2RihhjU1DsSUzHKtuwYfj+kHw9IDNX1Ncy67jCGegU63P0wR6huObiyZJ9x0Q2vZv4nSKgqzUYNXGcoWgamzRHGjiMpzOIJQyvwcskzp4/QZn0GezXlG1IQcLsw/vYxxPO8yVNO8IajNC0ksy9PUEZ3tmjaRykaoJSKQxqmccfP6SIDC7qilnbw14uMDsblBItKzE7lT3bpJdLZOIYs5JpBUgjDc8QGCm3xvnX8Y0whUG2xDMLHMdjZ0gglwwmBm2UcfL053z8R3+LJsyQ2ZHJLs6BQHp+gWyPKMweo48nrIUzrLRDNWzi9RJNvB0o6n6DwooytvnuzGQ97DhodJaHjzn/p5/zq18/xTJ6jNoC79EeP//55xwfHtILT7i8uKZzW3I34o9++C3Kt3/BaGySvfop19Jt0p5dhQymj9AiDW1i4T8VyD6QGLh9jOk+n7cXSLXHqjzHP2upm5bvavdZdj4fqX3yWuTXV89QKoPdRUXPULGs2yXlwewRDQt6m5K0C0muTjicdKTPFnQPx7S1zavrkquJjtgYfPVsAWKHqZu4rcDzf/2v2Z+MsFuPTz/9Ods24d7sPrL58EZjrpWobsqujliKAUVuIs1UxE7h09d/wT3H4mz9BlSflwsfc2rTliE/DZZ0tsV3v/0+v3r+KZ08RO502kLmhwcH/Et+s5/NBRPlcERnyzgTDSF7w5t1Tt4U3H3/AUU3ZjKrKf0V2u4ue65HGLeM5RG6NkTOW9Y7iRaF8WSOqds8+dlLiIubNrRhjNmNidsSXkccDo4Q6yU8vsOdxx9xcvICWRvz+fM1jtYRXqvIssv7n3jMBgaJYtOgoR8e0jcXCJGCxO3Su3cIq+1T1IlDkC7xL0rsPZN+N+ennz1hnIp82+lj2jLB2SvawOU0q7HuKDho2O8dIr9nol8u6QydjZRw5+4YLb+tvby9qOipHp9dReThgruDKX/yv/+cnj1BUseUu4q93hFNtCJYxuycPlNLpCl8ErWPlcQs8h2JVGAy5koYcfDhJ79zPn4jTMFSBWZHI5JC5KuLjJ7RILUFRXYKqoTlSmzWO0xboG4SsqCgJ0vsD/dYtil1ssMyOw4GNqIq0U8zgi6+iT/UHFZJQD68ZK85RD1w8QOBrtPJ9wxifcA81km7mr6o8sd/PMEPRPLdEkcuuL/X52g0xjACvv1730GRZM4X54zbW1OYjO4Q1A0vlZLvxRq9ucTFpubBH9xjkat4Soav++xOG8KrHZ989zFFpXMcz9DbHXXtgTOg33jszOegKuxN7t7EjxSF5CRm5tbMR3c4vD8lKgK+PFmxfyzzZvGGMlPQLwo0V8H3wdE0zGRNaHaUWc7F8xdcVBVpmlBbDp49oBZv6yKWKTCemVRhx/U2oXQk+sqaSBaJdJ/GssiFgOFIYbQnU1YR+tTgx4+PqZApA5/Q3/H+4zsoqoqllUxc9ya+pneM1B5NsyNcl3hanzf1KVZnIJMT5RYDc4RcuTidycF0RKw21NcRhSQgmgPKZcfQ1snyiEou6WyNanl741BtW5YvrxjPNO4+ekSx/oLQl2hSjc2zFYvVGtmb0bM8HMFBFRfsTSdUxESCTOYnnJ6dIjsCy7Rl4PXZXN3Wp/zlipfRCtmJkXsGp89XfOdgwjKukA9N7Lri7OQSPV1ij/vonkSVb7FMC8/ruNi94jCaI3Ulbb5ge64SnJ9z4Do3Go5o0RQKTZGDNOW6aJEDj9NXpxx9OMIxLWzHoVItpHiHv4tQlBpV7ONmIhk28cUpsTHixeuvsDwdxbudJP86vhGmMPEk1LqkqhT2ZJO6VUnSC6ZjnTCsOX/xFVoG7ntTojBls1xiiiV1sEImxF8nHHx8gIqGJHbIRDjm7Y+gJa+ZKxp9ekjHHtbcwT99i1OoiI6FUQnYioVqdsi5Qq1bOKLMrlTIqpCBZyDKOScvX3J4f4ZoS1wuTrk3u70LYfZsootzJv6Y5fVbLi43SJ/c5fJEJLpjkakqB/2W+KKlVQWEuETZSPx68Qz7ZYebQ1LGxJsYx7PQ3AipvE2osmgJfB+1EJGKt5hlSNwzyMME4fIVamuhdzlv/ZJ5KqO0NWWboVsqMhKmOkMXtnRKhq3L4E4Y7x2QS8aNhiwVlFFBFcTM5g8YOX1mezrRvQ7hr1Q2p9fIjoD+QEed6JSrErHJ6Q/3EaSWkyxmbrlYZGiihC3nSNwW6bargFyt0agxKtA8kTvuPqK8Q6pDhq4EvoNTtEydCTNnzHm55niY8fb1FQgDNAkqy6bJa4QoQW5LFOdrRbRaZqzKZEFGFQSUssHlIsY7jtCcHuLOojVcxDRGs0vySsSPA7zjIzJFJYlyVDUmT0MMS8NxbZJIvQlfiDGCqCG4Gmbe0jvwuO4inA/uI7gVo1pFsXeUYYM+lgjWEYvwhEI9Rp7p9NQVWlvQtgWLuGY6cditNzjVrfF02y2bk5qeYbNpZTTV5W7fAHUfRxpTJCEnUUaVJUiCgJg3CKmG1lc5u1hhVjGbsMRfnXG5TXlgKxzPHv/O+fiNMAVdDLj61RecbETcyQPyRqGsVU7Khl7P4mkcY4gip5s1r07PWMcZWbRFTa957298DwYGJ3XM6jzFEVS8yYg2vj2XHSs14kjlZy+/4PTkM/LWxtYtXqxjevfu8Ps/+YD81GdxnbMLC2SpIEhSjo7GSIoJroNoVLjo7IoUPV3y0Xe/x0z82mBRC0SpIBiec/FFg3Toclf1kFUbKRHY7/bZPn/LrOxzrxbQzxPy5JzmjYGj3cHppazOEtxJxmEnEr1ueFPc3qQTuz6PPvgee941hpZTK4fEn7/h+KM7ZBuf7e4t+/s/YL5vo2g2I7eiLTIsZYGWbfjxvQ+Rg0vKfE2s6Fj9OVfXFcvbOzPs9RVq32caifSVCLEuOFUr0jxBuOvw9NWvqaYG+z98TOfKKNFd/MULPvj2FCyL6sDhzToiDTLSWGP0YESS/PomfhyXFHqJLocYusnyZYIfLZjpPZxyzKB/l3t7+9ipT/zVmp+ef8nbiwVfBgZn6xXjxzPCMGZPXCPrAsQ+WaggCre1ndG975Bop0S7c6q45W18QTm+izbc50//7Csu0h1yv2F0z0XJW+gU5DBl+Sf/HCmD+8MjPr5/jCk7LIUeutvj+ent9mSkDil7W6Lc5fxqiajK1D2FmAjn8YA7732fkz97gqiYvMregm+xb3+PTi8ZHPZJJI2zqwXpZoE9OqSKWx4+ekQb3x57XtYuvw4izn/2S0pV4MhwEb/zEe8P5/zTf/zP2f/oA3ZFjS53iLbNq9NTvkyItPPYAAAgAElEQVSHSJ/9HLEKyS8vuNj+5uh9/v4UJRUoNrd3av46vhGm0HYtSZjgGQNEocCUTeICPGdCTUbmGIiOjOpqbOOavBVg4CIpNYGo0Gg1YmIglSV1HhM5HeS3lfsi98lebVmeXnMe55S6zv6jHzG7rzAcHuF3O+SRRvp2iayY5HKJbHjkfkx3aNKTUrooZlVfoycGtZAxu3ePoTW40eh5Iy75nEkzJ2kX8ELkqbtmIsj05i1+8oailjje30ddD8msLfJFTnbdcPBQwqllluuAfjNlkZ1jNAbC125lSqbH3lGP90c2ZVyi6ib+OmBsOvDRAYNAx68V4hK2toNd70izmO88/JA0WiJGCaoz5+DxAW5/iqwO+bOfXhHKt7cBzULhzXKNO3lAUdWM6oyoLek6hdaFWO2QDRh8NKHIE4xDkJwpu2yFLHZUjUyFQaeLnJztUJWGce92WSxpHbZc4jQNUp1hAq59iGtUaKVJt4Fhd4ik9dj5HcW2xrOHpGenqO2AY8tjW8XE1ZaOFtvQqYoEsbp9g/Lw8WPK1OQ6WLFeZ7S7ksv4S7bXK+qwRSgK5H6B3MyQpxM2bz5jujfDFTPKMkJW7hGLHX2rpb1MadKWUp7cxBfiFqkSaNUCR5axJi67KkV1dCb9EW/LU7QPhxgji2BxhdAIdGFHGm24ulpjTCxeL0NkWaQtIEkKklojL2+NJ0ckVQ3SakkliJxWPv/nPzvjA1Pjbdqx2ESMHn/MulOQdyVffvWK5NUrZkVKWQfYSotiuUhGgaybqLMx48Nb4/zr+EaYgpHUtCOL2hwQ0WObtry6jJkfj5BNk9PdDtPQENBJhjMyLeBouM96s6NRVLI8R2xEVMljtA/r7a94f2LexJ+PXbI2ZiKOsIIxzmzO21WJ9YPvMp1NUMOQeBugTIYEZYx63aEfVXgfSLz85Zd8Gmx5/70ZIxoso6AvWQjLJ2zz0Y3G1ZmPN7qLZnWMjU8QswjH1alsuHyTMx/1qbwR/mcpXq6y+OUphhTyd+79+xTrHVetiDQpeBYseNwY2HObfnO7pAz0nDZr0QwPP1qw217x8eEE1dORbZGjD/oEVyA7OmYf/DO4e/T7rHav2d8fUst3uVqd0ctyxn2ZEI1cTqi/9jjh0l8j279PllncP/4+oVGSFDlV2aGUJdLIQTDhF2lAVxRMuwZ9qtNXxmSlTM4Oxxojpx0H7ms2ywvm/dv9fhS+oZZdDr9lMvYGSErF+uwK9/geM1Wn1VWWC4NyA21wQG6NOA+WfO/79/j8lc/VFxdYnsG4X7GJt9DfQ1cSprPZjcbnz77iQ7nCLiwutqdYQs2+oJBGl1y93tLpHovLa+bjObvPXvLmy0tWl2/4D/7wR0z6xyTxJeky5PJ5w+GPvkexacmj21m8ljukApafPycpJa7MjEfffY/EB+OwR3Z1TTGtWStX8J6NmIqUhcDmZUETNYxVm299OOblL16jtiaaWKH5AfHuVmM4tXkQBFzMEwxtQJuX1KcBr9KKLxcbPiu3VJ9+iZALaD2XNvTRVQ/lUEBpW9yxSjU26YkKjVmiTw95+N2f/M75+I0whTRakpsRdamQtRppK1K1AoXYMOz3Kc0ax7UxJx6mKbNcS4iaSCHkSAoYqsji9BrR6VPnGm0YEbW3zivVDZerCtKGZbRgl4jsOgGtSaiyCEkr2W1O8JsEVUwJuo5OtAiTiPEHU7KdRV6kbKkp8x66JKApHtrB7SyI6OPkDZUgQJaSlQJ6MybKdmhBjWnNWC+uGB/MSKsA+SuNayWgZ5/yl08rpuMZdTmj5tdE+hG52+FGt4+6NlHLX+3W/Ed//0dMJy6b5Rnp+pImEblMT9iTBLa1Qn8wx79qyFT4xYsvSXfPyfpTrN6M680pljXg7ck1Z1XE2apGmtzOsnWSo+k1Qb7Er7dEcUssFGR6gyYp9AcO0qDBElSyfovgjBGiEk12EEWBXXpNVeS4ksN1lqAVESS3VfVi06B7CVeXKVkUQppgahp1GBHaArNen3i3oslNrpY7/HRD3qW0aovUVeiDOU0SolYVA1XHKI8xVYHqtqs5izv2bQu5N2eqF8SLAEmbsn3xhsqzSC4WuEePeHN+yer6jCQSkCuB+jRGm6uk1wpVIRLUOeHFkqpqyZrbbSJyR9JUjLweViWQGharYIfTn+AHPkF4zayoiboMe75PljfMXRWh65ju91HFliqMGVs2sqJwuVwyms7pmbcTgOzUNF7CB4/v4rYmgpITj4aUwY462tAKHeLERMkK7h/PiGORzdU5k4P30LWWRtOQejpjV6U2JayRhaDe1o7+Or4RpjCd7tGMDWLdxDYs1m+vGU4hBfIoRFMGCIqG2thoZc5ANUh3CuO2Rx4XuLrFUF+z19cY2jJGrNLVt/fhg+UGo5ExdJWPRg47RcSaeMg7nzNpTbYsWT/5Am92lyqr6e9bXK/WdGIfw694dG+GqhZ0gc/Zi8/wO4P/9A//iDa5PeGwB3NG1+dcs8V/PeXOx3scu/sktc3kjsXpMmRxckF97WMM9okVGLnfotw4/OG05VJco+7P2S5mKEIPW3Dx+sOb+F/FW7z3jvgXP3vJ0G2RBYPTzQpD3yNpdU6XCRelwuY6o4lCjnsu6/CU7SIi2vn0zIAy3fJVK9F/dIfM6LPpTmmvbjMqblryzQLzcJ/hUGW3WPDseslVVJI3EYczm0GnU21VymjB27rCM1yS9AuKVMC0XRTXRNFU5luDutNBuH1MJPbWNHJLfzQF2cDSLQ735hRlReqJbM2GYr1jLA/xjVfQtghOiWTa/I3v3yfPrkk8lfU6pRFzztdrLMvHkm6PbqMy5dqFvaSHaf4Io+5z5V8xffAxAzbcu/sRzczk9asLHuwNEYWCRIZoveHJP/kL4ixFVXPeu/cD7Pe/xfPrlGZ9fRPfEoa4hcC+O2Rv5vAnL5+w8kMGI4X1+pKRPcRzKygTmtVTTL3H7gXIUgdaiaAp6KXE9qpBDTN6XUV69hbB+No2q7PoH/TQehoBNcGVhPyeQB5a/OgHfx8VnbNIxFBg1J/zQ/UBrZxwPFHpSyZF05KlGZZnkY9seorKedtw+5Lm38w3whQO9o7IBlNUxeXVLsfVFJpGRtRMqqIAoSNYhmhyn2SdIBsyZRRjdQpK3aLUEu7QpWlygl3FnfmYzL89aqvWV6iWihR3XHVbZsOPGYgdsWZCmvDpl1fEqUy3aygCULOAvF4TVzVvm4ofBBM0pcUz+1znHY1c8vTVl2QXt+8Geh3M3ruDlDjIhymVVLO63CApMn4k4VcpB9r7aPaaVnepJZs2VxjscvTDu1h+iLZqKJoxd46mxNuI+49uL808f36B2nQcRCs+uHuH3txiK5goTQyhQCsNyDOf1hcxLYPPfvkzBAFaTaU1HN5+8YSu0RnOG8r4IS83IdtEpFBuh4AnDpCn+yjWmLIUULwRRpzT+QtsUYMSTp4tqBOTIgvwrI5g1VGmJf2jAzxzSDyqaS+3CLWK7nn42fImvmzJJNmG/flDrq4LqqrG355R7raMhH1qYoy+RVQmJFKNpOYYmo4zHrKI1wg0tE1OWARohobZ14kKBde4bcPrXclh4uJpJcfGgDNN50TMf3MSI6ccHI6x9BHlo5zz1RnafM5YL2h7Mu2i4mju0TmPyPf3aLYyWRqQJrez+IPeCCVTePHlNRPL5Xh2wLDpaDuBvthiWTJlnlImGRN3SJEVFPIUhQSqgjaTodIoGxldEemJg988Vy+/dq/mzgHe0qHWV/RaGToQJQlcDcuyqTqJ2V0PU5UwEVFNGa9v8slkQJnE7FYpriux8DfImYg+cejkf8euOVe5ShiJLJqAoNBJcomiAVOXUWSVWu4T+SFZLRFmArqkU5YlPVHBMjrKLKMnGJhiR11XOOM+NLemEGc+VSxSLFsKRyGVLxA1D8NWOFvvUNqGfO3jv+24Nx2w3C3ImzUaBh+PXNRqg978piObWKd2C57+4jP2rNu6xeT9j3G219DKJN0WPykQVluk0iE7jOnOOzB2XIkFHwgG6wsP+hXxekhgZCTrhnSwxtZ1DFlFd0Tc4Hb2WPsVr9+cE9874nwHrVYS6yqK6tLmObswwB271FKM1rRUqoDgyHiNRB2nFKbFUd9j1wj4vs9FaLDLRPyrrz1tDiVqpaL0VxReSpt6DOQ+9bhCNizSNCDPKuTKIysz1MGEcLPj0dEdWkMjrGL2RnN2Bah5D0dzEbvbtxWWLmF6Dik11lhEa21yf01Uy8gX59xV77IuQtqVT5oXmFZDXVRsWaJYHdFuzb7ZR+3VkIFiCZiGSqHfarSdSKn3kSwILbi8aJD6UwQjQbUd+vMD5vtHbF5veDB/wOZZzvG9b6FXMVd5RdjTMBTIrq8pOoss0Yiz25Osy3VAXVbs1iFL2/9NUbqvsEpyRNVmG3U4qUyVCbSSzMXJFYrV4og2kqTTZDJF2SGIIxJChm2J2rTUX7txaJtTvFGPLmjRTY1xPyNsNWaNSEqF7YxZVBJK2TC/00eKI7SuISoSSlUmli/RhR6KXrLMtmg7k+Jqze/dv/2XrX8T3whTUASLfHmOo9rorYZelzSyhFGW9N0+UbjF8hSE9Qo5ChjRMRBTVF3DtWQaapTNgjKLqbOAN/KQ6ddmwPrNC0qrz0SucJXHrE42KJ2FGgZM0o58W8G1zsH9faIu5lhTqb0DhEwkWwUMRIlMOGcki+T1GcbJlvd++DFefXvC8f+x9ybBtmZXftfv6/vTd7d9993XZeZ72SjVZKmqpFLZJVOOqgIDYZsIBxM8hDHMiGDAgGDCjGBAmIAJYLABl6GMXa4qqSSVpMxUdi9f/25/T998ff99DKTI85ggTQjShNb4xN5nn7PXf6/1X921f0GrdY92cskKm7JyCOwETYeFC7ErEs9Tik1B+PqKy/MVbzh9Uj1Bmg7QFIm+bWPrTdq2TJR3WYhbku7ue+8xsCUmdcmy9Pjo5RnCak4ZPkeXh3h5gpUeYyk6YX5NlckYhsaLswW6aWH23+SZ6CCVCdVCYeFHhPIxsbrlLYxax89DGoKBd3oN2hRVgYGlU6oqq7MNXU1D1QSavsEb3RYbVcatBJzcJ5241NmUYrbBDSaoRcnBK9EHTYsQLJnRTo80TVmPVwiDBjceDGnlIaJVkJyGhGpBeatJakpEq4QdSSaTQnpHJomY0xgNkDWR5SSlahaU5dZFWStwFdZsyg0sJhiRR9bwMbpDpqsl0SrlSXpGWJuEiUbeLvl4NaOByqN6jnmaoDorRs4xi6cPKdglb27B3xF0DEPhwc2bGEoTQQyJYw8lDRDymEJSENout4dN5s8e8eagxdnpGb3ekLayQypUaKVMqk2I1hG7t3u0d0eUccx/+Ys9olwFo0YOip9XYQ5t0iqnQkcufKzekOm1z7pISKUKrcowq5zKTDHSjInk4m/GiLqG7HbYPPmcs2UC/9q3fyV9/FKAAo2COk5p6CKDyANFovZDvHwJaxPdapOWJYpco62XKPkcw9KgFKjWBYXv01ag3VQoQhOlTojyrUIpez0ir2YTa2i2gFYJGDmk+RrCHewqoNodoqo1e0oDWfFBNDD2VFpik25Pg7RkOd2w3+tRGjKpt8C1tntsnmUwTFhJO5TJlJWyQosqykhhX27xvLpAdNvMxmNaRoypd6lXEmmjS1eWqAWLCInDtUw5UbEIqeItIy3kMm5cMq5ijE1EqUhovksS6dRaRryKGPZyVFQaVhPBVLDkmnWnSa05jDe/KAOWNK5VhY2rIDkNsldqRAJWRAuZZiclc0+Reh3IVOoiJsgLDDlCq0QMf4IXLfGmFXn688rT5UXJYnrNLiYdR6ZebKDWcItX2ow5XXwBFouEOM9ZhgW20UBTDMpNhFarVKJEWmVIUkWxKXH9gGAV0G4qRF0BWRCZ+CGO7bDZRPQlDVHcmvdelZG1FkSbJdXyBDlYUYsqejrjgyendEwXe7/D0VBjLUUM2yWXXskjNyafL1kIGlUGl5NTxJ19TDz07rZBybJeEvk1su4Tpzn9my1mG42hEBHqEpUCewMNqYpo2Dqh6zMYtHGaKmUaUxU1Xl6gSxV1o6CiIAwvkcwt4ZsJPqam0B5pOK0KQ4XAnSGpOskiQHVgMl2QiCJFnTHs7GC2YfJigejN8OOCUtX4ud9hEksS63Kb8/LLRKjr+lf+8P9bIgjC//df4tfya/n/udR1/SsRC7+e+/Br+bX8Wv5v8qVwH/6X/32KNHnJhyce7XVOeGQzn4V05mcUmsInVx7H3RbFjTYNr6YjC3zw7IeslwLt127ScWw+XY14sP+CvenXuP2mzP5rI977Gz8Pwvz7/9kPiOKAvEqp05xSXDEOoVsleFJJQ5Kow5LUqKiLin6vi1dliGuNmoQiz9jUAVYuoLYM2p0GNwavM9jd5z/4w5/PA/jP/6sf8uTzU0oxgawgDAMapkrgThHrjFG3z9zz2N0dUpcp/f6Ii3OPuIwpUKkRScMctakRrzzEXMHY2eEf/Bd/F4Drx3/M7GJBmCaURoi4sBg9OObi8oQ41THTglVSolkyquizcAUCN6a9u0Mt56RuhlZW6JKCKueIUsJee8TOfpf2/d8H4D/6r/8TgmmO0dTZaxq4tchk5pJmKWDRs2QWqxnZJmAdxjgdnYZdEWegKRWq1WBv5whBK5iMx6h6ytBo8R/+vf8UgG8/+PvcuNkgSQXah28hlgKr5Qlzd4IYRayEDMKExgCSVUGj6rDeq2GiMrhhc8/Z49SbE8ynaLqIiUJ8sULsw//6o/8ZgP/t+/+A2WrOxaMxdlthcTFj1HyXhT9hVWg0Wj3quOSHf/WniLaE3d4nS2IqP8GSNRrDEQ/eatJvN3n2wRS1lfHVb97kb/3OvwfAX/3xkmDzFLFM0GWLVbxAkhS86RW642C0Da5nPlVa07ZFNLXJNLhCFHUGWoNpFKMnOZ6kI9UbytDAUEf07zX4/b/zVQD++J+scMMxvicTV1BbJuX1S9wwYbGYk6QbXtsf0Os2WLoVszQhXM/Y6+2j6jZzd0VSyugStNs5VW7we3/z67+yPn4pQEGKVnz0V+B2/oIXfJPmcsqOoHBp9pFcmaJa4PZl3lqYpMMWl9mC2rzDO/vHbNoz5NmM27sN4vCI+sjlRw+nfCd9pWtRfIXi+xRVjU5OYdSI7oK4qqlFn7JpYzWhjiEpI4QioKPoTOuUvEgpCxFdr1gCh90dSlMmkEMkf1s44C2nqFKBoOmEhUfPkVDqDZJTEvkhQiWi1C7+xQqnIRDbOU5TRo1z6jpE0rqsK59ShE7TJC0MtOaWpAuChPPJGVezkv5ug6DyCF4EfHIW0DQUUNYEm4pubrKWIvLKJrNMgouCUiqQ9A19s0OtmFwunzEQAUlHD7fprxvPQzY7xO4GwdZA0Gi2RYKsS02bOncxm1001aZKI3a6BgoqkZ5h1jmS0aAWDYL5z3+XxTgjqV+JbjgK3rrCcmxsz+P0xZxzcUYWVeSiRqst0pfaNBttHm5OqBOQ5hJnZxcUygMMISDrRRiKRZ6LLOIZeqowG2+jA48fnRE3RMaFz4FvASKnp885PLjNJ88ueN3apWnk7Iy6nF16BJqPoQnsNQcUiJTLU4LlW0hxhSjISHXG8nobVr2cP8JbrWhZMrpjETUciqIgbgqUYoQYrzlbb+gpHSKWaHWPXDdxqoq0U1PWNYmdMZ/FRO41WmtARxAoNluy9KMPfkxSx7ixRZpFICisrufQkomDNXkS0Ry0uHp5wWadkJkS3sQjknTqYoquaCS5yDJYk7olYVZw+qTHb7y7zcD9f5IvBSgE6yZJ/5zM/Rotu+SWeZfn7oalPKZ9x+P4+TEbV2V+o4dt2MipjnLksJQ9jkoLsfkGmZjSk5tYrx1y/vAnPN9sM7gcpSZSciShRJUTFKAqPQQjwQ1dpDBAEkyaqkBHUMnnM+RBg2IdoVgVUqFRJjJDU2dPq5kvAmZXT0mPtok/1+NrEkrUtCYIQ2q1QtF9ijLDMUSMRo6jd1lcP6JKa8SlhCbJeMs1jf4hYbRh5U3J/SXtdp+0SKjT7RlmizXP1nPEUibSbiCuMl6YASvTIo8zagSSZY2g5rxY5WSGjFnJTCUfeRnT6Du4pcuxpiIqBrVmohYi+Tbvh5FlE2QamQD+aozktLBllUIR0LSMZOLRdNrsdh3SvMIvXIpMRckj6qrA1KAtaSR1QLGIMGQRU9xGaFSGiEGMIDe4DFwabQf9XKH05nSGGma1j3SzpNlucUfYBy3FnMVc72u0Ahnzaxl1MKDbVcn0kMXnKY09AzHY5nN8cn6O0bEZez79xpB5HRJGAcpqzuXJZ0ynT7kxHDGeXxCkCevnM1buHOXG19jbAdF0iMKc3NtQpVOyUOH6LPpi/fn8gmRxDaM9DEfiZJEilSn5xqU7EvGzBMWMKOyUoA6os5je6DZhmFFqPoE5JpzVbNYulDXKYkMxEFDSbYTjsxefkVQikn4bpRLw5JDLMkPfFIxUk8Kx2IQ1yzDHbMqERZtVnSCmNbpYsb66QJZaOLbBRTQnnLnkryRg/TL5UoBCNTsnPJnwcv6C+7f/iA+NDftlxPX8hKeLDtko4huqzKqzi1TN+Pz5c7JQof3WbcKLj6i0NYPIpJBCuPgZqt7huto28yQ7x1YKtJZIV+xiDWw6PYMCgaU7ZqfbJw9+Xt0XGxnpBpbPXGIhxCxg//AA3bSpk5i6vqAjaqw1A6PcgkI8O6N2VGaJj2G0KDSTyrbI1hFhsuDejRss5A3WnklaSoSNGE0yaDf2kXWJOs64tXebJPSIgoQgCcmCrbUjaCLD3jtcu2vOrl1WxIQvllxO1jQshdgLOGo0CYIW8fUEzHOmZYvmaIBuRtR+SlyZTA4DXp4kNK2SNw5N6lf6QOZiwk67R5SpqOHP24cvPJAbGoo9JFp7WLVOuclRRRk5C7H1GG9asPIDxsGGRvMZe3s2G/eSTFMRRtvLfvRgiDKPkSkRYgmtKTLaP2a9eocXH73Pb4sqTaVDFTq4ukcRSRy0In53YDFbBAyKioWsoKcJZu8eJ62Cjq+hjCT47Od7bE4j0syi49zlhx/MMKqCelPxZHnFbz64y7PzCz768KdInQZN1aaMFwycXW6OWuhdm599POWnP/spX3/vPXIPalyK3vYVP798xKCj8/D550QvVK6oEASdZrtC9UAWYjpajKfYKGVM77jBdLrktaM+aZqgVn2yOmFxNSbNatpqzsaF5Xjb860OUnJD5WL1EqfZoVRbxGrBqbfmzKvZHQ6gNgn1JqmkEE1PUTUBoQgxdI2w1kjTOetMQko1aCp8/PKMf/dX1McvBSh8VI5pGF2++d0jUn9OJ8xw7wX8ZJGwE+l0OyYPz22+1vVBPODOm3OWH76gfH/DmXhF+/7X0JZj6kokW1TY2ZDqlclEQR3hrdc0EoP2SEVGpK13EFQDQSgxNYGrM5lMU4nGKyqtiXooIZ2HVLJEllbYeopq6EhpSaClWFGEv9q+gk5HQLMMJC9HcSzCGISsRnRkBFlmLZUEaY7dbZAlBefrCbbeQak9oklAZbYRE1CtAkmRkJQUia1pP3ELhI5DVRqIwoZWsGHmhxRlQJA4rOOMgQlxfE5YepDVtPUGlZyySRJkQ8fWZLB0yigh1wXSTKHsba+AIyjIVU2n1yRxA6SFxpHTJRd1fC+nK9gctNs8f7KkqUg0BQ1JlLD8AKl0aPYMynxByxoi9lxKIeR6Mv5i/cVjkaPBirbqsCrX6MabtBYiS21KS+rSfqPL3oN3qTZXaCsF+Y0OXurw/Pv/J8Ww5lqRkK2Kd8Rdnl58yl5VkjgDzMH2JVcKhW5jj/lkiRYLSHHO/tBCK0VGvV0MBBL/HLXdYH26xLEb3Bl0udVxcOcCt9t9rkyFuKxxypisDEDYVpIW1QpX7kPHpAh88jBB0xPSGrxlQX/UYmPmyD2f6OUEd22gihKPXjyliiJ0o8FqmZGSkyQh41qgX4Ghb/9ro19j621SFwzbRFJDFqQ01SaqbpELOoFRU8YFmmqgdgcIQYI39QhbOaWQYRolTVFBbJaQKujl9jf6ZfKlAIXs41Oym7eZBleY0zn72ogff5IwsG+g+HOefuDSQiFqXXLRb+D9T2dk+2PqRofN5ADz5Z/g6ClRccatWZOXG4Ph1TbGX6UBh+0OpmTQGZoomkG09lCFgMUyJq97dHZrPv7ZNXJW0u/06Bkp9+7fR2q2sOSQwXBIKYhEbkxZ1QQrlzLfRniC9Yp2o6K2YsK6QtdlNlpEWcb0nF3OVZW1JtLRwUtiZGeIZpm0LI1oWtPUDUQ5pwgE/HRBW5YZdLal05+9vODk2iXUa+p0QVlDGgsUgovfOGI1XvG91Usqb8k0i9jZ66EPQtqXTZq9Jl6cIUkK+8sa2WwwY0l1ek3kbuPjsZ6QzsbYNUTXC7QwJll5tK0OsmGRrS7QEoW7YYuFt2S9XlBXEY1IY9QwCOoxSUshmgSslx7d+/uo3jaHoHHDIm1/g3/6j/8HrEaPPdHASx+jlW9x826L57HH2Z9/yO7BkDgK+fBPCx7cD9D795gHJzy7mnB/ZLHai+iWDZ7HK2rJJ4+27sMdR0c6H9MVBZ5Pcjo7TepNjXBk89J7wdHNfb7Z+TcRowuikcPlxZps5lHo1zxodPj2O1/hz88e8v73f0hrMMDQTbJy68Y9PH1M8uyc3YMhuQKKZhCrGbEj0DGbzPOCUM4w3BSnN8T1E2wxIRNdFtma9fNHKM4u6TLGsnsUk3PCToFdblUxixQKKUGQ1wTJiiI0qFEIGga2aiHIIX1/TUezcKOKKF2hijrKrknguhwfN1E1g2Dm444DdKOJ+koC1i+TLwUojLr3+GTpcmRLXCUCD1nSEk1qM2U8C7kMFwT2lFPFZL7+kKYVUGa3mFS9XjsAACAASURBVAURR90TppHMceeA5YvnzOUUSW0g3N/2OqgqHwqHXJKp8oii7mBbOkWhcvN2kyoswFfpiQ61IaPVNZtMZtjV6NkaqmqxGMeoooBuRpzPVhiag2ZsL4siFgx7fURT4v2HFyRSjtK08L2YhVigBRKxbpKkKZKuIXo1dr9FkZbs7hzitJpcPT2j4ejUYYajGTTNLejUhURUheSlRaPVgTphJYjkpUpXbuF2lpw9r7BKA68KsWINfeYw1mPmfsLBsU0nN/FSH7/Vxsx1Lq/PaRhbF6j0YhbjDWEBViVx8XxKI1DIszGNVodOU6M+WVOJKT1RAqHEqHXqMsHKSpZhgnrYwent8nJ1TTavUNQt6DiqgLwsODSaiE4Gqsyu+RotQ8GtZRxnH+/JGXXeoao9hMaAbG2z8Df4mUzj4HUeqx7q8ye4Ws4lGTuNEa2bh1/sYTZbzE/nFJKFiMD4wqczgGOxzbqs0auMvMio4xVds8Nvfec1lmeXjHr36GYzZCHna51jlt0pLdsG26F6xY2rRBAzCT8HzJqPLi4wDRlJdyhKm43vMV247LYbXG9mSKqCLEREqxnhMqPXsuhmCUEADRsys6SqIi5f6dEo1QKSpNLpj5icbfDEEqndpSWZJEmF4GeUuzpWx+H0ZE4sKlhVTTm7RDFrstpETCtkoWTnsI2qa6SvlOH/MvlSgML7wfc5Hu2hixbPNi/oqRm+uGZhD5GOIvqrjN8UOhyoM5qDFNHfJVue0rkrcL13F01r89hTsIwminJJd6PT/um2SvJeZ0ieQuBf8fKxjSn93KwSBIVckvHjjEgVOfdXWKMu7baD5vrglzg3W5iOgyJeshyvWOc5aVlgCiJCtnUf7u+3sSSdeZnS7aiYtojSsnlZeAhygtyWKLwFuWAjmi0s28R1YxxbQXDnTPzHNEudVqJhCCWUEbq8zaQL/Rn9OyNCySKZeERZxlGzzWw9R66nHIv77Bwa7L6+y9PNAjkViFc1w77C9BSiywSz7dFUC3bsmKTTYN/okFbbV3bnxg0iL6coAvZaJqoscPKPfkwXieB0SufubUo5xhQ7aLaBKVmkF5e0X9+h1AWOpR5PRI1INOnevUuYpHSdbQRl9kTBtM+4dSgwcSNy+THzss33nnzGd37/b3P5VEMZ/usE/RTlWucrrw9YiyG54KMLD3DuzlGWKo9f/hnhZ89ZObDGJ32+Vdqf/diDpEA3M/7g93+Xa2+FJOTIdcR373yH5l5IVsz5wb8s2e9J6OKKb713i73WHidnDeZjk2efTzlovIlNiBcW/MVnn3+xfrR26TT6nF6NubqO6Vld7GaLy8cr5vWc1s4Ncj/iZ59fcOPwkCAG2X3Bjj4gfrrgaXRNW604bo7I43OM0QBLsXg5244kmF2O2WtVPFu0qISKJF0SbQIypUbHYWTqdPeGZPmaO3cMLj6fM5mccHA4AN0hlBXiMGAgQ7i4pDtqkb8yMOeXyZcCFO7Ub5I0PyBs7nBw/A6595RBY4BoLikP+rSCM/wbJVfOD+iUNeJRH/O1P2Dn7TvEP/oTxIOvcu91l2dhg4Goc8VHxI2tuXQ1nzPsdBk2ZJ66c1apSxWKdOwRzdt76KVPnYloew9IhRDJOURunjF0VKI4J/XPCWYzptcX1HVGlJTs326ySbdpzmFcUkYeERW1u6CsbOxOjSp69K0Osyqgqam4QUIVT2k6FkG4pCgkWkoHIYaomFHFLnrmIEgCtf9KOE+VERJQSBEbAfVaQNc8JCEhD1SixZQCiXQacmjp+IsrOp0m7ahAbC/p7t9koKhYjoReNUlIyAoRpbl9yausQLdylNohFKGyLRK5xo9yijJHDCJy1SDXY8aTiP6ORmRnKInL/GrDytRp/fZ7oAmM7C4rd0odby0RyzTpKQ6OmnOWFHiZSCys+MOvvEe4N2D+7CMGlomcNAiGFX50QX5xycpYsnvrgN/sOXz08CnLk3MEZU6/cJB3KpoHAvyi69uzqzktRaMTxRx3b9GUClarAHO3i93QsfSapHQ4oaKIM47at7iqDaxEI9EyxqlIUUiUC5cTfwWOQLzZKuw6LwjjcxaBgiRKGI5KEVe4J5ccdFoY2hqvKKiXOs+rU5TKwPFE0mbMTnOPa+0EWzBxpYywiGivNoSdkPKVEnNjr0WJSsuSAJumlbLQSpTaoih9ssIncyuMco5aZhzvCmTrJe3hLjUWLaukrjKapJiVRyjomK/2hPgl8qUAhZfqgvxc5+37cOv5mPe1nIV0wX7rXWLtU/7qRYgZWvwNryYwz9CMHSLpn/EsP2GzHxC3fsC905CQBnbdpbv3GzTubDOnsyxG0n3yWiAdJySLMZHaQxAsGrpBU3fI/Yqqv2ZxWaPpCqrewWg1EUlx3QWhN4fMx1Yi1Eqm9K+Irl6pxAwz8vUcTxdYTeeopY/iDrBFkSQO8fISw27QcxyQCtpiykLJCa897L0WgmJQpz7UBWJzD6GAvNyeQXQ0fFKC2RWm1aYp1qy8Ci02MNWIeSYQzxfItcfNOztkik7f6TFePqcrGDS6OyiTDcPdEkHoshhPkId99PZ2crap2rT3KspERjYEdFGieXQT7/kcu1GQKzJVo6bIJVaVjygUSLrCZVgzm6wIjJr9zi6SUJOrFXa3if9823NCa8F1XHKxmpOrG7yzDjffuc1GXNMJHtIVprz/vc8I7Fvc+bpDJhQYwobf+cpt5Foi3lygpwsEseD2zR30ch/t7e/Sbm87BQhmji3rjLoDzmdXaA2Hm0dNtL5N0k2pd9o0nD43wjVQI8g3KEuRtdHEm2YkEZhKk/qgyYd/OacKA84mr/RrKMFUBAw9otbaaKJAudrwYL/PYlVQn18RWyNev3XE5+M5uRgyuDMiOLsgVUDTR5Sli+7oFKHEKlkQLnv46StEoOggiiF3dw5Z+C4X5zG3b47Q5QGb9RV5lrO5fImspGRCQmvYo+kM8PwxzaHM4uQa0wjpNbt0Ggd4mYTZvfEr6+OXAhR2RikPjt4gXTwkuZdi/mzKYCdleG+FfpLxtd83efy0QhcTGjvfQNr4KLbFYBZy82vv8tNPAsT7e/xW+Jhwo1H9eIPrb0m6TiWzI7To7TdYXDylfOMuHz57DL7OnqBw++AB7w17DB/OuDxc8K1vv4MtlpBfUC5XXCQZF+4TIn9NVYeIWs2tqo38ygSn882aBzu7dKoSzW7StAyuL84JYoFeu0kycYnkFXKpEkUb6l0VRVKx5JJkPqFWJA6tJgf7fU4fX2OVPRRlq1B7d7+BqKQItzOEVcjl86foUUBe5gQLePfeLT4pp1htg+ja5mD/LiEFSjXFGpq8kddIdw1a1g1ezCdInZrH45BmvDXvu7XA1WqOYTcJhRauUBHudVC6JmcPX+KMNqR5Rv++xo7c4vn1Kfl6A6MOq9csXnvzdepugR+XXM027HcNOvf3v1j/Oo9I3AkPNiqP9SXazhOkTofCKfnv/5t/SFQrPBi2qdwLRsIhh2aFfafk/UefkCQqej5jUrocyyGSLxMIn2Jrv83s8pUW7GfnUI6Q2yEXr93i5ccX/O0/+gYHX73JX159H1UeYY0sVm81qdYukpnw9tFdoicp7jTmejPDNna4CEoGd+4QFhk7s49Y/CKYNXpwj8PR6/STFXYN5WZFWDhsxAG3mjqy1efPP3gCA4dhXGF0b9IqSlQTmm2Lb71zG6Hw0dotTq+uObu45mR6TZLufXGGb371HiYBeeQxUGLaDhiGi1r5HHxlj9jNmawFtHRFzxkiWzqys886cbmx12Mz9bh7/zWKzGV1kkNDIo5+9fKiLwUoXHt7vP1kzHIO9etw3LjEVt7AWaUs976Fd/Ev0bsps0ud7udXzHWQZJmhpRMsP6VbT9Ci36aZLJjOa/qNktN4SzRKUUIWT/GymlDYIGYWO3dbOKJFlopMwgWDqkVrIDJdiKSmQjG+ZnDQR2/tceVBqQl0Ww5xHtI2ZdI64PR8a97n/pKd5m0qWSMrc0xLw8sELFvE1mWOd0zCpCDzQvYO+jSkFLFOoUiwrTaSkuGUEqoHO86IJNcw9S2RmesOLCuEpKLbsrl93COcSwSpyvRUoJUO+dq9QyIKorrght0isjPkJ206uYG7mbIrjliE11xcnLEJYlTzNpm4JbiatoOmLfFLj7JsMg4KRqMGF8+mhMqGgB6J6KOtzliYCmFRESkxSVWh9XWc3oilIuIGIYGXMK3WmDtbzsJdXmELOeVoxZ1NyTSV0b0rKiniLmNCf8BBKyQxzqnnc5pJjTmsuNm9hZ9M+fTTCZuZy/03DcJ8SZsbqOsF46ut6f2db32HemPjumck8Rpdq/n8esXZ935Eek9n7L+guTSI/Q3f//O/4PBWRJCv6J0XNEuJTSqQqhJX1xOkIqJWMpqHwy/ck4Hq0CgC7rZeo9kG1XeJI4m1qlLVItNI5Ldev4Uv2bz5jQMsu0sUPWKnr3Gr20DSVbotCS8Z0JVmhP2b5EaT5WKblTm98Glacxp+Rp6OOdBqvNRm6S3Y23uXs+AEIgWvSNGkCEeX6Roye06P2SKmaZgUtYSqOkR8AvU+4ivzNn+ZfClA4ap8yvu8wBoq/OE7NzhZP+DFMuHZ+ZqbfYk//fSCjZTzjTcqxmuFA3fNzJRQ3Sckt46JWu8RPn+IZ+Rg3aJ/w2L3pMc//MX6gXfOfHlEpMfsHhyA0qRaXdFXfCxzhSHAbFaT5CWjOxU/ffIx+XRN50pFl3IWl08R84DdoYNd6GhSwvT8klTYts2eXc3YvFyw21exez9Pmf2Ks48/v2a1OuGuYxMEEXpDZtSSma5LjhptgjjCFw3kVOTf+O679EyJf/rDFYbY5nJ2+sX6n/zFEll+wVCvMROH+86QsSyTfXDJH339KwgthVvf/Fs8f7JCjwXkLOAsWHHzOOdkM8bOetRRwWriUa9c2u0+zyMDQ96OjbvaPCJYe+hWGzUOGFnwSR6ifrWLos348cPvs7fXQ2zDoLPDxy9+CJWJ2DERG/s8ySekTyqEVKBr1iiVj/timyJcBiEH/SOab9V88ug5h+2U809f0h7t0Lr9BmyuaPMCxyiZf/g9xP1Dlsoh52OZ147f5Xd+Y8RnpxMupZxOR0fw1jx/9jlPT7bzMUSroNHIqMcDnj59xjqYc2qvsUoFpbGDvbvg5QsBvwjp3TnkIrlGuq64HclMJjKzfpc72ZIbt0r2nTZ5o0SSv8ZffvonAKRjmHhj9o8K9ssdvvrWG2zSnPVmSlk7xKLD6u27PH4x5dbRXdRwQx7f4nZLQbZr3DJgp9yjsl36gxFy1CSvJxivdIw+efiQjuoyOmygqiFIKZNP1nRHLTh7jHBxTa3YDJu7KOsNL5chmrHhtdtvYDsS7viE8IWLbaiUYhtZ7/P0ZMuL/DL5UoCC/cIhbr7E3Sn54blF2zW5XF9RyDt8tF7hTnxMu0Xx9JLjUZdUbdMwu1z5MZt/vGFslxzXP6LBt9ktLtnvfJ2r1rYuQUpTSiFGTSPSuk0Vh+g0KWuV6PSU8fKULJRo9O9QOQbXyyeI84pFHmIOTIRFjFuV3LRGWKuYVXqOZUsw3hKNcemjCzZCIaLIKlpVY2ttWk0BR5KwBjr1aIciSTnaPUSWpyiySFM0qZOUfsfCTGuSrKBKJSopJXmlfqNo5tSrDMNa0nd0drtNRMlAik2+ebzL+09OiWcy+5qEtym4u38Hazlh5p1wo+1g37dJ5iGV7nAxTpGXLteXY7TXtqBALKIpKZG/RilkhIGJIzR4+fSEstvEk2V0pULXBETPRz3apVolyPuHeF6KmIa0OiLqYo0fxIh+APa2X0MdBIjHNaePAnJdJtaavP72PrOq5OkHc5yyYi64rJxj7u3oXFUq7tma/lv3adoNPltfcLKseW2/gSwUnIdX9AZf4fTJ0y/2CJMFgt7gzp02V896CHaOLcpcLyYYXklmx5xvzpEtm+fjp3T024w1g0c/PGNH6dE5PmRzsWEg+RjOkNnkJc7+NpIl9AVet/c5bup0GgqmqGObLRpSgqRYzBcl7YMOZg2DezqG8Brh+3+Ko0hYasVxf0hxNeVqE2EWFXUcocglub+12PR2gzif4ksStimjqjbmTgul3efZ5UPOpwnt125CHnNw9wbVyyliCk8vzpDCGGFT0m7r9HUDb7xC1WLq7FdX9S8FKAQ3D7jlvEc8+ed8+NOnzG7n8JNztL/mI6UlTaPHZOHzkycy8u/dQ/RPOX6Zs+zn+NNPyYod1N0baKrH+6ZAHT7n8VafEEoX9TJCcyqkasnh4IAVNk5/yNzbkHgxmVIyO3/MiohJVTCoLIy4YH9t0DF02vlNZmILw94QBjewygT5FWa9MTjAFy0kIaWRV9RVSVtQubU7JJcHXFxdoLXahHmBP3axl1OE3pDe8BbC2SmdzOT505TAF1hOUwxTIIy2Jl/kVQxbA/pHr9Fu1cSKRqOVcvzmIZqj8vqtr7LrKMxVB5YhgZtSFAFvvXGPqWuhSA6X6oLuToPYsLB0mT//R0+4+OT0iz2azRHuxyeIwoLn7op2OmTVirlWc9JKp/ut32V4x+Do976CXaXoJyX5bMOTZcJgb49Bq0P80sfzFvzok1P2eybf+s62BZjTzLF2Mqqqz6PnC177yuukq33c+Slf/be+jRMuaFxd0YkUPjt/hCeqTEqDO90mT70LekcWX//62/z4L/+K+YXH3s49Lh99RFRt8zmcvTaiL2LfuMHxSKO/1piS0lYNvMmS6emGqTrhO3/9LmrcQG9ZFOsYY6/HQXeIdPk53Y7GV7pvcfr+M56cn/Dbo21ouNPqYTc7DI4aHLX2cS8+RMwk9E4DTZYphhHB8gWreMnk6RXdJCb2ZyhCk826IFlCvEnZuTsgzTUelkvEsUfNdoL56OAAx7bwVo8oM5VJGfL05JRudJfreY7htFm/vOaqMtjEOo9ezmhZEv1HU4LNmDffeY/j/RHB5JxmxyEIAzzvX7E8hRuXH7H6vZDn4z7ivkZw4qLftOhNNHpvDnh/taHvG4yOLbLogqR1RKulYogRq4FAkSaY0yZldMHvHO3QkNro5Rn/7S/Wz/MKuS+jyTpOQyFXAtQwZ71MePH4BYtlxFq3KfSQcZAiqSL7ezdZugGKJCLZ+wikSHMI9YjU9ZAFlXJrKFAWUEopRSXzfDbDMCx67SFFQyUWE1rDW8RxSBCHOKZFzIg0MDF1lV77FkWuQaizWKz45OVLKrmJYWzJoUQWkVWd5dULrjY1mWwwsge0ZIlE2YGuQlpcI4VthrsFgrFkUNpchguMsObk/Clr3yO8XMOByEy1MEMXxd7Gr+Nsg6bZSJkJfkYaqkTxNVoic3ywh1AtuPXOTYa3j9jMNkzXH5BGBd1eD1UUSHOB05OnCBu40RsgyTFCuSVjxSolDSZM64Be9xZSbFCEArcOWqynJXFRkOtdKilkYe5zkayQK535xYyX1wKtPMWbacSKirivc1WqXKcC7itzGSK5QVptyNOco/0jvEFNunnB2C2J1hMW6Zx3f+OAbOpjZwrDOkUSdRaqwB0lI1MdqmWF1a3RRiN2NhOGR68M5VkvyMWY8hquqkuqZMWgFIivfDq3Klp1CzyftlBQLK6Jrq+olAa5LNC2RqzmLmGRk7wQEfSaKEuo5A1WsVXa1F3TEmKkuCRpxKyvU/baNqqcEnR0oiDmRmcfUTfIco/39vewNYj0kE7vHov5lBeKT5GDsb9D4qUI2SuX9ZfIlwIUfhz6/L3gNmZzgeM3WCRr2uqGgzf7iDshh4OSSn+Ng9dLHn/+f1BeisTpX0fpnmAd/xYj65T2esmFtUczktDdnIW8JW6MKkYOQoL1kjxsEaklm1mE1BKxTIvxbEm03CB3cupSpYrWZHUPpy/QbFl0tSaVV0LkEYkWjUaCWHvo6nbArKqpXF7PmUsCm2zMa4f3GWsZtg2ybTKNEq5OJ9hCzSLP6DSaaLLCZurTaLbZeDXTyUsiSWIR13jBklfKEkirjDpfklgm7iZA0Bcom5yHxjmr0wuGe28SmhZSGZCvYg7MnKJnM778iDBfMlsmiEaFUG1QS5vxRzkL0SORtkpbeSJds40b+JSKRJD62Ht7NIKMRtGg3beowpJakLBkE2+R4hgN9DIjL3TWwRxVaRJWC3rdFnmRYFhbstSsLpD1+zTqDW+8dZfwWc7D6acMjBv4fkgqtfjuvTtEwZoXn/+E1Gtwd9SlcNaskinLJwtO2xOOykO6Q5mWL9Ox7hJqPyD4hZdiN2X6YgcfgbPJlMt8SufekFthzo8fPWKgFRyJBnkecaerUi4Dnp2e8O7gbQ5uHvInP/4JPdHh44v32cxyNC1mdPBgewbTws89klQgGq/oyxGx0SJcbZC8inYHTjdnrMM1vh/SFECPCmaTNb5xRh5ppIZM6+4b5GpGNY4ogohlunV3Y1NC0yRyvUPlh6TJNXf3H7BOc7qKDmufyk2ogc31c4yjYxbzDXt7Q2x9wOnZY9K8wFYdgijG92Ki8l+xAbNH0SVGo8m/89rf50en/5RvP3iT64cvSKMjbny45pJLFNXjaq1z78bfRLThdPGIQ2NAZy7zYdLjB9/7Z/z2wR2q39rlunR5uN4maxi6jGOKjCyHjjOkljpM2jGRntDKE9wsxz0/50Zrj3aRorf7lGGAHFY0zT7aqOTjn75PNq35u//272LbBcHZAlXfovuos0smK6QUXE4z6uwSKYXTi5xhZ8TerWMOukecvTjHcWquXZ/TqyVmo4U7WVMkMF9sSAs42/jYXY2LYFvUdTY+4VRc8h//ta/TKjpI1Yalv2Y2z6hCl0xYsKrvs9tsk2pz3FLlYpLwwePPKcOQ47cPqROdzuEuf/bohwT1kObgNvNiayms5gvCq2uSmcJR94iLswtEU2Q01Mm9M1a+h6Ds8eh//DOIK+JFgaG4VK0ecqURxjESEoPBAeFqTC1H6NUrcx9yCDcfMXj7AX/2x/+Es8BnIB5Rm6dooY5ycMB/98//Bd/41nf5zd/9O1xdP6QcqGSfiWhmxP17Dh+//z5n3QXytEtPUzgJnnDY0Lj4xZ3/6k6fhTHl6sVjuPc7vD16l6vTJ9zfv8lbD/6A56GHezKnzha0923czyaYfkRWzPnhpz9isDuk8EMyAS6KmGYz5yJ++cUZwk6TzdWczaHBYatmtvYJJhHuKmfqJgTLT7Fu7xOlESkFT6INVhajpW1kA/I2OJpKHUw5f7liJcrMhZhC2UZpUpZsBJ1OxyCOInrdA7w4Jkpk+p0+0a4KgyGVH3Lw4KuoUo6LQlisGLQUxGuRpBRplDKZ3CBOK9T2K9zRL5EvBSh8biV822jiBy853B8ylWqGvQXaQYvmjsUtP8YpD7HVJX3XJOipaEnOjlGwvKty8NOc/P4ugWBzePUA/94eRy9f6cDb0lEMCXNXx27uMr/0mF89Rh44jL01tbfBFAwGgz77JUxXM9I4IylgfTVBySzaooN0Q0WISrJcxotC8s0WFI7vvsHF2SVrcgRdY7OOOeslFJM1s42AZAyY+i6a2eHp6QlVEnM1TTHDDaulx+rMR9ZVStkitXQahUqhbhOLhsd7aKXNvFxTlh6HzT5pWLN30OMiLil7bYLC40VYEGUxlwSEiykLOSPXXAZ5hBd6ZIsV/aM7iLkIkkrjufeFNysIEr4r0TQsFE0jUXN2K4s6q5m4EMg59fmKTrdJXSRYVYcii6l8G1FU6HYc8mCCKdu0NAlNiBjY29BwvHmOstIJPo5xvYKGICEWZxi8SemAUmfcPL7J/8Xem8Tcli35Xb/d9/vs05/ztfd+X94m29fk68v1bCNbWDaySkgM8IyZZTFBCDEBI5ggQEI0U4SYUFCIki1TskFAlW2qnJWvyZcv29vf+7Wn73bfbwZp8iQTsoSElCVejI9iaa+zVkSsiH/8w883tC0Lt92inM8oOjIH5hEaK+4cnlHeLCmGNyT1GNtfU+p74E+mZhRNzqDXQ28kdlHA4aFLd+girBrmcYqctpltr5C8Nk+vXyIUOq8dtmGbslYr5rcJYn5BnjsUckFT7Yfy9C2P+vwtXvhXOEJJFUg89q+w9S6pUZEfdHgxn1JLCYJiIpY6T6KKO6ZPJBnEkxV+UfP6W2/jmxDPMpKygyzv80eF4bChYdAIaE4HQSiJ/JyWp2BZNgOlQnJscqHGcByE8BrDSKnlDF3VcOwWnlCTiNCzjph7HeTd3sF8nXwjjMJ29ZL61VOe/fYBR807eNELpt1z3nn2lE+EAZbzJqfHrzFZ3/J/yDIPPvmHRM47RKbKgT5h+maI9eF9rLHJ+1LA7uePmCyffan/uPMaRaHhByJZFbNOS/wgQHUExolJ11W5P+5jOxKLbcpRV8ITXJSoYFnkhMs5ap1Slgqz2YyaDa7RcHp6CFwB0Dv+FjfzgGxXMfcrirpiO4soZZ1ms+P3fu/vM/YGSFoMgoouSmwmWwRZRjMN6qGBKcs0VY7umJy88SZoNn/4z34XgLj6guI7FCSG3gkzM6NQVpi2iZ7vEIUA1ZJQRJlEWxBMZGSvpidkJH6LF9MnqJ7N7Syl6Z3xrDRoEh9J3QOkvj04g7FGXSto3pD7dYHVPqTUHO50ZR6/fA+1djBkj8ViRa82KMoIWWyxXYYYO5F2+4zNzYL7LQ/HaZNl+8P+8PW30E14nr/kzshDMUS2QsXW3/Gtt/8asuUQP53QakRq4xVOUeHbJsKhxLczmUcfXHKn7JEeSEjpCnkdIr4J0gdfuVDrjEFvyEoOeXT5Hr1Wn2ePJqiWyebzx4gtG+mo4dNfK/zioylSqNBVNf6X93bEQopdGVS1zaCrUU9XOAj01H009UEQoGxfIUYTZl2bk2OPSDsi1OH2dk6FiOkWaG4Lq3F4nM55cNRlGlV8en3Lw9MOSQJPwxvSWk28eAAAIABJREFULObSOUKWNApzH9n+4tWCN8Yu5nkbxzbxwxmuJpAlNX61xuvrSNoGHIdi8ZKMjM6JS5FAHM/p9FXyWcwmzfjg41csw4ii2s+V+Dr5RhiF8Q/fIPjeGaeKxlC4Zv75R2h9mSe9krvbY5Zewlpb4q52bOvn3IxexziwMZQFT/6gTX1/xyp5jj85p/YWhJ95rFr72nUhy+ximXzlY9Rr8qYgjiMqX2DQu0eW+lSqwsDrUNc+quihVRkbf0O5TikzH5ESKU6IViUVW7Q4xfVOgD8FYHhyijG9QY5kKjOEWmNbidS1TiU23ERzpsUUNS+wRw6O4pI1UMUlBz0X1zqhqSL6bZNV1VArNm53T59VCjFBPaXdegeMhriO0Zw2Ubkj9KYc9If0rC6eoeHsYCoWhFbK0bTPSphSuz3CosZ1NFaOziCQuKwrCnX/1pR0nRKfpuhQ+QFSIxIEG0xNpjYsBNmhTkBKFJYbgfuGQSiIdN0BkqgjVRFdQcHs9ajShEYoGHj7bzCbkGkuMGp3KeqAgJgD9xDdNHlwWJAtnuK8c4RdOEwurugf2MwUmZYG0+nHHHUafDVF25octz2iXsFrvR6yes0/efFFWbKRBaom5MafIZg623TBq+mWsVtTCTJBmnL1j2cYoy6a3uKwc4eWp7POIby9pjs+g6LECBLOvn+XzfSGjz/bN0SJuUUhDpDkFdNtg6GXiE7DPNqR6JAUCgOrja4rpLJIuy+jaW0sSpqjFO/1czqxTFSnyEKD9UomlVR0Yc+n4HSHSMcGKCLLMmZ3dYMpaKCWiHFB5R7TxBmatGGX5zS2zIFhE8+WrPOGpDHw5QZDMlDFgo7VZRr8OUM0ZoHJo59FiCevmG2uuL5QyD+e0H7jW/zR6grzaUCq7nh4vOPA9kjSC5qfvyTVx/zSvWH8MkVKelzsJlSrNWeDv8z4wQFX/90X+stiSRBEbNOaoyKAoqCjROTTjFTMcEQdgZhqHfDt8YB0G0NLwClqRqbLLioRVhtiQYboElVUyOyS4itedrJq0PQhR/dsencPmW62PL+4QDQkskrCPT4kClY0HY9FnpFINfLBMVmcMxocUrgux4M+ilDTlzWcgYeu7cPWUdfFMNu8yFUuoxVNGXCqZ6zVGqca8ky0qEwBDkYEwzHp5ZQ8lSlOa+zzb/N0tiOPNpiOzMXzgE+iNYXWQhb2mPiMFS1DRFUD5usl4TalZ51SxjNubhOi5YrD8SEjoUTWC9abC4QmJmqmdByHIizpKxKqJWMpC0RZxNP2icaACMmX2HoR5ycqktABR8bLbN7o6DjdA4oQZFXl7ukBm5cvcCwbf3PD64cCRVMyrwxu5GsSHJalSKtRSYt99UGNS2x3wFtHNs9WCsn8gu2LNcKpRuTnCILA8f1z4mBJ0dxgah3kqsS/8Xn7/muMujZ6AkgyPS/nfrtNvNp72c6dA4pY4k77jHC1RrMX6KVGPXSJChmtjGl1PdAzbncNiWkSt8eI2xjv+IT3oi1drc+BLDGdX9A5OCPUbZZfwSl0jg8w2gqZECFUOwTPJS18HN3mZbzAWki8efeIolI47TsE2zWrmxW+ZFOrDbLWwcp0LpcbtkmDqAtY4/1k7q+Tb4RRaMoNz5++ZL3REC5qst3H3Jolh88jchKipE+k/ZLiJmCeniPEN5S3Y2zt5yx6BWqnxSeXl1SlTmyJpE3G4eO9B3RdnUJsyCoDygCjqjlWXJZCxMhqYfRa0KgMWwKeJbArAiz6DM5PiLOA1dRkLYmYRY3hyBBXhHmBpu9LVYqqIcsOuqUwMlQ6LRtJqlEtk6oCQVTRZWioieKMsgoRGw1R0hj1DpDlmnF3iKzIOIpDpbrYxr6DURDHWJ6Kr+SUm0syYubTkH5fo62riHXN4iqiP53RWBrCsiRqduRJRp1VlJ7Bcp4QzhoiYYAeQNCWSXb7wzjq2dxIBapW4UkmWBK9tkCjiDgWqH0V105QZY+uZePYDpYBWVPgSiqNo2BqEi2xYJXnWJR0+w++1N8atrElGUHr0/EkyuwQq+/QLEPK3RI/z4jzCsX/BM9rMzYVgkHIYeZSWgq5FlBES3ajFh3R481WTVHkvLjdN6b1uzlunVJ2u+yiGdMsRtQyxOwZHa/H4LhHmggMhkesdhcUeY7WVAxHDjdRgpEkvHV0xm69ZNwqKCKNk/N9lUkrHVQlBVQqZUvUmNxm1xzoI05bImk+oLBzpMLi+EjkZeazXk2Q9BZJsmE9lQj0OfbBAZtSZbeOaWwQw/0agq5Tlw3rJKQUGxIhp9muiTwNURAJ8x2fP14jGzZdUWSXr9juIuTKJiljUkln51eUTQlOF1E1yJI9DuLr5DfDYH4jv5H/n8hvhsH8Rn4jv5H/V/KNeD783f/+P6XXG7NLfJRtSi6DKIiILY0msyFMUEwVT5WYxiF55BMrCrpYUEodIGUTLCgyA0F3sFWFthTwH/ytfwOAf/Dv/5doU4fldsH5wEas4ejuiG3W49Ona8xTSKoNZ0rC8ydtynlFb7ymPM1YrRPc6Y94c3jJy+OGcTqkuPCZ3I/Jbrf8zn/xbwHwd/7jf4/LZ0/oDDz6pkNXVcA6o1EbhCzH7pjcXi5pZIOyKfHkCqejI+QCm90a0+uh0JBJOp+/vKISG2rN4nf/7X8TgP/sP/rPiTY+WVliaBKyJoIokyc+SlMgijJJXiPWKoalIJKQoyMKDbIqskkShFJB0TQkSSHa+Si1iCCp/Lv/yb8DwN/4W/8a24WAoVc8+fyWszsq33nnJ7Rqg0G/IGssKtVl8uoZXUej0I5I0h2umLFZ58iixTJe4w07zJ4sKAyFrWjxj373iz36u38HfvwXfgDVgG2WcjAekhcCE99HwKHKCly9RpQLHHXIJvIRdlMUCWzvACnJkWWR5dUzikbAFBRKqeDy+Qv+9f/qC/DPv/LX/0PkLCDVBdqtIXkRs5ncotgSimEiqy5ekzJdFtRlSuvoLmEm0EzXjFsmQqehJVUkWcJqHpCuVF7NnvGz6f8AwOPZ3wbJoNyV7KIArZG/4GgTXPxNwCr00UuRiphZDLWk4Zoi1AV1+MXEaGdsMuwYyGVGU29IqgwxT/n2u38PgL/33wRcLq5A0RErGcnOmX/8IcGqplFDaMBpmfg0kCbUdpvl5BYL0FCJRR1BlWg7KkajIKkldx784M98H78RRkHPR7y8qChLmeTqiu1qjtPUrMIKYy1jjIa02h1e1RrBKsfo6lhGStHu0EgC6BYduUawGrK84LQ1Iim+0hI8cVm9Y2E97fPr3VNE4RhxJ/Ho+lfE8Yjr95csDlX8ucyyekneeoNHyQVHlxlj5R5pK+RKUxHU10jWv8JUJUpRodXeb19/9Br9szN2/oxjwcAwDPqqxmw1Z5uFRE8TOobGa14ff7WmPexBSydMtsiChyxbtHoecp1QKUc0tsnTmz0T8mI5QZNlWmZOkgYUhcDRaERlyISxgKo0NEmJmKdEUUxTFTSSgmGYFIWMJqSUDdSFiCWqoJSkOWTZHmsh0eW7PzwgTmrOzw85HHscezZqHaA5Cr7YYLdlepaClMek4SVh2VAmJafnJk1hcjwcEQsOJ999l9Vswq9+vfxS/8n5b9N2HqBIGtG8QKp62PaIThWxu00Y3h+T79ZUcsOLKx+BMX37DNFSiLOMWqoZdV3GThcFmXC2pNt3sJ0D4H8C4Px0yPUnr7CCHcmLFZ2zE5yBS2mI6HoXQbWQaegNMqpApKlKyqbg4K7DyZ0eYRpTiDmt2Ga9CTCNiIc/+C1+9g++MAoFp6yjCMM9QFMq5pfPkQWZPHEZts6JoylxJpJpManYQdQkVssbXmv1ieyC3kELXAPJ0AmDjLYaUu+WGLYAfGEU/vi9P2AbbWg7I4SmpFRsrrZz3JFJDwdRAqetEy4TopaI0PgE+Q2H/VPsnkOwSWg6GmkhkMyvWTy7xPIGwJ7b4v9JvhFGwfM0VqsaS3eJ1MfU64qtECFcL5gHEd9+7Q2kTEFcxlSywPZmhvraEUViUlAzbjm4uolkxiSiiCTX7JZ7rPcHVOjTjNpxvqDO0nSKmw9YGh5inOD1JaTiin+6XNIedCC7pLXM+DAJ+EV1w3ceLHis3Kd7+yfcEzb4zeuYn6hEp3v4q94R8dp9TFtinKtcLSbImwJdVbBUhQiZ1N+xii7Iogqhjmj1h5RFgNzo5H6I4HTwjo5oCxfkqoDn7glQFL3BU0TiPCQrA2RTpxEqZFmnqhbs4pKUEoGKRhdoGQ6yopOlDZLaYGITiylZmVFU0NQxCgpBtN8nPwio0HC8grJosY4LOt2C0vZwbJfVq0siVaAMQWkEgusn7Oo2jiLTxyUyK3JFI6lF5LxB0kU20leYlySHuFFRaodGaCgTkVjKaQ8OmU1ekuQeXrdDnAVMox2EMa3+IbKesVuEHA0HiJaOnJk0noZUqCiag+nsHYB7cp+jzYTV7SsKtcL0BOpKJisK4nBDY+2QLY2sFkiFNp5j0JYCOh0JTysp0oh0usaXApK6Jlcrjr5SVl0GMtN5xNmZhKqYKGKX1WpKs61pKp1kU+C0Oni2TibJxIXI0HTQDJkoCJksNwhBReDKpElKozVItUbN/rmvOgJqLLLeTnDtIc6pS18a4fsJjbQkk1s8EWuKNEcwNQhqZK1Hy+ngDVy2TYH/YoPoqBTBjijJqfw/Z+ClUmmwBYVdlqLr99AHBk26xjzoct+x2Tz/Ja46oFy6DHsjWl7N6vmMbTLj8M1TlKWJeKhw8asFplNwVUukwv4w/o2TM544KkVusrhac9iqSe8csfnVUzbuh3z6iwuaWkTqiyjaZ3z8fMMPv/OQB1uJb//URY6+z+frG5wCcv0MwZ6Qtt7GTvZZ7/P+AUUJh9YpA6Gm5Rm8/PAJNSU912L6+OfIlsoui8iLgoE+pKgmTG4itN5dFKUmnMc4TUnbhlWYIfr7jHETLMBro8g5qiTQ1AXLbE1dJeRlSSlq0MSUyKiKRlIJpHmAKUo0fohg6wiqSlXWaJaGophsNisMa19BGSgedrylkVVc0aV3MKaIXtDEM6J0jaKkSH7KT//aa7yaz0h7OYLgIioKN5sV63DO6mrOcloyPBiTZCX3VIF/+s/1W/pd1HJIUBSUbY1cOyZYh9xcrXge23z2s485bx0ye/WKVaxgdhommcf0+WMsVaZVCaxvbvFq2C42NKZFGVeU9Z6LQIslRuMhB07J0xefkMczbq6u0DwPqcwZjl6jf9Thly8vuZ69Yi3rHB26eIqIIoSEiynHHYkwg+7DU3aZyPnBd7/U/3JSEYQW4YuKanPDOwctyl7FThPwxgccnhxh1gZRPOdw1GIVFuiZh+fqaNtDXm0CPLtNlQQEvs+TRsUsDDxxX30wiHBPOmSGghgDQUSQrAiEnFVrwNHIo0pktEMVe2BTvZrizEsm5Yr1bEteyOhjhQO9YKuP6Xse2PuO3q+Tb4RR0GKVgTUm16asljPmtwn+ZsqR0VCkMcmzJacHAvNNRuewRxpp2FVOv6Xj2g7DXodEWqK4Eut6hWJ0yDd7lNvzmzXzOqG+KzFdbJjbPke5gJI9pR6qtN+QaHYVy1rledEQxCW//J+f8S/8zQG3GxntvKDDEbvLknIocfi5ybMm4Xyw77NveR5qU+IUNtvFU+pFiB7VZIXPbLGhJWv4Pni6ix+HrB+tUIYuB45H3JQIhYiQplzf+ozu2vSPztCVvQcs4pBIqrE9hUBrMDwHmhrREJHR0QQDPxERapVabCgUA7VWSNIAXRaQmwylKRGrjDrXiKIKUywJhP0aTh5wInrMVjC466GnMaUqkdNAIzA47fPpqyt2YkqwnlPKIpJQg6QQlwXGYAQvGywlwdR0DKMgU/f6xc4BiSAT1zJF4RIqEDQ1uZagZAq1ZKNIDbljUgspWv+QAoEdFpLZsFMEdMNltlkThjkjXaSyTsl2eyKXtiyQ2gpW3qPX6VA5Ni+ehCi6SG/UotXrEs0KbuY+LbtLpolMZxG6KLDwn+J27nI0FpkGEtuVQ1PLLPOvRDuCQJTUXKdf5A42eY2sD2iLESCiSgZlXtEbHZEs11iijOF5CIqIYoB/m6M2NlrdEKxVVF0kSRM8vtJcVzYgbEirDnZLB9MgWstUyCRixjSpyZqCYltT5jrFImAW5gzJWGYl56MBhlDj73ISf0HTKLTrP2d8CovNikUhILoeLWNMdSqT1RGbxRPyXY6WTLl+NOP89DXG9hGRqKG2D1AGB/R+68f48ZJJGKC3TphlAopdk873YXG6OWYTfUQZxJz/VOX6o09Rh+cUxxIn0Sdkbp9FPuViXuIMj/npDw22uswfXD5F+d/f5403Je7c+dtog3OiVzKnRybObZ9ocbX/iCTm8iKkRYj/8RWLV094+osPyHYZVZJw9sZ9JPsOsWDQa1s8/9U/ofhYxB6eYpsqoanS++49zu+9QZRGaLLKcHB/r18okOwSZzxgt8hYpymmJmFaJmGjU+UijaohqQqIAnHSIEoyd+4OyNItY0tEkWTU5QJTkbDNEkPuMVktvlziNvN5QMCD1gmSGCM4sMkKTE1mUzVc+iXynYf81598hJrn/HB0H62u8fOSUnOo0hrx5pJ3zgbYSJhSxp/G+//h5OicrSoyv5yyvF3z5oMerd6Qwu/S+0GLVVpz8+IjpkVIvzNCUFSCdIlstXk8uUHqyRTbHaZo4h7YbE2JLJpja/toRzAUpAuDzeRzol2ETYe//tMHLOqYi6RFvZyT6DqNIzIzYhRrhGBVTKM5s6ji8CCiXnbpBCsMy6HTv4d0uMdaFGGAki2Ry4zu4A0WvkhT+JhWzgeTX+MWGQ8fnrHzFaaLNcNOj/WmoCq2RCIkTYMp9qhWIUctg+nyimS6ZWPtEbgtUyOuZepsxe2NDo1Pdzxg3mxZRB6T2Qqh5ZAlKZOrZ9iijqUP2fgfoSkCA0VBrypsI6DtqqRyiev9OYM5N0hkqzWSqrPwM0opw+t2uHyRUma3sH2OIEkMQtit2+jOkDvHb1M7XcyxS3gTc3sZsMwz0rrPZvEKP9y3ot4cOsibDnWdoSxaSP1DdE/jW+37fPTqE5Q0Qxi6HPVbZOMSs7DYtXbc6XQYGyq+1ZAGt+ipxHd6BlniMN7mzIWHX64xPruHWiwotgHNoIsqjUmfWNxs1mzSiCwMEYoZo5MTpDrH0RQqWUaM5gRxjXN+iJJuqOMlVcslSiq0zr6zTWlAKjUEsaEqJUTRoFRrdtuCnaChCjqrskIqSqRapSgrFFkgrwTCXGJVlVRVglApNE2GISlQRNTpvovx7til1XOQ6pJWS0dvmTz+5XPKVoijizTyAcH0Au3gkHJ1wadX16iygicIfPL+MwZOhzfvetjktO2UIBLIt/uRa2KhEkZLFNlBVUIEocSSFG6FhLLwuJlvyNU+uCrLRUbL0MkakaioEFodhJZKVKxZztb0HYdV0jBWZFRtv0azjZHlHbIgkcY+rrfi44uXtEyF1XLDzOzTDM9Y+DvkxiBpLoloWOcpbdtglIq0q4Y8TNmu52SmQq9z70v9flmQVzJnoyM6wxHPnz5itp4iGDIYCqbj4PSOqPMNrVYP0WqxiRokwQJRYrWeMu03aJsKd2Cx2a0Ik5xhvDfOSeST2CqWUuCnOlt/wVV5Q9IYKC2DTG8QSotAaAgamc26RtYu6WY57VBjY9e0WxJ5JGPlOV1JJgn30c7XyTfCKOyyjMR1cAsQnJr1Imftv2LothB1ncifoLQc/Lzg8sVj7p5n2EOFreeiKCpFmrJSFXYzn5m+Rgh8Mn/PE9AdVQSFQNu8RxgsUN0uD1SN9+sB4+4byGqJqtvUhcDdfgSVxjupS3f8kElrwl3/muW1zZtvnNFdOaxcgUfhNWNv/05znDY7pyaehSBCXilItkWyKqCIsUdjslphs9uQI5AYGprcEK9TkjwluBI4PvAI05D+w7uERUW62nvAtMmxRYk4FxH1NkmcU0UyZV6yRcZueVysbqmCiI7poWgOklSyy1zyUuAyDxHSBE0U6coamiwQxFuErzDFxHlD9fEt+r0+nVrk+nrL7fSW1aNLBscd3DsZm7xh7IxpqiHr2xcoEqSFiOIolJLIqeqgGSJvn97n8TRk1OyfD7twQaUUqFKD6fa4vLzE6rQJxBp1YHP96gJX6DNy+lytPyUOEnJbZKdnhIsN2UJHCSsMr6FodtiKh6JluM7+qVjpK9Rog9xcc+r4NNqQ0hd5PtlRn6jMNzn+LMY7OYXNhEpx6LsyN0GKprXIXr6gME7IkwvkbZ+duaN7/L0v9auYGLbJYWuEY7jM2x6rYIbebTPfrlClhmWa8drJIctoQhRveRE21Jsthwc9XK9LEGQgSJSpQa81QhF3OOr+KoZRQZsYX5bpqdAMPLalyK5OMSqZRDgmMBUMxWCg6dTmkkSo6EuvY4o+Vhd000Gq5lQ3Vyx9kYGzh8x/nXwjjMLV0w8YPfirrJa39M6HSI5A66pgbT+ik+aMjVOqYM5qdU1nBNrojKAvMTqA1Ixp/+AI61dTLrcFWhkz7LuEyf6wZ+sKnx7NpmRwqBMPP2EpufTXa7ZHD5F6OiNTpRBrhj8Smf0eDH/o83Kj4am3lPFP+Uvvfg95c80yV/ng9+c8urzm6kd7PLlSBLiETIoV23TOxF/waBGzFRXu3v8hb//kr3IRrCn0HnE0p997gFBlGJs51zcRfr7g2FPYlhu8ZIauV0xffPqlfk2VKIuE261NWTSIuUZmeJRqwzZxWGwUXgQGmj4ikGzKtEI1RFZXFVImc+9gzC7M0MSMJA+wBYnzkY30lcGmR6MzuuGSo9qg9XzDZn7Fb+U1t6ZGkYvYAiRlRnq7pCFmrASsXgWwGfIXH/6ELE3pJApD3Wb9ccLu9oqOuefFm2UVre6IXz/9lJvpKxxJ52hgslUsjDxGsGp2/oK48Ti+9xpB3bDaXTEcdhkcyaTSmtZYYRHFHGsN43bCiXGOPN+XVautjGp2GN055I/fe8Ik/hXy4euoI4X3Xl4ShZ8hHAzoWQ9w7Yo/+Yf/LVvzANFKsHoSxg7e/99+nxPF5PWf/KvUzgGGvk9kPhyckEch5fw5rz79gPvv/oT7Jz/m0hQwdxFRXPCPXl7RuXyJ9eAtwk3DIpzw7ftvM757l239Etdo4bhn2FLB4Umbskkw9X1473VdKmHKqWXy6xcbkmLHvb/4W9xTVP7w1YLt5inR1oOOjlguKYotpgJiT6M3OqR19YQs/IwzUcfsizwLQtrq/n/+OvlGGAW7ziiiG4zWXZa7HS3bI1ZfkpEQpyUaN7TNko6qU3sS26qklyTcHWtEeYmfpqRJTaZUSGWbKFhQJvsSjNdts5lc8jSac/D9PndfnmPch91dgaKzoJRVBr0HcPIhfqlz5ydtKuMd/Op9NOchb2xEwvkLWB5gGxmjByOeVTsmi30ZyagTrmc3pHXBdJPSaDq2pyF86w7e+A4bu0KVVIK2isIYbZdyOGzz4pEEygx1G+MvV8yzkvEdF3YqTbGPRAxTRVJqDFkhLjQkKrIwJZTb7CqNrNSR3AfkjUDZQKUWKElDWcbYtsGN32A5fZQqAbEgKzPWwZavTL7jvNdCqEsQKsoIOqXB+cjguWCxkHesdxn9JuXlOuB0oPC6WjA5atG3VOw8pixSxmaPKqrRWw07f00c7L14Hi6ZXJakdYKo1sieSChl3PgR1WRLtM5wrWPG+ohmG5PcTijLgOiwoViuse/J3Ppb0uWKuqeiyDLxLkTO9ij5q/WSQggo6h3eQIZU5hfrpwy7oLgpx6MOhmMQyzM6HRNvuMIWDcogQhJ6YEY8vNvh3PA4GQ7IDg6QvL3+7eYl/jTBEVI2dYK4WaPIFrM4R+oMUXse1SuXX08+53AZky0LWq7LPFdgtqJIa26iNa00xB13qYqaGomk2e+TKKrIpkOVyyitkmwFVZSxVBO6pomotLm5uURfx3RGKu1xCxUdQ4pxk5hKKPGkAW0v4uIa+oKAoO4b075OvhFGIZ2v+MFbKRPxBULTIiwLatvFtC0cfclB61382SuGJ0O0bp92f8zq9lP+13/cIA8foh9IGC040ExsT2H+i1t0ZZ/Nffl0RuJ7mIcR2yjD7bb44PJ9hrbLX/reT9h1x/z9jy5YiyNm65CfniZUmw9pTzUWlsGu933U61+Sj2pmTy22rYx8abLR901X26ePWE8WRGVFmNa8ulpxdD5GrDdIVkn3VCOqM3JKrI7DUPsOj3/5jE3T4N474LT9Pd7/7CnNusT6HEw95OB0n1PI6hgxkWlUleUOyqrCGh8RlhpNqJEkAnbvPoXcQjdU/NlzVE9CTW+wey6r2RTNERGtLnWg0Aghq8UFLXu/T6ISUUlDcrHLoFnjmjKCl3MvX/HAHvOzxRW6Az/pHHOTFzT1nG6a0s8Ujpxr0qLHk/d+CfIDrqOY0Btz95294VxHGe22gGkmiF2FxM9Z72bYsUotHCAoKvMbkceT57x7/030fo43qdldbVgFDSNzy+DEJo8fc9I5Y+Bq+IuKbbSPRha3a1p2g6VlnA1EtrXCZLYiraCnremOan583uWzi88YrFO+/1dOEVKRZKfjX26YXgS4h0f07r2F3jLo6Rq/+PjDL/VH/hbd6VGkKt968G1+dhUQBxr2cESxSmg8Db37gEP5jMbuIsk7DnoO0e2Ci6DBVCtWzyfgZTydPOdU3+JfLZC1PSnQIpjiRiLz4ItcyJlTEEpLzLVAkank25S+I5OWa8Ra4X7bonZkztqnJNOUy8sFWlukTnLyeglOj8urz4Hf+TPdx2+EUbAcBa//BqIBVDYrocQxdbbTp5BsuVoskVQBRZepdjn6ScTLKma+mnPv7l3SdUQzS7B1gaqoyKRrBH/vZQ9NjYv0FQfP7iCcigz0K+afvUX7X1br5EX1AAAgAElEQVR4WR1TTQqqdsrbyjm2syL59YzV4HXuH0vMXviE7ga5rMkijxOmWJ0+/2P5EVqwZ0baJTtURUdMG1abCEQJ89RFWZXsipC4XiEYAmm4wZRsLucT5tk1ytBE1CzmYYpj2dSKi2ErWHqJpu7duGpZhH6JZxvc67epJZWpL2GKEqNOl6HQQu0dURstRLVilQVERUhnPGTo2UyiJYogY+guXUsnizao8RLJ2l/a4fiM3aLm0WWNuWuw3QFSOEE0NOIi5H63i2lJfLq6ZdMYiImK3gj07pxBJCIaMqo3oiwEbl6+BHHMuPXal/olJFSz4DWrw69eTYjzEa4u09YH+GXNdL0h39r0Wl3kOEEUJUTF5OWz59zGE955zaXxC6y8JskWbPKacFNQ+nsv2HUk1FaOkNsoqslpr8Wk56L3LQZ5TcfcICs5kq4xX075wetvk5Yu8SRC2V5jPzzn7M4p2p2HiDsTGosy3p+leBuTSVP8ZUwuitSFxhqB/ui7KLuEOFQwTJVVsEUqFVptlW1eUTYNkijRdmyEcYuelqPUJob0lNLh/wZeCrc+ki1SRA2iEyOisXx+g2S1uTt6Dducspxf0dluuAoy2t4Qz81IzCF1HaNWDT4qjihSFC0EYcj8Zvpnvo/fCKMg2za3yxfId+4hRRHT2YQquOZgHjKZT+muEmpxSe/uPcI85OLzNfadbxFHAZOPfoFQ9hkO2zyeXIO44OiwhaTvs62PjBVpPaDsRYySkLqRufsvHeHnPvnmCoqcn3bb/PzlU+x7LsLpm3QWMdcX76Nlx8yeKrTf+m2Onv+Sx7/+hLbzgF9dPePkO2/B9RdrmD2b1ad/SpO5CNWO4UAiVnzWVsWJd8QfffBz7t87xjx9HVEtUKyUnZUyv77k+OghuzDj9HREsElYZj5+smSdvPzyG5qqodM7RK0E5rM1TSPRGAPMTKJxBFIiToYypVxRCxVv/oXXCXZL5rOn6FXKvX4PqYzYzG5xOxa2bLOJLeJon/U27C5/8Ee/jxJ5bKk4PK/4kdbBzLrYuop03ybKJT775DPUtsmDQQuBhvhqwtPSRb5Z82QncvX0FknTyW5f8JcPfutL/dNtSD13+Gj+CFERSJQdVViw9WPQzzgzH+A3Lfr1gJafcDOryBWBt++/yyi2aScBrchk277LJp0ilTvy2Kbx93iRsOhTCDGZY1CdHtJ2PE4MhXAbIjZXxGULpbjB7fyYSnmb9xYOg84pB8ctzk97fPj+K15kEFzo7FZrijSkWu6rG2kjIgsK9+/fp4grnrx6QYPOp1mB5h1gOj0O2gccnYyZLUDZ7nAqm+vLW7LNjotEwu7UxE3BkRuTxiarcEm/vX+idIZjxG1I7IasdJBFhTsHRwTCgJezJ2xI6bpdJFnjzZ7D5uqa3E9RhI8RChkqE2VaMnElDkcDbBQSfw+0+9r7+Gf+5f+HkqgmrrUlSXLyKoDtnKSOePD6KQY7rjcTBmmbIjfpjo/w7BF+tqQoBNr1CZfJhF6oYeVLAj+gVhrCcB/a32wjnM4RnfCKb7XG1Ectdp/8CdY9j3ohMYtlFonEfalEjk9Ztq9RJyUX4wfUVyL9jsHJdcanuUFYHZOV8y+gtau9B5lsN9RxQZSGtHWVbs9j11UR6lvKWiROa4JC5p0Dl6yMCXMBU3JRap1KaqHqK5xDl5YscpVmxNuAdncfUhaNgNwo1HWDKFUElYgpCtRCRpxOkGuLePmCIC8xZJepmKBKCooIDTJGIxJGKf5yizwwQFAQFPkLavn/63+IKhrLYTZfMTRNXj1J6OVw/0gkrnbUTcJW9OhZx7RNE48585sNq8zGzyK2yxWfXDQISpc2MpYiIlr7w25kFaq8o1MJ6LZGkCVsNxXD9ikj7y5lYdARuhBJKEmDKUtUFTiNiFY5CFlInISoooLjtej1PGaTDXN//3xo6gRHHlNktwRJn42o8OF77yP0RQ7OzlivPmMs94mnU1aLBKOv0M9FQtEk6daookGyjpEPDuhsYuqDLs8WX3nvKwnjO23MeEus5bT1DF13aLodbKfP4cEh2zAiKVK0tQSCz81nH1DEGbnoYslw2BtTB58iSyJRmNMICXylSiPkIYGdsdosaZlHmEaX5XSD1rMogNfah1/wRFiHKKZAJFwidGyqPGd7uWHkypixgKyW9CqZ3sBAq74ywPZr5BthFIzaJav6mFVNXWQMrQ510HAbbECoiHY6YsfBG7fJ+x1qyaJ7+C2cpiJAwckLVosVeSxzvd5w0Cooiv0mGBenLLYfYh9KPPIV3skELsQ2ryXQ8VOyoYgbCRy//S8iVyWPP51iLEb8/PiSb3XuU20mvBQ+Zv1Cxhg9IZydEIQBP/rRmF//88lxq9kC1dBwVZtwWILs0mg5QlXz8eoZA9Pm8KxLbWZ4ik2TiTjWnMOjHn1LJKgkbp5fcbfVYXH5kvXNjNdf3+cUGlGnkQUKQ6Ol2SiNiGhAlEbcGZ/glwLLyQVRnhDVCoYmo9gSqjXAkAWWiwVaGtO2LJo4p65TwqzGtb+CI2jVtO71UI0hWSng7pYskhzzlY+i5WyqEqE14PXxu0hGgbjbMr8xEByPcFVxfbUgr12OT1v4yx1vf/dNTr8CyonCGG9tMfYklkmC6o6wihrLNWi5Bot5giCK1HHKNA/YVBWSUrP1F9R1QC1mNFGMrMYIfsagbZJFIeFmf6EqJSesb2k1Cp989oLGcpjvLFy5QZRM3nrjeyw++oz+Zk68zmgfOaRxiVbr6KbF3QcmtxdLFqsaXR5gBAWBv4+mhNIn9BUE08VSGx4OHFqnd/j1KmfnP8WSYspEZDpfIlYtbE1BjH2CbUi/4/LGsYtuR1xulyxvl6hhQbVco2h7jsZKjDEtgzIq0SPALAjKBrvJuDdwMXsexaSgaRqErGA4PEBpdui6hdHy6Vlj2l5NyRxj0MJPTYz23sF8nXwjjEKs2SjtY2IUSjGldzgkv36JsAx4thJ55949NFHl1XWIlnRpj2SqwqGyZQxX4bAQCHdrPtlucZ0OebJC1PZTfJX7KvrsBCtqaI1dmrTF+PyaTRpwK0/ROaezK0kyqCmRPZFW/Tm/s6z5Z3/4C4zzLf71iuXza36gP+AlFu/+lW9zeHffdRYtIhTRpis6rOSazsmI9YufI93mHBsHnA0dwssFJ98/RxE7XPzqPaIypykaerZJuSrJk4IXu4yTszsMxh1azj4JKBci1WaBqQ5p5ALbFBCQaDoaFHMODAvFE1nMfMLdDrfboid6mFwRBz5SFiCqInEQEYcKKglDwyUX9uW8H9x/wIfSJf03LaY3AXWnw6NPfs7rRy20ZYBidVj7C7LPSlwFyibhk0mGXTwjWsXsNiLv/M3fxjs95PH1c45//Abe+cmX+kPdJinAHbYRIpldICJsGpxBm1cXCyxzTCqaaO4hHdsj8XdgZoTiJavLG86cAL3doV2IWKKNP6kYnLxDMNu/l5ehRNA+QOi2eeP8dZ69vKTlDLndTuj86YZrAe6Ov8u16TKNZ+w+zWm/0eaPH3/O7r2Yd9/5CX5p0/YGxFqf5OaSprcnbs1uPkXT3+bkwUOOxyd8+tljLhYrXhud8+jp50yfXNA1z8jnGyy1QUoLpHjGu/cdZHFO0NyiyhrjU53guc9xT6AQZFr2PqegMaHRT/jOG++S2Qa3N2sOzu/QNAKyGhNOPueNkx8SFTOe3U7+T/be5Ff3Lb3v+vz6vnnbvfe79z777NPfxrfsKpexccCYIBQGmQSRWaRIjJkgIEGKUIiQIiGEImDAiEGQGICUDGACAkeOHTu4KrduVd3u9Gf3b//++r5hcOP7nlkZRrdEPX/AWlq/31pP+32+D/cnJ/jeI3Z3b/AfPKTczAm7jENvwLYPactbinjfcfuL5DuhFKSuRm1kciGljhOUosWM1vjGkO7eGebdO44dG7MQyJdzUn+ALCzplg3Xtx1VVkEc0bUi9z2fuIUq3LutklbiD45g/FOKTEAetTxcWvyZ1HN/obHabAkPvsfmi1c81M8pL9/yR8UTJskLCjdHrifoUYAyfsLPLiVOxB2S6sLlfuBMp/XoscpdNkeVBlR1T1/IOLrHwVBiND6jFJfkbxLWSUjfWxi9Tq0axFULuoLFEdsmRihr+vIbuvI/F1nV2Kwj/FlBL3YUUU0v1Uh9TZVUZKqFgo9Fi+GoiGJPX0bM1yGa2COLFWla0gsdfSuTFRllktCaeyu7aFvkqcTbd284mj2kDRQcy0fpNYqhQ+tPWb8tqC/XrLQQs8pY5yKdM6S1bHRV4eT8gNyTOCjvcfL0hIvN/jJurze41hC7khGFClMZkSoZXRTQtDaC3jDIFWpXROtsTDFGMHraRqDuCoTKQQlrgrZi5FmIvUGHRlbtQV6WOKFB5PJ2xR/984DKE/GkjmKbslanCELLH/58iTY+prTGnEw1ZG3M3cUFkmZR1C1ZWNJUAeNWxesHqNo+fNhdLjCcMaeZwDLo6IUhat9AsGQoVdw7PeH6zZqhopIs52SWRJDe8pCnBMECXbXpQoNWK/F8HylvkI2aMtzfpfldwYGu0CoZmzKkaSXstCQHXAmuBRDEjLQTsRsXz9Np4xi91jANibiV0W2LgW7TSC2ILfdmR3/h9/idUAoPPjlBcgQeSQfwtuTdao6YbEi7hm6ZsUsVjmwXqa5I4xzhtqBvVyRJRGEYlFJHXmnoukRRdoiCiyrcfLv+o/FD3lX/mJefCuhigJzOOfKP+YGic/EoItke0m2WRJuvSc0LynmLFn6K/tsH/JX5GclhQfKbf4OzVxnPpX/Opdbwu9k50ZEG3wwjRqgEFpcrNH/I7PCAi7dbDoQBmzpDCDpe/vFnaE7DSJownAwZzB6xu1sQJjlvvrjC9GcIfck9W0PUZI7p6eR9slTXR3gjh9urW3RLI8o3ZHFGGOecnj2gqRPuVu9oRAFvMkYtEpbtDm88RKEj2gXQSxiKSROt0WQVw7Lo3pty9ekX79gZAfLEYecJ+AMNR3xGWCb49mP+53/6E67fvUE3OgYDjYdHI6qiRBuNkHyXwYHH4ZPHWB8c8JOfvOZqviBb76241tdsrncMZ/eobksyCjTJpqxanH6NKVkMxzuGqkPfCyi7AtmoeXtb8/EHh2SLF+zajvS6wSgabE2maxdcX3z17R6CEKHlIi/mS5om5sPhQxzJ4Koz6PKa2tQ4Ozwg6iVUt+DnP/oxV1+HPPrh76OVBWGVs7pIyJMr8A2e3TvBk/dcmY7roNKiCCFff7mkKBQEzSTMwHfGlFHF9cUFQ9ng7PETOrFB24xQBZGT8YibpuQ6jZgoDbZu0szf0AYLssVeeTp2S2W/ZbctkfVDjtwMwy5RxJxNZiJtQzbTLUPRRDxU2Vz9HGFXMLYKjNCgSN5iVwrx9SXDB+eIgsqm/CWbENUXHd22oPV0HDniSNixFTXmz+9otlui5Yo3uwhpeIJtjiikBi8VEdBZFwW2O6TqBChSXF2hkRVydc9F0O7eoCYW578LbevQWA2+3NBkOcNXKdFkgyCv0WanlH9QsJ0JKNNThE1AMtE57Acs/vhnXOoNQidyv49p7DFP7H3fQJeBZWno3pQgSFCahMH4GLkKkGXYRTGm5NJVLZKg0woKvRIw9hzeRRnuyGazzkF0cOoOY2ggtXsUWlz1SK3INszxJYGBN0A3fGynJ6gFTNFAVBpcy2HsWFRRCqiU6wzDV5HLjqovoe2RVYMwTFBGB9jWvqx69fKS89N7rMc5L1YL4nWL0W0YTWcUvsKzj2aM79uE4TWK4TL43mMOlIZff/oJujjCHPnINpS6yMMf3kfUG+Tne0/EHCmY9oBy11D1Km7qYAxlhExlMj2gUQ2yqyVVk3L25BhPk+naivsnR4g5XO+G1IRgaci1QysarG6+whT3IdB9qyV1dIxdgyi5WO6EsSwwX/QoloppeZiazuVXz2kSlXp4Sp2UBEuFT35tRr2bIz4S8HZDTFtDUCVI9i3sM1djYgkYYkuXB3S9gpLnzOwj6FTkuuIH5+cIuoAxGtL0YBVzxFoiz3fQQG912HWFTkeYvmPYlsDes01UkVmkkJgahuuhHHWM+pqrVU2UVdSayIllUMcV2SLASGLKKkZQVOqmQiLDcA+R9ZibzQalySiLvzhx63dCKVh5jZTXFM0db75+zc1mSX9XYMgim3rDwVCiWy0wHz5lWUWYbwWeV1/hzXw+efSMRBQoqgsGgwltA5YMI3+vFFQBnh3/On2Q8Pn2FZOpyp+mPY/nDu9kCd/saXYuP/lfv+Jd6/DDXCaWTG70GPFkx3az5UV4g56foxyHvIiOiHZ/yu1iP41Y1kfIcoFWZYi1w+T8iMt1imIoSELDR89+i9LsiAqFt58lTAyZt6/esU1iBtNT2lXHVHYZGgN8OSYIrpCKPSqzkzwsT+ao00jziEUGB+dHdH2EkveUbY9l2rRJzW18S1NEaLaJ1Aukgs5wOEIUZVo6yrxB1zy6VmW52mMh/o+vPuU3q4f0Zs+/+uAj7v/+iM9/csVmt6KqM/76v//vkOQiL25/yr2TZ6BldE2IWAq4vodllryYbzk5dFgtXrJIN/zv/9sffru+mBQ445pT7yFxvWN6OqOROw6mU0RRQ3XGWGObbB5iqzmuW/MvrtbYkoWkWpwOR/i9y6dpzCquYLNC0WwmD/b/euZNaQYWB+b32eQGlTpgeXdBmQmErY7ayNxcXRGUPbMDnTaGpq1R6pSv/izhowePOJbOSP05ry6+ZN4YfKDvk4C9umC+iREWYyylR08NmlzDSwWKWkTtWsqqp0okdusFUdDhzGyaMkejwCkzdL2lXl3heia7aMV6FaB1e8U2tj0kx8DOEsR4zXqZkko5SVlwu3M5nByy+fwVVZEgNBHWsMBXQAxDgr7n0DFo6wgh25GFW4K0YyLviWJ+kXwnlMJU7Ulvt9xuW4qwxQgLEteguNkgli6dtWBweA+hqDA2DZGxZDic0mYCSQOraE2Z21TCDjoB3ZawtP1ll+uU0jtjbZhsw0/56vlrvm8+4isGNOgQeMTlLT/073MYZ7wYO1SvXzBLGhLHYlneIek9GQKK/pfw/DXdH3RoZ6f7Q4QRbSORxTtkS0JtTZLlglxRsBUYOCa2PCKVM0qhYbe+pSpDxkObtmtJ8zXD4RG7MMQaNnS9RrDenyETeizBoLVaZFHEkFuqsKYpeiRBpqoayGUkRaaqShR9SC9L0PbUtYWiTukVAdoesajRVdBEg+69ROPN2zecn0yR9I6m2hDLI3ZFTikWGAOTxnAxLYUD90OGR8cIwpZBaLFTZAi3vNukXFx9RTo3aagI0xsuPrv+dn3dGWGJHoamI0/HNIWFLLXYuourDag9k2xe0dkevQS2fcihWdG1LaLa0uCxTnY4sk8v11zlt1ihiKXvrWwp1giKy8C3SN+W5EVA2o3wj4f0vYeklywsH6lq0VqZvmuxnIaD3sUcWBwenhKWKdnrCNEeIXc6+Xtj4ttVhqTniEVEVen4+jGCrSLmDp4OnqrT3uzIS+GbqeFyzEhq0UyVXjKZDQyqNkYsXNquZmbphJVI9B7Wos0FUqNElUSaKqRrUppaQKoNRraO2Cl0bYpGjdw39DlUQUonwEAH2x+glQ2Lm5AwCZBaD639i3M0fyeUQrkTkRQJIQ8RJRFTm1A3EGa3dPWWpFEYjWvefPmSWJEQK4VSMDg4FhCTAr8zyZqArDaZ+hqKlyAbe+ux4x7Hb1do2h2z9jFho/NqYFFudZyz3yBPY6r4C5KjDynWJsf1Q17IVxjTc9YXARLn+PoRsXrDKBkhdBO+2OXs7u3hr3UUIdYqvVJTNS2v5xGerpI1O2RFI1jGOAcVlmWRaSV5nGL4Jo4u0OQ76lpkGy6gb9hVApv1ikp4byJ0olINBTRNp2s1BKGmLEraTseyDMS+RdQVJLHDKi2SDizdICsrNNmgFBWETkS3VOqiQm070kahKPegljKKWW1VlCzlKyWiulqA0tDVKpYz5Gr1AlV3SE2FsAg4n43INY8u3HEdr5jvIuqq4XW0II4DVos70vcSvqou4oyHzNMaWzNQdBg5Z0wOH+LoNpJmsUnW1KrMUDa4WbxDEGTkvoFcwrBldlnL5TJA8Qe0uUxWR2zW+zb5OFEoLtY4E4XKVGnSiq6vUVKN48eH6IrIIBHJXRd56GBdX1PJMV2nIZU2cpbTZAFS32AnJkJdk/X7eNwfeFDJJOsWpJrc7jk9tCiWKp7lYWIxGJl4XU/bLBhKY7bbBUPNRGhEJKkg3m2QmgxTlihFsNuePBX48xCiq2uaXMBxFHrBQZIUqjCmsw3EpEWsGg6cBsmxMTWbfrFmp4NWV0hpA0VDrUKr1eixiWGqZMGeK/MXya/mPvxKfiX/P5FfzX34lfxKfiX/n+Q7ET78p//hf4uUJyiSyMC3qBtom5yy3CBpIg/On3I3X2MoAzo1oqka8k3M2DWQkJEVlbAWyfKaus/QU52oavm7/8N/AsDf+1v/HU1b0AkqcleQCQ0jMSWNdmhlSatK+AOPOFMp6hypr9GGI6SmpopzsrTCOZ7RdD2aplJsCm5WEYau8Q/+4X8BwH/19/8BBzMFWbOxTYFCsFlvVmhqDp2CaTpQFwiSgOs55NGS8cGMchvTmya79QIZEVQZWWuhaRFLgb/61/8DAP6n//E1gZjRNyJpOCdLS1YpVF2Bo4BSFzRtw9GBhGwMKcKYvuuYZzmGKrJIAoS0xfQ0fP8Id6zz/Q9/h6Njn49OvzEgf/M//2ucjo+QFJt3n/0LLO2Y1S7CNxxSLWWkzBD7goKavlSpLp/jjiVaQaXeNiAJzMZDKsEg7gtEc8A2nfMP//t//C+/0d+j7FyC5golVVisF+iWQyP1pNuUsk1wi5Tx8RTRkIjCGFtXaAUNUdVYrhP6MGLXmYw8jVZKGPjnDHyJv/t3/v43e/w3/wuq2pO+qfEGYxaDkvDlCklu2CYXNH3E1FIZDM7YFAFiLrHqco6dGeNW5l1cIHhL6muDM7sijHu8ByV/++/8l9/cpf/6D9nOF6RZhKoLdFmKZUESben6BlPpacUhrmXQdCWiqpDmFVLf0HYiPS2SaiHpOpKoEG9zbHuIMxjxn/3HfxmAv/of/Vucei79as1ta9D1OS+v1ox0Cbf32GUF6lCi76GuZGy3YtobvFxdsulTouUG1bdpEokjX8ZxFbTtLxnzkibC6f1DVBpyOceqZLreRdY0aqFBNgowCnS3JCtCqjimE0SKvkfTVcq2AQlUu0VrO7oGrPcyxpavISsuWZIhdyVG3eBIYLoOUq8jyQK9KjAxbRTDZLtaoSjQdCWSp6G5BoquYpg2fddQZyWa3lOV+5JkWwUI1ZjFaklj95SCCZrANi0wLYv2X3bKqUlHpTfERQNFTlynJMuUzXKLrzQEaYBtTHGsEinde3t3wWt6SeRuU6E2KY3YchkEDDWD2/kKhI66XZOkM1xvSS3ASFKQZJkgrzCqBsHW6POWRN7SNDZfC1+yy/a5F2F4jO7NUCSVj7//u9j+Ma9/+payWKJWLsPeovdbZtoznN5ho8ioNHx1PSe6DBCHLqoHUrDBPj+gVUvcbg8sQmgQxIokEhF6mVAw2ZLjyjab1Q2t0H7TUSpHOEMPqW8oMxX98IiiblANj6qsoAhplAFSZ5AlKW2zT5ZuPvuMse+xEQyy1zsCTee2fs7R8QxdOKMIKwo/Ic48irpCKTWiSKLfSrRGgKG7dPWERpfYzm9YtQL6at9bkcYLRLnAsSsEemyjQuhybLcnynLEtsK1BTQhQdElarGjSCMMQ6dXBEQ6VF0kE2tUSaHqSyTBpkn3j9Zvc8bCgNofYzsZF9ct596QRqkY+Sd8bLqkQkMsmhRljNlniHqDKOY4OwPx2McvKlZaizIZM/J7ov8XQcF3QilcX3zBZHBOXu5YpjkDZ4Q5HNEZJm0Z8s+uviTIa7wqRCvvcL0Bzcgh7Xs6XSLLcsq0xrIVhrKFdWiyDvZowCROOHBBkgPy+BZdMTDHI/pWoopKyqokLxI6LyNNKxRXw9cFyrxncuQg9CJRtCPMYjRZZehY6LrA1bvtt3s8++gQIWyo+ph2EdEJPZ16yIePT7Bdk5cXFyx3V5w6Q6R1xtEnv0Xb5RwdPuKLf/J/05cVTVfg9Bp68g4Tm5PpHqo9LG/ZZjm7VcxYNOgGPmd2SlEmtNyhaD7n9gxhWDCuZaI85S6aYzkj+kqjyDP8DnpVod5BoGs4Rkyv7nsfpNYgLA9RxATKAXdvV/zrv/aUA/s3uNylDE0Po2zZBjFR0pPVKk0as359Q7Zp0QyV3XzL9TrAGqhMZB/h3r5/I95F1HaP3sus+5pEqfE1nyLe0PYlp/cHqKoPHSibHds6Z9cVaHlBY4zIV1uqrqGtK9Zk+COHXMzIN3s25+jA5+JnHc1U4mx2wtAQqIpDytWcA8VDetQjcM6L1wv06SnaoMHtfZ50LmknsPQblEzkeDzjrilxGxfhYH+XLGmLZNeU6Q271RLh8BxHleirnoYeoTXQBzI0JZLQMxiOyfKAVgw5G024jraEeYykWsiNgCbUKGXBdr1PZv7g3n3U2sBQFHxF4INHMnM3QJuMkNwpcttz4PksyoYw3TI6vodki3wYrHn7YoXR3iKGGatgjnzk0WUtE/+XjGQl2O3ohfvkVUsliOzKnjwoGIxUBMtAkaZ4dc062CJ3Mq2u4oyHmJpFV0Yosk8tFyRpBCpIss7qPcBJsVuSSgm+qdNLGgI1Qt3Syx2FUJB2GUXTk4Ylggn0DXHbcnBygKq0tB3UkkZR1piiiKR0SE2H7uzBRY3QcDwbUPUdZZlQlRJ92lGvShrDo+xsNI6J5isapyN/syPME/x2ThkXiHmMLPdohoIkwcD3cKw92rAXQ8qqRGwtrHwAACAASURBVEw3xKaKXRTYXkt7GVGbJr4PZRnjbA3CJKbttvQFhGJD3wrEZY7ZWqhiQ91AXLTUZYrw3oSowaHPy59/hSsL9LbFw75ns73FbacI64jAqVFVAT2qWN+tmQo9z6OcvBOoBJi/+jHJR2es85bm6oLIWvPQPN+foSqgF5m3AWkMiqEiUFC3BfMwp1rqOHrCUB1QhwmtaUJTcJdU6ELOJskxPBVJOABRpGhEDLNAb97jgbwrsM58Gt+mMypW84abOqAUK8KNwChJcIczmt5FW9QklkBDwp0FXjNkMN8i6znJKibtaqJ0hx3svakwvGbi6HRVycgzEKUKfTgij1JM2cR3HXLdpK9yQKDTHLTBELkv2SoputDSaSpFsqFUdZqup662NP17peGyxnMshpsSqdVJ8g2+dY/Z2KI5+IBqXRKVC8hzHN3ELYbUYovWS4xGLc3NmrJaY1Y9+bLAmrR49Xse2y+Q74RSuHfyDdeh4ziUYk+QC/SWgBCvaS0dazohj7bUmUNRS0jYdKJBWdR0cYYqKfStSl3VGIpGkuYY6j588B0ZQwGlKTENgZsoJt60KLpFkWcEaYI2PiSJIk4O79MXGWXT03YFRSWRZxW9Atk2x/cH7OIGUzdw35tM1Cger5ZrlLogyDuKdYClqDRxQ3hbc+Dc48G5xR//o3/GQeOh+D1UMqkII9tEbY5wvQpHMolqAbsW8JT9GeZvr4kNhVKO0e0zzLGN1okMH/uskx2aInO1DdAMhTLICJIUzdLp6NH0HD8zwC1RcUnVCqWFQt+SrPZXoLyLWKdbKtXCKHPyJw9ZvLhEHIootYySXBPLPqeSRdJo5GLGoWfwwaMT3ryds3nXc3dT0dDSVgWl5DK/evPt+mmxxWxsTH2AYYlczTdIUo9nKPTqgCKTUJsGbSqRNx1yWaApFn2rUwag6AOKtqPuC06HE3p6HLmibt8re2oSmeNwbJ+gJSXStMK8WeJmY9RRxEB+yGDqcCmukEZHuDaM39kk24LVaY1xA247RXqqI98MyL0SQdn3DTh9iyiWqBoohs46DFFNA8030ESFTlGJgghR0rAGEzKpotJa2ixFLTuSLqGoJe5WS05PzqnqHMUQkaQ9p+hGNsmClEFtschTiiDn0dRFCGw6UyYoSsR2wnrzmioC7ZMeRzjmdFQxlFWubt9QjabI2ESrL6i9A2pjD9X+RfKdUAqj6RGnxyOQWooyQ6lryiLjeZSgNiYdNhE2b+sdQbxjqA4xsp6RA8NKR2olwvmGkSIzdV22izmOu+9sU7sIqZAwDieEpYxrnHF67BBWMZ8+zygdlzIsEe894arokbsBZdWBX9BGG8o4xBQlTF9BM0DtGzRZp2727aj2gUVKizP0McWKuyrjQJHpNxmS1pHf3XAoPOXf+K3fQ1VVEs/hzZvPyd7ccqqFZPWOzaphIa+5//0TtAOb19s9Hv7P5l+D7zIwfZr8gjefBYj2ALEDQ7e4ThTi1Ya02qF0BUU/x8xVPOkE73BMqa7I6pa1I/Pm+UsszWTQnpJ07zHy1AlDXaVNWpJ+hxLp6ElPkt7yeGRxeHiCWK65i1TGnsbLr2LiZcab8hbHtph88BFvVg3qWKOMrolVAYK9BawFmUJqvxkSk8po9ZZwLdOOdZ5+OKV1xrTrSzgcMRqLqFEHSY7qTTFHQ0QE+jDkdaVimS49DZ/MDskP963NofmEZi7xB6+u+f0nMpviiEnso50MWS5XLEbvsAuR31Yd4m7L+qZEFqfYRs9YLkhcEd05RqwyXtQ6XebzzNkrnTTdoisi2sgiylsqVWVXxnSeQFcraKLBoqxRNR2/VjDFIZJeMRh6VNEcT+ww0pzxkwNkqUY0ZUx9yDrchyia5xIHcG3M+FA3KbQrpExFHPpI2xxnl/Lyy0t2QsrUNZGSnJG3ZOY+ZWDd49PbmMXN53yerzl58AGZJJHlv2Rj4/KqIC1zVLUmTlPyMiML5kTtiK5vuYhjVrmI3Kvs4h7VaWmQkEVowpKhpVFuEgIVStvGV2Q0873kUy3QizJdVLJrOhBrXl/MkTyNZuDQqRZ1LHCXibRZhtwJaPScHI6Jk4pOEyiKkqpIqKUNqiAiCzJFt88prDbXlLucohGYWjaK4+JpPptlg9va6LZMvEl4ODhnk6zZLW/QlnNUoScMEzQKGrGkdafkbYuU17TveTtBEhMXAvLjA7oeOkGnFywaOUZMKko5hyBkEywZHA/oVxsqd8D12xcskxVG2zInxPEdutqgU3uKN0uCco+kcw2TkyObm9jCzFsenH/CzWrNIN3wJqmJwhX3Bjr1XQEVKLLMRuho0oTrIEQbeXg6pI5FIqiYiATvEYZqpoysSdy/9wlpskLqciLZQvQd5HlA2+SEUYs9qLAOjpH7gsgRGJom7tEQsVZZU+BIHo4xxFNFBDchWewTviNTYF3D2dDg4tpgejanORpjWQrDmc2BYZC/uWNw2JJscxTzHD/d8cJo8PspWArlSUn5acvEcVlZOam575KUFQVVBknWCOSaouwQVPAMk50gESUFqaQjKx6V4ZCXPdtNRS1odLXJ2JCh1lhvrjkYjjHlFt9sud3t+T+SOiNvNCQqNk1Jm5ac+S5ZuuPui1tiGSzRoG4EyqDGW66ZyC4n9zzoK6o4IGt6dG1GWqfUdsaxuGek/kXynVAKshISLwoaOSdJW2RdwhFHdMsG+hqr1ogKg8VtjSLep+kcHEvCaTKkvMRVbR4eKjzwDGhSfE+mfg+aeqCDO/KIG7BtnagSKPxToqzEvD+jFnyiRU2Ya8iaQtfF2EXHyxoaWaFpN0ykgofnH3PiWchFy+buU+Rk/6BGqsXdQUsXQyEbDM9PCV9uGSojsss5p6dPsDqFtz96wd3VC4yxhl3lNH2GNdTRFZE3xYLp6SGRHmIMNLz3Rn3ZJtSiztfXKxypYGIJ1GGC2Ky5b54iLAMM9ZbjcxfXaTBm99kVFZU8JuvBHfZotc7ruuGmTxlIOcf+A1ZX+8y66RyxKRxORy5+NWO5zXn88Zg4qFl98YrtK49XZcL92ZgqLxAfPabSE66uXiDpPZKWYs98JMUgLWesmpyPzx/ygj8DYHI4pZQsOl1gnRRYjsjD+wp1GVNlYFgmzVDCkG18TeQla9SqI0l14sUlg7MzelmmU3JC+Yq8kHh273tEu72V3e06nJmEGTqs6zu28yGNu2PqjhkX99CDCud7H2DXF/yaInP1OuR5vsSZzNDcKbJywC6bs1Dn5O9S7KnBWt+73kejHlVQ6VQBMYWslShSic9/ukB0BgiaRSrPyLcwagfkNFSVzYu7iImkca+RMToJw53R9gpyu4Uqx2njb/couhZHSsnaa5LcoDUU5lXKcTemaVX8JOLm7nOKWKLNQ2ZPf8jYPEPbSqx2EYtdxz99e8lKMFDViofeCaH/S1Z9EIQWWUkhT3kgaIiyQ6c5dIqBNr3PFxcqA3eAud0g0jJWTaaawvFghqBpHBstelagdg1CL1PHIZr/3oj1XkATC1ZxiTo+QmtlwtaCwYhNZCNYBrXh4fcO9sGYxWJBS8R8E+CY5xj2kL5cEm9gW1bobYUtS/BemBbkK3RVoBYgUxRc36UR+28YfWt49fw1VSSxWoWkhcSobzAdDdeb4vOOKI45//hDyoGAYhpsswhrtK8MvH37nETbMnz0EYqskEjXlDcRfdvgn43RbIMD9wxbymnLBqNVaYY2FSIDb8KWW3xzxH2zQw0bsu1X7NYrqnAPf61NeHzvE7b1juzzG+rdkuMnB5jdGMcN6YUhy9s18zBEagTC2yVi3fHy4oKjowmarXH4wMGajZidDkibluF7mPsoEdgIHfFNAH3DuV3T1wF1VXHfG6MMfIL5Fe9e/gzFNLCaDMewyAyJoFaxzs5Qu4gwSREVC6UqiJoM0dpTygWGghfYNGzZuCUHkwCvFtA0jTa44PYm5J5S4RwsqBc1A79guNjgPBugjCyiKGNRSgy6iO1RhdpDstj/aEsSkCSBiySmFR1oZZJWokKh7lykzicRBoSSQJ7J5HVJkpQIaYQ48RjZIkXZ4mxS7JFHkRUcex7JaP8UjxybOI0oJZVEUNEGDlXSwuEpkvIaW9Zw1gPWfYNsaGwzjcPWZRUVfPqjH/Ojz99yVxYEbsFI76nKAn20T1r/IvlOKIXHT0/xy7fIosKxMkOTHYKg41w/o8x1bNdmenBEpDiUVYQzGlOtrpkZJcejGXVfIpgNrpXTSRE/fbclF/ZHG9yz2NxllKLL7a1M3atMvAeUvYah2SQhZLsO2Ttkc9WgNzpCJfDw8D5SkSF0Qx5M7mNRsX33M9S+wVNLJGWPI0iJefrsHnGgU+1WiKKO9egx1cUWx3dJ5ld0UcVX/+cLxocDik3F8Ucz3COT0p8gSWA/nFDUOUW8xJrohNHi2/VvbndMnh3jjGqG6oQ2h8T6kn/l9BC5ztDGPXqsM7Fm9JaHJIhUdcibTUIUbKlFMOo1vXnCsq/pc497uoLs7d17MxNI0ozjiUfuNYzvjRm4PtVBxMGBRHjV8/T4CN+f8eXrd7z54prh0wMO3Q595DM2h7x78ZJxEZOlDdtVyUZ5b4ahbnPv/AMKZ4hnj5Fu/wSzr/j+oyFvf/QF1evXvPjJax589CFBGNMYNoGicVnklG2M7hq8vluyrHqW65yZKOL3IXGwd73LHu5u35LYG548OCGbS2yVgGdyQmomTGdXxM+fI1YVWXmNPv4dnv5gxuvrJYL2GfPlkjxoGZgCDzhnYcV8/6O/zD/68/+cbBk6PpZ+Rq2aSBEYtUyiTZCcGVHfE3Y+t3mJoWiMbJdDXUbvU1wxI0sDnswGGJZJkcfcd6dky4xo8frbMwiWjDod8PNPv2Ls2jxy73EtHuNJNYfDIa6ssnx+xcSf4boGauUgdQZ/+uKGN5FLYlc8fvZrfHUbYk5CUqUhK/Ye4S+S74RSKKSUqhcwMDn1NWzFZm1KqIWEoI3oUnDKlqfHz6i6Hb0hIOstQr/m8cmA7bpj0/aUtUiVKbS9RtXuXUpR7kirks1uya4bYyoyCDbbrEVWJizmFySFgOdY6EpPX4QYYk96cUXfVoi9zI8ubxn5oKxTJgOZPuk5PtyXJD86PqAhQRFKMEBsKpRDjy6WiTYdYR4TlS3iwGKnFbiKQafLVF3GcHKCNRzzebMmDFZonohjd1jO3lMYCAYTRUbPdTbJLUYOVbBmMTD4zbMjBgcDfvYnX9IaBpPKQBjY1FFL01uMDJ+tGmBpA1RR4laxUAcrVNXHlffxcleJxOuIB6MDZGNNeKeghyHNuOXmJsKzjvji9i0fOD3NSKHSTe6WEfrpMW5TkO+u6PWMNtlhOjMufrzj43/zhD+fc5Vsa0b3LIJWI9lG+FFDFN9AuYOmwJw6rNKAwWLFbrvBnh3Q9hWqOkLWI9LLt8xUB+1kxsOsQ3ccJoqLNv/y2zOYosPDs5omb3HSgmIg80wyEdqfflOt2oVogsWyveD+wSmtccF1odAqArpZMxUknj5ySFhzM7+mDRzu0n0FpWpiktYm6Q1EacDIkil1HVucojkjwrs5guthDEQcTUCXE4zWREkKVGyCLOFmHjNzJeRMYVdkyGWA1OwVm+5WaLmCYYvoUsiu3RKvdhityIFc4os+zx4/JK5NlkWEYJywW+4ory/48uYVygReXX1OXDmcToeMHAvT/SVDNGZ5xoAhqjMljteYxpSB5eM5Dsttjt/lnCsuqpfimj6L9QbjcES6ekNxs2Z9e0NMi6aYLOKcWB3TZPvMfX6zZLVK2BQjGsdB1G02YUpQdcTLC+4ur7H9KUKWU+Y72tU1kgaBECNXHUUIeTxHYIAhmZi6zUD1cM29FRzcd7mLLiglaOwRq5uYJxPQEptNfMPnlyvCiwV9LWIWLpMnY+zhiMHJEUl9hTNw6buSQW/inCqUxYLoPayFIxjYQoWmVBjGgGUcoOsKQRKSjGfoiozsH6FLNsumYar3RNcliuLhyDqWpiDqMusg5MyTiMshQ9+iid/jbDAHlFnG3Tai2mnUtsu4/BIhnhK1MXEzYCtaLJKIuNXIJy7hXc7RyTNmXUbuSXz9xR9jomE1Ehg9PvsKjWGrZMGO0dCj6E2kUuRunVEGJacnR3SCQaNOaMwTkk1Gn5nI2RK8IZLk4AgiR8MJdSExnh1SNBbWwQF9tP9OvlaQbjPSJkZezZk8kHGle6xvV5xEKcvFGyT1gMXNBU4mMz46xtRbZiciRb7mtoAitRmqGl19iyNXXH69zx3F2zlVYzGYHRFUPf7Up9JtHiunBFmJrblMpgfYlYhMjN4pDKlQxBzfNlkHAVUT0XUWgiDS1jJ1JVO/hyOQioJlcYsgZVzVAk4QcTyRKfSefBej+DayA3rnUKcVrh6ziUokT+HeUOOfBDmVKCFaBTNfY1ffcqjuuT9+kXwnlILmD7n5uqO2Kp5/vsKsNhwOD8iQSCtAEinuPueugK4p2c4XjKcOcrtDbSskV8KanbC7m7OqZeqTp3TvXcYHv/6ETbei3Xi8DRK+ur5FD1rQLLo+R64apHDBj198xmq5ZWxViILIwdERhqFhKy5dL3Cz3DFQVLZRSOvWHPl7T8EeCHSdwmAk8PzFBbpmEqm3jD+aYtgHfHzzhIvZiOt3l6iugPtAJM7n2AIMHonEYoFRG0T1EluxSdcNi+2+utFJImZRUc7vOD87Z3KkslNnKJJAX+Zcb2O02TmuNmQg5FS7EKdreTAbc6v2fH39jmWYYfXfAIDkKuPw8TmXn7/kvU3QDJ+7yzm66jLtQxpLIAo21JlI0ogIxjGr1Ya2yxiJLscfj/j0j97yOgFflfjtHzxkE2WoSsHv/f5jDo735B5lEJMlP8NcfIVqynRij5RLLG9uMG5uUSyfk8PvocsGHz/+XaqyJEhEno0NYkPhSDGolxseaiXZ56+5u8r53l/791i8V0GJGx/11MLQfdLFBYNkw+dXlwyMU9SxgzK9wxdqdPmYzeoFue8w38WUJ7+DcQSDeUeyvqA/m7I0h+zWJfnlT/Z3VZawdYs2yzl2jni5zQjWKYNHx7RCz0PPINu9RZEdBLnFUmTyYANCT5t2HBoiYieT3GYIokLdeoj9lkrcV1A2uwvybMvwRGG4MxFGLvcmMSo5ljRg1zS8fbejbgOOzz/g5vrHaIJOfRjTjEt+6+E5m2RO3Cf0u1ccqBJS8UtG8X5zOee+/RHB/I447fFcl0JsWe5i8qzBO5xys9yw62IOh0MMX6PMLrA9BUMVsXyLL9/coNtDclknClbU3Xukp6WA7x6QVg7VOkITW6Qmpa5LRH+Abok8OD8k02scW2fq6BR5wfGRhq1ayJKIbt7jzbuX1HWB4zgMhx59vXe9NxcrFDvj7u0SVR5iqwrLxTsqFyRjwPjhIRfBin6nsK0LEs1DUaAydAYTWMdrFElEU3oqOkxvgPNeSXIy8jGtCWUdIasBbWfR9C6mfkicdCiVSJbBpR0ipxWODUEJYVETLCqu7gKCZMHZcEyxTVDahijOSKr3LmOUMRp47Ko151OX7XzOLkrIw5JpI7MMn7PYNDybTXj+4hXWocLV6wI5SlDICIMbziYiaRET9+/wigGqOfx2/RoZvYCeFbY6Yxd3bKIAUzbRPJ/14o7VVuXm5orf+97HNK5EX7cUiklStTTxnCwssc+OuLqdU+5MlLZE0vaIw6GdM4/W2J2AnBl0whRTrNDdIT9P31EmHaVmImUR9x4/ZR7VSOYYyxXJbjXm6w3HsxFS61HPr3GKIVtpH48rtNiqyevrJa/LBUn3DfW+7D6gTjOiIsYYHaBlCponYIkC25sbNEXBOb6PKumIUs3Li+ecDDwOhxK66rGd7x+t0MuUVIzEAdrYR9EltrdLDE3lh5PHfPbZc7ZiRtdbLL7+nGEl4E8MVFdnpKncmDJOLaGpOrYvYbsKXbs3ML9IvhNKYbmsWdS3OC1o1ohrUWWY5khCgurJxKtb4izhXRlyu32N2jaMvAJrPSCyLKRaoLZtlIlLV4sIRos72rtLq2TN63VCoT/AOlEwJZnD2ZSrxYaJV4Eh0TQXnI0bGsvEdAwwXLKkQxkcQROjG2vsTYs/cXDFnNZQccbvuca7gMtXr5GLFsfW6E2NdaOykkSOJxr+vzbjyVMZafWKrkz5S3/l36XfXlOka35+/SVBXtKFAbaYktsGdZnie3v+xIc/+LdxBYv65f9F9idzUinl+as5v/HDX6fVPuD2LqZVVjwcPiM2BP703SVSajOIdlxfvkVV/h/23uTXtmxL7/qtul5r18Wp77lVFC+KzHyRlTOdlhLLEgLRoEmHBh2gR9NIuAMWcscCRIJAFhKi4Qa1bKWEbUxmkk+Zz/mqiLg3bnnOuafadbH2qmsakY4dtF6KVjzxxh8wlqbmXN8c8xvfGEOio4ywCplwE1OqLslUQMj3zPoiqem4KaYksQqv8Q7GqFsboRWwunxGW5BR2g2b+T0fHnR4OjgiHX+d7bi4eMmdf0sdW3StDj1vTBqvaKI9WaoNf4XFu9ccbJcI6QVOliG+eYvjusxna3bLBYfeOe2zcw4Pf5efPv9j5i9ykmbN7dsfM2+ZZLLGUz8km6QoXp/N9ZT4cq8GvF/B4+MzgvCC6uxXGYsCcSmwzkrGkoc1PIRijhv3SQ6hj8duUFJNSyIt5Ff/lU8IVjKr9AucsxHC1RWb+31EaMoKNzdXxK5LWYk4ikSCQHnzY8b9HlU8Z7m+QBJ1do3KRsgg3lJIIltZwkvWtDQ47LbRqgwEKBOJjrs/rx1XwaqO0boeOi3MGFadit0y5mfJDfHI5mY3ZSe+gqbk9Pt/C4qU5c07pGOX7bsJmlAw7hxgHlkE4YTi+heMU3BdlyjTIEtxdI1it0WSVRpLpW2LyI2Gncssr3f01BZpFjLot2krHjtBJCpMGkEjzWqMtk4uNNTJtzohizKuXFBqBS1HQXNbaE3F4LxPk4SYqkKqy1RRSljlSOiUO59MspGLgDyLiPOazsjBEbbUWYmtWRjungg87PTx6y2LbY3pDAiSmr5mUjUSPc+jJqP1qMvTJzLryZJp+Ibt5p4y2hDUNdtoRTnboLc7eIlDEt6j2943/ufTkFquOeseMPNvqBODYeuQKMrwdmvibYHVaoiiCMvS6cYbdg0E24Yj2yHaqUy2M27yhK4u0m8foNsDJHH/Hq87GrbRoLVHGKKJbB5AfsGT0RnbwzMuXt5wezMhVla0XAPdssjKhDjcEFsZRtqhKCPSWKTbc+geDEn1PbBFokS6C+m0DG4uLnAtm65qkC+XtASHweAAqYRBYCKtrzAXPp7YQ5uHPOkO2W4apEbl9eoFk1DDODNY72Sab03SyiydrbamiNs40oL5bUrr0yfYtz73q5SRPaDYVrw3NMhri/BQwzvP+PMfLGg0h+Vf3BEIIZnkk8l97lOd6v5bpLWpI2U1Yh0hCyKrrKKKBSyrYZbMyfMEt31IEiQk2RRDNTCknI7j4qopQlxSpA22brDbLIi3Eq5doxv7NZTziPk6xCk6SMIaXcpJIovaMDGcDmUzo2o3ZIFAKTZYByabhcwsKFi/vkbvdBn2LFTTJgxCyFTmwi9YN2fB8gjjFZolsy4Kxo8NVFVnMd+wI8Gxe1SqgltatPoDihS20YxVXKIQE4k5md7CcnLmqy2NbuFnezFIv9XGcxOyPMCyDPI6ZfRQJ29kvnp1xSQI0c0Rippz0G4QlC1uq81ue0OxK5GrGEkUUJyctuN9nQJM5mTbfQ5+lawBlSbc4jcRi22G8+EZSVIyW96SbK7wbJOtKAA1E3HO4MBgOYnoCS4qJZJg4jY6abiDpoXOPiz+2fU1h1aH7/dj/FSkpxsMpSUdoUs8neJJMmnks726YSbUvLp/RVGK9OSaw8PHmC7oaUUaChy2XTQh5eKLG9JvVZMKyilX8YLk2ZIHR116xi3pbEM3nFHkMZ+cPcIrfRa3PuHO55/8+H9GGnrYToA0DWiigPb4ELG4Z5HmqK0+k8U+bVsKHsbwiHebz8kVGG42jFUJuX3AZHLHJDSpiVjFFYNsRhoVpPMbvvrqBedPHpLLBddvbzGVmrLzgDqvuZ4VaMODb75RmSKaNGL8vkv6ps3L8jmtm9esFxrvmV3ubt7g9se86Z4hByl+y0R747Lrv0bhmMS6xlFF9LzLbRlS6SXWQcH2y6/9d5oBcbUjlzI0SaORZBpFJLNWdCQdJasY9kUKT2Tp6yi2woEosU3WiElGnsyYJTHj4Rmtgz5OuUIvY0RxTzSWpY6rKPjvAhqlZLkK+bXf/R4PBr/G/bOfkbybYldrslqg8Uz+/NUb3h+PGB68Tzx9zWF/hKArmNoBhrViPD6gJX8rNfxz7DsBCprdRotK8iLAtGWqumaxW+LaCo2ooBsmkqERHcsUmkiQpXRPBuRRQ5lrpNsU3dQoihyZEkWq8Q72ZcdVIaOkIAs5r2+/IC9EBDlF0FVcS0XGxrXhcrPh0cP3ubi9Y7X28TwBRTQQ0hRLVTFUjfj6DVKZcvRkRKe738jb2Q5/EyHnEmbX5qv1Pc1uyzafsdhldCUdTZNg67NbZ2hiidDEJMuI3tkp02VBVpS4SkG8WyFIFsq33vv+9o6xUXP08GO6R1vqacg8MxA6beK7LaJUc/RhnzDWmU1f8f0HD5kEKw4li2Gr5IurkNLPkIWC4eCcxlF5PSlZNfv+hiIWmyrGPeuhewYSDnZ3g5AaJHkKvoEst9ltbrF6PdqDCblQcPNmy3y24oOHHyP3e0hpRVznLAPYZvvQfp0n5I7MyHiEZensnn9FKueIWo3SOsJVFRyxzc1kSZJXSFKJYdYcdx8BCXEiozqgtR6g2yMyo8ddmSIV+1swr7cI6zbqoODP3nyJyJrNrKA6sUm0ikBJiFb3eO9/Sl2VKELMCBjoKAAAIABJREFU2kjYPg8Zvi+j+CHv5jt0WcbpPOYuyRDb+z6Wpq2iBQ26kbEtUuLVDt3ycHIFua1R5Q11skWUwVEa0rRmmc5QZAlNFxFlgUzS6NsZZRzTcWua6P9dwRgJOo0g0267BGnI0t+w3pZ4Ix/JFNFPW/RWBavlNatlyeMPHxFN5iSqQUrOs5evcCyPh+95MK2YVAH5tyZn/zz7ToDCoa6TGA5RUyA7IoahkyYq69ktvW6X1SZCzGpKxyaIcwKxQrNa5HKKvyzIbRnbdPGjiDApsDoetbBXcK3WGzTdoIx8PEEiNhPC6J5o2TB++B66qFCVKVWVksVrbEtkkyzwBJe2JZLJFT2noNwV5Mk9tqzgqKek4Z6AiqdbgqAi3yWcj0/ojlrspu/IkYmlkCYyGA4VBp0ejuUzW98iyB61ohIoOWdPnjD76kv8psTcldRGRLTaD7QxOh30lkMRlPTHPfD6XP7khzTrKZgqiuDQHx/RUQRUIUGvQ2qpzcCxybdTRhpEhoONxvj0QzZyhTT7AsvZv2XVJMHRHIw6J5pVxGnDQaoTNBG7IMbVYxablNzUMQjwRgOC6Rq3sAhkl0qS2dwvuFtlqAcDVuGast5zFnmvi7ZrmH7+BR1NITddgtxHXTboArjuAYkjImcyO6ZUYo3sDZFYEO5qimSLSpuWd4JxfsZEs9ioJq65j6i2ccDspEdzE3Dc1ZguugjNCnvWBUcn0w8ZHfepYhlb1AmzkgyLohSJpZBybXOQZdxKMzpnv409ekP5bL/PhiozGPQIBQFPE9mFO1RNJK9UXHNE3QjEcYxh6GjS15Ot6kZCqGostSZXROSuhFzE5MmGXRHiKSLFt86rp/QJCo0D94BwtyB7pDDQHFqOwbwScPoHLMMcr9tn3Ktwui6SYJOs7jENk7SYswmmRMUIr17ANCYN9z0nfp59J0Bhut5BkRMufQaDMYVuoSk2sS5xVzc0RULP67BJAsKy5I0/Q7JLbF1hfH6CIBvEYYMi1Wga7MIUSdwr9e7uFxwdjqnlgtmzLxiPBgyHA4KsZjNbIes2i9kUEwV/dUfX0DhoycTBDYZscWB7lHGE7Uq0jg+I8xh/l1Bs97zF6nbGu9uUdbRh1XiImsHgqcs0iEnWDesy4vMf3dAanFJFGV++eolpj5A0gwfTOY2ioaoDdu8mOFKJf3HHpNpHClary6Q0ibsWst6mChpEu43a9ujKBU1cIRUzZFHA6YlM7lJUKUHtdMn9PrJQ0beG1HXKn128JbdkcqmDpOyfWV9Nr+iLI8a9Ll1NxdElOsE5NCvcLOPV53/Kj66umcfv+OTRGaPRKbsu2JicykMW91Ou301ZNTM+PnrIWNMJqn0hTpS4LIKYD7zvE2s5727uKaMaMVfYLZ6hXPyY4fFjkEtcXWQR7lBlEyyIUo0kyxGNhnmwwZ31yMc2J2ef0Oh7YCs3P2RblIQHLmXZULamrOOaswcRY+0Bo2OPXRKjWFti30c3ezRmxqefuKS7G2YjBX9dYOctXr/5CdHbNZmwVxuWZQtFqcluJ1SqwYPjE2RVJ40FyiLDUVvodYWqOchNheRnSEVDW1IRg4xe22btryn8iIaKqmqT6gINe1AQ8WjqmrtlyN31GqlomJsJmx/eoaQSUaTyxcsbonXJMp7w8E1C92yEZts0WUHPbhPJIlpScvflDacHFW3vF4xoLCUXRRQxzBZCbWIaA6SyYhGsCOsGRTMI8posTagFAc900HUdU1NJUwEMhUqRaPQaodZxNQvb2pdOz/0Ezd6RhRGOoCGX4GQ1UpoxnS1ZlaAUCYpiIUY1ZktF1YA8QohkZKuma9gkcYRQZtiFjIFEku5bsE9f39Bp9egKp8S7FNEokFMbtxZIRRFDdhh7LagVgjjCDGqEwufJ2EPXGqJIYKCXhJSIGx+jqRkP9ynJYX9ELcEqrYmrgIaKldwwkgUMz6XsyWwVj16RI8oasbRkm3voSomv1eRpRrJOkYSEQBAINypq+wjN2DPrxs5GFmMMTaJ3/Cldz6W+mBJFGXci+OuUwjZwhS67QOPFzT11uWS7TZANk8lki64WHAyfMjKGtIdHHLrdb/w/fHrG6q7PXbKkCGIEr0XVVGhdA08/RJAUIkehSUV2gsx9WZJnGQ+7Q7LDElU8ZrNdMT54j9I9QNaPaNAJ9P0+BNclypMdiiiwdTKSeUa/Y9GWFDInoklFeo1DLYnMpIKBGXM48riZt6nvfQSzoRRkqrzkYatme9JiVX/Iv5xeIUkOcpniqQ5xWSKEKqIpU5cldqkQxStiP0WwGhRdRqsqijhmJdaYhYqtKZi1QhRNKRFIFAFTtJGE/V6X4QxyD112kRqF5XaKnTgIakm1cUnUKzxRgK5FspAx+5D6WwQ5xtUMHMPBkUCMM6y+huCWnMi/YAVRvh9ycOhQmxJBrVAvS1xdQpNtuo5JmkXM1ztkAUTRwLEUTOOYRJCo6xpFsKhVCcGSEYUIV+mSNXvkLZuCMM5RFJ2H5w/IVJd4EpIkKYOyoS9m2K7GchGj2gapX1M3OobaQc9VmlnMTqoxVBNdcilymN4FbML9LTt8YCPnFe5Yo8osZNfEaFR2RYmR6uRKTT+vsOoVSZbxya99QrDKcF2JvKgoqoTtqy/4oO+RNAGimeNo+zr+pmtRrWa8nU/I8w1lXFP79+w2Bj8UZcJbn94nT5ErAVuTkUQRUU/54d2Eza3Pm5eXuJJKZX2dMrSMLp2hjOCOvvmG5XRJmpBVvMHfvSW9r4lnIYm/QddMZpHM0GnhG0NW6y1SU2E7H2KYBZPdgs7oCK9/QtVxebfTeL6eog/3+/DVrCDJSsoiI0kX6E3JNvYZWTJBkzOf3iJuB8iKRlqnCLaComi8rDXWocJ6eYE1POdt4XKgd+gMjlHMLu639BzjkzZqqWL5DXZfoO2coKg6sqbz2MtR1B45Cnml8qsPj5hPf0S20jgxWqQPRnhVyWUhEBcTNo2F0Y85m5t8/pf+b+4XaEpNU4AqGUhlQ7GOkMSv51gKSciR6aHIFZpgsSgj9FafrR8iyRppkFClFUJho+QlqquzmefUxR7YPjp3COoARxzw8eExtXzAqmlYbzf0hwaVpPKqqDGbNe1G4tGjPkqd0rgKYhkyGjTk6xix3Sa3NpwMHE4P9h2wfp59J0BhvppgSBIVDdvMJ5VCIlVCUQt0OacpBDzTYj1P0SwFQSm5Ws5RNJk4klAVn8CvQIamzLnJM7JvyUZX9zvIQTA0REVFEEQ8Q6CMQvI8pypKtHaBLAtkcUYpCOTFjiQGP3JQhQLHkKAKqcQIJTXZzCLi3b65x1lXpS6HqLpNmnewBxZ6W0ZRSnStw65YI+cZVS6SFjLCtkBzXBxV52bxElsRkE2FTbxivbnHMQQseZ/yPLBUlqVB6i8phYKmylkoNXKVkac1OArxzAdiyq6MWVbUok7LdJE9lbTbR5YNzJ6D2ugIqoRu2WjiXoAVr0BxKtAaYn9N5Bfc32ekSkK2zdgIOUqucPHqOfM45aw7wtMzHNvjTIsQhYesEgWCBrMjUS01KPecglLXzJMlsi6jaBqpX5O3O/hqTT4Y0R30MGuDbbBg0O3ipzl9R6PSh1T+AqRD1HaX4/MhtdhBEEQCrUHO9hkOW2+R9yR6aobs69QtFSmRaSSd+cuI6sGMeBoyKAzeHXexcw9Bf4een5O0Y/wXGUpzTe2JHGMj0bAt91LwNBdJsxRDdxBlGcs0ECSROE0RRQFN0ei3dTTRJqobeoVFXmT0Ox6y7VJEG1S5oa4KVL2mLCTyRiKt9xeA4zXooQLUxGaNlGdYwoxSVzF0CVUQca2CCpvKhen2Na32ABofK0vRNZVYqRHTDbE8JzEyjNZfvUryl8Ngfmm/tP+f2C+HwfzSfmm/tP9P9p14Pvy3/+Hfo3U6oggE3OEhZd+Dcku6XbKJd7x+/jndjsNJr4usKRRNwMIvEK0Ow7bFcrnh7j6gLGr6Lah20NIb/v2/8/Wglr/7X/3XvLrfkmzWVA1sliuO7BFXsyXvjVxkwwXF4O7FiiBdo2c66dZnOG6TVyUqBXJ/iBHvqOYRHJ+CF/PqzT1//Mf/HQD/zh/8H/QPzpBUAbGJyFc7Uqkh304J1hNaYoyhCARVipxmdMd9TK9DFhfI3tdzDSxBp3JdAsmiTCNCSeQP/rXfAuB//B/+cyRVJdwUbNMaoa5Q5T4f/sqYlxchliIhijIroaEMdshKwoF6zhezC7ImQNd0kiqi3x4jiQHbSYBQbNGHOv/Bv/23Afjsb/9TqrBAMiqa3MdQYoa9PopYYGkK45FNnOVUYYSkJUyXAWIuIdQlUVmTBAXbcoPkDNlOtmQ52O45P/6DfwuA/+bv/yMup88IV1tMzaCsYgwlQ6gUgmqFikVdb3BbPWRFxXZsmkzjanaLhkKSedTBmqzt0K4z3s0zWr0TXMvk7/0X/y4A/9M//F3CEl6/vmKotLl7lxOEAZEosS7W5POKUd8ijQE9x2kds13nzGavEcM+xpmAZDWMHRkxFeh4OZKz4z/+u1+/+f/Lf/APefPuDTQxs3mCKaw5PP2QuBRomYdIlkR4fc86lEnyOaLkcGgV6F4HKonO4weYuYNbhSRJxfaBSLxMef78hn/wn/57APxn/9Hf5+16xSk2gitDsMY2uwRFTleJ0EZ9vvxigi+oqBmcfvoB9XpJHt5hyqc0QYjWt8lFkXp5DY3Ky9W3enH+HPtOgMKzy2vEyZaBe0R29Rq/pRIlBt0jDUPsspGPWMcyz1/OUbUuRsdkcjeHasHAjGiLAbuqRO6MkFsem1dfItn7F8kXtxVRrZLHKq6ucno8Ql/c89HAYObf4GYaxdrgfDRApEMtHlGt1myiDcEyQGh1KAODsAlI2lAXU776v97QPd9LeD99/5DR01MqIWX10xfslIDbz/+I6dVr1i8+Rx85CJqElVXEq3turS5Oz0FwVc7e/5t43iHt0zFiR0RtdcilDm/v9rnlOBAJ4yvmQgdlpeOrGY78jps/yai1kvkq5v0Pe/jlDMOXWElwZf05UtbC0kWaqOao85AiLbifZEjbKVf5De3bvbx2ZNzSP2ojqBmL3RpSkHZfYtsFappSZh0sr8ApM6R0g5ykFI1EnVX0tA4zR6WvNEhazl1ecrmYc3m1L2G/uv4xy7whK3KWecGg67Aiw5VSilwAKcSsDTbvLmm0ipkOiqCS+SAPXTwHLuIZSbShUBtGBzalnrLK98VEP7yQEEyNm/CcuyrgflqjFjJH/b8G/j294z6KXHATvOCp+T3mkw33/i3H1u9T9EOwdCqz5HKZ8n5HpGW4lOoC/pJqXN+9ZfbiFZlQY5Y6nWGPfHVBLSisrp4hlxb+LqFdOzz68AnDwxOk2uXaf0OmFDjrnEK8ZVvN2RUVm+cqV+sVhrhXHDZNi0d9hRfzKY6vYlZD0nRLmNVMwhxz/Y6otFluJrRQCd4+A7lH3zqlKmFtGQjpDm/g0NKPccdt1s/cv/L/+J0ABbvdglpgVRbUVYNhWkjnYzbLjPnsiuOWgWR2+NE848RsoUsifavEdHsY5YJ6E7IKbPqyhmYabGqLsboXtFCIaILNLo6I1+9wNQO7DHF0BU9QUSsdy6x51O0Q+PdkUUJSLFglS5AEVFXG7WYswobLK5/+40N2eYQw36c9h4cdbFshCGYITcR2ecdscsv2+i2p76MPOiSrhPurS6gSSrbIPEJniKEptG2Vh48ekKvQyBKVmFG09+SQnwV8/m7GmdlG9tq0ZJ3Yn3AXveXR0MOUYl683ZA1Me2WRaPo3F2nnDoCsuGRrdbkuxWu0yFf+rybBai6gNLbM/emtkEtMmRV48iREA1YNQJio2LIOppWs7hfUNVL7KpEKVPWiYZhqximipbJHB54lLXCbpqgCjtsxeBfaiYzYYslCwTNjl0Y0j5+hG65BHVJ8GpJy6qIRIFNO6RXtzEUEbOl05gaoqsjiRKt8yFOkKPUBWnWkCQ+/nIvLrp88YZJDoLxmL4wYtG8xrovKIrXuLiAimG3sE8qDj55wvaf/oCxfkT/GLaZw+WbGaUlU6kaF3lIVLiMuvu07WrmQ+3Q1iL0JkWSBJpQ4WjgkaYbqpGOlW9xNIOeJGJHKffLO7bRGiEzaP06ZIJDbWQkaYSa12hKQ5jvn/uLbEKeO6SbhMiosbWQaluRlQayKbMMZdaTS1RDIFcslsUOSAhDg+ORx82biPG4Is9c3hUC/XcrxOqvRCcA3xFQuJ1s+ZXf+hUK0SVtTDRP4/V6yrsXCRsE5mqfdrfF/TZEcAzGHYVRu83rFy84PR7jmD0+EiqaVcGL52tyQeMLf58uLMJ74lDg7eU7Tg8FltUtx8MBRrHi1zSTVAgYVwrvP9Qo4kPe3M4YP1D5F36fzLNZLBPuljectg1eTBOkYMfw4RF5vJfw2lpMc/UTyskdymSNmYaMSpVB9xBvoPL68or1xYKBd0xSbNDPPiUTPK6fxQw+KEjTOyqljds1UK0pmeKQVnv5bpH36dg+S1XHny45kUrUkcKHLZG/uHuLppZsZtdIpoOqDhjoMp8dHXCsWZSiyaJ7ROVfcF+GHD0dU+kRbWcM3yKaH4gJjpmDoSNGArugRt8kiEaCqQS8+mqGqAh89OmnGIbMl88vcTWH3WTK5O5LFvMl2eP3kFyDdBdyoBfoTsXNX/pXViHeQZsaE9Nt4UsVciVRSAU7Q8DtDDC7OVqoE9ciu7QhTmbUWQd3t2FhDEkkGb0FijukuUkQIp+2sQeFJj1nqLd5tryn0CTO2qdE9g4bh9/+7Pu89+GY1csbPkwPKdSU3/vN73M2dLicrrhfBQRRxV/MbhiJMpmscOFHnJj7uQ9vrp5xNYlolzrHj1uYuUxbbPPXvVPiX+0Sb+6ZVQ2dVocH3TbrsmEnK7zfGaGPPWphRVmUzCubu8WUx08/5dX9hvBbisPz1gc0dclP5Aq7ydk2Fo65Qam2iKaIfqSxKtq0uxpx7rMTFQamy4O+zS4N6I4tslRiYS4YFmO2ggjqLxgobIWKH331BrU14vD9c6S8YFnMkM6PMNcZN9GUofaQpvoZyA5ZbhI5Fn6mobgtsnBNS9AxRh5VVTD76gLP3R+UaltSq9BzKzY3d1TpCsOoaTYLvvc7H9MZdvBqBSPPWIkhT0873L56xlGvS+m6tKU21/cp6S7mvfMjsqbDzfQnFNleJaZpCT0VZHTCNEDd1UhJQRlskTwVQdLR7K8HmBSJzIllsYwKXENFTENqxaQRCoK0YjzoY5sSs/v9Rq7zGdsw5u7+BleOmbktjmST2XyNJ8fImsl1UjPoSDx6VPPsy8+xNzME7yGm28Vre2wLi27ks7xfYVKQbBu0faBAJSYcWWPiOsfodFHTHfeWiCzZkKckhUpa5iz9hnK+JPFzouIdqmLiiB6pJzD2XGIaEqvEznWCcg9sobRELipERUMUAkzrgLvNCq2tIRgmqemyk2YUmkwjKKTxlqKRsOUNM0HDUULqUsSo2jhaBdoay+6gfatwTFUkYvGWeJPT+t4ZcW1gJjL2RyZuX6eocrT2iMfHB0TRlixZo+c1bjPkYr1h3vY4TStW0ZxToYthGxgPjr/x3+kVpDsPOfWJwoTElBDEBOox3TLC1gUCUupgh5qVDPQUtRuhDj8mrEWMdo84nVD6EUr/hFIpsDoV+WbP+cc3E8xBl7YVstk2WKKIbEfcxRUfPW4hpi7tj0wOXJWdLPLqn9+gtWzernfIcx/9qY6tawjqGLWqCPwCt7sHtp9n3wlQ6A0/4Gp7w0Eas77bEDg2SjaC8SlVT2SUj/mT53/Bk/MxyfqeL+cevbNDAtvgB7czHvZ03EGHxXKC0JVJeiZlvg/58mxCtE5xhQpJGXA6MjjRVUrZZX57R/r2nneaysOjAe+WOR88HqMONf7ZbMJhS0JSa7r4NLJIEer40ZyLizdY3l5eu1zuyEKdrSSitDT6Us3124asZTErTZrdilHvIS2ljXnUZr2YYwgW2zxjexmjjAwuw68YPx0w0TRGRkav3v9QGRZKlNOUMs7pI7a3M+TnMzQ9Ra58eg8SToQ1vVbD+mbC+2cZjrzg/stXbJZdHgw2eKVF4miouxb3sc58e0HH3cuQv7x6h1aL2D0XaTdHUlUMBe4ma7qdHo6qczB6zLKsySKXKCxA0lEVmypJeKS3Wb9+Q+fogGYdEmcS+rcGp2Zxg6/FHP3GGf7dip8sFySaxDprKCWbbWyS6GNaiky1W6EbHrXZR1BrPLnhvHfE+nZFFOyQoiFiqfLkkcntch8Vqm2DcHnPR4cedeGxlgqSpqLVdfnDi3/M34g/wOgdcnN5h2ZZfP+3z3kXyMzDFzQnFe99LuIeDfh8XjIa93HEDf5kf4v7X60JtxGKPEITKv7Wbz5BwcJ//YaTB10W8YqH3QNuNzFWW8cqVewkYxtEDDo6yaLm85evcHpHFJrI5EfPWK5l7PZeli/YOdl2RcuCUgxoZJE3N1+iVAqLWc2dHrJJahJBots1+fBffQxbFXYliSviaSXh/A5d0Sg3Io58RJDuS+R/nn0nQCH2V5wdddENBT+MmJYZfmHB/QTvwTFZ6fJ49BFFveA+2OGd6Dx7fUGebTjRPuZqMccbSLx8vaYllCgtFflbo8QaJWexSsmLLe+fnCC5CYLYIIrw4vmXUApIRp/Rw1+naW34crEjS3yWfk0/rdnNVxThhN3OoawUVrsN1tDg0LN5+Zex8aeHHjfXCbvXd4hhim6C1uxIwpCsSum1XOyuhRU5DFptJHeHZR7z+v4eJS+wnZyYmO1UYI5GoBlo+v4GTAyJQIezrk5bzTDbKZuywXCHWPU7zMphNIrwSLDbMpbURatctAcu26mBrbXJVRF/ktPpGIi6wTTskhf7J9DAEiiSFfOLOY3jIWOhLlOksELTG9pCTbVc0j44RmnJvL2skXQNU7XQchlLqhgfHyFaGnVisFgWxPL+sPdsHd0ckEQ6vtlH29wiN6BLMS+KilG/T+MLCG0Bw1AIthWClOEWOoYqMl1fswlmdGOBWm8YaDID2+b+7b6xqlWCZh8wS/tY/RFBccN1lFDfTfieY1O3Kw67No3XMB7DtNmwnW3RpRuyukY8kplsa4rgjuEjnZ/84AVq/+Qb/ztNZl7JtG/f4D06I9MUTC1lOl2RvpizWe2oK5dM0Lmd7mgJDfrxEEnt8qA34KZ+hduCrGpwGpfnjUojFUjGvneGHeQEIwUjEzhw+uzKnJ6rs822CEJJW8swlTbNWGZouFj5FrUd4gwNLt7qiJuKo56DplgIpNyvIkR+wQbM0sh0h238KOF6syaUZKrqHsEbYUQGy6VMf2ARZRIfPxqheRY/+tFzHjxsUygBO6nPZinhtlXm0wllnOIpexIwjmNyPUIoKjRtR52IzOySlpMz/ZmPYuqkiymLVALX5fpyjWu6aLbGNMmoq5LSqOhoJYUf0BVC3mUlprZXTSpGi/huwSZMKMuQni/Sbh1C3AAlcuuAUdtDWrSRei2K3Qa/byBWHdwjk1VQIvZstkKJU0UsyoRsu9+egfQEX0iptgnLJqZteBgskYsIo9WlnUt0eio3/iX1UqPzwGIy2/DJ+e/wpN3lzc7h4vINWd4jkmq6qUR30MYW9tkHtZQIplNUTceSdYI8J1us0fMUL5Cp0x0JO9qRg6SZ9OQWpWLQrw0UCdLwmn6nTdFEpE6XKg+5rPagI8gSVpzz1XbJNirpWCrOsUlaScT+AtfNuA9uuL2WODt5hKDEuGKO5yiU6YbF/JZkHTL2+pRpRArkuxqp2K/h7jbDaQ+RLHh0ppNddrkV3rBJIO9ETFfXeKMzxq2AHWOm0wtmeYxCzeBQ5s/uBDpig9H+AD9REHQdLd/fsjoFRbNhoxd4RcLLTYicphiByKrKiESVeBfSH6kkPQF/veTj848JYgEGEpvlnNNWl//z+i0HtkpUB8gtF6+1V37OIxXztsDwBojSKzxJofXx+1yv7hmdDgiFnJfNEm+t4ZzpjOwBUp4iS0tMfYNZ2bhNhZqKmNKQlVGS/KIRjerjJwTF5ddFSIqMwZZNtON7Hwyw8g3+2y+ZXTX8xqiLZrs0acNvyDl6mHL4tEGoYnaTP0UrNJ4eHTBZLHAP9g1DEVRcQUEfxdjqEWIRoaGz24oIR6cMnFOc0Qf0fvuv4QyO+N/+k7/DQJGww1fcX9cMPn6fR08ldlnJ3fUzRj2N4zCn2u7Dyi//6H+l5pi7y9dsdBllV5LulmR1xsPjDzgdHiLHGXRbyHXA93/395nFEqJ9TV5kLPMtTlWy3CX0KBgftFj4b77x3z//kO3lHdkYTro5Vr/hQ3octCq2dc0sveHRow7dsuZn0xntwzaDwSmir9L+6JT7P5yzSw/RUKh8gS92OxapzpPOvkFJvlmj5jluZfNer+Lt8zd05zndaEff39FXIfYF7t5m2H2NIyOnnFaMx3+dvikzXW4QrhI6wwa5gSIsSZ/94Bv/724nbPsB85sNRWODsmO3yekcDTlxK6LdHYdWF2XYoQw3jNQS17C5/OlPUbt9rONH3F3/CUs3olVZUNu8uXpO+a1in2KnI5UBw2OPOLjn9z874ezjD9nYOXJtc/S9zwirKeHIZNnUXN015I1BdrJBW7T49LMHbC9M7MpnsZxilmfYfR34usHtu+0O1VQ46h6jux6bMCdujXErgZFa4MldHE1Aco7Yqg6rlsWnbQ87uOenzzc4g4fI/QWHsUY5nfM3z57y7OIV0v39N2u4WF1jeg2HeY5h6xyPFR57Kg+lLotwRVtIefroBMwOsXhD8+o1iqXjFm1+R+ywyDe0jQ5CuOR6Dau7iKmxr634efadAAXd1um1xixvvqQ76BBvJAZnY7QqQPLn6FmCp5U87T+lKgyOTwf89G0H0xVfFG4sAAAgAElEQVTxJwsODZGruzWipqHIAkVTwLeLZNyH2I7A8u4ePS0grpkEEY2s8+lHH2EKHWxvSCyWzFcb5IFHUSRsNwGeU6OJDrfBBrVloWst6qykkVQEd59bltOCJNvSslrMl1uMfo/HZslmNcQaPWQ2f8ZQaqEMx6x2W5q7HPXBIcNzkWx+j5ZklIlAUuUktYIWFlSTfX/DbDtllS048ix6LZdlVHLwQMd0K5JtD6G5YFfYLNcbPGFIEDWciB6J3MWUOvS9LcvbFbZ+jKQ0HAw6aImNI+65l1ookAXQ05p+o1G7PfRyQ2zodFptNF3mql4gZjGeH9JpApaFyKG/ptc4WI1KIOzYrBtyK0PIU7Rw36AkURVabg8t9xmoKmlWIDU54eSOQh2y3IUgJ9iuyS6cIaou/v0NmVzTbDdYwwMs4YCOmxHM1qRCgVY2+OF+DZtnl1QPCh5330OZOcy8LboFaRyzEEq4uUDXRbRzkyT06T5U2GZthIuar7IpriTRcWOEWia6N6jbp1TWfg3v2Sf4TY2iKFS6C2aXYD3ls9/4HmqqkJZzprMr5FyDVCLZ+rx4fQXiGkt2mRc74rwmkioUycBWMoZum6jcp5/vZhmjKGDw4SHdPKJqSvJlRmPbKFOJzUimyJZIoYTZFihNmaGSIYsBSqtPHFTYSYxniFxmCY3ik233a/h59p0AhXe7km4Wc+iNGCc3hGZE0z2EoCKPVH795EM+eP8xg9jn0/eOaFvQ+Tf+dfx4wZ8svsAPAn7v/WOW4Yyr139C6+AEmm+16CorgtsdtpJTz3U82aE0Z7iGzT/6Zz9iePaA1rnKP/7vL/ns08dcVQ0DWefJyfvkaUW0jHn0+JyXP/kBqgHXd0uOhkcY3hE/448BePHP/xecD/5N2k+eIG6f4Qcy/dLAcDoo4YwPPzhnO/cp7l7TPRrT72XkcUAu1PiWTe/0e/zff/5PaKQWqnBKPF9zdHj+zRpGWp/3nv4eX775Aqo2ulByMduw2+ZoxyKG9oRGuWHY7jFLYyZfvaN9INAZfkDiB3x4+IBWKrKObN5+viBSE5ImodXe/1CyvyRPT3BaXf7of/+Kvp5zXE6wbitEFSxX4mi54Xe7D6jcLtPFHUItoaY/okpcjm2Lt7MpcZTS++Q3qYUVj8+O+NPrr9V0SZniGTVHnRFNLTK2TrhZT7nPCiRFQFNkXk4qEv+Wli2h70IO+gphHuD2ByjxBZ/9ioOTO+SHHcJAJMwUiuDymzV89Dd+DXGyRQw1Wkca201GURv01Hd89tEJLySJxIG7Zc3l5pp2oKD0Gi6DNalcEd6+It20mG1KlGrBA1nGnO1/KDmLMYqGgZvT8Q5xBZV2d8huHiDZER1Txld2TO58HlY52ljgVXKJtXMp1Rv6g1+lin3OujGlKXD5Zk3r0RA53hOytVZTCkMGB4fU8R3NKuKOhKD7FtHX2JKQJG36fYlwssW/jNj1ZKzoksPihMVUJZElrh2XwhUYDM+Y/GzPu/w8+06Agn8fEJ6uGZkSwXzGSBVoFwGfX4n83mcfcffFDG/pcPbeAS0txL+aEucpz68/B6/maUfhh2/ekNzOMNoWjdbh+vrqG/+CUHHQ0bm8mDNzJZQddDstjO2c/skJetuhezLAy3rMtgJ5bBEZFbkWs1tm5MQwK6g2NWkWYo4sFpuSTNs3QRHKhNZgQDAt2NynmGOZWCiopzOiZMe59zHzl284GJ0DW56/usawZmT2A8xSpnl3TccWMSWPJnyBECSo7re6CLdUqm1BtApJ9AVKu+F6MWHXg/Fgh1q4LIoGcVujmCYjUyKs2jxVVKqWylevUq7mFaddC6WdYUcBqmpRN/tvHPeH5IHFxo+YTdbkXhtLSHFUkYyaUbtPcfEO/cCnkC2Wt1vanR5SX0cpE5I0o91SeTDscZnMoa4R1X0VZjkpCLo548ceg+6IJk7pd0WczYRAKqnkivODmnQn0zVNst2M5fWWtlLhhjtyQycqah6fPyJqVIpqRSVWiN4+KrR1DWP4gJm4Qq9rWl6bl+kzfuujT3idu9hqgCLopFuB21XG+UePud5mJHbKQWbwIlRBdLHMGq0okI2Ao7Mz+MO/PKuFT9s84OF5j0SRUJsEBQfBS/8f9t7j15YsS+/7hXcnThxv7rn22Xwv86WpqizXVBtJpNCUSGggCBA40KAnGjYogAONNBYH+g80EShBEASRIAWihVY7squ7qisr7cvnr7/3eBfehwbJzpMjVUGAgCyo1jiwN2LHjm+vvda3vgW5TFYo1HpHHIspN1fPqauHCEmTS2H9lZbD1TlBMUWvRAzLp6XBYrWkkHZ7KTRDVEmijKFZKngrDfeopJ73GLc2GFmfbDnl1fqGoSVyKpm0BYnOWUksrogyEVl7gFGZZJLGws1JxV+zQGOVqzx//ZqL24BhDYw04+rLCzqj3+Pi5ZRcUpAFm830jKjmEJPz8icfcffdE+xyQyHX+fAgJ7t3n3mZ8MXPLnC9nTs22QiIFIg9h3e7Ku/2Djl/9SWBkPCP/t7v4boR6t6QQt/jk1dTlMWEvb0Os/GYO8MTruYTVuM1zXs9/ubPFlSGwLKc09nulu/9t5r8yZ/+H6SxRa1ocfP5Cx5++JjecZub2YLTz26R5T6yaBO5Jj1dYSOqzK/f0Lt7j+uFx48f/JiLmyuqQEDv6gxaO/ru2eWEs48/552ejGGLJK7H4dv3sZsRiLekQUDouiTLJX6o88GjR/juClcUGf/VS27WJyiOxcT1aO3tId6sOTWm9Nvdr+do9AzOXy6ZjbdkXknatLDbj+lJUC6W2HmXwTu/y5/ePifeXIJpoYkig4bEdOPiXa2IhiecjdcEqoY9krnz6Aj++KtmKuvglmyu0uk0UKVrDh88JAhU8oZGuo5Y6g56w2G5CPjBk3tE1SOmV2P06pbJKqTVMOmYGW8NVc5XIqLT49lkwZsvd6nblTtGbtQwZjJ/+idvMOLP+d5/9h4//eg18b0jTg4PuFo9x3+2wg8Evlx+Qlbr8vP/bUIxk6lZPZRyxYkq8qM793j9LESpf7PpTxc1d5lXNUZ1h31TwGzE2K0ezlEdf37FMG/zhZDz5//qJ/B6yve/FzJLIz48ep9oNUWqCfRP7nJ1PmNzPGfflNgsdgFZd2HS/tGHrCKfRG8hDHzkWKRSt9Stu9Tf11m+0jH1EktW+NHDQ5pZwZ9/+UeIXsndgwE5KoVWUFgy0nTDyvgGIeWX2LcCFFRbpvANDDfh+Mke/vmEm3KOFOqslIJ7vQNWpKhbizc6rNcF8tBhJUfEhYStmhzsP+H06iWr1xds8pwi2mkd3CzXOGLG0X4NQ1d4M7/AMAxWbsp2syapgDQjllIsoaKm6whlyeN7j3m702Kv7vPqOiDPNWyrhjnosP3450y+EVlf+y7uNGKZHkKe0VNa1Ib3cdScAIE4Vhl2bfSGzsV6yWLmkyo2izRmuxWYeTOka5n5i0uGrYyb1Kev7sQ2B02Bab3EtnscdYZUwobMW1K1TLxJziIpUVs96g2HdjdnqlTctY741z+9pYlFpngUkootlVTzkJW7QtFy9J1kA5FQsRBylkFOkWTsxQVBZpPEHjdBTPO4IE0N1nODUKxQxRCvzJjNNoimwY0tM48zIstivvU5yQ2KbxxQqeSQlg18QaZum+hhhJD4aKLIvPAwlx79ThfNSVhMZogq9GsJwVqGyZpOW2N7dsEb0cBdAWmPNC5I4l2HKLXXwL30EGSFDBnbyrg4den+4DFzMQetojMtqO8fIHx5C75EKzVpxA20+w9pahrp5Zyjfg/fd1HFFLo7b8evoGUr7DdrPLk3Ypll6MoekRBi3Ai8niRUlsLQqKEd2piRz3oxpm87WGqCbRZkao3n51ekE5+TA5FcskjN3beu2U2Wq1smjTZtKaE7uktj9pJQLViuN1hrnfKhQxpWFHGCkLv4koC8aSAg4WhNzpcpTcOmKA3StYdY7t7hl9m3AhROX33Ef/z+kETQWYclZr3DA2eAM7TIsy7rqwBRu2H/3gGJBNM0pHx0j2U4RlQFoirh5y8/J0x9hKFNsSyZCbtFPrq/j7e+QYtERNtia0LqGBh6zjqSaPZGONWQcJpRVvCwN0LYzCmzlG0uEPkmdueIyXLC8OgtZFshl00248uv51D1Dscjm3vNd/n0zRRp+JClWyCqOl9+uaY1aiPpGsvERzo4QvImxLZBszHiw8d3WNcqDKWOHOvcfPwvqR8eEsv7X4+vFRmqrVFJCbaq8NQLacpwYJmURotSEsiLJnIv5FDcJ6kVbEoVd75mulR5p79HeD1j5DQYH8Y4mk3letjDXeT+yeMnxLcz+n2Fq6c+m5bGn2UFXT9D6vfQR8ekTpvl8A5VkvPy/EtUWWD/6F3mC58LX+LwrYe07QaLFz+hanV4/9ED4J8DIAo6PjKCabJdTvl0tuCH90+wM5FHHx6RpSKr+S13yhZiWbDdzggyaDcH3HmnznxeYmcW7puScR4xr5YkucjoaASffFWwdLFd4yYRB4bF9zpHTIU6hSiTvlqTIzA+9xjtHWFPDLR8RG1ZQLPkP3ykkZBxr9fmjeVCPGG1bSHa+0jCzlN4cnKIIoskkcb4pU88arNN1oSv14SmidNtEcdr4oHD2/sPcSdb8tWYNBMJ4jlu+y5hqJGHG/adQ9z0lm0QE/g7YJOFlFNvRX0ZMVY09r1L2o0KTXfZb40QFJ19vU44m5OFGtk6xagEPvjx91GMLVb1CKEVUiYKxUZi3LB44PyadZ1WbYuDOz3CrElbTVnFlySrhNLycDcBUR4hOS0m/oK0LEnbNSRdJEoFLEklMFzSaYZTykihzDrYELu7dGEplrTqdZQkZhNXhPmWvVoDLxXZfnmGmFgc9AJex1PeGvY4v/I5jS/wpwqGqeBVAQd3H5PoGmt/wpmnkqkNYnEOfBWE6slDfrKck2XX5KVBuzVkNr3lwX6X4f1DKiljGS6p79UoqdgIEbLVxw1jxAIkqUYap7hBhu0cYUoy/e7uGD8+0LhetijKjASfepJTaWtKacjQGeF5M8zUp+U5bJyM9rTEc1OMTYFka6zWa07nY8gCNqmLHlus1A0d7e3dHKMhHysLVFOh/fiQLE24nWzRHu2hCCs+yyqK9YZZorMNRNTmkKK5xzKvU2o2hRWxikqkuoAxsNAa4K53EvKV6ZBkMePzUzbuFXuDAy5qW/qSjNFqgw2fPT+lL8tUjRZZJVN3dJavA1bLW+JGk2Q6IzJs1pXNZeQym3lsom9seN+g22ugt1OqoUi1qWjtDbHbdZaf/oyHtcfI0SGXp+f4iLx5/gwpPufx++8xVjJePH9FrZUw33rkhcVRzWKwv2sXoDs99CqCtcpFHnJwZ0R85VGTSlTZQp4umCQRVfiMjlFiDzLcsMNW0tgEBfosxLRVgskc96jB2drjoLmPmHyjilGGIhLRG3vI6RJPF6hpx+SygiBaOGWJlon4tkXdBN/zqOkirG4ovC5nwRgvDpHrDudhgb+SEeo7r/aX2bcCFCwFtq7Lu+/e4fbmBtcNEbWKzeQZsrTHcNBF3teYbTScmkypqChmSXwdoT+qQ6oit02qTGfLNVkRo+g7v9U0BwzaKtJ8zez0lFIymASXLLdT+rrG9s0LToYNBkSE7oTLYIUuSQh2gzebBWrg04siVK0B0TlSlTI6PGF2m3/VRh3YLGc4WcR4PKeU72GVBY9aGsOuiW0NmeUSYjVCCRcoNZmo3SKMUoooZjq7Jt5siJICP13x3h2FgVWyHV99/Q6qkHGvVfKL8zXnRYaBiiEaBF6EKJeMnAbPrmZEsUexPCXstIl9aLV1ZKWOKLWQbz3mmwVBXtBqHKKGt6SrXX7c92MsU2WeBxiDIWmsoggqcq9FYbq4qkjmu6SVSrMnEsXHzCORRVXi1HXKvI8vbwmiCNvW0Bp1im/0MCyFjMlszdSpE7hrBEniNNXYGipZWjJoOlTykFWaY6cZSZEwvvX57PktYp4i3uas85SIKbdSyHxWcr4JMNVdDr6uOlTRhmRu89T1qVUdzOMuF0+f8djso1RNbv7yggCb0F0hTF9xevmMVm3AJJHYG4w4m18QeRu6YZ1L08Vxd6lnp5Dodg55enVBKccky5JSyZCafZqbgFfRlvujHkUh8HF6jhEmnPTuchH7TPwVdmnRdSzOowyqjAedQ5rH+4zjHbBZlkakV6yWMYJe0UwTPHOGVIr06iZqd0Cw2mCrNk7XoJ2PWLDmi9sXOEVAYqjkucFivUKNGxhNmdc3v2Y05+eTn3Fv/QDrhUoxf0UpR1y+ueX4uw8Iky1Pg5TBdI+DvsZtEaAUGZurp3w+G/ODg7soAtjKBpkOlVDwYO8tTms7UYksLBhnMfu9DjVB5W63xvLKoxa/4HTyBc1Rk08nG9bSAmVbo9JLRLeFXOhE5ZrLhUirqKjqPbrv/Qhx6/PXf/lz4mEf/p3XZ1EwSz02lY1Rq/irv/xTjFGXV1OP0eguDz/8gM3VBfX6iJvJlOPjAXEeMDubsrydUVoi/mxM35IJkhXbwKO0d6esJ04535xTZDHGfoP1bENj2EJqeDj6HlaeMY67WGnCeHFDstoiDw8xMo1hu8bT0xfcec+iijPKGzid/xUfvPcYcbg7QcabmLNyiaeIDI4k1p9tyfoycXXF/b23iVSFLI0o1hHzeIXdbXNzuaArySwd6L11Qnr9gpplUKgqvpChGztm6Q9/+z8hija8/PwvUHKb1UXERL9ClCS6f3PFwfEdwsogb1YI44LJeoOeZkRVTuWXPPviI8TMZPTuiNRqM5V9aqO7NI578OyrYGZtFRKqIYYkE0kH2AcO7bVDt/ghaVTw2UeXzGY+4c2Wo706kv49vvvOE4a9FrVNjto+watEbL9JXIoo2pojcUdBfufDB3z85mM6/Trz25JVIdNtHXJxc4YcehR5wsau2EoyqgfBas5HNzJ5lbNKQjbHIutOk+GD36E+GpAIa05nW+LhrujqwZ0DPllfcjV9jqioBJryVR3IoqTqtJFkHVfTMbZ1XC3kdrYlatS5850fES2WLIIa88olvIqYiQHyKOXh6PGv/D9+K0CBAAIvY9a4xOjUWF1vSOWCm9mMRt2mKzeZTK5wWhVpPmPz0kPSE7xowfQ2ZHIx4YPRManjolkWF+sbJt7y6+GnroehKXScDkYWcj7PIc8R610O6ifIik4VjpmJW1hfcP/+d0kCEbWIsalR1EO2KwFFDbmZuxSGieo0UKOUv81gt4cnvOt2WNcO+MuPTtFiAdFtE7dStLLi6V//hCgKePfwLuqeSpXoeNs59XaNKAxRK5nJOmabTvlOR+T4fgM939F3U70gNUXufzBgPp0jqSLJ4pQs1sES2aYiYk+imuRY7UMm45i67CMoKV9eXyA5Kio5USkh1USOtXfot216zZ2ac1BU2G0TEpWkDJAbMVuhQVFIXEVbtEoDJWWez9BVGcUyqPVbGGWOZBg0+ja5uc92NuHuvSM6loZt7GpQIsnGdT2uPKijE/k5900TOTf4C++CzssExXSwkj4dUWDuF2hlRRhmGJpMpbepzJR1GKM4bWwJtP07qMNdZ+v9JweI0gitTHgVxsiChRxt2KQGsReixxpHvSbhNsVOW5TZBDURCGceyBayUnGS6Fw5GY1WBzXKyOxd0Vgm+liGg9xpUTZl/M2Sq21GFQv06gZVoHG7nCEbCn7uoVp9LEXg2oPSNBHkNoYnsffuPoJax0LEzzLUZBfbUQOF/VTiNg7w5Rl1V0E9OeZUu6I2WXJtSJipit8rseU202pFdLpCaO7h9G3On39Bhk4sr0E/obFt0h4c/8q/47cCFOpdF7m+ZZt2iNig2BGNxxaHtsygLXPcsOgcfUAcBaxvC2q/3WWqeLwfDvHOX3L8aITn+cS5gG3XePKdfeoblb/8F1+NL9X6VILO07OIo94x9+8I3PziY+609pgnKVUQ4ZUy6qhDFjT553/xjNbRY+S1T6NhkogtPvvJK4YPHhPpxwiyzOGBiNGJWX/+v371DvYeZTVlswjZs3o4j+9z7YbIVQ7SEt0rWFcZp4sblmmJ7G148fJLMjHlw/eeIMUpbcNjv9fkfrOk3dFoWbvctSzHPO62+Sw+p3GvzUBp4ccacajQqny0vsUyGLM2RUytyeFbDntWnXhVklQu8WbOyeEI8iPOrq4w7YKN+5KLyS5LsxqvWS8EvCKj26vROFCJo5K09Mi1LfpeFzETkWUJUZPJkzVxdMq1IHO/tUciyszcJboa8ub8U8LDLurtDhTah99BszqMr8+4nY4xbJNTTSKKS3xjwJtVTLq6pDtf02rqZEKCKfTIMwFTkxn8/d8mSxMGtkZQFcy8it5ohNPdEdWMoYokNlkbMzoLE3U14lWZMYyOMOM50szn88+v+P73fofRccbLTz/EPpIR39J4+fOfI7/20UcO6sLj4UOLV77A9S/++uvxG923aejvs/zkS5RanaQKSLwVJ3tDRC0hUVM27hRVE9kmA3Rdw1vmTL05e84J0bnEXA8RkGnadeLVnK5ziK7vAuPv/r3fwfhZxsXGQ9jK3FqHRJ+ck4s2zy5+gfeRgagI5POAerMGoYta6fT3Lshf60SuxaRcceDrxHs5vpFifyNY+svs2wEKho2UV0CKHkeYPYUs0On3DBpNEbuh0lRlNlGBsmcR5D7NpM6GLXrXJqtcarpDFodsU5guFtRq38iFWSNW24xtdIHoP6c1d9BUlWnkISs1hF7OZD5n0BpRlRWqaiEUFd17D6grfT56+YZFbpNsHaTKQotKTiczomw3hxik5O6auihgHN1FsCG59UgkifXGo99qcZRZrPIMtgVRuEaXVjStQ6LNLWXkIS5cUhTyRp3ZVUiZLb4ev1XCUkp5dNIjkmoELmSRjyibuIKEVAXYdgfCOYoeYfYcCn9JIpZsyyXfvTeksd9nsd5yPylZbDakRgPFKr+eYxvn5HmA0bDI8g2GqhKvL5EEnTCKaeY6iZQiKjlpnqPJObpZUVQFQXTL+uKa2cUZLV1ir2NjxAbBZndXFgSojDrG4AhRtagSCJOMIFuQqjKyUWPlFWiAoXYIhISVVHEkHMNhm7g+QJckPHlDrdalNc3ptA+R+zvX2x3fsN+yCSqTybSJIG+5I35A1G5iZiJci9w5/B65Bq8Kg7QhYg47LJ+fMurcwY0L8s2CCIXnk5A9c021WyLQDOSbkvkqpEjAIWObZdzeznEcFU0uUNU6slAi2BpFaiHU1jzZG1GJbTaVh0mTVFA5XSfIgs78ckyh7uIWRmtAY/iYxq1LrtZJvBw/PGSV3VDlBRfLKVUlUxYZxWKBGyeMNJ3b8h5mraLV03GiO1R9kbvNPeymgyLs8avatwIUfvAffBcvFVhVW4SqQelIDPZNjKqLYItczydsN0s6vQ5vderEQcGZt6VjGZzqJv4y4s12RSQJaIqCrdls3F2N/XxSYPc12kYPvXL5xRdjGuQ06jrrYAuVxmJaclrkzK/mJI0B+yuB9sERV9trek4HqjrjZYEuxygCVLQZ1Eb8bZhuGa5oySsamkzbmKN3VbppQpKEBPEN6oVFBdxv1vGFiPaghvHgLmWakCQ5682Ywx8PMUuVlrXFXcWU1Y5wojYU7kj7FEZOuBTJjIorN2DRt7DDLU5Ppb5vYqcnKPUS11uSWzZlvKLXHHG52BKcnnOw32FSLBm2GxwUGY3+LsNRVT7dpkQugsUKw6kTRzFFskVUU5QsRS5yDEnCrmms5mP292oYikm2jojTlPvfeYRcJkhRRBh4JMtdzKLIFPLS4dEHP+CBG5MIPm44J1EeUS8sMjFEsGsYXskmuGJ9U1DrQIKGbTvUsCjb0Gr8gDiROeqIOO13MBq7O79VHrOISqpyyJFpMd3OuIhc5EhC3qxx9o9Ryxq3N2/Y9yya+4/wX10y2r9LVlmI+hX10sbSUzr3ZfQwJl0+361RorB3GPD61CDNXaxMR63pZI6LUoqkioAQyhQR7DcOefuwhW22UUWRy8UEtfWErtmmKnIaTsE0LHFaNlpz99POTpeU5pAf/u7fJ0ma5Okblm6GvT4iSjZYZUzmFby6XCBVHv32kCz00JQuA+sQxxCwRx1MOUNBI/ILJtIU2JWA/z/Zb/o+/MZ+Y/8/sd/0ffiN/cZ+Y/+v7FtxffijP/w++zWL88DByHpUrWsO7x+RXfeZmzlqBpq0Jo4LHLPJ9fMzupXNukyxe30e6jau9DlasyRwFU6vEtLFmt//n/8UgJ/+7/8FWrdDHIicbWZI8wg0g1hTaGsOa3dNlojURwamWePmbE2aJCiI5IKGosuo2ZbEu6XdMPHnIdfLJU8//4J/9n999Q5/8I9/n3ExoSG2MRNItegrNaJ6n020opJlFvMV2TpHs/ax1SmDe/s0hCZLJaCX6wSFh1mvcb0I0Rp7NGWV//YP/zsA/uF//t+QVxXJ+opau42JzWl8i10CmY3SMTCsOsJcQIhzMiUlO+6hzWKUUma/XrCxa7RshWDjEQQRy7VLI8z5Z//6nwLwP/73/z5qa4/wOuB6PCFF4kHnhFg3kE2byWRGuzvC3brEnofZGxH6HlGpQZZSKRJ6I8MgAT+lkkJk3ecf/5M/AuCf/OH/gCqJ5HmKZhpIeo0szskqF8WqSL2I6WKLYWTU9AbbRCWKPXTToe6o6KJAVghEswDTAqSclinScdr8wX/9VW+Jf/T9fUTLoFYG3EwiRGHLb333P6LWqGNqFVqpMhj22SxWSJpKp72HH/ksiynbeUSJwSr2EJG4uDlnchsxWW7568uvWsz+wX/1XyLbCpIL/nLG2fWGSIBCMnHsAYqtkq4uiEKFpKhRk1O6lo+cKRSNhKrWoN2s0RV1xuMl9ZFBVhaMxyv+xf/yVdXVH/9P/6ejvRwAACAASURBVJTtessmqUjWPqoocrtIUVKNQJHJvIxtkpJXCdW2ophFHHZsnE6LtMx4eNhECNeICcSGQufghGm2k9r/ZfatAIV684dcCRFpPkaM15jaPZp2ky+6BcFawqQky0bcjme0BhqKvccvFhtyX6CZB9iHFY56QBEI7IUbZkKJv7dTRaLsMFsWqKpIdJvg+QJQIAgFxr5DERtohoO7rXBnoEgHKNmaSbAhVQRqsYVthMjaEE0ViR0RO4RG/wT4qmw3kDTkrUVopVitLmZSp9QdvGVESoSaVmhjhbIlIqdrMq2OXOmUeUA9SImpoxzWcDZ1tn2VbpGy1XefxzV77IVXLMgotyJmU+Xe8JBiJVK906CXOrQaFvIg4eVFghMtCDwH19zDGC6YvXyFUY7IhJI0u6amlYiSQ62xi1tUtXuEpU2kLKk5FcgCgVyj4QxQlRbzGqiaQUxO1eizDCpqgsKoaZNEMaWR0mhoZMgYdZ+0iJHK3WYsUoEkX1GhIsk2QZERFgVhEDKod5FtE6eU6dk221LE0CRCWabEoqg08nKOLulQtyGLScI1cSxQaLsg3d69e9RMFVkqabQl+j2NutXBVCoUQaLW7iAZJkKaoOkOdqtN4VU0ggFqZ8vtJmWwf0RDc5BrCu1DDen1Ffw7UGjICsXKRagU8limplUopcRSLojcJbV2l37vIZPEowhNWg2dgenhxikhPlVWYkQByBmmLSIlBcV2TYvdO5xdzTm7niAYA2zboS4IbPw1/npJrhjkYY5ZszEtA11pEss5ZstmWyVUKGhHe9jbNv7miqySCPMIu/0N0aFfYt8KUPi3Lzx6ByPcbYQ2aPKe8z6/kGX8qysuLiQe/qffIXt1RaKIfLRVia9mNM0am3xF5btcxR2uvAkP792jGLZpRQqNdQL8MQCRcUIUbbm6cVmkQ2Q5IU1dxNDioz855+jhY94afYc8SVgWHtNlgVnv0LI8SjFGFSVEo00Y+SS6RENViKNT7sgt/hYURnfuUPvu91jGZ9jLBS9eRtxtaPjanPQmxHULxost+jgmD2T2B+9Q1EVOywQDlYaq0VcH2EOT9wcWGAXMd2Hvh90DnPZ9hE//Dc3qmrKA/f4DIlunlEsEpUDWRHJgcHBELCj0qpBU02kVNeK7bxNzy/KLGUVf4eLcpS+viN7bkVpk5S6L7Yqa9oig75NulrheztJPaB+ExKFO2Nxnq2wweg6T18+oRSmFKRGLASo1fE9HEB0aRY+2qeGWu1SYMjpmfVmQehWDRo1GpwlUqKHJqhBQsxS93mAcZciCibde4JgNqppNvN2CrhMnCraiYjcbvD71sRSLQt21uw8jmbsP7tMwO0zqE/K0RB00KSuJuDJZpxmkFVHeJ5mveXHxbwgKEbVUUFs1lqGJ1XKIK4n9t3/MQZTw+e1Oi6Br1BGadZa3MYN2g99+6x2mfkjnfofp0mUtw80Xz3giNFgVK5KbjHVDomGKNLQu3SylV7OJ3RAlq7h0LxkHFc3mTo7NV98nrG3QxJJClxhfX6EZBaWfEzcbNIcO0qlPmYgkokG4vMa1RebuikFtxIsXN1QIeHmF0K7TEy2U8ldvMPutAIV+q09RNQi4g6DuEWsS9SwmkQdo2g3Ji5eM4xJBUlCSFVeLiqzu0hlo6FHE7WaK1jaZ21usok80v+ZisVuEstSItjpRFhFLJTVRRpEq4sJF7jrkaUG8iZHlAkuxCYIz6nYPwVSZXa+paSJN2aKiYjy+xbAbLGcJqbkTVpWUjHUeUK1USuGIjrhkvlVwljZNXWfsLhG8ENdPITUY3Y1JFhHexqXqDlClhGLqkx+bdEqRZRyRJrvKtobaRxJi9hsjhMAmsQryyQKj2SXQSuJlgekMWIgFQX5DvHEJmSOpKYOOzmw1JmdNbucUbsRIrVH079OTd9LfstynTAOCjkG0CTHqNXLFJYjXiKFN/6hN3VKZJSWUtzRtH7uuIloJQlCjqlREQ2fpxqRJwHKu0Bt+Q8cyFch0G0VRCIuYYLPF9UOSYkuMgJaKNLpt0shDJyfeJKTbKXfuKGhlTCmY+FWAkEmkZUkl16gUk4QdeWloNUg3ISICnqtQlAElDkEYkGclkiig9E3Epoy2KUjPZ6RuySrxEBYZRakQTkvyOKOqJATVJY52JeyRJhImCfg+cWEQqCuamsH32geMrYhnU5fbiYekF4iySbEKcLQmhmpTUxy0dkqwmWDQJA+nHOx3kG5d0mx3AMSFzHYR0uwoUNo4/SHyrEI70fnJ02vsdkn/YES+LlhHEXYzJndvuPf222xvSvIyoe5YXI8XGKWIl8cMrF8zT6FFjdP5l+jauyxOX3Gm3CX2LZz9KVpe0e+H/PXPX7MMM4LonHHewxa2vNtyGDZOSJoCwiTjqeczq9dIzBMCfZcKm595aLaCqtW4vVygGQWSLNFsD5AUlYWYUSyfY2ltgm1Ew2qxDV1sRef4vSdEeUair9Ejna1UUKoaW+o4xi6d1y1UHEfF0u8y+/KaMFS4vLjh6W3CqGtQLbY05TpBdkyWZ5xOCvphgdypI5UR7jxm66jIasVeI6Zl9SjKz78ev93XaNwmyG/VKRYSq/wGp33Ai+cTsmVEvRAxGk0ub19iyPfRJJVwa3N8cMHFZYgfu4RhykDVaIQ6wnsNzHhALu5IM+urG2JTYPpmQnN/RG5MUHotRCFHNkKabYm1+4JRc8NqMqXerCMrCmfjS7xCotm/g5DkuJVAnBRIQszI3qXBlksPU6lTtmrYZcTxAK42sFnobBINxVK4d/cBy9k1JjaoEmw3VGsP1amxSn0ySeRAl/GCDFNW8IIIO9i1iq8XIurE42JxRWdwl9tgzYuLK2arJa1eD6Et8vIXn3Ly3T0uP/6Efi7QbQ1J6w6T7YonD97Gm85Y+BNaK5MKOKjtpPyv/YpCkojfBDy8NyR2U1qNBo2JgiBEaKpFpTRxNwW5v+DAlDk6cXjn+CGa0mC9cFmKNS6DMX5Qcb9/RCl4fPZqx8C9NxyhJjqfvnrB7etfcLdvcV+vuD8a0qlX9GoDwtMN3BWpooI/+rNP0A2NZuNDREEkMU1WiUfv4QMERaLMWtjVNzqm/RL7VmQf5Myh6eY4psrElViFOaIVU14pHD1qE9/tIg1cAiEhySNo+XRUm8/WW/5P9w2X8Za0nmJqCqWwhmc/xSp3RTKVUhCLFl65JkhuyMqv2GSaphGlHpaaU4kiqBVrOaPUCzqdLksxY1UJJB2bSNMJKLFbJl1VYuWuub3dVWJ64gZ/E1Iu4dXNLVEyZ3ExxkoXLF9doyRdxMACdYCltmleaGxezghvNSS3jmXVCFSTQhdZ5m2aRpuYXXWeJvuslA3V7TWb9Zh2KWO7IqORQBFkbIuUM+9jZKOilK6Ji5KAa96EJbPzW8JlgSt9RY+uHzxAc2MW7Zw02LmtmqYwn1yj2imKrZOVPXJZw+5YTMsZ5/Etq/CSs9lnuPGC/ns65gjCdkJqQqZFSLLCsWPTsCzqSslqveOLSEKdMEsptwHR+pbxfI0YliBZYMmYdZHN7TPaZYhjxtjxnLqq0h4eomg15DSko2qUckEpfiWzl4gSlbrzRsIsZLHwySUHVAVBLJmsMmJDYan4rCQB86DF0/mYeZ5jHR2yKVym5ZZVlZHJBisvQKxKqnABsxtUeUc3b5kSLatF7Oyx9lUUqcRfzenpFvfsPqM4YdS2ENKEoaOy35RwFgvSmxXRIsRuCIiCzJuzMRt3yYvzK85uA8JqB86b+ZS8CCndEr1ScOo1iqSiCFOsPGPjzQkMj5vFDamyoN1soNRk5guXUi3YzsfEVUGATrzNSKMNX7zZ7dVf+j/+yk/+f2jWsM7Sa2A0RAZ+jdE7Dl2lwdp/QeDeMH13xLymsVReUA5POJFzbGmD64dIZwtCucXzCn4otRA8H7d/hLLZ3TNbtS5Td4K0jVALBan0UfUGeeIjWxWlkoKdslrcIBcO9YGBbQtEY4/VKqXdHHHY0ikiKLMUxS5p9xtI7DZjlSpU2FwVMZ2ixkZSaaVnFFVMmlWkmUHaGPGw8QGdQ50vnv1LrKmKU9qE55cs2yoP7DrGnSZOw6S02siDHWan6gBRDvHmOqb6itnKoXOQU1c8dDWlZQxYeSqDFhjbOa+HCnq5j3k7ozjQqRU+drpHs3+AL15RXLXp3q3RV3fXB8NuM0osxvlX+pEZPkWyoO40iRdLCrUgE1eM1y9p6jKGeRdPrDBWGVqvTpgt6ddaEKSc3LEpPRXX3WkPqrZJEfnIVYgmCXizGXK9RdOWUQQLSzSYXXyJ2WuAWFLXDTRFJ8OnJCczFXQ5wi0Fokql1WsTiCLdwQ48Iz+lP+gjWgJeviUPSmaBj2pWuEGOoGpsdJ3NcguqQGhkVKmDqmpUbkIcrEndCksQkRSZUMpoajt1quvTNwxHj6iLGpWho1oVPa3Om+tL7jRkcn+N7m9o1zLs5iG2nHCgyzj9BrVWnZdPTwknZ2i1A7Riw8at4ccR+73dd1j7HpLZZtQ/QFMq3r434oufLhAvX+Ktb5HsJo+ePGGRFBQ9ne//3ruMNyGTckyeraiilGVqoaURB8d3SVORzN+Bzi+zbwUoZNucIBGJn57j1ha8+WOP8WOFoC5QWSZv/tWf82pWYB5YWLHHp+uKh08OMaSE11+8Icg/53d5zMuzU7qGiB2ouPHuhIryOcghDbtNEf+Us3VMULloPZWJ4eC+PEXRNP7u7/4eammxkgqmuo9/WCffeNi9gmA5Azvj1V/8nL6dIyKgaLvN2OsfkW5MkqsFUV1HaMHB/T7nr5cIasXBow/QaNHv76MUAffv/0P0xykvPz/ndpZRhDOKVkDrTcGi+YBny4hq/Q1Z7rlHx5EQpwuCFIzqGu/lAUF9xtb30Y9z/OQh1ToG3UGphaivbtFHdfL2fZSspFqOkRYVjVnA2r1l81nA8N1/7+sp3txMODi+R02BlA3PT18R75W8fPqcdiNHOKhAhrffdYhd+Nn2T8jENvS6qMqKJNSZTSZ4kzWDvXfwgjUEO17aYrMlLzwO2zbrxZZwHaIEBUqjjimnIPs8ePx3aLVKgu0L9ptd5ouAyowJkFGVfdw4QnI3hOGMSLWom3XSZMfJaWmHyJmBk1h42oLhqMVHKYxnG4ShilrIpEKENChRU5vPJ2cIskF9q7EJIxbnS2qOiO6pfPC932Kb5fzikx3d3BmMuJ6sKeMl8uyWMYcs1Yx+csO/JaWIDbxSwmjUIPOQRZv6W98nkGwKT2O9dpklJV8srqkN9qlkg9phD9nZ6SlslxlyN2B4VycvepxdzXH2NYRK4fXrNUZS8fa9Ac1jB3fuo/Y09h61+OKza8Krc9bhLf3GHlI+ZLNscHY95ff/we//yv/jtwIULvKCZtvmzF9y/WZBMrqhff0I612TF+M32J1jzIFI6Z2TJwKjwRK5I6J4NTq9Hu3Eo2ipqIGGFpXUH3+H9dnN1+MbpoEh21iNgk8tiU2qUskKerNDuNqw7gw4tBxuwoC+U0Ota3hyzmq+pdEyaFgVVSji5glO08BqtHE3S6Rot+E3XowpFIyDFZNwRXnrEk0FFoGLzYBR7T3OZzmxuofa0GjFpyyDkFyPmfsrSjWhG+mM7Qq5JVLPM1bSN9rGdbuQb7GbDiM54XyqsO3Ouc4LFnXwL8bImknTKkjWCu01rJMZTTFFmKvoikQ3LFltPiVYhKi5iEhIkOy8nUHvAG9+i1Cr0R7VOTrpcWsucHoO49VrEqVJWEyIyyXNloVb6lReRr0DiqkjeQrhdYGuNQhzEU3skKk7cDb7TbbLC6I0JsljNEOhVpMRdZlaTUfPUtz5BYYqYMU+vX0HS6hYSsJXtSi9HvPtknDzkm6jYpnLuGHA1Xa3ToZqkfsFXuHizSbcNqdML6443c54dPIOYgfCZUmtq9Dq1MlFH3eWMH0dIKkOT8Mxbzc76I0GadGgrqcc9HdBwNdX19iNPqohsC0VPr6+YWh3uWoOaJgt9D2dvShHNOqsowrFttDbx3TkHq9fPefjRci1F3MRBhjLMe+dPEBVFapvVJNOooz6VqL3wGE9XrF2A5pCjpfl+JpOrdUiURTqlkGQ5ZS6xn7/kOyT52QD6GzaOHcPyNYipSnQcPbZTn7NJN7rucrTVxMmzQ2C4BII+xw68Pr8c850h1h22TN6tE7uInBJPD4mjGOOeiYPjmrEC5vT5yGdtYm9tw8XZ9jJriS4ikMMQWMdBxg9C9w1vu5zfhNjD+5wt6VTlhDmNdJC43oco9VrHDZbWPUKQVRR6grqRmF/WEeTVcyTD/C83YavBQviXMMaFkhPJyjlgPNqSWYcIO4fcC759N5/B/vAwdlvsnx1SXNPIaDOTeRQ5XMy1WN5M+PJpIOiG4Te9dfjHzh9pCufpVGxinMWecSyLHk9LakfaayKNn3DZ9v1iNIlre4BxmyB3mhTJQmOolGkFY4u8nd+9Fssgjb1dz6kknfFRGJZkcYS3VbG+fUc6gktZ81t7JHbFU+Xr5GkhP22wDRKKYIuV1HB48Ma1zfX4PbQNBtbrrMpdBAj6nJz96HtPknUJNvccLetMo9KQnnFkW7SlWeopszN2ccocpNSXzGZrgi8kGXaxk09hu9mXFx8jqMIdLr3CKMCq3dC/+i7X09x/GCP6fMF5+MVnywTQjnm3bf3eet793gmRqx8j+OjJteJQi010cweg7dGSLMLJNPBjgTESCGX9rg6v2J5+Zqas+MQnNQkzAOLn52+5vX5Gff3n+CnfX68f8R7b3+HSilpiEeswgqz1Hh5eg79+/zZTz5mk6RMBZ+1LbJdZ+CmlPGSZeKhrb7R0CYtePr0DetFTpH7HD28yzR3UFP48O+OkNUG1d4A2iqlXbINPP5m/Antusvdvff49IuPGDabyAVsXn5BmrSJj3dXoF9m34pA4/LFa5TcRXJDmvfvIAgCbzYFV67Pw6bNOkiZlitUw+BB6x/wo0c9usYJU01H93SUvKAWKDh9k4ZQgNXGbu/y40kosQpiKjKGjRNOTvoogo6WlTitBpVuoxoqr2/GzGL//2bvTX5uW4/zvt/q+7X79utPd8+5DS9JkaKoxpYMOAZkDRIICJDYUwEJgmSQQWwoCQLBAw8SwAkS+I8wYgRRnEHiBJAssREl0rz9uaf5ztfuvl19vzKgcPedkQgQ4AphjTdqYa1d71NVbz1VRS2VpIGPIutUTpM4rgk2OYtpjFbp6GmJHO/J/UN4b8Y52ySjiAQaVp+iWeCqJsP2AEfWUTsatS2hHSvYT45Rji4Io4xSgdAoKRrnrCN4s6tIrA5RVHLaPftC/0nXoFZ2NAqHOtHp9kUKoaZ15GO3mqzq7zH45op49ori+BKUT+k8UJhyi0DIuayRqg7SccIn8zcs6zk3tx+Rix9+8Yxt6JElAvOwxuy1kBoOim4gGzpnwwsEs4HkdEntEV5ukyga3eEISRoi1yb+1kfJVFpuk3S+RPZr7j++/kK/Mz5i4A55etJGw6PfqTnvm/SclHR/haqlDMYOopvgNHXaZoWoCqiNitHYxEgyBv0e/ZZB6C1YriZcz2bczA/3Fi/XBZONim/1qcsmSt1iE+7x3sx5cDrATF02mUi2qdhuctxmj2F3hD04oWW12d1t2W18YkFDq1oMWk/odQ8lT0dpMFus8JhT1gXTJON+NeW+KPgkuKLQK+yBi2LV3C6vyLOYxdanVlXW4Z7Ro2dofZsyCVFdBaN3wtvPvk7nrbe+eIayj9jvpuRlxHax5uXla9a7DV6scBOlzNSAP/6rP+GDVy/JVJs/++ie5/MVcZyRLtYYUguiAMcREFDw4xCBL4Hzz5GvRKRwlUXo05rGcYemYHCz9Li8/D6/8fu/z1+mKe9ZLqE85MM3n7A254xLnf/w3/tt/vxqyif/4l/T7Q8Y922enJsYi5ppJiGEX+r9yAKeHT9CdOdE8Z7MUnj++nMKvYX32T0LvyRKZNzWGftVg0dPGuiWw6tggeKlSGZNFUekex+xGxItMzazLavDKAKics5o/B12VY2/3rKOFmhPGryZZPjhG757/Gvk2c3PCDR+yTq9Z6UvieQ9oVNTkdAea1h2l2CTU1Q1WnoAnej1x6ym9wyknOnNj3j67T7ntk17fEqd+9hSn83dJV6yJL5cQT6l8+ghwrZF0cj50cKgax7RHvwedeKjljXqjYfhHkLvclvS6DUIgiVH3SGFLHMbVfzKhcmq3hDLKcOTAbpsEBUevbdGTD6dsl/lnNlPaR/pSBuHKpHIqpBmlTMaH7r/1rMN5WZLZC9ouwJt5XMMq0stQevBiCQPmNRLcl/gfnaHn2WMLt5D81d0Bw9IDZEBbbZLSHQJt/eMyBN5PjuMGtOkLpfyjvsABpZEYCT0Bk8ItQVVrvL2yEEfufxkG5DJFbu4z/Z+wejpOWZs0MgclNmW9H7Hn02u0FoW3/7usy/0i82QI11m0Y0JpyEnrYzRQ4lX6kuy3Rpt3GBRCOyWKyKhpP+syyycop3olEWLaz9FN12e9NY0bRupeMk6XjO0Dp78nUctouCWYp/QVJqolUKXhFUYYT67IDw9R9ltud6ZLCZb1KP30USB8vb7FMuAvthi/dmCxlgg28yhakLyi6+N+0pECnKwJzYE0rDg+sdrLudrlGDMepbj3KyRNR2jqhE+ihH+ZEKrdHh+k8OrFK3poIc2ptmj9t5nFY6xJIn2+SHkU4wGznGbSuqiyC7tcQtDbiNucmIfyAuaqJzrMtouwUhVBnoDM8wxpjHpbYoeK3TaHeKNRBQnJPuYPD6kD82OgqUG2Ah4Ow/FVEhLCdsVaLFjcX9FUe9pdVVkRad1bKPnEmtvTS2LrLx71BgsOeR+u/nZvsPyMOE3qmoatsOmkeI8/Q5b4bcwhBGIDTx5zTpQubqfIJgW9dnbhLbCSq7I1SYZT+j1zvkw2BLnKderHXdvpnw2ecn06kBDDrMMSchRBRu7FNnerXFKkXSdkm1iutYAvdRoTBLcyECPRPr9E8TJnsnzNYkX8+ZyyjYMGPd0ZEunMzzUx4sshjKlcfwI5aRDYzxAEjXu53eElHhpyDaXuIt9NlVNnIpcL7csipRdndIyumCoZJqB5vSIyz3brCYODiSv2fSKyew5+8U1gqFgdDt42whvHdHXG7iWhuJn+G881E1EnuS0mg38zYLcD5hc+3gxxLOU/T7ClnR05+A7Z/GOtbdltfXYlEt6pxqREdB1ZE7efozo5NwuMgrHoWy0CGWHyWLGTz/7lGXyOb7/EZqdc/r2BUU5Q7dDNKegFg45/96b4Xm3zO4/o8pDpHzPavocIVxgxiVGJNNoHKFkLcRpyd96+G2+fvwW484JVSn9bNaF3aOiwT7asdzf4u++5MF+3nn8hX/5/6GEZUTkL9kHTR5//ZxleYfa6LOp16S+yvGqS3bqEl97yK0jdvsW1s09VmLTCd/j4fkpTWCWRKjVS+TZQ4r8YCjhqmC2XVMlM5ZeQmLkFIHI0GlwNV0iqzqdhswFFq7hEN0XBELCu/ZTXu1nZP6OTK5xtB7b4hVtU0dt6mjFgelWZA0m+ymafEzsKtSrHWngEyQ1rZMHfDCf8kRt09j4iNs1PTfno2rP1WqBpLVp9xV0u0OqW2wsk3ZVcM/hwH7+p39JHcmIvR3GscmgpbHrPkIp5twvHCKtQk17jNw2t9aU8tWIlzcmj797TDnTqUdDWsuQa19AVBp0+jnJKqNOD8zPtPApagVXF1jdz5juppy0HpB6HmGScHHcR8orouuM1tAkf76m0zzlg083BHFGr6dT5QpUNW3NJUlrVOMQsZW1SuooLOodSiTiuD0yOSZt9XjhBz9jOKYZaa7QaDdQLIhlB701Yr5PCcWE2/sVZ4MWsSBSbkEpDVTj4ACEtk2liJh1irf1sBsqaQFCmFEuFihNm7pnYboax+0TetWOYmfAMsbLakzbJttIzL17hrLBvbfiV9XvfKH/8pMJseWxDrY8/to5ulWj+CFuB4bDDlVWcZ8s6NoSf/6v/2/8WmIky0SINM5cjCylNuBkfIpap8i6RF0W5NqhwvH9Fx+Q7BZ85523aXdddoWApHUxzAolTNld3dAeDhEzgdBPKW5uoUrRBRmr1smLhP6gTSlUyI6LoWSsdgdb/XnylQCFF9cTGs09arVAaAsoL9oIgcQT/QF5oDH5WOXoXuBB6x8gCWuGdwa1NkaxRwzeykjfXPIy+Zxm5yn98Rnlg1M208PEn0wR2d7cE1UrJGI0oeLpxQA5bZHsF0xuEqpeRLWMGR41GL99Tr0USc5F3rsYEIZbNosVb25f0LJBbzus71+weH3IZa9Wr+gcPQW9oq8KLMdHRFaFdr/lPv6cU+M7VM4KdbghKxU+DyukdsGTXoutkLLcTIiKBkepTD2/5NXUp9E9jGPz7+4I7ARbqNltA6pqzmXS4LPnARenY+xvnJN/0CCv5vx6OeT5cUJLOsN9OaRvNZBTm/74W5hTlcoKuMk8Tp4MuY8PYaXdskiyLXldogUbxGXGNniJNT7hQX3M082ANPJQApf0g4pdHPDGv0bdnfK1sy6uIzLNQzpSzda7w5K6tIQDOWqzndBqtSnqPV7gcdewiLKUCJnJco9VOkjhDj9d83zi0Ro/Rq1SLGGDtAvx1yG6ZnO9usNodLCaNpv7K4rkMGSl86THM6tLFpXMZmtevHxOq0xJCp95rVI7KQ8fuvzdfMRppDP3Mj56dcPJ8AnL1z4bb8VmH/CwdYYXTWjIFnD4n88e9FltCiTV5l17wOOjM/IqRnAyPnz9PUajZ4TSnq1Yk48CNFHmfrrHlUoqv0HzvRPiVcCj9jGn3SbT7YLcWrNbHOw1vl3SV0UW63vuNq+RWo/4nd/9LqOGzuJVSbJKMG2dbFXw6+1vEX/iY/Usr3cnfwAAIABJREFU3h9ckCgNfjL7HC3Ys1v7POyN0O5u+eD/+l+B/+AXOo9fCVAw+yNMb8s6zVlcgiEllKLCVThHlXospj6Sn/Oe8YzBcMjdzOfbz04ZvfeQlx+/xvnNdyleaIxdk7Zo0rg7RhkePJSsNYjLknZXYq2syNIITdbRFJdCrDGYIaYyq9LCL2WCooGuq/RMhTfXL1hWCbWW0RuJ7Gc5c2+NnOmo7qFUpdh9js8e4K99er0hwTLl+vIKOdxR6RLmwECzREKhoGO3yV98SOxJSMM2ajlHMpqYwZa6thkKLXbqHvdL25vEhwPOpZxI39EXYJsNWFwv0QQBA5WTvM0bI+Th6AJntuZRz+XNi0u6Y4c71nS3CqKrUhg1jnFM178g++gVx+4hotoFPlUGnYaMhcujvgkNB7Nvsrn3WL4MEDKB6q7CskwM+zFHdUhW1wSzFW7a4e2jBoVR4t9YlIXMJj7Qd9PSRywS0gwUzWQ3WaFpEoou0u02KXcRWSFx1BvSDW1K26ROFVRJYEeGkIfsE4/uoEF32EXUh/zVyxek1YHm7HQGJEWKFMl89uYVSlPHqEXE2y3EMv5uyTSWuH31ivziFNQMUpnV3ZZ44+EUAr1OH6fTIHy95PGz97D751/o1x0dK5JJNJe6tKjqmnVR8LTRZzg8Qc6gKgLy9YK6lYDQRIvb+P49eb5GW6uklYAXGwgpyMo9mSBSVQcH4PQ6yLs5SVCiW01s0cXKdbS8yejigkaRY9kWQk9jIMJPrq7RKo1c0VluPGxJJ08XxMEaGYtGoaAbv/hNwVcCFDb7FmkhMm9Z2A0LkSZ2EeF94BGpE4yLx9QvdaTfHHHn+1RRQpHkfPRnn/D8sx/yVldDNjKuliVeXfKNhw2K+lBqu3694dl7Y8I0IeaMvIpw0orL+SvqCZw/epuhcUTb/Q7tps4mDBg6OstlRuSv8Lw3PBgdcTnbYnoisi4jqyrkh7BVCgtWt0v2VchumXMqODQlAz2NaYwd3n/q0h90Maoc8hRFVxEkncxooOx3aI5FqR5TbUXy5o4HTxok5gF0fu3khE2msiwF5umOaCdiSw4oIpPVmsuPa056I3ZVg1p9m/WnE/rdU7avZ/zpyy3f/fZbCIZEsg847+xocYH1tA+dA3h6NxuGXz9BVBXqOkFSu7iGil1p+PGCU/eUN68CQi/g+U+nBP4rcinF/NrXib2YUA+RvIIq1BgOT9lczwnLgwcUzQKvinindcJ6c8PLZQQSDMen+PuYi5MLJovXKONTLj/6MbUvI+gWndrGHhxjj1yE1YzHgzF7L6KSKzK5RDcOB+q4fcZ++pyr+wlHrQZvj/v8+f/2xxwfy3TcmkZ9zovZLfM3a+5up5z3j3hVZCilhxIF/J3f+bvkQk3e7WGWKfb4lEQ+RFNqGnF2ccZuds/1xENuLqmynPb7KvXG4+NPXmIqKcQRRRKS+1u6w/dI9RGiIHHabLBbhXirFFn2GByfM3w45OWHh5FvcWEQxCaTT15z/NYTfqupc/2nf4F18gCGMk/efcxIbZLvPabrOSf5mq1oM7u7QbFS3mo/ZrXuspr+hOs3czyhzTz6hYYuAV8RUPjWucP1QqVTJ6gNmePmI9qmxvPkX/DqhUTn4ohE6GE1VDpmH7Wqmd35pPIVfdFm7ctkhs9+nrMcnnDkDXHFL/XYd9s4tsG2UDBSDRWRVMmhdJlttzSSnMBVeCgqpIVG1zBp2g0uVx+xXS4wpAbbtU+Yw0mrj6pr1KwwnUM+btoSd7MlTmHQbKlka9CCW2RzyMgY0hYc9qHCU8GmWPncFRl1tsTYlXw+XVDIGlZDwzM2nDkOsVqi7A/GqGdtHg1r7l8l3MeXDJq/Tjb5lONezKerkuO0IvZlBv0RtaSiazmLmUe6Tfnm8YB2WHIdpqxXHs5ditrf8/jBA3r9gwlImormKtRiQVYqXHTbyIbBYrnGcU9ZzAqCrYgjO5yPNNJjibySCXMBq92irGxqSce1DYJ9TpiZ2PYB2O7Xcx4/sBBVCzVTaDZbLD2fuNBAKClymck6xmxmlJkBPZOyKIhqAcMpQLYRU7hbLMkcjXFWYDsGeXag8NZFgKjCXqtp6U1022IwPkZKfRZ3AbeLLZIErt1AMTX67z4hCVSe//QjFFml2R0jWwr1mYu3nVCXCW+mhwpNp91n4s0RpZph8wRbsCj1kn2co4kRki2jxAVZsSd6fY0mNEj8CUmaoDsG97OCKKnR2qeopcGqTGDic707RDv7oqJWoX18xnhwzHB8xGZ7Q4VK7vmUm5Q7NaJKcjrDU/xki9kQWNyUyEFKt29RCiW5YlEJOqWmo7Z+8aP+lQCFlZVgPGzx+ccT+MsdQ+WnBBc9sucaX3vYxM9rxIsc5cXHbEyF9sUJz04KvKyHcnxC8fxDJqsGZr/J05P3eXX/hp5yCJfmwT3JZxP0rsbV5SX75Z6BNqYdiHxjPCYLBaLXVyRPnpF5c97/xu/RtTPKpIehr9AsES/KyRUHkRJDt/D2E4QvbeKqdgrKnUc9apLfzigzg7/zje8wW87pdBpsX3xGJot8Ur7L6UmfcVUS1S1W8oQzVaOQdOL5ml67QJ1ZmPoK/0urvjY3P0Qu30Xuq4zu30Pqefy9wXdRz4/wfvCaavoZ747eJ8sMgmVEZQ3Qt2/YJxKq5lIf9fjmpmB1nGFVPudtl0YJ9qeHISt6q6bRKHA1eLnIkLw96t0cXW8giiW5IfFw1CFatVBbHuLeQ0oVKkPCoSCMS5qawOz+np7ZZZ8tuNAOJclPLz/A6LzHx0XOeDRElRs0Eh+pUlBsm1hROD49ZhJ7ZI5DtUnRmjaTNGU6yTn2P6BSNB48fEyW1KzDgs3NhiQ7pEA/Xt6QI/HO+6f8xb/5txSTNzy/3tDuiIj5BqNlkKawWk0YDp7g5SEnDjR/9Zj5ZcTd5gpVaTLYSvz6334fydTYJgdQUDJwMPjtX/06DaPLvg6oJQNDbyNXIXa2JRIKppfX2JbJoNNhsUxxWm2CYENTHlBKMWIScf3migenMr6dMNIO4FnFFX2nD2JCMF3x492H/IPf/VuMj0b0Tlvcz17zvdeX2M0u79tfp/P4IWqwR+pdgHLE9ecvmG1Skq2E0D7n9vaGXf6ltXQ/R74SoNBR9kSVxa9994xm95xubGCfyRSbEblcMug8xGrIBKsFFw++i2HBy8+uMKsdWd8lafuwddASgbCsWKUh4/zQl9BzTSypIooLBNHFMgyCICT0SuS6wkgrqm6bq8kSswbFC9hsdry+vULXRKqkQC9r9NzGMSqESMMyQK0PBKlCCMhbfYxMpAxENB1MxyGebJBLDVF2ETQNNY3Y3ITc30Yk8TVxkFAXNk25Sd2KMQQJvbNDrhWcL61I1M6GUMSIcYNmZqH4Ef7TC8TXS9qyRdR9zOtXMc0zi3qSYJ2ZiEaPbeXRcBT6gYQgxKhdC2cus8xNzDwC8xB6nx21cR2DtMw5HTaJo4xguUcwSrK8wNAkllVMXogoYY6YNailAkFQKbWAIo/IAxEzA9WQcSQVLzqUVQ2lRgjXqA/eITM10rhEEC28PMNRFLbxljyvSTchWb7H9z0cd0DjwQjR9wjyikHDZrnbUSsWeZGSyT6CcDDj3WaHpQhkYYvTtknZqPEfH5PkEeOBhqWoJFXNfn/Ddr1l2Leo5YJ9CM3hANFwWS72dJsWkqASZBH31wcCVkKOKrTw0hJD05jM5yAGJLqEpWjsPA0xCbia7ZktfMbjFLN5TBz4RLmKGkdke4+s10MZNVCFCMc0UMSDLemuRVVUnD8+RUpiZC+hjBOKIuTyzsfbhLitDsv1kk9efs5o+ITFbkWr5SC1LZafbokCj1oQyfjZwBpdOUTOP0++EqBgjh4g5nNaaoU+NJC0Hmg6D3sxH+5vOHlbIQ4U3txuccOUaB+xqlKswsZQ9miFhNF0qYZNjrSExVhnNz+sXMtjn2VdYFs2rizh1R6Rl2BpDaK4oNXr4Vp9VtMQs9/n9uVLslpBrRuYdkZeBGz9LZKiEcQmtVaxRsHWDzfretqhCKYURo2kmoS2SrzJEYMab7akMXCQixWvVjVHYsVks2J9/RGi2KUwRYp6CYYMQoPNJEctAlL90O6qegath22+Iago3SaviwWLyzn7u2viWOZutiK1Fe7/ZM8jS8ftWRhHCvWrJepK4/VqwcWjU47CIfH6imSzo2hnJO1DROVHMdtCQdFFxCLFlFR8VSbah+yyCLMqyMWM0dERQi6TZh66MQYjZx+X5FWBIGtYDRHLFalDCHaHd9CNilTKMVwZNJnt8gpRl9EUmQqRXZAhqCqFoVIJKsbpKW6zQUvpEWY++0xjHoBcJ6iKRFUL9Pt9/OgQKbxehXSFhHZH5Lu//gRVtVisPe6WIZar0LMbrMsaq9WhMWiRiREiFRoCjU6NIoU86rV559GYXRoSTPd874c/+EJ/lZQookAelxjHNeo8IowltKCi1FJUqeJuO8FWDao6xuw2acoG8/WOmoRwG9FUFdpjjUE4wNU3qKqAbBwIWLLUoq58ZDvH1VTctkyQlXh+xdr0SIqIwjERbIE4g9e3L9lmHmr5s01VoiSiGy79Zhstzim0AdPob9gq+keDt4l2b7FxEvaSTP2yxcWTnOGvujxKv8l8ueZq2aR2T0lIEU80skuDVhHR22dsjr/NT//i+9heBucP+OmffJ9G84CMadjE0EXu7ys2iUWQymiKxll3hO6XmKKLafeoW2CjUCdtsnxLu6lRZRJm6bDwl0xiH0mRMY0MLdUR88PnC6YrtmWOcvcCz9WpPi8R64rKA1GM8fQt7XGLbrwniWp0/3NORw0EKcFbZtSCjIGEnO9IjS6LMKCeHZbN5OGc2aqHMjhGy0SORYf4boKhHhMWIcPzNlLocXZhMBodE+9ibudzInuCXQj8/m/8bapKJcp30CvZ+zFFadP+Uo0/KyK29xZyyyBZ1aR5QmYMMCQBoSiRE4PKNHg+W+PoGndbETtcsstCjtpdDLPLal8T+RErL8ISBDrOoYX99GSEoekUZUJRFZiGTrclE8cVsSygVSpSpjI4P8E0RkjkFFWIJGxxHo55Imv4acntzZR9kCEKKadvnbNeHBxAchfgn/YI/AB1ZnI+lPid3/ttFonPSJUo8oQj38cZjOiMTKoA4jzA0KDICpAsoiTne5fXaMi8fHXL/v6Qxp08srEVh9ef3SFFOt88d6l1nTKdU8RA14Iq5NweImghQz3iYpjwdKAThAW9lkTXcUnKDTthj2qWdNsqwpcWIv+9v//vc315haPtkbdr2laDmVdyM/mUi9/4Bn42pS0P8FKFTzcLLMFl3D3CkPrc5zfoo1+BsGSf5ayCNaG3omkdLt5/nnwlQOH+eoJ10sBbRIzNdxEeFBh6mzUWaVSSjwreGepMFj5lXNKwmpiPGqQfTAglk2K3YFkrGLlOnLykqX0dIzo0E/lzKI8tanw0pY/t6giWSKFqJLsSMTeQM4MHbYvdPscwFZrtx1T+LXpDRcsCFmWPYJJiWQaq1sY6yVgvD7P7fArC1Uvq7Bgnj8h1lzSVcLpLhNxBr1QIKmjpYIS83XgHS9qzCbdgZGxrFSOUid6REG9nJNEG2/rSXD3ZJV3PcdtjhEQmNWSeHuvMdyLe5ZRdz8Sk4Pj8McLGI3EkTvIWQqgh6BbLXYSqCAjFnGSeYoYdDPeWaHKYKpR6ColSUFY1u3XJ/XZL21apooo68ombfYzaIIhqon1KrRlc3W05Pu9TKi5+5NMyLTJJo4GAKMuUHDxULAkoZcydP6dcC6TRjM26Jk0LdL2FFwQUWYIQhPRHbfQ0IKuDny1pwcZuwnIWMt1uKCQFTXFw/AjPO+T8k2BJcJNSygKiKFNWJe1eHxeDB2+N8aKALI4ZX7joLRWKGiGuWSymRGXB5SpAlCvy6Z6rxZz7+ZQkOeT7jlajizWdgY3TKjF1kaQEmiJG3YGOxTK1KKwMc6pQGhpuy6FnNVmtf9Zx2sIhUzLsUkQxKiQbbOcAzq+u7lGrgtgrCPclxSaiynJsS+AHn0yIs4DmcsY02FGWBbLrshFDqtUbFKtitylY+zFVJiFrBk2tjT2++IXP4y+XwfxSfin/P5FfLoP5pfxSfin/r+QrkT781//R/0SYzbDNinefHSOHGoHV4eXdDYMqozN2WfsLmuYYwTAx9iGiVBNnM1zllCCTUYo5sb+nlhymd3PuMon/4X/+pwD8o3/+XyFRYOkKVVpyftSgoociaKQF6JJFSUYYl8jI5IWIKVWoPYckCSAKkEyR/XxBQYXiuhhCQhyH/Cf/8L8E4D/7o3+GoFSIcYyi5biawFhXkHSRfTgn3glEgkzHsXCVlMt5QafTxjEqJtuQKBYoyxCp0UOUmmReRWbo/Pf/+A8A+Id/+C+ptlMEQ+CooZOXOk0xZ757RRFFiIZNe9wgD2qKUmO+v6budyjuNkiuwYPuUzIxRe/YBJ+vmG/uWXhNmpHFv/zf/2MA/ovf/SeUL15R2mv6rUdoIxfBkqlqm22k03ddXKXFNl7RzGXUnkutmWzma9TVgkTysNttqusFn1x+Sm62sWqN/+6jfwbA//jf/p+sZnNUM6UoBYIyJdhtkKSaOvWRVZE8LbCbLtv9G2pNQzVcqETEQsHSXATdwmzqlGVAcJeRFTWjk8f84R/+uwD8O3/wjxm2u7y+2fDOU4HpViQSoDQkXKVHsltReBGSlJBLMlqj5GhwxibwUAsFxXXx/BVBFDJQh5jWiqOsyT/5o38EwB/9p/+KIr4h3G8Q3VN80yEtMvR6j+noKHVJ6Qs4askqSylinVerJXZ/gF2mVP6M9nCIVoIqisTBHaeDBt96dsZv/cHvA/Cj/+Y/Z1+meLsVWZajlQqDiw67DGTlGNmsOR8/IBYlwo1E7CckQY4iBphyTBIu0ByFXEuw9xKzecay/hu2DCbKJgzUNoouY2Q6uVjSSkr6sYxW+uz3NXtvzlhxMAUZsWEhuSLVUqVUTVzPY5NIDBoOXpqg9mrM20MprNkcIksKUlESJ3NCr6ZtSqgdnfi+QCgKJFmiqTooioxY6shCjNEYkCk+W3+KgkAhdsnTLVKmorsdNPFAOPG3Ey4etMlFnzQK0C0LsWWhJRVtwySzK0rBQM8UGo0CP07p6Rlx7OEqMv7eJxFTRK+k3/7ZLFO1c/h7DGuFomQIQkCRuOT1lvJCx6wM7v09bqRR6RpJx6CXKOzyFmty3HaMXTbIzArLarH1MtJGgn/vY0gjlvKBhqyoA7SzNbvpjjINcIwuwvghsghqWJLFEht1hSE6GE4bS5RIZAGz00JTS6SoTVAFtJQGptPFEA1y51AfD9M1VbUiSRNk04Q8RW6KFHFGmsX0bJdGXyUuSjRRQZUUcrFGKQskTcfuW2SliFKWyJJIYlfEq4gy2Ry+k1BS5RG6uOH1ZYAiOlhqB7s7oMhEdkWKVGcct5s4tsEyz9FQ6Jh94nyHnoZEQYqa+NzeTLBNOH924HKkpom3NdjtZR6NDSS3yz7PQbNIJI0yiAhYg6ZR6m1yNaIln2MKIrKm4ro1sm7gNsaYccyff/IBzTJlenK4kC06Y9ZvbrDUEa5TYOgWpeRimhGV00NOTKJijKDbrHURZf0B+63P0dikLDMst0WuazQEg71VUJoLBubfsL0PIhqmpZMnPvt1G90qMRsVX3+/RXSTo1sxO2OII1dE0paxdILveSDJyH6ODLg6lFpKKbsYfolmH26MVcVCVSwEWcAUIPZiNnFIRzUw0xTRUGi7Dyj3AbokUZo6uScQ7lPmt2uWyz2DZs1m72N3DQxFwVAlcutg8C1pS8NqsYsCfCkmrR0ExSBLI+K8xNId7pYBtpAi6wJBXpHuNpSFyOjJEft6ietITBZz8tojiRPy1aGzTZZNLL3mJEiJ2+CXAsfKkKUeMzVszArqZItUZszcHuWxy9MNpGmTwTOLtm4ziXKaUchSsVHFmlLdMege+vhVvUGn/z6OohOs7xEDnzJcIXYeIewmqCK4VZOplJBGe0a6jVhFOFJKJO7RhIpPnv+Eja7jhwVFV2OkHb6RIEW4TZXED6nzFKfTQS0rdssNWWoiSwqlUpIUJbXsEpOT5AlSJHFyrGEaJnKYUMUBqq6iZj4FBXV1YDRarkq631H4AYqUIpYinmlRbzz8/ZJ0t0VUUsS9Rm0WGO1TJM2AMsK7T7i7v8bIYtJSpc4ngEuZH9qa3UaHcLUlZ4sXpLQ6MpWqE+QlpgyZVFGkCZ6kY5o1671Hu3mOKddEd/eEVoqKjMGSRDYRNINEHZEmB+CJyj6CGCDrOsvZPcO2Ck5BpunsVzsSyaMW3oJKY1PkJAVYTZHrzZLZ7TVvPTtjsfNxxQxNbFJKY2zlUPL8efKVAIULq8lPX7/iUddFF+84OnuKrPZoZh7hOOXFm8+RipxFXSM5Ba/jHcbZGZpUUjoi1WyB0WsSbSTSVc7ai1nu51/otxoW6+s9TuOYTn9Aank0MxepMjh+BME0pApC6ruS11cvqBsuRlPn7idrVlGIqllosk3TFFCCPY5qEN4tkb5UHUjn1+z1mPvFFq35gJ3SwogspKLGlGXE/jGZ94beN36Nhl7zw+gTpFTENUVmgUes5ghyE0+6wywSSkNgFR28uBpPUfwZaQ5WYdDUTar5kkTwGYlQm1P2vo1UR4xMg2mhsbEEjh4F2HnFZ9MfoMcW++2euoCmNeT4nREsDtdKo/4IO7nm6NlTAk/DbMh8ejvFmKSEccTgkY3bHfFvv/9johqyIxcpT2iGJXlTZLGWOBtY5KKBK8so9QWDJw/h//jrd8BH0iJcTQNdwy8i0qLgrGvy4f6WwrQpBAPRyLDMAUgC/SxDqj00AbR8RZ3nOKaMrAhInQ6SFWE1D7YUSRVuu4MRpUhRhhiEPMIiuJJouWN8vcHAfYvPP/sRZ9UZi89SZGVLx20zpI+S3KHIXTotkeU+pKHnhNObL/RP53dUWs63/v5vUYUxx6c696uQ9Zs9m6lPe9il//QbNE0VMzZptwZIV89RehbyeZOwVtGFnHeOHvBmu+Lho7fRGg6twYH5mW4qWs0TZFPCkQrCXkkQymzTgNnVNePzJ/jhKzxBYDq5Zfr6mjC+JLgFR20x/LrO2UWf9WxDVdm8ur/h24Nv/sLn8SsBCntTQJZK4igjXFdkYYpUTlCDirgMMIuaVZRzd/0xXaVPMjC56CV03C620yauZTRVxeq2kewp3kxhvT98ZE10MQ0ZQ5OpawkEhVzWiPcxiWFQ1DEuMrfLBZVXoek66TwmDwKEIKdqSoSVg1RIlGlKXaU0ZJMv80EUs6JlK3irDMMx2YQrgkLGkgv8QuSz51sW65KjusHOC0jrLuvVHZZW89A1cOwKv0ixVJW8UlAlEds+7BtQEhtda6E2PXRRJS5Uxicq8VomaCuESpvJGwHpxGCed9CSBTki1esNZt/B2CnYXRVX1PhsKlLqAf7rjGp8ADZNEsDoY2oJXn6D0zonfPkBm+ISRVJ4ePGMyWJO5aQ0fYVK1agJuGtJGHcrslzAMjq4lk3VtYm2DeLy8A6WXBIEEbKRo+tD+rJKT3ZIEOlsmoRJwa5MkUSDWRrSlHOkukbYJ/QbFWUKjaZNESdIlUhWRYhigVgcWJmIEIUBLavN8uoTJN9n5xuonTM+f31Lu9ugPxaJW+fo1QlNcYq/V9G9ArcJn3xwhWDLLFpNRsMCTTMIvjTcVqljioZJGHs8dFx6w4pQk3Fu2kSyjuyn2M0+YXLDqHfC+npKVYo4hYmmpfjXM0JZZxL9JV4ESV7gFAmb9YGn0NY6YBZ8unhNlCRUYYyPxHwXIQ4auKbCpHxJURc4wxZ3y4zVOkIwNGb1LY/9p0ibGr8ucWOd2BgSpn/DRrwvlxNMRaNKRPr9Pra1pZs2+asXH9A/6rDxIVUTKlReliWdrGC/80hjna5c8vDolNfz5zTMHppicfuTj1jsD1VOb7uiqlWWqwCzp3PaPSVcJQhizuKzS3QxQaZFsZ1xpCrc3t8S5yvibUluKpR1yv0UOqcntE6GpHWJ2XSw9IOXDaICy4H3fvtbfH7tIyg2O7PmpSdTFQaXtz6VOab44QvMpsE2EtFaj0nxCRSLZrvB/b/6Y6ROSE/LOTN72B2bf/7X+mUNdtuMq7s1x4OUmjXNvstb3SOerwRuS4Hx8bfYdlOmn9eISclt3cKa3PHp5Q95+t5btFcSWbrnvG8irQyOH7W53R1q/LXexa0uEcsaQS9J9i95T4tI5Bk3/o5XLww8S+Vz/55RS8S092zufBqKxF6L8BSVRO7SbamEe4HxsEXcOf5Cv6yKjDsD/PAeIQzITJWWWeG02zSzI2pZZ/NqSWY45EHEmzBHqwS+/uQpHRvwNgiCgFDPEOIduhdzMhijNA6ht1TrBLMVLO+4GHZ4tUgQruY0Ryq/0RxjrGLsf/M9frP7NarFnDeJh46EksSktwvibY7hNLHsLi+n9xxZDfrKIRU9bvYJlivS4oq7RcGnnyWMz45pDXWSQAHV4pNPfsR77/bYzH6E4ZTY3z2nNExago9rP0Ia2viXb3D1lOXGZiNVnB5YzvhmzGozJ062VHKBM2iRGArN2CTRluijhPFRjGgZbLYbvvb+Q5Q3EouFRMdoYbRlRNll9/EUzS14aDfItAPo/Dz5SoDC0Gjx4urHCP0hpR0iC32a43OG659yfRsQbiOCWmZda9S7FHSdKq/JbYFBrlMqGZIgk/gSqawS+iJS94DuaagSJjGCVFKLFkEq4lgioqiSezLpfk+k1JRhwGwV4md7klpB6PdRRIn+cRfxpEdvfISgqeRByDavGH+p7fjBiYU76BEj4XRatFoDXiwjVpuYfntMf2hRijaGZWI1G0iCTJnuKMKS9fUb5KCLo1QMRJkxJVlqiqjiAAAgAElEQVS4JM0OdwrNZoZUyxTbhNvPA7ITg82f3zHsCOylIwLTJkHg0x+J+MqevFIxNwX3ko16tabTy6FMODcfItZLpGpDlN+Tp4cDtY1BRcMSPUaSQZF5vI5vOGrHqLnIi8WatNcnqHLWWYVwfcO+SNiFR9g9HXkqYygWVgrLaY46nHLeffKFflNRsUQdSXGogFJrkCQlyWxP0+6C00BeqWjmEXt1TSPbUy23+H5Ct9klzyMcVcA025RSiprkkMRk0uGicbn12QQRZlohVQVmo0G92GCnoKzfYAkttNSg8J9TiCq/9dZT9tGMyS5BbZl0Wkc4Ryd0TvpspykYbTT3kI9P5ylJ4NNWCspK5Ho6R+w06Z6cUuKRVhba4IxK73K/+QGKYDJ9M+V03GPu1mRCzQO7QaooeJsV/e6QSktptA/DYeeXWwolpxXLrGuPwtaQBhlF6iFYEJlz7mqPpnOE0utxdXVJ3JYIy4zF7iWn+TukwYT97hVto4chtpCjv2GTlwprxWDUoukmhNGOlPfZFTWb6m1qJ+DDH0fsxYBd4BFENme6zKj5hDrfo5zqqNsthbhguf6M7MSmEDJM+RAWP399id0YMuw0qcQS2XGhVGj2xiBUhL5Fst+zSrd8ePOc+W6C3j/n+KGDMGyjjwyOHg+pmgpPHj0kWPm8+fgvuLk85A+ffvohSSZTuw20WCPTYeS4eK+2DH5FJ/VMZAxef+RzMTBB3JGGMYt1yFvnF+y8PWbWJ10KlJ2CjlLRPjr0VshyTdvS8IOEp32ZMLSI3n1GWUr8L3/2UxaLAu28Q9k6od36FrnoMyn/ivy2gauNMCclb7xbFrHJN+01uqbTuZD42tMx//SvnxEEIe8+0Sk3KmmYMY9WbCqZ13f3eK5JrTZZrTKSVonf8Mi3e3qdEa9frTjqO7gtgdndhyRWh776hLvbKWr7UAXKQp8omxNlPoqkMfh/2HuTX9my7Lzvd/r+nOib27/7msz3sqmszGIVyWKZpEQTMiwZBOipPbBnMgzBBvwXaOixh4Y8E+yBTcOyQEqwSINUkZWVlaysbN7L1902Im70ESdO33qQREXOWDAgO4uq7w/YB9gR+9t7rfWtbx00ODg7RtFafPjsis1iwcA7R3KOeDC4jybFpOsbPFKGjkudRQTbLcVkRp6GpKsFl5KE2drb+R8NREhrnOEJg0aHWt/w6mcvsHYx3x8+QRSnKK1DNguLVMxQ64wyVzk7UPnk5RX/4A9+n7ktEAcVtmNTlFvi7T63kzg289GMQpljLhMOu12GjoB33iV9Nida+xSqhOIoPLqvc/b4jHB0S/9xG8UaML9+jZhmXKw+QihjPv/4KbnqMh7vief+o3fJlBhR+oTtrcxnN8+gadL4VptlmKP1Dd54XycLfDSlYBgr0ILQUjjUD0jGBdVqReO4j6sYqIJG5v+SmaxsR3NcRaQsNJzeAKeMUYePMF6vCacrKrMmH21IyxayllBZEiV3mFKOop/R6tZUc4NdaCA9n9JvyEyz/S0u5j7CVkdqOyymd5iNFq1Bh7Ufc+/+feTpmFlW88XqmoWwxDptsqsy3DcbCI6BpKgcHjdJFJvM30CeQF5R+HvjVjFYY+QJy7mHVyvotYdXe2w3Y6IfXVHXLqdHD1Eqn84uQkhDMsDNLB6IXUTnFNPQcJUUQctoOSmUexuwgWkj7iQUXSKnxfj1FW+/8x+wU1KsSYFU1/iUmHrOfHWFvJZxRJnm8G1axoKH6jVu0aVYvaDTMOi0VM7cCk/bG6uazR6SndCofT7KC6q1TK4lyM4xQpmwjG4RBwa5X+EqJvNCRd1MaJ8e4FHhWSX93oCBHiGLCo7ZZr3bl22DIEdII7I0QVMqXn70KcI25PDwHuV2R52LLGcT1J6C7pqIakXmZ9xtb4nGNUdqwm58TbOOqDIoy5o4jUmU/T6lpsrBwyFpoGI0FCrb5f77D9GvtlRSgqXENAWfV+s5Z/0uV1eviMi5ySpevPgZD997E+/wN8jVEWasgVOirvYy50gO2bg6p7XEvdNDPk22XPkr/qG0I3NL4iDg9pNPMPI2jwYG80nJxWefkXshKFfMxkuCV3e8+tlPeNh7l00d0z86wvpamGWpGqousMx0VrsVgeowmlzy3QdNEilhF0csJiotMyEqMl4uVlxsVJzuEVHhY+sDpuJLTrUzDKeDVXgoB/sL5m/DN4IUGm2T3IeWqVJkOReqypsvnmHoEu17bRovLpmZNVEe0Va7iHpGbHZx9RRXaqCZMwQ7RFamJJsNG99HtPaboKwyUmXMRlTo3H/Exl8y00TqWsHXKlZRzCoekdkJypmJ7h2RxwVWxwGtRe3BMg+oBQmncqmElFRUqOV9iNIcNihqMMqcRuHiVCotweRB+10CAZZfzCii13ijgFBcoQkKpmdx0h1gLVLyXcY7949IqyW6l1HVW5ablz9fXzAKfHnN3W2KPAzAcakXEdJxm/Pf+g2KYEftPQbHYVxn9A4D5Djmgdyh2gkI2gEdMcPNPCqxQrI9mpqDGu0PVEsDdV1TtyWEIMex2zy9fcGDrsAiiFg0wG60WNYjnKGLK+YcHhwSLaHbNnEjlWHP5bzsI6kN5FgjDfelgTDNkUST0c0lp6bHbDqlTnOCeUIleghyC7VQyGcrwkLC7SgIksRmuiOsU8qeAkkOpsp2MyMqK5yGTfE1Ya6UBmiyg2XLNA5NjNjlshlSrWSm2wUtWyaSdxwNNZQBLDZzKtfEV0WKYZdpnKAkr7EkC4GC/uEx3cY+Hp/nImVc41kmqlEgZxAGG2Yvn7K7/ZLeYYdHw4y+sibI5ox9H8lQGF3foZkCnt3lYvkcr9Gg0VPYjTecNRQ0c9/qXyx8tIcey8QgNQyEbcF4t+Vnl2MOfr9FBgRuwetPr9HNHrutRJQliNQYmUkcJUSxSqHU9A9cqlCFdO9j+bfhG0EK5YWA52nIDR1dkGnslqzyJmYlMs09WsMe56nP9OlzrGM4UH6NqkwRIgVkmZQWrGoMI6HrHHB5mWJ0ej9fX4i3PDi5D1rO/SOVMAsRzCEaGtO7V+TalF0zRHn8VV19nYFeqjxfzZGNmFPrPkW7g6GKCIKOcSdjSSEbZZ/1jrIRXe8HONIHXP/pU6SGTSFsObV6OK0OrrrEu5vzTveE5TplYotYtk6+eEqRiZQCvHy1xuv3sN99F78sWab7Gr8xifnk02vKe2eMbqZkvsbH7eeYiwPevPcbpJslR+cSWZjw8fWC3zst0HpvMtBz6huBy+kt9WLOTNVxXyYUVcXxqU51sncRXryMEA7ntLIpB67F1eaKd757SDp/yb2ejp+NOD4reb3Zsg1e8ts/eJ9oE9LLRnhbCVW5z7PbV/j9e3RXNYpq4ud70skqkdHFU9JxSFxssAyRV09fcfVijNn7NvNqwyjXEQ2XV+En9OwGjltjJz5UMT98+hr8NbVXE6chut2hZ+k4XxNIfecNl7s0pihL8uEBsQ/D33/ExZ9v+fxffswkShFaPR6f9rle/QxfaLELCuaZTtANOPy+QWVLRHmALLu02z6Dw30l692Hb2OaCm9K/wpPLnhynhO5FtXqIw4eHRNYLq+1hFm2obzeYowKBr0unnBOV7X45OWPsAcOb543mE9HPHjnMXIhsE72/6WPp19wpLYxDna89+aQgycVstijOldoWS1Gs1f8yYcTdklNOXrOgdGm2kZk5QGi3GIxHvMf/fb3eVvxSKcTPLPBv/rTL/nuH579QufxG0EKDVsjsws8TWVyfYHarDk/6HJX5zTXEapds7NN4lDmw5+9IBIVnP5biPcfU9ZrwmWBY6iUHCP6Eq1WGzXcx/uqa6FqOYJikuchu1jhUJYQLY2NHxGu7tjGMf1BnzScg1MjVyKhnBPHS6JER1GeYNst2hgIJ8fcvvyEo86+w7BpDejSpk5qTk7fpliXyOstcjjCn835wDlGzFfo6h0tV8BfBnTlnOHggIvZlgKBwWGbzpvnfHZ3y93mDqH9te48u83R0SnXlxtuKoMikjAnIsqbJv3a4PFJH3F2y3W0wVVFXnyx5a2zDtnBAP1xGyOYIbYf0HxQ4W1MouVLVkGCcbOvPjjmgtKYU5WQ1Rv0uskbJ22iR2fcRF/yRIjomqcIxp8jbGIkQUYMVfzAps5j1HSBOXyPIFfxChCyGI19eJJFEck2JqgzoryiKGpWYUicxxxpPmmhEuQ7NpMxWVLxYv0Fh02N+72EnusQhSFipSAUFYJ1QCyLxJUB1ddCRSmmNn0OzAfEroaWSwStJfGJyp29IxUt3HiCn8forsLVOqLj9ZgzhmaP+WxGnYucNBuctpsgrbCSfZJusVrj1HdYQ4eWJXJ2tCSI4Vlk0z9oI+/WKFrO/GaEopWMwwC7aXI5fkHbekQPje69A+zKZ3D2CDV5yPR1wiLcO+oIDZso3OIvcrpvmThin4NSQrJt7tYj5osUu7YJ7rZouoBjt3l1dUPrLOFBX+Xe/W/hdPoUqk3q+7iei1z9ks19mCkGmiLwajLn/tG3CTW4quGNo3vEbsqXn4e8r2l8OZwTfjbn9idzThqv6CtdvA/ukaq3nL7xLuunH/PF+jOCZENY7p98QbFjs1NQHYkoznDdJreTWxTHIBlvERLYTMa8OWyh9hp8/MlTMsdG2PpIYgXtHvNxjn5P4sXmjnZDIDdrDGHfx//WuQOhixiXFHkbx5Q5EQ2EIOByNKY2Q1RkNnclvV6LR0MPUdihpQEPBn0kByoT1puALy9yFKHG1r5mSHookktvs3t1RdBqEag1rVYLmjrzpc9qNsdpN5ku51zvpmSFTHDzjP/sH/0nPGoeIKkrfpZeMHsd8VZX5+nlFOkTn5P39tWHT39ySbvKSBo6A+8JwzctngcvCNYGzc63uM4Tkk3C75z9HuEm5S7qkNc2B802jdO3EGODdGKwHa1Z+SPWtxK6P/75+p1ehzR8jFw8Y0eEYHcYHt0jQGC6zJktF0TDI65mPo/ffIRU1Gxur1C7pxRGiSofkq7m+GlBF5VVViPKBqW0r+fJy1cMJIhjETmMKc0+q+KGtJtz/A+/z/OP/gy7rKh0jXU8Q2o7jMSa3vfexvNUos2U9MpnfFdhHQ7ZrULeHe7Dk81ii6Fk/LQuaEgSTfuAn/z1h/zfs5TG518QJiu+9BUCReG99+6jKSp1aqKKMq8Clco84Wq85HtPDkl2EbswYxvrZNXXWpvDFOVRh8zoo8pNpHKArtyyvR7x8cUPOT11ObIThk0Nf9YmqBXeOPw+6U9HCPct+t95nyLocrmb4hRrXt/GGPL+gvnb8I0ghTC8Q7Y0ZLWF5MTItcFJa8B0HSFkIZWwoVBlxHWG21DZ7TYYuwNUaUwgpBSyxPomRpMC3E3Fy6CglPc3YCHmCCgMWyZNVQYpJ1ZdpELAaFlUVg8rXmKrAWlWczg8Zl7kVKJKLahUBcRBgpKIhHFMmCeokoYg7/+MtdJknqnMpgrz17c8bnZ42JI4kkSKDKwsQfdctpuS+WKD0Wniax1miwWNRzqaIvLDz5+TeH3GwRYjn7ER90/76bPXbFOPK9egYai8ZzpcVw6L6wJfumQnKmy3P+bqp3NqOUXqDlE9iFYbFkOTq8QnshKUyZTWg7c5++AYuyUiTfffmKUZB9kRQpWSCS1W4Y7rK5kSn7PTcw5nA1qGTp2DurgiTCYc2KcYNwKaH+EexNwtjzg8ecTrz65ZljvsrwmLBEoUvcRotIhKncPzI4oyQk5UwjJDknSclsm5ImA0LTabJZ3zBoleIFQJXquNItZo+ZZuo41dKl9Vj7b7m7yjSdztCtpZzjhMsYoVsaaxROP8nfdYpQVWtaH/po2bJmjNtzA1lUx3UNSUQJLRzjTK7YrFaslp3+Xo0dnP14+TDMUzKXcV42DGX4kyP7q74cXapet+JTxrekds5Igo9Ig9k9OWS50ZYASsXy0wDQ+9SEGTiBcxtQZFvS+rkuloToZnQag3eTG5ZrWKKIQdj60Gi5uUZRGRTJYcahqzTz9iU5jc6zzE8E36acR8NaJpG5jiDkGq2dm/ZDkFvW/zyLPwBZFasThqnpCbCcE1bJOQdveMj+OXnD064+ruks7JgHEpYozveP7UR9JBdQV2mybCt59g/flPCOP9k1JLbXboFJlMnMWkkUzsOCRkRK8uaVk63dYZ0rCGcsPxvQOy52Oy2Zi6oXF4fMJ69oynasiRPiDKa4yGhxDvQ5Tzb/0uf/QvK3xhzetww00esgq7nGUBlWRzenKIYJmEeoRutPni7pKlnPP44W/zIs65vRhx+vg7XMwX/OTiC/pdg0fePjw5NEa8Xt8xvPcBD+wBuR9DVtB6r8/N659xYGrk/TPeLGbczFVeJ1NaScEni2umn4eMw4iTwROyzjnz2RfUbomkZQyP9olA0TbIsoptmnGEjrg7RdnekqxHVOqYH7z794jLhEG2QXrYwr+ecxh3eVkUKFlM+ElGkChcJTWVauPmN2yn+z1KV1OycIfRa/Du6QFZPMZ2HNqWyZHhERRNhMYhVrtDnCmsdjbVPKSjSqwnE1rtQ+JGA6Ve07YsalVntIhQvjapq6G63G6v2VQy01VMy5NYNWVydJSezP3fesTB+z3e+vVjbq8uWLzMyFYrphefI0ke/uWE8SShrRrcO3rA9rPPSR/sS562MqZQMlJJx7QPGN3dMTx4SN5S6bkmfpDw6sMveWjabK7m1JqJ5syRGhY3P3qO3mph+HN6nSa/9v3f4dV6zmqVU3+t92HtVRTXEeJgjqkWnNYpDw6P8PMM/+6Ws3XF//I//J9ookDu9Hnr197gsHfEROhRRD7+ZIwhlmxTmXsthcVuSc0vmU7BTFuEtUcuZJhZSLDLWV8UiKKJ1B0ymbwgSwTcQYcHpkIYbFAGA2aVzHgx48E9j0FZsapOwYipnC/JlX2Mprc7aLJIZToodR+/rhDKmANFZqI4yLXMacMhiVZomoWq2lSaRqraFFnG7e0trXtnmLmAaeuYpk65U0myfaPMYecBljkibgjoDxxkpcW//rPPeNzXOWg3WMg1+WRNS5SI1JrB6T0c1SKzbBYvXnA1W7C2ayK9INJFMkPE6+3j8VRqoAgZzUmI+L0TkrTBLHrB7ssKDI/LyQVK3aLoP+a4VXP7b/6I0jpnPhnz+uVrcGMkqUWop7SUAH1dcdiyqJO98lPWC6rTE95tCRiZTpLe0RB7lGXMaC6ifj7i/vEJQqNDETs41r/FrnNmoyXXl0tO28cUepNYNxFWCkLvEWRL+BsTrDgPcV0VwdHQdYV1kGHrGpkoUpISphEPTmwky6VVQJZU1A0JJw8Q2zXDvsV8XVEkBXrLxU9K4niLbn7N9LQUMT2P9YuEvjXgxXrB4OQN/NBnuiqRpJAySLldpyhun+38KW1XwjSajOc7MCWM/KuBLp5WUQOBti89X+2mWEMbvRaY7WTKIOP++RnmbUjla1iKwbfe/R5K85iQGU8/u2W6NXAWAcPeW3gHNsFmTlttUi4SdKXJZv4Zs7t9f4VmebT6DUTRYDuaYHsmRjxGlXLMzjnzuwt+cPp9NvMLdtuQPMwJI5/B+SM2wZyhbSJrMqJcogoWZVKwyX7JZM5GWyaza5SNzCbJ2DKipzrcbVbUUwmlWHJ00KCWc2YrKG8Fzt44RfbnbJQxyzuFpCUTyrdEuc7Ds7e52xTAPwegjBJUo8FqsiUYX9I/GrBNfDK15sAwqcsYLStJJwGFkrCQBZJQIboZUeQVfj1HCjXKloiezTk+GeA2PIqvuVYdHz/kwRMJcTom7zVJQonj3zlClhVuM3B1g6ynQvsIudngwy9+xjqaEcZjivCGUAgY1gGWKSA4G+49sRGlvWhGrmOS+Yw/+eRLnNEzpkaPdx4fs6suWD0XaD7s8VfTz5GEmjf7j7FO30Bazrg7qOk1G7jtNtgBdjxFC3yq3QUH9kMG9tdmGhh91Ist/+z/esbb33+TtlCxeHbJYrUg+OGC6m2PzVnKr3//D5hOnxEtmlyNK/JtHznJSDstos2Aqxdf0NdcWlqD+++8zT/70Vfri6ZCEe942B/iRwnvvP8E29apFZuL8SVHeov1eo1ERs+y6DRK0nSLLJWcOA6aErDiFrOpcrMYkVLSdSXMxn6U1uuLG9JZTB1q2HZFMR2jVI/oNExupp+STn7McvsYb/I5VSizHe0YNVTOjXOypscXX/4USzJxbJdnP/2MI6+G13tSkMQCrTngN777AaOnX2JYfeKqousFlJWCJe740eU1fV1mEW6wLInRrCCqFBpsmeYprz/9K6Ttt1lsVTbmCZVn4JT7F9Xv/dbvk9kRHz+9pi5kGkaP6GJEq+nQLQvSCP7jv//3mcxfsd3knLx5n1IsCRYx3arP/NmYo7NziiJgeP4B+uExQrC3Dvzb8I0gBdvs0+p6LNmRbLfkWYOWWbETK8RtjSjpvHu/z8QvKAUTOYgoUp9cqWFlEw7uqCsXTTE5OOjxQsnYrvYvhVbTRZZKPGNIXgrUfoquJnQbNotXW+JwwzIO6DgG9VZAEivULKHTPiLNctJExLK6lGGGKMpIuUSaLtDFfYiiSAaltKRQE3qnXdKVyKboYdQVjtrk8vWc569mHD9KMBYazy9f4Gclgpxi+AFBsUZ2OozuYjaZTxhH1MN97ZpsS0GAd5KRJze0dR85s1HMksHvHmKnDv3lBMk9ItEEkjIgVwOMArzjHupkSqOYUMRbAv8W93JM8JunvH69j/mlzYSs3aN9MqRVFnQ6bcSTJ5TJUworYrsKOHkgkM3u6JYHPI8CBDPi/Fu/jbha0vIcfpj6sBARjpp0em12m33fgGy6OI7LKk2R9ApLlxHECtWoaZ03UASbtaTTOTwmXy9wLZWtpyGlCbWjUKUxXU8hyHIGHQM/KqmEGulrg3/MQmCdaRyYXXqHHsv8nDgr0OOU2cUd/iQkqUY0nccoWUAaC7RrjfFqQ9sd8vZb38Jf3SFuI8h2bBOdNNwnSxfbO+LqgJuJi2k36XQkJq+/xD0YwtxnM0+53+tgHljU83sUbCgKnwqZdRzQS0SOOwf0nQ5H906xiy4Xr+cEyb50u1uPaDTvEwSglRaFLNGxHRRB4vXsligrOGupVJFIFbts1gGNAxezbhBX0OgNaLTbrHYi4+0ECg1B+iVTNBq6zu4uJ4rGiNgYYsp6USGrObLjoDgxiaAwDl8RFwocHlEaDlJQE+9mxINTinmG1zSoMgUr6SDbn/x8fUVJqDEwbQ3BVyCJadgm+kLCCkri1ZZZonLw4A2IN1RlQhEXVKFALeioRUkZCYSIVGmOln9l9S2r++2brAKCXQ5VTpEsqBSP5tAiTnLICybJBsWVWJURRlUwKZaIyHgqnD/00BwXQYTF+IY33jjj/OF7HJzu9fCqp/GDR0M+/Mk1flPE1CQG3ZyB+BYv5ZTCkuk4LeRjge3Vgrffe4Bnvo02jvCkCvt+g26ZYjgiGyfBPhI5FjU2X+8bSGO8KGe+gk+yJU9q8MISs9XDThUMcUszP+Lp0wTbrCiTNoreYDcXOG29DZaIWD2j4Q45b3gUQYVd7klBQKQQa7b+Bt0y6ZgWmipBSyG8FTAbOk3Tw7Ecnr14QVWDadlEQYpbyYTBjmjtI5tN8kwjqANkwSCJviYiUxwW8o4sLFDdIx7eq7hBQlE9MlGgrF2KVU64NFEUFfH2NX7LZl0koMRoeYVZO5Rije9DKRVc3O5t6j99/jndIwMxXfPB2ZukmKiDE5aLHaswopZUZE8k3t5x88kdghKgWB2CYg1CgCA4nJwe8OT9J6iiw1998hlXn31JGuz36Xb5HJoFwnZHt2thhxWz8RLNKdhOd7iNIbdhwXylUycFfhDSSY6Q2xaGlCMXM6KFQLr1EYYDrp+PYbsntr8N3whSCKYBqZxTlz0sapJ2SpgbVHXKylhi+BVZfctks8RJWpRVyGxyS0OXURoD3DufpJkhLA4ITOkrCyt5/6Q8K21k18ZKYo7Ph+yCiKoWEcsMtWHQoUkh5IRxzIMHD9GupgjrO14HO/qdFutgi7P1se0mgg8r6ZYqDGj39mXPL1/MqaOEZBWht1Ta3UPm8xjbMRCUHG8tIUc5qrTF6TY5xiP3p7Rcm+PTAZ5tE+ULekePMXSXRs/Ds/YGKFcfrvFOW/zmW+8iJZc0vFOKw0cE8xnxNkNq2zx5x2V3U7LVQt64p5MbDuv8gkNB5eT8mJZ5QL3YcrP6hPilS+pVhLv9a6eluHQdne+oAzqWRlQZ3EU7soVAGGuovQe8msg4Wo3dOGIW7SDNMDOFn370GqUh8NbRB8yMDa9GI6qbORV7Tf8yAV1xGK1nZDdLasVC8hQYlVxtQ/xkzBtvPiB/OeZmfo3nqCh5hZuIfLlZ0LCapHqTxXhOikqQCchZSFXtk3SBoOAYTWQHnj17TejP8K0WuQH9ashCEui0DyA+4OLpa5qVTdPq8v7RfSaLG2RR4dDU+OjSpzVwUMqEB0d78ZJpxWx2t3iDB6ztik9++iFZPsGrZZahgBAlnB0+ZpXGtH+9T5ravPXOO0zmd2xejMiCiFml8ceXM7abGz5/ccsq3mJI+1D0QL7Gzbb8V3/4bbKZz8X8DrdjkKxuCPI1+rrJaDnGabs0zjus/ZThoMVo+QpJ0ihnAlflHLF1SlVecTXfUE9Gv/B5/EaQgtjVaRY2FQq7+oaucEzGFjFdI0caQTlnk+p4ORj1HNQGm2pJnHY4QGVXWnQEm7LRZlT7SFHBKNmHD46uYisStVSRTrcUWUKldRDFgiosURWLZLOAjkqw3rKe3rFdTHC1mmgT41omqmSgyCrryRpHtTDqhCjcJ29evr7ERwRdxj1oodouWioh6gKeY/Dbf+8dbiZLKtWgaTvYtgL5Aaaj0tdc3JbMq9sFmmTS73Uhz+EBwRkAACAASURBVFjO9rf4eLkgaTm8NTRI8iOaXZ2Zv6RSA36z20dtdYiqhNytkFQVz2hSFSly+gi1p+GZHQ5chZ1yx3acY50JrCZT8sX+G2lVIrgqVgl5XiIlNZncR+9l9Iw1tlBQb1WuoxKlXrG9uUVsOVRlxfCoSy5bGJWDukoxagOxeURa7PdoFdYY5Q6KGs322O4WVGlFXZYooolY5sxXC5KsIAkT0sinY9jM0wSrEvGzlHAbE6Y5yDpilBIVCiL737qsN0g1xL6IsLkmTyOkowJPP2bxcokqxyiLCNIx5d0Fw0GTcjxiqwicyjLLyYSsFDlX5lThktZZk2q3L9s2bA/XaeF2bBquxMv4Bl1X6dgesZSzCWSmu5AcnSqa4TlwOxmzurpD0kq62iGS95WvYk6C2ZEpGgM6isnn/+KrbwiJhFw1ibMG0S6h1BoMvT63CHTlLttohyucoMgiZuWylXfkoUUSy3RFk2a/y64qIXcoKhOrDqnPfsnmPgzcPrmSsrsBVVGItysqPcZxjtC1DYulQ5ELSLaGXHs07Qjv/APUTMXUSzo9h2ilYGoZJ4nLH/MKPdv3PqhKhlDExIsVaq+gTg1cI8HGJmPFZhMgpSaqD+vditjPaJk9hGIDBMhiC0tXqXUNvWGhlymtBmj63kDkT//8p5iOi9ZyYBkg7m6JNnOqLIOGyhvnD2jc08lLCUWvcWUPUZQJdjG27rCLV/Tb52R5QhTnzKYZ6W7/5FvdPUfdpZRvrnGaDUaBhK8vqWYj5PPfQN5UmMoEzTIxhRbHtkKR+FwrCt1SZfzjP2dSZES1zyYOUTYZixefMwv2DlXidk6w2tDx2sxjB8WFJ8q3yIuMhVJgWjlZrfPIUsAU0Nx7zJNr0osMtanSE46ZjCZkcQpKxXY1A3N/iwtiQJVKeM0mqlYh6hCEEUHh0x46uA0JfzlHVWWODntQ5YgpxFGJj0x4NYOyQFZtdElG63iIQU6V7/MiLSnFl2JaDZeOXHInN1DYsNpe8VBbolHhlCu6gsjg0KVjlMimh+LfoMsip0nEXTLDLQqi6BIjusE23vr5+qE/4cWXOzQvQalM5pd/gSEqPHWGNMw20zTg8mc5VHBgidzpPuEsospsYhUGnsX8w5uvEqWZjtUeEuYqi69Ndfuj//WHHD045N7xnKIuuF3seKN3wGiScXc5Y3g0ZOg0ifw5P17OMfKcT64/YtByaAwP2JRdomSBWsDAkmgeNPjow89/4fP4q7kPv8Kv8O8JfjX34Vf4FX6F/1f4RoQP/+U/eZ+sjNFtF2EbYEkCOyTaiYIysElmGVZTovIGVFWCUsmookIm7tjeSmRxzDi6RspF+s0+qpSx3mX8T//8YwDecv9zMkTyOOU//N4PcLoGSkNitZ1y7HVp6BbpbsPlKkCvKgbnxzhlwHY+x3Qc/FWI0nTJq5LVUidkzadfPIWsyb+d/PcA/Lf/5Dc5fec98m2G4wpUssN2F6KoGrJqkUVrElXi8fG7FHXCZnRLp+GCnCHGAvFuxy7I2QYLmvcPECiQ/JD/4h//jwB8/MdfzU9cRSn1ZsssNBGsAkvfUG7v2BQilQntqE33oUu09aiVGZWfEFcym0DAcGDrp7QdA1WqaffOqRSXf/QHX4mk/um/iUniBVmSsp5N2WUhjc6AKlxRySJ6UWGrFk2tIq1rKrFk4sesc5GySNjd7YjLOZ7Zp394gCTXPHrwHf67H3xlePOP/yl8+7u/w1HjIbUi82oTMZpMadkDMlEjjSKSuKbZMUAwkNQSUxUYbbeESchNtETLZc4GNrm/ptsSSe6e0nBV/ps/vAHg7n/7T4mnJderLSI6ZRjQsA6oyjY7M4JcptG1uXrxEr3WOTp4l1wMuR3fICQij07uAROQE+a3t8RZzucv/oL/+l/8f3wo/n/EN4IUtM4h+e4lWQ6O3UXMclTNQ5YLbKnJ8IkLionR6eOYHlW+JLpZEfs+EyUjXkVokoxa2wgyZIaB4+3VgG4lMw9SFCFgtatZpRtapsp2XRDWF/TEBuHmivUixVU0jG7NStS4Gc/pHiwJcps3tA7hckOS3vLplzdMF9B0sp9/Q1c8HNEg1W2GfYckN5HxSbKAWjEJ0wCrsMgzHcsZkBsZhuxSWCqxf4Wf1kiqgqa7NBUdsa4p9H0Ty2ZrYFg5RnHIvOmQqzGOpUNVEikxpiWQFzvKpkdcm5RuQJbqiA2bgSmR380JwxjJbdNwZeos4nL0DK+xlzlvppesFxMUrUYVdoi7NfH2GuqcjT/F1TySlonqNAn8mKZnoYdb7FqnMAyUVkYSKcgKaG5NHglMZvu8iCYNWa8qXNdF2kqslhnjMciNGsl0WUQCXsslR2C9LhH1CuoVYVYjpi6uLKA6ElmuUcg6RZUhCDrBci8u2gZNKkXFx8LMZCR5wDYTUdwWieBR6zJO2WY7/wKl8wTJfsAmmkKoYMklu8LB8jTMPENVQKoTvPb7wMf/jv793zx8I0gh0B2W03vU8ZqCirooMOsVxmEbxepx//5bDA7vsckXFKUCwiGPhmvubkNmo1tCW+SvryCRfbaXPt8+HnBxt5+IY/YE2p7CQ/c+9iBDKxXajQcc2nes8iXr3UtiL+TNJ0cIsYqUlrSGfV4srinrPuZpF2coIkgiktTj/v0IdbiiLTT48d8kpmu5hWEcoTS/Goqrpz6d3psU2zWTUGU4eEC89SmvROg6NKTvolsgGjq32wxEjbar0W1EdA665JuSRNmrDePgc+Jdg7m15ipNEUUbtXNMrDmM0jVGd8h6NCPKdyjzNUIMxXZN01M5O+uxLVZsix09GaxmH6/yMLnhev7X+33KX7CJJ7SVDqPZAk2pkP0V68UUMcn4rd9/H0GsqfwNgpnx+nZMmQh0ToZoTZtQVikaTXa7mOnNp2RhhtzaZ71/83v/gFeTKVejAsPu0JJFdkaEv7U57B+Szj8lyHLynoHZ6RIVBVHV4rhjUAsFm3BOQ3YZvZzTdNuUa5+TvkdLj4H/GYC/fGGjtRQqzWFVl6S7kGgTEI/WdE6PWa5LTDnlWjtlUOv86z/631EJeTIYUjW7vLy9Q15BxzHYrGQ8uUMu70nn3wd8I0ihnhXcXL1GKzIaJ6fkgoofxejeAZ5UcthtcNpqMMPgbrSkqGG+TAmjGK1M2FQCbtPk8uUtm7sIWRQI5vup06arY8g+CBKpJHDkaRR6hRE3aNs109UFxS5CPrExrYTKlKmbGiJtioaHVgqsQgXDNNAym0G1YXIVs9G/5j8oSWSSgiKJ9PptdHHIdhXhS1ATMV8KZPMIU9ApwzXLIkcZKSRVSDGfY3dzZM9ks0zQOjVZEFCW+96KNJjQGWZMEoWqigi2FfrBNUGpcLNM0bKXKKLDTFmiK4/RpAVst5ydv8UuCClaR7SNBXEgkis1u0Tk2fKCYrPXEUjFEj2Yk8opw75KEWlErobsV8hxgF3VbOs5h3aLxLZpJDmZIBAvUvJyRlJJ1ArkYoaU1niijOHuD1SudPAOVBr9d1lNcyhiLF3DdV0ux1Nkw2PtFyQXt3TuhewSgTpWcBsNptsEaLKcjyirkixMGa9veef4DWR7/6Lqm2eUeUrqNFimM2S3RkkDwqKgEhPabR2t0SKYHiM3JTrVgFaV4rgGmSISPC0I44yqFsnDnG0eMd/94n0DfxfwjSCFi9sxu13MqqwY7BIoBWRVpttSUTuHHPb7OLrO5fMpA8cmS0Nip4XnNPjhqwk3ATRbR3zwuMFNZ0NUCygq8NFXvQOS1yZPdGZ5xO+e9ZlM5vwGFT4RYbCgoXlM1ms+erYlCzKGw4J0+pc0hz08R6A77HGvblCrFre8QCr6DBoZSbIPH0RjwF0g4NomFBKxn2FgoqgOlZ6wez3npPeEH/7bj/EGJzwYaPibFSN/xdBRaFkWltVHsQ12fgmiQZbvlXpVtGWTidB4QH0TsXNidv6Ms8MTRh2Pd04f8cXyBQ/kLupQZXcbQajxl599REeUuPetQ+Qo4WW14bx7xM3lHW7XYqfuCz+L3WtsU+V2es2jNx6TSXAR7ugOuiidJh/+5M9wrQrFHOIcDemKOome4dc6Uilg1TFVLjC6u6YxtBCTktnVXgfxl5dbVhWUL39Ko7I5anXp3h+SCyJZtGO9W/LOO0NqweWLz54zPDygYw25vB5TBCK1LOO6xzz64IQXl5ccNu/x2S7kVN8L1YRVTKoXzLKIjS9idFoU/Q2qI2MPchxZ5bNPP+b+Ow7r1wsSs0boWkhKTRDu0N5tUUx9bmqTrj4Act79znfh//jTf3cH4BuGbwQpqNEW1SzRRYNms4mQpwiCwCYSEW5uGNkmt50zbkdjJDnD1AfYZwbxNKDqOASLDeZsgWcoGIcOry5fMdnsBSedwwHjuwmHzgChEhm2PARpQmMo84Z2hnIzQdHhy1rh2G4iKz5zcroZaKJOOZ8wVnbUhYBrSswskek8pt3cO0bnRUqsC+iljCJU5JJCloqsg4I8zEnzgok/wWoJaNoSxeph2zYnRo7et2kMHFRFplZqHKNgsrgjqveinIvwAndc0xqmmJaIaXooZsKn/gL3XoOJAZ2qhaEIrKcTNHfHNpSxZI+tJFPcZdQPRB7NupTpClPZ0Dm26Zr7lto0T9mu5uxEg0WwoixkDF1mmeaooootqvhZReCpKLXM68WYKBU4OBuQ2SpCGRPVPr1SxWj00XYhobIP47TeACdX2fg+jeERUtYiKwtajsHNds5qOaLRqDgY2jw57TA4GXDcOuSPvvyEdSZxIPTYjSZox23aTQ3TPWS3u2az2d/kaRawSiJOH/Z5No8wdgqO4tK3NeoqZVmWRNKEizCmlEM6JwM0WeDTly/YFSZNOaesU/quxZEmcTuKKde/uEHJ3wV8I0hhYqZ4iULDsFlMX2IJJcPhETerMRUmf/LxT3h0r+Kz0S2OabIJdjS3PdL1gvXoGrvecXxgsppvMY0ES9vRanxNNtqxyYp7aO2KWhFwPYuTgzZ6s+LTH78ilw9BPkFeXJM+OKJLgLErOT7wsE2P+XhBkayoix72e6cERUTr1x7SMobwZ199Q1RTyjxANhyKssa1LGqnhdNS2WxW+NMZZXqHHrxEqF3iYIfgmDidA6yzJpoZMU6m7NY5iupSO/ZXwqe/wdFgQPekh3LiUD46ZDhP+YvXn3NTBsiRgnleEfuvObz3HdLVM15fbEkzl4f4yHrCJhSoZ01ury+5/+g7HL/j0Xw545N0L17yyhSt4SJnIrZm4OsySl6RFSGFGiPLIZ2uxrFnI7gKRBtKUWZ8+QXtXoNUqEmqGZoM2WpB0zGZv94TW+OgT7ndYfVPODm9x/Mf3RFc7cjTHY65okvKYSNDnP+YXpZwtAsZOgWPnZCla3JbrBBVix9djDhpmBRCTBgJ1OK+b8CxJTy7hV9KPB42eBEt2CkrIj+gaWeIpoT+dsZG+JRmx0VqFCw3Mg1LIX5xi2QcYSpglRnN5pDPf/ohdfKLOyH/XcA3ghSsRKE9aOOVAlqqk2U1S1XgweED4smULy9CbuJrDhyZm7uAtNyg2y7+KiIIY6LtlsRKSNMV3XKAIqQcWz0+/JtG/u7giMrasvJ3bNI1vljwtn3OaDljJ8B1PCdWG6ynBvJA4HmgMhT75PmKhuYxXt1huzY7PcPUwfWOqJUBvYO9Ws/PQvqeRpzsiOQBi01Id9hGrmRSSUcqDDRZYC0YBOGGoXgPxW1gGw0yMvwgo+1o1FpFqZfUuwpB2/sEZHdjniUpoeSxUpdU64ggFRjKCYan4wkqvqpw+fFfEd7d0nFbVLMrht0O4SYlbYiIpYfevkfh96jLjNJqUW/2Mb9tqexiFcUUaHhN6jInTzc4SJSJSGqDZkKixMiqg+9k2LKC7rY4ftTj9uUXICqsN1v+n/bua0eSND3v+D+8j0hfVVm+7ZieWcvdJUUSXFDSgaAT3Z+uQIAgHUiHkkCCpMjlkruzY3raVHd1ufQ2vNcBpcmuM0LAAg1O/C4gApkZePIzb7yfIKds1i6huFsXsXOXrSRQ1yLL1YzJ4ookjhDEHFN1MMxjPjr0MJKQ2c0V5FN+9XLFOC7Iogy/cphvEtynFgQburJA21Up3is3n47A6zioA41+O2MTLXmRRiDHKGZJqVWg1ki6hF5K3KTvKNjDyGP0sz6j5ys+9g7RFgK9Tg9HdbDeK6P+PvggQuHh4xNaZYltKWxGPpZsoHdtBKPHKBwTyA6LN9doz54RKjmzuc8iGVEna3JZZCGUTBYLHMNBc+DY/Yj3z75QWnBq90mljNTf4t8GrD4LWE8myHGEOFII8hmd0wMq30CMSypL5rR1Rk6GrhS4dRdnPyNTdMpyRlUkVNHuH2QThUQFaHVJ5fWRpBRyCb1nct46QL2csn33hvRuRC0VbPojDo469FyFuKNgorAs5yi1iOTqBKstRbDbfbi5mhOUGduLb1F7RwydQ2TtNcFCxTjuofoZhqoTz+84ykz0ckTiuWRFgCaB6A7JqoJTzWH09o70MCIv31Aauz6T/nxNf/gpmSGwTFLCqMBPClpajaJWJKJCaDuMkxBtOUbxVKZFjBrekL3ZsvYXDIc2VpIjpDVitaYn7F4a67cPiOc1byYTyqRG3/cQyhBH1rBdCy3fMnn3FZ9/ZDKfGYyWY96MKuLMpdNv0xI0EtdGaXuUpBQqlLqDJOyakqqCQRHprG7uON6zONl3cO2HhMaUu/g1fa9FZWTEWkFubWHlsJ2L1LXMoGMi9rrEa1AUhaAU2D96cO+kru+DDyIU2opDGAW4qkZdbRl0e6ilwSxes//RI/7zf/l7lCzjL5K3LDYFr2/+gQf9x1gtkSf7Fg8f7iOFJa4tk+cFpqgzUHfF5EpfY1lX1LnM6ckJJ5+ZbLY27cNP0cU589WIdQ4tHIK84sHHP8LUJJKLf0TsSuwZHq3TknEp8+76FUkccfi0Qxntau7FJCNbT7FPz1gnU84Hhyx8hXK5ZCDHtMUbtuk7jGjCu+madmfI9ttbjv5Q4az1mA0F6bZmshmRXo4owxV1vWu8cfbsEXnZ4Zs3GZ3U5/r275DMgB/96U/4+ssXzF+E7FkJv7QMsrwm3OZsJYWrb1+yllXk3CO+veFHT9v8jy9HrIUpf9xV2Vd2la+jmzEPWx8h1hK+oLBVCx739hiXWxy1h7S+5Wo2pjs4Zdiz8GqFoTsky2OWmwRyDT0WcW2FulYY6m2+fPnr767/6uI3LDcxv/72OdgqD/YrbCtHNl2OTjyEQOXckNGvfM7qIdVC5Wmu8rWkcrla4Ms+rYMjcsdkGdT4ccwPnp5RjXZrO7fPr/CT33D6ww7Xr/v0zjS8o5hfpxtC1SDseih6ht5NqTWLIpapjILOeQelzujs2ZSFiiK3eDlZMbpbsS+3f1+P/gfpgwgFt9PCFFW6jo2m+HhZwXy9ZJtqWK7Fer2iSFW6R0NULecw+zFW36InhIShTTZZU2Q39I0BddcCPyLJdmsKxoGOMg4wTJFSkPH2NYLLNWZboIoKel0P3RKZLgQm0xBtuMXNNOI6ZTDx0Ns5Pc9gIOiomcFMCegcPiV6rw9kX9AZtCzUUkazZNSy4Oz0Mepii5hskVQBGQll30PxffxpiNUJuH7tM/i8SxrP0BSdlmYzrdZstxmyuBvuzKIAyorffXWFNvYo30756E+esb5c01cl5P0TrhYrpnioypL1128QjT43b3VGxzrq3y3QSpmvKhU0H3XlsDVSrP7uzIR67qPKLcS8YqOYyKLI3eyKUqrIex6ClBIkCfZoRt1SocoQrIgqUZBjgdpYo5bgILLNQkxdxRV3Q3uxgk0+RmwJiI7DKPuGR+6nzPyA7nrBwNEICxlTM/ndr6+4/HaM2u5z8MlnjCchql3SNWtezyfMNgseHR2STgLqaHePPKqRpH1WcclBZ8hmMyOb52RGTuuwz4ttiqkYuLWLnMrMZzNMq4NUeEh6ReIXFGuBQIxRZiWu6hLH7zVV/R74IEIhnl3RtjsU0Zp27eK2+5iZwEDo8Woy5pPDH7LepsRxj7Koefbzx1TJEjOYcGY7tI48kuQYRS9ACrl88wWKtNumqtcSYl2SiT6H/YdcvrzGKwq6ic1k+4b92kFr9Zj99W8xF3MOehK1nvNsr4dgXTNfZCi6Qea0OB9oHA2G/PWLWxB2dQqVXCJmIUqx5fToU/r7D1A3ITfZgnx9x9V1ykqzEBSL3pFNVa94805g05LpvrtA67eos4CzPRcl6pOnFbfj99qxGS5/+5e/wryZUec9Dva6rJ7fMv2twKMff8b1+gJ18Cc8dY6IlSlROiNPFPb6FYeKii+IRNGUl3//G3xJZrQskf/8Eai70c7Fi3f84o/m1KhcLkfUnoq8+AqvvY9KymF3wFoc8dgz8FchyjhDSH2kg3NONYGs68DtV5iKwiNRRJ2NuH7zfPcZdI9O/5xT6zmVWXAzc/mr519gSx7PTntcvtrSo0ssxBzafY5/vs9AsfmPX39Jv6VzI3rMZxlyy+DkfEjfLUnnryjGu63bk0+fsa1qMqHCKmQ2dc3VpcQP/+CXfFHf8MQrqQ2R2V3Ni+Utp09/hFnpjC8SzjKdbSEwPBjAbYa/uGGv7aK1dsH5ffBBhIKHRSkVVJqLWleso4q0qKjUgiJ1OTAMDj2FbeSxNSr2pA6dvS6aWyIXEvKmprOvEGk5aeijWBZl9l77dbVGUTT2GLD0rzgwAXuN7kg4x12EWY6qOhRygKQs2SQJq4u3fHL8MW3doB5s6LhdrDOHZVdECGM0qWC+2i3SBamBolsopgliRlZFWKJGlpSQ63juHnGSIJQp/qrE6eTUaorox5hVjZIVDPtDrjZbZmVGUULL3pUg+8BiGrFMbnBXIvFEYPi4h2CuCWfXqJHC4s1r/ueTd5w7Brqn4RUyqyIhW8+glAn8Dft2hpMJyEfQkRy60W40cuwpRLMFy7Di5PgjsipGtvfpmQZhHqGNCp7oPY5OnyApAnfbiAP7iFjtMZ5PEIM7+nobudVDWN4y6Lno4nsFXnmJZgRUfk5baTFSRfaHHYS1gB/W2LqFWIqkVwuOvXNO2zpvlxf88uc/4/XiilkR4zg6ZbeL7tkY5SW1XtPt7F5hH4UTVFElrxU2q5p3t9dM2ikP/R6aJUK3QpUtbkdTFL9N5mhUYkVxGfFi7rO8E9gkKUeSx9PTPVKp5sD557dH/5fggwiFu7sLXPkRd5tL/DhAUNqI0hGpsMJV9jnd38fSTP7hiwBllbB6cUWu3jDYc2m3QdRTJncTbu4u6O1lPHg4RA53oSAkMpYmQJ0jFhXt8x7m+RnVZsn43SWeZPD27gWGa2JrT3i7mvCDz4Y4j2QO2z3EqCCsV8zTnHSlkzkF0qDCSHdfXxJBmAa49pBOO+Lm+ncsI41wk5EvE+pqhZCvKVYlvW6PsW/Sdl3cukLLRCxBxjR63NyOMVii9xXG73ahc7sWsHoeJw8+oyPvYR2GGBcrzh4/YbadM59M+Vf/7j9gZTqRkrANbeJ8jLRImXzxFXu9Gmu+Qj3Vabld4qeHZAqE762sf/rsmNnNmNW24Eh1MQUVvX2CqzmoRcrNi5dojoN/U7MMU+a/nXNhV9BdIcsp/nhF6CqEFyFP+n1SL6Wc7uoUFF2klEX2qwCjNBgGAuvtioHV47//5Tf8otuj3lSo6w2xnfH224jxOsT4xSl305yzf/1L1tGcVjHm0O2Q3N0wXVSIxW7OX3RtovkWWc8p1il1UfDj/mOEoE14lfFZe8hmteDBQkTJBohf3DFJRVYvHfqtfR55GnG+QdMlmC/xc4Fnn/7g9/Tkf5g+iFCQDRm9SKiomSCgaDlDS2FyW3CopWj9NrPFnMnlDTEispyymlzjqfuUloW4XZB3rgkWC0hTTgdD8vS9MwzDb3H7LRx02r0WA8NheznHdUVkQyEFtoJGdWwQvrpmr61wN59x92rN1/ENtengayWfnD3AHVQsapHajsnq92rivQ6GYVJWEKYimqKyrSUqQ8Pp1UShiXUnoR20WS19+vtDzo8HhHKMYtoESUQcrsgEEdkyqOsEy96tWQzOHrHYbDgUFnT0gm5kcStPUa9KHjz4AaKpY642tL2KpFK480NuFqN/WjxTY7iWKKWcB70hp3/4U2b+ksjtEZm7adbQ7BEIXeRiTREsUY0uWm5Q5TmWWNLu7NEfnoLRoSoLtP3PKMQKt9cmmK7x2iq16mLqEBKR+Sa224L/25LN1gwKTOpAoj9ocZm9xUtFugOXM9MjFVNE1WKeB4jLCcOOTevJGZebHLl1wrMHHb55MWOWV6xXPoZmswkDpHK3fpT5AbVcoIgym3VEdhuTPxEgzNkLDIpvRZxOi2fKL6hXWzbaGKYltXbIXlfiqdTi68kLBOspwUYky1Tk6W60833wQYRCp28gSlCpOn0lZRWUrIWYQnTZ2hp1nHN147OIE/q9AZbYxjIj7JbL9O2STL1i+NikXUBwV1L7CUG4287rtx2EtUZYz7EEheV0Q7KcsZmXdNsmZctmsK+y/nKMOtCJyhDLqbndVkyqiHKZIWsVb42ak+4BUi1hyCFCsduDN3SVgor1fEbeG6IKNkKaUlYqta7jeiFbzQRLpEuHon9EooiUgkitg6AZ6FWJrJZ0RZNIk5kUu0q6ehUTTRYc/sxCvItJ1A193cURBQ4/sRiqf8riIsXc1zBLhXK/xNX6vHoX0x32kfYzkPYQrQqjjrC1I+h6uL3dcWVFVnDQsagFhaskItUliijCzHu8u75CMB3KNVw/f8mqFjhGZBILIG0Iwpo6zhFckTTOWMU+zpGG5zzg/71hGIQrwmxJXFQkm4ihZlP1NfY6h6gPJDbLaxJJoW7bTG8TssrAqGwUr4slC6RvZnQFma1cEc1KzI6NlG3Ihd335PsxWRJT7Vc8htqtzQAADapJREFUOW0j2p/RbQ1BFnk3WrLZbnn0ZA9z26Ll5NipjtSJEP0O5uWUtTfG7XawOxVGOUDLQLX+Wb1J/sX4IEJh8nqK0PMwbJHI8Bh2hyymIT0XFv6UT48/IdQL/uSPP2GzWJEmOcPTY06PPP7Tf/0L9g4toqBEyVo8OjLpOx7ye0eJaV7Mm1e/QdpkvBVlPv78p1w9f04WLxm0znk3+x3jVUVuqXROKnBkjk+esLy+QwljDg8qTqxjzOMDDvZcLuZf4axFjO2ulHqbbVHtp2i1zNfffMme9xhFEPm4f8Z4laCrLQTLZXZRk6Yx9v6Ww7M/4OGxx+1sgmsYSDEoYUFcqyiJha3t5sqXVDjHDqIuUA4kbGWFKqzw3CGvvvorykxnZpwzjF6T3lQcD0KW2y177Qukox7O6U+5vf0VerditIalLvJiFHEq76om5yufMpsRhQlJ7mJ6AobaweqaHDofcXEzIo9jwkCi3VepxRpHUJlvZ2iexyqKWb26xJR1PjlXyBcrDu3dK+zdNCLapOyLCslyS7qWODs+4PFpn5eiz8fHn/Pmf42wXYfblxm3LwLE+rf8q3+vYu2dc303hzqm11UJF2PcsEOnlPnk9MHuHqrCqg4w7QrcHnumQLIYUy0r/qDTodbazL9YYh3ss7mc8vri17zZbtD1Hu/8CNltUVkJN7fv6NPCri289m4x9vvggwgFW7WhV6P4BZs4Zab6VKYNc9AlnSALKAsfu31MsDXoGzm9owFFT6R3eo6tV6y2M0RDQVIVNqsNRfreVhgyuSJBy0HUQFczwiqm1Cy21oLM95F6Nmq2ohZUvrkecdg1MI57HIgSqgqeYtM/NigEH7KCPA3v9wZ099Dx0A2dXuxTlwGS0OJqNOFuGnGsxlSFSC5aJELNfrvFZnFDtJpQ9XO2LYuWvkeQFrT3PeZpQSnsPsOqUNjcZqwfGrhewuZ5TrsMuBADOnrGrfY5cuBz8SLiBIHWgQZ6gvNHQxbLDKl4gd51UPSaUaWwied4zmMqaTcfd10FyxQRuqcs1gaBX6McwF0ImiTi9NsUaGTLOzzZItFiVpPpP/VclAyGg33W24Snp6cIxpJlvCZNNt9dPwgzlFhAKCXyIqASaqbLNc4q4mZ2i9U7Q3Fc9myLK/U3HA08+sfHqGgct21+dzMhteDQ6iDFBReXC7Q8xxB3I4XDjsd6dM38aoPnHXL+yadkE4Hl6ooqSJleX3KxqXjU2SKrOnkq4aVtLNPEcz2kowFhvSYI7pgHMqrdRi2+X90CP4hQqPKYU7XFrRmw+PItndCif9pCf9DjzDBQspLjJx8x9Tf88Oc2smtRBQVVvOWHnz3CjybcrLdYUkxHM5msLxjf7mr6/XiKWvjM/BEKZ/zu1RcslTWSW1HZEkHPZ+gkbIIRleDwx/t7dM5NVvmErJYJo4C75ZdIv/F49tm/YZX7+NN35MruYcyEFD/UmV5c8m9/8ohed8hyGRKJAs6ewsvfvMO0NAJRolJykqWPNzRZRCnDWsTIC7x9G7tQiLOSYjRDfm/68Fa2ER4/5r/9719zYI34s/1z/mbbp4g2dG+XDJ6OuAgK+icHpMcO34zXdJ52UZlxtm9xXXiMl1um6wnywTNebTO0k89xBk++u8cvfvpn/Orr13T3dZRwzfX1Ha/GIlksU8suzr6L5/b47OEZSbxhOl6hISCvtuTjNaUHZrvN1XTEYdek67psWr3vrv/sZz/g25ffUm6WWLKHmdYYkop/fclZ74hYjDn9/IRoLnH26UN0LWe9nfPRz/6QX7/5mtKqcToyV5dfUaQFPTvjZE/Dq6+/u4eoBPziJw+ZIfPm4gY5DdDjmrqWCWa3xBl83j2guhhT9EQ6lsvQg7b9gKot8SpY0O56xKpKe2Axejvl0dmf/74e/Q/SBxEK/U6b5TZkUBa8SQuKYosa52jFhtKwyJIJda0xW00wq31sP0LXfTJJh9DHFGqELERKKupaIM8E7Py9wzWub1klCybXMg+eGGSGgNDS0Psu1y//hqCqUQ6OKLIQWdeZ1j5C9o4kjPjb0ZrDyMTasxF1mVW0Zl0UOJ0Ok+Vu+hCvpiTrNeQC021Jshwx2BsQByvqOCUTRbbTJbGYYNU6RRITLBfolsHAOkCzNMosJDM1jEDANXTyehcK06nP0DkkLf+ORdTly6QAHIKNwM31a2av1njHe7xdXbFcnyP6Y6ZizdnRObMwI5Pe8vwmRZR9rkfP2VY97PGCt+HuPADTHCCYUzarnJ7RJuwkjJMYr9/DyFRSQUKuSlabBZVQ0nNctsUGoYix2i3qImYyvkSqa2q3i9Jx6D84+e763UMD6SrDn68QM4uiFKhzm6yW8AyDfkelWNQE0xlRJRFMZsRVxo0/IU7XyCUInkONQBDGaBqsliXa7swcjs9PkNQEoUxQPnaoQonVu1tkoUKyPZwqRAgEXgYjTooBTmCzkVK28RSpdOgKBatXc1RBoXPWJTQV8mpXWfp98EGEwnaVols+mTrgo0dnEJusl2tev3iF3e3geYfYqsJBpbO8/ZbbYMy+9wTHFRhHC4oiZqjbKLJHNI0gg3yx+2gnj4aY8z79zojZ+oK2J/C4V3A9/i21kdLTXHRnidlRWMQ3fHI+YDsPGF9+zTFtSntLt3NAXlW8mvwjHV1nU+a4vfeae1Q1j5QC8/Ejjrp9yrggSFU2vo9SSKyun5OjstczKfwAK+uii20MVUaWDigSAaHbxtY7bIo5+Z5EL9itixwdd3FUl+u3H7MOvmZWt/hxy0RS99nWPtm7d7yM5rhTm/H2Dk0vYCZzlM8pSo+DoyE3ks5GvsZ2f0JRKggdm4tvdivrbd1D3MgIasJWCNAlmbOjIbrh4JhtFDXHMYd4LZHbaYxUxohZiiQoGJ6EXRiUQU6VZMRBzaIq+MHDh99dv558Q7p5ztHRA0Qk1l/fErFBHT4kjDYUk5QkhCxO0Fo+mqlThhnR3QiBguO+QmUJ5JuKzqGMjIAuFTw+3b1fkRQ5hukhegrcVoSCgdg5pCWbhMmG8TTlLrwmiEXm85Kb6becnp7S8jS8CMK9AbZ3hlalyEqN2/F4NXr5e3ryP0wfRCgg2WSbEl/OcVKPEpme4qF6FZLURbE9hDJjEdXYlUhZD5lECxIGKLUPcY2fJVRxQB4XGIZELLWAf6oIfHx+gNua41+ZpO02WgSVldN/VGAEJlqrT5WM6bXbHKhPefNmjGzq9M5+xEFbIphN0BwTSVXp6D5lmtJ/eI7h7xbpclkhl6AMQ9YrCaHSacs1aVARhxGCoKHVIvN3c9bbGJ7kDPyIWnVQJOh6Kt8uVtiFxCIKSPOI4L1DSLCeoFg6Z09OKeVD9oySSriistqcqKe89HOqIGJqVrSClKhl8+xPP0LeuqjthEhQ0E+OyM0TNpGDg4vrPmH7YLetarU8hmctRBGetEwWYc7zqzlVGeCUCabZo+XltHUZrVVQVimJpXF9t6CkYBmt6PVVpNKko2m4AxdR39WLiNQotUmxlQhCEdEaEAgFSVKgrTXiAB47XWLBZzSfULQ9BLEgKUtct4vhmIiaiC+t6NhdhCLn0M0x3iulTmKNUIWktIlClTiI0ZVjkr6C8EZArkVMR2B88xLDVLFFh3CeopYZLW2AWRiY25JcVql1Ay3LCEa73/n74IMIhfE8RfU6VEJKHKc4so5QWmSqh5jGzJ+/pVRk7oKCcpUhGwbp/AbHes3xvoloOCyvlkh6TSkXmKh036tMvb27QxVSlL5AMtWR3JzpekarZfH44w6t4T43NxZytSJch4hOyuIu4LNHZyyuX7EoMrIoQwo3lLLHaDnHLE2Cze5fNlwWfHMzZU9fMlq2kCqdY0/ldrTB3255dzVDLyWef/2Sy3cTfhxndPstWssWsquTlgdMkw1bPyRKYiQ5oRR2C5lxpCDrEdrRY+5Wr1jna1K5heblFJWIeWRwuveA2VfPEYIafzZlgorq1LB8QLYnkERzsrlGpJtYLZG2oSK9V63XPdtnb9rFKFOcrsexoGAZDlWeIqsCp+cnqLLLQc9htvCphYg8lXl2dkxd5GThiKrSyGQRtcoQ0VHl3Xae53T5/KNPSUKH0VZgevUOQ9URBJG89DFrgU0RkMqQFG3U0kXVDQqrQ//klJIYnZKjY40WOUK54aivobD7HfTcIysVBKEm0AUsOaEOO6TLlFIsaB3tISkOs0mFKug8/fgRy/Gc8+NH1GpNlGZ0tA4dS+TA1kkkj/V7/T6/D5rDYBqN74nmMJhGo/H/pQmFRqNxTxMKjUbjniYUGo3GPU0oNBqNe5pQaDQa9zSh0Gg07mlCodFo3NOEQqPRuKcJhUajcU8TCo1G454mFBqNxj1NKDQajXuaUGg0Gvc0odBoNO5pQqHRaNzThEKj0binCYVGo3FPEwqNRuOeJhQajcY9TSg0Go17mlBoNBr3NKHQaDTu+SDOfWg0Gh+OZqTQaDTuaUKh0Wjc04RCo9G4pwmFRqNxTxMKjUbjniYUGo3GPU0oNBqNe5pQaDQa9zSh0Gg07mlCodFo3NOEQqPRuKcJhUajcU8TCo1G454mFBqNxj1NKDQajXuaUGg0Gvc0odBoNO5pQqHRaNzThEKj0binCYVGo3FPEwqNRuOeJhQajcY9TSg0Go17/g+IKvBu/mtPMwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# visualize the weights of the best network\n", + "show_net_weights(best_net)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Run on the test set\n", + "When you are done experimenting, you should evaluate your final trained network on the test set; you should get above 48%." + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test accuracy: 0.499\n" + ] + } + ], + "source": [ + "test_acc = (best_net.predict(X_test) == y_test).mean()\n", + "print('Test accuracy: ', test_acc)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Inline Question**\n", + "\n", + "Now that you have trained a Neural Network classifier, you may find that your testing accuracy is much lower than the training accuracy. In what ways can we decrease this gap? Select all that apply.\n", + "1. Train on a larger dataset.\n", + "2. Add more hidden units.\n", + "3. Increase the regularization strength.\n", + "4. None of the above.\n", + "\n", + "*Your answer*:\n", + "\n", + "*Your explanation:*" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/assignment1/README.md b/assignment1/README.md new file mode 100644 index 000000000..5a9494e95 --- /dev/null +++ b/assignment1/README.md @@ -0,0 +1 @@ +Details about this assignment can be found [on the course webpage](http://cs231n.github.io/), under Assignment #1 of Spring 2017. diff --git a/assignment1/collectSubmission.sh b/assignment1/collectSubmission.sh new file mode 100644 index 000000000..8f8a7e7b8 --- /dev/null +++ b/assignment1/collectSubmission.sh @@ -0,0 +1,2 @@ +rm -f assignment1.zip +zip -r assignment1.zip . -x "*.git*" "*cs231n/datasets*" "*.ipynb_checkpoints*" "*README.md" "*collectSubmission.sh" "*requirements.txt" ".env/*" diff --git a/assignment1/cs231n/__init__.py b/assignment1/cs231n/__init__.py new file mode 100644 index 000000000..e69de29bb diff --git a/assignment1/cs231n/classifiers/__init__.py b/assignment1/cs231n/classifiers/__init__.py new file mode 100644 index 000000000..cef2b5807 --- /dev/null +++ b/assignment1/cs231n/classifiers/__init__.py @@ -0,0 +1,2 @@ +from cs231n.classifiers.k_nearest_neighbor import * +from cs231n.classifiers.linear_classifier import * diff --git a/assignment1/cs231n/classifiers/k_nearest_neighbor.py b/assignment1/cs231n/classifiers/k_nearest_neighbor.py new file mode 100644 index 000000000..13ec31fac --- /dev/null +++ b/assignment1/cs231n/classifiers/k_nearest_neighbor.py @@ -0,0 +1,195 @@ +import numpy as np + +class KNearestNeighbor(object): + """ a kNN classifier with L2 distance """ + + def __init__(self): + pass + + def train(self, X, y): + """ + Train the classifier. For k-nearest neighbors this is just + memorizing the training data. + + Inputs: + - X: A numpy array of shape (num_train, D) containing the training data + consisting of num_train samples each of dimension D. + - y: A numpy array of shape (N,) containing the training labels, where + y[i] is the label for X[i]. + """ + self.X_train = X + self.y_train = y + + def predict(self, X, k=1, num_loops=0): + """ + Predict labels for test data using this classifier. + + Inputs: + - X: A numpy array of shape (num_test, D) containing test data consisting + of num_test samples each of dimension D. + - k: The number of nearest neighbors that vote for the predicted labels. + - num_loops: Determines which implementation to use to compute distances + between training points and testing points. + + Returns: + - y: A numpy array of shape (num_test,) containing predicted labels for the + test data, where y[i] is the predicted label for the test point X[i]. + """ + if num_loops == 0: + dists = self.compute_distances_no_loops(X) + elif num_loops == 1: + dists = self.compute_distances_one_loop(X) + elif num_loops == 2: + dists = self.compute_distances_two_loops(X) + else: + raise ValueError('Invalid value %d for num_loops' % num_loops) + + return self.predict_labels(dists, k=k) + + def compute_distances_two_loops(self, X): + """ + Compute the distance between each test point in X and each training point + in self.X_train using a nested loop over both the training data and the + test data. + + Inputs: + - X: A numpy array of shape (num_test, D) containing test data. + + Returns: + - dists: A numpy array of shape (num_test, num_train) where dists[i, j] + is the Euclidean distance between the ith test point and the jth training + point. + """ + num_test = X.shape[0] + num_train = self.X_train.shape[0] + dists = np.zeros((num_test, num_train)) + for i in range(num_test): + for j in range(num_train): + ##################################################################### + # TODO: # + # Compute the l2 distance between the ith test point and the jth # + # training point, and store the result in dists[i, j]. You should # + # not use a loop over dimension. # + ##################################################################### + dists[i, j] = np.sqrt(np.dot(X[i] - self.X_train[j,:], X[i] - self.X_train[j])) +# dists[i,j] = np.sqrt(np.sum((X[i,:]-self.X_train[j,:])**2)) +# pass + ##################################################################### + # END OF YOUR CODE # + ##################################################################### + return dists + + def compute_distances_one_loop(self, X): + """ + Compute the distance between each test point in X and each training point + in self.X_train using a single loop over the test data. + + Input / Output: Same as compute_distances_two_loops + """ + num_test = X.shape[0] + num_train = self.X_train.shape[0] + dists = np.zeros((num_test, num_train)) + for i in range(num_test): + ####################################################################### + # TODO: # + # Compute the l2 distance between the ith test point and all training # + # points, and store the result in dists[i, :]. # + ####################################################################### +# dists[i, :] = np.sqrt(np.sum((X[i] - self.X_train) ** 2, axis = 1)) + dists[i, :] = np.sqrt(np.sum(np.square(X[i, :] - self.X_train), axis = 1)).T +# dists[i,:] = np.sqrt(np.sum((self.X_train-X[i,:])**2,axis = 1)) + ####################################################################### + # END OF YOUR CODE # + ####################################################################### + return dists + + def compute_distances_no_loops(self, X): + """ + Compute the distance between each test point in X and each training point + in self.X_train using no explicit loops. + + Input / Output: Same as compute_distances_two_loops + """ + num_test = X.shape[0] + num_train = self.X_train.shape[0] + dists = np.zeros((num_test, num_train)) + ######################################################################### + # TODO: # + # Compute the l2 distance between all test points and all training # + # points without using any explicit loops, and store the result in # + # dists. # + # # + # You should implement this function using only basic array operations; # + # in particular you should not use functions from scipy. # + # # + # HINT: Try to formulate the l2 distance using matrix multiplication # + # and two broadcast sums. # + ######################################################################### + MUL = np.dot(X, self.X_train.T) + X_squar = np.sum(X * X, axis = 1) +# print(X_squar.shape) +# print(X_squar) + X_train_squar = np.sum(self.X_train * self.X_train, axis = 1) +# print(X_train_squar.shape) +# print(X_train_squar) + + dists = np.sqrt(((-2*MUL).T + X_squar).T + X_train_squar) +# dists = np.sqrt((-2*MUL) + X_train_squar + X_squar) + + ######################################################################### + # END OF YOUR CODE # + ######################################################################### + return dists + + def predict_labels(self, dists, k=1): + """ + Given a matrix of distances between test points and training points, + predict a label for each test point. + + Inputs: + - dists: A numpy array of shape (num_test, num_train) where dists[i, j] + gives the distance betwen the ith test point and the jth training point. + + Returns: + - y: A numpy array of shape (num_test,) containing predicted labels for the + test data, where y[i] is the predicted label for the test point X[i]. + """ + num_test = dists.shape[0] + y_pred = np.zeros(num_test) + for i in range(num_test): + # A list of length k storing the labels of the k nearest neighbors to + # the ith test point. + closest_y = [] + ######################################################################### + # TODO: # + # Use the distance matrix to find the k nearest neighbors of the ith # + # testing point, and use self.y_train to find the labels of these # + # neighbors. Store these labels in closest_y. # + # Hint: Look up the function numpy.argsort. # + ######################################################################### + closest_y = self.y_train[np.argsort(dists[i])[:k]] + ######################################################################### + # TODO: # + # Now that you have found the labels of the k nearest neighbors, you # + # need to find the most common label in the list closest_y of labels. # + # Store this label in y_pred[i]. Break ties by choosing the smaller # + # label. # + ######################################################################### +# most_common = 0 +# label = closest_y[0] +# closest_y = np.array(closest_y) +# # print(closest_y) +# for j in range(k): +# vote_num = np.sum(closest_y == closest_y[j]) +# # print(closest_y == closest_y[j]) +# if most_common < vote_num : +# most_common = vote_num +# label = closest_y[j] +# y_pred[i] = label + y_pred[i] = np.argmax(np.bincount(closest_y)) + ######################################################################### + # END OF YOUR CODE # + ######################################################################### + + return y_pred + diff --git a/assignment1/cs231n/classifiers/linear_classifier.py b/assignment1/cs231n/classifiers/linear_classifier.py new file mode 100644 index 000000000..defb4c497 --- /dev/null +++ b/assignment1/cs231n/classifiers/linear_classifier.py @@ -0,0 +1,135 @@ +from __future__ import print_function + +import numpy as np +from cs231n.classifiers.linear_svm import * +from cs231n.classifiers.softmax import * + +class LinearClassifier(object): + + def __init__(self): + self.W = None + + def train(self, X, y, learning_rate=1e-3, reg=1e-5, num_iters=100, + batch_size=200, verbose=False): + """ + Train this linear classifier using stochastic gradient descent. + + Inputs: + - X: A numpy array of shape (N, D) containing training data; there are N + training samples each of dimension D. + - y: A numpy array of shape (N,) containing training labels; y[i] = c + means that X[i] has label 0 <= c < C for C classes. + - learning_rate: (float) learning rate for optimization. + - reg: (float) regularization strength. + - num_iters: (integer) number of steps to take when optimizing + - batch_size: (integer) number of training examples to use at each step. + - verbose: (boolean) If true, print progress during optimization. + + Outputs: + A list containing the value of the loss function at each training iteration. + """ + num_train, dim = X.shape + num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes + if self.W is None: + # lazily initialize W + self.W = 0.001 * np.random.randn(dim, num_classes) + + # Run stochastic gradient descent to optimize W + loss_history = [] + for it in range(num_iters): + X_batch = None + y_batch = None + + ######################################################################### + # TODO: # + # Sample batch_size elements from the training data and their # + # corresponding labels to use in this round of gradient descent. # + # Store the data in X_batch and their corresponding labels in # + # y_batch; after sampling X_batch should have shape (dim, batch_size) # + # and y_batch should have shape (batch_size,) # + # # + # Hint: Use np.random.choice to generate indices. Sampling with # + # replacement is faster than sampling without replacement. # + ######################################################################### + sample_index = np.random.choice(num_train, batch_size, replace = True) + X_batch = X[sample_index, :] + y_batch = y[sample_index] + ######################################################################### + # END OF YOUR CODE # + ######################################################################### + + # evaluate loss and gradient + loss, grad = self.loss(X_batch, y_batch, reg) + loss_history.append(loss) + + # perform parameter update + ######################################################################### + # TODO: # + # Update the weights using the gradient and the learning rate. # + ######################################################################### + self.W += -learning_rate * grad + ######################################################################### + # END OF YOUR CODE # + ######################################################################### + + if verbose and it % 100 == 0: + print('iteration %d / %d: loss %f' % (it, num_iters, loss)) + + return loss_history + + def predict(self, X): + """ + Use the trained weights of this linear classifier to predict labels for + data points. + + Inputs: + - X: A numpy array of shape (N, D) containing training data; there are N + training samples each of dimension D. + + Returns: + - y_pred: Predicted labels for the data in X. y_pred is a 1-dimensional + array of length N, and each element is an integer giving the predicted + class. + """ + y_pred = np.zeros(X.shape[0]) + ########################################################################### + # TODO: # + # Implement this method. Store the predicted labels in y_pred. # + ########################################################################### + y_pred = np.argmax(X.dot(self.W), axis=1) + ########################################################################### + # END OF YOUR CODE # + ########################################################################### + return y_pred + + def loss(self, X_batch, y_batch, reg): + """ + Compute the loss function and its derivative. + Subclasses will override this. + + Inputs: + - X_batch: A numpy array of shape (N, D) containing a minibatch of N + data points; each point has dimension D. + - y_batch: A numpy array of shape (N,) containing labels for the minibatch. + - reg: (float) regularization strength. + + Returns: A tuple containing: + - loss as a single float + - gradient with respect to self.W; an array of the same shape as W + """ + pass + + +class LinearSVM(LinearClassifier): + """ A subclass that uses the Multiclass SVM loss function """ + + def loss(self, X_batch, y_batch, reg): + return svm_loss_vectorized(self.W, X_batch, y_batch, reg) + + +class Softmax(LinearClassifier): + """ A subclass that uses the Softmax + Cross-entropy loss function """ + + def loss(self, X_batch, y_batch, reg): + return softmax_loss_vectorized(self.W, X_batch, y_batch, reg) + diff --git a/assignment1/cs231n/classifiers/linear_svm.py b/assignment1/cs231n/classifiers/linear_svm.py new file mode 100644 index 000000000..d748b4a04 --- /dev/null +++ b/assignment1/cs231n/classifiers/linear_svm.py @@ -0,0 +1,144 @@ +import numpy as np +from random import shuffle + +def svm_loss_naive(W, X, y, reg): + """ + Structured SVM loss function, naive implementation (with loops). + + Inputs have dimension D, there are C classes, and we operate on minibatches + of N examples. + + Inputs: + - W: A numpy array of shape (D, C) containing weights. + - X: A numpy array of shape (N, D) containing a minibatch of data. + - y: A numpy array of shape (N,) containing training labels; y[i] = c means + that X[i] has label c, where 0 <= c < C. + - reg: (float) regularization strength + + Returns a tuple of: + - loss as single float + - gradient with respect to weights W; an array of same shape as W + """ + dW = np.zeros(W.shape) # initialize the gradient as zero + dW2 = np.zeros(W.shape) + + # compute the loss and the gradient + num_classes = W.shape[1] + num_train = X.shape[0] + loss = 0.0 + for i in range(num_train): + scores = X[i].dot(W) + correct_class_score = scores[y[i]] + for j in range(num_classes): + if j == y[i]: + continue + margin = scores[j] - correct_class_score + 1 # note delta = 1 + if margin > 0: + loss += margin + dW[:, y[i]] += -X[i, :].T + dW[:, j] += X[i, :].T +# print(dW2[:, y[i]]) +# print(dW2[:, j]) +# print(dW2) + + # Right now the loss is a sum over all training examples, but we want it + # to be an average instead so we divide by num_train. + loss /= num_train + dW /= num_train + + # Add regularization to the loss. + loss += reg * np.sum(W * W) + dW += 2 * reg * W + + ############################################################################# + # TODO: # + # Compute the gradient of the loss function and store it dW. # + # Rather that first computing the loss and then computing the derivative, # + # it may be simpler to compute the derivative at the same time that the # + # loss is being computed. As a result you may need to modify some of the # + # code above to compute the gradient. # + ############################################################################# +# for i in range(num_train): +# dtest = np.zeros((W.shape)) +# for j in range(num_classes): +# if j == y[i]: +# dW[:,j] -= (np.sum((X[i].dot(W) - X[i].dot(W[:,y[i]]) + 1) > 0) - 1) * X[i] +# # print(dW[:,j]) +# continue +# # dW[:,y[i]] -= ((W[:,j].T.dot(X[i]) - W[:,y[i]].T.dot(X[i]) + 1) > 0) * X[i] +# # dtest[:,y[i]] -= ((W[:,j].T.dot(X[i]) - W[:,y[i]].T.dot(X[i]) + 1) > 0) * X[i] +# # print(((W[:,j].T.dot(X[i]) - W[:,y[i]].T.dot(X[i]) + 1) > 0)) +# dW[:,j] += ((W[:,j].T.dot(X[i]) - W[:,y[i]].T.dot(X[i]) + 1) > 0) * X[i] +# # dW[:,j] += ((X[i].dot(W[:,j]) - X[i].dot(W[:,y[i]]) + 1) > 0) * X[i, :].T +# # print((W[:,j].T.dot(X[i]) - W[:,y[i]].T.dot(X[i]) + 1) > 0) +# # print("@",dW[:,j]) +# # print(X[i]) +# # print("@",np.sum((X[i].dot(W) - X[i].dot(W[:,y[i]]) + 1) > 0)) +# # print("--",dtest[:,y[i]]) +# # dW += dW +# # print(dW) +# dW /= num_train +# # print(dW) +# # print(dW2) + return loss, dW + + +def svm_loss_vectorized(W, X, y, reg): + """ + Structured SVM loss function, vectorized implementation. + + Inputs and outputs are the same as svm_loss_naive. + """ + loss = 0.0 + dW = np.zeros(W.shape) # initialize the gradient as zero + delta = 1 + + ############################################################################# + # TODO: # + # Implement a vectorized version of the structured SVM loss, storing the # + # result in loss. # + ############################################################################# + N = X.shape[0] + C = W.shape[1] + + Z = X.dot(W) + Sy = Z[list(range(N)), y] + Diff = (Z - Sy.reshape(Sy.shape[0],-1) + delta) + Mask = (Diff > 0) + Sum_h = np.sum(np.multiply(Mask, Diff), axis = 1) + Sum_h -= 1 + loss = np.sum(Sum_h, axis = 0) + loss /= N + loss += reg * np.sum(W * W) + + ############################################################################# + # END OF YOUR CODE # + ############################################################################# + + + ############################################################################# + # TODO: # + # Implement a vectorized version of the gradient for the structured SVM # + # loss, storing the result in dW. # + # # + # Hint: Instead of computing the gradient from scratch, it may be easier # + # to reuse some of the intermediate values that you used to compute the # + # loss. # + ############################################################################# +# Mask_num = np.ones((Mask.shape)) +# Mask_num *= Mask +# Mask_num[np.arange(N), y] = -(np.sum(Mask, axis = 1) - 1) # note that dimesion +# dW = X.T.dot(Mask_num) +# dW /= N +# dW += 2 * reg * W + + Mask_num = Mask.astype(int) + Mask_num[np.arange(N), y] = -(np.sum(Mask_num, axis = 1) - 1) # note that dimesion + dW = X.T.dot(Mask_num) + dW /= N + dW += 2 * reg * W + ############################################################################# + # END OF YOUR CODE # + ############################################################################# + + return loss, dW diff --git a/assignment1/cs231n/classifiers/neural_net.py b/assignment1/cs231n/classifiers/neural_net.py new file mode 100644 index 000000000..4101caaaa --- /dev/null +++ b/assignment1/cs231n/classifiers/neural_net.py @@ -0,0 +1,259 @@ +from __future__ import print_function + +import numpy as np +import matplotlib.pyplot as plt + +class TwoLayerNet(object): + """ + A two-layer fully-connected neural network. The net has an input dimension of + N, a hidden layer dimension of H, and performs classification over C classes. + We train the network with a softmax loss function and L2 regularization on the + weight matrices. The network uses a ReLU nonlinearity after the first fully + connected layer. + + In other words, the network has the following architecture: + + input - fully connected layer - ReLU - fully connected layer - softmax + + The outputs of the second fully-connected layer are the scores for each class. + """ + + def __init__(self, input_size, hidden_size, output_size, std=1e-4): + """ + Initialize the model. Weights are initialized to small random values and + biases are initialized to zero. Weights and biases are stored in the + variable self.params, which is a dictionary with the following keys: + + W1: First layer weights; has shape (D, H) + b1: First layer biases; has shape (H,) + W2: Second layer weights; has shape (H, C) + b2: Second layer biases; has shape (C,) + + Inputs: + - input_size: The dimension D of the input data. + - hidden_size: The number of neurons H in the hidden layer. + - output_size: The number of classes C. + """ + self.params = {} + self.params['W1'] = std * np.random.randn(input_size, hidden_size) + self.params['b1'] = np.zeros(hidden_size) + self.params['W2'] = std * np.random.randn(hidden_size, output_size) + self.params['b2'] = np.zeros(output_size) + + def loss(self, X, y=None, reg=0.0): + """ + Compute the loss and gradients for a two layer fully connected neural + network. + + Inputs: + - X: Input data of shape (N, D). Each X[i] is a training sample. + - y: Vector of training labels. y[i] is the label for X[i], and each y[i] is + an integer in the range 0 <= y[i] < C. This parameter is optional; if it + is not passed then we only return scores, and if it is passed then we + instead return the loss and gradients. + - reg: Regularization strength. + + Returns: + If y is None, return a matrix scores of shape (N, C) where scores[i, c] is + the score for class c on input X[i]. + + If y is not None, instead return a tuple of: + - loss: Loss (data loss and regularization loss) for this batch of training + samples. + - grads: Dictionary mapping parameter names to gradients of those parameters + with respect to the loss function; has the same keys as self.params. + """ + # Unpack variables from the params dictionary + W1, b1 = self.params['W1'], self.params['b1'] + W2, b2 = self.params['W2'], self.params['b2'] + N, D = X.shape + + # Compute the forward pass + scores = None + ############################################################################# + # TODO: Perform the forward pass, computing the class scores for the input. # + # Store the result in the scores variable, which should be an array of # + # shape (N, C). # + ############################################################################# + Z1 = X.dot(W1) + b1 + A1 = np.maximum(0, Z1) + Z2 = A1.dot(W2) + b2 +# Z2_exp = np.exp(Z2) +# A2 = Z2_exp / np.sum(Z2_exp, axis=1, keepdims=True) + + scores = Z2 + ############################################################################# + # END OF YOUR CODE # + ############################################################################# + + # If the targets are not given then jump out, we're done + if y is None: + return scores + + # Compute the loss + loss = None + ############################################################################# + # TODO: Finish the forward pass, and compute the loss. This should include # + # both the data loss and L2 regularization for W1 and W2. Store the result # + # in the variable loss, which should be a scalar. Use the Softmax # + # classifier loss. # + ############################################################################# + Z2 += -np.amax(Z2, axis=1, keepdims=True) + Z2_exp = np.exp(Z2) + Z2_exp_hsum = np.sum(Z2_exp, axis=1, keepdims=True) + loss = np.mean(-np.log(Z2_exp[np.arange(N),y] / Z2_exp_hsum)) + loss += reg * ( np.sum(W1*W1) + np.sum(W2*W2) ) + ############################################################################# + # END OF YOUR CODE # + ############################################################################# + + # Backward pass: compute gradients + grads = {} + ############################################################################# + # TODO: Compute the backward pass, computing the derivatives of the weights # + # and biases. Store the results in the grads dictionary. For example, # + # grads['W1'] should store the gradient on W1, and be a matrix of same size # + ############################################################################# + dZ2 = Z2_exp / Z2_exp_hsum + dZ2[np.arange(N),y] += -1 + dW2 = A1.T.dot(dZ2) / N + 2 * reg * W2 + db2 = np.mean(dZ2, axis=0) + + dA1 = dZ2.dot(W2.T) + dZ1 = (Z1 > 0) * dA1 + dW1 = X.T.dot(dZ1) / N + 2 * reg * W1 + db1 = np.mean(dZ1, axis=0) + + grads['W1'] = dW1 + grads['b1'] = db1 + grads['W2'] = dW2 + grads['b2'] = db2 + ############################################################################# + # END OF YOUR CODE # + ############################################################################# + + return loss, grads + + def train(self, X, y, X_val, y_val, + learning_rate=1e-3, learning_rate_decay=0.95, + reg=5e-6, num_iters=100, + batch_size=200, verbose=False): + """ + Train this neural network using stochastic gradient descent. + + Inputs: + - X: A numpy array of shape (N, D) giving training data. + - y: A numpy array f shape (N,) giving training labels; y[i] = c means that + X[i] has label c, where 0 <= c < C. + - X_val: A numpy array of shape (N_val, D) giving validation data. + - y_val: A numpy array of shape (N_val,) giving validation labels. + - learning_rate: Scalar giving learning rate for optimization. + - learning_rate_decay: Scalar giving factor used to decay the learning rate + after each epoch. + - reg: Scalar giving regularization strength. + - num_iters: Number of steps to take when optimizing. + - batch_size: Number of training examples to use per step. + - verbose: boolean; if true print progress during optimization. + """ + num_train = X.shape[0] + iterations_per_epoch = max(num_train / batch_size, 1) +# print(iterations_per_epoch) + + # Use SGD to optimize the parameters in self.model + loss_history = [] + train_acc_history = [] + val_acc_history = [] + + for it in range(num_iters): + X_batch = None + y_batch = None + + ######################################################################### + # TODO: Create a random minibatch of training data and labels, storing # + # them in X_batch and y_batch respectively. # + ######################################################################### + sampel_index = np.random.choice(num_train, batch_size, replace=True) + X_batch = X[sampel_index, :] + y_batch = y[sampel_index] + ######################################################################### + # END OF YOUR CODE # + ######################################################################### + + # Compute loss and gradients using the current minibatch + loss, grads = self.loss(X_batch, y=y_batch, reg=reg) + loss_history.append(loss) + + ######################################################################### + # TODO: Use the gradients in the grads dictionary to update the # + # parameters of the network (stored in the dictionary self.params) # + # using stochastic gradient descent. You'll need to use the gradients # + # stored in the grads dictionary defined above. # + ######################################################################### + for key in grads: + self.params[key] -= learning_rate * grads[key] + ######################################################################### + # END OF YOUR CODE # + ######################################################################### + + if verbose and it % 100 == 0: + print('iteration %d / %d: loss %f' % (it, num_iters, loss)) + + # Every epoch, check train and val accuracy and decay learning rate. + if it % iterations_per_epoch == 0: + # Check accuracy +# print(self.predict(X_batch) == y_batch) + train_acc = (self.predict(X_batch) == y_batch).mean() + val_acc = (self.predict(X_val) == y_val).mean() +# train_acc = np.mean(self.predict(X_batch) == y_batch) +# val_acc = np.mean(self.predict(X_val) == y_val) + train_acc_history.append(train_acc) + val_acc_history.append(val_acc) + + # Decay learning rate + learning_rate *= learning_rate_decay + + return { + 'loss_history': loss_history, + 'train_acc_history': train_acc_history, + 'val_acc_history': val_acc_history, + } + + def predict(self, X): + """ + Use the trained weights of this two-layer network to predict labels for + data points. For each data point we predict scores for each of the C + classes, and assign each data point to the class with the highest score. + + Inputs: + - X: A numpy array of shape (N, D) giving N D-dimensional data points to + classify. + + Returns: + - y_pred: A numpy array of shape (N,) giving predicted labels for each of + the elements of X. For all i, y_pred[i] = c means that X[i] is predicted + to have class c, where 0 <= c < C. + """ + y_pred = None + + ########################################################################### + # TODO: Implement this function; it should be VERY simple! # + ########################################################################### +# print(type(X)) +# print(X.shape) + Z2 = self.loss(X) +# Z1 = X.dot(self.params['W1']) + self.params['b1'] +# A1 = np.maximum(0, Z1) +# Z2 = A1.dot(self.params['W2']) + self.params['b2'] + Z2 += -np.amax(Z2, axis=1, keepdims=True) + Z2_exp = np.exp(Z2) + Z2_exp_hsum = np.sum(Z2_exp, axis=1, keepdims=True) + A2 = Z2_exp / Z2_exp_hsum +# y_pred = A2 + y_pred = np.argmax(A2, axis=1) + ########################################################################### + # END OF YOUR CODE # + ########################################################################### + + return y_pred + + diff --git a/assignment1/cs231n/classifiers/softmax.py b/assignment1/cs231n/classifiers/softmax.py new file mode 100644 index 000000000..d827ede31 --- /dev/null +++ b/assignment1/cs231n/classifiers/softmax.py @@ -0,0 +1,90 @@ +import numpy as np +from random import shuffle + +def softmax_loss_naive(W, X, y, reg): + """ + Softmax loss function, naive implementation (with loops) + + Inputs have dimension D, there are C classes, and we operate on minibatches + of N examples. + + Inputs: + - W: A numpy array of shape (D, C) containing weights. + - X: A numpy array of shape (N, D) containing a minibatch of data. + - y: A numpy array of shape (N,) containing training labels; y[i] = c means + that X[i] has label c, where 0 <= c < C. + - reg: (float) regularization strength + + Returns a tuple of: + - loss as single float + - gradient with respect to weights W; an array of same shape as W + """ + # Initialize the loss and gradient to zero. + loss = 0.0 + dW = np.zeros_like(W) + + ############################################################################# + # TODO: Compute the softmax loss and its gradient using explicit loops. # + # Store the loss in loss and the gradient in dW. If you are not careful # + # here, it is easy to run into numeric instability. Don't forget the # + # regularization! # + ############################################################################# + N = X.shape[0] + D, C = W.shape[0], W.shape[1] + for i in range(N) : + z = X[i].dot(W) + loss += -np.log(np.exp(z[y[i]]) / np.sum(np.exp(z))) + + ds = np.exp(z) / np.sum(np.exp(z)) + ds[y[i]] += -1 + dW += X[i].reshape(D,1).dot(ds.reshape(1,C)) + + + loss /= N + loss += reg * np.sum(W * W) + + dW /= N + dW += 2 * reg * W + ############################################################################# + # END OF YOUR CODE # + ############################################################################# + + return loss, dW + + +def softmax_loss_vectorized(W, X, y, reg): + """ + Softmax loss function, vectorized version. + + Inputs and outputs are the same as softmax_loss_naive. + """ + # Initialize the loss and gradient to zero. + loss = 0.0 + dW = np.zeros_like(W) + + ############################################################################# + # TODO: Compute the softmax loss and its gradient using no explicit loops. # + # Store the loss in loss and the gradient in dW. If you are not careful # + # here, it is easy to run into numeric instability. Don't forget the # + # regularization! # + ############################################################################# + N = X.shape[0] + + Z = X.dot(W) + Z -= np.amax(Z, axis=1, keepdims=True) + Z_exp = np.exp(Z) + Z_hsum = np.sum(Z_exp, axis = 1, keepdims=True) + loss = np.mean(-np.log(Z_exp[np.arange(N), y] / Z_hsum)) + loss += reg * np.sum(W * W) + + dZ = Z_exp / Z_hsum + dZ[np.arange(N), y] += -1 + dW = X.T.dot(dZ) + dW /= N + dW += 2 * reg * W + ############################################################################# + # END OF YOUR CODE # + ############################################################################# + + return loss, dW + diff --git a/assignment1/cs231n/data_utils.py b/assignment1/cs231n/data_utils.py new file mode 100644 index 000000000..77ee7c196 --- /dev/null +++ b/assignment1/cs231n/data_utils.py @@ -0,0 +1,230 @@ +from __future__ import print_function + +from six.moves import cPickle as pickle +import numpy as np +import os +from scipy.misc import imread +import platform + +def load_pickle(f): + version = platform.python_version_tuple() + if version[0] == '2': + return pickle.load(f) + elif version[0] == '3': + return pickle.load(f, encoding='latin1') + raise ValueError("invalid python version: {}".format(version)) + +def load_CIFAR_batch(filename): + """ load single batch of cifar """ + with open(filename, 'rb') as f: + datadict = load_pickle(f) + X = datadict['data'] + Y = datadict['labels'] + X = X.reshape(10000, 3, 32, 32).transpose(0,2,3,1).astype("float") + Y = np.array(Y) + return X, Y + +def load_CIFAR10(ROOT): + """ load all of cifar """ + xs = [] + ys = [] + for b in range(1,6): + f = os.path.join(ROOT, 'data_batch_%d' % (b, )) + X, Y = load_CIFAR_batch(f) + xs.append(X) + ys.append(Y) + Xtr = np.concatenate(xs) + Ytr = np.concatenate(ys) + del X, Y + Xte, Yte = load_CIFAR_batch(os.path.join(ROOT, 'test_batch')) + return Xtr, Ytr, Xte, Yte + + +def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, + subtract_mean=True): + """ + Load the CIFAR-10 dataset from disk and perform preprocessing to prepare + it for classifiers. These are the same steps as we used for the SVM, but + condensed to a single function. + """ + # Load the raw CIFAR-10 data + cifar10_dir = 'cs231n/datasets/cifar-10-batches-py' + X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir) + + # Subsample the data + mask = list(range(num_training, num_training + num_validation)) + X_val = X_train[mask] + y_val = y_train[mask] + mask = list(range(num_training)) + X_train = X_train[mask] + y_train = y_train[mask] + mask = list(range(num_test)) + X_test = X_test[mask] + y_test = y_test[mask] + + # Normalize the data: subtract the mean image + if subtract_mean: + mean_image = np.mean(X_train, axis=0) + X_train -= mean_image + X_val -= mean_image + X_test -= mean_image + + # Transpose so that channels come first + X_train = X_train.transpose(0, 3, 1, 2).copy() + X_val = X_val.transpose(0, 3, 1, 2).copy() + X_test = X_test.transpose(0, 3, 1, 2).copy() + + # Package data into a dictionary + return { + 'X_train': X_train, 'y_train': y_train, + 'X_val': X_val, 'y_val': y_val, + 'X_test': X_test, 'y_test': y_test, + } + + +def load_tiny_imagenet(path, dtype=np.float32, subtract_mean=True): + """ + Load TinyImageNet. Each of TinyImageNet-100-A, TinyImageNet-100-B, and + TinyImageNet-200 have the same directory structure, so this can be used + to load any of them. + + Inputs: + - path: String giving path to the directory to load. + - dtype: numpy datatype used to load the data. + - subtract_mean: Whether to subtract the mean training image. + + Returns: A dictionary with the following entries: + - class_names: A list where class_names[i] is a list of strings giving the + WordNet names for class i in the loaded dataset. + - X_train: (N_tr, 3, 64, 64) array of training images + - y_train: (N_tr,) array of training labels + - X_val: (N_val, 3, 64, 64) array of validation images + - y_val: (N_val,) array of validation labels + - X_test: (N_test, 3, 64, 64) array of testing images. + - y_test: (N_test,) array of test labels; if test labels are not available + (such as in student code) then y_test will be None. + - mean_image: (3, 64, 64) array giving mean training image + """ + # First load wnids + with open(os.path.join(path, 'wnids.txt'), 'r') as f: + wnids = [x.strip() for x in f] + + # Map wnids to integer labels + wnid_to_label = {wnid: i for i, wnid in enumerate(wnids)} + + # Use words.txt to get names for each class + with open(os.path.join(path, 'words.txt'), 'r') as f: + wnid_to_words = dict(line.split('\t') for line in f) + for wnid, words in wnid_to_words.iteritems(): + wnid_to_words[wnid] = [w.strip() for w in words.split(',')] + class_names = [wnid_to_words[wnid] for wnid in wnids] + + # Next load training data. + X_train = [] + y_train = [] + for i, wnid in enumerate(wnids): + if (i + 1) % 20 == 0: + print('loading training data for synset %d / %d' % (i + 1, len(wnids))) + # To figure out the filenames we need to open the boxes file + boxes_file = os.path.join(path, 'train', wnid, '%s_boxes.txt' % wnid) + with open(boxes_file, 'r') as f: + filenames = [x.split('\t')[0] for x in f] + num_images = len(filenames) + + X_train_block = np.zeros((num_images, 3, 64, 64), dtype=dtype) + y_train_block = wnid_to_label[wnid] * np.ones(num_images, dtype=np.int64) + for j, img_file in enumerate(filenames): + img_file = os.path.join(path, 'train', wnid, 'images', img_file) + img = imread(img_file) + if img.ndim == 2: + ## grayscale file + img.shape = (64, 64, 1) + X_train_block[j] = img.transpose(2, 0, 1) + X_train.append(X_train_block) + y_train.append(y_train_block) + + # We need to concatenate all training data + X_train = np.concatenate(X_train, axis=0) + y_train = np.concatenate(y_train, axis=0) + + # Next load validation data + with open(os.path.join(path, 'val', 'val_annotations.txt'), 'r') as f: + img_files = [] + val_wnids = [] + for line in f: + img_file, wnid = line.split('\t')[:2] + img_files.append(img_file) + val_wnids.append(wnid) + num_val = len(img_files) + y_val = np.array([wnid_to_label[wnid] for wnid in val_wnids]) + X_val = np.zeros((num_val, 3, 64, 64), dtype=dtype) + for i, img_file in enumerate(img_files): + img_file = os.path.join(path, 'val', 'images', img_file) + img = imread(img_file) + if img.ndim == 2: + img.shape = (64, 64, 1) + X_val[i] = img.transpose(2, 0, 1) + + # Next load test images + # Students won't have test labels, so we need to iterate over files in the + # images directory. + img_files = os.listdir(os.path.join(path, 'test', 'images')) + X_test = np.zeros((len(img_files), 3, 64, 64), dtype=dtype) + for i, img_file in enumerate(img_files): + img_file = os.path.join(path, 'test', 'images', img_file) + img = imread(img_file) + if img.ndim == 2: + img.shape = (64, 64, 1) + X_test[i] = img.transpose(2, 0, 1) + + y_test = None + y_test_file = os.path.join(path, 'test', 'test_annotations.txt') + if os.path.isfile(y_test_file): + with open(y_test_file, 'r') as f: + img_file_to_wnid = {} + for line in f: + line = line.split('\t') + img_file_to_wnid[line[0]] = line[1] + y_test = [wnid_to_label[img_file_to_wnid[img_file]] for img_file in img_files] + y_test = np.array(y_test) + + mean_image = X_train.mean(axis=0) + if subtract_mean: + X_train -= mean_image[None] + X_val -= mean_image[None] + X_test -= mean_image[None] + + return { + 'class_names': class_names, + 'X_train': X_train, + 'y_train': y_train, + 'X_val': X_val, + 'y_val': y_val, + 'X_test': X_test, + 'y_test': y_test, + 'class_names': class_names, + 'mean_image': mean_image, + } + + +def load_models(models_dir): + """ + Load saved models from disk. This will attempt to unpickle all files in a + directory; any files that give errors on unpickling (such as README.txt) will + be skipped. + + Inputs: + - models_dir: String giving the path to a directory containing model files. + Each model file is a pickled dictionary with a 'model' field. + + Returns: + A dictionary mapping model file names to models. + """ + models = {} + for model_file in os.listdir(models_dir): + with open(os.path.join(models_dir, model_file), 'rb') as f: + try: + models[model_file] = load_pickle(f)['model'] + except pickle.UnpicklingError: + continue + return models diff --git a/assignment1/cs231n/datasets/.gitignore b/assignment1/cs231n/datasets/.gitignore new file mode 100644 index 000000000..0232c3ab1 --- /dev/null +++ b/assignment1/cs231n/datasets/.gitignore @@ -0,0 +1,4 @@ +cifar-10-batches-py/* +tiny-imagenet-100-A* +tiny-imagenet-100-B* +tiny-100-A-pretrained/* diff --git a/assignment1/cs231n/datasets/get_datasets.sh b/assignment1/cs231n/datasets/get_datasets.sh new file mode 100644 index 000000000..0dd936212 --- /dev/null +++ b/assignment1/cs231n/datasets/get_datasets.sh @@ -0,0 +1,4 @@ +# Get CIFAR10 +wget http://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz +tar -xzvf cifar-10-python.tar.gz +rm cifar-10-python.tar.gz diff --git a/assignment1/cs231n/features.py b/assignment1/cs231n/features.py new file mode 100644 index 000000000..3b10ae184 --- /dev/null +++ b/assignment1/cs231n/features.py @@ -0,0 +1,150 @@ +from __future__ import print_function + +import matplotlib +import numpy as np +from scipy.ndimage import uniform_filter + + +def extract_features(imgs, feature_fns, verbose=False): + """ + Given pixel data for images and several feature functions that can operate on + single images, apply all feature functions to all images, concatenating the + feature vectors for each image and storing the features for all images in + a single matrix. + + Inputs: + - imgs: N x H X W X C array of pixel data for N images. + - feature_fns: List of k feature functions. The ith feature function should + take as input an H x W x D array and return a (one-dimensional) array of + length F_i. + - verbose: Boolean; if true, print progress. + + Returns: + An array of shape (N, F_1 + ... + F_k) where each column is the concatenation + of all features for a single image. + """ + num_images = imgs.shape[0] + if num_images == 0: + return np.array([]) + + # Use the first image to determine feature dimensions + feature_dims = [] + first_image_features = [] + for feature_fn in feature_fns: + feats = feature_fn(imgs[0].squeeze()) + assert len(feats.shape) == 1, 'Feature functions must be one-dimensional' + feature_dims.append(feats.size) + first_image_features.append(feats) + + # Now that we know the dimensions of the features, we can allocate a single + # big array to store all features as columns. + total_feature_dim = sum(feature_dims) + imgs_features = np.zeros((num_images, total_feature_dim)) + imgs_features[0] = np.hstack(first_image_features).T + + # Extract features for the rest of the images. + for i in range(1, num_images): + idx = 0 + for feature_fn, feature_dim in zip(feature_fns, feature_dims): + next_idx = idx + feature_dim + imgs_features[i, idx:next_idx] = feature_fn(imgs[i].squeeze()) + idx = next_idx + if verbose and i % 1000 == 0: + print('Done extracting features for %d / %d images' % (i, num_images)) + + return imgs_features + + +def rgb2gray(rgb): + """Convert RGB image to grayscale + + Parameters: + rgb : RGB image + + Returns: + gray : grayscale image + + """ + return np.dot(rgb[...,:3], [0.299, 0.587, 0.144]) + + +def hog_feature(im): + """Compute Histogram of Gradient (HOG) feature for an image + + Modified from skimage.feature.hog + http://pydoc.net/Python/scikits-image/0.4.2/skimage.feature.hog + + Reference: + Histograms of Oriented Gradients for Human Detection + Navneet Dalal and Bill Triggs, CVPR 2005 + + Parameters: + im : an input grayscale or rgb image + + Returns: + feat: Histogram of Gradient (HOG) feature + + """ + + # convert rgb to grayscale if needed + if im.ndim == 3: + image = rgb2gray(im) + else: + image = np.at_least_2d(im) + + sx, sy = image.shape # image size + orientations = 9 # number of gradient bins + cx, cy = (8, 8) # pixels per cell + + gx = np.zeros(image.shape) + gy = np.zeros(image.shape) + gx[:, :-1] = np.diff(image, n=1, axis=1) # compute gradient on x-direction + gy[:-1, :] = np.diff(image, n=1, axis=0) # compute gradient on y-direction + grad_mag = np.sqrt(gx ** 2 + gy ** 2) # gradient magnitude + grad_ori = np.arctan2(gy, (gx + 1e-15)) * (180 / np.pi) + 90 # gradient orientation + + n_cellsx = int(np.floor(sx / cx)) # number of cells in x + n_cellsy = int(np.floor(sy / cy)) # number of cells in y + # compute orientations integral images + orientation_histogram = np.zeros((n_cellsx, n_cellsy, orientations)) + for i in range(orientations): + # create new integral image for this orientation + # isolate orientations in this range + temp_ori = np.where(grad_ori < 180 / orientations * (i + 1), + grad_ori, 0) + temp_ori = np.where(grad_ori >= 180 / orientations * i, + temp_ori, 0) + # select magnitudes for those orientations + cond2 = temp_ori > 0 + temp_mag = np.where(cond2, grad_mag, 0) + orientation_histogram[:,:,i] = uniform_filter(temp_mag, size=(cx, cy))[int(cx/2)::cx, int(cy/2)::cy].T + + return orientation_histogram.ravel() + + +def color_histogram_hsv(im, nbin=10, xmin=0, xmax=255, normalized=True): + """ + Compute color histogram for an image using hue. + + Inputs: + - im: H x W x C array of pixel data for an RGB image. + - nbin: Number of histogram bins. (default: 10) + - xmin: Minimum pixel value (default: 0) + - xmax: Maximum pixel value (default: 255) + - normalized: Whether to normalize the histogram (default: True) + + Returns: + 1D vector of length nbin giving the color histogram over the hue of the + input image. + """ + ndim = im.ndim + bins = np.linspace(xmin, xmax, nbin+1) + hsv = matplotlib.colors.rgb_to_hsv(im/xmax) * xmax + imhist, bin_edges = np.histogram(hsv[:,:,0], bins=bins, density=normalized) + imhist = imhist * np.diff(bin_edges) + + # return histogram + return imhist + + +pass diff --git a/assignment1/cs231n/gradient_check.py b/assignment1/cs231n/gradient_check.py new file mode 100644 index 000000000..03ef74a8c --- /dev/null +++ b/assignment1/cs231n/gradient_check.py @@ -0,0 +1,126 @@ +from __future__ import print_function + +import numpy as np +from random import randrange + +def eval_numerical_gradient(f, x, verbose=True, h=0.00001): + """ + a naive implementation of numerical gradient of f at x + - f should be a function that takes a single argument + - x is the point (numpy array) to evaluate the gradient at + """ + + fx = f(x) # evaluate function value at original point + grad = np.zeros_like(x) + # iterate over all indexes in x + it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite']) + while not it.finished: + + # evaluate function at x+h + ix = it.multi_index + oldval = x[ix] + x[ix] = oldval + h # increment by h + fxph = f(x) # evalute f(x + h) + x[ix] = oldval - h + fxmh = f(x) # evaluate f(x - h) + x[ix] = oldval # restore + + # compute the partial derivative with centered formula + grad[ix] = (fxph - fxmh) / (2 * h) # the slope + if verbose: + print(ix, grad[ix]) + it.iternext() # step to next dimension + + return grad + + +def eval_numerical_gradient_array(f, x, df, h=1e-5): + """ + Evaluate a numeric gradient for a function that accepts a numpy + array and returns a numpy array. + """ + grad = np.zeros_like(x) + it = np.nditer(x, flags=['multi_index'], op_flags=['readwrite']) + while not it.finished: + ix = it.multi_index + + oldval = x[ix] + x[ix] = oldval + h + pos = f(x).copy() + x[ix] = oldval - h + neg = f(x).copy() + x[ix] = oldval + + grad[ix] = np.sum((pos - neg) * df) / (2 * h) + it.iternext() + return grad + + +def eval_numerical_gradient_blobs(f, inputs, output, h=1e-5): + """ + Compute numeric gradients for a function that operates on input + and output blobs. + + We assume that f accepts several input blobs as arguments, followed by a blob + into which outputs will be written. For example, f might be called like this: + + f(x, w, out) + + where x and w are input Blobs, and the result of f will be written to out. + + Inputs: + - f: function + - inputs: tuple of input blobs + - output: output blob + - h: step size + """ + numeric_diffs = [] + for input_blob in inputs: + diff = np.zeros_like(input_blob.diffs) + it = np.nditer(input_blob.vals, flags=['multi_index'], + op_flags=['readwrite']) + while not it.finished: + idx = it.multi_index + orig = input_blob.vals[idx] + + input_blob.vals[idx] = orig + h + f(*(inputs + (output,))) + pos = np.copy(output.vals) + input_blob.vals[idx] = orig - h + f(*(inputs + (output,))) + neg = np.copy(output.vals) + input_blob.vals[idx] = orig + + diff[idx] = np.sum((pos - neg) * output.diffs) / (2.0 * h) + + it.iternext() + numeric_diffs.append(diff) + return numeric_diffs + + +def eval_numerical_gradient_net(net, inputs, output, h=1e-5): + return eval_numerical_gradient_blobs(lambda *args: net.forward(), + inputs, output, h=h) + + +def grad_check_sparse(f, x, analytic_grad, num_checks=10, h=1e-5): + """ + sample a few random elements and only return numerical + in this dimensions. + """ + + for i in range(num_checks): + ix = tuple([randrange(m) for m in x.shape]) + + oldval = x[ix] + x[ix] = oldval + h # increment by h + fxph = f(x) # evaluate f(x + h) + x[ix] = oldval - h # increment by h + fxmh = f(x) # evaluate f(x - h) + x[ix] = oldval # reset + + grad_numerical = (fxph - fxmh) / (2 * h) + grad_analytic = analytic_grad[ix] + rel_error = abs(grad_numerical - grad_analytic) / (abs(grad_numerical) + abs(grad_analytic)) + print('numerical: %f analytic: %f, relative error: %e' % (grad_numerical, grad_analytic, rel_error)) + diff --git a/assignment1/cs231n/vis_utils.py b/assignment1/cs231n/vis_utils.py new file mode 100644 index 000000000..0c9fbd4cf --- /dev/null +++ b/assignment1/cs231n/vis_utils.py @@ -0,0 +1,73 @@ +from math import sqrt, ceil +import numpy as np + +def visualize_grid(Xs, ubound=255.0, padding=1): + """ + Reshape a 4D tensor of image data to a grid for easy visualization. + + Inputs: + - Xs: Data of shape (N, H, W, C) + - ubound: Output grid will have values scaled to the range [0, ubound] + - padding: The number of blank pixels between elements of the grid + """ + (N, H, W, C) = Xs.shape + grid_size = int(ceil(sqrt(N))) + grid_height = H * grid_size + padding * (grid_size - 1) + grid_width = W * grid_size + padding * (grid_size - 1) + grid = np.zeros((grid_height, grid_width, C)) + next_idx = 0 + y0, y1 = 0, H + for y in range(grid_size): + x0, x1 = 0, W + for x in range(grid_size): + if next_idx < N: + img = Xs[next_idx] + low, high = np.min(img), np.max(img) + grid[y0:y1, x0:x1] = ubound * (img - low) / (high - low) + # grid[y0:y1, x0:x1] = Xs[next_idx] + next_idx += 1 + x0 += W + padding + x1 += W + padding + y0 += H + padding + y1 += H + padding + # grid_max = np.max(grid) + # grid_min = np.min(grid) + # grid = ubound * (grid - grid_min) / (grid_max - grid_min) + return grid + +def vis_grid(Xs): + """ visualize a grid of images """ + (N, H, W, C) = Xs.shape + A = int(ceil(sqrt(N))) + G = np.ones((A*H+A, A*W+A, C), Xs.dtype) + G *= np.min(Xs) + n = 0 + for y in range(A): + for x in range(A): + if n < N: + G[y*H+y:(y+1)*H+y, x*W+x:(x+1)*W+x, :] = Xs[n,:,:,:] + n += 1 + # normalize to [0,1] + maxg = G.max() + ming = G.min() + G = (G - ming)/(maxg-ming) + return G + +def vis_nn(rows): + """ visualize array of arrays of images """ + N = len(rows) + D = len(rows[0]) + H,W,C = rows[0][0].shape + Xs = rows[0][0] + G = np.ones((N*H+N, D*W+D, C), Xs.dtype) + for y in range(N): + for x in range(D): + G[y*H+y:(y+1)*H+y, x*W+x:(x+1)*W+x, :] = rows[y][x] + # normalize to [0,1] + maxg = G.max() + ming = G.min() + G = (G - ming)/(maxg-ming) + return G + + + diff --git a/assignment1/features.ipynb b/assignment1/features.ipynb new file mode 100644 index 000000000..4ee38fa29 --- /dev/null +++ b/assignment1/features.ipynb @@ -0,0 +1,561 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Image features exercise\n", + "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n", + "\n", + "We have seen that we can achieve reasonable performance on an image classification task by training a linear classifier on the pixels of the input image. In this exercise we will show that we can improve our classification performance by training linear classifiers not on raw pixels but on features that are computed from the raw pixels.\n", + "\n", + "All of your work for this exercise will be done in this notebook." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "import random\n", + "import numpy as np\n", + "from cs231n.data_utils import load_CIFAR10\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "# for auto-reloading extenrnal modules\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load data\n", + "Similar to previous exercises, we will load CIFAR-10 data from disk." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from cs231n.features import color_histogram_hsv, hog_feature\n", + "\n", + "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n", + " # Load the raw CIFAR-10 data\n", + " cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n", + "\n", + " X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n", + " \n", + " # Subsample the data\n", + " mask = list(range(num_training, num_training + num_validation))\n", + " X_val = X_train[mask]\n", + " y_val = y_train[mask]\n", + " mask = list(range(num_training))\n", + " X_train = X_train[mask]\n", + " y_train = y_train[mask]\n", + " mask = list(range(num_test))\n", + " X_test = X_test[mask]\n", + " y_test = y_test[mask]\n", + " \n", + " return X_train, y_train, X_val, y_val, X_test, y_test\n", + "\n", + "# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n", + "try:\n", + " del X_train, y_train\n", + " del X_test, y_test\n", + " print('Clear previously loaded data.')\n", + "except:\n", + " pass\n", + "\n", + "X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extract Features\n", + "For each image we will compute a Histogram of Oriented\n", + "Gradients (HOG) as well as a color histogram using the hue channel in HSV\n", + "color space. We form our final feature vector for each image by concatenating\n", + "the HOG and color histogram feature vectors.\n", + "\n", + "Roughly speaking, HOG should capture the texture of the image while ignoring\n", + "color information, and the color histogram represents the color of the input\n", + "image while ignoring texture. As a result, we expect that using both together\n", + "ought to work better than using either alone. Verifying this assumption would\n", + "be a good thing to try for your interests.\n", + "\n", + "The `hog_feature` and `color_histogram_hsv` functions both operate on a single\n", + "image and return a feature vector for that image. The extract_features\n", + "function takes a set of images and a list of feature functions and evaluates\n", + "each feature function on each image, storing the results in a matrix where\n", + "each column is the concatenation of all feature vectors for a single image." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Done extracting features for 1000 / 49000 images\n", + "Done extracting features for 2000 / 49000 images\n", + "Done extracting features for 3000 / 49000 images\n", + "Done extracting features for 4000 / 49000 images\n", + "Done extracting features for 5000 / 49000 images\n", + "Done extracting features for 6000 / 49000 images\n", + "Done extracting features for 7000 / 49000 images\n", + "Done extracting features for 8000 / 49000 images\n", + "Done extracting features for 9000 / 49000 images\n", + "Done extracting features for 10000 / 49000 images\n", + "Done extracting features for 11000 / 49000 images\n", + "Done extracting features for 12000 / 49000 images\n", + "Done extracting features for 13000 / 49000 images\n", + "Done extracting features for 14000 / 49000 images\n", + "Done extracting features for 15000 / 49000 images\n", + "Done extracting features for 16000 / 49000 images\n", + "Done extracting features for 17000 / 49000 images\n", + "Done extracting features for 18000 / 49000 images\n", + "Done extracting features for 19000 / 49000 images\n", + "Done extracting features for 20000 / 49000 images\n", + "Done extracting features for 21000 / 49000 images\n", + "Done extracting features for 22000 / 49000 images\n", + "Done extracting features for 23000 / 49000 images\n", + "Done extracting features for 24000 / 49000 images\n", + "Done extracting features for 25000 / 49000 images\n", + "Done extracting features for 26000 / 49000 images\n", + "Done extracting features for 27000 / 49000 images\n", + "Done extracting features for 28000 / 49000 images\n", + "Done extracting features for 29000 / 49000 images\n", + "Done extracting features for 30000 / 49000 images\n", + "Done extracting features for 31000 / 49000 images\n", + "Done extracting features for 32000 / 49000 images\n", + "Done extracting features for 33000 / 49000 images\n", + "Done extracting features for 34000 / 49000 images\n", + "Done extracting features for 35000 / 49000 images\n", + "Done extracting features for 36000 / 49000 images\n", + "Done extracting features for 37000 / 49000 images\n", + "Done extracting features for 38000 / 49000 images\n", + "Done extracting features for 39000 / 49000 images\n", + "Done extracting features for 40000 / 49000 images\n", + "Done extracting features for 41000 / 49000 images\n", + "Done extracting features for 42000 / 49000 images\n", + "Done extracting features for 43000 / 49000 images\n", + "Done extracting features for 44000 / 49000 images\n", + "Done extracting features for 45000 / 49000 images\n", + "Done extracting features for 46000 / 49000 images\n", + "Done extracting features for 47000 / 49000 images\n", + "Done extracting features for 48000 / 49000 images\n" + ] + } + ], + "source": [ + "from cs231n.features import *\n", + "\n", + "num_color_bins = 10 # Number of bins in the color histogram\n", + "feature_fns = [hog_feature, lambda img: color_histogram_hsv(img, nbin=num_color_bins)]\n", + "X_train_feats = extract_features(X_train, feature_fns, verbose=True)\n", + "X_val_feats = extract_features(X_val, feature_fns)\n", + "X_test_feats = extract_features(X_test, feature_fns)\n", + "\n", + "# Preprocessing: Subtract the mean feature\n", + "\n", + "mean_feat = np.mean(X_train_feats, axis=0, keepdims=True)\n", + "X_train_feats -= mean_feat\n", + "X_val_feats -= mean_feat\n", + "X_test_feats -= mean_feat\n", + "\n", + "# Preprocessing: Divide by standard deviation. This ensures that each feature\n", + "# has roughly the same scale.\n", + "std_feat = np.std(X_train_feats, axis=0, keepdims=True)\n", + "X_train_feats /= std_feat\n", + "X_val_feats /= std_feat\n", + "X_test_feats /= std_feat\n", + "\n", + "# Preprocessing: Add a bias dimension\n", + "X_train_feats = np.hstack([X_train_feats, np.ones((X_train_feats.shape[0], 1))])\n", + "X_val_feats = np.hstack([X_val_feats, np.ones((X_val_feats.shape[0], 1))])\n", + "X_test_feats = np.hstack([X_test_feats, np.ones((X_test_feats.shape[0], 1))])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(49000, 155)\n" + ] + } + ], + "source": [ + "print(X_train_feats.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train SVM on features\n", + "Using the multiclass SVM code developed earlier in the assignment, train SVMs on top of the features extracted above; this should achieve better results than training SVMs directly on top of raw pixels." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "lr 3.000000e-08 reg 4.000000e+05 train accuracy: 0.093327 val accuracy: 0.099000\n", + "lr 3.000000e-08 reg 4.500000e+05 train accuracy: 0.097224 val accuracy: 0.100000\n", + "lr 3.000000e-08 reg 5.000000e+05 train accuracy: 0.122204 val accuracy: 0.132000\n", + "lr 3.000000e-08 reg 5.500000e+05 train accuracy: 0.109612 val accuracy: 0.115000\n", + "lr 3.000000e-08 reg 6.000000e+06 train accuracy: 0.376898 val accuracy: 0.372000\n", + "lr 6.000000e-08 reg 4.000000e+05 train accuracy: 0.098184 val accuracy: 0.085000\n", + "lr 6.000000e-08 reg 4.500000e+05 train accuracy: 0.107837 val accuracy: 0.117000\n", + "lr 6.000000e-08 reg 5.000000e+05 train accuracy: 0.118306 val accuracy: 0.101000\n", + "lr 6.000000e-08 reg 5.500000e+05 train accuracy: 0.200449 val accuracy: 0.231000\n", + "lr 6.000000e-08 reg 6.000000e+06 train accuracy: 0.317000 val accuracy: 0.315000\n", + "lr 7.000000e-08 reg 4.000000e+05 train accuracy: 0.145939 val accuracy: 0.138000\n", + "lr 7.000000e-08 reg 4.500000e+05 train accuracy: 0.168735 val accuracy: 0.148000\n", + "lr 7.000000e-08 reg 5.000000e+05 train accuracy: 0.228000 val accuracy: 0.215000\n", + "lr 7.000000e-08 reg 5.500000e+05 train accuracy: 0.317286 val accuracy: 0.311000\n", + "lr 7.000000e-08 reg 6.000000e+06 train accuracy: 0.343224 val accuracy: 0.361000\n", + "lr 8.000000e-08 reg 4.000000e+05 train accuracy: 0.197816 val accuracy: 0.213000\n", + "lr 8.000000e-08 reg 4.500000e+05 train accuracy: 0.271082 val accuracy: 0.258000\n", + "lr 8.000000e-08 reg 5.000000e+05 train accuracy: 0.358286 val accuracy: 0.356000\n", + "lr 8.000000e-08 reg 5.500000e+05 train accuracy: 0.392082 val accuracy: 0.404000\n", + "lr 8.000000e-08 reg 6.000000e+06 train accuracy: 0.310878 val accuracy: 0.294000\n", + "lr 9.000000e-08 reg 4.000000e+05 train accuracy: 0.277102 val accuracy: 0.293000\n", + "lr 9.000000e-08 reg 4.500000e+05 train accuracy: 0.357796 val accuracy: 0.327000\n", + "lr 9.000000e-08 reg 5.000000e+05 train accuracy: 0.387388 val accuracy: 0.396000\n", + "lr 9.000000e-08 reg 5.500000e+05 train accuracy: 0.405796 val accuracy: 0.398000\n", + "lr 9.000000e-08 reg 6.000000e+06 train accuracy: 0.323857 val accuracy: 0.334000\n", + "lr 1.000000e-07 reg 4.000000e+05 train accuracy: 0.366143 val accuracy: 0.379000\n", + "lr 1.000000e-07 reg 4.500000e+05 train accuracy: 0.393347 val accuracy: 0.410000\n", + "lr 1.000000e-07 reg 5.000000e+05 train accuracy: 0.411776 val accuracy: 0.405000\n", + "lr 1.000000e-07 reg 5.500000e+05 train accuracy: 0.408776 val accuracy: 0.404000\n", + "lr 1.000000e-07 reg 6.000000e+06 train accuracy: 0.311245 val accuracy: 0.314000\n", + "lr 1.100000e-07 reg 4.000000e+05 train accuracy: 0.383653 val accuracy: 0.362000\n", + "lr 1.100000e-07 reg 4.500000e+05 train accuracy: 0.397612 val accuracy: 0.418000\n", + "lr 1.100000e-07 reg 5.000000e+05 train accuracy: 0.398878 val accuracy: 0.393000\n", + "lr 1.100000e-07 reg 5.500000e+05 train accuracy: 0.402265 val accuracy: 0.382000\n", + "lr 1.100000e-07 reg 6.000000e+06 train accuracy: 0.269490 val accuracy: 0.244000\n", + "lr 1.200000e-07 reg 4.000000e+05 train accuracy: 0.398429 val accuracy: 0.385000\n", + "lr 1.200000e-07 reg 4.500000e+05 train accuracy: 0.404388 val accuracy: 0.391000\n", + "lr 1.200000e-07 reg 5.000000e+05 train accuracy: 0.404673 val accuracy: 0.401000\n", + "lr 1.200000e-07 reg 5.500000e+05 train accuracy: 0.403000 val accuracy: 0.405000\n", + "lr 1.200000e-07 reg 6.000000e+06 train accuracy: 0.277857 val accuracy: 0.275000\n", + "lr 1.300000e-07 reg 4.000000e+05 train accuracy: 0.403735 val accuracy: 0.420000\n", + "lr 1.300000e-07 reg 4.500000e+05 train accuracy: 0.403531 val accuracy: 0.405000\n", + "lr 1.300000e-07 reg 5.000000e+05 train accuracy: 0.405327 val accuracy: 0.407000\n", + "lr 1.300000e-07 reg 5.500000e+05 train accuracy: 0.414898 val accuracy: 0.407000\n", + "lr 1.300000e-07 reg 6.000000e+06 train accuracy: 0.275551 val accuracy: 0.278000\n", + "lr 1.600000e-07 reg 4.000000e+05 train accuracy: 0.404245 val accuracy: 0.405000\n", + "lr 1.600000e-07 reg 4.500000e+05 train accuracy: 0.391551 val accuracy: 0.392000\n", + "lr 1.600000e-07 reg 5.000000e+05 train accuracy: 0.399082 val accuracy: 0.396000\n", + "lr 1.600000e-07 reg 5.500000e+05 train accuracy: 0.395796 val accuracy: 0.399000\n", + "lr 1.600000e-07 reg 6.000000e+06 train accuracy: 0.127694 val accuracy: 0.128000\n", + "best validation accuracy achieved during cross-validation: 0.420000\n" + ] + } + ], + "source": [ + "# Use the validation set to tune the learning rate and regularization strength\n", + "\n", + "from cs231n.classifiers.linear_classifier import LinearSVM\n", + "\n", + "learning_rates = [0.3e-7, 0.6e-7, 0.7e-7, 0.8e-7, 0.9e-7, 1e-7, 1.1e-7, 1.2e-7, 1.3e-7, 1.6e-7, ]\n", + "regularization_strengths = [4e5, 4.5e5, 5e5, 5.5e5, 6e6]\n", + "\n", + "results = {}\n", + "best_val = -1\n", + "best_svm = None\n", + "\n", + "################################################################################\n", + "# TODO: #\n", + "# Use the validation set to set the learning rate and regularization strength. #\n", + "# This should be identical to the validation that you did for the SVM; save #\n", + "# the best trained classifer in best_svm. You might also want to play #\n", + "# with different numbers of bins in the color histogram. If you are careful #\n", + "# you should be able to get accuracy of near 0.44 on the validation set. #\n", + "################################################################################\n", + "for lr in learning_rates :\n", + " for reg in regularization_strengths :\n", + " svm = LinearSVM()\n", + " svm.train(X_train_feats, y_train, learning_rate=lr, reg=reg, num_iters=100,\n", + " batch_size=200, verbose=False)\n", + " X_train_feats_acc = (svm.predict(X_train_feats) == y_train).mean()\n", + " X_val_feats_acc = (svm.predict(X_val_feats) == y_val).mean()\n", + " results[(lr, reg)] = X_train_feats_acc, X_val_feats_acc \n", + "# print(\"X_train_feats_acc\", X_train_feats_acc)\n", + "# print(\"X_val_feats_acc\", X_val_feats_acc)\n", + " if X_val_feats_acc > best_val :\n", + " best_val = X_val_feats_acc\n", + " best_svm = svm\n", + "################################################################################\n", + "# END OF YOUR CODE #\n", + "################################################################################\n", + "\n", + "# Print out results.\n", + "for lr, reg in sorted(results):\n", + " train_accuracy, val_accuracy = results[(lr, reg)]\n", + " print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n", + " lr, reg, train_accuracy, val_accuracy))\n", + " \n", + "print('best validation accuracy achieved during cross-validation: %f' % best_val)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.405\n" + ] + } + ], + "source": [ + "# Evaluate your trained SVM on the test set\n", + "y_test_pred = best_svm.predict(X_test_feats)\n", + "test_accuracy = np.mean(y_test == y_test_pred)\n", + "print(test_accuracy)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# An important way to gain intuition about how an algorithm works is to\n", + "# visualize the mistakes that it makes. In this visualization, we show examples\n", + "# of images that are misclassified by our current system. The first column\n", + "# shows images that our system labeled as \"plane\" but whose true label is\n", + "# something other than \"plane\".\n", + "\n", + "examples_per_class = 8\n", + "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n", + "for cls, cls_name in enumerate(classes):\n", + " idxs = np.where((y_test != cls) & (y_test_pred == cls))[0]\n", + "# print(np.where((y_test != cls) & (y_test_pred == cls)).shape)\n", + "# print(type(np.where((y_test != cls) & (y_test_pred == cls)))) #\n", + "# print(np.where((y_test != cls) & (y_test_pred == cls)))\n", + "# print(idxs.shape)\n", + " idxs = np.random.choice(idxs, examples_per_class, replace=False)\n", + " for i, idx in enumerate(idxs):\n", + " plt.subplot(examples_per_class, len(classes), i * len(classes) + cls + 1)\n", + " plt.imshow(X_test[idx].astype('uint8'))\n", + " plt.axis('off')\n", + " if i == 0:\n", + " plt.title(cls_name)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inline question 1:\n", + "Describe the misclassification results that you see. Do they make sense?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Neural Network on image features\n", + "Earlier in this assigment we saw that training a two-layer neural network on raw pixels achieved better classification performance than linear classifiers on raw pixels. In this notebook we have seen that linear classifiers on image features outperform linear classifiers on raw pixels. \n", + "\n", + "For completeness, we should also try training a neural network on image features. This approach should outperform all previous approaches: you should easily be able to achieve over 55% classification accuracy on the test set; our best model achieves about 60% classification accuracy." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(49000, 155)\n", + "(49000, 154)\n" + ] + } + ], + "source": [ + "# Preprocessing: Remove the bias dimension\n", + "# Make sure to run this cell only ONCE\n", + "print(X_train_feats.shape)\n", + "X_train_feats = X_train_feats[:, :-1]\n", + "X_val_feats = X_val_feats[:, :-1]\n", + "X_test_feats = X_test_feats[:, :-1]\n", + "\n", + "print(X_train_feats.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "learning_rate: 0.1 reg: 0.0 Tra acc: 0.5083469387755102 Val acc: 0.508\n", + "learning_rate: 0.1 reg: 0.01 Tra acc: 0.4870204081632653 Val acc: 0.476\n", + "learning_rate: 0.1 reg: 0.02 Tra acc: 0.46518367346938777 Val acc: 0.451\n", + "learning_rate: 0.2 reg: 0.0 Tra acc: 0.5458775510204081 Val acc: 0.531\n", + "learning_rate: 0.2 reg: 0.01 Tra acc: 0.5177551020408163 Val acc: 0.506\n", + "learning_rate: 0.2 reg: 0.02 Tra acc: 0.5015102040816326 Val acc: 0.503\n", + "learning_rate: 0.25 reg: 0.0 Tra acc: 0.5627142857142857 Val acc: 0.547\n", + "learning_rate: 0.25 reg: 0.01 Tra acc: 0.5119387755102041 Val acc: 0.501\n", + "learning_rate: 0.25 reg: 0.02 Tra acc: 0.49951020408163266 Val acc: 0.5\n", + "learning_rate: 0.3 reg: 0.0 Tra acc: 0.5730408163265306 Val acc: 0.533\n", + "learning_rate: 0.3 reg: 0.01 Tra acc: 0.5193061224489796 Val acc: 0.497\n", + "learning_rate: 0.3 reg: 0.02 Tra acc: 0.49912244897959185 Val acc: 0.474\n", + "learning_rate: 0.35 reg: 0.0 Tra acc: 0.5868163265306122 Val acc: 0.556\n", + "learning_rate: 0.35 reg: 0.01 Tra acc: 0.5126326530612245 Val acc: 0.503\n", + "learning_rate: 0.35 reg: 0.02 Tra acc: 0.49614285714285716 Val acc: 0.494\n", + "learning_rate: 0.03 reg: 0.0 Tra acc: 0.250469387755102 Val acc: 0.268\n", + "learning_rate: 0.03 reg: 0.01 Tra acc: 0.24840816326530613 Val acc: 0.271\n", + "learning_rate: 0.03 reg: 0.02 Tra acc: 0.220265306122449 Val acc: 0.228\n", + "best_val_acc: 0.556\n" + ] + } + ], + "source": [ + "from cs231n.classifiers.neural_net import TwoLayerNet\n", + "\n", + "input_dim = X_train_feats.shape[1]\n", + "hidden_dim = 500\n", + "num_classes = 10\n", + "\n", + "net = TwoLayerNet(input_dim, hidden_dim, num_classes)\n", + "best_net = None\n", + "\n", + "################################################################################\n", + "# TODO: Train a two-layer neural network on image features. You may want to #\n", + "# cross-validate various parameters as in previous sections. Store your best #\n", + "# model in the best_net variable. #\n", + "################################################################################\n", + "learning_rate = [1e-1, 2.0e-1, 2.5e-1, 3e-1, 3.5e-1,]\n", + "reg = [0.0, 0.01, 0.02]\n", + "best_val_acc = 0\n", + "\n", + "for lr in learning_rate:\n", + " for rg in reg:\n", + " net = TwoLayerNet(input_dim, hidden_dim, num_classes)\n", + " net.train(X_train_feats, y_train, X_val_feats, y_val,\n", + " learning_rate=lr, learning_rate_decay=0.95,\n", + " reg=rg, num_iters=800,\n", + " batch_size=200, verbose=False)\n", + " \n", + " # Predict on the validation set\n", + " val_acc = (net.predict(X_val_feats) == y_val).mean()\n", + " tra_acc = (net.predict(X_train_feats) == y_train).mean()\n", + " print(\"learning_rate:\",lr, \"reg:\",rg, \n", + " 'Tra acc:', tra_acc, 'Val acc:', val_acc)\n", + " if val_acc > best_val_acc :\n", + " best_val_acc = val_acc\n", + " best_net = net\n", + "print('best_val_acc:', best_val_acc)\n", + " \n", + "################################################################################\n", + "# END OF YOUR CODE #\n", + "################################################################################" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0.554\n" + ] + } + ], + "source": [ + "# Run your best neural net classifier on the test set. You should be able\n", + "# to get more than 55% accuracy.\n", + "\n", + "test_acc = (best_net.predict(X_test_feats) == y_test).mean()\n", + "print(test_acc)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/assignment1/frameworkpython b/assignment1/frameworkpython new file mode 100644 index 000000000..5ed8ebd05 --- /dev/null +++ b/assignment1/frameworkpython @@ -0,0 +1,15 @@ +#!/bin/bash + +# what real Python executable to use +#PYVER=2.7 +#PATHTOPYTHON=/usr/local/bin/ +#PYTHON=${PATHTOPYTHON}python${PYVER} + +PYTHON=$(which $(readlink .env/bin/python)) # only works with python3 + +# find the root of the virtualenv, it should be the parent of the dir this script is in +ENV=`$PYTHON -c "import os; print(os.path.abspath(os.path.join(os.path.dirname(\"$0\"), '..')))"` + +# now run Python with the virtualenv set as Python's HOME +export PYTHONHOME=$ENV +exec $PYTHON "$@" diff --git a/assignment1/knn.ipynb b/assignment1/knn.ipynb new file mode 100644 index 000000000..a69f46a32 --- /dev/null +++ b/assignment1/knn.ipynb @@ -0,0 +1,933 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# k-Nearest Neighbor (kNN) exercise\n", + "\n", + "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n", + "\n", + "The kNN classifier consists of two stages:\n", + "\n", + "- During training, the classifier takes the training data and simply remembers it\n", + "- During testing, kNN classifies every test image by comparing to all training images and transfering the labels of the k most similar training examples\n", + "- The value of k is cross-validated\n", + "\n", + "In this exercise you will implement these steps and understand the basic Image Classification pipeline, cross-validation, and gain proficiency in writing efficient, vectorized code." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "# Run some setup code for this notebook.\n", + "\n", + "import random\n", + "import numpy as np\n", + "from cs231n.data_utils import load_CIFAR10\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "\n", + "# This is a bit of magic to make matplotlib figures appear inline in the notebook\n", + "# rather than in a new window.\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "# Some more magic so that the notebook will reload external python modules;\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training data shape: (50000, 32, 32, 3)\n", + "Training labels shape: (50000,)\n", + "Test data shape: (10000, 32, 32, 3)\n", + "Test labels shape: (10000,)\n" + ] + } + ], + "source": [ + "# Load the raw CIFAR-10 data.\n", + "cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n", + "\n", + "# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n", + "try:\n", + " del X_train, y_train\n", + " del X_test, y_test\n", + " print('Clear previously loaded data.')\n", + "except:\n", + " pass\n", + "\n", + "X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n", + "\n", + "# As a sanity check, we print out the size of the training and test data.\n", + "print('Training data shape: ', X_train.shape)\n", + "print('Training labels shape: ', y_train.shape)\n", + "print('Test data shape: ', X_test.shape)\n", + "print('Test labels shape: ', y_test.shape)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 plane\n", + "1 car\n", + "2 bird\n", + "3 cat\n", + "4 deer\n", + "5 dog\n", + "6 frog\n", + "7 horse\n", + "8 ship\n", + "9 truck\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize some examples from the dataset.\n", + "# We show a few examples of training images from each class.\n", + "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n", + "num_classes = len(classes)\n", + "samples_per_class = 7\n", + "for y, cls in enumerate(classes):\n", + " print(y,cls)\n", + "# print((y_train == y).shape)\n", + " idxs = np.flatnonzero(y_train == y)\n", + "# print(idxs)\n", + " idxs = np.random.choice(idxs, samples_per_class, replace=False)\n", + " for i, idx in enumerate(idxs):\n", + " plt_idx = i * num_classes + y + 1\n", + " plt.subplot(samples_per_class, num_classes, plt_idx)\n", + " plt.imshow(X_train[idx].astype('uint8'))\n", + " plt.axis('off')\n", + " if i == 0:\n", + " plt.title(cls)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# num = list(range(5))\n", + "# print(num)\n", + "# test = np.arange(10,20,1)\n", + "# print(test)\n", + "# print(test[[1,2,3]])\n", + "# print(test[num])" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "5000\n", + "(5000, 32, 32, 3)\n", + "(5000, 32, 32, 3)\n" + ] + } + ], + "source": [ + "# Subsample the data for more efficient code execution in this exercise\n", + "num_training = 5000\n", + "mask = list(range(num_training))\n", + "print(len(mask))\n", + "print(X_train.shape)\n", + "# X_train = X_train[:num_training]\n", + "X_train = X_train[mask]\n", + "y_train = y_train[mask]\n", + "print(X_train.shape)\n", + "\n", + "num_test = 500\n", + "mask = list(range(num_test))\n", + "X_test = X_test[mask]\n", + "y_test = y_test[mask]\n", + "# y_train[[1,2]]\n", + "# print(y_train[[1,2,4999]])\n", + "# print(y_train)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(5000, 3072) (500, 3072)\n" + ] + } + ], + "source": [ + "# Reshape the image data into rows\n", + "X_train = np.reshape(X_train, (X_train.shape[0], -1))\n", + "X_test = np.reshape(X_test, (X_test.shape[0], -1))\n", + "print(X_train.shape, X_test.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "from cs231n.classifiers import KNearestNeighbor\n", + "\n", + "# Create a kNN classifier instance. \n", + "# Remember that training a kNN classifier is a noop: \n", + "# the Classifier simply remembers the data and does no further processing \n", + "classifier = KNearestNeighbor()\n", + "classifier.train(X_train, y_train)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We would now like to classify the test data with the kNN classifier. Recall that we can break down this process into two steps: \n", + "\n", + "1. First we must compute the distances between all test examples and all train examples. \n", + "2. Given these distances, for each test example we find the k nearest examples and have them vote for the label\n", + "\n", + "Lets begin with computing the distance matrix between all training and test examples. For example, if there are **Ntr** training examples and **Nte** test examples, this stage should result in a **Nte x Ntr** matrix where each element (i,j) is the distance between the i-th test and j-th train example.\n", + "\n", + "First, open `cs231n/classifiers/k_nearest_neighbor.py` and implement the function `compute_distances_two_loops` that uses a (very inefficient) double loop over all pairs of (test, train) examples and computes the distance matrix one element at a time." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(500, 5000)\n" + ] + } + ], + "source": [ + "# Open cs231n/classifiers/k_nearest_neighbor.py and implement\n", + "# compute_distances_two_loops.\n", + "\n", + "# Test your implementation:\n", + "dists = classifier.compute_distances_two_loops(X_test)\n", + "print(dists.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# We can visualize the distance matrix: each row is a single test example and\n", + "# its distances to training examples\n", + "plt.imshow(dists, interpolation='none')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Inline Question #1:** Notice the structured patterns in the distance matrix, where some rows or columns are visible brighter. (Note that with the default color scheme black indicates low distances while white indicates high distances.)\n", + "\n", + "- What in the data is the cause behind the distinctly bright rows?\n", + "- What causes the columns?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Your Answer**: *fill this in.*\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[1, 2]]\n", + "[1, 2]\n" + ] + } + ], + "source": [ + "test = []\n", + "test.append([1,2])\n", + "print(test)\n", + "print(test[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# k = 5\n", + "# closest_y = np.array([3, 3, 4, 4, 4])\n", + "# most_common = 0\n", + "# label = closest_y[0]\n", + "# for j in range(k):\n", + "# vote_num = np.sum(closest_y == closest_y[j])\n", + "# print(closest_y == closest_y[j])\n", + "# print(vote_num)\n", + "# if most_common < vote_num :\n", + "# most_common = vote_num\n", + "# label = closest_y[j]\n", + "# y_pred = label\n", + "# print(y_pred)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Got 137 / 500 correct => accuracy: 0.274000\n" + ] + } + ], + "source": [ + "# Now implement the function predict_labels and run the code below:\n", + "# We use k = 1 (which is Nearest Neighbor).\n", + "y_test_pred = classifier.predict_labels(dists, k=1)\n", + "\n", + "# Compute and print the fraction of correctly predicted examples\n", + "num_correct = np.sum(y_test_pred == y_test)\n", + "accuracy = float(num_correct) / num_test\n", + "print('Got %d / %d correct => accuracy: %f' % (num_correct, num_test, accuracy))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You should expect to see approximately `27%` accuracy. Now lets try out a larger `k`, say `k = 5`:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Got 145 / 500 correct => accuracy: 0.290000\n" + ] + } + ], + "source": [ + "y_test_pred = classifier.predict_labels(dists, k=5)\n", + "# print(y_test_pred)\n", + "num_correct = np.sum(y_test_pred == y_test)\n", + "accuracy = float(num_correct) / num_test\n", + "print('Got %d / %d correct => accuracy: %f' % (num_correct, num_test, accuracy))" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# x = np.array([0, 1, 1, 3, 2, 1, 7, 23])\n", + "# print(np.bincount(x))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You should expect to see a slightly better performance than with `k = 1`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Inline Question 2**\n", + "We can also other distance metrics such as L1 distance.\n", + "The performance of a Nearest Neighbor classifier that uses L1 distance will not change if (Select all that apply.):\n", + "1. The data is preprocessed by subtracting the mean.\n", + "2. The data is preprocessed by subtracting the mean and dividing by the standard deviation.\n", + "3. The coordinate axes for the data are rotated.\n", + "4. None of the above.\n", + "\n", + "*Your Answer*:\n", + "\n", + "*Your explanation*:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "# x = np.array([[1,2], [3,4]])\n", + "# y = np.array([[2,1], [2,1], [2,1]])\n", + "# print(x, y, x-y)\n", + "# np.dot(x,x)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Difference was: 0.000000\n", + "Good! The distance matrices are the same\n" + ] + } + ], + "source": [ + "# Now lets speed up distance matrix computation by using partial vectorization\n", + "# with one loop. Implement the function compute_distances_one_loop and run the\n", + "# code below:\n", + "dists_one = classifier.compute_distances_one_loop(X_test)\n", + "\n", + "# To ensure that our vectorized implementation is correct, we make sure that it\n", + "# agrees with the naive implementation. There are many ways to decide whether\n", + "# two matrices are similar; one of the simplest is the Frobenius norm. In case\n", + "# you haven't seen it before, the Frobenius norm of two matrices is the square\n", + "# root of the squared sum of differences of all elements; in other words, reshape\n", + "# the matrices into vectors and compute the Euclidean distance between them.\n", + "difference = np.linalg.norm(dists - dists_one, ord='fro')\n", + "print('Difference was: %f' % (difference, ))\n", + "if difference < 0.001:\n", + " print('Good! The distance matrices are the same')\n", + "else:\n", + " print('Uh-oh! The distance matrices are different')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(2,) (3, 2)\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[2, 4],\n", + " [2, 6],\n", + " [2, 6]])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ts = np.array([1,2])\n", + "tt = np.array([[1,2,], [1,4], [1,4]])\n", + "print(ts.shape, tt.shape)\n", + "ts + tt" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Difference was: 0.000000\n", + "Good! The distance matrices are the same\n" + ] + } + ], + "source": [ + "# Now implement the fully vectorized version inside compute_distances_no_loops\n", + "# and run the code\n", + "dists_two = classifier.compute_distances_no_loops(X_test)\n", + "\n", + "# check that the distance matrix agrees with the one we computed before:\n", + "difference = np.linalg.norm(dists - dists_two, ord='fro')\n", + "print('Difference was: %f' % (difference, ))\n", + "if difference < 0.001:\n", + " print('Good! The distance matrices are the same')\n", + "else:\n", + " print('Uh-oh! The distance matrices are different')" + ] + }, + { + "cell_type": "code", + "execution_count": 197, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two loop version took 19.860330 seconds\n", + "One loop version took 67.483680 seconds\n", + "No loop version took 0.225398 seconds\n" + ] + } + ], + "source": [ + "# Let's compare how fast the implementations are\n", + "def time_function(f, *args):\n", + " \"\"\"\n", + " Call a function f with args and return the time (in seconds) that it took to execute.\n", + " \"\"\"\n", + " import time\n", + " tic = time.time()\n", + " f(*args)\n", + " toc = time.time()\n", + " return toc - tic\n", + "\n", + "two_loop_time = time_function(classifier.compute_distances_two_loops, X_test)\n", + "print('Two loop version took %f seconds' % two_loop_time)\n", + "\n", + "one_loop_time = time_function(classifier.compute_distances_one_loop, X_test)\n", + "print('One loop version took %f seconds' % one_loop_time)\n", + "\n", + "no_loop_time = time_function(classifier.compute_distances_no_loops, X_test)\n", + "print('No loop version took %f seconds' % no_loop_time)\n", + "\n", + "# you should see significantly faster performance with the fully vectorized implementation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Cross-validation\n", + "\n", + "We have implemented the k-Nearest Neighbor classifier but we set the value k = 5 arbitrarily. We will now determine the best value of this hyperparameter with cross-validation." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.17986816 0.87440594 0.0742834 ]\n", + " [0.02535961 0.69783367 0.01798927]]\n", + "[0.17986816 0.87440594 0.0742834 0.02535961 0.69783367 0.01798927]\n", + "[[0.17986816 0.87440594 0.0742834 ]\n", + " [0.02535961 0.69783367 0.01798927]]\n" + ] + } + ], + "source": [ + "# test_temp_y = np.random.random((2,3))\n", + "# print(test_temp_y)\n", + "# test_temp_y1 = np.array([y for x in test_temp_y for y in x])\n", + "# print(test_temp_y1)\n", + "# test_temp_y2 = np.array([y for y in test_temp_y])\n", + "# print(test_temp_y2)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.24447222 0.45677828 0.08571756 0.74106172]\n", + "[[0.24447222]\n", + " [0.45677828]\n", + " [0.08571756]\n", + " [0.74106172]]\n" + ] + } + ], + "source": [ + "# test_temp_y1 = np.random.random((4,))\n", + "# test_temp_y2 = test_temp_y1.reshape((4,1))\n", + "# test_temp_y3 = np.random.random((4,1))\n", + "# print(test_temp_y1)\n", + "# print(test_temp_y2)\n", + "# print(test_temp_y3)" + ] + }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(3, 3, 2)\n", + "(1, 3, 2)\n", + "[[1 2]\n", + " [3 4]\n", + " [3 4]\n", + " [1 2]\n", + " [3 4]\n", + " [3 4]\n", + " [1 2]\n", + " [3 4]\n", + " [3 4]\n", + " [7 8]\n", + " [3 4]\n", + " [7 4]]\n", + "(12, 2)\n" + ] + } + ], + "source": [ + "# a = list([[[1, 2], [3, 4], [3, 4]], [[1, 2], [3, 4], [3, 4]], [[1, 2], [3, 4], [3, 4]]])\n", + "# b = list([[[7, 8], [3, 4], [7, 4]]])\n", + "# print(np.array(a).shape)\n", + "# print(np.array(b).shape)\n", + "# # print(np.concatenate((a, b), axis=0))\n", + "# print(np.concatenate(a[:]+b[:]))\n", + "# print(np.concatenate(a[:]+b[:]).shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "k = 1, accuracy = 0.526000\n", + "k = 1, accuracy = 0.514000\n", + "k = 1, accuracy = 0.528000\n", + "k = 1, accuracy = 0.556000\n", + "k = 1, accuracy = 0.532000\n", + "k = 3, accuracy = 0.478000\n", + "k = 3, accuracy = 0.498000\n", + "k = 3, accuracy = 0.480000\n", + "k = 3, accuracy = 0.532000\n", + "k = 3, accuracy = 0.508000\n", + "k = 5, accuracy = 0.496000\n", + "k = 5, accuracy = 0.532000\n", + "k = 5, accuracy = 0.560000\n", + "k = 5, accuracy = 0.584000\n", + "k = 5, accuracy = 0.560000\n", + "k = 8, accuracy = 0.524000\n", + "k = 8, accuracy = 0.564000\n", + "k = 8, accuracy = 0.546000\n", + "k = 8, accuracy = 0.580000\n", + "k = 8, accuracy = 0.546000\n", + "k = 10, accuracy = 0.530000\n", + "k = 10, accuracy = 0.592000\n", + "k = 10, accuracy = 0.552000\n", + "k = 10, accuracy = 0.568000\n", + "k = 10, accuracy = 0.560000\n", + "k = 12, accuracy = 0.520000\n", + "k = 12, accuracy = 0.590000\n", + "k = 12, accuracy = 0.558000\n", + "k = 12, accuracy = 0.566000\n", + "k = 12, accuracy = 0.560000\n", + "k = 15, accuracy = 0.504000\n", + "k = 15, accuracy = 0.578000\n", + "k = 15, accuracy = 0.556000\n", + "k = 15, accuracy = 0.564000\n", + "k = 15, accuracy = 0.548000\n", + "k = 20, accuracy = 0.540000\n", + "k = 20, accuracy = 0.558000\n", + "k = 20, accuracy = 0.558000\n", + "k = 20, accuracy = 0.564000\n", + "k = 20, accuracy = 0.570000\n", + "k = 50, accuracy = 0.542000\n", + "k = 50, accuracy = 0.576000\n", + "k = 50, accuracy = 0.556000\n", + "k = 50, accuracy = 0.538000\n", + "k = 50, accuracy = 0.532000\n", + "k = 100, accuracy = 0.512000\n", + "k = 100, accuracy = 0.540000\n", + "k = 100, accuracy = 0.526000\n", + "k = 100, accuracy = 0.512000\n", + "k = 100, accuracy = 0.526000\n" + ] + } + ], + "source": [ + "num_folds = 5\n", + "k_choices = [1, 3, 5, 8, 10, 12, 15, 20, 50, 100]\n", + "\n", + "X_train_folds = []\n", + "y_train_folds = []\n", + "################################################################################\n", + "# TODO: #\n", + "# Split up the training data into folds. After splitting, X_train_folds and #\n", + "# y_train_folds should each be lists of length num_folds, where #\n", + "# y_train_folds[i] is the label vector for the points in X_train_folds[i]. #\n", + "# Hint: Look up the numpy array_split function. #\n", + "################################################################################\n", + "X_train_folds = np.array_split(X_train, num_folds)\n", + "y_train_folds = np.array_split(y_train, num_folds)\n", + "################################################################################\n", + "# END OF YOUR CODE #\n", + "################################################################################\n", + "\n", + "# A dictionary holding the accuracies for different values of k that we find\n", + "# when running cross-validation. After running cross-validation,\n", + "# k_to_accuracies[k] should be a list of length num_folds giving the different\n", + "# accuracy values that we found when using that value of k.\n", + "k_to_accuracies = {}\n", + "\n", + "\n", + "################################################################################\n", + "# TODO: #\n", + "# Perform k-fold cross validation to find the best value of k. For each #\n", + "# possible value of k, run the k-nearest-neighbor algorithm num_folds times, #\n", + "# where in each case you use all but one of the folds as training data and the #\n", + "# last fold as a validation set. Store the accuracies for all fold and all #\n", + "# values of k in the k_to_accuracies dictionary. #\n", + "################################################################################\n", + "for k in k_choices:\n", + " accuracies = []\n", + " for i in range(num_folds):\n", + " classifier = KNearestNeighbor()\n", + "# classifier.train(np.array(X_train_folds[i+1:]).reshape(4000, -1), np.array(y_train_folds[i+1:]).reshape(4000, ))\n", + "# classifier.train(np.delete(X_train, i:i+np.array(X_train_folds[i]).shape[0], 0), \n", + "# np.delete(y_train, i:i+np.array(y_train_folds[i]).shape[0], 0))\n", + "# print(np.array(X_train_folds[i+1:]).reshape(4000, -1).shape)\n", + "# print(np.array(y_train_folds[i+1:]).shape)\n", + "\n", + " temp_X = X_train_folds[:]\n", + " temp_y = y_train_folds[:]\n", + "# print(type(temp_X)) #\n", + "# print(type(temp_X[0])) #\n", + "# print(np.array(temp_X).shape, np.array(temp_y).shape)\n", + " X_validate_fold = temp_X.pop(i)\n", + " y_validate_fold = temp_y.pop(i)\n", + "# print(np.array(X_validate_fold).shape, np.array(y_validate_fold).shape)\n", + "# print(np.array(temp_X).shape, np.array(temp_y).shape)\n", + "# print(\"f\",np.array(temp_X).shape)\n", + "# print(\"f\",np.array(temp_y).shape)\n", + "\n", + "# temp_X = np.array([y for x in temp_X for y in x])\n", + "# print(temp_X.shape) \n", + "# temp_y = np.array([y for x in temp_y for y in x])\n", + "# print(temp_y.shape)\n", + "# classifier.train(temp_X, temp_y)\n", + " classifier.train(np.array(temp_X).reshape(4000, -1), np.array(temp_y).reshape(4000, ))\n", + "# print(\"@\",np.array(temp_X).reshape(4000, -1).shape)\n", + "# print(\"@\",np.array(temp_y).reshape(4000, -1).shape)\n", + " \n", + " \n", + "# classifier.train(np.concatenate(X_train_folds[0:i]+ X_train_folds[i+1:]), \n", + "# np.concatenate(y_train_folds[0:i]+ y_train_folds[i+1:]))\n", + "# classifier.train(np.concatenate((X_train_folds[0:i], X_train_folds[i+1:]), axis = 0), \n", + "# np.concatenate((y_train_folds[0:i], y_train_folds[i+1:]), axis = 0))\n", + " dists = classifier.compute_distances_no_loops(X_train_folds[i])\n", + "# print(X_train_folds[i].shape)\n", + "# print(dists.shape)\n", + " \n", + " y_train_pred = classifier.predict_labels(dists, k=k)\n", + "# y_train_pred = classifier.predict((X_train_folds[i]), k=k)\n", + " num_correct = np.sum(y_train_pred == y_train_folds[i])\n", + " accuracies.append(float(num_correct) / num_test)\n", + " k_to_accuracies[k] = accuracies\n", + "################################################################################\n", + "# END OF YOUR CODE #\n", + "################################################################################\n", + "\n", + "# Print out the computed accuracies\n", + "for k in sorted(k_to_accuracies):\n", + " for accuracy in k_to_accuracies[k]:\n", + " print('k = %d, accuracy = %f' % (k, accuracy))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# plot the raw observations\n", + "for k in k_choices:\n", + " accuracies = k_to_accuracies[k]\n", + " plt.scatter([k] * len(accuracies), accuracies)\n", + "\n", + "# plot the trend line with error bars that correspond to standard deviation\n", + "accuracies_mean = np.array([np.mean(v) for k,v in sorted(k_to_accuracies.items())])\n", + "accuracies_std = np.array([np.std(v) for k,v in sorted(k_to_accuracies.items())])\n", + "plt.errorbar(k_choices, accuracies_mean, yerr=accuracies_std)\n", + "plt.title('Cross-validation on k')\n", + "plt.xlabel('k')\n", + "plt.ylabel('Cross-validation accuracy')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.5312 0.4992 0.5464 0.552 0.5604 0.5588 0.55 0.558 0.5488 0.5232]\n", + "10\n", + "Got 141 / 500 correct => accuracy: 0.282000\n" + ] + } + ], + "source": [ + "# Based on the cross-validation results above, choose the best value for k, \n", + "# retrain the classifier using all the training data, and test it on the test\n", + "# data. You should be able to get above 28% accuracy on the test data.\n", + "best_k = k_choices[np.argmax(accuracies_mean)]\n", + "# print(accuracies_mean)\n", + "# print(best_k)\n", + "\n", + "classifier = KNearestNeighbor()\n", + "classifier.train(X_train, y_train)\n", + "y_test_pred = classifier.predict(X_test, k=best_k)\n", + "\n", + "# Compute and display the accuracy\n", + "num_correct = np.sum(y_test_pred == y_test)\n", + "accuracy = float(num_correct) / num_test\n", + "print('Got %d / %d correct => accuracy: %f' % (num_correct, num_test, accuracy))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Inline Question 3**\n", + "Which of the following statements about $k$-Nearest Neighbor ($k$-NN) are true in a classification setting, and for all $k$? Select all that apply.\n", + "1. The training error of a 1-NN will always be better than that of 5-NN.\n", + "2. The test error of a 1-NN will always be better than that of a 5-NN.\n", + "3. The decision boundary of the k-NN classifier is linear.\n", + "4. The time needed to classify a test example with the k-NN classifier grows with the size of the training set.\n", + "5. None of the above.\n", + "\n", + "*Your Answer*:\n", + "\n", + "*Your explanation*:" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/assignment1/requirements.txt b/assignment1/requirements.txt new file mode 100644 index 000000000..41067441c --- /dev/null +++ b/assignment1/requirements.txt @@ -0,0 +1,46 @@ +Cython==0.23.4 +Jinja2==2.8 +MarkupSafe==0.23 +Pillow==3.0.0 +Pygments==2.0.2 +appnope==0.1.0 +argparse==1.2.1 +backports-abc==0.4 +backports.ssl-match-hostname==3.5.0.1 +certifi==2015.11.20.1 +cycler==0.10.0 +decorator==4.0.6 +future==0.16.0 +gnureadline==6.3.3 +ipykernel==4.2.2 +ipython==4.0.1 +ipython-genutils==0.1.0 +ipywidgets==4.1.1 +jsonschema==2.5.1 +jupyter==1.0.0 +jupyter-client==4.1.1 +jupyter-console==4.0.3 +jupyter-core==4.0.6 +matplotlib==2.0.0 +mistune==0.7.1 +nbconvert==4.1.0 +nbformat==4.0.1 +notebook==4.0.6 +numpy==1.10.4 +path.py==8.1.2 +pexpect==4.0.1 +pickleshare==0.5 +ptyprocess==0.5 +pyparsing==2.0.7 +python-dateutil==2.4.2 +pytz==2015.7 +pyzmq==15.1.0 +qtconsole==4.1.1 +scipy==0.16.1 +simplegeneric==0.8.1 +singledispatch==3.4.0.3 +sites==0.0.1 +six==1.10.0 +terminado==0.5 +tornado==4.3 +traitlets==4.0.0 diff --git a/assignment1/setup_googlecloud.sh b/assignment1/setup_googlecloud.sh new file mode 100644 index 000000000..2c6f5f315 --- /dev/null +++ b/assignment1/setup_googlecloud.sh @@ -0,0 +1,24 @@ +#!/usr/bin/env bash + +# This is the set-up script for Google Cloud. +sudo apt-get update +sudo apt-get install libncurses5-dev +sudo apt-get install python-dev +sudo apt-get install python-pip +sudo apt-get install libjpeg8-dev +sudo ln -s /usr/lib/x86_64-linux-gnu/libjpeg.so /usr/lib +pip install pillow +sudo apt-get build-dep python-imaging +sudo apt-get install libjpeg8 libjpeg62-dev libfreetype6 libfreetype6-dev +sudo pip install virtualenv +virtualenv .env # Create a virtual environment +source .env/bin/activate # Activate the virtual environment +pip install -r requirements.txt # Install dependencies +deactivate +echo "**************************************************" +echo "***** End of Google Cloud Set-up Script ********" +echo "**************************************************" +echo "" +echo "If you had no errors, You can proceed to work with your virtualenv as normal." +echo "(run 'source .env/bin/activate' in your assignment directory to load the venv," +echo " and run 'deactivate' to exit the venv. See assignment handout for details.)" diff --git a/assignment1/softmax.ipynb b/assignment1/softmax.ipynb new file mode 100644 index 000000000..7a789477a --- /dev/null +++ b/assignment1/softmax.ipynb @@ -0,0 +1,435 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Softmax exercise\n", + "\n", + "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n", + "\n", + "This exercise is analogous to the SVM exercise. You will:\n", + "\n", + "- implement a fully-vectorized **loss function** for the Softmax classifier\n", + "- implement the fully-vectorized expression for its **analytic gradient**\n", + "- **check your implementation** with numerical gradient\n", + "- use a validation set to **tune the learning rate and regularization** strength\n", + "- **optimize** the loss function with **SGD**\n", + "- **visualize** the final learned weights\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "import random\n", + "import numpy as np\n", + "from cs231n.data_utils import load_CIFAR10\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "# for auto-reloading extenrnal modules\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train data shape: (49000, 3073)\n", + "Train labels shape: (49000,)\n", + "Validation data shape: (1000, 3073)\n", + "Validation labels shape: (1000,)\n", + "Test data shape: (1000, 3073)\n", + "Test labels shape: (1000,)\n", + "dev data shape: (500, 3073)\n", + "dev labels shape: (500,)\n" + ] + } + ], + "source": [ + "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000, num_dev=500):\n", + " \"\"\"\n", + " Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n", + " it for the linear classifier. These are the same steps as we used for the\n", + " SVM, but condensed to a single function. \n", + " \"\"\"\n", + " # Load the raw CIFAR-10 data\n", + " cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n", + " \n", + " X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n", + " \n", + " # subsample the data\n", + " mask = list(range(num_training, num_training + num_validation))\n", + " X_val = X_train[mask]\n", + " y_val = y_train[mask]\n", + " mask = list(range(num_training))\n", + " X_train = X_train[mask]\n", + " y_train = y_train[mask]\n", + " mask = list(range(num_test))\n", + " X_test = X_test[mask]\n", + " y_test = y_test[mask]\n", + " mask = np.random.choice(num_training, num_dev, replace=False)\n", + " X_dev = X_train[mask]\n", + " y_dev = y_train[mask]\n", + " \n", + " # Preprocessing: reshape the image data into rows\n", + " X_train = np.reshape(X_train, (X_train.shape[0], -1))\n", + " X_val = np.reshape(X_val, (X_val.shape[0], -1))\n", + " X_test = np.reshape(X_test, (X_test.shape[0], -1))\n", + " X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n", + " \n", + " # Normalize the data: subtract the mean image\n", + " mean_image = np.mean(X_train, axis = 0)\n", + " X_train -= mean_image\n", + " X_val -= mean_image\n", + " X_test -= mean_image\n", + " X_dev -= mean_image\n", + " \n", + " # add bias dimension and transform into columns\n", + " X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n", + " X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n", + " X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n", + " X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n", + " \n", + " return X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev\n", + "\n", + "\n", + "# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n", + "try:\n", + " del X_train, y_train\n", + " del X_test, y_test\n", + " print('Clear previously loaded data.')\n", + "except:\n", + " pass\n", + "\n", + "# Invoke the above function to get our data.\n", + "X_train, y_train, X_val, y_val, X_test, y_test, X_dev, y_dev = get_CIFAR10_data()\n", + "print('Train data shape: ', X_train.shape)\n", + "print('Train labels shape: ', y_train.shape)\n", + "print('Validation data shape: ', X_val.shape)\n", + "print('Validation labels shape: ', y_val.shape)\n", + "print('Test data shape: ', X_test.shape)\n", + "print('Test labels shape: ', y_test.shape)\n", + "print('dev data shape: ', X_dev.shape)\n", + "print('dev labels shape: ', y_dev.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Softmax Classifier\n", + "\n", + "Your code for this section will all be written inside **cs231n/classifiers/softmax.py**. \n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss: 2.360768\n", + "sanity check: 2.302585\n" + ] + } + ], + "source": [ + "# First implement the naive softmax loss function with nested loops.\n", + "# Open the file cs231n/classifiers/softmax.py and implement the\n", + "# softmax_loss_naive function.\n", + "\n", + "from cs231n.classifiers.softmax import softmax_loss_naive\n", + "import time\n", + "\n", + "# Generate a random softmax weight matrix and use it to compute the loss.\n", + "W = np.random.randn(3073, 10) * 0.0001\n", + "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n", + "\n", + "# As a rough sanity check, our loss should be something close to -log(0.1).\n", + "print('loss: %f' % loss)\n", + "print('sanity check: %f' % (-np.log(0.1)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Inline Question 1:\n", + "Why do we expect our loss to be close to -log(0.1)? Explain briefly.**\n", + "\n", + "**Your answer:** *Fill this in*\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "numerical: 1.840498 analytic: 1.840498, relative error: 9.463563e-09\n", + "numerical: 1.360287 analytic: 1.360287, relative error: 5.428264e-08\n", + "numerical: 2.471600 analytic: 2.471600, relative error: 6.999345e-09\n", + "numerical: -3.609723 analytic: -3.609723, relative error: 4.592565e-09\n", + "numerical: 0.455820 analytic: 0.455820, relative error: 1.799344e-07\n", + "numerical: -3.553380 analytic: -3.553380, relative error: 2.093326e-09\n", + "numerical: 2.474077 analytic: 2.474077, relative error: 3.668579e-09\n", + "numerical: 1.791949 analytic: 1.791949, relative error: 8.629964e-09\n", + "numerical: -1.208928 analytic: -1.208928, relative error: 2.653493e-08\n", + "numerical: -0.772397 analytic: -0.772397, relative error: 1.595247e-08\n", + "==============\n", + "numerical: -1.915317 analytic: -1.915317, relative error: 1.185577e-08\n", + "numerical: -1.771815 analytic: -1.771815, relative error: 3.182251e-09\n", + "numerical: -0.441094 analytic: -0.441094, relative error: 7.897026e-08\n", + "numerical: -0.083030 analytic: -0.083030, relative error: 7.455856e-08\n", + "numerical: 0.301674 analytic: 0.301674, relative error: 5.518636e-08\n", + "numerical: 1.394915 analytic: 1.394914, relative error: 1.621416e-08\n", + "numerical: 0.653937 analytic: 0.653937, relative error: 2.905406e-08\n", + "numerical: 1.600552 analytic: 1.600552, relative error: 1.438189e-08\n", + "numerical: 1.636157 analytic: 1.636156, relative error: 3.326788e-08\n", + "numerical: 0.167717 analytic: 0.167717, relative error: 1.718313e-07\n" + ] + } + ], + "source": [ + "# Complete the implementation of softmax_loss_naive and implement a (naive)\n", + "# version of the gradient that uses nested loops.\n", + "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 0.0)\n", + "\n", + "# As we did for the SVM, use numeric gradient checking as a debugging tool.\n", + "# The numeric gradient should be close to the analytic gradient.\n", + "from cs231n.gradient_check import grad_check_sparse\n", + "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 0.0)[0]\n", + "grad_numerical = grad_check_sparse(f, W, grad, 10)\n", + "\n", + "print(\"==============\")\n", + "# similar to SVM case, do another gradient check with regularization\n", + "loss, grad = softmax_loss_naive(W, X_dev, y_dev, 5e1)\n", + "f = lambda w: softmax_loss_naive(w, X_dev, y_dev, 5e1)[0]\n", + "grad_numerical = grad_check_sparse(f, W, grad, 10)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "naive loss: 2.360768e+00 computed in 0.035903s\n", + "vectorized loss: 2.360768e+00 computed in 0.006986s\n", + "Loss difference: 0.000000\n", + "Gradient difference: 0.000000\n" + ] + } + ], + "source": [ + "# Now that we have a naive implementation of the softmax loss function and its gradient,\n", + "# implement a vectorized version in softmax_loss_vectorized.\n", + "# The two versions should compute the same results, but the vectorized version should be\n", + "# much faster.\n", + "tic = time.time()\n", + "loss_naive, grad_naive = softmax_loss_naive(W, X_dev, y_dev, 0.000005)\n", + "toc = time.time()\n", + "print('naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n", + "\n", + "from cs231n.classifiers.softmax import softmax_loss_vectorized\n", + "tic = time.time()\n", + "loss_vectorized, grad_vectorized = softmax_loss_vectorized(W, X_dev, y_dev, 0.000005)\n", + "toc = time.time()\n", + "print('vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n", + "\n", + "# As we did for the SVM, we use the Frobenius norm to compare the two versions\n", + "# of the gradient.\n", + "grad_difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n", + "print('Loss difference: %f' % np.abs(loss_naive - loss_vectorized))\n", + "print('Gradient difference: %f' % grad_difference)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(lr, reg) 1e-07 25000.0 (y_train_pre, y_val_pre) (0.32142857142857145, 0.345)\n", + "(lr, reg) 1e-07 50000.0 (y_train_pre, y_val_pre) (0.30006122448979594, 0.313)\n", + "(lr, reg) 5e-07 25000.0 (y_train_pre, y_val_pre) (0.3226530612244898, 0.32)\n", + "(lr, reg) 5e-07 50000.0 (y_train_pre, y_val_pre) (0.30557142857142855, 0.319)\n", + "lr 1.000000e-07 reg 2.500000e+04 train accuracy: 0.321429 val accuracy: 0.345000\n", + "lr 1.000000e-07 reg 5.000000e+04 train accuracy: 0.300061 val accuracy: 0.313000\n", + "lr 5.000000e-07 reg 2.500000e+04 train accuracy: 0.322653 val accuracy: 0.320000\n", + "lr 5.000000e-07 reg 5.000000e+04 train accuracy: 0.305571 val accuracy: 0.319000\n", + "best validation accuracy achieved during cross-validation: 0.345000\n" + ] + } + ], + "source": [ + "# Use the validation set to tune hyperparameters (regularization strength and\n", + "# learning rate). You should experiment with different ranges for the learning\n", + "# rates and regularization strengths; if you are careful you should be able to\n", + "# get a classification accuracy of over 0.35 on the validation set.\n", + "from cs231n.classifiers import Softmax\n", + "results = {}\n", + "best_val = -1\n", + "best_softmax = None\n", + "learning_rates = [1e-7, 5e-7]\n", + "regularization_strengths = [2.5e4, 5e4]\n", + "\n", + "################################################################################\n", + "# TODO: #\n", + "# Use the validation set to set the learning rate and regularization strength. #\n", + "# This should be identical to the validation that you did for the SVM; save #\n", + "# the best trained softmax classifer in best_softmax. #\n", + "################################################################################\n", + "for lr in learning_rates:\n", + " for reg in regularization_strengths:\n", + " softmax = Softmax()\n", + " loss_hist = softmax.train(X_train, y_train, learning_rate=lr, reg=reg, num_iters=1500, verbose=False)\n", + " results[(lr, reg)] = ( np.mean( y_train == softmax.predict(X_train) ), np.mean( y_val == softmax.predict(X_val) ) )\n", + " print(\"(lr, reg)\", lr, reg, \"(y_train_pre, y_val_pre)\",results[(lr, reg)])\n", + "# print(results[(lr, reg)][1])\n", + " if (results[(lr, reg)][1] > best_val) :\n", + " best_val = results[(lr, reg)][1]\n", + " best_softmax = softmax\n", + "################################################################################\n", + "# END OF YOUR CODE #\n", + "################################################################################\n", + " \n", + "# Print out results.\n", + "for lr, reg in sorted(results):\n", + " train_accuracy, val_accuracy = results[(lr, reg)]\n", + " print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n", + " lr, reg, train_accuracy, val_accuracy))\n", + " \n", + "print('best validation accuracy achieved during cross-validation: %f' % best_val)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "softmax on raw pixels final test set accuracy: 0.330000\n" + ] + } + ], + "source": [ + "# evaluate on test set\n", + "# Evaluate the best softmax on test set\n", + "y_test_pred = best_softmax.predict(X_test)\n", + "test_accuracy = np.mean(y_test == y_test_pred)\n", + "print('softmax on raw pixels final test set accuracy: %f' % (test_accuracy, ))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Inline Question** - *True or False*\n", + "\n", + "It's possible to add a new datapoint to a training set that would leave the SVM loss unchanged, but this is not the case with the Softmax classifier loss.\n", + "\n", + "*Your answer*:\n", + "\n", + "*Your explanation*:" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the learned weights for each class\n", + "w = best_softmax.W[:-1,:] # strip out the bias\n", + "w = w.reshape(32, 32, 3, 10)\n", + "\n", + "w_min, w_max = np.min(w), np.max(w)\n", + "\n", + "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n", + "for i in range(10):\n", + " plt.subplot(2, 5, i + 1)\n", + " \n", + " # Rescale the weights to be between 0 and 255\n", + " wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n", + " plt.imshow(wimg.astype('uint8'))\n", + " plt.axis('off')\n", + " plt.title(classes[i])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/assignment1/start_ipython_osx.sh b/assignment1/start_ipython_osx.sh new file mode 100644 index 000000000..4815b0012 --- /dev/null +++ b/assignment1/start_ipython_osx.sh @@ -0,0 +1,4 @@ +# Assume the virtualenv is called .env + +cp frameworkpython .env/bin +.env/bin/frameworkpython -m IPython notebook diff --git a/assignment1/svm.ipynb b/assignment1/svm.ipynb new file mode 100644 index 000000000..bef86d3be --- /dev/null +++ b/assignment1/svm.ipynb @@ -0,0 +1,934 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multiclass Support Vector Machine exercise\n", + "\n", + "*Complete and hand in this completed worksheet (including its outputs and any supporting code outside of the worksheet) with your assignment submission. For more details see the [assignments page](http://vision.stanford.edu/teaching/cs231n/assignments.html) on the course website.*\n", + "\n", + "In this exercise you will:\n", + " \n", + "- implement a fully-vectorized **loss function** for the SVM\n", + "- implement the fully-vectorized expression for its **analytic gradient**\n", + "- **check your implementation** using numerical gradient\n", + "- use a validation set to **tune the learning rate and regularization** strength\n", + "- **optimize** the loss function with **SGD**\n", + "- **visualize** the final learned weights\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from __future__ import print_function\n", + "# Run some setup code for this notebook.\n", + "\n", + "import random\n", + "import numpy as np\n", + "from cs231n.data_utils import load_CIFAR10\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "\n", + "# This is a bit of magic to make matplotlib figures appear inline in the\n", + "# notebook rather than in a new window.\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "# Some more magic so that the notebook will reload external python modules;\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## CIFAR-10 Data Loading and Preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training data shape: (50000, 32, 32, 3)\n", + "Training labels shape: (50000,)\n", + "Test data shape: (10000, 32, 32, 3)\n", + "Test labels shape: (10000,)\n" + ] + } + ], + "source": [ + "# Load the raw CIFAR-10 data.\n", + "cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n", + "\n", + "# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n", + "try:\n", + " del X_train, y_train\n", + " del X_test, y_test\n", + " print('Clear previously loaded data.')\n", + "except:\n", + " pass\n", + "\n", + "X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n", + "\n", + "# As a sanity check, we print out the size of the training and test data.\n", + "print('Training data shape: ', X_train.shape)\n", + "print('Training labels shape: ', y_train.shape)\n", + "print('Test data shape: ', X_test.shape)\n", + "print('Test labels shape: ', y_test.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize some examples from the dataset.\n", + "# We show a few examples of training images from each class.\n", + "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n", + "num_classes = len(classes)\n", + "samples_per_class = 7\n", + "for y, cls in enumerate(classes):\n", + " idxs = np.flatnonzero(y_train == y)\n", + " idxs = np.random.choice(idxs, samples_per_class, replace=False)\n", + " for i, idx in enumerate(idxs):\n", + " plt_idx = i * num_classes + y + 1\n", + " plt.subplot(samples_per_class, num_classes, plt_idx)\n", + " plt.imshow(X_train[idx].astype('uint8'))\n", + " plt.axis('off')\n", + " if i == 0:\n", + " plt.title(cls)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train data shape: (49000, 32, 32, 3)\n", + "Train labels shape: (49000,)\n", + "Validation data shape: (1000, 32, 32, 3)\n", + "Validation labels shape: (1000,)\n", + "Test data shape: (1000, 32, 32, 3)\n", + "Test labels shape: (1000,)\n" + ] + } + ], + "source": [ + "# Split the data into train, val, and test sets. In addition we will\n", + "# create a small development set as a subset of the training data;\n", + "# we can use this for development so our code runs faster.\n", + "num_training = 49000\n", + "num_validation = 1000\n", + "num_test = 1000\n", + "num_dev = 500\n", + "\n", + "# Our validation set will be num_validation points from the original\n", + "# training set.\n", + "mask = range(num_training, num_training + num_validation)\n", + "X_val = X_train[mask]\n", + "y_val = y_train[mask]\n", + "# print(y_val)\n", + "# print(y_train[num_training:num_training + num_validation])\n", + "\n", + "# Our training set will be the first num_train points from the original\n", + "# training set.\n", + "mask = range(num_training)\n", + "X_train = X_train[mask]\n", + "y_train = y_train[mask]\n", + "\n", + "# We will also make a development set, which is a small subset of\n", + "# the training set.\n", + "mask = np.random.choice(num_training, num_dev, replace=False)\n", + "X_dev = X_train[mask]\n", + "y_dev = y_train[mask]\n", + "\n", + "# We use the first num_test points of the original test set as our\n", + "# test set.\n", + "mask = range(num_test)\n", + "X_test = X_test[mask]\n", + "y_test = y_test[mask]\n", + "\n", + "print('Train data shape: ', X_train.shape)\n", + "print('Train labels shape: ', y_train.shape)\n", + "print('Validation data shape: ', X_val.shape)\n", + "print('Validation labels shape: ', y_val.shape)\n", + "print('Test data shape: ', X_test.shape)\n", + "print('Test labels shape: ', y_test.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training data shape: (49000, 3072)\n", + "Validation data shape: (1000, 3072)\n", + "Test data shape: (1000, 3072)\n", + "dev data shape: (500, 3072)\n" + ] + } + ], + "source": [ + "# Preprocessing: reshape the image data into rows\n", + "X_train = np.reshape(X_train, (X_train.shape[0], -1))\n", + "X_val = np.reshape(X_val, (X_val.shape[0], -1))\n", + "X_test = np.reshape(X_test, (X_test.shape[0], -1))\n", + "X_dev = np.reshape(X_dev, (X_dev.shape[0], -1))\n", + "\n", + "# As a sanity check, print out the shapes of the data\n", + "print('Training data shape: ', X_train.shape)\n", + "print('Validation data shape: ', X_val.shape)\n", + "print('Test data shape: ', X_test.shape)\n", + "print('dev data shape: ', X_dev.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[130.64189796 135.98173469 132.47391837 130.05569388 135.34804082\n", + " 131.75402041 130.96055102 136.14328571 132.47636735 131.48467347]\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAP8AAAD8CAYAAAC4nHJkAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAEhdJREFUeJzt3W+oZdV5x/HvL0YT71Ucp0YzjFKN+CISmlEug2AJNmmDlYAKTdAX4gvJpG2ECukLsVAt9IUpVRFaDGMdMinWP42KQ5E2IimSN8arHccx0zZGpsnUYcagop0bmuo8fXH2wJ3J3euc85y997mT9fvAcM/d+6y9nrPveWafu5+71lJEYGb1+ci8AzCz+XDym1XKyW9WKSe/WaWc/GaVcvKbVcrJb1YpJ79ZpZz8ZpX66CyNJV0N3A+cAvxdRNxdev7i4mJsOHvDLF0OQNO3mL6JzVn+D1vX91/EvvvOuxw5cmSid2Q6+SWdAvwt8HvAAeBFSbsi4kdtbTacvYE/vPWPW/YWTmpLdpVeoZIZmWlXbtK+M9ls/eg4D/KHm75lNvmzfw5fate6J9HXt/7mgYmfO8vH/q3A6xHxRkT8EngUuHaG45nZgGZJ/s3Az1Z9f6DZZmYngVmSf60Ppr/yOUXSNknLkpaPHDkyQ3dm1qVZkv8AcMGq788H3jzxSRGxPSKWImJpcXFxhu7MrEuzJP+LwCWSLpJ0GnADsKubsMysb+m7/RHxgaRbgX9hVOrbERGvTdCy7XitLdTWpnRLvHSntHQnPQo723YV22RvK+ea/brqujIXySMW7/bndrXH0vN7YKY6f0Q8AzzTUSxmNiD/hZ9ZpZz8ZpVy8ptVyslvViknv1mlZrrbn9FWKok4WmjUUkpLl9GSpbm2XYWRPcXD9TJ4p7UeWQikjziGkwk/PUAneR6LvaXKkWv/nKd5Wb7ym1XKyW9WKSe/WaWc/GaVcvKbVWrwu/3ttzYTA3GSd1fbBgqNDSMxsKd4R7/4krOlgMSUVoU2w0WRbZQ9ZGZPeWc2/G4H9kzeyFd+s0o5+c0q5eQ3q5ST36xSTn6zSjn5zSo1bKkvolBLK5Xf1t7XRxmqWJnLDDBKTyWYrBFmesusJtODPvrqen68fDlvuL4m5Su/WaWc/GaVcvKbVcrJb1YpJ79ZpZz8ZpWaqdQnaT/wPvAh8EFELJWeH5Tm8Jt+ZFm5FDJgkSo7GV/X1bysPvrK/dBadR1iP2XFIdvN/gq6qPP/TkT8vIPjmNmA/LHfrFKzJn8A35P0kqRtXQRkZsOY9WP/lRHxpqRzgWcl/XtEPL/6Cc1/CtsAzjrrrBm7M7OuzHTlj4g3m6+HgaeArWs8Z3tELEXE0sLiwizdmVmH0skvaVHSmcceA18E9nYVmJn1a5aP/ecBT2k0+uyjwD9ExD+Pbzb9BJ7lZYum6wbyFba2iT+jcMTyyL3CzvUiPQRyuDhSXSXP/bDlvH7fIOnkj4g3gM92GIuZDcilPrNKOfnNKuXkN6uUk9+sUk5+s0oNvlZfxNGptpcP1r6ruB7f9D3lA+mhWefWSzmvB60hZmMvTKzafRkwtXDkxP36ym9WKSe/WaWc/GaVcvKbVcrJb1apge/2ty/XlZnDL7/MVKGvrgeQDKzzoSBDToXYx0ETJ6Q0UKv0nis2mz6M9ICxSfnKb1YpJ79ZpZz8ZpVy8ptVyslvViknv1mlBh/Y01oqyczhlxzYU1Kq5LR1WBz7kpxLMKutu3RfxYZdv4Iein0tEyWW50/MjXQadn6/2Q/mK79ZpZz8ZpVy8ptVyslvViknv1mlnPxmlRpb6pO0A/gScDgiPtNs2wg8BlwI7Ae+EhHvTNJh+9JbpeF007fJl9gyw/pyQwGzU+fl9LE+1cB1zOmjGLt3baVyXrKEnDohpfL37Cd4kiv/t4GrT9h2O/BcRFwCPNd8b2YnkbHJHxHPA2+fsPlaYGfzeCdwXcdxmVnPsr/znxcRBwGar+d2F5KZDaH3G36StklalrS8cmSl7+7MbELZ5D8kaRNA8/Vw2xMjYntELEXE0sLiQrI7M+taNvl3ATc3j28Gnu4mHDMbyiSlvkeAq4BzJB0A7gTuBh6XdAvwU+DLE/UWFCbwbF+uq31Szexsm90ur5WafHRwfUyPmZixMn1COi6Mlt46pVlcs7N0Fo6Zefe0rxo2+c95bPJHxI0tu74wcS9mtu74L/zMKuXkN6uUk9+sUk5+s0o5+c0qdXJM4FmeVXNNSq7jl5rXMRFfX4YtLXZdfsudRxXLaC1xFGddLfVW6Ku9/pZ7aekYJ+Mrv1mlnPxmlXLym1XKyW9WKSe/WaWc/GaVGrjUFwQto/dKtZBBJ/As6LikVxo8VqgadT5Ar5/yYMvozWQc+UGanQ8vLHSVe9O1lSP7fgv4ym9WKSe/WaWc/GaVcvKbVcrJb1apdTOwpzx4Z+19pcE75RhSu1BrHLkwStLVikQs+eWu1scMhZnTX3y/Je7Mj4uj+FZteQOV+pJmv277ym9WKSe/WaWc/GaVcvKbVcrJb1YpJ79ZpSZZrmsH8CXgcER8ptl2F/BV4K3maXdExDOzhTL9wJ7sMlnlKs/0haPs8bLlvPVTfOu2rjh9sbeRWEGrVEbLLuVVPhvTlwjLJd3Z68uTXPm/DVy9xvb7ImJL82/GxDezoY1N/oh4Hnh7gFjMbECz/M5/q6Q9knZIOruziMxsENnkfwC4GNgCHATuaXuipG2SliUtr6ysJLszs66lkj8iDkXEhxFxFHgQ2Fp47vaIWIqIpYWFhWycZtaxVPJL2rTq2+uBvd2EY2ZDmaTU9whwFXCOpAPAncBVkrYwqlLsB742cY+J5bpSS3wVQsgu5dXeKFm/Kh+0sC9RCOwjxK7lqm+p11Ys9ZXiKJYBuy3QZkaYTvPTHJv8EXHjGpsfmrgHM1uX/Bd+ZpVy8ptVyslvViknv1mlnPxmlRp+As/WZZy6LfWly4Bd18R6mGS0uExZ5oDpEBPlyB7WoMqU7UqxlyfbLIzOKw7TnH68ZalJJiVO5Cu/WaWc/GaVcvKbVcrJb1YpJ79ZpZz8ZpWaQ6mvRak011rXOFo4Xq6vlPTowsIhk3WvtupQ+SX3Ma4vMbowUQ4bd9DW110q2ZV66ricVxSFtfo6+Jn5ym9WKSe/WaWc/GaVcvKbVcrJb1apge/2R+pOe/vd/tzAnvygn5bt2UE4yRu25bExJ/Ecfsk76anxVsk5Evs4V+0vrd+fjK/8ZpVy8ptVyslvViknv1mlnPxmlXLym1VqkuW6LgC+A3wSOApsj4j7JW0EHgMuZLRk11ci4p1sIMUBE23z/vVQ6stID5opVbZyR2zfu07qeYWxKmMadtxf18cbc8zyfHxr7yyfqmEG9nwAfCMiPg1cAXxd0qXA7cBzEXEJ8FzzvZmdJMYmf0QcjIiXm8fvA/uAzcC1wM7maTuB6/oK0sy6N9Xv/JIuBC4DXgDOi4iDMPoPAji36+DMrD8TJ7+kM4AngNsi4r0p2m2TtCxpeeXILzIxmlkPJkp+SacySvyHI+LJZvMhSZua/ZuAw2u1jYjtEbEUEUsLi6d3EbOZdWBs8ksS8BCwLyLuXbVrF3Bz8/hm4OnuwzOzvkwyqu9K4CbgVUm7m213AHcDj0u6Bfgp8OV+QsxJVA4n2dlxIMkoEiXC8nJohb46npau3Ff3a3m1n/7SEl/dn6vygMXMa5v9BzM2+SPiB4WevjBzBGY2F/4LP7NKOfnNKuXkN6uUk9+sUk5+s0qtn+W6ihNdtozqyx4vXTZau13X1bCms1yzqXdkD5hUrOYNtxRWdgLPrNwR0/XqifjKb1YpJ79ZpZz8ZpVy8ptVyslvViknv1ml1lGpr70Y0lbl6XgezmNH7bjFOpk5sw+lgXGJw5VHMiZnO81Eki45Dls+nJWv/GaVcvKbVcrJb1YpJ79ZpZz8ZpVaN3f7i8sZFWama20z8LJQ7dZJIAPfbF43p3Go4407aKm/1n2FCliimxP5ym9WKSe/WaWc/GaVcvKbVcrJb1YpJ79ZpcaW+iRdAHwH+CRwFNgeEfdLugv4KvBW89Q7IuKZsT1mSiwtbcpjLNp3pstQqWWVCvpYuqpl13oZXpSfiq/jUUTp45UGoHW7r+NpC3/FJHX+D4BvRMTLks4EXpL0bLPvvoj46/7CM7O+TLJW30HgYPP4fUn7gM19B2Zm/Zrqd35JFwKXAS80m26VtEfSDklndxybmfVo4uSXdAbwBHBbRLwHPABcDGxh9MngnpZ22yQtS1peWflFByGbWRcmSn5JpzJK/Icj4kmAiDgUER9GxFHgQWDrWm0jYntELEXE0sLC6V3FbWYzGpv8Gt2KfAjYFxH3rtq+adXTrgf2dh+emfVlkrv9VwI3Aa9K2t1suwO4UdIWRlWk/cDXZgulNIJp+lpfFMpy5SLakMPfkgW40pDF1l2581GWaNnD6S2V0ZIHTLYrHTJTBiwecOomJ5rkbv8PWg45vqZvZuuW/8LPrFJOfrNKOfnNKuXkN6uUk9+sUifHBJ6ZCQ57KNe0yg6ZK77owuSkiWBay6Uzmf6Y6apcqVRWbJdqlYsju68llr5H9fnKb1YpJ79ZpZz8ZpVy8ptVyslvViknv1mlBi/1ZQo2mbKdPtL+/1oUymgqTo45+0iqEwIpdFU4H8UyYLf1oc6rTcn6Vfel22wcqc7GlAETbUphTMhXfrNKOfnNKuXkN6uUk9+sUk5+s0o5+c0qNXCpT7QVKTIllPJSfblSWWqIXnohvELJrodjDisz4q+PkZgdlz6zfSVKfWMiyTQ6jq/8ZpVy8ptVyslvViknv1mlnPxmlRp7t1/Sx4HngY81z/9uRNwp6SLgUWAj8DJwU0T8cvzxWvspxbDm9vIAnZLS4J1iw46tlzgGlL6hn1mirIdAsjquSHQxv98kV/7/BT4fEZ9ltBz31ZKuAL4J3BcRlwDvALfMHo6ZDWVs8sfI/zTfntr8C+DzwHeb7TuB63qJ0Mx6MdHv/JJOaVboPQw8C/wEeDciPmiecgDY3E+IZtaHiZI/Ij6MiC3A+cBW4NNrPW2ttpK2SVqWtLyyspKP1Mw6NdXd/oh4F/hX4Apgg6RjNwzPB95sabM9IpYiYmlhYWGWWM2sQ2OTX9InJG1oHp8O/C6wD/g+8AfN024Gnu4rSDPr3iQDezYBOyWdwug/i8cj4p8k/Qh4VNJfAv8GPDRZl20De7odCDJwIacH9dX6Bhyf08/ZTR4016zthEx+osYmf0TsAS5bY/sbjH7/N7OTkP/Cz6xSTn6zSjn5zSrl5DerlJPfrFIqjYzrvDPpLeC/mm/PAX4+WOftHMfxHMfxTrY4fjMiPjHJAQdN/uM6lpYjYmkunTsOx+E4/LHfrFZOfrNKzTP5t8+x79Ucx/Ecx/F+beOY2+/8ZjZf/thvVqm5JL+kqyX9h6TXJd0+jxiaOPZLelXSbknLA/a7Q9JhSXtXbdso6VlJP26+nj2nOO6S9N/NOdkt6ZoB4rhA0vcl7ZP0mqQ/abYPek4KcQx6TiR9XNIPJb3SxPEXzfaLJL3QnI/HJJ02U0cRMeg/4BRG04B9CjgNeAW4dOg4mlj2A+fMod/PAZcDe1dt+yvg9ubx7cA35xTHXcCfDnw+NgGXN4/PBP4TuHToc1KIY9Bzwmhc7hnN41OBFxhNoPM4cEOz/VvAH83Szzyu/FuB1yPijRhN9f0ocO0c4pibiHgeePuEzdcymggVBpoQtSWOwUXEwYh4uXn8PqPJYjYz8DkpxDGoGOl90tx5JP9m4Gervp/n5J8BfE/SS5K2zSmGY86LiIMwehMC584xllsl7Wl+Lej914/VJF3IaP6IF5jjOTkhDhj4nAwxae48kn+tqUbmVXK4MiIuB34f+Lqkz80pjvXkAeBiRms0HATuGapjSWcATwC3RcR7Q/U7QRyDn5OYYdLcSc0j+Q8AF6z6vnXyz75FxJvN18PAU8x3ZqJDkjYBNF8PzyOIiDjUvPGOAg8y0DmRdCqjhHs4Ip5sNg9+TtaKY17npOl76klzJzWP5H8RuKS5c3kacAOwa+ggJC1KOvPYY+CLwN5yq17tYjQRKsxxQtRjyda4ngHOiUaTMT4E7IuIe1ftGvSctMUx9DkZbNLcoe5gnnA38xpGd1J/AvzZnGL4FKNKwyvAa0PGATzC6OPj/zH6JHQL8BvAc8CPm68b5xTH3wOvAnsYJd+mAeL4bUYfYfcAu5t/1wx9TgpxDHpOgN9iNCnuHkb/0fz5qvfsD4HXgX8EPjZLP/4LP7NK+S/8zCrl5DerlJPfrFJOfrNKOfnNKuXkN6uUk9+sUk5+s0r9PyhPkvaabPDEAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Preprocessing: subtract the mean image\n", + "# first: compute the image mean based on the training data\n", + "mean_image = np.mean(X_train, axis=0)\n", + "print(mean_image[:10]) # print a few of the elements\n", + "plt.figure(figsize=(4,4))\n", + "plt.imshow(mean_image.reshape((32,32,3)).astype('uint8')) # visualize the mean image\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# second: subtract the mean image from train and test data\n", + "X_train -= mean_image\n", + "X_val -= mean_image\n", + "X_test -= mean_image\n", + "X_dev -= mean_image" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(49000, 3073) (1000, 3073) (1000, 3073) (500, 3073)\n" + ] + } + ], + "source": [ + "# third: append the bias dimension of ones (i.e. bias trick) so that our SVM\n", + "# only has to worry about optimizing a single weight matrix W.\n", + "X_train = np.hstack([X_train, np.ones((X_train.shape[0], 1))])\n", + "X_val = np.hstack([X_val, np.ones((X_val.shape[0], 1))])\n", + "X_test = np.hstack([X_test, np.ones((X_test.shape[0], 1))])\n", + "X_dev = np.hstack([X_dev, np.ones((X_dev.shape[0], 1))])\n", + "\n", + "print(X_train.shape, X_val.shape, X_test.shape, X_dev.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## SVM Classifier\n", + "\n", + "Your code for this section will all be written inside **cs231n/classifiers/linear_svm.py**. \n", + "\n", + "As you can see, we have prefilled the function `compute_loss_naive` which uses for loops to evaluate the multiclass SVM loss function. " + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "loss: 8.545906\n" + ] + } + ], + "source": [ + "# Evaluate the naive implementation of the loss we provided for you:\n", + "from cs231n.classifiers.linear_svm import svm_loss_naive\n", + "import time\n", + "\n", + "# generate a random SVM weight matrix of small numbers\n", + "W = np.random.randn(3073, 10) * 0.0001 \n", + "\n", + "loss, grad = svm_loss_naive(W, X_dev, y_dev, 0.000005)\n", + "print('loss: %f' % (loss, ))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `grad` returned from the function above is right now all zero. Derive and implement the gradient for the SVM cost function and implement it inline inside the function `svm_loss_naive`. You will find it helpful to interleave your new code inside the existing function.\n", + "\n", + "To check that you have correctly implemented the gradient correctly, you can numerically estimate the gradient of the loss function and compare the numeric estimate to the gradient that you computed. We have provided code that does this for you:" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "numerical: 3.027074 analytic: 3.027074, relative error: 1.262886e-10\n", + "numerical: 10.533671 analytic: 10.533671, relative error: 9.780302e-12\n", + "numerical: 16.006009 analytic: 16.006009, relative error: 1.788442e-11\n", + "numerical: 13.171008 analytic: 13.171008, relative error: 4.577983e-12\n", + "numerical: 0.618890 analytic: 0.618890, relative error: 9.657097e-10\n", + "numerical: -33.776680 analytic: -33.776680, relative error: 8.236627e-12\n", + "numerical: 11.639214 analytic: 11.639214, relative error: 3.220063e-11\n", + "numerical: 10.899776 analytic: 10.899776, relative error: 1.810145e-11\n", + "numerical: 2.133655 analytic: 2.080314, relative error: 1.265824e-02\n", + "numerical: -3.136638 analytic: -3.136638, relative error: 1.001046e-10\n", + "-----------\n", + "numerical: -2.725699 analytic: -2.725699, relative error: 4.626492e-11\n", + "numerical: 9.305123 analytic: 9.305123, relative error: 5.792794e-12\n", + "numerical: 29.928665 analytic: 29.928665, relative error: 6.097930e-13\n", + "numerical: 4.666315 analytic: 4.525973, relative error: 1.526730e-02\n", + "numerical: -32.922391 analytic: -32.922391, relative error: 8.769666e-12\n", + "numerical: -8.795829 analytic: -8.795829, relative error: 8.514601e-12\n", + "numerical: -4.341290 analytic: -4.378089, relative error: 4.220402e-03\n", + "numerical: 5.861410 analytic: 5.861410, relative error: 2.037273e-11\n", + "numerical: 0.999569 analytic: 1.009625, relative error: 5.005311e-03\n", + "numerical: -8.529687 analytic: -8.529687, relative error: 1.631007e-11\n" + ] + } + ], + "source": [ + "# Once you've implemented the gradient, recompute it with the code below\n", + "# and gradient check it with the function we provided for you\n", + "\n", + "# Compute the loss and its gradient at W.\n", + "loss, grad = svm_loss_naive(W, X_dev, y_dev, 0.0)\n", + "\n", + "# Numerically compute the gradient along several randomly chosen dimensions, and\n", + "# compare them with your analytically computed gradient. The numbers should match\n", + "# almost exactly along all dimensions.\n", + "from cs231n.gradient_check import grad_check_sparse\n", + "f = lambda w: svm_loss_naive(w, X_dev, y_dev, 0.0)[0]\n", + "grad_numerical = grad_check_sparse(f, W, grad)\n", + "\n", + "# do the gradient check once again with regularization turned on\n", + "# you didn't forget the regularization gradient did you?\n", + "print(\"-----------\")\n", + "loss, grad = svm_loss_naive(W, X_dev, y_dev, 5e1)\n", + "f = lambda w: svm_loss_naive(w, X_dev, y_dev, 5e1)[0]\n", + "grad_numerical = grad_check_sparse(f, W, grad)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inline Question 1:\n", + "It is possible that once in a while a dimension in the gradcheck will not match exactly. What could such a discrepancy be caused by? Is it a reason for concern? What is a simple example in one dimension where a gradient check could fail? How would change the margin affect of the frequency of this happening? *Hint: the SVM loss function is not strictly speaking differentiable*\n", + "\n", + "**Your Answer:** *fill this in.*" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "# A = np.random.random((10,10))\n", + "# print(A)\n", + "# print(list(range(10)))\n", + "# B = np.array([1,2,3,4,5,6,7,0,0,0])\n", + "# print(A[list(range(10)),B])" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ True False]\n", + " [False True]]\n", + "[[ True True]\n", + " [False True]]\n", + "[[2 0]\n", + " [0 4]]\n" + ] + } + ], + "source": [ + "# A = np.array([[2,0], [-2,4]])\n", + "# B = A > 0\n", + "# print(B)\n", + "# B[0,1] = 5\n", + "# print(B)\n", + "# C = A * B\n", + "# print(C)" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8.545905804832543\n", + "8.545905804832545\n" + ] + } + ], + "source": [ + "# loss_naive, grad_naive = svm_loss_naive(W, X_dev, y_dev, 0.000005)\n", + "# print(loss_naive)\n", + "# from cs231n.classifiers.linear_svm import svm_loss_vectorized\n", + "# loss_vectorized, _ = svm_loss_vectorized(W, X_dev, y_dev, 0.000005)\n", + "# print(loss_vectorized)" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Naive loss: 8.545906e+00 computed in 0.104720s\n", + "Vectorized loss: 8.545906e+00 computed in 0.002993s\n", + "difference: -0.000000\n" + ] + } + ], + "source": [ + "# Next implement the function svm_loss_vectorized; for now only compute the loss;\n", + "# we will implement the gradient in a moment.\n", + "tic = time.time()\n", + "loss_naive, grad_naive = svm_loss_naive(W, X_dev, y_dev, 0.000005)\n", + "toc = time.time()\n", + "print('Naive loss: %e computed in %fs' % (loss_naive, toc - tic))\n", + "\n", + "from cs231n.classifiers.linear_svm import svm_loss_vectorized\n", + "tic = time.time()\n", + "loss_vectorized, _ = svm_loss_vectorized(W, X_dev, y_dev, 0.000005)\n", + "toc = time.time()\n", + "print('Vectorized loss: %e computed in %fs' % (loss_vectorized, toc - tic))\n", + "\n", + "# The losses should match but your vectorized implementation should be much faster.\n", + "print('difference: %f' % (loss_naive - loss_vectorized))" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Naive loss and gradient: computed in 0.092751s\n", + "Vectorized loss and gradient: computed in 0.002992s\n", + "difference: 0.000000\n" + ] + } + ], + "source": [ + "# Complete the implementation of svm_loss_vectorized, and compute the gradient\n", + "# of the loss function in a vectorized way.\n", + "\n", + "# The naive implementation and the vectorized implementation should match, but\n", + "# the vectorized version should still be much faster.\n", + "tic = time.time()\n", + "_, grad_naive = svm_loss_naive(W, X_dev, y_dev, 0.000005)\n", + "toc = time.time()\n", + "# print(grad_naive)\n", + "print('Naive loss and gradient: computed in %fs' % (toc - tic))\n", + "\n", + "tic = time.time()\n", + "_, grad_vectorized = svm_loss_vectorized(W, X_dev, y_dev, 0.000005)\n", + "toc = time.time()\n", + "# print(grad_vectorized)\n", + "print('Vectorized loss and gradient: computed in %fs' % (toc - tic))\n", + "\n", + "# The loss is a single number, so it is easy to compare the values computed\n", + "# by the two implementations. The gradient on the other hand is a matrix, so\n", + "# we use the Frobenius norm to compare them.\n", + "difference = np.linalg.norm(grad_naive - grad_vectorized, ord='fro')\n", + "print('difference: %f' % difference)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Stochastic Gradient Descent\n", + "\n", + "We now have vectorized and efficient expressions for the loss, the gradient and our gradient matches the numerical gradient. We are therefore ready to do SGD to minimize the loss." + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iteration 0 / 1500: loss 797.643070\n", + "iteration 100 / 1500: loss 289.536172\n", + "iteration 200 / 1500: loss 108.843714\n", + "iteration 300 / 1500: loss 43.182707\n", + "iteration 400 / 1500: loss 18.855964\n", + "iteration 500 / 1500: loss 11.033021\n", + "iteration 600 / 1500: loss 7.497600\n", + "iteration 700 / 1500: loss 5.664093\n", + "iteration 800 / 1500: loss 5.323653\n", + "iteration 900 / 1500: loss 5.611071\n", + "iteration 1000 / 1500: loss 5.486707\n", + "iteration 1100 / 1500: loss 5.337462\n", + "iteration 1200 / 1500: loss 5.207909\n", + "iteration 1300 / 1500: loss 5.376285\n", + "iteration 1400 / 1500: loss 5.346116\n", + "That took 6.164895s\n" + ] + } + ], + "source": [ + "# In the file linear_classifier.py, implement SGD in the function\n", + "# LinearClassifier.train() and then run it with the code below.\n", + "from cs231n.classifiers import LinearSVM\n", + "svm = LinearSVM()\n", + "tic = time.time()\n", + "loss_hist = svm.train(X_train, y_train, learning_rate=1e-7, reg=2.5e4,\n", + " num_iters=1500, verbose=True)\n", + "toc = time.time()\n", + "print('That took %fs' % (toc - tic))" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1500,)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# A useful debugging strategy is to plot the loss as a function of\n", + "# iteration number:\n", + "print(np.array(loss_hist).shape)\n", + "plt.plot(loss_hist)\n", + "plt.xlabel('Iteration number')\n", + "plt.ylabel('Loss value')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "training accuracy: 0.363959\n", + "validation accuracy: 0.376000\n" + ] + } + ], + "source": [ + "# Write the LinearSVM.predict function and evaluate the performance on both the\n", + "# training and validation set\n", + "y_train_pred = svm.predict(X_train)\n", + "print('training accuracy: %f' % (np.mean(y_train == y_train_pred), ))\n", + "y_val_pred = svm.predict(X_val)\n", + "print('validation accuracy: %f' % (np.mean(y_val == y_val_pred), ))" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(lr, reg) 2.5e-08 25000.0 (y_train_pre, y_val_pre) (0.3475714285714286, 0.371)\n", + "(lr, reg) 2.5e-08 30000.0 (y_train_pre, y_val_pre) (0.35877551020408166, 0.36)\n", + "(lr, reg) 2.5e-08 35000.0 (y_train_pre, y_val_pre) (0.3629387755102041, 0.369)\n", + "(lr, reg) 2.5e-08 40000.0 (y_train_pre, y_val_pre) (0.3616122448979592, 0.376)\n", + "(lr, reg) 2.5e-08 45000.0 (y_train_pre, y_val_pre) (0.35928571428571426, 0.382)\n", + "(lr, reg) 3e-08 25000.0 (y_train_pre, y_val_pre) (0.35951020408163264, 0.378)\n", + "(lr, reg) 3e-08 30000.0 (y_train_pre, y_val_pre) (0.36679591836734693, 0.368)\n", + "(lr, reg) 3e-08 35000.0 (y_train_pre, y_val_pre) (0.3618571428571429, 0.371)\n", + "(lr, reg) 3e-08 40000.0 (y_train_pre, y_val_pre) (0.36483673469387756, 0.373)\n", + "(lr, reg) 3e-08 45000.0 (y_train_pre, y_val_pre) (0.35997959183673467, 0.37)\n", + "(lr, reg) 3.5e-08 25000.0 (y_train_pre, y_val_pre) (0.3690204081632653, 0.359)\n", + "(lr, reg) 3.5e-08 30000.0 (y_train_pre, y_val_pre) (0.36642857142857144, 0.38)\n", + "(lr, reg) 3.5e-08 35000.0 (y_train_pre, y_val_pre) (0.3656122448979592, 0.381)\n", + "(lr, reg) 3.5e-08 40000.0 (y_train_pre, y_val_pre) (0.3652244897959184, 0.377)\n", + "(lr, reg) 3.5e-08 45000.0 (y_train_pre, y_val_pre) (0.36287755102040814, 0.382)\n", + "(lr, reg) 4e-08 25000.0 (y_train_pre, y_val_pre) (0.36842857142857144, 0.385)\n", + "(lr, reg) 4e-08 30000.0 (y_train_pre, y_val_pre) (0.37187755102040815, 0.389)\n", + "(lr, reg) 4e-08 35000.0 (y_train_pre, y_val_pre) (0.36579591836734693, 0.376)\n", + "(lr, reg) 4e-08 40000.0 (y_train_pre, y_val_pre) (0.3669183673469388, 0.383)\n", + "(lr, reg) 4e-08 45000.0 (y_train_pre, y_val_pre) (0.3616326530612245, 0.379)\n", + "lr 2.500000e-08 reg 2.500000e+04 train accuracy: 0.347571 val accuracy: 0.371000\n", + "lr 2.500000e-08 reg 3.000000e+04 train accuracy: 0.358776 val accuracy: 0.360000\n", + "lr 2.500000e-08 reg 3.500000e+04 train accuracy: 0.362939 val accuracy: 0.369000\n", + "lr 2.500000e-08 reg 4.000000e+04 train accuracy: 0.361612 val accuracy: 0.376000\n", + "lr 2.500000e-08 reg 4.500000e+04 train accuracy: 0.359286 val accuracy: 0.382000\n", + "lr 3.000000e-08 reg 2.500000e+04 train accuracy: 0.359510 val accuracy: 0.378000\n", + "lr 3.000000e-08 reg 3.000000e+04 train accuracy: 0.366796 val accuracy: 0.368000\n", + "lr 3.000000e-08 reg 3.500000e+04 train accuracy: 0.361857 val accuracy: 0.371000\n", + "lr 3.000000e-08 reg 4.000000e+04 train accuracy: 0.364837 val accuracy: 0.373000\n", + "lr 3.000000e-08 reg 4.500000e+04 train accuracy: 0.359980 val accuracy: 0.370000\n", + "lr 3.500000e-08 reg 2.500000e+04 train accuracy: 0.369020 val accuracy: 0.359000\n", + "lr 3.500000e-08 reg 3.000000e+04 train accuracy: 0.366429 val accuracy: 0.380000\n", + "lr 3.500000e-08 reg 3.500000e+04 train accuracy: 0.365612 val accuracy: 0.381000\n", + "lr 3.500000e-08 reg 4.000000e+04 train accuracy: 0.365224 val accuracy: 0.377000\n", + "lr 3.500000e-08 reg 4.500000e+04 train accuracy: 0.362878 val accuracy: 0.382000\n", + "lr 4.000000e-08 reg 2.500000e+04 train accuracy: 0.368429 val accuracy: 0.385000\n", + "lr 4.000000e-08 reg 3.000000e+04 train accuracy: 0.371878 val accuracy: 0.389000\n", + "lr 4.000000e-08 reg 3.500000e+04 train accuracy: 0.365796 val accuracy: 0.376000\n", + "lr 4.000000e-08 reg 4.000000e+04 train accuracy: 0.366918 val accuracy: 0.383000\n", + "lr 4.000000e-08 reg 4.500000e+04 train accuracy: 0.361633 val accuracy: 0.379000\n", + "best validation accuracy achieved during cross-validation: 0.389000\n" + ] + } + ], + "source": [ + "# Use the validation set to tune hyperparameters (regularization strength and\n", + "# learning rate). You should experiment with different ranges for the learning\n", + "# rates and regularization strengths; if you are careful you should be able to\n", + "# get a classification accuracy of about 0.4 on the validation set.\n", + "learning_rates = [2.5e-8, 3e-8, 3.5e-8, 4.0e-8]\n", + "regularization_strengths = [2.5e4, 3.0e4, 3.5e4, 4e4, 4.5e4]\n", + "\n", + "# results is dictionary mapping tuples of the form\n", + "# (learning_rate, regularization_strength) to tuples of the form\n", + "# (training_accuracy, validation_accuracy). The accuracy is simply the fraction\n", + "# of data points that are correctly classified.\n", + "results = {}\n", + "best_val = -1 # The highest validation accuracy that we have seen so far.\n", + "best_svm = None # The LinearSVM object that achieved the highest validation rate.\n", + "\n", + "################################################################################\n", + "# TODO: #\n", + "# Write code that chooses the best hyperparameters by tuning on the validation #\n", + "# set. For each combination of hyperparameters, train a linear SVM on the #\n", + "# training set, compute its accuracy on the training and validation sets, and #\n", + "# store these numbers in the results dictionary. In addition, store the best #\n", + "# validation accuracy in best_val and the LinearSVM object that achieves this #\n", + "# accuracy in best_svm. #\n", + "# #\n", + "# Hint: You should use a small value for num_iters as you develop your #\n", + "# validation code so that the SVMs don't take much time to train; once you are #\n", + "# confident that your validation code works, you should rerun the validation #\n", + "# code with a larger value for num_iters. #\n", + "################################################################################\n", + "for lr in learning_rates:\n", + " for reg in regularization_strengths:\n", + " svm = LinearSVM()\n", + " loss_hist = svm.train(X_train, y_train, learning_rate=lr, reg=reg,\n", + " num_iters=1500, verbose=False)\n", + " results[(lr, reg)] = ( np.mean( y_train == svm.predict(X_train) ), np.mean( y_val == svm.predict(X_val) ) )\n", + " print(\"(lr, reg)\", lr, reg, \"(y_train_pre, y_val_pre)\",results[(lr, reg)])\n", + "# print(results[(lr, reg)][1])\n", + " if (results[(lr, reg)][1] > best_val) :\n", + " best_val = results[(lr, reg)][1]\n", + " best_svm = svm\n", + " \n", + "################################################################################\n", + "# END OF YOUR CODE #\n", + "################################################################################\n", + " \n", + "# Print out results.\n", + "for lr, reg in sorted(results):\n", + " train_accuracy, val_accuracy = results[(lr, reg)]\n", + " print('lr %e reg %e train accuracy: %f val accuracy: %f' % (\n", + " lr, reg, train_accuracy, val_accuracy))\n", + " \n", + "print('best validation accuracy achieved during cross-validation: %f' % best_val)" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{(2.5e-08, 25000.0): (0.3475714285714286, 0.371), (2.5e-08, 30000.0): (0.35877551020408166, 0.36), (2.5e-08, 35000.0): (0.3629387755102041, 0.369), (2.5e-08, 40000.0): (0.3616122448979592, 0.376), (2.5e-08, 45000.0): (0.35928571428571426, 0.382), (3e-08, 25000.0): (0.35951020408163264, 0.378), (3e-08, 30000.0): (0.36679591836734693, 0.368), (3e-08, 35000.0): (0.3618571428571429, 0.371), (3e-08, 40000.0): (0.36483673469387756, 0.373), (3e-08, 45000.0): (0.35997959183673467, 0.37), (3.5e-08, 25000.0): (0.3690204081632653, 0.359), (3.5e-08, 30000.0): (0.36642857142857144, 0.38), (3.5e-08, 35000.0): (0.3656122448979592, 0.381), (3.5e-08, 40000.0): (0.3652244897959184, 0.377), (3.5e-08, 45000.0): (0.36287755102040814, 0.382), (4e-08, 25000.0): (0.36842857142857144, 0.385), (4e-08, 30000.0): (0.37187755102040815, 0.389), (4e-08, 35000.0): (0.36579591836734693, 0.376), (4e-08, 40000.0): (0.3669183673469388, 0.383), (4e-08, 45000.0): (0.3616326530612245, 0.379)}\n", + "[2.5e-08, 2.5e-08, 2.5e-08, 2.5e-08, 2.5e-08, 3e-08, 3e-08, 3e-08, 3e-08, 3e-08, 3.5e-08, 3.5e-08, 3.5e-08, 3.5e-08, 3.5e-08, 4e-08, 4e-08, 4e-08, 4e-08, 4e-08]\n", + "[25000.0, 30000.0, 35000.0, 40000.0, 45000.0, 25000.0, 30000.0, 35000.0, 40000.0, 45000.0, 25000.0, 30000.0, 35000.0, 40000.0, 45000.0, 25000.0, 30000.0, 35000.0, 40000.0, 45000.0]\n" + ] + } + ], + "source": [ + "# import math\n", + "# print(results)\n", + "# x_scatter = [(x[0]) for x in results]\n", + "# y_scatter = [(x[1]) for x in results]\n", + "# print(x_scatter)\n", + "# print(y_scatter)" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the cross-validation results\n", + "import math\n", + "# 取出results中的lr和reg作为坐标轴\n", + "x_scatter = [math.log10(x[0]) for x in results]\n", + "y_scatter = [math.log10(x[1]) for x in results]\n", + "\n", + "# plot training accuracy\n", + "marker_size = 100\n", + "# 取出训练集和测试集的准确率\n", + "colors = [results[x][0] for x in results]\n", + "# print(colors)\n", + "plt.subplot(2, 1, 1)\n", + "plt.scatter(x_scatter, y_scatter, marker_size, c=colors)\n", + "plt.colorbar()\n", + "plt.xlabel('log learning rate')\n", + "plt.ylabel('log regularization strength')\n", + "plt.title('CIFAR-10 training accuracy')\n", + "\n", + "# plot validation accuracy\n", + "colors = [results[x][1] for x in results] # default size of markers is 20\n", + "plt.subplot(2, 1, 2)\n", + "plt.scatter(x_scatter, y_scatter, marker_size, c=colors)\n", + "plt.colorbar()\n", + "plt.xlabel('log learning rate')\n", + "plt.ylabel('log regularization strength')\n", + "plt.title('CIFAR-10 validation accuracy')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "linear SVM on raw pixels final test set accuracy: 0.370000\n" + ] + } + ], + "source": [ + "# Evaluate the best svm on test set\n", + "y_test_pred = best_svm.predict(X_test)\n", + "test_accuracy = np.mean(y_test == y_test_pred)\n", + "print('linear SVM on raw pixels final test set accuracy: %f' % test_accuracy)" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0, 1, 2]\n" + ] + } + ], + "source": [ + "nums = list(range(5))\n", + "print(nums[:-2])" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the learned weights for each class.\n", + "# Depending on your choice of learning rate and regularization strength, these may\n", + "# or may not be nice to look at.\n", + "w = best_svm.W[:-1,:] # strip out the bias\n", + "w = w.reshape(32, 32, 3, 10)\n", + "w_min, w_max = np.min(w), np.max(w)\n", + "classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']\n", + "for i in range(10):\n", + " plt.subplot(2, 5, i + 1)\n", + " \n", + " # Rescale the weights to be between 0 and 255\n", + " wimg = 255.0 * (w[:, :, :, i].squeeze() - w_min) / (w_max - w_min)\n", + " plt.imshow(wimg.astype('uint8'))\n", + " plt.axis('off')\n", + " plt.title(classes[i])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Inline question 2:\n", + "Describe what your visualized SVM weights look like, and offer a brief explanation for why they look they way that they do.\n", + "\n", + "**Your answer:** *fill this in*" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/assignment1/two_layer_net.ipynb b/assignment1/two_layer_net.ipynb new file mode 100644 index 000000000..344b7df87 --- /dev/null +++ b/assignment1/two_layer_net.ipynb @@ -0,0 +1,820 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Implementing a Neural Network\n", + "In this exercise we will develop a neural network with fully-connected layers to perform classification, and test it out on the CIFAR-10 dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# A bit of setup\n", + "from __future__ import print_function\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from cs231n.classifiers.neural_net import TwoLayerNet\n", + "\n", + "\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "# for auto-reloading external modules\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "def rel_error(x, y):\n", + " \"\"\" returns relative error \"\"\"\n", + " return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We will use the class `TwoLayerNet` in the file `cs231n/classifiers/neural_net.py` to represent instances of our network. The network parameters are stored in the instance variable `self.params` where keys are string parameter names and values are numpy arrays. Below, we initialize toy data and a toy model that we will use to develop your implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a small net and some toy data to check your implementations.\n", + "# Note that we set the random seed for repeatable experiments.\n", + "\n", + "input_size = 4\n", + "hidden_size = 10\n", + "num_classes = 3\n", + "num_inputs = 5\n", + "\n", + "def init_toy_model():\n", + " np.random.seed(0)\n", + " return TwoLayerNet(input_size, hidden_size, num_classes, std=1e-1)\n", + "\n", + "def init_toy_data():\n", + " np.random.seed(1)\n", + " X = 10 * np.random.randn(num_inputs, input_size)\n", + " y = np.array([0, 1, 2, 2, 1])\n", + " return X, y\n", + "\n", + "net = init_toy_model()\n", + "X, y = init_toy_data()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Forward pass: compute scores\n", + "Open the file `cs231n/classifiers/neural_net.py` and look at the method `TwoLayerNet.loss`. This function is very similar to the loss functions you have written for the SVM and Softmax exercises: It takes the data and weights and computes the class scores, the loss, and the gradients on the parameters. \n", + "\n", + "Implement the first part of the forward pass which uses the weights and biases to compute the scores for all inputs." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[0.01828828 0.75014431]\n", + " [0.98886109 0.74816565]]\n", + "[[0.01828828 0.75014431]\n", + " [0.98886109 0.74816565]]\n" + ] + } + ], + "source": [ + "# ta = np.random.random((2,2))\n", + "# print(ta)\n", + "# ra = np.maximum(ta,0)\n", + "# print(ra)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Your scores:\n", + "[[-0.81233741 -1.27654624 -0.70335995]\n", + " [-0.17129677 -1.18803311 -0.47310444]\n", + " [-0.51590475 -1.01354314 -0.8504215 ]\n", + " [-0.15419291 -0.48629638 -0.52901952]\n", + " [-0.00618733 -0.12435261 -0.15226949]]\n", + "\n", + "correct scores:\n", + "[[-0.81233741 -1.27654624 -0.70335995]\n", + " [-0.17129677 -1.18803311 -0.47310444]\n", + " [-0.51590475 -1.01354314 -0.8504215 ]\n", + " [-0.15419291 -0.48629638 -0.52901952]\n", + " [-0.00618733 -0.12435261 -0.15226949]]\n", + "\n", + "Difference between your scores and correct scores:\n", + "3.6802720496109664e-08\n" + ] + } + ], + "source": [ + "scores = net.loss(X)\n", + "print('Your scores:')\n", + "print(scores)\n", + "print()\n", + "print('correct scores:')\n", + "correct_scores = np.asarray([\n", + " [-0.81233741, -1.27654624, -0.70335995],\n", + " [-0.17129677, -1.18803311, -0.47310444],\n", + " [-0.51590475, -1.01354314, -0.8504215 ],\n", + " [-0.15419291, -0.48629638, -0.52901952],\n", + " [-0.00618733, -0.12435261, -0.15226949]])\n", + "print(correct_scores)\n", + "print()\n", + "\n", + "# The difference should be very small. We get < 1e-7\n", + "print('Difference between your scores and correct scores:')\n", + "print(np.sum(np.abs(scores - correct_scores)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Forward pass: compute loss\n", + "In the same function, implement the second part that computes the data and regularizaion loss." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.3037878913298204\n", + "Difference between your loss and correct loss:\n", + "1.7963408538435033e-13\n" + ] + } + ], + "source": [ + "loss, _ = net.loss(X, y, reg=0.05)\n", + "correct_loss = 1.30378789133\n", + "print(loss)\n", + "\n", + "# should be very small, we get < 1e-12\n", + "print('Difference between your loss and correct loss:')\n", + "print(np.sum(np.abs(loss - correct_loss)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Backward pass\n", + "Implement the rest of the function. This will compute the gradient of the loss with respect to the variables `W1`, `b1`, `W2`, and `b2`. Now that you (hopefully!) have a correctly implemented forward pass, you can debug your backward pass using a numeric gradient check:" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ True True]\n", + " [ True True]]\n" + ] + } + ], + "source": [ + "# ta = np.array([[2,2],[2,2]])\n", + "# print(ta > 0)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "W1 max relative error: 3.561318e-09\n", + "b1 max relative error: 8.372507e-10\n", + "W2 max relative error: 3.440708e-09\n", + "b2 max relative error: 4.447625e-11\n" + ] + } + ], + "source": [ + "from cs231n.gradient_check import eval_numerical_gradient\n", + "\n", + "# Use numeric gradient checking to check your implementation of the backward pass.\n", + "# If your implementation is correct, the difference between the numeric and\n", + "# analytic gradients should be less than 1e-8 for each of W1, W2, b1, and b2.\n", + "\n", + "loss, grads = net.loss(X, y, reg=0.05)\n", + "\n", + "# these should all be less than 1e-8 or so\n", + "for param_name in grads:\n", + " f = lambda W: net.loss(X, y, reg=0.05)[0]\n", + " param_grad_num = eval_numerical_gradient(f, net.params[param_name], verbose=False)\n", + " print('%s max relative error: %e' % (param_name, rel_error(param_grad_num, grads[param_name])))\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 1 2 3]\n", + "[1]\n", + "[0]\n", + "[0]\n", + "[1]\n", + "[2]\n", + "[2]\n", + "[0]\n", + "[0]\n" + ] + } + ], + "source": [ + "# ta = np.array([[1,2],[3,4]])\n", + "# ta = np.arange(4)\n", + "# print(ta)\n", + "# print(ta[np.random.choice(4, 1, replace=False)])\n", + "# print(ta[np.random.choice(4, 1, replace=False)])\n", + "# print(ta[np.random.choice(4, 1, replace=False)])\n", + "# print(ta[np.random.choice(4, 1, replace=False)])\n", + "# print(ta[np.random.choice(4, 1, replace=True)])\n", + "# print(ta[np.random.choice(4, 1, replace=True)])\n", + "# print(ta[np.random.choice(4, 1, replace=True)])\n", + "# print(ta[np.random.choice(4, 1, replace=True)])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train the network\n", + "To train the network we will use stochastic gradient descent (SGD), similar to the SVM and Softmax classifiers. Look at the function `TwoLayerNet.train` and fill in the missing sections to implement the training procedure. This should be very similar to the training procedure you used for the SVM and Softmax classifiers. You will also have to implement `TwoLayerNet.predict`, as the training process periodically performs prediction to keep track of accuracy over time while the network trains.\n", + "\n", + "Once you have implemented the method, run the code below to train a two-layer network on toy data. You should achieve a training loss less than 0.2." + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "Final training loss: 0.017149607938732093\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAEWCAYAAACJ0YulAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3XuYZHdd5/H3py5d1feenumZJHPJJGESCTEhcYiwREQESRATQAWCKCBsXJWVBRaN7oKC7gqyj64ognm4iWAggpCIgeASCHIJZEKSIRcSJtfpJHPL9Ez39LUu3/3jnO7UzHT31Ey6urq7Pq/nqafrXKrO9/Tprm/9Luf3U0RgZmYGkGl2AGZmtnQ4KZiZ2QwnBTMzm+GkYGZmM5wUzMxshpOCmZnNcFKwJU9SVtIhSZsWct/lQlJOUkjaPMf210n68uJGZSuVfJ+CLTRJh2oWO4BJoJIu/1ZEfHrxo3rqJP0ZsCEiXr/Ix80BJeC0iHjoKbzPp4AdEfEnCxSarUC5ZgdgK09EdE0/l/QQ8KaI+H9z7S8pFxHlxYjNTpykbERUjr2nLWeuPrJFJ+nPJH1W0tWSRoDXSnqOpJslHZD0uKQPSMqn+x9WfSLpU+n2L0sakfRdSacd777p9ksk3SfpoKS/kfRtSa8/gXN6hqSb0vh/KOkXa7a9VNI96fEHJb01Xb9W0vXpa/ZL+uYxDvNiSTskDUn6QM37v0nSN9LnmfR896TntF3S2ZJ+B3gV8Edp9doX6oj7U5I+KOkrkkaB35f0mKRMzT6vkrTteH9ftnQ5KVizvBz4J6AX+CxQBt4CrAGeC1wM/NY8r38N8E6gH3gE+NPj3VfSWuAa4B3pcR8ELjzeE5HUBnwJ+DdgAHgr8FlJT0t3+TjwxojoBs4FbkrXvwN4IH3NSWmM83kJ8FPA+SSJ9IWz7HMJ8GxgC7AKeDWwPyL+juT3/L8joisiXl5H3JD87t4NdAN/CYwAP1+z/bXAPx4jbltGnBSsWb4VEf8aEdWIGI+IWyLiexFRjogHgKuAn53n9Z+LiG0RUQI+DTzzBPZ9KXB7RFybbvsrYN8JnMtzgTbg/RFRSqvKvkzygQxJe8DZkrojYn9E/KBm/SnApoiYioibjnrnw/15RBxM2xW+weznXAJ6gJ8AiIi7I2LXCcYN8IWI+G56nSaBT5IkAiStIUkQVx8jbltGnBSsWXbWLkj6CUn/JmmXpGHgPSTf3udS+0E3BnTNteM8+55SG0ckvS4G64j9SKcAj8ThvTYeBtanz18OXAo8Iukbkn46Xf/edL+vSbpf0juOcZxjnnNEfBX4MPAhYLekD0vqPsG44YjrRFIqeJmkDpLk8fWI2HOMuG0ZcVKwZjmy29vfA3cCT4uIHuBdgBocw+PAhukFSeLwD8R6PQZsTF8/bRPwKEBaAroUWEtSXfOZdP1wRLw1IjYDLwP+QNJ8paO6RMT/jYgLgHOAs4G3TW86nrhne01EPAJsAy4Dfh1XHa04Tgq2VHQDB4FRSU9n/vaEhfIl4AJJv5R2+3wLSd36fLKSijWPAvAdkjaRt0vKS3oBSf3/NZLaJb1GUk9aRTVC2j03Pe4Z6YfywXT9U+rdI+nC9JEDRoGpmvfcDZxes/uccR/jMJ8E/pCkiurapxKvLT1OCrZUvB14HcmH5t+TNIo2VETsJumR85fAE8AZwG0k91XM5bXAeM3j3rSu/ZdIvj3vAz4AvCYi7ktf8zrg4bRa7I0k37ABzgJuBA4B3wb+OiK+9RRPqw/4KHAAeIikNPRX6baPAOelvZc+V0fcc/k8SXL5XESMP8V4bYnxzWtmKUlZkiqVX4mI/2h2PEtVWrJ5EHh9RHyjyeHYAnNJwVqapIsl9abVQO8kqU75fpPDWupeSVKaOlZvKVuGfEeztbqLSLqptgF3AS9Lq1VsFpK+RXIPxK+FqxlWJFcfmZnZDFcfmZnZjGVXfbRmzZrYvHlzs8MwM1tWbr311n0Rcawu18svKWzevJlt2zz+lpnZ8ZD0cD37ufrIzMxmOCmYmdkMJwUzM5vhpGBmZjOcFMzMbIaTgpmZzXBSMDOzGS2TFO7dNcL/ueFe9o9ONTsUM7Mlq2WSwgN7D/G3X9/BroMTzQ7FzGzJapmk0F3MAzAyUWpyJGZmS1cLJYVkRI+RiXKTIzEzW7paLylMuqRgZjaXhiUFSR+TtEfSnXNs/zVJ29PHdySd16hYoLb6yCUFM7O5NLKk8Ang4nm2Pwj8bEScC/wpcFUDY3H1kZlZHRo2dHZEfFPS5nm2f6dm8WZgQ6NiASjkMuSzclIwM5vHUmlTeCPw5bk2SrpC0jZJ2/bu3XtCB5BEdzHv3kdmZvNoelKQ9HMkSeEP5tonIq6KiK0RsXVg4JgTB82pu5hzScHMbB5NnXlN0rnAR4BLIuKJRh+vq5Dj0KSTgpnZXJpWUpC0CfgX4Ncj4r7FOGZSUnD1kZnZXBpWUpB0NfB8YI2kQeCPgTxARHwYeBewGvg7SQDliNjaqHgg6Za6c/9YIw9hZrasNbL30eXH2P4m4E2NOv5s3KZgZja/pjc0L6aeYp5hVx+Zmc2ppZLCdENzRDQ7FDOzJamlkkJ3MUcEjE5Vmh2KmdmS1GJJwcNnm5nNp8WSgsc/MjObT4smBZcUzMxm06JJwSUFM7PZtFhS8JwKZmbzabGk4JKCmdl8WiwpuPeRmdl8WiopdLZlkfBIqWZmc2ippCCJroLHPzIzm0tLJQXw+EdmZvNpuaTgkVLNzObWoknBJQUzs9m0YFLIu6HZzGwOLZcU3NBsZja3lksKblMwM5tbCyaFPCMTJU+0Y2Y2ixZMCjlKlWCyXG12KGZmS07LJYUej39kZjanlksKXZ5TwcxsTi2XFLoLHj7bzGwuDUsKkj4maY+kO+fYLkkfkLRD0nZJFzQqlloePtvMbG6NLCl8Arh4nu2XAFvSxxXAhxoYy4zp4bMPTbr6yMzsSA1LChHxTWD/PLtcBnwyEjcDfZJOblQ806ZLCsMuKZiZHaWZbQrrgZ01y4PpuqNIukLSNknb9u7d+5QO6uojM7O5NTMpaJZ1s95RFhFXRcTWiNg6MDDwlA7aVXDvIzOzuTQzKQwCG2uWNwCPNfqguWyGjrasSwpmZrNoZlK4DviNtBfSs4GDEfH4Yhy4u5jjkJOCmdlRco16Y0lXA88H1kgaBP4YyANExIeB64GXADuAMeANjYrlSN3FPCPufWRmdpSGJYWIuPwY2wP43UYdfz4ePtvMbHYtd0czJNVH7pJqZna0lkwKPenw2WZmdriWTApuaDYzm11LJgW3KZiZza4lk0J3Mc94qUKp4ol2zMxqtWhSSDpduQrJzOxwrZ0UJp0UzMxqtWhSSIbPHnYPJDOzw7RkUuhpT0oKB8edFMzMarVkUljbXQRgz/BkkyMxM1taWjIprOspALB7eKLJkZiZLS0tmRS6i3k627LsclIwMztMSyYFgHW9RZcUzMyO0LpJobvIbrcpmJkdpmWTwkm9RXYddEnBzKxWyyaFdT1F9oxMUK3OOi20mVlLauGkUKBUCYbGppodipnZktGySeGknuReBfdAMjN7UssmhXW9SVJwDyQzsye1blLomU4K7oFkZjatZZPC2u4CEu6BZGZWo2WTQj6bYXVnwdVHZmY1WjYpQNIDyUnBzOxJDU0Kki6WdK+kHZKunGX7Jklfl3SbpO2SXtLIeI50Uk+RXW5TMDOb0bCkICkLfBC4BDgbuFzS2Ufs9j+BayLifODVwN81Kp7ZePwjM7PDNbKkcCGwIyIeiIgp4DPAZUfsE0BP+rwXeKyB8RxlXXeR/aNTTJYri3lYM7Ml65hJQdJfSOqRlJf0NUn7JL22jvdeD+ysWR5M19X6E+C1kgaB64H/OkcMV0jaJmnb3r176zh0fU7qTeZV8GQ7ZmaJekoKvxARw8BLST7YzwTeUcfrNMu6Iwcauhz4RERsAF4C/KOko2KKiKsiYmtEbB0YGKjj0PV58l4FVyGZmUF9SSGf/nwJcHVE7K/zvQeBjTXLGzi6euiNwDUAEfFdoAisqfP9n7J1HurCzOww9SSFf5X0I2Ar8DVJA0A9n6K3AFsknSapjaQh+boj9nkE+HkASU8nSQoLVz90DCf5rmYzs8McMylExJXAc4CtEVECRjm6wXi215WBNwM3APeQ9DK6S9J7JF2a7vZ24D9LugO4Gnh9RCzaWNZ9HXnachlXH5mZpXLH2kHSrwJfiYiKpP8JXAD8GbDrWK+NiOtJGpBr172r5vndwHOPN+iFIol1PQUPdWFmlqqn+uidETEi6SLgxcA/AB9qbFiL56Qe36tgZjatnqQw3Yn/F4EPRcS1QFvjQlpc65wUzMxm1JMUHpX098ArgeslFep83bKwrqfIruEJFrEpw8xsyarnw/2VJI3FF0fEAaCf+u5TWBZO6ikyUaoyPFFudihmZk1XT++jMeB+4MWS3gysjYivNjyyReIZ2MzMnlTPMBdvAT4NrE0fn5I063AUy9G67mSoC/dAMjOro0sqyV3HPx0RowCS3gd8F/ibRga2WNavagdgcGi8yZGYmTVfPW0K4skeSKTPZxvXaFk6ubedfFY8vH+02aGYmTVdPSWFjwPfk/SFdPllwEcbF9LiymbEhlUd7Nw/1uxQzMya7phJISL+UtI3gItISghviIjbGh3YYtrU38HDTzgpmJnNmRQk9dcsPpQ+ZrYdx2ipS96pqzv4wcNDRATSiqkZMzM7bvOVFG4lmf9g+lNy+u4upc9Pb2Bci2pTfwcjk2WGxkr0d66Ym7XNzI7bnEkhIk5bzECa6dTVnQA8/MSok4KZtbQVM1zFU3Hq6g4AHnFjs5m1OCcFkuojwI3NZtbynBSAYj7Lup6Ck4KZtbx6Jtnpn2X1SDoL24pxan8nj/gGNjNrcfWUFH5AMm/yfcCP0+cPSvqBpJ9qZHCLadPqDrcpmFnLqycpfAV4SUSsiYjVwCXANcDvAH/XyOAW06n9HewenmSiVDn2zmZmK1Q9SWFrRNwwvZAOm/28iLgZKDQsskW2yT2QzMzqSgr7Jf2BpFPTx+8DQ5KyQLXB8S2aJ+9VcFIws9ZVT1J4DbAB+CJwLbApXZclmZVtRTh1pluqG5vNrHXVMyDePmCuSXV2LGw4zdPXkae7mHP1kZm1tHpmXjtT0lWSvirpxulHPW8u6WJJ90raIenKOfZ5paS7Jd0l6Z+O9wQWiiROXe3RUs2stdUzn8I/Ax8GPsLhk+3MK21z+CDwImAQuEXSdRFxd80+W4A/BJ4bEUOS1h5P8Avt1P5O7n58uJkhmJk1VT1JoRwRHzqB974Q2BERDwBI+gxwGXB3zT7/GfhgRAwBRMSeEzjOgtnY38FX795FpRpkMx5C28xaTz0Nzf8q6XcknSypf/pRx+vWAztrlgfTdbXOBM6U9G1JN0u6uM64G+LU1R2UKsHjBz1fs5m1pnpKCq9Lf76jZl098ynM9lU7jljOAVuA55P0cPoPSedExIHD3ki6ArgCYNOmTXWEfGKmeyA98sQYG1Z1NOw4ZmZLVT29j050XoVBYGPN8gbgsVn2uTkdR+lBSfeSJIlbjojhKuAqgK1btx6ZWBbM9A1sD+8f4z816iBmZkvYfNNxviAibpT0itm2R8S/HOO9bwG2SDoNeBR4Ncn9DbW+CFwOfELSGpLqpAfqDX6hndzbTj4rd0s1s5Y1X0nhZ4EbgV+aZVsA8yaFiChLejNwA8mNbh+LiLskvQfYFhHXpdt+QdLdJD2b3hERT5zAeSyIbEas72tnp5OCmbWo+abj/OP05xtO9M0j4nrg+iPWvavmeQBvSx9Lwsb+DicFM2tZ9cynUAB+Gdhcu39EvKdxYTXPpv4Orv/h480Ow8ysKerpfXQtcBC4FZhsbDjNt6m/g6GxEsMTJXqK+WaHY2a2qOpJChsioqn3Dyym6fmad+4f4xmn9DY5GjOzxVXPzWvfkfSTDY9kidhYkxTMzFpNPSWFi4DXS3qQpPpIJG3E5zY0siaZTgrulmpmraiepHBJw6NYQnrb8/S259m530NdmFnrme/mtZ6IGAZGFjGeJWFTf4dLCmbWkuYrKfwT8FKSXkfB4WMZ1TP20bK1qb+DezyEtpm1oPluXntp+vNExz5atjb2d/Dvd+/2ENpm1nLqaVNA0iqSgeqK0+si4puNCqrZNvV3MFWpsnt4glP62psdjpnZoqnnjuY3AW8hGeX0duDZwHeBFzQ2tObZ2J8kgkf2jzkpmFlLqec+hbcAzwIejoifA84H9jY0qibb5HsVzKxF1ZMUJiJiApJxkCLiR8BZjQ2ruU7paycjJwUzaz31tCkMSuojmfvg3yUNcfRkOStKPpvhlL52d0s1s5ZTz8xrL0+f/omkrwO9wFcaGtUS4HsVzKwVzVt9JCkj6c7p5Yi4KSKui4ipxofWXBtXdfCI72o2sxYzb1KIiCpwh6RNixTPkrFpdQf7Dk0yNlVudihmZoumnjaFk4G7JH0fGJ1eGRGXNiyqJWB6YLzBoXHOXNfd5GjMzBZHPUnh3Q2PYgma7pb6yBNjTgpm1jLqSQoviYg/qF0h6X3ATY0JaWmYTgoPu7HZzFpIPfcpvGiWdSt+OO1VHckQ2g/uO9TsUMzMFs18Q2f/NvA7wOmSttds6ga+3ejAmk0SZwx0cv+e0WPvbGa2Qhxr6OwvA38OXFmzfiQi9jc0qiXijIEubrpvRY/oYWZ2mDmrjyLiYEQ8FBGXR8TDNY+WSAgAZ6ztYs/IJMMTpWaHYma2KOppUzhhki6WdK+kHZKunGe/X5EUkrY2Mp7jdcZAFwAP7HUVkpm1hoYlBUlZ4IMkjdJnA5dLOnuW/bqB3wO+16hYTtQZA50A3L/Hjc1m1hoaWVK4ENgREQ+kw2J8Brhslv3+FPgLYKKBsZyQjf0d5LPi/r1OCmbWGhqZFNYDO2uWB9N1MySdD2yMiC/N90aSrpC0TdK2vXsXr+E3n81w6upOJwUzaxmNTAqzTW4cMxulDPBXwNuP9UYRcVVEbI2IrQMDAwsY4rGdMdDJ/W5TMLMW0cikMAhsrFnewOHzMHQD5wDfkPQQyTSf1y3FxuaHnxilVKk2OxQzs4ZrZFK4Bdgi6TRJbcCrgeumN6ZdXtdExOaI2AzcDFwaEdsaGNNxO2Ogi1IlPAubmbWEhiWFiCgDbwZuAO4BromIuyS9R9KyGWH1jLVJt9Qd7oFkZi2gngHxTlhEXA9cf8S6d82x7/MbGcuJOn26W6rbFcysBTT05rWVoKeYZ213wT2QzKwlOCnU4YyBLicFM2sJTgp1OGNtJ/fvOUREHHtnM7NlzEmhDmcMdDE8UWbfoalmh2Jm1lBOCnWYHhjPVUhmttI5KdRhuluqk4KZrXROCnU4uadIR1uW+3aNNDsUM7OGclKoQyYjzjmll+2PHmx2KGZmDeWkUKfzNvZy12PDTJU9BpKZrVxOCnU6d0MfU+Uq9+12FZKZrVxOCnU6b0MfAHcMHmhyJGZmjeOkUKeN/e2s6shzx04nBTNbuZwU6iSJczf0sX3Qjc1mtnI5KRyH8zb0ct/uEcamys0OxcysIZwUjsN5G/uoBtz56HCzQzEzawgnheNwbtrYvN2NzWa2QjkpHIeB7gKn9Ba5w+0KZrZCOSkcp/M29rkHkpmtWE4Kx+ncDX08sn+MoVEPo21mK4+TwnE6b0Mv4JvYzGxlclI4Tuds6EWCO3a6XcHMVh4nhePUU8xz7vpevnDbIOWKB8czs5XFSeEE/O7PPY2HnhjjC7c92uxQzMwWVEOTgqSLJd0raYekK2fZ/jZJd0vaLulrkk5tZDwL5UVnr+Oc9T184MYfU3JpwcxWkIYlBUlZ4IPAJcDZwOWSzj5it9uArRFxLvA54C8aFc9CksTbXnQmO/eP8/lbB5sdjpnZgmlkSeFCYEdEPBARU8BngMtqd4iIr0fEWLp4M7ChgfEsqJ87ay3nbezjb27c4Yl3zGzFaGRSWA/srFkeTNfN5Y3Al2fbIOkKSdskbdu7d+8ChnjipksLjx4Y57Pbdh77BWZmy0Ajk4JmWRez7ii9FtgKvH+27RFxVURsjYitAwMDCxjiU/O8LWt45sY+Pv7tB4mY9dTMzJaVRiaFQWBjzfIG4LEjd5L0QuB/AJdGxGQD41lwknjNT2/igb2jbHt4qNnhmJk9ZY1MCrcAWySdJqkNeDVwXe0Oks4H/p4kIexpYCwN84s/eTKdbVk+e4urkMxs+WtYUoiIMvBm4AbgHuCaiLhL0nskXZru9n6gC/hnSbdLum6Ot1uyOgs5Ln3mKfzb9scZmSg1Oxwzs6ck18g3j4jrgeuPWPeumucvbOTxF8srt27k6u/v5EvbH+fyCzc1OxwzsxPmO5oXwDM39nHmui4+4yokM1vmnBQWgCReuXUjd+w8wL27RpodjpnZCXNSWCCvuGAD+az49PcebnYoZmYnzElhgfR3tvGK8zfwye8+zDW+mc3MlqmGNjS3mndf9gweOzjOlZ/fTjGf5dLzTml2SGZmx8UlhQVUzGe56te3snVzP2/97O189a5dzQ7JzOy4OCkssPa2LB97/bM4Z30vb/3s7Tx2YLzZIZmZ1c1JoQG6Cjn+9vLzqQa884t3elwkM1s2nBQaZGN/B2//hTP52o/28K/bH292OGZmdXFSaKA3PPc0ztvQy7uvu4uh0almh2NmdkxOCg2UzYj3/vK5HBwv8c5r76RSdTWSmS1tTgoN9vSTe/hvL9zCl7Y/zus+9n32u8RgZkuYk8IiePMLtvC+X/5Jvv/Qfn7pb77F7TsPNDskM7NZ+ea1RfKqZ23i6Sf38Nuf+gEv++C3OX1NJ887c4DnnzXARU9bQy7r/Gxmzafl1l1y69atsW3btmaHccKGRqf4wm2P8s0f7+XmB55golRlbXeBl1+wnldu3cgZA13NDtHMViBJt0bE1mPu56TQPBOlCjfdt5d/3jbI1+/dQ6UavOKC9bzjxWdxcm97s8MzsxXESWGZ2TMywUe/9SAf/9ZDZDJwxc+czht/5nR62/PNDs3MVgAnhWVq5/4x3veVH/Gl7Y/TXcjx2uecym8+9zS6izmGxqYYmSizcVUH7W3ZZodqZsuIk8Iyd+ejB/nQTfdz/Q+Tu6FrL1M2I85a1815G/t43pY1PO/MAToL7jNgZnNzUlgh7t97iGtvf4xCLsOqjjY6C1l27DnE7TsPcPvOA4xMlGnLZfiZp63h9IFO2ttydLZlyWUzCJBgdVeBLWu7OG1NJ8W8SxhmrajepOCvl0vcGQNdvO1FZ866rVypcstDQ3z17l3c+KM9fOf+JxgvVeZ8r4ySMZlOX9PJaWu66CrmGBqdYv/oFBKcua6bs07q5uTeIuNTFUanyuQyGc7f1Ed30W0bZq3AJYUVploNxksVypUgCKoBu4cn+PGeQ+zYPcL9+0Z5YO8oD+47xGS5Sl97nlWdbUyVqwwOzT7MdzYjzt3QyzNO6WFotMTjB8d5YnSKXEa05bIUchl62vP0tufpbc+lP5PHQHeBdT1F1vUUETBRrjI+VZkZOVZK5rjOSGQEGYm2XIZcRuSyGfJZkc2ItmwGSYfFVakGEeF7PMzq4JJCi8pkdFT7Qn9nG08/ueewddVqECQf+NNGJ8v8eM8h9gxP0FnI0VnIcWiizM0PPMF37t/Htbc9xkB3gZP7ipy3qo9KBFPlKhOlCgfHS+zcP8aBsSmGJ8oNGeepkMtQzGfJCMamKkyWq0hwSm87G/vbGeguMlmqMF6qMFmqks2IXDZJOKVKlclylXI1WNPZxsl9RU7qKZLJiHIlqFSD7mKONV0F+jvbmCxX2T86yf7REp2FLBtWtbO+r4NDkyXueXyEe3eNMDJRor0tR0dblo62LMV88sgKpipVJktVqgGdhSwdbTnyWTFeqjA6WWGiVEFpEsxlRX9HG6u7CvQUc+w9NMljB8bZdXASCdpyGfIZMVmpMjaZnF8xn6G3PU9PMX9YEh6ZLDM4NM7g0BilSpXOQo6uthx9HXnWdBUY6C5QyGUZnigxPF6iVA16ikkiz2czPDE6xb6RScamyqzrKXJKXztrugocmixxcLzEockKnW1ZetvztLdlGRotsWdkgn2HJmnLZegq5OksZMllnkzUxXwmiaOQo1SpMjxeZniiRESyrZhPvli0pQ8hJsvJ9a1Ug+RPVJSrVYZGSxwcn+LQZIVsJvn95bMZ2vNZ2tNrUKkm13OyXGHfoUn2DE8yNFZiTVfbzHWcLFcYGisxNDZFPit6inl62vN0F3N0F/N0FXJMlCrsOjjB7uEJxksVMkq+oLTns/R2JL/vXEYcHC9xYKxEpRqs7SlwUk+R7mKe4YkSB9LOITD95QdymeTLTj6bIZ9LnhdyWboLOTI1/48RwchkmT3Dk+wZnmDX8ASnD3TxzI19C/6/VauhSUHSxcBfA1ngIxHx3iO2F4BPAj8FPAG8KiIeamRMlqj945vWWcjN+gd30ZY1wFl1v3dEcGiyzIGxEnsPTbI7/ceSkn+oQj5DNiMiINL9I5Jv/pUIypWgVKlSqiQf4sk/eJXJUvJhWg3oaEs+BKrVYHBonEf2j/HDwQMU0w+HQi5DpRpMlCtUq0FbLkMxnyEj8djBCW59ZIgDY6UT/v11F3L0deYZn6owNpV8UC90obsz7WE2ValSqiTn0NmWpT2fZaJc5eB4ac7kO52kDk2WmSpXFzawZSiXEeUlPiClxExyH52scGBs6qiY33TRacs3KUjKAh8EXgQMArdIui4i7q7Z7Y3AUEQ8TdKrgfcBr2pUTLY4JNFdzNNdzLOxv6PZ4cxpIm1/yWWS0sTIRJl9o5M8cWiKYj5Df2cbqzraGJ0ss3NonEcPjNOez/L0k7tZ39d+WHVWxHTiqlKJoJDLUMglVV5jU2XGpipMlat0tGXpLOQo5JJv0pVqUKoE+8eSb+jDEyUGuguc0tdOT007TkQcVX0WEYxOJaW04fHkm3xnW44Nq9rp68jP7D9VrnJgfIp9I1PsOzTJZLlKTzFHT3uefDb5pntwvMRUOVjT1caargIdbVl2DU/w2IEJnhidpDstkXQVsoxOVhieKDFi4cAGAAAHsUlEQVQ6Waavo411PUXWdLVRriRfBkYmylTTDBmR/J5Hp5L1bdkMPe3Jt3EJJktJSXOyXGWqXGWyXCGAYu7oLw9ZiVUdefo62ugq5KhGUK4G5WpSJTk+VWGiXCGbSasfM2J1V4G1PQW6CzkOjpcYTK9jMZ+lv6ONvo58UnqZKDM8XkrjLzEyUaaQz3JST1Ki7CgkX0AqEYylv/ODYyXK1aCvPU9vR56MYPfwJLsOTnBoskxfWproLuYQSqpzq1CuJkl++ovPVCWYTEvbQ2NTDI+X6SxkWdWR/P2t7XmyCvaknmID/yMSDWtTkPQc4E8i4sXp8h8CRMSf1+xzQ7rPdyXlgF3AQMwTlNsUzMyOX71tCo1soVsP7KxZHkzXzbpPRJSBg8DqI99I0hWStknatnfv3gaFa2ZmjUwKR1daJ6XA492HiLgqIrZGxNaBgYEFCc7MzI7WyKQwCGysWd4APDbXPmn1US+wv4ExmZnZPBqZFG4Btkg6TVIb8GrguiP2uQ54Xfr8V4Ab52tPMDOzxmpY76OIKEt6M3ADSZfUj0XEXZLeA2yLiOuAjwL/KGkHSQnh1Y2Kx8zMjq2h9ylExPXA9Uese1fN8wngVxsZg5mZ1c/jA5iZ2QwnBTMzm7HsBsSTtBd4+ARfvgbYt4DhLBeteN6teM7QmufdiucMx3/ep0bEMfv0L7uk8FRI2lbPHX0rTSuedyueM7TmebfiOUPjztvVR2ZmNsNJwczMZrRaUriq2QE0SSuedyueM7TmebfiOUODzrul2hTMzGx+rVZSMDOzeTgpmJnZjJZJCpIulnSvpB2Srmx2PI0gaaOkr0u6R9Jdkt6Sru+X9O+Sfpz+XNXsWBtBUlbSbZK+lC6fJul76Xl/Nh2YccWQ1Cfpc5J+lF7z57TCtZb01vTv+05JV0sqrsRrLeljkvZIurNm3azXV4kPpJ9v2yVdcKLHbYmkUDM16CXA2cDlks5ublQNUQbeHhFPB54N/G56nlcCX4uILcDX0uWV6C3APTXL7wP+Kj3vIZLpX1eSvwa+EhE/AZxHcu4r+lpLWg/8HrA1Is4hGWxzeirflXatPwFcfMS6ua7vJcCW9HEF8KETPWhLJAXgQmBHRDwQEVPAZ4DLmhzTgouIxyPiB+nzEZIPifUk5/oP6W7/ALysORE2jqQNwC8CH0mXBbwA+Fy6y4o6b0k9wPNIRhomIqYi4gAtcK1JBvJsT+dg6QAeZwVe64j4JkfPLzPX9b0M+GQkbgb6JJ18IsdtlaRQz9SgK4qkzcD5wPeAdRHxOCSJA1jbvMga5v8Cvw9U0+XVwIF0mldYedf8dGAv8PG0yuwjkjpZ4dc6Ih4F/g/wCEkyOAjcysq+1rXmur4L9hnXKkmhrmk/VwpJXcDngf8WEcPNjqfRJL0U2BMRt9aunmXXlXTNc8AFwIci4nxglBVWVTSbtA79MuA04BSgk6Tq5Egr6VrXY8H+3lslKdQzNeiKIClPkhA+HRH/kq7ePV2UTH/uaVZ8DfJc4FJJD5FUDb6ApOTQl1YxwMq75oPAYER8L13+HEmSWOnX+oXAgxGxNyJKwL8A/4mVfa1rzXV9F+wzrlWSQj1Tgy57aT36R4F7IuIvazbVTnv6OuDaxY6tkSLiDyNiQ0RsJrm2N0bErwFfJ5nmFVbYeUfELmCnpLPSVT8P3M0Kv9Yk1UbPltSR/r1Pn/eKvdZHmOv6Xgf8RtoL6dnAwelqpuPVMnc0S3oJybfH6alB/1eTQ1pwki4C/gP4IU/Wrf8RSbvCNcAmkn+qX42IIxuwVgRJzwf+e0S8VNLpJCWHfuA24LURMdnM+BaSpGeSNKy3AQ8AbyD5oreir7WkdwOvIultdxvwJpL68xV1rSVdDTyfZIjs3cAfA19kluubJsi/JemtNAa8ISK2ndBxWyUpmJnZsbVK9ZGZmdXBScHMzGY4KZiZ2QwnBTMzm+GkYGZmM5wUrGVJ+k76c7Ok1yzwe//RbMcyW+rcJdVaXu29DcfxmmxEVObZfigiuhYiPrPF5JKCtSxJh9Kn7wV+RtLt6Vj9WUnvl3RLOjb9b6X7Pz+dr+KfSG4QRNIXJd2aju9/RbruvSSjeN4u6dO1x0rvOH1/OhfADyW9qua9v1EzP8Kn0xuSzBZV7ti7mK14V1JTUkg/3A9GxLMkFYBvS/pquu+FwDkR8WC6/JvpHaXtwC2SPh8RV0p6c0Q8c5ZjvQJ4Jsn8B2vS13wz3XY+8AySMWu+TTKm07cW/nTN5uaSgtnRfoFkHJnbSYYIWU0yeQnA92sSAsDvSboDuJlkQLItzO8i4OqIqETEbuAm4Fk17z0YEVXgdmDzgpyN2XFwScHsaAL+a0TccNjKpO1h9IjlFwLPiYgxSd8AinW891xqx+qp4P9PawKXFMxgBOiuWb4B+O10GHIknZlOYHOkXmAoTQg/QTIF6rTS9OuP8E3gVWm7xQDJ7GnfX5CzMFsA/iZiBtuBcloN9AmSuY83Az9IG3v3Mvv0jl8B/ouk7cC9JFVI064Ctkv6QTqM97QvAM8B7iCZBOX3I2JXmlTMms5dUs3MbIarj8zMbIaTgpmZzXBSMDOzGU4KZmY2w0nBzMxmOCmYmdkMJwUzM5vx/wFMsT6g+AdSAAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "net = init_toy_model()\n", + "stats = net.train(X, y, X, y,\n", + " learning_rate=1e-1, reg=5e-6,\n", + " num_iters=100, verbose=False)\n", + "\n", + "print('Final training loss: ', stats['loss_history'][-1])\n", + "\n", + "\n", + "# plot the loss history\n", + "plt.plot(stats['loss_history'])\n", + "plt.xlabel('iteration')\n", + "plt.ylabel('training loss')\n", + "plt.title('Training Loss history')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0 1 2 2 1]\n", + "[0 1 2 2 1]\n" + ] + } + ], + "source": [ + "# print(np.argmax(net.predict(X), axis=1))\n", + "print(net.predict(X))\n", + "print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[False True]\n", + " [ True True]]\n", + "[[0 1]]\n", + "[[ True True]\n", + " [False True]]\n" + ] + } + ], + "source": [ + "# ta = np.arange(25).reshape(5,5)\n", + "# print(ta)\n", + "# print((np.argmax(ta, axis=1) == y).mean())\n", + "ta = np.array([-1,3])\n", + "(ta > 0).mean()\n", + "ta = np.arange(4).reshape(2,2)\n", + "bool_ta = (ta > 0)\n", + "bool_tb = ta[0:1,0:2]\n", + "print(bool_ta)\n", + "# print((ta > 0).mean())\n", + "print(bool_tb)\n", + "\n", + "print(bool_ta == bool_tb)\n", + "\n", + "# ta_single = False\n", + "# print(np.array(ta_single))\n", + "# print(np.array(ta_single).mean())\n", + "\n", + "# ta_single = False\n", + "# print(ta_single.mean())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load the data\n", + "Now that you have implemented a two-layer network that passes gradient checks and works on toy data, it's time to load up our favorite CIFAR-10 data so we can use it to train a classifier on a real dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train data shape: (49000, 3072)\n", + "Train labels shape: (49000,)\n", + "Validation data shape: (1000, 3072)\n", + "Validation labels shape: (1000,)\n", + "Test data shape: (1000, 3072)\n", + "Test labels shape: (1000,)\n" + ] + } + ], + "source": [ + "from cs231n.data_utils import load_CIFAR10\n", + "\n", + "def get_CIFAR10_data(num_training=49000, num_validation=1000, num_test=1000):\n", + " \"\"\"\n", + " Load the CIFAR-10 dataset from disk and perform preprocessing to prepare\n", + " it for the two-layer neural net classifier. These are the same steps as\n", + " we used for the SVM, but condensed to a single function. \n", + " \"\"\"\n", + " # Load the raw CIFAR-10 data\n", + " cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'\n", + " \n", + " X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)\n", + " \n", + " # Subsample the data\n", + " mask = list(range(num_training, num_training + num_validation))\n", + " X_val = X_train[mask]\n", + " y_val = y_train[mask]\n", + " mask = list(range(num_training))\n", + " X_train = X_train[mask]\n", + " y_train = y_train[mask]\n", + " mask = list(range(num_test))\n", + " X_test = X_test[mask]\n", + " y_test = y_test[mask]\n", + "\n", + " # Normalize the data: subtract the mean image\n", + " mean_image = np.mean(X_train, axis=0)\n", + " X_train -= mean_image\n", + " X_val -= mean_image\n", + " X_test -= mean_image\n", + "\n", + " # Reshape data to rows\n", + " X_train = X_train.reshape(num_training, -1)\n", + " X_val = X_val.reshape(num_validation, -1)\n", + " X_test = X_test.reshape(num_test, -1)\n", + "\n", + " return X_train, y_train, X_val, y_val, X_test, y_test\n", + "\n", + "\n", + "# Cleaning up variables to prevent loading data multiple times (which may cause memory issue)\n", + "try:\n", + " del X_train, y_train\n", + " del X_test, y_test\n", + " print('Clear previously loaded data.')\n", + "except:\n", + " pass\n", + "\n", + "# Invoke the above function to get our data.\n", + "X_train, y_train, X_val, y_val, X_test, y_test = get_CIFAR10_data()\n", + "print('Train data shape: ', X_train.shape)\n", + "print('Train labels shape: ', y_train.shape)\n", + "print('Validation data shape: ', X_val.shape)\n", + "print('Validation labels shape: ', y_val.shape)\n", + "print('Test data shape: ', X_test.shape)\n", + "print('Test labels shape: ', y_test.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train a network\n", + "To train our network we will use SGD. In addition, we will adjust the learning rate with an exponential learning rate schedule as optimization proceeds; after each epoch, we will reduce the learning rate by multiplying it by a decay rate." + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iteration 0 / 1000: loss 2.302954\n", + "iteration 100 / 1000: loss 2.302550\n", + "iteration 200 / 1000: loss 2.297648\n", + "iteration 300 / 1000: loss 2.259602\n", + "iteration 400 / 1000: loss 2.204170\n", + "iteration 500 / 1000: loss 2.118565\n", + "iteration 600 / 1000: loss 2.051535\n", + "iteration 700 / 1000: loss 1.988466\n", + "iteration 800 / 1000: loss 2.006591\n", + "iteration 900 / 1000: loss 1.951473\n", + "Validation accuracy: 0.287\n" + ] + } + ], + "source": [ + "input_size = 32 * 32 * 3\n", + "hidden_size = 50\n", + "num_classes = 10\n", + "net = TwoLayerNet(input_size, hidden_size, num_classes)\n", + "\n", + "# Train the network\n", + "stats = net.train(X_train, y_train, X_val, y_val,\n", + " num_iters=1000, batch_size=200,\n", + " learning_rate=1e-4, learning_rate_decay=0.95,\n", + " reg=0.25, verbose=True)\n", + "\n", + "# Predict on the validation set\n", + "val_acc = (net.predict(X_val) == y_val).mean()\n", + "print('Validation accuracy: ', val_acc)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Debug the training\n", + "With the default parameters we provided above, you should get a validation accuracy of about 0.29 on the validation set. This isn't very good.\n", + "\n", + "One strategy for getting insight into what's wrong is to plot the loss function and the accuracies on the training and validation sets during optimization.\n", + "\n", + "Another strategy is to visualize the weights that were learned in the first layer of the network. In most neural networks trained on visual data, the first layer weights typically show some visible structure when visualized." + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the loss function and train / validation accuracies\n", + "plt.subplot(2, 1, 1)\n", + "plt.plot(stats['loss_history'])\n", + "plt.title('Loss history')\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Loss')\n", + "\n", + "plt.subplot(2, 1, 2)\n", + "plt.plot(stats['train_acc_history'], label='train')\n", + "plt.plot(stats['val_acc_history'], label='val')\n", + "plt.title('Classification accuracy history')\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Clasification accuracy')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(50, 3, 32, 32)\n", + "(50, 32, 32, 3)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from cs231n.vis_utils import visualize_grid\n", + "\n", + "# Visualize the weights of the network\n", + "\n", + "def show_net_weights(net):\n", + " W1 = net.params['W1']\n", + " print(W1.reshape(32, 32, 3, -1).transpose().shape) \n", + " W1 = W1.reshape(32, 32, 3, -1).transpose(3, 0, 1, 2)\n", + " print(W1.shape)\n", + " plt.imshow(visualize_grid(W1, padding=3).astype('uint8'))\n", + " plt.gca().axis('off')\n", + " plt.show()\n", + "\n", + "show_net_weights(net)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Tune your hyperparameters\n", + "\n", + "**What's wrong?**. Looking at the visualizations above, we see that the loss is decreasing more or less linearly, which seems to suggest that the learning rate may be too low. Moreover, there is no gap between the training and validation accuracy, suggesting that the model we used has low capacity, and that we should increase its size. On the other hand, with a very large model we would expect to see more overfitting, which would manifest itself as a very large gap between the training and validation accuracy.\n", + "\n", + "**Tuning**. Tuning the hyperparameters and developing intuition for how they affect the final performance is a large part of using Neural Networks, so we want you to get a lot of practice. Below, you should experiment with different values of the various hyperparameters, including hidden layer size, learning rate, numer of training epochs, and regularization strength. You might also consider tuning the learning rate decay, but you should be able to get good performance using the default value.\n", + "\n", + "**Approximate results**. You should be aim to achieve a classification accuracy of greater than 48% on the validation set. Our best network gets over 52% on the validation set.\n", + "\n", + "**Experiment**: You goal in this exercise is to get as good of a result on CIFAR-10 as you can, with a fully-connected Neural Network. Feel free implement your own techniques (e.g. PCA to reduce dimensionality, or adding dropout, or adding features to the solver, etc.)." + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "hidden_size: 70 learning_rate: 0.000325 reg: 0.15 num_iters: 3000 Tra acc: 0.496469387755102 Val acc: 0.485\n", + "hidden_size: 70 learning_rate: 0.000325 reg: 0.15 num_iters: 4000 Tra acc: 0.5178775510204081 Val acc: 0.491\n", + "hidden_size: 70 learning_rate: 0.000325 reg: 0.25 num_iters: 3000 Tra acc: 0.4952244897959184 Val acc: 0.463\n", + "hidden_size: 70 learning_rate: 0.000325 reg: 0.25 num_iters: 4000 Tra acc: 0.5125918367346939 Val acc: 0.488\n", + "hidden_size: 70 learning_rate: 0.000345 reg: 0.15 num_iters: 3000 Tra acc: 0.5026122448979592 Val acc: 0.476\n", + "hidden_size: 70 learning_rate: 0.000345 reg: 0.15 num_iters: 4000 Tra acc: 0.52 Val acc: 0.497\n", + "hidden_size: 70 learning_rate: 0.000345 reg: 0.25 num_iters: 3000 Tra acc: 0.5035306122448979 Val acc: 0.484\n", + "hidden_size: 70 learning_rate: 0.000345 reg: 0.25 num_iters: 4000 Tra acc: 0.5173061224489796 Val acc: 0.488\n", + "best_val_acc: 0.497\n" + ] + } + ], + "source": [ + "best_net = None # store the best model into this \n", + "\n", + "#################################################################################\n", + "# TODO: Tune hyperparameters using the validation set. Store your best trained #\n", + "# model in best_net. #\n", + "# #\n", + "# To help debug your network, it may help to use visualizations similar to the #\n", + "# ones we used above; these visualizations will have significant qualitative #\n", + "# differences from the ones we saw above for the poorly tuned network. #\n", + "# #\n", + "# Tweaking hyperparameters by hand can be fun, but you might find it useful to #\n", + "# write code to sweep through possible combinations of hyperparameters #\n", + "# automatically like we did on the previous exercises. #\n", + "#################################################################################\n", + "input_size = 32 * 32 * 3\n", + "num_classes = 10\n", + "best_val_acc = 0\n", + "\n", + "hidden_size = [70]\n", + "learning_rate = [3.25e-4, 3.45e-4,]\n", + "reg = [0.3, 0.35]\n", + "num_iters = [3000, 4000]\n", + "\n", + "for hs in hidden_size :\n", + " for lr in learning_rate :\n", + " for rg in reg :\n", + " for num in num_iters :\n", + " net = TwoLayerNet(input_size, hs, num_classes)\n", + "\n", + " # Train the network\n", + " stats = net.train(X_train, y_train, X_val, y_val,\n", + " num_iters=num, batch_size=200,\n", + " learning_rate=lr, learning_rate_decay=0.95,\n", + " reg=rg, verbose=False)\n", + "\n", + " # Predict on the validation set\n", + " val_acc = (net.predict(X_val) == y_val).mean()\n", + " tra_acc = (net.predict(X_train) == y_train).mean()\n", + " print(\"hidden_size:\",hs, \"learning_rate:\",lr, \"reg:\",rg, \"num_iters:\",num, \n", + " 'Tra acc:', tra_acc, 'Val acc:', val_acc)\n", + " if val_acc > best_val_acc :\n", + " best_val_acc = val_acc\n", + " best_net = net\n", + "\n", + "print('best_val_acc:', best_val_acc)\n", + " \n", + "# # Plot the loss function and train / validation accuracies\n", + "# plt.subplot(2, 1, 1)\n", + "# plt.plot(stats['loss_history'])\n", + "# plt.title('Loss history')\n", + "# plt.xlabel('Iteration')\n", + "# plt.ylabel('Loss')\n", + "\n", + "# plt.subplot(2, 1, 2)\n", + "# plt.plot(stats['train_acc_history'], label='train')\n", + "# plt.plot(stats['val_acc_history'], label='val')\n", + "# plt.title('Classification accuracy history')\n", + "# plt.xlabel('Epoch')\n", + "# plt.ylabel('Clasification accuracy')\n", + "# plt.legend()\n", + "# plt.show()\n", + "#################################################################################\n", + "# END OF YOUR CODE #\n", + "#################################################################################" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(70, 3, 32, 32)\n", + "(70, 32, 32, 3)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# visualize the weights of the best network\n", + "show_net_weights(best_net)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Run on the test set\n", + "When you are done experimenting, you should evaluate your final trained network on the test set; you should get above 48%." + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test accuracy: 0.499\n" + ] + } + ], + "source": [ + "test_acc = (best_net.predict(X_test) == y_test).mean()\n", + "print('Test accuracy: ', test_acc)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Inline Question**\n", + "\n", + "Now that you have trained a Neural Network classifier, you may find that your testing accuracy is much lower than the training accuracy. In what ways can we decrease this gap? Select all that apply.\n", + "1. Train on a larger dataset.\n", + "2. Add more hidden units.\n", + "3. Increase the regularization strength.\n", + "4. None of the above.\n", + "\n", + "*Your answer*:\n", + "\n", + "*Your explanation:*" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/assignment3/.gitignore b/assignment3/.gitignore new file mode 100644 index 000000000..55cab1cfc --- /dev/null +++ b/assignment3/.gitignore @@ -0,0 +1,6 @@ +*.swp +*.pyc +.env/* + +# gitignore the built release. +assignment3/* diff --git a/assignment3/.ipynb_checkpoints/GANs-PyTorch-checkpoint.ipynb b/assignment3/.ipynb_checkpoints/GANs-PyTorch-checkpoint.ipynb new file mode 100644 index 000000000..25017dc80 --- /dev/null +++ b/assignment3/.ipynb_checkpoints/GANs-PyTorch-checkpoint.ipynb @@ -0,0 +1,995 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generative Adversarial Networks (GANs)\n", + "\n", + "So far in CS231N, all the applications of neural networks that we have explored have been **discriminative models** that take an input and are trained to produce a labeled output. This has ranged from straightforward classification of image categories to sentence generation (which was still phrased as a classification problem, our labels were in vocabulary space and we’d learned a recurrence to capture multi-word labels). In this notebook, we will expand our repetoire, and build **generative models** using neural networks. Specifically, we will learn how to build models which generate novel images that resemble a set of training images.\n", + "\n", + "### What is a GAN?\n", + "\n", + "In 2014, [Goodfellow et al.](https://arxiv.org/abs/1406.2661) presented a method for training generative models called Generative Adversarial Networks (GANs for short). In a GAN, we build two different neural networks. Our first network is a traditional classification network, called the **discriminator**. We will train the discriminator to take images, and classify them as being real (belonging to the training set) or fake (not present in the training set). Our other network, called the **generator**, will take random noise as input and transform it using a neural network to produce images. The goal of the generator is to fool the discriminator into thinking the images it produced are real.\n", + "\n", + "We can think of this back and forth process of the generator ($G$) trying to fool the discriminator ($D$), and the discriminator trying to correctly classify real vs. fake as a minimax game:\n", + "$$\\underset{G}{\\text{minimize}}\\; \\underset{D}{\\text{maximize}}\\; \\mathbb{E}_{x \\sim p_\\text{data}}\\left[\\log D(x)\\right] + \\mathbb{E}_{z \\sim p(z)}\\left[\\log \\left(1-D(G(z))\\right)\\right]$$\n", + "where $z \\sim p(z)$ are the random noise samples, $G(z)$ are the generated images using the neural network generator $G$, and $D$ is the output of the discriminator, specifying the probability of an input being real. In [Goodfellow et al.](https://arxiv.org/abs/1406.2661), they analyze this minimax game and show how it relates to minimizing the Jensen-Shannon divergence between the training data distribution and the generated samples from $G$.\n", + "\n", + "To optimize this minimax game, we will aternate between taking gradient *descent* steps on the objective for $G$, and gradient *ascent* steps on the objective for $D$:\n", + "1. update the **generator** ($G$) to minimize the probability of the __discriminator making the correct choice__. \n", + "2. update the **discriminator** ($D$) to maximize the probability of the __discriminator making the correct choice__.\n", + "\n", + "While these updates are useful for analysis, they do not perform well in practice. Instead, we will use a different objective when we update the generator: maximize the probability of the **discriminator making the incorrect choice**. This small change helps to allevaiate problems with the generator gradient vanishing when the discriminator is confident. This is the standard update used in most GAN papers, and was used in the original paper from [Goodfellow et al.](https://arxiv.org/abs/1406.2661). \n", + "\n", + "In this assignment, we will alternate the following updates:\n", + "1. Update the generator ($G$) to maximize the probability of the discriminator making the incorrect choice on generated data:\n", + "$$\\underset{G}{\\text{maximize}}\\; \\mathbb{E}_{z \\sim p(z)}\\left[\\log D(G(z))\\right]$$\n", + "2. Update the discriminator ($D$), to maximize the probability of the discriminator making the correct choice on real and generated data:\n", + "$$\\underset{D}{\\text{maximize}}\\; \\mathbb{E}_{x \\sim p_\\text{data}}\\left[\\log D(x)\\right] + \\mathbb{E}_{z \\sim p(z)}\\left[\\log \\left(1-D(G(z))\\right)\\right]$$\n", + "\n", + "### What else is there?\n", + "Since 2014, GANs have exploded into a huge research area, with massive [workshops](https://sites.google.com/site/nips2016adversarial/), and [hundreds of new papers](https://github.com/hindupuravinash/the-gan-zoo). Compared to other approaches for generative models, they often produce the highest quality samples but are some of the most difficult and finicky models to train (see [this github repo](https://github.com/soumith/ganhacks) that contains a set of 17 hacks that are useful for getting models working). Improving the stabiilty and robustness of GAN training is an open research question, with new papers coming out every day! For a more recent tutorial on GANs, see [here](https://arxiv.org/abs/1701.00160). There is also some even more recent exciting work that changes the objective function to Wasserstein distance and yields much more stable results across model architectures: [WGAN](https://arxiv.org/abs/1701.07875), [WGAN-GP](https://arxiv.org/abs/1704.00028).\n", + "\n", + "\n", + "GANs are not the only way to train a generative model! For other approaches to generative modeling check out the [deep generative model chapter](http://www.deeplearningbook.org/contents/generative_models.html) of the Deep Learning [book](http://www.deeplearningbook.org). Another popular way of training neural networks as generative models is Variational Autoencoders (co-discovered [here](https://arxiv.org/abs/1312.6114) and [here](https://arxiv.org/abs/1401.4082)). Variatonal autoencoders combine neural networks with variationl inference to train deep generative models. These models tend to be far more stable and easier to train but currently don't produce samples that are as pretty as GANs.\n", + "\n", + "Here's an example of what your outputs from the 3 different models you're going to train should look like... note that GANs are sometimes finicky, so your outputs might not look exactly like this... this is just meant to be a *rough* guideline of the kind of quality you can expect:\n", + "\n", + "![caption](gan_outputs_pytorch.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "from torch.nn import init\n", + "import torchvision\n", + "import torchvision.transforms as T\n", + "import torch.optim as optim\n", + "from torch.utils.data import DataLoader\n", + "from torch.utils.data import sampler\n", + "import torchvision.datasets as dset\n", + "\n", + "import numpy as np\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.gridspec as gridspec\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "def show_images(images):\n", + " images = np.reshape(images, [images.shape[0], -1]) # images reshape to (batch_size, D)\n", + " sqrtn = int(np.ceil(np.sqrt(images.shape[0])))\n", + " sqrtimg = int(np.ceil(np.sqrt(images.shape[1])))\n", + "\n", + " fig = plt.figure(figsize=(sqrtn, sqrtn))\n", + " gs = gridspec.GridSpec(sqrtn, sqrtn)\n", + " gs.update(wspace=0.05, hspace=0.05)\n", + "\n", + " for i, img in enumerate(images):\n", + " ax = plt.subplot(gs[i])\n", + " plt.axis('off')\n", + " ax.set_xticklabels([])\n", + " ax.set_yticklabels([])\n", + " ax.set_aspect('equal')\n", + " plt.imshow(img.reshape([sqrtimg,sqrtimg]))\n", + " return \n", + "\n", + "def preprocess_img(x):\n", + " return 2 * x - 1.0\n", + "\n", + "def deprocess_img(x):\n", + " return (x + 1.0) / 2.0\n", + "\n", + "def rel_error(x,y):\n", + " return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n", + "\n", + "def count_params(model):\n", + " \"\"\"Count the number of parameters in the current TensorFlow graph \"\"\"\n", + " param_count = np.sum([np.prod(p.size()) for p in model.parameters()])\n", + " return param_count\n", + "\n", + "answers = dict(np.load('gan-checks-tf.npz'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dataset\n", + " GANs are notoriously finicky with hyperparameters, and also require many training epochs. In order to make this assignment approachable without a GPU, we will be working on the MNIST dataset, which is 60,000 training and 10,000 test images. Each picture contains a centered image of white digit on black background (0 through 9). This was one of the first datasets used to train convolutional neural networks and it is fairly easy -- a standard CNN model can easily exceed 99% accuracy. \n", + "\n", + "To simplify our code here, we will use the PyTorch MNIST wrapper, which downloads and loads the MNIST dataset. See the [documentation](https://github.com/pytorch/vision/blob/master/torchvision/datasets/mnist.py) for more information about the interface. The default parameters will take 5,000 of the training examples and place them into a validation dataset. The data will be saved into a folder called `MNIST_data`. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "class ChunkSampler(sampler.Sampler):\n", + " \"\"\"Samples elements sequentially from some offset. \n", + " Arguments:\n", + " num_samples: # of desired datapoints\n", + " start: offset where we should start selecting from\n", + " \"\"\"\n", + " def __init__(self, num_samples, start=0):\n", + " self.num_samples = num_samples\n", + " self.start = start\n", + "\n", + " def __iter__(self):\n", + " return iter(range(self.start, self.start + self.num_samples))\n", + "\n", + " def __len__(self):\n", + " return self.num_samples\n", + "\n", + "NUM_TRAIN = 50000\n", + "NUM_VAL = 5000\n", + "\n", + "NOISE_DIM = 96\n", + "batch_size = 128\n", + "\n", + "mnist_train = dset.MNIST('./cs231n/datasets/MNIST_data', train=True, download=True,\n", + " transform=T.ToTensor())\n", + "loader_train = DataLoader(mnist_train, batch_size=batch_size,\n", + " sampler=ChunkSampler(NUM_TRAIN, 0))\n", + "\n", + "mnist_val = dset.MNIST('./cs231n/datasets/MNIST_data', train=True, download=True,\n", + " transform=T.ToTensor())\n", + "loader_val = DataLoader(mnist_val, batch_size=batch_size,\n", + " sampler=ChunkSampler(NUM_VAL, NUM_TRAIN))\n", + "\n", + "\n", + "imgs = loader_train.__iter__().next()[0].view(batch_size, 784).numpy().squeeze()\n", + "show_images(imgs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Random Noise\n", + "Generate uniform noise from -1 to 1 with shape `[batch_size, dim]`.\n", + "\n", + "Hint: use `torch.rand`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def sample_noise(batch_size, dim):\n", + " \"\"\"\n", + " Generate a PyTorch Tensor of uniform random noise.\n", + "\n", + " Input:\n", + " - batch_size: Integer giving the batch size of noise to generate.\n", + " - dim: Integer giving the dimension of noise to generate.\n", + " \n", + " Output:\n", + " - A PyTorch Tensor of shape (batch_size, dim) containing uniform\n", + " random noise in the range (-1, 1).\n", + " \"\"\"\n", + " pass\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Make sure noise is the correct shape and type:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_sample_noise():\n", + " batch_size = 3\n", + " dim = 4\n", + " torch.manual_seed(231)\n", + " z = sample_noise(batch_size, dim)\n", + " np_z = z.cpu().numpy()\n", + " assert np_z.shape == (batch_size, dim)\n", + " assert torch.is_tensor(z)\n", + " assert np.all(np_z >= -1.0) and np.all(np_z <= 1.0)\n", + " assert np.any(np_z < 0.0) and np.any(np_z > 0.0)\n", + " print('All tests passed!')\n", + " \n", + "test_sample_noise()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Flatten\n", + "\n", + "Recall our Flatten operation from previous notebooks... this time we also provide an Unflatten, which you might want to use when implementing the convolutional generator. We also provide a weight initializer (and call it for you) that uses Xavier initialization instead of PyTorch's uniform default." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "class Flatten(nn.Module):\n", + " def forward(self, x):\n", + " N, C, H, W = x.size() # read in N, C, H, W\n", + " return x.view(N, -1) # \"flatten\" the C * H * W values into a single vector per image\n", + " \n", + "class Unflatten(nn.Module):\n", + " \"\"\"\n", + " An Unflatten module receives an input of shape (N, C*H*W) and reshapes it\n", + " to produce an output of shape (N, C, H, W).\n", + " \"\"\"\n", + " def __init__(self, N=-1, C=128, H=7, W=7):\n", + " super(Unflatten, self).__init__()\n", + " self.N = N\n", + " self.C = C\n", + " self.H = H\n", + " self.W = W\n", + " def forward(self, x):\n", + " return x.view(self.N, self.C, self.H, self.W)\n", + "\n", + "def initialize_weights(m):\n", + " if isinstance(m, nn.Linear) or isinstance(m, nn.ConvTranspose2d):\n", + " init.xavier_uniform_(m.weight.data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## CPU / GPU\n", + "By default all code will run on CPU. GPUs are not needed for this assignment, but will help you to train your models faster. If you do want to run the code on a GPU, then change the `dtype` variable in the following cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "dtype = torch.FloatTensor\n", + "#dtype = torch.cuda.FloatTensor ## UNCOMMENT THIS LINE IF YOU'RE ON A GPU!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Discriminator\n", + "Our first step is to build a discriminator. Fill in the architecture as part of the `nn.Sequential` constructor in the function below. All fully connected layers should include bias terms. The architecture is:\n", + " * Fully connected layer with input size 784 and output size 256\n", + " * LeakyReLU with alpha 0.01\n", + " * Fully connected layer with input_size 256 and output size 256\n", + " * LeakyReLU with alpha 0.01\n", + " * Fully connected layer with input size 256 and output size 1\n", + " \n", + "Recall that the Leaky ReLU nonlinearity computes $f(x) = \\max(\\alpha x, x)$ for some fixed constant $\\alpha$; for the LeakyReLU nonlinearities in the architecture above we set $\\alpha=0.01$.\n", + " \n", + "The output of the discriminator should have shape `[batch_size, 1]`, and contain real numbers corresponding to the scores that each of the `batch_size` inputs is a real image." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def discriminator():\n", + " \"\"\"\n", + " Build and return a PyTorch model implementing the architecture above.\n", + " \"\"\"\n", + " model = nn.Sequential(\n", + " )\n", + " return model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test to make sure the number of parameters in the discriminator is correct:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_discriminator(true_count=267009):\n", + " model = discriminator()\n", + " cur_count = count_params(model)\n", + " if cur_count != true_count:\n", + " print('Incorrect number of parameters in discriminator. Check your achitecture.')\n", + " else:\n", + " print('Correct number of parameters in discriminator.') \n", + "\n", + "test_discriminator()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generator\n", + "Now to build the generator network:\n", + " * Fully connected layer from noise_dim to 1024\n", + " * `ReLU`\n", + " * Fully connected layer with size 1024 \n", + " * `ReLU`\n", + " * Fully connected layer with size 784\n", + " * `TanH` (to clip the image to be in the range of [-1,1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def generator(noise_dim=NOISE_DIM):\n", + " \"\"\"\n", + " Build and return a PyTorch model implementing the architecture above.\n", + " \"\"\"\n", + " model = nn.Sequential(\n", + " )\n", + " return model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test to make sure the number of parameters in the generator is correct:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_generator(true_count=1858320):\n", + " model = generator(4)\n", + " cur_count = count_params(model)\n", + " if cur_count != true_count:\n", + " print('Incorrect number of parameters in generator. Check your achitecture.')\n", + " else:\n", + " print('Correct number of parameters in generator.')\n", + "\n", + "test_generator()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# GAN Loss\n", + "\n", + "Compute the generator and discriminator loss. The generator loss is:\n", + "$$\\ell_G = -\\mathbb{E}_{z \\sim p(z)}\\left[\\log D(G(z))\\right]$$\n", + "and the discriminator loss is:\n", + "$$ \\ell_D = -\\mathbb{E}_{x \\sim p_\\text{data}}\\left[\\log D(x)\\right] - \\mathbb{E}_{z \\sim p(z)}\\left[\\log \\left(1-D(G(z))\\right)\\right]$$\n", + "Note that these are negated from the equations presented earlier as we will be *minimizing* these losses.\n", + "\n", + "**HINTS**: You should use the `bce_loss` function defined below to compute the binary cross entropy loss which is needed to compute the log probability of the true label given the logits output from the discriminator. Given a score $s\\in\\mathbb{R}$ and a label $y\\in\\{0, 1\\}$, the binary cross entropy loss is\n", + "\n", + "$$ bce(s, y) = -y * \\log(s) - (1 - y) * \\log(1 - s) $$\n", + "\n", + "A naive implementation of this formula can be numerically unstable, so we have provided a numerically stable implementation for you below.\n", + "\n", + "You will also need to compute labels corresponding to real or fake and use the logit arguments to determine their size. Make sure you cast these labels to the correct data type using the global `dtype` variable, for example:\n", + "\n", + "\n", + "`true_labels = torch.ones(size).type(dtype)`\n", + "\n", + "Instead of computing the expectation of $\\log D(G(z))$, $\\log D(x)$ and $\\log \\left(1-D(G(z))\\right)$, we will be averaging over elements of the minibatch, so make sure to combine the loss by averaging instead of summing." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def bce_loss(input, target):\n", + " \"\"\"\n", + " Numerically stable version of the binary cross-entropy loss function.\n", + "\n", + " As per https://github.com/pytorch/pytorch/issues/751\n", + " See the TensorFlow docs for a derivation of this formula:\n", + " https://www.tensorflow.org/api_docs/python/tf/nn/sigmoid_cross_entropy_with_logits\n", + "\n", + " Inputs:\n", + " - input: PyTorch Tensor of shape (N, ) giving scores.\n", + " - target: PyTorch Tensor of shape (N,) containing 0 and 1 giving targets.\n", + "\n", + " Returns:\n", + " - A PyTorch Tensor containing the mean BCE loss over the minibatch of input data.\n", + " \"\"\"\n", + " neg_abs = - input.abs()\n", + " loss = input.clamp(min=0) - input * target + (1 + neg_abs.exp()).log()\n", + " return loss.mean()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def discriminator_loss(logits_real, logits_fake):\n", + " \"\"\"\n", + " Computes the discriminator loss described above.\n", + " \n", + " Inputs:\n", + " - logits_real: PyTorch Tensor of shape (N,) giving scores for the real data.\n", + " - logits_fake: PyTorch Tensor of shape (N,) giving scores for the fake data.\n", + " \n", + " Returns:\n", + " - loss: PyTorch Tensor containing (scalar) the loss for the discriminator.\n", + " \"\"\"\n", + " loss = None\n", + " return loss\n", + "\n", + "def generator_loss(logits_fake):\n", + " \"\"\"\n", + " Computes the generator loss described above.\n", + "\n", + " Inputs:\n", + " - logits_fake: PyTorch Tensor of shape (N,) giving scores for the fake data.\n", + " \n", + " Returns:\n", + " - loss: PyTorch Tensor containing the (scalar) loss for the generator.\n", + " \"\"\"\n", + " loss = None\n", + " return loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test your generator and discriminator loss. You should see errors < 1e-7." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_discriminator_loss(logits_real, logits_fake, d_loss_true):\n", + " d_loss = discriminator_loss(torch.Tensor(logits_real).type(dtype),\n", + " torch.Tensor(logits_fake).type(dtype)).cpu().numpy()\n", + " print(\"Maximum error in d_loss: %g\"%rel_error(d_loss_true, d_loss))\n", + "\n", + "test_discriminator_loss(answers['logits_real'], answers['logits_fake'],\n", + " answers['d_loss_true'])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_generator_loss(logits_fake, g_loss_true):\n", + " g_loss = generator_loss(torch.Tensor(logits_fake).type(dtype)).cpu().numpy()\n", + " print(\"Maximum error in g_loss: %g\"%rel_error(g_loss_true, g_loss))\n", + "\n", + "test_generator_loss(answers['logits_fake'], answers['g_loss_true'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optimizing our loss\n", + "Make a function that returns an `optim.Adam` optimizer for the given model with a 1e-3 learning rate, beta1=0.5, beta2=0.999. You'll use this to construct optimizers for the generators and discriminators for the rest of the notebook." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def get_optimizer(model):\n", + " \"\"\"\n", + " Construct and return an Adam optimizer for the model with learning rate 1e-3,\n", + " beta1=0.5, and beta2=0.999.\n", + " \n", + " Input:\n", + " - model: A PyTorch model that we want to optimize.\n", + " \n", + " Returns:\n", + " - An Adam optimizer for the model with the desired hyperparameters.\n", + " \"\"\"\n", + " optimizer = None\n", + " return optimizer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training a GAN!\n", + "\n", + "We provide you the main training loop... you won't need to change this function, but we encourage you to read through and understand it. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def run_a_gan(D, G, D_solver, G_solver, discriminator_loss, generator_loss, show_every=250, \n", + " batch_size=128, noise_size=96, num_epochs=10):\n", + " \"\"\"\n", + " Train a GAN!\n", + " \n", + " Inputs:\n", + " - D, G: PyTorch models for the discriminator and generator\n", + " - D_solver, G_solver: torch.optim Optimizers to use for training the\n", + " discriminator and generator.\n", + " - discriminator_loss, generator_loss: Functions to use for computing the generator and\n", + " discriminator loss, respectively.\n", + " - show_every: Show samples after every show_every iterations.\n", + " - batch_size: Batch size to use for training.\n", + " - noise_size: Dimension of the noise to use as input to the generator.\n", + " - num_epochs: Number of epochs over the training dataset to use for training.\n", + " \"\"\"\n", + " iter_count = 0\n", + " for epoch in range(num_epochs):\n", + " for x, _ in loader_train:\n", + " if len(x) != batch_size:\n", + " continue\n", + " D_solver.zero_grad()\n", + " real_data = x.type(dtype)\n", + " logits_real = D(2* (real_data - 0.5)).type(dtype)\n", + "\n", + " g_fake_seed = sample_noise(batch_size, noise_size).type(dtype)\n", + " fake_images = G(g_fake_seed).detach()\n", + " logits_fake = D(fake_images.view(batch_size, 1, 28, 28))\n", + "\n", + " d_total_error = discriminator_loss(logits_real, logits_fake)\n", + " d_total_error.backward() \n", + " D_solver.step()\n", + "\n", + " G_solver.zero_grad()\n", + " g_fake_seed = sample_noise(batch_size, noise_size).type(dtype)\n", + " fake_images = G(g_fake_seed)\n", + "\n", + " gen_logits_fake = D(fake_images.view(batch_size, 1, 28, 28))\n", + " g_error = generator_loss(gen_logits_fake)\n", + " g_error.backward()\n", + " G_solver.step()\n", + "\n", + " if (iter_count % show_every == 0):\n", + " print('Iter: {}, D: {:.4}, G:{:.4}'.format(iter_count,d_total_error.item(),g_error.item()))\n", + " imgs_numpy = fake_images.data.cpu().numpy()\n", + " show_images(imgs_numpy[0:16])\n", + " plt.show()\n", + " print()\n", + " iter_count += 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "# Make the discriminator\n", + "D = discriminator().type(dtype)\n", + "\n", + "# Make the generator\n", + "G = generator().type(dtype)\n", + "\n", + "# Use the function you wrote earlier to get optimizers for the Discriminator and the Generator\n", + "D_solver = get_optimizer(D)\n", + "G_solver = get_optimizer(G)\n", + "# Run it!\n", + "run_a_gan(D, G, D_solver, G_solver, discriminator_loss, generator_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Well that wasn't so hard, was it? In the iterations in the low 100s you should see black backgrounds, fuzzy shapes as you approach iteration 1000, and decent shapes, about half of which will be sharp and clearly recognizable as we pass 3000." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Least Squares GAN\n", + "We'll now look at [Least Squares GAN](https://arxiv.org/abs/1611.04076), a newer, more stable alernative to the original GAN loss function. For this part, all we have to do is change the loss function and retrain the model. We'll implement equation (9) in the paper, with the generator loss:\n", + "$$\\ell_G = \\frac{1}{2}\\mathbb{E}_{z \\sim p(z)}\\left[\\left(D(G(z))-1\\right)^2\\right]$$\n", + "and the discriminator loss:\n", + "$$ \\ell_D = \\frac{1}{2}\\mathbb{E}_{x \\sim p_\\text{data}}\\left[\\left(D(x)-1\\right)^2\\right] + \\frac{1}{2}\\mathbb{E}_{z \\sim p(z)}\\left[ \\left(D(G(z))\\right)^2\\right]$$\n", + "\n", + "\n", + "**HINTS**: Instead of computing the expectation, we will be averaging over elements of the minibatch, so make sure to combine the loss by averaging instead of summing. When plugging in for $D(x)$ and $D(G(z))$ use the direct output from the discriminator (`scores_real` and `scores_fake`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def ls_discriminator_loss(scores_real, scores_fake):\n", + " \"\"\"\n", + " Compute the Least-Squares GAN loss for the discriminator.\n", + " \n", + " Inputs:\n", + " - scores_real: PyTorch Tensor of shape (N,) giving scores for the real data.\n", + " - scores_fake: PyTorch Tensor of shape (N,) giving scores for the fake data.\n", + " \n", + " Outputs:\n", + " - loss: A PyTorch Tensor containing the loss.\n", + " \"\"\"\n", + " loss = None\n", + " return loss\n", + "\n", + "def ls_generator_loss(scores_fake):\n", + " \"\"\"\n", + " Computes the Least-Squares GAN loss for the generator.\n", + " \n", + " Inputs:\n", + " - scores_fake: PyTorch Tensor of shape (N,) giving scores for the fake data.\n", + " \n", + " Outputs:\n", + " - loss: A PyTorch Tensor containing the loss.\n", + " \"\"\"\n", + " loss = None\n", + " return loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before running a GAN with our new loss function, let's check it:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_lsgan_loss(score_real, score_fake, d_loss_true, g_loss_true):\n", + " score_real = torch.Tensor(score_real).type(dtype)\n", + " score_fake = torch.Tensor(score_fake).type(dtype)\n", + " d_loss = ls_discriminator_loss(score_real, score_fake).cpu().numpy()\n", + " g_loss = ls_generator_loss(score_fake).cpu().numpy()\n", + " print(\"Maximum error in d_loss: %g\"%rel_error(d_loss_true, d_loss))\n", + " print(\"Maximum error in g_loss: %g\"%rel_error(g_loss_true, g_loss))\n", + "\n", + "test_lsgan_loss(answers['logits_real'], answers['logits_fake'],\n", + " answers['d_loss_lsgan_true'], answers['g_loss_lsgan_true'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Run the following cell to train your model!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "D_LS = discriminator().type(dtype)\n", + "G_LS = generator().type(dtype)\n", + "\n", + "D_LS_solver = get_optimizer(D_LS)\n", + "G_LS_solver = get_optimizer(G_LS)\n", + "\n", + "run_a_gan(D_LS, G_LS, D_LS_solver, G_LS_solver, ls_discriminator_loss, ls_generator_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Deeply Convolutional GANs\n", + "In the first part of the notebook, we implemented an almost direct copy of the original GAN network from Ian Goodfellow. However, this network architecture allows no real spatial reasoning. It is unable to reason about things like \"sharp edges\" in general because it lacks any convolutional layers. Thus, in this section, we will implement some of the ideas from [DCGAN](https://arxiv.org/abs/1511.06434), where we use convolutional networks \n", + "\n", + "#### Discriminator\n", + "We will use a discriminator inspired by the TensorFlow MNIST classification tutorial, which is able to get above 99% accuracy on the MNIST dataset fairly quickly. \n", + "* Reshape into image tensor (Use Unflatten!)\n", + "* Conv2D: 32 Filters, 5x5, Stride 1\n", + "* Leaky ReLU(alpha=0.01)\n", + "* Max Pool 2x2, Stride 2\n", + "* Conv2D: 64 Filters, 5x5, Stride 1\n", + "* Leaky ReLU(alpha=0.01)\n", + "* Max Pool 2x2, Stride 2\n", + "* Flatten\n", + "* Fully Connected with output size 4 x 4 x 64\n", + "* Leaky ReLU(alpha=0.01)\n", + "* Fully Connected with output size 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def build_dc_classifier():\n", + " \"\"\"\n", + " Build and return a PyTorch model for the DCGAN discriminator implementing\n", + " the architecture above.\n", + " \"\"\"\n", + " return nn.Sequential(\n", + " ###########################\n", + " ######### TO DO ###########\n", + " ###########################\n", + " Unflatten(batch_size, 1, 28, 28),\n", + " )\n", + "\n", + "data = next(enumerate(loader_train))[-1][0].type(dtype)\n", + "b = build_dc_classifier().type(dtype)\n", + "out = b(data)\n", + "print(out.size())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the number of parameters in your classifier as a sanity check:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_dc_classifer(true_count=1102721):\n", + " model = build_dc_classifier()\n", + " cur_count = count_params(model)\n", + " if cur_count != true_count:\n", + " print('Incorrect number of parameters in generator. Check your achitecture.')\n", + " else:\n", + " print('Correct number of parameters in generator.')\n", + "\n", + "test_dc_classifer()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Generator\n", + "For the generator, we will copy the architecture exactly from the [InfoGAN paper](https://arxiv.org/pdf/1606.03657.pdf). See Appendix C.1 MNIST. See the documentation for [tf.nn.conv2d_transpose](https://www.tensorflow.org/api_docs/python/tf/nn/conv2d_transpose). We are always \"training\" in GAN mode. \n", + "* Fully connected with output size 1024\n", + "* `ReLU`\n", + "* BatchNorm\n", + "* Fully connected with output size 7 x 7 x 128 \n", + "* ReLU\n", + "* BatchNorm\n", + "* Reshape into Image Tensor of shape 7, 7, 128\n", + "* Conv2D^T (Transpose): 64 filters of 4x4, stride 2, 'same' padding\n", + "* `ReLU`\n", + "* BatchNorm\n", + "* Conv2D^T (Transpose): 1 filter of 4x4, stride 2, 'same' padding\n", + "* `TanH`\n", + "* Should have a 28x28x1 image, reshape back into 784 vector" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def build_dc_generator(noise_dim=NOISE_DIM):\n", + " \"\"\"\n", + " Build and return a PyTorch model implementing the DCGAN generator using\n", + " the architecture described above.\n", + " \"\"\"\n", + " return nn.Sequential(\n", + " ###########################\n", + " ######### TO DO ###########\n", + " ###########################\n", + " )\n", + "\n", + "test_g_gan = build_dc_generator().type(dtype)\n", + "test_g_gan.apply(initialize_weights)\n", + "\n", + "fake_seed = torch.randn(batch_size, NOISE_DIM).type(dtype)\n", + "fake_images = test_g_gan.forward(fake_seed)\n", + "fake_images.size()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the number of parameters in your generator as a sanity check:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_dc_generator(true_count=6580801):\n", + " model = build_dc_generator(4)\n", + " cur_count = count_params(model)\n", + " if cur_count != true_count:\n", + " print('Incorrect number of parameters in generator. Check your achitecture.')\n", + " else:\n", + " print('Correct number of parameters in generator.')\n", + "\n", + "test_dc_generator()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "D_DC = build_dc_classifier().type(dtype) \n", + "D_DC.apply(initialize_weights)\n", + "G_DC = build_dc_generator().type(dtype)\n", + "G_DC.apply(initialize_weights)\n", + "\n", + "D_DC_solver = get_optimizer(D_DC)\n", + "G_DC_solver = get_optimizer(G_DC)\n", + "\n", + "run_a_gan(D_DC, G_DC, D_DC_solver, G_DC_solver, discriminator_loss, generator_loss, num_epochs=5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## INLINE QUESTION 1\n", + "\n", + "We will look at an example to see why alternating minimization of the same objective (like in a GAN) can be tricky business.\n", + "\n", + "Consider $f(x,y)=xy$. What does $\\min_x\\max_y f(x,y)$ evaluate to? (Hint: minmax tries to minimize the maximum value achievable.)\n", + "\n", + "Now try to evaluate this function numerically for 6 steps, starting at the point $(1,1)$, \n", + "by using alternating gradient (first updating y, then updating x) with step size $1$. \n", + "You'll find that writing out the update step in terms of $x_t,y_t,x_{t+1},y_{t+1}$ will be useful.\n", + "\n", + "Record the six pairs of explicit values for $(x_t,y_t)$ in the table below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Your answer:\n", + " \n", + " $y_0$ | $y_1$ | $y_2$ | $y_3$ | $y_4$ | $y_5$ | $y_6$ \n", + " ----- | ----- | ----- | ----- | ----- | ----- | ----- \n", + " 1 | | | | | | \n", + " $x_0$ | $x_1$ | $x_2$ | $x_3$ | $x_4$ | $x_5$ | $x_6$ \n", + " 1 | | | | | | \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## INLINE QUESTION 2\n", + "Using this method, will we ever reach the optimal value? Why or why not?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Your answer:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## INLINE QUESTION 3\n", + "If the generator loss decreases during training while the discriminator loss stays at a constant high value from the start, is this a good sign? Why or why not? A qualitative answer is sufficient" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Your answer:" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/assignment3/.ipynb_checkpoints/GANs-TensorFlow-checkpoint.ipynb b/assignment3/.ipynb_checkpoints/GANs-TensorFlow-checkpoint.ipynb new file mode 100644 index 000000000..89d16667b --- /dev/null +++ b/assignment3/.ipynb_checkpoints/GANs-TensorFlow-checkpoint.ipynb @@ -0,0 +1,1009 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Generative Adversarial Networks (GANs)\n", + "\n", + "So far in CS231N, all the applications of neural networks that we have explored have been **discriminative models** that take an input and are trained to produce a labeled output. This has ranged from straightforward classification of image categories to sentence generation (which was still phrased as a classification problem, our labels were in vocabulary space and we’d learned a recurrence to capture multi-word labels). In this notebook, we will expand our repetoire, and build **generative models** using neural networks. Specifically, we will learn how to build models which generate novel images that resemble a set of training images.\n", + "\n", + "### What is a GAN?\n", + "\n", + "In 2014, [Goodfellow et al.](https://arxiv.org/abs/1406.2661) presented a method for training generative models called Generative Adversarial Networks (GANs for short). In a GAN, we build two different neural networks. Our first network is a traditional classification network, called the **discriminator**. We will train the discriminator to take images, and classify them as being real (belonging to the training set) or fake (not present in the training set). Our other network, called the **generator**, will take random noise as input and transform it using a neural network to produce images. The goal of the generator is to fool the discriminator into thinking the images it produced are real.\n", + "\n", + "We can think of this back and forth process of the generator ($G$) trying to fool the discriminator ($D$), and the discriminator trying to correctly classify real vs. fake as a minimax game:\n", + "$$\\underset{G}{\\text{minimize}}\\; \\underset{D}{\\text{maximize}}\\; \\mathbb{E}_{x \\sim p_\\text{data}}\\left[\\log D(x)\\right] + \\mathbb{E}_{z \\sim p(z)}\\left[\\log \\left(1-D(G(z))\\right)\\right]$$\n", + "where $x \\sim p_\\text{data}$ are samples from the input data, $z \\sim p(z)$ are the random noise samples, $G(z)$ are the generated images using the neural network generator $G$, and $D$ is the output of the discriminator, specifying the probability of an input being real. In [Goodfellow et al.](https://arxiv.org/abs/1406.2661), they analyze this minimax game and show how it relates to minimizing the Jensen-Shannon divergence between the training data distribution and the generated samples from $G$.\n", + "\n", + "To optimize this minimax game, we will aternate between taking gradient *descent* steps on the objective for $G$, and gradient *ascent* steps on the objective for $D$:\n", + "1. update the **generator** ($G$) to minimize the probability of the __discriminator making the correct choice__. \n", + "2. update the **discriminator** ($D$) to maximize the probability of the __discriminator making the correct choice__.\n", + "\n", + "While these updates are useful for analysis, they do not perform well in practice. Instead, we will use a different objective when we update the generator: maximize the probability of the **discriminator making the incorrect choice**. This small change helps to allevaiate problems with the generator gradient vanishing when the discriminator is confident. This is the standard update used in most GAN papers, and was used in the original paper from [Goodfellow et al.](https://arxiv.org/abs/1406.2661). \n", + "\n", + "In this assignment, we will alternate the following updates:\n", + "1. Update the generator ($G$) to maximize the probability of the discriminator making the incorrect choice on generated data:\n", + "$$\\underset{G}{\\text{maximize}}\\; \\mathbb{E}_{z \\sim p(z)}\\left[\\log D(G(z))\\right]$$\n", + "2. Update the discriminator ($D$), to maximize the probability of the discriminator making the correct choice on real and generated data:\n", + "$$\\underset{D}{\\text{maximize}}\\; \\mathbb{E}_{x \\sim p_\\text{data}}\\left[\\log D(x)\\right] + \\mathbb{E}_{z \\sim p(z)}\\left[\\log \\left(1-D(G(z))\\right)\\right]$$\n", + "\n", + "### What else is there?\n", + "Since 2014, GANs have exploded into a huge research area, with massive [workshops](https://sites.google.com/site/nips2016adversarial/), and [hundreds of new papers](https://github.com/hindupuravinash/the-gan-zoo). Compared to other approaches for generative models, they often produce the highest quality samples but are some of the most difficult and finicky models to train (see [this github repo](https://github.com/soumith/ganhacks) that contains a set of 17 hacks that are useful for getting models working). Improving the stabiilty and robustness of GAN training is an open research question, with new papers coming out every day! For a more recent tutorial on GANs, see [here](https://arxiv.org/abs/1701.00160). There is also some even more recent exciting work that changes the objective function to Wasserstein distance and yields much more stable results across model architectures: [WGAN](https://arxiv.org/abs/1701.07875), [WGAN-GP](https://arxiv.org/abs/1704.00028).\n", + "\n", + "\n", + "GANs are not the only way to train a generative model! For other approaches to generative modeling check out the [deep generative model chapter](http://www.deeplearningbook.org/contents/generative_models.html) of the Deep Learning [book](http://www.deeplearningbook.org). Another popular way of training neural networks as generative models is Variational Autoencoders (co-discovered [here](https://arxiv.org/abs/1312.6114) and [here](https://arxiv.org/abs/1401.4082)). Variational autoencoders combine neural networks with variational inference to train deep generative models. These models tend to be far more stable and easier to train but currently don't produce samples that are as pretty as GANs.\n", + "\n", + "Example pictures of what you should expect (yours might look slightly different):\n", + "\n", + "![caption](gan_outputs_tf.png)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import tensorflow as tf\n", + "import numpy as np\n", + "import os\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.gridspec as gridspec\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "# A bunch of utility functions\n", + "\n", + "def show_images(images):\n", + " images = np.reshape(images, [images.shape[0], -1]) # images reshape to (batch_size, D)\n", + " sqrtn = int(np.ceil(np.sqrt(images.shape[0])))\n", + " sqrtimg = int(np.ceil(np.sqrt(images.shape[1])))\n", + "\n", + " fig = plt.figure(figsize=(sqrtn, sqrtn))\n", + " gs = gridspec.GridSpec(sqrtn, sqrtn)\n", + " gs.update(wspace=0.05, hspace=0.05)\n", + "\n", + " for i, img in enumerate(images):\n", + " ax = plt.subplot(gs[i])\n", + " plt.axis('off')\n", + " ax.set_xticklabels([])\n", + " ax.set_yticklabels([])\n", + " ax.set_aspect('equal')\n", + " plt.imshow(img.reshape([sqrtimg,sqrtimg]))\n", + " return\n", + "\n", + "def preprocess_img(x):\n", + " return 2 * x - 1.0\n", + "\n", + "def deprocess_img(x):\n", + " return (x + 1.0) / 2.0\n", + "\n", + "def rel_error(x,y):\n", + " return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))\n", + "\n", + "def count_params():\n", + " \"\"\"Count the number of parameters in the current TensorFlow graph \"\"\"\n", + " param_count = np.sum([np.prod(x.get_shape().as_list()) for x in tf.global_variables()])\n", + " return param_count\n", + "\n", + "\n", + "def get_session():\n", + " config = tf.ConfigProto()\n", + " config.gpu_options.allow_growth = True\n", + " session = tf.Session(config=config)\n", + " return session\n", + "\n", + "answers = np.load('gan-checks-tf.npz')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Dataset\n", + " GANs are notoriously finicky with hyperparameters, and also require many training epochs. In order to make this assignment approachable without a GPU, we will be working on the MNIST dataset, which is 60,000 training and 10,000 test images. Each picture contains a centered image of white digit on black background (0 through 9). This was one of the first datasets used to train convolutional neural networks and it is fairly easy -- a standard CNN model can easily exceed 99% accuracy. \n", + " \n", + "\n", + "**Heads-up**: Our MNIST wrapper returns images as vectors. That is, they're size (batch, 784). If you want to treat them as images, we have to resize them to (batch,28,28) or (batch,28,28,1). They are also type np.float32 and bounded [0,1]. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "class MNIST(object):\n", + " def __init__(self, batch_size, shuffle=False):\n", + " \"\"\"\n", + " Construct an iterator object over the MNIST data\n", + " \n", + " Inputs:\n", + " - batch_size: Integer giving number of elements per minibatch\n", + " - shuffle: (optional) Boolean, whether to shuffle the data on each epoch\n", + " \"\"\"\n", + " train, _ = tf.keras.datasets.mnist.load_data()\n", + " X, y = train\n", + " X = X.astype(np.float32)/255\n", + " X = X.reshape((X.shape[0], -1))\n", + " self.X, self.y = X, y\n", + " self.batch_size, self.shuffle = batch_size, shuffle\n", + "\n", + " def __iter__(self):\n", + " N, B = self.X.shape[0], self.batch_size\n", + " idxs = np.arange(N)\n", + " if self.shuffle:\n", + " np.random.shuffle(idxs)\n", + " return iter((self.X[i:i+B], self.y[i:i+B]) for i in range(0, N, B)) " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# show a batch\n", + "mnist = MNIST(batch_size=16) \n", + "show_images(mnist.X[:16])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## LeakyReLU\n", + "In the cell below, you should implement a LeakyReLU. See the [class notes](http://cs231n.github.io/neural-networks-1/) (where alpha is small number) or equation (3) in [this paper](http://ai.stanford.edu/~amaas/papers/relu_hybrid_icml2013_final.pdf). LeakyReLUs keep ReLU units from dying and are often used in GAN methods (as are maxout units, however those increase model size and therefore are not used in this notebook).\n", + "\n", + "HINT: You should be able to use `tf.maximum`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def leaky_relu(x, alpha=0.01):\n", + " \"\"\"Compute the leaky ReLU activation function.\n", + " \n", + " Inputs:\n", + " - x: TensorFlow Tensor with arbitrary shape\n", + " - alpha: leak parameter for leaky ReLU\n", + " \n", + " Returns:\n", + " TensorFlow Tensor with the same shape as x\n", + " \"\"\"\n", + " # TODO: implement leaky ReLU\n", + " pass\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test your leaky ReLU implementation. You should get errors < 1e-10" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_leaky_relu(x, y_true):\n", + " tf.reset_default_graph()\n", + " with get_session() as sess:\n", + " y_tf = leaky_relu(tf.constant(x))\n", + " y = sess.run(y_tf)\n", + " print('Maximum error: %g'%rel_error(y_true, y))\n", + "\n", + "test_leaky_relu(answers['lrelu_x'], answers['lrelu_y'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Random Noise\n", + "Generate a TensorFlow `Tensor` containing uniform noise from -1 to 1 with shape `[batch_size, dim]`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def sample_noise(batch_size, dim):\n", + " \"\"\"Generate random uniform noise from -1 to 1.\n", + " \n", + " Inputs:\n", + " - batch_size: integer giving the batch size of noise to generate\n", + " - dim: integer giving the dimension of the the noise to generate\n", + " \n", + " Returns:\n", + " TensorFlow Tensor containing uniform noise in [-1, 1] with shape [batch_size, dim]\n", + " \"\"\"\n", + " # TODO: sample and return noise\n", + " pass\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Make sure noise is the correct shape and type:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_sample_noise():\n", + " batch_size = 3\n", + " dim = 4\n", + " tf.reset_default_graph()\n", + " with get_session() as sess:\n", + " z = sample_noise(batch_size, dim)\n", + " # Check z has the correct shape\n", + " assert z.get_shape().as_list() == [batch_size, dim]\n", + " # Make sure z is a Tensor and not a numpy array\n", + " assert isinstance(z, tf.Tensor)\n", + " # Check that we get different noise for different evaluations\n", + " z1 = sess.run(z)\n", + " z2 = sess.run(z)\n", + " assert not np.array_equal(z1, z2)\n", + " # Check that we get the correct range\n", + " assert np.all(z1 >= -1.0) and np.all(z1 <= 1.0)\n", + " print(\"All tests passed!\")\n", + " \n", + "test_sample_noise()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Discriminator\n", + "Our first step is to build a discriminator. You should use the layers in `tf.layers` to build the model.\n", + "All fully connected layers should include bias terms. For initialization, just use the default initializer used by the `tf.layers` functions.\n", + "\n", + "Architecture:\n", + " * Fully connected layer with input size 784 and output size 256\n", + " * LeakyReLU with alpha 0.01\n", + " * Fully connected layer with output size 256\n", + " * LeakyReLU with alpha 0.01\n", + " * Fully connected layer with output size 1 \n", + " \n", + "The output of the discriminator should thus have shape `[batch_size, 1]`, and contain real numbers corresponding to the scores that each of the `batch_size` inputs is a real image." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def discriminator(x):\n", + " \"\"\"Compute discriminator score for a batch of input images.\n", + " \n", + " Inputs:\n", + " - x: TensorFlow Tensor of flattened input images, shape [batch_size, 784]\n", + " \n", + " Returns:\n", + " TensorFlow Tensor with shape [batch_size, 1], containing the score \n", + " for an image being real for each input image.\n", + " \"\"\"\n", + " with tf.variable_scope(\"discriminator\"):\n", + " # TODO: implement architecture\n", + " pass\n", + " return logits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test to make sure the number of parameters in the discriminator is correct:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_discriminator(true_count=267009):\n", + " tf.reset_default_graph()\n", + " with get_session() as sess:\n", + " y = discriminator(tf.ones((2, 784)))\n", + " cur_count = count_params()\n", + " if cur_count != true_count:\n", + " print('Incorrect number of parameters in discriminator. {0} instead of {1}. Check your achitecture.'.format(cur_count,true_count))\n", + " else:\n", + " print('Correct number of parameters in discriminator.')\n", + " \n", + "test_discriminator()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Generator\n", + "Now to build a generator. You should use the layers in `tf.layers` to construct the model. All fully connected layers should include bias terms. Note that you can use the tf.nn module to access activation functions. Once again, use the default initializers for parameters.\n", + "\n", + "Architecture:\n", + " * Fully connected layer with inupt size tf.shape(z)[1] (the number of noise dimensions) and output size 1024\n", + " * `ReLU`\n", + " * Fully connected layer with output size 1024 \n", + " * `ReLU`\n", + " * Fully connected layer with output size 784\n", + " * `TanH` (To restrict every element of the output to be in the range [-1,1])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def generator(z):\n", + " \"\"\"Generate images from a random noise vector.\n", + " \n", + " Inputs:\n", + " - z: TensorFlow Tensor of random noise with shape [batch_size, noise_dim]\n", + " \n", + " Returns:\n", + " TensorFlow Tensor of generated images, with shape [batch_size, 784].\n", + " \"\"\"\n", + " with tf.variable_scope(\"generator\"):\n", + " # TODO: implement architecture\n", + " pass\n", + " return img" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test to make sure the number of parameters in the generator is correct:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_generator(true_count=1858320):\n", + " tf.reset_default_graph()\n", + " with get_session() as sess:\n", + " y = generator(tf.ones((1, 4)))\n", + " cur_count = count_params()\n", + " if cur_count != true_count:\n", + " print('Incorrect number of parameters in generator. {0} instead of {1}. Check your achitecture.'.format(cur_count,true_count))\n", + " else:\n", + " print('Correct number of parameters in generator.')\n", + " \n", + "test_generator()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# GAN Loss\n", + "\n", + "Compute the generator and discriminator loss. The generator loss is:\n", + "$$\\ell_G = -\\mathbb{E}_{z \\sim p(z)}\\left[\\log D(G(z))\\right]$$\n", + "and the discriminator loss is:\n", + "$$ \\ell_D = -\\mathbb{E}_{x \\sim p_\\text{data}}\\left[\\log D(x)\\right] - \\mathbb{E}_{z \\sim p(z)}\\left[\\log \\left(1-D(G(z))\\right)\\right]$$\n", + "Note that these are negated from the equations presented earlier as we will be *minimizing* these losses.\n", + "\n", + "**HINTS**: Use [tf.ones_like](https://www.tensorflow.org/api_docs/python/tf/ones_like) and [tf.zeros_like](https://www.tensorflow.org/api_docs/python/tf/zeros_like) to generate labels for your discriminator. Use [tf.nn.sigmoid_cross_entropy_with_logits](https://www.tensorflow.org/api_docs/python/tf/nn/sigmoid_cross_entropy_with_logits) to help compute your loss function. Instead of computing the expectation, we will be averaging over elements of the minibatch, so make sure to combine the loss by averaging instead of summing." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def gan_loss(logits_real, logits_fake):\n", + " \"\"\"Compute the GAN loss.\n", + " \n", + " Inputs:\n", + " - logits_real: Tensor, shape [batch_size, 1], output of discriminator\n", + " Unnormalized score that the image is real for each real image\n", + " - logits_fake: Tensor, shape[batch_size, 1], output of discriminator\n", + " Unnormalized score that the image is real for each fake image\n", + " \n", + " Returns:\n", + " - D_loss: discriminator loss scalar\n", + " - G_loss: generator loss scalar\n", + " \n", + " HINT: for the discriminator loss, you'll want to do the averaging separately for\n", + " its two components, and then add them together (instead of averaging once at the very end).\n", + " \"\"\"\n", + " # TODO: compute D_loss and G_loss\n", + " D_loss = None\n", + " G_loss = None\n", + " pass\n", + " return D_loss, G_loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test your GAN loss. Make sure both the generator and discriminator loss are correct. You should see errors less than 1e-5." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_gan_loss(logits_real, logits_fake, d_loss_true, g_loss_true):\n", + " tf.reset_default_graph()\n", + " with get_session() as sess:\n", + " d_loss, g_loss = sess.run(gan_loss(tf.constant(logits_real), tf.constant(logits_fake)))\n", + " print(\"Maximum error in d_loss: %g\"%rel_error(d_loss_true, d_loss))\n", + " print(\"Maximum error in g_loss: %g\"%rel_error(g_loss_true, g_loss))\n", + "\n", + "test_gan_loss(answers['logits_real'], answers['logits_fake'],\n", + " answers['d_loss_true'], answers['g_loss_true'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Optimizing our loss\n", + "Make an `AdamOptimizer` with a 1e-3 learning rate, beta1=0.5 to mininize G_loss and D_loss separately. The trick of decreasing beta was shown to be effective in helping GANs converge in the [Improved Techniques for Training GANs](https://arxiv.org/abs/1606.03498) paper. In fact, with our current hyperparameters, if you set beta1 to the Tensorflow default of 0.9, there's a good chance your discriminator loss will go to zero and the generator will fail to learn entirely. In fact, this is a common failure mode in GANs; if your D(x) learns to be too fast (e.g. loss goes near zero), your G(z) is never able to learn. Often D(x) is trained with SGD with Momentum or RMSProp instead of Adam, but here we'll use Adam for both D(x) and G(z). " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# TODO: create an AdamOptimizer for D_solver and G_solver\n", + "def get_solvers(learning_rate=1e-3, beta1=0.5):\n", + " \"\"\"Create solvers for GAN training.\n", + " \n", + " Inputs:\n", + " - learning_rate: learning rate to use for both solvers\n", + " - beta1: beta1 parameter for both solvers (first moment decay)\n", + " \n", + " Returns:\n", + " - D_solver: instance of tf.train.AdamOptimizer with correct learning_rate and beta1\n", + " - G_solver: instance of tf.train.AdamOptimizer with correct learning_rate and beta1\n", + " \"\"\"\n", + " D_solver = None\n", + " G_solver = None\n", + " pass\n", + " return D_solver, G_solver" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Putting it all together\n", + "Now just a bit of Lego Construction.. Read this section over carefully to understand how we'll be composing the generator and discriminator" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "tf.reset_default_graph()\n", + "\n", + "# number of images for each batch\n", + "batch_size = 128\n", + "# our noise dimension\n", + "noise_dim = 96\n", + "\n", + "# placeholder for images from the training dataset\n", + "x = tf.placeholder(tf.float32, [None, 784])\n", + "# random noise fed into our generator\n", + "z = sample_noise(batch_size, noise_dim)\n", + "# generated images\n", + "G_sample = generator(z)\n", + "\n", + "with tf.variable_scope(\"\") as scope:\n", + " #scale images to be -1 to 1\n", + " logits_real = discriminator(preprocess_img(x))\n", + " # Re-use discriminator weights on new inputs\n", + " scope.reuse_variables()\n", + " logits_fake = discriminator(G_sample)\n", + "\n", + "# Get the list of variables for the discriminator and generator\n", + "D_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'discriminator')\n", + "G_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, 'generator') \n", + "\n", + "# get our solver\n", + "D_solver, G_solver = get_solvers()\n", + "\n", + "# get our loss\n", + "D_loss, G_loss = gan_loss(logits_real, logits_fake)\n", + "\n", + "# setup training steps\n", + "D_train_step = D_solver.minimize(D_loss, var_list=D_vars)\n", + "G_train_step = G_solver.minimize(G_loss, var_list=G_vars)\n", + "D_extra_step = tf.get_collection(tf.GraphKeys.UPDATE_OPS, 'discriminator')\n", + "G_extra_step = tf.get_collection(tf.GraphKeys.UPDATE_OPS, 'generator')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training a GAN!\n", + "Well that wasn't so hard, was it? After the first epoch, you should see fuzzy outlines, clear shapes as you approach epoch 3, and decent shapes, about half of which will be sharp and clearly recognizable as we pass epoch 5. In our case, we'll simply train D(x) and G(z) with one batch each every iteration. However, papers often experiment with different schedules of training D(x) and G(z), sometimes doing one for more steps than the other, or even training each one until the loss gets \"good enough\" and then switching to training the other. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# a giant helper function\n", + "def run_a_gan(sess, G_train_step, G_loss, D_train_step, D_loss, G_extra_step, D_extra_step,\\\n", + " show_every=2, print_every=1, batch_size=128, num_epoch=10):\n", + " \"\"\"Train a GAN for a certain number of epochs.\n", + " \n", + " Inputs:\n", + " - sess: A tf.Session that we want to use to run our data\n", + " - G_train_step: A training step for the Generator\n", + " - G_loss: Generator loss\n", + " - D_train_step: A training step for the Generator\n", + " - D_loss: Discriminator loss\n", + " - G_extra_step: A collection of tf.GraphKeys.UPDATE_OPS for generator\n", + " - D_extra_step: A collection of tf.GraphKeys.UPDATE_OPS for discriminator\n", + " Returns:\n", + " Nothing\n", + " \"\"\"\n", + " # compute the number of iterations we need\n", + " mnist = MNIST(batch_size=batch_size, shuffle=True)\n", + " for epoch in range(num_epoch):\n", + " # every show often, show a sample result\n", + " if epoch % show_every == 0:\n", + " samples = sess.run(G_sample)\n", + " fig = show_images(samples[:16])\n", + " plt.show()\n", + " print()\n", + " for (minibatch, minbatch_y) in mnist:\n", + " # run a batch of data through the network\n", + " _, D_loss_curr = sess.run([D_train_step, D_loss], feed_dict={x: minibatch})\n", + " _, G_loss_curr = sess.run([G_train_step, G_loss])\n", + "\n", + " # print loss every so often.\n", + " # We want to make sure D_loss doesn't go to 0\n", + " if epoch % print_every == 0:\n", + " print('Epoch: {}, D: {:.4}, G:{:.4}'.format(epoch,D_loss_curr,G_loss_curr))\n", + " print('Final images')\n", + " samples = sess.run(G_sample)\n", + "\n", + " fig = show_images(samples[:16])\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Train your GAN! This should take about 10 minutes on a CPU, or less than a minute on GPU." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "with get_session() as sess:\n", + " sess.run(tf.global_variables_initializer())\n", + " run_a_gan(sess,G_train_step,G_loss,D_train_step,D_loss,G_extra_step,D_extra_step)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Least Squares GAN\n", + "We'll now look at [Least Squares GAN](https://arxiv.org/abs/1611.04076), a newer, more stable alternative to the original GAN loss function. For this part, all we have to do is change the loss function and retrain the model. We'll implement equation (9) in the paper, with the generator loss:\n", + "$$\\ell_G = \\frac{1}{2}\\mathbb{E}_{z \\sim p(z)}\\left[\\left(D(G(z))-1\\right)^2\\right]$$\n", + "and the discriminator loss:\n", + "$$ \\ell_D = \\frac{1}{2}\\mathbb{E}_{x \\sim p_\\text{data}}\\left[\\left(D(x)-1\\right)^2\\right] + \\frac{1}{2}\\mathbb{E}_{z \\sim p(z)}\\left[ \\left(D(G(z))\\right)^2\\right]$$\n", + "\n", + "\n", + "**HINTS**: Instead of computing the expectation, we will be averaging over elements of the minibatch, so make sure to combine the loss by averaging instead of summing. When plugging in for $D(x)$ and $D(G(z))$ use the direct output from the discriminator (`score_real` and `score_fake`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def lsgan_loss(scores_real, scores_fake):\n", + " \"\"\"Compute the Least Squares GAN loss.\n", + " \n", + " Inputs:\n", + " - scores_real: Tensor, shape [batch_size, 1], output of discriminator\n", + " The score for each real image\n", + " - scores_fake: Tensor, shape[batch_size, 1], output of discriminator\n", + " The score for each fake image \n", + " \n", + " Returns:\n", + " - D_loss: discriminator loss scalar\n", + " - G_loss: generator loss scalar\n", + " \"\"\"\n", + " # TODO: compute D_loss and G_loss\n", + " D_loss = None\n", + " G_loss = None\n", + " pass\n", + " return D_loss, G_loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test your LSGAN loss. You should see errors less than 1e-7." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def test_lsgan_loss(score_real, score_fake, d_loss_true, g_loss_true):\n", + " with get_session() as sess:\n", + " d_loss, g_loss = sess.run(\n", + " lsgan_loss(tf.constant(score_real), tf.constant(score_fake)))\n", + " print(\"Maximum error in d_loss: %g\"%rel_error(d_loss_true, d_loss))\n", + " print(\"Maximum error in g_loss: %g\"%rel_error(g_loss_true, g_loss))\n", + "\n", + "test_lsgan_loss(answers['logits_real'], answers['logits_fake'],\n", + " answers['d_loss_lsgan_true'], answers['g_loss_lsgan_true'])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Create new training steps so we instead minimize the LSGAN loss:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "D_loss, G_loss = lsgan_loss(logits_real, logits_fake)\n", + "D_train_step = D_solver.minimize(D_loss, var_list=D_vars)\n", + "G_train_step = G_solver.minimize(G_loss, var_list=G_vars)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_Run the following cell to train your model!_" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with get_session() as sess:\n", + " sess.run(tf.global_variables_initializer())\n", + " run_a_gan(sess, G_train_step, G_loss, D_train_step, D_loss, G_extra_step, D_extra_step)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Deep Convolutional GANs\n", + "In the first part of the notebook, we implemented an almost direct copy of the original GAN network from Ian Goodfellow. However, this network architecture allows no real spatial reasoning. It is unable to reason about things like \"sharp edges\" in general because it lacks any convolutional layers. Thus, in this section, we will implement some of the ideas from [DCGAN](https://arxiv.org/abs/1511.06434), where we use convolutional networks as our discriminators and generators.\n", + "\n", + "#### Discriminator\n", + "We will use a discriminator inspired by the TensorFlow MNIST classification [tutorial](https://www.tensorflow.org/get_started/mnist/pros), which is able to get above 99% accuracy on the MNIST dataset fairly quickly. *Be sure to check the dimensions of x and reshape when needed*, fully connected blocks expect [N,D] Tensors while conv2d blocks expect [N,H,W,C] Tensors. Please use `tf.layers` to define the following architecture:\n", + "\n", + "Architecture:\n", + "* Conv2D: 32 Filters, 5x5, Stride 1, padding 0\n", + "* Leaky ReLU(alpha=0.01)\n", + "* Max Pool 2x2, Stride 2\n", + "* Conv2D: 64 Filters, 5x5, Stride 1, padding 0\n", + "* Leaky ReLU(alpha=0.01)\n", + "* Max Pool 2x2, Stride 2\n", + "* Flatten\n", + "* Fully Connected with output size 4 x 4 x 64\n", + "* Leaky ReLU(alpha=0.01)\n", + "* Fully Connected with output size 1\n", + "\n", + "Once again, please use biases for all convolutional and fully connected layers, and use the default parameter initializers. Note that a padding of 0 can be accomplished with the 'VALID' padding option." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def discriminator(x):\n", + " \"\"\"Compute discriminator score for a batch of input images.\n", + " \n", + " Inputs:\n", + " - x: TensorFlow Tensor of flattened input images, shape [batch_size, 784]\n", + " \n", + " Returns:\n", + " TensorFlow Tensor with shape [batch_size, 1], containing the score \n", + " for an image being real for each input image.\n", + " \"\"\"\n", + " with tf.variable_scope(\"discriminator\"):\n", + " # TODO: implement architecture\n", + " pass\n", + " return logits\n", + "test_discriminator(1102721)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Generator\n", + "For the generator, we will copy the architecture exactly from the [InfoGAN paper](https://arxiv.org/pdf/1606.03657.pdf). See Appendix C.1 MNIST. Please use `tf.layers` for your implementation. You might find the documentation for [tf.layers.conv2d_transpose](https://www.tensorflow.org/api_docs/python/tf/layers/conv2d_transpose) useful. The architecture is as follows.\n", + "\n", + "Architecture:\n", + "* Fully connected with output size 1024 \n", + "* `ReLU`\n", + "* BatchNorm\n", + "* Fully connected with output size 7 x 7 x 128 \n", + "* `ReLU`\n", + "* BatchNorm\n", + "* Resize into Image Tensor of size 7, 7, 128\n", + "* Conv2D^T (transpose): 64 filters of 4x4, stride 2\n", + "* `ReLU`\n", + "* BatchNorm\n", + "* Conv2d^T (transpose): 1 filter of 4x4, stride 2\n", + "* `TanH`\n", + "\n", + "Once again, use biases for the fully connected and transpose convolutional layers. Please use the default initializers for your parameters. For padding, choose the 'same' option for transpose convolutions. For Batch Normalization, assume we are always in 'training' mode." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def generator(z):\n", + " \"\"\"Generate images from a random noise vector.\n", + " \n", + " Inputs:\n", + " - z: TensorFlow Tensor of random noise with shape [batch_size, noise_dim]\n", + " \n", + " Returns:\n", + " TensorFlow Tensor of generated images, with shape [batch_size, 784].\n", + " \"\"\"\n", + " with tf.variable_scope(\"generator\"):\n", + " # TODO: implement architecture\n", + " pass\n", + " return img\n", + "test_generator(6595521)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have to recreate our network since we've changed our functions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "tf.reset_default_graph()\n", + "\n", + "batch_size = 128\n", + "# our noise dimension\n", + "noise_dim = 96\n", + "\n", + "# placeholders for images from the training dataset\n", + "x = tf.placeholder(tf.float32, [None, 784])\n", + "z = sample_noise(batch_size, noise_dim)\n", + "# generated images\n", + "G_sample = generator(z)\n", + "\n", + "with tf.variable_scope(\"\") as scope:\n", + " #scale images to be -1 to 1\n", + " logits_real = discriminator(preprocess_img(x))\n", + " # Re-use discriminator weights on new inputs\n", + " scope.reuse_variables()\n", + " logits_fake = discriminator(G_sample)\n", + "\n", + "# Get the list of variables for the discriminator and generator\n", + "D_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,'discriminator')\n", + "G_vars = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES,'generator') \n", + "\n", + "D_solver,G_solver = get_solvers()\n", + "D_loss, G_loss = gan_loss(logits_real, logits_fake)\n", + "D_train_step = D_solver.minimize(D_loss, var_list=D_vars)\n", + "G_train_step = G_solver.minimize(G_loss, var_list=G_vars)\n", + "D_extra_step = tf.get_collection(tf.GraphKeys.UPDATE_OPS,'discriminator')\n", + "G_extra_step = tf.get_collection(tf.GraphKeys.UPDATE_OPS,'generator')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train and evaluate a DCGAN\n", + "This is the one part of A3 that significantly benefits from using a GPU. It takes 3 minutes on a GPU for the requested five epochs. Or about 50 minutes on a dual core laptop on CPU (feel free to use 3 epochs if you do it on CPU)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with get_session() as sess:\n", + " sess.run(tf.global_variables_initializer())\n", + " run_a_gan(sess,G_train_step,G_loss,D_train_step,D_loss,G_extra_step,D_extra_step,num_epoch=5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## INLINE QUESTION 1\n", + "\n", + "We will look at an example to see why alternating minimization of the same objective (like in a GAN) can be tricky business.\n", + "\n", + "Consider $f(x,y)=xy$. What does $\\min_x\\max_y f(x,y)$ evaluate to? (Hint: minmax tries to minimize the maximum value achievable.)\n", + "\n", + "Now try to evaluate this function numerically for 6 steps, starting at the point $(1,1)$, \n", + "by using alternating gradient (first updating y, then updating x) with step size $1$. \n", + "You'll find that writing out the update step in terms of $x_t,y_t,x_{t+1},y_{t+1}$ will be useful.\n", + "\n", + "Record the six pairs of explicit values for $(x_t,y_t)$ in the table below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Your answer:\n", + " \n", + " $y_0$ | $y_1$ | $y_2$ | $y_3$ | $y_4$ | $y_5$ | $y_6$ \n", + " ----- | ----- | ----- | ----- | ----- | ----- | ----- \n", + " 1 | | | | | | \n", + " $x_0$ | $x_1$ | $x_2$ | $x_3$ | $x_4$ | $x_5$ | $x_6$ \n", + " 1 | | | | | | \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## INLINE QUESTION 2\n", + "Using this method, will we ever reach the optimal value? Why or why not?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Your answer:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## INLINE QUESTION 3\n", + "If the generator loss decreases during training while the discriminator loss stays at a constant high value from the start, is this a good sign? Why or why not? A qualitative answer is sufficient" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Your answer:" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/assignment3/.ipynb_checkpoints/LSTM_Captioning-checkpoint.ipynb b/assignment3/.ipynb_checkpoints/LSTM_Captioning-checkpoint.ipynb new file mode 100644 index 000000000..0ebc2e6e7 --- /dev/null +++ b/assignment3/.ipynb_checkpoints/LSTM_Captioning-checkpoint.ipynb @@ -0,0 +1,626 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Image Captioning with LSTMs\n", + "In the previous exercise you implemented a vanilla RNN and applied it to image captioning. In this notebook you will implement the LSTM update rule and use it for image captioning." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# As usual, a bit of setup\n", + "import time, os, json\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from cs231n.gradient_check import eval_numerical_gradient, eval_numerical_gradient_array\n", + "from cs231n.rnn_layers import *\n", + "from cs231n.captioning_solver import CaptioningSolver\n", + "from cs231n.classifiers.rnn import CaptioningRNN\n", + "from cs231n.coco_utils import load_coco_data, sample_coco_minibatch, decode_captions\n", + "from cs231n.image_utils import image_from_url\n", + "\n", + "%matplotlib inline\n", + "plt.rcParams['figure.figsize'] = (10.0, 8.0) # set default size of plots\n", + "plt.rcParams['image.interpolation'] = 'nearest'\n", + "plt.rcParams['image.cmap'] = 'gray'\n", + "\n", + "# for auto-reloading external modules\n", + "# see http://stackoverflow.com/questions/1907993/autoreload-of-modules-in-ipython\n", + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "def rel_error(x, y):\n", + " \"\"\" returns relative error \"\"\"\n", + " return np.max(np.abs(x - y) / (np.maximum(1e-8, np.abs(x) + np.abs(y))))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Load MS-COCO data\n", + "As in the previous notebook, we will use the Microsoft COCO dataset for captioning." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "train_captions (400135, 17) int32\n", + "train_image_idxs (400135,) int32\n", + "val_captions (195954, 17) int32\n", + "val_image_idxs (195954,) int32\n", + "train_features (82783, 512) float32\n", + "val_features (40504, 512) float32\n", + "idx_to_word 1004\n", + "word_to_idx 1004\n", + "train_urls (82783,) (40504,)