{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# PyTorch Introduction\n", "\n", "Today, we will be intoducing PyTorch, \"an open source deep learning platform that provides a seamless path from research prototyping to production deployment\".\n", "\n", "This notebook is by no means comprehensive. If you have any questions the documentation and Google are your friends.\n", "\n", "Goal takeaways:\n", "- Automatic differentiation is a powerful tool\n", "- PyTorch implements common functions used in deep learning" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", "\n", "from mpl_toolkits.mplot3d import Axes3D\n", "import matplotlib.pyplot as plt\n", "\n", "import numpy as np\n", "\n", "torch.manual_seed(446)\n", "np.random.seed(446)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Tensors and relation to numpy\n", "\n", "By this point, we have worked with numpy quite a bit. PyTorch's basic building block, the `tensor` is similar to numpy's `ndarray`" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "x_numpy, x_torch\n", "[0.1 0.2 0.3] tensor([0.1000, 0.2000, 0.3000])\n", "\n", "to and from numpy and pytorch\n", "tensor([0.1000, 0.2000, 0.3000], dtype=torch.float64) [0.1 0.2 0.3]\n", "\n", "x+y\n", "[3.1 4.2 5.3] tensor([3.1000, 4.2000, 5.3000])\n", "\n", "norm\n", "0.37416573867739417 tensor(0.3742)\n", "\n", "mean along the 0th dimension\n", "[2. 3.] tensor([2., 3.])\n" ] } ], "source": [ "# we create tensors in a similar way to numpy nd arrays\n", "x_numpy = np.array([0.1, 0.2, 0.3])\n", "x_torch = torch.tensor([0.1, 0.2, 0.3])\n", "print('x_numpy, x_torch')\n", "print(x_numpy, x_torch)\n", "print()\n", "\n", "# to and from numpy, pytorch\n", "print('to and from numpy and pytorch')\n", "print(torch.from_numpy(x_numpy), x_torch.numpy())\n", "print()\n", "\n", "# we can do basic operations like +-*/\n", "y_numpy = np.array([3,4,5.])\n", "y_torch = torch.tensor([3,4,5.])\n", "print(\"x+y\")\n", "print(x_numpy + y_numpy, x_torch + y_torch)\n", "print()\n", "\n", "# many functions that are in numpy are also in pytorch\n", "print(\"norm\")\n", "print(np.linalg.norm(x_numpy), torch.norm(x_torch))\n", "print()\n", "\n", "# to apply an operation along a dimension,\n", "# we use the dim keyword argument instead of axis\n", "print(\"mean along the 0th dimension\")\n", "x_numpy = np.array([[1,2],[3,4.]])\n", "x_torch = torch.tensor([[1,2],[3,4.]])\n", "print(np.mean(x_numpy, axis=0), torch.mean(x_torch, dim=0))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### `Tensor.view`\n", "We can use the `Tensor.view()` function to reshape tensors similarly to `numpy.reshape()`\n", "\n", "It can also automatically calculate the correct dimension if a `-1` is passed in. This is useful if we are working with batches, but the batch size is unknown." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([10000, 3, 28, 28])\n", "torch.Size([10000, 3, 784])\n", "torch.Size([10000, 3, 784])\n" ] } ], "source": [ "# \"MNIST\"\n", "N, C, W, H = 10000, 3, 28, 28\n", "X = torch.randn((N, C, W, H))\n", "\n", "print(X.shape)\n", "print(X.view(N, C, 784).shape)\n", "print(X.view(-1, C, 784).shape) # automatically choose the 0th dimension" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Computation graphs\n", "\n", "What's special about PyTorch's `tensor` object is that it implicitly creates a computation graph in the background. A computation graph is a a way of writing a mathematical expression as a graph. There is an algorithm to compute the gradients of all the variables of a computation graph in time on the same order it is to compute the function itself.\n", "\n", "Consider the expression $e=(a+b)*(b+1)$ with values $a=2, b=1$. We can draw the evaluated computation graph as\n", "
\n", "
\n", "\n", "![tree-img](./tree-eval.png)\n", "\n", "[source](https://colah.github.io/posts/2015-08-Backprop/)\n", "\n", "In PyTorch, we can write this as" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "c tensor(3., grad_fn=)\n", "d tensor(2., grad_fn=)\n", "e tensor(6., grad_fn=)\n" ] } ], "source": [ "a = torch.tensor(2.0, requires_grad=True) # we set requires_grad=True to let PyTorch know to keep the graph\n", "b = torch.tensor(1.0, requires_grad=True)\n", "c = a + b\n", "d = b + 1\n", "e = c * d\n", "print('c', c)\n", "print('d', d)\n", "print('e', e)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see that PyTorch kept track of the computation graph for us." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## PyTorch as an auto grad framework\n", "\n", "Now that we have seen that PyTorch keeps the graph around for us, let's use it to compute some gradients for us.\n", "\n", "Consider the function $f(x) = (x-2)^2$.\n", "\n", "Q: Compute $\\frac{d}{dx} f(x)$ and then compute $f'(1)$.\n", "\n", "We make a `backward()` call on the leaf variable (`y`) in the computation, computing all the gradients of `y` at once." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Analytical f'(x): tensor([-2.], grad_fn=)\n", "PyTorch's f'(x): tensor([-2.])\n" ] } ], "source": [ "def f(x):\n", " return (x-2)**2\n", "\n", "def fp(x):\n", " return 2*(x-2)\n", "\n", "x = torch.tensor([1.0], requires_grad=True)\n", "\n", "y = f(x)\n", "y.backward()\n", "\n", "print('Analytical f\\'(x):', fp(x))\n", "print('PyTorch\\'s f\\'(x):', x.grad)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "It can also find gradients of functions.\n", "\n", "Let $w = [w_1, w_2]^T$\n", "\n", "Consider $g(w) = 2w_1w_2 + w_2\\cos(w_1)$\n", "\n", "Q: Compute $\\nabla_w g(w)$ and verify $\\nabla_w g([\\pi,1]) = [2, \\pi - 1]^T$" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Analytical grad g(w) tensor([2.0000, 5.2832])\n", "PyTorch's grad g(w) tensor([2.0000, 5.2832])\n" ] } ], "source": [ "def g(w):\n", " return 2*w[0]*w[1] + w[1]*torch.cos(w[0])\n", "\n", "def grad_g(w):\n", " return torch.tensor([2*w[1] - w[1]*torch.sin(w[0]), 2*w[0] + torch.cos(w[0])])\n", "\n", "w = torch.tensor([np.pi, 1], requires_grad=True)\n", "\n", "z = g(w)\n", "z.backward()\n", "\n", "print('Analytical grad g(w)', grad_g(w))\n", "print('PyTorch\\'s grad g(w)', w.grad)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Using the gradients\n", "Now that we have gradients, we can use our favorite optimization algorithm: gradient descent!\n", "\n", "Let $f$ the same function we defined above.\n", "\n", "Q: What is the value of $x$ that minimizes $f$?" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iter,\tx,\tf(x),\tf'(x),\tf'(x) pytorch\n", "0,\t5.000,\t9.000,\t6.000,\t6.000\n", "1,\t3.500,\t2.250,\t3.000,\t3.000\n", "2,\t2.750,\t0.562,\t1.500,\t1.500\n", "3,\t2.375,\t0.141,\t0.750,\t0.750\n", "4,\t2.188,\t0.035,\t0.375,\t0.375\n", "5,\t2.094,\t0.009,\t0.188,\t0.188\n", "6,\t2.047,\t0.002,\t0.094,\t0.094\n", "7,\t2.023,\t0.001,\t0.047,\t0.047\n", "8,\t2.012,\t0.000,\t0.023,\t0.023\n", "9,\t2.006,\t0.000,\t0.012,\t0.012\n", "10,\t2.003,\t0.000,\t0.006,\t0.006\n", "11,\t2.001,\t0.000,\t0.003,\t0.003\n", "12,\t2.001,\t0.000,\t0.001,\t0.001\n", "13,\t2.000,\t0.000,\t0.001,\t0.001\n", "14,\t2.000,\t0.000,\t0.000,\t0.000\n" ] } ], "source": [ "x = torch.tensor([5.0], requires_grad=True)\n", "step_size = 0.25\n", "\n", "print('iter,\\tx,\\tf(x),\\tf\\'(x),\\tf\\'(x) pytorch')\n", "for i in range(15):\n", " y = f(x)\n", " y.backward() # compute the gradient\n", " \n", " print('{},\\t{:.3f},\\t{:.3f},\\t{:.3f},\\t{:.3f}'.format(i, x.item(), f(x).item(), fp(x).item(), x.grad.item()))\n", " \n", " x.data = x.data - step_size * x.grad # perform a GD update step\n", " \n", " # We need to zero the grad variable since the backward()\n", " # call accumulates the gradients in .grad instead of overwriting.\n", " # The detach_() is for efficiency. You do not need to worry too much about it.\n", " x.grad.detach_()\n", " x.grad.zero_()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Linear Regression\n", "\n", "Now, instead of minimizing a made-up function, lets minimize a loss function on some made-up data.\n", "\n", "We will implement Gradient Descent in order to solve the task of linear regression." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "X shape torch.Size([50, 2])\n", "y shape torch.Size([50, 1])\n", "w shape torch.Size([2, 1])\n" ] } ], "source": [ "# make a simple linear dataset with some noise\n", "\n", "d = 2\n", "n = 50\n", "X = torch.randn(n,d)\n", "true_w = torch.tensor([[-1.0], [2.0]])\n", "y = X @ true_w + torch.randn(n,1) * 0.1\n", "print('X shape', X.shape)\n", "print('y shape', y.shape)\n", "print('w shape', true_w.shape)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Note: dimensions\n", "PyTorch does a lot of operations on batches of data. The convention is to have your data be of size $(N, d)$ where $N$ is the size of the batch of data." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# visualize the dataset\n", "\n", "fig = plt.figure()\n", "ax = fig.add_subplot(111, projection='3d')\n", "\n", "ax.scatter(X[:,0].numpy(), X[:,1].numpy(), y.numpy(), c='r', marker='o')\n", "\n", "ax.set_xlabel('$X_1$')\n", "ax.set_ylabel('$X_2$')\n", "ax.set_zlabel('$Y$')\n", "\n", "plt.title('Dataset')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "def visualize_fun(w, title, num_pts=20):\n", " \n", " x1, x2 = np.meshgrid(np.linspace(-2,2, num_pts), np.linspace(-2,2, num_pts))\n", " X_plane = torch.tensor(np.stack([np.reshape(x1, (num_pts**2)), np.reshape(x2, (num_pts**2))], axis=1)).float()\n", " y_plane = np.reshape((X_plane @ w).detach().numpy(), (num_pts, num_pts))\n", " \n", " plt3d = plt.figure().gca(projection='3d')\n", " plt3d.plot_surface(x1, x2, y_plane, alpha=0.2)\n", "\n", " ax = plt.gca()\n", " ax.scatter(X[:,0].numpy(), X[:,1].numpy(), y.numpy(), c='r', marker='o')\n", "\n", " ax.set_xlabel('$X_1$')\n", " ax.set_ylabel('$X_2$')\n", " ax.set_zlabel('$Y$')\n", " \n", " plt.title(title)\n", " plt.show()" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "visualize_fun(true_w, 'Dataset and true $w$')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Sanity check\n", "To verify PyTorch is computing the gradients correctly, let's recall the gradient for the RSS objective:\n", "\n", "$$\\nabla_w \\mathcal{L}_{RSS}(w; X) = \\nabla_w\\frac{1}{n} ||y - Xw||_2^2 = -\\frac{2}{n}X^T(y-Xw)$$\n", "\n", "Let's see if the match up:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Analytical gradient [ 5.1867113 -5.5912566]\n", "PyTorch's gradient [ 5.186712 -5.5912566]\n" ] } ], "source": [ "# define a linear model with no bias\n", "def model(X, w):\n", " return X @ w\n", "\n", "# the residual sum of squares loss function\n", "def rss(y, y_hat):\n", " return torch.norm(y - y_hat)**2 / n\n", "\n", "# analytical expression for the gradient\n", "def grad_rss(X, y, w):\n", " return -2*X.t() @ (y - X @ w) / n\n", "\n", "w = torch.tensor([[1.], [0]], requires_grad=True)\n", "y_hat = model(X, w)\n", "\n", "loss = rss(y, y_hat)\n", "loss.backward()\n", "\n", "print('Analytical gradient', grad_rss(X, y, w).detach().view(2).numpy())\n", "print('PyTorch\\'s gradient', w.grad.view(2).numpy())\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that we've seen PyTorch is doing the right think, let's use the gradients!\n", "\n", "## Linear regression using GD with automatically computed derivatives\n", "\n", "We will now use the gradients to run the gradient descent algorithm.\n", "\n", "Note: This example is an illustration to connect ideas we have seen before to PyTorch's way of doing things. We will see how to do this in the \"PyTorchic\" way in the next example." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iter,\tloss,\tw\n", "0,\t10.80,\t[-0.03734243 1.1182513 ]\n", "1,\t2.31,\t[-0.28690195 1.3653738 ]\n", "2,\t1.24,\t[-0.4724271 1.5428905]\n", "3,\t0.67,\t[-0.6105486 1.6702049]\n", "4,\t0.36,\t[-0.71353513 1.7613506 ]\n", "5,\t0.20,\t[-0.79044634 1.8264704 ]\n", "6,\t0.11,\t[-0.8479796 1.8728881]\n", "7,\t0.06,\t[-0.89109135 1.9058872 ]\n", "8,\t0.04,\t[-0.92345405 1.9292755 ]\n", "9,\t0.03,\t[-0.94779253 1.9457937 ]\n", "10,\t0.02,\t[-0.9661309 1.957412 ]\n", "11,\t0.01,\t[-0.97997516 1.9655445 ]\n", "12,\t0.01,\t[-0.9904472 1.9712044]\n", "13,\t0.01,\t[-0.9983844 1.9751165]\n", "14,\t0.01,\t[-1.0044125 1.9777979]\n", "15,\t0.01,\t[-1.0090001 1.9796168]\n", "16,\t0.01,\t[-1.0124985 1.9808345]\n", "17,\t0.01,\t[-1.0151719 1.9816359]\n", "18,\t0.01,\t[-1.0172188 1.9821515]\n", "19,\t0.01,\t[-1.0187894 1.9824725]\n", "\n", "true w\t\t [-1. 2.]\n", "estimated w\t [-1.0187894 1.9824725]\n" ] } ], "source": [ "step_size = 0.1\n", "\n", "print('iter,\\tloss,\\tw')\n", "for i in range(20):\n", " y_hat = model(X, w)\n", " loss = rss(y, y_hat)\n", " \n", " loss.backward() # compute the gradient of the loss\n", " \n", " w.data = w.data - step_size * w.grad # do a gradient descent step\n", " \n", " print('{},\\t{:.2f},\\t{}'.format(i, loss.item(), w.view(2).detach().numpy()))\n", " \n", " # We need to zero the grad variable since the backward()\n", " # call accumulates the gradients in .grad instead of overwriting.\n", " # The detach_() is for efficiency. You do not need to worry too much about it.\n", " w.grad.detach()\n", " w.grad.zero_()\n", "\n", "print('\\ntrue w\\t\\t', true_w.view(2).numpy())\n", "print('estimated w\\t', w.view(2).detach().numpy())" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQkAAAEECAYAAAA79sG6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAACdgElEQVR4nOz9d5wkZ3Xvj7+fqs49nSbP5pyDtNKKIDLCYCEhEeQv2BgTHMDGBmMw2NjX4foa+/c1Njbf62uuuRcbMGCQZExOJidlafPOzO7O7OTYOXfV8/ujQlf3dPeEnd2VUH/8ktnprvBUdT2nznPO53yOkFLSRhtttNEMyvUeQBtttPHkRttItNFGGy3RNhJttNFGS7SNRBtttNESbSPRRhtttETbSLTRRhst0TYSbbTRRku0jUQbbbTREm0j0QBCiNNCiBe0+H5ECHHbKo63qu2vF4QQ/yKE+IurcNwPCCHeud7HvVq4Fr+XEOJBIcTBq3mO9cKKjIR50/JCiLQQIiGE+LEQ4q1CiNXsf9UnyXqdR0p5UEr53fU85tMVQoge4A3AR8y/R4QQJSFEd912jwkhpBBi23UY5qoghHitEOIBIURWCDFr/vs3hRDC/H4l8+VvgD+/PlewOqzGk7hTShkCtgJ/BbwX+D9XZVRtLAshhOt6j2GFeCPwFSll3vHZJeB11h9CiMNA4BqPa00QQvwe8PfA/wv0A33AW4FbAY9j0+XmyxeAFwoh+q/FuK8IUspl/wNGgNvqPrsF0IFD5t/vAy4AaeAM8Erz80+Y2+WBDPD7rbY3v3svMGF+dx54sfn5BuA+YA7jQfsdxz4Nz+P4/k3AFx1/DwGfc/w9BtzgvN4WYx8B3g2cAJLAvwO+ldy/Za6h6T1xHOe95nmLgKvVWFqdy/z+RuBR83z/DnwG+Ism15ABtpj/fisggX7z7/cA/6fJft8GXl93DX8EPOT47G+A95vH3LaS+7Hcb2Aea5fj73+xrm2F9/m2BtcSAbLAq690vpiffRP4lZXMwev535qNhPn5ZeBt5r/vMR9KBfh/zJs50OKmNdwe2IsxYTeY220DdprbPQL8NwyLvQO4CLx0uXGa3+0AEuZxNgCjwLjjuzigNJjUjcY+AjxoHqcTOAu8dbn7t9w1tLqHjuM8DmwG/K3GsoJzecx78LuAG3gNUKa5kRgDDgACOIlhZPeZfw8DR5vsNwccb3AvzgP7ARUYx3jj1huJ5Z6ppr8BrY3ESu5zo+f9ZUAFcF3pfDH//gfgb6+3EVjuvysNXE6aPxBSys9JKSellLqU8t8xHqJbmu3YYnsN8AIHhBBuKeWIlPICcBzokVL+uZSyJKW8CPwz8NqVDNTcPg3cADwP+DowKYTYBzwf+IGUUl/Ftf+DOf5F4IvmcZdDy2tY4T38BynlmKx13xuNZbn79UwM4/AhKWVZSnkv8FCLsSeADuDnMIzCKSCKMXEmpJRPNNkvinHf6/EJjFjFSzAm+ET9Biu4H2v5DVb9rDrQDcxLKSvWB2a8IWHGIJ63zP72fDGRxrg/T2pc6bp2I7AIIIR4A/AujDc/GA9Ud+Pdmm8vpRw2I+F/ChwUQnzd3G4rsEEIkXAcRgV+sIrxfg94AbDL/HcCw0A8y/x7NZh2/DuH8WZaDi2vYYX3cGyFY1nufm3AmNxOrYDRFmOPm+N5J/DXGMu3GPCbGG/EVvuFGnz+CeD7wHbg4412XMH9WMtvsOpn1YEFoFsI4bIMhZTy2eYxx1k+xmfPFxMhjGfwSY01exJCiOMYF/1DIcRWjLfU24EuKWUU400jzM1l3b4tt5dSfkpK+RyqLuhfY0yOS1LKqOO/kJTydsehlxPHsIzEc81/fw/DSDyf5kZiPQU3ml7DCu7hasez3P2aAjZaEXkTW1ocLwHcjBGH+C6QAo4Ch4DPt9jvBLCn/kMp5ShGnOR24P7671dxP5ohR20wtH8djvsTjFjQXSscgw3nfHF8vB9o5oE9abBqIyGECAsh7sAIcn1SSnkSCGI8vHPmNm/CeHgszGCsiS003V4IsVcI8SIhhBcoYAQNdYz1Z1oI8V4hhF8IoQohDpk3v9l56vE94IUY6/lxjLfqy4Au4LEm+yx3zNWg1TUsdw/X81xgPPAV4HeEEG4hxKto7XLHMeIXHzb/TgHvAD4ipdRa7PcVDCPcCG8BXiSlzDb47krvx+PAL5rX/TLHGNZ8XCllAvgz4B+FEK8RQoSEEIoQ4gbzuEvQZL4ghPABN2EEL5/UWI2R+KIQIo3xhno/8LcYLidSyjPABzEevBngMPAjx74fAP7IXLu9e5ntvRgpo3kMd7IX+APzQbwDY915yfz+oxgR54bnqb8AKeUgRpT+B+bfKYxg3o9aPOgtj7katLqGFdzDdTuX+X0JeBVGinIRI4C35I3uQBxjefop8+8Uxnr6n5cZyseB24UQ/gZjvCClfLjJ+K/0frwDuBPDA/olTG/nSo8rpfz/YSxVft/cfwaDA/Je4MeOTZvOFxN3At+VUk6u4pquC0TtkrSNNtYfQoi/BGallB+63mN5skAI8QDwFinlqes9luXQNhJttNFGS7RrN9poo42WaBuJNtpooyXaRqKNNtpoibaRaKONNlpiJYzLdmSzjTauPlZKErvmaHsSbbTRRku0jUQbbbTREm0j0UYbbbRE20i00UYbLdE2Em200UZLtI1EG2200RJtI9FGG220RNtItNFGGy3RNhJttNFGS7SNRBtttNESbSPRRhtttETbSLTRRhst0TYSbbTRRku0jUQbbbTREm0j0UYbbbRE20hcJ0gpKZVKVCoV2mLEbTyZ8VRpX/8zBV3XKZVKFAoF+zNVVXG73bhcLlRVpbaxVhttXD+sRFK//ZpbJ0gpqVQqVCoVhBCUy2X7cykluq7bxqFtNJ52eNL+wG0jcY1gLS+chsAyEo22rTcalUqFQCCAx+NpG42fTTxpf9D2cuMaoFKp2AZBCIEQomUcwtpGUYyQkZSSwcFBtm7dSjBotJx0uVy43W5UVW0bjTauKtpG4iqifnlRP5GllCua3JbBsAyClBJN06hUKvY2ltFwuVwoitI2Gm2sG9pG4ipB13XK5bK9ZKiftLlcjuHhYYLBILFYjI6OjhVP7Prj1RsNIQQul8v+r2002rgStI3EOsOasCMjI6iqyoYNG5ZsMzU1xcWLF9m+fTulUonLly+TyWQIBALEYjGi0SjBYLCh59EIjYxG/RKnbTTaWCvaRmIdIaWkXC6jaVpN0NGCpmmcPXuWSqXC8ePH7Um/YcMGpJTkcjkSiQQjIyNks1nby4jFYqsaRyOjUS6X20ajjTWhnd1YJ1jcByvOMD4+jpSSLVu2AJDJZDh58iSbNm1i06ZNCCFqtq+HlJJsNks8Hicej5NIJIhEIvT29hKNRvH7/Wseq5U5sSCEqEm3to3GdcGT9oa3jcQVollwcnx8HE3T2LJlCxMTE1y+fJnDhw8TCoXsfVsZiXqcOXOGzs5OSqUS8XicYrFIKBSyPQ2v13tF15BIJJienmbPnj01RsPlcjWMqbSx7njS3uD2cuMKUM99cE4kIQSVSoUTJ06gqiq33HILLtfab7cQgmAwSH9/P1u2bEHXddLpNPF4nDNnzlAul4lEInZMw+PxrOrYiqLYGRTruorFIgCKouB2u+2Ua9toPL3QNhJrhKZplMtl2xOonzT5fJ6xsTH27t3bMHh5pVAUhUgkQiQSYdu2bWiaRiqVIh6P215MNBq1/3O73Ss+thACVVWBarC0VCpRKpXsczt5Ghafo42fTbSNxCpRv7yonyBSSkZHR5mcnGRgYGDdDMRyBCxVVWuCnJqmkUwmicfjXL58GSkl0WiUWCxGJBJp6NU08g6cNHFoG42nI9pGYhVYjvtQKpU4efIkgUCAXbt2kc/nr9NIjUnd2dlJZ2cnYLA+E4kEi4uLXLp0CSGEbVTC4fCKK1HbRuPph7aRWAEs7kM9tdqJxcVFzp49y+7du+nt7WV2dnZVJeDLBTBtT0LXEVNTUCohu7ogHF7R8V0uF93d3XR3dwNG3UgikWBubo7h4WGklCiKQiKRIBwOr3hiNzIaVkzDaTTqsydtPHXQNhLLQErJ4uIiQFOC04ULF1hcXOSmm27C5/MByy8PnNB1yfB0nA6fh55IALfaZBLpOup3voNy8SJSCISqUrn9dmRf36qvy+1209PTQ09PDwCzs7NMTU0xPT3N4OAgHo/H9jQ6OjpWZTTqORpSSorFIouLi2QyGTZs2GB7GVb2pI0nL9pGogUs7sPs7Cxer5eOjo6a7wuFAidPniQajXLzzTfXTCQhRA0XoRXm03lKFZ3FTIFEtkBXyE932I9adzx1ehrlwgX0zZsBkJkM6o9+ROVVr7ria3W73QQCAXbv3m1fmxUETafT+P1+O6axVgp5pVIhm82i63pbS+MphLaRaADn8sKK9Nd7BXNzcwwODrJv3z66urqWHGOlnkRF05lPV2MXuoS5VJ7FTIHecIDOkM+eNLJYRJpuPQA+HyQSa7vIZeDz+RgYGGBgYAAppW006inksViMQCCwooltLWmcxtQidrWNxpMXbSNRh0bcB+eE13WdwcFBstksN998c1MS03JGolwuMzg4SKKgI90+AoHapYym60wlMsyn8/RGAsa5YzHjuNks+HyI6Wn0AwfW7bqbTUYhBH6/H7/fX0Mhj8fjXLx4kVwuR0dHh+1p+P3+pizS+s8bLU/aRuPJhbaRcKAZ90FRFDRNI5fLceLECfr6+ti7d+/KAo0NkEgkOH36NH0DG8lnUiQXZ8nnc3g8XsLhEKFQmGDAj0RQ1nQmFjPMLObwb40S/fmfR/3hD2F+Hv3AAfRbbrkq96IVLGJXMBhk06ZNNRTy4eFh8vl8DRvUitOshF3azGjk8/m2atd1QttIsDz3QQhBMplkfHycgwcPEo1Glz1mIyNhcSimp6e58cYbmYzn6Oxy09PTjabrFIslUqkUk5OTFPJ5AsEAoVCYcDhEsaIztpCh0tNF3yvuJuBdOTnqakMIQUdHBx0dHWzevBkppc0GPXfuHKVSyc6YrDaz0UiAp200ri2e9kZiOe6DpmlMTk5SLBZ5xjOesWLmYr2RKJfLnDp1Cq/Xyy233EKuVCFdMFKEurRceh8+n4/+vl40XZLP50il0oyOXiabzVIo5KlUyiQyYbrCQfqiAbzu9fkJV1pDshIIIQiHw4TDYbZu3Yqu66RSKTsIGo/HCYfDtqexWjbockajVCoRCoVqaORtrB1PWyOxEu6DVblpPdCreZgVRbGNRDKZ5NSpU+zcuZP+/n4ApuOZuj0EUoIqJNIcTyAQJBAw6jUuX76M1+uhUCgwOzvHkK4RCoXY1NvFzs39BHxrL/C62lAUhWg0SqFQIBKJsGHDBptCPjY2hq7rdjwjGo2uqsalkdE4c+YMhw8ftrkbbdWuK8PT0kisRFbOWbmZz+dJJpOrOoeVArUo2jfccIOtT5nIFsiXKg33kwjTs7DGYh4P8Pn85iQDXddIp9OMzy5y/tIoYZ+b7Rt66O7qIhKJPCkJS5a3Vk8hr1QqNoV8ZGQEoMZoqM6MzjKw7rtlEBqpdjmXJ22jsTyedkZiueVFpVLh9OnTKIpiV24Wi8UVcx4saJrG4uIiLpeLW265xX7QdV0ym8w13EcIY+kBTuMgAetNWV2+KIpKJBIlEokggHJFYzaTZiE1DuVBfF6vPRFDodCyE2E9lxurPYfL5aKrq8tOJTsp5BcvXkRRlBoK+XJGw0q1Qlvqbz3wtDES1sMxNDTE9u3bG75pk8kkp0+fZtu2bTWFWathT1rHOXnyJD6fj4MHD9Z8N5/OUyxXEIilAgINTiERCAFCND6/IgzPw+VyEYkab2aXKgh7VUQ5b8cB1sJrWG84J28r1FPIS6USiUSC2dlZhoeHcblcRKNROjs7CYVCq/Ka2lJ/q8fTwkg4uQ9TU1Ps2LFjyfdW1uHo0aP2ssCCoigr8iSklIyNjTExMcH+/fsZHR2t+b6i6cylDC9CYsUeli4tGh4bgdQligBdGt4FSHS59AGuaJJ4voLH5WPjtp2E/Z4lvAYrRdnZ2XlFgjWrwVq9FY/HQ29vL729vQAUi0Xi8ThTU1OcP3++hkLuFPVZCVYq9ecsVnu6GY2feSNRLyvXqHLz1KlT+P1+brnlloZvpZV4EpVKhVOnTtnLC4tv4cRsMrvE2BibSBQEiAaGQkikZQhMr8H8J1awsyEkFMsaY/NpfB6V/mjQls5zpigtwRqPx4PL5aJcLq8qQLsarNeSxuv10t/fbweB6ynkhUKBsbExYrFYw3qbVnBqaVhjrjcaTzepv59ZI7Ec9wGWVm42w3KeRCqV4tSpUzXLlPpGwIVyhcV0oeH+1pIBcxJJ21MAYUYlamFsIxB1noX5bZ2xKZQ0RmZTdPjc9EYCBLzuJSnK0dFR4vE4J06cqNGeWG3gsBWuVtyjnkL+4IMPoiiKLSh8JUutRkbDUu2anJykr6+PQCDwM63a9TNpJFrJyoHhXVy8eJHFxUWOHTu2rKisM51Zf57x8XHGx8c5cuRITQFYvfcxE882FQutTnLTM5CgKEYQ0w5g1h3PMixSVs2DtP5/gyUIQLZQ5mIhQTjgpT8SxONW7euzxr59+/YlgUMrG7GWGIATK41JXAmsF8LGjRvZuHFjUwq5kw26VqOxsLBAf3+/bTSsc/+saWn8zBmJRi31nJBS8vDDDxOLxZZUbjZDo4pOKwti6VfWv22dhiVbKJPKm3qRgHUkIRQUoS81HkIYhkOCopj/dn6NNJcdZuGX7XWAUKCZ02N4GIJUrkQ6XyIW9Nml6c63fKPAoTMG4HVkTlZTEdqozcB6o96YN6KQZzIZ4vE4g4ODFIvFJUZjpdB13e6q5jy3paXx1re+lT//8z9nz54963eB1wE/M0ZiOe4DGJWbuVyOo0ePtlxe1KPek0in05w8eZKtW7eycePGhvs43/xTDuKUNX+1SoWhoWEAQuEwkUgYr7f6gCpCoFNNiQocE0CIJpkQCbqxBDFtjGM81WOB8b2zNF3Xm/k5RuCwr6+PPlO3Ip/P11SEOvuDNCvuguubZrUghCAUChEKhWxBYctoOCnk1vW0EhTWdX2JPABUBXgWFxcJBALrdGXXDz8TRmI57oOu6wwNDZFOpwmHwyuqvXDC8iScJKv65UWjfaSUJnGqtnt4Op3h4sULbNm0GZfbRSKVYnT0MuVyiWCww44XVJmHopoKpXkWxLkEMfZyGIom++hSMpfMkUymCKg6W1cwkesrQp3FXYVCoanU/7UwEvUTdzkoitKQQh6Px5mYmEDTtBoV8vqgbqvryWazq862PBnxlDYS9dTqRg9HLpfj5MmT9Pb2ctNNN/Hoo4+umhhlVYGePHkSYEXy+JZhmY5nHeOF6elp5ufn2bdvHy6XC03T6ff72dDfT0XTyGZzpNMpZmZmkFKaD3AIKXWs0IUAI/RQezeMZYYznWf+f8VavjRo7WB5LJquM58vMTgZpzcSINaxMre7vrirXuq/UqnYk0zTtCedkaiHRSGPRqNs3769oaCwdT3LZbzy+Xzbk7iecLbUa7a8mJ6e5sKFCzWVmyvlPDiRzWZJJpNs2LCBTZs2rXi/RK5EWDdiDrqmMTx8AZfLxcGDB1FVxc6ACKGgS1AVlXC4g1Cogw0bNqJpFVKptBlEjON2qRSLRSKRMH5/AFUxMh9SVid7s3sFVkzCmTmpjW0Admn6gqljEQ6sjkPRSOrfmmRzc3MkEgm6u7tt1e71ypxYuFIjUY9GgsLW9eRyOR555JEaFXLn9WiadkW9ViwIIaLAR4FDGLb/zVLKn1zxgVeIp6SR0HWdy5cv09fX17Ry89y5c5TLZW655ZYaF3G1RmJiYoKRkRECgcCqDISmSxL5CpulJJfNcuHCBfoHBujt6WnKu5Bg8yWQoKqumkpJI1quMj09TS6Xx+/3GZ5GKIzX56Wpp1BD9XakTR2xjdqlgKRQrnB5Pk3Am6cvGiS4xtJ05ySrVCp0d3ej6zrz8/NcuGAYTScR6kon+HobiXo4KeTxeJwjR46QSCTs61FVlWg0yvj4+Hp6TX8PfE1K+RohhAe4pu7JU8pIOIOTly5dor+/v2nl5saNG9m8efOS71dqJDRN48yZM0gpOX78OI888siqxjqbzBpSdHPzTE5OsmvXLoLBAIpoxHswIOo4D1a1hsSY7Kqq0tVlZB2klOTzeVKpFJfHLlMslQh3GAG5kB3PaMzIbBGjNM6bTsOZM1Askt+5k0sbNxHyu+mLBPF51v7ISClxuw2OhiXAa7EnJycnSafT+Hw+22islggFV99IOM9jEaucgsJWJugTn/gEY2NjvOQlL+FlL3sZ7373u9d0HiFEBHge8EYAKWUJKK3PVawMTxkjUc99UFW1xp2rr9xsFjBaiZGwDM3mzZvt7MVqajeKZY35VM5WiD506GA1TWb+v0YPv+FAVD+vpkpZEng0SskDBAMB+vv77Sh9Op1iZnYGXdeJRCKEQuGGateGN7P02DKdQb3vPsgXwOWCkyfRbn856e3byRaShAMeeiMBPK7VLxMa8SSc7EnL8FnVoNlstiY9uZImydcizQrGS6TRUsnKBH3kIx/hec97Hh//+MftWNYasR2YAz4mhDgKPAK8Q0qZbb3b+uEpYSQayco5J3ujys1mWM5ITE5OMjIy0tLQLIfR6QVOnTqNogizAa/xuQRTYcb4QwDqxDjKw4+glMtoBw7AwYM1wUcb9tKgLgBpHssZpQeoVMpk0hni8UXGxi6bb/AI4XCIQCBgU72rtk8iBLguX4JsFjkwYHycyaI8/DD69u1IJIlskWSuSGeHj55wAFcz+f8GWG4CW4YvEAjYRKh6TsNy6Ukp5brHORrB4kg0Q6lUwuv1smHDhivt4uYCjgG/LaV8QAjx98D7gD++koOudgBPWrSiVlueRLPKzWawMhX10DSNs2fPomnaFTX3HR2f4sHHTrFjxw4uXrxUM99VBLqjmlPOzqF+5SsoHR1I1YX6gx+AotSJ20qkjlHXYX5iBSCd8YZ6eNxuouZkEgIKxSLJZMqOZwQCfkIhg5/h8XiR0lwGabUGVGQyMD+HMngefedOUF1ICQvpAvFske6Qn+6QH0VZ/u292hRoI06DMz1peUtOsZprkUEB43lptayx+CPrgHFgXEr5gPn3vRhG4prhSWskluM+CCEYGxtjcXGxYeVmMzSiWFvLC6sAai0PmZSS4eFhTo9MceDAQdxuV5XXYF2Tk0MNiLExUFVkqMNw/WUEZXCwxkgszVoYywQppWOV0CjuYHgcVvbD6/XS29NDb08PuiOeMTIyQrlcxuVy4fV6KW3ciM/tRVlYQMbjKGfPIjdvwf2fX0Dbs5vKnXeC4tTGyLJoZkJiHa0pzlfKk2iUnkwkEvbyRAhhMyavdmyi2XLDgrVUulJIKaeFEGNCiL1SyvPAi4EzV3zgVeBJZyRWIitXKpVIJpP28mK15BnncsNaXhw6dMh21VeLUqnEiRMnULwBduzeV1P6bUnRIeWSkgrh9UBFM/kPAsoVZMxrewrCwW+oz4ioimKvXGoqRanSr51wVpsqStWtt+IZExPj5HJ5BvNzuI8cpnd0hNipU4hDh5ADG9CFQLlwATExiTSbA4FhxCq6ZDKeteX/o8HGHIv1JlMZgdyqWE25XLYL1R5++OElJeTree6VGIl18iQAfhv4NzOzcRF403odeCV4UhmJlXAfrMrNjo4Otm7duuq3haqq6Lq+JE261uWFJY+/e/du4mWVUmXpUgYp0c2gnXOi6zt3opw4gZieNoouVAX92E12qrJBvNI6oJ21MOa+sAOQss5gOOGsNnUSrBRFIeDzG95Gbx+VSoX07l1kzw+SQcE1N4ff58On6VCuskfreRalis74gtErpC8SJOSvjRms2Eik06gPPgjZLPrBg8idO5ffB6MLmSWAu3Xr1iUl5OspvHMtjYSU8nHg5nU52BrwpDESy+k+SCm5ePEiCwsLHDt2jNHR0YaxheWgKAq5XI4HH3ywaZp0JZBScvnyZaampjh27BiZkk4p3yzgLKpEJpP4pCHRiiW0ri7cpRJ6fz/ylmcgTdKXoBrjrHomFilqqY5ElYrdRJeiZkJbxqJabepc0rhcLmJd3ag330zk7BlKHWFKySSZSpnLC/N4kYTDESKRMG730uBhoVTh8lyKgNdNfyyI31PNQC17rzMZPH/3d4i5OXC74ZvfpPxrv4Z+5EjNxSpDQ5BMIgcGkA7+inOZUV9Cvp7CO8stZzKZzLosN54MuO5Gwrm8aKb70KjnpuURrBbpdJrZ2VmOHTtGJBJZ05gtgRm3280tt9yCBGbnFkzth6VViDUxEAE6kvzcPLn//b+gUEZ4PfjGJ6C7G/eNx4yJZHkGZgzCmvwgbU+jHtW6DunwQoRjHPU7VEV3l44ctNteDB4PrpFLqJu34HnhC9nX1WVI/adTXLp0iXK5bAYXDfq4qrpsjyVbLHNhOkE44KE/ElxRqbhy5gxidha5bZvxQTqN60tfouQwEq7Pfhb1u98FVQUpKf/Kr9hNippN3kbVoBZ9/OzZs5TL5VXJ/F+rmMSTAdfVSCyn+wDNe242y1I0g67rnDt3jlQqxebNm9dsIDKZDCdOnKjJpkzFM9VyboenYF5kg2uaJ/HTn7DD7UNs34XUNAqpJIXvf59Bj5dAwG+mK8N2mk86ji0bH9YRJTUzFVKansLyhsX2WqxDAMLrRbvtNrS67QOBIB3BIAP9A0hdJ5XOkEoZmROJJBIKE45ECAaDKIpil6bPJPPs12XLh05UKrUpYJcLSlXukBgfR/3+95FbthhuUKGA+1OfonjsGLhctlL2chBiaW8Qi249Nja2rPDONY5JXFdcNyOhaRrxeJzR0VEOHjzYsnKzUc/N1XgSVnu+gYEBYrEYuVxjterl0IhDUSxrLKSqDX8tT8GKGDjrqnRd2tmEvTt3IoaH0QDFpRIMBOjwegkdPGBK+Ke4dOkimqbR0RECJB6PxzZGSxSsGi0xzDe6kZ1sUuRlWwVpeC32sXQzttHAsAgHa1MoRCJhIuEQEoGmVUgmUywuLnD58ihut4dIJEwoFCZdKDM8laA7EqCnrmu6BX33bqPP6dwc0utFzM9TefWrqxvk84ZxsPb1+Yw4SbFoG4m1ZDWcitywVLHb2QYgHA6jaVrLMvK2J3EFcHIfFEWxlxlO1FduNvIwVupJWEVehw4dIhKJMDs7u+plitXAdmZmZkmQcyaRaeCoVylPElAF5AslhoYGicU62bF9G+Ry0NGBmJtDeD2IbJbKi16MS1EIBo2mPAMDA3Z/jenpaeLxBMlkkpguiSgCb28fSmcMTZeNtLcBZ3ARe5tavoVjW1ElWClCMSnhkmZKV/a1msdQBFBXEFUsFkil0kxPTZHL57l46SLz4QizsQgbuiJ0dtRyLGRPD6Xf+R1cX/kKZLNoL34x2nOfW/2+vx/p88HiIkSjiKkp9B07wHxrr1fqs5nwzvT0NIODg3YJeTAYbCi8k81mGbAIaU9xXFMjUc99sMgvTjSq3GwEVVXtNGmzc50/f558Pl9T5LXaAq98Ps8TTzyBqqocOnSoxkBkiyWS2WKjly2qECCMbEYimeHSxYts277N7JMhkMEglVe/Bh55BFEoIHfsQN+z236rW56C1V/Dyvr0jI8jv/FNiqUSqUqZzPNfgPfGo0TCEVxuN0s9BYOFpZw/h3LyJHi86Lfcghzos5cmDe+f7XVYmRPD01AEcPESYnICQiH0/QeMAKN1HDPGYfK/8Hp99PT46Ovt4eSpU/T395NMphi+cJFz5ytEwiF2bepjy0Cv/RvJzZsp/8ZvNP5BQiHKv/3buD/+ccNA7NlD+fWvr477KvEj6oV3zp8/jxCiqfBOLpdbt+WGEEIFHgYmpJR3rMtBV4FrYiSacR8s1iRUKzdLpdKSys1GaDXZreVFf38/+/btq7HyqzESi489xuUzZ9j3zGcytLhYDUDqOszOMj2fho5wQ7Fa3YzkT01NEY8vsm//frxeT+2UjESoPO951UYytk9Sq3WpWcHFbBbfD36AvnEjXrcbigXCTzzB9O5dXJhfQNOM1n/hcNioqFQVpBQoZ87g+vKXkaEOhKahXLpI5fW/BF09SGF4CoZBco7O8XZ3eArqIw8jvvp1wzCUy+inz1D5hXtAVQ2PRVjthKppVmEHSKutCy0vKZvJMjQ+x8nzF+kMetjU30NnZ6fdYLgR5JYtlP7ojxp+d60KvIQQ9Pb2Eo1GlwjvfPrTn+aRRx6hWCzyvOc9z1b1vgK8AzgLrI3Ic4W46kailaycZSSWq9xsBKeBcWJmZobh4eGmnshKjISUkpl/+ifc3/8+N/b2ojz2GBPPfCbyyBEoFFA++lFSZ85TxIPYuRN5190It9swIsJ4gCqVCoVCgXw+x4EDB2tdakNnqu4dXhu/AKoxBXN7JW/GPiwD6vXhURUGolH6I1F7aZJKppgYn0B1uQiHw/Q9+ABKOIQIhQwjNDWDGL6A1tVT5VhUT1kT63B8Y6Qw/+s7iN4eNJcbIUAZHUGZmICtW+so4g75f9mY76EoCqFwmJBdb1JhoZAleXmCcmEQr9dLZ2fnqipCr5WRcAYu64V39u3bx2/91m+RSCT4pV/6JT7wgQ9wi5l9WS2EEJuAlwP/A3jXul3AKnBVjcRy1GqoshVXW1BVP9mdy4vjx483DSotZyRKpRLnvvENdjzwAOFjxxAuF2Qy9H3ta+i334747ncRp88wtWGH8fYdHkZ/9BHkM54Bwnjb5nM5zg8Znaa2bt1mG4gqgclc6wuBYrKgWonGWG9nrSOE8HkhkzHiGckkMhBEBjvMa7Na/0URQLlsMFPTuTxyYQGlVMbn9RLUykjFKROPvUxovgSRoGmgVdBVk3IuQQpheBTOBqY1QxdVZmiD76SVqpHS6JrVEQEidPrchH0KuXTKrghdCa/hehiJeng8HlRV5W1vexvHjh270lN9CPh94Lrp4F0VI7ES7oNVubnWgiqnJ5HP5zlx4gS9vb1Llhf1aGUkLPbkgViMSGenkX4D6OhALRSQpRLi8mXmQ1FKVqrRH4CZWfsYC4tGxmb37t2Mjl6uLlGkkfWohy4linD2+ayrUaHq7kuvl9Ldr8L9pS8ipqaQ0QjlV9xVHWfdji63h67uHtQ7Xo762c9SLpcoJRMsCsGklPgvXzYzD6HqMscRD3GORRECXXWhHT6M+sQJZCwG+RwEgsiB/oYGwglnsBSLvCWlsRT60pehWETfv4/KHXcifD7ShTLpAkQCYfbs68etKmQyGRYXF2tk8To7O2s6kV9LPYlW51mP7IYQ4g5gVkr5iBDiBVd0sCvAuhuJlXAfnJWb2Wx2TZRoa7LPzs4yNDTEgQMH7PTVSvarH7OTPenP5w2ijvnGZmKC4saNuF0uKtu2Mff4eegw3n7ksjAwgJQwPjZGOpPh4MFD1QIvYWY4Gkjj22MSoEsjslGTXnTEKOxP+vspveVXEaUiwuutnsCB+qyFtmUr+ut+EXVwEL/HhefQYYKhEOl0mmQyxcTEBJWKRkcwiN/vw+83KMvVxj/YNHDt516K9AdQL11E79mC/sIXIQPBmnqV2uuqHZv1vUuAnJjC9bl7DYMTCaOcPoPq8SDvusveLpkrkspbpelBtoZCbN261a4AXlxcZGRkxE5hFovFpr/9emI5nsQ6MS5vBV4hhLgd8AFhIcQnpZSvX2a/dcW6GgkpJcVisSW1ur7nptVqfrUQQhCPxykWiy2XF/WoNxL17ElFUcDvR//1X0f513+FhQXkjh0s3nwzQSmZufEZlM6O4BocNJYABw5SOnSI4XPnCAYD7N+/354wlhhuq3es5Y6Dg11pvm2d39UwN4UAn69J16/GKUu5cSOVjRuxMieKlPbSBGByYpxSuVJTSm5Rr71ud3Up5Hajv+hF6LzIHgrSEdwEoxxeLvVGHKNBk6BMTxm+iym9J3u6Uc+dp/SKuq2lUZpu6FgYpen12pPlctlWuLLaNlpLk6vRIHk5I2HRvq8EUso/AP4AwPQk3n2tDQSss5GwDEOz2EOznpurrQ7M5/OcPn0aIQTHjh1b1b5OI9GIPWmPafdutL/4C4Oo43ajnzpFsVRmoaAhX/kqyqkkADmXi6HB82zZvJmY+cA674ezmrNaV+F8vS6dSFb1qCrtBYD5eTUSWC3iqs2E2LoQDWBVhzptjT25VZWw309nZxdOabxLly5RKVcIhUNEwmE6QiEUK57RoJjMWEYI1AZehAW70MwfcCh1SWQ2h4w2Y8JKNA1mkzlbpLfTUZrudrvp7e1lYmKCQ4cOUalUbCJUPp+no6PDDoKuR4Pk5Z7ZXC63IiWtpwLWfbnRyJ235NUb9dysl6FbDhZNe9euXYyNja36DWGNb8UKVA5+xXQii3R5jTkdiTA7O8f06GX27NlDIOBvQJWuaj+ARUzCLh1PJ5PEkwkikSiBQKBWVMcxySzGZPWoDQyBs6pTsIRduTRrYdWEgFBkzdidClEbBgyp/0wmYy9NVFWlIxQmGovg9zV6SxtVqrLheavS//qe3eh796KcHwRFQfGolF/+choZTqfAjqZLpuJZ21g4S9OtZa7f769p9ZdOp2viGU7K9VorgJfTzlhPhSwp5XeB767bAVeBq5rdqK/cbGRZV2oknDTt48ePI4RgdHR0TePKZrPMzs6uKmBarOhkK0UiEW8NvfrgwQO4XKo94XAsCxRFaTSd0XXJxMQ4qWSSWGen2Vksi9frIxKJEI6E8bo9pi8vHMZC1Lz962FlC4xsgsW6MB5kY1XQYBmCBN38ttFk142siVFLYrzlS6US6XSK6SmnanfEVrmqTuiqlyOExFbTsg6vuqj8wi+gjIxCqYQc6EdGovZIq+NfKv0PVml6mvlUnv5okA6/p2ERmbNOwynzXx/PuNJep/Zda/YDPUVx1YxEo8rNRmjGd6g/1okTJ+jq6rJp2pYmxGpgsSeFEBw9enRVXshitoQn4KFYNOjVnZ1dbN++HWdZtuE6WxRpY0JodT63Zvbf8Ho87N23j0qlQm9PD5ouKRQKJJNJLo+MUK5U6OgI2dkHY8mim0VeSz0Fm2dRQ722OBCNVbOhuuSw/qtlVzZOy3o8Hrq7u+nq7EIIyOXyJB0qV6GOEOGIoaepKGqVYGUHWR1jV1T0HTvqjJ+wtxCmF9Vq6VIoa4zMpQh63eRLlWUneX08o77Xqc/ns5cma41nNFt2PxWx7kZCCNG0crMRljMS1rH2799v/6jWeVZjsa3jHDhwgLNnz67qB0zmihQqkko2y+XRUbZu204kEm46Dmcth3QsvQqFApceeIC+QIDOPXvQhYI1AYSAYMCP3+8z1aK0muyDJUefNde6iqAmJtBM71Kay5tG/UENw7I0HgLGBG3e9YsadqU/4CcYDNDf32e79slkisnJCdMLMbQ0kdKka4sa42oOZenYLQKXfZ+XbuMcY7ZYZipV5PJcir5IAO8K5f+dlGunYnd9PKOzsxOPx7Pscyel/JnyJtbdSFy6dInZ2dmGlZsNB9CgfgOM5cXw8DCpVKrhsVY6yS3tyUQisaosiHP/6XiGTCZDsVjkwIED+L0e9HIZymWDJ9FgKMLMf0ppSMbFL4/CBz/IwdHLuHxetG3bkW96I2L7DmsP21gYQUi1JvswOztDMplkamqSQqFAIBA0qi8jEVwWJbpJxabTONh8KeonnnO5IewNGzEwlz7+1eWFolCzNCmXy6RSSWZmZsjnC1y4MFzNmni9plOxEjUtlhg6KxBbj1S+RKZQIhL00hsJ4l6FoncjxW4rnnH69Gmbn1GpVJpmOAqFws9M0BKugpEYGBhYldpTo2pOa3nR2dnZtAp0JbDYnJFIhJtvvnlNx5lNZDh5+iyVSoVNmzbhRSK/9S3UH/wARUi0LdvQf+EXDD6FBUfaUpeSsbExgv/7n+m5PIbs6kSvVBBjl1E//RnK732vTYYyPH0zhmClFs1Dej0e88HdZNcKJJMJZmZmEUA4HCLcIABaD2tJpChNSsftcRj/sv7XWuI0e6ODk++Bzfdwu910dXXT2dlJoVBkYGCDLcBbqVTo6Oiwa01Utf5xrI1F1HRYZ6nxco5flxDPFElmi3SG/E1L05dDo3jGwsICc3NzPPbYYw3jGeullC2E2Ax8HOjDuOT/LaX8+ys+8Cqx7kbC5/OtKlZQv9yYn5/n/PnzK1qqtILFntyzZ4/dXWm1SKXTfOfHD9LT228oSo+MoN53H+L8eYTPh3boEOLyZdQvfxntF/4f+3kVirBdzvHxMTqAzkIBGfAjhAJeD1LTIJOGQqHWwJhwFlU5O4UDNbUCmzZCuVIhlUoxNzdLPpfH4/UQiUSJRiK4G3lODmPpJEw5v643BI1EaepGXA1W4oxvgBQSXTMYirUCvEaBVyKZZHJyClVVbJn/QCCIojQ2SFbWRLCcRoYx7vlUnsVMgZ6Qj65QYEXy/82gqqpt1I4cOWLHM6wOZOVymW984xv2suQK4xIV4PeklI8KIULAI0KIb0opn9pq2au9KdZyw7ksWOlSpRGWsCfX6PbNzs7y4IkzbN2+g45gkOmREYKf/w+jAtTnA48b5ewZ9GM3wcgIRt2GQDPTC4VigcXFRXp7e9i6YSMEAghdGsYBFZHPQ2cXBIzxNctaGKIxZsS+wQZCGPfQWjNLKSkU8qSSSS6OXESraDUBUIPj4EhDmpkQa7lRy/isP5djSUQ9u3JpTKQa3xAm6av2e6OhUMgu8CqXy6SSSWZnZ8lksvj9frP5sJE1cV6zlFX+iHNJJGhyH3XJbCrHQqZAbyRILOhd8wR2LjPq4xmzs7N89atf5dy5c9xwww286U1v4p3vfOeaziOlnAKmzH+nhRBngY083ST1VVWlUCjw8MMP25mQ1fx4TmvdkD25SljGaiGeYNP2Paiqy6jAzGQQ5QqEOkDXkW43lMqGgejtgYVF9K5OFCFIJBOMjIwQjUYNmTy3C/mqVyI//gkYG4NKBX37dipveQtCmGnSpsIuxoSWZjhUEWbpODSc0AZHwGj/19c/gNQ1Uo4AqMvlstv/+f1+Y/mA+ea3U49NxlGzBDFjBOY9s4xOPaxJq5vpT2dmo37p4na76erupqu7G4EkXygQTyTqliYRwqEQih0LqC6JBK0Chkb2p6JJJs2u6X1r6JoOrXU0+/r6uPPOO8nlcvzTP/0TCwsLqz5+IwghtgE3Ag8ss+m647obiXw+z+TkJIcPH7ZVgFYKJ6OxFXuyERq5gs4Yxsbte0jkjDoAiYRwGBSB9Puhvw8xMQnJJEqxiPR6Uf7n/0R/05sYE4JkMsHBAweYmpquToIbbqDS14+YnQWfF7l7j3HsSsWcPFWXfsk1Vv8ytzEmXCvas5XyFIpKNBIlFo2iSygViyRT9QHQCJqmm+57baNiC408Bd1MZyqCFhWsxoGMgKPAYobqsrVhlIDP52eg38/GgQHKlQrZbJZUMsXk5KTd1tBamlgGRwiloVdWP/5iWePyfBq/J09/JEDQv/KA9kpFcFVVXUIeXAuEEB3AfcA7pZSpKz7gKnHdlhtSSi5cuMDc3BwbNmxYtYGAajxjenp6Vf07Ldal84dOpVKcPHmS3bt3E4rEGJ6O1+wj/AGSd95J/399E6IRZLEI0Sjy8GFwu5HxOMlPfoLya1/H/v0HjHWvsFboAAIG+o2KSesTe91suspSR0mlDVc6ErFjGwbfwZlqrY8p1F5f/RvaGSPw+bx4vL309PSi6xq5TJZkOkU8vmiQu7IZmwGqKoptLFoFOZ3y/JaXY4zDOVnNJZOwDJF1Z5Yet35C6xJcquEBRSMRdOnMmsyaFGgfHR0hh1dUvfZWPJF8qcyl2SQdfg/90ZV1Tb+WIrhCCDeGgfg3KeX963LQVeK6eBLFYtF+Y+/Zs4dkMrmm4yiKwtmzZ9F1fVXsSUtE1/qhrW7kN9xwA8FgkIsziSX7CAGFrduovPu9hgdx5gzie98FtxutUiGRyxIIBNm+fZtjH4NMZcXJGnkKhssuoFzG9bnPoZw+jZA68sABKq99LdLVSKFL2m/mmgCh47tGE9piMAoByslTeP7jP/DlssQOHkQ885n4OjsBUccADRONRHB5vA19FiyClKDGy6n3FHTdGZOQWGVvSzkTjZcutkExsydW1qSrq9uOw1gFf6dPnzIVuiKEQh0tJ7RFGMsUygxPJ4gEvPRFAnjczfe5RhWgCOON+3+As1LKv12H4+0HvgrskFLqpizeV4FPSik/3my/a24krA5cVtZhcXGRSqWy6uMYitJJtmzZwq5du9ZU5KXrOmfPGunN48eP4750icw/foTCYgaxezfyVa+yBVbt2EHADwE/ulZB/e53qMQXSOQLdJXLcPx4jYtuvNF12y0XEod3YBCt8vkCXp8P9cc/Qjl5Avr7jTl36hTKD36IfOELbfakTfeue9M6C7aMN3sTzoE0JoSYnET9t38z4ivd3YhTp4hkMlRe9zoikagjAGowQC9dMmIC4bDRXyNkMikbBwmdwVDnGKvLO6enY94a29CJJixPMLwP6zunp2BxG1RVJZvNsXPnTjKZWkKXoegdxh9wKlwtNUhWaXpvJEBPONBwHNew58atwC8DJ4UQj5uf/aGU8itrOZiU8qwZ/LwD+AKG2tX5VgYCruFyw1nHcdNNN9mNXVdCy66HxZ6MRCL09/evqcgrl8sxODhIX18fW7duRSwuovzlXzLlDiFjnbjOnUf7939Hf/ObzesCzcGelBs3MX3bS3B/4+t0+72IZ9+K9sIX1p1J1C7szSi8QFCulBkcHETXdSqVCltOnSLkcuMyaw9EMAgT43aw0kllamYELGq1veZ37CWoxg3E5CQgwR8wOBOdnXiHL6A57qNVJBUM+JcyQCfNAGg4QihcDYAuGQ8OL8ceT2NPxzZ05v2ptz32ssZxbOtzaTJHdd3gfxjxCoPQpQgoloylyfTMDPlcHq/PZy5dQrg9S/uWSklLAtZygjO5XI5Njq5ia4WU8oc0DjpdCf4O+F1zGXMrmDX/LXBNPAkrIBgKhZbUcazGSNSnSYeGhtbUxatUKnHy5EkOHTpkU73F6CiLJZ1iVwQAra8PMTyMUjHk2lyOPp6apnPhwgVcmzez7b//BVJRbNUpZxevamquFplslgvDQ2zevJlgsAMJVC6NoA8PE1cUVMCfSqHfdBOKNFxzQzHK0LtsplAhAOn0MuxXfd32Ab+RjpXGSPViEdnR0XCBYr1p6xmg5VKRZMoIIhYKBYJBIwAaDodxu1z2JHbSvK16hmYJCCNbI+zt6+xrw6xL9eokUtcMHopz/FI0XJqkkykujoxSMTuQVZcmLrxutWnTY2BFPTcCgcZeyPWGlPIbQogPAh8AnielbC45b+KqGwmrTLwZqWmlRqIRe3K1XoiU0tZLPHLkSE0tiB4IMIOr+tSViob8vKI6umYZLvjg4JCZG+9dQkay5N+QElUoS4hKCwuLjI+Ps2fPHnw+P+VyGVUIlNtuwz0zje/iRdB1Mtu3Mb59B/kzpwkGO/B4PGgVDYmjr2iphHLxEugacutWW+vSgOXFiCXBTX3fPvQD+1HOnjWWLi438dtvx2deuhUjqM2s1MLj9dLd3UOvz4ccHKSQybCga8xMTyMEhMJhIpGoLWCrS92IvzTTwqRRgVo1bdrMezLvuHFd0or/SPO6l2ZknCni3v5+kDqpdJpUKm1nTXZv6iUVVJt2Il9JTOJKBWeuMn4MPCalnF7JxldtuSGl5NKlS8zNzbUkNa1kojdjT65GHt/iUHg8Hnp7e5dI9s/2bqR0wzGUxx6zF/f6a19npD0xUomFQoHz58+zc+dOY80pMd/qtU9ijfdgxR8kdnfrQwcPoprl5Vh7e71ob3ozYn4WXQdPbw87FCPAms1mmZubI51OcfbcecLhMFGfl+jHPw5TU4BAhMOU3vY2ZJ3wjTWemsY8ikr5l3/Z8JQKRfRNGylksvgsN1+CUdoNzTIaUoJYmMf14Q8jUml8SEJd3VR+57cp+QMmA3SOkZERfD6fwcTVdXv9YRDP6hdES89kkMkchrFmu1peh5SY/AnDn2vG3aiJRQiFSDhCJBIx9kenyyuZmJggnU7j9/ttopr1DK9ElepJ3r3rAPCxlW58VTwJy53v6Ojg+PHjLddvrYzEcuzJlbb6q+dQnD17tuac5YrGQraIfM1r0G+4ATIZ5MAADBjxDl2XLCwskMlkOHLkKD6PIecmlMbLCTCNpaIYgUtNZ2h4CJ/Px/79+03PZMkrzpB16O1zcCBM2flQCEUIVFVhw4aNJJNJct/4Bq7zg8i+HrweD550GvXrX6fyutfVH7amCMpIRkhQVMTevWjWMDL1HdGFY//G91X9+jeMe9XbgwaI2VnU734H9c67ahig+XyeudlZUuk0Z86crmWAqqodU2h4H3F6QfWCOrWejq5rVI2IQIhqktWJ+hJ4Z/B0oDNMLOizGZS5XI7FxUUGBwcpFotEIhEKhUKNF1qPp0Af0IPAqZVuvO5GQtd1HnvsMbZv374iIkkzb2Al7MmVtPqbmZmx2/yFTfpv/TmnE1k0XUcoCuzZUzOBLf0HKQ1NSI9pIJoS+zDfY2Y0v1gsc+r0aQb6++nt6zFTlc0Ni8nqbsqodLvddHd3o3q8qJ2dlANBysUihVKJ8vAg6ckJIpGISTBiiTdQLdhqoTHhuD5pziDrze9UzBKJBHira3fF5UZLpWvSoFbmobMrhqKqbNy4oaYE3uVyEQ6FiEajeH0NAqB1jprz3khZawCqgjO1AsLOJVSzFCuAx6USc8QihKh2It+8ebPdVHhwcJChoSHcbrdd3BUOh+2xW/L/VwohxMuAvwdU4KNSyr9ah2NuBhJSysxK97kq8nW33HLLijMOjbZbKXtyOS/EqWTlXF44jUShVCGRLRj72AFHY5IXi0XOnzcyIKFQiImJCccx6lKSThKE+WDn83nm5mbZu3cfoVAHUjf2a2QojOfXGYarciBkg2IKuWsn4ic/xoPE7fODHqd84CAVVWVmZoZcLk8w4DfFXyINOqLVuv3gTFHWG0HL7XfK3Am0QwdxD55H+n2g6+iFAvr+/fb21rGQoGumAG9dANRggKYYn5ikWCzQEQgSsgKgbleTAi9hX4LToFnZjUZkMiRVvkqTwG9PuHWdj1XxGQwG2bFjBy6Xyy7uOn/+PH6/nwsXLlAoFNZDTl8F/ifwEmAceEgI8YUrLe6SUo4BO5bd0IGrstxQHJmA1WLF2pM090KsIGc0Gm0olOvcbyq+1KBKKUkkEoyOjLBz5y46Qh3k84Wac0mHUdDN2WxNIikl09PTZoFXH6GQ8cAIh6y+QSKq3iNVNOY3GClNscRY6IePUPn523F/65swvwDFIp6f/pS+M2fp/LVfhR07yWWzxJNJLlwwPKFwOGQEEzuCdh2GRYCqFnk1L/BCVlmSAtCf81wqqTTq97+PIqB8913oNzqb0RiT1RDIaRweMBigPfT09KDrOrlcjlQywczMDAK5JABqDsQxFmcNiY7AevaWnkw3XQ+L/+XEchkNJ6yYRH1xVy6X43vf+x6Dg4O87GUv49Zbb+Vv//Zv11qseAswLKW8CCCE+AxwF9e4uAuukpFYrWoUGMsUZy/QlbAnVVVd0mchmUxy6tSpliXilpFI5YpkCqWa76Q0DFUyEWf/gYN4PG4UIczyYofnsOQxMwqgpK5z6dIImq6zadMmikXLS6GGcinNaL79dmvaAcssFQcQjgIvIdBf/CKKe/fg+bu/Q8a2GqK9iQTuj3+cynvfiz8YMAzChgEqFc0OJo6OXsLn8xOJRAmHw0ZZs+lVONW566/P6SpJQKgK+h13UHn5y41PROPYky6lybg0DaMjzek0SIqiVEvgNxkl8Mlk0g6AWlqa0UgYt6Mq1CKrGeKzgkYGovq71WZOrPjGcl6EE5qmNdTRDAaDvP3tb+czn/kMP/nJT3j00UdXLXLkwEZgzPH3OPCMtR7sSnDdC7zAMBAPPfQQfX19Zt+KlS1V6j2J8fFxxsbGuPHGG1vmqa1YxmyiNlhn8x9UlX3799sPgi22YvbQaNZkpzI0RPb//F82lUr4j93I/IteRMHcVG1oWMxScKVRtL8WtfEKiSqMsnRlYREplGp/0GgEZWYavWS2ApCG1+J2G+XkXZ2d6GYw0WBTXkTTdKTU8fl8+ANBY6LVrfcbBTCtvw1DpzSMtJj+SfXtLqtivs24D9axVdUcc1cXUtfJ5QukLAaoVllSAq9rOgjFJo7V3st6Md3qksjvWbkXASyp+2kEn8/HrbfeuuJjPplx3Y2EUSeQ4+abb24ZMW4EKyah6zpnzpyxaziW+wEVRSGeLSL8Zj2CEOTzeZv/YGk1OiGEgqZLhDAyFvXIjo0jP/hBOkJhPJ0xePgRAskU2VfcCTgMy/g44tvfQRQL6Lfcgti3HykV8z1d22inUfGWORpzewGdnUatR6ViKFylUsiu7qrRwBG9BxDG0sISfxkYGEDTKly4cIFUynhrW6rd0UgYj9drkK6Wqdg0RtXIsEj7m2p63OE0NVga1BokM74gBMFggI5ggH6zI3l9AFQRCoFg0DTq1HgKzUlcgq7Q6jRHGilyO79bJ0wAmx1/bzI/u+a4asuN5eBkT1pKP6uFoiiUSiUeeugh+vv72bJly8q8ECGYS+Xo9YeRQNLULNixY4fRF7PBD21QJ6ShWI3p7kvDMV9YWCD54E/Z6fOjdJtqWn29uM+dQ3v57XZKU05No/7Dhw3hGpcL9dQp9F/8JTS7qazVC0M4ovE4vqum9KyHX27ahHb77bi+8hV0RUX4vJTe8Iamly6lcKzhjc9U1YXX46W7p5tAIFit2TDVry39iUZy807CkhV8VRSnV1TlzdT/Ns7gZk0coWFMwbyHwhg/irIkAHp57DKJRIJ4fNEugY9EwrhUtbpeq8NqYhErxTopZT8E7BZCbMcwDq8FfvFKD7oWXBdPop49+eijj6JpWoMIfGtkMhlmZmY4duzYivqAWohnS5Qrmh1/SCTi7N9/wI4/NFpOCKEYcQMT0iyUGB8fJ51Js3f/QZQf/Kj6miyWDAUrql6EcuIJRKmI7DfKxYvlEsn/uJ+5SLguPlB9KzdyyeuDnJUXvRjt2E2ITBrZ3Y30NXkzWpkG07VodK1WzYbfb9RsaJpGOpUikUwwMT6Gy+MhGjHIR16vd2k6UVQ1KYzTGVdhZR7sYdR7CliGuEWBmnlsaynhDLL6fF4CgQBdXQEikQi5XM7UAJ1BEdJoJhSJEqgJgC6f0Vgt1lIm0AhSyooQ4u3A1zFSoP9XSnl6XQ6+SlxzI9GIPblWevXU1BRdXV2rMhDlikYiV6ZS0RgaGsLlclX1H6hOmvq0pkutpVhrmrG/3x9g/779KFIi9+9HnD2DEWFUyL/qldRwFMw8AroknckgymU6+/txDWwgmUxy8eJFdF0nHAkTMx9oTLah8ygNS6mjUUPfAlMEplRCeeIEIpNBbt+G3LatYVoTaRaENYkOuFwq0ViMqHmPC4U86VSK0dFRtEqF4BJpPPPootokyPrNmkdcjPFY3kbjZVYtr8NOERu72sFRq8DLCoBu3AiVSplUKsXs3By5kUv4/QFC4TA9XbF19yLy+fy61W2Y1Z5rqvhcT1yz5YaTPVkfWFyNkahUKpw8eRKfz8fhw4e5cOHCqsY2m8xSKpeYm5tl8+Yt9PVVCV/Ot7YzrWllFyx336rf2LBhwBDLkaArAvGrv4o8dRKyOdi8GT0SQXfIl8ljx5Df+TbZ0RE8bg8+RVB88W1L4gNp84HOjowQCBg6j0aUXJrpu+bxARDo5Qqef/xfKIPnkcLIPVZ+5VfQbj6+dBdrQkqJsiQ7sZSa7fP58fn89Pb2ous66UyGRCJpxgXctv6E1/RmHL6XkSVqkWIVopZfIalmQpr2FcH0WoRRli9E/XIIXC43nZ1dNX1O06kU8akxHpobIxo1yuOj0eiy8azlYg5PAbblqnFNPInl2JMrNRL1JKtCobAq965QqnBpYoaJ8XEi4UidgWhAlTYj4k5qcyKRYHR01K7fEAikRf9VFTh6tMo2zGRqHqp8RwcjL30Z20ZG8LhcVG66CW3XTlRRVXRSVJf55rYozTkSCaNvRbFYYmJ8kmgsapZnV++jc4zKuXOI4SH03l4EApHP4/rMZ2BxEWV8An3rFrTnvwBcrtqWfMgaN75VxSYIhKIa6/5wBAkUiwXyJ0+R/fJXWHC7qRw/Tri/n3DYjPMoqnmORoVjVYMA2MZJmGuTZn1FnJ6Vrum4VEt8z9h2aU9UI2gbi4TYPRBD0zQSiYTdXNjtdtsZlUbdu5YrE28biTVgJezJlRiJ6elpLl68WEOyWgkt24KUkodPnWdsaoat27aTTCarD6uU9kRvvK+xf7lcZnx8wo5fNDYsZsrU/D+rg1cymWRkZIRdtxwn8MIXoltv6XK5RtEJ6VBtEoJAIEggEKSzs5PxsTF8fh/T0zPkclmCgSCRqMWodPyUhYLJWTCvz+tBGTyP5/7/QPf7UB56COXiJcq/+hbzXLVBUWmOp96LsODMPjjjCYEzZ4l89J9tTkj53DnG3vhGJicnqFQ0OjoMirPP53UQ7pbxFKRZ4EVjCT1nHYbl/VlLKKeidj2sWISqqnR1ddntGwqFgm0wcrkc4XDYXtK63e6GHAkn1qvnxpMJV3W5sVL2ZCsjYTUKzmQyS+jVKy3w0jSNBx99nPl0mQMHDpLLZZFStye4IdLS/Fo0TefixQvous6BAwdQzfiERTluDMM1kEhmZmaYnZ1j//4DuD1uY3KI6tiMMShmPEFpyAgEEIqocZtzuSypZJLhmWkQRj+IaDRCYNs2Ix2aSaN4vciZWVAUtL4+Q+Q2LFGeeBwlHkfvrO1tovz4R6gPPYQIBin//M/Dxk3NL9F5tRLUez8Hfj8Eg0ghcM/OsXl+no3Pehbj4+NUKmUmJiYoFgsEgx2mFxJCKKo50RssU6k1DvVpVWd8xl5uOAxOo76prTIaPp+PDRs2sGHDBmM5lU6zsLDA2JjBawqHw+i63jBbA+uqSvWkwVUxEpqmcebMmRWzJ5sZiVKpxBNPPEEsFmtKr17Ok7CaBFe8EXbuNCaEM1NhPITGPxQh0OrePcVikcHBQbq6uslms3bNhrB2bhCPc2YN0ukMUsLBgwdQVdUk+hhvaU2roKoqUhpSegKJhm7XHyiiSlBakhAUgmCwg9DcPNseeYyK1Fk4fISpfI58vkDnK1/Jhv/6Fp5cDnnDUThtsHnNBuKo0uoBUoX3+z/A/Z+fN7IylQqe02co/eEfQnd3Na3ZoiWfWiigeY1+Foo0mgCIssFoVRWFQDhCZ2enXf5utC2cQhEQjcUIh8P4/bUuvuJYRtVkQjB/fydV3ZlBMferCZ6a2600o6EoiplGjQCG+O7U1BTFYpEHH3yQYDBoV7taSmvrbSSEEP8vcCdQAi4Ab5JSJtbtBCvAVTESmUyGQCCwYvZkIyOxEnr1csdeWFjg3LlzbNy2k1Sl6iI6mZoqJhNSGJPXqUOZzWYZHh5m27ZtRCIRZmdnq+e21vCibskhjeNUKhUuXryEoghTg7Ma9LL0NQ3hHAVQQep2hN4wGobBsLcplXBPTSPCEWR3txFUvXgR74f+zlCTBvoeepjud/0u5YP7yWbzTGzfRjKVRkWyc36ewPQ0BIOIXB593x5kV7djXBLP976LDIVRfF50BGJ2BuXkSbQXvai6JJJWJmTpva8885ko3/ovZDgM5ZKhIr5nD5j8Euv3ssrfDe9SUiqXSSVTTE1NUcgXCJgqV6FwGLdLbXAu457req1auHFPlSVLJdvQCvC6lDVnNNxuN9FolFwux969e8lms7Zma6VSIZfL8eCDD14JFbsRvgn8gZkS/WvgD4D3rucJlsNVMRJGqfLK00Aul4tSqVpDMTY2xvj4+LL06maQUjI6OmpyKG5iZCGDkLo9+Q1vwDASusP1B0wSk2Rhbo7JqSn27t1rvyUsONWoqkXJxitaKIJsLm/qZ/aSTKZqspUVkwKtCKWGMCWEgmJkTs1r0A26dLGI65OfwP/FL9JR0VD6eqn8/M+j3fMLqN/+tpEK7DLSk2Ixjvje9xC/8it0dATpCAbZuElQKpVIvOlNpL/8FdyTE2h798Er7iRkTnrM+AmKgqhUaqskHYO3O3jZ96n2npRf+SpUlxv1kYeRnZ1U7rkHvX/A9Aaqb/naeynwuD10d3fT3d1tL6MSiQSzszNIiU2KCjhEbK0YRjUMYRhXS7a/0RpJSuhuIm67UljFXc5Wi1u2bEHTNB577DEef/xxTp48yWOPPcYf/dEf8ZznPOeKziel/Ibjz58Cr7miA64B141x6YS1bNA0rUYif7l0VCNomsbp06dRVZXjx48zn8pT0XR78ltuqq7LhoVaUsLly6MUCwUOHDyIy2xia3sLsokalfn2SprVo7t270JVVbtdgHR4CbYsnBVgQywpBxdCweVScP/7vyO++CW0UgnF7UadnUN+/etU9u1DViroSt2E1gyqkWJ5Rhit6Lq3bIW3vc2otMxmiScSTJw7Z3f0KlcqlH7u5/D826fQiyWoVCAURr/xxiX32Bq701hICbhcaK98JdorX1mzdXUyC5wFXtZ39dmHYLDDqPrEEAxOJqv9NQKBAJFIuKb83fIapJS2Qbpa7Mpm2Q1VVbn55pt5yUtewp133skdd9yxpud3GbwZ+Pf1PuhyuO61G1Ct5nzooYfYsGHDqrqSO2HFHzZu3MjmzZspVzRmU7mabSRmkFDXlrxsKpUKQ0PDdHQE2b1nbzVXT/WRW7K8cGB2dpq5uXn2HziAz+shXyhW6djf/i9EoYB+/BbkwYP2PkbgTa+pM3COVv/JjxGVCorfj1BUZKmIks/jmp+n8vzn4TlxAuIJY+tKhfKtz8YZ0JNgB1gloCqCjlAHHWYguVQqkkgkyeVynOnspO81r6H74gXc0Rj6bbcZJC1qMxrOe4l0OBvW97qO8vDDiPk5xIaNVI4erS3wMjdtlWK1PAWXy0W3mX2QEiNYm0oxPDwMUC1/DwYNw68qTe4l9EaunOS0Ejn9np4etmzZsuJj3nbbbfzXf/1XI6Wo90sp/xNACPF+jAbC/7bKIV8xnhRGIpvN2hJ1q2FPOmHFHw4ePEjUfLBnk7kmdRiKndbErKso5AsMDg6ycWPjbmLGI2dGKuueP12XjFy6iKbrHDhwEEWpqjKpCwu4/r//iSwWUV0u1J8+QOWtv4F+w43mWMwAG5YHVk1Hzs3NEkIQDvhRiiWkRzUW4KoLZeNGOHAQ7bd/G+U730EiKb3gBeg7dyEqFZOpqRgGsVhEGRxC1TW0XbsgUE3ReTxeent7SadTbNiwgfLWrYzv20c6ncIbXySsaUSikSVLrpo7Y94Sg6Wq4/7oR1F/+lOQJoH6538envmMaoEXgOnV6XZYsfaY1axFNU2tKoJgh+FlDAxsoGJ3UzdKycvlEvPzC0QiUSMlbHIsQOBzq0TW0PezHisxEqtdIn/rW98CONTseyHEGzF6ZbxYrmMF2UpxXZcbllju9PQ03d3dazIQFkV7Zmampp9HoVxmMZNvuI8iRLWHhpQk4nHGLl9m165ddHR0NGXVKapqdORSFJuJWS5XGBwcJBaLMjCwwX6rWofwPv445cQion8DqtsNuSzKl79iG4naawHrdXz58mVKpSI9b34z/OM/IicnIJsBjxftrrvQ9u/HTJsgDx1EAi7T8GlaxVze6OjpFP6/+SCKKeKiRmOU3/dedLNblwWDRFXtVwEGOSqRTHL58iilUplQyEixdnRUC72c3oAuQUxM4n7gp2ixqFleL3F94+uIQwcRjnSrIcBT5Yc43/z1GpTmicyaEGn+Wy7ppn769EnKZaOiVdd1IyUcidDR0UHPOngRsDIjsZ5K2aaE3e8Dz5dS5pbb/mrgunkSFr3a7/eviV4Nxg9WLBZtiTrnWnE6btxPS2+yNhZn5dUdBV4HDuL2uJb61A5IMAOexgNbMMvLN2/ZXGPgpLTWroLNAwPg8lAsl6jkc7iLJYQ/h6yUcbvdS06n6zoXLgzj9/nYvXs3SCj/0ftRzp0DTUc7fhylr7cmJFLlBBjsT6PvijFW5TvfRZmaNMrHkcjFOOLe+9B/9S1m+tWYnI3YJl6vj75eH/29fUahVyZNPB5nbGwMj8drULCjUTwOARhRKqKpLuMeG+4FCAVRKFYNqHWTTCJXbZqylcq12WBIWkaNGj6EEAoDAwM2vT2VSjO/sMDUxBgyFbNJU2tUijLOr+stU/pXgSfx/wFe4Jvmc/tTKeVb1/MEy+GqGYlW6lQWC3P79u0MDAxQKBRW3cXLij+43W727t1bYyAyhRLpfLUjeNXNdeo1GKXqqqraBV6KmQ61+mY4Ry8weAu6LlHVKj17167ddAQD9raWgbAClBy/Bde3/gtXqYxUVaSusfCsZzJ+/jyKEIQjUWKxGIGA0YNjcHCIvt5eenp6bAOibN+Otn27PTmaEb+siksr+yKEgrq4gHB7zECmAJ8XZX4eXZfoegWQuFUVWdOr03nd5lxXDW3KqMkZyBeKpFIJLl26hKZphEJhIpEIHf0DuMMhRCKB3tGBSGdg4wDlSFUotpFUn3VJqjnORpfopJ7X9EEFI9bhuABVdRGLxYjFYmzq6sCNxsLCAmfOnKFSqRCLGUYjEom0ZFDW41o2CwaQUu5at4OtEdfck2hEr14pc9KClZs+cOCA/ZDWnKNOt9IZfBQSCsUShUKB/v5++vr67O2sqk/LuFXF3Iz/VRQFubhI7pOfRB0f58hNx1D27rUDeAjQdM1YbwuzOcyGDZTf/W7Ur34VCgX0Zz+byC3HiSEoaxVTSHWCbDZHuVxmYGCA7u6umkli1FFIQ80bSQPNG/v6rGI0YVGZ9+1D+fGPQdMQiorI59EOH8btdtnZllKlQrlcQuq6LUtvqU7XB/8sqpnP78Pv76e3t98oSktniMcXGctk6LjnHjZ/7Wv4FhaRRw5T/pU3wuKCWWvSuh+GmZxZonkBjbMWlqFoxn71OTIawWDQTlfG43FmZ2cZGjJaHXR1ddX01miGa73ceDLgmhkJi16dzWYb0qtX0jTYyX+4eds2/PffT/HsWcQrXgHPex4A8UyBfKnxsYQQJFMpu5DHaSAaZS2kGZETqkncKZXQ/vt/x5OI443GEN/+DnJuHu2d70QCWqUCCFRFqXnA5datVN761rpjG2+7nu4e3G43+fxltm3bRj6f4+Sp07ZcezQaxev1mm9QwwNq3JmqrlemZSye8xz0qWmUr38dpER/znPQXn674WUYHC6Ghy8Qi3Xi8fqM5ZTUqZjLparBqIWCZbzApapEo1Gi0SiGyniBmS1bSSaT6LpOJJuhVDa6ydkeTQPU1mEYd8ny/Iz/bR7rMoyjXELDbhSLUFW1hpeRz+dZWFhgcHCQUqnUsir0GjYLftLgmiw3isUiJ06coLOzkxtvvLEhvXq5oK3Ff1AUheO7duH59V9HzM3RWSjg+/GPkX/2Z2gvvo2ZRPN2AtMzs0xPT7Nv3z7Onztva0a0WhoJYaQpK+Uy+sULeFIpPBs2Gs9gwIc4fQotmTB6aYrqGlsVZrOdBsdVFDP1CUzPzLC4uMD+/ftxu90IYPNm454lEoY7X6lUiETCtpy7pblQ/6ZtBIlA+4V70F/9aqNeRa3+5OVyyZbsc2Z0jIZCGrqUdgDUGLdxfUJR7IloL4nsJY5R/+CMDSSTKRYWFhgeHiYQDBCNRIhGoiguV425WJq2NJcUpidVm4yu/j6GvF6V7IUEoRh9NJbLaFhVoYFAgM2bN9tVoQsLC1y4cAGv12t7GYFAoO1JXA00a9G3GtTzH5QvfAExM4PctIlKKmUEkz76UWZuuZWypi8JVuq65PLoKMVSya6hkDiqBpu4qgYEuVyOoaEhgn4/HlVBSENGTWq6EbtQVNtAWNDNmEb9ZBZYBkIyOnqZSqXCvn377LJvY5kg8Xq9tly7ruu2/uSlS4ZoSjRqxAc8Hrd5vsajtzIHUlGAKoegUMgzPDzM5s1b7NoE+4qFgtut2DoTullbopszUJG6mbJVTC/DqQNRa3AtMduFhQW2bt1CpVIhkUgyODQEQCQSJhKOEOwIUm8AHANqWbBlGBOH9K2ZcVkLL6K+KtTyMoaHh+3YWTKZxO/3NzQWxWJxvWnZ1x1XzUhIKRkbG2NiYmLN9GqojT/YGYRSyV7TCiHQFYVKqcycSZxyBitL5TLDQ4OEQmG2bttWsxSWstpwplGwUhGwsBjnspkenfL5KO/ahWf4gsHa1DQqL3oRIhjA+dA6PQXnw2092pWKxoULFwgEAmzdusXeVyDsgiVnkZjVFCYajQGSXC5PPB63J1o0GiUWi+Jb0gFrKe1Ll5JMJsPIpQvs2LGTQLCBa+wkTglj+eRyucxgpxHwNIydbldEqqpixgUMunm93ZXmQsIqfd+wweI5JJmbm2FkJIc/ECRqlr5bGQRHj3b7flqZjZolnaxlQq4XL8Lv97Np0yY2bdqErus8+uijpNNGc+Fm2hOrCYSuFEKI3wP+BuiRUs6v+wla4KoZieHhYXK5HMePH18TPdVSspqenq7hPwDoz3gGaiAA8/OolQpKPs/Um3+jtnmOOZmGh4fYtGnTEiVue4ljBtPqg5VSSsYnp4jH4xw4cAC324VwqeTe+jaUBx+A6Wn0HTvg1lup5xs0isFawcdSqWx0Bevvr3Hxhf2GtLaXRrDSonDZX1Xd440bN6JVKsSnpyj/w4dRhwahp4fiG95AcPduXEKgq7U/cSIRZ3x8gj179xmpQLnUiVKgtlemtOIC4HIp6Ho1xWpkczRz2Qa6XjGrWBVUpVqfYiwZaiePwXNwKEblssQTBgVbCGHzHPyBQK1xt5YhVO+PswIUGscirhSKYnhOu3btwuVy1WhP5PN5Pv3pT6OqKul02m4puR4wW/P9HHB53Q66Clw1I7Ft2zYURVkVvdoKUNXEHxo1HN68mcqHP4zykY9QmZgg+YIXsvDSl9dssrho5PN3795lW3lL3Rqs9bVsGKzUdcnopYtoEof+pfGQ6243+ktfalccgvlmU3DENxpfXy6bY/jCBbZv227oEiwTUJBmlyrFfHUujZtIXG4X/Z/5d5STJ5HBAHJ8gsAf/iEVVUUXCqXjNyPf9ja8oTCzs7MsLMyzb98+3K5qC716AljTDl5gGwPzLiKEMXksz0ITRvrX8jLAoIJrutbwWbA8BSEEgWAHgWAHmzZtpFwqkUylmZqeJp/PEwxW1a9V1VWTDhUCoyeK+XuslxfRCE7RGaf2hKZpLC4u8u1vf5uXvOQl7Nu3j3/9139dr9P+HQah6j/X64CrwVUzEh6PZ1XcB6t829KQsOIPzSD37EH74AeZuXSJuUwZv4MgNTExTjKZ4sCBA3jcbtszsN1U3XgotYqG4qk1QAaD8jyxWIyBgQ2ojtZ8AOlMCr/PZ7a4N8eCcUylhYFIxBcZn5hg9+49+Hw+m7ZtLUKasjztZYdcMpkVIdALRdTHH0fGYkZ4pVhCSSZxbdyEHupAefRR5j76UU4//wWoqsq2bdtwuVy1S4EaY9G6w7fTq1EU47qlua9QFFzmBLLK3aXUqWgVSqVygxSrddRaSAkut5ve7i66ujqRElN/IsH09DSKotjLEiNlKdClbpbdy6viRTjRrMDrtttuIxKJ8MADD5DN1ndpXxuEEHcBE1LKJ9ZBpn9NuKrZjdVAVVXm5+cZHh6ujT8sg6ImSeWLBCKCSkVjeHgYj8fD/v37calLJeOtmJdRX1G7Lshmc4Z+xJYtRGJRoLoE0HWdnp4eZmenOX3mdDV4GI06GHjCTsNVJ5PRFzSZSLBv3/4atp5lGFRFNulULhtOZmNymtJsLheoCmhGcx6RzRrRfrfb6O0RDhO5cJHYXXcTiUZZXFjg8ugo/kCj8QO6sGtPnGhE4rKWVYZGZ20w0UqxahXJheGLbNy4EdXlcqRYNdMDU2pUtqv7W42Mjd+qoyNoq1+XSyUSySSTk2aT4Y4OfD4fUkp8btdV8yKWQy6Xs4lUqyFUtSrwAv4QY6lx3fCkKPCyOnhfvHhxSfxhOSxkimiabipYD9Lf10dPr0Fb1m1uQd35AEWotnchcS5PdhNwEGqcDMqOYIDg9h0YgjQ54vE458+fR1EEnbEYkagRPKxOJsmlSyMgJXv27l2yJgerjmRpsLL699Jr1nUjbiABXCqVV78G12c/a3xZKiE8HqTfj5RQSqXR929i+/btKIpCd5fR5i+bzZFIJOzxRyJROjtj5mSrXUJBtTVfI1jcqHpDUi6XGBocZMPGjWbQ1bqnhpehaxUH87OaYq19U9f25ZASPF4PPT3VJsOZTIb5+XlSqTRTo8N4K/10dXWZYsHX7u27VrZlswIvIcRhYDtgeRGbgEeFELdIKaevbLQrx3U3EpbUnaZpHDlyZFUGIpEtUNIMMsy5c+fYvn0H4XDImEANyFEWFGHk+jXNUIOanppiMZ6oWZ6AZSA0O1ZifaYogqAp6rpp0yZKpZKhIzF6mXK5ZBZJhZmeniIcjrBhYKBJdk/WTDxdSpQHforry19BFwL9zjugkQw+tbRk+Yo7KW/ehDI4hAx3oHz/BzA2jhaP41YV3Ht2U9F1Q14f4y0dDBrj37hxI5VKmUQ8wdjlMQrFAqFQiGjUkJNTVaUlFbxKBXGUpWO0TRweGmLrtq2EQrVBPEMrA6SqmhklafwWutHO14j3OFOs5vGlfZbqb6kohMNhFEUh4HVz/Ib9NSnLaDRKV1fXiuTyrxRXgZJ9ErAl3YUQI8DNPzPZjZVY8EKhwOOPP86GDRtaEpoaQUrJdDxLKpUmkYhz6NBhvF4jP60ZG1RLtuv3NSPhmmakIoUQ7N+/D5dFDzdjC04D4ewJYWwi7c88Xg89vb30mL0oFhbmuXDhAqqq4HG7WVhcJBoxRFJqPAVF1GRClEcfxf0PH0Z6Pbg0Df7u7yi9+93oNx6rGb9Tss1gVgrEsWPoZrvA9LOejXjP79ORySCCAcQXvwjz8+i/8ztVspEZD5HS6EvR29dDd08PUuomxTrO+PgYbreHTpP56fF6lngT9R6GlIbmw4ULw+zcsdNoMNQAttK4MFSx3G6zObOuG7ELk8TlTLGCIeUnZdWTsk6t6zpdIR8+n4+NGzeyceNGdF1vSIyyvIzVYrnnM5PJ/MyxLeE6ehL1/IezZ8+uKtA5m8xyfmiYfD5HZ2eXbSDADCBawco63o2lRmWUqV+kp6eXgYGB6sMuDEEazdSgrC4RapcuVubBdrPNz3O5HNPT0+zdu5dgMEg+n2NxMc709DSqqhCLGgVdHnMNXfNW/PZ/IV0uCASM46UzuL79HcrHjtW43M2k5wHS6RTTDzzAvlwWsWHAMHi6RP3pT6m8/pfBjPVYD7wVP7GMlVEuHrZTeMVigXg8zoWLF6hUNGLRKJGoUX4tGiyHMpk0ly5dYveu3fgD5kSsS7PWp3ud41eEMPQyWJpidXoZuullWDkqjyoI15GYFEWxS8mBGvp1sVi0i7yi0eiKuA3L9dy42nL6UsptV+3gLXDNjUQz/sNquniVSiUunDtNVyQIXV0sOLpkWeewIar/IxH2ejweT7BhwwAbNgzY31tvL0ODUtgehdLgobYPb1K7FQHzC4tMTk6yZ89evF4viqiSh6xlSSKR4NLIKJVyiXAkQjQaNWm8AtwekLrJUxCg6+herz0GSb2pqkUimWBsbJx9mzbjVhQjmGhaMQENCRy6tMqsG/dA9fv8ePt99PcP2GzD2dlZLl26RDDgJxLtJBIxyE+JRILx8XH27t2Hz+upMSB22wLZ+hosw2NsryCkI5sgJRVNwzIWNl1cCCJ+F4psXf/jJEZZ9GsrWG4VeXV1dTVd8i5Hyc7lcm1PYjVotNyw4g9CiCX8h5UaiXQ6zYkTJ2ya9+TMPKl41Ug0a/hrTbBFU2CmszNGwKHQZLxNqyXeEmG65XWuSN1RrQzGxOQUyWSSA/v3G+nRBoE+j8dDb2+v2SJPI5lIsrCwwKVLIwSDQXqe+1y6H30EGY8b7rjbjfby24FqMVXt1VQxOzvLwrzBgXBJnUr/AMrEOMLrhUIB7eAh6FyaMap6JrJhsNJ5L1VVdbyZJZlsllQiyfmpKTQzvblz5048HnfDTIixRLPO14Az4fCS7O0VR30Nws7EOL0Mt6rgNmtNNM3gYyznGdTTr3O5nK1uVi6XG5aSPx2Lu+AaehLO+EMjDcvVdPE6evSo/WOEgz42Rn1s7Awxm8xRbnYMCeOTEyQSCfYfOMDs9IzdXUsAFc0ZoHQyKK03mzDfXI7lgTAUri5dGkEI2GtmMCw+RiOdRWM/QFGJdXYSMydcLptl0eth7vWvp/OJJ/D5A7he+nO4t++ojkVYk0c4XHijs3mxUGDvvn32A13+4z/G9ZlPIy6Pwa5daK99rckurYXzrW7xPazfptUbXxGCjmAHHcEOVLeLxYV5Ojv7mJ6eZnRkxOjiHY3aQUUwlmimg2b+3Xws1vYWZV4R2ClR415UiVw+iiwsLHDo0CG7IM3Z9GglRqO+yMtZSu73+20P4+nW4g+ukZFoWH9Rh1ZGQkrJhQsXSCaTS8rMLRJWZ8hPJOhlNpljIZWvyWzouuTihWGEorJ//34j1ebgSWia3tBAGM6EMdGtt5mg6qmUyhWGh4eIRqP09/dX93VOZmonQ+OYgsE2DIY6EJs3U3j+C4jH48TjcSqnThKJRIjFYnQEO+wlkHFgnUsjl1AVFzt37aodezhM5dd/oyaw6AxWNh8L1awJSwOTtftJJiYmyeWy7Nu3H0VRGOjrRZPSDCgnGB83VKyi0SixaBS3I27gNBbNxmJB0xsbl0wqTqGQ5MYbb7SfC2sp4gx8WoZipV5GrcR/zg5+FgoFLly4QHd3N+FwuOZldzU8CSHEbwO/hRGP/7KU8vfX9QQrwFU1ElaR19TU1LL8B0sxux6WzF0gEGjYxctpXFRFYSDWQWeHn+l4hlS+SKlUZmjwPF3d3eZENiCEmQLVNKQ09q1/SI1Scuf1YBePFQt5BoeG2LhxI7FYbV1Itf7DOld1/1Z8AyGNieLzeug3K0A1TTOKoGbnuJS9RCAQNAxGRweT3/8eXckUsZ070LdubfjWr/EU6oKVLeEINipm5kk6vgOjilXTNLP5kGIGfgWqUIg6Ol8VCnkSiYQd/IxGI0SjMTrMyk9Ddk+HlTI9zfHPzc0hCimOP+PmGkKYVWMB2EbCaTQqlYq9zXIGw5kuDoVCzM7OEgqFmJyc5Ny5cwSDQbuUPJvN1jxjVwohxAuBu4CjUsqiEKJ3uX2uBq5qFeipUwaJrGH9RR0aeRK5XI4nnniCrVu3Nm027OzGZcHrVtnaG2F6bpHvnTrBxk1bbAVtY2zG8iEeX8Tr9RIKddgBPCmrb1C9yastnUpxceQSu3fuJBAI1kbuaR65N4Rha5cs9n7O9bhjMmDGAQxDJMlksgZx6HOfY9vXvoZLESiqinju89B/+7drCrOUJm9nQ+/CmJPmfK9B/X7VatQquezixUu43W527NhuX4+1X32PVZ/Pz4YBP/39A7bCtRH8zNhGLxwO46lLEdffF+f4Z2dnyKYSvPwFz2oZJ7CeO2sbayli/e9qliWapuF2u+24kpRGRe3CwgJ//dd/zec//3luvvlm9u7dy0033bQe1aBvA/5KSlkEkFLOLrP9VcFVDVz29fXR09OzIs5EvZGwgkiHDh1aonfQaj8LMzMzXLxwgZc//5kUpcpMIoum6/ZD3tnZhaqqzM7OMjJyiY6ODmKxTqOAyGze22gyLywsMDMzzb69+/B4PHYBli3Q2spTwOgY3kgTodH63yqLVgDNHI/LpZKJL3LDt/8LEepABwqahvKdbzN74434jx4lEg6ZehZKg6Oax0aYupYW36M6HtkkGqHrRsBweGiYYDDIho0ba76v38/JJ7G+cipcW0YvmUwwNTWFqhq9NztjnXjMnqKNRjI9PU0ymeRFzzq2aoJUMy/Deoacgc/6SV7fUVwIYbcr/G//7b+RSCTo7+/nH//xH/m93/s9Dh1qqpK/UuwBniuE+B9AAXi3lPKhKz3oanHVjcRKCVLWZG9VIt7sPM5zWDL9i4uLdvyiA4gGvcwksswljY7iqqI4ypSrBKKxscv4fD5isSixWKf5EBqP6sTEJNlMmr1796I6SrDtzEMLN77eUxAIe3I2e+Nb+2lm8C6TTnPx0iV2DQygArjdCASqG5CSgKYxOzfHyMglo5ltLEYoHFkykQxDZoY9bb6HFY+RTX8zXdcYHByks7OLvr5ecBSmNSPDWcFK2wbVbCIIhzrMmoxqinjUbCcQCoaIdsYIh0M2X2VqapJMJsPhg/vpDF1ZIZfTy3C73baxkGaWxJJUtNr66bre0iiVy2Ve/vKX88xnPnPFY7jtttuYnp7m9OnT9bUb78eYn53AM4HjwGeFEDuude+N607LtuByuahUKpw+fRopJTfffPOK3hJOL8UqMXe5XBw7dqzG6itC0Bv2E/a5mUnmyBZLTQhE0tQJiHP+/CCKgEg0SjqdwePxsHfvXpZyOKvxBuN4zb0Je3uoBkuFbGpdrI8XFxeZmJg0PBi3G31gA+rkBDIUgkIBobroOHKYDntZYhi9iYlJVLeLWLSql9nwPBKUM6dx3/tZZEWj8vM/j/6sZ9vfVyplBs+fp39gg9nnwhhdbVq22TU4jUn1fPV7OVPEUupk0mkW43Euj47i8xs1JVJK9uzZTX90/VONjbwMa2kChuqUJdrcaCmxluyGWbcBjWs33gbcbxqFB4UQOtANzK3qJFeIq2okVkO11jSN+fl5duzYwdatW1ddmFMsFnn88ccZGBhY0mJNSmm/FfxeN9t6I2QKJabiWQp1orlCCGMNvcHPhg0bbOk6RRGUS0XGxsdrgm4W6r2B2mBlq/tgdceuCw46jjkzM0M8vmhwIMwyb/2P3o/4mw8iLlxAdnVRfuc7wQygKkKhoyNER0cINptNdhJxU1m8QiQSWXIN4vx5PP/tvyHLZYQi8J4+TfFdv4t+63MpFosMDw6yactSqTuD6FU1dPVXudTTq94fI37T+K4oikIoHCEUjiClzujICJlcDlVRGB48R1DbBA0yDOuF+lhGKpViZmaGgwcPNo1lXAV9y88DLwS+I4TYA3iAa1q3AU8STyKVStmNerZt27bq/TVN4+GHH2bfvn02OQaoiWpb9RcWOnwedvW7WcwUmE3mjKbCdSgU8ly8eIGtW7cQjcbQdY10KsnM9DSX8jkzjhEjHI4g1No3izUZ6vUomsEODjriG1IaHIhCoWBzMMyjo/f0oP3VXxkefI0bv7Sszev10dc3QF/fALpeMdWfZrh0KUsw2EEsFqXnC/8J83MIkwUmfV7U//wC+ZuPc/78IDt2bDeMTgNIqjL/zvFb3zbcx1x+OJmYTlQvSXL58hgIwaEDB1EUhf6Ij3I+w9jYmK0C1d3dTVdXV8vGOWtFJpPh9OnTHD161Ow5utTLsERn1jkF+n+B/yuEOAWUgF/5mWnztxpMTU1x6dIljh49yrlz51a9/8zMDPl8nltvvbXG1WtlICwIIegK+Yma/IrFdMGerKlUitHREXbuNJStLAJUJNpJNNqJEJBMpozu3OPjeLxeWwLf5XLXjAMaK1Y1WpZUmZWS4QsXcblc7KrjQFhd0Y2tcJC3ar+rh1GKbTTg7enqsvUu4/E4nT/9KaqmG5oUAIUCcmGRwcFB9pjqXo0OuzQTYnoJiukZNfMUrEyIrAY3dYeXYfEwRkZGEEIxXx4Cj1ulK9IBkQ76+/uRUpJMJpmfn2dkZMRoMGxyHNaD2JTNZjl58iSHDx+2j9coY/LDH/6QkZGRda00lVKWgNev2wHXiOtmJKSUDA0NkclkuOWWW1ZVu2Htf/HiReLxOMFgsEZodyUGwgknv2IqnuHS2AQzM7OGzJvbg8mOqB4f4+EOR8KEwmEEklw+TzyeYHBwCCEscdoYfp/f3rfWxZZNeQFWd/No1Cgzr52cSyeenbaFlssa621fTfMKwqEQHR0deNxuo/mP1W1dl8zHYmzauAm/31+d/NQahUZns2IHguZpWGcmxFks52BFmGlWl6lQZtyr3nBtsFIIYYvn7Nq1i0KhwPz8PENDQxQKBWKxmN1ndrUpyWw2y4kTJzh8+HBLD+Ghhx7ife97Hw899NCaG14/mXHVYxKNUKlUOHHiBB0dHTV9OFYTvzh16hQej4djx47xwAMP2EFAyw10lnivFB6XQiU1h0/Pc+ORQ5Q0awnQWPzF4FsA0hCn9fsDRmfushGlN5r+lqqMyY4OpJkChcbHLJdLDA8O0dtvCKfo0lnVasQbmhebsWR7C/Vl6db4JeaSaNculGwOoVWQmoauqLie9zxmE3HGJ8bp6OggGo0SiUQNgVtwpE6XwukpLGkr0DQTYngVUjcYtl6fj02bNmIZCJ/HRSTYWnXK5/PVFHHF43Hm5uYYHBwkEAjYXsZy/UBXaiAeffRR3vnOd/Kf//mfLeUWn8q45p5ENpvliSeesPuArhaFQoEnnnjCrgGBavpUCGEHKFf71rAyIz6fj2febOgyGPGKrNmBvIGxMVOJliakVVzmdhv6Er29PWiaJJlMMDtr9Mzo6OggGosRDYeNSLljrhQKeYaGhti6davd2Rtq4xWaNPqKNByLRSGXTuMm7XE2vAYkuhTov/M7eP7wD6ksxtErZcTznkfHHS8npKhIJOm0QbOemJjA7fYQi0bo7OzE5W7cY8JpAurbCrSC1CVDw0MEgx1s2rTB1tCEpV7EcqinV2ezBhHt5MmThv5EVxc9PT2EQqGal0kul+PkyZMcOnSopYF44okn+M3f/E3uu+++NcXSnioQK3h7rzlQUqlUapYQ8/PznD9/vilB6sc//jHPfvazl3xuIZlMcurUqSUBykceeaTaAWuV3gNgi+8ODAywadOmmu80TWc2lWMhnV9RTMGKD1iTrxbVGEAymcTj8RKLRemMdZLL5xgZGWH3rt34mgiiWIzQRsVjilktWY9qvKKxkXBWzU5fvkxp8Dxb9+xFbt5sivYsHUehUCCZiBNPJNA03aRZR801u2haiQsGMYwGxXJgELWGhoYJh8N1FHqDRbt7oJb+fiUol8ssLCwwPz9vBz97enrw+XycOXOGgwcPtsxUnD59mre85S189rOfZd++fesxpPVP0awTrslyw+rhOTs7y80337ym1u9WBWh9ox9rWTE3N0d/f/+qo9uZTIZTp06xe/fuGsNjQVWteIWPqXiWdL5kXltjLoTzo6VutcHQ6+gIsXmz4TnE43FOnzlDqVSkv6+/5aPiVKOyyE82KapJsNIKf9Rvbw4Hq2nO+Pg4hVKJnS9+MVIo5lu/sWHx+bz4+wfoM2nWyWSS6elp8rkcQUfGp5E3JwUm01PUxDd0XWdocJBYZye9vbUlClJCX2R9qyvdbjf9/f01wc+pqSkmJyfp6OggHo+jqmrDplLnzp3jLW95C5/61KfWy0A8qXFVPQlN0yiVSpw+fRohBAcOHGi5DPjxj3/Ms571rBpPwFkBeuTIkZoKUCtAmclkmJqaYmFhAZ/PR29vL93d3cu2W1tYWGBoaGhZt9KJdL7EdCJLqVxpnuMXomaJ4FyP1wfyLA7Etm3byJiduYvFEpFoNY7R6u28XE/Q+vM5t7eYlyMjI4Bg27atVOswTOm/OvJTo2NakFInl8myGF8kmUoZy5JYjFgsitvtaVpRqmkaQ4ODdHV30929tBWkz+Ni98DVDQharSSNRkxu5ufnmZ+fp1gs0tnZSXd3N6FQiNHRUV7/+tfziU98gqNHj67nEJ60nsRVNRLZbJZHHnmE/v5+tmzZsuwy4IEHHuCmm26yvQFN0zh58iRer9fsl1lrPBoFKLPZLLOzs8zPz6Moiq2qXK9pOD4+ztTUFEeOHFm1ZyOlbMqvaOZhGLJ5zkpHo0K2WCyyc+dOs6OY8Y3Bx0ixsLBINmdyGaJRIg1k1qzzNQpWtoJT49Pn89cECA0lq9r+G9UeG60aEFW/U4Qgm8+RTCRI1CxLYgQdbRErlYqtct7V1dXwYdvaEyZ8FWXyLa2T/fv3L1kGW/yHyclJ3vCGN5DP5/m1X/s13va2ty3xeK4QT08jsbi4SKFQaOjGN8LDDz/M4cOH8Xq99g9nRaprBuRgULbyTAqFAnNzc8zNzVGpVOju7qanp4epqSkKhQIHDx68ory2puvMJHIsZvIOT6F1xB+MyXnx0iVcLpfdC9TZP9SC9dSkM2k7juF2e+jsNPgYbrengadg6WS0jg1IqXP+/CCdsSi9fX04n9FWtSSqItHs8tG68TYwkBZZSq9UWIwbBiOfz5mFUWGmp6fZuGGAqM0WrT331fYiWhkIJ8bGxrjnnnt473vfaxPc/uRP/mQ9h/L0NBK6rlMul1e8/WOPPcbevXspl8ucOnWK/fv3L+nhabHcVhugLJfLzM7OcuHCBaSU9Pf309vbSzQavWJab7FcYSqeJVMoNa8ANSeQpmkMDw0RjUbo66/qaza7yYZdMWIDUlbjGIlEAikhamYZjEK4RnyMpdC0MufPDdLb10t3d48Z3KwalKbjMT0MEA2OX+3LufTaq+MHw0AlEgkuXRpBURSCgQDRWNQ2fNXx6GztiVw1L8IyEPv27auREqjH5OQk99xzD//wD//Ac5/73KsyFtpGYmU4ceIEoVCI6elpjh49ekUEqXoUi0WeeOIJNm3aRF9fH4uLi8zNzZFMJolEIvT09NDZ2XlFnkU6X2QqnqVYXkoKUwQUSyUGB4foNzkQdkEYy/MNYGlxlFapEE8YClbFYpFwOEIsZgjrKsIqd699u5fLJYbOD7JhU23DHOP4AiF0dL3xva33TJzGqFl2xXkNFlmqVCpy/vwgmzdvJhaNmEQ0w/DpurSJaLFIiD0b1i+j4USxWLRfSq0IUNPT09xzzz38zd/8DS984QuvylhMPD2NhJSSUqm04m1/8pOfoCgKN99885J2eFYZ72qbEIMhnnvq1Cn27t27xDOxItuzs7MsLi4SCATo6emhu7u7Jki6UkgpWUgXmEtV4xVCGIGx4eFhtmzZWtNxWojq5FtJihWsZUsdHVrXSaWSxONxW9o9FosRiURxuRSkDvlCgeGhIbZs2UK4iWttTPylxWaN4hT2eDCzFst4UWCkm4cGz7Nlq9G0pz4DVKlUSCQSJBJxQi6djb1dtgFfBxEXoFoMuGfPnpYGYm5ujle96lV84AMf4Od+7qp32msbiVawApS5XI49e/bQ3d1dc4y1MigBWzLdyb1vNV5n4NPlctmBz9V0FoPaeIWtA7FrF35/Pa2YunhGlT/QKjZQNRRL05RCYOpjLJJMpnC73QQCAeLxRXbt3Ekg2DiTUx8XcRZfLTcWvck2Tu+jWCwyNDTItm3b6OgI2UpXjR5Bn8fFzr4IiUSCubk54vE4fr/fjistl7lqhlKpxGOPPcbu3buXvDCcWFhY4NWvfjV/8id/wstf/vKm260j2kaiGZwBynw+TyQSsaPGV2ogxsbGmJmZ4ciRI2t6qPL5vB341HWd7u5uent7V1U4NDYxxaNnhti0beeSMTSaVM5LXMmbuUqWqv5dv9vCwgKXL4/i9nhQhTAYn9Go3ZG7/pi155JmFXjjeAN12Q4BDXuIFgqGJ7V9+w77/llehN2g2HGC+oyGkzE5N2fIKVhsSqtR0HJYqYFIJBK86lWv4n3vex933333ssddJ7SNRCNYDEpLRfvixYv4/X4GBgbWHKC0zjs4OEi5XF6Wm7FSlEol5ufnmZ2dtTM2vb29LfUMxsbGmJ2d5ciRIxQq+pJ4RbOJaX1nXMvS71oZl/qAotUwZ8+ePfh8HkqlMolEgng8TqlYpCMUprMzRjgUaiimY51PNjg2LPU+nOMRwvgunze6tVsVtdVrkIjJKcjnYctmhMdo6LOSjIb1e8zPz5PNZonFYvT09DQt5LIMxK5du1pm21KpFK9+9at55zvfyT333NNyDOuMp6eRABoqYINRIj4yMlIToBwdHUVVVQYGBtZsICqVCqdOnSIUCrFjx46rIkiiaRoLCwvMzs6STqeJRqP09vbaD6iUkuHhYfL5PIcOHXL0najGKzRNbyF1V12nLy2Oak2cEkKgXx5F/fFPyJTKjO7cwc7jx3G73EvOp+s66XSaxYUF0tkMwYAVx1gqeec8h/3SbxGnsMaay+W4MDzMzrqllpAS9S//EtePfgiKioyEKf3t30F/H5u7wssWctVfh1XIFY/Ha+JKHo+HUqnE448/zs6dO1saiEwmwz333MNv/MZv8Iu/+IsrPv864elrJEqlUk1gyppA6XSaI0eO1AQox8fHKZfLbNq0aU0GolAocOLECTZv3rym4rG1wGpKOzs7a5etF4tFQqGQKRSz9Boqms5sMstiptDExW/AN7DevE2JTOYEPncez3veA7kcmiJQI1FK/+t/QU93i/2EWcSVIZGIk0gkcbvdxGIxOqNRXA2Waobxaq64pQhIpTOMjFxi167dBAI+u1hLCIHyja/j/ru/M10ggayU0Q8dxvXhv2fXFfAirGXJ3Nwc8/PzSGnIEW7fvt1+rhohl8vxC7/wC7zhDW/gjW9845rPfwVoGwmo7aGxZ8+eJQzKeDzO6dOnCYfD9PX1rSolmUqlOH36NPv27btuNf3lcpnHHnsMl8tFuVzG4/HYgc9GrM5iucJkPEsmX12StRTFpVacpeY707C43/1uOHkC6XKjqgqiUES/+y5Kv/lbjY/pjG8IiRCGaE2hUCBhpiU1XScajdLZGavGMcz0p5G+rS/WMgrZRkZG2L17T821W56R+pGP4Prs58D6TteRwSD93/vGuvEiyuUyjzzyCLFYjEKhQC6Xa7gsyefzvO51r+M1r3kNv/Zrv3ZVvM8V4ElrJK5ZqXg+n+fxxx9ny5YtbKyXYjcDlKFQiGc+85l2X4bhYUO63arFaFa8NTs7a7f/a1SQcy1geTFbt26lr68PMN5Oc3NznDx5EiklPT099Pb22mP0ul1s743U8CtaWmTTQDSPV0jK8/O4EKgu1SRiCUQq1SIwWf3caKtn1GsE/D4C/g30DwzYacmJiQny+TzhcITOzpgZMKympK3jpNNpRkdH2bNn75JgrSU2I7ZtB48bK9ohdQ3v1k3raiCsJUZPj1EP4lyWDA4Okk6nOX/+PN/5zne46667rqeBeFLjqnsS5XKZxcVFTp8+3bDNn1MnsD7gZDU/mZ2dZW5uDq/XS19fn73WtOT35+fnlxR/XUtkMhlOnjzZkIdhoVQqMTc3x+zsLKVSyQ58WloGRrwiz2wyh9bAVVguWGn1JO356lfp+cpX7NkvkBTf/0foz372ErHdlkxPR7zBuY2UOslkikQiTjqdtpvrGJ3FVZIJo7P5nr17TFWvpceVEpA6nr/8S5Qf/hBUFzISZuBjHyG0e8eSfVaLSqXCY489xtatW5vWV1jB7Xe9611cvnyZTZs28Qd/8Ae87GUvu+LzrxFPWut01Y3EyMgIIyMj3HDDDTVFVmthUFochrm5OVva3Ov11gQHrzUSiQRnz55dVsHIiUqlYgc+M5kMsVjMpojrkobxilYBS6nrDA0N0REKsaGvD9fHPob6ta+By4X2+tdTueOOmu0tsVplhUzPJfUhNrtSks3miMcXSSSSgFFTs3fvXgL+QAPl7PprMLIbSi6He9d2dm+98hZ5loHYsmWL7dE1Qrlc5s1vfjPHjx/nve99L3Nzc+TzebZu3XrFYwAjs/WGN7yBmZkZhBD8+q//Ou94xzta7fL0NRKjo6NLlgpXSrG2HgSXy2XzKOpd+WsBo1WdIeK7WrKVBcsFnp2dJZFIEAqFDC5GKMJsukAmX1rWQJwfPE9nZyf9fX1LZP2bBitbEJkaeRgW/0HTpBnorIXRF2Scrq5uUqkkmqYZvT5iUfM3ES3Hsx6VnpVKhccff5zNmze3NBCVSoVf//Vf58CBA/zxH//xVVliTE1NMTU1xbFjx0in09x00018/vOf58CBA812efoaiXp1qislSOXzeU6cOMG2bdvsB6FUKjE7O8vs7Czlctk2GMFg8KqtMS9fvszc3Ny6LnOklHY8xtLGCIRjlFUfOks9JaNhziD9AwP2MscZr2idLm2uF7HcMkRSu4FBcJpl3969CEU1x1alV+fzBcLhELFYJ6GQEcdwwu9xXVFGwzqfRcpr1bRX0zR+67d+i82bN/MXf/EX1ywGcdddd/H2t7+dl7zkJc02aRsJuHIDkUwmOXPmDAcOHGha1lsul23SUz6fXxHpaTWwUrhWqfnVXOY4l1eZkg7eDsIRowuXVQOxafPShjkAqmr17lx63GbiLxaWfySq21sGbc+ePaiq2nBfKXUyqRSL8QSpdAq/P2C3H1BV9Yq9CE3TePzxx9mwYUPL1Leu67zzne8kFovx13/919dsiToyMsLznvc8Tp06VVO3U4e2kVipBkQzzMzMMDIywpEjR5YIyDRDPekpFovR19e35vJwXdc5ffo0Xq+X3bt3X9NIeKFQYGpmhsHRSRZSOcqlMlu2bjHrXJaOwxajaaAn2VIvQoAGDX/1enblzIzRuHfXrl24XGpD5qVzLNa/s5ksi6Y+RsDr5sY9W9ZUHwOrMxDvec97cLvdfOhDH7pmBiKTyfD85z+f97///bzqVa9qtenT10iUy2XK5fIVUaxHR0dZXFzk8OHDa3btdV1ncXGR2dlZuzy8t7d3xdWFlUqFJ554gp6eniVtBK8lUqkUjz5+AjUYZT6RolAo1JSIN1r7C/P/LbcEsZYZ9foPsHS/6ekpUqk0u3fvMshRdiFXc4PlhLV9b8hDMZNkbm4OTdNsz28l9RiapvHEE0/Q39/Phg0bmm6n6zrvf//7KRaL/OM//uM1MxDlcpk77riDl770pbzrXe9abvOnr5H4l3/5F3bt2sXRo0dXrdWg6zpnz55FCMG+ffvW7ceVUtosSas1m8XFaDTGRhyI64HFRaOj1tGjR/H7/aTzRSYW0swtLNol4h0dHXY38UZSd8jaRkNOtNSLcHw3OTlJLpdl586dCKHYHoagttjMOGZzr6U+FmEpWM/NzdlZn2b1GJaB6OvrW8K7cUJKyZ/+6Z+ysLDAP//zP69rh61WkFLyK7/yK3R2dvKhD31oJbs8fY3E/fffz6c//WkGBwd50YtexN13381NN9207IQvl8ucOHGC7u7uFeljrhX1wUK/328bDLfbbatpLydOcrVhZVJuuOGGGgZjLb/CEAVeXIyTSiXx+XxEo1brQVe1pNvWq6xiuZoQo17D6E1aLJbYsWO7GYCU5r6i5ljG2Foft1Usor4ewyLVdXV1oSjKig3EBz7wAUZHR/mXf/mXa2YgAH74wx/y3Oc+l8OHD9vP+l/+5V9y++23N9vl6WskLORyOb761a9y3333cfLkSZ7//Odz991384xnPGPJj5fL5Thx4gQ7duxYb7HRlqjXk5BSUiwWOXz48HU1EJOTk0xOTnL06NGmyy2rHiSeKdhtBHO5quKTqqp0xmJEYzGbBemMVyyrF6Ebwr2VSoXtO7ZT1bxowbVQJFJvXGK+moyGk1Q3Pz9PPp+ns7OT3bt3N41PSSn54Ac/yJkzZ/jkJz95VRoJrzPaRsKJQqHAN7/5Te69914eeeQRbr31Vu6++25uvfVWHnvsMUqlEocPH24VCb7qMLpuX6K7u5t4PI4Qgt7e3obK21cTVjzmyJEjK3oTFkoVpuIZMoVa2cBSschiPE4iEbcl4jo7jV6l0CLliTHhRkZHAdi2dSuKapKphFi2ClTKRp3G18aL0HWdJ554gkgkgtvttgWO6ztxSSn58Ic/zEMPPcRnPvOZ68bEXSXaRqIZSqUS3/72t7nvvvv4xje+gaqq/Pmf/zl33HHHmtWHrhSNOBDFYtHmYmiaVsPFuBqw+o3k8/nVpVo1DTE5SdLjZ6qiUKoY6Wen21+pGJoSi4txSqUi0YghphswO3A5oQi4cPEiqupiy5Zq416Ltr20S1l1v3pilxXfWAsvQtd1Tpw4QVdXV03PzXr26n/8x3/Ywe7777//uj1Da0DbSCyHj3zkI3zxi1/krW99K1/+8pf5wQ9+wI033sjdd9/Ni170ojV1/VotrE7nxWKx5cQsl8t2HUahUKC7u5u+vr4VKyStZBznzp0DWNJvpBXEyAje229HzM+DplF63x8w8xu/aeptNv4ZdamRTCRZXIyTy2UJh0JEYzHbi7t48SJeb23jXuNkZlWqqVjViHfRjKOxFr2IkydPEovFWmaWNE3jT//0T/nqV7+K2+3mxhtv5GMf+9hTpWjrSTvIJ42RmJmZqckuaJrGj370I+69916+853vcPDgQe6++25uu+22q0K9tjgQPp+PXbt2rfjBst5kMzMzZLNZO4UXiUTWxsWYmWH83ntxd3bSf889iFWspX3PehbizBnjDynB56N4332Unn2rXQ/C2DjqD74PLheV225D6ex0tA/USaczLC4ukkmn0CoVgqEw27dvX7LUadTvo9r5vHmcYrVehGUgotHosnUVH//4x7nvvvv4whe+gM/n4/Lly+tWiwHw5je/mS996Uv09vZy6tSpdTuuibaRuBLous6DDz7I5z73Ob71rW+xa9cuXvnKV/JzP/dzKy6qagUrk3KlHAir29Ps7CypVGqJYtVykI8/jvelL0VgKFDrR45Q/PKXYYUusz8WA02rphdcLsp/9mdU3v52AEoPPsz8a3+ZrFSMWe71Ufz4vyJ76ntv6gwODeLz+lBVtVaEpjOGy+02dS9rYaRAGyhtO7CaWISu6zZLcbmu3Z/+9Kf55Cc/yZe+9KWrtgT8/ve/T0dHB294wxvaRqIO191IOKHrOo899hj33nsvX/va19iyZQuveMUruP3221t2YGqGq8WBqFesCofDNnmrUQCyXC6j3nwzwQsXqr6630/5r/6KylvesqJz+vbtQ0xMVKu3/H5KH/0o2p13AuB9yUtQf/xjkm4fU8EoJdVN+e67qfze79WMe2hoiFg0Qm+fUQMhhKCQz7MYXyQeTyCQRGMxYrHOJSxJy6OApcuN1XgRloEIhUJs37695bb33Xcf//zP/8yXv/zllp3A1wMjIyPccccdTysj8aTPC9VDURRuuukmbrrpJv7H//gfnDp1invvvZc77riDvr4+XvGKV3DHHXe0VEO2cDU5EIqi0NnZSWdnJ87eHo2EdKw+EM+bn68eQAjI5xEjIys+Z+lf/xXv3XcbRqJSQXvZy9AcZeJicRGASLlAODHNvK+DyWSCivm9rusMDp43swVV70JKidfnY+OGjQwMbKBcLhGPJxgdHaVcLhONRojFOgkGA0v0OHH83RtZ2TJRSsnp06dXZCC+8IUv8E//9E/XxEA8XfGUMxJOKIrCkSNHOHLkCH/2Z3/GuXPnuPfee3n1q19NJBLhFa94BXfeeSfd3d1L4gPxeJzz58+vqqP4WiGEIBo12tg5c/6W8G8+n2fv3r1w003w/e+DWeNCIIB+/PiKz6M/4xnkH38c5YknoKsL/dixmsqtyitegfvyZUQuhwC6FZ3A7S9issPHXDLL4OB5enp66Wmih6lLiSoEisdDb18vvb29aJpGMpk0+qvmc6b6tlHtiVm5qghDhWslywzLQASDwWUNxFe/+lU+9KEP8ZWvfKVlm742rgxPueXGSmClD++9916+8IUv4PV6ecUrXsFdd91FX18fJ06coFgscuTIkTXrQKwH0um0ndZLpVL4UilueO978V66BLpO5bd/m/Kf/3ltieaVoFLB/Z734PrUp4x4xe//PpV3vINyucyDDz+KJ9yNvyPc8gev1ndUU5o2pE4ylSYeX7RVqzo7jS5iO/qjhPytjYSUkjNnzuDz+di5c2fLbb/1rW/xF3/xF3zlK1+paeZ0tfF0XG78TBoJJ6yc+X333cfnP/95EokEbrebT37yk2zduvW6pccSiQTnzp2r6SxWKBSYnZkhPjRExeOha8uWqy6kY8nNb9++nZ6eHpK5AtPxnM2vcGI1/T4MMdws8fgi+Uyanf1Re4nViLtgGQiv12vWhDT/Xb73ve/xx3/8x3z5y1++5rU0bSPRGE9pI+HE+9//fs6ePctznvMcvvjFL1IsFrnjjju466672LZt2zUzGFbrwRtuuKGpJ1OviWlxMdZTSMeKhdQ3rJFSMp/KG/1BmnG1HTAa8ZhZjQabb+sNo+iVGulBS0Xc7/cjpeTs2bO43e5l088/+tGPeO9738uXvvSllpWfVwOve93r+O53v8v8/Dx9fX382Z/9GW9ZYVB5BWgbiScDHn/8cY4cOWI30JmdneU//uM/uP/++0kkEtx+++3cfffdV1UrYnp6msuXL3PDDTesmA14NYR0rPaKe/bsaRrkLWsas4kci5lC005dsLTzuVO5qlFGo1Ao2O0Tra7zHR0d7N+/v2Wq+IEHHuB3f/d3+eIXv1jDuvwZQdtIPNmxsLDA5z//ee677z5mZ2d56Utfyitf+Ur279+/bgZjfHycmZkZjh49uuaCo0ZCOhYXY6XjzOfzPPHEE+zbt29FAb9m9SAGljYMcsYrtvWGm8YirCVGqVRCURRyuZxdh1EvDPTII4/w9re/nf/8z/9cljPxFEXbSDyVkEgk+MIXvsD999/P6OgoL3nJS3jlK19ZU/a7GkgpGRkZIZVKcejQoXUrWbbKqWdmZlYspGNV2O7fv3/VvJJUzugP4oxXtKoeDXpd7OhvnFqWUnL+/HmEEHajpnoyWiQSYXJyklAoxDve8Q7uv/9+du3ataoxP4XQNhJPVaRSKb785S9z//33Mzg4yItf/GLuvvtujh07tjIWpVkPUi6Xl3WnrwQrEdKx+oMcOnRozZyC2niFbtduNEIzL8LqeSGlbNoK0bqe97znPXz961/nlltu4Zd/+Zd57Wtfe93aJ1xltI3EzwLqNTFe8IIXcNdddzXUxICqspbb7b6mmphSStLptK2/4Pf7CYVCTE9Pc+TIkfWhsjviFY3QjF1pGU1d15saCAvnzp3jjW98I5/61KfQdZ3vfve7/M7v/M4Vj92Jr33ta7zjHe9A0zR+9Vd/lfe9733revxVoG0kftZgaWJ87nOf49FHH+U5z3kOd999N89+9rNxuVxUKhW7r+m1zJw0wszMDOfOncPj8eD1em1djPWorM2XykwtZskWa+MVjbwIS2m8UqksW906NDTEL//yL/OJT3yCo0ePXvE4G0HTNPbs2cM3v/lNNm3axPHjx/n0pz/dqjfG1UTbSPwsw9LEuPfee/npT3/KsWPHOHnyJH/913/Nc57znOs6NouPYeli5vN5WxdDCGHrYlypkE4yW2Q6kaFU0Rt6EZaBsJZdrQzEyMgIr33ta/nYxz7GTTfddEXjaoWf/OQn/Omf/ilf//rXAfjABz4AwB/8wR9ctXO2wJPWSFwXWvZ73vMevvjFL+LxeNi5cycf+9jHntK0Wo/Hw8te9jJe9rKXMTU1xUte8hK2bt3Ku971Lo4dO8bdd9/NC1/4wv9/e2cfFHXVt/HPj8BNMzEjMNBsEHzSGIEBcrVU4g6MMUGRCLCBRppifBl3vLOXO5uRadRMyx4HG6snx56x1AGxQIkYmEHv/kCnHDOxFwiUt0UXlOEdhD33H7g7y62toLv8lt3zmdmZfWHZC2b32u8553uuMyqZGJaYWs8t+zHGjx/PjBkzmDFjhjlI5+LFi/ccpOP5gIZJE8bR3NbN/eOGvq1MHbB9fX3MmTPHqkHU1dWRmprKF198YVeDAGhoaBiylDpt2jROnz5t19cci6gyAxQdHc2FCxc4f/48s2bNMju4M1BZWclHH33EiRMn+OWXX8jIyKCsrIxFixaRkZFBQUEB3d3ddtfR0tLCn3/+SWho6N82bGk0GqZPn05YWBihoaFoNBoqKyspLy+nqqqKtrY2hlFpmlEUhUc8J/Dg+KH9H9XV1fT29t7RIBobG0lOTiY7O5t58+YN+3Ul9kWVSiImJsZ8XavVkpubq4YMu7Bo0SLz9fvuu4/FixezePFijEYj5eXlHD16lG3bthEYGMiKFSuIjo62+QYzg8FATU0NoaGhw27Y8vDwwNfXF19fX3OQzqVLl+js7GTKlCn4+PjcVZBOdXW1OYLP2nObmppISkri448/HrUhmp+fH3V1debb9fX1VtO3XRXV5ySWLVvGSy+9xMsvv2zPl3EoTJkYOTk5FBUV8fjjj5szMe41/Ne0uzQkJMQmAbD3EqRTU1NDR0cHQUFBVg3CYDCQkJDA9u3bh3yB2Jv+/n5mzZpFaWkpfn5+RERE8M033/Dkk0+OmgYLHHZOwm4m8dxzz9HU1HTL/Vu3biU+Pt58/aeffiIvL2+s5BDaHFO4Sk5ODt9///2QTIyRZlw0NTVRV1dnM4O4nVbLIB3TCegPP/zwLUvANTU1tLe3ExQUZNVMWlpaSEhIYMuWLSxdutTmmu9EYWEhOp2OgYEBVq9ezbvvvjvqGm7isB8A1SqJAwcO8Nlnn1FaWmrXXY5jCdNGp9zcXE6cOIGnpyfx8fG88MILPPLII1af29jYiF6vv6eW75FqbWtr48qVK7S0tAwJ0qmvrzd3l1oziNbWVhISEnj77bdZvny53TU7ONIkLCkqKmLjxo2cPHnyjm9+V8W0ZGgZ7BoXF0dcXBw+Pj5DKq/6+nquXr16V0cp2kqrKUinoaEBIQQzZ87E29v7b+dE2traWLlyJTqdjhdffHGUFTsk0iQsCQgIoLe317w9WavVsm/fPlu/jNNgmYlx7Ngx3NzcWLZsGcuXL6egoIDg4GCeeuopVQzCktraWq5fv87MmTNpbm7GYDDg5uZmbt4yrbJ0dHSQmJhIZmYmqampqmp2IKRJjDY5OTls2bKF3377jTNnzhAeHq62JJsghKCxsZGjR4+yZ88ePDw8SE1NZeXKlaqG6NTW1ppPGrMcYvT09JhzJKqrqzl37hw///wzGRkZpKenq6LVVgghbPn/dliTcMqdMgBBQUHk5eUNWZJ0BhRFwc/PD09PT+bPn09JSQleXl5s2LCBqKgodu7cSWVl5Yj6G+6Vuro6WlpabjEIgPvvv5/HHnuMsLAwtFotv/76K62trXz66accOXJk1DTaAr1ez6FDh4DBSVyTQTQ1NaHX69WUZlectpIwERkZya5du5ymkjDR1dWFRqMZMsRobm7m22+/JS8vD4PBwPPPP098fLxNMzH+m/r6egwGA8HBwVYnKXt7e1m1ahVLly5lzZo1tLW10dLSgr+/v110ge2qSVPFsHv3bpqbm9m6dav5sYMHD1JeXk5fXx+bNm0iMDDwbuXKSkJiWyZMmHDLHISXlxevvvoqhYWFFBcXExgYyPvvv8/ChQvJysri/PnzN08Rtw2mCdPbVRCW9PX1kZ6eTnR0NGvWrEFRFDw9Pe1qEGC7atJksI8++iiVlZXm+ysqKsx7dObNm+e0q3RjOlJ/OL0YrspDDz1EWloaaWlp5kyMXbt2UVVVZc7ECA0NvetshoaGhmGtqNy4cYOMjAyefvppdDrdqM6ZzJ49+55/R1dXFwcPHiQ5ORlfX186OjrMj3l5ebF582YeeOABNBoNV69epaysjMjISKfq3BzTJlFSUqK2hDHBpEmTSElJISUlha6uLgoLC9m7dy8XL140Z2KMZHWksbHRHMNn7Tn9/f28/vrrBAcH8+abb47JhrmTJ09y6tQp9u3bR3R0NNeuDR4X8OCDD+Lj48PAwGBK17Vr19DpdKSlpTmVQcAYNwnJyJkwYQKJiYkkJibS09NDcXExX331FTqdjmeeeYb4+HhzJsbt0Ov16PV6QkJCrBrEwMAAa9euJSAggPfee89uBmHvajI2NpbY2FhKSkro7Oxk586dbNy4kUmTJrF582bc3Nzw9PRk8uTJREZGmtOzbbzyoSpOO3F57Ngx1q9fj8FgYPLkyYSEhJhzAyS30tfXR2lpKbm5uZw+fRqtVsvy5ctZuHChucVbr9fT2Nh4R4MwGo1s2LCBKVOmsGPHDtXj5u5l8tpoNJr1G41Gnn32WVJSUvj999+5cOECU6dOZe/evfT29uLt7X3Lc0aAwzqK05qEPXGgyDO7cOPGDU6dOkVOTg4//vgjYWFheHl50d3dzQcffGC17dtoNPLGG2+g0WjYvXu36gYBtl3h0ul0LFmyhNjYWM6dO8fEiROHhPPeQwXhsCZx80AVqxeJBf39/cLf31/89ddfore3V8ydO1dUVFSoLctu9Pf3iy1btojp06eL4OBgkZKSIo4cOSKam5tFZ2fnkEt7e7tYv369yMzMFAMDA2pLF3l5ecLPz0+MGzdOeHt7i5iYmLv+XUajUQghxNq1a0VWVpatJFoynM+iKhf1bX6McebMGQICAvD392fcuHEkJyfz3XffqS3LbhiNRi5fvkxFRQVnz55l3bp1lJeXExUVRXp6OseOHaOzsxOj0UhWVhadnZ1kZ2c7RAWxYsUK6uvr6e3t5cqVKzYZbkZERDjE3zaayInLEeJqkWceHh7s37/ffHvBggUsWLAAo9HI2bNnycnJYdeuXeZousOHD6u+h8QemIYQGo1mVA8odgSkSUjuCjc3N8LDwwkPD2f79u0UFBQQExPjlAZhSXJystoSRh1pEiNERp7dipubm8s3rzkzrjW4sgERERFUVlZSU1NDX18fhw8fJi4uTm1ZEondkCYxQtzd3cnOzmbJkiXMnj2bpKQktTIRXY5NmzbxxBNPMHfuXFasWEFra6vaklwC2SchGTMUFxcTFRWFu7s7b731FgA7duxQWZXNcNg+CVlJODCrV6/G29uboKAgtaU4BDExMeZGLq1WS319vcqKXANpEg7MK6+8QlFRkdoyHJL9+/cTGxurtgyXQK5uODCLFi3i0qVLassYVYZ7FIO7uzurVq0abXkuicubRHd3N2VlZYSGhjJ16lS15bg8d9r+f+DAAY4fP05paanT7LJ0dFx6uDEwMMD48ePJz883dxX29PRw+fJllZVJbkdRUREffvgh+fn5TpsC5Yi4tEmYugOvX79ubrV+5513eO2118jLy1NTmuQ2rFu3jvb2dqKjowkJCSEzM1NtSS6Byw83hBAkJSWRn5/Pzp07iYyM5NChQ0yZMkVtaZL/oqqqSm0JLolLVhKWvSHNzc0cP36cH374gW3btrFnzx7zGZy2DI29G1JSUpg/fz5//PEH06ZN48svv1RVj8Q1celmqqKiIj7//HNqa2vRarV88skno3KOpkRyGxx2FnY4JuF0KIryP0ACsAp4C/gV+D8gQQjRoSjKZCAFqAMKhRDqlhR2RlGU6cD/Az4Mfil8LoT4X3VVSRwFlxxuAOGAH/APIcQJ4FFg4k2DcBNCtAK/AxtxjXmbfuCfQog5gBZYqyjKHJU1SRwElzQJIcTXQoh1QogrN+8yAJcURVlgUTV0A+eEEH2Kojj1/0kIoRdCnL15vR34jUETlUhc4lvyFhRFuU8IMWC6LYSoVhTlbaDN4seigO9HXZzKKIryOBAKOG/clmREOPU35N9haRAW99UKIVoVRfFRFGU38ApQffMxp56TMKEoykTgKKATQrTd6eclroFLVhLWEEJcURTlC6AJCAH+UlfR6KAoigeDBvG1EEJ2kknMuOTqhmQoyuAmiK+Aa0IIncpyJA6GNInbcHOicvAwBBdAUZRngH8zuBRsGlr9SwhRqJ4qiaMgTUIikVjFJScuJRLJ8JEmIZFIrCJNQiKRWEWahEQisYo0CYlEYhVpEhKJxCrSJCQSiVWkSUgkEqv8B4wp0jTUHv9GAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "visualize_fun(w, 'Dataset with learned $w$ (Manual GD)')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## torch.nn.Module\n", "\n", "`Module` is PyTorch's way of performing operations on tensors. Modules are implemented as subclasses of the `torch.nn.Module` class. All modules are callable and can be composed together to create complex functions.\n", "\n", "[`torch.nn` docs](https://pytorch.org/docs/stable/nn.html)\n", "\n", "Note: most of the functionality implemented for modules can be accessed in a functional form via `torch.nn.functional`, but these require you to create and manage the weight tensors yourself.\n", "\n", "[`torch.nn.functional` docs](https://pytorch.org/docs/stable/nn.html#torch-nn-functional).\n", "\n", "### Linear Module\n", "The bread and butter of modules is the Linear module which does a linear transformation with a bias. It takes the input and output dimensions as parameters, and creates the weights in the object.\n", "\n", "Unlike how we initialized our $w$ manually, the Linear module automatically initializes the weights randomly. For minimizing non convex loss functions (e.g. training neural networks), initialization is important and can affect results. If training isn't working as well as expected, one thing to try is manually initializing the weights to something different from the default. PyTorch implements some common initializations in `torch.nn.init`.\n", "\n", "[`torch.nn.init` docs](https://pytorch.org/docs/stable/nn.html#torch-nn-init)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "example_tensor torch.Size([2, 3])\n", "transormed torch.Size([2, 4])\n", "\n", "We can see that the weights exist in the background\n", "\n", "W: Parameter containing:\n", "tensor([[ 0.2151, -0.2631, 0.4498],\n", " [-0.3092, 0.3098, -0.4239],\n", " [-0.0499, -0.2222, 0.0085],\n", " [-0.0356, 0.5260, 0.4925]], requires_grad=True)\n", "b: Parameter containing:\n", "tensor([-0.0887, 0.3944, 0.4080, 0.2182], requires_grad=True)\n" ] } ], "source": [ "d_in = 3\n", "d_out = 4\n", "linear_module = nn.Linear(d_in, d_out)\n", "\n", "example_tensor = torch.tensor([[1.,2,3], [4,5,6]])\n", "# applys a linear transformation to the data\n", "transformed = linear_module(example_tensor)\n", "print('example_tensor', example_tensor.shape)\n", "print('transormed', transformed.shape)\n", "print()\n", "print('We can see that the weights exist in the background\\n')\n", "print('W:', linear_module.weight)\n", "print('b:', linear_module.bias)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Activation functions\n", "PyTorch implements a number of activation functions including but not limited to `ReLU`, `Tanh`, and `Sigmoid`. Since they are modules, they need to be instantiated." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "example_tensor tensor([-1., 1., 0.])\n", "activated tensor([0., 1., 0.])\n" ] } ], "source": [ "activation_fn = nn.ReLU() # we instantiate an instance of the ReLU module\n", "example_tensor = torch.tensor([-1.0, 1.0, 0.0])\n", "activated = activation_fn(example_tensor)\n", "print('example_tensor', example_tensor)\n", "print('activated', activated)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Sequential\n", "\n", "Many times, we want to compose Modules together. `torch.nn.Sequential` provides a good interface for composing simple modules." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "transformed torch.Size([2, 1])\n" ] } ], "source": [ "d_in = 3\n", "d_hidden = 4\n", "d_out = 1\n", "model = torch.nn.Sequential(\n", " nn.Linear(d_in, d_hidden),\n", " nn.Tanh(),\n", " nn.Linear(d_hidden, d_out),\n", " nn.Sigmoid()\n", " )\n", "\n", "example_tensor = torch.tensor([[1.,2,3],[4,5,6]])\n", "transformed = model(example_tensor)\n", "print('transformed', transformed.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note: we can access *all* of the parameters (of any `nn.Module`) with the `parameters()` method. " ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Parameter containing:\n", "tensor([[-0.1409, 0.0518, 0.3034],\n", " [ 0.0913, 0.2452, -0.2616],\n", " [ 0.5021, 0.0118, 0.1383],\n", " [ 0.4757, -0.3128, 0.2707]], requires_grad=True)\n", "Parameter containing:\n", "tensor([-0.3952, 0.1285, 0.1777, -0.4675], requires_grad=True)\n", "Parameter containing:\n", "tensor([[ 0.0391, -0.4876, -0.1731, 0.4704]], requires_grad=True)\n", "Parameter containing:\n", "tensor([0.0454], requires_grad=True)\n" ] } ], "source": [ "params = model.parameters()\n", "\n", "for param in params:\n", " print(param)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Loss functions\n", "PyTorch implements many common loss functions including `MSELoss` and `CrossEntropyLoss`." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(0.6667)\n" ] } ], "source": [ "mse_loss_fn = nn.MSELoss()\n", "\n", "input = torch.tensor([[0., 0, 0]])\n", "target = torch.tensor([[1., 0, -1]])\n", "\n", "loss = mse_loss_fn(input, target)\n", "\n", "print(loss)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## torch.optim\n", "PyTorch implements a number of gradient-based optimization methods in `torch.optim`, including Gradient Descent. At the minimum, it takes in the model parameters and a learning rate.\n", "\n", "Optimizers do not compute the gradients for you, so you must call `backward()` yourself. You also must call the `optim.zero_grad()` function before calling `backward()` since by default PyTorch does and inplace add to the `.grad` member variable rather than overwriting it.\n", "\n", "This does both the `detach_()` and `zero_()` calls on all tensor's `grad` variables.\n", "\n", "[`torch.optim` docs](https://pytorch.org/docs/stable/optim.html)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "model params before: Parameter containing:\n", "tensor([[0.1950]], requires_grad=True)\n", "model params after: Parameter containing:\n", "tensor([[0.2219]], requires_grad=True)\n" ] } ], "source": [ "# create a simple model\n", "model = nn.Linear(1, 1)\n", "\n", "# create a simple dataset\n", "X_simple = torch.tensor([[1.]])\n", "y_simple = torch.tensor([[2.]])\n", "\n", "# create our optimizer\n", "optim = torch.optim.SGD(model.parameters(), lr=1e-2)\n", "mse_loss_fn = nn.MSELoss()\n", "\n", "y_hat = model(X_simple)\n", "print('model params before:', model.weight)\n", "loss = mse_loss_fn(y_hat, y_simple)\n", "optim.zero_grad()\n", "loss.backward()\n", "optim.step()\n", "print('model params after:', model.weight)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As we can see, the parameter was updated in the correct direction" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Linear regression using GD with automatically computed derivatives and PyTorch's Modules\n", "\n", "Now let's combine what we've learned to solve linear regression in a \"PyTorchic\" way." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iter,\tloss,\tw\n", "0,\t4.37,\t[-0.5072826 0.7721884]\n", "1,\t2.34,\t[-0.6624693 1.0903175]\n", "2,\t1.25,\t[-0.7725248 1.3242052]\n", "3,\t0.67,\t[-0.85030663 1.4962891 ]\n", "4,\t0.36,\t[-0.90505993 1.6230037 ]\n", "5,\t0.20,\t[-0.9434225 1.716392 ]\n", "6,\t0.11,\t[-0.9701522 1.7852831]\n", "7,\t0.06,\t[-0.98865306 1.8361537 ]\n", "8,\t0.04,\t[-1.0013554 1.8737577]\n", "9,\t0.02,\t[-1.0099901 1.9015862]\n", "10,\t0.02,\t[-1.0157865 1.9222052]\n", "11,\t0.01,\t[-1.019615 1.9375019]\n", "12,\t0.01,\t[-1.0220896 1.9488654]\n", "13,\t0.01,\t[-1.0236413 1.9573189]\n", "14,\t0.01,\t[-1.0245715 1.963617 ]\n", "15,\t0.01,\t[-1.0250894 1.9683164]\n", "16,\t0.01,\t[-1.0253391 1.9718288]\n", "17,\t0.01,\t[-1.0254192 1.9744583]\n", "18,\t0.01,\t[-1.0253965 1.9764304]\n", "19,\t0.01,\t[-1.025315 1.9779121]\n", "\n", "true w\t\t [-1. 2.]\n", "estimated w\t [-1.025315 1.9779121]\n" ] } ], "source": [ "step_size = 0.1\n", "\n", "linear_module = nn.Linear(d, 1, bias=False)\n", "\n", "loss_func = nn.MSELoss()\n", "\n", "optim = torch.optim.SGD(linear_module.parameters(), lr=step_size)\n", "\n", "print('iter,\\tloss,\\tw')\n", "\n", "for i in range(20):\n", " y_hat = linear_module(X)\n", " loss = loss_func(y_hat, y)\n", " optim.zero_grad()\n", " loss.backward()\n", " optim.step()\n", " \n", " print('{},\\t{:.2f},\\t{}'.format(i, loss.item(), linear_module.weight.view(2).detach().numpy()))\n", "\n", "print('\\ntrue w\\t\\t', true_w.view(2).numpy())\n", "print('estimated w\\t', linear_module.weight.view(2).detach().numpy())" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "visualize_fun(linear_module.weight.t(), 'Dataset with learned $w$ (PyTorch GD)')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Linear regression using SGD \n", "In the previous examples, we computed the average gradient over the entire dataset (Gradient Descent). We can implement Stochastic Gradient Descent with a simple modification." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iter,\tloss,\tw\n", "0,\t0.01,\t[-0.16747226 0.69458336]\n", "20,\t0.73,\t[-0.52777785 1.409119 ]\n", "40,\t0.05,\t[-0.74168175 1.7194624 ]\n", "60,\t0.04,\t[-0.8074937 1.831477 ]\n", "80,\t0.09,\t[-0.88882697 1.8813883 ]\n", "100,\t0.06,\t[-0.9371291 1.9570427]\n", "120,\t0.00,\t[-0.964763 1.9772899]\n", "140,\t0.00,\t[-0.9806282 1.9791764]\n", "160,\t0.04,\t[-0.98312473 1.9838824 ]\n", "180,\t0.01,\t[-0.99795353 1.9885796 ]\n", "\n", "true w\t\t [-1. 2.]\n", "estimated w\t [-0.9991454 1.9860797]\n" ] } ], "source": [ "step_size = 0.01\n", "\n", "linear_module = nn.Linear(d, 1)\n", "loss_func = nn.MSELoss()\n", "optim = torch.optim.SGD(linear_module.parameters(), lr=step_size)\n", "print('iter,\\tloss,\\tw')\n", "for i in range(200):\n", " rand_idx = np.random.choice(n) # take a random point from the dataset\n", " x = X[rand_idx] \n", " y_hat = linear_module(x)\n", " loss = loss_func(y_hat, y[rand_idx]) # only compute the loss on the single point\n", " optim.zero_grad()\n", " loss.backward()\n", " optim.step()\n", " \n", " if i % 20 == 0:\n", " print('{},\\t{:.2f},\\t{}'.format(i, loss.item(), linear_module.weight.view(2).detach().numpy()))\n", "\n", "print('\\ntrue w\\t\\t', true_w.view(2).numpy())\n", "print('estimated w\\t', linear_module.weight.view(2).detach().numpy())" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "visualize_fun(linear_module.weight.t(), 'Dataset with learned $w$ (PyTorch SGD)')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Neural Network Basics in PyTorch\n", "\n", "Let's consider the dataset from hw3. We will try and fit a simple neural network to the data." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "\n", "d = 1\n", "n = 200\n", "X = torch.rand(n,d)\n", "y = 4 * torch.sin(np.pi * X) * torch.cos(6*np.pi*X**2)\n", "\n", "plt.scatter(X.numpy(), y.numpy())\n", "plt.title('plot of $f(x)$')\n", "plt.xlabel('$x$')\n", "plt.ylabel('$y$')\n", "\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Here we define a simple two hidden layer neural network with Tanh activations. There are a few hyper parameters to play with to get a feel for how they change the results." ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iter,\tloss\n", "0,\t3.96\n", "600,\t3.69\n", "1200,\t2.58\n", "1800,\t1.10\n", "2400,\t0.91\n", "3000,\t0.68\n", "3600,\t0.14\n", "4200,\t0.08\n", "4800,\t0.06\n", "5400,\t0.15\n" ] } ], "source": [ "# feel free to play with these parameters\n", "\n", "step_size = 0.05\n", "n_epochs = 6000\n", "n_hidden_1 = 32\n", "n_hidden_2 = 32\n", "d_out = 1\n", "\n", "neural_network = nn.Sequential(\n", " nn.Linear(d, n_hidden_1), \n", " nn.Tanh(),\n", " nn.Linear(n_hidden_1, n_hidden_2),\n", " nn.Tanh(),\n", " nn.Linear(n_hidden_2, d_out)\n", " )\n", "\n", "loss_func = nn.MSELoss()\n", "\n", "optim = torch.optim.SGD(neural_network.parameters(), lr=step_size)\n", "print('iter,\\tloss')\n", "for i in range(n_epochs):\n", " y_hat = neural_network(X)\n", " loss = loss_func(y_hat, y)\n", " optim.zero_grad()\n", " loss.backward()\n", " optim.step()\n", " \n", " if i % (n_epochs // 10) == 0:\n", " print('{},\\t{:.2f}'.format(i, loss.item()))\n", "\n" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "X_grid = torch.from_numpy(np.linspace(0,1,50)).float().view(-1, d)\n", "y_hat = neural_network(X_grid)\n", "plt.scatter(X.numpy(), y.numpy())\n", "plt.plot(X_grid.detach().numpy(), y_hat.detach().numpy(), 'r')\n", "plt.title('plot of $f(x)$ and $\\hat{f}(x)$')\n", "plt.xlabel('$x$')\n", "plt.ylabel('$y$')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Things that might help on the homework\n", "\n", "## Brief Sidenote: Momentum\n", "\n", "There are other optimization algorithms besides stochastic gradient descent. One is a modification of SGD called momentum. We won't get into it here, but if you would like to read more [here](https://distill.pub/2017/momentum/) is a good place to start.\n", "\n", "We only change the step size and add the momentum keyword argument to the optimizer. Notice how it reduces the training loss in fewer iterations." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iter,\tloss\n", "0,\t3.83\n", "150,\t3.06\n", "300,\t0.74\n", "450,\t0.12\n", "600,\t0.04\n", "750,\t0.03\n", "900,\t0.01\n", "1050,\t0.00\n", "1200,\t0.00\n", "1350,\t0.00\n" ] } ], "source": [ "# feel free to play with these parameters\n", "\n", "step_size = 0.05\n", "momentum = 0.9\n", "n_epochs = 1500\n", "n_hidden_1 = 32\n", "n_hidden_2 = 32\n", "d_out = 1\n", "\n", "neural_network = nn.Sequential(\n", " nn.Linear(d, n_hidden_1), \n", " nn.Tanh(),\n", " nn.Linear(n_hidden_1, n_hidden_2),\n", " nn.Tanh(),\n", " nn.Linear(n_hidden_2, d_out)\n", " )\n", "\n", "loss_func = nn.MSELoss()\n", "\n", "optim = torch.optim.SGD(neural_network.parameters(), lr=step_size, momentum=momentum)\n", "print('iter,\\tloss')\n", "for i in range(n_epochs):\n", " y_hat = neural_network(X)\n", " loss = loss_func(y_hat, y)\n", " optim.zero_grad()\n", " loss.backward()\n", " optim.step()\n", " \n", " if i % (n_epochs // 10) == 0:\n", " print('{},\\t{:.2f}'.format(i, loss.item()))\n", "\n" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEdCAYAAAABymAfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABMTklEQVR4nO3deXwU5f3A8c+TCxKuQAhHNuEKEK4AkXCJKOKBomDwKB5o9WdrT1utxXrQ4kGVmlqp1dZ6VVuoRQUjKhoPxAPlCAQIVyABErLhSIBwJUCO5/fH7CxZCORgd2c2+32/XnklmZ2deSbHfOe5vo/SWiOEECJ4hVhdACGEENaSQCCEEEFOAoEQQgQ5CQRCCBHkJBAIIUSQk0AghBBBTgKBEEIEOQkEQgQJpdREpdREq8sh7EfJhDIhmj+lVEfgU9e3V2it91tZHmEvEgiECAJKqReB94BQYLLW+hcWF0nYiAQCIYQIctJHIIQQQU4CgRBCBDkJBMJWlFI7lVKX++lcSUqptUqpI0qpX51ln1il1GdKqYNKqdeVUk8rpe5r4PFXKqUGerXQZz/XG0qpWfXsExDXIvwvzOoCCNFUSqmdwI+01p838RAPAl9qrYeeY5+HgW1a6yuUUrHAWqB3A4//Z+AJ4IYmls/bmtO1CC+SGoEIZt2BjfXscznwjuvrO4HFWuuKBh5/EXCpUqpL04rndc3pWoQXSSAQfudq/nlYKbXJ1UzxL6VUyzr266+UWqqUKlNKbVRKTa712n+AbsAHSqmjSqkHG/n+JcClwAuu9/c97b0RSqlDQLLrHDnA1cBXp+33jFIqo9b36UqpL5RSEVrr48BqYMJZfg4PKaXyXU1Tm5RSU+r4Of1WKbVeKXVIKTXf/DkppVKUUmtc750PnPHza8y1nOs6AOq7FhHgtNbyIR9+/QB2AhuABKADsAyYVeu1y4FwIA94BIgAxgNHgKTTjnP5Wc7RkPcvxWhaOls5BwB7a31fAgw/bZ8Y4BCQAvwUyAHa1Xr9eeAvZzn+TUAcxgPZVOAY0PW061vp2qcDsNl1jgigALjfdZ03ApXmz7Ap11LfddR3LfIR2B9SIxBWeUFrvUtrfQD4I3DLaa+PAloDs7XWJ7XWS4AP69jvbM73/QBDgXW1vo/GCCZu2pih+xzwJkYb/ESt9aFauxxxve8MWut3tNbFWusarfV8YBsw4rTdnnftcwD4wFWmURgBYI7WulJr/S6w6nyupQHXcc5rEYFNAoGwyq5aXxdgPPXWFgfs0lrXnLafo4HHP9/3w5k3z4NAmzr2y8ZodnlYa73rtNfaAGV1HVwpdYdr1FKZUqoMGAR0PG23PbW+LscIbnGAU2tdezZowTmvpGHXcq7rgHNciwhsEgiEVRJqfd0NKD7t9WIgQSkVctp+zlrfn2tafEPeX58heN481wOn9yUkA//AeJL+vzqO0f+0Y5jv6w68AvwSiNFaR2M0l6kGlGs34FBK1d63Wz3vOee1NOA64CzXIgKfBAJhlV8opeKVUh2AR4H5p72+AuMJ+EGlVLhSahwwCfhfrX32Ar3OcvyGvL8+p988FwOXmN8opRwYzTU/BX4OJLvOY77eEhgGfFbHsVthBLIS1753YdQIGuJ7oAr4levarufMJqUGX0t919GAaxEBTgKBsMp/MbJhbgfyAY/JUFrrkxg37quBUuDvwB1a6y21dnsamOFqWvltE95/Vq5hku2B2vv/G5iolIpUSrXFuJn+RWu9SGtdDqRj9HeYJgFLtdan13bQWm8CnsW4qe/FaJJZ1pCyua7teowhoAcwOpoXNvFa2jXgOs55LSLwSdI54XdemAhmGaXUU8A+rfWcBuy7Arhba73B5wVrguZ0LeL8SCAQfhfIgUCI5kiahoQQIshJjUAIIYKc1AiEECLIBWT20Y4dO+oePXpYXQwhhAgoq1evLtVax56+PSADQY8ePcjKyrK6GEIIEVCUUnXOQJemISGECHISCIQQIsjZJhAopUKVUtlKqQ+tLosQQgQT2wQC4NcY+daFEEL4kS0CgVIqHrgGeNXqsgghRLCxy6ihORgLideV6x0ApdQ9wD0A3brVl3FXiObjtle+Z1n+Aff3YxI7MO/Hoy0skWhuLK8RKKWuxUh8tfpc+2mtX9Zap2qtU2NjzxgGK0SzMyMjhx4PfeQRBACW5R+gx0MfMfTxT8nIbszyCkLUzfJAAIwBJrsSkf0PGK+UmmttkYSw1oyMHOYuLwSgy+FS+u3bccY+ZRWVTH9nnQQDcd4sDwRa64e11vFa6x7AzcASrfU0i4slhKXeWuFaKVJrXln4JIvevJ9Ltp9Zaa6s0aRn5vq5dKK5sTwQCCHOVO1KBnlhwTqS9+ZTEd6Cl957ihG7zlwOoLiswt/FE82MrQKB1nqp1vpaq8shhJVqN/X8ZOVCSlpFc9X/vYCzbSyvvfs4ybu3eewfFx3p7yKKZsZWgUCIYDcjI4f7568FoN++HVyyYw1vXDCJ3W1jmTZ1FmWRbfn323+gb8lOAMJDFNMnJFlXYNEsSCAQwiYysp3MW16IuULIj1cu5Fh4S+amTARgf3RHbps6i5Nh4cyd/3uSy/eRftMQ0lIc1hVaNAt2mUcgRNBLz8x1B4Euh0uZvPlr5qZM5FBkGxSw7alrjBd/fSFcfDEfLHocHrzCquKKZkRqBELYRO1O37tWL0JpzWvD04DT+gEGDIDMTDh4EK68Eior/VxS0dxIIBDCJsybfZsTx7h17ccs7ncRRe06o+DMfoBhw+CFF2DzZu759T/p+dBHjJm9ROYUiCaRQCCETUyfkERkeCi3rP2ENicr+OeI61HAbaO61dkPsDhuMACJm7LQgLOsgocX5kgwEI0mgUAIm0hLcTB7UhI/WvMBy7oPpqxfMs9NHcqstOQ69//jqv1sjenGyMJTcwsqKqtlgploNOksFsJGrtv8NRwupdP8/7DsqvHn3NdZVsHybslcv3EJYdVVVIWGubcL0RhSIxDCBjKynYx5+gu2/HYmeV16ktFpUL3vCVWK5d2SaX2ygkF78z22C9EYEgiEsFhGtpOHF+bQZ8239Cst4O/D0nj4vQ31tvVXa82KBCNgjCrM8dguRGNIIBDCYumZuVRUVnP3qgx2t47hg/4XN6it3xEdyf5W0WyN6eYRCBySckI0kgQCISxWXFZBi6qTjNy1gfcHjqMyNNy9/VzMUUYrug0i1bmJsOoqIsNDJeWEaDTpLBbCYnHRkXTauIWImiqy45I8tp+LOaR0df4wWmcv5tJjRVxza5qknBCNJjUCISw2fUISw/cZGUWzuxqBoKFP9mkpDp587hcAvNL9qAQB0SQSCISwWFqKg9tD9rC3XSwlbWJwREfy9PXJDb+pd+4M/fvD0qU+LadovqRpSAgbSNi2AS4by47Z1zTtAOPGwX/+A1VVECb/1qJxpEYghIUysp1M/P17kJ/Pi+UxTU8PMW4cHD0Ka9Z4tXwiOFgeCJRSLZVSK5VS65RSG5VSj1tdJiH8wZw/0GnLegC+ad+z6bmCLrnE+CzNQ6IJLA8EwAlgvNZ6CDAUuEopNcraIgnhe+b8gaG7c6lWIazv0qfpuYKkn0CcB8sDgTYcdX0b7vqQqZGi2TPnCQzZvZVtMQmUR0R6bG+0cePgm2+MfgIhGsHyQACglApVSq0F9gGfaa1X1LHPPUqpLKVUVklJid/LKIS3xUVHgtYM2b2NtY2YP3BW0k8gmsgWgUBrXa21HgrEAyOUUmdk3NJav6y1TtVap8bGxvq9jEJ42/QJSfQ9uo8OFYdZ17Uv0PD5A3W6+GLjszQPiUayRSAwaa3LgC+BqywuihA+l5bi4ClHOQDr4vo2fv7A6bp0gX79JBCIRrN8wLFSKhao1FqXKaUigSuAP1lcLCH8InXvNoiKYvHLP/PO+P9x42DePJlPIBrFDjWCrsCXSqn1wCqMPoIPLS6TEP6xcqWx/rC3btrjxsGRI5Cd7Z3jiaBg+SOD1no9kGJ1OYTwu5MnjRv2vfd675i15xMMH+6944pmzQ41AiGC0/r1cOIEjBjhvWNKP4FoAgkEQlhlhWuU9MiR3j2uzCcQjSSBQAirrFxpzAhOSPDucc1+grVrvXtc0WxJIBDCz2Zk5JD48GLyP1zCZ216MOP9Dd49wbBhxuecnHPvJ4SLBAIh/GhGRg5zlxfSquIIiQeKWNu1L3OXFzIjw4s37R49ICICNm/23jFFsyaBQAg/emvFLgAG7zZWJDNTS5jbvSIsDPr2hS1bvHdM0axJIBDCj6q1kU9x6G4jw+j6rn08tntNv35SIxANJoFACD8KVQowMo7mdYjnSItWHtu9pn9/2L7dGJ4qRD0kEAjhR7eMTACtGVq81SPj6C0jvTtyKKtlJ6ip4cqfv8aY2UuavvKZCAoSCITwo1lpyfwyMZzY8jLWdu1LqFJMG9WNWWnJXjtHRraTJ/OMpqbE/btwllUw/Z11EgzEWVmeYkKIYPPb6EMAzHr6bmaZQz296LFFGzkRHQdA4oEiACprNI8t2tj0zKaiWZNAIIS/rVwJLVpAsvdqAbWVVVRCREuK2sbSe/8uz+3NUEa2k8c/2MjBcuP6oiPDeWzyQAl6jSCBQAh/W7ECLrjAGOvvQ/kxCSTuL/LpOayUke3ksUUbzwhwZRWV3Dd/LVkFB7za5NacSR+BEP5UVQWrV3s/v1At7aPCAcjvEE/igSKUrvHY3hxkZDt5eGHOOWs585YXSr9IA0kgEMKftm6FiopTaSB8YOakgYSHKvI6JhBVeYKuR0oJD1XMnDTQZ+f0t4cXrqeistpjW4vKE9yzYgEdjx0EQGP0l4j6SSAQwp82uPIKDTpjWW6vSUtxkH7jEPbF9QAgcX8RrSKaTyvwjIwcKiprPLa1qDrJy+/9kUeW/ouHv3zdvb2sopLbXvne30UMOJYHAqVUglLqS6XUJqXURqXUr60ukxA+s2EDhIQYM399LKeNMXKo9/5dlFVUNpshpP9dUejxfXh1JS9mPM0lO9aQ3TWJtE1f0atW38iy/APezeXUDFkeCIAq4AGt9QBgFPALpdQAi8skhNdlZDtZunAp+dFxjJnznU9vyo8t2sjelm0pa9na3WFsDiENZBnZTmpqZeMIq67ib4ue4fL8Vcy48ufcfeMfOB4Wwa++e8vjfV7N5dQMWR4ItNa7tdZrXF8fATYDMu5LNCtm52bC7u3kduyGs6yChxfm+CwYlFVUglLkxSS45xK4twew9Mxc99ehNdU89+GzXLX1ex6/7MfMTZnIgah2/PuCa5m86Wt6l56qOXg9l1MzY3kgqE0p1QNj/eIVdbx2j1IqSymVVVJS4veyCXE+0jNzqSkvp8fB3Wzr2B2AispqjxubL+R3iPeYSxDoissqAAipqeaZxXOYtOUbnhp3F/9KvY4xiR0AeHnEFMojWvLrZadqBV7P5dTM2CYQKKVaAwuA+7TWh09/XWv9stY6VWudGhsb6/8CCnEeissq6H2giFBdQ25sd4/tvuAeQhoTT+yxMtoeP+p+LZD7CeKiI1G6hqcyX+SGjV+SPvZ2Xh55A5HhIcz78WjGJHbgYFQ73hg2iWu2fEvfkp2A93M5NTe2CARKqXCMIDBPa73Q6vII4W1x0ZH0LSkAILdjd4/tvmAOFc2LMW6AtWsFvq6F+NL0CUlMyl/Bzes/5fnRU3nxwqlEhofy9PWDAZj349FMG9WN10dcz7GIlty37C2v53JqjiwPBEopBbwGbNZa/8Xq8gjhC5f2i6VvaSEnQsMoaN8VgMjwUKZPSKrnnU1jplfIj4kH8Jhh7KtaiD+kpTi4L6SI8ohInr/oVhzRkTx9fbJHOolZacmsmTOVNr/7LRNzlzGrZ805jijAHikmxgC3AzlKqbWubY9orRdbVyT7qyu/ysC4NizffpBqrQlViltGJsiTkA1kZDtZsNrJC6UFbO8QT1VoGAq4YZjDp/lwHNGR7KrpzInQMBJr1Qh8VQvxl1652TBuLHnPTD73jvffD88/D48/DguloeFcLA8EWutvAenJqUdGtpNHFq6nvLLup5uyikqW5R9wf1+tNXOXFzJ3ueeYa6km+99jizZSUVlNUkkBqx39AWPW65dbfDvoYfqEJB5emMOO9g73yCFf1kL8oqwMcnLgxhvr37d9eyMYPPYYZGdDSoqvSxewLA8E4tzOFgBanyin5wEnvQ4U0euAk0TX1zUqhFXxA1iRMIhV8QPZ3yra431zlxcyf2Uh6TcNleyMfpCR7aSsopJWJ8qJP7yP/w69yv2ar5tozN9v4cJu9N6dD0DLcMtbg8/Pd9+B1nDRRQ3b/777YM4cIxi8/74PCxbYJBDYlDHufL3HVPqWlce5YcMS7lz9AX1qVfWrVQi72nVmewcHLapPcvO6T7lr9QeAMXxwRcJAvuo1jMw+o0EpKmuQ7Ix+YnbMmr+vrX7oKD5dXod4Ltu8jIiqSg6Ww8MLjVm2Afkg8O23EBbW8KR97drBAw/A738PWVmQmurb8gUoCQQ2lJHtZPo766h0TaHseOwgt6/5iNuzF9Oh4jDruvThmYvvID8mnvwO8RRGd+Vk2KnMkuHVlQzak8+Iog0M37WRa7d8y63rMlnc90IeuvpXHG7ZGsDdbCTBwHfMp373iKFaQ0f90USTnpnLsPYOQnUN3Q8Wsy22u3v+QkAGgm++MRL2RUU1/D2/+hWkp8NLL8Grr/qubAFMAoENpWfmUlmjSSzdxY9XvceUjV8SXl3FF71H8MqIKayMHwjnmCBTGRpOtqMf2Y5+/HPkjYTUVHP3qvd58Os3SX7j1/xy8oOsc62XO295IandOwTmTSEAxEVH4iyrIKm0gPLwFhS16wQY4/z98TMvLqsgutYQ0m2uQBRoI4cysp389cMcPvl+OQsunEJUtrPhP7+2beHCC40FgUSdJBDYQEa2kwfeXku1axZ8i6qTPPTtPH688j0qQ8N4N/kyXktNY7trKGBdTh81VFtNSCivjLyerPgB/G3RM7w770H+dMkPeW14GlqFcN/8tTy2aKOs6uQDZodt35ICtsV0Q6sQIsND/ZYSOi46ku0njd9p7VQTgTRyyEzPMWBHDi2qq/gyNolvG9u8NXw4fPoplJc3rjYRJCQQWCwj28l989e6vx+8eyvPfvQcffbv4q3BV5J+yQ85ENXujPcp4LZ6RgDNyMjxGDWU7ejHxLue508fP8+ML19ndGEOv514Hwej2rmzU0KAth3blPmz7P/XQr7sfgGO6EimT0jy28/YDERFbTu55xIE2sih9MxcKiqrGVFkJMzLcvRvfPNWairU1Bijh8aM8WFpA5MEAouZnYkRVZX8etl/+emKBexr1Z4f3vQ4X/U6c/GSyPAQnr5+cIP+AWalJTMrLdlj5NHhlq35WdrD3J79ETOWvMrif/2Km299moL2cVTW6MBtO7axtG4t4cgBbrrzKm56YLx/z+36XRbN707v/bv8Hoi8welqxkot2sS2mAQOuh6MGtW8ZXYSr1olgaAOAT6WLHBlZDsZM3sJzrIKBu3JY9Gb9/GL5e+wYNB4Jtz94hlBoH1UOHOmDmXzk1c3+p84LcXBpievZtqobsaEDaX4zwXXcv3tz9Ky6iR/z5hNi6qTQOC1HQeEja7UzwOtWSEsLcXBqGvGkHxkN8seHBdQQcDMi6R0DalFm1gVfypDfaOat+LijI+sLG8XsVmQGoEFZmTkMG95IVpr7lq9iEeXvEZpq2juvHEmSxOHe+y7c/Y1XjvvrLRkUrt34IG311GtNRs7J/LANffz+oIn+P0XrzBjwi8Cqu04YPhhVbJ69etntI8XFUG3btaVo5HM9RP6lhbS7sQxsmoFgkY3bw0fbtQIxBmkRuBnGdlO5i0vJKy6kqc/+Rszv3iFJb1HcOXdfz8jCPTp1Mrr509LcfDsD4YQHmqMOlrSewQvjbieaWs/ZvKmryg/WUXPhz5izOwlAZ2l0lY2bDDGszssfBLvb8xoZssW68rQBOb6CcOLNgEYI+ZcGl2zSU011ow+dMhr5WsuJBD4kTE6aB3R5YeYO//33LL+U14Y/QN+MuUR99h+U59OrfjsN+N8Ug5zTVszVfGfL76DNfH9eSrzBaKLdqLB5wunBJUNG4zagJU58c2lMQMsEJiG79rIntYdKGrX+TwO4nrQWr3aO4VqRqRpyE/MIXC99u3ktQVP0PnoAX597QO8P/BS9z6O6EiWPeSfzsS0FM+EZ1NCK3jt+Z/w94ynSbv9WU6EtwjsiUd2obXRR3DTTdaWIzbWyL2zebO15WiE2g8hqUWbyKo1f8Z8iGkUs8M4KwvG+7fT3u6kRuBjZqfwffPXMmrLchbO/S0tq04y9dbZHkFA4Z+Zpmezljb85prf0L9kJzO/eMW9XTqPz9OePXDggGUdxW5KGc1DAVQjMEfUxR3eh+NICStr9Q80ZR5GRuFxnO27svj1RdL0eRoJBD40IyOH++evxVlWwR2rP+C1d59gZ/s4Jt/xHGvjTt30zTkBVj55x0VHsjQxlb+PupFb133C5E1LAQhRSv5hzocdOopN/foFVI3AfAgZvss1f+A8+gfMGnl2594k78mTps/TSCDwkSv+spS5rpFBv/zufzzx+T/5vM9IfnDrn9jTtqN7v1CleG7qUMvz/UyfkERkeCjPjr2dlfEDePqTF+i1v4hqreUf5nzYKRD07w9798LBg1aXpEHMEWzDizZxOCKKLa70GI4mjGwzJ6Wt79KbhEN76VB+yC9rRgcKCQQ+cMVflrJt3zHQmoeX/ovffjOXBQMv5WdpD1MR0dK9X2R4KM/+YIgt2uDTUhw8fX0yhIZx7+QHqQ4J5eGlrwPGIuvmMD7RSBs3QqdORhu91QKsw9h8OEkt2sQaR39qQkKbPCvarF2s79oHgOQ9eR7bg50EAi+bkZHDtn3HCKmp5qnMF/nJyoX8O+UafnvN/VSHhLr3q2uJPaulpTio0Zq9bTry8ogpXJG3kiHFxhNTWUUlMzJyLC5hANqwwfr+AVOADSFNS3Hw58vi6VdaQFb8gPP6nzFrFxs696YGxeDdWz22BztbBAKl1OtKqX1KqQ1Wl+V8mLl9wqqreO7Dv3Druk94cdRN/OGKn6KV8aNWwJypQ1n20HhbBQGT+Y/xr2GTORDZlt98O8/92rzlhdJE1Bg1NUaNwA7NQgA9ekB4uDGWPgBkZDtZ+i9jMZnt/S84r9QYZu3iaIsotndwMHhPXsDlXPIlWwQC4A3gqvp2sjMzCLSoPMFL7/2R6zZ/xZ8u+SHpl/zQY/y41Z3C9TH/MY61iOKfI6/nkh1rGOaazKNB2lQbo7AQjh61TyAIDYWePSE/3+qS1Mvs3E3MzeZkSBhftO52Xn1VZtOnIzqSnK59SNmbZ7sauZVsEQi01l8DB+rd0aZue+V7dxB4bcETjM/PYsaVP+cfozzHjvfp1MryTuH6pKU43GO0/51yLSVR0fzm27nu16VNtRHs1FFsSkyEvDyrS1Evs3M3tWgTOV16e8xraaq0FAfLHhrPlHvS6HhkP2mdZal0ky0CQUMope5RSmUppbJKSny76HdDZWQ7GfiHT1iWf4AWVSd5ZeEsLixYz/SJ9zE3ZaLHvr6cKextMycNRAEVES35x6ibGFOwnlGF6wEZTtooZrK5AQPOvZ8/JSYaNYLT1qywm+KyClpUnmDw7m2sShjosf281c5EKoAACgRa65e11qla69RYG4zAMKuux05WE1FVyT8X/pGLdq7ld1f/igXJl3nsO21Ut4AJAmA8Od3mylQ6L+Vq9rTuwG++mQtay3DSxtiwAeLjITra6pKckpgIhw/D/v1Wl+Sc4qIjGbJnGxE1VU3POHo2Q4cazWSSidQtYAKB3Tz+wUYqKo0g8I+Mpxi3YzUPX/VL3hl8hcd+0+pZPMauZqUl89zUoVSFt+CF0VMZUbSJsTuzAWT8dUOZOYbspHdv47PN+wmmT0hidLEx+W21wxjt5LXO3agoYySX1AjcJBA0wYyMHA6WVxJeXckLi/7EZfmreGTCL5g/ZILHfoEaBEzmcNK3B19JUdtYHnDVCkD6CupVVWXM4rVbIEhMND4HQD9Bv9ICdrXrTFlkW9pHhXu1c3dnrwGUffM9PX/3oaSbwCaBQCn1FvA9kKSUKlJK3W11mc6m9hDRvy16hiu3LWfGFT/jv0Ov9thvTGKHgA4CprjoSE6GhfO3C29m6O6tjM9f5d4uziE/H06csF8g6NnTGMVm4xqB2eyaULKL/A7GOt3HK2u8evw3TnQkuvwwjkN7Jd0ENgkEWutbtNZdtdbhWut4rfVrVpepLuZaAqE11cz54M9ctfV7Zl7+E+ZecGrxGIVRE5j349HWFdSLzPHXCwZdRkF0F37z7Twiw0Jk/HV9LF6V7KxatjTWRbBxIEjPzKXiZBU9DzjZ3sGoAXizOTI9M5esTkYT2WDXDONgb+60RSAIBOZaAuganvn4r1yb+y1PXno3bw6b5N4nOjKcHbOvaRY1AZM5/rpzTBueH3MLg/bm80Z0kYy/ro+Z3M1M62AnvXvbOhAUl1XQ5ch+WlUeZ3tMvMd2bx0/N7Y7J0LD3DOMvXn8QCTrETSAWVWtrqnhic/+yQ0blvDnsdN4bcQU9z4KeGyyzZ7+vMS9dkH1JRxJfJ/Wzz9Hz9I44gJwIXS/2bwZEhKgdev69/W3xET46COrS3FWcdGRdN9ZBEB+B4fHdm8d31kGmzv1dNcIvHn8QCQ1ggYwq6oPffUGd2R/xEsjb+CF0VM99rH7jGFvyFi/hxf7Xs7AXZvpW7JT2lbPZfPmU7l9bGZjZCzs2cPA37xry47S6ROS6HdoN4C7acib6SDM5s6cLn0YtCcPpWuCPt2EBIJzyMh2kvLEpzjLKvjl9/P56YoF/DvlGmZfcqc7bYTZJ9CcmoPOJj0zl/n9LuFEaBg3r8sEJDNpnWpqjMRuNgwEGdlOXi02/nYTyvbYMpinpTi4rX0F5RGR7Gsd4/UEjWZzZ2GvgbQ9Wc6oyv1Bn25CAsFZzMjI4b75azlYXsn/rXrfSCU9aDwzr/iJOwjYZS0Bfykuq+BgVDs+7TOaKRu/pEXVScDITGqnG4nlCguhvNxeM4pd0jNz2dbGWPe3e5nx1G3HjtLEA06iBvVnx5+u9UmCxrQUB4/OvB2Aty4IC+ogABII6mSODgK4ee0n/GHJKyzueyEPXv1rdxZRO60l4C9mG+pbQyYQffwoE7Z+535NagW1mB3FNqwRFJdVUBjdBYBuB/d4bLeV3FxI8m1TzfvH21IR3pJ/zXnblk1k/iSB4DTm6CANTN70FU9lvsiXvYbx68nTPdYTCMaqpNmG+n33wRREd+EWV/MQGLUCYdQk//jnhQCkvltkuzUc4qIjOdyyNQci29KjrNhju21UVEBBgU8DQUa2k4cWbSancy8G795myyYyf5JAUIt7dJDWXJa3gmc/+gsrEwby07RHqAwNd+/niI4MuiAAp9aJ1SqE+YOvZHRhDj0OBOc/Tl3MyYa9SgvZH9mW0si2zF1eaKtgYHaUFkZ3cdcIbNdRmpdnzGD3YSAws5vmdOnDgH07CK2ptmUTmb9IIHAxawIVldWMLljH3zNms7FzL350wx84Ed7CvV94iLLXP42fmSmq3x10GVUqhKnrP/PYHszeWrELgN77i8iLSThjux2YHaX7OsXTvWy3LVfKI9d1M/ZhIDCbwtZ17UNk1Qn6lhZ4bA82EggwgsD0d9ZRrTUpzi28uuBJdrbvyp03Pc7RFlHu/aLCQ0i/Kbj6BU43c9JAwkMV+9rE8GXicG7c8Dlh1VVoTdBWq03VWoPW9N6/i/xagaDaZimf01IcXDnpQrodLWXZA2Pt9/dsBoK+fX12CrMpbH0X1xrGu/M8ttvWsmU+SSEe9IHAHB1UWaPpt28Hb7wzk5JW7Zk2dRZlkW0BY3TQnKlD2fTk1fb7p/GztBQH6TcOoX1UOG8NmUDssTIuy1tJWUVlULexgvF3ElN+iPbHj3jUCEKVDRdA6d0bqquNtni72bLFSN/dqpXPTmE2kRW078rhFq0Ysmer/ZrIaqupgd/9Di66CN55x+uHD+pAYK4sBtDjgJP/vP17ysNbMu3mWZS07gAE5+ig+qSlOIiKCOOrXsPY3TrG3WkczG2sALeMTKD3fqMZKK9WaoRbRiac7S3WsXMW0txcn6fmMJvI4tq3Yn2X3gzbl2+/JjLT0aNw/fXwzDPwk5/AlCn1v6eRgjbFREa2k2X5xuqYcYf3MXf+DJTWTLtlFkXtOrv3s+0fh8WKyyrQIaG8k3w5v/z+beIO76O4bSecQdrGCsYaDu9/8jYAeR0TCFWKW0Ym2HOeiRkI7JZzSGsjENx+u89P5U6dcuhq+POf6dc/xufnrE9GtpP0zFycZRWEKkWnQ/v4d8Yseu/dgfrrX+Heez3WQPeWoK0RPLLQWHox9ugB5v3vUdqeKOeHP3jCo223fVS4BIGzMNtS3x5yJQA/cHUaK4K7r+C6FoehVSu+e/FO8p+eaM8gANCli7FAi40CQUa2k0kzFsDhwzxX6MclUYcPN9aPWL/eP+c7C3PUovkwlezcwqJ/30/n/bu5Z+rjZIy9wSdBAII0EGRkOymvrKFD+SHm/W8GnY4e5M6bHmNj50SP/WZOap5J5Lxh+oQkFFDUrjPf9hjKTes/J6SmGk2QTy7bvNlo1rBjv0BtSkGvXrYJBOZNMGqH0VS1JrKT//qcLFrDOCPbyZjZS+j50EeMmb3EveohwKRNXzH/vw9REdaC62//M591S/Fps2vQBQJzmGjb40f5z/zf0+3QHu6+8Q+scXjOAp0WBEnkzkdaigNz7ML/hkzAcaSEi3cYS1kGdcoJGyebO0Pv3rbpIzDH9fdyzUvZ3iHef31OCQnQqZNfA0FGtpPp767DWVaBBpxlFRwsNyZl3pa9mL99kM66rn1Iu+Mv5HXsBq59fDUDOqgCgfnU0fL4Md58eyZ9Sgv5yZRHWd5tsMd+c4Iof9D5cLiahz7rM5LSqHbcvP7UTOOg7DQ+fBiKigInECQmwvbtxogUi5nj93sdKKIirAXFbTt6bPcppdjTN5kdHy91P537+kHm8Q82Ull95jDQi3Zk8/hnL7GkVyrTpv6RA1HtPF731QxoWwQCpdRVSqlcpVSeUuohX50nPTMXXX6M1xY8QfKebfzyut/xVa9hHvvMmTpUagINZA61qwwNJ2PAOMbnraLt8aNAkE7M2bLF+GzDZHN1SkyE48dh926rS+Luc+p1wMnO9l3dOb38Ma4/I9vJOyFd6b6vkKgT5T5PN5GR7XQ//dfW84CTF9+fTV5MAr+a/CAnw+qepOmLmlK9gUAp9ZlSaohXz+p5/FDgReBqYABwi1LKJ/9JpaWH+ed7TzFi10Z+c+0DfNr31HKSZjppCQINl5bicM8o/qjfWCJqqrgsbyUQABNzfMHGyebqZKORQ+a4/l4HitzrFPtrXH96Zi5rOiUSgmbgvu2A74ZCm60Sp2t7/CivLniCqpBQHv2/pzjaIuqc80+8/aDVkBrB74A5Sql/KaW6evXshhFAntZ6u9b6JPA/4DofnIc/f/VPLtmxht9dfS+LBlzi3h5s6aS9aeakgUSGh7I2ri/FbToyMfdbe0/M8aXNmyE8/NQN1u5sNJcgLcXB7ElJJBzay44ODr+mviguq3DPMPb10pVmX0htYdVVvJgxm4SyvTxw80wW/OlWds6+hvynJ7qbX0/n7QetegOB1nqN1vpS4EPgE6XUTKWUN0vhAGonYylybfOglLpHKZWllMoqKSlp0okiH/odM665j3cGX3lqm0wYOy+1J+Z8nDSGi3esIfToEdIzc4Ovw3jzZujTB8ICZHpO9+5GWW1QIwC4rs1xwmpquPfnvlmD4GzioiPZ3yqaoraxDNm9zWO7t9UVXH6/5BXGFqzlD1f/krR7PVc+NGtKtfniQatBfQRKKQXkAv8A7gW2KaV8P+OjFq31y1rrVK11amxsbJOOcfkN40h98rc4oiNRYM+EWwEoLcXB9AlJfDFwLC2qq7gsb0VwpvUNpBFDYASB7t1tEwj8kWyuLubNdn2XPgzeYwQCX9VqTw8u07IX88M1H/HqiCmMevK3Z9yLzActX9+z6n10UUotA3oCG4HlwJ3AFuDXSqmxWut7zrMMTqD2HPx41zafcM8mFF6VnplLcee+7GndgYm5y3h/4KXudtag+HmfOGHcUKdOrX9fm8jIdtI1pD0tv1rDz2cvYfqEJGt/VxYFAvOaC1YNYOLW7+gXUclPp/hm0Mj0CUk8vDDHleV4PY999hJLe4+g44tzzno+f9yzGlKHvQfYpPUZKe/uVUpt9kIZVgF9lFI9MQLAzcCtXjiu8KPisgq0CuHjpDHcuvYTWp0o51iLqOAZPbRtmzEMM0BqBGan5SOtOzFp1xZ3DQ6wLhhs2WLMeG7b1u+nTktxwPSbIfNVPrkoCnz0MzB/ti++v4a/fPgsRR3jOfr6m6SldvPJ+RqqIX0EG+sIAqZrzrcAWusq4JdAJrAZeFtrHcRTUwOTWeVdnDSGFtWVjM9f5bG92QuwEUNmp2VBdBeijx+lXcUR65MG+mF5ynMa5hpK7uOJZWkpDj7bu5iu5Qfp8eE7XDvWtwn2GuK85hForbd7oxBa68Va675a60St9R+9cUzhX2Y762pHf/a1as/E3GXBNXpo82YjbYOVN7JGMGtqBe3jgFML2Vtag/ND1tFzio421kDw9Qzjr76Cl16C+++HESN8e64GssWEMhH4zE6trh1a80nShYzfnsUzV/UKjv4BMAJB9+5GIrcAYNbUClwL2Xc/uNtju9+VlsKBA9YH0tRUyMry3fErKuBHPzLyPD3xhO/O00gSCITXpKU4WPbQeHr+7E5aVJ0k85nX/TJd3xYCbMRQ7bWLAbqV7bG2BmdRR/EZhg8Hp9Ors61rJ5ebe9VdxryNV1+11UODBALhVRnZTn66I5KSVtFclbssOIaRVlcbN7IACgRmDS4mtj17W3dgQPk+a4dS2ykQgNeah2qnlh60exu3fPMOb6dcRUa075bhbAoJBMKr0jNzOVYNn/S9kPHbV9Gy8rj1nZC+VlBg5OwJoEAAp+Z/7O7oIHZvkbWTAHNzISICevSw5vymlBQICfFaIDA75cOqq3jm479S0iqaWRffabv/BwkEwqvMzsbFSWOIqjzBuO2rPbY3S5s2GZ8DJdmci/m0uq11Z7qV7ba29paba6TFDg2tf19fioqCgQO90k8wI+PUIjM/WbGA/iU7mXHlLzjcsrXt/h8kEAivMjsbVyYMojSqHRNzl3lsb5YCbOioyT2EtH0Xuhw9YG3tzeqho7UNH27UCM46ar5+MzJy3OuhJ5bu4lffvcUH/cbyeZ+RgP3+HyQQCK8yOyGrQ0L5tM9oLstbSTRVzXsY6ebN0LkztG9vdUkaxXwqLYw2ckl2K9vjsd1vqqqMWdl2CgT798POnU0+xLwVRhBQuoY/ffI85eGRPHb5TwD/ZVVtDAkEwqtq50ZZ3O8iWlUe55+dSpv3MNIAGzFkOmMIqSsQ+P1pdccOqKy0TyDwwtKVZmXitrWfkOrczJOX/Yj9raIBbJnfTAKB8DpzGOncub+DmBhGrl5idZF8R+uADQRm7W2na1JZt4O7rXlatcuIIdPgwUbH9Xn2E3Q+UsqDS9/gm+5DWThwvHu73YIANCzXkBBNExYGU6bA/PnGqJqWLa0ukfft2QOHDgVkIDBvSOmZuRxq0YoBFSXWPK3aLRBERMCQIU2uEZid7Y99/jIRNVU8OuEXxqxzICrcns/e9iyVaD6uvx6OHDGm1TdHAdpRbDKHkBZ3jKfz7kJrhpBu2QIdO0KHDv4977kMH07lylWMf2Jxo9cxfvS9HK7c+j1Xb/2OOWNupbD9qfW8nrp+8DneaR0JBMK3Lr3UGJL34YdWl8Q3AjwQmENIN0fH0fOA05ohpHYaMeTy9bDLCS8/Rton/0bT8EXjZ2TkoI4c4fHPXmJzbA9eHZ7m8bodm4VAAoHwtZYt2T38InbPfYeev/uw+aWc2LjRSJscF2d1SZrEHEKa3yEex5ESok5W+HcIqdbGz9BmczAe3teOjAGX8JOVC+h+sBho2DrGb63YxW+//jedjx7goavupSr0VOv72ZadtAMJBMKnMrKd/KNVP7qW7aVPaUHzSzmxYQMkJ7vbgAONOVQ0L8ZYG6rXAeP34vTXENKSEiPZ3MCB/jlfAxWXVfDUuP+jMjSc33/xisf2cxlctJk71nzEm8OuZV2cZy3HbkNGa5NAIHwqPTOXzB4XAHCZa42CZpNyQmsjEAwaZHVJmswcKpofEw9A4n5j+XAFPg/WGdlO7n30PwDct/6ErR4O4qIj2dcmhr9eeAuX569ifN5KAEKUOns5KyuZnfk39rSJ4c9jPVfyVdi3WQgkEAgfKy6rYG+bjuR0TmR83iqP7QGvuBgOHgzoQDB9QhIKKGjflSoVQu/9RQBo8GmwNvsmogvyAPiuZRdb1RTNobVvpE4ir0M8M794mRZVJ6nWmunvrjujnBnZTl6a9DOSSgr4/ZU/41gLz8yit42ydgWy+lgaCJRSNymlNiqlapRSqVaWRfiG+cT5Re8RXFC8hfblhzy2B7QNG4zPycnWluM8pKU40EBlaDgF7bu6awTg22Bt9k30LS3kcItW7GvdwVY1RXNiZHVYODOv+Cndy/Zwz4oFAFRWax7/4NQiihlrish6dDZ3ff4mHyWN4YveI92vhSrFtFHdmJVm778Rq2sEG4Drga8tLofwEfPJ6ovEEYTqGi7ZscaWU+ybJMdY4zeQawRwqhNze4d4d40AfBuszSDTp7SQbTEJ7j4WO9UU01Ic1GhY1mMoHyWN4RfL3yH+0F4ADpZXGjsdPkz47dOY9fELrEhINuYMuLSPCif/6Ym2DwJgcSDQWm/WWtvjEUD4hPlkdTBpEPtatWdSwWpbTrFvkg0boGtXiImxuiTnZfqEJMJDFHkxCfQ4WExoTTXhIcqnwdoMMn1KC9nasdsZ2+3mj+PvpkYpHl3ymnvbl//7lKPJQ7lq8zc8c/Ed/PAHj1MW2db9ujtYBACrawQNppS6RymVpZTKKikpsbo4ohHSUhx8+8jldLr5ei4rWEPaoE5WF8k7Aryj2IMyOowjaqqM5HM+HgQ1fUIScSePEFNxmDxXILBzTbG4bSdeGD2Vq7d+x8XbV3Nb9mIunHYtRw8c4pZbnuLvo3+AVgFzOz2Dz0uulPpcKbWhjo/rGnMcrfXLWutUrXVqbGysr4orfGjFgNFw+DC33PHnwJ9PUF1tjH9vBoEgPTOXymrtHkKauL+Iymrt0/b6tBQHfxpgjLHf1rEbjuhIW9YU20eFu79+dfgUdrTvyj/fe4o/fvp3lndLZuJdf2NlQt1/A9GR4XVutyOfBwKt9eVa60F1fLzv63ML+8jIdvLzvR04ERrG+PyVgT+fYPt2I39SAHcUm8x2+e0djJtw4oFdHtt9ZezJfQD8+9m7WPbQeNsFAYCZk07NbzgZFs4frvgZ1SEhPHPxHdx502MciGp31vc+NtlecyPOJXDrMiKgpGfmsl9FsLzbYMY3h/kEzaSjGE61yx9u2Zp9rdrTu7TIY7svZGQ7WfCfTzkcEcWY/1i4RGY90lIcTBvVzd1S9k3PC0i+b/45m4IUMG1UN1sGtrOxevjoFKVUETAa+EgplWlleYTvmE+XXyQOJ/GAk57+nsHqbRs2GCNdbJYaoSnMkV1gzDBOPLDLp+315hyCuOLt5HVMwHnouK1rh7PSknlu6lBCXSObztUXEKoUz00dGhAjhWqzetTQe1rreK11C611Z631BCvLI3zHfLpc0nsEgHumpj9msPpETg706gWtWlldkvNmjuxqHxVOfowxhLRFqO96i805BL1Ld7EtxugotnvtMC3FwbM/GOIOmHVRwLM/GBJQNQGTNA0JvzBnsBa168yWjt3d6SZ8PYPVZ5rTiCGX45U15MUk0PbEMcJLS3z2lF5cVkH78kPElpd5DB210xyCupgBs65OYIUxezgQgwBIIBB+Ys5gBVjSezjDizbS9vhRwP43gDMcPw7btjWLjmJT7SykYHQYV1RW89iijfW8s/HioiPp45rBnBcAcwhqS0txsHbmlcyZOhRHdCQKY0JeIDYH1SaBQPiNOYP1i8QRhNdUM3ZHNhAYNwAPW7YYw0ebUY3ADMZm8jlzhnFZRaXXawXTJyQx8KARCLYGwByCupjLse6YfY1tRzw1hgQC4Tdmp2R2XBIHW7ZhfP7KgLsBAM0ix9DpzGC8u01HjoW39Mg55Iumu6T9uzgaEcnuNh2Jjgy35RyCYCKBQPiN2cbatUNrliamctmO1Tx93YDAuwHk5EB4OPTpY3VJvMYdjJUiPyaexFo5h7zZdGeOGErYu9OYwKYUJ6pqvHZ80TQSCIRfmVXqKb//CdHlh0k7sav+N9nNhg3Qr58RDJqJtBSHexZtXkyCRyDwZtNd7ayjZrOQ3UcMBQMJBMIaEyZAaCh89JHVJWmUjGwne77LIqO6Q+CnyTjNzEkDiQwP9Vi20ttNd8VlFURXHCb2WJl76Ki5XVhHAoGwRnQ0jBkDixdbXZIGy8h28sf/LqdL2T62duwe+GkyTuPOFNstEYBRlaVeb7uPi46kT2khYOQYqr1dWEcCgbDMhqEXwbp1jP75mwHxdP3Yoo0k7N4BwJbYHkDza9ZIS3Hw1CM3AfD6qDZe77+ZPiGJAQeN3/O2AB0x1BxJIBCWyMh28shxI9vluO1Ztn+6zsh2UlZRSb/SnQBsje3ufq3ZNWv07m00223e7PVDp6U4uKPdUcojWrK7bUfbZh0NNmFWF0AEp/TMXJzR8RS1jeXS7Vm8NfQq99O1HW8K5tKEfUsKOBoRibPtqVToza5ZIyICEhON+RI+kFhSCEOS2f6nST45vmg8qREISxSXVYBSfJk4nDE71xJRVXlquw2Zq00llRawtWM3j8RjzbJZo18/nwUCNm1qFsn6mhMJBMIS5lP0l71SaVV5nBG7NnhstyWtSSopILdjd4/NdqzBnLf+/WHrVqiq8tohM7KdXDXzfdi9mxf3tbBtM2AwkkAgLGHOMv6u+2COh0UwPn+VrTsNoyPDiT1WRoeKw+S6OorN7c1Sv35QWQk7dnjlcOZEslb5WwHIatXV1n1CwUYCgbCEOVQxJrY933dL5oqd9l7U/rHJAxm4vwCAXFdHcXiICqhVqBqlXz/js5c6jGtPJAPYFpPQ7EZcBTIJBMIy5izjo5ddScJ+J3P+8RGJDy9mRkaO1UU7Q1qKgwfijH6CbR2744iOJP2mwMw93yBmIPBSP4HZ99OntJDy8BY423Xy2C6sJaOGhKVmZOSwNCSRScD4/Cxe7+Bg7nLjqdFuaX2TDxZCp05k/e02q4vie9HR0KWL1wJBXHQkzrIK+pQWkheT4O5st3WfUBCxeqnKdKXUFqXUeqXUe0qpaCvLI/zvrRW7KIruwraYBC51LVZjbreTjGwnmz77jmWRXQJi8tv5ysh2sjqqC2syv/PK9U6fkER4qKLP/kL3RLLwUGXbPqFgY3XT0GfAIK31YGAr8LDF5RF+Vq2N5Wq+7JXKyF0biDpZ4bHdDjKynTyyYB099u4kt2MP209+O19mx+6mdnEk7i/CebDcK9fbpuIoXY4eOJVjyD6/4qBn9ZrFn2qtzfFpy4F4K8sj/M9cEPzLxOFE1FRx0c61HtvtID0zl44lxURVnnB3FDfnjs7aq5W1O3GM2GNl53296Zm59NhnNPmZWUcra3Sz/RkGGqtrBLX9H/Dx2V5USt2jlMpSSmWVlJT4sVjCl24ZaaSZWBU/gCMRkYzbnuWx3Q6KyypIKjVGDG3t2IxTS7iY15UXY/wOEg/s8tje1GP22X9msrnm+jMMND4PBEqpz5VSG+r4uK7WPo8CVcC8sx1Ha/2y1jpVa50aGxt7tt1EgJmVlsy0Ud3QYeF80yOFS7dnMW1kgq06iuOiI0kq2Qngsdh6c+3oNK/LXLbSXJsgOqrpcybaRYbTt7SQirAWFLlGDNU+l7CWzwOB1vpyrfWgOj7eB1BK3QlcC9ymtY0ahoXfzEpLJv/piUx86Ed0PbKfWT3ttWLVpf1i6VdSwK52nTnWIgpo3hkzzY5dc9nK3q5lK48er2pSP0FGtpNjJ6tcI4bi3SOGwkOks9gurB41dBXwIDBZa11uZVmEDVx9tfHZRmsUZGQ7WbDaydDiXHI6G3n6FXDDMEeznUOQluKgVUTYGctWNrVNPz0zl8pqTZ/SQo9modYtw5rtzzDQWN1H8ALQBvhMKbVWKfWSxeURVurSBYYNs9WqZemZuUTv30P84X2sSjBmEWvgyy3Nu5/qUIUxeS4vJoG+pQXgqqw7m9CmX1xWgePQProe3c9GVzAFKHMl8hPWs3rUUG+tdYLWeqjr46dWlkfYwDXXwPLlsH+/1SUBjJvY8CIjBfXK+IEe25szs+1+taM/XY4eoMfBYsCoDTW2eSguOpKLdmYD8E2PoWecQ1jP6hqBEJ6uuQZqauCTT6wuCWDcrIYXbeJIRCRbOvX02N6cTZ+QhAKWdR8CwEUF6wCjNtTY5qFL+8Uyduda9rbu4B511Zz7WAKRBAJhL6mp0LkzvP++1SUBjBviyKJNZMf1ozokFAiOm1haigMN7GwfR1HbWMa45ndA42pDGdlO3ltVyJida/mmRwoo1ez7WAKRBAJhLyEhMGWK0WFcbv34gbTukfQt2cmWPkNREFRLKzqiI0EplnUfyoUF6wipqQYaVxtKz8ylV9E22h8/4m4WCoY+lkAjgUDYzw03wLFjkJlpdUlg2TIA7nn0h+yYfQ3LHhofFEEATq0ZsazHUNqdOMagvfmNrg0Vl1Uw1tU/sKxW/0Bz72MJNBIIhP1ccgnExMCCBVaXBL79FsLDYcQIq0vid+aaEduTjWu/eu+mRteG4qIjGbszm02delLaqr3HdmEfEgiE/YSHw3XXwQcfwIkT1pblm2+MfovI4LxxpaU4+NGNo8nr0pPkLatIz8xt1Kihh8bGM6xoM1/3SHFvC4Y+lkAjgUDY0403wuHD8Pnnlpw+I9vJpU9+zMkVq5gb3q3ZZhqtj5mJdGn8YIYXbaK0pKxRmUgnlW0joqaKLYNGBl0fSyCRhWmEPV12GZWt2/LpzL/xy2+MpoTpE5L8cgMxb35D8tcSUVPFktgkvl9orJoWbDcwMxPptz2G8qOs90l1bmZZj6GkZ+Y27Gfx2WfQsiVzXriXOUFaqwoEUiMQtpSxsYTFPYczZuMyQqur/LoGgHnzSy3aRA2KrPgBzTrt9LmYnborEwZRGRLqThPe4M7eTz+Fiy8O2qa1QCGBQNhSemYuH/YZTfTxo4wuXA/4bw0A8yY3YtdGcmO7c7hla4/twcTs1C2PiGRNXD/GFKz12H5ORUWweTNccYUPSyi8QQKBsKXisgq+7pHC0YhIrs79zmO7r8VFRxJaU80FxVvIih/gsT3YmENIwRj+OWhPPl2qyhvW2fvZZ8bnK6/0YQmFN0ggELYUHRXOifAWLEkczpXbvndPZjqfnPgNdWm/WAbs20HrkxWscuUXCtaRLuYQUkd0JN91H0IImue7HGx4/0DnzpBsn7UlRN0kEAhbMlem+LjvhXQsP8QIV+I3X69YYaadTq2VaC7YUyKkpThY9tB43v3XfdC6NSPys+t/U02NEQiuuAJstOyoqJsEAmFLZhrkpb1SqQhrwdW5xgzfsgrfpi42O4qH79rIrnad2dO2o6REMIWHw7hxDRvSu24dlJZKs1CAkEAgbMlsj6+IaMnSXsO4auv3KF3TpDTIjVFcVgFaM7xoE6tq9Q8EY0dxXdb3S4W8PC762b8YM3tJnb+LjGwnf3/k7wBM3twyaOdgBBIJBMKWzDTIAB8njaHz0QNc4NzSpDTIjREXHUmPg8XElpe5+wfM7cEuI9vJo0e6ADC6YG2dQ3rNORiDN69ic2wP1tdE+W3Yr2g6q5eqfFIptd61OtmnSqk4K8sj7MNMgwywJHE4J0LDmOhqHvLl0/n0CUmM2b0ZOLUQTbB2FJ8uPTOXnHYO9rVqz0U7jfUJTh/S+9iijejyYwwv2si3riRzwToHI5BYXSNI11oP1loPBT4E/mBxeYSNOFxP4UdbRPF1zwu4Kvc70NqnT+dpKQ7uUcUcbNWO7THxkhKhluKyClda6iGMKViL0jWntmPUBsoqKhmxayMtqquM9Qdqv1fYltVLVR6u9W0rwMdjQkQgqT2G/ZO+Y3AcKWFESb7Pn867b1pN+ysuZcefrg2qtNP1MQPwsh5D6Vh+iKSSAo/t5lP/2J3ZnAgNY2WCNK0FCqtrBCil/qiU2gXcxjlqBEqpe5RSWUqprJISGcERDGqPYf+8z0gqQ0KZmLuM++evPWtH5XnbvRvy8+Gii7x/7ADnXp/AtXzlmJ1rURjzLuDUwvYX7VzLqviBHA9v6fFeYV8+DwRKqc+VUhvq+LgOQGv9qNY6AZgH/PJsx9Fav6y1TtVap8bGxvq62MImzDHsj//wIr5NHMY16z4jouqk73IPffut8XnsWO8etxlIS3FwwzAHe9rGkt8hnosK1qKBz7/dwrcvv82PV2Xwlw+fpX/JTr7peapZSKngS9YXaHyefVRrfXkDd50HLAZm+rA4IkClZ+bS/YLJ/HfbDK7buJS3h1zp7oT06k3mm28gKgpSUurfNwh9uaUEjbGo/dT1mXz7j7uIP2zU0C8C9rTuwGe9R/B+/3Hu9/h6EqA4f5amoVZK9dFab3N9ex2wxcryCPtyllXg7D6EjZ168eNV7/HO4MvRKsTdHOE133wDo0cbk6fEGcxO3wWDxjNk91Z2to/jPxf0ZFOnXmzq1Iv9raLPeI9D+gdsz+r1CGYrpZKAGqAA+KnF5RE2FaoU1cArI6Yw58NnuWT7apYmDgeM0SpeqRWsXw9r18Izz5z/sZqpuOhInGUVrItL4rofPlfv/jL0NjBYPWroBq31INcQ0klaa5l1IupU7Wpf+LDfWHa3juHHq95zv/bwwvXeOcmcOUaz0N13e+d4zVDtkVz1kaG3gcPyUUNCNITZvFAVGsbrqdcxpmA9A/fmA1BRWcOMjJzzO8GePTBvHtx5J3TocJ6lbb5qj+Q6F0d0pAy9DSASCERAqJ1y4n9DJ3AkIpIfrTxVK3hrxa4mH3tGRg7P3/gbak5WclnV0PMPKs2cOZJrztShhIecmVk0PFRJc1CAkUAgAkJaioPbRnUD4EiLVvxvyAQmbf6arq4RK9VNHJoyIyOHd77Zxm1rPuKL3sPJbx/H3OWFEgwaIC3FQfpNQ4iOPNWx3j4qnPQbh0hNIMBIIBABY1ZaMuYD6L9SJwNw5+oP3K83ZU7BvOWFTNn4JTEVh3lteJp7+/nUMIJJWoqDtTOvZOfsa9g5+xqy/3ClBIEAJIFABJRbRxq1guK2nfio31huWfsJrU+UA/D4BxsbdawZGTlorbk76302durF8oRTK2k1tYYhRCCSQCACyqy0UzfrV0ZMoe3JcqauywTgYHllo2oFb63YxSU71tBn/y5eHZ7msZJWqKyqJYKIBAIRcMwRKxu69Ob7bsn8X9YiwqqrACMNckNVa83dqzLY27oDH/b3TClxy8gE7xVYCJuTQCACTu0RKa8Mn4LjSIl7rYKyiobXCvqXFnDxzmzevOBaKkM9ZxLXrnkI0dxJIBABJy3F4R6p8mViKnkd4vn5928TefI40PC+glk7P6cirAX/HXqVx/ZprtFJQgQLCQQiID022ch1r1UIs8fdRZ/9u/jXu48RefI4B8sbsMD93r0M+3Yx6y+bzJGodoDRLzBtVDepDYigY3WuISGaJC3FwX3z1wLweZ+R3H/tAzz34bO88e5j3HVjAxLY/uMfcOIEI//6JPlJMvlJBDcJBCJgRUeGU1ZhPP0vGnAJGpjz4bP8Z8Hj8MRV0Lq1x/4Z2U7SM3OJzt3A3Hf+yomLLqOLBAEhpGlIBK7HJg/0SHHwwYBL+M3k6aQ4N8PVV8ORI+7XMrKd/Pdv7/L4qw/x0Ru/JrSqknv7TvLNKmdCBBipEYiAZc5gTc/MpbisgrjoSC6deS8htw2DW26Bq6/mw9mv8dHcT7gl803e3pnNwZZt+PPYafz7gms53LI1xd5e2EaIACSBQAS0tBTHmTfylJtAKWpuvpkLJ4zg2vLDlEa14+lxdzJ36ESOtYhy71rs7YVthAhAEghE83Tjjcy4+fdM++xNXhg1lf8OneCxmLopTlbPEkICgWi+3opP5b93pZ71dVk9SwiDLTqLlVIPKKW0Uqqj1WURzce5nvZl9SwhTrE8ECilEoArgUKryyKal7qWVYwMD2XO1KGyepYQtVgeCIDngAcByfsrvKr2sooKqQUIcTaW9hEopa4DnFrrdaqetL9KqXuAewC6dZNcMKJh6hxVJITw4PNAoJT6HOhSx0uPAo9gNAvVS2v9MvAyQGpqqtQehBDCS3weCLTWl9e1XSmVDPQEzNpAPLBGKTVCa73H1+USQghhsKxpSGudA3Qyv1dK7QRStdalVpVJCCGCkR06i4UQQljINhPKtNY9rC6DEEIEI6V14PW7KqVKgIImvr0jEGzNT3LNwUGuOTiczzV311rHnr4xIAPB+VBKZWmtz553oBmSaw4Ocs3BwRfXLH0EQggR5CQQCCFEkAvGQPCy1QWwgFxzcJBrDg5ev+ag6yMQQgjhKRhrBEIIIWqRQCCEEEGu2QYCpdRVSqlcpVSeUuqhOl5voZSa73p9hVKqhwXF9KoGXPNvlFKblFLrlVJfKKW6W1FOb6rvmmvtd4Nr8aOAHmrYkOtVSv3A9XveqJT6r7/L6G0N+LvuppT6UimV7frbnmhFOb1JKfW6UmqfUmrDWV5XSqnnXT+T9UqpC87rhFrrZvcBhAL5QC8gAlgHDDhtn58DL7m+vhmYb3W5/XDNlwJRrq9/FgzX7NqvDfA1sBwjn5XlZffh77gPkA20d33fyepy++GaXwZ+5vp6ALDT6nJ74bovBi4ANpzl9YnAx4ACRgErzud8zbVGMALI01pv11qfBP4HXHfaPtcBb7q+fhe4TNW3KIK91XvNWusvtdblrm+XY2R8DWQN+T0DPAn8CTjuz8L5QEOu98fAi1rrgwBa631+LqO3NeSaNdDW9XU7oNiP5fMJrfXXwIFz7HId8G9tWA5EK6W6NvV8zTUQOIBdtb4vcm2rcx+tdRVwCIjxS+l8oyHXXNvdGE8Ugazea3ZVmRO01h/5s2A+0pDfcV+gr1JqmVJquVLqKr+Vzjcacs2PAdOUUkXAYuBe/xTNUo39fz8n2ySdE/6jlJoGpAKXWF0WX1JKhQB/Ae60uCj+FIbRPDQOo8b3tVIqWWtdZmWhfOwW4A2t9bNKqdHAf5RSg7TWNVYXLFA01xqBE0io9X28a1ud+yilwjCqlPv9UjrfaMg1o5S6HGN1uMla6xN+Kpuv1HfNbYBBwFLXehejgEUB3GHckN9xEbBIa12ptd4BbMUIDIGqIdd8N/A2gNb6e6AlRmK25qxB/+8N1VwDwSqgj1Kqp1IqAqMzeNFp+ywCfuj6+kZgiXb1wgSoeq9ZKZUC/BMjCAR62zHUc81a60Na645a6x7aSHO+HOPas6wp7nlryN91BkZtAKVUR4ymou1+LKO3NeSaC4HLAJRS/TECQYlfS+l/i4A7XKOHRgGHtNa7m3qwZtk0pLWuUkr9EsjEGHXwutZ6o1LqCSBLa70IeA2jCpmH0Slzs3UlPn8NvOZ0oDXwjqtfvFBrPdmyQp+nBl5zs9HA680ErlRKbQKqgela64Ct6Tbwmh8AXlFK3Y/RcXxngD/UoZR6CyOgd3T1fcwEwgG01i9h9IVMBPKAcuCu8zpfgP+8hBBCnKfm2jQkhBCigSQQCCFEkJNAIIQQQU4CgRBCBDkJBEIIEeQkEAghRJCTQCCEEEFOAoEQXuDKh3+F6+tZSqm/WV0mIRqqWc4sFsICM4EnlFKdgBQgYGdsi+AjM4uF8BKl1FcYKTzGaa2PWF0eIRpKmoaE8AKlVDLQFTgpQUAEGgkEQpwn18pQ8zBWjTraDBaDEUFGAoEQ50EpFQUsBB7QWm/GWBZzprWlEqJxpI9ACCGCnNQIhBAiyEkgEEKIICeBQAghgpwEAiGECHISCIQQIshJIBBCiCAngUAIIYLc/wN0/gnNvBOnggAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "X_grid = torch.from_numpy(np.linspace(0,1,50)).float().view(-1, d)\n", "y_hat = neural_network(X_grid)\n", "plt.scatter(X.numpy(), y.numpy())\n", "plt.plot(X_grid.detach().numpy(), y_hat.detach().numpy(), 'r')\n", "plt.title('plot of $f(x)$ and $\\hat{f}(x)$')\n", "plt.xlabel('$x$')\n", "plt.ylabel('$y$')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## CrossEntropyLoss\n", "So far, we have been considering regression tasks and have used the [MSELoss](https://pytorch.org/docs/stable/nn.html#torch.nn.MSELoss) module. For the homework, we will be performing a classification task and will use the cross entropy loss.\n", "\n", "PyTorch implements a version of the cross entropy loss in one module called [CrossEntropyLoss](https://pytorch.org/docs/stable/nn.html#torch.nn.CrossEntropyLoss). Its usage is slightly different than MSE, so we will break it down here. \n", "\n", "- input: The first parameter to CrossEntropyLoss is the output of our network. It expects a *real valued* tensor of dimensions $(N,C)$ where $N$ is the minibatch size and $C$ is the number of classes. In our case $N=3$ and $C=2$. The values along the second dimension correspond to raw unnormalized scores for each class. The CrossEntropyLoss module does the softmax calculation for us, so we do not need to apply our own softmax to the output of our neural network.\n", "- output: The second parameter to CrossEntropyLoss is the true label. It expects an *integer valued* tensor of dimension $(N)$. The integer at each element corresponds to the correct class. In our case, the \"correct\" class labels are class 0, class 1, and class 1.\n", "\n", "Try out the loss function on three toy predictions. The true class labels are $y=[1,1,0]$. The first two examples correspond to predictions that are \"correct\" in that they have higher raw scores for the correct class. The second example is \"more confident\" in the prediction, leading to a smaller loss. The last two examples are incorrect predictions with lower and higher confidence respectively." ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "tensor(0.1269)\n" ] } ], "source": [ "loss = nn.CrossEntropyLoss()\n", "\n", "input = torch.tensor([[-1., 1],[-1, 1],[1, -1]]) # raw scores correspond to the correct class\n", "# input = torch.tensor([[-3., 3],[-3, 3],[3, -3]]) # raw scores correspond to the correct class with higher confidence\n", "# input = torch.tensor([[1., -1],[1, -1],[-1, 1]]) # raw scores correspond to the incorrect class\n", "# input = torch.tensor([[3., -3],[3, -3],[-3, 3]]) # raw scores correspond to the incorrect class with incorrectly placed confidence\n", "\n", "target = torch.tensor([1, 1, 0])\n", "output = loss(input, target)\n", "print(output)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Learning rate schedulers\n", "\n", "Often we do not want to use a fixed learning rate throughout all training. PyTorch offers learning rate schedulers to change the learning rate over time. Common strategies include multiplying the lr by a constant every epoch (e.g. 0.9) and halving the learning rate when the training loss flattens out.\n", "\n", "See the [learning rate scheduler docs](https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate) for usage and examples" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Convolutions\n", "When working with images, we often want to use convolutions to extract features using convolutions. PyTorch implments this for us in the `torch.nn.Conv2d` module. It expects the input to have a specific dimension $(N, C_{in}, H_{in}, W_{in})$ where $N$ is batch size, $C_{in}$ is the number of channels the image has, and $H_{in}, W_{in}$ are the image height and width respectively.\n", "\n", "We can modify the convolution to have different properties with the parameters:\n", "- kernel_size\n", "- stride\n", "- padding\n", "\n", "They can change the output dimension so be careful.\n", "\n", "See the [`torch.nn.Conv2d` docs](https://pytorch.org/docs/stable/nn.html#torch.nn.Conv2d) for more information." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To illustrate what the `Conv2d` module is doing, let's set the conv weights manually to a Gaussian blur kernel.\n", "\n", "We can see that it applies the kernel to the image." ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# an entire mnist digit\n", "image = np.array([0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0.3803922 , 0.37647063, 0.3019608 ,0.46274513, 0.2392157 , 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0.3529412 , 0.5411765 , 0.9215687 ,0.9215687 , 0.9215687 , 0.9215687 , 0.9215687 , 0.9215687 ,0.9843138 , 0.9843138 , 0.9725491 , 0.9960785 , 0.9607844 ,0.9215687 , 0.74509805, 0.08235294, 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.54901963,0.9843138 , 0.9960785 , 0.9960785 , 0.9960785 , 0.9960785 ,0.9960785 , 0.9960785 , 0.9960785 , 0.9960785 , 0.9960785 ,0.9960785 , 0.9960785 , 0.9960785 , 0.9960785 , 0.9960785 ,0.7411765 , 0.09019608, 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0.8862746 , 0.9960785 , 0.81568635,0.7803922 , 0.7803922 , 0.7803922 , 0.7803922 , 0.54509807,0.2392157 , 0.2392157 , 0.2392157 , 0.2392157 , 0.2392157 ,0.5019608 , 0.8705883 , 0.9960785 , 0.9960785 , 0.7411765 ,0.08235294, 0., 0., 0., 0.,0., 0., 0., 0., 0.,0.14901961, 0.32156864, 0.0509804 , 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.13333334,0.8352942 , 0.9960785 , 0.9960785 , 0.45098042, 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0.32941177, 0.9960785 ,0.9960785 , 0.9176471 , 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0.32941177, 0.9960785 , 0.9960785 , 0.9176471 ,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0.4156863 , 0.6156863 ,0.9960785 , 0.9960785 , 0.95294124, 0.20000002, 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0.09803922, 0.45882356, 0.8941177 , 0.8941177 ,0.8941177 , 0.9921569 , 0.9960785 , 0.9960785 , 0.9960785 ,0.9960785 , 0.94117653, 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0.26666668, 0.4666667 , 0.86274517,0.9960785 , 0.9960785 , 0.9960785 , 0.9960785 , 0.9960785 ,0.9960785 , 0.9960785 , 0.9960785 , 0.9960785 , 0.5568628 ,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0.14509805, 0.73333335,0.9921569 , 0.9960785 , 0.9960785 , 0.9960785 , 0.8745099 ,0.8078432 , 0.8078432 , 0.29411766, 0.26666668, 0.8431373 ,0.9960785 , 0.9960785 , 0.45882356, 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0.4431373 , 0.8588236 , 0.9960785 , 0.9490197 , 0.89019614,0.45098042, 0.34901962, 0.12156864, 0., 0.,0., 0., 0.7843138 , 0.9960785 , 0.9450981 ,0.16078432, 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0.6627451 , 0.9960785 ,0.6901961 , 0.24313727, 0., 0., 0.,0., 0., 0., 0., 0.18823531,0.9058824 , 0.9960785 , 0.9176471 , 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0.07058824, 0.48627454, 0., 0.,0., 0., 0., 0., 0.,0., 0., 0.32941177, 0.9960785 , 0.9960785 ,0.6509804 , 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0.54509807, 0.9960785 , 0.9333334 , 0.22352943, 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0.8235295 , 0.9803922 , 0.9960785 ,0.65882355, 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0.9490197 , 0.9960785 , 0.93725497, 0.22352943, 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0.34901962, 0.9843138 , 0.9450981 ,0.3372549 , 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.01960784,0.8078432 , 0.96470594, 0.6156863 , 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0.01568628, 0.45882356, 0.27058825,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0., 0.,0., 0., 0., 0.], dtype=np.float32)\n", "image_torch = torch.from_numpy(image).view(1, 1, 28, 28)\n", "\n", "# a gaussian blur kernel\n", "gaussian_kernel = torch.tensor([[1., 2, 1],[2, 4, 2],[1, 2, 1]]) / 16.0\n", "\n", "conv = nn.Conv2d(1, 1, 3)\n", "# manually set the conv weight\n", "conv.weight.data[:] = gaussian_kernel\n", "\n", "convolved = conv(image_torch)\n", "\n", "plt.title('original image')\n", "plt.imshow(image_torch.view(28,28).detach().numpy())\n", "plt.show()\n", "\n", "plt.title('blurred image')\n", "plt.imshow(convolved.view(26,26).detach().numpy())\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As we can see, the image is blurred as expected. \n", "\n", "In practice, we learn many kernels at a time. In this example, we take in an RGB image (3 channels) and output a 16 channel image. After an activation function, that could be used as input to another `Conv2d` module." ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "im shape torch.Size([4, 3, 32, 32])\n", "convolved im shape torch.Size([4, 16, 30, 30])\n" ] } ], "source": [ "im_channels = 3 # if we are working with RGB images, there are 3 input channels, with black and white, 1\n", "out_channels = 16 # this is a hyperparameter we can tune\n", "kernel_size = 3 # this is another hyperparameter we can tune\n", "batch_size = 4\n", "image_width = 32\n", "image_height = 32\n", "\n", "im = torch.randn(batch_size, im_channels, image_width, image_height)\n", "\n", "m = nn.Conv2d(im_channels, out_channels, kernel_size)\n", "convolved = m(im) # it is a module so we can call it\n", "\n", "print('im shape', im.shape)\n", "print('convolved im shape', convolved.shape)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Useful links:\n", "- [60 minute PyTorch Tutorial](https://pytorch.org/tutorials/beginner/deep_learning_60min_blitz.html)\n", "- [PyTorch Docs](https://pytorch.org/docs/stable/index.html)\n", "- [Lecture notes on Auto-Diff](https://courses.cs.washington.edu/courses/cse446/19wi/notes/auto-diff.pdf)\n", "\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.6.7" } }, "nbformat": 4, "nbformat_minor": 2 }