From 4404649ba17d0d1684151bb3b064d2022cedc06d Mon Sep 17 00:00:00 2001 From: pswietojanski Date: Mon, 12 Oct 2015 00:31:57 +0100 Subject: [PATCH 1/5] solutions --- 00_Introduction_solution.ipynb | 622 ++++++++++++++++++++++ 01_Linear_Models.ipynb | 40 +- 01_Linear_Models_solution.ipynb | 890 ++++++++++++++++++++++++++++++++ mlp/dataset.py | 10 + 4 files changed, 1523 insertions(+), 39 deletions(-) create mode 100644 00_Introduction_solution.ipynb create mode 100644 01_Linear_Models_solution.ipynb diff --git a/00_Introduction_solution.ipynb b/00_Introduction_solution.ipynb new file mode 100644 index 0000000..b58d807 --- /dev/null +++ b/00_Introduction_solution.ipynb @@ -0,0 +1,622 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction\n", + "\n", + "This notebook shows how to set-up a working python envirnoment for the Machine Learning Practical course.\n", + "\n", + "\n", + "# Setting up the software\n", + "\n", + "Within this course we are going to work with python (using some auxiliary libraries like numpy and scipy). Depending on the infrastracture and working environment (e.g. DICE), root permission may not be not available so the packages cannot be installed in default locations. A convenient python configuration, which allows us to install and update third party libraries easily using package manager, are so called virtual environments. They can be also used to work (and test) the code with different versions of software.\n", + "\n", + "## Instructions for Windows\n", + "\n", + "The fastest way to get working setup on Windows is to install Anaconda (http://www.continuum.io) package. It's a python environment with precompiled versions of the most popular scientific python libraries. It also works on MacOS, but numpy is not linked without a fee to a numerical library, hence for MacOS we recommend the following procedure.\n", + "\n", + "## Instructions for MacOS\n", + "\n", + " * Install macports following instructions at https://www.macports.org/install.php\n", + " * Install the relevant python packages in macports\n", + "\n", + " ```\n", + " sudo port install py27-scipy +openblas\n", + " sudo port install py27-ipython +notebook\n", + " sudo port install py27-notebook\n", + " sudo port install py27-matplotlib\n", + " sudo port select --set python python27\n", + " sudo port select --set ipython2 py27-ipython\n", + " sudo port select --set ipython py27-ipython\n", + " ```\n", + "\n", + "Make sure that your `$PATH` has `/opt/local/bin` before `/usr/bin` so you pick up the version of python you just installed.\n", + "\n", + "## Instructions for DICE:\n", + "\n", + "### Directory structure and getting things organised\n", + "\n", + "To get things somehow standarized between people, and make life of everyone easier, we propse to organise your DICE setup in the following directory structure:\n", + "\n", + " * `~/mlpractical/` -- for a general course repository\n", + " * `~/mlpractical/repos-3rd` -- for stuff you download, build and install (numpy, OpenBlas, virtualenv)\n", + " * `~/mlpractical/repo-mlp` -- this is the actual course repository you clone from our website (do not create a dir for it yet!)\n", + " * `~/mlpractical/venv` -- this is where virutal envirnoment will make its dir (do not create a dir for it yet!)\n", + "\n", + "Create now repos-3rd directory (option -p in the below command will automatically create (non-existing) **p**arent directories (mlpractical):\n", + "\n", + " * `mkdir -p ~/mlpractical/repos-3rd`\n", + "\n", + "And now, let us set an MLP_WDIR environmental variable (MLP Working DIRectory) that will keep an absolute path of working dir pointing to `~/mlpractial`, **add the below line** to your `~/.bashrc` file (if it does not exists, create one using a text editor! e.g. by running `gedit ~/.bashrc`):\n", + "\n", + "```\n", + "export MLP_WDIR=~/mlpractical\n", + "```\n", + "\n", + "Now re-source `~/.bashrc` by typing (so the env variables get updated!): `source ~/.bashrc`\n", + "\n", + "Enter the `repos-3rd` directory by typing: `cd ~/mlpractical/repos-3rd` (or ```cd $MLP_WDIR/repos-3rd``` if you want)\n", + "\n", + "### Configuring virtual environment\n", + "\n", + "Make sure you are in `repos-3rd` directory and that MLP_WDIR variable has been exported (you may type export in the terminal and examine the list of availabe variables in the current session), then type:\n", + "\n", + " * `git clone https://github.com/pypa/virtualenv`\n", + " * Enter the cloned repository and type ```./virtualenv.py --python /usr/bin/python2.7 --no-site-packages $MLP_WDIR/venv```\n", + " * Activate the environment by typing `source ~/mlpractical/venv/bin/activate` (to leave the virtual environment one may type `decativate`)\n", + " * Environments need to be activated every time ones start the new session so we will now create a handy alias to it in `~/.bashrc` script, by typing the below command (note, MLP_WDIR export needs to preceed this command):\n", + " \n", + " ```alias activate_mlp=\"source $MLP_WDIR/venv/bin/activate\"```\n", + " \n", + "Then every time you open new session and want to activate the right virtual environment, simply type `activate_mlp` instead `source ~/mlpractical/venv/bin/activate`. Note, you need to re-soure the .bashrc in order alias to be visible in the current session.\n", + "\n", + "### Installing remaining packages\n", + "\n", + "Then, before you follow next, install/upgrade the following packages:\n", + "\n", + "```\n", + "pip install --upgrade pip\n", + "pip install setuptools\n", + "pip install setuptools --upgrade\n", + "pip install ipython\n", + "pip install notebook\n", + "```\n", + "\n", + "### Installing numpy\n", + "\n", + "Note, having virtual environment properly installed one may then run `pip install numpy` to use pip to install numpy, though this will most likely lead to the suboptimal configuration where numpy is linked to ATLAS numerical library, which on DICE is compiled in multi-threaded mode. This means whenever numpy use BLAS accelerated computations (using ATLAS), it will use **all** the available cores at the given machine. This happens because ATLAS can be compiled to either run computations in single *or* multi threaded modes. However, contrary to some other backends, the latter does not allow to use an arbitrary number of threads (specified by the user prior to computation). This is highly suboptimal, as the potential speed-up resulting from paralleism depends on many factors like the communication overhead between threads, the size of the problem, etc. Using all cores for our exercises is not-necessary.\n", + "\n", + "For which reason, we are going to compile our own version of BLAS package, called *OpenBlas*. It allows to specify the number of threads manually by setting an environmental variable OMP_NUM_THREADS=N, where N is a desired number of parallel threads (please use 1 by default). You can set an environment variable in the current shell by running\n", + "\n", + "```\n", + "export OMP_NUM_THREADS=1\n", + "```\n", + "\n", + "(note the lack of spaces around the equals sign and use of `export` to define an environment variable which will be available in sub-shells rather than just a variable local to the current shell).\n", + "\n", + "#### OpenBlas\n", + "\n", + "Enter again repos-3rd directory and copy into terminal the following commands (one at the time):\n", + "\n", + "```\n", + "cd ~/mlpractical/repos-3rd\n", + "OBDir=$MLP_WDIR/repos-3rd/OpenBLAS\n", + "git clone git://github.com/xianyi/OpenBLAS\n", + "cd OpenBLAS\n", + "make\n", + "make PREFIX=$OBDir install\n", + "```\n", + "\n", + "Once OpenBLAS is finished compiling we need to ensure the compiled shared library files in the `lib` subdirectory are available to the shared library loader. This can be done by appending the absolute path to the `lib` subdirectory to the `LD_LIBRARY_PATH` environment variable. To ensure this changes persist we will change the bash start up file `~/.bashrc` by opening it in a text editor (e.g. by running `gedit ~/.bashrc`) and adding the following line\n", + "\n", + "```\n", + "export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$MLP_WDIR/repos-3rd/OpenBLAS/lib\n", + "```\n", + "\n", + "Note, we again are using MLP_WDIR here, so the above line needs to be placed after you set MLP_WDIR.\n", + "\n", + "After you have edited `.bashrc` run\n", + "\n", + "```\n", + "source ~/.bashrc\n", + "activate_mlp # This is the alias you set up in the bashrc\n", + "#source ~/mlpractical/venv/bin/activate\n", + "```\n", + "\n", + "to rerun the bash start up script make sure the new environment variable is available in the current shell and then reactivate the virtual environment.\n", + "\n", + "#### Numpy\n", + "\n", + "To install `numpy` linked against the OpenBLAS libraries we just compiled, first run the following commands (one at a time)\n", + "\n", + "```\n", + "cd ~/mlpractical/repos-3rd/\n", + "wget http://downloads.sourceforge.net/project/numpy/NumPy/1.9.2/numpy-1.9.2.zip\n", + "unzip numpy-1.9.2.zip\n", + "cd numpy-1.9.2\n", + "echo \"[openblas]\" >> site.cfg\n", + "echo \"library_dirs = $OBDir/lib\" >> site.cfg\n", + "echo \"include_dirs = $OBDir/include\" >> site.cfg\n", + "python setup.py build --fcompiler=gnu95\n", + "```\n", + "\n", + "Assuming the virtual environment is activated, the below command will install numpy in a desired space (`~/mlpractical/venv/...`):\n", + "\n", + "```\n", + "python setup.py install\n", + "```\n", + "\n", + "Now use pip to install remaining packages: `scipy`, `matplotlib`, `argparse`, and `nose` by executing:\n", + "\n", + "```\n", + "pip install scipy matplotlib argparse nose\n", + "```\n", + "\n", + "### Getting the mlpractical repository\n", + "\n", + "Clone the course repository from the github, by navigating to `~/mlpractical` directory and typing:\n", + "\n", + "```\n", + "cd $MLP_WDIR\n", + "git clone https://github.com/CSTR-Edinburgh/mlpractical.git repo-mlp\n", + "```\n", + "\n", + "When download is ready, enter the repo-mlp directory and start the actual interactive notebook session by typing:\n", + "\n", + "```\n", + "cd repo-mlp\n", + "ipython notebook\n", + "```\n", + "\n", + "This should start a ipython server which opens a new browser window listing files in `repo-mlp` directory, including `00_Introduction.ipynb.`. Open it and run (from the browser interface) the following examples and exercies." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [], + "source": [ + "%clear\n", + "import numpy\n", + "# show_config() prints the configuration of numpy numerical backend \n", + "# you should be able to see linkage to OpenBlas or some other library\n", + "# in case those are empty, it means something went wrong and \n", + "# numpy will use a default (slow) pythonic implementation for algebra\n", + "numpy.show_config()\n", + "#numpy.test()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Also, below we check whether and how much speedup one may expect by using different number of cores:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import os\n", + "import multiprocessing\n", + "import timeit\n", + "\n", + "num_cores = multiprocessing.cpu_count()\n", + "N = 1000\n", + "x = numpy.random.random((N,N))\n", + "\n", + "for i in xrange(0, num_cores):\n", + " # first, set the number of threads OpenBLAS\n", + " # should use, the below line is equivalent\n", + " # to typing export OMP_NUM_THREADS=i+1 in bash shell\n", + " print 'Running matrix-matrix product on %i core(s)' % i\n", + " os.environ['OMP_NUM_THREADS'] = str(i+1)\n", + " %%timeit numpy.dot(x,x.T)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test whether you can plot and display the figures using pyplot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# Remove the below line if not running this code in an ipython notebook\n", + "# It's a special command allowing the notebook to display plots inline\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "x = numpy.linspace(0.0, 2*numpy.pi, 100)\n", + "y1 = numpy.sin(x)\n", + "y2 = numpy.cos(x)\n", + "\n", + "plt.plot(x, y1, lw=2, label=r'$\\sin(x)$')\n", + "plt.plot(x, y2, lw=2, label=r'$\\cos(x)$')\n", + "plt.xlabel('x')\n", + "plt.ylabel('y')\n", + "plt.legend()\n", + "plt.xlim(0.0, 2*numpy.pi)\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exercises\n", + "\n", + "Today exercises are meant to get you familiar with ipython notebooks (if you haven't used them so far), data organisation and how to access it. Next week onwars, we will follow with the material covered in lectures.\n", + "\n", + "## Data providers\n", + "\n", + "Open (in the browser) `mlp.dataset` module (go to `Home` tab and navigate to mlp package, then click on the link `dataset.py`). Have a look thourgh the code and comments, then follow to exercises.\n", + "\n", + "General note: you can load the mlp code into your favourite python IDE but it is totally OK if you work (modify & save) the code directly in the browser by opening/modyfing the necessary modules in the tabs.\n", + "\n", + "### Exercise 1 \n", + "\n", + "Using MNISTDataProvider, write a code that iterates over the first 5 minibatches of size 100 data-points. Print MNIST digits in 10x10 images grid plot. Images are returned from the provider as tuples of numpy arrays `(features, targets)`. The `features` matrix has shape BxD while the `targets` vector is of size B, where B is the size of a mini-batch and D is dimensionality of the features. By deafult, each data-point (image) is stored in a 784 dimensional vector of pixel intensities normalised to [0,1] range from an inital integer values [0-255]. However, the original spatial domain is two dimensional, so before plotting you need to convert it into 2D matrix (MNIST images have the same number of pixels for height and width).\n", + "\n", + "Tip: Useful functions for this exercise are: imshow, subplot, gridspec" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.gridspec as gridspec\n", + "import matplotlib.cm as cm\n", + "from mlp.dataset import MNISTDataProvider\n", + "\n", + "def show_mnist_image(img):\n", + " fig = plt.figure()\n", + " gs = gridspec.GridSpec(1, 1)\n", + " ax1 = fig.add_subplot(gs[0,0])\n", + " ax1.imshow(img, cmap=cm.Greys_r)\n", + " plt.show()\n", + "\n", + "def show_mnist_images(batch):\n", + " feats, tar = batch\n", + " fig = plt.figure()\n", + " fif, axarr = plt.subplots(10, 10)\n", + " for i in xrange(0,10):\n", + " for j in xrange(0,10):\n", + " k = i*10 + j\n", + " axarr[i,j].imshow(feats[k].reshape(28,28), cmap=cm.Greys_r)\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false, + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAEACAYAAACAi9xRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAEACAYAAACAi9xRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n1TP7f52W/XF3cxoRAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAEACAYAAACAi9xRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nMNMcs2aaaaZZAzPNMWummWaaNTD7f1dglqpCKsRxAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAEACAYAAACAi9xRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzsnXl8TFf/xz83iSSyEFmJIGqNNcRSxJbGTrVVO1VEN0VV\nbW2l1FKkHpR6KtRSsS99tBRFUEtrXytaDRIREUT2ZZb7+f1xZ0aW2ZLcyRPPb76v1/eVzMyZO+97\n7rnfe+45534/AklYzWpWs5rVyo/Z/LcBrGY1q1nNagXNGpitZjWrWa2cmTUwW81qVrNaOTNrYLaa\n1axmtXJm1sBsNatZzWrlzKyB2WpWs5rVypmVODALgtBTEITrgiDcFARhupxQLyJHeWKxclg5rBwv\nHkcBI1lsB+AA4C6A6gDsAJwH0KIk2yqNlxeO8sRi5bByWDlePI7CXtIec1sAf5J8QFIFYDuAPiXc\nVmmsvHCUJxYrh5XDyvHicRSwkgZmPwD3871O0LxX1lZeOMoTi5XDymHlePE4CphdCb9HABAE4R6A\ndACuAJwBvCcP1gvHoWUZLghCBwBqDcsRK4eVw8ph5SiulTQwJwCoAWmnugAYC8A+fwFBEGRNwkFS\nKMccWhY7AF1IpgiCMNWSLOWFwwiLlcPKYeUwn6NIoZIMmDsCuAcgHoAPpAHzloXKUE4vzxz5WJQA\nGgOoYGmWsuSIi4tjaGgobWxsintsyqw+rBxWjheZo7CbHGMWBGGdIAiPBEG4nu9tJwApkMZiEiH1\nWtub2hYA2NraolOnTpg0aRIyMjKQk5ODYcOGwdPTs0w5CluFChXg5eWFoUOH4quvvsKIESPw8ccf\nIzAw0CSHIAjuAH7WvLwGIANAIslLxWFo0aIF/vjjD4SHhyMqKgr29vYGy1qSQ2v29vZYsGABatSo\ngcqVK8PJyckQi0U5zLX/ZQ4bGxs0adIEw4cPR2BgIPr3748ePXqgbt26sLHRfxqXdX24uLjg7bff\nxsiRIyEIzzuFcnIEBASgQYMGBV7Xq1cPYWFhCAsLQ0BAQIHfzm/lpX2YZWb0jjsCaAHger73VgD4\nCIC35m8kgIsAQk1dZerUqcPExEQOGDCAzZs35zvvvMNPP/2UM2fONHWlkZUjv3fp0oUHDhzgpEmT\nmJWVRbVazfDwcB45coTvvvuuLBymWGrXrs24uDiKosjw8HAmJyfTzc1N9vooTg+gVq1aTE1NZV5e\nHv38/Az2mC3FUbFiRXbo0IG1a9dmaGgo7ezsTDFbtD6K4bJzNG3alPfu3WNeXh7Dw8OZkZHBlJQU\nxsbG8pVXXinz+nBzc2NgYCD79OlDAGzSpAnHjBnDI0eO8PPPP6e7u7vsHC1btuTt27d5+vRpDh48\nmIcPH2ZsbCxnzJhBtVpNURR548YNVqlSpUzro127dly9ejXHjRvH8+fP8/jx43R0dDRY3pwes8kC\nGjD/QjsUC8BD878ngH8AzAQw09TO1K1bl7m5uaxTpw4B0MXFhV9++SX/+OMPOjk5Gd0ZOTkEQaCD\ngwMbNmzImJgYqtVqHjx4kImJiTxz5gw/+OADfvLJJ6xRo4YsHMZYnJ2duWzZMoqiyKysLEZHR/Pp\n06fGGphFOPJ7xYoVuXHjRioUCgYFBZkqLwuHjY0Na9asySZNmnDUqFE8fvw4c3JyeOzYMZJkzZo1\nWbVqVdra2lqMQxAE+vj4sHr16qxTpw79/f0ZGBjIli1bsk6dOmzYsCFbtmzJli1b0tPT06L1ofWq\nVasyOjqaycnJnD59Onv16sUxY8ZwzJgx3LVrFzdv3sxDhw6xdu3aFuUAQCcnJy5fvpyPHz/moUOH\nePbsWQYFBfH48eMcN24clyxZwvT0dM6ePVtWDjc3N/773/+mWq2mWq3m0aNHqVarmZubyz179lCp\nVOrOH21ssfRxqVatGr/88ksmJiby4cOHjIqK4uXLl5mVlcWPP/7Y6Llb6sAMYB2AxwBy872XB+AB\ngCsALgPIAnACwKumdsbOzo5Tp06ls7Oz7kSIiIhgbm4ug4ODjZ38snHY2tryzTff5ObNm5mens6n\nT5/ywoULnDRpEtu0aUMHBwfZOYzVSatWrZiVlcUHDx5w1qxZVKlUzMvL46RJk8qUQ+vOzs6MiIhg\nZmYmV6xYYbSsxkvFUalSJY4YMYKRkZGMiYlheno6FQoFHzx4wPj4eJ1PmjSJt2/fZqNGjSzCMXbs\nWH733Xc8c+YMr1y5wrt37zIjI0N30iuVSiYnJ1MURYqiyKVLl1qEQ5+LosirV68WCb52dnYMDQ1l\nSkoKe/ToYXGOH3/8kefPn+fYsWM5c+ZM5uTk8I033qCHhwcBqeN19+7dwnVTao6GDRvy9u3bVKvV\nzMjI4Llz5zh9+nQOGzaMmzdvpkKhoCiKzM3N5YQJEyx+XDw9Pblv3z6mpKRw4MCBbNOmDWvWrEk7\nOzv+/PPPjIiIKNacTEkCc0cAvQvtUC6AeQCuanZKDeDL4pz8Wq9UqRJ//vlnqtVqtmnTxlhZ2Tj8\n/Px4+fJlqtVqLlmyhK6urtTMvJrjJeIwVifdu3fXnXiVK1dmbGwsRVFkWloaW7RoUWYcWv/ss8+o\nVCp5/vx5enl5mVMnpeIYOHAgC9uZM2fo4uJCQRDo5ubGuXPnUqlUkiTbt29vEY6srCxd0DXmDx8+\nNBWYZT8uw4YNY25uLq9du8YGDRoU+Gzo0KG8c+cOGzZsaHGO9PR0XRBu1aoVhw0bVuDz6dOn88GD\nBxbh8PPzY6NGjVirVi3d+XrkyBEqlUrdUIa2R71+/Xr6+vparD5atmzJP//8k9WrVy/w/pAhQ5iX\nl8djx47p6qmwmxOYTS6XI3lSEITgQm9nA1CQbC4IgheA30mGm9qW1mrVqoWxY8eiXbt2cHFxQbNm\nzXDr1i2cO3euTDgUCgXu3LmDpk2bwtXVFbVq1UJMTAzUarVJdkvUx+3bt5GUlIRGjRphxIgR+OCD\nD7B9+3ZUqlQJY8eOxYQJE7QNxKIcAODv74+xY8fC1tYWt27dwtixY9GjRw+sXbsW+/btQ1pamr6v\npZeG4/79+5g9ezbatm2L27dvY82aNYiLi0NmZia8vb0xf/58jB49Gra2tgCAtWvXolGjRrJzDBo0\nCB4eHnB1dUX16tVx8eJFqFQqJCcnIzs7W1cuNDQUERERhjZTag59tmXLFvj5+WHQoEG4ceMGDh48\niB9++AEPHz7EV199hQ0bNuDWrVsW5ejQoQM+/vhjPH36FPXr10dGRga2bNkCQJrUHzhwIDp27IiJ\nEydahCMhIaHA68aNG6NevXqwsbFBRkYGTp06hdTUVLz66quoWbMmmjZtisTERNk5AKkNXLhwQbd9\ne3t7BAYGom3btqhQoQJq166NKlWq4OnTp+ZsrqiZ1a0GglHwSnMWwBMAMQAuAFhdnKvu+fPneevW\nLcbExOh6ITdu3Cg8YVDkKiMXhyAI9PLy4rRp03jy5En+888/nD59Ol1cXEz2DkvKYaxObGxsOGjQ\nIIqiyJSUFCYlJenqZe7cuXp785bgqFChAk+cOEGVSlWg9yGKIjMzM/nVV18ZqpdScWzdupUkqVAo\nuHfvXi5btkznx44doyiKzG8JCQkW4XBwcKCHh4exMWwC4M2bNymKIiMiIizCYchtbW3p6+vLyZMn\nU6lUMiMjg4mJibx37x6rVatmcY5p06bx7NmzBMCQkBAGBATo2s3atWuZnp7Ohw8f6rujsUh92Nvb\nMzIykiEhIWzSpAnd3Nzo5OTESZMmkSTXrFljMY6QkBA+evSIP/zwAxcuXMgTJ04wLi6Of/zxB0VR\n5NGjRw3GM7NiromAXANAMqR1fgSQCmA0gCAATwHkQLrq7DG3Ul966SVmZWVRpVIxNTWVR44cYVRU\nFFUqFRcuXGjspJCVI39jDwsL4/Xr1zlv3jxWrFjRaPmScpjD8sEHH+iCkCiKnDFjRply9OvXj2q1\nmkqlkjExMVy3bh3nzZvH+fPn68bjDXy3VBydOnXigwcPqFarCwTgzMxMpqen88yZM1ywYAHPnTtH\nknzy5ImhCR6LHJf8XqlSJaampjItLY1NmjSxSH3kdzs7O9atW5crV67k+fPnGRISopusVqvVzMnJ\nYe/evQ1xKPLx7ABQF8AxSMvC8gA8BOBmbn0MGTKEjx49YuXKldmoUSP27duXJ06cYEpKCtPS0vj3\n33/zvffe09eRkJXDHBdFkY8ePbIYh6enJzdu3Mhz587xl19+4axZs1inTh327t2boihy06ZNtLe3\n18smR2D2AdAE0mzmnwD+BtAcmmUmmjLhAJ6Z2plKlSoRkHqrgwcP5tSpU9mrVy86ODjQzc2Nu3fv\n5q1bt+jv72+osmXhMOQtWrTgL7/8wu3bt7NWrVrGypaIwxRLgwYN+PvvvxcYy7x48SK7detWJhx2\ndnbcsGED1Wo109PTOW7cuAKfN2rUiPfu3dM38085OPz8/Dh58mTu2LFD5wMHDmTfvn11DTw4OFgX\ntEeMGGERDlOuPfGOHz9Ob29vQ+Vk4xg/fjzj4uJ45coVLlq0iG3atGGbNm04e/Zsfv3110xOTuZ/\n/vMfQxzdAVwH4FKYBYAvpIv7cnM4KlasyIiICCqVSh44cEA3D5KamsqDBw9y9OjR9PPzsziHOd6i\nRQtGR0frayMW55gwYQJFUeSaNWsMLu8sdWDOB+av2aFdkAbQ7+H5MpMZADKN7Yy7uzsvXLhgdIdC\nQkKoUql06yL17UxpOUy5m5sbs7Ky+OWXXxqdUS0JhzEWBwcH7t69m6IoMi8vj4sXL2Zubi5FUWRi\nYiLr1q1rcQ7tbPqZM2fYrFmzIvvfqFEj3r17l+PHjzcUiGSrD0OePzB//vnnZc5RrVo1njhxgqIo\ncs6cOcbKysIxfvx4qtVq3rx5U+9wliAIvHr1Kv/++2+jHJpt7wIwFJolYgAmANgH4B9THCNGjGBa\nWppuiEupVDIxMZGfffaZuRPnsnAA0kSnj4+Pwd9yd3fnjRs3SOodypCNQ587OTkxKiqKoijyo48+\nMliu1IEZRYcy1AA+0PxVQJrVTAeQbWxn3NzceOnSJY4YMYIVKlTQCysIAkVR5Jtvvmloh0rN0blz\nZ6PjyB4eHrx69SqvX79eZP1yaTkMHWAbGxuOHz+eqampVCqVXLFiBW1sbDh9+nSqVCqq1Wru37/f\n4hzawPyvf/2Lrq6uBT7z9PTkggULePXqVUNLCfMAiJr/f9QwJGn40jVcPUsbmJs0acLU1FSS5OrV\nq/Ut4rcoR/369Xnv3j2qVCq+//77xsqWmiMwMJB37tzhzZs32axZM72/07BhQ8bFxRm6SOXnUEFa\nCrZN81rLcQNAljEOf39/3rx5k8nJyTxy5AhFUeQnn3xi9AEKS3DUqFGD586dY1xcHNu1a1fkN+zt\n7dm8eXP+9NNPzMnJ4aNHj9i9e3fZOYx5QEAAHz16RIVCYWxJpyyBWTuU4QLgEqQ1f80hnfgf5yuX\nbmxnBEFg9+7dmZaWxsWLF+s9ucPCwpiVlcW2bdsa2qFSc0ycOJETJ05kgwYNGBoaylatWjEoKIif\nf/45v/nmG167do15eXm8du0aa9asKSuHoQPcs2dP3TKtK1eu8JVXXuHcuXN1y/lOnTpl6BZRVg4f\nHx+eOXOGGRkZ/Pbbbzlq1Ci2a9eOH330EW/cuMH79+/rWyer9daQJk+GQLpFzATwhZalOBzG3M7O\njtHR0STJzZs363vAw6IcHTp0oEql4sWLF3VDc5aqj6ZNm/LQoUMcPny43t/48MMPefv2be7Zs8fY\nEEKpzxkvLy9u2bKFq1atoru7O3NychgYGFis4yYHR7Vq1bhjxw4ePXq0yDxUcHAwt2zZwvj4eF1n\npnv37vrmq0rNYcx79epFtVrN1NRUgx1QyBGYNVAVABwCMBnPb81SAIRrPveCGd1/Gxsbjh49mgkJ\nCUxKSuInn3zCLl26MCgoiMuWLWNeXh5Pnz5dZF1gPi81R2RkJO/du8fMzEzdAVSr1bqJyLt37/LY\nsWOmGl6JOAwd4Dlz5hRZJ6tWq/no0SPu3bvX2NpuWTkA6eKYkJDAvLw85uTkMDk5mX/99Re///57\nU3VyCMBkzbZ3QZpEWQRgSkk4jPmOHTt0E6TvvPNOmXFUrlyZjx49oiiK+tYLy87x5ptvMjs7m++8\n8w6rV6/OqlWrskaNGgwODmZ0dDTT09O5adMmVq1aVfa2Wng7b7/9Nk+ePMkePXpw2bJlnDRpUnHW\n/cvC0bJlS96/f58xMTHs2rUr+/Xrx9WrV/Px48e64ZWkpCRu2bLFWJ3IUh+GPD4+nqIo8p9//jFa\nrtSBGYAA4AcASyGNz8RByldaomVqtra2bNWqFceOHct58+YxLS2NGRkZ3L59OxcsWMDGjRsb26FS\nc7i6urJWrVp88803OWXKFM6cOZPDhg3jlClT2Lt3b9aoUcOcVRkl4jBUJ/Xq1eOGDRv4888/8/Ll\ny9y+fTuHDh3KDh06GJzVtQQHIN3Z1KtXj2+99RYHDx7M5s2bG7tQ5velmu1qWb4DcADAHQCPANwC\n4C5HYO7RowdzcnIMBWaLcbRp04bR0dHMzc01NkEtG0eVKlW4detWZmZm8sqVK1y1ahVv3LjBzMxM\nRkVF8e233zYnd4hs526XLl34xx9/cP/+/dywYYPRHqElONzc3DhhwgQqFArm5OTw0KFDVKvVzMrK\n4s6dO/n111/z5ZdfNvXUrmz1Udh9fX25f/9+iqJobMKegDyBORjSGMw1SGMydwD0hLTM5LDm/VgA\n20uyM4IgFOfKazGOYnqJOMxhKWYvxGIcJfArkJ6eygIwB4A7gOMajl8BLAQQJQeHt7c34+LimJ6e\nzn79+pUZR2RkJMPDw3n37l2jOV3k5KhYsSLnzJnDpKQkhoeH89ixY1yyZIk5nQeLnDOurq4MDw/n\nxo0bixuYZeNYvny5LsnY2rVr9T3dV2b1kd9bt26tSz5mokNV+sCsgdJ1/w187gvgrzI4+V9oDguw\nlBeOMj82DRo0YK1atfStnLEIR1BQEO/cucPw8HDu2rXLVK/shW+rVo7ic/j7+7Nv375GkxdpvdSB\nGfmGMgq97w3panMd0vjZjTKo1HLNofnbE1Je6HQA0y3MUl44yv2xKS1HUFAQr1+/zmnTpumb6f9/\nVx9WjtK5HIFZO5Shzb50GUAvAJshLT25DekKdAWFJL8tUKnlmWMTpFshBaQniWpCjwz6/yhHeT82\nVg4rR7niMCcwG01iRPIU9ChpC4KQBaAyyb6a159Akvy+nO+7pnWtSmnlhQPAAUEQOgGYlo9FK4Ne\nlizlhaPcHBsrh5XjReAobCUVY/UDcF+POvU8mbheNA4tSydBEK7hv6u2a+Wwclg5XjyOAlbSwMx8\nf7tAega9S/4CZaQsW1448rN0oaS2O8SSLOWFwwiLlcPKYeUwn6OAmRRjNWAJkB7XBqQJwhoA7ms/\nFAShZwm3a9AEQbis8fzbLi8cWhY7DQfyswiC0LOQiOz/DEc+lheOQ8tizrZtbGxQuXJlTJ061aD4\naVlwFMesHOWaQx/LczNnIFrPpKAjpMQscZAeb8wGsFDzmQOAuzBjELxOnTrs2rUrO3fuzK1bt1IU\nRYMPmViKw97enh07djRnsb7RgXs8l0G/DmkCLg5Ay3wc1Y1tt2LFihw8eDCPHz/OkSNHMjg42Oi6\nZktxFHYHBweuXr2akyZN0ptMycSxKTaHnZ0dW7ZsaZCncuXKBteuFoejOG2kW7du3L17N8PDwymK\nIv/8809dLuKy5Ciuy8nh6enJiRMncvDgwbo86p999hlPnDhRRMXk/0N9FMc9PDxYo0YNnaKJOTHW\nZI9ZEIR1hWW/AThBepTRB0B9AN8C6CYIQiiAtpBSHho1d3d3rFu3Dtu3b0fHjh0xePBgAEDr1q0x\nfPjwMuNo27Yttm3bhnXr1sHNzc1Ucb0cwnMZ9ERITxVVhHQVdtdykHxgaJuOjo7o0aMH1q9fj44d\nO6J27dr417/+BScnpzLl0Gf169dHWFgYAGgbsj4W2TiqV6+OKVOmGOQJCAhASEiIHByAGW2kVatW\n2LZtG1577bUCDL169TL4HUtwAEBgYCAiIiLw9ttv49NPP8W8efMwZ84ctGjRAuvXr0dYWBgCAgIs\nwtGvXz8sXLgQDRo0QIMGDQBIqiUdO3bE0qVL0bBhwzKvj+KanByurq5YuXIl/P39jf6mq6srIiIi\nMHjwYHz00Udms5ozxrweUs7SH/K9NwfADySXCYLwEYDakJ49bw3pinO/yFbyWUBAAJYtW4bg4GDk\n5uaiWrVq+P3339G8eXOMHDkST58+RXR0NB4+fJj/ayGQHpmsLQeHt7c3tm/fDrVaDR8fH4wYMQIP\nHjzADz/8gCpVqqBp06Y4dOgQEhISoFKpzOHYT7JbPo4kc+vD0dERQ4YMgb29PZ4+fYouXbrAyckJ\ngmB0KEp2jsLm5uaGFStWQBAE2NjY4MEDgzFdNo6mTZvi2bNnej8TBAHDhg1DVFSUHBxHoJk8NrQx\nQApIDg4OuHHjBvLy8jB//nx89tln6N27N9asWYOMjIwy4QCAr7/+GoGBgbh27Rq6dOmiu1C+/PLL\nUCgUcHFxgaenp0U4AgICQBLt27fHw4cPkZKSAn9/fzx58gReXl544403sGDBAkPosteHjY0NNmzY\ngOHDh2PAgAFo3rw5jh49itjY2MJxwyIcrVq1wvjx43H79m0sX75c749VrFgRn332GeLi4nD//n2c\nPXsWACAIQgyAiwAmkkzR+2Uzhy78UVT22w9Sj9VT8/oEgFch5Tj9N/R06StWrMiBAwfyt99+KyCd\n5ObmRhcXF4aHhzMzM5OJiYn6sswJAJYhX5LxknLUqlVLlzc1LS2NERERzMnJoVqt5pMnT5ienk61\nWs3ExESOHj1aFg4aWQ9pb2/PHTt28P79+5w5cyZVKhVnzZplMCe0pTgKe48ePZiZmUlRFDl06FBj\nZWXjCAsL4/Tp0/X+jp2dHX/99VdDMkrF4tB8brCNaL1BgwZ8/fXXdUnxX375ZYqiyISEBNavX7/M\nOLS/rR3yO336NMeOHcuxY8dy2LBh7N27Nxs3blz4cXHZOHr27Mnvv/+ew4cPZ1BQED08PFitWjV+\n9913FEWRq1atMtZeZa+POXPm8OnTp8zLy+PZs2f54Ycf8vvvv+exY8cMDrnJybF//36SNKbIzZUr\nVzI9PZ0nTpxgcHBw4XN3DvQ8lq9jMyMor4N+2e+HeC6Vo1OXhaTevE8faM2aNXnx4kWq1WpeunSJ\n169f57/+9S/d571792ZqaqqhwLwOkjyPWBoOFxcX/vnnn7qgHBYWRnt7e917oihSoVDw0qVLTExM\n5J07d2ThMBUQGzRowJdeeokrV66kKIrG0p9alCO/z5w5U1cfJsrKxhEWFsYpU6bo/Z1evXrxwIED\ndHNzKzWHqbZqyP38/JiRkWEqMFuEY+DAgczIyODt27eNyVpZhMPGxkan5de+fXt+//33/Ouvv3Tn\nzM2bN40p/8haHy1btqQoiszKymJOTo5uTkIQBK5bt45Hjx61KMeMGTNIkklJSQbrPjg4mMnJySSL\nJtvSbNtgygRzA3NH6Jf91pvDFM8n5ArA+Pr66hJtZ2RkEECRJDTawLxr1y59Wc06Qrp6qUvDMXTo\nUIqiyLi4ONapU4cjR45kQkIClUolT5w4waioKAYFBdHOzo7+/v76lAhKymF00s3R0ZHTpk1jTk4O\nY2JizJmMtAiH1mvVqsULFy4wLy/P6GScxmXjCAsL486dO4u8LwgCb968yYULF8rCYayNGHNtj/nG\njRvGcnbLzuHh4cGff/6ZWVlZJrOXWYJjwoQJVCqVVCgUVCqVOpFerR87dsyY1Jas9TF79myKosjw\n8HA2bNhQl3fZ2dmZixcv5qVLl1ilShWLcQwdOpQkDUp6CYLAK1eukCTXrl1bhEWz7QkwoP1oVmDW\nbKSwuqzRHKaQHnUsALNy5UrdwTQky2OixxwD4I/ScLRp04ZxcXF88OABe/bsSUEQmJCQwJMnT3LF\nihX09vZmhQoVdKsh6tWrx/j4eLk4bhg5gThy5Ejm5eXphlPM6BFZhEPrWtXu5ORkcwKAbByvv/46\nY2Nji6xI6dq1K5VKJUNDQ2XjMNRWjbk2MO/evZvOzs5lxjFw4ECqVCpeu3atOJndZOPo16+fblir\nsO/atYutWrUytopINg5XV1fu2bOHN2/e1K1y0PqPP/5IlUrF7OxsQ0pFsnAcPnyYJA3KRwmCQIVC\nQZKGRINjABwEUL1EgRnSmr7fII29iJAe9QWkQXSthFEagPV6vqsDqVChgi7BuSiKbNq0qd4dmjx5\nMrOzsw0F5lJzfPbZZ1Sr1boMUIIgGJSqAaRk5UqlUhaOwiz53d7enrt27dLVD0mePXvWlCis7Bz5\nG9ZPP/1EtVrNtWvXmhMAZOOoU6cO79y5wwkTJtDT05Ourq709fXl6tWrmZKSYkrSSDYOV1fXIie3\nra0t586dS1EU+emnnxoLRLIfl1GjRlEURS5ZssSc46H1KxqOvwBMg5R7+CkkRZVsSBNbZqlCDxky\nhH/88QdjYmL4yy+/8KWXXtL7m9WrV2dQUJDFOLy8vHjixAmGhIQUeL9ly5ZUKBRMTk7mwIEDLVof\nFy5cYGZmJl9//fUiv+Hk5EStvffee3o5jMVcrZtalaHQQLtoXs8XBMERwE1Ijy7mQRor6WBsIw0b\nNkRgYKDRH/L09MTYsWPh6OiIBw8e4NGjR4WLlIpDEASMGjUKz549w5o1awAAJDFs2DDcunWrQFlb\nW1t4eHjgs88+w/Hjx2Xl0GeiKCIjIwMqlQqZmZk4fPgwBgwYgMjISPTv3x+5ubn6viY7h9Zat26N\nwMBAPH78GFu2bDHnK7JxxMfH44svvsDSpUsxYMAApKenw8/PDw0bNsTKlSsN1YVsHIIgYNCgQRg8\neDBEUcSdO3d0n1WsWFG3TM7FxQWdO3fGyy+/jHPnzuHYsWPak1gWjsKWlJQEpVKJ/v37Y86cOUhP\nTzfna36H51rYAAAgAElEQVSav84APgYQBmCVhiMHUhqDOQAmmdrQ7t27cfDgQdjb2yMrKwtZWVl6\ny2kZmzRpgo0bN8rOQRKiKOKtt94CAOTl5aFRo0YICwvD/fv3MWHCBBw6dMjQ12XjsLGxQfv27fHj\njz8WeH/IkCG6/8+fP29qM4bNnOiNoqq/sXiu+tsYgMLYVUYQBM6aNctoj7lFixYURZEqlYrvvvuu\n3qtMaTlGjx5tSOW5gA8aNIhpaWn85ZdfiogqlpTDVI/I3d2dAQEBrFatGgVB4O3bt6lWqw3KGFmK\nAwDHjRunk8gx1DMq5LJzODg4sFmzZvT392dQUBDv3btnToL6UnO4uLhw48aNem/Z9UmARUdHMzw8\nnCNGjLBofQiCwAsXLlAUxcIz/CbrQ7PtAiyQLhD/oARSSkbkzghIk7STJ0+2GMfQoUOpUCh00nCi\nKPLx48d0d3cvk/qYM2eOrlcsiiJTUlKYnZ3N7OxsPnv2jCT57NmzYj0sV+Q3ixGYb0Fag1oJQEa+\nzyYAUJramU2bNuka9N69ewt8VqtWLX744YcURVGf5HjhQFRijq1btzIxMZFdu3ZlpUqV6OLiwrp1\n67Ju3boMDAzkhAkTeO7cOaalpTEuLo4RERFFVgCUlMOcBq91FxcXjhw5kjk5OeYEZlk57O3tefPm\nzZIEZovVR5MmTXj16lVzFF5KzfH2229TqVTqJqnzB2KFQsH79+/z7t27Oo+Pj+fDhw8LP41okfr4\n7LPPShSY8VxK6SVoJrg0HHtQDPFROzs7/vjjj/zrr79Yr149vWW8vLwYHR3N+fPnW4wDkKSm2rZt\ny8GDB/PJkycMCwsrs/ro1asXz549S2Nm7GnIUgdmSGPMyZAeWSQkSZYxkJaVaMfM0gFkm9qZ1q1b\n85tvvqFKpaJCoeCvv/7KX3/9lYcPH+bVq1eZkZFBlUrFAQMGGNqhUnN07dqVSUlJfPToEX///Xee\nOnWKsbGxjI2NZUJCAhUKBXNzc7ljxw62bNnSkFJFiTjMOfE++OADrl+/nkePHmViYqLRHrOlOKZP\nn67rhRQjMOdp/qoA7NAwJOG5LLwaQM+SBuY33njD4Ay43Bw+Pj48deqUrkecPzBfvXqVQUFBuot5\n3bp12aBBAzZu3LjwRcMi9fHvf/+7uIE5D9KYKgGchpSvW8zHcQNAljkcgiDwww8/pEql4tOnT9mi\nRYsiZYYNG8aNGzcyNzeXsbGxFuHI73Z2dtywYQNjYmLMlZiSjaNq1aocPnw4p06dyp07d3Lnzp1M\nTEwkKfWijfXe5QjMPgACISWQng5Jir05pNnMWZoyZivLVqpUiZGRkVSpVEVuC+/du8fPP//cmCy8\nLBw9evTgzZs3+fjxY6akpDAhIYHHjx/nqlWr+PXXX5tzgEvEYaqh2dnZ8fz587pgoFKp+OzZM2PS\n9Bbh+Pnnn3XH5Pz58/Tx8TGnwZ+GpDzsomG5D0kV+uOScuT3uXPncvPmzWXG0aRJE/7666+8dOkS\nL126xCNHjrB79+4mtdwsWR/Vq1fn48ePqVAo2Lp1a3M5ZDt3bW1tuXjxYp26/ObNm7lo0SIuXryY\nixcvZlJSElUqlW5op0GDBhbhyO+tW7dmQkKC3qFPS9eHPtfa7t27TZUzGZhNTf4lA4gAcJPkIkEQ\nWkNaf3obQJCmzAgAv5jYDgAgPT0dn3/+OZ4+fYoHDx7go48+gq+vLyIiIrB//36cO3fO2Nc/loPj\n0KFD6NixIxo3bgwHBwfcuXMHDx48MDWpJDtHYRNFEYBUR9HR0Th48CCSk5ORkJBQphzXr19Hnz59\nkJGRgQkTJuibhNVn50guBQBBymtrD6AZpMdaS8RR2GJiYsqM48aNG+jRowcEQQBJCIKgOz5mmiwc\n7dq1g7e3NzIyMtC9e3d4eHjgyJEjuHbtmrkcsrURtVqN7du3o1mzZujevTuGDh2K48ePo0uXLroy\nx48fR5MmTRAfH4/k5GSLcOS3gIAA3L17Fz/88IPpwhbk0Jq2PgYMGFDSTTw3Ez3m/NJSf0K6JXsd\nkspvNqRb5kQA/iW5ygjFV8m2CEcxvUQc5rCURX1YgIN4LtfzJ4BHkCStYiHdOmYC2A7AvaTHpl27\ndub2iizKUdb1MXDgQN0kV3h4OK9fv27u0JJFz5n87UP7f/7XZcWxc+dOfvrpp//1+tB67969OXHi\nRJPlzOkxmyygAXOBpB33mua1J6TnvQ0+812MyjLLX3QOuVnKC8f/wrEpzxxhYWGMjIxkaGiosfmG\n/zf1kd8jIyP51Vdfmd2JKE/1UerAjP8H0uNlwWEBlvLC8cIfGyvHi8nh4+Nj8GG18lwfpQ7MkK4i\n5ULyu7xzaP72hHQ7lA5guoVZygtHuT82Vg4rR3nikCMw5x9jLpbkt5z+AnBsgqR+oABwDNKY4nlL\nsZQXjhfk2Fg5rBzlhsNcN7oqg+Qp6NEFFMyQ/JbTyjsHgAOCIHSClBtBy7LdUizlhcMYS3k5NlYO\nK0d54jDXSqqS7QfgviAI9yDdLrtCev58nkxcLxqHlqU8yKBbOawcVo4Xj6OAlVQlm/n+dgEwE9Lj\njAB0KsiU2fUpy5YXjvwsXUi2APB5IY7r/6McfFE5LNxGrBxWDmMcRlWyS9pjToD0uDYgTRDml6Z3\ngJSQWlbTVFp55dCyFJFBz8cRrCnzQnH4+/vj4sWLWL58ORISErBu3TpzWcq0PorLAfxX2qqVw8ph\n7NwtUMjUoPk6SIvk82v+VYOUJk8BTU4GAAs1n3WCCZmcbt26cfz48cakefS57Bym3NbWloJQZI2k\nPg53AEc1n2dAeuY+DkBLLYemXJHfqFu3Lnv27MlGjRoxLCyMYWFhbNGiBdu1a6fvty3Goc/d3d15\n7tw5iqLI9957z2C2LEtxVKhQgc7Ozqa0D0vEIVcb+W9wtGjRgmFhYaxdu3a5qQ97e3u6u7vzrbfe\nYlhYGL28vMqEQxAEjh49miqVirGxsdywYYMh9ZJy0z7MmfwzZyhjPaTlJPntU0hLT2IhBcMbALoJ\nghAKEwq3tra2+Ne//oUqVaoUkFo3w7Sq0LZycBgzZ2dnBAYG4vfff8fgwYPN4ZgDSQZ9KKQnu6rj\nuQy6UY6wsDBs3boVr732GhYtWoT58+ejW7du6Nmzp7kq2bJw6LMePXogKCgI9+7dw+7du4vkrc5n\nsnHY2tpi+PDh6NOnD/bu3YtTp05h8ODB+O677zBjxgxUqlTJWL0UhwOmWEphFuNwdHRE3759ERkZ\niZYtW/7XOArbq6++ikGDBmHt2rX62CzCYWdnh7lz56Jq1arYtm0bdu/ejdDQUAwZMgROTk76vlIu\n2ocgCDGCIEQJguBuqIzJwEzyJIDCevK9AXxKMgBAE0g7sguS7DcNbcvV1RUrV65E48aN0apVK6Sk\n6FfuNmC1IS1pqVZaDjs7OzRs2BCtWrWCo6MjXFxc0LBhQ4SGhuLw4cNITU3F0qVLkZWVhYoVK5rL\nsYnkNgBNIakirDTFAQDr16/HvXv30KBBA7z00kvw8fHBN998g0WLFpnKzyArR36ztbXFmjVrEBYW\nhp9//hmtWrXC48ePoVarDX1FNo4PPvgAkZGRmDJlClq3bg0HBwf07NkTISEhmDlzJr777jt88cUX\ncHfX26aLwwFTLKUwi3FERESga9euePLkCa5evVrmHF5eXjh69CgaNWpU4P2GDRvi6tWr6NChA0aO\nHAkfHx+LcgBAq1atMGbMGFSsWBHvvPMOpk2bhoEDB6Jz586oV6+evq/IxuHi4oKOHTti2rRpSE5O\nxoULF3Do0CEolUo8efIEs2bNwksvvQQbG70hthGkzuQ3BnfOnG418iWY1rxOhyT57ZTvtVae3qDC\nbadOnZidnU1RFJmYmMiVK1dy4cKFnD17tk7Kx9Btq+Z32gDIKy1Hs2bN+M8//zA9PZ179+7lTz/9\nxAcPHlCtVjO/qdVqXr58WRYOY7fuL7/8MnNzcwtn5DJ5OyQ3h9bfeecdJiUl8fLly+aqMcvC4eLi\nolNRT0xM5IgRI+jt7U1vb2/WrFmTffv25bJly5iWlsbTp0+zVatWJebQvC7SRtzc3Ni7d2+Ghoay\nefPmDA4OZu/evTlgwIAC3q1bN86bN4/Lly/XlwKz1ByGfMWKFRRFkfv27ZP1uJjD4erqygsXLvDJ\nkycMCAjQW6Zbt248depUYT6L1MfSpUupUChYo0YN3XuOjo48ffo0T506pS9trywctWrV4q5du3jx\n4kWeO3eOO3bs4Mcff8xZs2Zx8eLFnDt3LmNjY5mSksLu3bsbOndLrZK9DsBjFBQxNCZPr1dZtkmT\nJnz69KlRNYicnBx++eWXhlJNroN0u6EuDYeTkxOvX79OY3bnzh3OmTOHw4cP1ynwysBhUJ26Ro0a\nTElJ4cGDB8052SzGoXWt/qBWG9EMl4Xju+++oyiKfPjwodHx9ZCQED58+JAHDx4sfHzM5tDXRrp1\n68bc3Fyq1WqqVCoqlUq9itDatKza98eNG1fi+jDWVgu7vb09N2/eTLVabW5ieFk5ZsyYwcTERPbv\n31+v2Olrr71GtVrN1NTUwsmWZK8PV1dXxsfHF1FNd3Fx4dWrV3n06FGL1cfJkyeZmprKfv366W2n\nYWFhTE1NpSiK/O2334p8rtl26VSyIV01eqOouqzBHKbQoyw7dOhQXUNWq9XMzc3VeV5enu6vWq3m\nokWL9PWc7wG4WFoOGxsb7t27V9c7jouL461btxgdHc1ly5axc+fOplSIS8phUJ3a1taWq1evZnp6\nOmNiYnQeHh7OihUrlhmHIAg8duwY1Wo1N27cqO+iZMhLzWFra8tvv/2WCoWC4eHhJn+za9eunDJl\nSuHcxMXiKNxGZs2axfDwcEZHR5slLSWKIo8cOcLAwMBS1YehtlrYq1WrpsvZHRERIftxMcXx4Ycf\nUq1WFxAvrlq1Kvv27cvjx49TqVTy8OHD7Nmzp8XrY+vWrUxISCiS2Kl69er866+/OGvWLIvUh7Oz\nM9esWUOVSsXvvvuOERERbNiwIWfOnMmmTZvy3XffZWRkpG7SfNSoUfo4SqeSnQ8uuNAOnQXwH83/\nkwF8o+c7BWB8fHx4+PBhPnv2jEeOHGGLFi2KeGhoKO/evctnz56xV69eBb4vFwcg3Yps2LCBJJmV\nlcUFCxbQw8PDrEToJeUwxKL1Ll26MCoqisuWLeOoUaP41VdfMT09nW+99VaZcbRs2ZJ5eXkURZH9\n+/dntWrV+PLLL9PHx4d2dnbG6qXUHM2bN2d8fDzv3btn1vCJg4MD161bx9TUVNk4tJp6oigyKSmJ\nFy5c0Pm+ffv48ccfc8yYMfz444915U6ePMmqVavKXh/6vEaNGrx+/bpOTcVUebk53n77barVarZq\n1Yre3t788MMPeeXKFaalpTE5OZkLFixgixYtisixyc3Rpk0bpqenc9WqVUXO2cGDBzM7O7uIVqdc\nHDY2NmzQoAF79OjBiIgIDh8+nPXr12f9+vXp6OhIR0dHVqhQgXv37qVSqdQ33EazYq6JgFxYWioV\nwGgAyyB1+0VIeUybmVOpXl5eRmVxBg0axMzMTGZnZ3PQoEGFP5eNA5CWYi1dupT37t1jXl4e33//\nfbq6uprT2EvEYc6JV9gvXbrE//znP3R0dLQ4h6OjI3/44YcCvUGSuv/PnDnDTp06GWItNceQIUOY\nnZ3Nffv2mXWBtLGx4dKlS5mVlSUrh1YyytCSK1dXV964cYOiKPKvv/4yVCcWaR8vvfQS//nnH4qi\nyFOnTpnThhT5eHbgee5htea9EwDczOWoU6cOs7Oz+fTpU2ZkZFCpVPLOnTtcunQpa9asWSYcNjY2\nnD9/PlUqFceMGVPk82+//ZZJSUmGzhlZ60OfC4LA8PBw5uXlcc+ePXrLyBGYfSCtdvCHlFxaK8ey\nBsBHkBZlHwRwq7RByN/fn0ePHqVarWZUVJS+q65FOIKDgxkREcGHDx/yiy++MDZ0UCqOktRJ//79\nef/+fUNBQlYOLy8vHjp0yGBgFkWRP/zwgyHWUnM4OTlxw4YNjI+P16snV9idnJw4ZMiQwhqRFj8u\nzZo1040xv/feexarD32uDcxqtZpTpkwxh7c7pKxpWomrzgBWaFjmQFo+ttwcjqCgIP7yyy+64chL\nly5xzpw5hnqmFuPw9/dnTEwMT58+XWRyr0mTJrx161ZhhW6LcBjyDh06MCsri4mJiQYn80sdmPOB\n+aOYcuzF2Rl3d3fGxcXpAsCFCxeK3DpbmmPq1KmMiooyuWi/pBwlCcwAmJGRUWDW2VIc7du3Z3p6\nuu4YzJgxg/369dP533//zStXrhjiLDWHra0td+3aRbVazSVLlpisl1atWjEpKYnVqlWTlcOYOzo6\nMioqiqIo8uzZs4V/2+Ic+QNzcVShNdsuwAJpVcA/MKFxV6FCBYaHh1OtVjM7O5vHjh2jKIoMCgoq\nTjsuNYfWAwMDmZOTw08++aTIZ9u2beOtW7fo7+9vcQ597unpyePHj1MURUNj3Lpzt1SBGdJQxm+Q\npNjzIK1nrqT5PwFSBqb7AFQl2Zl69epxypQputUaKpWKZ86c4cSJE/VN/lmMA5AuDqtWrWJSUhJf\nffVVY2VLxFHSwPzkyRO9gVlujsWLF1MURSYnJzM7O5ujR48mIM0NjB8/nrdu3eKuXbsMcZ6FdIuu\nBDAL0lNUszUs9zVlTKpCBwcH89atW1QoFPziiy9YvXp1vb/XtWtXXrlyhb/99hudnJxk5zDkbdq0\nYVJSEkVR5Pjx442VtQhH//79mZ6ezsePH7Nz587mMGs5YjVt5KV8beQ+pKEWo6rQ7dq145EjRzh6\n9GjWrFmTgiDw0KFDXL9+fXHacak5tP7aa68xNze3wLi+g4MDp0yZwoyMDHbr1q1MOPT5559/ToVC\nwT///NPQUAoBeQKzDyRxwoeQxsfUAL6AJMv+AM9nFzPM2RlnZ2fOmDGDNWvWZEBAAM+cOcPMzExd\nL+3s2bPG5HNk4zDkbdu2ZV5eHr/77jtjKzNKxKGP5fXXX2eHDh2MMqWmphoKzLJxAODly5cpiiKH\nDBnCN954g/7+/rSxseGnn35KpVLJq1ev6lt9oPXHGo4nAJIgBaQkSI/AFoujTZs2vHTpku4iHRIS\nQg8PD7q4uNDb25tfffUVHz58yKSkJL7yyisW49Dn2qVqSqWSHTt2NFbWIhxjxoyhSqXi3bt3zV3z\nngxpXFUBKRDt03BpOaoDSDfG0adPH54+fbrAdocMGcKYmBizzys5OLQeEhLCuLg43R21p6cnN2zY\nwOTkZM6aNcvUJLVsHIV95MiRzMrK0rtSpLCXOjBroHRyLHje/U8BEK753GzJbw8PD0ZHR+vWh2oD\ncmZmJv/8809juRgoB0f37t3p7e3NKlWq8KWXXqKvry9dXV1ZrVo1Nm/enEuXLtXdShtZKlYiDn11\n0qdPH72rLmxtbenl5cV58+YxOTmZnp6eFuUAwFGjRnH58uVcs2YNAfDLL7/k3r17ef78eV64cIF9\n+/Y1dmx0cj0alocAFgGYUlwOQMoFcfHiRSYnJ1OlUjE3N5dPnjyhWq1mWloaT5w4wa5du1qcI783\na9aMOTk5VKvVnDdvnqnyFuHo168f09LSihOYS33OeHl5cevWrZwwYQKrVKlCJycn9unTx9zJR9k4\ntB4YGMiMjAwuXLiQn376KR8/fszY2Fi+9tprZcqR34ODg3n//n2q1WquXLnSJEepAzPySUtBGp+J\ng5Sv9Cyk3kAMpAHz1ebsjJOTE1evXk1RFBkdHa3rnfbr18+chEal4hAEgbGxsdy4cSMPHz7MO3fu\n8NKlS5w7dy7Pnz/PJ0+e8MiRIyTJYcOGyc6hr06aNGnCyMhILlq0iOPGjePChQu5aNEiTpgwgSdP\nnmRubi6HDh1qaJWCbBwy+FLNdrUs3wE4AOAOpN7ILRRTndrV1ZUhISGcPXs2ly1bxq+++opfffUV\ng4OD9T7cYCkOQFoJsGjRIkZHRzM1NZWVK1cu8/oAno8x79y5U+8yLLnaSP5taNftxsXF8dChQ5w9\nezbj4uI4ffr04rQP2WKIn58f9+/fzyNHjjA+Pp4RERGsV69emXNovUKFCrx8+TLVajW3bdtm7K5S\n53IEZq0cyzUAWZqG1RNAXQCHNe/HAthu7s5oc5Jq/y/GwS01h62tLW1sbGhvb6/z/K+1/5vgKhGH\noTpxdHTkqFGj2L17d2ZmZlKtVvOdd97hxo0b2bx58zLjKKVfAXBVwzIHUs6S4xqOXyEtS7K4+rCl\nOF555RU+efKE4eHh3LRp03+Nw9nZmT/99BPDw8M5duzYMjlntN61a1feu3eP4eHhPHDgAH19fcv0\n3M3vJYwfsnMA4NixY6lWq6lWq81OqVDqwKyBKhfKsi86hwVYygvHC39sTG1Xu8Z65syZ5gbE/+n6\nsHJId1GjR49meHg4MzIyipO+oPSBGVaVbLM5NH+tKtnl8NiUlsPd3Z0tW7akj4+PuQ8h/U/Xh5VD\n6q3XqlWL1apVY7NmzYyuwijscgTmEivLWqBSyzOHWerU/6Mc5f3YWDmsHOWKw5zAbDGVbJJGs7zL\nYeWFA2aqU5cBS3nhKDfHxsph5XgROApbScVYC2f2T9C8V9ZWXjjKE4uVw8ph5XjxOApYScVYCQCC\nINyDNI7pCsAZwHvyYL1wHFqW4YIgdMB/VwbdymHlsHK8eBwFrKQ9Zq06NQF0AbAKwHLth2Uo+V1e\nOLQsdngug74az9V2ewqCcP1/lMOQLHy557BwG7FyWDmMcehjeW7mDETrmRTUZvaPh/TY9nk8V5Z1\nAHAXega9BUHgqFGj+Ndff7Ffv34cNmyYoceNzRowLylHadxEnSghJampoGXJx2FSOeRF5DBxbErE\n0bhxY7Zq1YrJycncv38//fz8ZOco6zZi5bByGOMo7CZ7zIIgrBME4ZEgCNfzve0E6VFGP0jLsmoA\naK/5rC2klIf6toUaNWqgXr16aNGiBaKionDjxg306dMHHTp0KDMOfebo6Ig6depg3LhxCAoKKhaH\nIKnd/qx5eQ1S0ppEkpe0HCQfmMtijpUFh52dHV599VW8+eabplhk4xg+fDh++OEH9O7dG56enujV\nqxdee+01NG7c2CRvMTkAM9pIhQoV8O233+LMmTMYM2YMzpw5g+3bt6Nz584W5XBwcED9+vXRrFkz\nvPLKK2jRogXCwsIQFham+79v377w8vIqs/qwsbGBg4MD+vXrhyVLlmDw4MFISEhAbGwscnNzERoa\nitq1a1ucw5h5e3ujcePGqFKlyn+VQ2sODg7o06cPPDw8ivU9c4Yy1kNa55ff5kBaE1gV0vP/PwEY\nLQhCKIxIfouiiBUrVmDevHmIjY2FKIpwdXVFUFAQ9uzZg1GjRhnjCIF++fFicxQ2X19fLFy4EAMG\nDMDq1avx448/YvTo0Wjfvr2+4oY49kPqBU7RMPkVlyO/OTk5wcfHB87OzujRowdCQ0MRGhoKPz/d\nvITFOVxdXbF8+XJs3LgRtra2xorKxjF16lS0aNFC95ok3NzcjF4sS8gBUyyApMT87rvv4uWXX4af\nnx9efvllDBw4EJs2bSqsBC0rh6urK7744gvs27cPO3bsQL9+/RAZGYnIyEjd/5s3b8aSJUvg6Oho\n8frw9PTEihUrMGbMGERFReGDDz5A3bp14eHhgZycHABA+/btDZ0zsh8XfSYIAnbv3o1+/foZumDJ\nzmFvbw9fX1+Dn3fs2BEBAQGoXLlyfs4YQRCiNBcGvWYyMJM8CSkTU37Tyn4nA4iCFCR2wQx5+rS0\nNISHh2Pbtm3w8PDQXWG9vLzQuXNnYwGgNgzLjxebQ2u+vr746aefMHHiRPTsKV1//Pz8MHLkSOzc\nuVNfQ7MIh4eHB3bs2IFBgwYhIiIC169fR3x8PDZu3IgVK1Zg8uTJqFevHpKSkizKkd/8/f3h4eGB\nrKwsQzLsWpON49GjR0hJSUFeXh527NiBlJQUhISEYO7cuahUqZIp5OJwwBQLIPV4oqOjMXnyZJw9\nexbTpk3D5cuXUbVqVbz11lsW42jevDm6dOmCChUqQKFQoFmzZjh58iTi4+PRpUsXAFLw9vX1hb29\nvcU4AOnidPz4cYwaNQodO3bE7NmzUa1aNcyfPx8VK1ZEkyZNMGHCBLRr1w737+uNY7Ifl8Lm4uKC\nTZs2oW3btnB2dsbff/9tcY6aNWti9+7dmDRpkt7zw9vbG5GRkXj33XcLXzwbQXr8+xuDGzdjPNmQ\nSvYDPF+snYVC8vQwc7zF2dmZ3377LUVR5DfffGOs7DoATwGIcnF4enoyOjqaKpWqgFKHQqFgZmYm\n8/Ly9AmDloiDRhaqV65cmXv37qUoikxLS2NUVBQnTpzI4cOHs3Xr1oUVhy3GUdhXrVpFlUrFTp06\nURCM5iWQjaNu3boMCQkhICWI0eaJVigUHDp0qClmszk0nxerreY/Xnv27OHt27cNJZgqNYenpydb\nt27NNm3a6NzNzY1z5swpoNo9ePBgi9aHra0tDx48yNTUVE6dOlVvSksfHx9euXKFCoXCUBIfix+X\nV199lSqVimlpacYUcGTj8PDw4NatW5mXl8eJEycWOT+8vb3522+/MSkpqcj5o9m2wZQJJM0KzPpU\nsnMBzIOUqOUK9MvTm1WhWn0sURT55ZdfGivbEcC/UVB+vMQcgiDw119/1TVwtVrNmJgYKpVKhoeH\n08bGhhs2bOCOHTvk4jA42dWxY0c+ffqUO3bsYJMmTUwFQYtx5PeAgABmZGRQpVKZw2IxDgC6YzRu\n3DjZOErSVvP7pEmTGBMTYyhvt8U41q5dq6uPmzdvmsp0V2qOevXq8Z9//ikgkuDq6srVq1dz5MiR\nXLt2LbOzsymKIqdNm/ZfOS6+vr48e/Ys1Wo19+3bRy8vL4tzdO7cmY8ePeKVK1f0yeBx1qxZVKlU\n3MXLiX0AACAASURBVLFjR5GLt2bbEwDsKXFg1myksLqs0RymMEOKfdy4cdy9ezcVCgWfPXvGefPm\nGcuBTEhp+f6Qi6NTp04FesmLFy9mxYoV+cEHH+hyD48dO5Zt27aVi+OGPg5nZ2fevHmT/fr1K25w\nkJWjsHfv3p2iKDIjI8McFotxAMUKzMXiMLetFvbatWvzzJkz3LdvX5lxeHt7c86cOUxKSqJSqeTh\nw4dNKe3IxqGVW6tVqxZ/++03/vzzz0xJSSlw/uTk5HDu3LllflwqVKigE2c1ovYjO8eqVav4+PFj\nhoaGFvmsX79+TE5OZmJiIgMCAgyduwcBVJc7MJcqh+lrr73GrKwsiqLIrKwsfvjhhyZ7iXJy+Pv7\n6xQ70tLSKIqiLsWmjY0NnZ2d6e3tzaSkJI4YMUIWDkMs7u7uTE9PZ9OmTYsVHOTmKOyrV6/W5Zg1\no7zFOIBiBWaLcmj9yy+/ZFxcHLt06WJxDk9PTy5atIinTp3SiUskJSWZUlCxSH3UrVu3QDDOy8vj\nf/7zH86YMYOnTp1iZmamobzqFjsu77zzDvPy8piSksL27dub6tzJwuHs7My///6bCxcuLPIblSpV\n4pUrV6hSqbh06VK9iipmxVwTAbkGJDmWwnLsQZDGa3IgyX8X6ZIbq8zhw4fz9u3bOkWIp0+fMiQk\nxFSlysbx6quvMisri4cPH2br1q3522+/cd26daxUqRIBSUPs/fff59OnT9mjRw9ZOIwF5oyMDHMT\nn1uMI79XrFiRR48eZXp6urk9edk4KleurEuE7+fnx0WLFul6ZK+//nqZcLi5udHDw4M1a9akn58f\nK1WqRFdXVzZu3Jj79u2jUqnk6tWrDY0vy1ofXbp0KdI7FUWRx48f56BBg1irVi1jckqKfDw7IOUe\nPgZpWVgepGxqbua2j8qVK3Pfvn08ceIEx48fz9atW+uGcpo3b864uDgeO3ZMH4+sHFr39vbm8ePH\nmZuba5aAr1wclSpV4sOHD3ngwAE2b96coaGh7NChA1u2bMmVK1dSrVbz999/NzQ3JEtg9gHQBEXl\n2FcA+EhTJhzAs+JWaoMGDThkyBB+/vnnPHbsGNPT0/nWW28ZC86ycezZs4c3b97UpXCsVq2aTr5J\nEAT279+fDx484KJFi/SdfCXiMMTi7OzMxMRELliwwJyGZTGO/N63b18+e/aMd+7cMalfpnHZONau\nXcuoqChOmzaNFy9e1AWi27dvlwlH48aNuXDhQh4/fpw3b97ktWvXuHfvXu7Zs0c3ByGKIidPnkx3\nd3eL14eLiwtXrlzJ1NTUIsE5MzOT58+fZ6NGjQxxdIeUztKlMAukyadkAMuL0z7s7Oz0pj6tW7cu\nb9++zW+//ZYODg4W5wDARYsWUalU8s8//zQkv2YRDkdHRz569IhqtZp5eXlUKpW6ZPmiKPLp06fG\n7qZKH5jzgfmjoBz7PTyXY58BILO4lZrfe/fuTZVKxdu3b7NOnToGd0YOjnbt2jEzM5MzZszQ+zuu\nrq5Uq9VUqVRs3bq1bBzG6qRTp07Mzc3VJy5q9ODKzaH1sWPHUqVSGRtD1ReISs3h6+vLhISEIgFI\nq9797rvvWpRDEATevHlT7+8Xdq3+4PXr1/nGG29YpD7ye9u2bTlr1izOmjWLS5cu5bNnz3QsFy5c\nMFofmm3vAjAU0jItD0iTT/tQAo07Q37y5EnGxcXpG5aTneP999+nQqGgWq3myJEjzZ0wl40jODiY\nu3btYlhYGNu2bcu2bdty48aNzMnJMZk0v9SBGUWHMtQAPtD8VUCa1UwHkF2ag+vg4KDTAhw4cKCh\ncrJwjBw5kgkJCUWW1Dg5OXHKlClMTk421LhKxWGsTipXrsx58+bxwYMHPHToEBctWmRKVsoiHNAE\np5MnTzIpKYnBwcHmHsM8SLluCeBHDYNWHTpdw9XTFEfLli1548YN3bi/vmB49OhRjhkzhsOGDWNY\nWBgDAgLyJykvFYcgCCRZ5Hezs7MZHx/Pu3fv6u25Pnz40CL1Ycjr1q3Lu3fv6n7/7t27po6LCtJS\nsG2a11qOGwCyTHEEBQXx5s2b3Llzp97fcXNz4/Dhw3nr1i3+8ssv+u56ZeEApDmg9u3bMzk5mUlJ\nSZwzZ47ZcUZOjsIeGBjI+/fv87fffmPVqlWNlpUjMGuHMlwAXIK05q85pBP/43zljEp+d+jQgUeO\nHOGBAwf4/fffc8mSJdy2bRv37dvHM2fO8Pz587x9+7apJXOl5oAmMMfHx7NZs2a697y9vblw4UKm\np6dTrVYzLCzM0DKoEnOYOsAODg4MDg7m9u3bqVaruXHjRlNS7BbhaNSoEbOzs80dOtB6a0iTJ0Mg\n3SJmAvhCy1Icjpo1a7J///6cP38+9+/fX2DNrvb/3Nxc5ubm6oJSvvH5UnEIgsADBw7ofuvatWuM\niopihw4dWL9+fdatW5etWrViaGgoJ06cyNGjRzM0NFTf/IBs9aHPmzZtqruzUCqVxpapyXLOjBo1\nSvdbJ06c4MyZMxkWFsawsDB+++23vHjxIvPy8qhWqxkUFGQxDkBaP3zw4EGq1WquWbOGTk5OxWmn\nsnHkd1tbW27ZsoUZGRl8//33TXKYE5hNJcp/JAhCCqQu/iYAHSCtP83W7CAEQfCC1HszaOfPn8fp\n06cxaNAgtGnTBlWqVIFSqYSNjQ0UCgWysrIQHx+Pn376CevXrze0mb9KywEAiYmJqF69Og4cOIAl\nS5ZgwIABaNiwIapUqYKMjAycOnUKa9euNbYJWTgAwM3NDZGRkfjnn39071WuXBl37tzBgQMHoFKp\nyoQjv02aNAmOjo64fv266cLPbR6AzSS3CYLwJqTUiU4AMovLER8fj/j4eOzdu1f3nre3N6ZOnYrQ\n0FBUqVIFHh4e+OWXX7Bv3z5s2rRJNg6S6NOnDypUqABbW1soFAqDx+DIEaOZIWWrjwoVKmDw4MGo\nWrUqfH19UaVKFTRv3hy+vr4giWvXrmHz5s2Gvi5LG9myZQtCQkLQv39/dOzY8f/YO+/wKKq2jd+T\nBiShGBJCgFACGKQ3IyDBUKRIFwtSpEiVJs0gTXgFXkC6iHSQIgpSRAUsFEVqQgtShQAJpJEQ0jZt\nZ+7vj9ldN8mWyWY2hPfLua7nSnb3zOxvzznzzJlTnhuBgYF58sTHx2Pw4MG4cOGC3TgEQcDcuXPR\nrl07REdH47vvvoNGo7F2mOocuVO3bt3QrVs3nDp1Cl9//XV+DzedrPSYDZp/KKDkt7e3N6tXr86O\nHTty+PDh7NChA4cMGcK33nqLDRo0UKKlphpHaGiooRem3/l3+/ZtdunSRYk0vU0cplgcHBzYvn17\nzpgxg8uXL2doaCh37dpl9VFIbQ69OTk5cfXq1UxNTeUbb7yRn57Ict159SxrARyGrEQcC+AmAA9b\ne4h68/X1NfSoGzduzGrVqj0TjsIsDy8vL+7Zs4e//vqrYYfqb7/9xrt373Ljxo1s06YNHRwc7HrN\nAPJKnXHjxnHDhg2Ga+fIkSO8d+8ep02bxjZt2liauFeF44033mBKSgp37txpacLT7j4kt40aNYoa\njcbihJ+xKekxW3PMes0/VSW/bTTVOHr37s309HRKksTZs2dz8eLFSicPbOZQUib5YLALh7OzM0eP\nHs2dO3daWgpmyi5D3j2VBjkwjAeAEzqOXwEsBLCjENrI/yRHiRIl2LhxYyYkJFCSJNavX19JB0LV\na8bY9HGF9f8XFsfgwYM5dOjQgtSLXcpj4cKF/PrrrxVzFNgx66D+56THnwWHHViKCsdzXzfFHMUc\nhclRYMcMo6GMXO8/19Lj9uDQ/e0MOS50MoBgO7MUFY4iXzfFHMUcRYlDDcesH8p45pLfRZxjO+RH\noSzIO4mqQlZCsCdLUeEo6nVTzFHMUaQ4lDhma6sy/oKJmM1CEZH8LiocAA4LgtAGwMdGLN89A5ai\nwlFk6qaYo5jjeeDInWxVya4CIFLIq049TyWu541Dz9JGEIQwPFu13WKOYo5ijuePI0ey1THT6G8Q\n5D3oQcYZdLO1qiUzd62iwmHMEkTyiSAIfe3JUlQ4LLAUcxRzFHMo58iRlGj+mUoPIW/XBuQJQl/k\nkvy28bxmk2Ba8ruocOhZnHQcMGYRZAn0fO3YKIoc06ZNw44dO1CuXDlTLM+0PGzh0LMUcxRzPAMO\nUyz/JiUD0SYmBfWR/R9A3t6oAbBQ95lZyW9HR0fWrl2b7dq1Y7169dirVy/269ePTZs25aBBg/I9\nYG4rhyXz9vbmwIED+frrr/PatWsURZFPnz41rOu1UibZkGd3w3RMTY04TCp2lC9fnj179mSvXr14\n+/ZtPnr0iMOHD2e/fv0sbRxQncOSCYLAZs2aMSoqinfu3MkTaMpeHE5OTqxcuTKrVq3KwMBABgYG\nsly5cmbLJT8cBWkj1uz/C0eNGjXYv39/li9fPsf7zs7OeaSU/j+UR0E48nApcMKbIe9Wumr0ngdk\nR5gBOQ7A5wAuAOgAoA3M6GSNGzeO4eHhTEhI4IwZMwy6ep9++im1Wi1nzZplyRmpxmHKmjVrxjff\nfJNXrlyhRqPh7NmzDTucrl69atzQzHH8pqvUFMgzvI+MOWhidrds2bLcv38/w8PD2bBhQ9arV491\n6tShp6cnDx06ZC0OgGoc1uzjjz/mtGnTmJaWxpEjR5qqI1U5XF1d6evry0OHDvHmzZucMmUKY2Nj\nGRsby3HjxnH58uXmdpkp5tB9nq82kg+zK4ebmxu/+uorAnJEvoCAAHPxvO3G0b17d3788cfMyMjg\nkiVLDO+XKlWK//3vf3MH8v+fr5caNWqwU6dOPHr0KENCQvjNN9+YvX6VOGYlY8xbIMcs3Wb03lwA\n20iuEAThI8iKzXp12QcwI/kdHByMypUrAwA6dOgANzc3ALLEt6OjI2bNmoUff/wRly9fNnV4O8hb\nJmsUlMM4lS1bFmvXrsVbb72FkydPokGDBtBqtWjatCm2bt2K3bt34+zZs/qKtMTxM8nXjThirHG8\n88478PDwQJMmTZCUlJTjs/79+0Oj0WDo0KE4cOAAnjx5orQ88s1hLgmCgPfeew9z5szBwYMH8dpr\nryE0NNRUVtU4KlasiC1btsDBwQF+fn6IiopCxYoV8ffff8PZ2RlBQUHo0aMH0tPTMW/evNyxEvLD\n8TtMyNO7uLigatWqKFmyJFJSUpCRkQFRFJGYmAiSEATB0BYkSTL3MwrMYSkNHjwYo0aNgqenJ9q2\nbYurV68iOzsbkyZNwt9//213jvLly2PWrFk4fvw4bty4gT179gCQlaqHDh2KpKQkPH361C4cgiDA\n3d0dbm5uqFq1KsqWLYvHjx8jLi4OUVFR1tBVLQ93d3d4eXlh9OjRGDlyJEJDQxEQEAA3Nzc4OzvD\n1dXVZCwPQRBuQO5AjieZ58IGFEz+kTwpCEL1XG+/AeA1QRBcIct+n4M8VrMU8qoIk+nYsWNwcXGB\nKIqIjIxEeHg40tLSEB4ejjJlyuDll1/Gu+++a84x14C8z71VQTn0KTAwEPPmzUOLFi3g6OiINm3a\n4Ntvv8Xp06dx7do1XL9+HbGxsXbh8PT0xOLFizFkyJA8ThkAkpOT0a9fP0yYMAG///67Kcesennk\nTu3atcOcOXOg1WqxdetWXLx40VzWf9TiGD16NDp06IB//vkHnTt3RkREBLKzswHIAX1atWqFypUr\nY8KECYiJicGqVTkU4PPDAcg9mBxp06ZNeO+995Ceno6HDx8CAB4/foy7d+8aHHJmZia0Wi00Gg1i\nYmLw9OnT3MG3CsxhLvn7+2P58uVIT09H69atsXbtWgwcOBA+Pj5o3LhxbsdsF47XX38dV65cwbx5\n8xATE4PLly+jXr16+Oyzz9CtWzds374d165dswtH7dq1MX/+fDRp0gTp6ekoUaIEfHx8cOXKFSxc\nuBCHDh2ydMNUjcPV1RXBwcEYO3Ys7t+/j4ULFyIuLg47duzApk2bcPv2bWRkZJg7vC6AOQBWARhg\nMofCoYzHyKmVpZdh0UvlGKsg2yQJ7+fnR5IcN26cuTybYVp+3CYOQRB4+vRpZmdn88aNG1y/fj27\ndu2qhNUmDlOP7pGRkfzkk0/yfEdAQAB3797N7OxsS5I5qnGYsiZNmjAtLY1arZbDhg2zll8VjoCA\nAKalpTEjI4P79+83+yhYrlw53rx5k+Hh4blDoyrmMNVGBEFgVlaW2eD4ZN5YzWbiMReIw5Lt3buX\ncXFxbN26NQVB4Lvvvsv09HTeuXPHIJpqb46VK1caBIsFQWBQUBCTkpIoiiK/+uorU8ouqnHoVcJF\nUaSHhwcFQeALL7zAn376iaIoMiAgQJV2ao2jRYsWlCSJHTp0MAxzlihRguvXr2dqaiq9vb0JgPPn\nz2eLFi1yHKs7t9mQCUrHmAMh31mMHbPZGKawURJ+2bJlJMl33nnHXJ5AmJYft4lDX7Dbtm2zFHtZ\nTY48k12NGjXi2bNneeHCBa5Zs4Y///wzw8LCGBERwb/++ovp6elcvXq1uXF31ThyW8eOHRkREcHk\n5GROmjSJL7zwAl944QVLxxSYw8XFhUuWLOGtW7fYs2dPurq6WoxH3aZNG86cOZNVq1a1icNcG2na\ntClHjBjBzZs3c9GiRVy8eDH37NnDNWvWGN5btGgR9+/fT41Gw2PHjpkSdygwhznbs2cPt2zZQn9/\nfw4fPpxJSUk8e/asOXVo1TkEQWBYWBgnTpzI0aNH87vvvmN2djaTk5P55ZdfGosW2IWjfPnyfPvt\nt+nn55djgtHHx4fHjh3jgQMHLEWqVI1j7Nix1Gg0TEtL44oVKzh06FAeO3aMGo2Gbdu25dy5c/no\n0SMeOnQojzyb7tzjYEb7UZFj1p0kt7qsEnl6iw2sXLlyOf6PiYlhREQEa9eube6YG8in/LglDj8/\nPz558oRRUVHs0qWL1QtCBY6/TTXyypUrc9u2bczMzOTGjRvZvn171q5dmxUqVGDnzp15584dDhky\nxK4cxlaqVClGREQYNOWOHj3K0NBQnjlzJs+d38gKzNGlSxcmJiYyODhYUT00btyYGo2Gf/zxh80c\nltqIsW6dm5sbnZyccrw3ZcoUajQaZmRkmHqiUI0jt1WsWJH9+vXjTz/9RJL8+eefLV0zqnM4OTnx\n/v37TEhIoFarpSiKTE1NZbdu3cw5ZVU53N3dWbt2bYNwsrF17NiRiYmJbNmypd05XF1d2apVK06Y\nMIFDhgzhgQMHOH/+fA4aNIiVKlXiJ598YhBbMMF6A8ARAJXVdsw2xzDt378/Hz58yKysLN68eZNX\nrlxhVFQUSTIiIoLdunVjvXr16ObmluM4tTkAuXcUHx/PjIwMTpkyxeLytIJymGN5//33mZGRYTac\nYYcOHRgZGZlHGUJtDkBWpTbWksvMzDSYJEncv3+/uXIpMMeIESMoiiIHDBhgtQ4AuYd07tw5arVa\nVTmUmJ+fH48dO8bExESOGjXKVLuxC0f9+vW5efNmkmRKSgr37t1rjVV1jpEjR1IURWZlZfHGjRuc\nP3++JYesKsfo0aMZHx/PJ0+eMC4ujlFRUdy9ezc//PBDNmzYkN7e3gwJCeGGDRsKrTxMWbly5fj3\n338zJSWFvXr1MulDrPpcKw45t+afYjl2c9ATJ06ktRQXF8fXX38997GqcujtzTff5J07d/jo0SOl\nGnc2cZhicXNz45EjR3j06FGzQcYdHR05ffp07tu3L/eYq2ocgCzJ/s0331CSJGZlZXHnzp0cMWIE\nhw8fzmHDhvHw4cMMCwszVyYF5hgxYgSzs7MV6wz6+Pjw/PnzuR2zauVhzlxcXHjx4kWmpKTwgw8+\nMHczV52jSZMm/O2336jVannhwgV2795dCW+WEc9uyLGHj0NeGqYfXy2nlCMoKMggIbV69Wq++OKL\nSstNFY5Tp07x9u3b7NmzJ/v27cvg4GBu27aNkZGRjIuL45kzZ5iamsoLFy5w6tSpbNq0KV966SXj\nITFVy8OUVapUiQcPHmRKSopZyS81HLNe86868inHbgnez8+Pw4YNY2pqqsEZJyUlGf4/fvw4mzZt\nmvs41Tg8PDxYqVIlw+v+/ftTq9UyIiIij0irCbOJwxRLmTJleO3aNXNrUHPYBx98kHvsTDUOQB5z\nF0WRFy5c4BtvvJHH4YwZM4bffPONOb4CczRt2pSHDx9WomRDAKxZsyanT5+ee/JUtfIwZY6Ojly8\neDElSeLRo0cNEzz2KA9j69evn2Hy8f79+/kRVOgIeeOEe24WyJNPcQBWKuEoW7Ysf/zxR5LyBKh+\n8q8wOcaPH8/4+HhOnTo1x/tOTk788ssvKUkSIyMjGRMTw2PHjnH27NmcPXu28Zpq1crDlHl7e/Ov\nv/6iJEmcMGFCvjZC5csxG4FVRz7l2E0Bubi4MCgoiCtXrmRWVhYTEhI4fvx4enp60tPTky1atGBM\nTAw1Gg3feuutPD9GDY4XXniBP/74IytUqJDj/alTp/Lp06fcvXs3S5UqZbbwbeUwxeLu7s6jR4/y\nv//9r8UK9/HxYXh4OP39/e3CAYBLly5lREREjvEwNzc3Dho0iLt27eLOnTtNzbYbO6ICcQwbNoxa\nrdbkKhVT1qdPH8bHx7Nnz56qcliyAQMG8M6dO7x586a12X/VOPz9/RkVFcXr16/z6dOnfPfddxWx\nGnPozv09gPcgq3SUhzz59BNMj6vmOVePHj24a9cutmnThhcuXMivY1aFw9vbm4sXL+adO3eYlJTE\nu3fvMjY2lsnJybxy5QqHDx/OEiVKsGTJkvTz8+PUqVO5atUq9ujRQ/XyyG0VKlTgsWPHmJWVxdWr\nV+eYQ8ttBXbMyDuUIQL4UPc3C/KsZjIAjbUf07BhQ65Zs4bx8fEkyWPHjjEgICDHioguXbowNDSU\nn3/+uSndO1U4atWqxZiYGA4dOpSurq4G69GjB2NiYqjVaunn52epEmziMMXi4ODA8ePHMzY2ltWr\nVzf5fS+99BJPnjzJEydO5K5s1TgA8Ny5c4yJieG8efM4b948zpo1i/7+/ty7dy8XLlxIHx8fS2Wi\nl4UngP06hhj8KwsvAuhsiaNmzZq8c+cOr169amkyiy4uLnz77bd5//59fvHFF7l7jwXmMGelS5dm\nUlISU1NT2aZNG2v5VeMYNWoUSXLNmjW8du2aqSVxSji0kOWUvtW91nP8DSBNCce4ceM4bdo0AuDq\n1avz65hV43B2dqafnx/btGnDjh07smPHjgwKCsq9OsfuHMam36WakZHBzz77zJq6vSqOWT+UYbPk\nt4uLC7t3787ffvuNJJmWlsYffvghT7wFBaaK9Hj//v3NrlOVJIlhYWFs1KiR6hzmKrhkyZIMDQ3l\nqVOn2Lp1a9asWZM1a9Zks2bNOGfOHMbGxnLt2rV54hGozRESEkKtVsvk5GQmJCTw2LFj+amblyFP\nnvSF/IiYCuBTPYtSjqFDhzI1NZWnTp1i27Zt+eKLL7JGjRps2LAhmzVrxvnz5/Pw4cOMjo7mmDFj\nTE06qcKR21xdXQ29ofHjxxdaeZQqVYpRUVE8ceIESXLfvn2Kh3oK0kZMnWvz5s1cunQpfXx8uHr1\nanbq1OmZcBTQVOVwdnZmo0aNePz4ccPkuJeXl1WOAjtmHZRBJwv/PpopWWZCQL67kvK4cVhYGD/8\n8ENbC7VAHHrz9PTk+fPn+eTJE4NKdlZWFkNCQjhlyhQ2aNDALhyWKrhatWoMDg5mbGws7927x127\ndjEiIoKbNm1iYGCguYtRVY6GDRty6NChbNmyJbt165ZfB2DQUdOxRANYBGByfjjc3d0ZHBzMxMRE\n/vLLL4yKiuLt27d55MgRpqenMzIykgMHDmRQUJC5yVJVOHLb5MmTmZKSwsWLF1t7mlKVo1KlSiTJ\nqKgoHjt2TNFchBptxNS5Vq9ezaSkJK5du5ZXrlzhK6+88kw4CmiqcTg5OXHkyJH8+eefmZ2dzWXL\nlilyyoA6PWaD5h9slPw+ffo09+7dy9KlS+dXBTq3qSY9rlf5FYyUfvPBZhOHkoaWm+lZcdhgy3Xn\n1bOsBXAYshJxLICbADyU1k21atXYrVs3rl+/nuvXr2e3bt3Yvn17JcrdqnHoLSgoiGlpaZQkKccY\nf2Fx3L9/nyQ5ZsyYZ3rN1KtXj/fv3+fs2bP566+/WttwZDeOAppqHI0aNWJiYiJnz57NNWvWWB2+\nMDY1HLNe8091yW8b7LnmsANLUeEgZJ20KzqWuZCjdp3QcfwKYCGAHc8bR40aNTh9+nRmZWVxwoQJ\nz4TDw8ODc+fONTXn8j9/zRRVjpIlS/KTTz7h+vXr2a5dO7q7u+eLo8COWQdVJCS/n3cOO7AUFY7n\nvm7Mne+VV17h7NmzuXPnTpM7zf6/lUcxhzpWYMcMo6GMXO//v5UeN8eh+9sZQBTkGd5gO7MUFY4i\nXzfFHMUcRYlDDcesH8rIt+S3mvYccGyH/CiUBXknUVUAIfZiKSocz0ndFHMUcxQZDqVmMR4zyb9g\nQhdQieS3mqmocwA4LAhCGwAfG7F8Zy+WosJhiaWo1E0xRzFHUeJQmmxVya4CIFIQhPuQH5dLQw6A\nPk8lrueNQ89SFGTQizmKOYo5nj+OHMlWx0yjv0GQ96AHGWcoZOnxZ81hzBLEQpBBLyocFliKOYo5\nijmUc+RIph6HlaSHkLdrA/IE4bOS/C4qHHoWkzLogiB0FgTh6v8ihxHLc8ehZ7Hluzp37oy+ffs+\ncw5LqZijSHOYYvk3KRg0N6XG7AM5hGEWdDEZACzUfZYvye/+/fsrXaNpV458mDl16qO6z1Mg77l/\nAKCpEYdV5ZCixuHt7c3XXnuNgKyK/Oeff5rbWGAXjpdeeomXLl3iRx99ZC1oUL45CtpGPv/8c77/\n/vuFzhEaGsquXbvmiI74rMrD3d2d+/btoyiK/Oijj9i8eXNzsZkLrV6eRXnUq1ePH3zwAWvWhmdb\nHwAAIABJREFUrMlevXpZDTehZPJPSY95C+TlJMZpOuSlJ3chO8O/AbwuCEIHAK9ADnloNdWtWxdb\ntmxBQECAkux248hnMsUxF8CPkKNVpUJ2Ok6QK/4VANdIPnqeOF5++WX07dsXS5YsAQBkZ2ejVatW\n6Nevn6nsduEYMWIEateujVOnTuHmzZtKsPPDAdjYRtatW4fRo0fDwcHs5WM3DpKoX78+mjRpoiS7\nXcvjlVdeQZcuXeDg4IClS5eic+fOqFOnTqFwuLq6YsSIEVi8eDGGDh2KgwcPon///ihZsqSlw+xS\nHl26dMH777+POnXq4NVXX8WRI0fQuHFja4dZTAVRyQ4gmSAIgidkyZZNUCBPb5yuX7+OhIQEDBgw\nAAcPHrSWfT3krayOBeX48MMPERcXh+nTp+Pp06cICgpCaGgofv75Z9y8eROXL19GeHi4QZ05nxy/\nK+Xw9vbGzJkz8eeff+LWrVvw9fVFbGwsnJyc4OnpCQDw8fFBrVq1cPDgQfj4+ODSpUu4e/euqhy5\nU8mSJTF37lyUKFFC37OARqOBRqNBxYoVTR0yW22OihUrYuDAgThz5gxCQkLg7u6Ojz/+GNHR0Thx\n4gQiI02eIj8cVuXpTaVatWph+PDhiIiIwOnTp81lsyvHa6+9hnv37inJajeOxo0bY/LkyXBxcUFk\nZCR8fX3Rvn17lChRAjdu3EBmZqZdOBwcHPDuu+9i4MCB6NSpE9LS0vD777/jtddeQ7du3VC/fn3M\nmDHDnFK2XcpjyZIlhg7MnTt3MGnSJNSvXx+XL182mV8QhBsALgAYT/KJyUxKutUwimOqe50MwBWA\nq9HrPwD0gHz3+QoKHy8OHz7Mhw8fKskrAFgBoyDjtnLs3r2b6enplCSJWq2WGRkZTE9PZ3p6OrVa\nLaOjo7lx40ZzgdBt4tC9n+NcW7ZsoVarpVarpUajoSiKfPr0aY5od9nZ2bx37x7v3bvHqKgo9u/f\nX3WO3NaqVSvGxMTw/v37BkkrX19f3r59m6dPnzZ1jKocTk5OvHTpEh88eMC2bdsSAL28vDht2jSG\nhYXxhx9+MMeumEP3Ol9ttXTp0ty+fTvj4+P56quvWpIisxtHSEgIRVE0hOC0Ynbh8PT05OnTp/n0\n6VNu3ryZjRs3plarJUk+ffqUnTt3thtHtWrVeP36dUqSxH379rFnz55s1aoV3377bWZnZ3P79u2W\nYqrYtX0AYKdOnSiKIvv162cpnwC5t55nW76BTeEY82Pk1MqyKk+v9IfExMTw0aNHSvJuRj7kxy1x\n7N69m6IoUpIkfv7553RzczMEEFq/fj0TEhIoSRLPnTtnKtymTRymHFFmZiY3bdrEVatWMTAwkIsW\nLeJ//vMf1qpVizVq1GCNGjXo6+tLJyenPGKganLktrFjx1IURZ47d87w3uDBg5mRkcH58+ebOkZV\njtGjR5MkJ0+enCeY05AhQ5iammouNKtq8vSmrG/fvszMzOTy5cut5bUbRz4ds104Fi5cSI1Gw+++\n+87w3vDhwylJEsPDw03F01aNo2nTpszKyuK3336bI5Z769atKYqiNcds1/YBgOvWraNWq7Uo8Kw7\nt9mQCUodcyDkLn9uddlZuv9zhMpDPqTYX3nlFZLk7t27lfzoQOSVH7eJ44cffqAoily+fLnJqFCB\ngYGMiYnhjh07TDlmWznyTHaNHz+eGo2Gn376KVu1apXfiF2qcRibn58fQ0NDGRcXx7p16xreX7p0\nKSVJMieWqhpHqVKl+N1331Gr1ZoMwdq5c2c+ffqUgwYNKhBHftvqsGHDGB8fT0mSuHHjRmv57cYR\nEhJCjUbDgQMHKmkjqnI4OTnx7bffZmJiIu/evZvD+TRr1oyPHj3i119/zbJly9qNQ++Yc9fBe++9\nR0mSrDlmu9ULIPeWk5KSuHLlSov5dOceBzPaj6SCyT+SJyF38Y3TP5AFJgFgAIBDRvkzAIy2dl5A\nnjwgqR8ztZbWA2gCWW2gQBwtW7YEAMycORNarTbP59WrV4e7uzuio6ORmJioFscvuU+0f/9+/PHH\nH5g9eza+//57HDlyBEFBQRAEq8scVeUwTh999BEaNWqElStX4vr16wCA+vXrY+DAgQBgbhJONQ4v\nLy/Uq1cPly9fxu3bt/N8npqaiqysLLzzzjsF4sjFYjH16tULCxYsQOnSpXHz5k20bdvW2iF24dAn\nR0dHuLq6KsmqKsdLL72ELVu2oFy5cvjPf/6DI0eOGD4LCAiAm5sb3NzcoNFo7MqRO3l5eWHYsGFK\nstqVo1u3biCJZcuWWcynG2PuCtk5m05WesvmVLJXQO72S5AVABqaONbiXcPZ2ZnfffcdExIS2L59\neyV3JNU4kpKSmJycbPJ7HBwcuGfPHoqiaE6x2SYOcyzOzs709/fn6dOnGR0dzczMTEZFRfGjjz7K\nPXRhVw5AjjErSRJv3LjBatWqEZD1Bi9fvkxJkrh06VJzLKpxBAUFMSsry6y2XZs2bfj48WNOmTLF\nrhzG9fPLL78wMzOTc+bMYalSpXj//n1rbVV1Dr1t3749P0MZuVWhF+LfR/ZsyOOpilShXVxcuGjR\nIpLkf//7X3p6ehKQBWqrVatmmKPp2LGjXTnq1avH+Ph4pqamsmnTpqxWrRo3bdrE7OxsJT1m1Thy\nW0BAABMTE809yeUwSz7X8J1WHLM5lewNkJVlBQBHANzM749p2bIlo6KiePHiRYvChUamGsfZs2e5\nefNmk9/Tu3dvpqam8ocffjA1jGEzh7UyKVGiBFu0aMFJkybx2rVrTE9P55o1a1irVi1Vy8Mch6Oj\nI4ODgylJEjds2MASJUrwhRde4LZt2yhJEiMiIhgUFGSORTWO4OBgkqSvr6/J73r33XcZGRlpToNQ\n9Xrp06cPJUni8ePH6ejoyA8//JChoaHW2qrqHHo7d+4cJUlS6phzq0K/hn9VoedCDgyvSBW6ffv2\njImJYXZ2Nl999VXD+927d+eFCxdIkr/88ovBYduLw8XFhStXrqQkSbxy5Qpv3bplcMoKHLNqHMZW\nsWJFHjx4kMnJyezevbvVeimwYzYCq46cqr938a/qbz0AWfn9MQMGDGBmZiaXLFmipIFRTQ5ziiWu\nrq68desWJUkyrEZQi0PphafnW7p0KUVRNDfZpjqHp6cnT5w4QVEU6eHhQRcXF06fPt3Q4JcuXWpJ\nVUU1juDgYGZmZpq7wLlw4UL+/fffducA5JUgqampPHr0KD09Penh4cGjR49y2LBh1urQbu1jx44d\nFEWR+/fvV9KWqiOnKrSBBfLk0x0olFL69NNPmZWVxXbt2hnec3d35w8//ECSTElJYWBgoN05AHnj\n0/379ylJEuPj47lnzx5Dp8KKY1aVQ2+9evViSkoKd+3apej6Vtsx34S8BrUMgBSjz8YByM7vj/ns\ns88YGRmpOPq/vTiMbdSoURRFkQ8ePDCr1GwrR35ZKlWqxMuXL/PBgwcmd0aqzVGvXj0mJCRQFEX2\n7duXp0+fpiRJTEtL44YNG6xJXanGERwczMePH5vcQdayZUs+fPiQkydPtjsHAPr7+1MURfr6+rJu\n3brcv38/b926paT+7NY+5s+fT1EUeebMGaUcV/GvlJIfdGKjOo59UCA+2rp1a2ZkZPDWrVt0cHBg\n+fLlGRQUxLNnz/LMmTNs3749/f39ldy4C8RhbI6OjmzcuDFLlSpFAGzbti0lSeLJkyctae+pzuHs\n7Mz9+/czKiqKbm5uiq7tAjtm5B1jTgMwFPKYTBbk8bJkAJr8/BhBEHjjxg0eOXJE0Q/Rmeocxlam\nTBkeOHCAoihy2bJlljS8bOIwx+Lm5mZ2a+/+/fsZHR1t7rFdVY5mzZpRq9VSkiSDUK1Go+HChQuV\nCLNm6v5qIY/dZQGIwb+y8CKAzko4JkyYQFEUWadOnRwX4ZAhQxgdHc0///zT3PpyVTkA8M0336Qo\nijx16hTv3LnD+Ph49u3bV0l7UpXD2GbMmEFJkpT2zjIhj2sTwCnI8bolI46/AaRZ43j//fdJkvfu\n3eOyZct4/vx5rlixgvHx8UrFlVXhsGR6x3zt2jVWrVq10DgGDBjA1NRUDh06VDGrGo7ZG0BjyDPo\nwfh3zMziMhNrP6ZOnTrMyMjIr2K26hzG1rBhQyYnJ1Or1XLs2LGqc5hjqVmzJu/fv8/333+fHh4e\nhvfbtWvHtLQ0Hjp0yNwkoKocjRs3Nmy60W902bFjh9K6OQVZeVg/dhcJWRV6Un45atWqxbt37/Lx\n48cMDAxk48aNuWfPHiYmJvLEiROsUaNGoXAAsubf48ePKYoib926ZYgbUpjlkdsqVaqUn6EMVa6Z\nDh06UBRF6pMkSezatavSm5Tdr109oyRJ/OWXXywtO1WVw8XFhQkJCYyPj8+xtNSaKXHM1rZkxwH4\nHMB1kosEQXgZ8vpTi8tMrCWNRoPvv/8eFy9ezM9hk9TmME6VKlVCaGgoAgICsHnz5kLjuHv3LkaM\nGIF33nkHAwcOxNq1a3Hz5k0sWbIEgiDg008/zb291S4cycnJePToESIiIqDVarF+/XocOqT48PMk\nlwOALq6tC4CGkLe15osjPDwco0aNQv/+/XH06FEIgoCNGzfik08+wbZt20wtxbILBwBERESgffv2\naN68Oc6fP4+///5b6aGqchinlJQU7N271+RSQhNJlTZy7949zJ07F9OmTcO5c+eQnJyMsLAwc9vi\n7cZhLjk6OiIoKAgAEBcXh5SUlELh6Nq1K8LCwpCRkYHo6Ghb8U0nKz1mYzmWa5AfyXrj32UmGZC1\n5arn927XokULvvzyy4rvMvbi0NvatWs5e/ZsJTPuNnFYYhEEgQEBAczIyKAkSZw9ezYlSWJwcHCh\ncxj/zYfp5XquQY7gVRXypEom5OAw3wHwyG/dmJukLWwOG6yocKh6zdjQLuzCYcqMJ/8sbJVXleOd\nd97h7NmzOWbMmHyVh5Ies9UMOjB3yNpxvXSvPSEv/TG751vtRmZvjt27d3PixIn84IMP7MKhhKVm\nzZr8/PPPOWzYMC5ZssTiOmZ7chS1uinmKOawZhUrVuSUKVMsLeksUuVRYMcMM5Lf+FdZ9jaAx4Vw\n97crR40aNejh4ZFj/31+OIxYbkDuGdmkTu3o6Eh3d3drm0vszlGU6qaYo5jjf4mjwI4Z8l3ElOR3\nFfwb7HwCgETkUpa1Q6EWZY4K+Deo9kwA+2FCnfp/lKOo100xRzFHkeJQ4pgF3RebTIIgtAbwJ4Aw\n3UkBOTj9RwBaAngEeT3geciL5u0igvoccPTTcXhDnpH/AHLIwJL2YCkqHFZYikrdFHMUcxQZDqXJ\n4qoMmpf8fgFAOMnRutd5BAzVTEWdA8BhQRD6AQg0YnloL5aiwmGJpajUTTFHMUdR4lCaCqSSLQjC\nfcgLs0sDcAMwSh2s545Dz9JfEIRX8Wxl0Is5ijmKOZ4/jhypoCrZhHx3WQNgpf5DnQoyVTZLKtnP\nmkPP4gRZBr0JgHXIpQr9P8rB55XDzm2kmKOYwxJHwVSyzUwK6gNIR0AezwyBnRVuizKHEUs25CA1\nznoW2Eklu6hwWKmbIsvxjNpqMUcxh6LJP6s9ZkEQNguCECsIwlWjt10hb2WsAnlRti+AVrrP7KJO\nbQ8OHx8fVK9eHY0aNcJ3332HyZMnQxRFBAcHm1VANsUhCIIHZLVdQJ5cSAEQRfIi8qEK3b17d5w+\nfRqBgYHWstqVw9HREVOmTMGgQYPw8OFD/PTTT6hevbrZAP5qczg6OsLBwQEtW7ZE7969UblyZZQp\nU8Yadn45APu11f8XHB999BGuXr2KChUqFDqHo6MjFi5ciLi4OAwePBgNGjSwyltU6kVJUjKUsQWm\nZb+3AagIYDKAgwCGCILQATYoDytM7SDHSzVWubWJo2zZspgxYwaOHj2KgIAATJo0CVeuXMH27dux\nZ88e9OnTx5JChDmOnyH3AifrmKrktzxWrlyJV155BXXr1lWS3W4czZs3x+DBg3Hnzh107NgRwcHB\nSElJsaSsohqHj48PNm7ciGHDhmH//v3Yvn07+vbti2+//daaNH1+OWCNRRAElCxZEo6OjnBzc4O/\nvz9GjhyJTz75BC+//DK6d++OkSNHmrqJq8pRgGR3jnr16qFq1aqFztG4cWMMGzYM4eHh8PX1xaBB\ng5Tg2qU82rRpg71792LYsGEICQnB+fPn0atXL0sdmRuCIOzQ3RhMJqXSUrn1ld4AsJ1kHIAdkJ3E\n95Blv5n7HAMHDsTw4cOxf/9+g3322We4c+cOJEnCt99+ix49eliTVKoBeV+7j60c+lSpUiWMHTsW\n2dnZyMzMxLBhw7BgwQLExcVh9uzZSElJMdtjVpMjd/rhhx8AyI5RQbIbR/Xq1bFq1SqcOnUK169f\nx7Vr15CQkGBOEh5qcnTo0AEDBw5E3759Ub58eTg7O6Nr167o3Lkz/vOf/1hDzw8HLLE4OTlh1KhR\n+OGHH7B582Zcv34dderUQXR0NLy9vREVFYXo6Gg0b97c1A1DNQ59cnZ2RseOHfHhhx+icuXKqFix\nIurUqYNXX30Vs2bNwubNm9G+fXv4+fkZX0eqcxinFi1aKM2qOsfnn3+On376Ce3atUPVqlXRunXr\nQufw9vbG8OHDcfz4cfTu3Rv9+vVDs2bN0Lx5c3z//fcYPdqsKlVdyFv0V5k9ucIx5erQBZjWvbYk\nT59HWXbMmDGMjo5mSkoKNRoNU1JSeP36de7Zs4dbtmxhaGgoExISDHJGpkz3PQEAMm3l0Fu9evV4\n4cIFlilTJs9nixYt4o4dO+jq6qoqBxUsVG/WrJlBmcFaXntyDBgwgKNGjTL5mX4CI9f7qnE0bdqU\niYmJlCSJCxYs4Lx58wwR7+bNm2etXBRz6F6bbSMtWrRgREQERVFkeHg4x44dmyN2ePny5bl7926u\nXLnSVBxe1TgAWcBhx44dTEtLoyiKjIyM5Llz5xgXF8eLFy8yODiYb731lilxAVU5ctuDBw+YkpLC\n6tWrF1q96E2SJE6dOpWAHOfmn3/+UcKsGoejo6MhBKskSczOzmZ4eDj//PNPhoeHMzExkcnJySZ9\nmu7cBVbJ3gzgMXKqZFuSpzepLCsIAkuWLMkKFSrkubhnzZqVo6DN2GbIAWDEgnAAYNmyZfMEwhcE\nge3atWNKSoo53bKCclid7GrWrBlFUeTly5eVNDK7cjRs2NDkZ0FBQabiEajG4ebmxrlz53Lnzp18\n4403mJCQQEmSmJKSoqRMFHNYayORkZGUJInJyckm5b3atm3Lx48fm2srqnEIgsARI0YwOzvboNoR\nGRnJZcuWcfHixdZiZavGkdtcXV0ZHR3N8PDwQq0XvW3bts2gFJ4Px6wah17NRu+Y4+Pjc6y8GD9+\nPCVJ4vr16/Mcqzu3RZVsJY45EHKX39gxW5P97qKkcvWmd8xff/21pRgR9wFcUJOjRIkSXLFiBefM\nmcNffvmFKSkpDA0NtaZEYCvH39bKoXLlyoyIiGB2drbFYCz25qhWrVqeWLv+/v7ct28f9+3bxwYN\nGuQ+xi4cO3fuNDT8qKgovvjii9bKJF8cptqIk5MTp0+fTlEU+fDhQ7NPcZs2beLDhw/txqE3veRX\n79696efnx8DAQEtCAXbjyG1BQUEURZFr1qx5JhwODg50cHBguXLl+OTJE549e7ZQOQRBYJcuXbhs\n2TKOHj06T6zuOXPmUJIkdurUyRTHDcjaj5Vtdsw6uNa5ftA5AAd0/08EsMrEMYoaj6OjI5csWUJJ\nkrhp0yazel324Chfvjy1Wi1FUWRKSgoPHTrE9PR0BgQEmD3GVg4lZeLk5MTjx49TkiS+/vrrFvPa\nk6NWrVrcunUrAbB58+YcPHgwlyxZwpUrV7JLly6mhoDswvHll19SFEXDo+KdO3dyKJuYsAJzeHt7\n8/r169y7d6/ZsLSCIPDJkydcuHCh3Tj0VqVKFV6+fJkVKlRQdD0VRr0A4Ny5c6nRaNi/f/9nyhEY\nGEitVmuyZ1oYHA4ODixTpgxLlChBFxcXOjs7s1u3boyLi6NGozH55KnI51pxyLmlpRTLsSttPHpB\nR0mS+Pnnn9PR0dFcXtU5SpUqxX379nHmzJls1aoVAfDIkSNct26dSc25gnAodcwnTpwgSW7atMlS\nWdiVAwCnTZvG8+fP8/z58zx58iT79OljdnjDXhyVKlXixIkTefnyZcOQxtWrVy1JBxWYw9HRka+9\n9ppZ3Th9j/rChQusXLmy3cujYsWKPHv2LGfOnGlqbN+aZRnx7Ma/sYdF3Xt/ACiX33qpUKECr1y5\nwrNnzyoZX1aVQxAEvvjii7x48SKzs7MpiiKzs7M5YcKEQuVwcnLim2++ya+++opPnz7lnTt3eO7c\nOa5atYqSJFGr1fL48eMmOdRwzN4A6sMGOXaljadKlSq8cuUKJUkyq32nM7tw5G7sZcqU4cmTJy1d\n/DZxKHXM+h6zAsdsN44SJUqwb9++zMrK4vjx4y05IL3ZhcOYp0+fPoax5tatWz8TDkAeW05PT+f3\n339vachLNQ5HR0fOnz+fsbGx7NKli2JOnXWEHM5SL3H1GoAvdCxzIS8fW5nf8vD39+e9e/c4bdo0\nJXqQqnJ4eXnx8OHDTEtL46+//sr09HSKoshz584pCZWrGoefnx9v375tGGrLbQcOHDB70yqwYzYC\nq458yrErbTzt2rWjRqPhxYsXLeazN4fenJ2defnyZbOPzLZyqO2Y7cHh4+PDiIgILliwgP7+/pw0\naRKXLVumpNzsUh7GVqlSJUOjtyB8aVcOHx8fnjx5kqmpqZaeHlTn8PLyYkJCAmNiYti4ceP8tOfq\n0K2mys0CeVXAHdigtTdy5EhmZGSwV69ehc7RqVMniqLIiIgIpqenMz09nb///jtFUTQ89RYGR/36\n9Q2ixbktKirKkopKwR0z5KGMPyFLsWdCXs9cRvf/Q8jyOZEAtLY0dhcXF/7222+UJMmqY1aTQxAE\nNmnSJM/KDH2ju3r1Kn19fVXlUOqYT5w4obTHrCpH6dKluWPHDm7atMnQEyxZsiRr1qyp5MI7B/kR\nPRvALMg7qOboWCJ1eWxShdZbq1atDMvmBgwY8Ew4xo8fz8ePH1t7srMLR4sWLXjs2DEmJSVxz549\nHDdunMXlpbk47uraiJ9RG4mEPNSSL1VoQRAMnYc2bdoorT/VOPz9/XnkyBHeu3ePu3btYocOHdi8\neXNKksTVq1cTkJ8yzKjcq8ZRs2ZN3r59m1qtlqmpqbxy5Qp/+eUXarVanj171uKwkxqO2RuyOGE0\n5PExEcCnkGXZH+Hf2cUUWxp7nz59mJ2dTUmSLE2k6E01DhcXF27atIk3b940NG43Nzd+/PHHTE5O\n5tKlSy09FtnEYQfHrCpH+fLluXjx4hwKLn5+fhwyZIiSC++xjiMeQAxkhxQDWe/O5vIICAhgyZIl\n2apVK545c8awVKx+/fqFyqG3lJQUnjt3zmJvyJ4cFStW5NixYxkfH8+UlBTevHnT2tLOOMjjqlmQ\nHdFPOi49R2UAyfnh8PDw4OPHj/nnn3+yXLlyispNTQ5BEOjh4cFatWoZOhDGjtnX15dbtmxhnz59\n7Mrh7OzMF198kU2bNmWjRo1YpUoVNmvWjMnJyRRF0erTboEcsw7KIMeCf7v/TwDM1n1us/T4okWL\nDBdb2bJlreVXjaNMmTKGpVgajYYXLlzgpUuXqNFouHfvXmvLkWziyK9j/uqrr6w5ZlU5SpUqxaFD\nh3LatGns2LEjX3/9dW7fvp2LFy9WcuEZ5Hp0LNEAFkHe5mpTeezbt4+ZmZncunWrQaQ2OTmZQ4cO\nteQYVefQt5fly5dTo9FwxIgRz6Q8ctuoUaMoSRIHDRpUKNeM3jp06GCoC4UTf3bhMLZGjRoxJSWF\nkZGRTEpK4tmzZ821Ebty6FfQ2N0xw0haCvL4zAPI8UrPQe4N3IA8YL4uvz/GwcGBe/fupSRJnD59\nupIfripHUFAQJUnisWPHKEkSMzIyOGbMGCW9IZs4lDrm48eP88CBA2zTpo21WXjVORo2bMiXX36Z\nv/zyCxMTE7l161Yl66kJnVyPEctaAIcBhEPujdxEPlWhK1WqxOjoaEMdZWRksE+fPtbqR3UOABwx\nYgSTk5O5efNm+vj4PJPyyG0jR45U4phVv3YHDhxISZK4f/9+li9fXimvXXyI3kqVKsVFixYxOjqa\nCxYsMLUDslA4ateuzUePHhWKY24NuasfBiBN17A6A6gF4Dfd+3cBfJffH1O5cmXDhde9e3clP1x1\nDr3jM7PNWFUOpRVcFDjyWR6ELAl/RccyF4AHgBM6jl8hL0vKt/pwYGAg161bx0mTJim9QajOUapU\nKT558oSiKFoaQimU8jA2/Vb1rl27Fuo1o28f+WG1F4cNXHbjKFu2LCdMmEBJkvjw4UP7Tv7poMyq\nMes+N7nn29oPcXd35549e5iYmGhyEs6E2YXDBrOJww4sRYXjua8bS+esWbMm161bx3Xr1hWp8pg3\nbx4vXrxoMt7L/4d6edYczZo148CBA1m3bl0GBQVx5syZ7NatG9evX59nF2BuK7BjhnmV7Ar4V/I7\nGsDfthSqh4cHGzZsaG4GNbfZjSOfZpJD97cz5LjQyQCC7cxSVDiKfN38L3JUrlzZ0sqh/3fl8Txx\nqOGY9UMZlyEvwboEee/4TsjLTP6BfAe6DPtLjxdlju2QH4WyABwHUBWyEoI9WYoKR1Gvm2KOYo4i\nxaHEMduqkp0GoCzJbrrXUwB01f1Y/bEWgyurkYoKB2R16jYAPjZi+e4ZsBQVjiJTN8UcxRzPA0fu\nZKtKdhUAkUJedep5KnE9bxx6ljaCIITh2artFnMUcxRzPH8cOZKtjplGf4Mg70EPMs6gmyFVLZm5\naxUVDmOWIJJPBEHoa0+WosJhgaWYo5ijmEM5R46kRPPPVHoIebs2IE8Q+iKX5LeN5zVOWdaJAAAg\nAElEQVSbBNOS30WFQ8/ipOOAMYsgS6BfhZnk4OCAJk2aYOPGjXj48CEGDhxoVZDVHhy2pueVQ89S\nzFHM8Qw4TLH8m5QMRJuYFNRH9n8A4CLk0HkLdZ+Zlfx2cXFh+/bt+c4776gyYG4rR0HMSplkQ57d\nDdMxNTXiMKscUrp0aX744YcMDw/n48ePOWvWLIaHh1uMU2EPDjXLxFYOQRDo7e1NPz8/Dhs2jMOG\nDWONGjXYvHlzVTkKu40Uc/xvczRq1IhTpkxhVFQUe/bsyZSUFM6cOZMTJ07MsxFHkY9V4IQ3Q96t\nZKz55wHZEWZAlmv5HLI6QAcAbWBGJ6tq1aqG2Lo2FKxqHKasQYMG7Nq1K48cOcKQkBAOHz6cc+bM\nyQ/Hb7pKTYE8w/vImIMWZncdHBzo4eHBmjVrsm7dunzxxReZkZHB3bt321IeNnMUwFTj8PHx4eHD\nhzl16lTevXuXd+/e5ZgxYxgeHm4u/oFNHLrPFbcRFxcXNm7cmH/88QdDQkK4Zs0aSzvf7MZhr3pR\nwhEYGMiBAwdajJHh4eHB0aNH595goXp5+Pj4cMyYMdy1axeHDx/OkJAQtmjR4pm0j/r16/P8+fOc\nPXu2ITStJEmcPXs2NRpNHjUgJY5ZyVDGFsjr/IzTXADbSJYEMBOAC/5VlzUr+V29enXUqFEDZcqU\nQceOHeHh4YESJUrA19cXY8eOtaaS3Q6m5cfzzaFP3t7eWLhwITIyMhAaGopRo0ahSZMmcHJyQrt2\n7eDv7w8vLy+lHD+TrAY5mtghAKuVckiShCdPnuDu3bu4fv06bt++jbCwMPj4+Fg6THUOQFZjrl+/\nPiZOnIgDBw5AkiRIkoSlS5fCw8Os2rpqHMnJyTh06BDCwsJQs2ZN1KxZE4cOHYKbmxu+/PJLa/j5\n4YA1FkEQ4OTkhGnTpuHUqVNYunQp/P39UaZMGQwZMsSSareqHPpUunRpVKpUCfXr18eiRYuQkZEB\nSZJw/PhxDBo0yK4cDg4OaN68OYYMGYKZM2eaVZGvXr06PD09Ua5cObtwNG3aFNOnT8fWrVuxYsUK\n9OrVC2+99RaaNm2KdevWmWSyB4c+ubu745tvvkGTJk1QtWpVdOrUCe+//z5CQ0MREBCAM2fOICkp\nKccxgiDcEARhhyAIZi8opUMX1ZHzTnNXB+0KwFP3+g/IKsjvAfgKJu4sGzduNMQsTUxM5O+//86t\nW7cyIiKCiYmJ1sIYCpCVIBILylGmTBkOGDCAp06d4pMnT7h69WouW7aMb7zxBlu1akVnZ2f26dOH\noihy7ty5qnDkp6far18/JiQkcPny5aqXhyWOcuXKcenSpXz48CG1Wi0lSWJWVhYTExP56NEjSzua\n7FoetWvX5oMHD5icnGwtr2IO3edm2wgA9u3blzt37mRMTAx///13fvTRR2zRogUrVarEFStW8MmT\nJ+aGWFTlcHR05IQJE7hv3z5euHCBaWlpzM7OZlZWlkE09tChQ3blqFGjBsPCwihJEmfMmGFyy3G5\ncuV4/vx5Zmdns27dunbhCA0NNUTWW7JkCQcOHMhDhw5RFEWDHFphtQ9nZ2fu2LGD6enpXLp0KRs1\namT4rEKFCnzrrbcYFxfH0NBQU9fuXJjYlp/foYz8qGSblfzevXu32Yj/kiSxd+/elgp1M4AEAFJB\nOd577z1DuNHjx4+zYsWKefJUq1aNoihy2LBhqnAodUQNGjRgcnIyJUmypNRhF45Vq1ZRFEVqNBqO\nGjWKLVu2ZMOGDTlx4kRmZ2dbqh+7lQcgxyJOSUmxNrSTLw5rbaRZs2aMjIxkeno6P/300zy7U9u1\na8fY2FhT7UNVDi8vL+7Zs8dwjcTExHDjxo2cMmUKBUHgjBkzKEmSqQ6Eqhx//fWXQQ3anOza22+/\nbQhwZC8OYyVqQA52JYoiRVG0qpOpJoeDgwMnT55MSZK4YcMGs2USEhLCX3/9Ncd7unObDZmg1DGb\nUsnOADDJ6HWy0f9mJb9r167NDRs2MDAwkLt372ZSUpJBbFMURWthBAMh373EgnC8+eabhjCSISEh\nZiNRDRkyhJmZmaaCstvKYXbSTRAEtm7dmitWrOClS5coSRLPnDnDF154wR7lYZJj4sSJTEtL44kT\nJ+jr62voEfn6+jIqKoqSJOVpYEamGoezszMDAgLYtWtXvvnmm3z33Xf5+PFjXrt2ja6urtYuPMUc\nltrIyy+/zMePHxucsqnvWrx4MaOjo8212QJzVKlShQcOHGB6ejozMzP5xx9/cPz48XlEWdeuXcuH\nDx+ai3pXYA4XFxfOmDHD8AS1c+dODhgwgG+//TZbtmxpiFseGBjIf/75h5GRkTl6jmrWS27r2bMn\nnzx5wtTUVG7atMla21CVw9fXl6dOneLUqVMtxis5f/48g4ODc7ynO/c4APtsdsy6k+RWl7UYwxQW\nJL/1Kthly5ZlgwYNOG/ePINulxX9sBsAzhaEw8fHh9u2baMkSQwLC2OtWrVMfle7du148+ZN7t27\n11Q8Als5/jb329zc3AyB4PUWHR3NAwcOsH379mqXRx6OEiVK8ObNm5wxYwa9vb3p4uJikNaaMmUK\ns7OzmZGRYa53SDXLIyAgwBBXNzU1lRqNhpIkMTY2llOmTLF24eWLw1xbXbBgAbVaLXfs2MFSpUqZ\nbMc3btzgDz/8YDeOd955h7/99hufPn3KkSNH0tPTM8/wgb+/v7lHZdU4SpUqxc2bN+domxkZGdRo\nNIyOjubvv//OKlWq8K+//qJWq+XQoUNNRXlTpV6MzcfHh2FhYczKyuKCBQvo7e3Nli1bsm7dupbC\n96rGcfr0aUZFRVkSbWa5cuW4e/duU3JgeiGLymo75gLFMHV0dDTYq6++yoyMDIqiyNq1a9PT05Oe\nnp708/Nj3bp1DXFN1eAYMGCAQSds+PDhZp3ksmXLmJWVxSNHjuQZ5rCVw1KZuLi4cN26dbxx4wb3\n7dvHb775hiEhIUxPT+e9e/f40ksv5TlGTY6OHTtSFEXGxsby6tWrPHHiBPft20cAfOONNyiKItev\nX29pNl618qhUqRL37NnD0NBQnjlzhqtWreJ///tf/vjjj0xOTub27dstiSoUmMPd3Z1bt27lrl27\ncqi56M3BwYFz5sxhYmKiJWmlAnOsWbOGWq2WtWrVMhvO8ttvv6UkSZbEDArMUb58eZ49e5ZxcXEM\nCwvj3r17OX36dB46dIi3bt0yDLtJksTw8HC7t48GDRowKCiIsbGxFEWRWVlZvHz5Mv/55x+KosjU\n1FQmJyfzp59+MrVqpsAcrq6uhnkHS6uEXF1dOWvWLGZmZrJfv355rl2rPteKQ/aFLMeSW469GeTx\nGv3YTJ4ueW5QNzc3tm/fnpMmTeKGDRu4ZcsWbtmyhSdOnDA8Jl26dIl//PEHT5w4wbt37/LmzZuG\nHrYaHDNnzjTES23atKnJAh08eDCfPHnC6OjoPI+NBeGwdrMqW7YsK1asaLgRVaxYkUOGDGFWVhZX\nrlxpV47q1avzt99+4+3bt7l06VK+8847hqeXMWPGUKvVWhMfVb08clvp0qU5ePBgZmdns23btnbl\nEATBpEq6IAjs2bMn4+LiePz4cfr5+dmNo0ePHjxy5IjJHrvenj59yqSkJEtrvLOMeHZDjj18HPLS\nMP34ajlLHM7OzmzVqhUDAwNzdFJcXV1ZpUoVfv311yTJqKgoS/sTCsyhN73SEEnD5PS5c+d46NAh\njhgxgiNGjOClS5d48+ZNVqlSRXWOHj16MDk5mePHjzf2TTnMy8uLX3/9NePi4jh27FiTnbuCOmZv\nAPWRV479CwAf6fLMhtFMp7lCdXBw4OXLlw2TbnrTPybr1/9FR0dz79697NGjR+4eS4E5mjZtyr17\n93Lp0qV5FAYcHBwYGBjIlJQUZmRkWJrhtYkjN4sgCOzTp49ZNW5Alt4SRdHchacKhzFP7p6Zi4uL\nYSXN4MGDLTlO1TgsWeXKlSlJEj/55JNnwuHl5cWTJ09SkiROmjTpmZWHg4MDZ82aRUmSuGLFCkt5\nO0LeOOGemwXy5FMcgJW2cvj6+hpWamzZssWso1KTY+DAgTx58iSrV6/O6tWr09fXN0fbnTRpErOz\ns/nll1+aGmYoMEdQUBB/+ukns0o2np6eBnm4K1eumMxTYMdsBFYdOeXY7+NfOfZpAFKVFKqvry+n\nTJnCrl27sk6dOqxTpw5r1arFxYsXU5IkTpw40WwjUIPD29vb5Di2k5MTX331VV6/fp2iKDIsLMzs\n0j1bOXKzuLq6UhRFrl271uQk3+jRo5mcnMyUlBRLQxkF5rBkLVq04P3796nVavnGG29Yc0R24wDk\nm8SaNWv44MGD3EuxCoWjZMmSnD9/PrOysvj777+zcuXKz6w8vL29eebMGYqiyKFDh1rl0J37e8jL\nv+4CKA958ukn2Khx5+Liwq+++oqiKPLGjRt88cUXnwmH3kqUKMFVq1YxJSWFv/76q7nrt0AcgiAw\nMzOTBw4cyHHeChUqsEuXLpwxYwZDQ0OZnJzMPXv2mN25W2DHjLxDGSKAD3V/syDPaiYD0BSkULt1\n60aS3LBhg8lxPZ3ZjaNdu3aMjIykKIqMiIhg7dq1LQXvt4kjN4uLiwsfP37M7OxshoSEsE+fPhQE\nge3atePPP/9sGLvbsWOHuQkGVTgs2Y4dO6jVanngwAFrKyIyIce6JYD9Oga9OnSyjqtzQdpI7969\nmZmZyd27dxvUkQuLQxAENmzYkMnJyUxKSlKiuGPX8mjXrh2fPn3K69evWyoLYw4tZDmlb3Wv9Rx/\nA0izhePtt99meno6w8LCLIYOsDcHIA9zffHFF0xPT+fVq1dNdmTU4BAEgZIk8e7du9y6davBLl26\nxKdPn1Kr1TI7O5szZ85k2bJlzc4NqOGY9UMZ7pC3Pj+C3P23uMwkvxedq6srJUniwYMHLa3MsAvH\na6+9xjt37jA7O5uPHj2ypqFmM4cpFm9vbx46dIjx8fGGDQNarZZJSUk8d+4c/f39Ld0gVOPIbc7O\nzpwxYwYzMjJ48OBBa2rdhLxTKhRAX8iPiKkAPtWz5IfjhRdeYMuWLeni4kJBEFi5cmWOHj2a8fHx\nvHLlCmvUqFEoHMZWqVIlXr9+nampqRwyZIiSNm0XDr3t2rWLkiSxWbNmdmmr1r7fy8uLISEhTE5O\nVqrXaReOEiVKsEGDBjxw4ACfPn3KjRs3slOnTnbl+Pjjjw0Czvqh2PDwcJ46dYr9+/dn586drZaH\nEsdsLVB+rCAITyB38bcDeBXy+lON7gdCEAQvyL03m1N2djaePHkCQRCg1WrNZbulNoejoyNeffVV\n+Pn54dq1a+jXrx+uXrUa9Ew1jtjYWPTq1QutWrVCqVKl4OsrB8oLCwvD5cuXkZGRUSgcuVOVKlXw\n/vvv48iRI1i7di1EUbR2yDwAO0l+KwjCW5Bj2roCSM0vx4gRIzBv3jyMGzcOVatWRceOHRETE4PV\nq1fjq6++QmxsbKFwGKd169ahZs2amDFjBvbv36/kELtwAICfnx9Kly6N5ORkPHz40Fp2u7SRwYMH\no1GjRvj666/xxx9/KDlEdY7SpUtjwYIF6NatG44ePYrBgwfj4MGDkCTJrhyOjo7Izs4GIPutDz74\nAA8ePMClS5eQmpqan59gOVnpMRs0/2AnyW+9VaxYkdu2bbM0gaA6R+PGjQ07p6ZPn66U1SYOW8rk\nWXHUrFmTt27d4uTJk9mqVSslLMt159WzrAVwGLIScSyAmwA8lHDUqFGD165dMwSEiYmJYbly5SwN\ncdmFQ29t27ZlZmYmk5OTLT0i251Db8OHD+fs2bO5Y8cOu7URa+fVq9srCBpkN46JEycyMzOT27Zt\ns/s1Y+pcpibLlZqSHrM1x6zX/LO79LgCswtH69at+cEHH9idww5lYjeO2rVr886dOxw3bpxSBfPL\nAK7oWOZCjtp1QsfxK4CFMBEXwA5tRHUOHx8frl+/nn379s3PhWi38hg2bBhnzJjBd99995ldM0uW\nLOEXX3xhqRNld47WrVvzvffeUzLMZvfyyK8V2DHroP7npMefBYcdWOzG4ezszHr16tHLy0tpT/W5\nrpvnicPT05Pe3t4WtwH/fyqP55GjwI4ZRkMZud7/fys9bo5D97czgCjIM7zBdmYpKhxFvm6KOYo5\nihKHGo5ZP5SRb8lvNe054NgO+VEoC/JOoqoAQuzFUlQ4npO6KeYo5igyHErN2qqMv2BCF1CJ5Lea\nqahzADgsCEIbAB8bsXxnL5aiwmGJpajUTTFHMUdR4lCabFXJrgIgUhCE+5Afl0sDcIO8TKgwU1Hh\n0LMUBRn0Yo5ijmKO548jR7LVMdPobxDkPehBxhkKWXr8WXMYswSxEGTQiwqHBZZijmKOYg7lHDmS\nEs0/U+kh5O3agDxB+Kwkv1Xh8PLywoYNGxAcHAxRFCFJEt577738cOhZTMqgC4LQWRAEqztX8pOK\nCocRy3PHoWcp5lCPo0WLFvjwww+fOYepVMQ4TLH8m2wcSNdH9n8AeXujBsBC3WeFLT1eIA5fX1/e\nvn3boGobGhrKGzducPr06Zw5c6biGVWYkUE34jCrYKJWeTwLDit1U2Q5bG2rDRo04I4dO3jkyBFW\nqVLF5HLCwuAoKuWhNy8vL/bo0cMQW8UeHI0bN+a9e/fYpUsXsxzt27dnjRo1DMoq9iqPMmXKsHfv\n3pZCJtDT09MQT8QaR26z2mMWBGGzIAixuXo4rpCj/3sDeBHAlwBeFwShA4BXIIc8VDXZi6NcuXKo\nVq0aEhIScOPGDfTq1QtdunTBvXv30KFDB0Ucgqx2+yPkJWrVAZSCfBf20HOQfJT7XI6Ojvj0009x\n/PhxdOnSBV988QW++OIL+Pv7o3379vkuD1s5lKbXX38dU6dORY8ePXKz2IXD3d0dY8aMwaBBg/DH\nH3+gW7duFvPnk+P/2jvzsCiu7P2/BQiouAc3MOAWBVxwAY27JhoXMu6KxBXjNomJGqNJGDWOP40m\nJhg1asSYxdExxojiNvpTNCZiHIKo48YirlEWMWEV6O56v3/cptNgb0C1kpk6z3Mf6O7q6k+dqjp1\n69S95wXKeKx26tQJ27Ztw9ixYzFgwACMHDkSCxcufEzd3Z4cDRs2RHBwMGJjYy2pdNudw9g8PDyw\nb98+tGvXDqtXr8b06dPtwtG4cWM0btwYderUMbe92LFjB0aPHo0hQ4aY+lwxf3h6emL9+vUICgp6\nbP8D4twODAyEi4uLSVZrZkuO+UuImqXfGL23FMA3JNdIkjQHQFOIMnoBEFcck5LfkiTB2dkZ1apV\ng06nQ8uWLfHqq6/C0dERAwcOxCeffILPPvvMMBe9lPWDmDLZtKIcxla7dm1cu3YNs2bNQkxMjOH9\nV155BRcuXCgLx0GS/Y04Uq1xuLq6YvDgwQgICABJ9OnTBwDg5+eHDh06oGPHjrhx44Y5dMU4zJmD\ngwPc3d0xduxY+Pr6IjQ0FKdOnUJeXl7pRRXnePbZZ/GPf/wDrVu3xsGDB1GtWjVs374dY8aMwdGj\nR4t7OxXhOAYb5OkBwNfXF6tXrwYAtGvXzvD+0KFDkZqairp16yIzM9PuHAMGDMCqVauQkpKCjh07\nolWrVli9ejWys7PNfcUuHMVWrVo1zJgxAx999BH27NmD9evX4/fff7cbR35+PrRaLYqKiswy1a5d\nGwMHDsRHH31kNw4AqF69Otzc3DB79mwcPnwYhYWFJT7v2rUrXn31VZw8eRK7du0q8ZkkSVcBxAF4\ng+RDkxtiY+rCG/o6pvrXVuXpYaJr7+Pjw61bt/LIkSM8ceIEMzIyqNVqDTV/b9y4YamEoIQyyI9b\n4jBuderUMVkDYfv27Tx16pRiHPrlSqzL0dGRc+bMYVZWFrOysnj16lX+8MMPBjEBC4oQinKYal5e\nXly5ciV//vln6nQ6ajQaXrt2jfPmzTNVuF9RjhYtWvDSpUs8d+4cBw4caJjp9re//Y3ff/+9pQqE\nisrTA0KxIjk5mTqdjllZWUxPT+f69esZExNjEHkYN26c3TleeeUV3r59m2+99RaHDBnCW7duUZZl\nDhs2zNJ+VJyjuHXs2JEHDx5kYmIip0yZYlH7TgmOWrVq8ezZs7x37x67dOli8nckfb1kWZYZGBho\nV38sWbLEoM5tKm0yYsQI5uTkUKvVMiIiwtS5uxQmpuUb2GwIylsBZKCkVpZVeXpTGxMYGMi0tDQW\nFBSwoKCAOTk5nDlzJp2cnFhQUMCbN2+aFUjVc9gsP26Jw1rz8vJiYmKiucBcLg5LgUgykmSXJIlf\nf/21LYFZcY7i5uDgwMjISENpw9TUVE6YMIFubm7mvqMox/jx4ynLMqdPn17i/XHjxjEhIcFS6U/F\n5OmdnZ356quvUqPRMD8/nxMnTqSHh4dBucLV1ZWnT5+mLMum9CMV4yhuhYWFnDlzJgHxXOTChQuU\nZdla2U3FOQDQ19eXt27dYk5Ojq11ZirMMXnyZObk5PDKlSvmJN9KBGYzFwpF/NG0aVODHJ5Op3us\n/Koxh/F+K276dZstmWBrYO4JocJgHJhtkac3u6O8vLxKnFzt27enRqPhF198YUnjrCfKID9uC0eN\nGjVYs2ZNNm3alM8++6zhQU6PHj1469Ytc/Vuy8th08MuSZL466+/UpZljh492tKyduFwcHDgjBkz\neOvWLX733XecNGmSLfUyFOOoWbMmIyMjeffu3ceK8x89epSJiYmWArMi8vTu7u7ctm0bExISeOTI\nEXbq1MlksZzo6GhGR0eb0o9UhKO4tWnThkVFRYY7hZYtW/L27dvUarUWpcmU5ijeP2fPnjX4xcpx\noRjH4MGDGR0dbbGqnnFA7N+/v9380ahRI0OnJTEx0XBsODo6cvLkySVUxXft2vVYITD9umfDjPYj\naWXmH8RafpQkqUept83WMCVZIEnSLACHzK3z1q1bhv9r1KiBBQsWwMHBAZGRkZZqEG8GkAXxBLVC\nHM7OzujRowcWLVoEkmjSpAk0Gg3WrVuHzZs3IyQkBLIs4/z580pyHDG3YQDQt29fTJo0CQkJCahb\nty5kWUbz5s1Rp04d/Pbbb0+Eo2bNmvj4448xcuRI/POf/8SCBQuQn59vLp9rbB2U4qhbty58fHwQ\nFxeH/Px8w/uSJKFRo0bIzMws8X55OUqxGI6RFi1aYOvWrQgMDMTy5cvx+eefIz3dfInePn36oFOn\nTjh37pyiHMY2fvx4SJKEnJwcAMDw4cPRsGFD6HQ6JCcnm2VTmgMAjhw5Aj8/Pxw/fhxNmzbFw4cP\nLT0HUYyjVq1aCAgIwN69e639FgCYq6uuiD+qVq1q+P/UqVMAgN69eyM4OBhBQUHw8PAAAGi1Wpw6\ndQrXr18vAaHPMd8CMNXsBljpLTcBcAoi9yJDTPUFRBK9WMIoC8CXJr5r09W0ffv2vH79OnNzc+nn\n52dpWUU4ateuzf379zMjI4P5+flMTEzkr7/+yrS0NGo0Gp4/f57JycmWpOnLxWHJJw4ODtywYUMJ\nkdri9vbbb5srN6koR9WqVfnFF19QlmUeOnSIzzzzjK29ISrJ0axZMyYlJXHjxo0l2N5//33KsszI\nyEhLKZUKc2zcuJGFhYX89NNPLco2ubu7Mz4+3pzunqLHR3h4OHU6HXv37s1Ro0YZJK4yMjKs7Zfz\neo4EAAsgag9nQiiq5EM82LJJndrR0ZHLli0jSWo0Gup0OhbbnTt36O/vb6ksaoU5PDw8GBcXx6ys\nLK5bt44LFiwwtCVLlvDIkSPMzs4mSebn55srSVphDkmSuGzZMsqyzNzcXPr4+PCnn34y9NSNW2pq\nqkl/WIq5ht+0EpgbQFwt0vCHNtZiiBEaCRDj/h4ASCxvYI6IiKBWq30sD2OiVZijevXqXLNmDWVZ\nZnR0NEePHs3mzZuzZ8+eHDZsGO/evUtZlg26f0pyWPKJJElcunSpycC8atUqczVnFeVwc3MzSBYl\nJSVx9erV7Ny5s6UgaNwU42jYsCFjYmJ47949Dhs2jGPGjOHOnTuZlJREWZa5adMmS6mVCnF06tSJ\n8fHx3L17N729vS1u85AhQ3j//n3evXvX1C29osdH3759mZ2dzXv37vHKlSt8++23GRUVxUOHDlnb\nLw/0HHchRhsEAbgNMTzsOkQ9CJvUqZs2bcrExEQePnyYEyZMYGhoKLdv3869e/eSJGNiYszmfpXi\nmDFjBq9evcq8vLzHzhOdTmfI+6akpJg7ZyrM4ezszFOnTlGWZebn5zMmJoY6nc7wuvjBvV0DsxGY\nN0qq/l7HH6q/fgCKyhuYSTI9Pd1qHlMJjrZt2/LIkSP817/+9djoj8DAQD58+NCwk999911FOaz5\npG7duuzUqRPPnDlDWZa5YsUK+vv7m+212YPD0dGRrVq1YqtWrfjxxx/zzp07PHz4sC37UVGOl19+\nmQUFBYYD/MqVK2zXrh1lWebKlSvtxtGmTRvOnDnT6t2CJEk8ceIEdTqdyUlI9jg+3Nzc6O3tTRcX\nF7q7u/PHH3+0pTPjjZKq0AYWiIdPybBRnbpDhw7Mysoy2Stu3rw5SVrKOSvGUadOHfr6+jIuLo47\nd+7knj17OGvWLHbp0oWLFi2iLMtctGiR3TgcHR0ZERFR4qLwyy+/0Nvbm/7+/vz9998N7+fl5bFh\nw4Ymz10lA/M1iLxITQA5Rp/NBqApT2AeO3Ysi4qKGBYWZnXZinJIksRLly4xJibmsYdHL7zwAqOj\no1lUVMTFixczISGB6enpbNKkiWIctvikSpUqjIuLo0ajsSY6alcOQKRXWrRowRMnTnDbtm3WVLIV\n52jSpAlnzZrF/v37083Njd26dbNFAqxCHDdu3OCtW7fYtm3bEut1cXFhs2bNOGPGDB44cIB37tzh\nzZs3uWvXLnp5eT0Rfxi3kJAQ3r9/35aHst4QFwhvPUsz6B9w6Tn2wEYRVH9/fxNzmrUAABpmSURB\nVD569MjkUMV+/foxKyuLbdq0sTuHuebo6Gi447UWmCvC4erqyvj4eEMPOTIykh4eHgSE7Fdxj/k/\n//kPk5OT+dxzz5k8dysUmCFyzOkQt2SEkGQJhRhWUpwzywaQX1anduzYkSkpKbxz5w47dOhgi/Mr\nxCFJEjMyMtivXz/DOlu1asUFCxYwMTHRkFd0cHDg1KlTmZeXx+DgYMU4bPGJu7s7s7OzmZuba4uM\nkd04jH32xhtvUKPRWNO7K9T/1QLYpWdIxR+y8DoAAyty4hX3hkaOHGk3jhEjRlCj0TA+Pp6HDh0y\ntOjoaCYlJZXII4aHh7NWrVpPxR/Lly9ndHS0LcsWQty6E8BpiHrdshHHJQB5tnB07NiRGo2GFy9e\n5NatWxkaGsqpU6cyKiqKmZmZ3Ldvn6W0l2Ic5pqLiwtlWaZWq+Xw4cO5fPly9ujRQ3EOR0dHRkZG\nUqfTcceOHYYLlaurK8+fP2+44+7cubPZORlKBOYGAPwhnqAvhJBibw8xDXqRfhl32HgbYtzeffdd\najQa7t6921pvrLhVmGPOnDncsGEDo6KiePLkSep0Oj569Ij//ve/+cILLxiWq1q1Kr/55hvOmzdP\nMQ5bfLJ69WrDLZC9/FGaY+jQoezbty99fHzo5eVFb29venl5sXnz5gwICGB0dDQvXLhg6BWYaacB\nzIV4wp0I8RBlFYB5FfGHcVu+fDllWebQoUPtyjFp0iQeO3bssRxmdnY27969y++++44vvfSStd6q\n3fxRr1495uXl8fXXX38i50xxc3Nz44YNG5iamspHjx5RlmVqNBqmpaUxLi7O2tA5u8QQ4+bs7GzI\nM8fHx/PAgQOmequKcPTr14/79u2jp6en4T0fHx/DsZKcnEwHBwezrLYEZmvD5dIBfATgCslVkiQF\nQIw/TQLQSb/MeFgYXmPKJEmCm5sbJEnCsmXLLA1/MrZ5FeU4ffo0jhw5glq1aqFJkybYsWMHkpKS\ncO3aNdy/f9+w3KNHjzB37lw0bdrU1GoqzGHKXF1dMWHCBABiSJINpghHdnY2Jk6ciEePHiEjIwO3\nb9+Gt7c3XFxccOHCBRw7dgxffPEF0tLSLK3m3yTDAUASdW2dAbSDmNZaLn+YswcPHtiV49ixY3j+\n+eeRlpaGmjVrYuvWrfD09MTNmzeRkJCAlJQUaLVaa6uxmz98fHwQHR1dYsipBVPsWM3NzcW8efOw\ndu1atG/fHjVr1sTNmzeRm5uLM2fOPDEOc6bVanH69Gl0794dV69exfnz53HnzmOzqRXhOHHiBH7+\n+ecScatnz544efIk+vTpg7CwMMiyXJHNgbUes7Ecy2WIW7LhECq/+RC3zPcAeJflajdlyhQuXrzY\nUi7IVFOco5ytXBy2sBQ/fLQyzdbuHOVoxXI9lyFGJDwL8VClEGIo0rcA6laEo3i4XL9+/Sz1VhXl\nsCGd9MT9sWfPHr7++uvmctv/VedMWX+neObs0+Ao/l1bjhlbesxWF9CDuUFoxw3Tv34GYr632Tnf\nlsCSkpL417/+1dL0a5MbozRHeVp5OWxhmTp1Kjdv3myTX+zJ8aR8UpbfqFGjBtesWcNWrVqZvU38\nsx8jtqw7NDTU1mcy/xP++LNyVDgww4zkN/5Qlk0EkFGWjfH19WWdOnXMjTU01xTnKGczK4GuZ7kK\n0TOytzp1ZeGo9PtG5VA5KhNHhQMzxFXElOS3J/4odv4mgN9QSlnWDk6tzBz18UdR7b8BiIQJder/\nUo7Kvm9UDpWjUnHYEpgl/Q+bNH2NjFMQM5aKF3wPwBwAzwP4FWI84L8hBs3bRQT1T8ARoudoAPFE\nfipEyUBXe7BUFg4rLJVl36gcKkel4bDVLI7KoHnJ7zoAUkjO0r9+TMBQSavsHAAOS5IUAqCnEctd\ne7FUFg5LLJVl36gcKkdl4rDVKqSSLUnSTYiB2TUAVAcwUxmsPx1HMcsrkiR1x9OVQVc5VA6V48/H\nUcIqqpJNiKvLBgCfFn8oCRXkxwrAV7BZUsl+2hzFLE4QMugdAHyOUqrQ/6Uc/LNy2PkYUTlUDksc\ndlXJvg2Rz4zF01P8feocRiwaiCI1VYpZ8PRUsp8Ih5V9U2k5ntKxqghHy5YteeDAgafOUVn88d/A\nUbpVVCXbE2JQdhMA3fSfWVXadXBwQPXq1fHOO+8gOTkZixcvxrZt2+Du7v5EOQBRHL5+/frw8/ND\n/fr1rS1uTZ0aEA8XcgDcI3kOCqhTVwYOR0dHDBkyxCAYW4rFLhzNmjXDpEmT4O/vj+HDh6NDhw5w\ncjKffSsjB1BOVWhnZ2cEBATAw8MD48aNw/jx49G2bdsnxtGrVy8MGjTI5L4wNntzdOjQAY8ePULX\nrl2fCoefnx9CQ0Ph7++P7t27w9PTE56ennBwMB3W7O0PSZLQqVMnvPjiizhw4ADGjh2LsLAwjBw5\n0tZVGMyWVMaXEOP8jG0pxNCThgDeAhAFYIokSS/CBqXdJk2aYNKkSVi0aBGaNWsGAAgODsbo0aMt\nfa1YFdqxohw9e/bEnDlz8MMPP6BBgwbIy8tDREQERo0aZen3rXEchOgFvqVn8rTVHwBQr149zJ07\nF/PmzcNf/vIXBAYGPhUOc+bh4YENGzbgq6++wvPPP1/6Y7twzJ49G6tXr0bfvn2xfPlyREVFoX37\n9mZPvDJywFaWoKAghISEAADatGmD6Oho7Nu3D8HBwfjyyy+xdetWDBo0yO4cgFBMcXd3R2ZmZmnV\nFFNmNw4ACAwMhIuLCyZOnPhUOLZv346IiAi8/PLL2LNnD6KiohAVFYVhw4Y9UY5ia9u2LXbv3o0t\nW7Zg8ODBaNasGQYMGICYmJgSy0mSdFWSpH/oLwymzcbUhTceV8kuri/7DEQd03f1zaLS7oABA5ic\nnMz9+/fz4MGD3LJlC48fP06dTscjR46wTp065m4BzKlCl4nDycmJly9fplar5U8//WSoDuXh4cGQ\nkBD6+fnRwcGB9evXZ82aNRXjoInxkFWqVOE333zDwsJCRkZG8tatWzxz5gyjoqIYGxtrUUFDSQ5T\nPmrcuDG9vb0NBaaqV6/OsLAwfvDBB3Rycir9HbtwHDhwgM8//7zh9bRp0xgeHk5fX19z37GZQ/+e\nVVXoVq1asaCggGlpaWzevDkTExMNxWr279/PdevWsVevXqUnSynOAYDBwcFMS0vjsWPHrNWltitH\ncdu+fbtBvOBpcBjvB+OCU9HR0Xz77befGMezzz7LBg0acPfu3SwoKGBCQgLDw8MtFf6quEq2mcCc\nDZFGqGb0ulie3qzSbqtWrRgXF8eioiIuXLiQ8+fP58WLFw0O1Wg0XL58ucmN0f9OIIDCinCMGDGC\nWq2W586dM1u2cdSoUbxw4QK3bNmiGIepQOTu7s7Dhw/z73//O4cOHUpfX19WrVqVS5cuZVpaGmvX\nrm32YFCSw7i5ublxxowZPH78OLOysgxK1R4eHvz666/N7R/FOQBw5cqVj4lvhoSEcMCAAea+YzOH\n/rVVVejx48ezsLCQmzdv5ocffkhZlllQUMCdO3dy8ODB5i6einJ06dKFS5Ys4YMHDwx1gK0I9drN\nH8XNwcGBKSkptgZmRTnc3NwM1Qbv3LnDQYMGcfr06fz000+5ZMkSTp8+nb17934i/hg8eDAvX77M\n7du387XXXuPkyZPZuHFji/7Qr7vCKtlbAWSgpEq2JXl6s0q7CQkJBukXHx8f3rhxgzk5OTx79ix1\nOh11Oh2LiooYEhJiaoO2QhSA0VWEo7h0oYlaraxevTrPnTtnKHYdExOjJIfJh12SZLroyc2bNy0G\nZqU5oD/gc3NzqdPpeP78ecbHxzM9PZ2urq6MjIykVqvl3LlzTX1XUY7itmDBAmZnZ5eo8zt58mR+\n9NFH5r5jM4e1Y7W4BQUF8cSJE6xXrx7btWvHzZs3W5WdUpLjvffeY1paGmVZZnp6OmNjY3n79m22\nb9/eGoNd/FHcBgwYYOhQ2RCYFeXo1auXQc4pPj7eFj/YzR/fffcdZVnmyZMnbebQr9uiSrYtgbkn\nhASLcWC2WMMUwKDSMF5eXszLy+OxY8fYqFEjrlq1irm5uWzfvj1DQkIMgVmn03Hu3LmmCtXcBBBX\nEY7atWvzyy+/5Pr16+nq6kpA1O0YNWoUV65cyUuXLjE+Pp5Xr16lTqczdztUXo5Ltu44FxcXZmVl\nWSsKrzhHy5YtefnyZTZu3JiSJLF+/fo8ffo0t27dyqysLC5evNgci138MW7cOD569Ii+vr4MCgri\n2bNnef36dc6YMUMRDnPHqnHr1q0bz5w5Y2s1N8U5Zs2axVOnTvGTTz6hl5cXly5dytu3bz+msvKk\n/AGI2sebNm0qS2BWlKN3796G305JSbGkNWh3f4wePZr5+fmMjo5mixYtzHa0SrWrAP4FwKPcgVkP\n16PUBp0FsFf//1wAa018xwDi4uLCb7/9lllZWRw2bBi9vb2Zk5PDr776igAeC8zx8fGP5XeV4Oja\ntSt//PFHjho1isuWLeP+/fuZkpLCvLw85ubmcu3atfTz8+OWLVtYUFDAevXqPebU8nKUZrHUXnnl\nFWo0GnN3DnbjaNmyJW/cuGHIl7744ovMzMykTqfjkiVLDBczE80u/ujbty8fPHjAxMREPnz4kLt2\n7aKPj4+pHLfdOFxcXBgbG8u9e/daev5hN45ijb/i12FhYWUJzHbZL8899xyTk5MNah2BgYFPlGPF\nihWGwKzVannhwgW+8847T8UfTk5OXLNmDfPz83nu3Dl27NjRKodNMddKQC4tLfU7gCkQSXQdRH3T\nAgDtLG3M2LFjmZ+fz4iICAKgt7c37969Sz8/P9aoUYNRUVGUZZk7duzgL7/8wgsXLph68FZhjsDA\nQN67d6/ETs3IyOChQ4cYFhZGZ2dnenp6Mj09nVeuXDHn2HJxlCUwL168mBkZGdZSGYpz1KlTh7Is\ns1evXpwxYwYLCwt5//59Tps2zVpPwC7+8PPz482bN5mdnc3XXnvNFt/ZhWPQoEFMTU21Jp9kdw4A\nnD9/PuPi4ixdnIxbkRHPLvxRe1inf+8HALXLytGuXTvevn2bsizz+PHjT5TDz8/PcEdrrJAtyzLX\nrVv3VPxRr149bty4kQUFBYyPj7cq5qtEYG4AoA3Ew7/L+EOOJQKi+IcE0SW/Zmlj/Pz8ePjwYa5a\ntYqAuMpMmTKFnp6eHDhwIDMzM5mTk8Pg4GDGx8dzy5YtdHZ2Lr1BFeZwdXXl2rVreenSJSYlJXHF\nihV84YUX6OLiYlhm8+bNlGWZGzZsMOfYcnHYeuI988wzTElJsSUwK85Rv359ZmZmMi0tjWlpafz+\n++/ZrVs3izI5+mYXf2zatIkajYapqans1q2bLQHALhwODg6cNGkS09PT+cEHHzw1DkAE5oSEhBKy\nRhbaAIhylsUSV70BrNOzLIUYPvZpWTmGDh3KnJwcarVaWyWuFOPo168fHz58SJ1Ox7i4OG7bts0g\nMJGSksJGjRrZlcPcSKkqVapw8eLFzMnJ4fHjxyssLWV1AT2YN8oox24MMnbsWObl5TEpKYmtW7cu\nARkeHs6cnBx27tyZU6dOpUajMdljVoIDQImpkaacFhMTYzEwl5fD1hOvT58+BkFQS8PllOaoXr06\nv/nmG5JkZmYm/f39bTnhjAORov4ICQlhYWEh9+3bR61WyylTpjwRjr59+5rVr1u1ahULCgo4ZswY\naxcrux0f8+fPZ2pqKidMmMDu3bszMDCQVatWtcihX3cJFohRAckoh9belClTqNVqmZWVxSFDhti8\nX5TgmD9/PmfPnl3iHO7cubOh9xwaGmo3DkmSePLkSbM94po1a/LgwYOUZZmTJk2yeO5WKDBDpDJO\nQUixF0LUKq2p//8uhHzOHQBaS059+eWXmZWVZVCiNg7OixYt4oEDB9irVy/GxcVRq9Vy6dKlporo\nV5jDWvP29mZ+fj5/++03c8Ntys1hC4skSZw/fz51Oh3Hjh1rjVdRjqCgIF65coVhYWE8e/asSdl1\nC+0sxC26BsAiiBlU7+tZ7uiXsVkV2t/fn7m5uZw2bRqdnZ354MEDSyMxFOWYPn06v/32W3bu3Pkx\nkeCqVaty3bp11Ol07N69+xPzx8yZMxkZGcktW7YYhswZ38Y/ePCAw4YNM5X+K+a4rj9GmhkdI3cg\nUi1lUqeWJIlRUVHU6XQ8evSotbs6xTnCwsJ479499u3b15DzNw7MGzdutCvHihUrmJWVxUuXLnHX\nrl0MDw/nW2+9xVWrVjE2NpaFhYXUaDQW5eGUCMwNIMQJ70Pkx3QAlkDIsv+KP54u5ljamFq1ajEi\nIoJarZaFhYVMSkpiWFgYmzVrxkWLFvHatWtMT0+nLMvcuXOnuZ1dYQ5rB9zcuXMpyzJ//vlnNmzY\n0Nyy5eKwhaVKlSqMi4tjQkKCYeKLhaYox4cffshp06YREBfLLl262OQ3fcvQczwAkAoRkFIh9O7K\n7I/XXnuN9+7dM6SzwsPDGRsb+0Q4Jk6cyPz8fP7666/86aefuHbtWr755pt89913efToUV69epWy\nLFsaGaK4P1asWGF4MF4cjDMyMnjnzh3GxMTwl19+4bfffmvqNj4dIq9aBBGIDui5ijk8AGSXNTBr\ntVrKsmzrWGpFOQICApiens6MjAwePXqUXl5eXLVqla2BucIcbm5uHD58OC9fvsyioiLD/ijeN9nZ\n2Vy+fLlFFfUKB2Y9lEGOBX90/x8CWKz/3Gbp8ffee48pKSnUarUlNkaj0TAvL4+HDh1iu3btzG2Q\nYhymWo0aNQwziMLDwy0tWy4OW1hcXV0py7LZSTb25Pj+++8NPcQxY8Zw8+bNtp50hJFcj57lPoBV\nENNcy+yPt956i4cPHza87tKlCxMTE58IR8OGDRkREcH79++bbdeuXTOb7rCHP5ycnDh79mzOnz+f\noaGhvHv3LgcPHmy3Y8TSOt3d3Q3nbf/+/W09PhTlWLhwYYm7BuO7h549ez4RDicnJ7Zu3ZrTpk3j\nhAkT+P777zM0NJRNmjSx6o8KB2YYSUtB5GduQdQrPQvRG7gKkTD/3JaNcXBwYNeuXblp0yauXbuW\nqampTE5O5uzZszlmzBhrM2YU4zDVGjZsyM8++8yWwFwuDltY+vfvT1mWOXXqVEt5Q7twLFy40DAs\nKygoiEePHrX1pCP0cj1GLJsAHAaQAtEbuYYyqEKPGjWK+/btY3BwMEeMGMGVK1fy0KFDT4yjdevW\n7Nq1K7t27UofH5/H/rdwN2UXfxg3Z2dnBgQEsG7durb4Q/FzZurUqZRlmXl5eWzatKmtx4eiHI0a\nNWJQUBCzs7MNU7BlWWZSUpK1fWPXGGJrUyIw94Do6l8EkKc/sAYCaAHg/+vfvw7g2/JsjKWHcCaa\n3TgAcM6cOVy8eDFlWebs2bMV57CF5auvvqIsy3zjjTcey2/am8Pf35/Lli0jAB48eJAXL14sy8F2\nHsAFPctSAHUBnNRzHIUYlmSz+nCNGjU4YMAAFhYWGh7otGrV6olzVKBVFg67nDNlPG/txtGjRw9u\n2rSJ7733Hj/77DO+9NJLT4WjrK3CgVkPZVaNWf+5yTnfdjjI/tQctrAEBARwzZo1Nt0O2ZPjf23f\nqBwqx5PksCUwW5SWkiRJAvAFgCskw43er08yXf9yJMpR07Yc9l/PERsbi9jY2KfOUQ6rLCwqh8rx\nZ+CwauVVyQ4B0A6AM0SuZipLFT7X3+ooafwzc9iBpbJwlJtF5VA5/hc5SErWlrEYmFVTTTXVVHvy\nVl4xVtVUU0011exkamBWTTXVVKtkZvHhX3lNL8v9EYS+Vh6EOnIRxPhNT4gcT1WIqZANIGas1YEY\nziJDDPrOg5g+WU2/bHGC/l2S/1I5VI6KcpRi8QRQC2KKrsqhcpTmcATQHKIzq4Uoui8DyIQYB90R\nYtSHg/49N/3fZyCUUS5ClEoYDzEz1DKLLUM3ytJQUp7eCWLgdjrE01BAFN7/J4SqdQOIMZ0/A/h/\nEMXf20MMyE/X/38YwCmVQ+VQksMESx+Ii0OKyqFymDlWiwBMhShQ1RNAB4ig/DeIao+HAfwEMR56\nBETlugUQlew+1HPOs+W37ZHKMMjTk9RCDFFxLv6Q5I8AugH4nWQagNUAWkLMXf9F74T++o3wgLjS\n+KocKofCHKVZTkL0stxUDpXDBIcWohhVByOO3yBmD24keUn/W60hesYFEFO+v9C/f07PaXVEBmCf\nVEZpye+7ELcBTSVJughgM8RMqGwAIPlAkqTqAN4E0AiiIE99PduPAAIA1JUk6SqENMwbJB+qHCpH\nBTlMsWj161I5VA5zHOMAVJMk6XWIIkhOJDP1n+fr2YbqOdwhAncAhGDCVwBekyTpVWss9ugxmxp/\ndwSi1ukLekDHUp9rIG49RkPcBlQH8CbJHACfQeRzfPWfrVU5VA4FOEyxfAIgS+VQOcxwLIKoQndD\nz9G91Odf6b8zGiIf7grgOyMWDUSe2iqLPQLzXYg6zsXWBGJDQDIDoqpTIfTOlSSpkf7/7QAOQtym\nyBC5GkB0/dMpkj6fQ1x9VA6Vo6IcplhqANCoHCqHGY5aELltnZ6jHQCtJEnPSJJUBcCXAB6S3AuR\nwnACsI/kXkmS3AGkUW/WWOwRmGMBtJEkyUMPGwzgDADobzkGQuRbauunfEdBXD3W6DeGEDNwxuvX\nNxOi9jBQtimTKofKURaWmgBeBpCjcqgcZjiCIYpRSXqOJIi883j9b7sC+KeeazdEuiVXv67xAE4Y\nrdsii11m/kmSNAhiiElx4G8JcVXTQZQ9dIR4oqqDuKr8DjGsxRnAIwjHekAMN3HR/3WChWnGKofK\nUVaOUixe+t+QVA6VwwSHC0TO2UnfNBAPJatDXAycIXLQWojj2hlAAkRhpCoArkAEch9YKZkAqFOy\nVVNNNdUqnakz/1RTTTXVKpmpgVk11VRTrZKZGphVU0011SqZqYFZNdVUU62SmRqYVVNNNdUqmamB\nWTXVVFOtkpkamFVTTTXVKpmpgVk11VRTrZLZ/wHt05+v5zFs8wAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWYAAAEACAYAAACAi9xRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n/wP4vY1OxyCmaQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# An example for a single MNIST image\n", + "mnist_dp = MNISTDataProvider(dset='valid', batch_size=100, max_num_batches=5, randomize=False)\n", + "\n", + "for batch in mnist_dp:\n", + " features, targets = batch\n", + " #show_mnist_image(features.reshape(28, 28))\n", + " show_mnist_images(batch)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exercise 2\n", + "\n", + "`MNISTDataProvider` as `targets` currently returns a vector of integers, each element in this vector represents an id of the category `features` data-point represent. Later in the course we are going to need 1-of-K representation of targets, for instance, given the minibatch of size 3 and the corresponding targets vector $[2, 2, 0]$ (and assuming there are only 3 different classes to discriminate between), one needs to convert it into matrix $\\left[ \\begin{array}{ccc}\n", + "0 & 0 & 1 \\\\\n", + "0 & 0 & 1 \\\\\n", + "1 & 0 & 0 \\end{array} \\right]$. \n", + "\n", + "Implement `__to_one_of_k` method of `MNISTDataProvider` class. Then modify (uncomment) an appropriate line in its `next` method, so the raw targets get converted to `1 of K` coding. Test the code in the cell below." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# %load -r 150:160 mlp/dataset.py\n", + " return rval_x, self.__to_one_of_k(rval_t) #here we convert the targets to 1-of-K\n", + "\n", + " def num_examples(self):\n", + " return self.x.shape[0]\n", + " \n", + " #and here is the function which does it\n", + " def __to_one_of_k(self, y):\n", + " rval = numpy.zeros((y.shape[0], self.num_classes), dtype=numpy.float32)\n", + " for i in xrange(y.shape[0]):\n", + " rval[i, y[i]] = 1\n", + " return rval" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "### Exercise 3\n", + "\n", + "Write your own data provider `MetOfficeDataProvider` that wraps the weather data for south Scotland (could be obtained from: http://www.metoffice.gov.uk/hadobs/hadukp/data/daily/HadSSP_daily_qc.txt). The file was also downloaded and stored in `data` directory for your convenience. The provider should return a tuple `(x,t)` of the estimates over an arbitrary time windows (i.e. last N-1 days) for `x` and the N-th day as the one which model should be able to predict, `t`. For now, skip missing data-points (denoted by -99.9) and simply use the next correct value. Make sure the provider works for arbitrary `batch_size` settings, including the case where single mini-batch is equal to all datapoints in the dataset. Test the dataset in the cell below.\n", + "\n", + "Tip: To follow with this exercise, copy MNISTDataProvider in dataset.py, rename it to `MetOfficeDataProvider` and reimplement necesarry parts (including the arguments you pass to the constructor)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# %load -s MetOfficeDataProvider mlp/dataset.py\n", + "class MetOfficeDataProvider(DataProvider):\n", + " \"\"\"\n", + " The class iterates over South Scotland Weather, in possibly\n", + " random order.\n", + " \"\"\"\n", + " def __init__(self, window_size,\n", + " batch_size=10,\n", + " max_num_batches=-1,\n", + " max_num_examples=-1,\n", + " randomize=True):\n", + "\n", + " super(MetOfficeDataProvider, self).\\\n", + " __init__(batch_size, randomize)\n", + "\n", + " dset_path = './data/HadSSP_daily_qc.txt'\n", + " assert os.path.isfile(dset_path), (\n", + " \"File %s was expected to exist!.\" % dset_path\n", + " )\n", + "\n", + " if max_num_batches > 0 and max_num_examples > 0:\n", + " logger.warning(\"You have specified both 'max_num_batches' and \" \\\n", + " \"a deprecead 'max_num_examples' arguments. We will \" \\\n", + " \"use the former over the latter.\")\n", + " \n", + " raw = numpy.loadtxt(dset_path, skiprows=3, usecols=range(2, 32))\n", + " \n", + " self.window_size = window_size\n", + " self._max_num_batches = max_num_batches\n", + " #max_num_examples arg was provided for backward compatibility\n", + " #but it maps us to the max_num_batches anyway\n", + " if max_num_examples > 0 and max_num_batches < 0:\n", + " self._max_num_batches = max_num_examples / self.batch_size \n", + " \n", + " #filter out all missing datapoints and\n", + " #flatten a matrix to a vector, so we will get\n", + " #a time preserving representation of measurments\n", + " #with self.x[0] being the first day and self.x[-1] the last\n", + " self.x = raw[raw >= 0].flatten()\n", + " \n", + " #normalise data to zero mean, unit variance\n", + " mean = numpy.mean(self.x)\n", + " var = numpy.var(self.x)\n", + " assert var >= 0.01, (\n", + " \"Variance too small %f \" % var\n", + " )\n", + " self.x = (self.x-mean)/var\n", + " \n", + " self._rand_idx = None\n", + " if self.randomize:\n", + " self._rand_idx = self.__randomize()\n", + "\n", + " def reset(self):\n", + " super(MetOfficeDataProvider, self).reset()\n", + " if self.randomize:\n", + " self._rand_idx = self.__randomize()\n", + "\n", + " def __randomize(self):\n", + " assert isinstance(self.x, numpy.ndarray)\n", + " # we generate random indexes starting from window_size, i.e. 10th absolute element\n", + " # in the self.x vector, as we later during mini-batch preparation slice\n", + " # the self.x container backwards, i.e. given we want to get a training \n", + " # data-point for 11th day, we look at 10 preeceding days. \n", + " # Note, we cannot do this, for example, for the 5th day as\n", + " # we do not have enough observations to make an input (10 days) to the model\n", + " return numpy.random.permutation(numpy.arange(self.window_size, self.x.shape[0]))\n", + "\n", + " def next(self):\n", + "\n", + " has_enough = (self.window_size + self._curr_idx + self.batch_size) <= self.x.shape[0]\n", + " presented_max = (0 < self._max_num_batches <= (self._curr_idx / self.batch_size))\n", + "\n", + " if not has_enough or presented_max:\n", + " raise StopIteration()\n", + "\n", + " if self._rand_idx is not None:\n", + " range_idx = \\\n", + " self._rand_idx[self._curr_idx:self._curr_idx + self.batch_size]\n", + " else:\n", + " range_idx = \\\n", + " numpy.arange(self.window_size + self._curr_idx, \n", + " self.window_size + self._curr_idx + self.batch_size)\n", + "\n", + " #build slicing matrix of size minibatch, which will contain batch_size\n", + " #rows, each keeping indexes that selects windows_size+1 [for (x,t)] elements\n", + " #from data vector (self.x) that itself stays always sorted w.r.t time\n", + " range_slices = numpy.zeros((self.batch_size, self.window_size + 1), dtype=numpy.int32)\n", + " \n", + " for i in xrange(0, self.batch_size):\n", + " range_slices[i, :] = \\\n", + " numpy.arange(range_idx[i], \n", + " range_idx[i] - self.window_size - 1, \n", + " -1,\n", + " dtype=numpy.int32)[::-1]\n", + "\n", + " #here we use advanced indexing to select slices from observation vector\n", + " #last column of rval_x makes our targets t (as we splice window_size + 1\n", + " tmp_x = self.x[range_slices]\n", + " rval_x = tmp_x[:,:-1]\n", + " rval_t = tmp_x[:,-1].reshape(self.batch_size, -1)\n", + " \n", + " self._curr_idx += self.batch_size\n", + "\n", + " return rval_x, rval_t\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/01_Linear_Models.ipynb b/01_Linear_Models.ipynb index 071ec25..b860b0f 100644 --- a/01_Linear_Models.ipynb +++ b/01_Linear_Models.ipynb @@ -4,45 +4,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Introduction\n", - "\n", - "This tutorial is about linear transforms - a basic building block of neural networks, including deep learning models.\n", - "\n", - "# Virtual environments and syncing repositories\n", - "\n", - "Before you proceed onwards, remember to activate you virtual environments so you can use the software you installed last week as well as run the notebooks in interactive mode, not through the github.com website.\n", - "\n", - "## Virtual environments\n", - "\n", - "To activate the virtual environment:\n", - " * If you were in last week's Tuesday or Wednesday group type `activate_mlp` or `source ~/mlpractical/venv/bin/activate`\n", - " * If you were in the Monday group:\n", - " + and if you have chosen the **comfy** way type: `workon mlpractical`\n", - " + and if you have chosen the **generic** way, `source` your virutal environment using `source` and specyfing the path to the activate script (you need to localise it yourself, there were not any general recommendations w.r.t dir structure and people have installed it in different places, usually somewhere in the home directories. If you cannot easily find it by yourself, use something like: `find . -iname activate` ):\n", - "\n", - "## On Synchronising repositories\n", - "\n", - "Enter the git mlp repository you set up last week (i.e. `~/mlpractical/repo-mlp`) and once you sync the repository (in one of the two below ways, or look at our short Git FAQ here), start the notebook session by typing:\n", - "\n", - "```\n", - "ipython notebook\n", - "```\n", - "\n", - "### Default way\n", - "\n", - "To avoid potential conflicts between the changes you have made since last week and our additions, we recommend `stash` your changes and `pull` the new code from the mlpractical repository by typing:\n", - "\n", - "1. `git stash save \"Lab1 work\"`\n", - "2. `git pull`\n", - "\n", - "Then, if you need to, you can always (temporaily) restore a desired state of the repository (look here).\n", - "\n", - "**Otherwise** you may also create a branch for each lab separately (again, look here and git tutorials we linked there), this will allow you to keep `master` branch clean, and pull changes into it every week from the central repository. At the same time branching gives you much more flexibility with changes you introduce to the code as potential conflicts will not occur until you try to make an explicit merge.\n", - "\n", - "### For advanced github users\n", - "\n", - "It is OK if you want to keep your changes and merge the new code with whatever you already have, but you need to know what you are doing and how to resolve conflicts.\n", - " " + "-" ] }, { diff --git a/01_Linear_Models_solution.ipynb b/01_Linear_Models_solution.ipynb new file mode 100644 index 0000000..2087bc0 --- /dev/null +++ b/01_Linear_Models_solution.ipynb @@ -0,0 +1,890 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction\n", + "\n", + "This tutorial is about linear transforms - a basic building block of neural networks, including deep learning models.\n", + "\n", + "# Virtual environments and syncing repositories\n", + "\n", + "Before you proceed onwards, remember to activate you virtual environments so you can use the software you installed last week as well as run the notebooks in interactive mode, not through the github.com website.\n", + "\n", + "## Virtual environments\n", + "\n", + "To activate the virtual environment:\n", + " * If you were in last week's Tuesday or Wednesday group type `activate_mlp` or `source ~/mlpractical/venv/bin/activate`\n", + " * If you were in the Monday group:\n", + " + and if you have chosen the **comfy** way type: `workon mlpractical`\n", + " + and if you have chosen the **generic** way, `source` your virutal environment using `source` and specyfing the path to the activate script (you need to localise it yourself, there were not any general recommendations w.r.t dir structure and people have installed it in different places, usually somewhere in the home directories. If you cannot easily find it by yourself, use something like: `find . -iname activate` ):\n", + "\n", + "## On Synchronising repositories\n", + "\n", + "Enter the git mlp repository you set up last week (i.e. `~/mlpractical/repo-mlp`) and once you sync the repository (in one of the two below ways, or look at our short Git FAQ here), start the notebook session by typing:\n", + "\n", + "```\n", + "ipython notebook\n", + "```\n", + "\n", + "### Default way\n", + "\n", + "To avoid potential conflicts between the changes you have made since last week and our additions, we recommend `stash` your changes and `pull` the new code from the mlpractical repository by typing:\n", + "\n", + "1. `git stash save \"Lab1 work\"`\n", + "2. `git pull`\n", + "\n", + "Then, if you need to, you can always (temporaily) restore a desired state of the repository (look here).\n", + "\n", + "**Otherwise** you may also create a branch for each lab separately (again, look here and git tutorials we linked there), this will allow you to keep `master` branch clean, and pull changes into it every week from the central repository. At the same time branching gives you much more flexibility with changes you introduce to the code as potential conflicts will not occur until you try to make an explicit merge.\n", + "\n", + "### For advanced github users\n", + "\n", + "It is OK if you want to keep your changes and merge the new code with whatever you already have, but you need to know what you are doing and how to resolve conflicts.\n", + " \n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Single Layer Models\n", + "\n", + "***\n", + "### Note on storing matrices in computer memory\n", + "\n", + "Consider you want to store the following array in memory: $\\left[ \\begin{array}{ccc}\n", + "1 & 2 & 3 \\\\\n", + "4 & 5 & 6 \\\\\n", + "7 & 8 & 9 \\end{array} \\right]$ \n", + "\n", + "In computer memory the above matrix would be organised as a vector in either (assume you allocate the memory at once for the whole matrix):\n", + "\n", + "* Row-wise layout where the order would look like: $\\left [ \\begin{array}{ccccccccc}\n", + "1 & 2 & 3 & 4 & 5 & 6 & 7 & 8 & 9 \\end{array} \\right ]$\n", + "* Column-wise layout where the order would look like: $\\left [ \\begin{array}{ccccccccc}\n", + "1 & 4 & 7 & 2 & 5 & 8 & 3 & 6 & 9 \\end{array} \\right ]$\n", + "\n", + "Although `numpy` can easily handle both formats (possibly with some computational overhead), in our code we will stick with modern (and default) `c`-like approach and use row-wise format (contrary to Fortran that used column-wise approach). \n", + "\n", + "This means, that in this tutorial:\n", + "* vectors are kept row-wise $\\mathbf{x} = (x_1, x_1, \\ldots, x_D) $ (rather than $\\mathbf{x} = (x_1, x_1, \\ldots, x_D)^T$)\n", + "* similarly, in case of matrices we will stick to: $\\left[ \\begin{array}{cccc}\n", + "x_{11} & x_{12} & \\ldots & x_{1D} \\\\\n", + "x_{21} & x_{22} & \\ldots & x_{2D} \\\\\n", + "x_{31} & x_{32} & \\ldots & x_{3D} \\\\ \\end{array} \\right]$ and each row (i.e. $\\left[ \\begin{array}{cccc} x_{11} & x_{12} & \\ldots & x_{1D} \\end{array} \\right]$) represents a single data-point (like one MNIST image or one window of observations)\n", + "\n", + "In lecture slides you will find the equations following the conventional mathematical column-wise approach, but you can easily map them one way or the other using using matrix transpose.\n", + "\n", + "***\n", + "\n", + "## Linear and Affine Transforms\n", + "\n", + "The basis of all linear models is so called affine transform, that is a transform that implements some linear transformation and translation of input features. The transforms we are going to use are parameterised by:\n", + "\n", + " * Weight matrix $\\mathbf{W} \\in \\mathbb{R}^{D\\times K}$: where element $w_{ik}$ is the weight from input $x_i$ to output $y_k$\n", + " * Bias vector $\\mathbf{b}\\in R^{K}$ : where element $b_{k}$ is the bias for output $k$\n", + "\n", + "Note, the bias is simply some additve term, and can be easily incorporated into an additional row in weight matrix and an additinal input in the inputs which is set to $1.0$ (as in the below picture taken from the lecture slides). However, here (and in the code) we will keep them separate.\n", + "\n", + "![Making Predictions](res/singleLayerNetWts-1.png)\n", + "\n", + "For instance, for the above example of 5-dimensional input vector by $\\mathbf{x} = (x_1, x_2, x_3, x_4, x_5)$, weight matrix $\\mathbf{W}=\\left[ \\begin{array}{ccc}\n", + "w_{11} & w_{12} & w_{13} \\\\\n", + "w_{21} & w_{22} & w_{23} \\\\\n", + "w_{31} & w_{32} & w_{33} \\\\\n", + "w_{41} & w_{42} & w_{43} \\\\\n", + "w_{51} & w_{52} & w_{53} \\\\ \\end{array} \\right]$, bias vector $\\mathbf{b} = (b_1, b_2, b_3)$ and outputs $\\mathbf{y} = (y_1, y_2, y_3)$, one can write the transformation as follows:\n", + "\n", + "(for the $i$-th output)\n", + "\n", + "(1) $\n", + "\\begin{equation}\n", + " y_i = b_i + \\sum_j x_jw_{ji}\n", + "\\end{equation}\n", + "$\n", + "\n", + "or the equivalent vector form (where $\\mathbf w_i$ is the $i$-th column of $\\mathbf W$, but note, when we **slice** the $i$th column we will get a **vector** $\\mathbf w_i = (w_{1i}, w_{2i}, w_{3i}, w_{4i}, w_{5i})$, hence the transpose for $\\mathbf w_i$ in the below equation):\n", + "\n", + "(2) $\n", + "\\begin{equation}\n", + " y_i = b_i + \\mathbf x \\mathbf w_i^T\n", + "\\end{equation}\n", + "$\n", + "\n", + "The same operation can be also written in matrix form, to compute all the outputs $\\mathbf{y}$ at the same time:\n", + "\n", + "(3) $\n", + "\\begin{equation}\n", + " \\mathbf y=\\mathbf x\\mathbf W + \\mathbf b\n", + "\\end{equation}\n", + "$\n", + "\n", + "This is equivalent to slides 12/13 in lecture 1, except we are using row vectors.\n", + "\n", + "When $\\mathbf{x}$ is a mini-batch (contains $B$ data-points of dimension $D$ each), i.e. $\\left[ \\begin{array}{cccc}\n", + "x_{11} & x_{12} & \\ldots & x_{1D} \\\\\n", + "x_{21} & x_{22} & \\ldots & x_{2D} \\\\\n", + "\\cdots \\\\\n", + "x_{B1} & x_{B2} & \\ldots & x_{BD} \\\\ \\end{array} \\right]$ equation (3) effectively becomes to be\n", + "\n", + "(4) $\n", + "\\begin{equation}\n", + " \\mathbf Y=\\mathbf X\\mathbf W + \\mathbf b\n", + "\\end{equation}\n", + "$\n", + "\n", + "where both $\\mathbf{X}\\in\\mathbb{R}^{B\\times D}$ and $\\mathbf{Y}\\in\\mathbb{R}^{B\\times K}$ are matrices, and $\\mathbf{b}$ needs to be broadcasted $B$ times (numpy will do this by default). However, we will not make an explicit distinction between a special case for $B=1$ and $B>1$ and simply use equation (3) instead, although $\\mathbf{x}$ and hence $\\mathbf{y}$ could be matrices. From an implementation point of view, it does not matter.\n", + "\n", + "The desired functionality for matrix multiplication in numpy is provided by numpy.dot function. If you haven't use it so far, get familiar with it as we will use it extensively." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A general note on random number generators\n", + "\n", + "It is generally a good practice (for machine learning applications **not** for cryptography!) to seed a pseudo-random number generator once at the beginning of the experiment, and use it later through the code where necesarry. This makes it easier to reproduce results since random initialisations can be replicated. As such, within this course we are going use a single random generator object, similar to the below:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy\n", + "import sys\n", + "\n", + "#initialise the random generator to be used later\n", + "seed=[2015, 10, 1]\n", + "random_generator = numpy.random.RandomState(seed)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise 1 \n", + "\n", + "Using numpy.dot, implement **forward** propagation through the linear transform defined by equations (3) and (4) for $B=1$ and $B>1$. As data ($\\mathbf{x}$) use `MNISTDataProvider` from previous laboratories. For case when $B=1$ write a function to compute the 1st output ($y_1$) using equations (1) and (2). Check if the output is the same as the corresponding one obtained with numpy. \n", + "\n", + "Tip: To generate random data you can use `random_generator.uniform(-0.1, 0.1, (D, 10))` from the preceeding cell." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from mlp.dataset import MNISTDataProvider\n", + "\n", + "mnist_dp = MNISTDataProvider(dset='valid', batch_size=3, max_num_batches=1, randomize=False)\n", + "\n", + "irange = 0.1\n", + "W = random_generator.uniform(-irange, irange, (784,10)) \n", + "b = numpy.zeros((10,))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "y1e1 0.55861474982\n", + "y1e2 0.55861474982\n", + "ye3 [[ 0.55861475 0.79450077 0.17439693 0.00265688 0.66272539 -0.09985686\n", + " 0.56468591 0.58105588 -0.18613727 0.08151257]\n", + " [-0.43965864 0.59573972 -0.22691119 0.26767124 -0.31343979 0.07224664\n", + " -0.19616183 0.0851733 -0.24088286 -0.19305162]\n", + " [-0.20176359 0.42394166 -1.03984446 0.15492101 0.15694745 -0.53741022\n", + " 0.05887668 -0.21124527 -0.07870156 -0.00506471]]\n", + "ye4 [[ 0.55861475 0.79450077 0.17439693 0.00265688 0.66272539 -0.09985686\n", + " 0.56468591 0.58105588 -0.18613727 0.08151257]\n", + " [-0.43965864 0.59573972 -0.22691119 0.26767124 -0.31343979 0.07224664\n", + " -0.19616183 0.0851733 -0.24088286 -0.19305162]\n", + " [-0.20176359 0.42394166 -1.03984446 0.15492101 0.15694745 -0.53741022\n", + " 0.05887668 -0.21124527 -0.07870156 -0.00506471]]\n" + ] + } + ], + "source": [ + "\n", + "mnist_dp.reset()\n", + "\n", + "#implement following functions, then run the cell\n", + "def y1_equation_1(x, W, b):\n", + " y1=0\n", + " for j in xrange(0, x.shape[0]):\n", + " y1 += x[j]*W[j,0]\n", + " return y1 + b[0]\n", + " \n", + "def y1_equation_2(x, W, b):\n", + " return numpy.dot(x, W[:,0].T) + b[0]\n", + "\n", + "def y_equation_3(x, W, b):\n", + " return numpy.dot(x,W) + b\n", + "\n", + "def y_equation_4(x, W, b):\n", + " return numpy.dot(x,W) + b\n", + "\n", + "for x, t in mnist_dp:\n", + " y1e1 = y1_equation_1(x[0], W, b)\n", + " y1e2 = y1_equation_2(x[0], W, b)\n", + " ye3 = y_equation_3(x, W, b)\n", + " ye4 = y_equation_4(x, W, b)\n", + "\n", + "print 'y1e1', y1e1\n", + "print 'y1e2', y1e2\n", + "print 'ye3', ye3\n", + "print 'ye4', ye4\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Exercise 2\n", + "\n", + "Modify (if necessary) examples from Exercise 1 to perform **backward** propagation, that is, given $\\mathbf{y}$ (obtained in previous step) and weight matrix $\\mathbf{W}$, project $\\mathbf{y}$ onto the input space $\\mathbf{x}$ (ignore or set to zero the biases towards $\\mathbf{x}$ in backward pass). Mathematically, we are interested in the following transformation: $\\mathbf{z}=\\mathbf{y}\\mathbf{W}^T$" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-0.00683757 -0.13638553 0.00203203 ..., 0.02690207 -0.07364245\n", + " 0.04403087]\n", + " [-0.00447621 -0.06409652 0.01211384 ..., 0.0402248 -0.04490571\n", + " -0.05013801]\n", + " [ 0.03981022 -0.13705957 0.05882239 ..., 0.04491902 -0.08644539\n", + " -0.07106441]]\n" + ] + } + ], + "source": [ + "y = y_equation_3(x, W, b)\n", + "z = numpy.dot(y, W.T)\n", + "\n", + "print z\n", + "assert z.shape == x.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "## Exercise 3 (optional)\n", + "\n", + "In case you do not fully understand how matrix-vector and/or matrix-matrix products work, consider implementing `my_dot_mat_mat` function (you have been given `my_dot_vec_mat` code to look at as an example) which takes as the input the following arguments:\n", + "\n", + "* D-dimensional input vector $\\mathbf{x} = (x_1, x_2, \\ldots, x_D) $.\n", + "* Weight matrix $\\mathbf{W}\\in\\mathbb{R}^{D\\times K}$:\n", + "\n", + "and returns:\n", + "\n", + "* K-dimensional output vector $\\mathbf{y} = (y_1, \\ldots, y_K) $\n", + "\n", + "Your job is to write a variant that works in a mini-batch mode where both $\\mathbf{x}\\in\\mathbb{R}^{B\\times D}$ and $\\mathbf{y}\\in\\mathbb{R}^{B\\times K}$ are matrices in which each rows contain one of $B$ data-points from mini-batch (rather than $\\mathbf{x}\\in\\mathbb{R}^{D}$ and $\\mathbf{y}\\in\\mathbb{R}^{K}$)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "def my_dot_vec_mat(x, W):\n", + " J = x.shape[0]\n", + " K = W.shape[1]\n", + " assert (J == W.shape[0]), (\n", + " \"Number of columns of x expected to \"\n", + " \" to be equal to the number of rows in \"\n", + " \"W, bot got shapes %s, %s\" % (x.shape, W.shape)\n", + " )\n", + " y = numpy.zeros((K,))\n", + " for k in xrange(0, K):\n", + " for j in xrange(0, J):\n", + " y[k] += x[j] * W[j,k]\n", + " \n", + " return y" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Well done!\n" + ] + } + ], + "source": [ + "irange = 0.1 #+-range from which we draw the random numbers\n", + "\n", + "x = random_generator.uniform(-irange, irange, (5,)) \n", + "W = random_generator.uniform(-irange, irange, (5,3)) \n", + "\n", + "y_my = my_dot_vec_mat(x, W)\n", + "y_np = numpy.dot(x, W)\n", + "\n", + "same = numpy.allclose(y_my, y_np)\n", + "\n", + "if same:\n", + " print 'Well done!'\n", + "else:\n", + " print 'Matrices are different:'\n", + " print 'y_my is: ', y_my\n", + " print 'y_np is: ', y_np" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "def my_dot_mat_mat(x, W):\n", + " I = x.shape[0]\n", + " J = x.shape[1]\n", + " K = W.shape[1]\n", + " assert (J == W.shape[0]), (\n", + " \"Number of columns in of x expected to \"\n", + " \" to be the same as rows in W, got\"\n", + " )\n", + " #allocate the output container\n", + " y = numpy.zeros((I, K))\n", + " \n", + " #implement here matrix-matrix inner product here\n", + " for i in xrange(0, I):\n", + " for k in xrange(0, K):\n", + " for j in xrange(0, J):\n", + " y[i, k] += x[i, j] * W[j,k]\n", + " \n", + " return y" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Test whether you get comparable numbers to what numpy is producing:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Well done!\n" + ] + } + ], + "source": [ + "irange = 0.1 #+-range from which we draw the random numbers\n", + "\n", + "x = random_generator.uniform(-irange, irange, (2,5)) \n", + "W = random_generator.uniform(-irange, irange, (5,3)) \n", + "\n", + "y_my = my_dot_mat_mat(x, W)\n", + "y_np = numpy.dot(x, W)\n", + "\n", + "same = numpy.allclose(y_my, y_np)\n", + "\n", + "if same:\n", + " print 'Well done!'\n", + "else:\n", + " print 'Matrices are different:'\n", + " print 'y_my is: ', y_my\n", + " print 'y_np is: ', y_np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we benchmark each approach (we do it in separate cells, as timeit currently can measure whole cell execuiton only)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#generate bit bigger matrices, to better evaluate timings\n", + "x = random_generator.uniform(-irange, irange, (10, 1000))\n", + "W = random_generator.uniform(-irange, irange, (1000, 100))" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "my_dot timings:\n", + "10 loops, best of 3: 726 ms per loop\n" + ] + } + ], + "source": [ + "print 'my_dot timings:'\n", + "%timeit -n10 my_dot_mat_mat(x, W)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "numpy.dot timings:\n", + "10 loops, best of 3: 1.17 ms per loop\n" + ] + } + ], + "source": [ + "print 'numpy.dot timings:'\n", + "%timeit -n10 numpy.dot(x, W)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Optional section ends here**\n", + "***" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Iterative learning of linear models\n", + "\n", + "We will learn the model with stochastic gradient descent on N data-points using mean square error (MSE) loss function, which is defined as follows:\n", + "\n", + "(5) $\n", + "E = \\frac{1}{2} \\sum_{n=1}^N ||\\mathbf{y}^n - \\mathbf{t}^n||^2 = \\sum_{n=1}^N E^n \\\\\n", + " E^n = \\frac{1}{2} ||\\mathbf{y}^n - \\mathbf{t}^n||^2\n", + "$\n", + "\n", + "(6) $ E^n = \\frac{1}{2} \\sum_{k=1}^K (y_k^n - t_k^n)^2 $\n", + " \n", + "Hence, the gradient w.r.t (with respect to) the $r$ output y of the model is defined as, so called delta function, $\\delta_r$: \n", + "\n", + "(8) $\\frac{\\partial{E^n}}{\\partial{y_{r}}} = (y^n_r - t^n_r) = \\delta^n_r \\quad ; \\quad\n", + " \\delta^n_r = y^n_r - t^n_r \\\\\n", + " \\frac{\\partial{E}}{\\partial{y_{r}}} = \\sum_{n=1}^N \\frac{\\partial{E^n}}{\\partial{y_{r}}} = \\sum_{n=1}^N \\delta^n_r\n", + "$\n", + "\n", + "Similarly, using the above $\\delta^n_r$ one can express the gradient of the weight $w_{sr}$ (from the s-th input to the r-th output) for linear model and MSE cost as follows:\n", + "\n", + "(9) $\n", + " \\frac{\\partial{E^n}}{\\partial{w_{sr}}} = (y^n_r - t^n_r)x_s^n = \\delta^n_r x_s^n \\quad\\\\\n", + " \\frac{\\partial{E}}{\\partial{w_{sr}}} = \\sum_{n=1}^N \\frac{\\partial{E^n}}{\\partial{w_{rs}}} = \\sum_{n=1}^N \\delta^n_r x_s^n\n", + "$\n", + "\n", + "and the gradient for bias parameter at the $r$-th output is:\n", + "\n", + "(10) $\n", + " \\frac{\\partial{E}}{\\partial{b_{r}}} = \\sum_{n=1}^N \\frac{\\partial{E^n}}{\\partial{b_{r}}} = \\sum_{n=1}^N \\delta^n_r\n", + "$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "![Making Predictions](res/singleLayerNetPredict.png)\n", + " \n", + " * Input vector $\\mathbf{x} = (x_1, x_2, \\ldots, x_D) $\n", + " * Output scalar $y_1$\n", + " * Weight matrix $\\mathbf{W}$: $w_{ik}$ is the weight from input $x_i$ to output $y_k$. Note, here this is really a vector since a single scalar output, y_1.\n", + " * Scalar bias $b$ for the only output in our model \n", + " * Scalar target $t$ for the only output in out model\n", + " \n", + "First, ensure you can make use of data provider (note, for training data has been normalised to zero mean and unit variance, hence different effective range than one can find in file):" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Observations: [[-0.12 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13]\n", + " [-0.11 -0.1 0.09 -0.06 -0.09 -0. 0.28 -0.12 -0.12 -0.08]\n", + " [-0.13 0.05 -0.13 -0.01 -0.11 -0.13 -0.13 -0.13 -0.13 -0.13]\n", + " [ 0.2 0.12 0.25 0.16 0.03 -0. 0.15 0.08 -0.08 -0.11]\n", + " [-0.13 -0.12 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13]\n", + " [-0.1 0.51 1.52 0.14 -0.02 0.77 0.11 0.79 -0.02 0.08]\n", + " [ 0.24 0.15 -0.01 0.08 -0.1 0.45 -0.12 -0.1 -0.13 0.48]\n", + " [ 0.13 -0.06 -0.07 -0.11 -0.11 -0.11 -0.13 -0.11 -0.02 -0.12]\n", + " [-0.06 0.28 -0.13 0.06 0.09 0.09 0.01 -0.07 0.14 -0.11]\n", + " [-0.13 -0.13 -0.1 -0.06 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13]]\n", + "To predict: [[-0.12]\n", + " [-0.12]\n", + " [-0.13]\n", + " [-0.1 ]\n", + " [-0.13]\n", + " [-0.08]\n", + " [ 0.24]\n", + " [-0.13]\n", + " [-0.02]\n", + " [-0.13]]\n", + "Observations: [[-0.09 -0.13 -0.13 -0.03 -0.05 -0.11 -0.13 -0.13 -0.13 -0.13]\n", + " [-0.03 0.32 0.28 0.09 -0.04 0.19 0.31 -0.13 0.37 0.34]\n", + " [ 0.12 0.13 0.06 -0.1 -0.1 0.94 0.24 0.12 0.28 -0.04]\n", + " [ 0.26 0.17 -0.04 -0.13 -0.12 -0.09 -0.12 -0.13 -0.1 -0.13]\n", + " [-0.1 -0.1 -0.01 -0.03 -0.07 0.05 -0.03 -0.12 -0.05 -0.13]\n", + " [-0.13 -0.13 -0.13 -0.13 -0.13 -0.13 0.1 -0.13 -0.13 -0.13]\n", + " [-0.01 -0.1 -0.13 -0.13 -0.12 -0.13 -0.13 -0.13 -0.13 -0.11]\n", + " [-0.11 -0.06 -0.11 0.02 -0.03 -0.02 -0.05 -0.11 -0.13 -0.13]\n", + " [-0.01 0.25 -0.08 0.04 -0.1 -0.12 0.06 -0.1 0.08 -0.06]\n", + " [-0.09 -0.09 -0.09 -0.13 -0.11 -0.12 -0. -0.02 0.19 -0.11]]\n", + "To predict: [[-0.13]\n", + " [-0.11]\n", + " [-0.09]\n", + " [-0.08]\n", + " [ 0.19]\n", + " [-0.13]\n", + " [-0.13]\n", + " [-0.03]\n", + " [-0.13]\n", + " [-0.11]]\n", + "Observations: [[-0.08 -0.11 -0.11 0.32 0.05 -0.11 -0.13 0.07 0.08 0.63]\n", + " [-0.07 -0.1 -0.09 -0.08 0.26 -0.05 -0.1 -0. 0.36 -0.12]\n", + " [-0.03 -0.1 0.19 -0.02 0.35 0.38 -0.1 0.44 -0.02 0.21]\n", + " [-0.12 -0. -0.02 0.19 -0.11 -0.11 -0.13 -0.11 -0.02 -0.13]\n", + " [ 0.09 0.1 -0.03 -0.05 0. -0.12 -0.12 -0.13 -0.13 -0.13]\n", + " [ 0.21 0.05 -0.12 -0.05 -0.08 -0.1 -0.13 -0.13 -0.13 -0.13]\n", + " [-0.04 -0.11 0.19 0.16 -0.01 -0.07 -0. -0.06 -0.03 0.16]\n", + " [ 0.09 0.05 0.51 0.34 0.16 0.51 0.56 0.21 -0.06 -0. ]\n", + " [-0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.13 -0.09 0.49]\n", + " [-0.06 -0.11 -0.13 0.06 -0.01 -0.12 0.54 0.2 -0.1 -0.11]]\n", + "To predict: [[ 0.1 ]\n", + " [ 0.09]\n", + " [ 0.16]\n", + " [-0.13]\n", + " [-0.13]\n", + " [ 0.04]\n", + " [-0.1 ]\n", + " [ 0.05]\n", + " [-0.1 ]\n", + " [-0.11]]\n" + ] + } + ], + "source": [ + "from mlp.dataset import MetOfficeDataProvider\n", + "\n", + "modp = MetOfficeDataProvider(10, batch_size=10, max_num_batches=3, randomize=True)\n", + "\n", + "%precision 2\n", + "for x, t in modp:\n", + " print 'Observations: ', x\n", + " print 'To predict: ', t" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise 4\n", + "\n", + "The below code implements a very simple variant of stochastic gradient descent for the weather regression example. Your task is to implement 5 functions in the next cell and then run two next cells that 1) build sgd functions and 2) run the actual training." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "\n", + "#When implementing those, take into account the mini-batch case, for which one is\n", + "#expected to sum the errors for each example\n", + "\n", + "def fprop(x, W, b):\n", + " #code implementing eq. (3)\n", + " return numpy.dot(x, W) + b\n", + "\n", + "def cost(y, t):\n", + " #Mean Square Error cost, equation (5)\n", + " return numpy.mean(0.5*numpy.sum((y - t)**2, axis=1))\n", + "\n", + "def cost_grad(y, t):\n", + " #Gradient of the cost w.r.t y equation (8)\n", + " return y - t\n", + "\n", + "def cost_wrt_W(cost_grad, x):\n", + " #Gradient of the cost w.r.t W, equation (9)\n", + " return numpy.dot(x.T, cost_grad)\n", + " \n", + "def cost_wrt_b(cost_grad):\n", + " #Gradient of the cost w.r.t to b, equation (10)\n", + " return numpy.sum(cost_grad, axis = 0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "\n", + "def sgd_epoch(data_provider, W, b, learning_rate):\n", + " mse_stats = []\n", + " \n", + " #get the minibatch of data\n", + " for x, t in data_provider:\n", + "\n", + " #1. get the estimate of y\n", + " y = fprop(x, W, b)\n", + "\n", + " #2. compute the loss function\n", + " tmp = cost(y, t)\n", + " mse_stats.append(tmp)\n", + " \n", + " #3. compute the grad of the cost w.r.t the output layer activation y\n", + " #i.e. how the cost changes when output y changes\n", + " cost_grad_deltas = cost_grad(y, t)\n", + "\n", + " #4. compute the gradients w.r.t model's parameters\n", + " grad_W = cost_wrt_W(cost_grad_deltas, x)\n", + " grad_b = cost_wrt_b(cost_grad_deltas)\n", + "\n", + " #4. Update the model, we update with the mean gradient\n", + " # over the minibatch, rather than sum of particular gradients\n", + " # in a minibatch, to do so we scale the learning rate by batch_size\n", + " batch_size = x.shape[0]\n", + " effect_learn_rate = learning_rate / batch_size\n", + "\n", + " W = W - effect_learn_rate * grad_W\n", + " b = b - effect_learn_rate * grad_b\n", + " \n", + " return W, b, numpy.mean(mse_stats)\n", + "\n", + "def sgd(data_provider, W, b, learning_rate=0.1, max_epochs=10):\n", + " \n", + " for epoch in xrange(0, max_epochs):\n", + " #reset the data provider\n", + " data_provider.reset()\n", + " \n", + " #train for one epoch\n", + " W, b, mean_cost = \\\n", + " sgd_epoch(data_provider, W, b, learning_rate)\n", + " \n", + " print \"MSE training cost after %d-th epoch is %f\" % (epoch + 1, mean_cost)\n", + " \n", + " return W, b\n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "collapsed": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "MSE training cost after 1-th epoch is 0.017213\n", + "MSE training cost after 2-th epoch is 0.016103\n", + "MSE training cost after 3-th epoch is 0.015705\n", + "MSE training cost after 4-th epoch is 0.015437\n", + "MSE training cost after 5-th epoch is 0.015255\n", + "MSE training cost after 6-th epoch is 0.015128\n", + "MSE training cost after 7-th epoch is 0.015041\n", + "MSE training cost after 8-th epoch is 0.014981\n", + "MSE training cost after 9-th epoch is 0.014936\n", + "MSE training cost after 10-th epoch is 0.014903\n", + "MSE training cost after 11-th epoch is 0.014879\n", + "MSE training cost after 12-th epoch is 0.014862\n", + "MSE training cost after 13-th epoch is 0.014849\n", + "MSE training cost after 14-th epoch is 0.014839\n", + "MSE training cost after 15-th epoch is 0.014830\n", + "MSE training cost after 16-th epoch is 0.014825\n", + "MSE training cost after 17-th epoch is 0.014820\n", + "MSE training cost after 18-th epoch is 0.014813\n", + "MSE training cost after 19-th epoch is 0.014813\n", + "MSE training cost after 20-th epoch is 0.014810\n", + "MSE training cost after 21-th epoch is 0.014808\n", + "MSE training cost after 22-th epoch is 0.014805\n", + "MSE training cost after 23-th epoch is 0.014806\n", + "MSE training cost after 24-th epoch is 0.014804\n", + "MSE training cost after 25-th epoch is 0.014796\n", + "MSE training cost after 26-th epoch is 0.014798\n", + "MSE training cost after 27-th epoch is 0.014801\n", + "MSE training cost after 28-th epoch is 0.014802\n", + "MSE training cost after 29-th epoch is 0.014801\n", + "MSE training cost after 30-th epoch is 0.014799\n", + "MSE training cost after 31-th epoch is 0.014799\n", + "MSE training cost after 32-th epoch is 0.014793\n", + "MSE training cost after 33-th epoch is 0.014800\n", + "MSE training cost after 34-th epoch is 0.014796\n", + "MSE training cost after 35-th epoch is 0.014799\n", + "MSE training cost after 36-th epoch is 0.014800\n", + "MSE training cost after 37-th epoch is 0.014798\n", + "MSE training cost after 38-th epoch is 0.014799\n", + "MSE training cost after 39-th epoch is 0.014799\n", + "MSE training cost after 40-th epoch is 0.014794\n" + ] + }, + { + "data": { + "text/plain": [ + "(array([[ 0.01],\n", + " [ 0.03],\n", + " [ 0.03],\n", + " [ 0.04],\n", + " [ 0.06],\n", + " [ 0.07],\n", + " [ 0.26]]), array([-0.]))" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "#some hyper-parameters\n", + "window_size = 7\n", + "irange = 0.1\n", + "learning_rate = 0.001\n", + "max_epochs=40\n", + "\n", + "# note, while developing you can set max_num_batches to some positive number to limit\n", + "# the number of training data-points (you will get feedback faster)\n", + "mdp = MetOfficeDataProvider(window_size, batch_size=10, max_num_batches=-100, randomize=True)\n", + "\n", + "#initialise the parameters\n", + "W = random_generator.uniform(-irange, irange, (window_size, 1))\n", + "b = random_generator.uniform(-irange, irange, (1, ))\n", + "\n", + "#train the model\n", + "sgd(mdp, W, b, learning_rate=learning_rate, max_epochs=max_epochs)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Exercise 5\n", + "\n", + "Modify the above regression problem so the model makes binary classification whether the the weather is going to be one of those \\{rainy, sunny} (look at slide 12 of the 2nd lecture)\n", + "\n", + "Tip: You need to introduce the following changes:\n", + "1. Modify `MetOfficeDataProvider` (for example, inherit from MetOfficeDataProvider to create a new class MetOfficeDataProviderBin) and modify `next()` function so it returns as `targets` either 0 (sunny - if the the amount of rain [before mean/variance normalisation] is equal to 0 or 1 (rainy -- otherwise).\n", + "2. Modify the functions from previous exercise so the fprop implements `sigmoid` on top of affine transform.\n", + "3. Modify cost function to binary cross-entropy\n", + "4. Make sure you compute the gradients correctly (as you have changed both the output and the cost)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#sorry, this one will be added later..." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/mlp/dataset.py b/mlp/dataset.py index 75e4626..86857f2 100644 --- a/mlp/dataset.py +++ b/mlp/dataset.py @@ -60,6 +60,13 @@ class DataProvider(object): """ raise NotImplementedError() + def num_examples(self): + """ + Returns a number of data-points in dataset + """ + return NotImplementedError() + + class MNISTDataProvider(DataProvider): """ @@ -142,6 +149,9 @@ class MNISTDataProvider(DataProvider): return rval_x, self.__to_one_of_k(rval_t) + def num_examples(self): + return self.x.shape[0] + def __to_one_of_k(self, y): rval = numpy.zeros((y.shape[0], self.num_classes), dtype=numpy.float32) for i in xrange(y.shape[0]): From 2b1700180eec99d5393e5b920ec7fe8a56fd0c12 Mon Sep 17 00:00:00 2001 From: pswietojanski Date: Mon, 12 Oct 2015 01:50:05 +0100 Subject: [PATCH 2/5] addded code-base --- mlp/costs.py | 64 ++ mlp/layers.py | 281 ++++++ mlp/optimisers.py | 170 ++++ mlp/schedulers.py | 155 ++++ res/code_scheme.svg | 2030 +++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 2700 insertions(+) create mode 100644 mlp/costs.py create mode 100644 mlp/layers.py create mode 100644 mlp/optimisers.py create mode 100644 mlp/schedulers.py create mode 100644 res/code_scheme.svg diff --git a/mlp/costs.py b/mlp/costs.py new file mode 100644 index 0000000..942920a --- /dev/null +++ b/mlp/costs.py @@ -0,0 +1,64 @@ +# Machine Learning Practical (INFR11119), +# Pawel Swietojanski, University of Edinburgh + + +import numpy + + +class Cost(object): + """ + Defines an interface for the cost object + """ + def cost(self, y, t, **kwargs): + """ + Implements a cost for monitoring purposes + :param y: matrix -- an output of the model + :param t: matrix -- an expected output the model should produce + :param kwargs: -- some optional parameters required by the cost + :return: the scalar value representing the cost given y and t + """ + raise NotImplementedError() + + def grad(self, y, t, **kwargs): + """ + Implements a gradient of the cost w.r.t y + :param y: matrix -- an output of the model + :param t: matrix -- an expected output the model should produce + :param kwargs: -- some optional parameters required by the cost + :return: matrix - the gradient of the cost w.r.t y + """ + raise NotImplementedError() + + def get_name(self): + return 'cost' + + +class MSECost(Cost): + def cost(self, y, t, **kwargs): + se = 0.5*numpy.sum((y - t)**2, axis=1) + return numpy.mean(se) + + def grad(self, y, t, **kwargs): + return y - t + + def get_name(self): + return 'mse' + + +class CECost(Cost): + """ + Cross Entropy (Negative log-likelihood) cost for multiple classes + """ + def cost(self, y, t, **kwargs): + #assumes t is 1-of-K coded and y is a softmax + #transformed estimate at the output layer + nll = t * numpy.log(y) + return -numpy.mean(numpy.sum(nll, axis=1)) + + def grad(self, y, t, **kwargs): + #assumes t is 1-of-K coded and y is a softmax + #transformed estimate at the output layer + return y - t + + def get_name(self): + return 'ce' diff --git a/mlp/layers.py b/mlp/layers.py new file mode 100644 index 0000000..c511792 --- /dev/null +++ b/mlp/layers.py @@ -0,0 +1,281 @@ + +# Machine Learning Practical (INFR11119), +# Pawel Swietojanski, University of Edinburgh + +import numpy +import logging +from mlp.costs import Cost + + +logger = logging.getLogger(__name__) + + +class MLP(object): + """ + This is a container for an arbitrary sequence of other transforms + On top of this, the class also keeps the state of the model, i.e. + the result of forward (activations) and backward (deltas) passes + through the model (for a mini-batch), which is required to compute + the gradients for the parameters + """ + def __init__(self, cost): + + assert isinstance(cost, Cost), ( + "Cost needs to be of type mlp.costs.Cost, got %s" % type(cost) + ) + + self.layers = [] #the actual list of network layers + self.activations = [] #keeps forward-pass activations (h from equations) + # for a given minibatch (or features at 0th index) + self.deltas = [] #keeps back-propagated error signals (deltas from equations) + # for a given minibatch and each layer + self.cost = cost + + def fprop(self, x): + """ + + :param inputs: mini-batch of data-points x + :return: y (top layer activation) which is an estimate of y given x + """ + + if len(self.activations) != len(self.layers) + 1: + self.activations = [None]*(len(self.layers) + 1) + + self.activations[0] = x + for i in xrange(0, len(self.layers)): + self.activations[i+1] = self.layers[i].fprop(self.activations[i]) + return self.activations[-1] + + def bprop(self, cost_grad): + """ + :param cost_grad: matrix -- grad of the cost w.r.t y + :return: None, the deltas are kept in the model + """ + + # allocate the list of deltas for each layer + # note, we do not use all of those fields but + # want to keep it aligned 1:1 with activations, + # which will simplify indexing later on when + # computing grads w.r.t parameters + if len(self.deltas) != len(self.activations): + self.deltas = [None]*len(self.activations) + + # treat the top layer in special way, as it deals with the + # cost, which may lead to some simplifications + top_layer_idx = len(self.layers) + self.deltas[top_layer_idx], ograds = self.layers[top_layer_idx - 1].\ + bprop_cost(self.activations[top_layer_idx], cost_grad, self.cost) + + # then back-prop through remaining layers + for i in xrange(top_layer_idx - 1, 0, -1): + self.deltas[i], ograds = self.layers[i - 1].\ + bprop(self.activations[i], ograds) + + def add_layer(self, layer): + self.layers.append(layer) + + def set_layers(self, layers): + self.layers = layers + + def get_name(self): + return 'mlp' + + +class Layer(object): + """ + Abstract class defining an interface for + other transforms. + """ + def __init__(self, rng=None): + + if rng is None: + seed=[2015, 10, 1] + self.rng = numpy.random.RandomState(seed) + else: + self.rng = rng + + def fprop(self, inputs): + """ + Implements a forward propagation through the i-th layer, that is + some form of: + a^i = xW^i + b^i + h^i = f^i(a^i) + with f^i, W^i, b^i denoting a non-linearity, weight matrix and + biases at the i-th layer, respectively and x denoting inputs. + + :param inputs: matrix of features (x) or the output of the previous layer h^{i-1} + :return: h^i, matrix of transformed by layer features + """ + raise NotImplementedError() + + def bprop(self, h, igrads): + """ + Implements a backward propagation through the layer, that is, given + h^i denotes the output of the layer and x^i the input, we compute: + dh^i/dx^i which by chain rule is dh^i/da^i da^i/dx^i + x^i could be either features (x) or the output of the lower layer h^{i-1} + :param h: it's an activation produced in forward pass + :param igrads, error signal (or gradient) flowing to the layer, note, + this in general case does not corresponds to 'deltas' used to update + the layer's parameters, to get deltas ones need to multiply it with + the dh^i/da^i derivative + :return: a tuple (deltas, ograds) where: + deltas = igrads * dh^i/da^i + ograds = deltas \times da^i/dx^i + """ + raise NotImplementedError() + + def bprop_cost(self, h, igrads, cost=None): + """ + Implements a backward propagation in case the layer directly + deals with the optimised cost (i.e. the top layer) + By default, method should implement a back-prop for default cost, that is + the one that is natural to the layer's output, i.e.: + linear -> mse, softmax -> cross-entropy, sigmoid -> binary cross-entropy + :param h: it's an activation produced in forward pass + :param igrads, error signal (or gradient) flowing to the layer, note, + this in general case does not corresponds to 'deltas' used to update + the layer's parameters, to get deltas ones need to multiply it with + the dh^i/da^i derivative + :return: a tuple (deltas, ograds) where: + deltas = igrads * dh^i/da^i + ograds = deltas \times da^i/dx^i + """ + + raise NotImplementedError() + + def pgrads(self, inputs, deltas): + """ + Return gradients w.r.t parameters + """ + raise NotImplementedError() + + def get_params(self): + raise NotImplementedError() + + def set_params(self): + raise NotImplementedError() + + def get_name(self): + return 'abstract_layer' + + +class Linear(Layer): + + def __init__(self, idim, odim, + rng=None, + irange=0.1): + + super(Linear, self).__init__(rng=rng) + + self.idim = idim + self.odim = odim + + self.W = self.rng.uniform( + -irange, irange, + (self.idim, self.odim)) + + self.b = numpy.zeros((self.odim,), dtype=numpy.float32) + + def fprop(self, inputs): + """ + Implements a forward propagation through the i-th layer, that is + some form of: + a^i = xW^i + b^i + h^i = f^i(a^i) + with f^i, W^i, b^i denoting a non-linearity, weight matrix and + biases of this (i-th) layer, respectively and x denoting inputs. + + :param inputs: matrix of features (x) or the output of the previous layer h^{i-1} + :return: h^i, matrix of transformed by layer features + """ + a = numpy.dot(inputs, self.W) + self.b + # here f() is an identity function, so just return a linear transformation + return a + + def bprop(self, h, igrads): + """ + Implements a backward propagation through the layer, that is, given + h^i denotes the output of the layer and x^i the input, we compute: + dh^i/dx^i which by chain rule is dh^i/da^i da^i/dx^i + x^i could be either features (x) or the output of the lower layer h^{i-1} + :param h: it's an activation produced in forward pass + :param igrads, error signal (or gradient) flowing to the layer, note, + this in general case does not corresponds to 'deltas' used to update + the layer's parameters, to get deltas ones need to multiply it with + the dh^i/da^i derivative + :return: a tuple (deltas, ograds) where: + deltas = igrads * dh^i/da^i + ograds = deltas \times da^i/dx^i + """ + + # since df^i/da^i = 1 (f is assumed identity function), + # deltas are in fact the same as igrads + ograds = numpy.dot(igrads, self.W.T) + return igrads, ograds + + def bprop_cost(self, h, igrads, cost): + """ + Implements a backward propagation in case the layer directly + deals with the optimised cost (i.e. the top layer) + By default, method should implement a bprop for default cost, that is + the one that is natural to the layer's output, i.e.: + here we implement linear -> mse scenario + :param h: it's an activation produced in forward pass + :param igrads, error signal (or gradient) flowing to the layer, note, + this in general case does not corresponds to 'deltas' used to update + the layer's parameters, to get deltas ones need to multiply it with + the dh^i/da^i derivative + :param cost, mlp.costs.Cost instance defining the used cost + :return: a tuple (deltas, ograds) where: + deltas = igrads * dh^i/da^i + ograds = deltas \times da^i/dx^i + """ + + if cost is None or cost.get_name() == 'mse': + # for linear layer and mean square error cost, + # cost back-prop is the same as standard back-prop + return self.bprop(h, igrads) + else: + raise NotImplementedError('Linear.bprop_cost method not implemented ' + 'for the %s cost' % cost.get_name()) + + def pgrads(self, inputs, deltas): + """ + Return gradients w.r.t parameters + + :param inputs, input to the i-th layer + :param deltas, deltas computed in bprop stage up to -ith layer + :return list of grads w.r.t parameters dE/dW and dE/db in *exactly* + the same order as the params are returned by get_params() + + Note: deltas here contain the whole chain rule leading + from the cost up to the the i-th layer, i.e. + dE/dy^L dy^L/da^L da^L/dh^{L-1} dh^{L-1}/da^{L-1} ... dh^{i}/da^{i} + and here we are just asking about + 1) da^i/dW^i and 2) da^i/db^i + since W and b are only layer's parameters + """ + + grad_W = numpy.dot(inputs.T, deltas) + grad_b = numpy.sum(deltas, axis=0) + + return [grad_W, grad_b] + + def get_params(self): + return [self.W, self.b] + + def set_params(self, params): + #we do not make checks here, but the order on the list + #is assumed to be exactly the same as get_params() returns + self.W = params[0] + self.b = params[1] + + def get_name(self): + return 'linear' + + + + + + \ No newline at end of file diff --git a/mlp/optimisers.py b/mlp/optimisers.py new file mode 100644 index 0000000..9d4b947 --- /dev/null +++ b/mlp/optimisers.py @@ -0,0 +1,170 @@ +# Machine Learning Practical (INFR11119), +# Pawel Swietojanski, University of Edinburgh + +import numpy +import time +import logging + +from mlp.layers import MLP +from mlp.dataset import DataProvider +from mlp.schedulers import LearningRateScheduler + + +logger = logging.getLogger(__name__) + + +class Optimiser(object): + def train_epoch(self, model, train_iter): + raise NotImplementedError() + + def train(self, model, train_iter, valid_iter=None): + raise NotImplementedError() + + def validate(self, model, valid_iterator): + assert isinstance(model, MLP), ( + "Expected model to be a subclass of 'mlp.layers.MLP'" + " class but got %s " % type(model) + ) + + assert isinstance(valid_iterator, DataProvider), ( + "Expected iterator to be a subclass of 'mlp.dataset.DataProvider'" + " class but got %s " % type(valid_iterator) + ) + + acc_list, nll_list = [], [] + for x, t in valid_iterator: + y = model.fprop(x) + nll_list.append(model.cost.cost(y, t)) + acc_list.append(numpy.mean(self.classification_accuracy(y, t))) + + acc = numpy.mean(acc_list) + nll = numpy.mean(nll_list) + + return nll, acc + + @staticmethod + def classification_accuracy(y, t): + """ + Returns classification accuracy given the estimate y and targets t + :param y: matrix -- estimate produced by the model in fprop + :param t: matrix -- target 1-of-K coded + :return: vector of y.shape[0] size with binary values set to 0 + if example was miscalssified or 1 otherwise + """ + y_idx = numpy.argmax(y, axis=1) + t_idx = numpy.argmax(t, axis=1) + rval = numpy.equal(y_idx, t_idx) + return rval + + +class SGDOptimiser(Optimiser): + def __init__(self, lr_scheduler): + super(SGDOptimiser, self).__init__() + + assert isinstance(lr_scheduler, LearningRateScheduler), ( + "Expected lr_scheduler to be a subclass of 'mlp.schedulers.LearningRateScheduler'" + " class but got %s " % type(lr_scheduler) + ) + + self.lr_scheduler = lr_scheduler + + def train_epoch(self, model, train_iterator, learning_rate): + + assert isinstance(model, MLP), ( + "Expected model to be a subclass of 'mlp.layers.MLP'" + " class but got %s " % type(model) + ) + assert isinstance(train_iterator, DataProvider), ( + "Expected iterator to be a subclass of 'mlp.dataset.DataProvider'" + " class but got %s " % type(train_iterator) + ) + + acc_list, nll_list = [], [] + for x, t in train_iterator: + # get the prediction + y = model.fprop(x) + + # compute the cost and grad of the cost w.r.t y + cost = model.cost.cost(y, t) + cost_grad = model.cost.grad(y, t) + + # do backward pass through the model + model.bprop(cost_grad) + + #update the model, here we iterate over layers + #and then over each parameter in the layer + effective_learning_rate = learning_rate / x.shape[0] + + for i in xrange(0, len(model.layers)): + params = model.layers[i].get_params() + grads = model.layers[i].pgrads(model.activations[i], model.deltas[i + 1]) + uparams = [] + for param, grad in zip(params, grads): + param = param - effective_learning_rate * grad + uparams.append(param) + model.layers[i].set_params(uparams) + + nll_list.append(cost) + acc_list.append(numpy.mean(self.classification_accuracy(y, t))) + + return numpy.mean(nll_list), numpy.mean(acc_list) + + def train(self, model, train_iterator, valid_iterator=None): + + converged = False + cost_name = model.cost.get_name() + tr_stats, valid_stats = [], [] + + # do the initial validation + tr_nll, tr_acc = self.validate(model, train_iterator) + logger.info('Epoch %i: Training cost (%s) for random model is %.3f. Accuracy is %.2f%%' + % (self.lr_scheduler.epoch, cost_name, tr_nll, tr_acc * 100.)) + tr_stats.append((tr_nll, tr_acc)) + + if valid_iterator is not None: + valid_iterator.reset() + valid_nll, valid_acc = self.validate(model, valid_iterator) + logger.info('Epoch %i: Validation cost (%s) for random model is %.3f. Accuracy is %.2f%%' + % (self.lr_scheduler.epoch, cost_name, valid_nll, valid_acc * 100.)) + valid_stats.append((valid_nll, valid_acc)) + + while not converged: + train_iterator.reset() + + tstart = time.clock() + tr_nll, tr_acc = self.train_epoch(model=model, + train_iterator=train_iterator, + learning_rate=self.lr_scheduler.get_rate()) + tstop = time.clock() + tr_stats.append((tr_nll, tr_acc)) + + logger.info('Epoch %i: Training cost (%s) is %.3f. Accuracy is %.2f%%' + % (self.lr_scheduler.epoch + 1, cost_name, tr_nll, tr_acc * 100.)) + + vstart = time.clock() + if valid_iterator is not None: + valid_iterator.reset() + valid_nll, valid_acc = self.validate(model, valid_iterator) + logger.info('Epoch %i: Validation cost (%s) is %.3f. Accuracy is %.2f%%' + % (self.lr_scheduler.epoch + 1, cost_name, valid_nll, valid_acc * 100.)) + self.lr_scheduler.get_next_rate(valid_acc) + valid_stats.append((valid_nll, valid_acc)) + else: + self.lr_scheduler.get_next_rate(None) + vstop = time.clock() + + train_speed = train_iterator.num_examples() / (tstop - tstart) + valid_speed = valid_iterator.num_examples() / (vstop - vstart) + tot_time = vstop - tstart + #pps = presentations per second + logger.info("Epoch %i: Took %.0f seconds. Training speed %.0f pps. " + "Validation speed %.0f pps." + % (self.lr_scheduler.epoch, tot_time, train_speed, valid_speed)) + + # we stop training when learning rate, as returned by lr scheduler, is 0 + # this is implementation dependent and depending on lr schedule could happen, + # for example, when max_epochs has been reached or if the progress between + # two consecutive epochs is too small, etc. + converged = (self.lr_scheduler.get_rate() == 0) + + return tr_stats, valid_stats diff --git a/mlp/schedulers.py b/mlp/schedulers.py new file mode 100644 index 0000000..f5499e6 --- /dev/null +++ b/mlp/schedulers.py @@ -0,0 +1,155 @@ +# Machine Learning Practical (INFR11119), +# Pawel Swietojanski, University of Edinburgh + +import logging + + +class LearningRateScheduler(object): + """ + Define an interface for determining learning rates + """ + def __init__(self, max_epochs=100): + self.epoch = 0 + self.max_epochs = max_epochs + + def get_rate(self): + raise NotImplementedError() + + def get_next_rate(self, current_error=None): + self.epoch += 1 + + +class LearningRateList(LearningRateScheduler): + def __init__(self, learning_rates_list, max_epochs): + + super(LearningRateList, self).__init__(max_epochs) + + assert isinstance(learning_rates_list, list), ( + "The learning_rates_list argument expected" + " to be of type list, got %s" % type(learning_rates_list) + ) + self.lr_list = learning_rates_list + + def get_rate(self): + if self.epoch < len(self.lr_list): + return self.lr_list[self.epoch] + return 0.0 + + def get_next_rate(self, current_error=None): + super(LearningRateList, self).get_next_rate(current_error=None) + return self.get_rate() + + +class LearningRateFixed(LearningRateList): + + def __init__(self, learning_rate, max_epochs): + assert learning_rate > 0, ( + "learning rate expected to be > 0, got %f" % learning_rate + ) + super(LearningRateFixed, self).__init__([learning_rate], max_epochs) + + def get_rate(self): + if self.epoch < self.max_epochs: + return self.lr_list[0] + return 0.0 + + def get_next_rate(self, current_error=None): + super(LearningRateFixed, self).get_next_rate(current_error=None) + return self.get_rate() + + +class LearningRateNewBob(LearningRateScheduler): + """ + Exponential learning rate schema + """ + + def __init__(self, start_rate, scale_by=.5, max_epochs=99, \ + min_derror_ramp_start=.5, min_derror_stop=.5, init_error=100.0, \ + patience=0, zero_rate=None, ramping=False): + """ + :type start_rate: float + :param start_rate: + + :type scale_by: float + :param scale_by: + + :type max_epochs: int + :param max_epochs: + + :type min_error_start: float + :param min_error_start: + + :type min_error_stop: float + :param min_error_stop: + + :type init_error: float + :param init_error: + # deltas2 below are just deltas returned by linear Linear,bprop transform + # and are exactly the same as + """ + self.start_rate = start_rate + self.init_error = init_error + self.init_patience = patience + + self.rate = start_rate + self.scale_by = scale_by + self.max_epochs = max_epochs + self.min_derror_ramp_start = min_derror_ramp_start + self.min_derror_stop = min_derror_stop + self.lowest_error = init_error + + self.epoch = 1 + self.ramping = ramping + self.patience = patience + self.zero_rate = zero_rate + + def reset(self): + self.rate = self.start_rate + self.lowest_error = self.init_error + self.epoch = 1 + self.ramping = False + self.patience = self.init_patience + + def get_rate(self): + if (self.epoch==1 and self.zero_rate!=None): + return self.zero_rate + return self.rate + + def get_next_rate(self, current_error): + """ + :type current_error: float + :param current_error: percentage error + + """ + + diff_error = 0.0 + + if ( (self.max_epochs > 10000) or (self.epoch >= self.max_epochs) ): + #logging.debug('Setting rate to 0.0. max_epochs or epoch>=max_epochs') + self.rate = 0.0 + else: + diff_error = self.lowest_error - current_error + + if (current_error < self.lowest_error): + self.lowest_error = current_error + + if (self.ramping): + if (diff_error < self.min_derror_stop): + if (self.patience > 0): + #logging.debug('Patience decreased to %f' % self.patience) + self.patience -= 1 + self.rate *= self.scale_by + else: + #logging.debug('diff_error (%f) < min_derror_stop (%f)' % (diff_error, self.min_derror_stop)) + self.rate = 0.0 + else: + self.rate *= self.scale_by + else: + if (diff_error < self.min_derror_ramp_start): + #logging.debug('Start ramping.') + self.ramping = True + self.rate *= self.scale_by + + self.epoch += 1 + + return self.rate diff --git a/res/code_scheme.svg b/res/code_scheme.svg new file mode 100644 index 0000000..0b0eec8 --- /dev/null +++ b/res/code_scheme.svg @@ -0,0 +1,2030 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + image/svg+xml + + + + + + + The Model + Forward Computation + Backward computation + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + E(y,t)(here assumed cross-entropy) + + + + + + + + + + + + + + + + ParameterUpdates + + + + + + + + + + + + + + + + + + + From 28ccdd9c8b78ca54a33382b78342115e862935b1 Mon Sep 17 00:00:00 2001 From: pswietojanski Date: Mon, 12 Oct 2015 01:52:54 +0100 Subject: [PATCH 3/5] lab and coursework --- 02_MNIST_SLN.ipynb | 292 ++++++++++++++++++++++++++++++++++ 03_MLP_Coursework1.ipynb | 328 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 620 insertions(+) create mode 100644 02_MNIST_SLN.ipynb create mode 100644 03_MLP_Coursework1.ipynb diff --git a/02_MNIST_SLN.ipynb b/02_MNIST_SLN.ipynb new file mode 100644 index 0000000..eab08f4 --- /dev/null +++ b/02_MNIST_SLN.ipynb @@ -0,0 +1,292 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction\n", + "\n", + "This tutorial is an introduction to the coursework about multi-layer preceptron (MLP) models, or Deep Neural Networks (DNNs). Here, we will show how to build a single layer linear model (similar to the one from the previous lab) for MNIST classification using the provided code-base. \n", + "\n", + "The principal purpose of this introduction is to get you familiar with how to connect the provided blocks (and what operations each of them implements) to set up an experiment, including 1) build the model structure 2) optimise the model's parameters and 3) evaluate the model on test data. \n", + "\n", + "## For those affected by notebook kernel issues\n", + "\n", + "In case you are still having issues with running notebook kernels, have a look at [this note](https://github.com/CSTR-Edinburgh/mlpractical/blob/master/kernel_issue_fix.md) on the GitHub.\n", + "\n", + "## Virtual environments\n", + "\n", + "Before you proceed onwards, remember to activate your virtual environment:\n", + " * If you were in last week's Tuesday or Wednesday group type `activate_mlp` or `source ~/mlpractical/venv/bin/activate`\n", + " * If you were in the Monday group:\n", + " + and if you have chosen the **comfy** way type: `workon mlpractical`\n", + " + and if you have chosen the **generic** way, `source` your virutal environment using `source` and specyfing the path to the activate script (you need to localise it yourself, there were not any general recommendations w.r.t dir structure and people have installed it in different places, usually somewhere in the home directories. If you cannot easily find it by yourself, use something like: `find . -iname activate` ):\n", + "\n", + "## Syncing repos\n", + "\n", + "Look here for more details. But in short, we recommend to create a separate branch for the coursework, as follows:\n", + "\n", + "1. Enter the mlpractical directory `cd ~/mlpractical/repo-mlp`\n", + "2. List the branches and check which is currently active by typing: `git checkout`\n", + "3. Change the\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Multi Layer Models\n", + "\n", + "Today, we are going to build the models with an arbitrary number of hidden layers, please have a look at the below diagram and the corresponding computations (which have an *exact* matrix form as expected by numpy and row-wise orientation, $\\circ$ denotes an element-wise product). Below the diagram, we briefly describe how each comptation relates to the code we have provided.\n", + "\n", + "![Making Predictions](res/code_scheme.svg)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Structuring the model\n", + " * The model (for now) is allowed to have a sequence of layers, mapping inputs $\\mathbf{x}$ to outputs $\\mathbf{y}$. \n", + " * This operation is implemented as a special type of a layer in `mlp.layers.MLP` class. It keeps a sequence of other layers (of various typyes like Linear, Sigmoid, Softmax, etc.) as well as the internal state of a model for a mini-batch, that is, the intermediate data produced in *forward* and *backward* passes.\n", + "2. Forward computation\n", + " * `mlp.layers.MLP` provides a `fprop()` method that iterates over defined layers propagates $\\mathbf{x}$ to $\\mathbf{y}$. \n", + " * Each layer (look at `mlp.layers.Linear` attached below) also implements `fprop()` method, which performs an atomic, for the given layer, operation. Most often, for the $i$-th layer, we want to obtain a linear transform $\\mathbf a^i$ of the inputs, and apply some non-linear transfer function $f^i(\\mathbf a^i)$ to produce the output $\\mathbf h^i$. Note, in general each layer may implement different activation functions $f^i()$, however for now we will use only `sigmoid` and `softmax`\n", + "3. Backward computation\n", + " * Similarly, `mlp.layers.MLP` also implements `bprop()` function, to back-propagate the errors from the top to the bottom layer. This class also keeps the back-propagated stats ($\\delta$) to be used later when computing the gradients w.r.t the parameters.\n", + " * This functionality is also re-implemented by particular layers (again, have a look at `bprop` function of `mlp.layers.Linear`). `bprop()` is suppsed to return both $\\delta$ (needed to update the parameters) but also back-progapate the gradient down to the inputs. Also note, that depending on whether the layer is the top or not (deals directly with the cost or not) some simplifications may apply (i.e. as with cross-entropy and softmax). That's why when implementing a new type of layer that may be used as an output layer one also need to specify the implementation of `bprop_cost()`.\n", + "4. Learning the model\n", + " * The actual evaluation of the cost as well as the *forward* and *backward* passes one may find `train_epoch()` method of `mlp.optimisers.SGDOptimiser`\n", + " * This function also calls the `pgrads()` method on each layer, that given activations and deltas, is supposed to return the list of the gradients of the cost w.r.t the model parameters, i.e. $\\frac{\\partial{\\mathbf{E}}}{\\partial{\\mathbf{W^i}}}$ and $\\frac{\\partial{\\mathbf{E}}}{\\partial{\\mathbf{b}^i}}$ at the above diagram (look at an example implementation in `mlp.layers.Linear`)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# %load -s Linear mlp/layers.py\n", + "class Linear(Layer):\n", + "\n", + " def __init__(self, idim, odim,\n", + " rng=None,\n", + " irange=0.1):\n", + "\n", + " super(Linear, self).__init__(rng=rng)\n", + "\n", + " self.idim = idim\n", + " self.odim = odim\n", + "\n", + " self.W = self.rng.uniform(\n", + " -irange, irange,\n", + " (self.idim, self.odim))\n", + "\n", + " self.b = numpy.zeros((self.odim,), dtype=numpy.float32)\n", + "\n", + " def fprop(self, inputs):\n", + " \"\"\"\n", + " Implements a forward propagation through the i-th layer, that is\n", + " some form of:\n", + " a^i = xW^i + b^i\n", + " h^i = f^i(a^i)\n", + " with f^i, W^i, b^i denoting a non-linearity, weight matrix and\n", + " biases of this (i-th) layer, respectively and x denoting inputs.\n", + "\n", + " :param inputs: matrix of features (x) or the output of the previous layer h^{i-1}\n", + " :return: h^i, matrix of transformed by layer features\n", + " \"\"\"\n", + " a = numpy.dot(inputs, self.W) + self.b\n", + " # here f() is an identity function, so just return a linear transformation\n", + " return a\n", + "\n", + " def bprop(self, h, igrads):\n", + " \"\"\"\n", + " Implements a backward propagation through the layer, that is, given\n", + " h^i denotes the output of the layer and x^i the input, we compute:\n", + " dh^i/dx^i which by chain rule is dh^i/da^i da^i/dx^i\n", + " x^i could be either features (x) or the output of the lower layer h^{i-1}\n", + " :param h: it's an activation produced in forward pass\n", + " :param igrads, error signal (or gradient) flowing to the layer, note,\n", + " this in general case does not corresponds to 'deltas' used to update\n", + " the layer's parameters, to get deltas ones need to multiply it with\n", + " the dh^i/da^i derivative\n", + " :return: a tuple (deltas, ograds) where:\n", + " deltas = igrads * dh^i/da^i\n", + " ograds = deltas \\times da^i/dx^i\n", + " \"\"\"\n", + "\n", + " # since df^i/da^i = 1 (f is assumed identity function),\n", + " # deltas are in fact the same as igrads\n", + " ograds = numpy.dot(igrads, self.W.T)\n", + " return igrads, ograds\n", + "\n", + " def bprop_cost(self, h, igrads, cost):\n", + " \"\"\"\n", + " Implements a backward propagation in case the layer directly\n", + " deals with the optimised cost (i.e. the top layer)\n", + " By default, method should implement a bprop for default cost, that is\n", + " the one that is natural to the layer's output, i.e.:\n", + " here we implement linear -> mse scenario\n", + " :param h: it's an activation produced in forward pass\n", + " :param igrads, error signal (or gradient) flowing to the layer, note,\n", + " this in general case does not corresponds to 'deltas' used to update\n", + " the layer's parameters, to get deltas ones need to multiply it with\n", + " the dh^i/da^i derivative\n", + " :param cost, mlp.costs.Cost instance defining the used cost\n", + " :return: a tuple (deltas, ograds) where:\n", + " deltas = igrads * dh^i/da^i\n", + " ograds = deltas \\times da^i/dx^i\n", + " \"\"\"\n", + "\n", + " if cost is None or cost.get_name() == 'mse':\n", + " # for linear layer and mean square error cost,\n", + " # cost back-prop is the same as standard back-prop\n", + " return self.bprop(h, igrads)\n", + " else:\n", + " raise NotImplementedError('Linear.bprop_cost method not implemented '\n", + " 'for the %s cost' % cost.get_name())\n", + "\n", + " def pgrads(self, inputs, deltas):\n", + " \"\"\"\n", + " Return gradients w.r.t parameters\n", + "\n", + " :param inputs, input to the i-th layer\n", + " :param deltas, deltas computed in bprop stage up to -ith layer\n", + " :return list of grads w.r.t parameters dE/dW and dE/db in *exactly*\n", + " the same order as the params are returned by get_params()\n", + "\n", + " Note: deltas here contain the whole chain rule leading\n", + " from the cost up to the the i-th layer, i.e.\n", + " dE/dy^L dy^L/da^L da^L/dh^{L-1} dh^{L-1}/da^{L-1} ... dh^{i}/da^{i}\n", + " and here we are just asking about\n", + " 1) da^i/dW^i and 2) da^i/db^i\n", + " since W and b are only layer's parameters\n", + " \"\"\"\n", + "\n", + " grad_W = numpy.dot(inputs.T, deltas)\n", + " grad_b = numpy.sum(deltas, axis=0)\n", + "\n", + " return [grad_W, grad_b]\n", + "\n", + " def get_params(self):\n", + " return [self.W, self.b]\n", + "\n", + " def set_params(self, params):\n", + " #we do not make checks here, but the order on the list\n", + " #is assumed to be exactly the same as get_params() returns\n", + " self.W = params[0]\n", + " self.b = params[1]\n", + "\n", + " def get_name(self):\n", + " return 'linear'\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example 1: Experiment with linear models and MNIST\n", + "\n", + "The below snippet demonstrates how to use the code we have provided for the coursework 1. Get familiar with it, as from now on we will use till the end of the course, including the 2nd coursework.\n", + "\n", + "It should be straightforward to extend the following code to more complex models, like stack more layers, change the cost, the optimiser, learning rate schedules, etc.. But **ask** in case something is not clear.\n", + "\n", + "In this particular example, we use the following components:\n", + " * One layer mapping data-points ($\\mathbf x$) straight to 10 digits classes represented as 10 (linear) outputs ($\\mathbf y$). This operation is implemented as a linear layer in `mlp.layers.Linear`. Get familiar with this class (read the comments, etc.) as it is going to be a building block for the coursework.\n", + " * One can stack as many different layers as required through the container `mlp.layers.MLP`\n", + " * As an objective here we use the Mean Square Error cost defined in `mlp.costs.MSECost`\n", + " * Our *Stochastic Gradient Descent* optimiser can be found in `mlp.optimisers.SGDOptimiser`. Its parent `mlp.optimisers.Optimiser` implements validation functionality (and an interface in case one need to implement a different optimiser)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy\n", + "import logging\n", + "\n", + "logger = logging.getLogger()\n", + "logger.setLevel(logging.INFO)\n", + "\n", + "from mlp.layers import MLP, Linear #import required layer types\n", + "from mlp.optimisers import SGDOptimiser #import the optimiser\n", + "from mlp.dataset import MNISTDataProvider #import data provider\n", + "from mlp.costs import MSECost #import the cost we want to use for optimisation\n", + "from mlp.schedulers import LearningRateFixed\n", + "\n", + "rng = numpy.random.RandomState([2015,10,10])\n", + "\n", + "# define the model structure, here just one linear layer\n", + "# and mean square error cost\n", + "cost = MSECost()\n", + "model = MLP(cost=cost)\n", + "model.add_layer(Linear(idim=784, odim=10, rng=rng))\n", + "#one can stack more layers here\n", + "\n", + "# define the optimiser, here stochasitc gradient descent\n", + "# with fixed learning rate and max_epochs as stopping criterion\n", + "lr_scheduler = LearningRateFixed(learning_rate=0.01, max_epochs=20)\n", + "optimiser = SGDOptimiser(lr_scheduler=lr_scheduler)\n", + "\n", + "logger.info('Initialising data providers...')\n", + "train_dp = MNISTDataProvider(dset='train', batch_size=100, max_num_batches=-10, randomize=True)\n", + "valid_dp = MNISTDataProvider(dset='valid', batch_size=100, max_num_batches=-10, randomize=False)\n", + "\n", + "logger.info('Training started...')\n", + "optimiser.train(model, train_dp, valid_dp)\n", + "\n", + "logger.info('Testing the model on test set:')\n", + "test_dp = MNISTDataProvider(dset='eval', batch_size=100, max_num_batches=-10, randomize=False)\n", + "cost, accuracy = optimiser.validate(model, test_dp)\n", + "logger.info('MNIST test set accuracy is %.2f %% (cost is %.3f)'%(accuracy*100., cost))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise\n", + "\n", + "Modify the above code by adding an intemediate linear layer of size 200 hidden units between input and output layers." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/03_MLP_Coursework1.ipynb b/03_MLP_Coursework1.ipynb new file mode 100644 index 0000000..5236ba6 --- /dev/null +++ b/03_MLP_Coursework1.ipynb @@ -0,0 +1,328 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Coursework #1\n", + "\n", + "## Introduction\n", + "\n", + "This coursework is concerned with building multi-layer networks to address the MNIST digit classification problem. It builds on the previous labs, in particular [02_MNIST_SLN.ipynb](02_MNIST_SLN.ipynb) in which single layer networks were trained for MNIST digit classification. The course will involve extending that code to use Sigmoid and Softmax layers, combining these into multi-layer networks, and carrying out a number of MNIST digit classification experiments, to investigate the effect of learning rate, the number of hidden units, and the number of hidden layers.\n", + "\n", + "The coursework is divided into 4 tasks:\n", + "* **Task 1**: *Implementing a sigmoid layer* - 15 marks. \n", + "This task involves extending the `Linear` class in file `mlp/layers.py` to `Sigmoid`, with code for forward prop, backprop computation of the gradient, and weight update.\n", + "* **Task 2**: *Implementing a softmax layer* - 15 marks. \n", + "This task involves extending the `Linear` class in file `mlp/layers.py` to `Softmax`, with code for forward prop, backprop computation of the gradient, and weight update.\n", + "* **Task 3**: *Constructing a multi-layer network* - 40 marks. \n", + "This task involves putting together a Sigmoid and a Softmax layer to create a multi-layer network, with one hidden layer (100 units) and one output layer, that is trained to classify MNIST digits. This task will include reporting classification results, exploring the effect of learning rates, and plotting Hinton Diagrams for the hidden units and output units.\n", + "* **Task 4**: *Experiments with different architectures* - 30 marks. \n", + "This task involves further MNIST classification experiments, primarily looking at the effect of using different numbers of hidden layers.\n", + "The coursework will be marked out of 100, and will contribute 30% of the total mark in the MLP course.\n", + "\n", + "## Previous Tutorials\n", + "\n", + "Before starting this coursework make sure that you have completed the first three labs:\n", + "\n", + "* [00_Introduction.ipynb](00_Introduction.ipynb) - setting up your environment; *Solutions*: [00_Introduction_solution.ipynb](00_Introduction_solution.ipynb)\n", + "* [01_Linear_models.ipynb](01_Linear_models.ipynb) - training single layer networks; *Solutions*: [01_Linear_models_solution.ipynb](01_Linear_models_solution.ipynb)\n", + "* [02_MNIST_SLN.ipynb](02_MNIST_SLN.ipynb) - training a single layer network for MNIST digit classification\n", + "\n", + "To ensure that your virtual environment is correct, please see [this note](https://github.com/CSTR-Edinburgh/mlpractical/blob/master/kernel_issue_fix.md) on the GitHub.\n", + "## Submission\n", + "**Submission Deadline: Thursday 29 October, 16:00** \n", + "\n", + "Submit the coursework as an ipython notebook file, using the `submit` command in the terminal on a DICE machine. If your file is `03_MLP_Coursework1.ipynb` then you would enter:\n", + "\n", + "`submit mlp 1 03_MLP_Coursework1.ipynb` \n", + "\n", + "where `mlp 1` indicates this is the first coursework of MLP.\n", + "\n", + "After submitting, you should receive an email of acknowledgment from the system confirming that your submission has been received successfully. Keep the email as evidence of your coursework submission.\n", + "\n", + "**Please make sure you submit a single `ipynb` file (and nothing else)!**\n", + "\n", + "**Submission Deadline: Thursday 29 October, 16:00** \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Getting Started\n", + "Please enter your exam number and the date in the next code cell." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "#MLP Coursework 1\n", + "#Exam number: \n", + "#Date: \n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Please run the next code cell, which imports `numpy` and seeds the random number generator. Please **do not** modify the random number generator seed!" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "import numpy\n", + "\n", + "#Seed a random number generator running the below cell, but do **not** modify the seed.\n", + "rng = numpy.random.RandomState([2015,10,10])\n", + "rng_state = rng.get_state()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Task 1 - Sigmoid Layer (15%)\n", + "\n", + "In this task you need to create a class `Sigmoid` which encapsulates a layer of `sigmoid` units. You should do this by extending the `mlp.layers.Linear` class (in file `mlp/layers.py`), which implements a a layer of linear units (i.e. weighted sum plus bias). The `Sigmoid` class extends this by applying the `sigmoid` transfer function to the weighted sum in the forward propagation, and applying the derivative of the `sigmoid` in the gradient descent back propagation and computing the gradients with respect to layer's parameters. Do **not** copy the implementation provided in `Linear` class but rather, **reuse** it through inheritance.\n", + "\n", + "When you have implemented `Sigmoid` (in the `mlp.layers` module), then please test it by running the below code cell.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from mlp.layers import Sigmoid\n", + "\n", + "a = numpy.asarray([-20.1, 52.4, 0, 0.05, 0.05, 49])\n", + "b = numpy.asarray([-20.1, 52.4, 0, 0.05, 0.05, 49, 20, 20])\n", + "\n", + "rng.set_state(rng_state)\n", + "sigm = Sigmoid(idim=a.shape[0], odim=b.shape[0], rng=rng)\n", + "\n", + "fp = sigm.fprop(a)\n", + "deltas, ograds = sigm.bprop(h=fp, igrads=b)\n", + "\n", + "print fp.sum()\n", + "print deltas.sum()\n", + "print ograds.sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "To include the `Sigmoid` code in the notebook please run the below code cell. (The `%load` notebook command is used to load the source of the `Sigmoid` class from `mlp/layers.py`.)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%load -s Sigmoid mlp/layers.py\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Task 2 - Softmax (15%)\n", + "\n", + "In this task you need to create a class `Softmax` which encapsulates a layer of `softmax` units. As in the previous task, you should do this by extending the `mlp.layers.Linear` class (in file `mlp/layers.py`).\n", + "\n", + "When you have implemented `Softmax` (in the `mlp.layers` module), then please test it by running the below code cell.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "from mlp.layers import Softmax\n", + "\n", + "a = numpy.asarray([-20.1, 52.4, 0, 0.05, 0.05, 49])\n", + "b = numpy.asarray([0, 0, 0, 0, 0, 0, 0, 1])\n", + "\n", + "rng.set_state(rng_state)\n", + "softmax = Softmax(idim=a.shape[0], odim=b.shape[0], rng=rng)\n", + "\n", + "fp = softmax.fprop(a)\n", + "deltas, ograds = softmax.bprop_cost(h=None, igrads=fp-b, cost=None)\n", + "\n", + "print fp.sum()\n", + "print deltas.sum()\n", + "print ograds.sum()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***\n", + "To include the `Softmax` code in the notebook please run the below code cell. (The notebook `%load` command is used to load the source of the `Softmax` class from `mlp/layers.py`.)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%load -s Softmax mlp/layers.py" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Task 3 - Multi-layer network for MNIST classification (40%)\n", + "\n", + "**(a)** (20%) Building on the single layer linear network for MNIST classification used in lab [02_MNIST_SLN.ipynb](02_MNIST_SLN.ipynb), and using the `Sigmoid` and `Softmax` classes that you implemented in tasks 1 and 2, construct and learn a model that classifies MNIST images and:\n", + " * Has one hidden layer with a `sigmoid` transfer function and 100 units\n", + " * Uses a `softmax` output layer to discriminate between the 10 digit classes (use the `mlp.costs.CECost()` cost)\n", + "\n", + "Your code should print the final values of the error function and the classification accuracy for train, validation, and test sets (please keep also the log information printed by default by the optimiser). Limit the number of training epochs to 30. You can, of course, split the solution at as many cells as you think is necessary." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "# include here the complete code that constructs the model, performs training,\n", + "# and prints the error and accuracy for train/valid/test" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**(b)** (10%) Investigate the impact of different learning rates $\\eta \\in \\{0.5, 0.2, 0.1, 0.05, 0.01, 0.005\\}$ on the convergence of the network training as well as the final accuracy:\n", + " * Plot (on a single graph) the error rate curves for each learning rate as a function of training epochs for training set\n", + " * Plot (on another single graph) the error rate curves as a function of training epochs for validation set\n", + " * Include a table of the corresponding error rates for test set\n", + "\n", + "The notebook command `%matplotlib inline` ensures that your graphs will be added to the notebook, rather than opened as additional windows." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": false + }, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**(c)** (10%) Plot the following graphs:\n", + " * Display the 784-element weight vector of each of the 100 hidden units as 10x10 grid plot of 28x28 images, in order to visualise what features of the input they are encoding. To do this, take the weight vector of each hidden unit, reshape to 28x28, and plot using the `imshow` function).\n", + " * Plot a Hinton Diagram of the output layer weight matrix for digits 0 and 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "%matplotlib inline" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "## Task 4 - Experiments with 1-5 hidden layers (30%)\n", + "\n", + "In this task use the learning rate which resulted in the best accuracy in your experiments in Task 3 (b). Perform the following experiments:\n", + "\n", + " * Train a similar model to Task 3, with one hidden layer, but with 800 hidden units. \n", + " * Train 4 additional models with 2, 3, 4 and 5 hidden layers. Set the number of hidden units for each model, such that all the models have similar number of trainable weights ($\\pm$2%). For simplicity, for a given model, keep the number of units in each hidden layer the same.\n", + " * Plot value of the error function for training and validation sets as a function of training epochs for each model\n", + " * Plot the test set classification accuracy as a function of the number of hidden layers\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true + }, + "source": [ + "This is the end of coursework 1.\n", + "\n", + "Please remember to save your notebook, and submit your notebook following the instructions at the top. Please make sure that you have executed all the code cells when you submit the notebook.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 2", + "language": "python", + "name": "python2" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.9" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} From 3513d2f225cc8a3b7b9dace6dd3c05be557f6eaf Mon Sep 17 00:00:00 2001 From: pswietojanski Date: Mon, 12 Oct 2015 01:57:54 +0100 Subject: [PATCH 4/5] lab and coursework --- 03_MLP_Coursework1.ipynb | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/03_MLP_Coursework1.ipynb b/03_MLP_Coursework1.ipynb index 5236ba6..9bd251a 100644 --- a/03_MLP_Coursework1.ipynb +++ b/03_MLP_Coursework1.ipynb @@ -26,7 +26,7 @@ "Before starting this coursework make sure that you have completed the first three labs:\n", "\n", "* [00_Introduction.ipynb](00_Introduction.ipynb) - setting up your environment; *Solutions*: [00_Introduction_solution.ipynb](00_Introduction_solution.ipynb)\n", - "* [01_Linear_models.ipynb](01_Linear_models.ipynb) - training single layer networks; *Solutions*: [01_Linear_models_solution.ipynb](01_Linear_models_solution.ipynb)\n", + "* [01_Linear_Models.ipynb](01_Linear_Models.ipynb) - training single layer networks; *Solutions*: [01_Linear_Models_solution.ipynb](01_Linear_Models_solution.ipynb)\n", "* [02_MNIST_SLN.ipynb](02_MNIST_SLN.ipynb) - training a single layer network for MNIST digit classification\n", "\n", "To ensure that your virtual environment is correct, please see [this note](https://github.com/CSTR-Edinburgh/mlpractical/blob/master/kernel_issue_fix.md) on the GitHub.\n", From b04f150e05c26eb58dc5a9c9979ef441e84d1d4b Mon Sep 17 00:00:00 2001 From: pswietojanski Date: Mon, 12 Oct 2015 02:06:37 +0100 Subject: [PATCH 5/5] lab and coursework --- 02_MNIST_SLN.ipynb | 14 ++++++++++++-- 1 file changed, 12 insertions(+), 2 deletions(-) diff --git a/02_MNIST_SLN.ipynb b/02_MNIST_SLN.ipynb index eab08f4..84b2ee1 100644 --- a/02_MNIST_SLN.ipynb +++ b/02_MNIST_SLN.ipynb @@ -28,8 +28,18 @@ "\n", "1. Enter the mlpractical directory `cd ~/mlpractical/repo-mlp`\n", "2. List the branches and check which is currently active by typing: `git checkout`\n", - "3. Change the\n", - " " + "3. If you are not in `master` branch, switch to it by typing: \n", + "```\n", + "git checkout master\n", + " ```\n", + "4. Then update the repository (note, assuming master does not have any conflicts), if there are some, have a look here\n", + "```\n", + "git pull\n", + "```\n", + "5. And now, create the new branch & swith to it by typing:\n", + "```\n", + "git checkout -b coursework1\n", + "```" ] }, {