From d9a33e5214270fedbc499b2ef1971aa1dd1fe918 Mon Sep 17 00:00:00 2001 From: ZHANG Jing Date: Fri, 30 Aug 2024 17:11:31 +0200 Subject: [PATCH] udpate dl_scratch --- deep_learning_from_scratch.ipynb | 197 ++++++++++++++++++++++--------- 1 file changed, 143 insertions(+), 54 deletions(-) diff --git a/deep_learning_from_scratch.ipynb b/deep_learning_from_scratch.ipynb index 5af4a79..218079f 100644 --- a/deep_learning_from_scratch.ipynb +++ b/deep_learning_from_scratch.ipynb @@ -1802,7 +1802,8 @@ "plt.ylabel(\"accuracy\")\n", "plt.ylim(0, 1.0)\n", "plt.legend(loc='lower right')\n", - "plt.show()\n" + "plt.show()\n", + "# Guess why I only run one epoch? -- Because it's too slow!" ] }, { @@ -1851,7 +1852,7 @@ "* Back propagation of Addition Nodes \n", "Take $z=x+y$ as an example, the analytic derivatives of $x$ and $y$ are: \n", "$$\\frac{\\partial z}{\\partial x} = 1\\\\ \\frac{\\partial z}{\\partial y} = 1$$\n", - "The computational graph is as follows: \n", + "The computational graph of *addition* is as follows: \n", "![Addition nodes](./figures/dlscratch_computegraphchainruleadd.png)" ] }, @@ -1862,7 +1863,7 @@ "* Back propagation of Multiplication Nodes\n", "Take $z=xy$ as an example, the analytic derivatives of $x$ and $y$ are: \n", "$$\\frac{\\partial z}{\\partial x} = y\\\\ \\frac{\\partial z}{\\partial y} = x$$\n", - "The computational graph is as follows: \n", + "The computational graph of *multiplication* is as follows: \n", "![Product nodes](./figures/dlscratch_computegraphchainruleproduct.png)" ] }, @@ -1901,7 +1902,10 @@ ], "source": [ "# multiply layer and add layer\n", - "\n", + "# an example of buying apples: \n", + "# input: number of apples, unit price of an apple, tax of apples.\n", + "# output: total price a customer needs to pay. (forward propagation process)\n", + "# gradient of input variables, gradient of output. (back propagation process)\n", "class AddLayer:\n", " def __init__(self):\n", " pass\n", @@ -1980,6 +1984,7 @@ } ], "source": [ + "# add one mor fruit -- oranges\n", "apple = 100\n", "apple_num = 2\n", "orange = 150\n", @@ -2021,8 +2026,20 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Implemention of activation function\n", - "ReLU（Rectified Linear Unit): \n", + "### Activation function in back propagation\n", + "Why need activation function, after back propagation (calculating gradient/derivative process), you may be clear. If no activation function: \n", + "1. Linear superposition: The output of each layer is the product of the input and the weight matrix plus the bias. Since there is no activation function to introduce nonlinearity, the output of the entire network will only be a series of linear transformations of the input.\n", + "2. Gradient vanishing or exploding: In a multi-layer network, if each layer is linear, the gradients are continuously multiplied during back propagation. If the norm of the weight matrix is ​​greater than 1, the gradient may grow exponentially (gradient explosion), while if the norm of the weight matrix is ​​less than 1, the gradient may decay exponentially (gradient vanishing). This makes weight updates very difficult, thus hindering the training of deep networks.\n", + "3. Gradient Constant: In the absence of an activation function, the gradient of each layer will be constant because the derivative of a linear layer is a constant. This means that the gradient will not change as the depth of the network increases, but it also means that the gradients cannot be propagated effectively because they will not be adjusted for different layers of the network.\n", + "4. Lack of feature learning ability: Activation functions usually help the network learn useful feature representations from the input data. Without activation functions, the network will not be able to do this feature learning because it can only perform simple linear transformations." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ReLU and Sigmoid \n", + "* ReLU（Rectified Linear Unit) \n", "$$\n", "y = \n", "\\begin{cases} \n", @@ -2038,16 +2055,32 @@ "0 & (x \\leq 0).\n", "\\end{cases}\n", "$$\n", - "computational graph \n", + "computational graph of ReLU function \n", "![computational graph](./figures/dlscratch_computegraphrelu.png)\n", "\n", - "Sigmoid: \n", + "* Sigmoid: \n", "$$y=\\frac{1}{1+\\exp(-x)}$$\n", + "the analytic derivative:\n", + "$$\\frac{\\partial y}{\\partial x} = y(1-y)$$\n", + "computational graph of Sigmoid function, a bit complicated, let's first look at forward progation, which is easy to understand \n", "![computational graph of sigmoid](./figures/dlscratch_computegraphsigmoid.png) \n", + "computational graph of Sigmoid function in back propagation, difficult to understand unless some analytic derivative is recalled \n", "![computational graph of sigmoid](./figures/dlscratch_computegraphsigmoidback.png) \n", + "1. '/' means $y=\\frac{1}{x}$, so its analytic derivative is: $\\frac{\\partial y}{\\partial x}=-\\frac{1}{x^2}=-y^2$\n", + "2. '+' will keep unchanged (e.g. $z=x+y$)\n", + "3. 'exp' means $y=e^x$, so its analytic derivative is still: $\\frac{\\partial y}{\\partial x}=e^x \\text{or} \\exp (x)$, in this case, $\\exp (-x)$\n", + "4. '×' will exchange the variable (e.g. $z=xy$), so here multiply by -1\n", + "\n", "Simplified version \n", - "![computational graph of sigmoid](./figures/dlscratch_computegraphsigmoidbacksimple.png) ![computational graph of sigmoid](./figures/dlscratch_computegraphsigmoidbacksimple1.png) ![gradient of sigmoid](./figures/gradient_sigmoid.png)\n", - "\n" + "![computational graph of sigmoid](./figures/dlscratch_computegraphsigmoidbacksimple.png) ![computational graph of sigmoid](./figures/dlscratch_computegraphsigmoidbacksimple1.png) \n", + "Because Sigmoid function is $y = \\frac{1}{1+\\exp(-x)}$, so the final formula is shown as follow:\n", + "$$\\frac{\\partial L}{\\partial y} y^2 \\exp(-x) \n", + "= \\frac{\\partial L}{\\partial y} \\frac{1}{(1 + \\exp(-x))^2} \\exp(-x) \n", + "= \\frac{\\partial L}{\\partial y} \\frac{1}{1 + \\exp(-x)} \\frac{\\exp(-x)}{1 + \\exp(-x)} \n", + "= \\frac{\\partial L}{\\partial y} y(1-y)\n", + "$$\n", + "* The above formula is the Derivative of loss function $L$ with respect to $y$ and The derivative of the activation function $y$ with respect to the input $x$\n", + "* Intuitively, the derivative of the sigmoid function tells us that when the input $x$ is very large or very small, the derivative becomes very small (the gradient vanishing problem), and when the input $x$ is close to 0, the derivative is the largest, which helps the model update the weights during training." ] }, { @@ -2087,22 +2120,46 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Implemention of Affine/Softmax\n", - "![affine](./figures/dlscratch_computegraphaffine.png)\n", - "![affinebatch](./figures/dlscratch_computegraphaffinebatch.png) \n", - "![softmaxlayer](./figures/dlscratch_softmaxlayer.png) \n", + "Softmax with loss \n", + "The derivative after back propagation of cross entropy loss and softmax function look beautiful, clean, and very intuitive (shows difference bewteen output and label), why? \n", "![crossentropylayer](./figures/dlscratch_computegraphcrossentropy.png) \n", - "Cross entropy loss and mean square error loss are designed on purpose beause: \n", - "* derivatives\n", - "* derivatives\n" + "Beause: \n", + "* Softmax function $y_i=\\frac{\\exp(a_i)}{\\sum_j\\exp(a_j)}$, derivative is $\\frac{\\partial y_i}{\\partial a_i}=y_i(1-y_i)$\n", + "* Cross entropy loss $L = -\\sum_i t_i\\log(y_i)$, derivative is $\\frac{\\partial L}{\\partial y_i}=-\\frac{t_i}{y_i}$\n", + "* Derivative of L and Softmax: $\\frac{\\partial L}{\\partial a_i}=\\frac{\\partial L}{\\partial y_i}\\cdot\\frac{\\partial y_i}{\\partial a_i}=-\\frac{t_i}{y_i}\\cdot y_i(1-y_i) = y_i-t_i $\n", + "\n", + "Similary, mean square error loss e $L = \\sum_i(t_i-y_i)^2$, derivative is $\\frac{\\partial L}{\\partial y_i}=2(y_i-t_i)$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Affine transformation\n", + "An affine layer is actually a **matrix** of input, weights and bias, nothing new. \n", + "The computational graph below is a batch based affine layer, just to remind that the layer is storing the matrix, not the single elements. \n", + "Many layers in the deep learning library are implemented based on the principle of affine transformation. \n", + "![affinebatch](./figures/dlscratch_computegraphaffinebatch.png) \n", + "So far, we can have a simple network shown as below, affine layer, activation function layer, output layer etc: \n", + "![a simple networkr](./figures/dlscratch_softmaxlayer.png) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### TwoLayerNet case" ] }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ + "import numpy as np\n", + "from collections import OrderedDict\n", + "\n", "class Affine:\n", " def __init__(self, W, b):\n", " self.W =W\n", @@ -2120,14 +2177,14 @@ " x = x.reshape(x.shape[0], -1)\n", " self.x = x\n", "\n", - " out = np.dot(self.x, self.W) + self.b\n", + " out = np.dot(self.x, self.W) + self.b # out=x⋅W+b\n", "\n", " return out\n", "\n", " def backward(self, dout):\n", " dx = np.dot(dout, self.W.T)\n", " self.dW = np.dot(self.x.T, dout)\n", - " self.db = np.sum(dout, axis=0)\n", + " self.db = np.sum(dout, axis=0) # out = wx+b, biases have same influence on all x\n", " \n", " dx = dx.reshape(*self.original_x_shape) # Reshape input data (tensor compatible)\n", " return dx\n", @@ -2147,24 +2204,17 @@ "\n", " def backward(self, dout=1):\n", " batch_size = self.t.shape[0]\n", - " if self.t.size == self.y.size: # When the training data is one-hot vector\n", - " dx = (self.y - self.t) / batch_size\n", + " # When the label is one-hot vector\n", + " if self.t.size == self.y.size: \n", + " dx = (self.y - self.t) / batch_size # y-t\n", + " # when the label is integer\n", " else:\n", - " dx = self.y.copy()\n", - " dx[np.arange(batch_size), self.t] -= 1\n", + " dx = self.y.copy() # y not change\n", + " dx[np.arange(batch_size), self.t] -= 1 # y-t, in this case, the true label t=1\n", " dx = dx / batch_size\n", " \n", - " return dx" - ] - }, - { - "cell_type": "code", - "execution_count": 100, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "from collections import OrderedDict\n", + " return dx\n", + "\n", "def softmax(x):\n", " x = x - np.max(x, axis=-1, keepdims=True)\n", " return np.exp(x) / np.sum(np.exp(x), axis=-1, keepdims=True)\n", @@ -2180,6 +2230,7 @@ "\n", " batch_size = y.shape[0]\n", " return -np.sum(np.log(y[np.arange(batch_size), t] + 1e-7)) / batch_size\n", + "\n", "def numerical_gradient(f, x):\n", " h = 1e-4 # 0.0001\n", " grad = np.zeros_like(x)\n", @@ -2225,7 +2276,7 @@ " self.layers['Relu1'] = Relu()\n", " self.layers['Affine2'] = Affine(self.params['W2'], self.params['b2'])\n", "\n", - " self.lastLayer = SoftmaxWithLoss()\n", + " self.lossLayer = SoftmaxWithLoss()\n", " \n", " def predict(self, x):\n", " for layer in self.layers.values():\n", @@ -2235,7 +2286,7 @@ " \n", " def loss(self, x, t):\n", " y = self.predict(x)\n", - " return self.lastLayer.forward(y, t)\n", + " return self.lossLayer.forward(y, t)\n", " \n", " def accuracy(self, x, t):\n", " y = self.predict(x)\n", @@ -2246,6 +2297,7 @@ " return accuracy\n", " \n", " def compute_numerical_gradient(self, x, t):\n", + " # forward\n", " loss_W = lambda W: self.loss(x, t)\n", " \n", " grads = {}\n", @@ -2258,14 +2310,15 @@ " \n", " def backward_gradient(self, x, t):\n", " # forward\n", - " self.loss(x, t)\n", - "\n", + " y = self.predict(x)\n", + " self.lossLayer.forward(y, t) # loss value is stored\n", + " \n", " # backward\n", - " dout = 1\n", - " dout = self.lastLayer.backward(dout)\n", + " dout = 1 # inital gradient of loss\n", + " dout = self.lossLayer.backward(dout)\n", " \n", " layers = list(self.layers.values())\n", - " layers.reverse()\n", + " layers.reverse() # back propagation start from last layer\n", " for layer in layers:\n", " dout = layer.backward(dout)\n", "\n", @@ -2278,28 +2331,28 @@ }, { "cell_type": "code", - "execution_count": 101, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 1/10 - train acc: 0.1457, test acc: 0.1493\n", - "Epoch 2/10 - train acc: 0.2401, test acc: 0.2372\n", - "Epoch 3/10 - train acc: 0.3420, test acc: 0.3472\n", - "Epoch 4/10 - train acc: 0.3533, test acc: 0.3568\n", - "Epoch 5/10 - train acc: 0.4632, test acc: 0.4681\n", - "Epoch 6/10 - train acc: 0.4877, test acc: 0.4729\n", - "Epoch 7/10 - train acc: 0.5861, test acc: 0.5919\n", - "Epoch 8/10 - train acc: 0.6213, test acc: 0.6187\n", - "Epoch 9/10 - train acc: 0.6805, test acc: 0.6845\n", - "Epoch 10/10 - train acc: 0.7059, test acc: 0.7096\n" + "Epoch 1/10 - train acc: 0.1988, test acc: 0.2030\n", + "Epoch 2/10 - train acc: 0.1126, test acc: 0.1139\n", + "Epoch 3/10 - train acc: 0.3293, test acc: 0.3260\n", + "Epoch 4/10 - train acc: 0.4533, test acc: 0.4442\n", + "Epoch 5/10 - train acc: 0.5738, test acc: 0.5800\n", + "Epoch 6/10 - train acc: 0.5425, test acc: 0.5475\n", + "Epoch 7/10 - train acc: 0.5732, test acc: 0.5756\n", + "Epoch 8/10 - train acc: 0.5913, test acc: 0.5891\n", + "Epoch 9/10 - train acc: 0.6685, test acc: 0.6704\n", + "Epoch 10/10 - train acc: 0.7092, test acc: 0.7108\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAG2CAYAAACDLKdOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABQz0lEQVR4nO3dd3hUVf7H8ffMJDPpgSSQBAgQikBoAQIIiKICseGCqAgoxfJzFRWJuoCFoitgwUUFRVzLWsFVsaEoBrEA0oP03iEJIaSXSWbu749oNEuAkDbJ5PN6nnnM3Hvune9khPlwzr3nmAzDMBARERFxE2ZXFyAiIiJSmRRuRERExK0o3IiIiIhbUbgRERERt6JwIyIiIm5F4UZERETcisKNiIiIuBWFGxEREXErCjciIiLiVhRuRERExK24NNz89NNPDBo0iEaNGmEymfjss8/Oe8yKFSvo2rUrNpuNVq1a8fbbb1d5nSIiIlJ7uDTcZGdn07lzZ+bNm1em9gcOHODaa6/l8ssvJyEhgQcffJA777yTb7/9toorFRERkdrCVFMWzjSZTCxevJjBgweftc3EiRNZsmQJW7duLd52yy23kJaWxtKlS6uhShEREanpPFxdwIVYvXo1/fv3L7EtNjaWBx988KzH5Ofnk5+fX/zc6XSSmppKcHAwJpOpqkoVERGRSmQYBpmZmTRq1Aiz+dwDT7Uq3CQmJhIaGlpiW2hoKBkZGeTm5uLt7X3GMTNnzmT69OnVVaKIiIhUoSNHjtCkSZNztqlV4aY8Jk+eTFxcXPHz9PR0mjZtypEjRwgICHBhZSIiIlJWGRkZRERE4O/vf962tSrchIWFkZSUVGJbUlISAQEBpfbaANhsNmw22xnbAwICFG5ERERqmbJcUlKr5rnp1asX8fHxJbYtW7aMXr16uagiERERqWlcGm6ysrJISEggISEBKLrVOyEhgcOHDwNFQ0qjRo0qbv/3v/+d/fv3849//IOdO3fyyiuv8NFHHzFhwgRXlC8iIiI1kEvDzfr16+nSpQtdunQBIC4uji5dujBlyhQATpw4URx0ACIjI1myZAnLli2jc+fOzJ49m3//+9/Exsa6pH4RERGpeWrMPDfVJSMjg8DAQNLT03XNjYiISC1xId/fteqaGxEREZHzUbgRERERt6JwIyIiIm5F4UZERETcisKNiIiIuBWFGxEREXErCjciIiLiVhRuRERExK0o3IiIiIhbUbgRERERt6JwIyIiIm5F4UZERETcisKNiIiIuBWFGxEREXErCjciIiLiVhRuRERExK0o3IiIiIhbUbgRERERt6JwIyIiIm5F4UZERETcisKNiIiIuBWFGxEREXErCjciIiLiVhRuRERExK0o3IiIiIhbUbgRERERt6JwIyIiIm5F4UZERETcisKNiIiIuBWFGxEREXErCjciIiLiVhRuRERExK0o3IiIiIhbUbgRERERt6JwIyIiIm5F4UZERETcisKNiIiIuBWFGxEREXErCjciIiLiVhRuRERExK0o3IiIiIhbUbgRERERt6JwIyIiIm5F4UZERETcisKNiIiIuBWFGxEREXErCjciIiLiVhRuRERExK0o3IiIiIhbUbgRERERt6JwIyIiIm5F4UZERETcisKNiIiIuBWFGxEREXErCjciIiLiVhRuRERExK0o3IiIiIhbUbgRERERt6JwIyIiIm5F4UZERETcisKNiIiIuBWFGxEREXErCjciIiLiVlwebubNm0fz5s3x8vKiZ8+erF279pzt58yZQ5s2bfD29iYiIoIJEyaQl5dXTdWKiIhITefScLNo0SLi4uKYOnUqGzdupHPnzsTGxpKcnFxq+w8++IBJkyYxdepUduzYwRtvvMGiRYt49NFHq7lyERERqalcGm5eeOEF7rrrLsaOHUtUVBTz58/Hx8eHN998s9T2q1atok+fPowYMYLmzZszcOBAhg8fft7eHhEREak7XBZu7HY7GzZsoH///n8WYzbTv39/Vq9eXeoxvXv3ZsOGDcVhZv/+/Xz99ddcc801Z32d/Px8MjIySjxERETEfXm46oVTUlJwOByEhoaW2B4aGsrOnTtLPWbEiBGkpKRwySWXYBgGhYWF/P3vfz/nsNTMmTOZPn16pdYuIiIiNZfLLyi+ECtWrGDGjBm88sorbNy4kU8//ZQlS5bw1FNPnfWYyZMnk56eXvw4cuRINVYsIiIi1c1lPTchISFYLBaSkpJKbE9KSiIsLKzUY5544gluu+027rzzTgA6duxIdnY2//d//8djjz2G2XxmVrPZbNhstsp/AyIiIlIjuaznxmq10q1bN+Lj44u3OZ1O4uPj6dWrV6nH5OTknBFgLBYLAIZhVF2xIiIiUmu4rOcGIC4ujtGjRxMTE0OPHj2YM2cO2dnZjB07FoBRo0bRuHFjZs6cCcCgQYN44YUX6NKlCz179mTv3r088cQTDBo0qDjkiIiISN3m0nAzbNgwTp48yZQpU0hMTCQ6OpqlS5cWX2R8+PDhEj01jz/+OCaTiccff5xjx47RoEEDBg0axNNPP+2qtyAiIiI1jMmoY+M5GRkZBAYGkp6eTkBAgKvLERERkTK4kO/vWnW3lIiIiMj5KNyIiIiIW1G4EREREbeicCMiIiJuReFGRERE3IrCjYiIiLgVhRsRERFxKwo3IiIi4lYUbkRERMStKNyIiIiIW1G4EREREbeicCMiIiJuReFGRERE3IrCjYiIiLgVhRsRERFxKwo3IiIi4lYUbkRERMStKNyIiIiIW1G4EREREbeicCMiIiJuReFGRERE3IqHqwsQERGRWi7tCOScOvt+n2CoF1Ft5SjciIiISPmlHYG53aAw/+xtPGxw34ZqCzgalhIREZHyyzl17mADRfvP1bNTyRRuRERExK0o3IiIiIhb0TU3IiIicuEyjsOyqRhH12EqQ3OHYWCp8qKKKNyIiIjImZwOOLUPEn+DpK2QuBWa9oRLHwEgvdCDwC0flSnYAGw7lkGnxlVX7l8p3IiIiEiRgjz45h+QuAWSd0Bhbondh0+e5skDl7PjRAbH0nK53XIbTmCa57vnPXVqjr2Kij6Two2IiEhdYRiQfqSoFyZxCyRtAd+GcN0LAOTjgWXbF3jknwYgz2Rjl7MpWx1N2W40Y3NyC7YmJRWfblngDfTyPgqnzh9ugnysVfOeSqFwIyIi4u6+nw5H1haFmbz0ErsyvcKZmjOK7ccz2JucxQ2mG8kyvNlhNOOQEYoTM1aLmdahfkSFBzC0UQBR4QG0DQ8g0NsTx+nD5L/oiY2Cs758Pp60bx1Z1e+ymMKNiIiIq1TWzL5ZJ4uCS+KWol6Zghy45X0ADMPAvmcFtqSNABTiwQFTE34rjGC7synb7c1ZvfFY8am+9R5IVHgAV/weYqIaBdCygR9Wj9JvsLbUb8rP13zL84tXF73eX/b9cT3Ow0N60a9+0/O/j0qicCMiIuIKFZ3Zd81rsOe7ojCTlVhilxMzMz7byG+J+ew4kUHfgkvwpgfbjWbsNRpT8PvXf9MgH6LCA4j7S5AJD/TCZCrrZcJF+vXoRp5PI6Z/uZ0T6XnF28MDvZg6KIp+HcIv6HwVpXAjIiLiCmWd2XfdvyH3NKTshtFfgaXoqzv/0Dpse78HwImJ4+ZwfiuIYJuzGduNZqz89TB2PAH43tKbi8L86BgewLDwAKIaBdI23J8AL89KeztXdQhnQFQYaw+kkpyZR0N/L3pEBmExX1hQqgwKNyIiIjXZyjnFP7795ff8kh7M9uMZtMhsRTPT7exwNmWn0ZQcvAAI9PakfaMARv3eE/PHsJKnpern7bWYTfRqGVzlr3M+CjciIiIuUNZJ7TYYbVntaMN2ZzN+/jWTTBwAHKcjh4N6EhUeQL8KDiu5G4UbERGR6laQS+LKDyjLnHZT7Lexx9ySi8L9uDr8jxBT+cNK7kThRkREpLrkZ8H6N2HVyzTOTi7TIWN6N2PwNbHVMqzkLhRuREREqlpeOqxZgPHrPEy5RRPkJRn1CDWlnffQNqEBCjYXSOFGRESkijk/GI758EpMwAFnKK84/sZuZxM+t00577HtGwdUfYFuRuFGRESksmUmgc2Pk/kevPfrIRKPXswdzoPMLRxMvKU3f4tpxpyOnjg++CcW59nXXHKYrVh8Q6qxcPegcCMiIlJZ0o/CypdwbnibJcG389Cxy7A7nJjows8Bvbitdwue7BFBvT/WWXpgI6u27OK1n/aTkvVnyAnxs3L3pS3o3bFN2WYolhIUbkRERCoq9QDOX/4Fmz7AbBRgBqwn1mF39KVL03rc3ieSqzqEnXntTL0IeveNoGcfo0ZMfucuFG5ERETK6+Ru7D8+j8e2jzEbRfPPrHZE8YpzCPXb92fxJZF0aVr/vKepKZPfuQuFGxERkXI4mJJN1vuT6JAWD8AKR2fe9hhKVJ9Ynu3VjPBAbxdXWHcp3IiIiJSRcWwjG09aeHWznfidybRhAA95pPFZwAguuWwgr0Y3xttalnmHpSop3IiIiJxH/v6VpH4zg/CTv7C78HK+L7wLgPA23fC65Ebmtgqp80se1CQKNyIiIqUxDE5v+57M72bSNGMD4UChYcbTDKMubsroPpG0bODn6iqlFAo3IiIi/2P/mq8wrZhBZO426gN2w8I3HleQ0/0+rrm0Dzf6aE2nmkzhRkREBCh0OPluexJv/nKAvsc+ZrzHNvIMT5b7Xo33ZRO4NiYaDy2DUCso3IiISJ2WnpXH+q/f4OO9Bt9kRAJw0HINHYK9CY+dwDUXXeTiCuVCKdyIiEidtC/xNJuXLKDr4be40nQCP2db1vj+k5E9m3Lrxc0IDbjZ1SVKOSnciIhInWEYBit3HWPfd69x5akPuMGUAibIMPnj03YAq4ZeipfN5uoypYIUbkRExO3l2h0s3nSMgyve5vacN7nEdBpMkG6pz+nOd9Ms9j462vxdXaZUEoUbERGptRzOc6/JdCI9l3dXH+KDtYdJyyngb+ZcwqynyfBsQMHFDxB86V0EemomYXejcCMiIrVP2pFzrqYdEBzGOxtTabTzP5w0gkhz9CMiyJtOPceS69uBgOgbwUPDT+7KZBiG4eoiqlNGRgaBgYGkp6cTEBDg6nJERORCpR3B8VJXLE77WZsUGmZy8cTflM8pcwgbBv/AlR0itNJ2LXYh39/quRERkVrFkZ1yzmAD4GFy4k8+eUFtCb5iIgOjGoOCTZ2hcCMiIrXKlqPpRJeh3YFujxF57cNg1sR7dY3CjYiI1GiGYbDvZBar9p1i3e7j+O5dSnQZFt4+5N+FSAWbOknhRkREapyjp3NYvSeJY1t/ofDoJpoX7KGH6QAjTMfwsDjLdI4gH2sVVyk1lcKNiIi43KnUU+zY9As7jp3m3cRmHE7NwZs8ttrux2Iy4C89NQXWQDzt6ec9Z/vGummkrlK4ERGR6pWXTvahDRzb/iv5hzdSL307jR3HucRk4O1szdP26VjMJto1CeNoXjf8/QMIaBGDR+Mu0Cgaz6wkWNDvvC9jMekC4rrK5eFm3rx5PPfccyQmJtK5c2defvllevTocdb2aWlpPPbYY3z66aekpqbSrFkz5syZwzXXXFONVYuISJnknoa0I+QGt2fDodOs3JfC7Wuvo4HzJCWWozTBSVMItpDmvDkwhu7Ng/D38gTizzxnVnI1FS+1lUvDzaJFi4iLi2P+/Pn07NmTOXPmEBsby65du2jYsOEZ7e12OwMGDKBhw4Z8/PHHNG7cmEOHDlGvXr3qL15ERErKPgUnEuBEAs7jmyk4shFb1hHSzYF0z5+P3VE0rVpXz6a0NcEBz1bkNehIvRbdaR3dhwYNG9OgLK/jE1w0AV9h/tnbeNiK2kmd5NJJ/Hr27En37t2ZO3cuAE6nk4iICO6//34mTZp0Rvv58+fz3HPPsXPnTjw9Pcv1mprET0TqrLQjkHPq7Pt9gqFeRNnOlZMKPkHFT42PxmDavrjUpoecDRlkfxqfgGB6twrmkshALm4dRqN6FVj2oDLfi9QKtWISP7vdzoYNG5g8eXLxNrPZTP/+/Vm9enWpx3zxxRf06tWLcePG8fnnn9OgQQNGjBjBxIkTsVhKvy8wPz+f/Pw/031GRkblvhERkdog7QjM7Xb+3o77NpwZCjIT4XjC770ym4t+zjzO/jt2sPKonVX7TtFrbwGjgP3OMLYZzdnijOSgtTUBkTFEX9Scz1uF0DzYB1NlXQdTL0LhRc7KZeEmJSUFh8NBaGhoie2hoaHs3Lmz1GP279/P8uXLGTlyJF9//TV79+7l3nvvpaCggKlTp5Z6zMyZM5k+fXql1y8iUqvknDp3sIGi/Tkpf4aGX+fDLy9AVtIZTZ2YeOiVj9hktAZgLdcyzzqU9i0i6N0ymMEtQ2gb5o9ZswKLC7j8guIL4XQ6adiwIQsWLMBisdCtWzeOHTvGc889d9ZwM3nyZOLi4oqfZ2RkEBGhtC8iUqqUPdCoCwBZBQZ+WUk4MXPI1ISNhc3Y6izqldlhNKPAw5fezerTu2UwvVqG0KlJIJ4WTZonrueycBMSEoLFYiEpqeS/CJKSkggLCyv1mPDwcDw9PUsMQbVr147ExETsdjtW65kTNtlsNmw2rfwqIlIW+3ds4r1DHVi1L4VTif5EmKaxw2hKLl5YzCY6NQmkT8sQ4loG07VZfbw8yzBVsEg1c1m4sVqtdOvWjfj4eAYPHgwU9czEx8dz3333lXpMnz59+OCDD3A6nZh/n1J79+7dhIeHlxpsRESkiMMwKEsMeSihIZuMA78/q09IWDNGtAymd8tgekT+cXu2SM3m0mGpuLg4Ro8eTUxMDD169GDOnDlkZ2czduxYAEaNGkXjxo2ZOXMmAPfccw9z585l/Pjx3H///ezZs4cZM2bwwAMPuPJtiIjUeNuOZdCpDO0CfH0Z0b4pfVqGcHGLIIL91PMttY9Lw82wYcM4efIkU6ZMITExkejoaJYuXVp8kfHhw4eLe2gAIiIi+Pbbb5kwYQKdOnWicePGjB8/nokTJ7rqLYiI1AqpOfYytRt7SST9+nWs4mpEqpZL57lxBc1zIyJ1zoGfOLr+K5pse+28TX+75gs69bisGooSuTC1Yp4bERGpBr99hPHZvTRyFmA3LFhNjrM2zceT9q0jq7E4kapRrnDzww8/cPnll1d2LSIiUlkMA36eDcufwgQscVzM8wU34WvKwwT8tcv+j5loHh7Si371m1Z/rSKVrFzh5qqrrqJJkyaMHTuW0aNHa94YEZGaxFGIseQhTBvfBmBB4bW87TOWF8Z2JS3HzvQvt3MiPa+4eXigF1MHRdGvQ7iLChapXOW65iYlJYV3332X//znP2zbto0rrriCO+64g8GDB9f4W7J1zY2IuLX8LPIXjsZ24HuchonphaNIbDuKZ4Z2op5P0d/PDqfB2gOpJGfm0dDfix6RQVg0k7DUcBfy/V3hC4o3btzIW2+9xYcffgjAiBEjuOOOO+jcuXNFTltlFG5ExJ3t+O4N2q2KI8/wJM75AL2vHc3Ink0rb00nERep1nADcPz4cRYsWMCsWbPw8PAgLy+PXr16MX/+fNq3b1/R01cqhRsRcUf2Qiezv9vFaz/t5wHLpxys14Nxt42gTZi/q0sTqRQX8v1d7kVACgoK+Pjjj7nmmmto1qwZ3377LXPnziUpKYm9e/fSrFkzbrrppvKeXkREyujE1p8Y/cq3vPbTfgBSuz/Isw/eqWAjdVa5em7uv/9+PvzwQwzD4LbbbuPOO++kQ4cOJdokJibSqFEjnE5npRVbGdRzIyLuZM2X/yZ6/SQ2Ga24z/wET9/Ujdj2pa/PJ1KbVfk8N9u3b+fll1/mhhtuOOuilCEhIfzwww/lOb2IiJxHZq6d5W9N5W/Jr4AJzF71+fLOiwlvEOzq0kRcTjMUi4jUMpsPnWLvu/cztHAJAAmNhtHx9leweGheVnFfVX7NzcyZM3nzzTfP2P7mm2/yzDPPlOeUIiJyHk6nwb+XbyXpjZuLg82RmEeJvus1BRuRvyhXuHnttddo27btGdvbt2/P/PnzK1yUiIiUlJyRx+i31hL2w0MMNK+nwORJzvX/JuK6iaDbvEVKKFfUT0xMJDz8zJksGzRowIkTJypclIiI/OmHnck8/N/NnMq2k+p5I/18juJ78wI8m/dxdWkiNVK5wk1ERAQrV64kMrLkAmsrV66kUaNGlVKYiEhdl1/o4Nmlu/jvL1vJwJe2Yf68OOIW/ILHgMXT1eWJ1FjlCjd33XUXDz74IAUFBVxxxRUAxMfH849//IOHHnqoUgsUEamL9p3M4oEPN9EkMZ5fbK/x6UXPcMvNV+HlaXF1aSI1XrnCzSOPPMKpU6e49957sdvtAHh5eTFx4kQmT55cqQWKiNQlhmHw3w1Hmfr5Nm52fs1U6zuYMRjj9RN4jnJ1eSK1QoVuBc/KymLHjh14e3vTunXrs855U5PoVnARqaky8gp4bPFWvtp8lMkeH/J/HkV3RNFtLFzzPFh0R5TUXVU+id8f/Pz86N69e0VOISIiwMbDp3ngw02cPJ3OXM9XudaypmjHlVPhkgm6I0rkApQ73Kxfv56PPvqIw4cPFw9N/eHTTz+tcGEiInWBw2kw/8d9vLBsNzZnLh/5PEdn5w4we8LgV6DTza4uUaTWKdc8NwsXLqR3797s2LGDxYsXU1BQwLZt21i+fDmBgYGVXaOIiFtKTM/j1n+v4blvd+FwGlzZKZJ27dqDLRBu+1TBRqScytVzM2PGDP71r38xbtw4/P39efHFF4mMjOTuu+8udf4bEREp6fvtSTzy8WZO5xTgY7Uw/fr23NitCSbHq5B+BIJburpEkVqrXD03+/bt49prrwXAarWSnZ2NyWRiwoQJLFiwoFILFBFxJ3kFDqZ9sY0731nP6ZwCxoTsZE27/3JT18aYTCbwsCrYiFRQucJN/fr1yczMBKBx48Zs3boVgLS0NHJyciqvOhERN7InKZPB81by9qqDAMy7aBNTs/+J/66PYeN/XFuciBsp17DUpZdeyrJly+jYsSM33XQT48ePZ/ny5Sxbtowrr7yysmsUEanVDMNg4bojTP9yG3kFTkJ8PPikTTzNdrxW1KDLbdDlVtcWKeJGyhVu5s6dS15eHgCPPfYYnp6erFq1iqFDh/L4449XaoEiIrVZek4Bkxf/xtdbEgG4vFUAr/q9ideO3+8qvfwxuPQR3eotUokuONwUFhby1VdfERsbC4DZbGbSpEmVXpiISG23/mAq4xcmcCwtFw+ziceuCGfMkccw7VwJZg+4/mWIHuHqMkXczgWHGw8PD/7+97+zY8eOqqhHRKTWczgN5i7fy4vxu3Ea0CzYh5du6UJn0z5YvR6s/jDsHWh5hatLFXFL5RqW6tGjBwkJCTRr1qyy6xERqdWOp+Xy4KIE1h5IBeCGLo15cnAH/GweQDe46W2oFwFhHV1ap4g7K1e4uffee4mLi+PIkSN069YNX1/fEvs7depUKcWJiNQmS7cmMvGT30jPLcDXauGpwR24IWAnpG6H8N//Xmx7jWuLFKkDyrVwptl85h3kJpMJwzAwmUw4HI5KKa4qaOFMESkvh9Ng7YFUkjPzaOjvRY/IICxmE3kFDp76ajvvrzkMQKcmgbx0SxeaH/4EvnwQ/BrCXcshoJFr34BILVblC2ceOHCgXIWJiNRWS7eeYPqX2zmRnle8LTzQizv7tmDRusPsTsoC4O7LWvBQ/4uw/jwLfnq2qGHkZeAT4oqyReqkcvXc1GbquRGRC7V06wnueW8j5/rLMsTPxgs3d+bSFoHw5XjY/EHRjksfKbrdW7d6i1RIlffcvPPOO+fcP2rUqPKcVkSkxnE4DaZ/uf2cwcbmYWbJA5cQarXDBzfB/hVgssB1L0C3MdVUqYj8oVzhZvz48SWeFxQUkJOTg9VqxcfHR+FGRNzG2gOpJYaiSpNf6GT/yWxCdz1TFGw8fYvuirpoYLXUKCIllSvcnD59+oxte/bs4Z577uGRRx6pcFEiIq6SX+hgT1IWOxMz2Xkig5/2nCzTccmZeXDF45C6r+i/jbpUcaUicjblCjelad26NbNmzeLWW29l586dlXVaEZEqYRgGSRn57EjMYOeJTHacyGBnYgb7TmbjcJYchGpECvVNmaWeJ8KUzG/OFjT09wKvALj1k+ooX0TOodLCDRTNXnz8+PHKPKWISIXlFRT1xuw4kVEcZnYmZnA6p6DU9oHenrQL96dtWABdAjO56ofR2Ci9LUAhZkxBVwDBVfQORORClCvcfPHFFyWeG4bBiRMnmDt3Ln369KmUwkTEDaQdgZxTZ9/vE1w0W28lMQyDE+l5v/fCFPXG7DiRwYGUbJylXBFsMZtoEeJL2/AA2ob5ExUeQNtwf8ICvDD9cXfT8QT44ezBBsADJ+SegvpNK+29iEj5lSvcDB48uMRzk8lEgwYNuOKKK5g9e3Zl1CUitV3aEZjbDQrzz97Gwwb3bShXwMmxF7I7KYudvweYHb9fI5ORV1hq+/o+nrQLD6BtWADtwv1pFx5Aq4Z+eHlaLvi1S6dbvUVqinKFG6fTWdl1iIi7yTl17mADRftzTp0z3BiGwdHTucU9MTt/H1Y6fCoDm2HHCzsFeJBB0TIwPuZCrq9/iJb1LDSvZ6aJn4nGfib8LQWYCvOgYdSfSyDkZ8HHD0BBHhTmFv23IAcK86AgFy6KheiRlfUbEZFqUqnX3IiIXLB1r4MtEApzKcjPITMzk5zsTNZ79eI9ez92JWbil5/Ef23TicaOFwV4YcfT9ucyL+sb3sChnk/RLjyAlj7Z2OaMgmzgWCmv13n4n+HGZIKt57gAOPNEpb5VEake5Qo3Q4cOpUePHkycOLHE9meffZZ169bx3//+t1KKE5E6YNN7xT96AkG/P5YVerO+sDMAARYzTUwpZz1FTEQAMd2aFD3JNxf1znh4gaf3//zXCyIu/vNAD2+4atZZ2nqDbwjkZVT+exaRKlWucPPTTz8xbdq0M7ZfffXVuuZGRABwGAZluZrli8JeHCOEPMNKHlY8bT7UrxeAR3h75rSKpm24Py2DbJDc9s/Q8dcAYrHBXxfztfnBvavLVqTZDBffc+42xxPKdi4RqTHKFW6ysrKwWq1nbPf09CQjQ//KERHYdjSVTmVot67JrTRr35tOv9+xFOxnK71hk5hKrU9E3Jf5/E3O1LFjRxYtWnTG9oULFxIVFVXhokSklstJJWL1lDI1vbJtKHf2bUGfViFnDzau5BNcdFfXuXjYitqJSI1Qrp6bJ554ghtuuIF9+/ZxxRVXABAfH8+HH36o621E6rrCfHhjAPXT9papeZDPmb3ANUq9iKLb1atxvh4RqZhyhZtBgwbx2WefMWPGDD7++GO8vb3p1KkT33//PZdddlll1ygitYmHjaOtRmI5NY8gIw2bqfR5ZwDy8aR968hqLK6c6kUovIjUIibDMEqZt9N9ZWRkEBgYSHp6OgEBAa4uR8Q9GAbkpIJvMB+tP8Lji7fg6cihtX8hBVkpmIC//kXzx3R3Dw/pRb8e3VxQsIjUNhfy/V2unpt169bhdDrp2bNnie1r1qzBYrEQE6ML/0TqDHsOfHEfxoktzGoyl9fWFN2y3S+qOS8Mi+aXPSeZ/uV2TqTnFR8SHujF1EFR9OsQ7qqqRcSNlSvcjBs3jn/84x9nhJtjx47xzDPPsGbNmkopTkRquPRjsHAEnEjAgYXdJ5YBXRh/ZWvGX9kas9nEVR3CGRAVxtoDqSRn5tHQ34sekUFYzFquQESqRrnCzfbt2+natesZ27t06cL27dsrXJSI1AJH1sGikZCVRBr+3J3/IFs8OzD/5miu6hBWoqnFbKJXS91NJCLVo1zhxmazkZSURIsWLUpsP3HiBB4eWtFBxO0lfABfjgeHnd1GBLfbH8JcvzmfjupG2zBdyyYirlWueW4GDhzI5MmTSU9PL96WlpbGo48+yoABAyqtOBGpgda9AZ/dAw473zpiGJI/jeYto/jivj4KNiJSI5Srm+X555/n0ksvpVmzZnTp0gWAhIQEQkNDeffddyu1QBGpWbJaXEW+ZRbv5fdhTuFQbr+kJZOvbouHpVz/VhIRqXTlvhU8Ozub999/n82bNxfPczN8+HA8PT0ru8ZKpVvBRcoh+xT4BnMgJZu73llPYnIydg8/Zg7pyNA/FqwUEalCVX4rOICvry+XXHIJTZs2xW63A/DNN98AcP3115f3tCJS0+z9Hv57Ozu6PM6wX5uRkVdIaEB93rsthuiIeq6uTkTkDOUKN/v372fIkCFs2bIFk8mEYRiYTH/e1ulwOCqtQBFxEcOAX1/B+O5xTIaT06veJsP+KF2b1mf+rd1oGODl6gpFREpVrkHy8ePHExkZSXJyMj4+PmzdupUff/yRmJgYVqxYUckliki1K8yHz8fBt49iMpx8VHgZY+z/YFhMUz78v4sVbESkRitXz83q1atZvnw5ISEhmM1mLBYLl1xyCTNnzuSBBx5g06ZNlV2niFSXzCRYdCscXYsDM/8sGMm7xtVM+Vt7bru4WYleWhGRmqhc4cbhcODv7w9ASEgIx48fp02bNjRr1oxdu3ZVaoEiUo3yMuD1KyDjKBn4Ms5+P9u8Y3h3RFdNwicitUa5wk2HDh3YvHkzkZGR9OzZk2effRar1cqCBQvOmNhPRGoRrwC2hFyNT/oS7rQ/hFdYGz6/rRsRQT6urkxEpMzKFW4ef/xxsrOzAXjyySe57rrr6Nu3L8HBwSxatKhSCxSRKuZ0Qn46ds9Apn25jQ+3X4YPF9OvUwueu7ETPlbNOi4itUu557n5X6mpqdSvX7/Gj8drnhuRv8jPhE/vpiD9OGOMqaw8lIPJBA8PbMO9/VrW+D/PIlJ3XMj3d6VNKRoUFFTuvwjnzZtH8+bN8fLyomfPnqxdu7ZMxy1cuBCTycTgwYPL9boidVrqAfj3ANi1BGfiVuyHN+Jv8+CN0TGMu7yVgo2I1Founy990aJFxMXFMXXqVDZu3Ejnzp2JjY0lOTn5nMcdPHiQhx9+mL59+1ZTpSJu5MBP8PrlcHIHyUZ9huU/wangbiwe14cr2oa6ujoRkQpxebh54YUXuOuuuxg7dixRUVHMnz8fHx8f3nzzzbMe43A4GDlyJNOnT9cFzCIXat2/Md4dArmn2exswaD8p6h/US8Wj+tDq4Z+rq5ORKTCXBpu7HY7GzZsoH///sXbzGYz/fv3Z/Xq1Wc97sknn6Rhw4bccccd532N/Px8MjIySjxE6qyfX4AlD2FyFvKZozc326cwtF93/j26O4HeNXtdOBGRsnLpbRApKSk4HA5CQ0t2g4eGhrJz585Sj/nll1944403SEhIKNNrzJw5k+nTp1e0VBG3cCAslnrM4bWCq3nb/DeeHx7NoM6NXF2WiEilcvmw1IXIzMzktttu4/XXXyckJKRMx0yePJn09PTix5EjR6q4SpEaJvc0AMu2JzHovaNclvc8X/oP45N7+ijYiIhbcmnPTUhICBaLhaSkpBLbk5KSCAsLO6P9vn37OHjwIIMGDSre5nQ6AfDw8GDXrl20bNmyxDE2mw2bzVYF1YvUAju+wvjsHr5q9ST3b2gIQI/ICF4d2ZVgP/25EBH35NKeG6vVSrdu3YiPjy/e5nQ6iY+Pp1evXme0b9u2LVu2bCEhIaH4cf3113P55ZeTkJBAREREdZYvUnMZBvz4HCwaiSk/A8/f3gdgVK9mvH9nTwUbEXFrLp96NC4ujtGjRxMTE0OPHj2YM2cO2dnZjB07FoBRo0bRuHFjZs6ciZeXFx06dChxfL169QDO2C5SZ9lz4PN7YdtiAN4qjOVZ41Zm3dCRW3o0dXFxIiJVz+XhZtiwYZw8eZIpU6aQmJhIdHQ0S5cuLb7I+PDhw5jNterSIBHXST8KHw6HxN8owMITBWP53vtq3rutK92aBbm6OhGRalFpyy/UFlp+QdxWZhLG/D6Ysk9yyvDn7/YJ5DfuyWu3dSM80NvV1YmIVMiFfH+7vOdGRCpHnlcIG629qZ+5iTvtD9GzSzQzbuiIl6fF1aWJiFQrhRuR2sxRCIW5JOV7cve7G9h6Yig209+YcG0X7rgkUutDiUidpHAjUlvlnoaPbycjt4DByfdzIquQQG9v5o7oQt/WDVxdnYiIyyjciNRGKXvgw1vg1F48DBtB9r34h3bg9VExNAv2dXV1IiIupXAjUhOlHYGcU6XvO7IGI/5JTPYsjhoh/J89jibtevLCsGj8bPojLSKivwlFapq0IzC3GxTmn7WJCUhwtuAO+yPc1j+GB65ojdms62tEREDhRqTmyTl1zmDzh1nczozbriC2/ZlLlYiI1GUKN+JezjWcA+ATDPXcY5mOWTd1o7mCjYjIGRRuxH2UYTgHDxvct6F6A06hHfLSICe16A4neza07v/n/tXz4Oj6on25pzEyEynLAFNEkCbmExEpjcKNuI+yDOcU5he1K0+4KcgrDiBnPBz5cOkjf7b9fBzs//H3MJNV8jwWKzyejN1hkJptx2fnCgIOfVe8u6xXzmw7lkGnxhf+NkRE3J3CjdRtxzZA+rHSAwsGDHvvz7bv3QCHVpZ+HosVe684TucWkJKVT+jJRELSjxTvdmIix+xHhsmfNMOXW6ctITW/KMYMNLenkSmMNMOPNHwJJoPZ1tfOW3pqjr0i71xExG0p3Ejd9t0TZw0shtmTk+m5pGQXkJptp6Xdi1DM5HkEkG32J8PkR5rhxymnL0mFPkx7YgkOipY6aGPqjxeXkkZRmwx8MDhzAViL2cQm30s47GslyNdKsJ+N+tk74Oj5Sw/ysVborYuIuCuFG3EbDsOgLKso7U3OJCknhZSsfFo7mxLon0kGfpzGj1MOX04W+nDC7kVinjdfzfy+OJTYuA07Y0sNKX8wmyDI1wa+7fH1sxLhayX499AS5GslxM9KkO+fPwd4eZ5xC7fjGPD6+d9H+8Za+FVEpDQKN+I2th3LoFMZ2o1flMA2I+P3Z4N+f5TObILgP3pVfG0E+VkJ8f09oBT/XBRegn2tBHqfGVYulMU3BIfZisV59mEnh9mKxTekQq8jIuKuFG7EbZT1GhQfq4WL6vkVB5Zgv5IB5a89LPUqIaxcsHoRWB7YyKotu3jtp/2kZP35vkL8rNx9aQt6d2zjNre0i4hUNoUbqf0MA3Z8SZB32YZpnri2PZ16XFbFRVVQvQh6942gZx+DtQdSSc7Mo6G/Fz0ig7BoJmIRkXNSuJHazZ4DX9wHWz8hvcEt5BmeeJkKzto8H0/at46sxgIrxmI20atlsKvLEBGpVRRupPZKOwILR0DibxRiYelxHyY6ZlPflIkJMP7S9I++joeH9KJf/aYuKFZERKqLwo3UTgdXwkejICeFU0YA99jHs8e7Ey8Miya/wMH0L7dzIj2vuHl4oBdTB0XRr0O4C4sWEZHqoHAjtc+6f2N8MxGTs5Btzmb8nz2O8GYX8fWILoQHFi1JMCAqTNeqiIjUUQo3UrukHsD4ZjImZyFfOi7mkYK7GXNZFA8NvAhPy5/zz+haFRGRukvhRmqVb455scpxO36FaXxovYFXR3bh8rYNXV2WiIjUIAo3UvMd34TdsDBjg4W3Vx0ELqVr03p8PaIrjeppZWwRESlJ4UZqtt/+i/Pz+zhtBPJ5znQggLsvbcHDsW1KDEOJiIj8QeFGaianA76fBqtewgxsdbTDx8uL54fFcGW7UFdXJyIiNZjCjdQ8uadxfnwH5n3xAMwrvJ7l4Xfx0cjuNNYwlIiInIfCjdQsJ3dR8P4teKbtJ9ew8kjB3YT3GcHCq9pqGEpERMpE4UZqlKTPniA0bT9HjRDiTP/grlsHMyBKw1AiIlJ2CjdSI9gLnTyzdCf/3TeUKZ65fN7wHl64tR9N6vu4ujQREallFG7EtfKzSF37Ibf/FkXCkTTAj509n+GNq9pi9dAwlIiIXDiFG3Gd0wfJfPtmgtJ30b7gdvZ7XcXzN3VmYPswV1cmIiK1mMKNuEThvh+xf3gb/oXpnDQCKWzQjiWj+hIRpGEoERGpGIUbqV6GQdqPc/FfMQUfnGx2tmB553/x1N8u1TCUiIhUCoUbqT6F+Rx//14aHfgYgC/pi23oXCZ0bu7aukRExK3on8pSLQocTt77+BPC9n+CwzDxps8dRN+/iIEKNiIiUsnUcyNV7nhaLvd/uIkNhwLZa7mNlu2iGXnLGGweFleXJiIibkjhRqrU9qWv88gaL7blBuHv5cHFNz7KVR3CXV2WiIi4MYUbqRIFBXYS3rif7okLme2M4PFGc3hhZG+aButuKBERqVoKN1LpEhOPkfzmCLrbE4qeN7qS9++4DJunp2sLExGROkHhRirV2jW/EP7N7XQiiRzDxs5ez9LvqjGuLktEROoQhRupFIUOJ18uWsDAXVPwNeWTaA7FOex9urbp7urSRESkjtGt4FJhiel5jFywmuY7X8fXlM9+v27UG/8LjRRsRETEBdRzIxXy4+6TTFiUQGq2nYdsDzO/TQIX3fw0WPS/loiIuIa+gaRcCh1O3vpqOYfWfkWqYwBR4QG8MrIfzUOGu7o0ERGp4xRu5IIlZeSx4O03uP/U09TzzCaqdUtuGHkvXp6alE9ERFxP4UYuyE+7klm38J886nwHi8ngdP1OjLhhKCjYiIhIDaFwI2XicBq8/N0WIlY+ykOWn8EEmW1vpv7Ql8HTy9XliYiIFFO4kRIcToO1B1JJzsyjob8XPSKDOJWVz9T3l3H3iSlEW/bjwIJzwFP4974XTCZXlywiIlKCwo0USTvCqi27eO2n/aRk2Ys3B3p7Uuh00sa+k2jrfuyegViHv4OlRT/X1SoiInIOCjcCaUdwvNSV3k47vQFsf9nnLPpPvtWT1JgJBPUeDUGRLihSRESkbBRuBEd2Chan/ZxtbBTg0eVvCjYiIlLjaYZiYduxjEptJyIi4koKN0Jqzrl7bS60nYiIiCsp3AhZ+YVlahfkY63iSkRERCpO4aYOK3A4eeG7XXzz46oytW/fOKCKKxIREak4XVBcR+07mcWERQn8djSdaFNwmY6xaE4bERGpBRRu6hjDMHh39UE2fPM22wq6EejtRVy/9vCDqysTERGpHAo3dUhSRh7PLPyWIUeeZZRlK72C7qDf7TMIM07CzzYozD/7wR428ClbD4+IiIgrKdzUEV//dpSti5/jn84P8bHkU2i2cfPFrTAHegERcN8GyDl19hP4BEO9iGqrV0REpLwUbtxcRl4Br360hAF7n+Ia814wQW6jnngPfRWCW/7ZsF6EwouIiLgFhRs39uv+U3z34YtMtM/DZi4k3+KLZeCTeHe/Hcy6UU5ERNyTwo0byi90MPu73bz+835a0IRJNkhrcgX1bnoZApu4ujwREZEqpXDjZnYeTuKDRe/yzql2AHTvfjGFF/9IvUbtQbdyi4hIHVAjxibmzZtH8+bN8fLyomfPnqxdu/asbV9//XX69u1L/fr1qV+/Pv379z9n+7rC4TT44rNFeL/Rl6lZ/+RSn0O8PiqGWUM74dO4g4KNiIjUGS4PN4sWLSIuLo6pU6eyceNGOnfuTGxsLMnJyaW2X7FiBcOHD+eHH35g9erVREREMHDgQI4dO1bNldccxxIT+eH54Vyf8H80MyWR7hHMyze2YUBUqKtLExERqXYmwzAMVxbQs2dPunfvzty5cwFwOp1ERERw//33M2nSpPMe73A4qF+/PnPnzmXUqFHnbZ+RkUFgYCDp6ekEBNTu5QQMw2D11+/Rcu0ThJpOA7Cn6c20Gv4cJu96ri1ORESkEl3I97dLr7mx2+1s2LCByZMnF28zm83079+f1atXl+kcOTk5FBQUEBQUVOr+/Px88vP/nJwuIyOjYkXXEKez7WxZcDuXpn8JJjhuaYT5by/TulN/V5cmIiLiUi4dlkpJScHhcBAaWnL4JDQ0lMTExDKdY+LEiTRq1Ij+/Uv/Up85cyaBgYHFj4iI2j+Xy4pdycTO+YmvU0JxGCY2Roym4SPrCVOwERERqd13S82aNYuFCxeyYsUKvLy8Sm0zefJk4uLiip9nZGTU2oCTl3KI/3z7KzO3+AGwvsEg9sfeQtcO3V1cmYiISM3h0nATEhKCxWIhKSmpxPakpCTCwsLOeezzzz/PrFmz+P777+nUqdNZ29lsNmw2W6XU6zJOJ0e/n0f9VU9zreHLSzzDTb3bMenqtnh5WlxdnYiISI3i0mEpq9VKt27diI+PL97mdDqJj4+nV69eZz3u2Wef5amnnmLp0qXExMRUR6kuU5i8m2NzrqDJqsfxJZdUczBv3dKaade3V7AREREphcuHpeLi4hg9ejQxMTH06NGDOXPmkJ2dzdixYwEYNWoUjRs3ZubMmQA888wzTJkyhQ8++IDmzZsXX5vj5+eHn5+fy95HpXMUkhr/Ar6rnqMxdrING0sa/h8DRz9GPT9vV1cnIiJSY7k83AwbNoyTJ08yZcoUEhMTiY6OZunSpcUXGR8+fBjzX9ZBevXVV7Hb7dx4440lzjN16lSmTZtWnaVXGSMvg9RXBhKcsQOAlXQme+Dz3NS7OyZNxiciInJOLp/nprrV9HlukjPzmPTJFobue5Q+5m18WP8e/jb6IRrV93F1aSIiIi5Ta+a5kb84/Cs/nPTjoa9PkJptZ7vHHdzftwV3X9Eds1m9NSIiImWlcONq+ZnYv52Gx8Y3yHL0JLXgAdqFBzBn2KW0CfN3dXUiIiK1jsKNK+39nvzF92PLPg5ALjbu7duM8bHtsHnoTigREZHyULhxhZxUHN9MxrJlITbgiLMBs73GMWL4aG6OLH0ZCRERESkbhZvqdmwjhe/dhEduCk7DxFuOq9jXYTxPDY7B38vT1dWJiIjUego31cjpNHhvjyf9cwyyjMY8bbmH4TfdyB0dwl1dmoiIiNtQuKlqhgG7l3K84WU8/PFvrNp3iv+YJtGidRTP3RRDQ//S18QSERGR8lG4qai0I5BzqvR9Gcdh5b/gyFpe4++syrsUb08LY6+NZWTPppqQT0REpAoo3FRE2hGY2w0K88/ZLM/wwFGYT+eIevzr5s60aOBGy0SIiIjUMAo3FZFz6rzBBmB84QO0u3w4n1zeCg+LS9cqFRERcXsKN9Ug7sYraNPlIleXISIiUieoG6ECHGVclqtVQw1DiYiIVBeFmwrYdiyjUtuJiIhIxWlYqgJSc+yV2k5ERCqX0+nEbtffwbWF1WrFbK54v4vCTQUE+VgrtZ2IiFQeu93OgQMHcDqdri5FyshsNhMZGYnVWrHvTYWbCmjfOKBS24mISOUwDIMTJ05gsViIiIiolN4AqVpOp5Pjx49z4sQJmjat2FxwCjcVYPENwWG2YnGevcvTYbZi8Q2pxqpERKSwsJCcnBwaNWqEj4+Pq8uRMmrQoAHHjx+nsLAQT8/yr7eocFMR9SKwPLCRVVt28dpP+0nJ+jPkhPhZufvSFvTu2AbqRbiwSBGRusfhcABUeHhDqtcfn5fD4VC4cal6EfTuG0HPPgZrD6SSnJlHQ38vekQGYTFreQUREVfSMje1S2V9Xgo3lcRiNtGrZbCryxAREanzdIWViIjIWTicBqv3neLzhGOs3ncKh7Nsk7fWFM2bN2fOnDmuLqPaqedGRESkFEu3nmD6l9s5kZ5XvC080Iupg6K4qkN4lbxmv379iI6OrrRAsm7dOnx9fSvlXLWJem5ERET+x9KtJ7jnvY0lgg1AYnoe97y3kaVbT7iosqLb3AsLC8vUtkGDBnXybjGFGxERcXuGYZBjLyzTIzOvgKlfbKO0Aag/tk37YjuZeQVlOp9RxnUIx4wZw48//siLL76IyWTCZDJx8OBBVqxYgclk4ptvvqFbt27YbDZ++eUX9u3bx9/+9jdCQ0Px8/Oje/fufP/99yXO+b/DUiaTiX//+98MGTIEHx8fWrduzRdffHHOut59911iYmLw9/cnLCyMESNGkJycXKLNtm3buO666wgICMDf35++ffuyb9++4v1vvvkm7du3x2azER4ezn333Vem30l5aVhKRETcXm6Bg6gp31bKuQwgMSOPjtO+K1P77U/G4mM9/9ftiy++yO7du+nQoQNPPvkkUNTzcvDgQQAmTZrE888/T4sWLahfvz5Hjhzhmmuu4emnn8Zms/HOO+8waNAgdu3aRdOmTc/6OtOnT+fZZ5/lueee4+WXX2bkyJEcOnSIoKCgUtsXFBTw1FNP0aZNG5KTk4mLi2PMmDF8/fXXABw7doxLL72Ufv36sXz5cgICAli5cmVx79Krr75KXFwcs2bN4uqrryY9PZ2VK1eW6XdXXgo3IiIiNUBgYCBWqxUfHx/CwsLO2P/kk08yYMCA4udBQUF07ty5+PlTTz3F4sWL+eKLL87ZMzJmzBiGDx8OwIwZM3jppZdYu3YtV111Vantb7/99uKfW7RowUsvvUT37t3JysrCz8+PefPmERgYyMKFC4vnprnooouKj/nnP//JQw89xPjx44u3de/e/Xy/jgpRuBEREbfn7Wlh+5OxZWq79kAqY95ad952b4/tTo/I0ns7/ve1K0NMTEyJ51lZWUybNo0lS5Zw4sQJCgsLyc3N5fDhw+c8T6dOnYp/9vX1JSAg4Ixhpr/asGED06ZNY/PmzZw+fbp4ra7Dhw8TFRVFQkICffv2LXXSveTkZI4fP86VV155IW+1whRuRETE7ZlMpjINDQH0bd2A8EAvEtPzSr3uxgSEBXrRt3WDap2s9X/venr44YdZtmwZzz//PK1atcLb25sbb7zxvKug/28IMZlMZ11cNDs7m9jYWGJjY3n//fdp0KABhw8fJjY2tvh1vL29z/pa59pXlXRBsYiIyF9YzCamDooCioLMX/3xfOqgqCoJNlartXjpiPNZuXIlY8aMYciQIXTs2JGwsLDi63Mqy86dOzl16hSzZs2ib9++tG3b9oxenk6dOvHzzz9TUFBwxvH+/v40b96c+Pj4Sq3rfBRuRERE/sdVHcJ59dauhAV6ldgeFujFq7d2rbJ5bpo3b86aNWs4ePAgKSkpZ+1RAWjdujWffvopCQkJbN68mREjRpyzfXk0bdoUq9XKyy+/zP79+/niiy946qmnSrS57777yMjI4JZbbmH9+vXs2bOHd999l127dgEwbdo0Zs+ezUsvvcSePXvYuHEjL7/8cqXW+b80LCUiIlKKqzqEMyAqrFrXDXz44YcZPXo0UVFR5ObmcuDAgbO2feGFF7j99tvp3bs3ISEhTJw4kYyMjEqtp0GDBrz99ts8+uijvPTSS3Tt2pXnn3+e66+/vrhNcHAwy5cv55FHHuGyyy7DYrEQHR1Nnz59ABg9ejR5eXn861//4uGHHyYkJIQbb7yxUuv8XyajrDfgu4mMjAwCAwNJT08nICDA1eWIiEgVyMvL48CBA0RGRuLl5XX+A6RGONfndiHf3xqWEhEREbeicCMiIiJuReFGRERE3IrCjYiIiLgVhRsRERFxKwo3IiIi4lYUbkRERMStKNyIiIiIW1G4EREREbei5RdERET+V9oRyDl19v0+wVAvovrqkQuicCMiIvJXaUdgbjcozD97Gw8b3Leh0gNOv379iI6OZs6cOZV2zjFjxpCWlsZnn31Waees6TQsJSIi8lc5p84dbKBo/7l6dsSlFG5ERKTusGef/VGQV/nnvQBjxozhxx9/5MUXX8RkMmEymTh48CAAW7du5eqrr8bPz4/Q0FBuu+02UlJSio/9+OOP6dixI97e3gQHB9O/f3+ys7OZNm0a//nPf/j888+Lz7lixYpSX3/p0qVccskl1KtXj+DgYK677jr27dtXos3Ro0cZPnw4QUFB+Pr6EhMTw5o1a4r3f/nll3Tv3h0vLy9CQkIYMmTIBf0OKouGpUREpO6Y0ejs+1oPhJH/Ld9553QsvSdnWnqZT/Hiiy+ye/duOnTowJNPPglAgwYNSEtL44orruDOO+/kX//6F7m5uUycOJGbb76Z5cuXc+LECYYPH86zzz7LkCFDyMzM5Oeff8YwDB5++GF27NhBRkYGb731FgBBQUGlvn52djZxcXF06tSJrKwspkyZwpAhQ0hISMBsNpOVlcVll11G48aN+eKLLwgLC2Pjxo04nU4AlixZwpAhQ3jsscd45513sNvtfP311xf4i6wcCjciIiI1QGBgIFarFR8fH8LCwoq3z507ly5dujBjxozibW+++SYRERHs3r2brKwsCgsLueGGG2jWrBkAHTt2LG7r7e1Nfn5+iXOWZujQoSWev/nmmzRo0IDt27fToUMHPvjgA06ePMm6deuKA1KrVq2K2z/99NPccsstTJ8+vXhb586dy/GbqDiFGxERqTsePX72fSZL+c/74JbyH3semzdv5ocffsDPz++Mffv27WPgwIFceeWVdOzYkdjYWAYOHMiNN95I/fr1L+h19uzZw5QpU1izZg0pKSnFPTKHDx+mQ4cOJCQk0KVLl7P2/CQkJHDXXXdd+BusAgo3IiJSd1h9a9d5gaysLAYNGsQzzzxzxr7w8HAsFgvLli1j1apVfPfdd7z88ss89thjrFmzhsjIyDK/zqBBg2jWrBmvv/46jRo1wul00qFDB+x2O1DUA3Qu59tfnXRBsYiISA1htVpxOBwltnXt2pVt27bRvHlzWrVqVeLh61sUqkwmE3369GH69Ols2rQJq9XK4sWLz3rO/3Xq1Cl27drF448/zpVXXkm7du04ffp0iTadOnUiISGB1NTUUs/RqVMn4uPjy/vWK5XCjYiIyF/5BBfNY3MuHraidpWsefPmrFmzhoMHDxYPDY0bN47U1FSGDx/OunXr2LdvH99++y1jx47F4XCwZs0aZsyYwfr16zl8+DCffvopJ0+epF27dsXn/O2339i1axcpKSkUFBSc8br169cnODiYBQsWsHfvXpYvX05cXFyJNsOHDycsLIzBgwezcuVK9u/fzyeffMLq1asBmDp1Kh9++CFTp05lx44dbNmypdTepmph1DHp6ekGYKSnp7u6FBERqSK5ubnG9u3bjdzc3PKd4PRhwzi26eyP04crqdKSdu3aZVx88cWGt7e3ARgHDhwwDMMwdu/ebQwZMsSoV6+e4e3tbbRt29Z48MEHDafTaWzfvt2IjY01GjRoYNhsNuOiiy4yXn755eJzJicnGwMGDDD8/PwMwPjhhx9Kfe1ly5YZ7dq1M2w2m9GpUydjxYoVBmAsXry4uM3BgweNoUOHGgEBAYaPj48RExNjrFmzpnj/J598YkRHRxtWq9UICQkxbrjhhgt6/+f63C7k+9tkGIbhmljlGhkZGQQGBpKenk5AQICryxERkSqQl5fHgQMHiIyMxMvLy9XlSBmd63O7kO9vDUuJiIiIW1G4EREREbeicCMiIiJuReFGRERE3IrCjYiIuK06ds9MrVdZn5fCjYiIuB2LpWgphT9m15Xa4Y/P64/Pr7y0/IKIiLgdDw8PfHx8OHnyJJ6enpjN+rd8Ted0Ojl58iQ+Pj54eFQsnijciIiI2zGZTISHh3PgwAEOHTrk6nKkjMxmM02bNsVkMlXoPAo3IiLilqxWK61bt9bQVC1itVorpZdN4UZERNyW2WzWDMV1UI0YhJw3bx7NmzfHy8uLnj17snbt2nO2/+9//0vbtm3x8vKiY8eOfP3119VUqYiIiNR0Lg83ixYtIi4ujqlTp7Jx40Y6d+5MbGwsycnJpbZftWoVw4cP54477mDTpk0MHjyYwYMHs3Xr1mquXERERGoily+c2bNnT7p3787cuXOBoqulIyIiuP/++5k0adIZ7YcNG0Z2djZfffVV8baLL76Y6Oho5s+ff97X08KZIiIitc+FfH+79Jobu93Ohg0bmDx5cvE2s9lM//79Wb16danHrF69mri4uBLbYmNj+eyzz0ptn5+fT35+fvHz9PR0oOiXJCIiIrXDH9/bZemTcWm4SUlJweFwEBoaWmJ7aGgoO3fuLPWYxMTEUtsnJiaW2n7mzJlMnz79jO0RERHlrFpERERcJTMzk8DAwHO2cfu7pSZPnlyip8fpdJKamkpwcHCF76P/XxkZGURERHDkyBENedUA+jxqFn0eNYs+j5pHn8m5GYZBZmYmjRo1Om9bl4abkJAQLBYLSUlJJbYnJSURFhZW6jFhYWEX1N5ms2Gz2Upsq1evXvmLLoOAgAD9j1mD6POoWfR51Cz6PGoefSZnd74emz+49G4pq9VKt27diI+PL97mdDqJj4+nV69epR7Tq1evEu0Bli1bdtb2IiIiUre4fFgqLi6O0aNHExMTQ48ePZgzZw7Z2dmMHTsWgFGjRtG4cWNmzpwJwPjx47nsssuYPXs21157LQsXLmT9+vUsWLDAlW9DREREagiXh5thw4Zx8uRJpkyZQmJiItHR0SxdurT4ouHDhw+XmIq5d+/efPDBBzz++OM8+uijtG7dms8++4wOHTq46i0Us9lsTJ069YxhMHENfR41iz6PmkWfR82jz6TyuHyeGxEREZHK5PIZikVEREQqk8KNiIiIuBWFGxEREXErCjciIiLiVhRuKsm8efNo3rw5Xl5e9OzZk7Vr17q6pDpr5syZdO/eHX9/fxo2bMjgwYPZtWuXq8uS382aNQuTycSDDz7o6lLqrGPHjnHrrbcSHByMt7c3HTt2ZP369a4uq05yOBw88cQTREZG4u3tTcuWLXnqqafKtH6SnJ3CTSVYtGgRcXFxTJ06lY0bN9K5c2diY2NJTk52dWl10o8//si4ceP49ddfWbZsGQUFBQwcOJDs7GxXl1bnrVu3jtdee41OnTq5upQ66/Tp0/Tp0wdPT0+++eYbtm/fzuzZs6lfv76rS6uTnnnmGV599VXmzp3Ljh07eOaZZ3j22Wd5+eWXXV1araZbwStBz5496d69O3PnzgWKZlmOiIjg/vvvZ9KkSS6uTk6ePEnDhg358ccfufTSS11dTp2VlZVF165deeWVV/jnP/9JdHQ0c+bMcXVZdc6kSZNYuXIlP//8s6tLEeC6664jNDSUN954o3jb0KFD8fb25r333nNhZbWbem4qyG63s2HDBvr371+8zWw2079/f1avXu3CyuQP6enpAAQFBbm4krpt3LhxXHvttSX+rEj1++KLL4iJieGmm26iYcOGdOnShddff93VZdVZvXv3Jj4+nt27dwOwefNmfvnlF66++moXV1a7uXyG4touJSUFh8NRPKPyH0JDQ9m5c6eLqpI/OJ1OHnzwQfr06VMjZrGuqxYuXMjGjRtZt26dq0up8/bv38+rr75KXFwcjz76KOvWreOBBx7AarUyevRoV5dX50yaNImMjAzatm2LxWLB4XDw9NNPM3LkSFeXVqsp3IhbGzduHFu3buWXX35xdSl11pEjRxg/fjzLli3Dy8vL1eXUeU6nk5iYGGbMmAFAly5d2Lp1K/Pnz1e4cYGPPvqI999/nw8++ID27duTkJDAgw8+SKNGjfR5VIDCTQWFhIRgsVhISkoqsT0pKYmwsDAXVSUA9913H1999RU//fQTTZo0cXU5ddaGDRtITk6ma9euxdscDgc//fQTc+fOJT8/H4vF4sIK65bw8HCioqJKbGvXrh2ffPKJiyqq2x555BEmTZrELbfcAkDHjh05dOgQM2fOVLipAF1zU0FWq5Vu3boRHx9fvM3pdBIfH0+vXr1cWFndZRgG9913H4sXL2b58uVERka6uqQ67corr2TLli0kJCQUP2JiYhg5ciQJCQkKNtWsT58+Z0yNsHv3bpo1a+aiiuq2nJycEotDA1gsFpxOp4sqcg/quakEcXFxjB49mpiYGHr06MGcOXPIzs5m7Nixri6tTho3bhwffPABn3/+Of7+/iQmJgIQGBiIt7e3i6ure/z9/c+43snX15fg4GBdB+UCEyZMoHfv3syYMYObb76ZtWvXsmDBAhYsWODq0uqkQYMG8fTTT9O0aVPat2/Ppk2beOGFF7j99ttdXVqtplvBK8ncuXN57rnnSExMJDo6mpdeeomePXu6uqw6yWQylbr9rbfeYsyYMdVbjJSqX79+uhXchb766ismT57Mnj17iIyMJC4ujrvuusvVZdVJmZmZPPHEEyxevJjk5GQaNWrE8OHDmTJlClar1dXl1VoKNyIiIuJWdM2NiIiIuBWFGxEREXErCjciIiLiVhRuRERExK0o3IiIiIhbUbgRERERt6JwIyIiIm5F4UZE6pwVK1ZgMplIS0tzdSkiUgUUbkRERMStKNyIiIiIW1G4EZFq53Q6mTlzJpGRkXh7e9O5c2c+/vhj4M8hoyVLltCpUye8vLy4+OKL2bp1a4lzfPLJJ7Rv3x6bzUbz5s2ZPXt2if35+flMnDiRiIgIbDYbrVq14o033ijRZsOGDcTExODj40Pv3r1LrJa9efNmLr/8cvz9/QkICKBbt26sX7++in4jIlKZFG5EpNrNnDmTd955h/nz57Nt2zYmTJjArbfeyo8//ljc5pFHHmH27NmsW7eOBg0aMGjQIAoKCoCiUHLzzTdzyy23sGXLFqZNm8YTTzzB22+/XXz8qFGj+PDDD3nppZfYsWMHr732Gn5+fiXqeOyxx5g9ezbr16/Hw8OjxErMI0eOpEmTJqxbt44NGzYwadIkPD09q/YXIyKVwxARqUZ5eXmGj4+PsWrVqhLb77jjDmP48OHGDz/8YADGwoULi/edOnXK8Pb2NhYtWmQYhmGMGDHCGDBgQInjH3nkESMqKsowDMPYtWuXARjLli0rtYY/XuP7778v3rZkyRIDMHJzcw3DMAx/f3/j7bffrvgbFpFqp54bEalWe/fuJScnhwEDBuDn51f8eOedd9i3b19xu169ehX/HBQURJs2bdixYwcAO3bsoE+fPiXO26dPH/bs2YPD4SAhIQGLxcJll112zlo6depU/HN4eDgAycnJAMTFxXHnnXfSv39/Zs2aVaI2EanZFG5EpFplZWUBsGTJEhISEoof27dvL77upqK8vb3L1O6vw0wmkwkouh4IYNq0aWzbto1rr72W5cuXExUVxeLFiyulPhGpWgo3IlKtoqKisNlsHD58mFatWpV4REREFLf79ddfi38+ffo0u3fvpl27dgC0a9eOlStXljjvypUrueiii7BYLHTs2BGn01niGp7yuOiii5gwYQLfffcdN9xwA2+99VaFzici1cPD1QWISN3i7+/Pww8/zIQJE3A6nVxyySWkp6ezcuVKAgICaNasGQBPPvkkwcHBhIaG8thjjxESEsLgwYMBeOihh+jevTtPPfUUw4YNY/Xq1cydO5dXXnkFgObNmzN69Ghuv/12XnrpJTp37syhQ4dITk7m5ptvPm+Nubm5PPLII9x4441ERkZy9OhR1q1bx9ChQ6vs9yIilcjVF/2ISN3jdDqNOXPmGG3atDE8PT2NBg0aGLGxscaPP/5YfLHvl19+abRv396wWq1Gjx49jM2bN5c4x8cff2xERUUZnp6eRtOmTY3nnnuuxP7c3FxjwoQJRnh4uGG1Wo1WrVoZb775pmEYf15QfPr06eL2mzZtMgDjwIEDRn5+vnHLLbcYERERhtVqNRo1amTcd999xRcbi0jNZjIMw3BxvhIRKbZixQouv/xyTp8+Tb169VxdjojUQrrmRkRERNyKwo2IiIi4FQ1LiYiIiFtRz42IiIi4FYUbERERcSsKNyIiIuJWFG5ERETErSjciIiIiFtRuBERERG3onAjIiIibkXhRkRERNyKwo2IiIi4lf8HLmF/U/MsXwUAAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -2391,6 +2444,7 @@ ], "source": [ "# gradient check\n", + "# the meaning of numerical gradient is to check if the backward propagation is right, although it is very slow.\n", "import numpy as np\n", "from dataset.mnist import load_mnist\n", "\n", @@ -2416,6 +2470,41 @@ "## Tricks for learning" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Updating parameters (weights&bias)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Initializing weights" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Batch normalization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Normalization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hyper-parameters" + ] + }, { "cell_type": "markdown", "metadata": {},