From d328cc92839e3d8f56ae51735b98938be1bbb647 Mon Sep 17 00:00:00 2001 From: Arihant Bhandari Date: Fri, 17 May 2024 02:28:17 +0530 Subject: [PATCH 1/2] Metabolic Syndrome Prediction | 4. ML-based Feature Importance --- .../metabolic_syndrome_predict.ipynb | 922 +++++++++++++++++- 1 file changed, 906 insertions(+), 16 deletions(-) diff --git a/Metabolic Syndrome Prediction/metabolic_syndrome_predict.ipynb b/Metabolic Syndrome Prediction/metabolic_syndrome_predict.ipynb index 0ffbf113..8bbddf4b 100644 --- a/Metabolic Syndrome Prediction/metabolic_syndrome_predict.ipynb +++ b/Metabolic Syndrome Prediction/metabolic_syndrome_predict.ipynb @@ -2323,7 +2323,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -2345,7 +2345,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -2835,7 +2835,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -3928,7 +3928,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ @@ -3938,7 +3938,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 45, "metadata": {}, "outputs": [ { @@ -4113,7 +4113,7 @@ "[2401 rows x 7 columns]" ] }, - "execution_count": 62, + "execution_count": 45, "metadata": {}, "output_type": "execute_result" } @@ -4154,7 +4154,7 @@ }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 46, "metadata": {}, "outputs": [ { @@ -4210,7 +4210,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 47, "metadata": {}, "outputs": [ { @@ -4282,18 +4282,18 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 50, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "No information: defaultdict(, {1: 47, 3: 48, 2: 27, 7: 10, 4: 29})\n", + "No information: defaultdict(, {3: 38, 1: 47, 4: 28, 2: 25, 7: 7})\n", "\n", - "Majority information: defaultdict(, {5: 100, 6: 100, 10: 100, 11: 100, 12: 100, 0: 4, 9: 1})\n", + "Majority information: defaultdict(, {5: 100, 6: 100, 10: 100, 11: 100, 12: 100, 0: 2, 9: 2})\n", "\n", - "Max information: defaultdict(, {5: 28, 10: 67, 12: 5})\n" + "Max information: defaultdict(, {10: 70, 5: 28, 12: 2})\n" ] } ], @@ -4335,7 +4335,7 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 49, "metadata": {}, "outputs": [ { @@ -4347,7 +4347,7 @@ " dtype='object')" ] }, - "execution_count": 86, + "execution_count": 49, "metadata": {}, "output_type": "execute_result" } @@ -4364,10 +4364,10 @@ "\n", "after a **Hundred iterations** it was found that the following features show no importance with a score of 0:\n", "\n", - "* *'Income'*\n", - "\n", "* *'Sex'*\n", "\n", + "* *'Income'*\n", + "\n", "* *'Race'*\n", "\n", "* *'Marital'*\n", @@ -4408,6 +4408,896 @@ "\n", "* ***'WaistCirc'***" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Metabolic Syndrome Prediction | 4. ML-based Feature Importance\n", + "\n", + "-> XGBoost (eXtreme Gradient Boosting model)\n", + "\n", + "-> Random Forest\n", + "\n", + "-> Decision Tree\n", + "\n", + "-> LGBM (Light Gradient Boosting model)\n", + "\n", + "-> CatBoost (Categorical Boosting model)\n", + "\n", + "-> Extra Trees\n", + "\n", + "-> AdaBoost (Adaptive Boosting)\n", + "\n", + "-> Gradient Boosting model" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "x = df.copy().drop(columns=['MetabolicSyndrome'],axis = 1)\n", + "y = df.copy()['MetabolicSyndrome']" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "x_train: (1680, 13)\n", + "y_train: (1680,)\n", + "x_test: (721, 13)\n", + "y_test: (721,)\n" + ] + } + ], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "\n", + "x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)\n", + "\n", + "print(\"x_train:\", x_train.shape)\n", + "print(\"y_train:\", y_train.shape)\n", + "print(\"x_test:\", x_test.shape)\n", + "print(\"y_test:\", y_test.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We judge features as follows : Features are important if:\n", + "\n", + "Feature Importance > 5% importance\n", + "\n", + "100+ importance count" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. XGBoost (eXtreme Gradient Boosting model)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.9098474341192788\n" + ] + }, + { + "data": { + "text/plain": [ + "array([ 5.6163044, 8.819067 , 1.7450701, 2.8455133, 2.0169516,\n", + " 9.7672415, 9.607102 , 2.2360196, 3.8645415, 2.8161535,\n", + " 21.942804 , 7.282089 , 21.441141 ], dtype=float32)" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from xgboost import XGBClassifier\n", + "from sklearn.metrics import accuracy_score\n", + "\n", + "model_params = {\n", + " 'objective': 'binary:logistic',\n", + " 'n_estimators': 100,\n", + " 'learning_rate': 0.1,\n", + " 'max_depth': 3,\n", + " 'subsample': 0.8,\n", + " 'colsample_bytree': 0.8, \n", + " 'enable_categorical' : True\n", + "}\n", + "\n", + "model = XGBClassifier(**model_params)\n", + "\n", + "model.fit(x_train, y_train) # training model\n", + "\n", + "y_pred = model.predict(x_test) # predicting through model\n", + "y_pred = (y_pred > 0.5).astype(int) # converting y_pred to class labels\n", + "\n", + "# Accuracy\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "print(\"Accuracy:\", accuracy)\n", + "\n", + "model.feature_importances_*100" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", + " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", + " 'Triglycerides'],\n", + " dtype='object')" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_train.columns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Important Features*** based on **XBGClassifier**: based on percentages (descending order)\n", + "\n", + "* **'BloodGlucose'**\n", + "\n", + "* **'Triglycerides'**\n", + "\n", + "* **'WaistCirc'**\n", + "\n", + "* **'BMI'**\n", + "\n", + "* **'Sex'**\n", + "\n", + "* **'HDL'**\n", + "\n", + "* **'Age'**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Random Forest" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.8904299583911235\n" + ] + }, + { + "data": { + "text/plain": [ + "array([ 5.4468663 , 2.11115457, 1.63322985, 2.87164018, 1.57061713,\n", + " 14.18829404, 9.70870992, 0.75828731, 5.55706342, 4.2298375 ,\n", + " 19.41284562, 10.07545424, 22.43599991])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.ensemble import RandomForestClassifier\n", + "\n", + "model = RandomForestClassifier()\n", + "\n", + "model.fit(x_train, y_train)\n", + "\n", + "y_pred = model.predict(x_test)\n", + "y_pred = (y_pred > 0.5).astype(int)\n", + "\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "print(\"Accuracy:\", accuracy)\n", + "\n", + "model.feature_importances_*100" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", + " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", + " 'Triglycerides'],\n", + " dtype='object')" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_train.columns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Important Features*** based on **RandomForestClassifier**: based on percentages (descending order)\n", + "\n", + "* **'Triglycerides'**\n", + "\n", + "* **'BloodGlucose'**\n", + "\n", + "* **'WaistCirc'**\n", + "\n", + "* **'HDL'**\n", + "\n", + "* **'BMI'**\n", + "\n", + "* **'Sex'**\n", + "\n", + "* **'Age'**\n", + "\n", + "* **'UrAlbCr'**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3. Decision Tree" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.855755894590846\n" + ] + }, + { + "data": { + "text/plain": [ + "array([ 3.20396639, 4.09267422, 2.2220431 , 2.3265535 , 0.71003562,\n", + " 16.63651252, 3.62258047, 0.21575584, 5.71524286, 2.52528682,\n", + " 19.51304344, 7.84702446, 31.36928076])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.tree import DecisionTreeClassifier\n", + "\n", + "model = DecisionTreeClassifier()\n", + "\n", + "model.fit(x_train, y_train)\n", + "\n", + "y_pred = model.predict(x_test)\n", + "y_pred = (y_pred > 0.5).astype(int)\n", + "\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "print(\"Accuracy:\", accuracy)\n", + "\n", + "model.feature_importances_*100" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "x_train.columns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Important Features*** based on **DecisionTreeClassifier**: based on percentages (descending order)\n", + "\n", + "* **'Triglycerides'**\n", + "\n", + "* **'BloodGlucose'**\n", + "\n", + "* **'WaistCirc'**\n", + "\n", + "* **'UrAlbCr'**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 4. LGBM (Light Gradient Boosting model)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.8932038834951457\n" + ] + }, + { + "data": { + "text/plain": [ + "array([280, 97, 53, 161, 67, 419, 329, 6, 310, 229, 319, 369, 361])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import lightgbm as lgb\n", + "\n", + "model_params = {\n", + " 'objective': 'binary',\n", + " 'metric': 'binary_error',\n", + " 'num_leaves': 31,\n", + " 'learning_rate': 0.1,\n", + " 'feature_fraction': 0.8,\n", + " 'bagging_fraction': 0.8,\n", + " 'bagging_freq': 5,\n", + " 'verbose': -1\n", + "}\n", + "\n", + "train_data = lgb.Dataset(x_train, label=y_train)\n", + "test_data = lgb.Dataset(x_test, label=y_test, reference=train_data)\n", + "\n", + "num_round = 100\n", + "bst = lgb.train(model_params, train_data, num_round)\n", + "\n", + "y_pred_proba = bst.predict(x_test)\n", + "y_pred = [1 if pred > 0.5 else 0 for pred in y_pred_proba]\n", + "\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "print(\"Accuracy:\", accuracy)\n", + "\n", + "bst.feature_importance()" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", + " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", + " 'Triglycerides'],\n", + " dtype='object')" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_train.columns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Important Features*** based on **LGBM**: based on count (descending order)\n", + "\n", + "* **'WaistCirc'**\n", + "\n", + "* **'HDL'**\n", + "\n", + "* **'Triglycerides'**\n", + "\n", + "* **'BMI'**\n", + "\n", + "* **'BloodGlucose'**\n", + "\n", + "* **'UrAlbCr'**\n", + "\n", + "* **'Age'**\n", + "\n", + "* **'UricAcid'**\n", + "\n", + "* **'Income'**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 5. CatBoost (Categorical Boosting model)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.9029126213592233\n" + ] + }, + { + "data": { + "text/plain": [ + "array([ 4.56710772, 11.62804771, 1.06129061, 1.65206427, 0.7416957 ,\n", + " 15.69751939, 4.08420142, 0.611841 , 2.71786898, 0.71133944,\n", + " 21.06262069, 14.43682955, 21.02757352])" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from catboost import CatBoostClassifier\n", + "\n", + "# Define model parameters\n", + "model_params = {\n", + " 'iterations': 100,\n", + " 'learning_rate': 0.1,\n", + " 'depth': 6,\n", + " 'subsample': 0.8,\n", + " 'colsample_bylevel': 0.8,\n", + " 'eval_metric': 'Accuracy',\n", + "}\n", + "\n", + "# Initialize CatBoostClassifier\n", + "model = CatBoostClassifier(**model_params)\n", + "\n", + "# Train the model\n", + "model.fit(x_train, y_train, eval_set=(x_test, y_test), verbose=False)\n", + "\n", + "# Make predictions\n", + "y_pred = model.predict(x_test)\n", + "y_pred = (y_pred > 0.5).astype(int)\n", + "\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "print(\"Accuracy:\", accuracy)\n", + "\n", + "model.feature_importances_" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", + " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", + " 'Triglycerides'],\n", + " dtype='object')" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_train.columns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Important Features*** based on **CatBoostClassifier**: based on percentages (descending order)\n", + "\n", + "* **'BloodGlucose'**\n", + "\n", + "* **'Triglycerides'**\n", + "\n", + "* **'WaistCirc'**\n", + "\n", + "* **'HDL'**\n", + "\n", + "* **'Sex'**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 6. Extra Trees" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.8613\n" + ] + }, + { + "data": { + "text/plain": [ + "array([ 7.85749598, 2.91794336, 3.65928408, 4.67697385, 3.86039051,\n", + " 14.6587498 , 9.72502302, 2.38920523, 5.60023169, 6.15703292,\n", + " 11.83867671, 11.47766221, 15.18133065])" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.ensemble import ExtraTreesClassifier\n", + "\n", + "model = ExtraTreesClassifier()\n", + "\n", + "model.fit(x_train, y_train)\n", + "\n", + "y_pred = model.predict(x_test)\n", + "y_pred = (y_pred > 0.5).astype(int)\n", + "\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "print(f\"Accuracy: {accuracy:.4f}\")\n", + "\n", + "model.feature_importances_*100" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", + " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", + " 'Triglycerides'],\n", + " dtype='object')" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_train.columns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Important Features*** based on **ExtraTreesClassifier**: based on percentages (descending order)\n", + "\n", + "* **'Triglycerides'**\n", + "\n", + "* **'WaistCirc'**\n", + "\n", + "* **'BloodGlucose'**\n", + "\n", + "* **'HDL'**\n", + "\n", + "* **'BMI'**\n", + "\n", + "* **'Age'**\n", + "\n", + "* **'UricAcid'**\n", + "\n", + "* **'UrAlbCr'**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 7. AdaBoost (Adaptive Boosting)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.8779472954230236\n" + ] + }, + { + "data": { + "text/plain": [ + "array([ 8., 6., 2., 6., 0., 14., 6., 0., 6., 4., 16., 14., 18.])" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.ensemble import AdaBoostClassifier\n", + "\n", + "# Initialize CatBoostClassifier\n", + "model = AdaBoostClassifier()\n", + "\n", + "# Train the model\n", + "model.fit(x_train, y_train)\n", + "\n", + "# Make predictions\n", + "y_pred = model.predict(x_test)\n", + "y_pred = (y_pred > 0.5).astype(int)\n", + "\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "print(\"Accuracy:\", accuracy)\n", + "\n", + "model.feature_importances_*100" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", + " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", + " 'Triglycerides'],\n", + " dtype='object')" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_train.columns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Important Features*** based on **AdaBoostClassifier**: based on percentages (descending order)\n", + "\n", + "* **'Triglycerides'**\n", + "\n", + "* **'BloodGlucose'**\n", + "\n", + "* **'WaistCirc'**\n", + "\n", + "* **'Age'**\n", + "\n", + "* **'BMI'**\n", + "\n", + "* **'Sex'**\n", + "\n", + "* **'Income'**\n", + "\n", + "* **'UrAlbCr'**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 8. Gradient Boosting model" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 0.9070735090152566\n" + ] + }, + { + "data": { + "text/plain": [ + "array([1.93701995e+00, 4.68730697e+00, 3.02995274e-01, 2.28137369e-01,\n", + " 7.02390195e-02, 1.34819874e+01, 6.65235169e+00, 1.36211611e-02,\n", + " 1.79365716e+00, 6.17837269e-01, 2.84970568e+01, 7.88522668e+00,\n", + " 3.38325632e+01])" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from sklearn.ensemble import GradientBoostingClassifier\n", + "\n", + "model = GradientBoostingClassifier()\n", + "\n", + "model.fit(x_train, y_train)\n", + "\n", + "y_pred = model.predict(x_test)\n", + "y_pred = (y_pred > 0.5).astype(int)\n", + "\n", + "accuracy = accuracy_score(y_test, y_pred)\n", + "print(\"Accuracy:\", accuracy)\n", + "\n", + "model.feature_importances_*100" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", + " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", + " 'Triglycerides'],\n", + " dtype='object')" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "x_train.columns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "***Important Features*** based on **GradientBoostingClassifier**: based on percentages (descending order)\n", + "\n", + "* **'Triglycerides'**\n", + "\n", + "* **'BloodGlucose'**\n", + "\n", + "* **'WaistCirc'**\n", + "\n", + "* **'HDL'**\n", + "\n", + "* **'BMI'**" + ] } ], "metadata": { From 8211e5129e91ead051fe025b7e939e1ebd7c5ba2 Mon Sep 17 00:00:00 2001 From: Arihant Bhandari Date: Sat, 18 May 2024 12:49:47 +0530 Subject: [PATCH 2/2] Added plots, added HistGradientBoostingClassifier based permutation test from sklearn --- .../metabolic_syndrome_predict.ipynb | 384 ++++++++++++------ 1 file changed, 271 insertions(+), 113 deletions(-) diff --git a/Metabolic Syndrome Prediction/metabolic_syndrome_predict.ipynb b/Metabolic Syndrome Prediction/metabolic_syndrome_predict.ipynb index 8bbddf4b..625fe13f 100644 --- a/Metabolic Syndrome Prediction/metabolic_syndrome_predict.ipynb +++ b/Metabolic Syndrome Prediction/metabolic_syndrome_predict.ipynb @@ -3928,7 +3928,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 95, "metadata": {}, "outputs": [], "source": [ @@ -4273,6 +4273,72 @@ "Based on XGBClassifier we find: Age, Sex, Marital, Income, Race, WaistCirc as permutationally dominant, affecting the modelling based on what permutation is being used." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Sci-Kit Learn in-built permuation importance with HistGradientBoostingClassifier" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from sklearn.ensemble import HistGradientBoostingClassifier\n", + "from sklearn.inspection import permutation_importance\n", + "import matplotlib.pyplot as plt\n", + "\n", + "model = HistGradientBoostingClassifier(random_state=42)\n", + "\n", + "# fitting the model\n", + "model.fit(x, y)\n", + "\n", + "# performing permutation importance\n", + "perm_importance = permutation_importance(model, x, y, n_repeats=10, random_state=42)\n", + "\n", + "#plotting graph\n", + "plt.figure(figsize=(10, 6))\n", + "plt.barh(y=x.columns, width=perm_importance.importances_mean, align='center')\n", + "plt.xlabel('Permutation Importance')\n", + "plt.ylabel('Feature')\n", + "plt.title('Permutation Importances')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "above diagram shows: MetabolicSyndrome is heavily influenced by:\n", + "\n", + "* **'Triglycerides'**\n", + "\n", + "* **'BloodGlucose'**\n", + "\n", + "* **'HDL'**\n", + "\n", + "* **'Sex'**\n", + "\n", + "* **'waistCirc'**\n", + "\n", + "* **'Age'**" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -4441,7 +4507,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -4451,7 +4517,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 42, "metadata": {}, "outputs": [ { @@ -4503,25 +4569,25 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 75, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Accuracy: 0.9098474341192788\n" + "Accuracy: 0.8793342579750347\n" ] }, { "data": { "text/plain": [ - "array([ 5.6163044, 8.819067 , 1.7450701, 2.8455133, 2.0169516,\n", - " 9.7672415, 9.607102 , 2.2360196, 3.8645415, 2.8161535,\n", - " 21.942804 , 7.282089 , 21.441141 ], dtype=float32)" + "array([ 5.662689 , 10.348651 , 2.7501435, 2.371263 , 1.7858188,\n", + " 15.968141 , 7.2135744, 2.4300709, 3.8307328, 2.6711605,\n", + " 22.15427 , 7.6493278, 15.164155 ], dtype=float32)" ] }, - "execution_count": 11, + "execution_count": 75, "metadata": {}, "output_type": "execute_result" } @@ -4556,32 +4622,45 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 76, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", - " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", - " 'Triglycerides'],\n", - " dtype='object')" + "" ] }, - "execution_count": 12, + "execution_count": 76, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "x_train.columns" + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "plt.figure(figsize=(8,6))\n", + "plt.xticks(rotation=45)\n", + "plt.axhline(y=5, color='r', linestyle='--', label='Importance Threshold')\n", + "sns.barplot(x = x_train.columns,y = model.feature_importances_*100)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "***Important Features*** based on **XBGClassifier**: based on percentages (descending order)\n", + "***Important Features*** based on **XBGClassifier**: based on percentages\n", "\n", "* **'BloodGlucose'**\n", "\n", @@ -4614,25 +4693,25 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 77, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Accuracy: 0.8904299583911235\n" + "Accuracy: 0.8807212205270458\n" ] }, { "data": { "text/plain": [ - "array([ 5.4468663 , 2.11115457, 1.63322985, 2.87164018, 1.57061713,\n", - " 14.18829404, 9.70870992, 0.75828731, 5.55706342, 4.2298375 ,\n", - " 19.41284562, 10.07545424, 22.43599991])" + "array([ 6.16733415, 2.52218168, 1.60994949, 3.09682751, 1.78835544,\n", + " 14.16277997, 9.97322464, 0.63973712, 5.27687781, 4.14553806,\n", + " 21.08880175, 11.16806349, 18.36032888])" ] }, - "execution_count": 18, + "execution_count": 77, "metadata": {}, "output_type": "execute_result" } @@ -4655,32 +4734,42 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 78, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", - " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", - " 'Triglycerides'],\n", - " dtype='object')" + "" ] }, - "execution_count": 19, + "execution_count": 78, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArQAAAI4CAYAAACbTHp5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB10klEQVR4nO3dd1gUV9sG8GdFiijFggKKilhQQbGh2I2oYInYW6Jii4kYldiwlyQkxh57jCUaa+zRGA32164xVrCLRMEKKCj1/v7g25GVElHWZfD+Xddeyc6eXZ9lZ2fvOXPmjAYAhIiIiIhIpfIYugAiIiIionfBQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqpbX0AVkh+TkZLl3755YWFiIRqMxdDlERERE9BoA8uzZM7G3t5c8ebK3TzVXBNp79+6Jg4ODocsgIiIiov9w9+5dKVGiRLa+Zq4ItBYWFiKS8geytLQ0cDVERERE9Lro6GhxcHBQclt2yhWBVjvMwNLSkoGWiIiIKAfTx/BQnhRGRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKqW19AFEBERkfodWP3Q0CWkq/EnNoYugd4D9tASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqmUp0AYGBkqtWrXEwsJCihYtKj4+PhISEqLT5uXLlzJo0CApXLiwFChQQDp06CARERGZvi4AmTBhgtjZ2Um+fPnE09NTrl27lvV3Q0REREQfnCwF2oMHD8qgQYPk+PHjsnfvXklISJDmzZtLTEyM0mbYsGGyY8cO2bhxoxw8eFDu3bsn7du3z/R1p02bJnPnzpVFixbJiRMnJH/+/NKiRQt5+fLl270rIiIiIvpgaADgbZ/88OFDKVq0qBw8eFAaNmwoUVFRYmNjI2vWrJGOHTuKiEhwcLBUrFhRjh07JnXq1EnzGgDE3t5evvrqKxk+fLiIiERFRUmxYsVkxYoV0rVr1/+sIzo6WqysrCQqKkosLS3f9u0QERHRWzqw+qGhS0hX409sDF0C/T995rV3GkMbFRUlIiKFChUSEZEzZ85IQkKCeHp6Km2cnZ2lZMmScuzYsXRf49atWxIeHq7zHCsrK6ldu3aGz4mLi5Po6GidGxERERF9mN460CYnJ8vQoUOlXr164uLiIiIi4eHhYmJiItbW1jptixUrJuHh4em+jnZ5sWLF3vg5gYGBYmVlpdwcHBze9m0QERERkcq9daAdNGiQXLx4UdatW5ed9byRgIAAiYqKUm5379597zUQERERUc7wVoHWz89Pfv/9d9m/f7+UKFFCWW5rayvx8fESGRmp0z4iIkJsbW3TfS3t8tdnQsjsOaampmJpaalzIyIiIqIPU5YCLQDx8/OTLVu2yL59+8TR0VHn8Ro1aoixsbEEBQUpy0JCQiQ0NFQ8PDzSfU1HR0extbXVeU50dLScOHEiw+cQEREREWllKdAOGjRIVq9eLWvWrBELCwsJDw+X8PBwefHihYiknMzVt29f8ff3l/3798uZM2fE19dXPDw8dGY4cHZ2li1btoiIiEajkaFDh8rXX38t27dvlwsXLkjPnj3F3t5efHx8su+dEhEREVGulDcrjRcuXCgiIo0bN9ZZvnz5cundu7eIiMyaNUvy5MkjHTp0kLi4OGnRooUsWLBAp31ISIgyQ4KIyMiRIyUmJkYGDBggkZGRUr9+fdm9e7eYmZm9xVsiIiIiog/JO81Dm1NwHloiIiLD4jy09F9y7Dy0RERERESGxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqpbX0AUQERER0buJmHvE0CWkq9iX9d/Lv8MeWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJStSwH2kOHDkmbNm3E3t5eNBqNbN26VedxjUaT7u2HH37I8DUnTZqUpr2zs3OW3wwRERERfXiyHGhjYmKkatWqMn/+/HQfv3//vs5t2bJlotFopEOHDpm+buXKlXWed+TIkayWRkREREQfoLxZfYK3t7d4e3tn+Litra3O/W3btkmTJk2kTJkymReSN2+a5xIRERER/Re9jqGNiIiQnTt3St++ff+z7bVr18Te3l7KlCkjPXr0kNDQ0AzbxsXFSXR0tM6NiIiIiD5Meg20K1euFAsLC2nfvn2m7WrXri0rVqyQ3bt3y8KFC+XWrVvSoEEDefbsWbrtAwMDxcrKSrk5ODjoo3wiIiIiUgG9Btply5ZJjx49xMzMLNN23t7e0qlTJ6lSpYq0aNFCdu3aJZGRkbJhw4Z02wcEBEhUVJRyu3v3rj7KJyIiIiIVyPIY2jd1+PBhCQkJkfXr12f5udbW1lK+fHm5fv16uo+bmpqKqanpu5ZIRERERLmA3npof/75Z6lRo4ZUrVo1y899/vy53LhxQ+zs7PRQGRERERHlJlkOtM+fP5dz587JuXPnRETk1q1bcu7cOZ2TuKKjo2Xjxo3Sr1+/dF+jadOmMm/ePOX+8OHD5eDBg3L79m05evSotGvXToyMjKRbt25ZLY+IiIiIPjBZHnJw+vRpadKkiXLf399fRER69eolK1asEBGRdevWCYAMA+mNGzfk0aNHyv2wsDDp1q2bPH78WGxsbKR+/fpy/PhxsbGxyWp5RERERPSB0QCAoYt4V9HR0WJlZSVRUVFiaWlp6HKIiIg+OAdWPzR0Celq/MmH0TkWMTdnXpCq2Jf1lf/XZ17T6ywHRERERET6xkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqpblQHvo0CFp06aN2Nvbi0ajka1bt+o83rt3b9FoNDo3Ly+v/3zd+fPnS+nSpcXMzExq164tJ0+ezGppRERERPQBynKgjYmJkapVq8r8+fMzbOPl5SX3799XbmvXrs30NdevXy/+/v4yceJEOXv2rFStWlVatGghDx48yGp5RERERPSByZvVJ3h7e4u3t3embUxNTcXW1vaNX3PmzJnSv39/8fX1FRGRRYsWyc6dO2XZsmUyevTorJZIRERERB8QvYyhPXDggBQtWlQqVKggn3/+uTx+/DjDtvHx8XLmzBnx9PR8VVSePOLp6SnHjh1L9zlxcXESHR2tcyMiIiKiD1O2B1ovLy/55ZdfJCgoSL7//ns5ePCgeHt7S1JSUrrtHz16JElJSVKsWDGd5cWKFZPw8PB0nxMYGChWVlbKzcHBIbvfBhERERGpRJaHHPyXrl27Kv/v6uoqVapUEScnJzlw4IA0bdo0W/6NgIAA8ff3V+5HR0cz1BIRERF9oPQ+bVeZMmWkSJEicv369XQfL1KkiBgZGUlERITO8oiIiAzH4ZqamoqlpaXOjYiIiIg+THoPtGFhYfL48WOxs7NL93ETExOpUaOGBAUFKcuSk5MlKChIPDw89F0eEREREalclgPt8+fP5dy5c3Lu3DkREbl165acO3dOQkND5fnz5zJixAg5fvy43L59W4KCgqRt27ZStmxZadGihfIaTZs2lXnz5in3/f395aeffpKVK1fKlStX5PPPP5eYmBhl1gMiIiIiooxkeQzt6dOnpUmTJsp97VjWXr16ycKFC+X8+fOycuVKiYyMFHt7e2nevLlMnTpVTE1NlefcuHFDHj16pNzv0qWLPHz4UCZMmCDh4eHi5uYmu3fvTnOiGBERERHR6zQAYOgi3lV0dLRYWVlJVFQUx9MSEREZwIHVDw1dQroaf2Jj6BLei4i5RwxdQrqKfVlf+X995jW9j6ElIiIiItInBloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlK1vIYugIjodS23jjF0Cena5fOtoUsgIqJ0sIeWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhULcuB9tChQ9KmTRuxt7cXjUYjW7duVR5LSEiQUaNGiaurq+TPn1/s7e2lZ8+ecu/evUxfc9KkSaLRaHRuzs7OWX4zRERERPThyXKgjYmJkapVq8r8+fPTPBYbGytnz56V8ePHy9mzZ2Xz5s0SEhIiH3/88X++buXKleX+/fvK7ciRI1ktjYiIiIg+QHmz+gRvb2/x9vZO9zErKyvZu3evzrJ58+aJu7u7hIaGSsmSJTMuJG9esbW1zWo5RERERPSB0/sY2qioKNFoNGJtbZ1pu2vXrom9vb2UKVNGevToIaGhoRm2jYuLk+joaJ0bEREREX2Y9BpoX758KaNGjZJu3bqJpaVlhu1q164tK1askN27d8vChQvl1q1b0qBBA3n27Fm67QMDA8XKykq5OTg46OstEBEREVEOp7dAm5CQIJ07dxYAsnDhwkzbent7S6dOnaRKlSrSokUL2bVrl0RGRsqGDRvSbR8QECBRUVHK7e7du/p4C0RERESkAlkeQ/smtGH2zp07sm/fvkx7Z9NjbW0t5cuXl+vXr6f7uKmpqZiammZHqURERESkctneQ6sNs9euXZO//vpLChcunOXXeP78udy4cUPs7OyyuzwiIiIiymWyHGifP38u586dk3PnzomIyK1bt+TcuXMSGhoqCQkJ0rFjRzl9+rT8+uuvkpSUJOHh4RIeHi7x8fHKazRt2lTmzZun3B8+fLgcPHhQbt++LUePHpV27dqJkZGRdOvW7d3fIRERERHlalkecnD69Glp0qSJct/f319ERHr16iWTJk2S7du3i4iIm5ubzvP2798vjRs3FhGRGzduyKNHj5THwsLCpFu3bvL48WOxsbGR+vXry/Hjx8XGxiar5RERERHRBybLgbZx48YCIMPHM3tM6/bt2zr3161bl9UyiIiIiIhE5D3MQ0tEREREpE8MtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqeQ1dABEREZGh3Z9239AlpMtupJ2hS1AF9tASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaplOdAeOnRI2rRpI/b29qLRaGTr1q06jwOQCRMmiJ2dneTLl088PT3l2rVr//m68+fPl9KlS4uZmZnUrl1bTp48mdXSiIiIiOgDlOVAGxMTI1WrVpX58+en+/i0adNk7ty5smjRIjlx4oTkz59fWrRoIS9fvszwNdevXy/+/v4yceJEOXv2rFStWlVatGghDx48yGp5RERERPSByXKg9fb2lq+//lratWuX5jEAMnv2bBk3bpy0bdtWqlSpIr/88ovcu3cvTU9uajNnzpT+/fuLr6+vVKpUSRYtWiTm5uaybNmyrJZHRERERB+YbB1De+vWLQkPDxdPT09lmZWVldSuXVuOHTuW7nPi4+PlzJkzOs/JkyePeHp6ZvicuLg4iY6O1rkRERER0Ycpb3a+WHh4uIiIFCtWTGd5sWLFlMde9+jRI0lKSkr3OcHBwek+JzAwUCZPnpwNFRMRZa9Wm34ydAkZ2tmhv6FLICLSC1XOchAQECBRUVHK7e7du4YuiYiIiIgMJFsDra2trYiIRERE6CyPiIhQHntdkSJFxMjIKEvPMTU1FUtLS50bEREREX2YsjXQOjo6iq2trQQFBSnLoqOj5cSJE+Lh4ZHuc0xMTKRGjRo6z0lOTpagoKAMn0NEREREpJXlMbTPnz+X69evK/dv3bol586dk0KFCknJkiVl6NCh8vXXX0u5cuXE0dFRxo8fL/b29uLj46M8p2nTptKuXTvx8/MTERF/f3/p1auX1KxZU9zd3WX27NkSExMjvr6+7/4OiYiIiChXy3KgPX36tDRp0kS57+/vLyIivXr1khUrVsjIkSMlJiZGBgwYIJGRkVK/fn3ZvXu3mJmZKc+5ceOGPHr0SLnfpUsXefjwoUyYMEHCw8PFzc1Ndu/eneZEMSIiIiKi12U50DZu3FgAZPi4RqORKVOmyJQpUzJsc/v27TTL/Pz8lB5bIiIiIqI3pcpZDoiIiIiItBhoiYiIiEjVGGiJiIiISNUYaImIiIhI1RhoiYiIiEjVGGiJiIiISNUYaImIiIhI1RhoiYiIiEjVGGiJiIiISNUYaImIiIhI1RhoiYiIiEjVGGiJiIiISNUYaImIiIhI1RhoiYiIiEjVGGiJiIiISNUYaImIiIhI1RhoiYiIiEjVGGiJiIiISNUYaImIiIhI1RhoiYiIiEjVGGiJiIiISNUYaImIiIhI1RhoiYiIiEjVGGiJiIiISNUYaImIiIhI1RhoiYiIiEjVGGiJiIiISNUYaImIiIhI1RhoiYiIiEjVGGiJiIiISNUYaImIiIhI1RhoiYiIiEjVGGiJiIiISNUYaImIiIhI1RhoiYiIiEjVGGiJiIiISNUYaImIiIhI1RhoiYiIiEjVGGiJiIiISNUYaImIiIhI1RhoiYiIiEjVsj3Qli5dWjQaTZrboEGD0m2/YsWKNG3NzMyyuywiIiIiyqXyZvcLnjp1SpKSkpT7Fy9elGbNmkmnTp0yfI6lpaWEhIQo9zUaTXaXRURERES5VLYHWhsbG5373333nTg5OUmjRo0yfI5GoxFbW9vsLoWIiIiIPgB6HUMbHx8vq1evlj59+mTa6/r8+XMpVaqUODg4SNu2beXSpUuZvm5cXJxER0fr3IiIiIjow6TXQLt161aJjIyU3r17Z9imQoUKsmzZMtm2bZusXr1akpOTpW7duhIWFpbhcwIDA8XKykq5OTg46KF6IiIiIlIDvQban3/+Wby9vcXe3j7DNh4eHtKzZ09xc3OTRo0ayebNm8XGxkYWL16c4XMCAgIkKipKud29e1cf5RMRERGRCmT7GFqtO3fuyF9//SWbN2/O0vOMjY2lWrVqcv369QzbmJqaiqmp6buWSERERES5gN56aJcvXy5FixaVVq1aZel5SUlJcuHCBbGzs9NTZURERESUm+gl0CYnJ8vy5culV69ekjevbidwz549JSAgQLk/ZcoU2bNnj9y8eVPOnj0rn3zyidy5c0f69eunj9KIiIiIKJfRy5CDv/76S0JDQ6VPnz5pHgsNDZU8eV7l6KdPn0r//v0lPDxcChYsKDVq1JCjR49KpUqV9FEaEREREeUyegm0zZs3FwDpPnbgwAGd+7NmzZJZs2bpowwiIiIi+gDodZYDIiIiIiJ9Y6AlIiIiIlVjoCUiIiIiVWOgJSIiIiJVY6AlIiIiIlVjoCUiIiIiVWOgJSIiIiJVY6AlIiIiIlVjoCUiIiIiVWOgJSIiIiJVY6AlIiIiIlVjoCUiIiIiVWOgJSIiIiJVY6AlIiIiIlVjoCUiIiIiVWOgJSIiIiJVY6AlIiIiIlVjoCUiIiIiVWOgJSIiIiJVY6AlIiIiIlVjoCUiIiIiVctr6AL06eHC1YYuIV02n39i6BKIiIiIcg320BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGq5TV0AURERNmlw6aThi4hXZs6uBu6BKJcjT20RERERKRq2R5oJ02aJBqNRufm7Oyc6XM2btwozs7OYmZmJq6urrJr167sLouIiIiIcim99NBWrlxZ7t+/r9yOHDmSYdujR49Kt27dpG/fvvL333+Lj4+P+Pj4yMWLF/VRGhERERHlMnoZQ5s3b16xtbV9o7Zz5swRLy8vGTFihIiITJ06Vfbu3Svz5s2TRYsWZe0fjokRMTJ6dT/uZcp/8+QRMTZJuzw9mjwiJm/ZNj5OBMigrUbExPTV/djYzNuam7+6/+KFSHJyxnXkz/92bV++FElKyp625uYpdYuIxMWJJCZmT9t8+VI+PxGR+HiRhITsaWtm9mpdyUrbhISU9hkxNRXJmzfrbRMTU/4WGTExETE2znrbpKSUzy4jxsav1uGstE1OTlnXsqNt3rwpfwuRlO9EbKyYvkz/75ZklEcSjfMqbU3jMv7ckvPkkQSTV5u4jF4zS21jYlLWsXz5dJelYvry1WcDjUbiTV9tI0zj4kQy+NqLRiTO1PSt2prExYsmo+2JiMSZpdr25PJthOnLjNe1eBNTwf+3zZuQIEZJGb9ugrGJJP//9z4rbY0SEyVvYjrrpXY9ycXbCE1ivCDvq+99nviMPwvkNX7ztkZ5BcavthF54mKz1jbGPP3GRkYp23dt/fGZvK4mj4jxm7bViBjne6u2Eh8rmtcbaded17PB6zkiLtXfUKMRMXlVb0o+yeR7b5rv7domxGW+PUnd9uXLNNvLbIVsNnHiRJibm8POzg6Ojo7o3r077ty5k2F7BwcHzJo1S2fZhAkTUKVKlQyf8/LlS0RFRSm3u3fvQkQQlfLRprm9rFwVDxasUm7JJibptoMI4so567RNKmCRYdv4ko46bRMLFcmwbYJdcaUdAKBSpQzbolQp3Tdcs2bGbYsU0W3bqFHGbc3Nddu2bJlx29dXjY4dM2/7/Pmrtr16Zd72wYNXbb/4IvO2t269ajt8eOZtL1581XbixMzbnjz5qu20aZm33b//Vdt58zJv+/vvr9ouX5552w0bXrXdsCHztsuXv2r7+++Zt50371Xb/fszbztt2qu2J09m3nbixFdtL17MvO3w4a/a3rqVedsvvnjV9sGDTNvuaeIK7y0B8N4SAJ+1X2Xa9pCHs9LWe0tApm1P1HDSafvC1Djj9o0aQUeRjL/3IU6l0PK3Jcot3KZwhm1vl7DTaXu7hF2GbcNtCuu0DXEqlWHbSMsCSjsAH/Q2YsistWj/2wm0/+0E1nXql2nbEd8tV9qu/NQv07bjJy1Q2i7p+x/bqVy8jbjVbjj2r3qA/ase4ETgoUzb3mn5hdL22MzTmbYNa+qrtD0y/3Kmbe/X76K0PfjTf2x7OnbUXYczafvCuSnufX9PuSUZ58uw7csyHjptE/MXyrBtXImqOm0TCpbIuI5KlXTrzSRHJBayRficw8ot3sE5w7ZJ+a102saVdcuwbbKJmU7bl5XqZPp3C59zWGcbESUCEUFUVBSyW7YPOahdu7asWLFCdu/eLQsXLpRbt25JgwYN5NmzZ+m2Dw8Pl2LFiuksK1asmISHh2f4bwQGBoqVlZVyc3BwyNb3QERERETqoUnZKdGfyMhIKVWqlMycOVP69u2b5nETExNZuXKldOvWTVm2YMECmTx5skRERKT7mnFxcRKX6nBKdHS0ODg4SNS9e2Jpaaksf/jT2pT/yWFDDmw+/4RDDjjkQHWHE9/nkIN2Oyam29TQQw62tJn8n0MO2m9drvx/ThtysLND/1y/jei+8ViGTQ055GCNT82U/8nF24iDGyNz5JCDht1s0m/82pCD8K9vZPy6BhxyYDvs/4dw/seQg4gFR189loOGHBT7sn7K/798KdFPn4qVvb1ERUXp5LXsoPd5aK2traV8+fJy/fr1dB+3tbVNE1wjIiIyHYNramoqpqk25or8+XU3sKZmadtktvxd25qkU1NGzDMY05Oe1D+e2dnWLAvvLSttTU1fBZTsbGtiorsDYYi2xsavfgiys23evK9+uLKzrZGR7nciu9rmyaOfthqNSP78Emf2Bp+HRvNm7f5ftrRN7328tkxnvOrrr/um63oW26YOzf8pl28j4sze7P0lGhtL4ht+P7PSNilvXklK7/uZ3rqTy7YRyJsquOXJI8lmb76NeOO2Gk3W277h+4PJm/8u66utmJin3Y/NqP7Xc4RpJut+VvJJVtoaZ6Gtmdmbr2tvQe/z0D5//lxu3LghdnZ26T7u4eEhQUFBOsv27t0rHh4e+i6NiIiIiHKBbA+0w4cPl4MHD8rt27fl6NGj0q5dOzEyMlKGFPTs2VMCAgKU9kOGDJHdu3fLjBkzJDg4WCZNmiSnT58WPz+/7C6NiIiIiHKhbB9yEBYWJt26dZPHjx+LjY2N1K9fX44fPy42NiljWEJDQyVPnlc5um7durJmzRoZN26cjBkzRsqVKydbt24VFxeX7C6NiIiIiHKhbA+069aty/TxAwcOpFnWqVMn6dSpU3aXQkREREQfAL2PoSUiIiIi0icGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJStbyGLoCIiIhEZm4JN3QJGfJvZ2voEogyxR5aIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJStbyGLoAoJ1qxsrmhS0hX7157DF0CERFRjsMeWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJStWwPtIGBgVKrVi2xsLCQokWLio+Pj4SEhGT6nBUrVohGo9G5mZmZZXdpRERERJQLZXugPXjwoAwaNEiOHz8ue/fulYSEBGnevLnExMRk+jxLS0u5f/++crtz5052l0ZEREREuVC2Xyls9+7dOvdXrFghRYsWlTNnzkjDhg0zfJ5GoxFbW9vsLoeIiIiIcjm9j6GNiooSEZFChQpl2u758+dSqlQpcXBwkLZt28qlS5cybBsXFyfR0dE6NyIiIiL6MGV7D21qycnJMnToUKlXr564uLhk2K5ChQqybNkyqVKlikRFRcn06dOlbt26cunSJSlRokSa9oGBgTJ58mR9lp4jhM3rY+gS0lXCb5mhSyAiIiJS6LWHdtCgQXLx4kVZt25dpu08PDykZ8+e4ubmJo0aNZLNmzeLjY2NLF68ON32AQEBEhUVpdzu3r2rj/KJiIiISAX01kPr5+cnv//+uxw6dCjdXtbMGBsbS7Vq1eT69evpPm5qaiqmpqbZUSYRERERqVy299ACED8/P9myZYvs27dPHB0ds/waSUlJcuHCBbGzs8vu8oiIiIgol8n2HtpBgwbJmjVrZNu2bWJhYSHh4eEiImJlZSX58uUTEZGePXtK8eLFJTAwUEREpkyZInXq1JGyZctKZGSk/PDDD3Lnzh3p169fdpdHRERERLlMtgfahQsXiohI48aNdZYvX75cevfuLSIioaGhkifPq87hp0+fSv/+/SU8PFwKFiwoNWrUkKNHj0qlSpWyuzwiIiIiymWyPdAC+M82Bw4c0Lk/a9YsmTVrVnaXQkREREQfAL3PQ0tEREREpE8MtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkatl+YQUiMryxG70MXUK6vum029AlEBFRLsQeWiIiIiJSNQZaIiIiIlI1BloiIiIiUjWOoSW92b+0laFLSFeTfjsNXQIRERFlI/bQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGq5TV0AURElHO0+W2LoUtI146O7QxdAhHlYOyhJSIiIiJVY6AlIiIiIlVjoCUiIiIiVWOgJSIiIiJVY6AlIiIiIlVjoCUiIiIiVWOgJSIiIiJVY6AlIiIiIlXTW6CdP3++lC5dWszMzKR27dpy8uTJTNtv3LhRnJ2dxczMTFxdXWXXrl36Ko2IiIiIchG9BNr169eLv7+/TJw4Uc6ePStVq1aVFi1ayIMHD9Jtf/ToUenWrZv07dtX/v77b/Hx8REfHx+5ePGiPsojIiIiolxEL4F25syZ0r9/f/H19ZVKlSrJokWLxNzcXJYtW5Zu+zlz5oiXl5eMGDFCKlasKFOnTpXq1avLvHnz9FEeEREREeUi2R5o4+Pj5cyZM+Lp6fnqH8mTRzw9PeXYsWPpPufYsWM67UVEWrRokWF7IiIiIiKtvNn9go8ePZKkpCQpVqyYzvJixYpJcHBwus8JDw9Pt314eHi67ePi4iQuLk65HxUVJSIi0dHROu2evXiR5frfB9PX6szIsxfxeq7k7bz+d85IzIsEPVfydt6k/hcvEt9DJVn3pn/7uFh1158QG/ffjQzgTepPiM2Z2x2RN60/9j1UknVvvu4813Mlb+dN6n8Z++w9VPJ2oqPN/7NNzIucWX90tOkbtXv2MmfWnz86/xu1e/YyRs+VvJ18qdZ97fcAQLb/O9keaN+HwMBAmTx5cprlDg4OBqjmLXw1wNAVvJuRvxq6gnfzpZWhK3hrX3yu3tpFRGb0Vnf9VjLT0CW8EysZYugS3pq61xz11z/W0AW8C5X/5MpEQxfwjkalXfTs2TOxssreb0W2B9oiRYqIkZGRRERE6CyPiIgQW1vbdJ9ja2ubpfYBAQHi7++v3E9OTpYnT55I4cKFRaPRvOM7SCs6OlocHBzk7t27Ymlpme2vr2+s33DUXLsI6zckNdcuwvoNTc31q7l2EdafGQDy7Nkzsbe3z9bXFdFDoDUxMZEaNWpIUFCQ+Pj4iEhK4AwKChI/P790n+Ph4SFBQUEydOhQZdnevXvFw8Mj3fampqZiaqp7CMHa2jo7ys+UpaWlKldOLdZvOGquXYT1G5Kaaxdh/Yam5vrVXLsI689IdvfMaullyIG/v7/06tVLatasKe7u7jJ79myJiYkRX19fERHp2bOnFC9eXAIDA0VEZMiQIdKoUSOZMWOGtGrVStatWyenT5+WJUuW6KM8IiIiIspF9BJou3TpIg8fPpQJEyZIeHi4uLm5ye7du5UTv0JDQyVPnlcTLNStW1fWrFkj48aNkzFjxki5cuVk69at4uLioo/yiIiIiCgX0dtJYX5+fhkOMThw4ECaZZ06dZJOnTrpq5x3YmpqKhMnTkwzzEEtWL/hqLl2EdZvSGquXYT1G5qa61dz7SKs31A00MfcCURERERE74lerhRGRERERPS+MNASERERkaox0BIRERGRqjHQEhEREZGqMdBSrsJzHImI3k1ycrKhS6BcTh/rGAPtB0gb+pKSkgxcSfa7f/++iHCDTESGod2+JiQkGLiSrNu/f78kJCRInjx52DlAepOcnKxci+DKlSsSHR2dLa/LQJtF2i956i+72sKTRqORXbt2yfLly0Uk9/Rqbt26VRwcHOT48eOSJ08e1X0ulPNovxunTp2S33//3aC13L59W86cOcP1+jU5bful0Whk27ZtMnbsWHnx4oWhy3ljBw8elIEDB8qYMWMkMTFRNBpNjvvbkvqlDrMTJkyQPn36yOnTpyUuLu6dX5uBNguSk5NFo9GIiEhUVJTExsYqH47afmQ2bNggO3fuFBH1BfKMODk5Sfv27aV9+/Zy4sQJVX4u2h+Q+/fvS0REhNy8edPAFX24AIhGo5FNmzaJj4+P7N69W65du2awenx9faVly5Zy6tSpDzpoaN97VFSUPH/+XOLj4w1cka7z58/LF198IS4uLmJsbGzoct5YtWrVpH379nLkyBEZM2aMJCQkfBChVvv+YmNj0/QUZtd7V9vvkD5pw+zYsWPlp59+koCAAKlatWq2XMSBgfYNpd6r+OGHH6RDhw7y0UcfScuWLeXff//VuZSvGjg4OEh4eLiIiBgZGRm4muzh6uoqU6ZMkYYNG0qbNm1UF2q1AWrbtm3Srl07adKkiXh7e8ukSZMkMTHR0OUptBv569evy6VLl+T48eMGrkg/NBqNHDlyRHr37i2TJ0+WGTNmSLly5d57Hdq/9759+6RUqVLSu3dvOXHiRK4PGunRfkd+//136datm7i5uYmfn59s2rRJp42hXLx4Ufbu3SsdOnSQnj17Kh0gOV1iYqJYWlpKYGCgeHp6yunTp5XtTm4Otdr1aceOHcr6NGDAAFm8eLGIyDt/fo8fPxYRUdXv0Ptw7tw5WbdunaxevVo+/vhjMTU1lVu3bsmGDRve7fcElCVjxoyBjY0Nli9fjv3796N48eJwc3PD48ePDV3af7pz5w6uXbsGAPjzzz/h7u6Op0+fIikpCQCQnJys/L+aXbp0CV26dIGNjQ2OHz8OAKp5X7t370a+fPmwYMECXLlyBbNmzYJGo8GePXsMXRqAlHUEADZv3gwnJye4ubnB0tISXbp0wf/+9z8DV5f9Jk2ahC5dugB4tQ4lJia+t3//xo0b+P333xEdHQ0g5e/v5uYGZ2dnHDt2TPk8PiTbt29Hvnz58PXXX+OXX35Bt27dUKZMGaxcuVJpo++/S+p14eXLlwCAmJgYuLi4QKPRwNvb+73Vkh20NZ45cwYBAQEoV64crK2tMX78eCQkJOi0yW127NiBfPnyITAwENu2bUOPHj1gYWGBw4cPv9PrPnr0CHXq1MHIkSOVZWr5HdK3kydPomLFijh79iz+97//4csvv0TFihVhb2+PmjVr4s8//3yr12WgzYLbt2+jRo0ayh97x44dsLKywoIFC3Ta5cSV9uLFiyhUqBAKFiyIhg0boly5crCyssLq1atz5Q/j+fPnVRlqv/jiC4wZMwZAyvrm5OSEzz77zMBV6Tp48CAsLS2xdOlSACk7RxqNBr/++quBK3t32u/BnTt3kJiYiIEDB6JBgwZpHgdS1jF9CgsLg0ajgbm5OTZv3oyYmBjlsWrVqqFChQq58rub2oMHD3TuX716FdWqVcOiRYsAAJGRkbC1tYWrqyucnJx0Qq2+aLcjV69ehb+/P5o0aYITJ04ASPnO1q9fH6VKlcL27duVzyanfUbp1bNjxw7kzZsXU6ZMwezZs+Hp6YnKlStj1KhRuTLUJicnIyoqCq1bt8a0adMAvFqfhgwZ8s6vf//+fQwfPhyurq6YPHmysjyz36Hc9PfVSu/9PnnyBKVKlYKrqytMTEzw+eefY8uWLbh8+TLKly+PVatWvdW/xUCbBWfPnkWxYsUAADt37kSBAgWUDeuzZ88wb96899p7k1UnTpzA0aNHMW/ePAwfPhwajQYlS5ZEmTJlUKZMGZQqVQpjx45FXFycoUt9Y6kDyK1bt3DlyhXlsfRCbU7+fOLj41G9enUsWrQIUVFRKF68OAYMGKC8xwULFmDfvn0GrhL4+uuv8emnnwJI+VEvV64c+vXrpzyu/fFTq40bN8LNzQ3//PMPJk2ahEqVKuHq1as6RzKeP38OX19fvfaca3v8ChQoAGtra6xduxaxsbHK47k91M6aNQvVq1fX2R49ePAAgwcPxv3793H37l2UK1cOn3/+OS5evAh3d3cUL15c2Sbrg3YdOH/+PEqWLIlhw4Zh1qxZePHihc62qFq1avD09NT5vuakz+jevXvK/2vXZ29vb/j7+yvLY2JiMHz4cDg7O2PChAm5MtTGxcWhVq1aOHjwIEJDQ1G8eHH0799feXz79u04e/bsW79+WFgYJk6cCGdnZ51Qm/p3KCEhIUds1/UhdZjdt28fNm/ejO3btwNIyUy//vorgoKCEB8fr7SrXbs2li9f/lb/HgNtBtL70sbExKB58+b46quvUKBAASxZskR57OLFi2jevDkOHTr0PsvMkLb+yMhIPHz4MN02Xl5eGD16NO7evYtNmzbhhx9+wKVLl95nme9E+x63bt0KNzc3ODo6onLlyhg/frzS5sKFC+jSpQvs7e1x5MgRQ5X6xqZOnYoePXrAzs4OAwcOVDYIL168QO/evTF16lSDBsbk5GR0794dY8aMQXJycprQvWzZMqxfv95g9b0tbf1RUVFo3rw55syZAwCIjo5GyZIl0axZM1y+fBkJCQmIj4/HuHHjUKZMGdy+fVsv9Wh/8KZOnYqxY8fC398fxsbG6YZaFxcXHDp0KFcFDSClFyckJAQAdHqno6KiAABffvklOnfurNwfMGAASpYsCQ8PDzx58kRvf4+bN2/C3t4ew4cP11melJSkfG43b96Em5sbmjVrhv379+uljre1ePFiNG7cGC9fvtQJHJ6enjphDkjZ7jRs2BBFixbFl19+qfqd1dfXiSdPnqBJkyYIDAyEk5MT+vXrp/xN/v33X3z66adYv379W61L2tcJDQ3FxIkTUaFCBUyaNEnn8bi4OAwaNAhOTk6IiIh4h3eWs40aNQoODg6oX78+bG1t0aJFC52sFBMTg/DwcHh5eaF69epv3fHEQJuO1F/ywMBAnT2KTz75BKamphg8eLDSJjY2Fi1btkSrVq1yxGFt7Zdv+/btqFu3LpydnVG7dm0sXLhQ+dIkJyfD09MTX375pSFLfWc7d+5E/vz58eOPP+LChQuYMWMGNBqNzo/NxYsX4e3tjXLlyun0pBiStoYnT57gyZMnyvL169ejZMmSqFWrFm7evAkgped2zJgxKFWqFK5fv26QOsPCwvDs2TMAwKpVq+Dk5IRChQrBz89PZ53v06cPPvvsM2VcYU524cIFnZ6BvXv34uOPP0abNm2UseZAyjjWMmXKoHLlynB1dUWLFi1QuHDhd+q5eVN//fUXrK2tcfHiRUycOBGmpqZpQq2joyNq1aqFFy9e6L2e9yX1d/TkyZNwdHTE5cuXdR5v0qQJBg4cqCz74osvMHv2bL2dz6BdzydPnoxWrVohMjIy3XbaH+Nbt26hZs2aqFWrVo7p6ABS1qkbN24AgPKdfvnyJfr164dmzZohIiJC5zs9adIklC1bFj4+PqoOXdp1KigoCGPHjlW++4sWLYJGo4Gnp6dO+zFjxqBChQpvvNN6584dzJgxAy1atED9+vXRvXt3ZTty//59pac2dagdNGgQTE1NcebMmex4izlG6u/v4sWLYWdnh5MnTwIAZsyYAWNjY+zdu1dpO2PGDNSoUQP16tVTPpe3CbUMtK9J/UW+evUqPD09YWJigqCgIAApe1seHh6oXbs2+vfvj2+++QYNGzaEq6ur8kHkhFD7xx9/wNzcHIGBgbh58ya6deuGQoUKYc+ePcrKFhgYCC8vLwNX+vbCw8PRpk0bzJw5E0DKYbTSpUujSZMmMDU11RkHdfnyZYSFhRmo0vRt2bIFlSpVgpubGzp37qyEwDlz5sDR0RGNGjVC586d0a5du/cWoFJL3QPeuHFjzJkzB3Fxcbhy5Qrat2+PMmXKKL3e0dHRGDNmDOzs7BAcHPxe63wbK1asQIkSJZTePQA4cuQILC0tkSdPnjTjrp8/f44lS5YgICAAs2fP1gm82eXatWvYsWMHrl69qrN88ODB+OKLLwAAfn5+MDMzw9q1a3UCrHbnJ7fQrnuXLl3CvXv3UL16dbi4uCjrVlJSEvz9/VG7dm3MnDkTw4YNQ7FixfTWY55aixYt8Mknn2Rat/azuXr1Kho0aIA7d+7ova6sOnXqFGrWrKlsV65cuYICBQqgV69euH//vtJuyJAh+OabbzI80qcG2s/lt99+Q+HChTF48GAlRCYlJWH06NFKR8jIkSPRr18/WFpa4u+//36j179w4QIqV66M1q1b45NPPkHnzp1RsmRJWFtbY8uWLQBSeny1oXbixIkYPnw48uXL99636/p06tQpJYhqt51+fn5KB9OGDRt0zjt68eIFYmJiEBERgYULFyrPfdsjAQy0GRg9ejQ8PDzQunVrFCxYEKampvj9998BpOx5jxs3DvXr14ePjw+GDBmifACGOiSTOkS/ePECHTt2REBAAADg8ePHcHR0xOeff67znOnTp6NkyZI5fsxs6vem/f/Y2FjEx8dj+vTpuHnzJsLDw1G5cmV89tlniI2NxVdffQWNRqPTg5OTnD9/HnZ2dpg0aRJmzJiBMmXKoEaNGvj3338BpITdSZMmwcfHB1OnTjVYSNyxYwdMTU0xd+5cnRC3c+dOtGzZEoUKFULdunXRoEED2Nvbq2rjrA2BERERys7EyZMnUaRIEbRt21bpgXsf4661J4AZGRnBw8MDY8eOxY0bN5CUlITdu3ejRo0aSj2DBg2ChYUFVqxYkat6ZV+3fft2lC5dGidOnMDjx49Rp04dODs7K9+FY8eO4dNPP0XZsmVRvXr197bu1a1bF127dlXup3fEp0uXLjh27BiAnDumfM+ePWjYsCHq1q2r/O0OHz4MCwsLNG7cGJ07d0b37t2RL18+vezAvW/Hjx+HtbU1fvrpJ53l2s/n559/RtOmTdGoUSMMGDAAFy9efKPXPXfuHAoUKICRI0fq9GCfO3cOrVu3hpWVldJDHxoaiilTpsDS0hJGRka5qmd23LhxcHJywo4dO3RmAWnbti1+/vlnnD59GgUKFMDChQuVx2bPno01a9bovM67bG8ZaNPxyy+/wNzcHMeOHUN0dDTOnz+PXr16wdjYWAm1SUlJaTZkhjrh6NatW1i8eDFOnTqlLGvWrBkOHTqER48ewc7ODgMGDFAe27RpEy5evIi7d++qpmfn1q1b2LlzJ4CUvbxhw4YhOTlZ+UGfOXMmPD09lQ3KrFmzUKVKFZQoUULnBAhDSU5O1llfrl27hokTJyr3w8LCULlyZVSrVk0JtYb25MkTeHp64ptvvkn38atXr2Lt2rUYPnw4li1bluPXJe1GNvUO0unTp2FhYYHffvtN2bH73//+BysrK3Tt2lWZLgt4FVz0NWSlTp06yJs3L8aOHQtXV1e0adMG3bt3R3h4OKpUqYKvvvpKadunTx/Y2trq1JcbaP+29+/fR8eOHTF//nzlsSdPnqBOnTooX768Mrb22bNnaYbt6Lu2QYMGoXTp0jrTOqVepx48eIAWLVooj+eEIU7AqzpCQkKUbUxQUBBatmwJd3d3nDt3DsCr2Rs6dOiAbt266X02j/dl3rx5aNmyJYCUdWnz5s1o164d3Nzc8MsvvwB4NQQj9VCkzFy+fBnGxsYIDAxM9/Hr16+jQYMGKFOmDJ4+fQogZVv/3XffKetwbvH48WM0atQIdevWxfbt25U8NGvWLJibmyNv3rw64TU6OhpNmzbVOVnuXTHQpmPy5Mlo0aKFzjLtBtbMzEwZ5J8ThhacP38e5cuXR7t27ZTAB6Sc8NW2bVs4OTnh888/V76gUVFR8PHxwcKFC3PMhva/PHv2DF988QUcHByUQ0MrVqzQadOnTx80atRIuT98+HDMmDFD52QSQ9L+rffv34/AwEC0bNkSffv21dkJCgsLQ6VKlVC7dm3cunXLQJW+8vTpUzg6OirTc70u9TjOnE77XQ0LC8P27dt1emnatGkDGxsbbNu2TempPXLkCKysrPDJJ5/oDEvIbsnJyTpHSGrXrg13d3f8+eef2L17N7p27YqqVavC3t4e1apV0znsGx4erre6DOnQoUPo3LkzGjVqhAsXLgB41Vmg7amtVKnSez2BNfW28vjx4zA1NcXHH3+c7iHpCRMmwN3dPUd9Pqnnjy5TpgzmzJmDR48eAUiZdk8barU9tdrfi5x+9O6/pP7cfv31V2g0GixatAienp5o1aoVevbsib59+8LExAShoaHpPi+z1w4ICIBGo1F2Bl7v1EpMTMSqVauQP39+nXm6c/JsO28j9VzMDRs2RJMmTbBlyxYkJibiwYMH6N69O4oXL46///4bcXFxuHPnDry8vFCzZs1sPYLxwQfa9Hptpk+fjiJFiiiH+LQr98aNG6HRaGBqaooDBw7oPGYIV65cQcGCBTF69Og0vXr79u1DuXLlUKFCBZ3lY8eOhZOTk3JSQE6Wek7Jq1evomHDhtBoNBg2bBgA3QtBbNmyBSYmJujRowe6du0Ka2trnSm8coLdu3dDo9GgQYMGsLW1hZ2dHQ4fPqyzcfv3339hZ2eHjz76yOCzGdy9exfly5dXxjulruf8+fOYOXNmjtlhyIx2Hblw4QKqVauGrl27omPHjkpvDAB07twZ1tbWOqH26NGj0Gg06Nu3r16+5yEhIfDz80O7du3w7bffKsurV6+OihUrKoesDx06hK+//hqrV68GkHN6/PTl8OHDsLW1hUajwdq1a5Xl2s/xyZMncHZ2hru7+xv3pL2N+Ph45W/99OlTJCQkKOv7mjVrYGRkhCZNmmDZsmWIi4tDUFAQBg8eDCsrK/zzzz96q+tt7dmzB+bm5pg/f36ao1baUJt6+AGg3nVNW3fqbevLly/x1VdfoWTJkujfv78SMKOiouDm5palnuhbt24hMjISMTEx6NGjB/Lnz6+cT6D9t7Xr67Nnz6DRaLBhw4ZseW85TerstHfvXkydOhUmJiaoXr06/vjjDwAp21IfHx8YGxujXLlycHNzg4eHxzudAJaeDzrQrl27Fr6+vggJCcHz58+V5WfOnEHNmjXx1Vdf6exlHzt2DJ999hk+++wzlClTBnfv3jVE2QBSxsl26tQJgwYN0lkeHx+P+/fv4/jx4/juu+/g4uKCjz76CEOGDEG3bt1gbW2tinGOZ8+eRYUKFZTD2M+fP0fTpk1Ru3ZtuLq6YuvWrUrb5ORkREZGYunSpWjUqBHatWuXY35QtBu38PBwDBgwAEuXLkV8fDweP36MKlWqwNXVFSdPntT54bh37957n80gI35+frCyskrTEzVq1KhMz/TOKbR/18uXL8Pa2hpjxozROQs+dSBKHWq1PVPHjx/Xy/jlc+fOwcbGBj4+PujatSuMjY11Qq27uztKliyJo0ePZvu/nVOFhIQovYZnzpxB2bJl4eXlpZygB7z68Xz69KnejmJs3LhRZ73eunUratasiZo1a6JBgwY4ePAggJQdVCcnJ5iYmMDY2BilS5dG/fr1c8y2Rys5ORmJiYno1q1bmvMoUu+kBgUFoW7dumjatKmqe2a13/m9e/fi888/R9euXXVOanu953z06NGoVKnSG5/0Fh8fj8aNG8Pe3h5Pnz7Fy5cv0a1bN51e2NQdZbt27UKlSpXeywmLhhQQEAAbGxvMnDkTkyZNQpkyZVClShXs3r0bQMrfbdeuXVi1ahX+/PPPdz4BLD0fbKCNioqCk5MTbGxs4Orqir59++pM5jtz5ky4u7ujT58++OeffxAcHIxWrVqhT58+OHDgAIoVK4a//vrLYPUnJCSgQYMG+PHHH5Vlu3fvxtChQ1GgQAFlPOaff/6J7t27o02bNhgyZEiO67XMSGxsrDLmSBum4uPjce7cOfTq1QuVKlXSCbUAlJ2SnHaizIkTJ1CvXj3UqFFD+TEEUt6Pi4sLXFxccOrUKYMNYdH+AJw6dQpLly7FokWLlN6Kly9f4uOPP0b+/Pnx/fff44cffsDnn38OCwsL5TBbTvfs2TO0bt06zQmC2vedeoPauXNn2NjYYMOGDXr7Uf/nn3+QL18+5YpwSUlJ8PPzw9ChQ3WGNzRu3BilSpXC//73vxwxvEmfrl27hpo1a2Lw4MHKDsf//vc/ODk5oVOnTsqUP4B+h3qdP38eFSpUQKtWrRAfH4+rV6/CxMQEEydORGBgILp06QJjY2MsXrwYQMpUTWfPnsW6detw5cqVHHsJ9MTERNSoUQNff/21cj817awG+/fv1zn0rlZbtmyBmZkZBgwYAC8vL9SqVQsODg7KTlBycjKCgoLQv39/FCpU6I1nM9C6cOECatasCRcXFzx58gQvXrxQQq22p1a7ng4bNgxt2rRRfs9yg9ev4Hft2jU4ODgoMzoAKUdSatSogYoVK2LXrl3pBtfsHnrxwQbaxMREBAQEYNGiRThz5gx++OEHWFtbo0uXLpgzZw4SExMxY8YMtG7dGhqNBmXLloWrqyuAlD28cuXK6YST9y0qKgrOzs7o378/goOD8e2336JChQro0KEDZs+ejaVLl8LZ2Rnjxo1TnqOWw0epf7Du3buHEiVK4OOPP1aWHT9+HL169YKLi4vyBZoyZQqGDx+u10OQbysqKgoNGjSARqPBzJkzdT6H+Ph4VKtWDcWLFzdIz7m2lk2bNqFgwYLw9PRE6dKl0axZM50rLo0aNQoeHh6oUqUK2rRpk+N6oTLz+PFjlC1bFmvXrk33O/D6subNm6N06dI6QxKyS2hoKIoUKYJOnTrpLO/SpQvc3Nzg7OyMpk2bKnNfN2rUCAULFtTppcyNkpOTMXz4cNSrVw8jRoxQemqPHDkCJycndO3a9b30Vr98+RLLli1D3bp14ePjg/nz52Ps2LE6bcaPHw8jI6Mc13ueXtBPvaxly5b46KOPlPupLwIxbdo0Vc8xm9rDhw9RrVo1fP/998qyS5cuwdvbG6VLl8aDBw/w5MkTzJgxA61atVLGab+J1MMJrly5Ag8PD9SsWRNPnz5VQq25ubkSaseNG4ciRYqo6oJF/6VXr16YMWOGzrLQ0FCULl0au3btAvBqTO2jR49gY2ODJk2aYO3atXrfMf9gAy0A7Nq1CxYWFsqP84sXLzB+/HhoNBrUq1cP06ZNw7Fjx3Dq1Cn8/fffyofx1VdfwcXFRWeuPkMICgpC3rx5UapUKVhYWGDRokXK9Crx8fFo3ry5znyJagm02jqPHDmCPXv2YOXKlShTpgw6d+6stDl+/LgyV6CnpyeMjY1x+vRpQ5X8n549e4aPPvoI1atXx7Zt23T2TOPj41G3bl2DjWs+ePAgbG1tlSvfHT9+HPnz54erq6vOhuvhw4fKvIFqcurUKWg0GuVHJb2N6osXL3TOqNfXnMW3bt1CrVq18PHHHys/eoGBgTA3N8fUqVOxdOlSVKxYEaVLl1bmLm3atGmumDYptfRmjEhOTsa4cePg7u6OESNGKL2dR48eRcGCBdG7d2+9HX2ZPn06fv31VwApJ0ItX74cjRo1QpEiRZT5rFPvLLdr1w7e3t45bkquS5cuYfny5TpzGWvX9zVr1sDV1RUjRozQec7o0aPh4uKSawLtrVu3YGtrq4QrICW8nz9/HjVr1sS8efMApPQyvukJn6nXu9TrgXZ6yGrVquHJkyfK8IOCBQuia9euMDc3z1VTcwFQhs0BUGZZ0Z5APHToUKVdQkICEhISUK9ePZiZmSlzaevTBx1ogZSry6T+Q1eqVAk+Pj4YNmwYmjdvrnNG/cGDB/H555+jYMGCWT5EoS+hoaE4ffp0mvE/SUlJ6NSpk9JDq4Ywm7rGv/76CxqNBnv27EFkZCTWrl0LBwcHnVAbHByMlStXYtiwYTlmMn/te7hw4QI2b96Mv/76SwlSkZGRaNiwIWrXrp0m1BpKUlISpk6dqoytu3nzJsqUKYMuXbqga9euKF26tPIDoCap16WwsDBYWVlh0qRJGQaiP/74Ax4eHu9l8virV6/Cy8sLH3/8Mfr164eiRYvizz//VB6/c+cONBqNznCi3OjYsWOYOXOmzmeiDbUuLi4ICAhQDtMeP35cb6E+MjISPXv2RL58+bBp0yYAKT1My5cvh4uLCypUqKD8cGt/yEeNGoUmTZropZ63kZycjGfPnsHe3h6FCxfGgAED0LlzZ9y+fVsZD/z06VNMnDgRVapUQd26dTFkyBC0b98+3THyaqL9rmt7BZOSkuDu7o7Ro0en+d3z8PDAZ599lqXXDwsLQ6dOnbBv3z6d5d9//z0KFy6MpUuXokaNGsrwg7i4OHTu3BlmZma5Ksy+/rdctGgRBg4cqAzjWLduHYyNjXV6xhMTE+Hr65vm5Gd9+eAD7dKlS1GvXj08efIE1apVQ7169ZS9trCwMKxdu1bZCz9x4gT8/Px0LsGYE8XFxWHcuHGwt7dPc9UhNQgLC8PixYt1TpKJjY1NN9TmRL/99huKFi2KihUrwsHBASVLllTOUNeG2nr16mHDhg3vPdSGhoZi6dKlWLJkiTJP5r///ouzZ88iJiYGHh4e8PX1BfBqFo1SpUphzpw577XOt5Fez6v25LqWLVuiZMmSOHToULp/84CAAPTs2fO9XbI3JCQEzZo1Q758+TB9+nQAKT8Y8fHxCAsLQ9WqVbFx40ZleW6TnJwMX19fVK5cGXPmzEmzo9GxY0fY2dnhiy++UIYf6NPNmzcxePBgWFpa4rfffgOQsh1dvXq1crnj1ENQ+vbtC09PT8TGxuaoz2fkyJFo0KABDhw4gLZt26JWrVro1KmTcmJOUlIS/vrrL3Tt2hXNmzdH//79VX04PPUJYN9++60SzIcOHYo6deqkmVmgQ4cOGDNmTJp5wTNz48YNeHh4oGXLljpHVQoVKqRcvvXy5cuoVq0a3Nzc8PjxYzx//jxHTduWHVL/vRISEjB79mxUrlwZI0eOVGZZ+uGHH2BkZAQfHx/4+fmhQYMGqFSpks6FFvTpgw+0AFCrVi1oNBo0atQow0H92lCb08/+XLVqFb788ksUK1ZMFbMZvE7bO2VpaYnvvvtO57HY2FisW7cOZcqUgbe3t4EqzNzff/8Na2trLFq0CJGRkTh79iyGDx+OPHnyKIc0tdPEeHp66mWcZkb++ecflCpVCu7u7ihcuDCcnJyUH28g5SQcFxcX5cTBf/75B82aNYO/v3+OvHRneq5du4Y+ffoASNmxKFu2LEJDQxEaGory5cujcuXK2LlzpxJcHzx4gJEjR8LW1va976hev34dzZs3h7e3t3IlISBljKajo2OuODknMzExMejXrx/c3d0xc+ZMnXmNZ82aBScnJ7Rt21avwSD1j/StW7cwaNCgNKF2xYoVqFy5MsqUKYOePXtiyJAhMDc3z1EnRWoDw+HDh9GxY0dlWq6//voL3377LTQaDbp165bmaEtuONlw06ZNMDc3x6RJk5Sre0VHR6N169Zwd3fH4MGDsWbNGuWzfZsTo7VHVdq2bYv+/fvDxsZG56gKkNIBULp0adStWzdX/F1TS/098fX1Rf369QGkBHs3NzcMHz5c+Z7u378fbdq0gY+PDz799FPlqMb7+Jt80IFW+yGtWrUKLi4uyhjMnLTHnRXBwcFo3Lgx2rVrl+N7kTOzaNEimJiYwNfXN83k/bGxsVi5ciVcXFz0Ns7xXaxfvx7u7u46PU5Pnz7FsGHDUL58eeWw6bNnz97rNC7//PMPzM3NMXr0aMTExGDv3r0oXrw4WrVqpYyJPXz4MEqUKKEE7/Hjx6NHjx6qOjs3KCgIRkZGaNSoETQajXIFICDlsrYuLi4wNzdXdijq16+PkiVLGmznT/tD2aJFC5w9exbff/89zMzMVLkzmhntNvXmzZu4ffu2Ml48JiYGvr6+qF27ts6FUEaPHo158+alOZs6O7z+w5p6TGRGoXb16tWoUaMGChQogF9++SXH7uC9ePECNWvWRO/evZVlvr6+KFq0KAYNGoTixYujVKlSmDVrVrpXu1SbixcvwsHBId2Lv0RHRyMgIAD16tVDuXLl0KhRo3caWpHeURVAd30KCQnJ8VdMfBdXr15Fs2bNdGZ40obar776StkJf31s+fsaa/5BB1qtsLAw2NnZZXj5OjWJiIjI8XODvomFCxdCo9HojMfRevHiRY695Of69euRP39+5Qc79Qlutra2BjlbPaMz62vVqoXy5csr60t0dDR8fHxQvnx5lCtXLkeNFc+KsWPHQqPRoE6dOmkei4uLw9SpU+Hr64vOnTtj3rx5Br8q29WrV9G6dWsULVo0x5/c+C5+++03FC9eHI6OjnB1dcW6desApITa/v37w93dHdWqVUPnzp1hbm6ulzGz2u/jrVu3sHnz5nTb3Lx5M91Qu3DhQrRu3dqg84+/iSNHjqBevXq4ceMGevfuDTs7O6VXMjw8HP379881Jxnu3r0bzs7O/3mVr4iICJ255t9W6qMqGV36OLdatmwZGjRogLZt2+Lly5c6R6sDAwNRrVo1jBgxIk2gf587TQy0/2/u3LkoXLiwqscTqU3qE6iCgoJ05rADgB9//BEajQbTpk3LkT0J2prOnz+P48ePK/NW1qxZExMmTNCZBePevXtwdnY2yNzF6Z1Zrz0M6e7ujjZt2qBXr15Ys2YN9u/fjxUrVmDp0qWqGn+dev1YsWIF/P3904T49zU+9m0EBwfj448/Vg6Z5hbaz+XevXsoXrw4lixZgvXr1+PLL79Enjx5lBNuY2NjsWLFCgwYMAC+vr56/TtERkbCzs4OlpaWqFOnDtasWZPmpNJr166lG2pzUmdB6ouGpJ5G786dO/joo49QqlQplC1bFqdOndJpn5ssXLgQRYsWVe6n7gnUzk6U3VIfVdFuT3O72NhYTJgwAU5OTnBxcVGWp96mfvfddyhevLhBTyJmoP1/169fR8+ePT+IPa2cIPW1xUuUKAFXV1dYW1ujefPmOH/+vPI5/PjjjzA1NcXkyZMNWW4aqedvtbOzw3fffacMIZg4cSIqV66MMWPG4NKlS3j06BFGjRqFkiVLprlE8fvy+pn1NjY22LhxI+7cuYMtW7Zg6tSpsLGxgZOTE9q3b2+QGt9W6l7w9evXK+Pg//zzTxQuXDhNz3ROmz9UKyfOoZwdgoKCMHv2bJ3poh49eoTRo0frzCKT3oUu9OHx48fo0qUL1q5di9mzZ6NTp06wt7fHnDlzdNaN0NBQ+Pn5QaPRpLmIi6Gl3v6ULFkS06dP1xnC9PPPPyNPnjz4/fffDVWi3gQHBys726GhoShUqBCGDx+u0yY5ORl+fn6YPXu2XtYn7VGVOnXqKJeozk3Sy0ERERGYPn06LC0tda44l7qn9pdffjHo7D0MtKmkd/1nyh7pfUH27t2LggULKuOfzp49C41Gg48++ghnzpxRPo9p06ahUKFCOe4qPPv370eBAgWUE8BSmzx5MurUqQMjIyNUq1YNdnZ2Bh8XqR0DZmZmhh9++CHN448ePcKGDRtU2TO7adMmWFpaYsqUKcrh1MTEROzZsweFChVCx44d8e+//2LcuHFwdXXVy9hMShn72rdvX+V+TEwM+vbtC41Gg2bNmum01YZaY2Nj/PTTT++1zu+//x5ly5ZV5lXetGkTWrZsiVKlSuGzzz7D+fPnER8fj6dPn+Krr77KMdMCphYUFIT8+fNjwYIFabaN9+/fh5eXl3JibW7onU1OTkZoaCjKli2LgQMHKtupadOmwdHREUOGDMHz589x5coVjBs3DoUKFdLrlTGvXLmCjh075tjx1G8r9W/1qVOnEBQUpHPlyGnTpqFixYrw9/dX2r1+9MtQGYqBlvRO+wW5desWtm3bBiBlr27o0KGYOHEigFfzn/bu3RtlypRBnTp1cPr0aeW5T548MUjt6dH+OAwePBjdu3fXeSz13uq9e/ewa9cu7N27N8eMu8toDJjaegdT/0Dv378fVlZWWLZsmc6GVNszs3//fhQpUgRly5aFra1trh2jmhP8+eefaa4id+HCBQwaNAh58uRJc2b448ePMXjwYFhbWyMqKkrvwSv19ePbtm2rczGNli1bonz58nB1dUWNGjVQtWpVnQvqGFLqmR60f6O+ffsqM3popa51+PDhKF68uOq+2/9lzpw5qFy5MoYMGYKwsDA8f/4cixYtQrFixWBjY4OyZcuibNmy76UDIafPepRVqb9/AQEBcHR0hIuLC2xtbdG7d28EBwcjMjIS3333HVxcXNL0jBsaAy29F//++y+KFCmCihUrKmfR79mzB5cuXcLTp09Rq1Yt9OvXDwCwb98+aDQa1KhRI0dNjaOl/dK3bNkS/fv3B5B2jzQ4ODjH/pCoeQzYqFGj0vxQjRs3Dj4+PgBSegQPHjyI3r17o0+fPtixYweAlOC0c+fOHDkzRm60Z88edO3aVbl/9epV9O7dG1ZWVmlC7ZMnT/R+lSrtd1Y7rj0xMRFDhw5VLqndu3dvFCtWTJm3eO3atejSpUuOmC1m4sSJ8PPzS9ML1qRJEwwbNgxA2u3P/fv3cfPmTVSuXFm1078lJiYqn9vr29KFCxeifPnySqgFUtajLVu24H//+5/BhnblFnPmzIGtra3S6eHv748CBQrg4MGDAFK2pz/88AOKFCmCuXPnGrJUHQy09F7s378fefLkUU5OWrt2rfLY5s2bUbNmTeVQ8a5du/Dxxx+jWrVqBrsc7JsYOHAgnJyclKnFtL0jDx48wMSJE3P0DAFqHAP27Nkz9OzZU6cHMCkpSZmaZ82aNejUqRNatmyJunXrokuXLnBxcTH4LAYfop07dyJPnjz49NNPlWXBwcHo06cPChYsqExI/z5t3LgRtra2Smh98uQJHB0dUapUKdja2qbZUcopQ8927typnCSX+kz9zp07o3r16sp9bb3379/H1KlT8ffff+eok9je1Oufw4EDB/Dtt9+mudT8ggULYGdnBz8/P1UNk1KD7t2745tvvgGQ8vtsZWWFhQsXAoByMZFHjx5h9erVOeZ7AjDQ0nvUp08fuLm5oUOHDmjSpIkyR+jChQtRvHhxZU97zJgxmDBhQo75omh7Cf7991+EhoYqc8xeuHABLi4uaNWqlc58uWPGjIGTk1OO7yVQ4xgw7TqxZ88enDx5EgBw+vRp1K9fH6VLl8ann36KP/74AwCwfft2uLu757ix1x+C+Ph4/PHHH7CystIZlhMcHIz+/ftDo9Fg//79evm3Ux921/bsaS9fumjRIp02AQEBKFmypM4wlJw03jT1ewkKCoKvr6+yo3z06FGULVsWPXr00HnO6NGjUb58eb33euvDjh074OzsjAULFijLAgICYG1tjWnTpqW5yMbYsWNRqFAhDBgwINdMRfa+vb6+v3jxAk2aNEFQUBCOHTumnCcCpHyfZs+eneYoS075rWagpWz3+pgz7aGynTt3onfv3vjzzz/Rvn17NGzYEFu2bMHTp09RvHhxODk5oV69ejny2uK//fYbKleujCJFiqBHjx5KaPrtt99QvXp1ODg4oH379mjRogUKFSpk8BPA3pQax4DFxcWhY8eO0Gg0OHHiBADg4cOHaS5UERAQAA8Pjxw1/jo30v4g3rhxA3///bfO1e927tyZJtReunQJfn5+ej3RKvVh9mPHjqFTp05o0qQJQkNDdX58Dx06BFNTU+zZs0fnveQU2nqePHmCY8eOwdLSEp999hlCQkKQlJSEn3/+Gc7OzqhcuTI+/fRTtGnTBtbW1qrZ/rzuypUr+PTTT1G/fn2lRxBIuciLg4MDAgMDdXpqf/75Z5QvXx716tXLdZeafR9S/1annrJ0yJAhsLGxgZmZGVatWqUsf/z4MRo3boyZM2e+1zrfFAMtZSvtFyQ0NDTNxOUPHjyAs7OzcgWg9u3bo169etixYwciIiIwfPhwBAQE5Ihxa8Cr93Lp0iU4ODhg5syZWLp0KRo3bozGjRsr81OGhoZi9OjR6NevH8aMGYOQkBBDlv1BuHfvHnr06IECBQqkuVjFwYMHMXz4cFhaWubIMdi50aZNm1CoUCGULl0adnZ2+P3335WT8rShNvXwA32OL4+JiUHdunVRtWpVAMDy5ctRpkwZFCpUSDk5M/VUTgMHDkSdOnVy7MwXGzZsQNGiRREXF4ft27ejRIkS6Nu3rzKB/cWLFzFw4EB0794dQ4cO1euZ/e9DcHAwfH194eHhoTOn6dixY+Hg4IBvv/1WGYo2ZswYrFixgkdh3kLqnbeJEyeifv36yvktly5dQosWLVCuXDlERkYiKSkJDx48gJeXF+rUqZNjemRfx0BL2S40NBSFCxeGRqNBy5YtsX79eiXkbd++HQ0aNMCDBw9w+fJltG/fHo0bN8bGjRsNXPUrqS9be/HiRUyePBmjR49Wll25cgUdOnRAw4YNsWbNGkOU+EHJqNfs/v376Ny5MywsLJThB//++y+6deuGBg0aKFPNkP4kJyfj3r17cHNzw7x583Dq1Cn07dsXZmZmWLlypXIE4I8//oBGo1FO/NSnhIQEbNu2DVWqVIG3tzeAlCMpJUuWhI+PjzIUSPujPG/ePFSpUgWPHj3Se22ZyWyoxPz585XvwbZt25RQq/bwqn3PsbGxiIqKUnr3r169qoTa1DNRTJgwAZUqVULlypXRtGlTmJub55gOELUaN24cChcujL179ypHNpKTk7Fp0ybUrVsXVlZWqFGjBmrUqIGaNWsq62ZODLUMtJTtbt++jZo1a8LDwwPVq1dHv379UKpUKSxevBjr169H69atsWvXLgApe4Kenp5o3bo1oqKiDFz5qx8Q7RW96tatCwsLC50ztoGUutu3bw9PT08sXrzYEKV+ELQ/4gcOHMCwYcMwYMAA/Pzzz8rjERERaUJtWFhYju1tyy1Sz9n9/PlzBAQE6OwI+vn5wdTUFCtXrlR+APfs2aP3+Vy1ASkhIQF//PEHKlSoAC8vLwDAr7/+Cnd3d/Tu3TvNCUY5Zbx7ZkMlUvdqa0PtwIEDdYYX5LQhE5nRflZXr15F//790b17d51D2cHBwejdu3eaUPvbb79h8uTJGDJkiOoDvaFdvXoVbm5uynSawKt1KDk5GREREVi4cCHmzJmD9evX60x7lxMx0JJeXL16Fe3bt4ePjw82b96MLVu2oHHjxvDx8YFGo0Ht2rWV3pvg4OAcM0/rjRs34OHhgVatWiEkJATBwcFo0KABypcvr4RwrcuXL8PT0xNt2rTJEWE8N9D+yKUOR5s3b0ahQoXQvn17fPHFF9BoNJgwYYJyIl5ERAS6d+8OjUbDOWbfo99//x1dunRB9erVUbdu3TTfYT8/PxQoUACLFy/W2xAD7fqS+vVTh9pdu3bphNqVK1eidu3a6Nu3b44JsVpvMlQi9fvcvn07zM3NMWTIENWNhdd+RufPn0fx4sUxYsQIbN++XXlc+92+dOlSuqEWUFd4zyleP7/l5MmTsLS0THemm4y+szmxZ1aLgZb0Jjg4GN7e3mjevDlCQkLw/PlzHDt2DK1bt1YGmufEjdLVq1fRvHlzNGvWDJcvX8a1a9dQr149tGnTJs3ZnTkpjOcWd+/eRaVKlfDo0SPcvHkT9vb2ylm29+/fh5WVFTQaDQYOHKiccHj//n34+vqyx+Y9OXr0KMzMzNCzZ080a9YMefPmxddff52mZ1w7v6s+p4+6ffs2hg4dmmY6N+BVT23FihWVMbxLlixBpUqV8MUXX+SoH+c3HSqRunds165dqp2y6tq1a7Czs8PIkSN1ls+YMQOurq64d+8egFehtkGDBpg1a5YBKs19zpw5AyBlh8LR0VHn0s7a3+QtW7Yo2121YKAlvdKGw+bNm6tqEv/UdYeEhODKlSuoX78+WrdubZA5ND8koaGhcHR0RPfu3bF69WpMmTIFQErQLVWqFL744gusX78eefLkwZgxYxATEwMg/csrU/a7desWxo4dq3N4eNSoUXB0dMSMGTPw8OFDnfb6Pvtc+6M8cOBAZb5WQLe3f+XKlahUqZLSE7Vo0aIcNT9xVodK5NRDvm8iOTkZiYmJ+Oqrr9CxY0edWUi+/fZbFChQAOXKlUPFihV1Qm3Hjh3RvHlzPH361ECV5w7amXm0PbANGzaEi4uLTmfAy5cv0aZNG3z++eeGKvOtMNCS3qW+MlXqy63mdOmF2saNG6NBgwbYt2+focvLNV7vpU9MTMT3338Pd3d3rFixAqdOncLLly/h5eUFX19fJCYm4tGjR3B0dIRGo1GulkT6d+3aNbi7u6N48eJpestGjBiBUqVKYdasWTpzoL6PozB///23Ml4/dajV9sBGRkaiaNGiOaaHLzcNlXhbtWrVwuDBg5X7ly9fRvPmzbF7926cPn0aH330ESpUqKC83+vXrysBl97ezZs3YWZmhh9//BFAypRwVatWRdmyZTF69GgEBgaicePGqFy5sup2nBho6b1Q45WpAN1Qe/XqVVy8eBFeXl6qvZxkTqP9EX99rtinT5/CxcUFbdu2BQA8evQIVatWxc6dOwGkXDVswIAB2LBhA4cZ6NnrgXTSpEmws7ND69at04SrgIAAWFhYYP78+e+9x/zs2bNKqE09p2ZCQgKePXuGFi1aYMuWLQByxlCn3DJUIqsSEhKUHdIZM2YAePW+U5+sd/z4cVhbW2Po0KE54vNSI+3f9fVLCI8bNw5t2rRRdjyTk5MxcOBAeHp6okGDBujXr1+Ons0gIwy09N6o8cpUQEqobdmyJdzd3XHt2jW9zqH5Ibp+/TqKFCmCtm3bIiIiQhlCcOLECZiZmWH69OmIiYmBmZkZvvnmG9y9exdjxoxBxYoVefjxPTl69KjObB7ffvstXF1dMXLkSOUKf1oTJ0402FWbtKHW19dXOfs/Pj4eEydOhKOjY47a9uSGoRJvKjAwEEOGDNFZ1q5dO5QvX15nSEpycrLy/sPCwuDt7Y0NGza8z1JzhejoaJ37r68z27ZtQ8GCBdN0LsXHx+tc9ZI9tESZUNvZuFpXrlxB+/btc9QPYm5x9epVWFtbQ6PRoHnz5pg9ezYuXLgAABg2bBiqV6+OK1euYOnSpdBoNHBycoKNjY1qr4akNs+fP0ffvn1Rvnx5LF26VFk+efJkVKtWDSNGjMhRh8HPnTuHBg0aoFKlSmjXrh06duyIEiVK5LirDwLqGyrxNpKTk7FgwQJoNBqMHz9eWb5kyRLY2NigX79+aaZRA1J6EV1dXXnSbRYNHz4cQ4YMUcayb9iwARYWFhg2bBgOHTqktPvkk0/QpEmTNOFXS4294hoAECL6T/Hx8WJiYmLoMnKF5ORkyZMnjyQmJkrevHll7ty5cvv2bTE3N5fHjx/LmTNnZMqUKVK4cGH59NNPpUePHjJ+/Hg5d+6cPH78WJydnaV48eKGfhsfjAsXLsiCBQvk5MmTMnDgQOnfv7+IiEyZMkV+//13qVWrlowbN07s7OwMXGmK0NBQ2bJlixw+fFiqVasmnTp1kvLlyxu6rHT9/fff0q9fP6levboMGzZMKlWqJCIiiYmJ8vLlS+nYsaMMHDhQfHx8BIBoNBoDV5x18fHxsmbNGvnss8/E399fAgMDRUSkb9++snXrVmnYsKFMnTpVSpcuLcHBwbJ8+XL55Zdf5PDhw+Lm5mbY4lXGz89Pjh8/Lq1atZKvvvpKIiMj5X//+59MmzZNjI2NxdLSUr755hs5c+aM7N69W77++mupUqWKsk1WNQMHaiL6gGj3+rVXBNI6cOAAvLy8sGvXLsTGxuLHH3+EtbU1Zs6ciRYtWsDa2pqXsX3PXp+t4OLFi+jXrx+qV6+u01M7atQoNGzYUOdEMMoaNQ2VyIrk5GTlO3/9+nVMmzYNGo0G33zzjdLG398fTk5OMDExQbFixeDi4oKaNWvy+55FqXtUx44di2rVqmHChAnK9zg8PBwHDhyAt7c36tSpg9q1a+e6k2oZaInovbp//z4cHBwwZswYnR/qqVOnokiRIsqYzMOHD6NPnz5o1aoVNBoN2rRpg8TERFUeClObs2fPomHDhspJVFoXLlxAly5dUKFCBZ3LPr8efinr1DRUIqs2bdoEZ2dnfPrppyhatCg0Go3O5cT/+ecf/PLLL5gxYwb279/PnaO3kHrnAQBGjhyJatWqYdy4cWmmzvvrr78wZ84clCxZEuXKlVPmpVU7Bloieq+ePn2KyZMnw8rKCh999JHO+MBevXqhV69eykT84eHh2LdvH1q1aoXz588bqOIPz6FDh9C8eXN4enri999/13nswIEDsLCwgL29PZYtW2agCnOnO3fuYPbs2ejQoQO+/vprhISEGLqkd3b58mVYWFhgwYIFiI2Nxa1btzB9+nTkzZsXAQEBhi4vV0gdZC9fvqz8/6hRo1C9enWMHz8+3Z3Oc+fOoWzZsrnm8u0MtERkENrJ0suWLYvGjRsjODgYGzZsQK9evdJcvIK9svqR+rrtrzt06BB8fHzQqFEjncuSXr58GS1btsTIkSNVecY9vV/79+9H2bJldXpdnz9/ju+++w4ajQbTp083YHXql3p6vF27dqFGjRo6O6HphdrExETleSNGjECjRo10LjeuViofAUxEalWpUiVZvHixzJ49W6KioqRly5Zy9uxZuXjxomzcuFGnrRpPhFEDjUYj8fHxotFo5NSpU7J27Vr56aefJDIyUho0aCBjxoyRggULyg8//CC//vqrxMbGyurVq6Vw4cIyevRoKV26tKHfAuVwhQoVktu3b8v58+eVZfnz5xcfHx+xsrKSESNGyNSpUw1YoXqlPpFrx44d8ttvv8mNGzfkm2++kV27domIyHfffSfNmjWTXbt2ybx58+TBgwdiZGSkbFNDQ0PFyspK/SeEifCkMCLKGYYOHQovLy8UL14cGo0GP/30k6FLyrXmzZuHpk2bKvfXrl2L/Pnzw9nZGba2trCzs8PatWsBAKdPn4avry/MzMzg7OyMQoUK5YpxnZT90uvpf/78OT7++GO0a9cOp0+fVpY/efIEn3zyCZYsWcKLo2TR6xctGT58OEqWLImpU6fC398fjo6OaNiwIbZu3aq0CQgIQIkSJbBkyRLlNZ48eQI7OzucPHnyvdavL5y2i4gMCqmmIjpw4IDs3r1bmSLK2dnZwNXlLgAkKSlJ1q9fL6NGjZK6devKr7/+Kh06dJD27dtL27ZtJX/+/DJgwADZu3evzJ49Wzp16iTh4eFy48YNCQ0Nlbp160qpUqUM/VYoh9F+j48fPy4XL16Ue/fuSceOHaVChQpy4MABmThxohQqVEgGDBggFStWlJ9++kl27dolBw4ckEKFChm6fNU6d+6ctG3bVpYtWyZNmzYVEZF9+/bJjBkzJDIyUsaPHy9eXl4iIrJw4UIZMGCAGBkZKZ9XXFycmJqaGvItZBsGWiIyOLw2v2Z0dLRYWloasKLcKSwsTEqUKCExMTGye/duGT58uJQuXVpMTU1l3rx5UrZsWaXtp59+KgcOHJCQkBAxNzc3YNWkFps2bZLevXtLzZo1JSQkRMzMzKRDhw4yZcoUOX78uCxcuFA2b94sjo6O8uzZM/njjz+kWrVqhi5bNT755BOpUqWKjBw5UlkWEhIi9erVk19//VVatGihLA8KCpJ27dpJ5cqVZcyYMdKmTRvlsaSkJDEyMhKRtNteNcsFgyaISO1e36AyzGa/7du3S8mSJeXw4cOSP39+8fLykmnTpklkZKQcOnRI8uXLJyIiMTExIiLy448/ysuXL5WxeESZCQkJEX9/f5kzZ47s2bNH7t27J/369ZPjx4/LpEmTpFGjRrJ69Wq5dOmSrF+/Xs6dO8cwmwXPnj2TZs2aybBhw9I8ZmNjIyEhIZKcnCzaPsqmTZtK9erVBYAsXbpU/vnnH6W9NsyK5K7zExhoiYg+AHXq1JGuXbtK69at5ciRI5I/f37x9vaWMWPGiLW1tfTt21dEUk7YEUkJthYWFuydpTfy6NEjSU5Olrp164qxsbGIiIwZM0aaN28uGzdulLCwMDExMZEKFSpI9erVxdbW1sAVq4uFhYX06tVLjI2NZcmSJdKnTx8REalQoYK0a9dORo0aJdu2bZOkpCQREYmMjBRbW1vp0aOHXLhwQY4dO2bI8t8LBloiolxM22NTtGhRmTt3rnz88cfSokULOXLkiBQoUEBatWolc+fOlXPnzkmLFi0kJCRELl68KIsXL5Znz54pl2IlSo92/UpOThYRkdjYWBFJudytiMj48eMlMjJStm3bZpgCcwFtSBVJGTZ0//59OXbsmAwZMkRERL799lvp3bu3dO/eXfz8/GT8+PHi4+Mjt2/flsGDB0vZsmVl3759hir/vclr6AKIiCj7aaf00R5SBCBFihSRGTNmiIhIixYt5M8//5T69etLy5YtZd68eTJkyBBxc3OTVq1aiUajkd27d3NqLkoj9bhL7X/r168vFhYWMnz4cNmzZ4+YmJiISMp4+LJly4q9vb3B6lWzmJgY5aiJn5+f5MuXTz7//HMpUKCALF++XAYPHiw//vijLFy4UCpUqCBHjhyRf/75RxwdHWXZsmUikvJ5fQg7pjwpjIgolwoODpZVq1bJgAEDpESJEsrYuQcPHoi/v79s2bJFCbXaE8WGDRsmNWvWlHXr1imhhEhLG2ZPnjwpx44dExMTE3F0dBQvLy+5fPmyeHl5SZkyZWTKlClibm4u27Ztk8WLF8uJEyfE0dHR0OWrysqVK+Xu3bsybtw4uXbtmrRp00Z++uknadCggTx9+lSWLl0qK1eulCZNmsiPP/4oIiIvXrwQMzMz0Wg0EhsbK4GBgbJkyRI5dOiQVKhQwcDvSL8YaImIcqGEhASpV6+enD59WsqWLStt27aVWrVqSefOnUUkpeenX79+sn37diXUPnv2TPbt2yeVK1fWmfGAKLVNmzZJnz59xNXVVaKioiQ4OFhGjBgh3377rVy9elW6dOkiT548ERERc3Nz+fXXX6V69eoGrlpdlixZIgMHDpRDhw7JqVOn5MqVK2JkZCTz589XLoLw5MkT+fnnn2XVqlXy0UcfyezZs5Xn3717V6ZMmSK7d++WHTt2iJubm2HeyPv0Pie9JSKi92fatGmYOXMm9uzZg4kTJ6JgwYLo0aMHFi5ciOTkZERGRqJfv36wsLBAUFAQAF5mmDJ39epV2NraYsGCBQCAx48fY/Xq1TAzM8PYsWOVdufOncP58+d1LnlLb+aXX36BsbExdu7cCSDlwgkajQb16tVTvp/aiys8fvwY06dPh42NDWbPnq28RmJiIs6ePftBXZ6agZaIKJfav38/LC0tcerUKQDAvXv3MGnSJJiZmcHDwwNLlizB4cOH0bNnTxQvXhyxsbEMtKRYvnw5bt++rbPs6NGjqFChAsLCwnSWr1ixAmZmZjhw4MD7LDHXWb58OTQaDZo1a6Yse/jwIQIDA6HRaLB48WIAKTue2lD78OFD/Prrr0hMTDRIzTkFZzkgIsqlGjduLAMGDJDZs2fLy5cvxc7OTq5cuSKlS5eWcuXKyZo1a+Sjjz6S4sWLy/HjxyVfvny5al5KenvPnj2T0aNHS/v27SUsLExZbmpqKteuXZPr16+LiOjMe2pvby/37983SL25wU8//SR9+/aVvn37yqVLl2Tw4MEiIlKkSBEZOHCgjBs3TgYOHCirVq0SjUYjGo1GkpOTpUiRItK9e3cxMjLSmRHhQ8NZDoiIcrHatWvLzJkzxcTERPr16ycHDhyQoKAgqVy5sgQHB8tff/0lTZo0kRIlShi6VMpBLCws5NSpU+Ll5SUdOnSQ3377TRwcHKRcuXLKrBjW1tZStWpVEUmZ3N/a2lqZrouyZvbs2eLv7y87d+4Ub29vWbx4sYwbN040Go3MnTtXrK2t5auvvhIA4uvrKxqNRj755JM0O6CpL5rwoeFJYUREuVyjRo3kyJEjYmtrK7t27VJCCFFq2qnetFecMjIykrCwMPH09BQrKyvZtGmTlChRQjZs2CA//vijFC5cWAYOHCilSpWSlStXyvLly+XEiROc6u0tHDx4UO7fvy9du3YVEZGoqChZv369jB07Vrp16yZz585Vls+cOVOmTp0qu3btEi8vL0OWnaOwh5aIKJfC/0+xNGrUKAkPD5fvv/9eqlatmquu307ZQxtmr169KnPnzpV///1X6tatKyNGjJC//vpLPD09pV27drJ9+3bp3Lmz5MmTR9auXSstW7YUZ2dnSUhI4LzF76BRo0Yi8uo7a2VlpYTbsWPHiojI3LlzxcrKSoYOHSoODg7i6elpsHpzIvbQEhHlchEREVK/fn3p2rWrTJ061dDlUA6jDbP//POPNGvWTOrVqydmZmby22+/ybfffisjRoxQemrNzc1l586dYmdnJwkJCXL9+nUBIDY2NmJjY2Pot5LrREdHy7p162TcuHHSvXt3nam5REQSExMlb172TYqwh5aIKNcrVqyYTJw4UQYOHCht2rQRd3d3Q5dEOYQ2zJ4/f148PDxk2LBh8s033ygnG/37778SGxsrJUqUkL1790rbtm2lVatWsn37dilRooRUrFjR0G8hV7O0tJSuXbuKRqORzz77TEqXLi1Dhw5VHmeYfYU9tEREH4B///1XPvnkE1m1ahVPACMdd+/elerVq0uTJk1kw4YNyvKuXbtKcHCwvHz5UkqXLi2+vr5St25dadu2rTx//lz2798vxYsXN2DlH47IyEg5ePCgtG7d+oM+8SsznLaLiOgDULx4cfnjjz8YZimNpKQkcXR0lLi4OPnf//4nIiLfffed7NixQzp27CgjRoyQO3fuyLhx4yQmJka2bNki1tbWkpCQYODKPxzW1tbStm1bMTIyksTEREOXkyOxh5aIiOgDd+3aNfnyyy/FxMREihYtKtu3b5dVq1ZJ8+bNRUQkNDRUSpcuLQsWLJCBAwdy7CblOOyhJSIi+sCVK1dO5syZIy9evJBff/1VRo4cKc2bNxcAkpCQIEZGRuLq6ipFihQREY7dpJyHgZaIiIikfPnysnDhQmnQoIEEBQXJ4cOHRaPRiLGxsSxevFiePXsmtWvXNnSZROnikAMiIiJSaIcfAJDAwEDZu3evTJw4UY4ePSrVqlUzdHlE6WKgJSIiIh3Xrl0Tf39/OXnypDx9+lSOHTsmNWrUMHRZRBnikAMiIiLSUa5cOZk+fbrUqVNH/v77b4ZZyvHYQ0tERETpSkhIEGNjY0OXQfSfGGiJiIiISNU45ICIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVO3/AC62hBGUs3g3AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "x_train.columns" + "plt.figure(figsize=(8,6))\n", + "plt.xticks(rotation=45)\n", + "plt.axhline(y=5, color='r', linestyle='--', label='Importance Threshold')\n", + "sns.barplot(x = x_train.columns,y = model.feature_importances_*100)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "***Important Features*** based on **RandomForestClassifier**: based on percentages (descending order)\n", + "***Important Features*** based on **RandomForestClassifier**: based on percentages\n", "\n", "* **'Triglycerides'**\n", "\n", @@ -4692,8 +4781,6 @@ "\n", "* **'BMI'**\n", "\n", - "* **'Sex'**\n", - "\n", "* **'Age'**\n", "\n", "* **'UrAlbCr'**" @@ -4715,25 +4802,25 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 93, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Accuracy: 0.855755894590846\n" + "Accuracy: 0.8335644937586685\n" ] }, { "data": { "text/plain": [ - "array([ 3.20396639, 4.09267422, 2.2220431 , 2.3265535 , 0.71003562,\n", - " 16.63651252, 3.62258047, 0.21575584, 5.71524286, 2.52528682,\n", - " 19.51304344, 7.84702446, 31.36928076])" + "array([ 4.76364182, 2.99768815, 1.10844804, 3.8214706 , 0.76316145,\n", + " 16.29150013, 4.11040215, 0. , 4.43083233, 2.5424555 ,\n", + " 28.74543734, 11.58407814, 18.84088434])" ] }, - "execution_count": 22, + "execution_count": 93, "metadata": {}, "output_type": "execute_result" } @@ -4756,18 +4843,42 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 94, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "x_train.columns" + "plt.figure(figsize=(8,6))\n", + "plt.xticks(rotation=45)\n", + "plt.axhline(y=5, color='r', linestyle='--', label='Importance Threshold')\n", + "sns.barplot(x = x_train.columns,y = model.feature_importances_*100)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "***Important Features*** based on **DecisionTreeClassifier**: based on percentages (descending order)\n", + "***Important Features*** based on **DecisionTreeClassifier**: based on percentages\n", "\n", "* **'Triglycerides'**\n", "\n", @@ -4794,23 +4905,23 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 81, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Accuracy: 0.8932038834951457\n" + "Accuracy: 0.8682385575589459\n" ] }, { "data": { "text/plain": [ - "array([280, 97, 53, 161, 67, 419, 329, 6, 310, 229, 319, 369, 361])" + "array([293, 94, 68, 176, 68, 413, 269, 14, 299, 295, 282, 368, 361])" ] }, - "execution_count": 23, + "execution_count": 81, "metadata": {}, "output_type": "execute_result" } @@ -4846,32 +4957,42 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 82, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", - " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", - " 'Triglycerides'],\n", - " dtype='object')" + "" ] }, - "execution_count": 24, + "execution_count": 82, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "x_train.columns" + "plt.figure(figsize=(8,6))\n", + "plt.xticks(rotation=45)\n", + "plt.axhline(y=100, color='r', linestyle='--', label='Importance Threshold')\n", + "sns.barplot(x = x_train.columns,y = bst.feature_importance())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "***Important Features*** based on **LGBM**: based on count (descending order)\n", + "***Important Features*** based on **LGBM**: based on count\n", "\n", "* **'WaistCirc'**\n", "\n", @@ -4908,25 +5029,25 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 83, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Accuracy: 0.9029126213592233\n" + "Accuracy: 0.8848821081830791\n" ] }, { "data": { "text/plain": [ - "array([ 4.56710772, 11.62804771, 1.06129061, 1.65206427, 0.7416957 ,\n", - " 15.69751939, 4.08420142, 0.611841 , 2.71786898, 0.71133944,\n", - " 21.06262069, 14.43682955, 21.02757352])" + "array([ 4.91577719, 13.5587441 , 1.05211808, 1.3461468 , 0.3936465 ,\n", + " 16.58412232, 3.47160018, 0.44732418, 2.36145291, 0.81280151,\n", + " 21.26862273, 16.85998451, 16.92765901])" ] }, - "execution_count": 27, + "execution_count": 83, "metadata": {}, "output_type": "execute_result" } @@ -4962,32 +5083,42 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 84, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", - " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", - " 'Triglycerides'],\n", - " dtype='object')" + "" ] }, - "execution_count": 28, + "execution_count": 84, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "x_train.columns" + "plt.figure(figsize=(8,6))\n", + "plt.xticks(rotation=45)\n", + "plt.axhline(y=5, color='r', linestyle='--', label='Importance Threshold')\n", + "sns.barplot(x = x_train.columns,y = model.feature_importances_)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "***Important Features*** based on **CatBoostClassifier**: based on percentages (descending order)\n", + "***Important Features*** based on **CatBoostClassifier**: based on percentages \n", "\n", "* **'BloodGlucose'**\n", "\n", @@ -5016,25 +5147,25 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 85, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Accuracy: 0.8613\n" + "Accuracy: 0.8516\n" ] }, { "data": { "text/plain": [ - "array([ 7.85749598, 2.91794336, 3.65928408, 4.67697385, 3.86039051,\n", - " 14.6587498 , 9.72502302, 2.38920523, 5.60023169, 6.15703292,\n", - " 11.83867671, 11.47766221, 15.18133065])" + "array([ 7.87588426, 3.05869256, 3.55910983, 4.78860019, 3.85574076,\n", + " 13.78440556, 10.09374818, 1.67015006, 5.17729968, 6.14516898,\n", + " 13.83759421, 11.23011022, 14.9234955 ])" ] }, - "execution_count": 37, + "execution_count": 85, "metadata": {}, "output_type": "execute_result" } @@ -5057,32 +5188,42 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 86, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", - " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", - " 'Triglycerides'],\n", - " dtype='object')" + "" ] }, - "execution_count": 38, + "execution_count": 86, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "x_train.columns" + "plt.figure(figsize=(8,6))\n", + "plt.xticks(rotation=45)\n", + "plt.axhline(y=5, color='r', linestyle='--', label='Importance Threshold')\n", + "sns.barplot(x = x_train.columns,y = model.feature_importances_*100)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "***Important Features*** based on **ExtraTreesClassifier**: based on percentages (descending order)\n", + "***Important Features*** based on **ExtraTreesClassifier**: based on percentages \n", "\n", "* **'Triglycerides'**\n", "\n", @@ -5117,23 +5258,23 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 87, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Accuracy: 0.8779472954230236\n" + "Accuracy: 0.8682385575589459\n" ] }, { "data": { "text/plain": [ - "array([ 8., 6., 2., 6., 0., 14., 6., 0., 6., 4., 16., 14., 18.])" + "array([10., 6., 2., 2., 0., 14., 10., 0., 4., 12., 18., 10., 12.])" ] }, - "execution_count": 39, + "execution_count": 87, "metadata": {}, "output_type": "execute_result" } @@ -5159,32 +5300,42 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 88, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", - " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", - " 'Triglycerides'],\n", - " dtype='object')" + "" ] }, - "execution_count": 40, + "execution_count": 88, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArQAAAI4CAYAAACbTHp5AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABy/UlEQVR4nO3dd3xN9/8H8PcVGYIkRsgQRIwgIVaIrYLEqNirRaxqG1+kVmLTNq3Wau2qUauoXao0dm2qZmwilVAjm8zX74/87pEro0KumxOv5+NxH+0993Ov980995zX/ZzP+RwNAAgRERERkUoVMHQBRERERERvgoGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFStoKELyA2pqaly//59KVq0qGg0GkOXQ0REREQvASAxMTFiZ2cnBQrkbp9qvgi09+/fFwcHB0OXQURERET/4d69e1KmTJlcfc18EWiLFi0qIml/IAsLCwNXQ0REREQvi46OFgcHByW35aZ8EWi1wwwsLCwYaImIiIjyMH0MD+VJYURERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagUNXQARERGp34HV/xq6hEw1/8Da0CXQW8AeWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJStRwH2kOHDkmHDh3Ezs5ONBqNbN26VedxjUaT6e2bb77J8jWnTJmSob2zs3OO3wwRERERvXtyHGjj4uKkZs2aMn/+/EwfDw8P17ktW7ZMNBqNdOnSJdvXrV69us7zjhw5ktPSiIiIiOgdlOMrhXl7e4u3t3eWj9vY2Ojc37Ztm7Ro0UIqVKiQfSEFC2Z4LhERERHRf9HrGNoHDx7Izp07ZeDAgf/Z9vr162JnZycVKlSQPn36SGhoaJZtExISJDo6WudGRERERO8mvQbalStXStGiRaVz587Ztqtfv76sWLFCdu/eLQsXLpTbt29LkyZNJCYmJtP2QUFBYmlpqdwcHBz0UT4RERERqYBeA+2yZcukT58+YmZmlm07b29v6datm9SoUUPatGkju3btksjISNmwYUOm7QMCAiQqKkq53bt3Tx/lExEREZEK5HgM7as6fPiwXL16VdavX5/j51pZWUnlypXlxo0bmT5uamoqpqamb1oiEREREeUDeuuh/fHHH6VOnTpSs2bNHD83NjZWbt68Kba2tnqojIiIiIjykxwH2tjYWDl37pycO3dORERu374t586d0zmJKzo6WjZu3CiDBg3K9DVatmwp8+bNU+6PGjVKDh48KHfu3JGjR49Kp06dxMjISHr16pXT8oiIiIjoHZPjIQenT5+WFi1aKPf9/f1FRKRfv36yYsUKERH5+eefBUCWgfTmzZvy6NEj5X5YWJj06tVLHj9+LNbW1tK4cWM5fvy4WFtb57Q8IiIiInrHaADA0EW8qejoaLG0tJSoqCixsLAwdDlERETvnAOr/zV0CZlq/gE7x/IKfeY1vc5yQERERESkbwy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqDLREREREpGoMtERERESkagy0RERERKRqOQ60hw4dkg4dOoidnZ1oNBrZunWrzuP9+/cXjUajc/Py8vrP150/f76UL19ezMzMpH79+nLy5MmclkZERERE76AcB9q4uDipWbOmzJ8/P8s2Xl5eEh4ertzWrVuX7WuuX79e/P39ZfLkyXL27FmpWbOmtGnTRh4+fJjT8oiIiIjoHVMwp0/w9vYWb2/vbNuYmpqKjY3NK7/mrFmzZPDgweLr6ysiIosWLZKdO3fKsmXLZNy4cTktkYiIiIjeIXoZQ3vgwAEpVaqUVKlSRT7++GN5/Phxlm0TExPlzJkz4unp+aKoAgXE09NTjh07lulzEhISJDo6WudGRERERO+mXA+0Xl5e8tNPP0lwcLB8/fXXcvDgQfH29paUlJRM2z969EhSUlKkdOnSOstLly4tERERmT4nKChILC0tlZuDg0Nuvw0iIiIiUokcDzn4Lz179lT+39XVVWrUqCFOTk5y4MABadmyZa78GwEBAeLv76/cj46OZqglIiIiekfpfdquChUqSMmSJeXGjRuZPl6yZEkxMjKSBw8e6Cx/8OBBluNwTU1NxcLCQudGRERERO8mvQfasLAwefz4sdja2mb6uImJidSpU0eCg4OVZampqRIcHCweHh76Lo+IiIiIVC7HgTY2NlbOnTsn586dExGR27dvy7lz5yQ0NFRiY2Nl9OjRcvz4cblz544EBwdLx44dpWLFitKmTRvlNVq2bCnz5s1T7vv7+8sPP/wgK1eulCtXrsjHH38scXFxyqwHRERERERZyfEY2tOnT0uLFi2U+9qxrP369ZOFCxfK+fPnZeXKlRIZGSl2dnbSunVrmT59upiamirPuXnzpjx69Ei536NHD/n3339l0qRJEhERIW5ubrJ79+4MJ4oREREREb1MAwCGLuJNRUdHi6WlpURFRXE8LRERkQEcWP2voUvIVPMPrA1dAv0/feY1vY+hJSIiIiLSJwZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlK1goYugIjoZW23Bhq6hEzt8vnS0CUQEVEm2ENLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqpbjQHvo0CHp0KGD2NnZiUajka1btyqPJSUlydixY8XV1VUKFy4sdnZ20rdvX7l//362rzllyhTRaDQ6N2dn5xy/GSIiIiJ69+Q40MbFxUnNmjVl/vz5GR6Lj4+Xs2fPysSJE+Xs2bOyefNmuXr1qrz//vv/+brVq1eX8PBw5XbkyJGclkZERERE76CCOX2Ct7e3eHt7Z/qYpaWl7N27V2fZvHnzxN3dXUJDQ6Vs2bJZF1KwoNjY2OS0HCIiIiJ6x+l9DG1UVJRoNBqxsrLKtt3169fFzs5OKlSoIH369JHQ0NAs2yYkJEh0dLTOjYiIiIjeTXoNtM+fP5exY8dKr169xMLCIst29evXlxUrVsju3btl4cKFcvv2bWnSpInExMRk2j4oKEgsLS2Vm4ODg77eAhERERHlcXoLtElJSdK9e3cBIAsXLsy2rbe3t3Tr1k1q1Kghbdq0kV27dklkZKRs2LAh0/YBAQESFRWl3O7du6ePt0BEREREKpDjMbSvQhtm7969K/v27cu2dzYzVlZWUrlyZblx40amj5uamoqpqWlulEpEREREKpfrPbTaMHv9+nX5448/pESJEjl+jdjYWLl586bY2trmdnlERERElM/kONDGxsbKuXPn5Ny5cyIicvv2bTl37pyEhoZKUlKSdO3aVU6fPi1r1qyRlJQUiYiIkIiICElMTFReo2XLljJv3jzl/qhRo+TgwYNy584dOXr0qHTq1EmMjIykV69eb/4OiYiIiChfy/GQg9OnT0uLFi2U+/7+/iIi0q9fP5kyZYps375dRETc3Nx0nrd//35p3ry5iIjcvHlTHj16pDwWFhYmvXr1ksePH4u1tbU0btxYjh8/LtbW1jktj4iIiIjeMTkOtM2bNxcAWT6e3WNad+7c0bn/888/57QMIiIiIiIReQvz0BIRERER6RMDLRERERGpGgMtEREREakaAy0RERERqRoDLRERERGpml6uFEZEREQ5M2tLhKFLyJJ/JxtDl0D/4cF3RwxdQqZK/6/xW/l32ENLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqsZAS0RERESqxkBLRERERKrGQEtEREREqpbjQHvo0CHp0KGD2NnZiUajka1bt+o8DkAmTZoktra2UqhQIfH09JTr16//5+vOnz9fypcvL2ZmZlK/fn05efJkTksjIiIiondQjgNtXFyc1KxZU+bPn5/p4zNmzJDvvvtOFi1aJCdOnJDChQtLmzZt5Pnz51m+5vr168Xf318mT54sZ8+elZo1a0qbNm3k4cOHOS2PiIiIiN4xOQ603t7e8vnnn0unTp0yPAZA5syZIxMmTJCOHTtKjRo15KeffpL79+9n6MlNb9asWTJ48GDx9fWVatWqyaJFi8Tc3FyWLVuW0/KIiIiI6B2Tq2Nob9++LREREeLp6akss7S0lPr168uxY8cyfU5iYqKcOXNG5zkFChQQT0/PLJ+TkJAg0dHROjciIiIiejcVzM0Xi4iIEBGR0qVL6ywvXbq08tjLHj16JCkpKZk+JyQkJNPnBAUFydSpU/+znn8Xrn6Vst86648/MHQJRKQn7Tb9YOgSsrSzy2BDl0CUZ4XPCDd0CZmyHWNr6BJUQZWzHAQEBEhUVJRyu3fvnqFLIiIiIiIDydVAa2NjIyIiDx480Fn+4MED5bGXlSxZUoyMjHL0HFNTU7GwsNC5EREREdG7KVcDraOjo9jY2EhwcLCyLDo6Wk6cOCEeHh6ZPsfExETq1Kmj85zU1FQJDg7O8jlERERERFo5HkMbGxsrN27cUO7fvn1bzp07J8WLF5eyZcvKiBEj5PPPP5dKlSqJo6OjTJw4Uezs7MTHx0d5TsuWLaVTp07i5+cnIiL+/v7Sr18/qVu3rri7u8ucOXMkLi5OfH193/wdEhEREVG+luNAe/r0aWnRooVy39/fX0RE+vXrJytWrJAxY8ZIXFycDBkyRCIjI6Vx48aye/duMTMzU55z8+ZNefTokXK/R48e8u+//8qkSZMkIiJC3NzcZPfu3RlOFCMiIiIielmOA23z5s0FQJaPazQamTZtmkybNi3LNnfu3MmwzM/PT+mxJSIiIiJ6Vaqc5YCIiIiISIuBloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhULdcDbfny5UWj0WS4ffrpp5m2X7FiRYa2ZmZmuV0WEREREeVTBXP7BU+dOiUpKSnK/YsXL0qrVq2kW7duWT7HwsJCrl69qtzXaDS5XRYRERER5VO5Hmitra117n/11Vfi5OQkzZo1y/I5Go1GbGxscrsUIiIiInoH6HUMbWJioqxevVoGDBiQba9rbGyslCtXThwcHKRjx45y6dKlbF83ISFBoqOjdW5ERERE9G7Sa6DdunWrREZGSv/+/bNsU6VKFVm2bJls27ZNVq9eLampqdKwYUMJCwvL8jlBQUFiaWmp3BwcHPRQPRERERGpgV4D7Y8//ije3t5iZ2eXZRsPDw/p27evuLm5SbNmzWTz5s1ibW0tixcvzvI5AQEBEhUVpdzu3bunj/KJiIiISAVyfQyt1t27d+WPP/6QzZs35+h5xsbGUqtWLblx40aWbUxNTcXU1PRNSyQiIiKifEBvPbTLly+XUqVKSbt27XL0vJSUFLlw4YLY2trqqTIiIiIiyk/0EmhTU1Nl+fLl0q9fPylYULcTuG/fvhIQEKDcnzZtmuzZs0du3bolZ8+elQ8++EDu3r0rgwYN0kdpRERERJTP6GXIwR9//CGhoaEyYMCADI+FhoZKgQIvcvTTp09l8ODBEhERIcWKFZM6derI0aNHpVq1avoojYiIiIjyGb0E2tatWwuATB87cOCAzv3Zs2fL7Nmz9VEGEREREb0D9DrLARERERGRvjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaoVNHQBlLWweQMMXUKmyvgtM3QJRERERAr20BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRquV6oJ0yZYpoNBqdm7Ozc7bP2bhxozg7O4uZmZm4urrKrl27crssIiIiIsqn9NJDW716dQkPD1duR44cybLt0aNHpVevXjJw4ED566+/xMfHR3x8fOTixYv6KI2IiIiI8pmCennRggXFxsbmldrOnTtXvLy8ZPTo0SIiMn36dNm7d6/MmzdPFi1alLN/OC5OxMjoxf2E52n/LVBAxNgk4/LMaAqImLxm28QEESCLthoRE9MX9+Pjs29rbp7udZNFk1VbEYGp8eu1TUoWTeprtI2Ly9jY3DytbhGRhASR5OQsXzdHbQsVSvv8REQSE0WSknKnrZnZi3UlJ22TktLaZ8XUVKRgwZy3TU5O+1tkxcRExNg4521TUkSeZ7MOGxu/WIdz0jY1VeTZs9xpW7Bg2t9CJO07ER8vps8z/7ulGBWQZOOCSlvThKw/t9QCBSTJ5MUmLqvXzFHbuLi0daxQId1l6Zg+f/HZQKORRNMX2wjThASRrL5yGpEEU9PXamuSkJjt9z7BLN2259mztM8kK4ULv/j/58/T1ovcaMttRJpsthEFn8frNE0xNhEYpbXVpCSLUVI263BBY0ktaPwabVPEKCnr7UmqUUFJNX61bYQmOVFQ8MX3vkBi1t97FDR+9bZGBQXGL7YRBRLic9Y2zjzzxkZGaZ+dtv7EbF5XU0DE+FXbakSMC71WW0mMF83LjbTbmJezwcs5IiHd31CjETF5UW9aPsnme29a6PXaJiVkvz1J3/b588zzQ25BLps8eTLMzc1ha2sLR0dH9O7dG3fv3s2yvYODA2bPnq2zbNKkSahRo0aWz3n+/DmioqKU27179yAiiEr7aDPcnleviYcLVim3VBOTTNtBBAmVnHXaphQpmmXbxLKOOm2Ti5fMsm2Srb3SDgBQrVqWbVGuHADg3ve+uPe9LxLKZv26yUVMlXb3vvfF84o2WbZNMSmo0za+WpmsaxDRaRvnVj7btoiNffEB9euXfduHD1+0/eST7Nvevv2i7ahR2be9eDH9iph925MnX7SdMSP7tvv3v2g7b172bX/99UXb5cuzb7thw4u2GzZk33b58hdtf/01+7bz5r1ou39/9m1nzHjR9uTJ7NtOnvyi7cWL2bcdNepF29u3s2/7yScv2j58mG3bPS1c4b0lAN5bAuCz7rNs2x7ycFbaem8JyLbtiTpOOm2fmRpn3b5ZM+gomfX386pTObT9ZYlyi7AukWXbO2VsddreKWObZdsI6xI6ba86lcuybaRFEaUdgLT6s3pv5ua6761t2+w/u/S6ds2+LbcRabccbCO2j1qCmZvDMXNzOLaPWpJt29/85ihtNweuyrbtH4O/VNqun7Yp27YH+07EzM3hafX+xzbidqdR2L/qIfaveogTQYeybXu37SdK22OzTmfbNqylr9L2yPzL2bYNb9xDaXvwh//Y9nTtqrsOZ9P2mXNL3P/6vnJLMS6UZdvnFTx02iYXLp5l24QyNXXaJhXLZr9crZpuvdnkiOTiNoiYe1i5JTo4Z9k2pbClTtuEim5Ztk01MdNp+7xag2z/bhFzD+tsI6JEICKIiopCbsv1IQf169eXFStWyO7du2XhwoVy+/ZtadKkicTExGTaPiIiQkqXLq2zrHTp0hIREZHlvxEUFCSWlpbKzcHBIVffAxERERGphybtR4n+REZGSrly5WTWrFkycODADI+bmJjIypUrpVevXsqyBQsWyNSpU+XBgweZvmZCQoIkpDvkGh0dLQ4ODhJ1/75YWFgoy//9YV3a/+SxIQfWH3/wSkMOwuYN+P/XzVtDDuyHZjIUhIcT03DIQc7bZjLkoNOOyZk2NfSQgy0dpv7nkIPOW5cr/5/Xhhzs7DKYQw7y8Dbiu+26+7y8NOTAv5PNf24jDm6MzJNDDpr2ss688UtDDiI+v5n16xpwyIHNyP8fwvkfQw4eLDj64rE8NOSg9P8ap/3/8+cS/fSpWNrZSVRUlE5eyw16GUObnpWVlVSuXFlu3LiR6eM2NjYZguuDBw+yHYNramoqpuk25orChXU3sKZmGdtkt/xN25pkUlNWzLMY05Pp6xbMcr/2Rm2NX7Nt+r9xZkxNXwSU/5KTtiYmuj8gDNHW2PhFWMzNtgULvtjJ5WZbI6P//rxep22BAvppq9GIFC4sCWav8HloNK/W7v/lStvM3sdLy3TGq778uq+6ruewbfrQ/J/Sh/H/YpaD7V9O2nIbkWnbZLOs9wswKijJRq/2vc9ZWyNJNnrF/dF/bCNQMF1wK1BAUs1efRvxym01mpy3fcXtD0xefb+sr7ZiYp5xv5xV/S/nCNNsvts5ySc5aWucg7ZmZq++L3gNep+HNjY2Vm7evCm2traZPu7h4SHBwcE6y/bu3SseHh76Lo2IiIiI8oFcD7SjRo2SgwcPyp07d+To0aPSqVMnMTIyUoYU9O3bVwICApT2w4cPl927d8vMmTMlJCREpkyZIqdPnxY/P7/cLo2IiIiI8qFcH3IQFhYmvXr1ksePH4u1tbU0btxYjh8/LtbWaWNYQkNDpUCBFzm6YcOGsnbtWpkwYYIEBgZKpUqVZOvWreLi4pLbpRERERFRPpTrgfbnn3/O9vEDBw5kWNatWzfp1q1bbpdCRERERO8AvY+hJSIiIiLSJwZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUjUGWiIiIiJSNQZaIiIiIlI1BloiIiIiUrWChi6AiIgot3TZdNLQJWRqUxd3Q5dAlK+xh5aIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVC3XA21QUJDUq1dPihYtKqVKlRIfHx+5evVqts9ZsWKFaDQanZuZmVlul0ZERERE+VCuB9qDBw/Kp59+KsePH5e9e/dKUlKStG7dWuLi4rJ9noWFhYSHhyu3u3fv5nZpRERERJQPFcztF9y9e7fO/RUrVkipUqXkzJkz0rRp0yyfp9FoxMbGJrfLISIiIqJ8Tu9jaKOiokREpHjx4tm2i42NlXLlyomDg4N07NhRLl26lGXbhIQEiY6O1rkRERER0btJr4E2NTVVRowYIY0aNRIXF5cs21WpUkWWLVsm27Ztk9WrV0tqaqo0bNhQwsLCMm0fFBQklpaWys3BwUFfb4GIiIiI8ji9BtpPP/1ULl68KD///HO27Tw8PKRv377i5uYmzZo1k82bN4u1tbUsXrw40/YBAQESFRWl3O7du6eP8omIiIhIBXJ9DK2Wn5+f/Prrr3Lo0CEpU6ZMjp5rbGwstWrVkhs3bmT6uKmpqZiamuZGmURERESkcrneQwtA/Pz8ZMuWLbJv3z5xdHTM8WukpKTIhQsXxNbWNrfLIyIiIqJ8Jtd7aD/99FNZu3atbNu2TYoWLSoREREiImJpaSmFChUSEZG+ffuKvb29BAUFiYjItGnTpEGDBlKxYkWJjIyUb775Ru7evSuDBg3K7fKIiIiIKJ/J9UC7cOFCERFp3ry5zvLly5dL//79RUQkNDRUChR40Tn89OlTGTx4sEREREixYsWkTp06cvToUalWrVpul0dERERE+UyuB1oA/9nmwIEDOvdnz54ts2fPzu1SiIiIiOgdoPd5aImIiIiI9ImBloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFRNb5e+Jdq/tJ2hS8hUi0E7/7PNipWt30IlOde/3x5Dl0BERJTnsIeWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFSNgZaIiIiIVI2BloiIiIhUjYGWiIiIiFRNb4F2/vz5Ur58eTEzM5P69evLyZMns22/ceNGcXZ2FjMzM3F1dZVdu3bpqzQiIiIiykf0EmjXr18v/v7+MnnyZDl79qzUrFlT2rRpIw8fPsy0/dGjR6VXr14ycOBA+euvv8THx0d8fHzk4sWL+iiPiIiIiPIRvQTaWbNmyeDBg8XX11eqVasmixYtEnNzc1m2bFmm7efOnSteXl4yevRoqVq1qkyfPl1q164t8+bN00d5RERERJSP5HqgTUxMlDNnzoinp+eLf6RAAfH09JRjx45l+pxjx47ptBcRadOmTZbtiYiIiIi0Cub2Cz569EhSUlKkdOnSOstLly4tISEhmT4nIiIi0/YRERGZtk9ISJCEhATlflRUlIiIREdH67SLefYsx/W/DaYv1ZmVmGeJeq7k9bz8d85K3LMkPVfyel6l/mfPkt9CJTn3qn97tUuKT/jvRgbwKn//pPi8ud0ReTfWn6T4WEOXkKlX+ds/j495C5W8nuho8/9sE/csb9YfHW36Su1inufN+gtHF36ldjHP4/RcyesplG7d134PAOT6v5PrgfZtCAoKkqlTp2ZY7uDgYIBqXsNnQwxdwZsZs8bQFbyZ/1kauoLX9snH6q09P7CUWYYu4Y1YynBDl/DOUvs3d7yhC3gTKt/lymRDF/CGxmZcFBMTI5aWufutyPVAW7JkSTEyMpIHDx7oLH/w4IHY2Nhk+hwbG5sctQ8ICBB/f3/lfmpqqjx58kRKlCghGo3mDd9BRtHR0eLg4CD37t0TCwuLXH99fWP9hqPm2kVYvyGpuXYR1m9oaq5fzbWLsP7sAJCYmBixs7PL1dcV0UOgNTExkTp16khwcLD4+PiISFrgDA4OFj8/v0yf4+HhIcHBwTJixAhl2d69e8XDwyPT9qampmJqqnsIwcrKKjfKz5aFhYUqV04t1m84aq5dhPUbkpprF2H9hqbm+tVcuwjrz0pu98xq6WXIgb+/v/Tr10/q1q0r7u7uMmfOHImLixNfX18REenbt6/Y29tLUFCQiIgMHz5cmjVrJjNnzpR27drJzz//LKdPn5YlS5boozwiIiIiykf0Emh79Ogh//77r0yaNEkiIiLEzc1Ndu/erZz4FRoaKgUKvJhgoWHDhrJ27VqZMGGCBAYGSqVKlWTr1q3i4uKij/KIiIiIKB/R20lhfn5+WQ4xOHDgQIZl3bp1k27duumrnDdiamoqkydPzjDMQS1Yv+GouXYR1m9Iaq5dhPUbmprrV3PtIqzfUDTQx9wJRERERERviV6uFEZERERE9LYw0BIRERGRqjHQEhEREZGqMdASERERkaox0FK+wnMciYjeTGpqqqFLoHxOH+sYA+07SBv6UlJSDFxJ7gsPDxcRbpCJyDC029ekpCQDV5Jz+/fvl6SkJClQoAA7B0hvUlNTlWsRXLlyRaKjo3PldRloc0j7JU//ZVdbeNJoNLJr1y5Zvny5iOSfXs2tW7eKg4ODHD9+XAoUKKC6z4XyHu1349SpU/Lrr78atJY7d+7ImTNnuF6/JK9tvzQajWzbtk3Gjx8vz549M3Q5r+zgwYMydOhQCQwMlOTkZNFoNHnub0vqlz7MTpo0SQYMGCCnT5+WhISEN35tBtocSE1NFY1GIyIiUVFREh8fr3w4atvJbNiwQXbu3Cki6gvkWXFycpLOnTtL586d5cSJE6r8XLQ7kPDwcHnw4IHcunXLwBW9uwCIRqORTZs2iY+Pj+zevVuuX79usHp8fX2lbdu2curUqXc6aGjfe1RUlMTGxkpiYqKBK9J1/vx5+eSTT8TFxUWMjY0NXc4rq1WrlnTu3FmOHDkigYGBkpSU9E6EWu37i4+Pz9BTmFvvXW37IX3Shtnx48fLDz/8IAEBAVKzZs1cuYgDA+0rSv+r4ptvvpEuXbrIe++9J23btpV//vlH51K+auDg4CAREREiImJkZGTganKHq6urTJs2TZo2bSodOnRQXajVBqht27ZJp06dpEWLFuLt7S1TpkyR5ORkQ5en0G7kb9y4IZcuXZLjx48buCL90Gg0cuTIEenfv79MnTpVZs6cKZUqVXrrdWj/3vv27ZNy5cpJ//795cSJE/k+aGRG+x359ddfpVevXuLm5iZ+fn6yadMmnTaGcvHiRdm7d6906dJF+vbtq3SA5HXJycliYWEhQUFB4unpKadPn1a2O/k51GrXpx07dijr05AhQ2Tx4sUiIm/8+T1+/FhERFX7obfh3Llz8vPPP8vq1avl/fffF1NTU7l9+7Zs2LDhzfYnoBwJDAyEtbU1li9fjv3798Pe3h5ubm54/PixoUv7T3fv3sX169cBAL///jvc3d3x9OlTpKSkAABSU1OV/1ezS5cuoUePHrC2tsbx48cBQDXva/fu3ShUqBAWLFiAK1euYPbs2dBoNNizZ4+hSwOQto4AwObNm+Hk5AQ3NzdYWFigR48e+PPPPw1cXe6bMmUKevToAeDFOpScnPzW/v2bN2/i119/RXR0NIC0v7+bmxucnZ1x7Ngx5fN4l2zfvh2FChXC559/jp9++gm9evVChQoVsHLlSqWNvv8u6deF58+fAwDi4uLg4uICjUYDb2/vt1ZLbtDWeObMGQQEBKBSpUqwsrLCxIkTkZSUpNMmv9mxYwcKFSqEoKAgbNu2DX369EHRokVx+PDhN3rdR48eoUGDBhgzZoyyTC37IX07efIkqlatirNnz+LPP//E//73P1StWhV2dnaoW7cufv/999d6XQbaHLhz5w7q1Kmj/LF37NgBS0tLLFiwQKddXlxpL168iOLFi6NYsWJo2rQpKlWqBEtLS6xevTpf7hjPnz+vylD7ySefIDAwEEDa+ubk5ISPPvrIwFXpOnjwICwsLLB06VIAaT+ONBoN1qxZY+DK3pz2e3D37l0kJydj6NChaNKkSYbHgbR1TJ/CwsKg0Whgbm6OzZs3Iy4uTnmsVq1aqFKlSr787qb38OFDnfvXrl1DrVq1sGjRIgBAZGQkbGxs4OrqCicnJ51Qqy/a7ci1a9fg7++PFi1a4MSJEwDSvrONGzdGuXLlsH37duWzyWufUWb17NixAwULFsS0adMwZ84ceHp6onr16hg7dmy+DLWpqamIiopC+/btMWPGDAAv1qfhw4e/8euHh4dj1KhRcHV1xdSpU5Xl2e2H8tPfVyuz9/vkyROUK1cOrq6uMDExwccff4wtW7bg8uXLqFy5MlatWvVa/xYDbQ6cPXsWpUuXBgDs3LkTRYoUUTasMTExmDdv3lvtvcmpEydO4OjRo5g3bx5GjRoFjUaDsmXLokKFCqhQoQLKlSuH8ePHIyEhwdClvrL0AeT27du4cuWK8lhmoTYvfz6JiYmoXbs2Fi1ahKioKNjb22PIkCHKe1ywYAH27dtn4CqBzz//HB9++CGAtJ16pUqVMGjQIOVx7c5PrTZu3Ag3Nzf8/fffmDJlCqpVq4Zr167pHMmIjY2Fr6+vXnvOtT1+RYoUgZWVFdatW4f4+Hjl8fweamfPno3atWvrbI8ePnyIYcOGITw8HPfu3UOlSpXw8ccf4+LFi3B3d4e9vb2yTdYH7Tpw/vx5lC1bFiNHjsTs2bPx7NkznW1RrVq14OnpqfN9zUuf0f3795X/167P3t7e8Pf3V5bHxcVh1KhRcHZ2xqRJk/JlqE1ISEC9evVw8OBBhIaGwt7eHoMHD1Ye3759O86ePfvarx8WFobJkyfD2dlZJ9Sm3w8lJSXlie26PqQPs/v27cPmzZuxfft2AGmZac2aNQgODkZiYqLSrn79+li+fPlr/XsMtFnI7EsbFxeH1q1b47PPPkORIkWwZMkS5bGLFy+idevWOHTo0NssM0va+iMjI/Hvv/9m2sbLywvjxo3DvXv3sGnTJnzzzTe4dOnS2yzzjWjf49atW+Hm5gZHR0dUr14dEydOVNpcuHABPXr0gJ2dHY4cOWKoUl/Z9OnT0adPH9ja2mLo0KHKBuHZs2fo378/pk+fbtDAmJqait69eyMwMBCpqakZQveyZcuwfv16g9X3urT1R0VFoXXr1pg7dy4AIDo6GmXLlkWrVq1w+fJlJCUlITExERMmTECFChVw584dvdSj3eFNnz4d48ePh7+/P4yNjTMNtS4uLjh06FC+ChpAWi/O1atXAUCndzoqKgoA8L///Q/du3dX7g8ZMgRly5aFh4cHnjx5ore/x61bt2BnZ4dRo0bpLE9JSVE+t1u3bsHNzQ2tWrXC/v379VLH61q8eDGaN2+O58+f6wQOT09PnTAHpG13mjZtilKlSuF///uf6n+svrxOPHnyBC1atEBQUBCcnJwwaNAg5W/yzz//4MMPP8T69etfa13Svk5oaCgmT56MKlWqYMqUKTqPJyQk4NNPP4WTkxMePHjwBu8sbxs7diwcHBzQuHFj2NjYoE2bNjpZKS4uDhEREfDy8kLt2rVfu+OJgTYT6b/kQUFBOr8oPvjgA5iammLYsGFKm/j4eLRt2xbt2rXLE4e1tV++7du3o2HDhnB2dkb9+vWxcOFC5UuTmpoKT09P/O9//zNkqW9s586dKFy4ML7//ntcuHABM2fOhEaj0dnZXLx4Ed7e3qhUqZJOT4ohaWt48uQJnjx5oixfv349ypYti3r16uHWrVsA0npuAwMDUa5cOdy4ccMgdYaFhSEmJgYAsGrVKjg5OaF48eLw8/PTWecHDBiAjz76SBlXmJdduHBBp2dg7969eP/999GhQwdlrDmQNo61QoUKqF69OlxdXdGmTRuUKFHijXpuXtUff/wBKysrXLx4EZMnT4apqWmGUOvo6Ih69erh2bNneq/nbUn/HT158iQcHR1x+fJlncdbtGiBoUOHKss++eQTzJkzR2/nM2jX86lTp6Jdu3aIjIzMtJ12Z3z79m3UrVsX9erVyzMdHUDaOnXz5k0AUL7Tz58/x6BBg9CqVSs8ePBA5zs9ZcoUVKxYET4+PqoOXdp1Kjg4GOPHj1e++4sWLYJGo4Gnp6dO+8DAQFSpUuWVf7TevXsXM2fORJs2bdC4cWP07t1b2Y6Eh4crPbXpQ+2nn34KU1NTnDlzJjfeYp6R/vu7ePFi2Nra4uTJkwCAmTNnwtjYGHv37lXazpw5E3Xq1EGjRo2Uz+V1Qi0D7UvSf5GvXbsGT09PmJiYIDg4GEDary0PDw/Ur18fgwcPxhdffIGmTZvC1dVV+SDyQqj97bffYG5ujqCgINy6dQu9evVC8eLFsWfPHmVlCwoKgpeXl4ErfX0RERHo0KEDZs2aBSDtMFr58uXRokULmJqa6oyDunz5MsLCwgxUaea2bNmCatWqwc3NDd27d1dC4Ny5c+Ho6IhmzZqhe/fu6NSp01sLUOml7wFv3rw55s6di4SEBFy5cgWdO3dGhQoVlF7v6OhoBAYGwtbWFiEhIW+1ztexYsUKlClTRundA4AjR47AwsICBQoUyDDuOjY2FkuWLEFAQADmzJmjE3hzy/Xr17Fjxw5cu3ZNZ/mwYcPwySefAAD8/PxgZmaGdevW6QRY7Y+f/EK77l26dAn3799H7dq14eLioqxbKSkp8Pf3R/369TFr1iyMHDkSpUuX1luPeXpt2rTBBx98kG3d2s/m2rVraNKkCe7evav3unLq1KlTqFu3rrJduXLlCooUKYJ+/fohPDxcaTd8+HB88cUXWR7pUwPt5/LLL7+gRIkSGDZsmBIiU1JSMG7cOKUjZMyYMRg0aBAsLCzw119/vdLrX7hwAdWrV0f79u3xwQcfoHv37ihbtiysrKywZcsWAGk9vtpQO3nyZIwaNQqFChV669t1fTp16pQSRLXbTj8/P6WDacOGDTrnHT179gxxcXF48OABFi5cqDz3dY8EMNBmYdy4cfDw8ED79u1RrFgxmJqa4tdffwWQ9st7woQJaNy4MXx8fDB8+HDlAzDUIZn0IfrZs2fo2rUrAgICAACPHz+Go6MjPv74Y53nfPvttyhbtmyeHzOb/r1p/z8+Ph6JiYn49ttvcevWLURERKB69er46KOPEB8fj88++wwajUanBycvOX/+PGxtbTFlyhTMnDkTFSpUQJ06dfDPP/8ASAu7U6ZMgY+PD6ZPn26wkLhjxw6Ympriu+++0wlxO3fuRNu2bVG8eHE0bNgQTZo0gZ2dnao2ztoQ+ODBA+XHxMmTJ1GyZEl07NhR6YF7G+OutSeAGRkZwcPDA+PHj8fNmzeRkpKC3bt3o06dOko9n376KYoWLYoVK1bkq17Zl23fvh3ly5fHiRMn8PjxYzRo0ADOzs7Kd+HYsWP48MMPUbFiRdSuXfutrXsNGzZEz549lfuZHfHp0aMHjh07BiDvjinfs2cPmjZtioYNGyp/u8OHD6No0aJo3rw5unfvjt69e6NQoUJ6+QH3th0/fhxWVlb44YcfdJZrP58ff/wRLVu2RLNmzTBkyBBcvHjxlV733LlzKFKkCMaMGaPTg33u3Dm0b98elpaWSg99aGgopk2bBgsLCxgZGeWrntkJEybAyckJO3bs0JkFpGPHjvjxxx9x+vRpFClSBAsXLlQemzNnDtauXavzOm+yvWWgzcRPP/0Ec3NzHDt2DNHR0Th//jz69esHY2NjJdSmpKRk2JAZ6oSj27dvY/HixTh16pSyrFWrVjh06BAePXoEW1tbDBkyRHls06ZNuHjxIu7du6eanp3bt29j586dANJ+5Y0cORKpqanKDn3WrFnw9PRUNiizZ89GjRo1UKZMGZ0TIAwlNTVVZ325fv06Jk+erNwPCwtD9erVUatWLSXUGtqTJ0/g6emJL774ItPHr127hnXr1mHUqFFYtmxZnl+XtBvZ9D+QTp8+jaJFi+KXX35Rftj9+eefsLS0RM+ePZXpsoAXwUVfQ1YaNGiAggULYvz48XB1dUWHDh3Qu3dvREREoEaNGvjss8+UtgMGDICNjY1OffmB9m8bHh6Orl27Yv78+cpjT548QYMGDVC5cmVlbG1MTEyGYTv6ru3TTz9F+fLldaZ1Sr9OPXz4EG3atFEezwtDnIAXdVy9elXZxgQHB6Nt27Zwd3fHuXPnALyYvaFLly7o1auX3mfzeFvmzZuHtm3bAkhblzZv3oxOnTrBzc0NP/30E4AXQzDSD0XKzuXLl2FsbIygoKBMH79x4waaNGmCChUq4OnTpwDStvVfffWVsg7nF48fP0azZs3QsGFDbN++XclDs2fPhrm5OQoWLKgTXqOjo9GyZUudk+XeFANtJqZOnYo2bdroLNNuYM3MzJRB/nlhaMH58+dRuXJldOrUSQl8QNoJXx07doSTkxM+/vhj5QsaFRUFHx8fLFy4MM9saP9LTEwMPvnkEzg4OCiHhlasWKHTZsCAAWjWrJlyf9SoUZg5c6bOySSGpP1b79+/H0FBQWjbti0GDhyo8yMoLCwM1apVQ/369XH79m0DVfrC06dP4ejoqEzP9bL04zjzOu13NSwsDNu3b9fppenQoQOsra2xbds2paf2yJEjsLS0xAcffKAzLCG3paam6hwhqV+/Ptzd3fH7779j9+7d6NmzJ2rWrAk7OzvUqlVL57BvRESE3uoypEOHDqF79+5o1qwZLly4AOBFZ4G2p7ZatWpv9QTW9NvK48ePw9TUFO+//36mh6QnTZoEd3f3PPX5pJ8/ukKFCpg7dy4ePXoEIG3aPW2o1fbUavcXef3o3X9J/7mtWbMGGo0GixYtgqenJ9q1a4e+ffti4MCBMDExQWhoaKbPy+61AwICoNFolB8DL3dqJScnY9WqVShcuLDOPN15ebad15F+LuamTZuiRYsW2LJlC5KTk/Hw4UP07t0b9vb2+Ouvv5CQkIC7d+/Cy8sLdevWzdUjGO98oM2s1+bbb79FyZIllUN82pV748aN0Gg0MDU1xYEDB3QeM4QrV66gWLFiGDduXIZevX379qFSpUqoUqWKzvLx48fDyclJOSkgL0s/p+S1a9fQtGlTaDQajBw5EoDuhSC2bNkCExMT9OnTBz179oSVlZXOFF55we7du6HRaNCkSRPY2NjA1tYWhw8f1tm4/fPPP7C1tcV7771n8NkM7t27h8qVKyvjndLXc/78ecyaNSvP/GDIjnYduXDhAmrVqoWePXuia9euSm8MAHTv3h1WVlY6ofbo0aPQaDQYOHCgXr7nV69ehZ+fHzp16oQvv/xSWV67dm1UrVpVOWR96NAhfP7551i9ejWAvNPjpy+HDx+GjY0NNBoN1q1bpyzXfo5PnjyBs7Mz3N3dX7kn7XUkJiYqf+unT58iKSlJWd/Xrl0LIyMjtGjRAsuWLUNCQgKCg4MxbNgwWFpa4u+//9ZbXa9rz549MDc3x/z58zMctdKG2vTDDwD1rmvautNvW58/f47PPvsMZcuWxeDBg5WAGRUVBTc3txz1RN++fRuRkZGIi4tDnz59ULhwYeV8Au2/rV1fY2JioNFosGHDhlx5b3lN+uy0d+9eTJ8+HSYmJqhduzZ+++03AGnbUh8fHxgbG6NSpUpwc3ODh4fHG50Alpl3OtCuW7cOvr6+uHr1KmJjY5XlZ86cQd26dfHZZ5/p/Mo+duwYPvroI3z00UeoUKEC7t27Z4iyAaSNk+3WrRs+/fRTneWJiYkIDw/H8ePH8dVXX8HFxQXvvfcehg8fjl69esHKykoV4xzPnj2LKlWqKIexY2Nj0bJlS9SvXx+urq7YunWr0jY1NRWRkZFYunQpmjVrhk6dOuWZHYp24xYREYEhQ4Zg6dKlSExMxOPHj1GjRg24urri5MmTOjuO+/fvv/XZDLLi5+cHS0vLDD1RY8eOzfZM77xC+3e9fPkyrKysEBgYqHMWfPpAlD7Uanumjh8/rpfxy+fOnYO1tTV8fHzQs2dPGBsb64Rad3d3lC1bFkePHs31fzuvunr1qtJreObMGVSsWBFeXl7KCXrAi53n06dP9XYUY+PGjTrr9datW1G3bl3UrVsXTZo0wcGDBwGk/UB1cnKCiYkJjI2NUb58eTRu3DjPbHu0UlNTkZycjF69emU4jyL9j9Tg4GA0bNgQLVu2VHXPrPY7v3fvXnz88cfo2bOnzkltL/ecjxs3DtWqVXvlk94SExPRvHlz2NnZ4enTp3j+/Dl69eql0wubvqNs165dqFat2ls5YdGQAgICYG1tjVmzZmHKlCmoUKECatSogd27dwNI+7vt2rULq1atwu+///7GJ4Bl5p0NtFFRUXBycoK1tTVcXV0xcOBAncl8Z82aBXd3dwwYMAB///03QkJC0K5dOwwYMAAHDhxA6dKl8ccffxis/qSkJDRp0gTff/+9smz37t0YMWIEihQpoozH/P3339G7d2906NABw4cPz3O9llmJj49Xxhxpw1RiYiLOnTuHfv36oVq1ajqhFoDyoySvnShz4sQJNGrUCHXq1FF2hkDa+3FxcYGLiwtOnTplsCEs2h3AqVOnsHTpUixatEjprXj+/Dnef/99FC5cGF9//TW++eYbfPzxxyhatKhymC2vi4mJQfv27TOcIKh93+k3qN27d4e1tTU2bNigt53633//jUKFCilXhEtJSYGfnx9GjBihM7yhefPmKFeuHP788888MbxJn65fv466deti2LBhyg+OP//8E05OTujWrZsy5Q+g36Fe58+fR5UqVdCuXTskJibi2rVrMDExweTJkxEUFIQePXrA2NgYixcvBpA2VdPZs2fx888/48qVK3n2EujJycmoU6cOPv/8c+V+etpZDfbv369z6F2ttmzZAjMzMwwZMgReXl6oV68eHBwclB9BqampCA4OxuDBg1G8ePFXns1A68KFC6hbty5cXFzw5MkTPHv2TAm12p5a7Xo6cuRIdOjQQdmf5QcvX8Hv+vXrcHBwUGZ0ANKOpNSpUwdVq1bFrl27Mg2uuT304p0NtMnJyQgICMCiRYtw5swZfPPNN7CyskKPHj0wd+5cJCcnY+bMmWjfvj00Gg0qVqwIV1dXAGm/8CpVqqQTTt62qKgoODs7Y/DgwQgJCcGXX36JKlWqoEuXLpgzZw6WLl0KZ2dnTJgwQXmOWg4fpd9h3b9/H2XKlMH777+vLDt+/Dj69esHFxcX5Qs0bdo0jBo1Sq+HIF9XVFQUmjRpAo1Gg1mzZul8DomJiahVqxbs7e0N0nOurWXTpk0oVqwYPD09Ub58ebRq1Urniktjx46Fh4cHatSogQ4dOuS5XqjsPH78GBUrVsS6desy/Q68vKx169YoX768zpCE3BIaGoqSJUuiW7duOst79OgBNzc3ODs7o2XLlsrc182aNUOxYsV0einzo9TUVIwaNQqNGjXC6NGjlZ7aI0eOwMnJCT179nwrvdXPnz/HsmXL0LBhQ/j4+GD+/PkYP368TpuJEyfCyMgoz/WeZxb00y9r27Yt3nvvPeV++otAzJgxQ9VzzKb377//olatWvj666+VZZcuXYK3tzfKly+Phw8f4smTJ5g5cybatWunjNN+FemHE1y5cgUeHh6oW7cunj59qoRac3NzJdROmDABJUuWVNUFi/5Lv379MHPmTJ1loaGhKF++PHbt2gXgxZjaR48ewdraGi1atMC6dev0/sP8nQ20ALBr1y4ULVpU2Tk/e/YMEydOhEajQaNGjTBjxgwcO3YMp06dwl9//aV8GJ999hlcXFx05uozhODgYBQsWBDlypVD0aJFsWjRImV6lcTERLRu3VpnvkS1BFptnUeOHMGePXuwcuVKVKhQAd27d1faHD9+XJkr0NPTE8bGxjh9+rShSv5PMTExeO+991C7dm1s27ZN55dpYmIiGjZsaLBxzQcPHoSNjY1y5bvjx4+jcOHCcHV11dlw/fvvv8q8gWpy6tQpaDQaZaeS2Ub12bNnOmfU62vO4tu3b6NevXp4//33lZ1eUFAQzM3NMX36dCxduhRVq1ZF+fLllblLW7ZsmS+mTUovsxkjUlNTMWHCBLi7u2P06NFKb+fRo0dRrFgx9O/fX29HX7799lusWbMGQNqJUMuXL0ezZs1QsmRJZT7r9D+WO3XqBG9v7zw3JdelS5ewfPlynbmMtev72rVr4erqitGjR+s8Z9y4cXBxcck3gfb27duwsbFRwhWQFt7Pnz+PunXrYt68eQDSehlf9YTP9Otd+vVAOz1krVq18OTJE2X4QbFixdCzZ0+Ym5vnq6m5ACjD5gAos6xoTyAeMWKE0i4pKQlJSUlo1KgRzMzMlLm09emdDrRA2tVl0v+hq1WrBh8fH4wcORKtW7fWOaP+4MGD+Pjjj1GsWLEcH6LQl9DQUJw+fTrD+J+UlBR069ZN6aFVQ5hNX+Mff/wBjUaDPXv2IDIyEuvWrYODg4NOqA0JCcHKlSsxcuTIPDOZv/Y9XLhwAZs3b8Yff/yhBKnIyEg0bdoU9evXzxBqDSUlJQXTp09XxtbdunULFSpUQI8ePdCzZ0+UL19e2QGoSfp1KSwsDJaWlpgyZUqWgei3336Dh4fHW5k8/tq1a/Dy8sL777+PQYMGoVSpUvj999+Vx+/evQuNRqMznCg/OnbsGGbNmqXzmWhDrYuLCwICApTDtMePH9dbqI+MjETfvn1RqFAhbNq0CUBaD9Py5cvh4uKCKlWqKDtu7Y587NixaNGihV7qeR2pqamIiYmBnZ0dSpQogSFDhqB79+64c+eOMh746dOnmDx5MmrUqIGGDRti+PDh6Ny5c6Zj5NVE+13X9gqmpKTA3d0d48aNy7Df8/DwwEcffZSj1w8LC0O3bt2wb98+neVff/01SpQogaVLl6JOnTrK8IOEhAR0794dZmZm+SrMvvy3XLRoEYYOHaoM4/j5559hbGys0zOenJwMX1/fDCc/68s7H2iXLl2KRo0a4cmTJ6hVqxYaNWqk/GoLCwvDunXrlF/hJ06cgJ+fn84lGPOihIQETJgwAXZ2dhmuOqQGYWFhWLx4sc5JMvHx8ZmG2rzol19+QalSpVC1alU4ODigbNmyyhnq2lDbqFEjbNiw4a2H2tDQUCxduhRLlixR5sn8559/cPbsWcTFxcHDwwO+vr4AXsyiUa5cOcydO/et1vk6Mut51Z5c17ZtW5QtWxaHDh3K9G8eEBCAvn37vrVL9l69ehWtWrVCoUKF8O233wJI22EkJiYiLCwMNWvWxMaNG5Xl+U1qaip8fX1RvXp1zJ07N8MPja5du8LW1haffPKJMvxAn27duoVhw4bBwsICv/zyC4C07ejq1auVyx2nH4IycOBAeHp6Ij4+Pk99PmPGjEGTJk1w4MABdOzYEfXq1UO3bt2UE3NSUlLwxx9/oGfPnmjdujUGDx6s6sPh6U8A+/LLL5VgPmLECDRo0CDDzAJdunRBYGBghnnBs3Pz5k14eHigbdu2OkdVihcvrly+9fLly6hVqxbc3Nzw+PFjxMbG5qlp23JD+r9XUlIS5syZg+rVq2PMmDHKLEvffPMNjIyM4OPjAz8/PzRp0gTVqlXTudCCPr3zgRYA6tWrB41Gg2bNmmU5qF8bavP62Z+rVq3C//73P5QuXVoVsxm8TNs7ZWFhga+++krnsfj4ePz888+oUKECvL29DVRh9v766y9YWVlh0aJFiIyMxNmzZzFq1CgUKFBAOaSpnSbG09NTL+M0s/L333+jXLlycHd3R4kSJeDk5KTsvIG0k3BcXFyUEwf//vtvtGrVCv7+/nny0p2ZuX79OgYMGAAg7YdFxYoVERoaitDQUFSuXBnVq1fHzp07leD68OFDjBkzBjY2Nm/9h+qNGzfQunVreHt7K1cSAtLGaDo6OuaLk3OyExcXh0GDBsHd3R2zZs3Smdd49uzZcHJyQseOHfUaDNLvpG/fvo1PP/00Q6hdsWIFqlevjgoVKqBv374YPnw4zM3N89RJkdrAcPjwYXTt2lWZluuPP/7Al19+CY1Gg169emU42pIfTjbctGkTzM3NMWXKFOXqXtHR0Wjfvj3c3d0xbNgwrF27VvlsX+fEaO1RlY4dO2Lw4MGwtrbWOaoCpHUAlC9fHg0bNswXf9f00n9PfH190bhxYwBpwd7NzQ2jRo1Svqf79+9Hhw4d4OPjgw8//FA5qvE2/ibvdKDVfkirVq2Ci4uLMgYzL/3izomQkBA0b94cnTp1yvO9yNlZtGgRTExM4Ovrm2Hy/vj4eKxcuRIuLi56G+f4JtavXw93d3edHqenT59i5MiRqFy5snLYNCYm5q1O4/L333/D3Nwc48aNQ1xcHPbu3Qt7e3u0a9dOGRN7+PBhlClTRgneEydORJ8+fVR1dm5wcDCMjIzQrFkzaDQa5QpAQNplbV1cXGBubq78oGjcuDHKli1rsB9/2h1lmzZtcPbsWXz99dcwMzNT5Y/R7Gi3qbdu3cKdO3eU8eJxcXHw9fVF/fr1dS6EMm7cOMybNy/D2dS54eUda/oxkVmF2tWrV6NOnTooUqQIfvrppzz7A+/Zs2eoW7cu+vfvryzz9fVFqVKl8Omnn8Le3h7lypXD7NmzM73apdpcvHgRDg4OmV78JTo6GgEBAWjUqBEqVaqEZs2avdHQisyOqgC669PVq1fz/BUT38S1a9fQqlUrnRmetKH2s88+U36Evzy2/G2NNX+nA61WWFgYbG1ts7x8nZo8ePAgz88N+ioWLlwIjUajMx5H69mzZ3n2kp/r169H4cKFlR12+hPcbGxsDHK2elZn1terVw+VK1dW1pfo6Gj4+PigcuXKqFSpUp4aK54T48ePh0ajQYMGDTI8lpCQgOnTp8PX1xfdu3fHvHnzDH5VtmvXrqF9+/YoVapUnj+58U388ssvsLe3h6OjI1xdXfHzzz8DSAu1gwcPhru7O2rVqoXu3bvD3NxcL2Nmtd/H27dvY/PmzZm2uXXrVqahduHChWjfvr1B5x9/FUeOHEGjRo1w8+ZN9O/fH7a2tkqvZEREBAYPHpxvTjLcvXs3nJ2d//MqXw8ePNCZa/51pT+qktWlj/OrZcuWoUmTJujYsSOeP3+uc7Q6KCgItWrVwujRozME+rf5o4mB9v999913KFGihKrHE6lN+hOogoODdeawA4Dvv/8eGo0GM2bMyJM9Cdqazp8/j+PHjyvzVtatWxeTJk3SmQXj/v37cHZ2NsjcxZmdWa89DOnu7o4OHTqgX79+WLt2Lfbv348VK1Zg6dKlqhp/nX79WLFiBfz9/TOE+Lc1PvZ1hISE4P3331cOmeYX2s/l/v37sLe3x5IlS7B+/Xr873//Q4ECBZQTbuPj47FixQoMGTIEvr6+ev07REZGwtbWFhYWFmjQoAHWrl2b4aTS69evZxpq81JnQfqLhqSfRu/u3bt47733UK5cOVSsWBGnTp3SaZ+fLFy4EKVKlVLup+8J1M5OlNvSH1XRbk/zu/j4eEyaNAlOTk5wcXFRlqffpn711Vewt7c36EnEDLT/78aNG+jbt+878UsrL0h/bfEyZcrA1dUVVlZWaN26Nc6fP698Dt9//z1MTU0xdepUQ5abQfr5W21tbfHVV18pQwgmT56M6tWrIzAwEJcuXcKjR48wduxYlC1bNsMlit+Wl8+st7a2xsaNG3H37l1s2bIF06dPh7W1NZycnNC5c2eD1Pi60veCr1+/XhkH//vvv6NEiRIZeqbz2vyhWnlxDuXcEBwcjDlz5uhMF/Xo0SOMGzdOZxaZzC50oQ+PHz9Gjx49sG7dOsyZMwfdunWDnZ0d5s6dq7NuhIaGws/PDxqNJsNFXAwt/fanbNmy+Pbbb3WGMP34448oUKAAfv31V0OVqDchISHKj+3Q0FAUL14co0aN0mmTmpoKPz8/zJkzRy/rk/aoSoMGDZRLVOcnmeWgBw8e4Ntvv4WFhYXOFefS99T+9NNPBp29h4E2ncyu/0y5I7MvyN69e1GsWDFl/NPZs2eh0Wjw3nvv4cyZM8rnMWPGDBQvXjzPXYVn//79KFKkiHICWHpTp05FgwYNYGRkhFq1asHW1tbg4yK1Y8DMzMzwzTffZHj80aNH2LBhgyp7Zjdt2gQLCwtMmzZNOZyanJyMPXv2oHjx4ujatSv++ecfTJgwAa6urnoZm0lpY18HDhyo3I+Li8PAgQOh0WjQqlUrnbbaUGtsbIwffvjhrdb59ddfo2LFisq8yps2bULbtm1Rrlw5fPTRRzh//jwSExPx9OlTfPbZZ3lmWsD0goODUbhwYSxYsCDDtjE8PBxeXl7KibX5oXc2NTUVoaGhqFixIoYOHapsp2bMmAFHR0cMHz4csbGxuHLlCiZMmIDixYvr9cqYV65cQdeuXfPseOrXlX5fferUKQQHB+tcOXLGjBmoWrUq/P39lXYvH/0yVIZioCW9035Bbt++jW3btgFI+1U3YsQITJ48GcCL+U/79++PChUqoEGDBjh9+rTy3CdPnhik9sxodw7Dhg1D7969dR5L/2v1/v372LVrF/bu3Ztnxt1lNQZMbb2D6XfQ+/fvh6WlJZYtW6azIdX2zOzfvx8lS5ZExYoVYWNjk2/HqOYFv//+e4aryF24cAGffvopChQokOHM8MePH2PYsGGwsrJCVFSU3oNX+uvHd+zYUediGm3btkXlypXh6uqKOnXqoGbNmjoX1DGk9DM9aP9GAwcOVGb00Epf66hRo2Bvb6+67/Z/mTt3LqpXr47hw4cjLCwMsbGxWLRoEUqXLg1ra2tUrFgRFStWfCsdCHl91qOcSv/9CwgIgKOjI1xcXGBjY4P+/fsjJCQEkZGR+Oqrr+Di4pKhZ9zQGGjprfjnn39QsmRJVK1aVTmLfs+ePbh06RKePn2KevXqYdCgQQCAffv2QaPRoE6dOnlqahwt7Ze+bdu2GDx4MICMv0hDQkLy7I5EzWPAxo4dm2FHNWHCBPj4+ABI6xE8ePAg+vfvjwEDBmDHjh0A0oLTzp078+TMGPnRnj170LNnT+X+tWvX0L9/f1haWmYItU+ePNH7Vaq031ntuPbk5GSMGDFCuaR2//79Ubp0aWXe4nXr1qFHjx55YraYyZMnw8/PL0MvWIsWLTBy5EgAGbc/4eHhuHXrFqpXr67a6d+Sk5OVz+3lbenChQtRuXJlJdQCaevRli1b8OeffxpsaFd+MXfuXNjY2CidHv7+/ihSpAgOHjwIIG17+s0336BkyZL47rvvDFmqDgZaeiv279+PAgUKKCcnrVu3Tnls8+bNqFu3rnKoeNeuXXj//fdRq1Ytg10O9lUMHToUTk5OytRi2t6Rhw8fYvLkyXl6hgA1jgGLiYlB3759dXoAU1JSlKl51q5di27duqFt27Zo2LAhevToARcXF4PPYvAu2rlzJwoUKIAPP/xQWRYSEoIBAwagWLFiyoT0b9PGjRthY2OjhNYnT57A0dER5cqVg42NTYYfSnll6NnOnTuVk+TSn6nfvXt31K5dW7mvrTc8PBzTp0/HX3/9ladOYntVL38OBw4cwJdffpnhUvMLFiyAra0t/Pz8VDVMSg169+6NL774AkDa/tnS0hILFy4EAOViIo8ePcLq1avzzPcEYKClt2jAgAFwc3NDly5d0KJFC2WO0IULF8Le3l75pR0YGIhJkyblmS+Ktpfgn3/+QWhoqDLH7IULF+Di4oJ27drpzJcbGBgIJyenPN9LoMYxYNp1Ys+ePTh58iQA4PTp02jcuDHKly+PDz/8EL/99hsAYPv27XB3d89zY6/fBYmJifjtt99gaWmpMywnJCQEgwcPhkajwf79+/Xyb6c/7K7t2dNevnTRokU6bQICAlC2bFmdYSh5abxp+vcSHBwMX19f5Yfy0aNHUbFiRfTp00fnOePGjUPlypX13uutDzt27ICzszMWLFigLAsICICVlRVmzJiR4SIb48ePR/HixTFkyJB8MxXZ2/by+v7s2TO0aNECwcHBOHbsmHKeCJD2fZozZ06Goyx5ZV/NQEu57uUxZ9pDZTt37kT//v3x+++/o3PnzmjatCm2bNmCp0+fwt7eHk5OTmjUqFGevLb4L7/8gurVq6NkyZLo06ePEpp++eUX1K5dGw4ODujcuTPatGmD4sWLG/wEsFelxjFgCQkJ6Nq1KzQaDU6cOAEA+PfffzNcqCIgIAAeHh55avx1fqTdId68eRN//fWXztXvdu7cmSHUXrp0CX5+fno90Sr9YfZjx46hW7duaNGiBUJDQ3V2vocOHYKpqSn27Nmj817yCm09T548wbFjx2BhYYGPPvoIV69eRUpKCn788Uc4OzujevXq+PDDD9GhQwdYWVmpZvvzsitXruDDDz9E48aNlR5BIO0iLw4ODggKCtLpqf3xxx9RuXJlNGrUKN9davZtSL+vTj9l6fDhw2FtbQ0zMzOsWrVKWf748WM0b94cs2bNeqt1vioGWspV2i9IaGhohonLHz58CGdnZ+UKQJ07d0ajRo2wY8cOPHjwAKNGjUJAQECeGLcGvHgvly5dgoODA2bNmoWlS5eiefPmaN68uTI/ZWhoKMaNG4dBgwYhMDAQV69eNWTZ74T79++jT58+KFKkSIaLVRw8eBCjRo2ChYVFnhyDnR9t2rQJxYsXR/ny5WFra4tff/1VOSlPG2rTDz/Q5/jyuLg4NGzYEDVr1gQALF++HBUqVEDx4sWVkzPTT+U0dOhQNGjQIM/OfLFhwwaUKlUKCQkJ2L59O8qUKYOBAwcqE9hfvHgRQ4cORe/evTFixAi9ntn/NoSEhMDX1xceHh46c5qOHz8eDg4O+PLLL5WhaIGBgVixYgWPwryG9D/eJk+ejMaNGyvnt1y6dAlt2rRBpUqVEBkZiZSUFDx8+BBeXl5o0KBBnumRfRkDLeW60NBQlChRAhqNBm3btsX69euVkLd9+3Y0adIEDx8+xOXLl9G5c2c0b94cGzduNHDVL6S/bO3FixcxdepUjBs3Tll25coVdOnSBU2bNsXatWsNUeI7Jates/DwcHTv3h1FixZVhh/8888/6NWrF5o0aaJMNUP6k5qaivv378PNzQ3z5s3DqVOnMHDgQJiZmWHlypXKEYDffvsNGo1GOfFTn5KSkrBt2zbUqFED3t7eANKOpJQtWxY+Pj7KUCDtTnnevHmoUaMGHj16pPfaspPdUIn58+cr34Nt27YpoVbt4VX7nuPj4xEVFaX07l+7dk0Jtelnopg0aRKqVauG6tWro2XLljA3N88zHSBqNWHCBJQoUQJ79+5VjmykpqZi06ZNaNiwISwtLVGnTh3UqVMHdevWVdbNvBhqGWgp1925cwd169aFh4cHateujUGDBqFcuXJYvHgx1q9fj/bt22PXrl0A0n4Jenp6on379oiKijJw5S92INorejVs2BBFixbVOWMbSKu7c+fO8PT0xOLFiw1R6jtBuxM/cOAARo4ciSFDhuDHH39UHn/w4EGGUBsWFpZne9vyi/RzdsfGxiIgIEDnh6Cfnx9MTU2xcuVKZQe4Z88evc/nqg1ISUlJ+O2331ClShV4eXkBANasWQN3d3f0798/wwlGeWW8e3ZDJdL3amtD7dChQ3WGF+S1IRPZ0X5W165dw+DBg9G7d2+dQ9khISHo379/hlD7yy+/YOrUqRg+fLjqA72hXbt2DW5ubsp0msCLdSg1NRUPHjzAwoULMXfuXKxfv15n2ru8iIGW9OLatWvo3LkzfHx8sHnzZmzZsgXNmzeHj48PNBoN6tevr/TehISE5Jl5Wm/evAkPDw+0a9cOV69eRUhICJo0aYLKlSsrIVzr8uXL8PT0RIcOHfJEGM8PtDu59OFo8+bNKF68ODp37oxPPvkEGo0GkyZNUk7Ee/DgAXr37g2NRsM5Zt+iX3/9FT169EDt2rXRsGHDDN9hPz8/FClSBIsXL9bbEAPt+pL+9dOH2l27dumE2pUrV6J+/foYOHBgngmxWq8yVCL9+9y+fTvMzc0xfPhw1Y2F135G58+fh729PUaPHo3t27crj2u/25cuXco01ALqCu95xcvnt5w8eRIWFhaZznST1Xc2L/bMajHQkt6EhITA29sbrVu3xtWrVxEbG4tjx46hffv2ykDzvLhRunbtGlq3bo1WrVrh8uXLuH79Oho1aoQOHTpkOLszL4Xx/OLevXuoVq0aHj16hFu3bsHOzk45yzY8PByWlpbQaDQYOnSocsJheHg4fH192WPzlhw9ehRmZmbo27cvWrVqhYIFC+Lzzz/P0DOund9Vn9NH3blzByNGjMgwnRvwoqe2atWqyhjeJUuWoFq1avjkk0/y1M75VYdKpO8d27Vrl2qnrLp+/TpsbW0xZswYneUzZ86Eq6sr7t+/D+BFqG3SpAlmz55tgErznzNnzgBI+0Hh6Oioc2ln7T55y5YtynZXLRhoSa+04bB169aqmsQ/fd1Xr17FlStX0LhxY7Rv394gc2i+S0JDQ+Ho6IjevXtj9erVmDZtGoC0oFuuXDl88sknWL9+PQoUKIDAwEDExcUByPzyypT7bt++jfHjx+scHh47diwcHR0xc+ZM/Pvvvzrt9X32uXanPHToUGW+VkC3t3/lypWoVq2a0hO1aNGiPDU/cU6HSuTVQ76vIjU1FcnJyfjss8/QtWtXnVlIvvzySxQpUgSVKlVC1apVdUJt165d0bp1azx9+tRAlecP2pl5tD2wTZs2hYuLi05nwPPnz9GhQwd8/PHHhirztTDQkt6lvzJV+sut5nWZhdrmzZujSZMm2Ldvn6HLyzde7qVPTk7G119/DXd3d6xYsQKnTp3C8+fP4eXlBV9fXyQnJ+PRo0dwdHSERqNRrpZE+nf9+nW4u7vD3t4+Q2/Z6NGjUa5cOcyePVtnDtS3cRTmr7/+Usbrpw+12h7YyMhIlCpVKs/08OWnoRKvq169ehg2bJhy//Lly2jdujV2796N06dP47333kOVKlWU93vjxg0l4NLru3XrFszMzPD9998DSJsSrmbNmqhYsSLGjRuHoKAgNG/eHNWrV1fdDycGWnor1HhlKkA31F67dg0XL16El5eXai8nmddod+IvzxX79OlTuLi4oGPHjgCAR48eoWbNmti5cyeAtKuGDRkyBBs2bOAwAz17OZBOmTIFtra2aN++fYZwFRAQgKJFi2L+/Plvvcf87NmzSqhNP6dmUlISYmJi0KZNG2zZsgVA3hjqlF+GSuRUUlKS8oN05syZAF687/Qn6x0/fhxWVlYYMWJEnvi81Ej7d335EsITJkxAhw4dlB+eqampGDp0KDw9PdGkSRMMGjQoT89mkBUGWnpr1HhlKiAt1LZt2xbu7u64fv26XufQfBfduHEDJUuWRMeOHfHgwQNlCMGJEydgZmaGb7/9FnFxcTAzM8MXX3yBe/fuITAwEFWrVuXhx7fk6NGjOrN5fPnll3B1dcWYMWOUK/xpTZ482WBXbdKGWl9fX+Xs/8TEREyePBmOjo55atuTH4ZKvKqgoCAMHz5cZ1mnTp1QuXJlnSEpqampyvsPCwuDt7c3NmzY8DZLzReio6N17r+8zmzbtg3FihXL0LmUmJioc9VL9tASZUNtZ+NqXblyBZ07d85TO8T84tq1a7CysoJGo0Hr1q0xZ84cXLhwAQAwcuRI1K5dG1euXMHSpUuh0Wjg5OQEa2tr1V4NSW1iY2MxcOBAVK5cGUuXLlWWT506FbVq1cLo0aPz1GHwc+fOoUmTJqhWrRo6deqErl27okyZMnnu6oOA+oZKvI7U1FQsWLAAGo0GEydOVJYvWbIE1tbWGDRoUIZp1IC0XkRXV1eedJtDo0aNwvDhw5Wx7Bs2bEDRokUxcuRIHDp0SGn3wQcfoEWLFhnCr5Yae8U1ACBE9J8SExPFxMTE0GXkC6mpqVKgQAFJTk6WggULynfffSd37twRc3Nzefz4sZw5c0amTZsmJUqUkA8//FD69OkjEydOlHPnzsnjx4/F2dlZ7O3tDf023hkXLlyQBQsWyMmTJ2Xo0KEyePBgERGZNm2a/Prrr1KvXj2ZMGGC2NraGrjSNKGhobJlyxY5fPiw1KpVS7p16yaVK1c2dFmZ+uuvv2TQoEFSu3ZtGTlypFSrVk1ERJKTk+X58+fStWtXGTp0qPj4+AgA0Wg0Bq445xITE2Xt2rXy0Ucfib+/vwQFBYmIyMCBA2Xr1q3StGlTmT59upQvX15CQkJk+fLl8tNPP8nhw4fFzc3NsMWrjJ+fnxw/flzatWsnn332mURGRsqff/4pM2bMEGNjY7GwsJAvvvhCzpw5I7t375bPP/9catSooWyTVc3AgZqI3iHaX/3aKwJpHThwAF5eXti1axfi4+Px/fffw8rKCrNmzUKbNm1gZWXFy9i+ZS/PVnDx4kUMGjQItWvX1umpHTt2LJo2bapzIhjljJqGSuREamqq8p2/ceMGZsyYAY1Ggy+++EJp4+/vDycnJ5iYmKB06dJwcXFB3bp1+X3PofQ9quPHj0etWrUwadIk5XscERGBAwcOwNvbGw0aNED9+vXz3Um1DLRE9FaFh4fDwcEBgYGBOjvq6dOno2TJksqYzMOHD2PAgAFo164dNBoNOnTogOTkZFUeClObs2fPomnTpspJVFoXLlxAjx49UKVKFZ3LPr8cfinn1DRUIqc2bdoEZ2dnfPjhhyhVqhQ0Go3O5cT//vtv/PTTT5g5cyb279/PH0evIf2PBwAYM2YMatWqhQkTJmSYOu+PP/7A3LlzUbZsWVSqVEmZl1btGGiJ6K16+vQppk6dCktLS7z33ns64wP79euHfv36KRPxR0REYN++fWjXrh3Onz9voIrfPYcOHULr1q3h6emJX3/9VeexAwcOoGjRorCzs8OyZcsMVGH+dPfuXcyZMwddunTB559/jqtXrxq6pDd2+fJlFC1aFAsWLEB8fDxu376Nb7/9FgULFkRAQIChy8sX0gfZy5cvK/8/duxY1K5dGxMnTsz0R+e5c+dQsWLFfHP5dgZaIjII7WTpFStWRPPmzRESEoINGzagX79+GS5ewV5Z/Uh/3faXHTp0CD4+PmjWrJnOZUkvX76Mtm3bYsyYMao8457erv3796NixYo6va6xsbH46quvoNFo8O233xqwOvVLPz3erl27UKdOHZ0foZmF2uTkZOV5o0ePRrNmzXQuN65WKh8BTERqVa1aNVm8eLHMmTNHoqKipG3btnL27Fm5ePGibNy4UaetGk+EUQONRiOJiYmi0Wjk1KlTsm7dOvnhhx8kMjJSmjRpIoGBgVKsWDH55ptvZM2aNRIfHy+rV6+WEiVKyLhx46R8+fKGfguUxxUvXlzu3Lkj58+fV5YVLlxYfHx8xNLSUkaPHi3Tp083YIXqlf5Erh07dsgvv/wiN2/elC+++EJ27dolIiJfffWVtGrVSnbt2iXz5s2Thw8fipGRkbJNDQ0NFUtLS/WfECbCk8KIKG8YMWIEvLy8YG9vD41Ggx9++MHQJeVb8+bNQ8uWLZX769atQ+HCheHs7AwbGxvY2tpi3bp1AIDTp0/D19cXZmZmcHZ2RvHixfPFuE7KfZn19MfGxuL9999Hp06dcPr0aWX5kydP8MEHH2DJkiW8OEoOvXzRklGjRqFs2bKYPn06/P394ejoiKZNm2Lr1q1Km4CAAJQpUwZLlixRXuPJkyewtbXFyZMn32r9+sJpu4jIoJBuKqIDBw7I7t27lSminJ2dDVxd/gJAUlJSZP369TJ27Fhp2LChrFmzRrp06SKdO3eWjh07SuHChWXIkCGyd+9emTNnjnTr1k0iIiLk5s2bEhoaKg0bNpRy5coZ+q1QHqP9Hh8/flwuXrwo9+/fl65du0qVKlXkwIEDMnnyZClevLgMGTJEqlatKj/88IPs2rVLDhw4IMWLFzd0+ap17tw56dixoyxbtkxatmwpIiL79u2TmTNnSmRkpEycOFG8vLxERGThwoUyZMgQMTIyUj6vhIQEMTU1NeRbyDUMtERkcHhpfs3o6GixsLAwYEX5U1hYmJQpU0bi4uJk9+7dMmrUKClfvryYmprKvHnzpGLFikrbDz/8UA4cOCBXr14Vc3NzA1ZNarFp0ybp37+/1K1bV65evSpmZmbSpUsXmTZtmhw/flwWLlwomzdvFkdHR4mJiZHffvtNatWqZeiyVeODDz6QGjVqyJgxY5RlV69elUaNGsmaNWukTZs2yvLg4GDp1KmTVK9eXQIDA6VDhw7KYykpKWJkZCQiGbe9apYPBk0Qkdq9vEFlmM1927dvl7Jly8rhw4elcOHC4uXlJTNmzJDIyEg5dOiQFCpUSERE4uLiRETk+++/l+fPnytj8Yiyc/XqVfH395e5c+fKnj175P79+zJo0CA5fvy4TJkyRZo1ayarV6+WS5cuyfr16+XcuXMMszkQExMjrVq1kpEjR2Z4zNraWq5evSqpqami7aNs2bKl1K5dWwDI0qVL5e+//1baa8OsSP46P4GBlojoHdCgQQPp2bOntG/fXo4cOSKFCxcWb29vCQwMFCsrKxk4cKCIpJ2wI5IWbIsWLcreWXoljx49ktTUVGnYsKEYGxuLiEhgYKC0bt1aNm7cKGFhYWJiYiJVqlSR2rVri42NjYErVpeiRYtKv379xNjYWJYsWSIDBgwQEZEqVapIp06dZOzYsbJt2zZJSUkREZHIyEixsbGRPn36yIULF+TYsWOGLP+tYKAlIsrHtD02pUqVku+++07ef/99adOmjRw5ckSKFCki7dq1k++++07OnTsnbdq0katXr8rFixdl8eLFEhMTo1yKlSgz2vUrNTVVRETi4+NFJO1ytyIiEydOlMjISNm2bZthCswHtCFVJG3YUHh4uBw7dkyGDx8uIiJffvml9O/fX3r37i1+fn4yceJE8fHxkTt37siwYcOkYsWKsm/fPkOV/9YUNHQBRESU+7RT+mgPKQKQkiVLysyZM0VEpE2bNvL7779L48aNpW3btjJv3jwZPny4uLm5Sbt27USj0cju3bs5NRdlkH7cpfa/jRs3lqJFi8qoUaNkz549YmJiIiJp4+ErVqwodnZ2BqtXzeLi4pSjJn5+flKoUCH5+OOPpUiRIrJ8+XIZNmyYfP/997Jw4UKpUqWKHDlyRP7++29xdHSUZcuWiUja5/Uu/DDlSWFERPlUSEiIrFq1SoYMGSJlypRRxs49fPhQ/P39ZcuWLUqo1Z4oNnLkSKlbt678/PPPSigh0tKG2ZMnT8qxY8fExMREHB0dxcvLSy5fvixeXl5SoUIFmTZtmpibm8u2bdtk8eLFcuLECXF0dDR0+aqycuVKuXfvnkyYMEGuX78uHTp0kB9++EGaNGkiT58+laVLl8rKlSulRYsW8v3334uIyLNnz8TMzEw0Go3Ex8dLUFCQLFmyRA4dOiRVqlQx8DvSLwZaIqJ8KCkpSRo1aiSnT5+WihUrSseOHaVevXrSvXt3EUnr+Rk0aJBs375dCbUxMTGyb98+qV69us6MB0Tpbdq0SQYMGCCurq4SFRUlISEhMnr0aPnyyy/l2rVr0qNHD3ny5ImIiJibm8uaNWukdu3aBq5aXZYsWSJDhw6VQ4cOyalTp+TKlStiZGQk8+fPVy6C8OTJE/nxxx9l1apV8t5778mcOXOU59+7d0+mTZsmu3fvlh07doibm5th3sjb9DYnvSUiordnxowZmDVrFvbs2YPJkyejWLFi6NOnDxYuXIjU1FRERkZi0KBBKFq0KIKDgwHwMsOUvWvXrsHGxgYLFiwAADx+/BirV6+GmZkZxo8fr7Q7d+4czp8/r3PJW3o1P/30E4yNjbFz504AaRdO0Gg0aNSokfL91F5c4fHjx/j2229hbW2NOXPmKK+RnJyMs2fPvlOXp2agJSLKp/bv3w8LCwucOnUKAHD//n1MmTIFZmZm8PDwwJIlS3D48GH07dsX9vb2iI+PZ6AlxfLly3Hnzh2dZUePHkWVKlUQFhams3zFihUwMzPDgQMH3maJ+c7y5cuh0WjQqlUrZdm///6LoKAgaDQaLF68GEDaD09tqP3333+xZs0aJCcnG6TmvIKzHBAR5VPNmzeXIUOGyJw5c+T58+dia2srV65ckfLly0ulSpVk7dq18t5774m9vb0cP35cChUqlK/mpaTXFxMTI+PGjZPOnTtLWFiYstzU1FSuX78uN27cEBHRmffUzs5OwsPDDVJvfvDDDz/IwIEDZeDAgXLp0iUZNmyYiIiULFlShg4dKhMmTJChQ4fKqlWrRKPRiEajkdTUVClZsqT07t1bjIyMdGZEeNdwlgMionysfv36MmvWLDExMZFBgwbJgQMHJDg4WKpXry4hISHyxx9/SIsWLaRMmTKGLpXykKJFi8qpU6fEy8tLunTpIr/88os4ODhIpUqVlFkxrKyspGbNmiKSNrm/lZWVMl0X5cycOXPE399fdu7cKd7e3rJ48WKZMGGCaDQa+e6778TKyko+++wzASC+vr6i0Wjkgw8+yPADNP1FE941PCmMiCifa9asmRw5ckRsbGxk165dSgghSk871Zv2ilNGRkYSFhYmnp6eYmlpKZs2bZIyZcrIhg0b5Pvvv5cSJUrI0KFDpVy5crJy5UpZvny5nDhxglO9vYaDBw9KeHi49OzZU0REoqKiZP369TJ+/Hjp1auXfPfdd8ryWbNmyfTp02XXrl3i5eVlyLLzFPbQEhHlU/j/KZbGjh0rERER8vXXX0vNmjXz1fXbKXdow+y1a9fku+++k3/++UcaNmwoo0ePlj/++EM8PT2lU6dOsn37dunevbsUKFBA1q1bJ23bthVnZ2dJSkrivMVvoFmzZiLy4jtraWmphNvx48eLiMh3330nlpaWMmLECHFwcBBPT0+D1ZsXsYeWiCife/DggTRu3Fh69uwp06dPN3Q5lMdow+zff/8trVq1kkaNGomZmZn88ssv8uWXX8ro0aOVnlpzc3PZuXOn2NraSlJSkty4cUMAiLW1tVhbWxv6reQ70dHR8vPPP8uECROkd+/eOlNziYgkJydLwYLsmxRhDy0RUb5XunRpmTx5sgwdOlQ6dOgg7u7uhi6J8ghtmD1//rx4eHjIyJEj5YsvvlBONvrnn38kPj5eypQpI3v37pWOHTtKu3btZPv27VKmTBmpWrWqod9CvmZhYSE9e/YUjUYjH330kZQvX15GjBihPM4w+wJ7aImI3gH//POPfPDBB7Jq1SqeAEY67t27J7Vr15YWLVrIhg0blOU9e/aUkJAQef78uZQvX158fX2lYcOG0rFjR4mNjZX9+/eLvb29ASt/d0RGRsrBgwelffv27/SJX9nhtF1ERO8Ae3t7+e233xhmKYOUlBRxdHSUhIQE+fPPP0VE5KuvvpIdO3ZI165dZfTo0XL37l2ZMGGCxMXFyZYtW8TKykqSkpIMXPm7w8rKSjp27ChGRkaSnJxs6HLyJPbQEhERveOuX78u//vf/8TExERKlSol27dvl1WrVknr1q1FRCQ0NFTKly8vCxYskKFDh3LsJuU57KElIiJ6x1WqVEnmzp0rz549kzVr1siYMWOkdevWAkCSkpLEyMhIXF1dpWTJkiLCsZuU9zDQEhERkVSuXFkWLlwoTZo0keDgYDl8+LBoNBoxNjaWxYsXS0xMjNSvX9/QZRJlikMOiIiISKEdfgBAgoKCZO/evTJ58mQ5evSo1KpVy9DlEWWKgZaIiIh0XL9+Xfz9/eXkyZPy9OlTOXbsmNSpU8fQZRFliUMOiIiISEelSpXk22+/lQYNGshff/3FMEt5HntoiYiIKFNJSUlibGxs6DKI/hMDLRERERGpGoccEBEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGqMdASERERkaox0BIRERGRqjHQEhEREZGq/R9PzznFGviq/gAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "x_train.columns" + "plt.figure(figsize=(8,6))\n", + "plt.xticks(rotation=45)\n", + "plt.axhline(y=5, color='r', linestyle='--', label='Importance Threshold')\n", + "sns.barplot(x = x_train.columns,y = model.feature_importances_*100)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "***Important Features*** based on **AdaBoostClassifier**: based on percentages (descending order)\n", + "***Important Features*** based on **AdaBoostClassifier**: based on percentages \n", "\n", "* **'Triglycerides'**\n", "\n", @@ -5219,26 +5370,25 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 91, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Accuracy: 0.9070735090152566\n" + "Accuracy: 0.8779472954230236\n" ] }, { "data": { "text/plain": [ - "array([1.93701995e+00, 4.68730697e+00, 3.02995274e-01, 2.28137369e-01,\n", - " 7.02390195e-02, 1.34819874e+01, 6.65235169e+00, 1.36211611e-02,\n", - " 1.79365716e+00, 6.17837269e-01, 2.84970568e+01, 7.88522668e+00,\n", - " 3.38325632e+01])" + "array([ 2.33636143, 4.45864628, 0.24718341, 0.30719007, 0.16108625,\n", + " 19.1553376 , 3.23450899, 0.03687309, 1.6609577 , 0.78870594,\n", + " 34.87980522, 10.42812006, 22.30522396])" ] }, - "execution_count": 41, + "execution_count": 91, "metadata": {}, "output_type": "execute_result" } @@ -5261,32 +5411,42 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 92, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Index(['Age', 'Sex', 'Marital', 'Income', 'Race', 'WaistCirc', 'BMI',\n", - " 'Albuminuria', 'UrAlbCr', 'UricAcid', 'BloodGlucose', 'HDL',\n", - " 'Triglycerides'],\n", - " dtype='object')" + "" ] }, - "execution_count": 42, + "execution_count": 92, "metadata": {}, "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ - "x_train.columns" + "plt.figure(figsize=(8,6))\n", + "plt.xticks(rotation=45)\n", + "plt.axhline(y=5, color='r', linestyle='--', label='Importance Threshold')\n", + "sns.barplot(x = x_train.columns,y = model.feature_importances_*100)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "***Important Features*** based on **GradientBoostingClassifier**: based on percentages (descending order)\n", + "***Important Features*** based on **GradientBoostingClassifier**: based on percentages\n", "\n", "* **'Triglycerides'**\n", "\n", @@ -5294,9 +5454,7 @@ "\n", "* **'WaistCirc'**\n", "\n", - "* **'HDL'**\n", - "\n", - "* **'BMI'**" + "* **'HDL'**" ] } ],