diff --git a/3. Modeling.ipynb b/3. Modeling.ipynb index 4f57ba4..61a3171 100644 --- a/3. Modeling.ipynb +++ b/3. Modeling.ipynb @@ -50,7 +50,9 @@ { "cell_type": "code", "execution_count": 3, - "metadata": {}, + "metadata": { + "scrolled": false + }, "outputs": [ { "data": { @@ -285,6 +287,24 @@ "data.head()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Reserving data for API testing\n", + "Before spliting the dataset we'll reserve a few rows of data to do final\n", + "testing of the API. This ensure reserved rows never gets leaked into the training data.\n", + "\n", + "| Name | NBA ID | Position |Note|\n", + "|------|------|------|------|\n", + "|Lebron James|2544|Small Forward|Play style not bound by position label|\n", + "|Pascal Siakam|1627783|Power Forward|Standard power foward|\n", + "|DeMarcus Cousins|202326|Center|Standard center|\n", + "|Damian Lillard|203081|Point Guard|Standard point guard|\n", + "|Anfernee Simons|1629014|Shooting Guard|Rookie with little data|\n", + "\n" + ] + }, { "cell_type": "code", "execution_count": 4, @@ -294,10 +314,41 @@ "name": "stdout", "output_type": "stream", "text": [ - "X_train: (433, 19)\n", - "y_train: (433,)\n", - "X_test: (145, 19)\n", - "y_test: (145,)\n" + "Shape of data before dropping: (638, 20)\n", + "Shape of data after dropping: (633, 20)\n" + ] + } + ], + "source": [ + "print(\"Shape of data before dropping:\", data.shape)\n", + "labels_to_lookup = ['2544','1627783','202326','203081','1629014']\n", + "\n", + "# Drop duplicates because the same player will have multiple seasons of play data.\n", + "# Each in a different column\n", + "idx_to_drop = [data.drop_duplicates().index.get_loc(label) for label in labels_to_lookup] \n", + "\n", + "data_api_test = data.iloc[idx_to_drop,:]\n", + "data = data.iloc[[i for i in range(len(data)) if i not in idx_to_drop]]\n", + "\n", + "with engine.connect() as conn:\n", + " data_api_test.to_sql(\"api_test\", conn)\n", + "\n", + "print(\"Shape of data after dropping:\", data.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "X_train: (429, 19)\n", + "y_train: (429,)\n", + "X_test: (144, 19)\n", + "y_test: (144,)\n" ] } ], @@ -332,7 +383,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": { "scrolled": false }, @@ -403,114 +454,114 @@ " \n", " \n", " \n", - " 1626171\n", - " 0.315287\n", - " 0.216561\n", - " 0.164013\n", - " 0.020701\n", - " 0.014331\n", - " 0.269108\n", - " 628\n", - " 0.633333\n", - " 0.233333\n", - " 0.133333\n", + " 1629019\n", + " 0.409266\n", + " 0.094595\n", + " 0.241313\n", + " 0.021236\n", + " 0.021236\n", + " 0.212355\n", + " 518\n", + " 0.806451\n", + " 0.096774\n", + " 0.048387\n", + " 0.00000\n", " 0.000000\n", - " 0.000000\n", - " 0.000000\n", - " 30\n", - " 7.9\n", - " 22.1\n", - " 5.4\n", - " 2.8\n", - " 2065.831667\n", + " 0.048387\n", + " 62\n", + " 1.0\n", + " 5.5\n", + " 3.9\n", + " 0.9\n", + " 1458.563333\n", " \n", " \n", - " 1628964\n", - " 0.380165\n", - " 0.123967\n", - " 0.210744\n", - " 0.049587\n", - " 0.028926\n", - " 0.206612\n", - " 242\n", - " 0.533333\n", - " 0.333333\n", - " 0.133333\n", + " 202709\n", + " 0.176471\n", + " 0.176471\n", + " 0.340074\n", + " 0.031250\n", + " 0.040441\n", + " 0.235294\n", + " 544\n", + " 0.636363\n", + " 0.227273\n", + " 0.090909\n", + " 0.00000\n", " 0.000000\n", - " 0.000000\n", - " 0.000000\n", - " 15\n", - " 4.0\n", - " 10.6\n", - " 2.4\n", - " 0.8\n", - " 766.193333\n", + " 0.045455\n", + " 22\n", + " 1.7\n", + " 10.5\n", + " 13.1\n", + " 3.9\n", + " 4273.400000\n", " \n", " \n", - " 203476\n", - " 0.293333\n", - " 0.138667\n", - " 0.426667\n", - " 0.048000\n", - " 0.050667\n", - " 0.042667\n", - " 375\n", - " 0.619047\n", - " 0.380952\n", - " 0.000000\n", + " 1627885\n", + " 0.588652\n", + " 0.172577\n", + " 0.035461\n", + " 0.047281\n", + " 0.028369\n", + " 0.127660\n", + " 423\n", + " 0.682927\n", + " 0.219512\n", " 0.000000\n", + " 0.04878\n", " 0.000000\n", - " 0.000000\n", - " 21\n", - " 7.6\n", - " 19.8\n", - " 6.0\n", - " 3.8\n", - " 2363.836667\n", + " 0.048780\n", + " 41\n", + " 2.2\n", + " 12.8\n", + " 11.6\n", + " 6.2\n", + " 1814.446667\n", " \n", " \n", - " 1627750\n", - " 0.214347\n", - " 0.205807\n", - " 0.229718\n", - " 0.021349\n", - " 0.014518\n", - " 0.314261\n", - " 1171\n", - " 0.450980\n", - " 0.352941\n", - " 0.137255\n", - " 0.039216\n", - " 0.000000\n", - " 0.019608\n", - " 51\n", - " 2.8\n", - " 8.9\n", - " 12.2\n", - " 2.8\n", - " 5012.030000\n", + " 203121\n", + " 0.037267\n", + " 0.060041\n", + " 0.153209\n", + " 0.066253\n", + " 0.076605\n", + " 0.606625\n", + " 483\n", + " 0.133333\n", + " 0.066667\n", + " 0.200000\n", + " 0.00000\n", + " 0.066667\n", + " 0.533333\n", + " 15\n", + " 0.8\n", + " 6.7\n", + " 6.7\n", + " 1.8\n", + " 3701.945000\n", " \n", " \n", - " 203915\n", - " 0.328068\n", - " 0.171324\n", - " 0.057108\n", - " 0.029162\n", - " 0.052248\n", - " 0.362090\n", - " 823\n", - " 0.388889\n", - " 0.555555\n", - " 0.000000\n", - " 0.000000\n", - " 0.027778\n", - " 0.027778\n", - " 36\n", - " 1.5\n", - " 8.1\n", - " 18.7\n", - " 2.4\n", - " 4220.028333\n", + " 101139\n", + " 0.148387\n", + " 0.090323\n", + " 0.109677\n", + " 0.067742\n", + " 0.090323\n", + " 0.493548\n", + " 310\n", + " 0.588235\n", + " 0.176470\n", + " 0.117647\n", + " 0.00000\n", + " 0.058823\n", + " 0.058823\n", + " 17\n", + " 0.9\n", + " 8.8\n", + " 4.3\n", + " 2.8\n", + " 1150.968333\n", " \n", " \n", "\n", @@ -519,38 +570,38 @@ "text/plain": [ " shot_res shot_in_paint shot_mid_range shot_lcorner_3 \\\n", "nba_id \n", - "1626171 0.315287 0.216561 0.164013 0.020701 \n", - "1628964 0.380165 0.123967 0.210744 0.049587 \n", - "203476 0.293333 0.138667 0.426667 0.048000 \n", - "1627750 0.214347 0.205807 0.229718 0.021349 \n", - "203915 0.328068 0.171324 0.057108 0.029162 \n", + "1629019 0.409266 0.094595 0.241313 0.021236 \n", + "202709 0.176471 0.176471 0.340074 0.031250 \n", + "1627885 0.588652 0.172577 0.035461 0.047281 \n", + "203121 0.037267 0.060041 0.153209 0.066253 \n", + "101139 0.148387 0.090323 0.109677 0.067742 \n", "\n", - " shot_rcorner_3 shot_above_3 fga block_res block_in_paint \\\n", - "nba_id \n", - "1626171 0.014331 0.269108 628 0.633333 0.233333 \n", - "1628964 0.028926 0.206612 242 0.533333 0.333333 \n", - "203476 0.050667 0.042667 375 0.619047 0.380952 \n", - "1627750 0.014518 0.314261 1171 0.450980 0.352941 \n", - "203915 0.052248 0.362090 823 0.388889 0.555555 \n", + " shot_rcorner_3 shot_above_3 fga block_res block_in_paint \\\n", + "nba_id \n", + "1629019 0.021236 0.212355 518 0.806451 0.096774 \n", + "202709 0.040441 0.235294 544 0.636363 0.227273 \n", + "1627885 0.028369 0.127660 423 0.682927 0.219512 \n", + "203121 0.076605 0.606625 483 0.133333 0.066667 \n", + "101139 0.090323 0.493548 310 0.588235 0.176470 \n", "\n", " block_mid_range block_lcorner_3 block_rcorner_3 block_above_3 \\\n", "nba_id \n", - "1626171 0.133333 0.000000 0.000000 0.000000 \n", - "1628964 0.133333 0.000000 0.000000 0.000000 \n", - "203476 0.000000 0.000000 0.000000 0.000000 \n", - "1627750 0.137255 0.039216 0.000000 0.019608 \n", - "203915 0.000000 0.000000 0.027778 0.027778 \n", + "1629019 0.048387 0.00000 0.000000 0.048387 \n", + "202709 0.090909 0.00000 0.000000 0.045455 \n", + "1627885 0.000000 0.04878 0.000000 0.048780 \n", + "203121 0.200000 0.00000 0.066667 0.533333 \n", + "101139 0.117647 0.00000 0.058823 0.058823 \n", "\n", " blka oreb dreb ast stl min \n", "nba_id \n", - "1626171 30 7.9 22.1 5.4 2.8 2065.831667 \n", - "1628964 15 4.0 10.6 2.4 0.8 766.193333 \n", - "203476 21 7.6 19.8 6.0 3.8 2363.836667 \n", - "1627750 51 2.8 8.9 12.2 2.8 5012.030000 \n", - "203915 36 1.5 8.1 18.7 2.4 4220.028333 " + "1629019 62 1.0 5.5 3.9 0.9 1458.563333 \n", + "202709 22 1.7 10.5 13.1 3.9 4273.400000 \n", + "1627885 41 2.2 12.8 11.6 6.2 1814.446667 \n", + "203121 15 0.8 6.7 6.7 1.8 3701.945000 \n", + "101139 17 0.9 8.8 4.3 2.8 1150.968333 " ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -563,21 +614,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "A big chunk of players do not have meaningful number of blocks. We will keep this feature for now and see if the models think they are important later" + "A big chunk of players do not have meaningful number of blocks. We will keep these features for now and see if the models think they are important later" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([4, 0, 0, 1, 1, 3, 1, 1, 4, 3])" + "array([2, 1, 1, 3, 3, 2, 1, 4, 1, 1])" ] }, - "execution_count": 6, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -597,14 +648,14 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Baseline accuracy score is 0.6758620689655173\n" + "Baseline accuracy score is 0.6180555555555556\n" ] }, { @@ -648,7 +699,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": { "scrolled": false }, @@ -660,7 +711,7 @@ " steps=[('standarize',\n", " StandardScaler(copy=True, with_mean=True, with_std=True)),\n", " ('pca',\n", - " PCA(copy=True, iterated_power='auto', n_components=15,\n", + " PCA(copy=True, iterated_power='auto', n_components=18,\n", " random_state=None, svd_solver='auto', tol=0.0,\n", " whiten=False)),\n", " ('clf',\n", @@ -676,7 +727,7 @@ " verbose=False)" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -687,7 +738,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": { "scrolled": false }, @@ -716,12 +767,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -758,7 +809,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2019-05-31T20:22:36.595239Z", @@ -795,97 +846,97 @@ " \n", " 7\n", " block_res\n", - " 6.166780e+11\n", + " 6.148259e+11\n", " \n", " \n", " 0\n", " shot_res\n", - " 2.374377e+11\n", + " 2.352855e+11\n", " \n", " \n", " 8\n", " block_in_paint\n", - " 1.583628e+11\n", + " 1.575760e+11\n", " \n", " \n", " 5\n", " shot_above_3\n", - " 1.540693e+11\n", + " 1.539324e+11\n", " \n", " \n", " 1\n", " shot_in_paint\n", - " 4.895989e+10\n", + " 4.860428e+10\n", " \n", " \n", " 2\n", " shot_mid_range\n", - " 4.298271e+10\n", + " 4.248118e+10\n", " \n", " \n", " 9\n", " block_mid_range\n", - " 1.423671e+10\n", + " 1.403364e+10\n", " \n", " \n", " 12\n", " block_above_3\n", - " 9.814576e+09\n", - " \n", - " \n", - " 3\n", - " shot_lcorner_3\n", - " 6.060002e+09\n", + " 9.844536e+09\n", " \n", " \n", " 4\n", " shot_rcorner_3\n", - " 6.044524e+09\n", + " 6.066038e+09\n", + " \n", + " \n", + " 3\n", + " shot_lcorner_3\n", + " 6.058910e+09\n", " \n", " \n", " 11\n", " block_rcorner_3\n", - " 2.416444e+09\n", + " 2.424820e+09\n", " \n", " \n", " 10\n", " block_lcorner_3\n", - " 2.341358e+09\n", + " 2.350809e+09\n", " \n", " \n", " 6\n", " fga\n", - " 2.278709e+01\n", + " 2.275250e+01\n", " \n", " \n", " 18\n", " min\n", - " 1.389952e+01\n", + " 1.377749e+01\n", " \n", " \n", " 13\n", " blka\n", - " 1.288436e+01\n", + " 1.292427e+01\n", " \n", " \n", " 15\n", " dreb\n", - " 1.081562e+01\n", + " 1.093114e+01\n", " \n", " \n", " 14\n", " oreb\n", - " 9.888926e+00\n", + " 9.955716e+00\n", " \n", " \n", " 17\n", " stl\n", - " 9.643645e+00\n", + " 9.644491e+00\n", " \n", " \n", " 16\n", " ast\n", - " 6.816613e+00\n", + " 6.826604e+00\n", " \n", " \n", "\n", @@ -893,25 +944,25 @@ ], "text/plain": [ " Feature VIF\n", - "7 block_res 6.166780e+11\n", - "0 shot_res 2.374377e+11\n", - "8 block_in_paint 1.583628e+11\n", - "5 shot_above_3 1.540693e+11\n", - "1 shot_in_paint 4.895989e+10\n", - "2 shot_mid_range 4.298271e+10\n", - "9 block_mid_range 1.423671e+10\n", - "12 block_above_3 9.814576e+09\n", - "3 shot_lcorner_3 6.060002e+09\n", - "4 shot_rcorner_3 6.044524e+09\n", - "11 block_rcorner_3 2.416444e+09\n", - "10 block_lcorner_3 2.341358e+09\n", - "6 fga 2.278709e+01\n", - "18 min 1.389952e+01\n", - "13 blka 1.288436e+01\n", - "15 dreb 1.081562e+01\n", - "14 oreb 9.888926e+00\n", - "17 stl 9.643645e+00\n", - "16 ast 6.816613e+00" + "7 block_res 6.148259e+11\n", + "0 shot_res 2.352855e+11\n", + "8 block_in_paint 1.575760e+11\n", + "5 shot_above_3 1.539324e+11\n", + "1 shot_in_paint 4.860428e+10\n", + "2 shot_mid_range 4.248118e+10\n", + "9 block_mid_range 1.403364e+10\n", + "12 block_above_3 9.844536e+09\n", + "4 shot_rcorner_3 6.066038e+09\n", + "3 shot_lcorner_3 6.058910e+09\n", + "11 block_rcorner_3 2.424820e+09\n", + "10 block_lcorner_3 2.350809e+09\n", + "6 fga 2.275250e+01\n", + "18 min 1.377749e+01\n", + "13 blka 1.292427e+01\n", + "15 dreb 1.093114e+01\n", + "14 oreb 9.955716e+00\n", + "17 stl 9.644491e+00\n", + "16 ast 6.826604e+00" ] }, "metadata": {}, @@ -941,7 +992,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": { "ExecuteTime": { "end_time": "2019-05-31T20:56:08.653833Z", @@ -954,7 +1005,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Logistic regression accuracy score is 0.66\n" + "Logistic regression accuracy score is 0.65\n" ] } ], @@ -994,7 +1045,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -1008,17 +1059,17 @@ " random_state=None, svd_solver='auto', tol=0.0,\n", " whiten=False)),\n", " ('clf',\n", - " LogisticRegression(C=0.75, class_weight='balanced', dual=False,\n", + " LogisticRegression(C=0.5, class_weight='balanced', dual=False,\n", " fit_intercept=True, intercept_scaling=1,\n", " l1_ratio=None, max_iter=10000,\n", " multi_class='multinomial', n_jobs=None,\n", - " penalty='l1', random_state=None,\n", + " penalty='none', random_state=None,\n", " solver='saga', tol=0.0001, verbose=0,\n", " warm_start=False))],\n", " verbose=False)" ] }, - "execution_count": 13, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -1029,12 +1080,12 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf8AAAGpCAYAAACDJj9UAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3debxVdb3/8dfnDCCKKCCg4ABqpDgBYqKmONZNy+FqNngzS8Nu1+n+7JbcrF8/r6ZWotXNAjX1kpWlaXUrc8wpHEAUEMkZB1QMVECQ4Zzv74+9sSPBOfvsc/ZZZ7Fez8djP85a3733Wm++dfyc9V3DN1JKSJKk4qjLOoAkSepaFn9JkgrG4i9JUsFY/CVJKhiLvyRJBdOQdYBWeBuCJKkjotY72H27cZ1Wq2bOu7vmedfozsWfz+x9atYRcmvKg5MAWDRzWsZJ8qnf7mMA+69a9l/HrenD+bfdlnGSfBp82GFZR+jWHPaXJKlgLP6SJBWMxV+SpIKx+EuSVDAWf0mSCsbiL0lSwXTrW/0kSerOGusbs45QFY/8JUkqGIu/JEkFY/GXJKlgLP6SJOVARGwTEXdFxJyIeDwiziy3fzMiXo6IR8uvw9valhf8SZKUD6uBs1NKj0TEpsD0iFgz+cOlKaXvVrohi78kSTmQUnoFeKW8vCQingCGVLMth/0lSeoGImJ8RExr8RrfymeHAqOAB8tNp0XEzIj4SUT0bWtfHvlLklSlhrrOK6MppcnA5LY+FxG9gRuBs1JKiyPiR8B/Aan88xLg861twyN/SZJyIiIaKRX+61JKvwZIKb2WUmpKKTUDVwAfaGs7Fn9JknIgIgK4CngipTSxRftWLT52DDC7rW057C9JUj7sB3wGmBURj5bb/hP4VESMpDTs/zxwalsbsvhLkpQDKaX7gFjHW39o77Yc9pckqWAs/pIkFYzFX5KkgvGcvyRJVepR3yPrCFXxyF+SpIKx+EuSVDAWf0mSCsbiL0lSwVj8JUkqGIu/JEkF461+kiRVqUd9Y9YRquKRvyRJBWPxlySpYBz2r0C/gX059ZufY7N+m5IS3HXzvdx6/Z184ODRHPOFjzF46JZ883MX8dzceVlHzYWpMx7jsqun0NTczJGHHMiJxxyZdaTcsQ87xv6r3spVqzjzsstYuXo1TU1NjBs1is8dcUTWsdROFv8KNDU18bPv/Yp5f32RjTbuyXnXfo3ZDz3BS8/O53tf/TGfP+eErCPmRlNTM5dcdQ3f+/oEBvbrx+cnfJ39x4xm2DZbZx0tN+zDjrH/OqaxoYGJZ5xBr549Wd3UxOkTJ7L3iBGMGDYs62hqh5oM+0fEjhGx3zra94uIHWqxz1p6a+Fi5v31RQDeWbaC+c+/Qr8BmzP/+Vd59YXXMk6XL3OefoattxzEkEEDaWxs4ND9xnLPtOlZx8oV+7Bj7L+OiQh69ewJwOqmJpqamiDWNcW8urNanfO/DFi8jvbF5fdya4ut+rPd8G15+vHnso6SS68vWsTA/v3fXR/Yrx+vL3wjw0T5Yx92jP3XcU3NzZxy4YUcc8457LnTTowYOjTrSGqnWhX/QSmlWWs3ltuGru9LETE+IqZFxLTJkyfXKFr1evbqyRkXncp1l/6Sd95+J+s4kpSJ+ro6rpwwgV+dfz5z583jufnzs46kdqrVOf/NW3mv1/reSClNBtZU/XTvVad2aqiOqK+v44yLTuUvtzzEtD/PyDpObg3o148FCxe+u75g0SIG9O+bYaL8sQ87xv7rPL033piRw4fz0Jw5DBs8OOs4mWioq886QlVqdeQ/LSK+sHZjRJwC5PLk2innnsj851/llp/fnnWUXNt5x+158ZVXmf/aAlatWs3t9z/A/mP2zDpWrtiHHWP/dcybS5awdNkyAFasXMn0uXPZdtCgjFOpvWp15H8WcFNEnMDfi/0YoAdwTI32WTPD99iBDx6+Dy889RLnTzkXgF/96GYaGhs48cufZNPNe3P2pacx78kX+c6Z3884bffWUF/P2SefxFkXXExzczMfPWgc23uVdbvYhx1j/3XMwsWLuWjKFJqbm2lOiQNHj2af3XbLOpbaKVJKtdt4xEHAruXVx1NKd7bj6+kze3efYf+8mfLgJAAWzZyWcZJ86rf7GMD+q5b913Fr+nD+bbdlnCSfBh92GEDNb0P48K7Hd1oR/dPsX3bZbRM1vc8/pXQXcFct9yFJktrHx/tKklQwFn9JkgrGx/tKklQlp/SVJEm5YPGXJKlgLP6SJBWMxV+SpIKx+EuSVDAWf0mSCsbiL0lSwXifvyRJVfI+f0mSlAsWf0mSCsbiL0lSwVj8JUkqGIu/JEkFY/GXJKlgLP6SJBWM9/lLklSlhrr6rCNUxSN/SZIKxuIvSVLBWPwlSSoYi78kSQVj8ZckqWAs/pIkFYy3+kmSVKUe9fksox75S5JUMBZ/SZIKxuIvSVLBWPwlSSoYi78kSQUTKaWsM6xPtw0mScqFqPUOPrP3qZ1Wq6Y8OKnmedfwyF+SpILp1jcoLpo5LesIudVv9zEA7L7duIyT5NPMeXcDMP+22zJOkk+DDzsMsP86Yk0fLpz+QMZJ8qn/nmO7ZD+N9U7pK0mScsDiL0lSwVj8JUkqGIu/JEkFY/GXJKlgLP6SJBVMt77VT5Kk7swpfSVJUs1ExDYRcVdEzImIxyPizHJ7v4i4LSKeKv/s29a2LP6SJOXDauDslNIIYCzwbxExAjgHuCOl9D7gjvJ6qyz+kiTlQErplZTSI+XlJcATwBDgKODa8seuBY5ua1sWf0mSuoGIGB8R01q8xrfy2aHAKOBBYFBK6ZXyW68Cg9raVz6vVJAkaQOTUpoMTG7rcxHRG7gROCultDji75MBppRSRLQ506BH/pIk5URENFIq/NellH5dbn4tIrYqv78VsKCt7Vj8JUnKgSgd4l8FPJFSmtjird8Cny0vfxb4TVvbcthfkqQqdfGUvvsBnwFmRcSj5bb/BC4CfhkRJwPzgOPb2pDFX5KkHEgp3QfEet4+pD3bcthfkqSCsfhLklQwFn9JkgrG4i9JUsFY/CVJKhiLvyRJBeOtfpIkVamxrkvv8+80HvlLklQwFn9JkgrG4i9JUsFY/CVJKhiLvyRJBWPxlySpYLzVT5KkKvVo8FY/SZKUAxZ/SZIKxmH/Kkyd8RiXXT2FpuZmjjzkQE485sisI3Vrg7YawAWXfo3+W/QlpcSNP/sd1119IwCfOumf+eRnjqapuZl773yASy/8ccZpu7+Vq1Zx5mWXsXL1apqamhg3ahSfO+KIrGPlhv3XcRdMupL7ZzxK3z59uO7b38o6jqpg8W+npqZmLrnqGr739QkM7NePz0/4OvuPGc2wbbbOOlq31dTUxCXn/5AnZj/Fxpv04hf/ewVT75tG/y36cdBh+3HcR05m1cpV9Ou/edZRc6GxoYGJZ5xBr549Wd3UxOkTJ7L3iBGMGDYs62i5YP913OEHfJDjPnQo5/1octZRVCWH/dtpztPPsPWWgxgyaCCNjQ0cut9Y7pk2PetY3drfFiziidlPAbDs7eU89/Q8Bg4awPH/chRXXf4zVq1cBcCihW9mGTM3IoJePXsCsLqpiaamJojIOFV+2H8dN2rnnejTe5OsY6gDLP7t9PqiRQzs3//d9YH9+vH6wjcyTJQvg7fekp12eR+zHp3DdsO2Zs8P7M51N/+In1z/PXbZfaes4+VGU3Mzp1x4Iceccw577rQTI4YOzTpSrth/KrqaFP+IOCoi/q3F+oMR8Wz5dVwr3xsfEdMiYtrkyQ4nbWh6bdyLiT8+j2+f9wPeXrqMhoZ6+mzehxOO/lcmfutHfPfyb2YdMTfq6+q4csIEfnX++cydN4/n5s/POlKu2H8qulqd8/8K8MkW6z2BvYBNgKuBG9b1pZTSZGBN1U+LZk6rUbzqDejXjwULF767vmDRIgb075thonxoaKhn4o/P4/c3384dt9wLwGuvvM4dt9wDwOzH5tLc3EzffpvxxqK3soyaK7033piRw4fz0Jw5DBs8OOs4uWP/qaMa673Pv6UeKaUXW6zfl1JamFJ6gdIfALm1847b8+IrrzL/tQWsWrWa2+9/gP3H7Jl1rG7v/337qzz39DymXPnLd9vuvPU+9tpnFADbDduaxsZGC38F3lyyhKXLlgGwYuVKps+dy7aDBmWcKj/sP6l2R/7vORROKZ3WYnVAjfbZJRrq6zn75JM464KLaW5u5qMHjWN7r/Rv1agxu/GxYz/Mk088wy//cCUA3//OFdz0yz9w3ne+yq9vvZpVq1Zz7tneMlSJhYsXc9GUKTQ3N9OcEgeOHs0+u+2WdazcsP867hs/uJwZT8zlzSVLOeq0szjl2GP42EHjso6ldqhV8X8wIr6QUrqiZWNEnAo8VKN9dpl9R49k39Ejs46RGzOmzWL37db9H4b/POuCLk6TfzsMGcIV55yTdYzcsv867rzTv5R1BHVQrYr/vwM3R8SngUfKbXtSOvd/dI32KUmSKlCT4p9SWgDsGxEHA7uUm3+fUrqzFvuTJEmVq0nxj4iNgC8COwKzgKtSSqtrsS9JktQ+tbra/1pgDKXC/xHguzXajyRJaqdanfMfkVLaDSAirmIDuMhPkqS1NdZ5n39Lq9YsONwvSVL3Uqsj/z0iYnF5OYBe5fUAUkqpT432K0mS2lCrq/3zOQ4iSVIBOKufJEkFY/GXJKlgLP6SJBVMrS74kyRpg9fYkM9j6HymliRJVbP4S5JUMBZ/SZIKxuIvSVLBWPwlSSoYi78kSQVj8ZckqWC8z1+SpCr1qM/nVDYe+UuSVDAWf0mSCsbiL0lSwVj8JUkqGIu/JEkFY/GXJKlg1nurX0S8AaSWTeX1AFJKqV+Ns0mS1K011OfzGLq1+/y36LIUkiSpy6z3T5aUUtOaF7AXcEJ5eTNgSFcFlCRJnavNJ/xFxLnAfsAOwP8AvYCfAR+sbTRJklQLlZysOA44HHgbIKX0MtCnlqEkSVLtVFL8V6SUEuWL/yJi49pGkiRJtVTJxD6/jogfAptFxOeAk4Gf1DZWSb/dx3TFbjZoM+fdnXWEXBt82GFZR8g1+6/j+u85NusI2gC1WfxTShdHxEeAlcAewAUppT/WPJkkSaqJSqf0ncbf7/OfVrs477VoZpftaoOzZtTk7m9MzjhJPo07bzwA/+fgL2ecJJ8m3vldAGb/6GcZJ8mvXf/10wAsnP5AxknyqatGTBo31Cl9y0P9jwCfBv4FmBYRn611MEmSVBuVHPmfA4xOKb0OEBEDgPuAa2sZTJIk1UYlV/svAt5ssf5muU2SJOVQa8/2P6O8+FdgakTcTOmc/9HA7C7IJkmSaqC1I/8B5deLwB+BnsBGwC3AS7WPJkmS1oiIn0TEgoiY3aLtmxHxckQ8Wn4dXsm21nvkn1L6emeElSRJneIa4L8pPWq/pUtTSt9tz4Yqebb/FsDZwC6UjvwBSCl9qD07kiRJ1Usp3RMRQztjW5Vc8PdT4HlgOHAx8CrwaGfsXJKkPGtsqOu0V0SMj4hpLV7jK4xxWkTMLJ8W6FvJFyop/gNSSpOAlSmlO4DPAgdWGEiSJFUgpTQ5pTSmxauSp7T9iNKsuyOBV4BLKtlXJff5ryr/fDUiPgzMB/pXsnFJklQ7KaXX1ixHxBXA/1byvUqK/7ciYjPgy8APKU3n6zNPJUnKWERslVJ6pbx6DBXeil/JxD6/LS/OBPYv7+y0akJKkqTqRMTPKZ123yIiXgL+L3BgRIyk9Bye54FTK9lWpRP7rO0rlG43kCRJXSCl9Kl1NF9VzbYqueBvXaLK70mSpIxVe+SfOjWFJEk51FBf7TF0tlp7tv8brLvIB7BpzRJJkqSaau3If4suSyFJkrpMa8/2b+rKIJIkqWvk82SFJEmqmsVfkqSCsfhLklQwbRb/iDgqIp6IiLciYnFELImIxV0RTpIkdb5K7vO/BDgmpTSr1mEkScqTxoZ8DqBXkvo1C78kSRuO1h7yc2R58eGIuA64GVix5v0WE/5IkqQcaW3Y/+MtlpuBI1usJ8DiL0lSDrX2kJ/PAETE2JTSAy3fi4ixtQ4mSZJqo5Jz/pevo+2HnR1EkiR1jdbO+e8NjAUGRMQZLd7qAzTWOpgkSaqN1s75b0xpcp8GYECL9iW893oASZIKKa+3+rV2zv8u4K6IuDql9GwXZpIkSTVUyUN+JkVEWrsxpfShGuSRJEk1VknxP7fF8kbAsbS437+Ips54jMuunkJTczNHHnIgJx5zZNtfKrjhR4+j//BtWfX2cqb98AYAGnr1ZMTxh9Bz801Z8eYS5lx/O6vfWZlx0u7pE/9xPCPGjmDpm0v5zsnfBWDw9ltx3L8fS89ePVn02hv89ILrWLGs0L+aFemx+aZsc9gH/77epzcLHp7Jwpl/zTBVvlww6Urun/Eoffv04bpvfyvrOKpCmycrUkoPtnjdnVI6AzigC7J1S01NzVxy1TVM/NpX+Pml3+a2+6fy3IsvZR2r23ttxl+ZNeUP72nbdv+RvPHsyzz8vet549mX2Wb/kRml6/4e/tM0Jp9zxXvajv/y8fz+ij/wnVMuYda9szjoEwdmEy5nVr65hGd+9cfS64ZbaF69msXPvph1rFw5/IAPculXv5x1DHVAJRP79Gnx2jwiDgH6dkG2bmnO08+w9ZaDGDJoII2NDRy631jumTY961jd3lvzXmXV8vcelfbfaTtem/EkAK/NeJItdh6aQbJ8eHbmsyxbvOw9bQO23oJnZpYux3ly+pPsvv/uWUTLtd5DBrHyraWsWrqs7Q/rXaN23ok+vTfJOoY6oJJh/8cpPdEvgNXAc8AX2rOTiBgC1JdX56eUVrfn+93J64sWMbB//3fXB/brx+NPPZNhovzqsUkvVi5dDsDKpcvpsUmvjBPly6vzXmPX/XZh9v2Ps8e4Pdh84GZZR8qdzXbcjreenpd1DKnLtVr8I6IO+PjaT/hrS0RMABpTSueVm6YCbwI9gGuBC6vIqg3cP1xVqlZd/+3rOeb0oznsM4fx+F8ep2lVU9aRciXq6th06BBeffCxrKNIXa7V4p9Sao6IHwPtPRn7cWD/FusLU0qjIqIeuJv1FP+IGA+MB5g0aRLHjR3dzt3W3oB+/ViwcOG76wsWLWJA/8KeBemQlW8vp0fv0tF/j969WPX28qwj5cqCF19n0ldK1wEM2HoLRozdOeNE+dJ72614529v0LT8nayjKMfq6/N5n38lqe+KiKPau+GU0tstVr9XbmsC1ju2m1KanFIak1IaM378+PbuskvsvOP2vPjKq8x/bQGrVq3m9vsfYP8xe2YdK5cWzp3HoFHDARg0ajgL5zr82h69N+8NQERw6L8cyl9+OzXjRPmy2Y5DefMp/z+nYqrknP9JwJkRsQJYTuncf0op9WvlO70jojGltIrSh68BiIielB4PnFsN9fWcffJJnHXBxTQ3N/PRg8ax/TZbZx2r29v5uIPZbNhgGjfeiLFnf5rn75rOC/c+yohPHMqWo3cq3er3yzuyjtlt/cu5J7DjHjuwyWab8I3rz+VP19xKj1492O+o/QCYdd8sHrrl4YxT5kc01NN7my2Zf89DWUfJpW/84HJmPDGXN5cs5ajTzuKUY4/hYweNyzqW2qG1Z/tvm1J6gdIjftvrBkoPBzotpbSsvL1NKE0IdENVSbuRfUePZN/R3pbWHk/ccOc622de8/suTpJPPz3/unW23/vr+7o4yYYhrW5i7tU3Zh0jt847/UtZR1AHtTbsfzOUhurX9Wpju18HFgAvRMT0iJgOPA+8Wn5PkiRlpLXiHx3Y7mhK5/m3oXTa4BpgBqXJgnI97C9JUt61ds5/SER8f31vlp/0tz6TgENTSssjoi8wATid0l0Dk4HjqgkrSZI6rrXivxyo9tF19SmlReXlTwCTU0o3AjdGxKNVblOSJHWC1or/wpTStVVutz4iGspP8juE8r37FexTkqTcaGzI533+rRXijkyv9nPg7oj4G6URhHsBImJH4K0ObFeSJHXQeot/SmlstRtNKV0QEXcAWwG3ppTWPLm1jtK5f0mSlJGaDcGvaz6AlNKTtdqfJEmqTD5PVkiSpKq19oS/1h7fS4ur+SVJUo60Nuw/ndIsqwFsC7xRXt4ceAEYVvN0kiSp07V2wd8wgIi4ArgppfSH8vpHgKO7Jp4kSd1XQ05v9ask9dg1hR8gpfRHYN/aRZIkSbVUydX+8yPiXOCn5fUTgPm1iyRJkmqpkiP/TwEDgJvKr4HlNkmSlENtHvmXr+o/swuySJKkLtBm8Y+I4cCXgaEtP59SOrh2sSRJUq1Ucs7/V8CPgSuBptrGkSRJtVZJ8V+dUvpRzZNIkqQuUUnx/11EfInSxX4r1jT6hD9JUtHV10fWEapSSfH/bPnnf7RoS8D2nR9HkiTVWiVX+/sYX0mSNiCVXO1/4rraU0r/0/lxJElSrVUy7L9Xi+WNgEOARwCLvyRJOVTJsP/pLdcjYnPgFzVLJEmSaqqa6Yjexul8JUnKrUrO+f+O0tX9APXAzsAvaxlKkqQ8aMzplL6VnPP/bovl1cC8lNJLNcojSZJqrM0/WVJKdwNzgU2BvsDKWoeSJEm102bxj4jjgYeAjwPHAw9GxHG1DiZJkmqjkmH/rwF7pZQWAETEAOB24IZaBpMkSbVRyZUKdWsKf9nCCr8nSZK6oUqO/G+JiD8BPy+vfwL4Q+0iSZKkWoqUUtsfivhn4IPl1XtTSjfVNFVJ28EkSVq/mk+5d8eEH3darTrkwi922RSBrR75R0Q9cHtK6SDg110TSZKkfGhozOdZ8FaLf0qpKSKaI2KzlNJbXRVqjYXTH+jqXW4w+u85FrAPq7Wm/+7+xuSMk+TTuPPGA3D9qZdmnCS/PjHp3wGYf9ttGSfJp8GHHZZ1hG6tknP+S4FZEXEbpUf7ApBSOqNmqSRJ0ntExE+AjwILUkq7ltv6AdcDQ4HngeNTSm+0ta1Kxit+DXwduAeY3uIlSZK6zjXAP63Vdg5wR0rpfcAd5fU2VTKr37XtTSdJkjpXSumeiBi6VvNRwIHl5WuBPwNfbWtb6z3yj4ijIuLfWqw/GBHPll8+4U+SpE4UEeMjYlqL1/gKvjYopfRKeflVYFAl+2rtyP8rwCdbrPcE9gI2Aa7GJ/xJktRpUkqTgaqvMk4ppYio6NbD1s7590gpvdhi/b6U0sKU0guU/gCQJEnZei0itgIo/1zQxueB1o/8+7ZcSSmd1mJ1QLvjSZK0gamrz/w+/98CnwUuKv/8TSVfai31gxHxhbUbI+JUSrP8SZKkLhIRPwemAu+PiJci4mRKRf+wiHgKOLS83qbWjvz/Hbg5Ij4NPFJu25PSuf+jqw0vSZLaL6X0qfW8dUh7t7Xe4l+eyW/fiDgY2KXc/PuU0p3t3YkkSeo+KrnP/07Agi9J0gYi8ysVJElS17L4S5JUMJVM7CNJktYhr1P65jO1JEmqmsVfkqSCsfhLklQwFn9JkgrG4i9JUsFY/CVJKhiLvyRJBeN9/pIkVamhIZ/H0PlMLUmSqmbxlySpYCz+kiQVjMVfkqSCsfhLklQwFn9JkgrG4i9JUsF4n78kSVWq8z5/SZKUBxZ/SZIKxmH/drpg0pXcP+NR+vbpw3Xf/lbWcXLJPmy/4UePo//wbVn19nKm/fAGABp69WTE8YfQc/NNWfHmEuZcfzur31mZcdLuaa8TD2PwbtuzYskybjlvCgC7HrkPQ/bYgZQSK5Ys58Fr/sQ7b72dcdLub+WqVZx52WWsXL2apqYmxo0axeeOOCLrWGonj/zb6fADPsilX/1y1jFyzT5sv9dm/JVZU/7wnrZt9x/JG8++zMPfu543nn2ZbfYfmVG67u/5qXO45/s3vadt7q3T+dN//ZRbz7+O+TOfZZcjxmaULl8aGxqYeMYZXDVhAldOmMBDc+Yw57nnso6ldrL4t9OonXeiT+9Nso6Ra/Zh+70171VWLV/xnrb+O23HazOeBOC1GU+yxc5DM0iWD68/9TIrlr3znraWoyQNPRuB1MWp8iki6NWzJwCrm5poamqCiIxTqb1qMuwfEf+cUvp1eblvSumNWuxHKrIem/Ri5dLlAKxcupwem/TKOFH+7HbUvgwdO4JVy1dw18Qbso6TG03NzZx68cW8/PrrHH3AAYwYOjTrSGqnWh35n9ti+Y5KvxQR4yNiWkRMmzx5cg1iSRsuj1vbb9Zv/sLvJlzJvIfmsuNBnjapVH1dHVdOmMCvzj+fufPm8dz8+VlHykx9Q12nvbpSrfYW61luVUppckppTEppzPjx42sQS9pwrHx7OT16l472e/Tuxaq3l2ecKL/mPTiXbUbtmHWM3Om98caMHD6ch+bMyTqK2qlWxb9XRIyKiD2BjSJidMtXjfYpFcrCufMYNGo4AINGDWfh3HkZJ8qX3gM3f3d5yMgdWPyqZycr8eaSJSxdtgyAFStXMn3uXLYdNCjjVGqvWt3q9wpwCaWj/leB7671/sE12m/NfeMHlzPjibm8uWQpR512FqccewwfO2hc1rFyxT5sv52PO5jNhg2mceONGHv2p3n+rum8cO+jjPjEoWw5eqfSrX6/rPgMW+GMPfkjDHz/NvTsvREfu+gUZv9uKlvtOow+g/qSUuLtRUuYft3tWcfMhYWLF3PRlCk0NzfTnBIHjh7NPrvtlnUstVOtiv9XgRdTSq8ARMRngWOB54Fv1mifXeK807+UdYTcsw/b74kb7lxn+8xrft/FSfLpgav++A9tz93/eAZJ8m+HIUO44pxzso6hDqrVsP+PgRUAEXEAcCFwLfAW4JV8kiRlqFZH/vUppUXl5U8Ak1NKNwI3RsSjNdqnJEmqQK2O/OsjYs0fFocALccsfaSwJEkZqlUh/jlwd0T8DVgO3AsQETtSGvqXJCn3Ghrz+aDcmhT/lNIFEXEHsBVwa0ppzfNH6oDTa7FPSZJUmZoNwaeUHlhH25O12p8kSapMPscrJElS1Sz+kiQVjMVfkqSCsfhLklQw3nMvSVKV6rp4Kt7Oks/UkiSpahZ/SZIKxuIvSVLBWPwlSSoYi78kSQVj8ZckqWAs/pIkFYz3+cjTpjQAAA4ASURBVEuSVKX6xvqsI1TFI39JkgrG4i9JUsFY/CVJKhiLvyRJBWPxlySpYCz+kiQVjMVfkqSC8T5/SZKqVNeYz2PofKaWJElVs/hLklQwFn9JkgrG4i9JUsFY/CVJKphIKWWdYX26bTBJUi5ErXfw1HU3dlqtet8Jx9Y87xre6idJUpXq6rt2AD0ingeWAE3A6pTSmGq2062L/zO/uCnrCLm1wyePAWDh9AcyTpJP/fccC8CimdMyTpJP/XYv/fdo/m23ZZwkvwYfdhgA1596acZJ8ukTk/496wi1dFBK6W8d2YDn/CVJKhiLvyRJ3UBEjI+IaS1e49fxsQTcGhHT1/N+Rbr1sL8kSUWRUpoMTG7jYx9MKb0cEQOB2yJibkrpnvbuyyN/SZJyIqX0cvnnAuAm4APVbMfiL0lSDkTEJhGx6Zpl4EPA7Gq25bC/JEn5MAi4KSKgVL9/llK6pZoNWfwlSapSfWN9l+0rpfQssEdnbMthf0mSCsbiL0lSwVj8JUkqGIu/JEkFY/GXJKlgLP6SJBWMt/pJklSlui681a8zeeQvSVLBWPwlSSoYi78kSQVj8ZckqWAs/pIkFYzFX5KkgrH4S5JUMN7nL0lSleoavM9fkiTlgMVfkqSCsfhLklQwFn9JkgrG4i9JUsFY/CVJKhiLvyRJBeN9/pIkVamu0fv8JUlSDlj8JUkqGIf9q3DSpRfRq0dP6uvqqKur4/unnp51pFy5YNKV3D/jUfr26cN13/5W1nFyaeqMx7js6ik0NTdz5CEHcuIxR2YdKTdWrlrFmZddxsrVq2lqamLcqFF87ogjso7V7e114mEM3m17VixZxi3nTQFg1yP3YcgeO5BSYsWS5Tx4zZ945623M06qSlj8q3TRSePZbJNNso6RS4cf8EGO+9ChnPejyVlHyaWmpmYuueoavvf1CQzs14/PT/g6+48ZzbBtts46Wi40NjQw8Ywz6NWzJ6ubmjh94kT2HjGCEcOGZR2tW3t+6hyevusx9v7ch99tm3vrdGb/dioA7ztoJLscMZbpP7sjq4hqh5oM+0fEtrXYrjYMo3beiT69/cOpWnOefoattxzEkEEDaWxs4ND9xnLPtOlZx8qNiKBXz54ArG5qoqmpCSIyTtX9vf7Uy6xY9s572la/s/Ld5YaejUDq4lSqVq2O/G8GRgNExI0ppWNrtJ9MBMG5U64iCD4y5gN8ZMzeWUdSgby+aBED+/d/d31gv348/tQzGSbKn6bmZk69+GJefv11jj7gAEYMHZp1pNza7ah9GTp2BKuWr+CuiTdkHUcVqlXxb/ln9PYVfyliPDAeYNKkSRzSZ0Bn5+oU3zn5i2zRZzPeXLqUr/3PlWy9xQB2G1rxP1NSxurr6rhywgSWLlvG16+4gufmz2fY4MFZx8qlWb/5C7N+8xd2/qe92PGgkTz+u6lZR+pS0ZDP6+ZrlTqtZ7n1L6U0OaU0JqU0Zvz48TWI1Tm26LMZAJv37s0+O+/Cky+/lHEiFcmAfv1YsHDhu+sLFi1iQP++GSbKr94bb8zI4cN5aM6crKPk3rwH57LNqB2zjqEK1ar47xERiyNiCbB7eXlxRCyJiMU12meXeGflSpatWPHu8oxnnmK7gYMyTqUi2XnH7XnxlVeZ/9oCVq1aze33P8D+Y/bMOlZuvLlkCUuXLQNgxcqVTJ87l20H+Ttcjd4DN393ecjIHVj86hsZplF71GTYP6WUz0ceVeCNpUs4/xel21yamps5cLeRjHnf+zNOlS/f+MHlzHhiLm8uWcpRp53FKccew8cOGpd1rNxoqK/n7JNP4qwLLqa5uZmPHjSO7b3Sv2ILFy/moilTaG5upjklDhw9mn122y3rWN3e2JM/wsD3b0PP3hvxsYtOYfbvprLVrsPoM6gvKSXeXrSE6dfdnnVMVagmxT8iNgK+COwIzAR+klJaXYt9dbWt+vXnh186K+sYuXbe6V/KOkLu7Tt6JPuOHpl1jFzaYcgQrjjnnKxj5M4DV/3xH9qeu//xDJKoM9Rq2P9aYAwwCzgcuKRG+5EkSe1Uq6v9R6SUdgOIiKuAh2q0H0mS1E61OvJftWZhQxnulyRpQ1GrI/89WlzVH0Cv8noAKaXUp0b7lSSpy9Q15vMp+V7tL0lSweTz0USSJKlqFn9JkgrG4i9JUsFY/CVJKhiLvyRJBZPPexQkSeoG8nqrn0f+kiQVjMVfkqSCsfhLklQwFn9JkgrG4i9JUsFY/CVJKhiLvyRJBZPPGxQlSeoG6hryOYmtR/6SJBWMxV+SpIKx+EuSVDAWf0mSCsbiL0lSwVj8JUkqGIu/JEkF433+kiRVKRrzWUY98pckqWAs/pIkFYzFX5KkgrH4S5KUExHxTxHx14h4OiLOqXY7Fn9JknIgIuqBHwIfAUYAn4qIEVVtK6XUmdk6U7cNJknKhaj1DhbNnNZptarf7mNazRsR+wDfTCl9uLw+ASCldGF799Wd71Go+f9oHRER41NKk7POkWf2YcfYfx1j/3Wcfdh2wW6PiBgPjG/RNHmt/h0CvNhi/SVg72r25bB/9ca3/RG1wT7sGPuvY+y/jrMPO1FKaXJKaUyLV83+sLL4S5KUDy8D27RY37rc1m4Wf0mS8uFh4H0RMSwiegCfBH5bzYa68zn/7q7Q57k6iX3YMfZfx9h/HWcfdqGU0uqIOA34E1AP/CSl9Hg12+rOV/tLkqQacNhfkqSCsfhLklQwFv92iogtI+IXEfFMREyPiD9ExPCsc3VnEdEUEY9GxOyI+FVEbFxuHxQRP4uIZ8t9OTUijsk6b3cUEV+LiMcjYma5L/eOiIaI+FZEPFVuezQivpZ11u5qPX345/KjUtf033FZ5+yuWvk9bmrRf49GxNBsk6oSXvDXDhERwE3AtSmlT5bb9gAGAU9mma2bW55SGgkQEdcBX4yIS4GbKfXlp8vvbQccmV3M7qn8VK+PAqNTSisiYgugB3A+sCWwW0rpnYjYFDg7w6jdVit9CHBCSmladuly4x9+j4GJLduVHxb/9jkIWJVS+vGahpTSYxnmyaN7gd2Bg4GVa/XlPOAHWQXrxrYC/pZSWgGQUvpb+ajrC8DQlNI75fYlwDczS9m9/UMfApT+nlcV1vweK6cc9m+fXYHpWYfIq4hooDQhxSxgF+CRbBPlxq3ANhHxZERcHhHjgB2BF8oFX21bVx+ucV2LIev+WQXMi7V+jwF6tei/mzKMpnaw+Ksr9IqIR4FpwAvAVWt/ICJ+GBGPRcTDXZ6um0spLQX2pPQo1deB64EDW34mIj5X/o/vixGxzT9updjW1YcRcVL57RNSSiPLr4VZZcyB9f0eL2/Rf16zkxMO+7fP44AXBLXfP5wTjIjHgWPXrKeU/q18HtZzr+uQUmoC/gz8OSJmAacC20bEpimlJSmlq4GrI2I2pYd/aC3r6MPPZpsodzy3vwHxyL997gR6lmdeAiAido+I/TPMlFd3AhtFxL+2aNs4qzDdWUS8PyLe16JpJPBXSkde/x0RG5U/V8/fL2JTC+vpw3lZ5ZGy5pF/O6SUUvlWtMsi4qvAO8DzwFmZBsuhcl8eDVwaEV+hNBT7NvDVbJN1S72BH0TE5sBq4GlKw9dvAf8FzI6IJcBy4FpgflZBu7H19eENmaaSMuLjfSVJKhiH/SVJKhiLvyRJBWPxlySpYCz+kiQVjMVfkqSCsfhLbVjfbGZVbuvAiPjf8vKREXFOK5/dPCK+VMU+vhkRX660vZXtLO2M/Urqfiz+UtvWPL50V2AlpdnM3hUl7f5dSin9NqV0USsf2Rxod/GXpLZY/KX2uRfYMSKGlueB/x9gNqVJYz4UEVMj4pHyCEFvgIj4p4iYGxGPAP+8ZkMRcVJE/Hd5eVBE3FSe3+CxiNgXuAjYoTzq8J3y5/4jIh4uz0n//1ps62vlSWvuA97fnn9QRNwcEdOjNNf9+LXeu7TcfkdEDCi37RARt5S/c29E7FRFP0rKkMVfqtA6ZjN7H3B5SmkXSk8nPBc4NKU0mtIcBf+n/OjdK4CPUZpYZsv1bP77wN0ppT2A0ZTmkTgHeKY86vAfEfGh8j4/QOnxtHtGxAERsSfwyXLb4cBe7fynfT6ltCcwBjijxcx2mwDTyv++u4H/W26fDJxe/s6XgcvbuT9JGfPxvlLb1sxmBqUj/6uAwcC8lNID5faxwAjg/vIc8T2AqcBOwHMppacAIuKnlB4ru7aDgRPh3Qlo3oqIvmt95kPl14zyem9KfwxsCtyUUlpW3sdv2/nvO6P82GqAbcrbXAg0U5pBEOCnwK/Loxn7Ar8q/zsBerZzf5IyZvGX2rauWQmhdLT/bhNwW0rpU2t9rjNnQQvgwpTSpLX2UfXcEhFxIHAosE9KaVlE/BnYaD0fT5RGC990djcp3xz2lzrHA8B+EbEjQERsEhHDgbnA0IjYofy5T63n+3cA/1r+bn1EbAYsoXRUv8afgM+3uJZgSEQMBO4Bjo6IXhGxKaVTDJXaDHijXPh3ojSCsUYdf5/C+tPAfSmlxcBzEfHxcoaIiD3asT9J3YDFX+oEKaXXgZOAn0fETMpD/imldygN8/++fMHfgvVs4kzgoPI889OBESmlhZROI8yOiO+klG4FfgZMLX/uBmDTlNIjlIbnHwP+CDzcStRzI+KlNS/gFqAhIp6gdIHhAy0++zbwgYiYTem0xHnl9hOAkyPiMUrXJhxVaT9J6h6c1U+SpILxyF+SpIKx+EuSVDAWf0mSCsbiL0lSwVj8JUkqGIu/JEkFY/GXJKlg/j/qjuCDwrOMxgAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -1082,14 +1133,14 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Random forest accuracy score is 0.80\n" + "Random forest accuracy score is 0.73\n" ] } ], @@ -1118,7 +1169,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -1132,7 +1183,7 @@ " max_leaf_nodes=None,\n", " min_impurity_decrease=0.0,\n", " min_impurity_split=None,\n", - " min_samples_leaf=1, min_samples_split=8,\n", + " min_samples_leaf=1, min_samples_split=2,\n", " min_weight_fraction_leaf=0.0,\n", " n_estimators=500, n_jobs=-1,\n", " oob_score=False, random_state=None,\n", @@ -1140,7 +1191,7 @@ " verbose=False)" ] }, - "execution_count": 16, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" } @@ -1151,12 +1202,12 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1189,14 +1240,14 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Random forest accuracy score is 0.80\n" + "Random forest accuracy score is 0.73\n" ] }, { @@ -1206,18 +1257,18 @@ " steps=[('xgb_clf',\n", " XGBClassifier(base_score=0.5, booster='gbtree',\n", " colsample_bylevel=1, colsample_bynode=1,\n", - " colsample_bytree=1, gamma=0, learning_rate=0.1,\n", - " max_delta_step=0, max_depth=3,\n", + " colsample_bytree=1, gamma=0.5, learning_rate=0.1,\n", + " max_delta_step=0, max_depth=9,\n", " min_child_weight=1, missing=None,\n", " n_estimators=75, n_jobs=1, nthread=None,\n", " objective='multi:softprob', random_state=0,\n", - " reg_alpha=0, reg_lambda=0.5, scale_pos_weight=1,\n", + " reg_alpha=1, reg_lambda=1, scale_pos_weight=1,\n", " seed=None, silent=None, subsample=1, verbose=10,\n", " verbosity=1))],\n", " verbose=False)" ] }, - "execution_count": 18, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -1259,12 +1310,12 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1288,7 +1339,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -1300,7 +1351,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": { "scrolled": true }, @@ -1335,31 +1386,31 @@ " \n", " \n", " Decision Tree (Baseline)\n", - " 0.681293\n", - " 0.675862\n", - " 0.744828\n", - " 0.875862\n", + " 0.645688\n", + " 0.618056\n", + " 0.680556\n", + " 0.847222\n", " \n", " \n", " XGBoost\n", - " 0.750956\n", - " 0.786207\n", - " 0.951724\n", - " 1.000000\n", + " 0.762800\n", + " 0.722222\n", + " 0.930556\n", + " 0.979167\n", " \n", " \n", " Random Forest\n", - " 0.754733\n", - " 0.786207\n", - " 0.965517\n", - " 1.000000\n", + " 0.774016\n", + " 0.729167\n", + " 0.937500\n", + " 0.972222\n", " \n", " \n", " Logistic Regression\n", - " 0.620990\n", - " 0.634483\n", - " 0.868966\n", - " 0.993103\n", + " 0.627519\n", + " 0.638889\n", + " 0.875000\n", + " 0.979167\n", " \n", " \n", "\n", @@ -1367,19 +1418,19 @@ ], "text/plain": [ " Balanced Accuracy Top 1 Accuracy Top 2 \\\n", - "Decision Tree (Baseline) 0.681293 0.675862 0.744828 \n", - "XGBoost 0.750956 0.786207 0.951724 \n", - "Random Forest 0.754733 0.786207 0.965517 \n", - "Logistic Regression 0.620990 0.634483 0.868966 \n", + "Decision Tree (Baseline) 0.645688 0.618056 0.680556 \n", + "XGBoost 0.762800 0.722222 0.930556 \n", + "Random Forest 0.774016 0.729167 0.937500 \n", + "Logistic Regression 0.627519 0.638889 0.875000 \n", "\n", " Top 3 \n", - "Decision Tree (Baseline) 0.875862 \n", - "XGBoost 1.000000 \n", - "Random Forest 1.000000 \n", - "Logistic Regression 0.993103 " + "Decision Tree (Baseline) 0.847222 \n", + "XGBoost 0.979167 \n", + "Random Forest 0.972222 \n", + "Logistic Regression 0.979167 " ] }, - "execution_count": 21, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -1418,14 +1469,14 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": { "scrolled": false }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3AAAAF5CAYAAADeesg2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdebwlVXnv/8+X2QlUxBgBbQQ1wTghU4jXMSqKggOoqAkOcbiO+fmLCcaoiBkw18QkakwwqDhdQKMRBUWcZ6EZBEGJraI00QiIihpk8Ll/VG169+FMTffpqnXO5/16ndfZtXbtfZ4+Xad2PbXWelaqCkmSJEnS+G0xdACSJEmSpMUxgZMkSZKkRpjASZIkSVIjTOAkSZIkqREmcJIkSZLUCBM4SZIkSWrEVkMHMNPtbne7WrVq1dBhSJIkSdIgzjrrrMuraqfZnhtdArdq1SpWr149dBiSJEmSNIgk35vrOYdQSpIkSVIjTOAkSZIkqREmcJIkSZLUiNHNgZMkSZKkjXXttdeydu1arr766qFDmdN2223HLrvswtZbb73o15jASZIkSVp21q5dy61udStWrVpFkqHDuZGq4oorrmDt2rXstttui36dQyglSZIkLTtXX301O+644yiTN4Ak7LjjjhvcQ2gCJ0mSJGlZGmvyNnFT4jOBkyRJkqQl8rGPfYy73/3u7LHHHhxzzDEb/X7OgZMkSZK07K068pRN+n4XH3PQgvtcf/31vOAFL+D0009nl112YZ999uHggw9mzz33vMk/1x44SZIkSVoCZ5xxBnvssQd3uctd2GabbXjyk5/Mhz70oY16TxM4SZIkSVoCl156KbvuuusN27vssguXXnrpRr2nQyglSZKkhmzqoYATixkSqOHZAydJkiRJS2DnnXfmkksuuWF77dq17Lzzzhv1niZwkiRJkrQE9tlnH771rW/x3e9+l2uuuYYTTjiBgw8+eKPe0yGUkiRJkrQEttpqK970pjfxiEc8guuvv55nPvOZ3OMe99i499xEsUmSJEnSaA01x+9Rj3oUj3rUozbZ+zmEUpIkSZIaYQInSZIkSY1wCKUkSZJWNMvyqyX2wEmSJElalqpq6BDmdVPiM4GTJEmStOxst912XHHFFaNN4qqKK664gu22226DXucQSkmSJEnLzi677MLatWu57LLLhg5lTttttx277LLLBr3GBE6SJEnSsrP11luz2267DR3GJucQSkmSJElqxKISuCQHJrkoyZokR87y/AOSnJ3kuiSHTrXfJ8mXk1yQ5LwkT9qUwUuSJEnSSrJgApdkS+DNwCOBPYHDk+w5Y7fvA08H3juj/ZfAH1bVPYADgX9IcuuNDVqSJEmSVqLFzIHbF1hTVd8BSHICcAhw4WSHqrq4f+7X0y+sqv+cevxfSX4E7AT8ZKMjlyRJkqQVZjEJ3M7AJVPba4H9NvQHJdkX2Ab49izPPQd4DsCd7nSnDX1rSZIkjYgLY0tLZ7MUMUnym8C7gGdU1a9nPl9Vx1bV3lW190477bQ5QpIkSZKk5iwmgbsU2HVqe5e+bVGSbA+cAryiqr6yYeFJkiRJkiYWk8CdCdw1yW5JtgGeDJy8mDfv9/8g8M6qev9ND1OSJEmStGACV1XXAS8ETgO+AZxUVRckOTrJwQBJ9kmyFjgM+NckF/QvfyLwAODpSc7tv+6zJP8SSZIkSVrmFlPEhKo6FTh1Rturph6fSTe0cubr3g28eyNjlCRJkiSxmYqYSJIkSZI2ngmcJEmSJDXCBE6SJEmSGmECJ0mSJEmNMIGTJEmSpEaYwEmSJElSI0zgJEmSJKkRJnCSJEmS1AgTOEmSJElqhAmcJEmSJDXCBE6SJEmSGmECJ0mSJEmNMIGTJEmSpEaYwEmSJElSI0zgJEmSJKkRJnCSJEmS1AgTOEmSJElqhAmcJEmSJDXCBE6SJEmSGmECJ0mSJEmNMIGTJEmSpEaYwEmSJElSI0zgJEmSJKkRJnCSJEmS1AgTOEmSJElqhAmcJEmSJDXCBE6SJEmSGmECJ0mSJEmNMIGTJEmSpEaYwEmSJElSI0zgJEmSJKkRi0rgkhyY5KIka5IcOcvzD0hydpLrkhw647kjknyr/zpiUwUuSZIkSSvNgglcki2BNwOPBPYEDk+y54zdvg88HXjvjNfeFng1sB+wL/DqJLfZ+LAlSZIkaeVZTA/cvsCaqvpOVV0DnAAcMr1DVV1cVecBv57x2kcAp1fVj6vqSuB04MBNELckSZIkrTiLSeB2Bi6Z2l7bty3GxrxWkiRJkjRlFEVMkjwnyeokqy+77LKhw5EkSZKkUVpMAncpsOvU9i5922Is6rVVdWxV7V1Ve++0006LfGtJkiRJWlkWk8CdCdw1yW5JtgGeDJy8yPc/DXh4ktv0xUse3rdJkiRJkjbQgglcVV0HvJAu8foGcFJVXZDk6CQHAyTZJ8la4DDgX5Nc0L/2x8Br6ZLAM4Gj+zZJkiRJ0gbaajE7VdWpwKkz2l419fhMuuGRs732bcDbNiJGSZIkSRIjKWIiSZIkSVqYCZwkSZIkNcIETpIkSZIaYQInSZIkSY0wgZMkSZKkRpjASZIkSVIjTOAkSZIkqREmcJIkSZLUCBM4SZIkSWqECZwkSZIkNcIETpIkSZIaYQInSZIkSY0wgZMkSZKkRpjASZIkSVIjTOAkSZIkqREmcJIkSZLUCBM4SZIkSWqECZwkSZIkNcIETpIkSZIaYQInSZIkSY0wgZMkSZKkRpjASZIkSVIjTOAkSZIkqREmcJIkSZLUCBM4SZIkSWqECZwkSZIkNcIETpIkSZIasdXQAUib0qojT1mS9734mIOW5H0lSZKkDWEPnCRJkiQ1wgROkiRJkhphAidJkiRJjTCBkyRJkqRGLCqBS3JgkouSrEly5CzPb5vkxP75ryZZ1bdvneT4JOcn+UaSl2/a8CVJkiRp5VgwgUuyJfBm4JHAnsDhSfacsduzgCurag/gDcDr+vbDgG2r6p7A/YDnTpI7SZIkSdKGWUwP3L7Amqr6TlVdA5wAHDJjn0OA4/vH7wcemiRAAbdIshVwM+Aa4GebJHJJkiRJWmEWk8DtDFwytb22b5t1n6q6DvgpsCNdMvcL4AfA94HXV9WPZ/6AJM9JsjrJ6ssuu2yD/xGSJEmStBIs9ULe+wLXA3cEbgN8Psknquo70ztV1bHAsQB77713LXFM0mi48LgkSZI2xGJ64C4Fdp3a3qVvm3WffrjkDsAVwFOAj1XVtVX1I+CLwN4bG7QkSZIkrUSLSeDOBO6aZLck2wBPBk6esc/JwBH940OBT1VV0Q2bfAhAklsA+wPf3BSBS5IkSdJKs2AC189peyFwGvAN4KSquiDJ0UkO7nc7DtgxyRrgpcBkqYE3A7dMcgFdIvj2qjpvU/8jJEmSJGklWNQcuKo6FTh1Rturph5fTbdkwMzX/Xy2dkmSJEnShlvUQt6SJEmSpOGZwEmSJElSI0zgJEmSJKkRJnCSJEmS1AgTOEmSJElqhAmcJEmSJDXCBE6SJEmSGmECJ0mSJEmNMIGTJEmSpEaYwEmSJElSI0zgJEmSJKkRJnCSJEmS1AgTOEmSJElqhAmcJEmSJDXCBE6SJEmSGmECJ0mSJEmNMIGTJEmSpEaYwEmSJElSI0zgJEmSJKkRJnCSJEmS1AgTOEmSJElqhAmcJEmSJDXCBE6SJEmSGmECJ0mSJEmNMIGTJEmSpEaYwEmSJElSI0zgJEmSJKkRJnCSJEmS1AgTOEmSJElqhAmcJEmSJDViq6ED2BirjjxlSd734mMOWpL3lSRJkqSNsageuCQHJrkoyZokR87y/LZJTuyf/2qSVVPP3SvJl5NckOT8JNttuvAlSZIkaeVYMIFLsiXwZuCRwJ7A4Un2nLHbs4Arq2oP4A3A6/rXbgW8G3heVd0DeBBw7SaLXpIkSZJWkMX0wO0LrKmq71TVNcAJwCEz9jkEOL5//H7goUkCPBw4r6q+BlBVV1TV9ZsmdEmSJElaWRaTwO0MXDK1vbZvm3WfqroO+CmwI3A3oJKcluTsJH862w9I8pwkq5Osvuyyyzb03yBJkiRJK8JSV6HcCrg/8NT+++OSPHTmTlV1bFXtXVV777TTTksckiRJkiS1aTEJ3KXArlPbu/Rts+7Tz3vbAbiCrrfuc1V1eVX9EjgV2Gtjg5YkSZKklWgxCdyZwF2T7JZkG+DJwMkz9jkZOKJ/fCjwqaoq4DTgnklu3id2DwQu3DShS5IkSdLKsuA6cFV1XZIX0iVjWwJvq6oLkhwNrK6qk4HjgHclWQP8mC7Jo6quTPL3dElgAadW1dIs3iZJkiRJy9yiFvKuqlPphj9Ot71q6vHVwGFzvPbddEsJSJIkSZI2wlIXMZEkSZIkbSImcJIkSZLUCBM4SZIkSWqECZwkSZIkNcIETpIkSZIaYQInSZIkSY0wgZMkSZKkRpjASZIkSVIjFrWQtyQBrDrylCV534uPOWhJ3leSJGm5sQdOkiRJkhphAidJkiRJjTCBkyRJkqRGmMBJkiRJUiNM4CRJkiSpESZwkiRJktQIEzhJkiRJaoQJnCRJkiQ1wgROkiRJkhphAidJkiRJjTCBkyRJkqRGmMBJkiRJUiNM4CRJkiSpEVsNHYAkSZKk5WvVkacsyftefMxBS/K+Y2cPnCRJkiQ1wgROkiRJkhphAidJkiRJjTCBkyRJkqRGmMBJkiRJUiNM4CRJkiSpESZwkiRJktQIEzhJkiRJasSiErgkBya5KMmaJEfO8vy2SU7sn/9qklUznr9Tkp8n+ZNNE7YkSZIkrTwLJnBJtgTeDDwS2BM4PMmeM3Z7FnBlVe0BvAF43Yzn/x746MaHK0mSJEkr11aL2GdfYE1VfQcgyQnAIcCFU/scAhzVP34/8KYkqapK8ljgu8AvNlnUDVt15ClL8r4XH3PQkrxva/FKkiRJy9lihlDuDFwytb22b5t1n6q6DvgpsGOSWwJ/Brxm40OVJEmSpJVtqYuYHAW8oap+Pt9OSZ6TZHWS1ZdddtkShyRJkiRJbVrMEMpLgV2ntnfp22bbZ22SrYAdgCuA/YBDk/wtcGvg10murqo3Tb+4qo4FjgXYe++966b8QyRJkiRpuVtMAncmcNcku9Elak8GnjJjn5OBI4AvA4cCn6qqAv7XZIckRwE/n5m8SZIkSZIWZ8EErqquS/JC4DRgS+BtVXVBkqOB1VV1MnAc8K4ka4Af0yV5kiRJkqRNaDE9cFTVqcCpM9peNfX4auCwBd7jqJsQnyRJkiRtNmOvwr7URUwkSZIkSZuICZwkSZIkNcIETpIkSZIaYQInSZIkSY0wgZMkSZKkRpjASZIkSVIjFrWMgCS1aOxlgCVJkjaUPXCSJEmS1AgTOEmSJElqhAmcJEmSJDXCOXCSNBLO2ZMkSQsxgZMk3SQmnJIkbX4OoZQkSZKkRpjASZIkSVIjTOAkSZIkqREmcJIkSZLUCBM4SZIkSWqECZwkSZIkNcIETpIkSZIaYQInSZIkSY0wgZMkSZKkRpjASZIkSVIjTOAkSZIkqRFbDR2AJEmS5rfqyFOW5H0vPuagJXlfSUvHHjhJkiRJaoQ9cJKkFcEeDEnScmAPnCRJkiQ1wgROkiRJkhphAidJkiRJjTCBkyRJkqRGmMBJkiRJUiNM4CRJkiSpEYtK4JIcmOSiJGuSHDnL89smObF//qtJVvXtD0tyVpLz++8P2bThS5IkSdLKsWACl2RL4M3AI4E9gcOT7Dljt2cBV1bVHsAbgNf17ZcDj6mqewJHAO/aVIFLkiRJ0kqzmB64fYE1VfWdqroGOAE4ZMY+hwDH94/fDzw0SarqnKr6r779AuBmSbbdFIFLkiRJ0kqzmARuZ+CSqe21fdus+1TVdcBPgR1n7PME4Oyq+tXMH5DkOUlWJ1l92WWXLTZ2SZIkSVpRNksRkyT3oBtW+dzZnq+qY6tq76rae6eddtocIUmSJElSc7ZaxD6XArtObe/St822z9okWwE7AFcAJNkF+CDwh1X17Y2OWJIkaSOtOvKUJXnfi485aEneV5ImFtMDdyZw1yS7JdkGeDJw8ox9TqYrUgJwKPCpqqoktwZOAY6sqi9uqqAlSZIkaSVaMIHr57S9EDgN+AZwUlVdkOToJAf3ux0H7JhkDfBSYLLUwAuBPYBXJTm3/7r9Jv9XSJIkSdIKsJghlFTVqcCpM9peNfX4auCwWV73l8BfbmSMkiRJkiQ2UxETSZIkSdLGM4GTJEmSpEaYwEmSJElSI0zgJEmSJKkRJnCSJEmS1AgTOEmSJElqhAmcJEmSJDXCBE6SJEmSGmECJ0mSJEmNMIGTJEmSpEaYwEmSJElSI0zgJEmSJKkRJnCSJEmS1AgTOEmSJElqhAmcJEmSJDXCBE6SJEmSGmECJ0mSJEmNMIGTJEmSpEaYwEmSJElSI0zgJEmSJKkRWw0dgCRJurFVR56yJO978TEHLcn7thavJLXKHjhJkiRJaoQJnCRJkiQ1wgROkiRJkhphAidJkiRJjTCBkyRJkqRGmMBJkiRJUiNM4CRJkiSpESZwkiRJktQIEzhJkiRJaoQJnCRJkiQ1YlEJXJIDk1yUZE2SI2d5ftskJ/bPfzXJqqnnXt63X5TkEZsudEmSJElaWRZM4JJsCbwZeCSwJ3B4kj1n7PYs4Mqq2gN4A/C6/rV7Ak8G7gEcCPxz/36SJEmSpA20mB64fYE1VfWdqroGOAE4ZMY+hwDH94/fDzw0Sfr2E6rqV1X1XWBN/36SJEmSpA2Uqpp/h+RQ4MCq+qN++w+A/arqhVP7fL3fZ22//W1gP+Ao4CtV9e6+/Tjgo1X1/hk/4znAc/rNuwMXbfw/7UZuB1y+BO+7lFqL2XiXlvEuLeNdWsa7tIx3aRnv0jLepWW8S2up4r1zVe002xNbLcEP22BVdSxw7FL+jCSrq2rvpfwZm1prMRvv0jLepWW8S8t4l5bxLi3jXVrGu7SMd2kNEe9ihlBeCuw6tb1L3zbrPkm2AnYArljkayVJkiRJi7CYBO5M4K5JdkuyDV1RkpNn7HMycET/+FDgU9WNzTwZeHJfpXI34K7AGZsmdEmSJElaWRYcQllV1yV5IXAasCXwtqq6IMnRwOqqOhk4DnhXkjXAj+mSPPr9TgIuBK4DXlBV1y/Rv2UhSzpEc4m0FrPxLi3jXVrGu7SMd2kZ79Iy3qVlvEvLeJfWZo93wSImkiRJkqRxWNRC3pIkSZKk4ZnASZIkSVIjTOAkSZIkqREmcCOTZNvFtEmSJEmz8XpyeVv2CVyS3ScHbJIHJXlxklsPHdc8vrzINm2kJLcdOob5JLlDkjv0j3dK8vgk9xg6rrm0Fi9Aktsk2TfJAyZfQ8c0nyS3SLJF//huSQ5OsvXQcc0lyScX0zYWSX4jyXFJPtpv75nkWUPHtRwk2WLq2N0myV5jPge3Fu+0JLdPcqfJ19DxzCXJXZJ8OMnlSX6U5ENJ7jJ0XPPpP+cOTvKYyefdiDVxPZnktvN9DR3fWC37BA74d+D6JHvQlfncFXjvsCHdWH9SuB9wsyT37T8s9kryIODmA4c3p/4i8pNJvt5v3yvJXwwd10xJfi/JN5JckGS/JKcDZya5JMnvDh3fTEmeS3ei/UqS/w18BDgI+MAYLyhbixcgyR8Bn6NbIuU1/fejhoxpET4HbJdkZ+DjwB8A7xg0olkk2a7/4L1dnyRPPoxXATsPG9283kF3HNyx3/5P4I8Hi2YOSX4ryUeTnNLfpHxHkp8kOSPJbw8d30xJHgv8ALg0ySHA54H/A5yX5DGDBjeL1uKd6BOLbwHfBT4LXAx8dNCg5vde4CTgDnR/c+8D/u+gEc2j/8w4A3g83ZrHX0nyzGGjurEGryfPAlb332d+rR4wrnn1N6m/leSnSX6W5KokP9tsAVTVsv4Czu6/vwx4Uf/4nKHjmiXOI4BPA1f13ydfJwOPHzq+eeL+LLDv9O8U+PrQcc0S5xnAPYHfBS4H7t+37wV8cej4Zon3fLoT7Y7Az4E79O23Ac4dOr7W452KebtJfMBvAR8YOq4FYp6cz14E/Gn/eHS/X+AldBeRvwK+0z/+LvA14IVDxzdP3Gf236fPZ2P8/X4OeAxwOPA9urVX07d9cuj4Zon3HLqL9N2AnwF379vvTLee7OAxthzvVNxf68/B5/TbDwaOGzqueeI9b7Z/w9BxzRPvRcCOU9s7AhcNHdcscU5fT36qlevJ1r6ANcBvD/XzF1zIexm4NsnhdAf05M7Z6IYcVdXxwPFJnlBV/z50PBvg5lV1RpLptuuGCmYeW1fV+QBJLquqLwBU1dlJbjZsaLO6tqp+Cfwyyber6ocAVXVlkjEu3thavABXV9XVSUiybVV9M8ndhw5qAel7jJ8KTHo2txwwnllV1T8C/5jkRVX1xqHj2QC/SLIjUABJ9gd+OmxIs7pVVX0YIMlrq+qEvv3DSV4zYFxzmpwTkny/qi7q2743GaY4Nq3F27u2qq6YDP+sqk8n+Yehg5ppaljcR5McCZxA9zf3JODUwQJb2BV0SdHEVX3bqLR6PZnkk1X10IXaRuS/q+obQ/3wlZDAPQN4HvBXVfXdJLsB7xo4pvl8JMlTgFVM/f9U1dGDRTS/y5PszroLnkPphp6MzfSH7stnPLfN5gxkkSrJ1lV1Ld1QRKAbmsY4hz63Fi/A2nTzYf8DOD3JlXS9GWP2x3TH7wer6oJ+vsinB45pTlX1xiQHcOPz2TsHC2p+L6W7S717ki8CO9ENlRqb6aT972c8N8bzGX1C8WvgmVNtW2K8m9JPktySrof2PUl+BPxi4JhmcxbdNcPkzu9zp54rbvwZPagkL+0frgG+muRDdHEeApw3WGAL2yXJ9nSJ5lvpRhwdWVUfHzas9fXXCbegH3LPuuNie8Y95H51khPpriF+NWmsqg9sjh+evhtwWet7WO40uYs2Zkk+RnfH9yzg+kl7Vf3dYEHNo7+APBY4ALiSbpjU06rq4iHjminJwcAn+l6i6fbdgSdU1d8OE9ns0k08/6+qum5G+850XfafGCay2bUW70xJHgjsAHysqq4ZOp6FJLn5zGN5jJK8C9gdOJd157OqqhcPF9X8kmwF3J3uIuKi/qbEqPRzTt9TVT+f0b4H3RDVUc3bS7IPcH5VXT2jfRXdcPZ3DxHXXFqLdyLJLYD/obtp9lS6c9q7q+rHgwbWuCSvnu/5qhplr3eSr1XVvZM8gq4j4y+Ad1XVXgOHtp4kL6G7OXlH4FK6c2/RJZ7HVtWbBwxvTknePktzVdVmmRe57BO4fsLx64Ftqmq3JPcBjq6qgwcObVZJvl5VvzN0HBuq/+DYoqquWnDnEUvyxqp60dBxLFaSL1fV6IqwzGVM8Wb26lZXjfGCfaIfPnkccMuqulOSewPPrarnDxzarJJ8A9izGvmgSfL4WZp/Sncx/6PNHc/GSvLyqvqboeNYrCT/XlVPGDqOxRpbvEkeWVUfndH2vKr6l6Fimk+Sm9P1et+pqp6T5K508w0/MnBo82roBtp5VXWvJP8IfKaqPpjknKq679CxzSbJq4B/qKqfJXklXY/ha6vq7IFDG6WVMITyKLoiG58BqKpzM+4ytV9Kcs/JfK2xmxpaMNmGvgexqs4dJKiN83tDB7CBths6gA00pnjPpqtKeyXdHb9bAz9M8t/As6vqrCGDm8M/AI+gG+ZHVX0t41764Ot0xSDGOKx6Ns+iK3Q0GZb6ILrRELslObqqxjz8fjaHAc0kcMCYP5tnM7Z4X5nkV1X1KYAkLwMeAowygQPeTvf3dUC/fSldJcpRJnDTN9CA0d9AA85K8nG6YjwvT3Ir4NcDxzSfQ6vq6CT3pztuXw+8Bdhv2LDWl+RPq+pvk7yRfvrQtM01wmQlJHDXVtVPZxTZGPMBfH/g6UkmFdxC1yV7r2HDmtPe/deH++1H040Jf16S941taOIy1ETPxpQxxXs68P6qOg0gycOBJ9BdVPwzI/vQmKiqS2acz66fa98RuB1wYZIzWH+OwChHQNB9Jv52Vf03dOvCAe+kOxY+x7jnT88mC+8yKmM6PyzG2OI9mG4e/cuAA+kq6x4ybEjz2r2qnpSu0BxV9cvMOLmNTGs30J4F3IeucN/edOfjdwwZ0AImn2UHAW+tqlOS/OWQAc1hUrhkNQOeA1ZCAndBXxRky757/sXAlwaOaT6PHDqADbQLsNdkLkY/VvwU4AF0d9ZM4DRW+1fVsycbVfXxJK+vqucm2XbIwOZxSV8UpNIt4P0S1n2YjNFRQwewgXadJG+9H/VtP04y2qG18xhbgqElVFWXT+Z7033+Hjry4cvX9DUKJkXQdmfqRs8YNXYD7Zl0nxG70M1D3p9uvdaxVga+NMm/Ag8DXtd/Do+uCNqkAjBwIfDnrF+kq+hu+i25lZDAvQh4Bd1J4b10i7SOLqNPsn1V/Yz1S9S24Pasf8K9FviNqvqfJKM+Ec9hzHf/ZmO8N90PkvwZXQlr6EpY/6ivNDfWXvrnAf9IV5nrUrrFvF8waETzqKrPDh3DBvpMko/QDeOCrkf2M/0c358MF9ZNNqa/t8Uw3psgyVWsq+pYdJUy7wIcmqSqavsh45vHq4GPAbsmeQ/dFIanDxrR/Fq7gfYSYB/gK1X14CS/Bfz1wDHN54l0Pcevr6qfJPlNujWcx+rddPGdzwDXDMs6gesvxI6uqj+hS+LG7L10ww9nltel3x7bWPuJ97CurC50a+29t7/guXC4sG6sPx5e1x8Pc/nHzRXPQvp4P1FVD55ntz/YXPEsVpI7A3etqk/0d1e3mipuM3i8Sd5VVX9Al/zcma4EMMAX6BZG3pLug2RU+uPhD6rqqUPHspAkX6iq+09dWN7wFN2Q8LFeUL6ALmmbzIV9J/DvfS/GfH+Hm11/PLy4qt4wz27vm+e5zaqP950LHL9/trniWawFqliPIt6qutXQMWyofqjkN4HH0/UMBXhJVV0+aGDza+oGGo2tddoXhvnA1PYPGPf86cuq6uShfvhKqEL5laraf+g4lrO+5PJkEvIXq2r1kPHMp7XjIckngcdX1RgXE76RJM8GngPctqp274ct/0uNaIcEMDAAAB1aSURBVCHOJBcCvw98lO6ifHLXGoAxl9xOcmZV7TN0HBqHJGdU1b5Dx7FYSb4APKSFpTqgnSrWSeYtCz/WKn5Jzq+qew4dx2Is8obJqCT5IN1ayH9MVxTkSmDrqnrUoIEtE0keSnfT95O4Dtyml+QtdHdL3sfUgpab6xd8U6RbyPCuTFXsq6rPDRfR/PoT22+w/kK93x8uorm1djz0PZv3pSu4MR3vKNfRSnIuXdXXr05KFY/tQzrJi4H/Tderfen0U3S9Q2Pt7SbJG+gmpJ/I+sfDKC/QJpLcnvXPZ2M9PzweeB3d0PAw8h7D1o6HJO8EfpuuCMR0vDMXIx+FJGfRXfh+ZqznM4Akn57anK3H+yGbOaRFSXI88KaqOnPoWBaj5RtoaWyt0xYkeTddoaALWDeEsmozrQO3rIdQ9rYDrqA7CU8UU920Y5Lkj5h90ulYT8AvohvH/t90k3knvRljrZrZ1PFAF9dYY5vNr6rqmskk73SLIo/qLlFV/RPwT0neUlX/e+h4NtB9+u9HT7UV4z0/HAz8Hd0CrT+iG7L6DeAeQ8Y1j78FHlNVY57XMq2p4wH4dv+1BdDCsL/ZqliP6nwGMBlm3w/3fD5dNesCPk9Xhn2s9gOeluRiuoR+7FW3v5DkTTRyw2Rag/ORW7BPVQ02JHXZ98AtJCNb6DTJ+aybdHqfyaTTqpptgdnBJVkD7FdVVwwdy3K1wByMUUnyt3TFHv6QroDQ84ELq2rsc1CXhSRHVNXxQ8cxkeRrdMnEJ6rqvkkeDDytqp41cGizSvLFqmptLcjmpJ2FkI+jGx51JN3cyBfTDUF73qCBzSHJScDP6OamAzwF2KGqRjenF26YL30b4H/1TZ8DflJV3xsuqrlN9XROLpxH3cOppZXk7cD/qapB6j2MrjznAA4bOoAZrq6qq4EbJp0Co510ClxCt3B3E5LcLcknk3y9375Xkr8YOq659HMwzqWr1EWS+yQZbNLsIhwJXEZXlem5wKnAaH+/y9BLhg5ghmv7mztbJNmiqj5Ntx7RWK1OcmKSw5M8fvI1dFBzSfIbSY5L8tF+e88ko0yOoVsIuZ+D+s1++95J/nngsObzIrre4kkV65/SzScaq9+pqj+qqk/3X88GfmfooObxWLq1FW8H7NQ/HtX8QoAkL03yUroFxj9Mt1TSKf32KBcd12axP3BukouSnJfk/CTnba4fvhKGUC5kFGWAp6xNcmu6yninJ7kSGOXdqN536Mpsn8L6kzhHOacBeCtd2dd/Baiq85K8lxEuLdE7im5O2WcAqurcJKOdo0X3gfzOqnrr0IGsUGM7n/0kyS3phnK9J8mPmBp6NELbA78EHj7VNuYh1u+gW3h+0sP9n3TDu44bKqAFtLYQ8m/1owdaGUFwdpL9q+orAEn2o1tseKyeRbce5y8AkryOca5TNhnue3e6EVIfojvXPgY4Y6igNLgDh/zhJnAjG89eVY/rHx7Vd9fvQN/7MlLf77+26b/G7uZVdcaMOQ3XDRXMIsw2B2Osa5RB94H2hiSfo7uQ/FhVjfn3u9yM6nwGHAJcTddr8VS689nR875iQFX1jKFj2EC3q6qTkrwcoKquSzLmhYVbWwj575LcAXg/cGJVfX3ogGbTT70ouoI2X0ry/X77zvS9nSMV1v//n8yjH5Wqeg1A/7m212RZnCRH0fXEaQUaeqivCdwITxZ9SeDJJOQvjrli0OTE1pDLk+xOf6Gb5FDGvc7IBUmeAmzZl+R/MfClgWOaU1U9I90Cp4+kK6/75iSnV9UfDRzaSjGq81lV/aK/AN4X+DFw2pjnyybZjq5X4B6sXzVzs1QVuwl+kWRH1p3P9mfcQ9qbWgi5usWP70C3LuS/JtmeLpEb24iNRw8dwE30drp1ZD/Ybz+W8fYeQ1dte/p67Jq+Tdrsln0RkyS/V1VfnKstyZ9X1WhWpk/yKrp5eZMhO48F3jfCDwwAkuwE/Ck3vuAZ5aTefvjhsXTr1l0JfJeuqMLFQ8Y1lyQ3pxu+83C6i/PTgNdO5kmOVX9xdiDdGjQPqKrbDRzSstDPi/3VjLbbTtauS/KmqnrhMNHdWF9V91XAp+iO3wfSraP1tkEDm0OS99H1WDyFrqfwqcA3qmpscwuBG272vZFuntPX6eYRHVpVm20exoZIcju6hZB/n+54+Djd4s2jTeonktyT7rPuSVXVwmiTJkzdsAb4fFWdM2Q880nyCrpkfjrhPHFMhfC0cqyEBO7sqtprobaxSHIRcO+pQiY3A84dslTpfJJ8nG6o3J8AzwOOoFud/s8GDWwBSW4BbDEZCqFNI8kjgScBD6Kbt3cS8HGHUW4a/VzTx1bVtf32bwIfqar7DRvZ7Prz2QGTC/S+t+hLIz6fndNXyzyvqu7V34j4fFXtP3Rsc+mX6rg7XUJ00eTY0MZL8tt057NDgcvpPuv+vap+NGhgGkyfcN5QNXPMCaeWt2U7hDLJ79L1suzUVw+a2B7YcpioFuW/6HqyJj0s27L+YsNjs2NVHZfkJf06I59NMtpFOZNsS1cOehWw1WQuRlWNcl5OkrvRJcerWH+h9FH2cNItH3Ai8NyZPUXaJP4DOKkf+rsrXTGIPxk2pHldAUzfJLmqbxurSfLzkyS/A/yQblHvMduXdeeHvZJQVe8cNqTZ9SM2ns2Nz2djHaL6NuAE4OFV9V9DB6Ph9Wu+jX7dNy1/yzaBoyuocUu6f+P0gqE/o7ubNlY/pZv3dDrdvIaHAWck+SeAqnrxkMHNYnLB84MkB9EloLcdMJ6FfIjud3wWU1UzR+x9wL8A/8a4J/sDUFWHJ/kN4GF9cnyGd6s3nap6a5Jt6BK5VXSJ8mjnRAJr6Oa4fIjufHYIcN7kptoIq9Uem+Q2dEtfnEz3GfLKYUOaW5J3AbvTLTUyOT8UMMoEju78+3ngE7RxPvvd/u/tbkluiz2ckkZiJQyhvHNVfa8vZU1V/XzomOaT5Ij5nh/TIr0ASR5N94G8K91cjO2B11TVKNcqS/L1qhrzujjrSXLWWIfHzSbJYcDr6YZPhm6oycuq6v1DxtW6GaMIQtfTeR5wDowyEQIgyavne35MRZCSbEE3f+ykoWNZrCTfAPasRj7Ik5xbVfcZOo7FSvJAumT4Yrq/u12BI6rqc0PGJUnLuQdu4lZJzqHvFUpyOd0JeJTlgBdK0JL8e1U9YXPFM58kWwJ3raqP0PVqPXjgkBbjS0nuWVXnDx3IIn04yfPpJk1Pr7P34+FCmtdfAPtMet36IVOfoCvDrZvuVjO2PzBH+6gslKAleWNVvWhzxTOfqvp1kj+lm7fZiq8Dd2DclXSnfSTJo6rq1KEDWaS/pxs+eRHcMKT9/wLN3FSTtDythB64LwGvqKpP99sPAv66qg4YNLCbaDLJfug4JpKcUVX7Dh3HYiW5ENiDrvrkr+juqlZV3WvQwOaQ5LuzNFdVjXIx7yTnV9U9p7a3AL423SZNjK2gVJJjWFes4oYFx8d6w6RfK/Q+dIsJT9/gOXiwoOaR5CrgFnSxXsu68+/2gwY2h0kxm4XaJGlzWwk9cLeYJG8AVfWZvgJhq8aWcX8xyZu48QXPWCf5PnLoABarT36eNnMZjJH7WJLT6O5SQ1fBrZW77aPXz409rKp+0m/fBjihqh4xbGTLxpP67y+YaitglDdMgKOGDmCx0k2KvUdVfX/oWDbA6iT/Bry7334qsHrAeCQJWBk9cB+kqxj0rr7pacD9qupxw0V1043wjvWnZ2muMVZJ7Id8XlBVvzV0LIs1th7XxUjyeNZf1+eD8+2vxZttDlGLx8jE2M5nC0nysKo6feg44Ibz2SeqqoWh68CNe+jHrq9a/AKmzmfAP1thV9LQVkIP3DOB17Buzsjn+7ZWZegApi108ZDkiLEUXqmq65NclORODd0F/mSSJwAfaKVQAfAlugpzvwZGu6REo66fPn6T3Jnx9cpviFGdzxbhdcAoErj+fPbrJDtU1U+HjmeRzk6yT1U1cV6oql/1I0w+SXc+u6iqrhk4LEla/j1wy02Sh1fVx4eOY7HGdoc9yeeA+9LNGZke8jn2OSPXA//D+OeM/BHwKuBTdLE+EDi6qt42aGDLRJIDgWOBz7Kuyudzquq0QQO7iZI8vareMXQcizW23s5+eYb70iWV0+ezsS03A0CSb9LNQf4eXbxjn4N8EN0yLt+mi3U3uqU7PjpoYJJWvGWfwLW2EHKS36Ob13BnungnH3BjnYMxrxFe8DxwtvZ+EXJtpCQXAQdU1RX99o7Al6rq7sNGtnwkuR2wf7/5laq6fMh45tOff1/GuvMZMN7z70JGeENq1mVnxjLqYaa+x/hGqup7mzuWxegTzkdX1Zp+e3fglJaG4UtanlbCEMqmFkIGjgP+P7qFpluIdyGjukNQVZ/tF5rep28a/ULTSQ4GHtBvfqZftmGsrgCumtq+qm/TpnMA644HgDEfD5Pz71tZHuezUamq4ycLTfdNo15oul+T9d50PcfQzZH92pAxLeCqSfLW+w7rn98kaRArIYG7rqreMnQQG+Cny2x4xqjmuCR5IvB/WLfQ9BuTjHah6b6s+T7Ae/qmlyT5vap6+YBh3cjUQtNrgK/2Q7sKOIRuwWltAnMcDwdU1Z8PGNZ8Wjv/LuTioQOY1i+LczxTC033845HudB0kpcAz2bdnPR3Jzm2qt44YFg30hdigq4K5al0awMWcBjO65U0Ast2CGWS2/YPXwz8iEYWQu4v0Lak+4CbjnesZfnnleRNVfXCoeOYSPI14GEzF5quqnsPG9nskpwH3Keqft1vbwmcM7Y5I0lePd/zCy3orMVp5XiYSHIUDZx/py7YZ1VVH5jv+aEkOQt4ysyFpqtqlAtN98fv71bVL/rtWwBfHtvxm+Tt8z1fVc/YXLFI0myWcw/cWXR3zCY9QC9j/eF8Y51Ttl//fe+ptgJGNWdkqsdlVlX19/330SRvvS1mDJm8AthiqGAW6dbA5IJ3hyEDmYsJ2mY1+uNhymSO1sum2sa4rtpj+u+3pxui+ql++8F0VVVHmcABW0+SN4Cq+s8kWw8Z0ALC+kNpr2dkozTABE3S+C3bBK6qdoMbhsx9rKp+luSVwF7AawcNbh4Nrelzq/773emGdJ3cbz+GrsLjWM220PSYh6z+DXBOv95e6OY+HTlsSHPrezT/FLgHsN2kvdWiFSPU1PEwOQ+P3eSCPcnHgT2r6gf99m8C7xgwtIW0ttD02+mGWE/Whnws3bzvUUqyHfAsbnw+a3kpIknLwLIdQjmR5LyquleS+9Mlbq8HXlVV+y3w0s0qydOq6t1z9WxNerTGpi/Lf1BVXdVv34quStcD5n/lcFpbaLq/iJwuuvLDIeOZT38BfCJd5dfn0fXAXFZVfzZoYMtIC8dDkodU1afmGpo44iGJ36iq357a3gK4YLptTFpcaDrJXqx//j1nyHjmk+R9wDeBpwBH0yXI36iqlwwamKQVb9n2wE2ZDNc4CHhrVZ2S5C+HDGgOt+i/32revcbnN4DphU2v6dtGKcluwKmTC8gkN0uyqqouHjay2SV5HPCpqjq53751ksdW1X8MHNpcdqyq45K8pF+a4bNJnPS/kfqL3mlr++93THLHEc6RfSDdMMTHzPJcMd4hiZ+cpYf+EwPGs5CtgH+c3ODr50RuO2xIc0uyP11CfHa/vX2S/arqqwOHNpc9quqwJIf0FT/fS5ckS9KgVkIP3EeAS4GH0Q2f/B+6u9ajLFqxkCQvr6q/GTqOiSSvAJ5IV6QAuiExJ44pxmlJVtOtU3ZNv70N8MWq2mf+Vw4jyblVdZ8ZbaNaW29akq9U1f79RfA/Af8FvL+qdh84tKb1QyYnpk/ak3Uimxyi2ldMHNWaZX2v4aTM/efG3EOf5CvA71fVz/vtWwIfr6oDho1sdknOAfaq/sKj7+FcPaa19aYlOaOq9u1Hmjwf+CHd9cPY5nBKWmFWQg/cE4EDgddX1U/64UcvW+A1Y3YY3TyYUaiqv0ryUdZd8DxjzENigK0myRtAVV3TJ3FjNVuBlTH/3f5lkh2A/x94I7A93bqG2giTubFJbkZ3IXl/ukTu80DLZfpfQlcGfzT63vmx9hDOtN0keQOoqp8nufmQAS0gNXXXuKp+nWTM57Njk9wG+Au6ed63BF45bEiSNO4LwU2iqn7J1IdxPzn9B8NFtNFGUbEryfZ9YZjb0q1BdPHUc7cdW5nwKZclOXhqSOIhwOUDxzSf1Un+Hnhzv/0CugqrozS1yPhP6Sr4rWdsPcgNOh74GV3vJnRzc95Jd6OqRWM5n32hqu6f5Cpm7+HcfqDQFvKLJHtNDUm8H90ok7H6TpIXs+6mw/PpFscepar6t/7h55ilcuoYe5AlrQzLfgjlcpPk7DEMN0nykap6dJLvsm65hhu+j3WISZLd6RZBviNdrJcAf1hVawYNbA79OkmvBH6f7vd7OvBXk3WUWjOW47dVSS6sqj0XamuFx8PGSbIPcALdUOUAdwCeVFWjvMmT5PZ0Nx8eQnc++yTwxzOWdmmGx6+koSz7HrhlaBR3rKvq0f33JsqET1TVt4H9+7kiTA8/Gpu+IMFrqupPho5lExrF8duws5PsX1VfAUiyH+MuG7+Q0R0P/ZC5XZn6fBxhkRgAqurMJL9Ft5wLwEVVde2QMc2lP589taqePHQsm9Dojl9JK4MJ3Mgk+b2q+uI8be8bIKx5JbkXsIr1L3hGNYdkruUZku7zd4zLNFTV9f3yF8uJXf43QZLz6X53WwNfSvL9fvvOdGXORynJtjNL2s8YYv3FWV42mCSvBZ5ON6zv131z0fUYjcZcyzMAd0syuvMv3HA+Oxx4w9CxbEKezyQNwgRufN5IVy1z1raq+uvNHtE8krwNuBdwAetf8IztAqK15RkmzklyMl3ifsOwyTFeoC2Sd6xvmkcPHcBN9IF+2Ytr4YY17D4C3A+gql44ZHCzeCKw+3Sho5GabXmGiTGefye+mORNdGtFTp/PRtnDuQiezyQNwgRuJJL8LnAAsNOM3qLtgS2HiWpR9m9h/k1VvWYx+42wyMZ2wBWs3wMw2gu0FnuQW1BV3xs6hpvoP4CTkhxKNyzxZLpF3sfq68CtgVHPyaqqZyxmvxEW2ZgsiXL0VNvoejgnWutBlrRyWMRkJJI8EHgQ8DzgX6aeugr4cFV9a4i4FpLkOODvqurCoWPZFFqblD62hHO2319rv1NtWkleQLeUyyrguVX1pWEjmluSvYEP0SVyN1y4V9XBgwW1EVr72xtbwpnkFOBGPchVdb9hI5O00tkDNxJV9Vngs0neUVXfa6HIRu+dwJeT/JDugmdShfJew4Z1k7U2JGYU6wI23IOsJTDjGAhwJ+BcugJC+49xzmnveOB1wPmsGxLestbOZ2NbF7C1HmRJK4QJ3PjcKsk5wG0BklwOHFFVXx82rDkdB/wBy+eCp7Uu6bFcoG1Dt8jtVqw/3/BnwKGDRKQhzZxz+oE52sfml1X1Twvv1gzPZxuhqt6aZBu6RG4VI+9BlrRymMCNz7HAS6vq0wBJHtS3HTBkUPO4bLIo9jIxqguIRRjFBVrDPchaAoudczpCn0/yN3Q9LdNDKC2ysXmM4nzWcA+ypBXCBG58bjFJ3gCq6jP9Ys5jdU6S9wIfZv0LHotsbB5ju0BrrQdZSyjJ6cBhVfWTfvs2wAlV9YhhI5vTffvv+0+1WWRj8xnL+azVHmRJK4QJ3Ph8J8krgXf120+jW5NorG5Gl7g9fKpttFUSaW+ZhtYSztZ6kLW0dpokbwBVdWWS2w8Z0Hyq6sHzPT+2Ihs0tkxDKwlnwz3IklYIq1COTH+H+jXAZAHnzwNHVdWVw0V1042lSuJUkY0/Zv2FZLcHHldV9x4ksAW0VtUxyddm/i5na9PKkOQsur+v7/fbdwY+ONbjdyFj+9tL8mzgUXTzTG8oslFVHx80sDm0VtWxwR5kSSuEPXAj0ydqLx46jk1oFFUSaazIRsNVHVvrQdbSegXwhSSfpRse97+A5wwb0kYZyxA/oMkiG61VdWyqB1nSymECNzJJ7kb3gbaKqf+fqhrlHIxFGMUFT4NFNppKOKc8k64HeTKE9vN9m1agqvpYkr1YN6fsj6vq8iFj2kijGLLSapGNBhPO65PcaUYP8iiOAUkrmwnc+LyPbiHvfwOuHziWTWFsH3ZNFNloMOEElmUPsjbeAcADprY/MlQgm8AobkjRWJGNVhNOll8PsqRlwgRufK6rqrcMHcQmNJYLnonWimw0kXBOLMMeZG2EJMcA+wDv6ZtekuSAqvrzAcOak0U2lkxTCefEMuxBlrRMWMRkJJLctn/4YuBHwAdZvyz/j2d73dAWqpKY5M/HVNmxtSIbSb4EvGJGwvnXVTXKhDPJ1+h6kM9iqge5qs4aLCgNJsl5wH2q6tf99pbAOVV1r2Ejm51FNjRTkoNZ14P8mapquQdZ0jJhD9x4nEU33HDSY/Uy1h9+eJfNHtHiNFWWn/aKbLS2LuBy60HWxrs1MLkBtcOQgSyCRTaWUGsJZ2s9yJJWDhO4kaiq3QCSPBH4WFX9rE809gJeO2hws2i4SmJrRTaaSDinepA/nOT5NNKDrCX3N8A5ST5Nd3PqAcCRw4Y0N4tsLLmmEk66JRqme5CPB84BTOAkDcoEbnz+oqpOSnJ/4CHA64G3APsNG9aNNFklscEiG60knK32IGsJVdX/TfIZul4MgD+rqh8OGNKsLLKx2bSWcEJbPciSVgjnwI1MknOq6r5J/gY4v6reO2kbOrbZJLlzS1USLbKxtObqQa6qswcOTZtRX/hhTmM7HpK8er7nx1w0JMntWFdk4ytjLrKR5EC6olHrJZxVddqggc0hyeHAMcB6PchVdeKggUla8UzgRibJR4BLgYfRXfz+D3DGiIts/A7d8L7JELqxV0lsqshGawlnkvOq6l59D/Jr6XqQX1VVY+tB1hLqh0xOTH/IBKixHr8taq3IRksJJ9xQyGbSg3zGGHuQJa08JnAjk+TmwIF0vW/f6j887llVHx84tFk1WCXxrLFWlJtNgwlnUz3IWlpJbgY8H7g/XSL3eeAtVXX1oIHNYRkU2TgcOHPMRTZaSDhb60GWtPKYwGmjtFKWv+FlGlpLOJvqQdbSSnIS3bzYSYLxFGCHqnricFHNLcm5VXWfGW2jvQHR4DINTSSc9iBLGjsTOG2UJB8Ezmb9Kon3q6rHDRfVjSX5LusX2YCpD+aqGlWRjYYTzqZ6kLW0klxYVXsu1DYWSc4CHjejyMYHq2reHpmh9Ancgybng/688ZkRJ3CtJZxN9SBLWjmsQqmN1USVxNaWaaDRqo5V9UvWHQtU1Q+AHwwXkQZ2dl/F8SsASfYDVg8c03xaq+rY1DINvZaqOh5P14P8T/32U4B3AqPsQZa0ctgDpxWltSIbVnVUi5KcT3fDYWvg7sD3++07A98caw8cWGRjKbVW1bG1HmRJK4c9cNoorVVJZF0hkIOAt1bVKUn+csiAFtDKuoDStEcPHcBGOIB1RTYAWiiysbb/fsckdxzrDZ5W1gWc0loPsqQVwh44bZQGqyQ2VWTDqo7S5mORjaXRWlXHlnuQJa0MJnDaKA1WSWyqyEZrCafUMotsLI0GE847z/d8VX1vc8UiSbMxgdNN0mqVxNa0lnBKLWuwqmNryzQ0kXBK0tiZwOkmaa0svyQtxCIbS6u1hFOSxsoiJrpJGizLL0nzssjGkvudGcnlp5NcOFg0ktQoEzhtLKskSmpaa1UdZxTZ+FKS9YpsDBnbAlpLOCVplEzgtLFaK8svSTP93dTjGxXZoLs5NSZNLdPQcMIpSaPkHDhtFKskSlouLLKxNKzqKEmblgmcNopVEiUtFxbZkCS1wAROkiTaq+ooSVqZthg6AEmSRuLsJPtPNiyyIUkaI4uYSJJWNItsSJJa4hBKSdKKZpENSVJLTOAkSZIkqRHOgZMkSZKkRpjASZIkSVIjTOAkSZIkqREmcJIkSdL/a78OSAAAAAAE/X/djkBfCBMCBwAAMBFLRTdA7+VoIQAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -1452,7 +1503,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -1462,7 +1513,7 @@ "# Testing predict\n", "rf_trained_clf.predict(X_test[:5])\n", "\n", - "with open('model/trained_rf_0.754_aug_16.pickle', 'wb') as f:\n", + "with open('app/app/model/trained_rf_0.774_aug_16.pickle', 'wb') as f:\n", " p = pickle.dumps(rf_trained_clf)\n", " f.write(p)" ] diff --git a/4. Deploy as web API via dockerized Flask app.ipynb b/4. Deploy as web API via dockerized Flask app.ipynb index 04ce56c..7f6c203 100644 --- a/4. Deploy as web API via dockerized Flask app.ipynb +++ b/4. Deploy as web API via dockerized Flask app.ipynb @@ -19,20 +19,213 @@ "source": [ "## Deployment\n", "\n", - "Please run the startup script to spin up the docker container. The API is exposed on port 80 and is reachable via **POST** requests.\n", - "\n", - "`source run.sh`\n", + "Please run the startup script to build and run the docker container. The API is exposed on port 80 and is reachable via **POST** requests.\n", "\n", + "#### Building & running the container\n", "\n", + "In Terminal, type `source build_and_run.sh`" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ "## Calling the API" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import requests\n", + "import pandas as pd\n", + "\n", + "from src.player_stat import get_player_stat" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Players we're testing\n", + "\n", + "| Name | NBA ID | Position |Note|\n", + "|------|------|------|------|\n", + "|Lebron James|2544|Small Forward|Play style not bound by position label|\n", + "|Pascal Siakam|1627783|Power Forward|Standard power foward|\n", + "|DeMarcus Cousins|202326|Center|Standard center|\n", + "|Damian Lillard|203081|Point Guard|Standard point guard|\n", + "|Anfernee Simons|1629014|Shooting Guard|Rookie with little data|\n", + "\n", + "#### Grabbing the data from NBA api and pipe through ETL" + ] + }, + { + "cell_type": "code", + "execution_count": 3, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def test_api():\n", + " \"\"\"This function is a variation of the flask unit test.\n", + " \n", + " It calls the API and compares the predicted and ground truth label\n", + " \"\"\"\n", + " \n", + " \n", + " player_ids_to_test = ['2544','1627783','202326','203081','1629014']\n", + " \n", + " player_names = ['Lebron James', \n", + " 'Pascal Siakam', \n", + " 'DeMarcus Cousins', \n", + " 'Damian Lillard', \n", + " 'Anfernee Simons']\n", + " \n", + " label_encoder_dict = dict([\n", + " (\"C\",0),\n", + " (\"PG\",1),\n", + " (\"SG\",2),\n", + " (\"SF\",3),\n", + " (\"PF\",4)])\n", + " \n", + " player_labels = ['SF', 'PF', 'C', 'PG', 'SG']\n", + " player_labels_int = [label_encoder_dict[label] for label in player_labels]\n", + "\n", + " \n", + " # Making the API call\n", + " header = {'Content-Type': 'application/json', \n", + " 'Accept': 'application/json'}\n", + "\n", + " # IP of the docker container running the predict service\n", + " request_url = \"http://127.0.0.1:80/predict\"\n", + " \n", + " results = []\n", + "\n", + " for name, pid, label in zip(player_names, player_ids_to_test, player_labels_int):\n", + " \n", + " player_test_data = get_player_stat(pid).to_json(orient='records')\n", + " \n", + " # Make the request to our dockerized model\n", + " r = requests.post(request_url, data=player_test_data, headers=header)\n", + " \n", + " print(\"Response in JSON:\", r.content)\n", + " \n", + " predicted_label = pd.read_json(r.content).values[0][0]\n", + " \n", + " results.append([name, label, predicted_label])\n", + " \n", + " # Construct the result dataframe\n", + " result_df = pd.DataFrame(results, columns=['Name','Ground Truth', 'Predicted']) \n", + " \n", + " label_encoder_dict_rev = dict([\n", + " (0, \"C\"),\n", + " (1, \"PG\"),\n", + " (2, \"SG\"),\n", + " (3, \"SF\"),\n", + " (4, \"PF\")])\n", + " \n", + " for col in ['Ground Truth', 'Predicted']:\n", + " result_df[col] = result_df[col].map(label_encoder_dict_rev)\n", + " \n", + " return result_df " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Response in JSON: b'[{\"y_pred\":1}]'\n", + "Response in JSON: b'[{\"y_pred\":4}]'\n", + "Response in JSON: b'[{\"y_pred\":0}]'\n", + "Response in JSON: b'[{\"y_pred\":1}]'\n", + "Response in JSON: b'[{\"y_pred\":2}]'\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NameGround TruthPredicted
0Lebron JamesSFPG
1Pascal SiakamPFPF
2DeMarcus CousinsCC
3Damian LillardPGPG
4Anfernee SimonsSGSG
\n", + "
" + ], + "text/plain": [ + " Name Ground Truth Predicted\n", + "0 Lebron James SF PG\n", + "1 Pascal Siakam PF PF\n", + "2 DeMarcus Cousins C C\n", + "3 Damian Lillard PG PG\n", + "4 Anfernee Simons SG SG" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test_api()" + ] } ], "metadata": { diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..8e9fbe0 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,8 @@ +#FROM tiangolo/uwsgi-nginx-flask:python3.6 +FROM tiangolo/meinheld-gunicorn-flask:python3.6 + +COPY ./app /app + +RUN pip install -r ./app/requirements.txt + +WORKDIR /app/app diff --git a/app/app/main.py b/app/app/main.py new file mode 100644 index 0000000..7d6be61 --- /dev/null +++ b/app/app/main.py @@ -0,0 +1,35 @@ +import os +import pickle +import pandas as pd +from flask import request, jsonify, Flask + +app_root = os.path.dirname(os.path.abspath(__file__)) +app = Flask(__name__, root_path=app_root) + +def load_pickled_model(): + """Loads and returns the pickled model to be used for prediction""" + with open("model/trained_rf_0.774_aug_16.pickle", 'rb') as f: + model = pickle.load(f) + + return model + + +@app.route('/predict', methods=['POST']) +def process_post_api_call(): + """Makes prediction and returns response in JSON. Supports + multi row data input. + + Payload must be in JSON format. + """ + + request_data = request.data + + X = pd.read_json(request_data, orient='records').values + + prediction = model.predict(X) + prediction_df = pd.DataFrame(prediction, columns=['y_pred']) + prediction_json = prediction_df.to_json(orient='records') + + return prediction_json, 200 + +model = load_pickled_model() diff --git a/app/app/model/trained_rf_0.774_aug_16.pickle b/app/app/model/trained_rf_0.774_aug_16.pickle new file mode 100644 index 0000000..326250c Binary files /dev/null and b/app/app/model/trained_rf_0.774_aug_16.pickle differ diff --git a/app/app/requirements.txt b/app/app/requirements.txt new file mode 100644 index 0000000..8b46a66 --- /dev/null +++ b/app/app/requirements.txt @@ -0,0 +1,3 @@ +pandas==0.25.0 +scikit-learn==0.21.3 +pickleshare==0.7.5 diff --git a/build_and_run.sh b/build_and_run.sh new file mode 100755 index 0000000..a558dea --- /dev/null +++ b/build_and_run.sh @@ -0,0 +1,7 @@ +#!/bin/bash +app="nba_player_position_prediction" +docker build -t ${app} . +docker run -d -p 80:80 \ + -e MODULE_NAME="app.main" \ + -e VARIABLE_NAME="app" \ + --name=${app} ${app} diff --git a/db/nba.db b/db/nba.db index 42852eb..9fa9fd6 100644 Binary files a/db/nba.db and b/db/nba.db differ diff --git a/model/trained_rf_0.754_aug_16.pickle b/model/trained_rf_0.754_aug_16.pickle deleted file mode 100644 index 8545232..0000000 Binary files a/model/trained_rf_0.754_aug_16.pickle and /dev/null differ diff --git a/tests/test_flask.py b/tests/test_flask.py new file mode 100644 index 0000000..a3dec34 --- /dev/null +++ b/tests/test_flask.py @@ -0,0 +1,34 @@ +import requests +import pandas as pd + +from src.player_stat import get_player_stat + + +def test_api(): + player_ids_to_test = ['2544','1627783','202326','203081','1629014'] + + player_labels = ['PG', 'PF', 'C', 'PG', 'SG'] + + label_encoder_dict = dict([ + ("C",0), + ("PG",1), + ("SG",2), + ("SF",3), + ("PF",4)]) + + player_labels_int = [label_encoder_dict[label] for label in player_labels] + + header = {'Content-Type': 'application/json', + 'Accept': 'application/json'} + + request_url = "http://127.0.0.1:5000/predict" + + for player_id, player_label in zip(player_ids_to_test, player_labels_int): + player_test_data = get_player_stat(player_id).to_json(orient='records') + + r = requests.post(request_url, data=player_test_data, headers=header) + + predicted_label = pd.read_json(r.content).values[0][0] + + print(player_id, predicted_label, player_label) + assert predicted_label == int(player_label)