From 5137ae9ff5105c97c0daff03935a04e6ad9c18f7 Mon Sep 17 00:00:00 2001 From: jbpextra Date: Tue, 10 Jul 2018 19:55:39 +0200 Subject: [PATCH 1/3] append gitignore --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 848d2a0d..b5369bf0 100755 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ +.idea/ ### Python template # Byte-compiled / optimized / DLL files From b211e85638cd394926fd328cc1ac238289447c11 Mon Sep 17 00:00:00 2001 From: jbpextra Date: Mon, 20 Aug 2018 21:47:17 +0200 Subject: [PATCH 2/3] ex2 completed --- Exercise2/exercise2.ipynb | 471 ++++++++++++++++++++++++++++++++++---- 1 file changed, 422 insertions(+), 49 deletions(-) diff --git a/Exercise2/exercise2.ipynb b/Exercise2/exercise2.ipynb index 39983d90..3791e022 100755 --- a/Exercise2/exercise2.ipynb +++ b/Exercise2/exercise2.ipynb @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -100,6 +100,38 @@ "X, y = data[:, 0:2], data[:, 2]" ] }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "100\n" + ] + }, + { + "data": { + "text/plain": [ + "array([[34.62365962, 78.02469282, 0. ],\n", + " [30.28671077, 43.89499752, 0. ],\n", + " [35.84740877, 72.90219803, 0. ],\n", + " [60.18259939, 86.3085521 , 1. ],\n", + " [79.03273605, 75.34437644, 1. ]])" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "print(len(data))\n", + "data[:5]" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -125,7 +157,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -151,7 +183,13 @@ " fig = pyplot.figure()\n", "\n", " # ====================== YOUR CODE HERE ======================\n", + " # Find Indices of Positive and Negative Examples\n", + " pos = y == 1\n", + " neg = y == 0\n", "\n", + " # Plot Examples\n", + " pyplot.plot(X[pos, 0], X[pos, 1], 'k*', lw=2, ms=10)\n", + " pyplot.plot(X[neg, 0], X[neg, 1], 'ko', mfc='y', ms=8, mec='k', mew=1)\n", " \n", " # ============================================================" ] @@ -165,9 +203,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plotData(X, y)\n", "# add axes labels\n", @@ -202,7 +251,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -233,7 +282,7 @@ " g = np.zeros(z.shape)\n", "\n", " # ====================== YOUR CODE HERE ======================\n", - "\n", + " g = 1/(1+np.exp(-z))\n", " \n", "\n", " # =============================================================\n", @@ -249,12 +298,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "g( [-1 0 1] ) = [0.26894142 0.5 0.73105858]\n" + ] + } + ], "source": [ "# Test the implementation of sigmoid function here\n", - "z = 0\n", + "z = np.array([-1,0,1])\n", "g = sigmoid(z)\n", "\n", "print('g(', z, ') = ', g)" @@ -275,9 +332,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise logistic-regression\n", + "\n", + "Use token from last successful submission (jbpextra@hotmail.com)? (Y/n): \n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Sigmoid Function | 5 / 5 | Nice work!\n", + " Logistic Regression Cost | 0 / 30 | \n", + " Logistic Regression Gradient | 0 / 30 | \n", + " Predict | 0 / 5 | \n", + " Regularized Logistic Regression Cost | 0 / 15 | \n", + " Regularized Logistic Regression Gradient | 0 / 15 | \n", + " --------------------------------\n", + " | 5 / 100 | \n", + "\n" + ] + } + ], "source": [ "# appends the implemented function in part 1 to the grader object\n", "grader[1] = sigmoid\n", @@ -298,15 +377,36 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1. , 34.62365962, 78.02469282],\n", + " [ 1. , 30.28671077, 43.89499752],\n", + " [ 1. , 35.84740877, 72.90219803],\n", + " [ 1. , 60.18259939, 86.3085521 ],\n", + " [ 1. , 79.03273605, 75.34437644],\n", + " [ 1. , 45.08327748, 56.31637178],\n", + " [ 1. , 61.10666454, 96.51142588],\n", + " [ 1. , 75.02474557, 46.55401354],\n", + " [ 1. , 76.0987867 , 87.42056972],\n", + " [ 1. , 84.43281996, 43.53339331]])" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Setup the data matrix appropriately, and add ones for the intercept term\n", "m, n = X.shape\n", "\n", "# Add intercept term to X\n", - "X = np.concatenate([np.ones((m, 1)), X], axis=1)" + "X = np.concatenate([np.ones((m, 1)), X], axis=1)\n", + "X[:10]" ] }, { @@ -328,7 +428,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ @@ -373,8 +473,15 @@ " grad = np.zeros(theta.shape)\n", "\n", " # ====================== YOUR CODE HERE ======================\n", - "\n", + " z = theta@np.transpose(X)\n", + " h = sigmoid(z)\n", " \n", + " Jv = -y@np.log(h)-(1-y)@np.log(1-h)\n", + " J = np.sum(Jv)/m\n", + " \n", + " d = h-y\n", + " d = d@X\n", + " grad = d /m\n", " \n", " # =============================================================\n", " return J, grad" @@ -389,9 +496,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 56, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost at initial theta (zeros): 0.693\n", + "Expected cost (approx): 0.693\n", + "\n", + "Gradient at initial theta (zeros):\n", + "\t[-0.1000, -12.0092, -11.2628]\n", + "Expected gradients (approx):\n", + "\t[-0.1000, -12.0092, -11.2628]\n", + "\n", + "Cost at test theta: 0.218\n", + "Expected cost (approx): 0.218\n", + "\n", + "Gradient at test theta:\n", + "\t[0.043, 2.566, 2.647]\n", + "Expected gradients (approx):\n", + "\t[0.043, 2.566, 2.647]\n" + ] + } + ], "source": [ "# Initialize fitting parameters\n", "initial_theta = np.zeros(n+1)\n", @@ -426,9 +555,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 57, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise logistic-regression\n", + "\n", + "Use token from last successful submission (jbpextra@hotmail.com)? (Y/n): Y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Sigmoid Function | 5 / 5 | Nice work!\n", + " Logistic Regression Cost | 30 / 30 | Nice work!\n", + " Logistic Regression Gradient | 30 / 30 | Nice work!\n", + " Predict | 0 / 5 | \n", + " Regularized Logistic Regression Cost | 0 / 15 | \n", + " Regularized Logistic Regression Gradient | 0 / 15 | \n", + " --------------------------------\n", + " | 65 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[2] = costFunction\n", "grader[3] = costFunction\n", @@ -459,9 +610,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 58, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost at theta found by optimize.minimize: 0.203\n", + "Expected cost (approx): 0.203\n", + "\n", + "theta:\n", + "\t[-25.161, 0.206, 0.201]\n", + "Expected theta (approx):\n", + "\t[-25.161, 0.206, 0.201]\n" + ] + } + ], "source": [ "# set options for optimize.minimize\n", "options= {'maxiter': 400}\n", @@ -508,9 +673,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 59, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Plot Boundary\n", "utils.plotDecisionBoundary(plotData, theta, X, y)" @@ -530,7 +706,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 66, "metadata": {}, "outputs": [], "source": [ @@ -566,8 +742,8 @@ " p = np.zeros(m)\n", "\n", " # ====================== YOUR CODE HERE ======================\n", - "\n", - " \n", + " p = sigmoid(theta@np.transpose(X)) + 0.5\n", + " p = np.floor(p)\n", " \n", " # ============================================================\n", " return p" @@ -582,9 +758,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 67, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "For a student with scores 45 and 85,we predict an admission probability of 0.776\n", + "Expected value: 0.775 +/- 0.002\n", + "\n", + "Train Accuracy: 89.00 %\n", + "Expected accuracy (approx): 89.00 %\n" + ] + } + ], "source": [ "# Predict probability for a student with score 45 on exam 1 \n", "# and score 85 on exam 2 \n", @@ -608,9 +796,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 68, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise logistic-regression\n", + "\n", + "Use token from last successful submission (jbpextra@hotmail.com)? (Y/n): Y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Sigmoid Function | 5 / 5 | Nice work!\n", + " Logistic Regression Cost | 30 / 30 | Nice work!\n", + " Logistic Regression Gradient | 30 / 30 | Nice work!\n", + " Predict | 5 / 5 | Nice work!\n", + " Regularized Logistic Regression Cost | 0 / 15 | \n", + " Regularized Logistic Regression Gradient | 0 / 15 | \n", + " --------------------------------\n", + " | 70 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[4] = predict\n", "grader.grade()" @@ -630,16 +840,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 75, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 0.051267 0.69956 1. ]\n", + " [-0.092742 0.68494 1. ]\n", + " [-0.21371 0.69225 1. ]\n", + " [-0.375 0.50219 1. ]\n", + " [-0.51325 0.46564 1. ]]\n" + ] + } + ], "source": [ "# Load Data\n", "# The first two columns contains the X values and the third column\n", "# contains the label (y).\n", "data = np.loadtxt(os.path.join('Data', 'ex2data2.txt'), delimiter=',')\n", "X = data[:, :2]\n", - "y = data[:, 2]" + "y = data[:, 2]\n", + "print(data[:5])" ] }, { @@ -654,9 +877,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 76, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plotData(X, y)\n", "# Labels and Legend\n", @@ -686,13 +920,74 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 77, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1.00000000e+00, 5.12670000e-02, 6.99560000e-01,\n", + " 2.62830529e-03, 3.58643425e-02, 4.89384194e-01,\n", + " 1.34745327e-04, 1.83865725e-03, 2.50892595e-02,\n", + " 3.42353606e-01, 6.90798869e-06, 9.42624411e-05,\n", + " 1.28625106e-03, 1.75514423e-02, 2.39496889e-01,\n", + " 3.54151856e-07, 4.83255257e-06, 6.59422333e-05,\n", + " 8.99809795e-04, 1.22782870e-02, 1.67542444e-01,\n", + " 1.81563032e-08, 2.47750473e-07, 3.38066048e-06,\n", + " 4.61305487e-05, 6.29470940e-04, 8.58939846e-03,\n", + " 1.17205992e-01],\n", + " [ 1.00000000e+00, -9.27420000e-02, 6.84940000e-01,\n", + " 8.60107856e-03, -6.35227055e-02, 4.69142804e-01,\n", + " -7.97681228e-04, 5.89122275e-03, -4.35092419e-02,\n", + " 3.21334672e-01, 7.39785525e-05, -5.46363780e-04,\n", + " 4.03513411e-03, -2.98012201e-02, 2.20094970e-01,\n", + " -6.86091891e-06, 5.06708697e-05, -3.74226408e-04,\n", + " 2.76382476e-03, -2.04120477e-02, 1.50751849e-01,\n", + " 6.36295342e-07, -4.69931780e-06, 3.47065055e-05,\n", + " -2.56322636e-04, 1.89305413e-03, -1.39810280e-02,\n", + " 1.03255971e-01],\n", + " [ 1.00000000e+00, -2.13710000e-01, 6.92250000e-01,\n", + " 4.56719641e-02, -1.47940748e-01, 4.79210063e-01,\n", + " -9.76055545e-03, 3.16164171e-02, -1.02411982e-01,\n", + " 3.31733166e-01, 2.08592830e-03, -6.75674451e-03,\n", + " 2.18864648e-02, -7.08946949e-02, 2.29642284e-01,\n", + " -4.45783738e-04, 1.44398387e-03, -4.67735639e-03,\n", + " 1.51509052e-02, -4.90768525e-02, 1.58969871e-01,\n", + " 9.52684426e-05, -3.08593793e-04, 9.99597833e-04,\n", + " -3.23789996e-03, 1.04882142e-02, -3.39734512e-02,\n", + " 1.10046893e-01],\n", + " [ 1.00000000e+00, -3.75000000e-01, 5.02190000e-01,\n", + " 1.40625000e-01, -1.88321250e-01, 2.52194796e-01,\n", + " -5.27343750e-02, 7.06204687e-02, -9.45730485e-02,\n", + " 1.26649705e-01, 1.97753906e-02, -2.64826758e-02,\n", + " 3.54648932e-02, -4.74936392e-02, 6.36022152e-02,\n", + " -7.41577148e-03, 9.93100342e-03, -1.32993350e-02,\n", + " 1.78101147e-02, -2.38508307e-02, 3.19403964e-02,\n", + " 2.78091431e-03, -3.72412628e-03, 4.98725061e-03,\n", + " -6.67879302e-03, 8.94406151e-03, -1.19776487e-02,\n", + " 1.60401477e-02],\n", + " [ 1.00000000e+00, -5.13250000e-01, 4.65640000e-01,\n", + " 2.63425562e-01, -2.38989730e-01, 2.16820610e-01,\n", + " -1.35203170e-01, 1.22661479e-01, -1.11283178e-01,\n", + " 1.00960349e-01, 6.93930270e-02, -6.29560041e-02,\n", + " 5.71160910e-02, -5.18178989e-02, 4.70111767e-02,\n", + " -3.56159711e-02, 3.23121691e-02, -2.93148337e-02,\n", + " 2.65955366e-02, -2.41284865e-02, 2.18902843e-02,\n", + " 1.82798972e-02, -1.65842208e-02, 1.50458384e-02,\n", + " -1.36501592e-02, 1.23839457e-02, -1.12351884e-02,\n", + " 1.01929920e-02]])" + ] + }, + "execution_count": 77, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# Note that mapFeature also adds a column of ones for us, so the intercept\n", "# term is handled\n", - "X = utils.mapFeature(X[:, 0], X[:, 1])" + "X = utils.mapFeature(X[:, 0], X[:, 1])\n", + "X[:5]" ] }, { @@ -718,7 +1013,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 85, "metadata": {}, "outputs": [], "source": [ @@ -767,7 +1062,19 @@ " grad = np.zeros(theta.shape)\n", "\n", " # ===================== YOUR CODE HERE ======================\n", - "\n", + " z = theta@np.transpose(X)\n", + " h = sigmoid(z)\n", + " \n", + " Jv = -y@np.log(h)-(1-y)@np.log(1-h)\n", + " J = np.sum(Jv)/m + (theta[1:]@theta[1:])*lambda_/(2*m)\n", + " \n", + " d = h-y\n", + " d = d@X\n", + " grad = d /m\n", + " \n", + " reg = theta * lambda_ / m\n", + " reg[0] = 0\n", + " grad += reg\n", " \n", " \n", " # =============================================================\n", @@ -783,9 +1090,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 86, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost at initial theta (zeros): 0.693\n", + "Expected cost (approx) : 0.693\n", + "\n", + "Gradient at initial theta (zeros) - first five values only:\n", + "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n", + "Expected gradients (approx) - first five values only:\n", + "\t[0.0085, 0.0188, 0.0001, 0.0503, 0.0115]\n", + "\n", + "------------------------------\n", + "\n", + "Cost at test theta : 3.16\n", + "Expected cost (approx): 3.16\n", + "\n", + "Gradient at initial theta (zeros) - first five values only:\n", + "\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]\n", + "Expected gradients (approx) - first five values only:\n", + "\t[0.3460, 0.1614, 0.1948, 0.2269, 0.0922]\n" + ] + } + ], "source": [ "# Initialize fitting parameters\n", "initial_theta = np.zeros(X.shape[1])\n", @@ -832,9 +1163,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 87, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise logistic-regression\n", + "\n", + "Use token from last successful submission (jbpextra@hotmail.com)? (Y/n): \n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Sigmoid Function | 5 / 5 | Nice work!\n", + " Logistic Regression Cost | 30 / 30 | Nice work!\n", + " Logistic Regression Gradient | 30 / 30 | Nice work!\n", + " Predict | 5 / 5 | Nice work!\n", + " Regularized Logistic Regression Cost | 15 / 15 | Nice work!\n", + " Regularized Logistic Regression Gradient | 15 / 15 | Nice work!\n", + " --------------------------------\n", + " | 100 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[5] = costFunctionReg\n", "grader[6] = costFunctionReg\n", @@ -892,9 +1245,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 88, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Train Accuracy: 83.1 %\n", + "Expected accuracy (with lambda = 1): 83.1 % (approx)\n", + "\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEWCAYAAABMoxE0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzsnXd8k9X+x98n6UihpaVlU6aIgoIiyz3BhQpXXCwFuRdRFAfXBUILiKhcVJyoPxmyHBdFhl4BNyIqqIDsUUYZBQrdTZs05/dHkpKW7DxZ7Xm/XnmlybPOU+jzPec7Pl8hpUShUCgUCn/RhXsACoVCoYhulCFRKBQKRUAoQ6JQKBSKgFCGRKFQKBQBoQyJQqFQKAJCGRKFQqFQBIQyJIqoRgixTwjRKwjnvVoIke3D/kOFEGu0HodCEQ0oQ6JQRClCiLuEEGuFECVCiO+92H+gEGK/EKJYCLFECJHqsC1VCPG5bdt+IcTAoA5eUaNQhkShiF5OAq8BL3raUQhxHvAuMARoDJQAbzvs8hZQbts2CHjHdoxC4RFlSBQ1BiFEDyHEL0KIPCHEESHEm0KIOIftUgjxkBBilxCiUAgxWQhxlu2YAiHEJ477244ZK4Q4YXOhDXL4Pk0IsdR23G/AWdWOmyGEOGjbvkEIcYXW9yulXC2l/AQ47MXug4BlUsofpZRFwHjgdiFEkhCiLtAfGC+lLJJSrgGWYjU6CoVHlCFR1CQqgMeBBsAlwHXAQ9X2uRHoClwMPAW8h/Uh2wI4HxjgsG8T27maA/cB7wkhzrFtewswAk2B+20vR34HLgRSgYXAp0IIg7NBCyGesRk/py8ffweuOA/YaP8gpdyDdQXS3vaqkFLudNh/o+0YhcIjypAoagxSyg1SynVSSrOUch9WV85V1XZ7SUpZIKXcAvwNrJRS7pVS5gNfAV2q7T9eSlkmpfwBWAHcJYTQY53BT5BSFksp/wbmVhvLfCllrm0s04F44BycIKV8UUqZ4uoV2G+lkkQgv9p3+UCSh20KhUeUIVHUGIQQ7YUQy4UQR4UQBcALWFcUjuQ4/Fzq5HOiw+dTUspih8/7gWZAQyAGOFhtm+NYxgghtgkh8m2rimQnYwklRUC9at/VAwo9bFMoPKIMiaIm8Q6wHThbSlkPGAuIAM5X3xY/sNMSazziOGDG6g5z3AaALR7yNHAXUN+2qsh3NRZbHKbI1SuA8TuyBbjA4Zptsa6SdtpeMUKIsx32v8B2jELhEWVIFDWJJKAAKBJCnAs8qME5Jwoh4mzG4RbgUyllBfAZkCmEqCOE6Ig1huI4DjNWgxMjhJjAmTP+SqSUL0gpE129XB0nhNDb4i4xgE4IYRBCxLrYfQFwqxDiCptxnAR8JqUstK26PgMmCSHqCiEuA/oC87z7FSlqO8qQKGoS/wYGYnXJvA98HOD5jgKnsK5CFgAjpZTbbdsexuoGOwrMAWY7HPc11njLTqwuLyNV3WBaMQSrO+4d4Arbz+/bN9pWNFcA2GJCI233cQyrsXNMRHgISLBtWwQ8aDtGofCIUI2tFAqFQhEIakWiUCgUioAIqyERQswSQhwTQvztYvvVtqyXv2yvCaEeo0KhUCjcExPm688B3gQ+dLPPT1LKW0IzHIVCoVD4SlhXJFLKH7HqBSkUCoUiSgn3isQbLhFCbMSaOfNvZ5kkQogRwAiAhDoJXVu1axXiISoUCkV0s33T9hNSyob+HBvphuQPoJWUskgIcTOwBDi7+k5SyvewaibR4YIOcu7KudV3USgUCoUbejbpud/zXs6J6KwtmyZSke3nL4FYIUQ4ZSYUCoVCUY2INiRCiCZCCGH7uQfW8eaGd1QKhUKhcCSsri0hxCLgaqCBra1pBhALIKWcCdwBPCiEMGOt2r1HqgpKhUKhiCjCakiklAM8bH8Ta3qwQqFQaEsFxBbEIsyB6HpGHzJGYqpnAr1254z0YLtCoVAEhdiCWBqmNCQlNQWbB73GI6Uk72Qex/OOY6pv0uy8ER0jUSgUimAhzKJWGREAIWz3rPEqTBkShUJRa6lNRsROMO5ZGRKFQqHwkvz8fO654x7y86t3Jq7dKEOiUCgUXvLlsi9ZvnQ5Xy3/KtxDccqan9ZwWY/LSE5I5vPFn4fsusqQKBQKhZd8OMeqL/vhXHc6s+GjRYsWvPt/73LXPXeF9LrKkCgUCoULbrnxFhLjEitfv677FYB1a9dV+f6WG30XKJ+UMYm33nir8nPm+EzefvPtgMbbqnUrzu98PjpdaB/tKv1XoVAoXPDkM0/y67pfKS0pBaC8vLzKO0BCnQSeevYpn89937D7GHjXQEY9MgqLxcLiTxfz/c/fn7Ff72t6U1RYdMb3L7z0Atdcd43P1w0GypAoFAqFC666+ir+u+S/3NHvjkpj4khCnQQWf7GYK6+60udzt2rditS0VDb+uZFjx47R+YLOpKWlnbHfqu9W+TX2UKIMiUKhULjhqquv4sMFHzJkwBCMRmPl9waDgQ8XfOiXEbFz37D7mD9vPjlHc7h36L1O91ErEoVCoagB5Oflo4/Ro9PpiI+Pp6ysDH2Mnvy8wNKAb+t3G1MmTsFkNjF73myn+0TDikQF2xUKhcIDc2fPpaS4hE6dOvHx4o/p1KkTJcUlAWdvxcXFccXVV3B7/9vR6wMXv9qwfgPt27Tn88Wf8+ioR+l2QbeAz+kNakWiUCgUHqiXXI8XXnqBUaNHodPpuOqaq3jr9bf4ec3PAZ3XYrHw+6+/M2/RPE3G2bVbV3Zm7dTkXL6gDIlCoVB44OPFH1f5rNfrGf34aEY/Ptrvc27buo07/3Ent/a9lXZntwt0iGFFGRKFQqEIAx06duDvHX+HexiaoGIkCoVCoQgIZUgUCoVCERDKkCgUCoUiIJQhUSgUCkVAKEOiUCgUHigqKmLq81M4t20r6hmSOLdtK6Y+P4WiojMrzsNJWVkZ9w68l84dOnP1ZVezf9/+kFxXGRKFQqFwQ1FRETf1uoZf1rxKRkYuK1dKMjJyWfvTq9zU65qIMiZzZ88lpX4Km7ZtYtToUYwfOz4k11WGRKFQKNzwxmszqJ+SxXPPGWnXDvR6aNcOxo83kpKcxRuvzfDrvMGQkV+xbAWDhgwC4B/9/8H3332PlDKgc3qDMiQKhULhhrmz3mPAACPVW50LAQMGGJk7+32/znvfsPtYOG8hQKWM/N0D7j5jv97X9OaSbpec8frum+/O2PfwocOkp6cDEBMTQ3JyMrm5uX6NzxdUQaJCoVC44fDhk7Rp43xbmzZw5LB/D+pgyMg7W32I6hYwCChDoogqSopLWDRzPksXLubYkXwaNU3mtoH9GTByMHXq1gn38BQ1kGbNUsnKyqWdExWTrCxo2uzMh7+3aC0j3zy9OdnZ2TRPb47ZbCY/P5/U1FS/x+ctypAoooaS4hJG3T6cxmnZTM4sp00byMrKY8HCeYy6/Tve+uwDZUwUmnPf/SNYuPBVxo+v6t6SEhYtMnDfsH/5fW6tZeRvvuVmFsxbQM+Le/L54s+56uqrQrIiUTESRdSwaOZ8GqdlM/658ipBzwnjy2mUms2imfPDPUSvKSku4YPp79G36w1c0uxi+na9gQ+mv0dJcUm4h6aoxiOPPUpefhsmTzawaxeYzbBrF0yebCAvvw2PPPao3+fWWkb+vmH3cTL3JJ07dObNGW8yacqkgM/pDSIUEf1Q0uGCDnLuyrnhHoYiCPTtegOTM/Ocuhh27YKMiSks2fB16AfmI44rq4ED7CsrWLAwjmMn09XKKkTEHY/j7HPO9mrfoqIi3nhtBnNnv8+Rw7k0bZbGfcP+xSOPPUpiYqLfY7BYLFzW4zLmLZoXUgXgXTt2Ud6wvMp3PZv03CCl9KuBiVqRKKKGY0fy3QY9jx0NrFtdqKhJK6vaQmJiIs8+N47te/aRX1rI9j37ePa5cQEZkW1bt1kLB6+9Oupl5JUhUUQNjZomk5XlfFtWFjRqkhzaAfnJ0oWLGTig3Gk66cAB5SxbuDg8A1OEFLuM/NSXp4Z7KAGjDIkiarhtYH8WLIyjujdWSli4KI5bB/YPz8B8pKasrGoCNc217w3BuGdlSBRRw4CRgzl2Mp1Jk+OqBD0nTbbGFgaMHBzuIXpFTVlZRTsyRpJ3Mq9WGRMpbfcco+09q/RfRdRQp24d3vrsAxbNnE/GxMUcO5pPoybJ3DqwPxlRVEdiXVnNY8L48jPSSaNpZRXtmOqZOJ53nBMnToR7KCFFxkhM9UyanlNlbSkUIcaetdUotWrW1sJFKmtLET5U1pbiDFSdQuT+Duwrq/bdhpAxMYUbbxRkTEyhfbchyogoopKwrkiEELOAW4BjUsrznWwXwAzgZqAEGCql/MPdOdWKpObVKfgji1LTfgcKRbCJ5hXJHOBGN9tvAs62vUYA74RgTFFPJNQpFBUU8dTQpygqCKxXg90g7Nowj8mZeaxcKZmcmcfO9fMYdftwl6uLSPgdKBS1hbAaEinlj8BJN7v0BT6UVtYBKUKIpqEZXfQSCXUKP379Iz/87wd+WvlTQOfx1yBEwu9AoagthHtF4onmwEGHz9m276oghBghhFgvhFifdzIvZIOLVCKhTmHZomVV3v3FX4MQCb8DhaK2EOnpv85kK88I6kgp3wPeA2uMJNiDinSsdQrONamCVafw8J0P8/tPv1d+jo2NBWDTb5vo2aRn5ffdr+jOm5++6fV5/TUI4fgdKBS1lUhfkWQDLRw+pwOHwzSWqCEcFeBDHx2KIcFQ+dlkMlV5BzAkGBj22DCfzutv8V6ofgeRmhmmUISSSDckS4F7hZWLgXwp5ZFwDyrSCaQC3N8HY7fLuzF93vQqxsQRQ4KBV+a/QtfLuvp0L/4aBG9+B4EaAX8TARSKmka4038XAVcDDYAcIAOIBZBSzrSl/76JNbOrBBgmpVzv7py1Of3XMU0253AeSfXi0ekFBfllNLZVgAc7ZXbNyjU8+69nKS87LVEdFx/H1Pencvn1l/t1T/4W79l/H8sWVq2CtxvSQO/1g+nvsWvDPMY/d2aF+qTJcbTvNoThY0b4fM8KRTgIJP1XVbbXELQwAlo8GL/671e89PRLlJWWERsXi6ncRHxCPE+/9DQ33XGT3/fmyiD4Wwuixb3WlP4ovqLaHddMormORKERWtRNaJEyu3ThUowlRtp1bMe0udNo17EdxhJjQNlbderWYfiYESzZ8DVrD61jyYavGT5mREAPLS3utTZmhil3nsIZypDUECLlwZiYlMjojNHMXTmXnlf1ZM7Xc3hkwiPUTazrzW2EDC3utTaq+KpCT4UzlCGpIUTKg3Ha3GkMHDkQnc76X0uv1zPowUFMmzvN47GhRIt7rSn9UXxBFXoqnKEMSQ1BPRh9Q4t7rSn9UXyhNrrzFJ5RhqSGoB6MvqHFvdZGFd/a6M5TeEZlbdUQtOpxEYwMKU9YpAVThYkKWYHZYqbCUkGFxfazrEAg0AkdQljfHV/x+njiYuLQCR1FBUVMGj2JCa9PILFeYkTeqxaEM2vqg+nvsXO986ZcKuU5ulHpvw7UVkMC4X0wWqSFU6WnyC3JJc+YZ32VVn0vKi+i1FRKibnE+m4qocRUQpm57PSJjMASoB/gvLbRKXH6OMQmQdmnZaQMTCG1Zyp14+qSGJdI3bi6la/EuESS4pJINiSTYkipfE8xpGCI9eGCYSLc8viqKVfNRRkSB2qzIQkFeaV57Dm5hwP5BziYf7Dy/XDBYcoryj2fwAUxIga90GPZKDEtLsdwZwIJFyagE3pAYkEipQULFqSUWLBgkRbMFhMmaZNhmQPsA1oDQ30fQ3xMPA3rNKRJUhMaJzamaWJTmiQ1oUlik8r3WH2s3/eoBZFQBBmtKzmFe5QhcUAZEu04UXyC7Se2s+PEDnYc38GOEzs4WnTU+c5G0H+hp+HdjUlOSiExJpHE2HokxiSRFJNEYkwSCTF1MOgSiNfHY9AZiNcbiNfFE6uzuqYApj8zhZ2bt3FO5448MXWs2/G9Om4q2//aUvlZH6OnwlxR+W6nWcd0rnmyN6UVpZRWlFJiLqLIXERxRRFFpkKKzIUUmYswS/d9rAWCpklNaZHcgvTkdFrUs76nJ6eTXi89JEamthZBKoJPIIYk0tV/FSFCSknWqSz+OPwHfxz+g41HN3Ki5MQZ+8WKWNLrtKKJoSmNDE1obGhCI0MT9q3dy/xtH3BT4W1c3N17KZQzjYH1v+TurTt5oM/pgPe5F57H41OerXLszXf1Ze+2XZVyLHbj4WhE4uLjuGfIvZzTqKPH+y+zGMkrP8WRgsOsW/YDe3/aQmFuOXVS9dAljuLupRzmMIcLD/Nr9q9Vjteho2VKS1rXb026IZ3DK7PZ/OUGcnOKNI1hqKwpRSSiDEktRUrJgfwDrD+0nj8O/8GGwxs4VXqqyj4GfQIt67S2vupa3xsbmlauHhz5ZLW1EG3tqh+5+FrvDcmZxsBc5R2sxuDmu/uecew5F3Tk4Yx/8+bE/1TR9nI87uHMf3NOZ/dGBEAIgUGfQAqCuS++TotmOUyfarLFACqYN9/MwcXNGTB+JAW6PHKMORwvy+GY8SjHyo5youwE+/L2sS9nH4b50KUNvDAJ2/F5zJk3m0FLP+PhmU9yfovzaVS3EaJ6MYYXKHl8RSSiXFu1jL0n97Jixwq+z/qe7ILsKtvqxSZzTlIH2id1pH3SuTQyNHFqNMD5SqLCbK58t+NsJVGdHRu3BmQMNv32J+9NfR1T+WnXVGxcLCOeHU3nHl3cXrs6KxYtJj97ORkTTGfEIDInxpLS4hb6DDgzlbrcUk6O8QhfLfqchNw/mJRhOeP4cRnwawxYroJ68fVo36A9HRt1pEvTLlzQ5ALqxnmu/g8ka0ppZCncoVxbCrcYzUa+3fMtn2/7nE1HN1V+XzcmkQ71zrcZjw40NjT1epYcyEqiOudc0JF/PfOIU2Pwr2ce8biiKCkqRqfTI3RmYmJiMZtN6HQ6SoqKvboXR9auXM3UKSanlduDB5kYN361U0MSp4ujRZ1W7F+zg6lTLE6PHzYENo3VI681UFBWwPpD61l/aD0f/vkhAh0dG3XgomYXcVGzi1walgEjBzPq9u+YNNl51lSGi/oXx2yvyZnllSulBQvnMer271S2lSIglCGpwRwtPMrCTQtZsuULyixGAOJ08Vycdhnd0y7lrMSz0Qu9X+fW0q0EgRmDn1f+QHlZGeltWnL7/ffw2ayPyM464LObDSD3RKHbGETu8aKAji89aeHtLjM5VX6SAyX72Fu0i52F29lXvJctx7aw5dgW5v01Dx06OjftzMXpF9OzRU/ObXguOqGrLIJcNHM+GROrZk1luFlZOGpk2Y2cXSNr0mSrRpa7bC+1mlG4QxmSGsjB/IN8+OeHLN++HAsWAFrXbcsVDa+lW+rFGPTa1EsEupJwJBBjkFA3gf7DB3Bd3xvR6XSc+9p5fPPFV+zastPne0prkERWVqHLGERaQ/eFjt4cL4QgNT6N1Pg0LqxvbfRlrDCyp2gnOwu2saNwK/uKs/jryF/8deQvZv4+k2RDMj3Se9AzvSeXtLiE4WNG+JTmu3ThYiZnutbIypi42K1LTK1mFO5QhiRKcTZDvOIf13KqSwHfHPwGiUQg6JF6Kb2b3EzLuq1dnstYauSbJStYu3I1uScKSWuQxKXX9+K6fn1cdjysHIdGbqW4+DiatmjO4y88S92kRJ+MwUPjn6jyWafX0fv2PvS+vY/HY0uLS5jzyrsMfeIBEurW4dLrezFv/nIyM86MkcxfEMslvXu5PZ+/xxv0Bs5L7sx5yZ0BKDEXs71gK1sLNrE1fzO5xhOs2r2KVbtXAdCxYUeuaH0FV7a+krNSz/Lokgwk2yvQ1Yyi5qO0tqIQVz0hsjd+xprM1VAGlza4komdpjH8rIc8GpEZYzPJz17O1CmFrFoJU6cUkndwOTPGZmIsNbodS+VKonVLHprwOOmtW1JeVs7aVT+6PKa0uIR3Jr9KqUPviu5XXcLhA9ls/v0v4LQxeGj8414d7y8bf/2Dv9ZtYOOvfwBwXb8+ZB9pTObE2CoaXJkTY8k+0pjr+rk3ToEeb783USa4KLU7g1sPZ0rnV5nUaRr3tLyXTskXEiNi2Hp8K+/+/i6DPh3E3R/fzewNszlS6LoLdSAaWUrxV+EJZUhCRKD9wR1x1RNiykTo2kbHdVm9ua/NCBobmng81zdLVtCiWQ4ZE0xVzpWZYSK9aQ7fLFnh9ni7W2nsjMl07NKJsa9Npv/992Cok+DymOoPb7AaJMCtAXJ3vL9Uv64hwcCjL2SS0uIWxo1P4oYbBOPGJ5HS4hYefSHT4wot0OOd3ZsQgsaGplzT+Hoebv9vXu3yLg+1e5zLGlxFUkw99uftZ+bvM+m3oB+jlo1i9e7VmCqqFlcGIuqpalcUnlDpvyFAa30kT9XN48Yn8fysd7w617hhDzJ1inOfvq/n8hZ79bojvqQP+1L9Xh0t05aDga/3VmExs7Xgb37NXcOfp9ZjluZKlYE7nruDO7vdSYvkFgFpZKlq+tqBSv+NcLT2MXuaIXrKLHIk0Cwlb3BVve6Iu/ThQKrfq6Nl2rIWBHpvel0MnVIupFPKhZSYi/k1dy1ff72MU9tO8vF/P+bjXR/To3kP+nXsx4xP3+XT9z/yKdsL7KsZ57UrwepTo7LEogvl2goBWvqYtx3bRnwKbv3dnjKLHLFmGWlzLlfcfFdf4uLjKj87PrRd4Zg+7Op4f2tWHs74d5XzubpuKNDy3urE1OWaxr1puLUxAPX+TiZGxPLbod8Yu2osA78YSJ1eSXz861LWHlrHkg1fM3zMCI8P5lD3qVF94aMPl4ZECHGeEGKNECJLCPG2ECLZYdsvoRlezUArH/PmnM08sOQByi6QzP5QOPV3O8sMchectmYZxXp9Ln/w9PCuTvX0Ya0f/va05di4qiKL/qQtB4oW9/bquKk80Gdw5WvPtl0AFGcVY84wQSaQCcffPs5rv7zGHYvu4IttX2C2eDbo4F0Dr1DEAFVf+MjF3YpkJvAi0B04AKwRQtgfh5HfuCGC0KKr3OaczTz0xSjKLGVccHN3juQ08zozyF1wOtAsI29x9fB2hqncxFsTp/NAn8G8Om6q2+P9ffifTlsWxMbFIXTC72r4QAn03rxd1fQdeCfpCS05VnyMF354gQEfD2D17tVYpMXjGOvUrcPwMSNYsuHrM1YzWq8gVJZY9OHOkCRJKZdLKU9IKV8EHgdWCiG6AzUrQh9kAm2Du+/UPkZ98TDlljK6p17Mvzo8zGMvTPQ6M8hdRlSgWUa+4PjwdhYnqU51l46WD39/0pa1xlhqZMWixYwb9iBvT5qOXmdCr4eY2Fif7s3bVc3Nl/Zl3HnPM7ztQzSMb8SB/AOMWz2OoYuHsuHQBr/vQ+sVhMoSiz5cZm0JITYBl0spCxy+uxD4FKgvpWwQmiH6RiRnbfmTMXMo5xADBw3EeIuRC5p05YF2oz3KmkRqZtL0Z6aw6+/tldXrC9+aw/EjOU73FTodj095pspsvPrx9ur39p06+Jy99fbkVzj7/HMrq+EtFZbKAkhntStaY6/fadEsh8GDTJX/J2bPFuzLTkPoEji8P9une/NFvLLCYubnEz+w4vAS8kxW1edeZ/Vi9CWjaZzY2Kd70TqrS2WJhYdAsrbcrUimAec5fiGl/AvoDSzz52K1FW98zM6QUvLk609i/NtI2r4GDG/7oFfaWFoGcLWkes3JpHencWnvK8+oyo6Ni+Wh8Y+f4dLxp2bFFQ+Nf4Le/7gZnc76J+CuADIYuKrfef55SesWuXTu3tnne/NlxabXxXBlo+uY3Hk6tzXvT4yIZfWe1dyx4A6WbluKfYLpTexD6xVEoCt4RehRdSQRzNe7vmbCkAmwD9qefzZPv5Th9bGBSrOHinXfrmHhW3MoLy+rlFiJi4tj4KhhPgsuhoLqkir+4ql+56lnDLw07/98OmcgK7aTZSf4+MB8/spbD8AVra7gsW6PMX7wkx7rn7ReQai+8OEhWCsSRRh4+M6H6dmkJz2b9GTCFRPgoPX7/duzqmTm2IPQroikzCR3REKswhe0qqr3VL+Tf8q9NI0zAlmxpcY3YGS7Rxne9iHidQZ+2v8TAx67mwb1D3iMfWi9gvB3Ba8IH8qQRBhDHx1aNcBt6xrrj1sqkjKTXOHu4ecqbVlLrS1f8UXKxR2e6nfi4/Fp4gCBu+uEEPRIu5SJnV6iQ73z0f1pZsggs8fsqWDUmbjLElNEHh4NiRDiYm++U2hDt8u78fDrD4OLLFlf3FLRMNt39/BzNfvXUmvLE65qNOyV5/bXf55+3qfzuqvfmT0byh08kqGOZ9WPS2N0+6coy8Or2IdaQSi8WZG87eS7t7QeSE3E3yKtn3U/wx2gi636z+OrW0rL4HQ4cDX712pV4A3eJC4AnNXx7DOOdbdyclW/M24c/PknWGylHeGKZ+mEzuOqybH+Sa0gajfu0n97AJcA/8aawWWnHnCXlLJz8IfnO5ESbPdXqHF/3n7u+ugudJt0xHwZi6m8PCqC0FrgKm35DIQAKUOWzuwucUEIgZTSqcjium/XMHv6TIaNGen038zeB+aXVavJPV5IXJx1JWI3Iv72ndeKFYsWk3fQeW8VT/3hFdFHsILtdYEGWIUdGzq8yoE7/blYbcLfIq1PNn8CQOLmepjKysPqlgp1LMJrTS7b5CdU6czuqvLtqcvVXV2vjpvqceVkSDDQZ0B/np/1Dvc9PhKJAUnkxLNcrpoyYP+xNM01thTRi0tDIqX8Tko5HrhMSjne9vME4C0p5Y6QjTBK8UfmobCskC+2LgWgaXLTsLulQhmLAN81ueyEwv1TmbhQ7R/UYls+VDd62//a4jKe4ixwHgnxrOoTB2eqB0+MjeHXGNjfN4dfjvovuaelNpci/HgTI8kUQtQTQtQBtgBZQognPB3kDUKIG4UQO4QQu4UQzzjZPlQIcVwI8Zft9U8trhsK/CnSWrl7JSZZzjlJHXli4jh6/+NmysvKWbFoMeP/OYrFsxdxaO9OVixa7LFzoRaEMhZhx13acp8B/cKWzuzYU77/sAHgvrMt4FvSyD09AAAgAElEQVQhaCTEs5xNHBxXTe8sm8e0ObO48s7eWOIsjFs1jt+yf/P5Okrdt+bhjSHpZJNJ6QesBNKBoYFeWAihxxq0vwnoCAwQQjh7GnwspbzQ9vKtQiuM+CPUuO7gOgB6pF0K+N8G11+XlLcZSq5SUbVyhblKWy7MKwhbOrPjg/76O/rw4HOPV2aa2YmNi6XvvXf6peQb7kp78G7ioBM67ml5L9c3uQWJ5MkvnyI7P9un6yh135qHN4YkTggRA/QFlkgpywHPcqGe6QHsllLutZ3zI9s1agS+FmlJKdl4dCMA59azPmj8bYPrr0sqUGkVrVxhrtw8v/+4Lmzun+oPemNJaaUxczRqqQ3ToqIQFPyfOAgh+Ef6XXRK7oLRUsqT/3uS4nLvjblS9615eGNI/g+rjHx94AchREsg8LZ50JzKum0Asm3fVae/EGKTEOK/QogWzk4khBghhFgvhFifdzJPg6EFjq9FWvvz9pNvzCcltj5pcQ0BWLtyNYMHmZz+wQ0eZOKXVaudXttfl1SgvTG0coW5cvPExsWG3f1jx11MIxoKQSGwiYNO6Bje9kGaGJqx99ReJn03ya0cfVFBEU8NfYqigiKl7lsD8VlrSwihA2Jsqwj/LyzEncANUsp/2j4PAXpIKR9x2CcNKJJSlgkhRmJNO77W3XkjJf0XTrcLXbawamtTZ+1Cv9j2BS/88AJd6/dgRLvRAIy8dTCrVlpXItUxm+GGGwTvLJunudqvtyqykaoyHArcqQeXFpdoplIcbALVZMsxHmHKlvGUWYw80P0B7u96v9P9vvz0SyY+MpHMNzOZOfU1pe4bgQRVa0sI0VAI8a4QYrntq3OBgf5crBrZgOMKIx047LiDlDJXSllm+/g+0FWD64YMX4q09p7cC0Crum0rv/O2Da7War/ezqgjVWU4FLiLaURC4NxbAtVka2xoyoizrHO/935/n79z/na637JFyyrflbpvzcMb19Yc4AdOP/R3AWM0uPbvwNlCiDZCiDjgHmCp4w5CiKYOH28Dtmlw3YjkaNFRANLiT7d58bYNrtataL1NRY20/ueRQiQEzn0hUFfc+SkX0KvxTUgsZH6bSamptIr4aM8mPdn8+2YANv22ifemfcC6X8oZN46Q9IBXBB9vDEkjKeVCbAF2KaWJSilB/5FSmoGHga+xGohPpJRbhBCThBC32XYbLYTYIoTYCIxGg2yxSMVuSFLjThsSX9rgaqn268uMOhpUhsMp8hgNaFHD0i/9TpontOBg/kFm/DLjDPFRk8lU5d1ohA0b9Ix7LlFpc9UAPPc7hWIhRCq29rq2VruFWlxcSvkl8GW17yY4/PwsULOc6y7IKbR2CkyLS6v8zl4Q9s2SFYwbv5rc40WkNUzkkt696P9InzPa4J6eWZorZVX8CfI+NL5qmZB9Rt37duf927W6brBwzCarqfIygWCfONjjPee+dl5lvMdbYnVx3N/2QV7YOp7Pt37O5TddzvR50xkzZIzTNHVDgoFX5r9C18uiylutcIE3K5J/Y+2I2FYI8QOwCHjE/SEKXzBVmDhlPIVAR1Js1fqS6gVhz896hz4D+jvtpR6u6uhIqMp2RzgKK6MJrVxx6XVa0re5VT3p5Z9epvMlnZny7pQzXJ9x8XFMeXeKMiI1CJcrEiHExVLKdVLK9UKIa4AOWOt5twaasaWoSnmF9dcZp4tDJ/xvEaPFzDKarusKZ9lkcLo+wk5NzCYLN72b3MyvuT9zqOggy3csJ6EgAX2MHp1JR2xcLKZyE/oYPYUFmjg1FBGCu6dWpXy8lLJcSrlRSvmXMiLaY7ZYs5y86cfujnAFef25bjDjFrU5myzc6ISOPs36ATD3j7l8seALjCVG2nVsx7S502jXsR3GEmNlFpeWKP2u8KE6JEYAWhmSaCKYgpAqmyy8dKnfnaaG5hwtOkqRKGJ0xmjmrpxLz6t6MufrOTwy4RHqJtbV9JpKvyu8uDMkbYUQS129QjbCWkB1Q1IbsoyCHbeIhmyymorjqqSofxF3jbircrWq1+sZ9OAgps2d5u4UPqP0u8KLu6yt48D0UA2kNhOjs/4zVEhrVnVNzDIKR9wi0rPJajJdU3uy9NB/OVJ4hLUH1nJl6yuDer2lCxczOdO1flfGxMWqCVcQcbciKZRS/uDqFbIR1gIS46wV6qUVJUgpIy7LSIsVUjjiFpGeTVaT0QkdVza6DoDPtnwW9Osp/a7w4m5Fsi9Ug4hk7HpZSxcu5tiRfBo1TeY2F3pZ/jJmwBj4CcyYGcmQiMsy0mKFZI9bBKLr5CuRlk1W27ikwRV8nv0Jvxxcx6GCQzSv50yTVRusbRuc63e5atug0A53HRJvD+VAIpFQBfCGPjoUHFz5kZZlpNUKKdRxi2iTKqlpJMYk0T31YkCyZOuSoF5L6XeFF5W15QZfAniBpB52u7wbjR9oXMWYOBLqLKNAG1y5I1ok1ms7WiV82N1bK3auoMISsLKSS3xt26DQFmVI3OBtAx4tVi5tu7SFO0AfWzUFOBxZRsGMZ6i4RXSgVXp227rtSItrSG5JLptyNnl9nK8Tszp16/DWZx/QvtsQMiamKP2uEOOVIRFC3C6EeEUIMV0I8Y9gDypS8DaAp0XqYfN6zcEIQifCPlsPZh1GNEms12a0cmcKIeia2gOAb/d869Ux/k7MfGnboNAWb/qRvA2MBDYDfwMPCCHeCvbAIgFv+65r0Tq0eb3m8CeYy80RMVsPVjxDxS0ik2C6My+qbzUk3+39zm0XRTuqJiT68GZFchXWToazpZSzgZuBq4M6qgjB2wCeFqmHzes1h3hofFvTiJmtq3hG7SGY7szWdduSGpfG8ZLjLhtfOaJ6ukcf3hiSHUBLh88tAO+dnVGMtwE8b1cu7mhTvw0MgLIexpDN1j0FVFU8o/YQTHemEILOKRcB8Fv2bx73VzUh0Yc3hiQN2CaE+F4I8T2wFWhYG6RSvA3gaZF6mJ6cTp3YOuSZTpFvyvNrvL5m2ngKqKp4Ru0imOnZ59azHrvh0AaP+2oxMVOEFm8aW03wvEvNxR7AcyevMGDkYEbd/h2TJmczcEA5bdpY/8MvXGRduWR4kXqoEzrOaXAOfx75kwPFWXRK6eLzWH0tHHQMqDrb39cGV4roJ1iyMu2TrF0oNh7diNFsxBBzZj8dO9aJ2TwmjK/q3lI1IZGLR0Oi5FA8Y1+5LJo5n4yJizl2NJ9GTZK5dWB/MnyogD+/8fn8eeRP9hTt8suQeDIMqk+HwhOV7sw2Lbn9/nv4bNZHZGcdcPl/ylvqxiTSsk4rDpTsY/PRzXRP7+5yXy0mZorQ4q6x1Rop5eVCiEJsbXbtmwAppawX9NFFEd6sXDxxQZMLmMc8thds9Wp/Xw3DzXf1Ze+2XZUSJeGsoC8tLmHOK+8y9IkHSFDpmRFDMGVlzk46lwMl+9h4dKNbQ6LVxEwROlwaEinl5bb3pNANp3bTtXlX9EJPVvEeikyFJMa6/9X7ahjCoXflipqocFwT8Mad6e8koGWd1gDsyt3lcV8tJmaK0OFtQaJeCNFMCNHS/gr2wGojdWLr0LV5V0Dyd/5Gj/v7k2kTKX06Ik3hWOE9/la9N6/TAoCsUy4i6YqoxWOMRAjxCJAB5AD2aiIJdA7iuGotl7a8lN+yf+Pv/I1c3MDzTN1uGN6b+jqmclPl9+4MQzj6dKj4TM3BUyzOFY0NTQHBwbyDmCvMxOi9yfVRRAPe/Es+CpwjpcwN9mAUcFnLy3ht7WtszvsLs8Vc2fTKHb4ahmAFVN0RSfEZhW9oNQmI08XRIL4BJ8qOk12QTev6rYM2ZkVo8ca1dRBQFUAhomVKS9rWb4vRUsq2gs1eHeNr4WA46kNUH/XoRcuq99S4BgAcKz6m8SgV4cRd1pY96rYX+F4IsQIos2+XUr4S5LHVWq5vdz0zf5/Jb7m/eJUG7GumTbjqQ/xxwynCj5ZJGimx9QE4UXJC83Eqwoe7FUmS7XUAWAXEOXynMrmCSO92vQH489R6yivKPOwdXUKISr8rOtEqSSM5NgWAE8WRb0gC6TFU23CX/jsxlANRnCY9OZ3zGp3HlmNb2JT/J91SLw73kDQjHPEZhTZokaSRHGc1JMeLjwdrmFXwt1W2Xcq+cVo2kzPtRZF5LFg4j1G3f6d6nFTDGxn5VUKIFIfP9YUQXwd3WIobzr4BgLUnalZ6rNLvil60EPFMirHWMecZ/dOT84VAGs4pKXvf8CbY3lBKWfmvLqU8BTQK3pAUADeefSN6EcOW/M2cKAvN7C0URJMbTlEVLSYBBr1131JzabCGWUkgxkBJ2fuGN4akwrEAUQjRiqqSKYogkGxIpne7XoDk5+Pfh3s4CoUmk4B4fTwApabgG5JAjIGSsvcNbwzJOGCNEGKeEGIe8COgKsZ8xJ/AXb8O/QD4+cQPVMiKkIzTVyl6f49R1E4MOqvqbygMSSDGQEnZ+4ZHQyKl/B9wEfCx7dVVSqliJD7gr6/2wqYX0iqlFfmmPDae8tzHQQv8kb/wVzJDUfuI01lXJCWm4E86AjEGWvQYqk14pbUFXIq1ve7VQM1JIQoR/vpqhRDccd4dAHy9b0VIZv3+aGAp3azIJBJXisLmZ5Ih8I4HYgy87Y6qsOKN1taLQHdgge2rR4UQl0kplXvLS5YuXMzkTNe+2oyJi12qnN5y7i28+ctb7PtjD6xDc7Vcf+QvlG5WdBCJCsvS9lQXCA97+o895feLBf/l2JFy+q6Ha6+F4cPh6FHv+pooKXvf8GZFcjPQW0o5S0o5C7gRUC3yfCAQX22d2Drc2ekO+NP6WetZvz/yF4FIZkTiLLmmEskrxWAZEkc38vMT81m1Cl55BY4fh7vugvEZyWe0ynaFXcp+yYavWXtoHUs2fM3wMSOUEXGCt/KbKcBJ28+aRZmEEDcCMwA98H9SyherbY8HPgS6ArnA3VLKfVpdP1RYfbV5tGt35jZXvtqH73yY33/6/fQXeuvb7q07NJ31+yN/EYhkRiTOkmsK0bBStLu0RPXluUY4upHtl2jXDp5/3uqWat/tDtXjJAh4syKZCvwphJgjhJgLbABeCPTCQgg98BZwE9ARGCCEqP7kGQ6cklK2A14FXgr0uuHAH1/t0EeHYkhw6GttS9qqMJ/O3tJKLdcf+Qt/JTMieZYc7WgprugKY6mRFYsWM27Yg4y8dTDjhj3IikWLMZYavTrebLFqrHmjau0Pqv4jPLj91xTWacMarAH27ljb7D4tpTyqwbV7ALullHtt1/oI6As49pntC2Tafv4v8KYQQkhZ/ZEc2fjTg7rb5d2YPm86Y4aMcfpHqrVarj/yF94cEw2z5JpCsDtgGkuNzBibSYtmOUydYrL9Py5k3vzlzBj7O4++kFl18uOEUos17TcxLtGvMXhC1X+EB7crEtsDe4mU8oiUcqmU8guNjAhAc6wS9Xaybd853UdKacYqZ59W/URCiBFCiPVCiPV5J4MvveAr9sBd+25DyJiYwo03CjImpnj01Xa7vBtT3p1yhvS6iBH88+lRmqrl+iN/4c0xoZglK04TzA6Y3yxZQYtmOWRMMFXJPszMMJHeNIdvlqzweA57RXvduLp+j8Mdqv4jPHjj2lonhOgehGs7c5JWX2l4sw9SyveklN2klN1SUlOcHBJ+/A3cFRYUoo/Ro9PpiDfEgwCpk2w++pem4/NH/sJ+zBMvjiNr+05Ki04CkkN7d1a6O1QfktATLIXltStXM3iQyanbaPAgE7+sWu3xHMYgr0hU/Ud48MaQXAP8IoTYI4TYJITYLITYpMG1s4EWDp/TgcOu9hFCxGAN9J+kFmCvhP/PM5MxlpSSkAC9bruGRm0bQTn8vOpHSs3aZT75I3/x0PgnuOLGa3njuUnkZy9n6pRCVq2CV181k3dwOTPGZlYak0joE19b0EJc0Rm5Jwrduo1yjxd5PEeJ2WrMgrUiUfUf4cGbiNdNQbr278DZQog2wCHgHmBgtX2WAvcBvwB3AN9GS3zEX/lq+7F2CetXX62w+aItLFj4LWmJzaFvI45tP8bSw4u5u+WQEN2RcxzdHY5ZMpkZJjInWt0dfQb0D0uf+NqKr43OvCWtQRJZWYUusw/TGnpeZeSZTgHQoE4Dn6/vzd+Uqv8ID96sSJoCJ6WU+6WU+7GuCJoEemFbzONh4GtgG/CJlHKLEGKSEOI2224fAGlCiN3AE8AzgV43FAQiXw3uK+Ebpx7iivRLEQME3+Ws5EDxvtDclAu8dXcEa5asOJNgKSxfen0v5s2Pdeo2mr8glkt69/J4jrxyqyFpVNc3AXFf/qZU/Ufo8caQvAM4rlmLbd8FjJTySylleynlWVLKKbbvJkgpl9p+Nkop75RStpNS9rBneEU6gfYy8JTCuHbJ99zd6W4kkoX7Z2ORliDejXu8dXeoPiTRz3X9+pB9pDGZE2OruI0yJ8aSfaQx1/XzXKdsX5E0SvTNkKj+IJGNN4akSrqtlNKC94WMtZJAc9m9SWH8V/d/kahPIqt4Dz8d/06jkfuO1d3hfJuju0P1IYl+DAkGHn0hk5QWtzBufBI33CAYNz6JlBa3eJX6C3Cq3BribFi3oU/XVvUhkY03BmGvEGI0p1chDwFRsTIIF4HmsntTCZ8Yl8jYa59l7Kqx/PfgQjolX0BqvHO/s7HUyDdLVrB25WpyTxSS1iCJS6/vxXX9+nj1x+8Oq7tjOZkZVd1bvrg7FNGDIcFAnwH96TPAmv1UWlzCnFfeRVo8r4rNFjO5ZScAQePExj5dV9WHRDberEhGYlX/PYQ1i6onoDQG3BBoLru3KYzXtr2Wq9tcTbmljHn7PnDq4rIXkVVmVa2EqVMKq2RVBYIW7g5F9OJLC4FjZTlILDRLaoohxrcJjKoPiWy86UdyTEp5j5SykZSysZRyoJTyWCgGF60EmsvubQqjEIKnrngKgy6BrQWbWXn0zIIwLYrI3KGFuyMSUGKS/uGL5M2hEmv9cdvUtj5fR9WHRDbCVTatEOIpKeXLQog3cF4EODrYg/OHDhd0kHNXzg3rGOwZJo1SnUuieKM8ak91XLawagqjs/ThNfvXMOarMQh0jDl3LGcnnVu5bdywB5k6xXnK5q5dMG58Es/P0iR3IqpZ9+0aZk+fybAxI5WYpBucSd5UmM2V73acSd4sPvgRK48uZ3jX4Yzo7ptTQ4u/KYV7ejbpuUFK2c2fY92tSLbZ3tdjFWqs/lK4wF9JlOrn8DaF8fJWlzPkwiFILLyz6zVOledWbtOiiCzS0WI1UdPFJLVacQUieZNVvBuMsG7aOooKfPt/p8XflCJ4uAy2SymX2d7DO72PUuyGIFSS1SN7jGTb8W2sP7Sembtn8O9znyNWF6dJEZk77MHWoU88QEKY/pj9kaavbWKSWsn3+ysMWVZhZE/hLtgBW37cwk8rf+KmO3yrdQ7135TCe1yuSIQQS929QjlIhWdidDFM6TWFpklN2Ve8lwX7ZiOl1KSIzB3eBluDGYPwZzVR28QktVxx+SN5s7toJxYqqPO3dbKxbNGygMehiBzcpf9eglV5dxHwK84FFBUBEIiMijNSElJ4+YaXuX/x/fyS+xMt67bmun59mDH2dzIn5jB4kKnStzx/gTWrqv8jgWVVOT6g3M10tWxopcVqItiS6+Em2CsubyVvqo/DGGPNEtz02yZ6NulZ+X33K7rz5qdv+j4Ojf+GFP7hLkbSBBgLnI+1i2Fv4ISU8gcp5Q+hGFxNJlAZFVe0b9CezOsyAfjkwAL2lO/UNKvq1XFTeaDP4MrXnm27gNMPKPvr1XFTqxyn5YxYq9VEpIhJBmO1FuwVl7eSN9XHYTFbU9RNJlPld4YEA8MeG+bzGIL1N6TwHZeGREpZIaX8n5TyPqyNrXYD3wshHgnZ6GowwZR86NWuF8MuGobEwszdMzghj9FnQH+en/UO7yybx/Oz3qHPgP5+peZ6+4AqKSz2y+B4g5bS9MGSXPcFX2oxvCXY8v0JdRO4bXB/Uhum0ab9WS4lb865oCODnx0Osc7PY0gw8Mr8V+h6WVefx6BkUyIHt3UkQoh4IcTtwHxgFPA68FkoBlbTCbbkw4juI+h1Vi/KLWW8sv0FcoxHAjqfHW8fUHcMHxjUGbFWq4lIEJMMVsZYMFdcD41/gtRGDdj46x9s/PUPt5I3eemn4A7QxVZ93MTFxzHl3Sl+GRFQsimRhMsYia0/+/nAV8BEKeXfIRtVFOOtzzbYkg86oWPCNRPIM+ax/tB6pm2bzNMdMmhocC1N4a2Uiv0B9d7U1zGVn3ZRVH9ABTsGoYU0fbAk190RyoyxYMr3exsf++PUb2CEmJgYzBVmYuNiMZWb0MfoKSwo9Pv6SjYlcnC3IhkCtAceBdYKIQpsr0IhREFohhdd+OKzDYXkQ3xMPP+58T90adqFQnMBL2+bxHFjzhn7lRaX8Gbmf3j12QleS6l44xIKdEbsKXagxWoiHGKSocwY03LF5U987ETZcfYV70X8KTAZTbTr2I5pc6fRrmM7jCXGgLK3lGxK5OAuRqKTUibZXvUcXklSynqhHGS04IvPNlSSDwmxCbxy8yt0btKZAnM+L27L5Ghp1UaUG3/9gy0b/qJFU++lVLx9QAUSg/AUO4hWafpQth/W8nfkjwH85cRPADRIbcDojNHMXTmXnlf1ZM7Xc3hkwiPUTfS/U6KSTYkcXEqkRCvhlEjp2/UGJmc6V+3dtQsyJqawZMPXQOglH4rLi/n3V//mjyN/UEdflyfOHUuLOq0AmP7MFA7s2sYbb+C1lMrbk1/h7PPPrXQJWSoslS4hx9n89GemsOvv7aS3acnt99/DZ7M+IjvrAO07deCJqWPdjnn6M1PYuXkb53Tu6HHfaGTTb386dQ+OeHY0nXt0CePIXLNj41av3ZUVsoKxGx8jz3SKt259i27N/VLfcImSTdGWQCRSVF8RDfHFZxvslqDOYjU339MXXRsd66ev5/mscZX76mNisFTgk5TKQ+OfqPLZ7hLqfXvVuhRfYhC1rdo8GtsPexsfA/g77y/yTKdomdySrs38C6i7Q7XVjRyUIdEQb/qIOBIsyQfHnu+TM+0ztTwWLFxE8ermnNfvPLa8uQVsz4EKsxmDwTpGraVUvDU4YHWd7N22q3K2WxuqzcvLys5YrXkKXocbbw3gj8e/BaBfx36I6qlVGqFkUyIDb/qRKLwkUny2nnq+X6LrQdcnu1bJ7S8vh1mzCJqUijeEMnYQCURrjMeb+FiO8Qh/529CL2Lo0171pKnpKEOiId72EQk2nvLrV3z0OW88/AZXPXlV5ZrUYoE//4Rx4whrg6pIqTYPBdHaftgbA/i/I8sASZ9zbiYlISV8g1WEBOXa0pBI8dl6E6vR6/Rc0+wafon9hfKKctCD0QjrN+jZtiOWgrwy0homcknvXvR/JPCWvL4QjbGD2oQnd+WJsuOsO7EGgeC+LveFY4iKEKMMicZEgs/W21jN0oVLMRlNtDqnFYVXFnJy6UlMORUkNknnpXlTQjzq00Rr7EBh5esjy7Fg4cazbyQ9OT3cw1GEAOXaqoF4G6tJTEpkdMZoPvr2Iz4a+xE9J/eE3pBdsZ//HVnqtAd8MDGWGlmxaDGHs3YCktKik2Rt38kTU8dFRexAATnGo/x84nvQcDVSUlzCB9Pfo2/XG7ik2cX07XoDH0x/T4kyRhCqjqQG4m9+fYWlgvd+f485f84BoF3iOdzb5l80NjQJ+piNpUZmjM2kRbOqcvfz5ltjNA889xSL3p4b1gZaCvdUWMy8vH0S+4r30qd9HyZcOyHgczpmIDr+X16wUNWKaE2wWu0qohR/25LqdXoe7Pkg02+aTl19IruLdjDp72dZdfTLoK9OvlmyghbNXFfWf/zuXE0UcoPZYKu2s+zwZ+wr3kuTxCY8fpk2CQNK4Tc6UIakhuJLz/fqXN7qcj4f8hk3nn0jZmnivwcXMm3b5DOkVbRk7crVDB5kcpppNniQiR0b/7LuF6BCbjAk291RWwzXzsLtfHVkGQJB5nWZJMUnaXJepfAbHahgewQTqu5vrq7z9Min6d2uNxmrMtlbvItJW8ZyW/P+9G58E3qdtv91ck8Uus00KymuAAKvcvdWsVYrtOwM6QveKjlrQYm5mFl73wEkQy8aRpem2sm7KIXf6EAZkgjFdXX6PEbd/p1mvmFvrrNkyOe8tvY1lu9YzufZH/Nb7lruaDGQjsmdNLhTK2kNksjKKnSZaRYfb01P9rXKPdyyK6E2XFA13jR1ij3eVMi8+cuZMfZ3vzpjusIiLXyw921OlefSsWFH/tn1n5qc146vahGK8KBcWxFKqHzD3lwnKT6J8deMZ0afGTSv15xDpQeZsfMlZux4iYMl+zUZx6XX92Le/FinmWazZ1sr7x3xtso9lJLt4H8rYi3xFG+qruQcCIsPLuLv/I0k6OvwfO/nidFrOzeNFLUIhXuUIYlQQuUb9uU6F7e4mEV3LeLhng8TrzOwtWAzz295jjl73+VUeW5A47iuXx+yjzQmc2Jslcr6ceOsFfexsWArAPepyj3UsiuhNlzO8BRv+mXVak2u8/PxH1id8xU6dLzSZzrN6zXX5LyORIpahMI9ypBEKKHyDft6nfiYeIZ0GcKye5dyT6d70KHjl9yfeG7TGD7P/phSs39BZUOCgUdfyCSlxS2MfS6J66+HMWOgUSP49FN4803o2RMMBhBC+FTlHkrZlUjQC/MUb6qu5OwPuwt3MH/fLACevvJpLmp2UcDndIa/GYiK0KIMSYQSqu5v/l4n2ZDM45c9zqcDPqHXWb0wSzP/O7KMZzY+ypLsT8k35fk8FkOCgT4D+nPp9b248qpYvvgCHnsMEhOtrpkpU+CiiwQVZt87/AXSYMtXwq0XZo03Od8WiJKznW0Ff/P6zmlYqODuTnfTr2O/gM7niUAyEKPmsMMAABRjSURBVBWhQRmSCCVUvuFAr5OenM6U3lP44B8f0KVpF4yWUr468gXPbnyUD7Pe53Bpts9jcueaGTpUkpgU73OVu5YtZ70hlIarOu7iTYEoOUsp+TZnJTN2vEyZxcjVba5m9CWjNRixItpRhiRCCZVvWKvrnN/4fGb2ncn7/d7n6jZXUyEt/HziByb+/Qxv7JzG9oIteKui4Mk1U1hQ7rNCbqgl20NtuBxxFW8KRMnZbDEzf/8sPj7wIRIL93W5jxd6v0CMxmngiugkLBIpQohU4GOgNbAPuEtKecrJfhXAZtvHA1LK2zyduyZJpNjrO5YtrKokHKw6Ei2vczD/IIs2LeKLrUsxS2sHrfSEllzZ6Fp6pF1Kgt71eccNe5CpU5ynAjtr+xsqSotLmPPKu17JtHjbijhY2OtIflm1mtzjRZVKztXrSLy5pwJTPu/unsHuop3EiBgmXDuBG86+Iej3oAgtgUikhMuQvAyclFK+KIR4BqgvpXzayX5FUkqfHLo1yZDUBPKN+Szespj5fyyguMIa5I0VcfRscBmXNriStnXbndE9b8WixeQdXE5mRlX3lpTWWXVKi1voMyD0aZ/rvl3D7OkzGTZmZNSoEHsyFJ7u6UBxFu/sfo2T5bkkxiTxxm2v07GR6xhPUUERk0ZPYsLrE0is538sJlTFuIrTRKPWVl/A/rSfCwQ3WqcIG8mGZO7vej//u/8rJveazEXNLsIky1lz/Dte3jaRCZufZMXhJZwoO1Z5TDBcM1rgWFwYLXiShHF1T2UVRpYd+oypWzM5WZ7LeY3O4+MBH7k1IgA/fv0jP/zvB35a+ZPfY7YXye7aMI/JmXmsXCmZnJnHzvXzGHX7cKX6G4GEa0WSJ6VMcfh8SkpZ38l+ZuAvwAy8KKVc4uJ8I4ARAE3Sm3T9Yv0XwRm4QhP2ndrH0u1L+d+u/5Fbcrr+pGWd1nRN7cFF9XtQT6Z45ZoJJs6q4ivM5sp3O8GqiteC6c9MYefmbZzTuSNPTB3r9T3p2+qpuNcqS9P/vP48esmjxMfEe7zeg7c/yB9r/6DrZV15e/Hbfo35g+nvsWvDPMY/V37GinTS5DjadxuierQHgYh0bQkhVgPO9MfHAXO9NCTNpJSHhRBtgW+B66SUe9xdV7m2ogezxcxv2b/x1c6v+H7P95TL0+XrLeq04qL6PbiofneaJDQLy/h2bNzKmxP/Q3lZuct9wtFH3p27yltD4ZZYYCB06NGB0ZeMdlsj8vCdD/P7T7+fPjQ2FpPJVPlup/sV3Xnz0zddnsfRlZVzOI+0NLj1VrjzTkhwyIfYtQsyJqawZMPX3t2LwmsCMSRBS7mQUrrMMRRC5AghmkopjwghmgLHnO0npTxse98rhPge6AK4NSSK6CFGF8OlLS/l0paXYrzayK8Hf+Xbvd/y7Z7vOFiyn4Ml+/ni0Kc0NjTl/OQL6JRyIe0SzyFWF+v55BpgLy50ZUzCYUTAvRDkzXf1Ze+2XZXjdVZZHxNr/bM3m5wYllhIHZ7KY4Meo3e73uiEe+/30EeHsnn9ZoylRoBK4+FoRAwJBoY9NszlOZzrvcH8+fDEE/DKK6eNiRJqjEzC5dqaBuQ6BNtTpZRPVdunPlAipSwTQjQAfgH6Sim3uju3WpFEP+UV5fyW/Rvf7PmGb3Z/S5nFWLktRsTSPulczq13Hh3qnUd6nVaUG8uDqnS76bc/eW/q65jKTeh0EBcHZWWQXD+BK2++MSjuNnfqvW9NnF7FXVUddyspu/ErLClg1ovvUGGqOL0xBm4ZfwtPDX/KKzeWnfVr1jNmyJhKY+KIIcHAK/NfoetlXV0e786VNXEitG0L995r/U6tSIJHRLq23F5UiDTgE6AlcAC4U0p5UgjRDRgppfynEOJS4F3AgjUp4DUp5Qeezq0MSc3CbDGzOWczaw+sZe3+tew+ubvK9tjyWBIW6ujcysR9gy1ndFbUQul23bdrWPDmbHSijIsugmHDcHkdX1KEXeGqW+SsWVbdsXKTHktFhdtYjaPxq/xdxcVy4+jbyGl5hA3f/0rF8gowAXoQFoHBYODpl5/mpjtu8nnMa1au4dl/PVvFeMXFxzH1/alcfr37DLe+XW9gcqZzhd9du2DCBFi0SMVIgk3UZW1JKXOllNdJKc+2vZ+0fb9eSvlP289rpZSdpJQX2N49GhFFzSNGF0OXpl0Y1XMUC+5awJf3fsmk6yZx67m30iypGRW/mDivZRmTMixnKN02a3KEzz5ZgNniZWzABT+v/IEKcxkXdRU8/zxuFXW1aJzlSr13yhTo0gWQ1lWEOyFIx8r6mLgYEGDCxLI9i/ntyFrk9xUYdCCAtPp1aNCoPqUlpSxbtMyvMRcWFKKP0aPT6Yg3xKPT6dDH6CksKPR4rEe9t2NKqDHSUZXtiqgirU4aN5x9A89d/RyfD/qcBjvqcf8QnMqp3Du4gl+/+Y7RfwxnypbxzNv3AT8c+4a9Rbt9EpdMqJtAYlI8w4ZKj4q6WqQIu5OIGTbM6lpzxDFWY5EWDhTvY9nyzygrMyIbScx3m6ExUA5xG+Nourg+l3QUvPEGrFoFL75QQscORTRrkYrB4N/qbenCpRhLjLTr2I5pc6fRrmM7jCVGrwyTJ723uDiUUGOEo/QNFFHNiaPu5VTKToGUFRwoyeJASdWnVUpsfZokNKNxfBMaGZrS2NCYtPiGpMalYdCfThV6aPwTjLx1sNvrnDhWyAN9BmvSOMuTRExZ2enPMbExXPVQL3akbeXbXSvZVbSdYrNN3bc3cDG0a9iObrd1o2JtBeuX/0rr9KOMf+60UWzXDjLGlzNpchHtLzrXqzFWJzEpkdEZo7lnxD3odDq6Xd6Nj977iL/W/eXxWKve2zwmjD8zRrJwURz3PqJcWZGOMiSKoBLsCmVPHfSaNE1h/v2L2XViF9tPbGf78e3sObmHrJNZ5JlOkWc6xXa2nHFsgr4O9eNSba80klLjyMoq97qDYyD9R7zqFlkBmMEszKza9yU4iDQ3SWxCj4k96J7enW7Nu5GakGrdcAX0/eQGt/1nMiYu9uuhPW3utCqf9Xo9gx4cxKAHB3k8dsDIwYy6/TsmTc5m4IDTWVsLF1ldWRnKlRXxKEOiCBqhaBfsaTZ768D+JMYl0qVZF7o0O91LvMJSwdGio2SdyuJg/kEO5h/kcMFhDhUcIqc4h1JzCaWlJZXqxbpOMOtDmDKRM64z+0Mod0h+ckQXq+OsB9qzNvFH1u79EcHpgy1YKKsoo8xipNxSVvlzcady19eaDeVxWLUhVgE5kLI9hX5D+9G6fmvOa3QeLZJbnCE7YycSe6Dbe44smjmfjIlV9d4ylCRKVBCWrK1gorK2IodQVCjbjVWjVOezWX+MlZSSgrICcopyOFZ8jJyi/2/vzoOkKM84jn9/HErIpUhEURI1wQtNxQuEJAbJIYoFwWgSKuVVWJYmaI7SlCkvIn8kVsUkWsaDiJFARBOMihEjigdJBA2KXBIFMVZWKRSjRFGXwyd/dC87LLO7vTs7Pcf+PlVT0zPd/c477/Tu0/129/Oup+H1Bh667D4OHLhph6vDfjcDlvwb3h8G3EOSg6FJL+A04KAOfqlG6DMTjtgPzj69+Qqx26bDv9b25YLpF3PIoEMY+OGBzJ42m2cXPbvTEUFr2rtCypfWdl81d/lvOTmQVI+8/mlVMkvymAnjOfmscTz6wKPcfOXNNL7fSK/evdi6ZSu9d+3NmB+N4fCvHQ6wUxr9HupBn9596Nu7L3167fjcY0sP7p42u8u/07RrpvLC4uJHcL60tntzICngQFI9hg88lnnzgp49d563dSuMHi2eeGVR/hUrg/NPOZ8lC5cweMhgJl0+ieunXM/qlas5csSRnc45VQ7lOIKz+lCVKVLM2jsR3lXDBVeDUq5aypPPR1g5+IjEysbdKGa1o+bubLfuIa/hgs2ssty1ZWXjbhSz7sFdW2ZWlIe77V58st3MulQeN5Na/fA5ErPUu5veZdo1Uxl31AkMH3gs4446gWnXTO2WY4TPumkmA/Zo4PLLNu+QgfiKyzezZ78GZt00s9JVtCriQGJG8x746qdnMGXyW8ybF0yZ/BYvLJ7B906Z2OXBpNqD1pzb72ozJ9d9t99VmYpZVXIgMSPfPfC8g1ZnVGNOLqteDiRm5LsHXgvdRu2NEVJPN5Na6RxIzMh3D7wWuo2SrMq70PKizsKsymZNHEjMyHcPvBa6jXwzqXWEA4kZ+e6B10K3UdPNpAcefTpX/nQ3Ro+Wh7u1VvmGRDPyzYrrHGRWjZxry6xEee6Bu9vI6o2PSMwqIK/BuMyy8sBWBRxIzMw6zl1bZmZWMQ4kZmZWEgcSMzMriQOJmZmVxIHEzMxK4kBiZmYlcSAxM7OSOJCYmVlJHEjMzKwkDiRmZlYSBxIzMytJRQKJpNMkrZT0gaRWc7tIGi3peUlrJF2SZx3NzCybSh2RrABOARa0toCknsBvgBOBQ4EJkg7Np3pmZpZVr0p8aESsAlDLQat3NBRYExFr02XvAMYBz5W9gmZmlllFAklG+wD/KXjdAAwrtqCkc4GmIeUah+01bEWZ61Yr+gMbKl2JKuG2aOa2aOa2aHZQZ1csWyCR9DCwV5FZl0bEvVmKKPJe0cFTImIqMDX93MWdzalfb9wWzdwWzdwWzdwWzSQt7uy6ZQskEfGVEotoAAYVvN4XeLXEMs3MrItV8+W//wQGS9pf0i7At4E5Fa6TmZm1UKnLf8dLagCGA/dLejB9f6CkuQARsRWYBDwIrAL+GBErMxQ/tUzVrkVui2Zui2Zui2Zui2adbou6G7PdzMzyVc1dW2ZmVgMcSMzMrCQ1H0icbqWZpH6SHpK0On3evZXltkl6Nn3U1QUM7f3OknaVdGc6/0lJ++Vfy3xkaIuzJL1esC2cU4l6lpukWyW9Jqno/WVKXJe20zJJR+Zdx7xkaIuRkjYWbBNXZCm35gMJTrdS6BJgfkQMBuanr4t5LyI+lz7G5le98sr4O08E3oyIzwC/Aq7Ot5b56MA2f2fBtnBLrpXMz23A6DbmnwgMTh/nAjfmUKdKuY222wLgbwXbxFVZCq35QBIRqyLi+XYW255uJSI2A03pVurNOGB6Oj0d+HoF61IJWX7nwjaaDXxZ7eTqqVHdZZtvV0QsAP7bxiLjgN9HYhGwm6S986ldvjK0RafUfCDJqFi6lX0qVJdyGhAR6wDS5z1bWa6PpMWSFkmqp2CT5Xfevkx6iflGYI9capevrNv8N9LunNmSBhWZ3x10l/8PWQ2XtFTSA5KGZFmhmnNtbZdnupVq11ZbdKCYT0bEq5IOAB6RtDwiXuyaGlZUlt+5braFdmT5nvcBsyKiUdJ5JEdqo8pes+rTXbaJLJ4BPhUR70g6CbiHpMuvTTURSJxupVlbbSFpvaS9I2Jdemj+WitlvJo+r5X0GHAEUA+BJMvv3LRMg6RewMcpw6F+FWi3LSLijYKXv6VOzxdlUDf/H0oVEf8rmJ4r6QZJ/SOizcSW3aVrq7ukW5kDnJlOnwnsdLQmaXdJu6bT/YHPUz+p+bP8zoVtdCrwSNTnXbnttkWL8wBjSTJIdEdzgDPSq7eOBTY2dRF3N5L2ajpnKGkoSYx4o+21gIio6QcwnmSPohFYDzyYvj8QmFuw3EnACyR73pdWut5laos9SK7WWp0+90vfPxq4JZ0eASwHlqbPEytd7y5ug51+Z+AqYGw63Qf4E7AGeAo4oNJ1rmBb/AxYmW4LjwIHV7rOZWqHWcA6YEv6v2IicB5wXjpfJFe4vZj+TRxd6TpXsC0mFWwTi4ARWcp1ihQzMytJd+naMjOzMnEgMTOzkjiQmJlZSRxIzMysJA4kZmZWEgcSqyuSQtKMgte90gy3f0lfjy1n9mdJkyVd1Mq8JzpQzt1p9tU1LbKxjuhgfUal90YUmzdE0kJJjZJ+0JFyzQrVxJ3tZh2wCThM0oci4j3gq8ArTTMjYg4Zb0ZNb8xSRHzQFRWLiMxBICLGp3UYCVwUESd38mNHARtI7gloaQNwAcmNmWad5iMSq0cPAGPS6QkkN2EB28fguD6dHpDu+S9NHyMk7SdplaQbSPIODZI0QdJySSskXV1Q1mhJz6Trzi/4/EMlPSZpraQLC5Z/J30eKWlB+tnPSbpJUua/RUnHSHpc0tNpYr0B6fs/TMtbKmmmpE8D5wAXFzuaiYj1EbEY2Jr1s82K8RGJ1aM7gCvS7qzPArcCXyyy3HXA4xExPh2/4yPA7sBBwNkR8V1JA0lyUB0FvAnMSzMm/4MkP9VxEfGSpH4F5R4MHA98FHhe0o0RsaXFZw8lGSfkZeCvJGPqzG7vi6Xpba4luTt9g6TvAFNIxtH4MUnCvc2SdouItyTdAmyIiF+3V7ZZZzmQWN2JiGVKRj6cAMxtY9FRwBnpOtuAjUpGlXw5knEpAI4BHouI1wEk/QE4DtgGLIiIl9L1CxM/3h8RjUCjpNeAASTpKAo9FRFr0zJnAV8gQyABDgGGAA+nKZF6FpS9Epgp6V6SrK1muXAgsXo1B/gFMJKOjzeyqWC6tUGvROupxhsLprdR/O+s5bpZcxUJWBYRxY6wTgC+RDJQ02WSDstYpllJfI7E6tWtwFURsbyNZeYD50MyNK2kjxVZ5kngS5L6p91fE4DHgYXp+/un6/crsm5bhqaZeXsA3wL+nnG954B90sysSNolvfqqJ7BvRDwCXAx8AugLvE3SxWZWNg4kVpcioiEirm1nse8Dx0taDjxN0mXUspx1wE9IsuMuBZ6JiHvTrq5zgT9LWgrc2cEqLgR+DqwAXgLuzrJS2mV2KvDL9HOXAMNIjnpul7SM5CKBqyPibZKhBL4paUnLk+2S9pXUAFwITJbUIKlvB7+HmbP/muWtCy7pNasqPiIxM7OS+IjEzMxK4iMSMzMriQOJmZmVxIHEzMxK4kBiZmYlcSAxM7OS/B9GeR8T8k4XMgAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Initialize fitting parameters\n", "initial_theta = np.zeros(X.shape[1])\n", @@ -957,7 +1330,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.6.6" } }, "nbformat": 4, From 0b356733aa6b14795187e73eb72eddf91f14c990 Mon Sep 17 00:00:00 2001 From: jbpextra Date: Tue, 21 Aug 2018 01:20:02 +0200 Subject: [PATCH 3/3] ex3 completed --- Exercise3/exercise3.ipynb | 262 ++++++++++++++++++++++++++++++++------ 1 file changed, 224 insertions(+), 38 deletions(-) diff --git a/Exercise3/exercise3.ipynb b/Exercise3/exercise3.ipynb index c5771719..bc9900ea 100755 --- a/Exercise3/exercise3.ipynb +++ b/Exercise3/exercise3.ipynb @@ -19,7 +19,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -132,9 +132,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Randomly select 100 data points to display\n", "rand_indices = np.random.choice(m, 100, replace=False)\n", @@ -158,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -267,7 +278,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -348,7 +359,19 @@ " grad = np.zeros(theta.shape)\n", " \n", " # ====================== YOUR CODE HERE ======================\n", - "\n", + " z = theta@np.transpose(X)\n", + " h = 1/(1+np.exp(-z))\n", + " \n", + " Jv = -y@np.log(h)-(1-y)@np.log(1-h)\n", + " J = np.sum(Jv)/m + (theta[1:]@theta[1:])*lambda_/(2*m)\n", + " \n", + " d = h-y\n", + " d = d@X\n", + " grad = d /m\n", + " \n", + " reg = theta * lambda_ / m\n", + " reg[0] = 0\n", + " grad += reg\n", "\n", " \n", " # =============================================================\n", @@ -389,9 +412,23 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cost : 2.534819\n", + "Expected cost: 2.534819\n", + "-----------------------\n", + "Gradients:\n", + " [0.146561, -0.548558, 0.724722, 1.398003]\n", + "Expected gradients:\n", + " [0.146561, -0.548558, 0.724722, 1.398003]\n" + ] + } + ], "source": [ "J, grad = lrCostFunction(theta_t, X_t, y_t, lambda_t)\n", "\n", @@ -417,9 +454,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n", + "Login (email address): jbpextra@hotmail.com\n", + "Token: nRbZs04bBfHOwDjr\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Regularized Logistic Regression | 30 / 30 | Nice work!\n", + " One-vs-All Classifier Training | 0 / 20 | \n", + " One-vs-All Classifier Prediction | 0 / 20 | \n", + " Neural Network Prediction Function | 0 / 30 | \n", + " --------------------------------\n", + " | 30 / 100 | \n", + "\n" + ] + } + ], "source": [ "# appends the implemented function in part 1 to the grader object\n", "grader[1] = lrCostFunction\n", @@ -448,7 +506,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -526,7 +584,15 @@ " X = np.concatenate([np.ones((m, 1)), X], axis=1)\n", "\n", " # ====================== YOUR CODE HERE ======================\n", - " \n", + " initial_theta = np.zeros(n+1)\n", + " options = {'maxiter', 50}\n", + " for c in range(num_labels):\n", + " res = optimize.minimize(lrCostFunction, \n", + " initial_theta, \n", + " (X, (y == c), lambda_), \n", + " jac=True, \n", + " method='CG')\n", + " all_theta[c] = res.x\n", "\n", "\n", " # ============================================================\n", @@ -542,7 +608,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -559,9 +625,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n", + "Use token from last successful submission (jbpextra@hotmail.com)? (Y/n): Y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Regularized Logistic Regression | 30 / 30 | Nice work!\n", + " One-vs-All Classifier Training | 20 / 20 | Nice work!\n", + " One-vs-All Classifier Prediction | 0 / 20 | \n", + " Neural Network Prediction Function | 0 / 30 | \n", + " --------------------------------\n", + " | 50 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[2] = oneVsAll\n", "grader.grade()" @@ -580,7 +666,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 49, "metadata": {}, "outputs": [], "source": [ @@ -634,8 +720,12 @@ " X = np.concatenate([np.ones((m, 1)), X], axis=1)\n", "\n", " # ====================== YOUR CODE HERE ======================\n", - "\n", - "\n", + " h = np.zeros((num_labels, m))\n", + " for c in range(num_labels):\n", + " z = all_theta[c]@np.transpose(X)\n", + " h[c] = 1/(1+np.exp(-z))\n", + " h = np.transpose(h)\n", + " p = np.argmax(h, axis = 1)\n", " \n", " # ============================================================\n", " return p" @@ -650,9 +740,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Set Accuracy: 96.44%\n" + ] + } + ], "source": [ "pred = predictOneVsAll(all_theta, X)\n", "print('Training Set Accuracy: {:.2f}%'.format(np.mean(pred == y) * 100))" @@ -667,9 +765,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 51, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n", + "Use token from last successful submission (jbpextra@hotmail.com)? (Y/n): Y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Regularized Logistic Regression | 30 / 30 | Nice work!\n", + " One-vs-All Classifier Training | 20 / 20 | Nice work!\n", + " One-vs-All Classifier Prediction | 20 / 20 | Nice work!\n", + " Neural Network Prediction Function | 0 / 30 | \n", + " --------------------------------\n", + " | 70 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[3] = predictOneVsAll\n", "grader.grade()" @@ -690,9 +808,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 52, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# training data stored in arrays X, y\n", "data = loadmat(os.path.join('Data', 'ex3data1.mat'))\n", @@ -735,7 +864,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 53, "metadata": {}, "outputs": [], "source": [ @@ -774,7 +903,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 82, "metadata": {}, "outputs": [], "source": [ @@ -828,14 +957,18 @@ " # useful variables\n", " m = X.shape[0]\n", " num_labels = Theta2.shape[0]\n", - "\n", + " \n", + " X = np.concatenate([np.ones((m, 1)), X], axis=1)\n", + " \n", " # You need to return the following variables correctly \n", " p = np.zeros(X.shape[0])\n", "\n", " # ====================== YOUR CODE HERE ======================\n", - "\n", - "\n", - "\n", + " a2 = utils.sigmoid(Theta1@np.transpose(X))\n", + " a2 = np.concatenate([np.ones((1 ,a2.shape[1])), a2], axis=0)\n", + " a3 = utils.sigmoid(Theta2@a2)\n", + " a3 = np.transpose(a3)\n", + " p = np.argmax(a3, axis=1)\n", " # =============================================================\n", " return p" ] @@ -849,9 +982,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 83, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training Set Accuracy: 97.5%\n" + ] + } + ], "source": [ "pred = predict(Theta1, Theta2, X)\n", "print('Training Set Accuracy: {:.1f}%'.format(np.mean(pred == y) * 100))" @@ -868,9 +1009,27 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 84, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Neural Network Prediction: 4\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "if indices.size > 0:\n", " i, indices = indices[0], indices[1:]\n", @@ -890,13 +1049,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 85, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Submitting Solutions | Programming Exercise multi-class-classification-and-neural-networks\n", + "\n", + "Use token from last successful submission (jbpextra@hotmail.com)? (Y/n): Y\n", + " Part Name | Score | Feedback\n", + " --------- | ----- | --------\n", + " Regularized Logistic Regression | 30 / 30 | Nice work!\n", + " One-vs-All Classifier Training | 20 / 20 | Nice work!\n", + " One-vs-All Classifier Prediction | 20 / 20 | Nice work!\n", + " Neural Network Prediction Function | 30 / 30 | Nice work!\n", + " --------------------------------\n", + " | 100 / 100 | \n", + "\n" + ] + } + ], "source": [ "grader[4] = predict\n", "grader.grade()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -915,7 +1101,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.6.5" } }, "nbformat": 4,