From 06274298ba951171aef3aab2fd05e81a8cb480ef Mon Sep 17 00:00:00 2001 From: Sundeep Rangan Date: Fri, 1 Nov 2024 13:08:16 -0400 Subject: [PATCH] Began conversion to pytorch --- unit09_neural/demo1_synthetic.ipynb | 1962 +++++++++++++++------------ 1 file changed, 1100 insertions(+), 862 deletions(-) diff --git a/unit09_neural/demo1_synthetic.ipynb b/unit09_neural/demo1_synthetic.ipynb index 1f86c020..cc655c49 100644 --- a/unit09_neural/demo1_synthetic.ipynb +++ b/unit09_neural/demo1_synthetic.ipynb @@ -1,866 +1,1104 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# A First Neural Network Example\n", - "\n", - "In this demo, you will learn:\n", - "* How to construct and train a simple neural network with one hidden layer using the `keras` package\n", - "* How to get the weights and intermediate layer outputs of a `keras` network after training\n", - "* How to visualize the weights \n", - "\n", - "To illustrate the concepts, we consider a simple 2D classification problem on completely synthetic data. Using synthetic data will allow us to visualize the network more easily. We will then look at real data in later demos " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Loading Tensorflow and Keras\n", - "\n", - "Before starting this demo, you will need to install [Tensorflow](https://www.tensorflow.org/install/). If you are using [Google colaboratory](https://colab.research.google.com), Tensorflw is already installed.\n", - "\n", - "Tensorflow is a powerful and widely-used platform for deep learning. However, Tensorflow is relatively low level and may be a somewhat difficult to use as a starting point. In this class, we will use the `keras` package which acts as a high-level wrapper on top of tensorflow that allows you to quickly build and fit models. In 2018, `keras` was included as part of tensorflow and you do not need to separately install it. Building most neural networks in `keras` is generally much simpler than in raw Tensorflow and is perfect for getting started. Later, if you want more flexibility, you can learn how to build models in Tensorflow directly.\n", - "\n", - "First we check that tensorflow is installed." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "import tensorflow as tf" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We also load some other common packages." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "## Synthetic Data \n", - "\n", - "To illustrate the neural network we generate data with some rule that will create an interesting classification region. " - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "nsamp = 400 # number of samples to generate\n", - "nx = 2 # number of dimensions of each sample\n", - "\n", - "# The features are generated uniformly on the square [0,1] x [0,1]\n", - "X = np.random.uniform(0,1,(nsamp,nx))\n", - "\n", - "# The class of each sample is determined by some Gaussian. The particular function is not important.\n", - "rsq = (X[:,0]-0.5)**2 + (X[:,1]-0.5)**2\n", - "z = 10*(np.exp(-8*rsq)-0.5)\n", - "py = 1/(1+np.exp(-z))\n", - "u = np.random.uniform(0,1,nsamp)\n", - "y = (u < py).astype(int)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We create a scatter plot of the data. You can see that it is not linearly seperable. " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "I0 = np.where(y==0)[0]\n", - "I1 = np.where(y==1)[0]\n", - "plt.plot(X[I0,0], X[I0,1], 'bo')\n", - "plt.plot(X[I1,0], X[I1,1], 'go')\n", - "plt.xlabel('$x_0$', fontsize=16)\n", - "plt.ylabel('$x_1$', fontsize=16)\n", - "plt.subplots_adjust(bottom=0.2, left=0.2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Creating a Simple Neural Network." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We see that the above points are not linearly separable. We will see if we can build a simple neural network classifier to find a good decision region. We first import some key sub-packages from `keras`." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "from tensorflow.keras.models import Model, Sequential\n", - "from tensorflow.keras.layers import Dense, Activation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next, we clear the session. This is not strictly necessary, but it is good practice as it clears any model layers that you have built before. Otherwise, they keep hanging around." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "import tensorflow.keras.backend as K\n", - "K.clear_session()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we create a very simple network with one hidden layer with `nh=4` hidden units. There is `nout=1` output unit corresponding to the estimated class label." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "nin = nx # dimension of input data\n", - "nh = 4 # number of hidden units\n", - "nout = 1 # number of outputs = 1 since this is binary\n", - "model = Sequential()\n", - "model.add(Dense(units=nh, input_shape=(nx,), activation='sigmoid', name='hidden'))\n", - "model.add(Dense(units=nout, activation='sigmoid', name='output'))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Keras provides a nice command for visualizing the layers. " - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model: \"sequential\"\n", - "_________________________________________________________________\n", - "Layer (type) Output Shape Param # \n", - "=================================================================\n", - "hidden (Dense) (None, 4) 12 \n", - "_________________________________________________________________\n", - "output (Dense) (None, 1) 5 \n", - "=================================================================\n", - "Total params: 17\n", - "Trainable params: 17\n", - "Non-trainable params: 0\n", - "_________________________________________________________________\n" - ] - } - ], - "source": [ - "model.summary()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Training the Network\n", - "\n", - "To train the network, we have to select an optimizer and a loss function. Since this is a binary classification problem, we select the `binary_crossentropy` loss. For the optimizer, `adam` tends to works well over a wide range of problems and is a good starting point. We also set the `metrics` that we wish to track during the optimization. In this case, we select `accuracy` on the training set." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "from tensorflow.keras import optimizers\n", - "\n", - "opt = optimizers.Adam(lr=0.01)\n", - "model.compile(optimizer=opt,\n", - " loss='binary_crossentropy',\n", - " metrics=['accuracy'])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Keras provides a simple method `fit` to run the optimization. You simply specify the number of epochs and the batch size, both discussed in class." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1/10\n", - "1/4 [======>.......................] - ETA: 0s - loss: 1.0893 - accuracy: 0.3000WARNING:tensorflow:Callbacks method `on_train_batch_end` is slow compared to the batch time (batch time: 0.0000s vs `on_train_batch_end` time: 0.0010s). Check your callbacks.\n", - "4/4 [==============================] - 0s 998us/step - loss: 1.0329 - accuracy: 0.3275\n", - "Epoch 2/10\n", - "4/4 [==============================] - 0s 499us/step - loss: 0.9672 - accuracy: 0.3275\n", - "Epoch 3/10\n", - "4/4 [==============================] - 0s 499us/step - loss: 0.9107 - accuracy: 0.3275\n", - "Epoch 4/10\n", - "4/4 [==============================] - 0s 749us/step - loss: 0.8607 - accuracy: 0.3275\n", - "Epoch 5/10\n", - "4/4 [==============================] - 0s 1ms/step - loss: 0.8197 - accuracy: 0.3275\n", - "Epoch 6/10\n", - "4/4 [==============================] - 0s 748us/step - loss: 0.7867 - accuracy: 0.3275\n", - "Epoch 7/10\n", - "4/4 [==============================] - 0s 749us/step - loss: 0.7583 - accuracy: 0.3275\n", - "Epoch 8/10\n", - "4/4 [==============================] - 0s 1ms/step - loss: 0.7336 - accuracy: 0.3275\n", - "Epoch 9/10\n", - "4/4 [==============================] - 0s 748us/step - loss: 0.7155 - accuracy: 0.3275\n", - "Epoch 10/10\n", - "4/4 [==============================] - 0s 996us/step - loss: 0.6995 - accuracy: 0.3700\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "model.fit(X, y, epochs=10, batch_size=100)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Unfortunately, for this problem, we need a large number of epochs -- around 1000. We don't want to print out the progress on each epoch. So, the code below disables the print outs by setting `verbose=0`. Then, we run the optimization in 20 iterations with 50 epochs per iteration -- a total of 1000 epochs. In each iteration, we use the `evaluate` method to get the loss function and accuracy and print that out manually." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch= 50 loss= 6.3162e-01 acc=0.67250\n", - "epoch= 100 loss= 6.2887e-01 acc=0.67250\n", - "epoch= 150 loss= 6.1870e-01 acc=0.67250\n", - "epoch= 200 loss= 5.9900e-01 acc=0.67250\n", - "epoch= 250 loss= 5.8234e-01 acc=0.67250\n", - "epoch= 300 loss= 5.6792e-01 acc=0.67250\n", - "epoch= 350 loss= 5.4315e-01 acc=0.66250\n", - "epoch= 400 loss= 5.1379e-01 acc=0.70750\n", - "epoch= 450 loss= 4.9202e-01 acc=0.75500\n", - "epoch= 500 loss= 4.7016e-01 acc=0.78000\n", - "epoch= 550 loss= 4.3800e-01 acc=0.82000\n", - "epoch= 600 loss= 3.9530e-01 acc=0.85750\n", - "epoch= 650 loss= 3.5553e-01 acc=0.88750\n", - "epoch= 700 loss= 3.2679e-01 acc=0.88000\n", - "epoch= 750 loss= 3.0766e-01 acc=0.88000\n", - "epoch= 800 loss= 2.9511e-01 acc=0.88250\n", - "epoch= 850 loss= 2.8648e-01 acc=0.88250\n", - "epoch= 900 loss= 2.8037e-01 acc=0.88250\n", - "epoch= 950 loss= 2.7580e-01 acc=0.88500\n", - "epoch=1000 loss= 2.7241e-01 acc=0.88250\n" - ] - } - ], - "source": [ - "nit = 20 # number of training iterations\n", - "nepoch_per_it = 50 # number of epochs per iterations\n", - "\n", - "# Loss, accuracy and epoch per iteration\n", - "loss = np.zeros(nit)\n", - "acc = np.zeros(nit)\n", - "epoch_it = np.zeros(nit)\n", - "\n", - "# Main iteration loop\n", - "for it in range(nit):\n", - " \n", - " # Continue the fit of the model\n", - " init_epoch = it*nepoch_per_it\n", - " model.fit(X, y, epochs=nepoch_per_it, batch_size=100, verbose=0)\n", - " \n", - " # Measure the loss and accuracy on the training data\n", - " lossi, acci = model.evaluate(X,y, verbose=0)\n", - " epochi = (it+1)*nepoch_per_it\n", - " epoch_it[it] = epochi\n", - " loss[it] = lossi\n", - " acc[it] = acci\n", - " print(\"epoch=%4d loss=%12.4e acc=%7.5f\" % (epochi,lossi,acci))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can now plot the loss function and accuracy as a function of the epoch number. " - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "epoch_it = np.arange(1,nit+1)*nepoch_per_it\n", - "plt.subplot(1,2,1)\n", - "plt.plot(epoch_it, loss)\n", - "plt.grid()\n", - "plt.xlabel('Epoch')\n", - "plt.ylabel('Loss')\n", - "\n", - "plt.subplot(1,2,2)\n", - "plt.plot(epoch_it, acc)\n", - "plt.grid()\n", - "plt.xlabel('Epoch')\n", - "plt.ylabel('Training accuracy')\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Instead of manually measuring the loss and accuracy, we can pass a *callback* function. This function is automatically called at each batch end. We can then periodically print the value of the loss and accuracy." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "step= 0 loss= 2.4118e-01\n", - "step= 200 loss= 2.9560e-01\n", - "step= 400 loss= 3.5272e-01\n", - "step= 600 loss= 2.4297e-01\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import tensorflow.keras.callbacks\n", - "\n", - "class PeriodicPrintLoss(tensorflow.keras.callbacks.Callback):\n", - " def __init__(self, prt_period=100):\n", - " self.prt_period = prt_period\n", - " \n", - " def on_train_begin(self, logs={}):\n", - " self.losses = []\n", - " self.step = 0\n", - "\n", - " def on_batch_end(self, batch, logs={}):\n", - " # Record the loss\n", - " loss = logs.get('loss')\n", - " self.losses.append(loss)\n", - " \n", - " # Print the loss periodically\n", - " if (self.step % self.prt_period == 0):\n", - " print('step=%6d loss=%12.4e' % (self.step, loss))\n", - " self.step += 1\n", - " \n", - "# Compute print period in steps \n", - "batch_size = 100\n", - "prt_period = nepoch_per_it*int(nsamp/batch_size)\n", - "\n", - "# Create the callback \n", - "loss_cb = PeriodicPrintLoss(prt_period=prt_period)\n", - "\n", - "# Run the fit with the callback\n", - "model.fit(X, y, epochs=200, batch_size=batch_size, verbose=0, callbacks=[loss_cb])" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Visualizing Decision Regions\n", - "\n", - "To see how classification rule our neural network learned, we can plot the predicted class probability as a function of `(x_0,x_1)`. To do this, we create an input matrix `Xplot` with entries that vary over `[0,1] \\times [0,1]`. We feed that into the trained network and see what the probility `P(y=1|x)` is for each sample. Then, we plot this like an image." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Limits to plot the response.\n", - "xmin = [0,0]\n", - "xmax = [1,1]\n", - "\n", - "# Use meshgrid to create the 2D input\n", - "nplot = 100\n", - "x0plot = np.linspace(xmin[0],xmax[1],nplot)\n", - "x1plot = np.linspace(xmin[0],xmax[1],nplot)\n", - "x0mat, x1mat = np.meshgrid(x0plot,x1plot)\n", - "Xplot = np.column_stack([x0mat.ravel(), x1mat.ravel()])\n", - "\n", - "# Compute the output \n", - "yplot = model.predict(Xplot)\n", - "yplot_mat = yplot[:,0].reshape((nplot, nplot))\n", - "\n", - "# Plot the recovered region\n", - "plt.imshow(np.flipud(yplot_mat), extent=[xmin[0],xmax[0],xmin[0],xmax[1]], cmap=plt.cm.Reds)\n", - "plt.colorbar()\n", - "\n", - "# Overlay the samples\n", - "I0 = np.where(y==0)[0]\n", - "I1 = np.where(y==1)[0]\n", - "plt.plot(X[I0,0], X[I0,1], 'bo')\n", - "plt.plot(X[I1,0], X[I1,1], 'go')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We see that the neural network is able to learn a nonlinear classification region matching the training data points. To understand how this nonlinear region is realized it is useful to plot the response in the each of the hidden units. To extract the output of an intermediate layer, we create a new model, `model1` with the outputs set to the hidden layer outputs and then run the `predict` command on that model." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Each of the hidden units produces one linear decision region. The final nonlinear region is then formed by taking a weighted combination of these regions." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnoAAACTCAYAAAAZfrRvAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9a9A1y1Ue9qye/X7nCCSuRzhYF46EuUUJYAzISRA3W0HYcSgwVcJywJdQNk4gqXJSISkT8AXKcnAwKhsiC3ENYCVlbjIIVI6DjHCQLTkGY8mYKAKkIxnCwQYEEvrePb3yo9fqXt3TPXtmX2e/76yq/e2Z7p7Z+93f9PQzz1rPWsTMWG211VZbbbXVVlvt7pm79BdYbbXVVltttdVWW+00tgK91VZbbbXVVltttTtqK9BbbbXVVltttdVWu6O2Ar3VVltttdVWW221O2or0FtttdVWW2211Va7o7YCvdVWW2211VZbbbU7ahcHekT0HUT0tZf+Hqtd3tZrYbUxW6+P1fax9bpZ7b7bxYHeLiOix4nox4noPUT0c0T0Byce98eI6C1F299vtP33R/qun0VEP0tEv05Ev0ZEP0BEz2iM/TAi+jtE9C4i+g0i+kdE9HzTT0T0F4jo7UT0m0T0KiL6gGN8z2s1Ivor8vtuiegvzjju7NdC43uMfn8iegkR/RIR/TYR/SARfcjIuT6RiF4v184TRPTVpu8PE9FPynX4y0T0LUT0tBP9WYuwXfNpx7GLvz6I6MOJ6NXy9zERPb7jXM375npvyU1+p1+V3+JniOjzJh53keuGiL6CiH5Bvu+biOjTGuN2rTGfSUSeiH7LvP7Esb7nasuxxQM9AH8HwD8D8KEA/gKAv0tET59w3D8E8HE6log2AD4BwPsVbf8BgJ840nd9C4DPYeYPAvC7Afw/AP6XxtinAngjgN8H4EMAfCeAHyGip0r/lwD4YgD/kZzrKQD+5pG+57XaWwH8dwB+ZOZxl7gWatb8/kT0PAB/G+H//HcBeA+Abx451/cifNcPAfAZAP4cEf2n0veBAL4W4br5OADPBPD1x/kTFmu75tOYLf76AOAB/BiAPzrxXGP3zfXektt/DeDDmfkDAPwZAN9NRB8+4bizXzcC1F4K4AsR5vm3AvgBIuoqw6fMiXcx81PN6zuP8T1XW5adBegR0YuLp4b3EdHrzJAPJqIfIaJ3E9E/JqKPlOM+GsAnAfgaZn4vM38fgJ/FhJsdM78LwNsAfLo0fRKANyNMTtvmALyJiD6QiL5Lnux+iYi+iohm/T7M/CvyuWo9gN/TGPs2Zv4GZv7XzNwz8ysAPADwMTLkjwD4VmZ+BzP/FoC/BuDFRPR+c77T0mzfawEAmPk7mflHAbx7zmde4lpofI+x7//HAfw9Zv4J+f/+HwF8wQgT9ziA75Fr5/8F8JMAnief873M/GPM/B5m/rcAvgVhUV+87Xt9TJhPTbuG60PuLd+MsHCP2oT75p27txx4X/nnzLzVXQA3AJ616zMvdN08DuDNzPxPOZS1+i4AjwH4sMr323tOrHa37CxAj5n/N31iQHiCfBvCE6faHwPwlwB8MMJT7ddJ+/MAvI2Z7Y3vZ6R9iv0E0oT7dACvR1gQbdsbmPkhwhPtBwJ4LgJD8iUA/hQAENGnUXCDtV6ROieiZxPRrwN4L4D/FsD/NOWLEtEnIkzCt2qTvGD2HwHwURP/9kXaAdfCoXb2a2GmPQ/h2gYACHh7COCjG+O/EcCXENENEX0MAmvwfzTGfjrCArR4O9b1UZlPu2zp18cc23XfvHP3lkOvGyL6YSL6HQD/GMDrALxp4kef+7r5UQAdET1fWLw/DeCnAfzyri/amBMfRkS/QsEV/DeI6P0n/t2rXZGd1XUrTy/fC+B1zPy3Tdf3M/M/kaeq7wHwidL+VAC/UZzmNwBMjTeyT1YvQJiEry/a/qFMmBcD+B+Y+d3M/IsA/mcE9waY+SeZ+YNGXj+pH8jMbxfX7WMAvgrAz+36khTiY/5XAH+JmfXv/VEAX0oh1uYDAXyltF/tU7e1Pa6FQ+3s18JMm3ut/zCC++a9CNfYtzLzgO0hohcC+BMAvrrsW7Idcn005tMuW/r1Mcd2XUt39t6y73XDzP8Jwu/zhwC8lpn9xI8893XzbgDfhwAm3wfgawD8GWH3xn6X2pz4OfkdPhzAZyO4eL9h4t+92hXZuWP0vg5hMv1XRbt9GnkPwo0KAH4LQBkk/AGY7rr7CQAfT0QfDOD3A/gpZv45AB8ubZ8mYx5DeNL5JXPsLwGoCimmGDP/G4SYiB+iEKdRNSJ6CoC/h/DU91dN17chPJG+DoGN+XFpf2Lf77Qwm3stHGpnvRaI6M3GjfSCCYdMvtYpiDR+DMBfBvAogpvpc4jovyjG/X6ERe8Lmfnn53z/Bdhe18fIfNplS78+5tiua+ku31v2vq8w8624zj+HUrzrLjv3GvOlCCze8+R8/xmAHyai3906oDUnmPmXmfktzOyZ+RcQ4kO/cOb3We0K7GxAj4i+CIE+/0Jmvp142JsBPJfyOKVPwEQ3FDO/DcC7EAJs3y7xKADwU9L2VABvAPAkgFsAH2EOfzaAd8p3f0ER/1G+WjfqDULsRFXRRkSPAPhB+Zw/W3x3z8xfw8yPM/Mz5W9+p36na7Y9r4WD7NzXAjM/j1OA8+snfMU3I1zbkM95LoI7rQbQngugZ+bvYuYtMz8B4FUIbIQe/3sBvBrAn2bmfzDh8xdj+14fY/Npl13B9THHRu+bd/XecsT7ygbAR+4chYusMZ+AEMv78/L/+GMA/jWA/7D2/WbOCUbu0l/trhgzn/wF4PcC+FUAn1jp+w4AX2v2PxPAE2b/DQD+OgJz8fkAfh3A06XvcYSL8/GRz/5eAL8C4BtM238jbf/ItH03gB9AeBr8CARa+0tn/p1fgBDo6gA8HcD/DuD/boy9QXjK+kEAm0r/hyDcbAjAvwvgXyBQ9Gf5P1votXAj18H3IqhKHwXQLfFaGPk/b33/5wH4TQRXz/vLd3hV4zwfIPPgJXKt/TsIC8vXSf+/J3/Tiy/9/32u62PCfLrq60P6H5VrgxHuM4+OnGvsvnnn7i0HXDcfC+BzEZTHNwgM2UMAn7TE6wYhDOPnER72CMALERjKj21cT2Nz4jMRwCYheAV+HMC3X/r/cn0d/3WeDwH+IoAtgktBXz8qfc1JKPuPI7gY3gvgXwH4g6bvBQB+EcDNyGf/WZmoX2DaPlXa/qpp+2CZiL8K4B0IMU1u5t/5FQB+AcBvI7gKXgXgI0z/ywG8XLY/Q77De4rf5QXS/9Hy974HgeL/85e+WBZwLXyH/Gb29SeXeC00Pr/5/aX/JQDeLtfPDwH4kNq1I/ufjaDA/A251r4FwPtJ37cjpOOwv/GbL/1/f8rrY8J8ugvXR9nHI9fH42jfN+/cveWA6+bjEAQY70YAw28E8Plm7KKuGwRQ9pcR7hPvBvAvAXxx7TqYMCf+PALT9x75Pn8TwNMu/X+5vo7/IvkPv0ojoq8C8KucB92udg9tvRZWG7P1+lhtH1uvm9Xugl010FtttdVWW2211VZbrW3XUBljtdVWW2211VZbbbU9bAV6q6222mqrrbbaanfUVqC32mqrrbbaaqutdkdtBXqrrbbaaqutttpqd9SaFRtq9qE3G372ow8kpWLIq0ixaiJJBUXJt0gAaRsaY2L/vHey+zDnIzLnLtrtO6jRhmHb5DFm246zY7LNSl5KqrSNnqPRMNL/i29/O5588tdOkhTzscc+lB9/9rNPcerVzmSnvD4eJeIPMM+WtuAqgeytI71kKjnpz/rKNiI4F96JACfvcA7kCOgovJMDKu9EDnDy0nsJueK9eNl7Seu+lFl5bzDjdzQtJZftP/1nP/0kMz/92Oct1xdK/7FhABHI/odn64n+n6CynbdRdaz9P2scO9Y/6CuPN+NOsj60zjMyZnLXvOvuVNfHvvYs2vDvYDmi0yfhX8vMLzrnZ84Ces965Ab/58c/F9Q5kJObY+dAXZgIYdsB8h73icKYsr3rwk2168JFvNnk+64YY7edC5O+6wDXmX55J3Msubxfj9Nxrgs3fKf99jts0o2+68JnlmPIDfflc6hcEGZtI20D9cWl1R/78jGf8umfvd+VMsEef/az8aaffN3Jzr/afJurqv+UF3zWib4J8DQ4/FG8PxxkuoGwobC9obC9IcID2e6I8ICABy60PeIIN0QyNmw/IMJG+286PPKIwyMPOjx40OHBA4cHj27gHrlB934P4N7/kfD+6APg0UeBRx4J77JNjz4FeOQpsv8o8OAR4OZBeD14FNg8AOl+dwNsboBuA+o25j7i0v3AOQDyB8a57erztPVwmS3uxYI7svDTTlCwv9H7f9AvneK8z3pwg3/w7z8XzhFo08kaQaCbsE2bLt/uKG1v5H6+2aR7u64n9l36qVwvNjdhW48v15Sy3dmXS9tdB3KVdcVeH67LrgXS62Sf9QGYsQZgpL3S1+qv9qVr7lTXx772PjBeTMeqpHm4fRP/5mPn/sxZQA8MbHtGxx7OcbiIPQM+TMg0juOLmcMFwE5TfGYvcg7wXm6KCO/MCYwxp3fm1O8cWLapM+d0nI5nnyYXe9n3+fmIgM4D3IW/peNwjB7Lsk9hwWRH8nDGYUwnfSQ1sInCd5Bt1smsk48FwOr6SxjZJvmO+vdUxuk+imPRGLPavbC7njbJLGX1/pH1aThgtSUYA7i99XAdYcMM8g7Uy72y8+H+zAx0Tu7VDtwxyDOo96AbD2IO64n3ab3wxT3fe7CMIdcD3tzn2Yf9zU2+ZrAHem2XdaZjwPeyxnhZRxjswppFbNcVOTdv0veR+zoD89eHWK1MGgf3/GLNUCP5J66Raa2K57Rtg/54knQO/cSF3nMIwIMlTfcL/EyzgB4D8D2DPaPrCI4D0AuZlw2QIwWA8nKk2ZkDKPThHBSBlQ+Ajzk8OdmL0AC77L3rIkBkZpArJiXpeDPWAsGuBHPSBuTt3JkbRZi4LBM3PjWTgN54szCTQyezfXrzPj11MY1vk2zrZGYu+sxvrnPR7ut/XPa/uNpdtYNutgu9UU+xWcHG9qFy0FdZEcgNt2nkE1cQuZcxM7Zbj44J7AmdZzgXwBt1LgA6u62eId9FkAXPoI0Avb4P64kFfsxZeyQLmIFuI/f4mwTOvAdcH9oiobCRz5N1xhINHUeAyNJHCiB1fdFrx6V1jtUDNHV9iOwbDCEA7CQBam261pZgzgK5DNRxOkkGBJdphOABuM82D+gxo+89nKOIaRwxXHxS4sTupdIbOfDrGAN2jyhMCHvRlGxejd0z41jeI7unwKwrgJ+ZiAMwF8cXT2HOfDaQsXuBlexkEur3L9g9BXyuA3ufP70NtnUhwfDprXiIi+Mwsj8412p30e4rwAMuqCi754vHsY05eIzC8zzDe0K3cei4h+uFaWMkdq9z4M4F8OedOFZkPfKGPCiBnm2XbfYe5AXk6eLmuwDq4jqxydk9de3adSZ6jXwI+2EP7rysEYZQUHav9AAB89aH+FBfEAJABdxRPterRAD2Z/di37KMAGyW97XOavNct1DXLUDEYCawI8FvwZ0b2T0D7thRAHHWnSvsHvcc4vdKd66dkEQ5/W7dvaU717J7ltVzNAR42l66c+1kjJ+poC9n90AMZpnICvRKdq/lzq1S9B47n96q7F5t3/zHtSb1aldtdw3gHQLawnqX7uhUY+dqB9W29/nwY4y5x8YMbG89vCO4jtA5gDntb9gwej2DNsLo9R64kYdz38H3HnTTiYvXgyyrp+uI9yl2T7ajO3ej4G6T1ovo3i3ZPU5eInXnWnYvMnZs3LnlusLZ+hbZvao7t1gfMvdsjRAw7FvNnVuCujF2T8cP2D2kz1jgPYUoxPveZ5vJ6AH9lgO+oXRNk4C54M5loPfypOWAngPDZ125EQB6od6H7lwq3LPZk5kVaVggKJOW5Z00No96GV9MzI4BT5W4vgIoahyfM2BQ28ghc+caABhvEmS+v43NUFA7xYU72EY+masAz0zsbHKudu121wBezfYFfVUhgrPCqMEB+TEqmNBt2162DU82ujvJ7us8ZcbtNniMOk/wjuCZ0DmC88md2ymT17sI9oglTk9AHgmBQDcd0Psg1tCwIHXd9n0SbWjbZhPmlutBGn+32QSgF708nBg93yUgqOBQ2T09vubOLdcQ6zWSdSOL7/Ys193ImnBMd25srwC+AbunBy7zuiUEQdd9tvlAr/dgDhcfdwHkdeLKZWH6qoBPwAbLhISocyPg8+EpDZ0c0zlQ56NqNwN8FgDWmD19MpLjIuBTANfJJNTJSr2ZqAoA+8TiRcDXD925GeAzE5kI0QVslVf6/cSdy3r+yPAdCfBl4er2Se46FvnV6nZagMe4c9fHqUFTC/TdV7B2gCmj57oA8pwjeE/oHaHbhG3vCX3P6DofAF8va0UEeAL2OlcAPmlXcKfrhgV5GtcnY3izSYCv2wBdH8QYGUAsAJ+KOVSd6/t8X8awrBkDwFeuLRngY/MQMmF9UHcucyQXhjHdBZs3BfCxaau6c5dlhNV1O9N1y+g9a3gEVFHL+tCi+zyM32OdfF1g+GqAr4zfS8e4xPDZ2Ioa4NPJGuMnLOCTSRfjK8xTlwI8pdZtkK0yfZnAI03E/ElM4zIkZrAG+KIaWCeXMHxQNmLHJHbpN6oDvvT/NQB8q12lnR7gnd/0IdtNYAJaD+QtPJUTdCXL1mD2Bie5WPTfvTSGMHpeWDwD+JgJviMwuxi/VwI+1zNw48C9h9t0af1QwKdg76YC+NSVq14jw/ixbFMEhTeyjlQAn43fiwCvEr8n604G+HRtYB+8XBXAFy7JqSTADsCnthfDV4C8BcfoAcBmoWzjuWwPRo9jfB4RRcDHosKN+0zwRMJce7k+1G3rhmrcMn6vJ0WT2SuL37OAzwLBqYIN+zRVxu9ZN65lCoEhGLRAMKZnCe8DwQaA6Na1wbgxlqMSnxEZOhfeVJXVjM8oAJ59clvtquwuAryWTQF8R7WqG3dl6C5lur6kELewrjCHV+dJbtFhnVHA5xnoJPUK9QHYeXXXdgH40U0HJw/c3Hu4mwDySNk869KtsXzi0iXXyzpmXLVZHJ/ZHgC+DuhuinVHHvI7307HokDKdcED5Lr6+tBKzRLZOhljY7ztnKuRck3AZzZqgG9BtjJ6e+TR8z0nYktAXXTdhnA12efYH+P34PN0LBp7UI3fo2Y6lmr8Xus9TpIJgg37HoNllYmzT2TFZLSBtcAgHUsm2Eh0ZxibxQFCYm1Jnt5cMfl8++ltsmDjgKtltbPZfQJ4U8087oRtu0btC8RWALcYYwBbZnQ9R3BHHugco9s44Ql8jN/rNiROlyDY2DCj62R9KVOwMMN7AYKbXLARc+/V8rXaNYY5pWOpuWpVsRszPxhCQdcVXTesF8mpCEPWN1dZVwrGbJCftSQBWoINXR+YKx4g5MAuE14YFm/QjrxvYUaENb3KnMEMq7qFgDmK8wJAZPeIwiQ0cyQ81DiAuDeTieJTh2X3qHMicFAEiXQiHWPYuuZ7CfQG7J4+hZn4vYH7VhjIbBLXJqNhBQGZ3OrODa5ZEIe5JDkIQ7yeT0yCsnsSrrGT3RswehYIojKZr3ORv0+2N8ibdFxjzMKexPW27CbcoNPYfJ3JPLbSMarEXdm8i1vPDAbBeQ4vdduyx2Zj2D1O7lznCJtOxwV2L6Zj6VjYsnC+QTqWzgsg9CH/ngV6VplbAED2HqRrhU2krAmRS0ZPc/R1lXUmeo1EsNEVpED0NBmPk3h+UgYHNNYHxqg7V+Nya+7cyexeAQQXZgTgwT2PwpjJ6IWnIr3eI47pBOCJQsqyfaU7V9k90uoaGp+n7twi0XIGAEt2L7pFR1i9AuDV2D0Q1atr2MnVWSBXuHkjyOvi7xReXUa7R/odwkDYdCylOxfAINkyKZ8BDNi9jNGD2TaTeXXdLtruM8Abuw/PvUc3Q+vGAvpqyZPPYSuIjMYIjJ4j0cMJ4LO35k0Xbqt6m448gPYpu7cJgkBbXcMLwxfWA40LlzWlc2G8ZfdsdQ3m5M6VMVl1DebcdRtTsGjMnYA/vkE1HYsnTKquAaQ524rvhkO2PgzWhHK78ADZtQQY3jpI/rFEih2/MFsTJu9TGcNz/L9lRxKvx3BSAq0EedF7STmTnalzSWP1CnVu6dq17J4qekt3bsnm2TQsc6trdBoUy2k8kLN7cYJ2qd2ye5J+Jd48AESxBnGejqV05xp1bnLnAkPmbsL26rddrC0G4DHfuUtkL5euI8OwF8dX4/qo3bfaZGPILRSB1SMSkAdk7tyaWKPz0mfYvdCeqms430V2L3PtqjuXOWf3yuoaliyoVdfwcp9Xdi8yej5f/Cy7F1OwmHOPVtco2D31AAFtdm+nWEPGM+dLha6hFvCRGadtsO3LmwMEZBVa76PNT5jMueuWSJMmcwiQVXZPEik7EW64jozns63Ojeye5N+z6tyUdkWUugoKozpX8/LtEGnEXEiFOrcUa8R+pejt+NK9qz+KPpUVcXyVmIwQhCufSZQfQ4Y1NOrc8ADWcOfuyp6+1Eeue2qLAnh32crF5xgM3twFbYEL4OKMgS0YxCFcOdy+CB2SOzcjCyS1lwI+BXfeEzZdUuc6R9gIOUCbLqwtos6lLoA86j3IdykRc+9BXR/GW0VuyfhpihbvwZtNqK7hRZlrRRkbX9+260tNnatpuzJ1rllXrDpX3bnq5Zq0PjDmuXMN4wezueBbyBqjtw+jx/K0hXqsXqcgrgusnScy2UiSOtfJcToRVZ3rnMQ/ODcEfJxm+SA9i+mL7txa6pWaWreQ2rPUN6QqIDQALAbqeqQce3oXMjn3SnWuxmTUAJ8NxFV3rk5m4ysfBONm7B3yNp2w+t1Wu6hdRGgxCeCd79o4tcJ2EpM39+Y/YPd2gcXLLC57C1MubAxGz7K6UAJ8HgGadJCIHmZ0XkEdR4YvsXgE3wcvUwJ8QdDReYbbCIvXuWE6lhsP13eBVLCAzzJ7Cu50TTDpWFhUuzF9SwR8cnwp4Gipc20S5iIdC2UkgwV8aV0ZVecCRRtXxhjAZ0ODYLqsLRjwEYCbK50Tx7L5YgwGOpmEFvANPaMB8Nn4PRVosAO84wzwpXQsQsuXgM9zctcaVi9n/DixevIaAD7r1i0BX/FHDACfPk1ZIFcCvrHya5b9U5evBXwyQckAwAzwFVL7YfyeTNYWdX/PL/ZL23IZvGXdnecksT/4ii6ZvaaaozHmqHa/56euLwQWRi8HfAyk+D0FfJSS9WsIkXXn+l4AngO87+E7B+cZm87H+D3qHPyNsn0e/iasJwPAp/VwSzav63IXr7pzS8AXxyjj1w8Bn7p9lR3JEi7b+D31AhWAj3M3MxMNAd9AuCHXXQbgLMCrAb4K4wcs9hK+51qM+a5bDxFjEMEhAT4HBveJ2fNkYvW6XKDRMWXxexp+V6ZjIU+pfq7m1SsFGwrylPEbCDZ8AnxKu5dpWVpAUOL7WIAd+eJJywI5u2/duBHMGbo9K6dWAEVbTs2CurJ+bllOzVbXqEnsdXu1s9tVALwrZ3pTmByZNrPtCANZbmn7KHJXO6ptmRFKn8uaggT4HCc3ro3foz4wfMFbJA6e7Hac6uUy+6ycmtOqTGzcthxi92Iuvt4BGxVkmHJqVpnb97mLV8Agy3uWENmWUxMyIVtTynWmrJ9bxu/FkKEuXyM0xpuL/Kwe7fWhCf5ko2TzFszkWZui3r/LNpvR61nRsU44wIEBppAxxIeJagUbGr+nLl4AWfyera5RpmMJog42YG6GYEOeaEYFG2U+vhIIGuA3TbDB+aSzgo1sMhrgZ/MkldU1SsEGgGo6lsnVNRY+I++QXR3AY8Y1XR/JCRW2FNjNdl2ubPcijBGIBCjII8DLduD5AvAr4/ci57QN64t3dcHGRsQcG1lLNGyo84xOlbdemDD1HKlgQ4HgjbQp4CuVuXYNsYIN2aaYjoVzt60lCXiDQbqv0fg9CfuxYLIUbJiQn/2qawA7y6npf+LCjBCumfts8xMmR38+QMaFC9kmmXZGDBRBX6dYRueFYLTOafswHYutruGc5KKz6VgsmyevjN1TJsy8BulYlL2rAUEdp/mTNlJMxZ7TqmxraVdcNxwPVJ7CymPDe15dwzB5+j2IUFVfxaczV4+rWO0kdrFkx+WxswDe8swSbJZPI5rh3nWNwWPArmTvLsXm3UPwGVW3RCERAdJDtjJ9yu4p8KMRwUZZXWPDISTHVtdgdiFPH3NQ3nInpTp9WqBYU7AENk7TsSS2zgA9BXiWPJC0LMwM2iggVBbPVNcoK22U8XsxX5+uWz4REbuqawDYKegr14qIohXQqWeI6+BuoZfsNTF6RPQiAC9DwKevZOaXFv0fCOC7ATwbAcP9dWb+9rFzzq51ywx4uViIKWSpp/AUVrJ7xMmdG37nIbunYg515wIyQVvVNWrsHmHo0o3+YBq6c0t2L7pIG2lYFOhJPE+k4y27FxMLmiezyOZxYg6rcXwlIBQgqMpbra4Bw1Zo3J7r0nlsHxHYdTLvfJrMy1zT74wtgsUbA3i2Pxu3/AuDcCTsc0yhhn2aXe0gY4SEyRqyEm5XsmYYd25k94Tx62T98a10LIrVOgTXrbJ7Igws3bnK7uWMnrhzPUd2z0tbdOdaYsC+K8OncXPMgJNQIE214jvE8mjlGmLbgMTuxTRciTzQIgMUk/br2mYJjJqgTx9mzFpRE/QBBbun+2e5RPYywvWUQCOiDsA3AXghgCcAvJGIXs3MbzHD/ksAb2HmP0JETwfwr4joe5j5Yeu881W3YBCT3HQT4GNwiPFEmnAhtiK5c3N1rl6rprqGXrMuHzuorqHsHrP6gONTR8nuhacexkHVNWruXefydCyZe9awe1GAIRMd5jvYmD11/9p6uhntbty5kd2zwK7izgUq7N6CZ+QV2yIA3qBtBADG7Vrb5WyOEGPMJuGuSYBvobF5dxRYeghBAKATsR8JyOsMu0emP4xFXH8su6fVNbwBd7Z2rnOpugYzZbVzs+oaWi9Xcgk284cAACAASURBVKWGHK6SmkWrazDntXPLGD5tlz5WcUcUYjCa9XKtO9eqc0t3blwnhN2L6Vd88iSVhEDLnXtodY2FGIHOX0d7f/tUAG9l5rcBABG9CsDnAbBAjwE8jcKi/lQA/wbAduyks8UYPYfnqVDMIQd8gdVL7tzOuHO5oc611TUARHaPPDXVuewI5JI6N7B2jLK6huZJygCgZfc0PQuPVNeYrM519eoaUZRRijcarJ4CP233VHfn7qnOXe24dqcAHvNZbtSZS/bSl+RJ5kR5zkv/kddhzIHRcyQBQLLtZM0BJXaPUHfnqoDDiSPFFe7coM0bqnMD0HOyHCTxhk3HAobUy011clNqltDubrphdQ0L8vq+HrtXq65Rc+22qmtEdW5K88Wy1uTuXLOOmHVjkI5lanWNUp27xEt9TqjH5e0ZAN5h9p8A8PxizN8C8GoA7wLwNAAvZmY/dtL9GD2QsLY54EuTTcCfgDybjmVMnas1csM1WAd8MTex5wHgs+7cCPIs4NOky96BND+fBXwxnYtPT2Ml4IsxdS4HgLXqGpr1nBkgK5PvMACCMV2LaR8APm+e4kSd6yivi1hT52oKl4U+cV2bnTYGD5gM8KrnajB0JcBr9i3rAnEYj6+hkZUlO4wkfGTXHd+mW6mxebsYvvVham9jhPQqTrxDTtg7b7adADsyHiRNx8LQSJnA6oXjwi1V07GoIIMqgC/wAITeh+oazquwQ9OxeFDfSTUNSbZ808HL+uH6sE03JtmyVmay7lsr+LPVNbwHWfYvqm+LdCx6f5+izvVOAF+fV9cghwHgY6vOlXZyGDB9NXWuid1fmin7uyB7jIjeZPZfwcyvkO3aFy1/1c8B8NMAPhvARwL4+0T0emb+zdYH7sXoOaHTa4APlfg9ZsR0LIEFlkSXKAAfI8bvtQCfqnOVsFLAF9KxBLpd4ytKwFfG77GnHPCV8Xs1wGcnqZ3E8h4nrD5ZlYAvi9/r88lWi98rAd+gzQC+GlVP5nt3ejtcbV9bBIM3OFejv8byDfpqY6/PiELpp10ZVKrmXJgnO0HcQt24d8QYHGrdIqwdJeALRENYR1wjfi+AP0iS5RzwxQgar+tODvjC87vm3yN0GyERZH+zCetLqKRhEyonwEe9qHM7ygGfZfYyMFcAPmX4dG1QwNcL2PMqEKkAPUsklO5dBXy6vtk1ZDR+bybgWxSeStYt6wHsSWb+5EbfEwCeZfaficDcWftTAF7KYTF6KxH9AoCPBfBPWh+4F6PHSIqoEvDpMzYVgC/VLxRK3sTvWcAXwBsywUbylIrrtkvJlxXwRVCogg3Wx7hK/J4FgxngswmZlQWcELdn6+mW5dTIAL6x+D0bWGuBX6nKzcqp6cTcAEwp/x6AJGnuEOP3eHmMzbXYIgDeoG0PgBe3a8BvOdfGHJXcqIA2xqfakx8hjOHQEmqzbVEL1cnMA/AsAK8AfCCK8XteU6uY+D2WbQ9GZ9KxWFVuzMMnogsFfCGEKKhxuSN0wvxp/J6tvLFhBEKhd8Ft2/noziXj2o3pWPpQO5e6fsjsGZAXEiuncmpBsNEHwUas0tQNS6hZoLcxdXTjOmOqNA3KqXVm/bEhRnnITwB8rg7yFp6rlYBrqnX7RgAfRUTPAfBOAF8E4CXFmLcD+AMAXk9EvwvAxwB429hJZzN6HNAbAIIHAKXa5cbZcz1+T9m+WjoWJgCeBwI2G7+nylv9DqVgo8zRp+XUqvF7Zcm0XYKNktUbS8ti+51LBa93xe/FhMkaWNsV368WZ1FOTJbfR+L3NGYvJlb2S1rLr8KuCuBl25U22zfWdiU25radZC2wVgOBK5t3cmOo6xaIIgANN5F9jd9TVkrj91hctixrkY3fc+JVUn+GunOb6Vh4GL/nuxDDF0KEEOP3wBzi92LFo7S+aDoW7lLePYpkQyUFi62lq+uHFWxYYGbBXSbU8Hl1DdebtUIBYDgPcyHYADCorjEq2JA5UcbvLdCuRYzBzFsi+nIAr0W4ZL+Nmd9MRF8m/S8H8FcAfAcR/SzCL/6VzPzk2Hnnu26BOLmUzQuAr+3ODaExjL6RjiXgRsrSsTAjxOBRYOKUWs9AXqW6RsRRnofVNSyQIxoAv2Z1jY4BJ/F7wFCF23q39XO5kmzZlkmL6VcMECwTKtdUucyI1TXK+L1WdY3VdtoyAV5x7D4AT/eroG/8W5/a5pU+Gx98cL3XMcZuAPquYxG5BvNyb/YC+KL7tmD3OhFmhKUjAL4QNjR057IcX1bXmJaOBVHvwN6j25h0LB2h46K6RpmORVOvaPiQgEEVCTaBnk3HIvuD6hpZOhaJ31OQV8aDV6trmHUiCgEtoJT1hlJIVp6OxWNl9I5vzPwaAK8p2l5utt8F4D+ec87ZrltmDkmMgQjoNN+RunOV3dPqF0CYuC12r3TnKrsXGTtK+ffkD5WKG8bF25m0LYbpy6pr6BOXd5A7QQJ3GfBjDNg9Yf2CW1T3R9y62XGFO1cnnU2vMnDflu5dBYI6XtFtAQYVCCq75+S3BpCk8Ku17CLJjo8C8MyYvQAeF/2nsWPwYnsxeYIiBwBwUoqVxphxn/HEL7aaGnMuxijZvDF2L1y1KR2Lra5h3bkw7F64G7aTLZPnrLrGRlOzbFxcZ7S6xoYRUq/4JIqoVteQ80YwaFOwKMCz2woGvQ9rVXTJ3sh6JS5cVfV6Tu7bQ6prAIh5XDXNl/yf7K6usTy7poTJp7D5rlsI0II8SWlj5s6dx+6V7lxl96KC3ITUVGvnmjg+IGE1opSOxbpzI7tnwB07albXYAmujXcAVeeOsXktd2/J7pWsnlqc5JZ2t+5hCxS7xlgBhCKfD6qrva+VO21XAfBs/1yAF98bAK/1fc5gx2TysrGD2Lw9bvZzFoipY+/5ojNmGg4Easfq1cQa+gCu7J6trpG5c5GzexrHF8UaCOyejylXkFXX6DqHLP2KQ+bO3TAndq9SXSPUZ3fARlKz3HSJrbNpWCpl1KrsXkzB4g2jV7h2Yy6+myG7F8OCOHfn2pCfijuXAcPuVdy5CzIiWpoY4+y2Rwm05KjIAB/X2b0a4NN8ewEfDt25lt2ruXNtdY1SnctMid2TpMr6dJZV12C9Ebj0lFiprsFOVbtDd25TnVsTadgnN2X3ImAUcKZKK1vg2lbXsCxgS51ry63pWKvOXZFeZvcK4Ol2FeDxhL/ncuZqooqK7eWytcHBx14QpjCI93wRUmMMXbfK3nnsBnxWrEE2HcuYOldi+6I6F4jv6s71nuA8EIpf+Cx+TwHfaHWNnoNCl22snlTX0Jx8ZXUNG8NXJl3ebIw6twB60cvDZs0wwM6KNmzWh4E716pzK+7canWN5V7H3TX5bk9g81W3shjEpygAYEaP6YBPaXRC7s4tq2uEcyGmYymra1TVuWzYvIY613WA830Qb7BNrBz+FqvOjbEVFXduOG6HOpcoB36F4ioBvoY6t5d2TceiT2elOrdkBjPXb5ePWe0yAK927BjA48b2XBdtbJP9sj/uX+5BoFXXdpflGI3kXPZkNGTyaoBuBWCLMIaUQQPyWL3CfRvAWA74PBibwp2bpWOpqHMj4JPzWHWuhzhHYOL3PGXu3DIdi/fh1feMrvOBAexCwuWkxvVZWpYsHUvvQ3WNUpVbJl22+fc0HUu3ATpJw6Ln2GyG6lybgLkTgiGL6QvrRabOzYgEQygQFYBveesL0XjI7X2w2UBvy2bSIQE+pc53xe8lwGfL2CTAp7ULq/F7YINvhoCPXJqQCeDlgM/GVZSAL8bv2VQrAvhS2hWHkHg5TE4FiRHw1Vi9EvDpZG0BPjYTVUGaBXwD2bwBfDpxNYGmBYJrHr3rYPCOBfDiOLNv2bsB2PNnvTx23XtPfm9egdziTNcXhwbgM+7aGuBD4c4t07FYdS5VAB8jxO9Z4BcBnymnVgN8mo5FEy4PAF/v4HoGblxaN0rAp2Cv64eAz+ZwrSVc3vQm4fINYv69EvCxH4K/WvyerCN5Ohb5D8pythaAb4Hmyoe9e2YzY/Q4xlB4JMDnSDPoIaPONX5PJxWQ1FFK81bTsbAAQAP4kkJKntAqgM+wzzE+rwR8jimygMwUgGkX4veIRD3lkqs2gjxOi2Ni/AiDVC1clFMrAV9LsDGon2v78zxI1STLZUHgUsyhY+8po3fnAV58bwC8sl+vhQHwu77ro3YLPwjDjT3+FwvG/ure+73w1CwAMgaYUlUL5IBvAO4Kgca2Eb9n6+cyOLpsS8DXSfweMWI6FpuHr5qOpaifG+L4EOP3FPBtNrI+9E5KqHlTQk1q6bKUU9NkzDc+1c8ty6lZt67c/9n7tHZkcXqm2oYtpzYAfOaYCADD+hHr55ZCwLLk5sKMCNh0ywSg57K9XLdhEjYmnY6tAD5P48mWFfA5AnpwFr+nIg1bXaMUbOg7YDyZhWBDq2uIiDYlYtb4PYTg2ZpgYxi/R810LIP4vfJL2vc4SSYINuy7jcWw9XNVjGEnYwSOx7hsrseuAuDZ/kMAnm6PAjzZ9n7YduLrY19o07pFz3PxUt1lOyOX3sEpW1bbaZ4BzRgQgrTDpsNw7TmFYAM8TMdi6+eWgo3A7iFV1+gcPPssfi9F9nhsWNKxsChvOw71c4UwiOlYvAGCKtgwooxmLV3vg2CDOcXv2UTKrDn2xHNUy+9aS8eiv41W13DFukKEKNhYnNHK6M09IP436n8ukD1RWXZPx3mNneHd8XsdMXwl2bKTD1J3LliqHBIEbJmvk12beXWN0J+nYynj9zoHEPcGfMmNxbJ5kYnTSZHH74E5BNjuqq5RA3qD6hqGuWtW1xAGUv+oeB4zGd39cd1eRQxe2d8CcnF7IsCL+xWAF69Pn7Uxc3DVLOz6aN2fJ922j3lz3wny7vdCcgxjJNWto8TuAQAoAfuWYAMGAIKHAo4NBabQep3C/TWsR+BGdQ2SkCIU1TXAg/x7Kddeqq7BHYXja9U1OgfnpbqGgj8f1hitye6lHZ5BGwP0rCs3rjkJ9LH3gOtBVjHLnKdjqcXv1dKx2CpOEr83qLEOYImJxYNX+X7Pz/lAT9cBE6fXpNQh844D9a7xe4hPbULRm/2ec3bPAj5V61p2T6trQNy58esIbrLVNQBk7J6trqF9mo6l60Lt2GZ1DXkKY04L5YDd09g/5vF0LAXAG7B7Y9U1bHBs5t4t3LzRnbushfwUdvXJjlt9owDPjBkDeIXrNgK8DPzdIaMGE2eZPNu/a+yhX2a1naZgD8Aouxf667F6NQHHtuLOhREQQti9kHd0d3WNGEpUuHOVSCira/DGmdu8H1bXYCCmY2GWWHBTXcOHfLDUAnoWzOl+9A6J4II5sXsDcYYCu5uc3WtU12BZGwfu3AXayujNsPjEJTs2Tq+k1HXByBRwPI/dG3PnwrB71p2r6tzI0pnqGtxRxu6V1TVsOpZwD9DauZS7cxkJ3JWuXcvuEeruXPuu8vV9q2t0GhTLaTyQs3uekOXhu6N2FW7aKogzY7h4HzB00rY3wAuAbgDw+j4HkBeyKaWK6jF5JO9TyLcGmKuxES2GYnXjnsQyIgHIAZ9h94C2O1fvq2PVNTby/2era8R0LJzX0bXVNSAep8jqzaiuwezBm8TuDaprcMHoifgvunZ9F9g9Wzu3VUaNOQkxmANZoPn3IiA0gE7Yv+TaLeP2dG0z60qZjkXB4MKMENb2+2x7MHrmSQpIkwvInp4sCATypyjL7img2wX4lLcbU+eClVDnoes2DDAk17C6hgWCZXUNR5XqGj0DnSiImUM6lpsu7GtqFgGFYEnHcmPYPQV5NQAYaXarvq1U14j9VjWlwLGk3S+/kJ/Crp7Bs22HADxgJPYubHOM8elzgOe3xWct08rbtYVhs7HXvmBtge6pu2JBAUt1wGfZPekr3bklu2fbNkhjauwey0m1di5V0rF0yNm9sKrUxRre80Cdq65b3xE24hHKqmv0wrSpOleVuRtJy+K7sK3VNWJMn88SK1dj+LS6htbOzdS5HYau3Uq40Gh1Db/MuUFY8+jNGcw8TK9SxkrE4NgK4CvdufokNebOjRCP6+pcQg74MvCHPB0LS0LmTpi4mjqXHeCdBOF6SNbzXJ0bq2sQoZaOJaZgMYBP07GEO4Q8XVnAN5Z0OVGMcQIzM0D9UJ07yIekNzedtMteyOfYnQV4o21mfy6DVwI83fa9PLz0E3+b09uhywUd4wn+0EXrfq8ts02foRXQDQBf3E6AT9cXVedadq8MJbLl1VpiDZZ1Sj1OFvCplygAvFydGz5LthlwzOiIMsC32SSgF3LvBRfvpnOizmV0GxfSuGwk917nYjqWpM71cH0X1htV52o6FgV7mnpFSQKTdJkl6XJw5wrYUwYvMiHGtTtVnatpvRZmRLTG6M09QOMnSsYuBsICeTDshPi9CPi4xu4h0OUVd64FfJqOpQb+LODLPaNDwNcxgTw1AR87AjmKOZVYAVsRvxeTMNcA38YwfrvKqZXAT5/WjDsX1JsM6ZzHV9js57SchfwQux8Az2zHw+YAvEYMXgnwhNFjs71EI7TBXxOOWcZO5u0g3q7G6k1l+pbIXtwBS+CuAHw1dy4wAHyjmSEmqHPZHG8BXyqZJmsKhoCP9XvwEPCFZ/xh/J4FfN738J0LzKDzGeDzN8Le9R7+JqwfA8Dnw2uQa6/rMmYvS7Ycc+3dmDGybmhKFgv4NureZcRE/hbwLdBW1+1MixQ5MAB8g8nViN/LWD9MBXzt+D0CjBQ+gT9nBBuaf8+WU/NkYvW6NBlr8Xsx/I6RlVMjT3n9XEYCeQr8FOSxBtJycPlq/J7zCfCNlVEr1bmGCazG72n+vRLwXandD4Bn2o4N8JiDi1ZBne/DOAV/fotzxdgchXBbyr17l5hjtcmmV18AbLJTcdmG/Ur/hPi9APymAT67Jmk6FltOrQR8WTk1EhykgE9SrnQsz/iOI+DbsAN7n5VTC6lbGJtO8rv2LoT+xBx7XUrHktXPNe7cgs0blFPzPiXrV1duJtTgFL+XtZWMnr0XLcsIWMUYcwbrf6EXelvp6vxpqw0Eq5J4JMCnx8+N33PytOVH0rE4MMAhHUtNsGHr5ypz5xkSj0GR+Uu59wRzdQoKpSEcBI3N2ynYYMnlNCbYqOXjs/savyfAjzYW2BWCjSu0FeBNAXgB0O0EeOKiZQP24LeG6bvOa6RlNKEEWlWVewhbt4K9vYyRbp97A76GYCMTZ1TWoxLwbZDWuGo6loZgQ182yXJNsBEZvSjY8AL4jHvXSYoWrx6kIKYYpGOJMXwOtBHBhmep1tQPS6hZssBUzojZHWzlDGbjtvUJ0PkO6CSOrwwZWpqtMXrzGT0L9gBkoC7sIy0WhWBDmbyaYGOf+D2dzRrXYd25QPgMW10DNEzHol8xxl+YtVdT6KlgI7TzaHUNp3Irm47FGcGGvLJ0LCYNi75mV9cwaVoYSMfriyjK4q/FrhfgmTE1MKf7VdBn9hXI2fFF/jvd3imyUAavBfD8ZYDeFJVtzVpYioj2w1kkgHAM4JHbHwCu4G+ChWtPgV0N8Gl+vTJ+LxEOQzCo8XsEpBCjynpkFbtZPF8jHYu6cx2SYANCDFjBhkNYf2ZX19BIHKmu0W0cOsnvatOxsLh6NUY8q66hceONXHtxfTHgL6ZjKRW4mo9P07F4y/wZocbCjAhXFaNHRC8C8DKEy+eVzPzSypjPBPCNAG4APMnMnzF2zr0TJmdqp/DJdXZP+gZAsAECS3avx3x3bo3dI3naK9k94uTODR+ds3vazszoWFKtyJ+g6VgG1TVCJ6I7t3OGTSlend69Aijcu7qGAj2JQUq1c40SNwMXy7WrSHZ8LIAX22S/BgArzJ1tCyDPJ6DWqxtWtqUvA3nb2xzg2di9C1kJodwMcBRIupk38znj13i8s5iCOCABu9BeZ/emxO+NsXtz3bnxQZpSOU9djyLIw7C6RhfDiTBk93yqrtFJrr2yusZGWD9Nx9J1Ashq1TVMOpb4cG/LeGYuqSHQA3Ni9wa59ow7NybmN/emRXqNKPweV2BE1AH4JgAvBPAEgDcS0auZ+S1mzAcB+GYAL2LmtxPRh+06714Jk/VJKzyphLlSxu6FbyTvI8CuNumy2rlyfC3Zci+bFvBpf5lsmTgxeoxUO1era6g716ZV0VRB5FJS5YjNXD62dOd2QsUHVxoP3bkDto1Rra7B4vrdlYbFAkLzm2fpWDwtGuidFuABTZA3B+DZ/rkAL75XAF7cL0BduW3Sp0SAxyyAzefArQbw7HZ/a7aXI8bYBb+mwLOht9ZQ97O+DM0/Zs65p7TdM/MoQBzG2T0AKBm8rH+E3au5c1vxfJqeRdk9BuCRu3Br6VhYgF/aztm9kAc2sHmefVTnZtU1WFN/BWDoGcGdW6muYdk9ra5BN5KfT2P6IljrqkDP1s4N1TV8LsRQdq9U5HazIcXpjcTDdR32qQDeysxvAwAiehWAzwPwFjPmJQC+n5nfDgDM/P/tOukeCZPziQPU2b14gI5rsHs1+nyOWKN0546pc1HUzrXpWKZU1+AuAbyaOreM8bNijVZ1jSjcsADQsnsxHx+31bk2PUtnJrGtrmH3F2jLdNOOAMASyNm2EszV2uYCPMPkNQGeVdKWAI89sNU4PcPoKcDrt4sBeqWNxVHPgkUnB1YrSDvUchavDfgsuzdw585h94D62qNs3kx3LiivnWurayi7p8BP1bmu5s6tqHMD0HOyHPhUS7eorpEEGj7kddXqGuLOdbI+kI3ds+5cq86VhMzsfUrlZdOwWFHGgmvd4koYPQDPAPAOs/8EgOcXYz4awA0RvQ7A0wC8jJm/a+yke8HvVlLLUcBn2L1MCaXHF09Px3bnkk4wyt25zIjqXGbE6hoOdXVurbqGAr6QpsXEq0oKlrnqXGw6sCeQJmQu1bk6IS3AqwHAMjGzU6fCcuzqAd6g78gAzzJ4Cuz03bB2NnVKk8GLwE6YPAV+W7u/rBv1wJ1bGdNy2c525Q4+fMLxKwN3dLMADhgCvkPEGl6AVVWda9aecj2amo4lVteQECCNz1N1LkPWk4Y6d8OJ3SM/BHyBB8ira+TqXD9MqFyoc720wSZbVhduTamr6lxR7WYAMQN6DLj+SFfB8YwIcDeLEok8RkRvMvuvYOZXyHbthlIuWBsAvw/AHwDwFAA/RURvYOafb33gAbVuh09bY4Avc88CA8A3ps61gM+6c/cBfDFQFgnwMYqJaty5FvBZdS6ZRMpBVSWT06hzlRW0gE/VuYnJS4BPQR9rjEXHBvBJQmYBhaG/i79XM+FyLQ/fhe3qYvCy/RqQa7VXAF7ZXwN4rRi8GsCb4qItGbztNu1vtznoW2Aw9UFWc706l7cNcutdzdP/nTJGYuuAOuDb5c4FcDTA5/YAfOFvCMRBDfDp+PS3hjXBE6ImLxScCGuGjd/TFGDa3sf4PQF8PWGzCe5c6ru4ppCuLzfy3nfBnduRtPUJ8CmA07x7NiTIAr7NBlTm2tP0LEszWhyj9yQzf3Kj7wkAzzL7zwTwrsqYJ5n5twH8NhH9BIBPAHAcoGcnYgvwlfF7QIUiB9oMX+HObaVj2RfwdVKrUN25JeDT+D2l1KfG7zELDS8BudylahsK+JjDvHC+DzF/zMlXwYisjcbvpaTLDLCLFThwo7J3nwO+sbg9m4/vQnYVMXhV9s6M2Rfgxf0RgGcYvKiiHYvBE2BWBXj9bT6uZPC22wTyMobv9NdHqbR1lbaalSNqR5A7gMmzAG/UX0wTwKA5fmX9ZtlQ8Cf7GnOHujtXjxmL3wv78r5HOpZISjQAX3DdtgGfunFt/J5l+DR+z0MAHxLDF0KIfCXhMqHbkIgDtZ1FuSv590zuvRird1MAPq2fW7J51pXbdQnwbTaA6wPg6wQc+uUxegCuRowB4I0APoqIngPgnQC+CCEmz9oPAfhbRLQB8ADBtfs3xk66p+s22JSnqLmCjRqTV5t0+wg2HBF6rsfvKeCzgg2bjkXr5w48orIW2/q5+ueUgo0yR19Mx1KJ37OxezkDGFRZIUdS6qeStWumZdnnf/xwW4SLdgzg2f4LAryMwYtuWgPwprhoS5HF1iRJzkBe7sLl7Ra8UEZvClSiDFtNOMIyeQrc7nli1SVZDfBNid8DEKdeCfgGMX4T0rEMcu1V0rHY/Vb9XKLwOTZ+j4BCsKGnKgQbwvBx54bpWFTI0YUYvhAi5ES5y6l+bpfWklROrQuCDUbKx6dkg64h1pWr7l0DAFmYwODSXZSLNBghlB+9AmPmLRF9OYDXIlwO38bMbyaiL5P+lzPzvySiHwPwzxEu51cy878YO+/erts5OY50TDheOgzgi+dqMX9le+HOVSszmZeCDfB4dQ1HjL6RjiXgRqqmYwmxfvOqa4SnM27G75HE5sX4PWEAq4INjd/rXFIXtdKynJnRWwTAG7SNAMASyNk229dqmwvwDGs3iMGbKrKIoK5g6KzIYnsbzheB3m0G8CL4OwOjdwwrb9s78RlJCbRzKmhXm20WzMU2jLtzgdyjZI8ZsIF7VNcI/TmYm+rOVRKiTMei7F5Yi4aCjTIdixfApylWYrrWSnWNblNU1+gIGxYFLneDdCwx76u+q7dI3bn6Yh7m4NMH0VidaYGMHlH4W67EmPk1AF5TtL282P96AF8/9Zx7a6HHVFC73LnK7mnmcQvqLHUOmAOA/OlJxutCGyeVjNtVXUMZQe3v5Mmtxe6Rum7FnQvPqc1RKo3j9CtwYu4U9HWJ7ctSs9Sqa3gHmf3QfEmD/Hs2HUucrBxvLlGEEdk8Nj/2aW2ZAK849pgALx66C9QV21rNIoI8n4O4KdUsYhyeBXVm34I9BXn9NgA8BYQK9M78IFCaLtRHIdZWMcVVWgnmgHF3bujfHb83RkS03LkZQTHBnbupsHsewFg6Ft12tPWHpwAAIABJREFUcmA1HYsAPwbAW4nfU/etQ6yusekSu+ccxX2trtF5BjbCOtyYXHwq3uAusHudT9U1NgboVVKwWPDHm+WlVyG6KtftSWyPhMkJxAHIgFxo3x0jMcbuZaBO+so4vZaIo8nuxXOHD7Dsnn5gz+PsXunOVXbPmWs+/hmG3YvpWKKgAxm7RxrTV7hzI7tH6tYNwJEM0LDsHkusRZyEWjvXTsgzxOhdRGhxFIBnxtTAnO7PAXjxHAnUVQFeLdlxCfAUAFq3rHXZ1hS0fQX4bW8Tg9f3w/eFum6tWQBgHu9ObyUoPGVqlhWANgGfK8bMdeeOERGlO1fXl9KdW/UsMbDdwe6NVddAJR0Lcdud26quEdk9Q9hpdQ1V9lp2D52P7txINKgwMCp3tRZupYyauni1b3FGSxNjnN3miTF4COLm5jgqQSFQoceBKuArgV0JEEt1rh4/V51bY/dKd65l96w7N4C5YXUNC/qYKQJBra7BDJAvqmswhzq4ytwJk5jR7IoYHQ3dua3qGkuzawB48b0B8Mr+CnOnbZnQwgK8movWMnw1oUUZfxcBXU1ZexsUc7elGKO/OtettVFM5MRlWx4wBUhpyTNyCU2sAOxkxkhrhbXSnTuV3Sv7Wp6nvdy5LQJihzu3E88PI61JIe1XLtaYU13DxxQrgayztXOr1TW0dq7G5NnqGgrqTO3canWNUqBhXbtLs5XR21OMUYA4YPh0FNrak6oJ+HaINWKfAXZT1blWrMEjgA8Fu2cBHyNJ5aeoc0MuJGTpWBwbNm9EnduxlwDePB1LxubZvlZ1jVKduxS7NoCn27sAXqMeLVhAngK4MYBXum/nAryC4WML5lpA78yM3il0D3vVuj0nU3diOzh34AKsBfaA6YBvqucJwDTAt0d1jZo614t7V9k9BXwx/16luoaGPIVlr6LORSqnxhxSrXQC7qw6V9k+7yVtS0udy6mCRkzNYtW5Nn6vps5doK1Ab6a1AmNLN+1cwKcX81h1jRawG1Pnhs8YTqwxwBcodAzEGgr4PKeKGgPAh0SpEw0BX1TnsgV4OeDTfk9hsg7Ssag6V8rfUOey7QDqHLjjqM4NYNAjBzoXsEmfvwCAZ9tqDN4A/Mm+Uc82GTytQGHr0U6JwWvlwPNF+8OHIQbPAjjdVpBngd92C9724G2/KEbPFe/AdAw2aZwddIhQ4w6Aq6WZN/PYgr5DAN8h6Vi8rAVj7tyWOrcEfKi4cxmI8Xua1F/j9zyTOV6YPCAyiFk6Fm/i9wrA1/sQs+c7s+0Jfc/oOh8AX+/gegZuXMrvqoBP07Eo2Ov64M61HqOFJVwHgGsTY5zCDk6vAgzjJA6ZVKPxezrO9LUAX+nmzdKxVABfLX6vpc7VihqdKG7L+rkxMWYF8HUcFFihikYd8DmmLH4vAL4ifq+n5L5VkGdYvMj49SSAT+nCff7Hj2TXwOBNBXgl2CsBXktkoQBvH5GFzYE3UNSOxODZVwPg8W0P3vqg9D6hHZPFs/F5gckbObkCuV2gTNOsLDlp8j0DlnMYvjJ+T8fMTcfSFGxMjN/LwF0h0NiOxO8FEEeD+L1B/VwTv2cBXy1+jzxHwMc8LKem8Xt9z9hswkHUC2FgAZ9NxyLl1KqAb2m2um73SJicgbpgtZi80D4vxxGAaYDPunO1rwCCA8GGnXTx8Ho6linl1BwBPTiL31ORhi2nVgo29B0Ia0lqHwo2iCT8TmP7bPye0P2lYKN8RQGHsoCXYPSuAeDF9wbAs/0V1q7K4JUu2haDF9W1BrSVAM+qZucCPO8HbtsS4HnZXhKjB+Tzda7NzqW32sWtll4FGLpi7XigvibVzjk3fm8QklT01+L37NqTxY7viN+rpWPR+L1B/Vzk8Xuq1LXxe9SzAXUi2GCS2rdAVi9XAB9zEGs45weCDSUVcCNqwt4BGyfnC/dFusT6stNoFWPsc1Btcs2lzacINpSmDuetp2MBoLSZbO9oL9g9Hedl3KHVNSBPVRpbR0awAW++DtsyablgI/Qn5W41fs8BxL1BinJjsWye/v1lOpZz2bkAnu0/BODpdgvgWWDXAHuDZMdjMXgW4JXJjlsxeNEda1OlFDF4LcDXS1Lkh9sM4KH34Ns+gL0FAL0WuLPNU9W2NFV4sWi79u8/z1pgD6ize7VjjhG/t8udG/YZZfxeOCcPPE7xfsxDd64Cvg3l6Viy+D2JH6foQjbl1IT9s/F7JH1Z/B6jXl3DUcy/l1XXUOVtloKF83QsPaf6uQu4fwyMcO8f6GYCvfw/scXuDfv4oEk1JX6vxe5V3bkFuxeAWpgYteoaHojJLoHx6hpBlZvcuRrL16qu4Rxk8gUAB+Ts3lh1ja4j0Eh1jfjDChgJDOYZJuK+AK91bA281fpaQC5uTwR4cb8C8HS7rEcbGTxOAC0CPj8EebV6tINyZElMkfaN2EJVtBbQlapaw+jxtod/uAXf+ozR84bZuwjjKzbm1m117YXhiI544y+/wP0CZaeymms29k1k98JYaTNjpqRjmUpEzEnHMubO1TFb1N25cQURQJfYPUR3LmJIEYTd0/q74+lYbHUN3jhZd8ara8TMDyxAUKtrLBLo0WJFIueyo+TRAw5j9wDE9XUsRsI+LSm7lyabnoebQLCk1HVRyxiEmezemDtXc/ERyXHhES1j95gR3Ktys6ilY7HVNYCUjiX8qSzu3AD0bHWNMKML4HfqeXguFm8WwJO+UYBnxowBvILNywBemQrFxOVxjbUrwZ6Culo1CyvE0GTHNfdsRWzB2x5eY/AU1D3cGjZPXLfbHgflQbyQWRdtIPBmgq258Xg2aeZqJ7V9AV85vrUu6XmOpc6N69YOd25cj/Zw5zara+hvIR6nKNIw7tyS3UvJlpG5c8vqGptNCBkKCZU5Z/dE/BfduYszCvGD99j2r4xRUOi72D0gB3G1Y2rsXsudO5nd074SCOoTVgH49CnKsnsK6BTwdfEpLlXXqLlzS3Vu5s4Vdq903dZq56aHJxFrGHbPVtdwVKmuIT9e5s69iJ0S4JkxXLwPGDpp2wfgGSavCvCYEYUWNYCnQovejKmmSGkAPN+DG2xdBu5MHN4A4GXvCeB5z9hueRGu2102xW1bgr24m9W3bZwnBtGK23fJwox7YrvcuQAG6xGwnzv3EHVuq3Zu+LzG2mNcvBukMTbUyLpzld0La8ewukYUc6CoroGc3fOeq+rcsrpG8C7l6ViU3Yv1co1rd3G2um73q3Vbo761D9jtzj21WKMEcM3klg11rn6Fljq3L9i9UXcuD9W5FvxZdW5ewCLF6JXq3FZ1jSnq3PPHUJwS4FXamgyeadsL4AVANwngeWHGakrafjtk8MpyZVZZqwyeTZXy8GGe+67IkTcH4G17hu8Zfe/D9vJxXtN2KnpHfcNufDHQxMlTTO9FU1i/lRmcbGPsHjAkH1rHnFSdG7fTulW6c1tCQRBhy7vZPZZ1ylbX0HQsTEo8BOA3VOfKNhumT0Cf84G5S6BO8u51QaFrq2t0nuE2IfceTDoWt8g0JiujdyQxxnTAd051bg3wle271LkDwMfz3LkEmMlGEfw5o871Avi4l9QrDAmuFZauAHwdp4SXVp1ry6l1HYG8Mn4J8J2P0NsX4HG77yIAr8Lg+T4waWVCY2bwoESZ9lcAXs1FWyQ8HrhoKwKLgYv2YZ9i8ERoUQN4/daj7xm9Z/TbkBn/3K7buelW8pQqpr2GwaacvARahwCvFbQdbCUIq44ZAXzHVOfqeeaoc6tiDWAA+Ep3bkuc0QJ8bI4vy6kpg0cI7twgCMzLqTlZXzwDjkM1KL31dY6HYo2epbqGg/c9fOcCM+h8BHzUOfibZaZXWRm9A+xSgG9X/F5or7ttW0xeUxJ/ZMDnJH4vTkZCFfCV5dQs4LOsnzJ9FvDpGI3fs4CvCcCOZvsCvOLYMYDX6ssAntmeC/BaMXgWuJUiC2XwbPWKsRi8msii74Hbh22RhQV4twoOKy5aUdXGlCk9VwGeZfN6z+h7PtuDwK7b7tFuy46GiGCKErfVv7pxT241EFYdtyfgm+rOLc9TW3PmxO/F/uz4w+L3SsBXK6dWAj5V50bgaQGfKadWA3whrCiP3ysB39KMQKBVjDHdGPUnruHk2Q34DknHMniKArLJQ8CsdCyteIldgo1a/N4Y4HMckioH0JiXU1PABx6WUyOiQf1cW07NUQ74tLqGsoMa7+cy0HMKmwLmam0TAZ5tOwXAazF4VmRRpkopXbQK3GoAr1TNFnVoqyIL66K9va0zeIWL1pv0Kdz7gYv2djsEeF6A35kJvau2u1BubMl2KsA3N35Pz3OKcmrp+ALczQR8MCQEOMXshdrtYVvr5+pLy6nNEWwEFa5x70qMn3cU8+8tzq6M0SOiFwF4GQIB+0pmfmlj3KcAeAOAFzPz3x0751EqYwCtyTNPsDFnUu0SbIRj5UvNEGzsqq4Rh1p2LzUCGKZjib8PcRa/B4TPsPF7MOlYgBC/VxNsxK/IuWADUFBHQ1AogO8sdg6Ap/tHcdEGQHeQyKJ00VqRRQRslRg866K1MXgW5NlqFrfbIcDrLZs3FFn0vQ8EYO/Rbzm8K/jzwW0bGL3LID1nFr1h33AF13FhLuVjZ+OvYwC2qedYweFsm+LOBYaEQ36O08fvlWvTlOoa2jdFsGEZv9o+Ia1LKsiwgg2trgEhBpyJIW8JNpgR4/e6qMY1dXPFnavrjJsbi3EWo6uJ0SOiDsA3AXghgCcAvJGIXs3Mb6mM+2sAXjvlvIe5bnEcdg+Y584dy3EEYNSdW03HIn0lENzlztXje8x355bsnoOAPx6ye1pdQ78mkNi9QXUNllQr8qd14rLV/tN7bo8B8MyYOQAvdnO93zB2JdgbVLPYtx5tWa4sY/JKNk+qWVQqVwzYvL4HP7ytVrPISpjJft97bLcJwG17H1m7XsCeAjzvGVvPZ8m+U7PW2jDwuGLGIlIe7GiYPPmKnvLvu53anWuPmRK/t+TqGir6sGtSSOuFBPKE3dtVXaMzcePhxeg01x5rlggfq2ssEk9dF6P3qQDeysxvAwAiehWAzwPwlmLcVwD4PgCfMuWkBzuuj8Hu6Xla7F44fzFZMG1SaToWdedW2T0gPSXBHGDaS3duVjtXxtWSLfeyqYAvBe3m7J4CPhh2T2vnanUNdecCyuYNq2vo72dLp2V5+XBGOwfAi22y3wJ4hWvWtlWrWViAJ32jyY4H1SvGq1kMAN6uahZWUHG7zQFe7yO757ceWxVZRKGFD2BOQJ4CPgvwPBj9hYDeIixTdiyRlVgNOB27VztmajoWe+zsdCzAwJ1bsnuDUKIRAKjpWSy7V7pzLbsXa+dKm+bfs+wegTN3rmefpWOJ8XsbgucFzh2ia0qY/AwA7zD7TwB4vh1ARM8A8PkAPhunAnqtCdRi94A6aKv3y37j2EMo89nu3LH2CrsXgFpdrGHduZ54wO5l7txG7VzrzlWxhoI9W12Du5zdI09gB3gXntrOEoQ1BvDK/hpo29leAXhx34K6yrYVWijAUybPCi3mAryymoUFbbZNhRYW2BXpUVoAr1XNQtW1pdDCAjwvgK/3EDcuY2sA3lKBXnTRGvDVWkoGMXNT1pwxgHds4UU8/wIXwyuyc7J7+nmHqnPLtWkwpsHujVbXEHBnAWCWnqXhzlV2z9bOJel3sgZZds8J8bCrusbqup1sjxHRm8z+K5j5FbJd+wHL2/I3AvhKZu6nxgkfJb1KbJf3S4g1AAwo8UPUuS2xhg2OPbY7Vxm9MO+TOjeqqiAVMYgiu6dgz1MCeDap8qC6Bk5ojDo7Z36X7N2OuSaAZ1OoKFArlbTK4Bmwx6Vrtpbw+PZ2FsDzWx9ZOwvwFNxNBXge4ro9x4PACax1wyOiYd9YZYvSxTOpCsYSF7e7b0tW5x4i1ggMXg74jlFdQ/Pv2dq5dv3S6hoMxNq5TsZade6GJe7b19W5izPC0ly3TzLzJzf6ngDwLLP/TADvKsZ8MoBXyX3tMQB/iIi2zPyDrQ88anqV2C7vU9y5YdwQ8Fntzr7xey3Ap+7c8JkG8JkxOgFa6VhKSt1OGEJy584FfCzflyqAT9W5zOHJkIXpcximYwnxezV1Ls5gZwB4Zf++Ltq59WhtjF0Zi2cBnnHhcumO3eWifbiNMXiQPHgZwHu4FZGFCCr8EOCVLlrvw7XYcx3gaSLXa4J5J711F2xeBhanPEUvcL27qzYH8I25c8M5KBuvNiYizPsLjxJQADZtOxDwKZiza88EwAdh9zSVVwn4YhJ/tAEfMwLAQx3wLc8Wx+iN2RsBfBQRPQfAOwF8EYCX2AHM/BzdJqLvAPDDYyAP2CO9Ss1OCfj0PFMZvrFJVatDmAG+GfF7Vp07iKHAEPDNqZ/bit+z6Vha8Xu1cmoW8J0e6FVA3VyAV22T/bJ/X4C3KwZve5sYv76SHqWsaDE3Bk9TpZQu2of9UGQxEoO3LQCdFWHUYvA8GFtObV4eYHQBWYKNLdiTvLG11bwGzrRt6tP+EtmKO2SH3pqmxO+NsXvhHEPAp8ddKn6vBfha8Xva1gJ8HVF059YAX0eA5zrgs/F7Hjng03QsizMC4K4D6DHzloi+HEFN2wH4NmZ+MxF9mfS/fJ/zzo/Ra0wE4DiAb990LPqd9qHN48Vcc+fKuBawq7XbdCyKK8v6uYLeAOSCDUcj5dTku9fKqdn6uclli5RE2eu1fuKZeAjAi+8VgBf3Lagrto2iNqporYvWMngmL96AwdO4u0E92lRzdgDwTP9sBq9w0dby4E0BeGMiixaDpwDPg9PPfUUW4lnTPSOFwTWA3bGEFrPj91aQOMU0/H9fO4Y7N5xnejoW+3lT4/cAxMm2r2DDxu+V4K4l2NiYtUnXJQV8WjMXqsolYCDYQKquoXn4GCEpf+d5ma5b0DWJMcDMrwHwmqKtCvCY+U9OOefef31LuQS0KfJrFmwkabzps8eX7YU7V415XLABHq+uoWyfCjaYEeP3VLxBXBdshFxHOL2dG+CBcZEYvMKVe+kYvMjo7QHweqRr89R2jLVgkvd0zgftK7xYFbpHN70KLw349hVs7Irf075jCTYG4UcFuLOM37YRv0fCCtjqGqVgw9bPdTZFCyETbCzOiK7JdXsSOzCPXn0iAPPYPR1/asHGmDu3lY5lanWNsn3Mnavj5lbX6OS81p3byaQexO+FPyAjMdiC01NZCeRsWwnmyvH7ADzD5k2qR2sBHjOqyY772xzglWDPum/HqlnsqkfrfZEHr16PNsXg5dUsLMALIguG52EsHjeAXwnwsuv8AtZ6cJxqTcw1Avjmx94tKqj7TtuxAN+U/7G58Xu1Y6bG79ljj5GOJR3fWHsmunO9ISGUcLDuXM2/p9HkZToWDSdapF2J6/ZUdhQ+c1/Atwvs6bnPUV2jNnHCseZpCWiyezVgl0niDWWulrF7cu6x6ho95+yeI0ZfpGOx1TWU3XNsWD2c0gyQg/kdSjDXbDP7FsgBqMXeZQAvgjw/rGbhucLgjSQ7Lt2zZekyLVfWqFxRrWYR3bIlsDMxeNJ2u/WxRFlKjSI58WJlC8PocWDrtghAzzPQY5gfT0Gg3tB7A/ASw3c+mwrsqHivjpkD8na5cFcwtyi7RnduGaa0rzu3JiQcsHumbywdi2X8IlFh9mvsXvQ4Ze5cJOAXq2vIaZYYorAyescBempz3bnHFGvoefZh91qUuf1uLXUugAGwG2X9GuzeXHVujd1TwKfVNSy7p+7cs1A2Y27a2QDPAjsD9izAqwktSoDH4kKtAbxWDjwL9kqhRVm5wrhmawAvq2ahMXgFwFMhRQvgpXJmOcBrCS1KgMfGfTsAeAxsWaNwLm+1smdqJ/WWnuLkq3v3YDs3uwfMd+cewu5p387METV2D8Cxq2vAkhCMzJ27q7rG4owI2Nxc+ltc1I6WMDn2H8mdO1WsYceU7txDxRotd+4ude5eYg05vhRrBJiTAz4HGrB7U6tr8KnnYQnmtC2+NwBePNYPxxZsXia0aClpLcCzStoWwOstyKswezWAN5LwuArwRsqVxUoWIrSoATwtZ1Zj8DTernTZWoCXA7vwvuUc7F2TzSLx9gkMPKZ4o3bu1WbboYBvKrsHjK91Y+lYjq3OBVBl8MK+6d+juoZl/Czg2xRiDbL590x1jVKdu8TCGOEHWRm92baL4gZOB/h2TbDqJAEGrF1r/L7u3Diu4c61gG8wwQp1rn2SCjR8Dviwo7pGoNJzdS6dI36CkQAaMIPBk30jqKjF4x2lHu1YDryai1ZFFjNctF7y4GnFihLghf7eMHQ+aDaiW9ZnbN4YwLMuWgvmdrloS4DnzfilWHwowrSFGUhTsppAuUx+nAZXxtpxjU8fS9my2kntXIBvijs3nOc4gG/ftQlyD3DiZtVwoV3qXFdZjzYgbE2/XZdUncuy5pSAr1uk6xZAd7/DMU6SMDkbc2bAtyt+7xiS9zHAZ+PxtK8G+GoTbLycGmK8Xs91d64FfEkZlcfvnXwhzxg5+WuWHoNnGTwbg1dj7Kyy1ihqp8bg+dttozxZDvAOjcErRRY1gFcDeydnfHfYrmWi7A+VL1qDF7jorHZUWxLg2zd+T8ccGr8Xxxj2rwX4qmuPsA1bCflpqXMZqZxaCfguff+o2hqjdyQxxkTANxa/Vzt+imDjFPF7AA4GfM34PT2+iKGoAb5weD0dyz7l1GIuvpPZVAbPbiOBvEsDPN8Dtw8Tg9dKeJzVo62zdVn6FMmFV8bg9eqONSILVdQqwOsNeKsBPOuincPgbQuAB3P8NVjtTlJl8ahSAq1mu1y7UwQaK7C8mC1BsDE1HUuLyJibjqWVOQJFfwn4yvi9lvu2Fb9HAIIqN61JTFhujB6wum6PebJD4vdaxx9TsHFIOpaxHEccz7t/OpasvYjf03Fzqmt0xPC1+L2T2wyAF/cPFFnc8Ri8AN4U3B0Wg6d9W/kvsC7bcypuL2pEiNUwbFWMU6htV/B3NruP6VgATIvf036yx9fXninpWGK+ViQSIhALC7zeVzHGcYEeMJ3dA47vztVzXyodC6PB7um4Bru3K35PTzNWXaNMxzJaXeOUxpwDPG1rAb6CzRutR9sSWdSSHddi8TLwdkA92krlipjs+GECfGP1aBXglfVopyY7rgE8ZfNarF0rJs8KMc79PO6K931tEms31Vo3LwWCVUC4wAXuntoS2L1wntNX1yjXpprgEHbt2rO6hnqgNqCMjLDuXI3fW56trtuT1QU5hju3To8fx527T1DslBiJmjs35T7S83ATCDYl8XYhm8nuZe7cU5sFd2MAD4ysmkV00cq7rWZhQF2zmkWsYlEBetY1W4gtuHTPFq7ZQbLjh9tqNQv0PsbnabkyZei2PWd58bRcWe8RAZ+6XkugpwAv3Ejz9hBTF64ZBkxqlXx7CsDTc57aDk2KPMVaLtyMyWsefAxWb8+/cWX/jmbXUF1jLFRpLCa9JC+mZI6YxO4BVXAX2TzaHb+3yGuYsLpu5x4wR54OjFPc4XzXwe7pMTV2b1d1jZ3sHswBQAKClfF2UpXsHiOVUxsmWw7u3JM/cO0D8CK4MwDPsnjMCeD1t3WAZxW0mWvW58ra24fIlLQ2Fu/2tsrmxWoWqqTN8uDVq1n0vbhmt8rmCbNX1Ke14gkL9GoAj81YC/DSccPtFsBDbGcD9s7P6NWsdb/QuUrxfTgwgrwp6VSi6vZ+K/Lusi3ZnTuV3bNjDs0c0WL30vGcs3sz3LlaXWN5tjJ6B9S6DTZ1AgDnA3zXKtbQidQUaxjKPH4NGych5/YSK1Gyez2nG99JrIy3q4I9P2TwrBu2BfBUaKHMXOauHcbbDQCeVdK2atHe3o4DPHXJPtwCvc8AnsbZbWNt2lSuLE98XAd4LaGFBXiM5JotGbypaVNSew7wzsHmtexkLN8+ufOs1QBgLSXLElmM1TK7RnfuydS5Dfav5s4tQ4mmVNdYnBEB3cmcl1dhB//1pwB8h7pz9xVrAIcDvqnu3AzUATnDVwC7MXduOnyaOvfk1syFVwF4u+rReh1jVLKli7ZWoszu71GPNipnex6kSilz5LXq0ca4u0EMHg9ctCnWbrwe7b4Ab4zBs67bcB2d4RrBPAw2NpQonauKyxxNA2LlwaPxeFNt6h+5wMXxDto1uHPtMbuIjH3VuWNijWOocxdna3qV48XoTaW3gWlPPcDp3Ln23MeO3xtMKmA24GsxeTZeYl/Ad9ppaBi9qTF4NYB3yhg8y9rd0xg8y+ohG7NcOyoUshUvDk29coqnpyWyInfIrh3w7YrfA1C4Y7VtyOCF/Up/4c5tkg0VwLdIW2P0jmfXFr9nz92KeRj27fcU1Yrfm5qOxQK+akkb5IBPBRtODzkHo8cQ4HYCkYUvAd14RQsu06JUUqSo2za6aDXZsVXR3vZAz9FFe3ubq2gV4EW37NZXAV4PZKlRWgBPGTwFazUGb0oM3hjAq7VD+pbyPN66h0T2rrgn7Lq2J5VAO9TVu9pV2TUAvoulY2nE75Vkw0CwsZg7iDUCXRHQI6IXAXgZgA7AK5n5pUX/HwfwlbL7WwD+HDP/zNg5T+K4XnL8Xjn2kulYwrGJ3QvjkMa1YvtG3LzN6hr23Kc0AXXNGLwS4DFPj8GrJTi2yZBbLtooxJgQg/dwWwV4VmRRA3i7RBYag9dXAB4jgbRTx+C1AF6yy92oyzns9LqdaYGwq9xQLJMHYKcCd7V7YUsSbOybjkXHzE3HAqAO+Brxe+HzuLr2ZALCJRkR4K4jRo+IOgDfBOCFAJ4A8EYiejUzv8UM+wUAn8HM/5aIPhfAKwA8f+y8J/3rj+nODee7XDoWIH8qmsPujeU4mpyORfrmxO8hHm4KUw9/oiPajnq0YyKLCOq2OcAr2bt+W2HzGsmOG2yeBXjoTbLjWNViKLJKXiYYAAAL60lEQVQoq1mM1aOdUs2iBvASG9dm7UrwF371aQAP2X4O8Pwi79DzbS/W2t4MiMZFGKvdWVuCYGOqO1c/79D4vebaVGH/psbvLc4IwOY6gB6ATwXwVmZ+GwAQ0asAfB6ACPSY+f8y498A4Jm7Tnryv/7a3Lktdk/PMyWp5VTKfFY6FmDgzi3bS3durbrGSY0RgJgFeGMxeLavN6rZEuB5C95uhwCvVM7W2Ly+Bz+8nVXNIqtW4YfJjrXfe8bWJzC3LQCeZeosy2eBnR3TYu2mumlL8QWyMSj20zXhT3x5HNt2umvnpFpZrF3zd78+WxK7ByzLnWvFHAN2T8cu8nKla4rRewaAd5j9JzDO1v3nAH5010nPBnNP4c49FrtnP2tfds9+pymU+VSxBoC2O3esvcLusTnVaYwNa+cH26NxeGUd2sH+FrGahQDAWdUsFNA97HOA1/sE8ozQIpYs84Wq1gDAOdUsuGi3YI2RmLp9qlkcE+BdA9YbxueN3CiOycQNzrWsVe2o1UHuuS2B3QvnWU51jRa7V6ZjWZwtT3X7GBG9yey/gplfIdu1K6H6qxLRZyEAvU/b9YGzgF5YlA6fAEtT5+r4Jatz47ENdm9MrFGtrnEKY04AbS7As/nuSoCXlTArypWVMXgtgGeUtD5LeDwN4HnD6JUM3q5yZR6hvRRa9Dzulj0XwIvX5sKtHnZH1e1Rc86objWNSvXkM7/hanfJrkGsUR7TWpfK84y5cw+prrHYe8myGL0nmfmTG31PAHiW2X8mgHeVg4jo4wG8EsDnMvOv7frAvRi9QyfAPu5c4PSAr+XOteduPREN++ZNqp3VNYABi5fVyAUGTF5VnXvKJy7mWHkC7OsAr6xsUQVz2zTWAMDJDJ66aCWpcaak1Tx4tz3Y+wHA20pqFCussKlS5gC8HmGulGDt0Hq0pwJ4S3DdnuxhZO55z8ES7nOeFXye3c4N+PZx5wJ1r1O9nwfr2b7pWML6kgO+xRkR0N1c+ltMtTcC+Cgieg6AdwL4IgAvsQOI6NkAvh/AFzPzz0856UGu20sAviWlY5mqztXj9omRyL9XzuLpuBawq7WfdC1nBm8f5q7bsRi8QUWLgtGruWgta2dj8y4Ug8fAbIB36Rg8C/BKcLcArDew2pQv8c6A2avdKErV7aC/mnF52pfc9QVXu3o7V/zevsTGnPi91nq2b/xeCfiWZQRaluu2acy8JaIvB/BahPQq38bMbyaiL5P+lwP4agAfCuCb5b63HWEIARwpRu9c8QzA7kkQzndawLdv/B6AIR2O6YAvgArD7gFthm+M+TuVsRdGb5szeTXmzoosKjF4A5FFo0wZvE8uWmHrqgCv9+CH2wHAqzF4GQDknMELitrUZoGZBXiqoj2UwbNAbh+AZ4HcGMC7hOp2H43ErvtM5r7d9QH7zIc1Jcu9t7sQv6djjpaOBUCWf29JRlia63bUmPk1AF5TtL3cbH8pgC+dc86jiTHOqVYCpgO++yTYSLEURdoVPZ45/j+dxljA2i0G8XgTY/D49mEd4O0SWYiLNpYv2xGD13LRHhKDN+ainRuDdyjAq40p28vx57Jdc7zWv/cziqPdx1rWzsbv1fpXWw3XH7+nY6YKNpC1DQUbKSXYQn0CVwT0TmFHV93eVXdu7bNOIdg4ZXUNGNx3ErMxelZkoXVqNQavxu71W7B1y9YYvb6XPHgFwPOBrbPVLGr1aDXZcU1kYatZzFXRqshirB7tlGoWiO1DFy2Q2oFhn/YP28z2DoB3yRi9s2ZAOQKzvSpcVwOuI37v0HQsetwsd+6SbHmq27PbydKr3GV37nDc8qprWHZP+06+kCvQUxFF6Z61YM8CvDH2TsGegMBqNYvs3WfVLLIatNt2NYsA8Di6YHtWANdm9izAS2xcHdTVXLb632FZPAvkam7YQwGeHd/qvxbTGTcmnG2a2+egCd9oBYD30g5d74Ah41Yds2Otm+PObYUp7ZuOBcBCY/SAa6mMcSo76V9/CXfuLmbgGO7cVuweMN+dO5XdG8txVAV8NXbv1KZAr0yZUqlFi36bRBYT1LQpNUoB7GwevNse/nabATzvgW3v0W+H1Sy0Zq3G4W0RgJ6vADyW37dMj2IB3hShxbYB8JCN1/4cwB07Dm/JAE/nTU2Fa+fiZFzlaDy+blfs3S737Qrw7r1dmzt3F5HRikff5Xlanu2Y+/fAzgJzz+nOPTe7V46tsXt2TOnOPXd1jZPOQ/bAw9/JlbVlXN7twyHAE5fsGMCLStpaDF6hpFUGLwd1SUlbAryW0KIEeKXQYgzgKYMHDFm8SwstWjfjMpbvHDY2T8v5Pnb/yM7jqM0snAKQrSBvNWN3qbrGXurcpRnh3sfZnpXPvCvu3LliDR1zbLEGgFnu3JObZ+B970v1aotUKbPq0fYeg1QpD4vYPBlTAryyHq1NldL3uYt2rB5tdM3OAHil6EL/L0qAVwNxNeCn+2Hs3QF41o4Zn2cx184SaMMcLWbb3XsWYLXD7FwExxR3bjhPm4Cofd6+7txF2j1/GDu74/qc9DZwGsA3JtawY0/hzgUwUECFtmmA76QeXPbA+95rgFsAemwA3IDJKwHekWPwrIt2KsCzTB5jCPBawopSgKE/9RJj8C4N7g61qRBskmhianLkKitwvxeQ1XbbkgDfqeP3FinGWFW35wd6anchHcsx1bl6nkPi9wDsBnynNO8Do6cxeGMlygpVbUqNMg3gDZWzgcGriSx6lhcSUOMKwLMlyqaILFrxeHoMYnsO5MZi8E4N8MpzlHbJ+/SUuXwUWHXPn+5Xu4wtIf/eMeP39DxVwLc0W123l7W7mo6lFb9nz70rfk/7apPKArly7Jhg46TGDLzvvUOAV0t4LH1ZebLbCsDreXIM3j4iixLg1Ri8EtSVAA9mbOmiRdweB3gY6bdjynY7vtVfO8fgv26Zj+IAdrNy2j9WPu3/b+9skpyGgTDa4gCshjVXoKg5BEdmw4I9cwjWcICZ1MTNIlEstWU5MpGtKO9tkpJl2ZU49pf+naxxcet+mI7XeiggMB+ereP3RMoF3/+UY2kSRzLG7kLP00v8nj2HOcG3ZTkWm7BRC9VB9O0tds2Gr4FFb5JkkWlXdoqxi4sd2yQLb8VLdbMIky1ySRaxO/Y+u1mUumlbFnghqXvD7G99TlDlbvglInHxOLm5iD3Y/nlXo7tGLia9NRwWvXbowZ07dw5r3LlrgmJt/N6mNY5URQ6H5W4Wh/dzWZQhtui9H0UPZ6E3DJduFmO7srEfbdjNorTY8bXdLEoFnpg1JTEuMi/w4rGYlEt3bvs4L/NVNSrwrnLfJhIurBhzNaPCix8a7T4AYT/urRyLP17OutcmFa30d0JTQs+z5b8dkfw/ntN692Hd8/ukrHub1DgaVOT1NXbbBmJvLI0SCzw9DlF8nhV4R++i9UkXgcDzgi+Mv7MCTxPCb6mbxbXtyuQyfhuBF86z43af1Ha7f4oWRF6tf/+RwPPvZyxvq7pb4H6FG9NTOZYmcUIyxt4nMEer2bk5615q/6WgVr/uac7tkjVEJJ2dWxMdRoteIPCiTNpJHbx0okUo8HyplKPflhB4VuilBF7krg0Enk20WNOuTCRt2RMz328TMxbOs+N2n9T21BqWJgTe1g+DkgM+eBwP7EsLyRqndda7c5ulWRW6Dc0KPU9r7tyleIRr3blz1r1w7VsIPju36m9x0HPWbULgBXXwfDyeHDUp8MKyKbZdmXfRWoE3Jl2EyRR5gZey2pVk0pYKPL99OhZ/hHau/YgnY7nvRNoQeCWESRXhT2nufTGTxIzE3cG5eN7aBwUWQCjg3t25bYLr1mlB2Q3n3B8R+V3vdGADPqvqpxoLc310AdcHLFHlGuH66IZq95A1PH/9or9+/tj7NC64j08vqvq85TGLLHotfXnQHlwfkIPrA3JwfUAd3MPH6BVZ9AAAAADuBefcdxF52vs8Av6q6rctD4jQAwAAAOiUx45QBAAAAOgYhB4AAABApyD0AAAAADoFoQcAAADQKQg9AAAAgE5B6AEAAAB0CkIPAAAAoFP+Ab94/ogwWaGbAAAAAElFTkSuQmCC\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Get the response in the hidden units \n", - "layer_hid = model.get_layer('hidden')\n", - "model1 = Model(inputs=model.input,\n", - " outputs=layer_hid.output)\n", - "zhid_plot = model1.predict(Xplot)\n", - "zhid_plot = zhid_plot.reshape((nplot,nplot,nh))\n", - "\n", - "# Get the weights in the output layer\n", - "layer_out = model.get_layer('output')\n", - "Wo, bo = layer_out.get_weights()\n", - "\n", - "fig = plt.figure(figsize=(10, 4))\n", - "\n", - "for i in range(nh):\n", - "\n", - " plt.subplot(1,nh,i+1)\n", - " zhid_ploti = np.flipud(zhid_plot[:,:,i])\n", - " im = plt.imshow(zhid_ploti, extent=[xmin[0],xmax[0],xmin[0],xmax[1]], cmap=plt.cm.Reds)\n", - " plt.xticks([])\n", - " plt.yticks([])\n", - " plt.title('zh{0:d}, Wo={1:4.2f}'.format(i,Wo[i,0]))\n", - " \n", - "fig.subplots_adjust(right=0.85)\n", - "cbar_ax = fig.add_axes([0.9, 0.30, 0.05, 0.4])\n", - "fig.colorbar(im, cax=cbar_ax)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Let us print the model parameters. \n", - "\n", - "First we print the entire model weights" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Model weights\n", - "[array([[ 6.59272 , 11.723463 , 0.13931467, 2.011473 ],\n", - " [ 3.388066 , -5.8400793 , -12.651688 , -5.9218583 ]],\n", - " dtype=float32), array([-6.8954244, -0.3916084, 3.3514736, 3.6494682], dtype=float32), array([[-10.406469 ],\n", - " [ 7.7749357],\n", - " [ -9.563922 ],\n", - " [ 2.2439706]], dtype=float32), array([-3.302257], dtype=float32)]\n" - ] + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "HI1QbY85zZbC" + }, + "source": [ + "# A First Neural Network Example\n", + "\n", + "In this demo, you will learn:\n", + "* How to construct and train a simple neural network with one hidden layer using the `keras` package\n", + "* How to get the weights and intermediate layer outputs of a `keras` network after training\n", + "* How to visualize the weights\n", + "\n", + "To illustrate the concepts, we consider a simple 2D classification problem on completely synthetic data. Using synthetic data will allow us to visualize the network more easily. We will then look at real data in later demos " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Nqx3bkJazZbE" + }, + "source": [ + "## Loading Tensorflow and Keras\n", + "\n", + "Before starting this demo, you will need to install [Pytorch](https://pytorch.org/get-started/locally/). If you are using [Google colaboratory](https://colab.research.google.com), Pytorch is already installed.\n", + "\n", + "\n", + "First we check that tensorflow is installed." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "scrolled": true, + "id": "yzQxziXZzZbE" + }, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim" + ] + }, + { + "cell_type": "code", + "source": [ + "# prompt: Convert the code above to pytorch\n", + "\n", + "\n", + "\n", + "\n", + "# Create an instance of the network\n", + "net = Net(input_size, hidden_size, output_size)\n", + "\n", + "# Define loss function and optimizer\n", + "criterion = nn.CrossEntropyLoss() # Example loss function for classification\n", + "optimizer = optim.SGD(net.parameters(), lr=0.01) # Example optimizer\n", + "\n", + "\n", + "# Example synthetic data (replace with your actual data)\n", + "inputs = torch.randn(100, input_size)\n", + "labels = torch.randint(0, output_size, (100,))\n", + "\n", + "\n", + "# Training loop (replace with your training loop)\n", + "for epoch in range(10): # Example number of epochs\n", + " optimizer.zero_grad()\n", + " outputs = net(inputs)\n", + " loss = criterion(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + "# Access weights and intermediate layer outputs\n", + "# Example: access weights of the first layer\n", + "weights_fc1 = net.fc1.weight.data\n", + "print(weights_fc1)\n", + "\n", + "# Example: access the output of the hidden layer\n", + "intermediate_output = net.fc1(inputs)\n", + "intermediate_output\n", + "\n" + ], + "metadata": { + "id": "-5y2G8vHzdK_" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YOQL0tPmzZbG" + }, + "source": [ + "We also load some other common packages." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "TC9JZ0qmzZbG" + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true, + "id": "Z_ItzwqqzZbG" + }, + "source": [ + "## Synthetic Data\n", + "\n", + "To illustrate the neural network we generate data with some rule that will create an interesting classification region." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "id": "fUz4N4WUzZbG" + }, + "outputs": [], + "source": [ + "nsamp = 400 # number of samples to generate\n", + "nx = 2 # number of dimensions of each sample\n", + "\n", + "# The features are generated uniformly on the square [0,1] x [0,1]\n", + "X = np.random.uniform(0,1,(nsamp,nx))\n", + "\n", + "# The class of each sample is determined by some Gaussian. The particular function is not important.\n", + "rsq = (X[:,0]-0.5)**2 + (X[:,1]-0.5)**2\n", + "z = 10*(np.exp(-8*rsq)-0.5)\n", + "py = 1/(1+np.exp(-z))\n", + "u = np.random.uniform(0,1,nsamp)\n", + "y = (u < py).astype(int)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "T6V10hpLzZbH" + }, + "source": [ + "We create a scatter plot of the data. You can see that it is not linearly seperable. " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "scrolled": true, + "id": "eTzGusT8zZbH", + "outputId": "bab7f577-2546-4249-94fd-6f146155cde9", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 412 + } + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "I0 = np.where(y==0)[0]\n", + "I1 = np.where(y==1)[0]\n", + "plt.plot(X[I0,0], X[I0,1], 'bo')\n", + "plt.plot(X[I1,0], X[I1,1], 'go')\n", + "plt.xlabel('$x_0$', fontsize=16)\n", + "plt.ylabel('$x_1$', fontsize=16)\n", + "plt.subplots_adjust(bottom=0.2, left=0.2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4mdh2OfAzZbI" + }, + "source": [ + "## Creating a Simple Neural Network." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "75SqpJKXzZbI" + }, + "source": [ + "We see that the above points are not linearly separable. We will see if we can build a simple neural network classifier to find a good decision region." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4bAqmjJwzZbJ" + }, + "source": [ + "Neural networks in PyTorch are represented as `class` derived from the `nn.Module`. In the constructor of the class, we define the layers of the neural network. In this case, there are four layers:\n", + "* A fully connected linear layer (FC1)\n", + "* An activation layer with sigmoids (activation)\n", + "* A second fully connected layer (FC2)\n", + "* A sigmoid output since we are performing binary classification\n", + "The dimensions are passed in the contructor.\n", + "\n", + "The `forward()` method then take the input through the steps in the neural network to create the output." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": { + "id": "v-S5ye-NzZbJ" + }, + "outputs": [], + "source": [ + "\n", + "# Define the neural network architecture\n", + "class Net(nn.Module):\n", + " def __init__(self, input_size, hidden_size):\n", + " super(Net, self).__init__()\n", + " self.fc1 = nn.Linear(input_size, hidden_size)\n", + " self.activation = nn.Sigmoid()\n", + " self.fc2 = nn.Linear(hidden_size, 1)\n", + " self.sigmoid = nn.Sigmoid()\n", + "\n", + " def forward(self, x):\n", + " x = self.fc1(x)\n", + " x = self.activation(x)\n", + " x = self.fc2(x)\n", + " x = self.sigmoid(x)\n", + " return x\n" + ] + }, + { + "cell_type": "markdown", + "source": [ + "We next create an instance of the neural network for our problem. Note that there is a single output since we are performing binary classification.\n" + ], + "metadata": { + "id": "7cD2JVr1eEXz" + } + }, + { + "cell_type": "code", + "source": [ + "nin = nx # Number of inputs\n", + "nh = 4 # Number of hidden units\n", + "\n", + "model = Net(nin, nh)\n", + "\n", + "# Print a summary\n", + "print(model)" + ], + "metadata": { + "id": "KfB7y0SgeQ6i", + "outputId": "85640f7e-89a7-43df-e1a0-cde35aabe364", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 49, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Net(\n", + " (fc1): Linear(in_features=2, out_features=4, bias=True)\n", + " (activation): Sigmoid()\n", + " (fc2): Linear(in_features=4, out_features=1, bias=True)\n", + " (sigmoid): Sigmoid()\n", + ")\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2NtbDzNgzZbK" + }, + "source": [ + "We can also print the number of parameters per layer" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": { + "id": "YKulTxhizZbK", + "outputId": "b34d226b-58e8-4813-bf73-63ca69fb5e8a", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "fc1.weight 8\n", + "fc1.bias 4\n", + "fc2.weight 4\n", + "fc2.bias 1\n" + ] + } + ], + "source": [ + "# Iterate through the model's layers and print parameter counts\n", + "for name, param in model.named_parameters():\n", + " if param.requires_grad:\n", + " print(name, param.numel())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KbhkwiaEzZbL" + }, + "source": [ + "## Training the Network\n", + "\n", + "To train the network, we have to select an optimizer and a loss function. Since this is a binary classification problem, we select the `binary_crossentropy` loss. For the optimizer, `adam` tends to works well over a wide range of problems and is a good starting point. We also set the `metrics` that we wish to track during the optimization. In this case, we select `accuracy` on the training set." + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": { + "id": "FJjyIrb5zZbL" + }, + "outputs": [], + "source": [ + "# Define loss function and optimizer\n", + "criterion = nn.BCELoss()\n", + "optimizer = optim.Adam(model.parameters(), lr=0.01) # Example optimizer" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CXcL1MuGzZbL" + }, + "source": [ + "Next, we have to convert the `numpy` arrays `X,y` to `torch` tensors and load them into a `DataLoader` class that can provide mini-batches of data. " + ] + }, + { + "cell_type": "code", + "source": [ + "from torch.utils.data import DataLoader, TensorDataset\n", + "\n", + "# Convert your data to PyTorch tensors\n", + "X_torch = torch.tensor(X, dtype=torch.float32)\n", + "y_torch = torch.tensor(y, dtype=torch.float32).unsqueeze(1) # Reshape y to be (n_samples, 1)\n", + "\n", + "# Create a TensorDataset\n", + "dataset = TensorDataset(X_torch, y_torch)\n", + "\n", + "# Create a DataLoader\n", + "batch_size = 100\n", + "data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True)" + ], + "metadata": { + "id": "oj4056NokJFO" + }, + "execution_count": 52, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Now we will run the data over many epochs to train.\n" + ], + "metadata": { + "id": "XvZa11rokNOp" + } + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": { + "id": "CIkj9_kzzZbL", + "outputId": "a38bc37a-2727-453a-f22f-95e4d76700cd", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch [20/1000], Loss: 0.6741, Accuracy: 0.6875\n", + "Epoch [40/1000], Loss: 0.5348, Accuracy: 0.6875\n", + "Epoch [60/1000], Loss: 0.5951, Accuracy: 0.6875\n", + "Epoch [80/1000], Loss: 0.6354, Accuracy: 0.6875\n", + "Epoch [100/1000], Loss: 0.6107, Accuracy: 0.6875\n", + "Epoch [120/1000], Loss: 0.6742, Accuracy: 0.6875\n", + "Epoch [140/1000], Loss: 0.6744, Accuracy: 0.6875\n", + "Epoch [160/1000], Loss: 0.5656, Accuracy: 0.6875\n", + "Epoch [180/1000], Loss: 0.5880, Accuracy: 0.6875\n", + "Epoch [200/1000], Loss: 0.6113, Accuracy: 0.6875\n", + "Epoch [220/1000], Loss: 0.6583, Accuracy: 0.6875\n", + "Epoch [240/1000], Loss: 0.6428, Accuracy: 0.6875\n", + "Epoch [260/1000], Loss: 0.5871, Accuracy: 0.6875\n", + "Epoch [280/1000], Loss: 0.6188, Accuracy: 0.6875\n", + "Epoch [300/1000], Loss: 0.6420, Accuracy: 0.6875\n", + "Epoch [320/1000], Loss: 0.6255, Accuracy: 0.6875\n", + "Epoch [340/1000], Loss: 0.6297, Accuracy: 0.6875\n", + "Epoch [360/1000], Loss: 0.6027, Accuracy: 0.6875\n", + "Epoch [380/1000], Loss: 0.5758, Accuracy: 0.6875\n", + "Epoch [400/1000], Loss: 0.5953, Accuracy: 0.6875\n", + "Epoch [420/1000], Loss: 0.5040, Accuracy: 0.6875\n", + "Epoch [440/1000], Loss: 0.5153, Accuracy: 0.6875\n", + "Epoch [460/1000], Loss: 0.5246, Accuracy: 0.6875\n", + "Epoch [480/1000], Loss: 0.5414, Accuracy: 0.7050\n", + "Epoch [500/1000], Loss: 0.4818, Accuracy: 0.7025\n", + "Epoch [520/1000], Loss: 0.4804, Accuracy: 0.6875\n", + "Epoch [540/1000], Loss: 0.5338, Accuracy: 0.6950\n", + "Epoch [560/1000], Loss: 0.4759, Accuracy: 0.7025\n", + "Epoch [580/1000], Loss: 0.5349, Accuracy: 0.7025\n", + "Epoch [600/1000], Loss: 0.5042, Accuracy: 0.7100\n", + "Epoch [620/1000], Loss: 0.5296, Accuracy: 0.7125\n", + "Epoch [640/1000], Loss: 0.5216, Accuracy: 0.7150\n", + "Epoch [660/1000], Loss: 0.5083, Accuracy: 0.7275\n", + "Epoch [680/1000], Loss: 0.5157, Accuracy: 0.7375\n", + "Epoch [700/1000], Loss: 0.5613, Accuracy: 0.7450\n", + "Epoch [720/1000], Loss: 0.4312, Accuracy: 0.7600\n", + "Epoch [740/1000], Loss: 0.4677, Accuracy: 0.7725\n", + "Epoch [760/1000], Loss: 0.3984, Accuracy: 0.7950\n", + "Epoch [780/1000], Loss: 0.4533, Accuracy: 0.8075\n", + "Epoch [800/1000], Loss: 0.4544, Accuracy: 0.8175\n", + "Epoch [820/1000], Loss: 0.4619, Accuracy: 0.8300\n", + "Epoch [840/1000], Loss: 0.3578, Accuracy: 0.8350\n", + "Epoch [860/1000], Loss: 0.3722, Accuracy: 0.8425\n", + "Epoch [880/1000], Loss: 0.3370, Accuracy: 0.8425\n", + "Epoch [900/1000], Loss: 0.3775, Accuracy: 0.8425\n", + "Epoch [920/1000], Loss: 0.3624, Accuracy: 0.8575\n", + "Epoch [940/1000], Loss: 0.3668, Accuracy: 0.8550\n", + "Epoch [960/1000], Loss: 0.3551, Accuracy: 0.8575\n", + "Epoch [980/1000], Loss: 0.3301, Accuracy: 0.8575\n", + "Epoch [1000/1000], Loss: 0.3800, Accuracy: 0.8575\n" + ] + } + ], + "source": [ + "# prompt: Fit the data with the optimizer above on the data `X` and `y` with a batch size of 100 and 1000 epochs. Shuffle the data in the mini-batch and print the training accuracy and loss every 100 epochs. Use a DataLoader class to create the mini-batches.\n", + "\n", + "lossval = []\n", + "epochval = []\n", + "accval = []\n", + "\n", + "# Training loop with DataLoader\n", + "num_epochs = 1000\n", + "for epoch in range(num_epochs):\n", + " for i, (inputs, labels) in enumerate(data_loader):\n", + " optimizer.zero_grad()\n", + " outputs = model(inputs)\n", + " loss = criterion(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " if (epoch + 1) % 20 == 0:\n", + " # Calculate training accuracy\n", + " with torch.no_grad():\n", + " outputs = model(X_torch)\n", + " predicted = (outputs > 0.5).float()\n", + " accuracy = (predicted == y_torch).sum().item() / len(y)\n", + "\n", + " # Save the values\n", + " lossval.append(loss.item())\n", + " epochval.append(epoch)\n", + " accval.append(accuracy)\n", + "\n", + " print(f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}, Accuracy: {accuracy:.4f}')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "w7igRrPOzZbM" + }, + "source": [ + "Unfortunately, for this problem, we need a large number of epochs -- around 1000. We don't want to print out the progress on each epoch. So, the code below disables the print outs by setting `verbose=0`. Then, we run the optimization in 20 iterations with 50 epochs per iteration -- a total of 1000 epochs. In each iteration, we use the `evaluate` method to get the loss function and accuracy and print that out manually." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "c4_o9OlHzZbM" + }, + "source": [ + "We can now plot the loss function and accuracy as a function of the epoch number. " + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "id": "FrDqwnhrzZbM", + "outputId": "ec8df8ec-8758-44a1-ff08-a6b5aaf85a18", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 487 + } + }, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "epochval = np.array(epochval)\n", + "lossval = np.array(lossval)\n", + "accval = np.array(accval)\n", + "\n", + "plt.subplot(1,2,1)\n", + "plt.plot(epochval, lossval)\n", + "plt.grid()\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Loss')\n", + "\n", + "plt.subplot(1,2,2)\n", + "plt.plot(epochval, accval)\n", + "plt.grid()\n", + "plt.xlabel('Epoch')\n", + "plt.ylabel('Training accuracy')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xNxu1dvRzZbN" + }, + "source": [ + "## Visualizing Decision Regions\n", + "\n", + "To see how classification rule our neural network learned, we can plot the predicted class probability as a function of `(x_0,x_1)`. To do this, we create an input matrix `Xplot` with entries that vary over `[0,1] \\times [0,1]`. We feed that into the trained network and see what the probility `P(y=1|x)` is for each sample. Then, we plot this like an image." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": { + "id": "S0Lc1ZbJzZbN", + "outputId": "870f781f-8ab0-41bb-abe8-86da2a9764a7", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 452 + } + }, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[]" + ] + }, + "metadata": {}, + "execution_count": 56 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ], + "source": [ + "# Limits to plot the response.\n", + "xmin = [0,0]\n", + "xmax = [1,1]\n", + "\n", + "# Use meshgrid to create the 2D input\n", + "nplot = 100\n", + "x0plot = np.linspace(xmin[0],xmax[1],nplot)\n", + "x1plot = np.linspace(xmin[0],xmax[1],nplot)\n", + "x0mat, x1mat = np.meshgrid(x0plot,x1plot)\n", + "Xplot = np.column_stack([x0mat.ravel(), x1mat.ravel()])\n", + "\n", + "# Compute the output\n", + "with torch.no_grad():\n", + " yplot = model(torch.tensor(Xplot, dtype=torch.float32))\n", + "\n", + "# Convert yplot to numpy\n", + "yplot = yplot.numpy()\n", + "yplot_mat = yplot[:,0].reshape((nplot, nplot))\n", + "\n", + "# Plot the recovered region\n", + "plt.imshow(np.flipud(yplot_mat), extent=[xmin[0],xmax[0],xmin[0],xmax[1]], cmap=plt.cm.Reds)\n", + "plt.colorbar()\n", + "\n", + "# Overlay the samples\n", + "I0 = np.where(y==0)[0]\n", + "I1 = np.where(y==1)[0]\n", + "plt.plot(X[I0,0], X[I0,1], 'bo')\n", + "plt.plot(X[I1,0], X[I1,1], 'go')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ceslmyNLzZbN" + }, + "source": [ + "We see that the neural network is able to learn a nonlinear classification region matching the training data points. To understand how this nonlinear region is realized it is useful to plot the response in the each of the hidden units. To extract the output of an intermediate layer, we create a new model, `model_act` with the outputs set to the activation outputs in the original model and then run the `predict` command on that model." + ] + }, + { + "cell_type": "code", + "source": [ + "\n", + "b2 = model.fc2.bias.data.numpy()\n", + "print(w2)" + ], + "metadata": { + "id": "UArBb_bXoke0", + "outputId": "324b9b47-d2e2-42b2-f2fe-0dcb21147394", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 60, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[[ 5.793046 -7.3178473 1.2586372 -7.6920195]]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# prompt: Create a new model, model1, with the layers `activation` as the output.\n", + "\n", + "# Assuming 'model' is your trained network\n", + "class ModelAct(nn.Module):\n", + " def __init__(self, original_model):\n", + " super(ModelAct, self).__init__()\n", + " self.fc1 = original_model.fc1\n", + " self.activation = original_model.activation\n", + "\n", + " def forward(self, x):\n", + " x = self.fc1(x)\n", + " x = self.activation(x)\n", + " return x\n", + "\n", + "model_act = ModelAct(model)\n", + "\n", + "# Compute the output\n", + "with torch.no_grad():\n", + " zhid_plot = model_act(torch.tensor(Xplot, dtype=torch.float32))\n", + "zhid_plot = zhid_plot.numpy()\n", + "zhid_plot = zhid_plot.reshape((nplot, nplot,nh))\n", + "\n", + "# Get the weights\n", + "w2 = model.fc2.weight.data.numpy()\n", + "\n", + "fig = plt.figure(figsize=(10, 4))\n", + "\n", + "for i in range(nh):\n", + "\n", + " plt.subplot(1,nh,i+1)\n", + " zhid_ploti = np.flipud(zhid_plot[:,:,i])\n", + " im = plt.imshow(zhid_ploti, extent=[xmin[0],xmax[0],xmin[0],xmax[1]], cmap=plt.cm.Reds)\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + " plt.title('zh{0:d}, W2={1:4.2f}'.format(i,w2[0,i]))\n", + "\n", + "fig.subplots_adjust(right=0.85)\n", + "cbar_ax = fig.add_axes([0.9, 0.30, 0.05, 0.4])\n", + "fig.colorbar(im, cax=cbar_ax)" + ], + "metadata": { + "id": "3N46WQYYmm7d", + "outputId": "8eac69b0-6c5f-479a-8e49-da691d36a511", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 233 + } + }, + "execution_count": 63, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 63 + }, + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0CuF6PomzZbN" + }, + "source": [ + "Each of the hidden units produces one linear decision region. The final nonlinear region is then formed by taking a weighted combination of these regions." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "t57BBgQ-zZbO", + "outputId": "1c293951-7e7d-4969-e11b-d832c56c063e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "# Get the response in the hidden units\n", + "layer_hid = model.get_layer('hidden')\n", + "model1 = Model(inputs=model.input,\n", + " outputs=layer_hid.output)\n", + "\n", + "\n", + "zhid_plot = model_act.predict(Xplot)\n", + "zhid_plot = zhid_plot.reshape((nplot,nplot,nh))\n", + "\n", + "# Get the weights in the output layer\n", + "layer_out = model.get_layer('output')\n", + "Wo, bo = layer_out.get_weights()\n", + "\n", + "fig = plt.figure(figsize=(10, 4))\n", + "\n", + "for i in range(nh):\n", + "\n", + " plt.subplot(1,nh,i+1)\n", + " zhid_ploti = np.flipud(zhid_plot[:,:,i])\n", + " im = plt.imshow(zhid_ploti, extent=[xmin[0],xmax[0],xmin[0],xmax[1]], cmap=plt.cm.Reds)\n", + " plt.xticks([])\n", + " plt.yticks([])\n", + " plt.title('zh{0:d}, Wo={1:4.2f}'.format(i,Wo[i,0]))\n", + "\n", + "fig.subplots_adjust(right=0.85)\n", + "cbar_ax = fig.add_axes([0.9, 0.30, 0.05, 0.4])\n", + "fig.colorbar(im, cax=cbar_ax)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XtObg1rDzZbP" + }, + "source": [ + "## Let us print the model parameters.\n", + "\n", + "First we print the entire model weights" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zFL0V4-qzZbP", + "outputId": "74c1a14e-eded-4fa7-8dc2-d10bce762d50" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model weights\n", + "[array([[ 6.59272 , 11.723463 , 0.13931467, 2.011473 ],\n", + " [ 3.388066 , -5.8400793 , -12.651688 , -5.9218583 ]],\n", + " dtype=float32), array([-6.8954244, -0.3916084, 3.3514736, 3.6494682], dtype=float32), array([[-10.406469 ],\n", + " [ 7.7749357],\n", + " [ -9.563922 ],\n", + " [ 2.2439706]], dtype=float32), array([-3.302257], dtype=float32)]\n" + ] + } + ], + "source": [ + "g=model.get_weights()\n", + "print('Model weights')\n", + "print(g)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "agRsR1YzzZbP" + }, + "source": [ + "Now we print individual layer weights" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "BgOgKmhczZbP", + "outputId": "b3f3ee65-8897-4193-e0fe-aec47603abf5" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Wh=\n", + "[[ 6.59272 11.723463 0.13931467 2.011473 ]\n", + " [ 3.388066 -5.8400793 -12.651688 -5.9218583 ]]\n", + "bh=\n", + "[-6.8954244 -0.3916084 3.3514736 3.6494682]\n", + "Wo=\n", + "[[-10.406469 ]\n", + " [ 7.7749357]\n", + " [ -9.563922 ]\n", + " [ 2.2439706]]\n", + "bo=\n", + "[-3.302257]\n" + ] + } + ], + "source": [ + "layer_hid = model.get_layer('hidden')\n", + "Wh, bh = layer_hid.get_weights()\n", + "print('Wh=')\n", + "print(Wh)\n", + "print('bh=')\n", + "print(bh)\n", + "\n", + "layer_out = model.get_layer('output')\n", + "Wo, bo = layer_out.get_weights()\n", + "print('Wo=')\n", + "print(Wo)\n", + "print('bo=')\n", + "print(bo)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "collapsed": true, + "id": "PJFgKINLzZbQ" + }, + "source": [ + "## Computing Gradients via Backpropagation\n", + "\n", + "The tensorflow package computes all the gradients manually. But, we show how to compute the gradients manually via back-propagation manually so you understand the mathematics. First, we create a function that evaluates the forward pass of the neural network. That is, it takes the inputs `X` and parameters `param` to output the loss function." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "R2DjPczIzZbQ" + }, + "outputs": [], + "source": [ + "def forward(param, X, y):\n", + " \"\"\"\n", + " Computes the BCE loss for a neural network\n", + " with one hidden layer and sigmoid activations\n", + " \"\"\"\n", + "\n", + " # Unpack the parameters\n", + " Wh, bh, Wo, bo = param\n", + "\n", + " # Hidden layer\n", + " Zh = X.dot(Wh) + bh[None, :]\n", + " Uh = 1/(1+np.exp(-Zh))\n", + "\n", + " # Output layer\n", + " zo = Uh.dot(Wo) + bo[None, :]\n", + " zo = zo.ravel()\n", + "\n", + " # Binary cross entropy\n", + " loss = np.sum(np.log(1+np.exp(zo))-y*zo)\n", + "\n", + " return zo, loss\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "OOs9BiPEzZbR" + }, + "source": [ + "We will test with some initial values." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Aw93wBHMzZbR" + }, + "outputs": [], + "source": [ + "# Random initial values\n", + "Wh = np.random.normal(0,1,(nx,nh))\n", + "bh = np.random.normal(0,1,(nh,))\n", + "Wo = np.random.normal(0,1,(nh,nout))\n", + "bo = np.random.normal(0,1,(nout))\n", + "param0 = [Wh,bh,Wo,bo]\n", + "\n", + "# Compute output on the training data\n", + "zo, loss = forward(param0, X, y)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wFUZ47HZzZbS" + }, + "source": [ + "## In-Class Exercise\n", + "\n", + "Complete the following function that computes the loss and gradients for all the four parameters. I have already written the gradient and loss for the output layers. Note the use of broadcasting. You will need to compute the gradients for the hidden layers." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Yb3_4TySzZbS" + }, + "outputs": [], + "source": [ + "def loss_eval(param, X, y):\n", + " \"\"\"\n", + " Evaluates the loss function and gradients\n", + " for the neural network\n", + " \"\"\"\n", + "\n", + " # Unpack the parameters\n", + " Wh, bh, Wo, bo = param\n", + "\n", + " # Hidden layer\n", + " Zh = X.dot(Wh) + bh[None, :]\n", + " Uh = 1/(1+np.exp(-Zh))\n", + "\n", + " # Output layer\n", + " zo = Uh.dot(Wo) + bo[None,:]\n", + " zo = zo.ravel()\n", + "\n", + " # Binary cross entropy\n", + " loss = np.sum(np.log(1+np.exp(zo))-y*zo)\n", + "\n", + " # Gradient for the output layer.\n", + " # Note the use of broadcasting\n", + " grad_dzo = 1/(1+np.exp(-zo))-y\n", + " grad_Wo = np.sum(Uh[:,:,None]*grad_dzo[:,None,None], axis=0)\n", + " grad_bo = np.sum(grad_dzo)\n", + "\n", + " # TODO: Compute gradients for the hidden layer\n", + " # grad_Wh = ...\n", + " # grad_bh = ...\n", + " grad_Wh = 0\n", + " grad_bh = 0\n", + "\n", + " # Pack the gradients\n", + " grad = [grad_Wh, grad_bh, grad_Wo, grad_bo]\n", + "\n", + " return loss, grad\n", + "\n", + "" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e25bYT9zzZbS" + }, + "source": [ + "When you are done, try to test your gradient.\n", + "\n", + "* Construct a list of parameters, `param1` with values slightly perturbed from `param0`.\n", + "* Evaluate `loss0, grad0` at `param0` and `loss1, grad1` at `param1`\n", + "* Compute the actual difference `loss1-loss0`.\n", + "* Compute the expected difference which is the sum of the terms: `np.sum(grad0[i]*(param1[i]-param0[i]))`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dHoRwXYHzZbS" + }, + "outputs": [], + "source": [ + "# TODO\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dRVd-c9ezZbS" + }, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "zty_vccdzZbS" + }, + "outputs": [], + "source": [] } - ], - "source": [ - "g=model.get_weights()\n", - "print('Model weights')\n", - "print(g)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we print individual layer weights" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Wh=\n", - "[[ 6.59272 11.723463 0.13931467 2.011473 ]\n", - " [ 3.388066 -5.8400793 -12.651688 -5.9218583 ]]\n", - "bh=\n", - "[-6.8954244 -0.3916084 3.3514736 3.6494682]\n", - "Wo=\n", - "[[-10.406469 ]\n", - " [ 7.7749357]\n", - " [ -9.563922 ]\n", - " [ 2.2439706]]\n", - "bo=\n", - "[-3.302257]\n" - ] + ], + "metadata": { + "anaconda-cloud": {}, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.3" + }, + "colab": { + "provenance": [] } - ], - "source": [ - "layer_hid = model.get_layer('hidden')\n", - "Wh, bh = layer_hid.get_weights()\n", - "print('Wh=')\n", - "print(Wh)\n", - "print('bh=')\n", - "print(bh)\n", - "\n", - "layer_out = model.get_layer('output')\n", - "Wo, bo = layer_out.get_weights()\n", - "print('Wo=')\n", - "print(Wo)\n", - "print('bo=')\n", - "print(bo)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true - }, - "source": [ - "## Computing Gradients via Backpropagation\n", - "\n", - "The tensorflow package computes all the gradients manually. But, we show how to compute the gradients manually via back-propagation manually so you understand the mathematics. First, we create a function that evaluates the forward pass of the neural network. That is, it takes the inputs `X` and parameters `param` to output the loss function." - ] - }, - { - "cell_type": "code", - "execution_count": 81, - "metadata": {}, - "outputs": [], - "source": [ - "def forward(param, X, y):\n", - " \"\"\"\n", - " Computes the BCE loss for a neural network\n", - " with one hidden layer and sigmoid activations\n", - " \"\"\"\n", - " \n", - " # Unpack the parameters\n", - " Wh, bh, Wo, bo = param\n", - " \n", - " # Hidden layer\n", - " Zh = X.dot(Wh) + bh[None, :]\n", - " Uh = 1/(1+np.exp(-Zh))\n", - " \n", - " # Output layer\n", - " zo = Uh.dot(Wo) + bo[None, :]\n", - " zo = zo.ravel()\n", - " \n", - " # Binary cross entropy\n", - " loss = np.sum(np.log(1+np.exp(zo))-y*zo)\n", - " \n", - " return zo, loss\n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We will test with some initial values." - ] - }, - { - "cell_type": "code", - "execution_count": 82, - "metadata": {}, - "outputs": [], - "source": [ - "# Random initial values\n", - "Wh = np.random.normal(0,1,(nx,nh))\n", - "bh = np.random.normal(0,1,(nh,))\n", - "Wo = np.random.normal(0,1,(nh,nout))\n", - "bo = np.random.normal(0,1,(nout))\n", - "param0 = [Wh,bh,Wo,bo]\n", - "\n", - "# Compute output on the training data\n", - "zo, loss = forward(param0, X, y)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## In-Class Exercise\n", - "\n", - "Complete the following function that computes the loss and gradients for all the four parameters. I have already written the gradient and loss for the output layers. Note the use of broadcasting. You will need to compute the gradients for the hidden layers." - ] - }, - { - "cell_type": "code", - "execution_count": 89, - "metadata": {}, - "outputs": [], - "source": [ - "def loss_eval(param, X, y):\n", - " \"\"\"\n", - " Evaluates the loss function and gradients \n", - " for the neural network\n", - " \"\"\"\n", - " \n", - " # Unpack the parameters\n", - " Wh, bh, Wo, bo = param\n", - " \n", - " # Hidden layer\n", - " Zh = X.dot(Wh) + bh[None, :]\n", - " Uh = 1/(1+np.exp(-Zh))\n", - " \n", - " # Output layer\n", - " zo = Uh.dot(Wo) + bo[None,:]\n", - " zo = zo.ravel()\n", - " \n", - " # Binary cross entropy\n", - " loss = np.sum(np.log(1+np.exp(zo))-y*zo)\n", - " \n", - " # Gradient for the output layer.\n", - " # Note the use of broadcasting\n", - " grad_dzo = 1/(1+np.exp(-zo))-y\n", - " grad_Wo = np.sum(Uh[:,:,None]*grad_dzo[:,None,None], axis=0)\n", - " grad_bo = np.sum(grad_dzo)\n", - " \n", - " # TODO: Compute gradients for the hidden layer\n", - " # grad_Wh = ...\n", - " # grad_bh = ...\n", - " grad_Wh = 0\n", - " grad_bh = 0\n", - " \n", - " # Pack the gradients\n", - " grad = [grad_Wh, grad_bh, grad_Wo, grad_bo]\n", - " \n", - " return loss, grad\n", - " \n", - " " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "When you are done, try to test your gradient.\n", - "\n", - "* Construct a list of parameters, `param1` with values slightly perturbed from `param0`. \n", - "* Evaluate `loss0, grad0` at `param0` and `loss1, grad1` at `param1`\n", - "* Compute the actual difference `loss1-loss0`.\n", - "* Compute the expected difference which is the sum of the terms: `np.sum(grad0[i]*(param1[i]-param0[i]))`." - ] - }, - { - "cell_type": "code", - "execution_count": 91, - "metadata": {}, - "outputs": [], - "source": [ - "# TODO\n", - "\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "anaconda-cloud": {}, - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.3" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} + "nbformat": 4, + "nbformat_minor": 0 +} \ No newline at end of file