From c61dc772bfc57162e600ed375806b75385f6404c Mon Sep 17 00:00:00 2001 From: waddason Date: Tue, 17 Dec 2024 14:29:00 +0100 Subject: [PATCH 1/2] Fix typos in notebook --- .../01-cross_validation_and_metrics.ipynb | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/03_generalization_and_cv/01-cross_validation_and_metrics.ipynb b/03_generalization_and_cv/01-cross_validation_and_metrics.ipynb index b1f7f76..dddadbd 100644 --- a/03_generalization_and_cv/01-cross_validation_and_metrics.ipynb +++ b/03_generalization_and_cv/01-cross_validation_and_metrics.ipynb @@ -10,7 +10,7 @@ "\n", "## Table of contents\n", "\n", - "* [1 The benefits of cross-calidation](#benefitscv)\n", + "* [1 The benefits of cross-validation](#benefitscv)\n", " * [1.1 Load our dataset](#benefitscv_load)\n", " * [1.2 Empirical error vs generalization error](#benefitscv_empirical)\n", " * [1.3 A single error is not enough... what about the variance?](#benefitscv_single)\n", @@ -23,7 +23,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "A core question in machine learning is how to evaluate the performance of a model once it's parameters are estimated (i.e. the model has been trained). In this notebook, we aim at presenting how you should answer this question in a statistically sound way. First, we will present the benefits of using cross-validation for this task and then have a quick look at different strategies and metrics that one should use in supervised learning." + "A core question in machine learning is how to evaluate the performance of a model once its parameters are estimated (i.e. the model has been trained). In this notebook, we aim at presenting how you should answer this question in a statistically sound way. First, we will present the benefits of using cross-validation for this task and then have a quick look at different strategies and metrics that one should use in supervised learning." ] }, { @@ -465,11 +465,11 @@ "

Generalization error:

\n", " The aim of model training is to select the model $f$ out of a class of models $\\mathcal F$ that minimizes a measure of the risk. The risk is measured with a loss $l$ between the true value $y$ associated to $x$ and the prediction $f(x)$ and thus we want to find: \n", " $$\n", - " f^\\star = \\arg\\min_{f \\in \\mathcal F}\\mathbb E_{(x, y) \\sim \\pi}[l(f(x), y]\n", + " f^\\star = \\arg\\min_{f \\in \\mathcal F}\\mathbb E_{(x, y) \\sim \\pi}[l(f(x), y)]\n", " $$ \n", " The issue is that we cannot compute the expectation $\\mathbb E_{(x, y) \\sim \\pi}$ because we don't know the input distribution $\\pi$. Therefore, we approximate it with a set of examples $\\{(x_1, y_1), \\dots (x_N, y_N)\\}$ drawn i.i.d. from $\\pi$ and use the Empirical Risk Minimization (ERM):\n", " $$\n", - " \\widehat{f} = \\arg\\min_{f \\in \\mathcal F}\\frac1N\\sum_{i=1}^Nl(f(x_i), y_i]\n", + " \\widehat{f} = \\arg\\min_{f \\in \\mathcal F}\\frac1N\\sum_{i=1}^Nl(f(x_i), y_i)\n", " $$\n", " If the samples are drawn independently, we know that the error has a variance of $\\mathcal O\\left(\\frac{1}{\\sqrt{N}}\\right)$. Thus there is a gap between the minimizer of the risk and the minimizer of the empirical risk. If we optimize too much for the ERM, the gap might be big and the selected model will have bad performance on unseen data. This is what is called overfitting. To control, this, one need to have a measure of the risk independent from the measure of the risk which is used to select the model: the Empirical Risk on the test set!\n", "\n" @@ -486,14 +486,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "While we were able to estimate the generalization error, we are indeed unable to know anything about the variance of our model and thus if it is robust or not. This is where the framework of cross-validation is used. Indeed, we can repeat our experiment and compute several time our generalization error and get intuition about the stability of our model." + "While we were able to estimate the generalization error, we are indeed unable to know anything about the variance of our model and thus if it is robust or not. This is where the framework of cross-validation is used. Indeed, we can repeat our experiment and compute several times our generalization error and get intuition about the stability of our model." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The simplest way that we can think of is to shuffle our data and split it into two sets as we previously did and repeat several time our experiment. In scikit-learn, using the function `cross_validate` with the cross-validation `ShuffleSplit` allows us to make such evaluation." + "The simplest way that we can think of is to shuffle our data and split it into two sets as we previously did and repeat several times our experiment. In scikit-learn, using the function `cross_validate` with the cross-validation `ShuffleSplit` allows us to make such evaluation." ] }, { @@ -902,7 +902,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We see that the median value range from 50 k\\\\$ up to 500 k\\\\$. Thus an error range of 3 k\\\\$ means that our cross-validation results can be trusted and do not suffer from an execessive variance. Regarding the performance of our model itself, we can see that making an error of 45 k\\\\$ would be problematic even more if this happen for housing with low value. However, we also see some limitation regarding the metric that we are using. Making an error of 45 k\\\\$ for a target at 50 k\\\\$ and at 500 k\\\\$ should not have the same impact. We should instead use the mean absolute percentage error which will give a relative error." + "We see that the median value range from 50 k\\\\$ up to 500 k\\\\$. Thus, an error range of 3 k\\\\$ means that our cross-validation results can be trusted and do not suffer from an excessive variance. Regarding the performance of our model itself, we can see that making an error of 45 k\\\\$ would be problematic even more if this happens for housing with low value. However, we also see some limitation regarding the metric that we are using. Making an error of 45 k\\\\$ for a target at 50 k\\\\$ and at 500 k\\\\$ should not have the same impact. We should instead use the mean absolute percentage error which will give a relative error." ] }, { @@ -1077,7 +1077,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We see that with a low number of samples, the variance is much larger. Indeed, for low number of sample, we cannot even trust our cross-validation and therefore cannot conclude anything about our regressor. Therefore, it is really important to make experiment with a large enough sample size to be sure about the conclusions which would be drawn." + "We see that with a low number of samples, the variance is much larger. Indeed, for low number of samples, we cannot even trust our cross-validation and therefore cannot conclude anything about our regressor. Therefore, it is really important to make experiment with a large enough sample size to be sure about the conclusions which would be drawn." ] }, { @@ -1127,7 +1127,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We plot the generalization errors for each of the experiment. We see that even our regressor does not perform well, it is far above chances our a regressor that would predict the mean target." + "We plot the generalization errors for each of the experiment. We see that even if our regressor does not perform well, it is far above chances our a regressor that would predict the mean target." ] }, { @@ -1193,7 +1193,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's take an example of some financial quotes. These are the value of compagny stocks with the time." + "Let's take an example of some financial quotes. These are the value of company's stocks with the time." ] }, { From 3aed49f9de65dd2692426beacec2d9d908e46216 Mon Sep 17 00:00:00 2001 From: waddason Date: Fri, 20 Dec 2024 09:33:54 +0100 Subject: [PATCH 2/2] Notes of Dec, 19 --- .../02-parallel_and_caching_with_joblib.ipynb | 529 ++++- .../01-evaluation_metrics_regression.ipynb | 174 +- .../01-imbalanced_learning.ipynb | 1955 ++++++++++++++++- .../01-grow_a_tree.ipynb | 1012 +++++++-- .../01b-grow_a_forest.ipynb | 202 +- .../02-gradient_boosting_pure_python.ipynb | 107 +- .../figures/decision_bounary.py | 21 +- 7 files changed, 3460 insertions(+), 540 deletions(-) diff --git a/02_pipelines_and_column_transformers/02-parallel_and_caching_with_joblib.ipynb b/02_pipelines_and_column_transformers/02-parallel_and_caching_with_joblib.ipynb index f421fdd..e7c793c 100644 --- a/02_pipelines_and_column_transformers/02-parallel_and_caching_with_joblib.ipynb +++ b/02_pipelines_and_column_transformers/02-parallel_and_caching_with_joblib.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -27,21 +27,32 @@ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "import warnings\n", + "\n", "warnings.simplefilter(action=\"ignore\", category=FutureWarning)\n", "warnings.simplefilter(action=\"ignore\", category=UserWarning)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading Adult Census datasets from UCI\n" + ] + } + ], "source": [ "import os\n", "from urllib.request import urlretrieve\n", "\n", - "url = (\"https://archive.ics.uci.edu/ml/machine-learning-databases\"\n", - " \"/adult/adult.data\")\n", + "url = (\n", + " \"https://archive.ics.uci.edu/ml/machine-learning-databases\"\n", + " \"/adult/adult.data\"\n", + ")\n", "local_filename = os.path.basename(url)\n", "if not os.path.exists(local_filename):\n", " print(\"Downloading Adult Census datasets from UCI\")\n", @@ -50,34 +61,205 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "names = (\"age, workclass, fnlwgt, education, education-num, \"\n", - " \"marital-status, occupation, relationship, race, sex, \"\n", - " \"capital-gain, capital-loss, hours-per-week, \"\n", - " \"native-country, income\").split(', ') \n", + "names = (\n", + " \"age, workclass, fnlwgt, education, education-num, \"\n", + " \"marital-status, occupation, relationship, race, sex, \"\n", + " \"capital-gain, capital-loss, hours-per-week, \"\n", + " \"native-country, income\"\n", + ").split(\", \")\n", "data = pd.read_csv(local_filename, names=names)\n", "\n", - "y = data['income']\n", - "X_df = data.drop('income', axis=1)" + "y = data[\"income\"]\n", + "X_df = data.drop(\"income\", axis=1)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageworkclassfnlwgteducationeducation-nummarital-statusoccupationrelationshipracesexcapital-gaincapital-losshours-per-weeknative-country
039State-gov77516Bachelors13Never-marriedAdm-clericalNot-in-familyWhiteMale2174040United-States
150Self-emp-not-inc83311Bachelors13Married-civ-spouseExec-managerialHusbandWhiteMale0013United-States
238Private215646HS-grad9DivorcedHandlers-cleanersNot-in-familyWhiteMale0040United-States
353Private23472111th7Married-civ-spouseHandlers-cleanersHusbandBlackMale0040United-States
428Private338409Bachelors13Married-civ-spouseProf-specialtyWifeBlackFemale0040Cuba
\n", + "
" + ], + "text/plain": [ + " age workclass fnlwgt education education-num \\\n", + "0 39 State-gov 77516 Bachelors 13 \n", + "1 50 Self-emp-not-inc 83311 Bachelors 13 \n", + "2 38 Private 215646 HS-grad 9 \n", + "3 53 Private 234721 11th 7 \n", + "4 28 Private 338409 Bachelors 13 \n", + "\n", + " marital-status occupation relationship race sex \\\n", + "0 Never-married Adm-clerical Not-in-family White Male \n", + "1 Married-civ-spouse Exec-managerial Husband White Male \n", + "2 Divorced Handlers-cleaners Not-in-family White Male \n", + "3 Married-civ-spouse Handlers-cleaners Husband Black Male \n", + "4 Married-civ-spouse Prof-specialty Wife Black Female \n", + "\n", + " capital-gain capital-loss hours-per-week native-country \n", + "0 2174 0 40 United-States \n", + "1 0 0 13 United-States \n", + "2 0 0 40 United-States \n", + "3 0 0 40 United-States \n", + "4 0 0 40 Cuba " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "X_df.head()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "income\n", + "<=50K 24720\n", + ">50K 7841\n", + "Name: count, dtype: int64" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "y.value_counts()" ] @@ -91,9 +273,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CV score: 0.905280194469601\n" + ] + } + ], "source": [ "from sklearn.compose import make_column_transformer\n", "from sklearn.pipeline import make_pipeline\n", @@ -102,20 +292,21 @@ "from sklearn.ensemble import RandomForestClassifier\n", "from sklearn.model_selection import cross_val_score\n", "\n", - "numeric_features = [c for c in X_df\n", - " if X_df[c].dtype.kind in ('i', 'f')]\n", - "categorical_features = [c for c in X_df\n", - " if X_df[c].dtype.kind not in ('i', 'f')]\n", + "numeric_features = [c for c in X_df if X_df[c].dtype.kind in (\"i\", \"f\")]\n", + "categorical_features = [c for c in X_df if X_df[c].dtype.kind not in (\"i\", \"f\")]\n", "\n", "pipeline = make_pipeline(\n", " make_column_transformer(\n", - " (OneHotEncoder(handle_unknown='ignore', sparse_output=False), categorical_features),\n", + " (\n", + " OneHotEncoder(handle_unknown=\"ignore\", sparse_output=False),\n", + " categorical_features,\n", + " ),\n", " (StandardScaler(), numeric_features),\n", " ),\n", - " RandomForestClassifier(max_depth=7, n_estimators=300)\n", + " RandomForestClassifier(max_depth=7, n_estimators=300),\n", ")\n", "\n", - "cv_scores = cross_val_score(pipeline, X_df, y, scoring='roc_auc', cv=5)\n", + "cv_scores = cross_val_score(pipeline, X_df, y, scoring=\"roc_auc\", cv=5)\n", "print(\"CV score:\", np.mean(cv_scores))" ] }, @@ -128,32 +319,58 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "22.8 s ± 720 ms per loop (mean ± std. dev. of 2 runs, 1 loop each)\n" + ] + } + ], "source": [ "%timeit -n1 -r2 cross_val_score(pipeline, X_df, y, scoring='roc_auc', cv=5)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "12.4 s ± 3.63 s per loop (mean ± std. dev. of 2 runs, 1 loop each)\n" + ] + } + ], "source": [ "%timeit -n1 -r2 cross_val_score(pipeline, X_df, y, scoring='roc_auc', cv=5, n_jobs=-1)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.97 s ± 83 ms per loop (mean ± std. dev. of 2 runs, 1 loop each)\n" + ] + } + ], "source": [ "%%timeit -n1 -r2\n", "\n", "pipeline[-1].set_params(n_jobs=-1)\n", - "cv_scores = cross_val_score(pipeline, X_df, y, scoring='roc_auc', cv=5, n_jobs=1)" + "cv_scores = cross_val_score(\n", + " pipeline, X_df, y, scoring=\"roc_auc\", cv=5, n_jobs=1\n", + ")" ] }, { @@ -167,9 +384,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(, (2,), {'x': 1})" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from joblib import Parallel, delayed\n", "from math import sqrt\n", @@ -179,20 +407,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Main process in 83837\n", + "working on 85042\n", + "working on 85043\n", + "working on 85042\n", + "working on 85042\n", + "working on 85042\n" + ] + }, + { + "data": { + "text/plain": [ + "[0, 2, 4, 6, 8]" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import os\n", "\n", + "\n", "def f(x):\n", " print(\"working on\", os.getpid())\n", " return 2 * x\n", "\n", + "\n", "print(\"Main process in \", os.getpid())\n", - "Parallel(n_jobs=2)(\n", - " delayed(f)(i) for i in range(5)\n", - ")\n", + "Parallel(n_jobs=2)(delayed(f)(i) for i in range(5))\n", "# [0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0]" ] }, @@ -205,12 +456,13 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "from sklearn.base import clone\n", "\n", + "\n", "def _fit_score(model, X, y, train_idx, test_idx):\n", " X_train = X.iloc[train_idx]\n", " X_test = X.iloc[test_idx]\n", @@ -223,19 +475,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.8441578381698143, 0.8478194103194103, 0.8504299754299754, 0.8502764127764127, 0.8499692874692875]\n" + ] + } + ], "source": [ "from sklearn.model_selection import StratifiedKFold\n", "\n", "n_jobs = 1\n", "\n", "cv = StratifiedKFold(n_splits=5)\n", - "\n", - "scores = Parallel(n_jobs=n_jobs)(delayed(_fit_score)(\n", - " pipeline, X_df, y, train_idx, test_idx\n", - ") for train_idx, test_idx in cv.split(X_df, y))\n", + "# Parallel arg: return_as=\"generator\"\n", + "scores = Parallel(n_jobs=n_jobs)(\n", + " delayed(_fit_score)(pipeline, X_df, y, train_idx, test_idx)\n", + " for train_idx, test_idx in cv.split(X_df, y)\n", + ")\n", "\n", "print(scores)" ] @@ -254,32 +515,60 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[Memory(location=./joblib)]: Flushing completely the cache\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.8435436818670352, 0.8493550368550369, 0.8504299754299754, 0.8521191646191646, 0.851044226044226]\n", + "10.2 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n" + ] + } + ], "source": [ "from joblib import Memory\n", "\n", - "location = '.'\n", + "location = \".\"\n", "mem = Memory(location, verbose=0)\n", "mem.clear() # make sure there is not left over cache from previous run\n", "\n", "_fit_score_cached = mem.cache(_fit_score)\n", "\n", + "\n", "def evaluate_model():\n", - " scores = Parallel(n_jobs=n_jobs)(delayed(_fit_score_cached)(\n", - " pipeline, X_df, y, train_idx, test_idx\n", - " ) for train_idx, test_idx in cv.split(X_df, y))\n", + " scores = Parallel(n_jobs=n_jobs)(\n", + " delayed(_fit_score_cached)(pipeline, X_df, y, train_idx, test_idx)\n", + " for train_idx, test_idx in cv.split(X_df, y)\n", + " )\n", " print(scores)\n", "\n", + "\n", "%timeit -n1 -r1 evaluate_model()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.8435436818670352, 0.8493550368550369, 0.8504299754299754, 0.8521191646191646, 0.851044226044226]\n", + "2.14 s ± 0 ns per loop (mean ± std. dev. of 1 run, 1 loop each)\n" + ] + } + ], "source": [ "%timeit -n1 -r1 evaluate_model()" ] @@ -295,18 +584,142 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;31mInit signature:\u001b[0m \u001b[0mPipeline\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msteps\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m*\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtransform_input\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmemory\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mverbose\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m \n", + "A sequence of data transformers with an optional final predictor.\n", + "\n", + "`Pipeline` allows you to sequentially apply a list of transformers to\n", + "preprocess the data and, if desired, conclude the sequence with a final\n", + ":term:`predictor` for predictive modeling.\n", + "\n", + "Intermediate steps of the pipeline must be transformers, that is, they\n", + "must implement `fit` and `transform` methods.\n", + "The final :term:`estimator` only needs to implement `fit`.\n", + "The transformers in the pipeline can be cached using ``memory`` argument.\n", + "\n", + "The purpose of the pipeline is to assemble several steps that can be\n", + "cross-validated together while setting different parameters. For this, it\n", + "enables setting parameters of the various steps using their names and the\n", + "parameter name separated by a `'__'`, as in the example below. A step's\n", + "estimator may be replaced entirely by setting the parameter with its name\n", + "to another estimator, or a transformer removed by setting it to\n", + "`'passthrough'` or `None`.\n", + "\n", + "For an example use case of `Pipeline` combined with\n", + ":class:`~sklearn.model_selection.GridSearchCV`, refer to\n", + ":ref:`sphx_glr_auto_examples_compose_plot_compare_reduction.py`. The\n", + "example :ref:`sphx_glr_auto_examples_compose_plot_digits_pipe.py` shows how\n", + "to grid search on a pipeline using `'__'` as a separator in the parameter names.\n", + "\n", + "Read more in the :ref:`User Guide `.\n", + "\n", + ".. versionadded:: 0.5\n", + "\n", + "Parameters\n", + "----------\n", + "steps : list of tuples\n", + " List of (name of step, estimator) tuples that are to be chained in\n", + " sequential order. To be compatible with the scikit-learn API, all steps\n", + " must define `fit`. All non-last steps must also define `transform`. See\n", + " :ref:`Combining Estimators ` for more details.\n", + "\n", + "transform_input : list of str, default=None\n", + " The names of the :term:`metadata` parameters that should be transformed by the\n", + " pipeline before passing it to the step consuming it.\n", + "\n", + " This enables transforming some input arguments to ``fit`` (other than ``X``)\n", + " to be transformed by the steps of the pipeline up to the step which requires\n", + " them. Requirement is defined via :ref:`metadata routing `.\n", + " For instance, this can be used to pass a validation set through the pipeline.\n", + "\n", + " You can only set this if metadata routing is enabled, which you\n", + " can enable using ``sklearn.set_config(enable_metadata_routing=True)``.\n", + "\n", + " .. versionadded:: 1.6\n", + "\n", + "memory : str or object with the joblib.Memory interface, default=None\n", + " Used to cache the fitted transformers of the pipeline. The last step\n", + " will never be cached, even if it is a transformer. By default, no\n", + " caching is performed. If a string is given, it is the path to the\n", + " caching directory. Enabling caching triggers a clone of the transformers\n", + " before fitting. Therefore, the transformer instance given to the\n", + " pipeline cannot be inspected directly. Use the attribute ``named_steps``\n", + " or ``steps`` to inspect estimators within the pipeline. Caching the\n", + " transformers is advantageous when fitting is time consuming.\n", + "\n", + "verbose : bool, default=False\n", + " If True, the time elapsed while fitting each step will be printed as it\n", + " is completed.\n", + "\n", + "Attributes\n", + "----------\n", + "named_steps : :class:`~sklearn.utils.Bunch`\n", + " Dictionary-like object, with the following attributes.\n", + " Read-only attribute to access any step parameter by user given name.\n", + " Keys are step names and values are steps parameters.\n", + "\n", + "classes_ : ndarray of shape (n_classes,)\n", + " The classes labels. Only exist if the last step of the pipeline is a\n", + " classifier.\n", + "\n", + "n_features_in_ : int\n", + " Number of features seen during :term:`fit`. Only defined if the\n", + " underlying first estimator in `steps` exposes such an attribute\n", + " when fit.\n", + "\n", + " .. versionadded:: 0.24\n", + "\n", + "feature_names_in_ : ndarray of shape (`n_features_in_`,)\n", + " Names of features seen during :term:`fit`. Only defined if the\n", + " underlying estimator exposes such an attribute when fit.\n", + "\n", + " .. versionadded:: 1.0\n", + "\n", + "See Also\n", + "--------\n", + "make_pipeline : Convenience function for simplified pipeline construction.\n", + "\n", + "Examples\n", + "--------\n", + ">>> from sklearn.svm import SVC\n", + ">>> from sklearn.preprocessing import StandardScaler\n", + ">>> from sklearn.datasets import make_classification\n", + ">>> from sklearn.model_selection import train_test_split\n", + ">>> from sklearn.pipeline import Pipeline\n", + ">>> X, y = make_classification(random_state=0)\n", + ">>> X_train, X_test, y_train, y_test = train_test_split(X, y,\n", + "... random_state=0)\n", + ">>> pipe = Pipeline([('scaler', StandardScaler()), ('svc', SVC())])\n", + ">>> # The pipeline can be used as any other estimator\n", + ">>> # and avoids leaking the test set into the train set\n", + ">>> pipe.fit(X_train, y_train).score(X_test, y_test)\n", + "0.88\n", + ">>> # An estimator's parameter can be set using '__' syntax\n", + ">>> pipe.set_params(svc__C=10).fit(X_train, y_train).score(X_test, y_test)\n", + "0.76\n", + "\u001b[0;31mFile:\u001b[0m ~/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/pipeline.py\n", + "\u001b[0;31mType:\u001b[0m ABCMeta\n", + "\u001b[0;31mSubclasses:\u001b[0m " + ] + } + ], "source": [ "from sklearn.pipeline import Pipeline\n", + "\n", "Pipeline?" ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "DataCamp", "language": "python", "name": "python3" }, @@ -320,7 +733,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.19" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/04_metrics/01-evaluation_metrics_regression.ipynb b/04_metrics/01-evaluation_metrics_regression.ipynb index 701b7f7..df47ab6 100644 --- a/04_metrics/01-evaluation_metrics_regression.ipynb +++ b/04_metrics/01-evaluation_metrics_regression.ipynb @@ -64,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -79,7 +79,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -98,25 +98,23 @@ "\n", "reg = LinearRegression()\n", "\n", - "with open('anscombe_quartet.json') as f:\n", + "with open(\"anscombe_quartet.json\") as f:\n", " anscombe_quartet = np.array(json.load(f))\n", - " \n", + "\n", "fig, axes = plt.subplots(2, 2, figsize=(10, 10), sharey=True, sharex=True)\n", "\n", "for data, ax in zip(anscombe_quartet, axes.ravel()):\n", - " \n", " x, y = data[0], data[1]\n", " reg.fit(x[:, None], y)\n", " y_pred = reg.predict(x[:, None])\n", " ax.scatter(x, y)\n", - " \n", + "\n", " xlim = ax.get_xlim()\n", " t = np.arange(*xlim)\n", - " ax.plot(t, reg.coef_ * t + reg.intercept_, 'k--')\n", + " ax.plot(t, reg.coef_ * t + reg.intercept_, \"k--\")\n", " ax.set_xlim(xlim)\n", - " \n", - " ax.set_title(f\"RMSE = {np.sqrt(mean_squared_error(y_pred, y)):.2e}\")\n", "\n", + " ax.set_title(f\"RMSE = {np.sqrt(mean_squared_error(y_pred, y)):.2e}\")\n", "\n", " df = pd.DataFrame(np.array(data).T)\n", " print(reg.coef_, reg.intercept_)" @@ -176,6 +174,7 @@ ], "source": [ "import pandas as pd\n", + "\n", "for i, data in enumerate(anscombe_quartet):\n", " print(i)\n", " df = pd.DataFrame(data.T)\n", @@ -202,14 +201,14 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "R2 score: [0.71024046 0.90114339 0.78988269 0.66888628 0.91832746]\n" + "R2 score: [0.7046321 0.90324092 0.82117814 0.66797656 0.91208121]\n" ] } ], @@ -220,6 +219,7 @@ "\n", "# The Boston house-price data\n", "data_url = \"http://lib.stat.cmu.edu/datasets/boston\"\n", + "# Clean the file format: remove header, merge the row that spans on 2 lines\n", "raw_df = pd.read_csv(data_url, sep=\"\\s+\", skiprows=22, header=None)\n", "data = np.hstack([raw_df.values[::2, :], raw_df.values[1::2, :2]])\n", "target = raw_df.values[1::2, 2]\n", @@ -233,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -460,7 +460,7 @@ "[1012 rows x 11 columns]" ] }, - "execution_count": 24, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -472,7 +472,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -481,7 +481,7 @@ "(506, 13)" ] }, - "execution_count": 25, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -502,25 +502,31 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Along Charles River: [ 0.71507573 -1.63659283 -0.20672541 0.31320593 0.11272204]\n", - "Not Along Charles River: [0.70306625 0.82137268 0.74741804 0.43548206 0.42212539]\n" + "Along Charles River: [ 0.37750551 0.3703775 -12.85338374 0.7170686 0.70851219]\n", + "Not Along Charles River: [0.77896401 0.87074651 0.88271053 0.79530792 0.90191517]\n" ] } ], "source": [ - "print(\"Along Charles River:\",\n", - " cross_val_score(regressor, data[data[:, 3] == 1],\n", - " target[data[:, 3] == 1], cv=5))\n", - "print(\"Not Along Charles River:\",\n", - " cross_val_score(regressor, data[data[:, 3] == 0],\n", - " target[data[:, 3] == 0], cv=5))" + "print(\n", + " \"Along Charles River:\",\n", + " cross_val_score(\n", + " regressor, data[data[:, 3] == 1], target[data[:, 3] == 1], cv=5\n", + " ),\n", + ")\n", + "print(\n", + " \"Not Along Charles River:\",\n", + " cross_val_score(\n", + " regressor, data[data[:, 3] == 0], target[data[:, 3] == 0], cv=5\n", + " ),\n", + ")" ] }, { @@ -532,27 +538,39 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Along Charles River: [ -45.12794286 -7.03824286 -19.02844286 -69.25598571 -173.27517143]\n", - "Not Along Charles River: [ -7.23511474 -16.10621489 -22.51471596 -33.9433266 -14.47351702]\n" + "Along Charles River: [-102.30535714 -84.04335714 -47.82104286 -49.74912857 -29.6372 ]\n", + "Not Along Charles River: [-19.10748105 -10.83902872 -6.73442766 -21.20532553 -8.09474787]\n" ] } ], "source": [ - "print(\"Along Charles River:\",\n", - " cross_val_score(regressor, data[data[:, 3] == 1],\n", - " target[data[:, 3] == 1], cv=5,\n", - " scoring='neg_mean_squared_error'))\n", - "print(\"Not Along Charles River:\",\n", - " cross_val_score(regressor, data[data[:, 3] == 0],\n", - " target[data[:, 3] == 0], cv=5,\n", - " scoring='neg_mean_squared_error'))" + "print(\n", + " \"Along Charles River:\",\n", + " cross_val_score(\n", + " regressor,\n", + " data[data[:, 3] == 1],\n", + " target[data[:, 3] == 1],\n", + " cv=5,\n", + " scoring=\"neg_mean_squared_error\",\n", + " ),\n", + ")\n", + "print(\n", + " \"Not Along Charles River:\",\n", + " cross_val_score(\n", + " regressor,\n", + " data[data[:, 3] == 0],\n", + " target[data[:, 3] == 0],\n", + " cv=5,\n", + " scoring=\"neg_mean_squared_error\",\n", + " ),\n", + ")" ] }, { @@ -579,22 +597,22 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 35, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -607,7 +625,7 @@ "eps = 1.35\n", "t = np.linspace(-3, 3, 1000)\n", "plt.plot(t, abs(t))\n", - "plt.plot(t, t*t)" + "plt.plot(t, t * t)" ] }, { @@ -619,12 +637,12 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -637,17 +655,17 @@ "from sklearn.metrics import mean_absolute_error\n", "import pandas as pd\n", "\n", - " \n", + "\n", "fig, axes = plt.subplots(2, 2, figsize=(10, 10))\n", "\n", "for (x, y), ax in zip(anscombe_quartet, axes.ravel()):\n", " reg.fit(x[:, None], y)\n", " y_pred = reg.predict(x[:, None])\n", " ax.scatter(x, y)\n", - " \n", + "\n", " xlim = ax.get_xlim()\n", " t = np.arange(*xlim)\n", - " ax.plot(t, reg.coef_ * t + reg.intercept_, 'k--')\n", + " ax.plot(t, reg.coef_ * t + reg.intercept_, \"k--\")\n", " ax.set_xlim(xlim)\n", " ax.set_title(f\"MAE = {mean_absolute_error(y_pred, y):.2e}\")" ] @@ -668,12 +686,12 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzYAAANECAYAAABipbqLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAADW20lEQVR4nOzdeViUVf8G8HsAYVhHRREwF8QFAcUtzaXcUDFFTUXBJdNSU8uFMqUywg33QvPFJUULxFzLJTUt11wAUZOwNENFBVGRGfZl5vn9wY/JEVDRGR5m5v5c11zXO2fOzHPP+DaH75zznEciCIIAIiIiIiIiPWYidgAiIiIiIqKXxcKGiIiIiIj0HgsbIiIiIiLSeyxsiIiIiIhI77GwISIiIiIivcfChoiIiIiI9B4LGyIiIiIi0nssbIiIiIiISO+xsCEiIiIiIr3HwoaIiIiIiPQeCxvSmk2bNkEikUAikeDUqVOlHhcEAfXq1YNEIkH//v3LfI2MjAxIpVJIJBJcuXKlzD7vvPOO+jhP3qRSqVbf07OoVCqsWbMGrVq1go2NDerUqYO+ffvi9OnTFX6tU6dOqd/HgwcPNB778ssvK/X97tmzB23atIFUKkX9+vURHByMoqIijT4pKSmYPXs2unfvDltbW0gkEhw7dkwneYiIXpQxjk2FhYUICQlBo0aNYGFhgUaNGmH+/PmlvsfLkpubi3fffReenp6QyWSwsbGBl5cXwsLCUFhYWOZzjhw5gh49ekAmk8HW1hZt27bFDz/8oO23hdOnT6NLly6wsrKCo6Mjpk6diqysLI0+WVlZCA4Oho+PD2rWrAmJRIJNmzZpPQtVTWZiByDDI5VKsWXLFnTp0kWj/fjx47h9+zYsLCzKfe727dshkUjg6OiIqKgozJ8/v8x+FhYW+Pbbb0u1m5qavlz4Cpo5cyZWrFiBUaNGYfLkycjIyMDatWvRtWtX/P7772jfvv1zvY5KpcKHH34Ia2trZGdnl9svPDwcNjY26vu6eL8HDhzAoEGD0K1bN6xatQqXL1/G/PnzkZaWhvDwcHW/v//+G4sXL0aTJk3QokULnDlzRutZiIi0xZjGplGjRmH79u0YN24c2rVrh7Nnz2LOnDm4desW1q1b99Tn5ubm4s8//8Sbb76Jhg0bwsTEBKdPn8aMGTNw7tw5bNmyRaN/REQE3n33XfTq1QsLFy6Eqakp/v77byQnJ2v1PV28eBE9e/ZE8+bNsWLFCty+fRvLli3DtWvXcODAAXW/Bw8eYO7cuahfvz68vLz4g5uxEYi0JCIiQgAgDB48WKhVq5ZQWFio8fj48eOFtm3bCg0aNBD69etX5mu88cYbwuDBg4UZM2YILi4uZfYZM2aMYG1trfX8FVVYWChYWloKQ4cO1Wj/999/BQDC1KlTn/u1wsPDBXt7e2HatGkCAOH+/fsajwcHB5fZrgvu7u6Cl5eXxr/fZ599JkgkEuHKlSvqNoVCITx8+FAQBEHYvn27AEA4evSozvMREVWEsY1NMTExAgBhzpw5Gu0fffSRIJFIhEuXLr3Q637wwQcCACElJUXdlpSUJFhaWlZovHtRffv2FZycnAS5XK5uW79+vQBAOHTokLotLy9PnTE2NlYAIEREROg8H1UNXIpGWhcQEICHDx/i8OHD6raCggLs2LEDI0aMKPd5t27dwsmTJ+Hv7w9/f38kJSW90JKuylJYWIjc3FzUqVNHo93BwQEmJiawtLR8rtdJT0/H559/jrlz56J69epP7SsIAhQKBQRBKLdPfn4+goOD0bhxY1hYWKBevXr45JNPkJ+f/8wsiYmJSExMxIQJE2Bm9t+E7uTJkyEIAnbs2KFus7W1Rc2aNZ/9BomIqgBjGZtOnjwJAPD399do9/f3hyAIL7xErGHDhgCKl+WVWLNmDZRKJebOnQugeBlYeeOTSqXC119/DQ8PD0ilUtSpUwcTJ07Eo0ePnnlshUKBw4cPY9SoUbCzs1O3v/3227CxscG2bdvUbRYWFnB0dHyBd0iGgIUNaV3Dhg3RsWNHREdHq9sOHDgAuVxe6ov2cdHR0bC2tkb//v3Rvn17uLq6Iioqqtz+Dx48KHVTKBTPzPfo0aMyn/vkLScn56mvY2lpiQ4dOmDTpk2IiorCrVu38Mcff+Cdd95BjRo1MGHChGdmAYA5c+bA0dEREydOfGbfRo0aqdcwjxo1Cvfu3dN4XKVSYcCAAVi2bBl8fX2xatUqDBo0CF999RWGDx/+zNe/cOECAKBdu3Ya7c7OznjllVfUjxMR6RtjGZtKfsR68sc1KysrAMD58+efmQUoLvoePHiA5ORk7N69G8uWLUODBg3QuHFjdZ8jR47Azc0NP//8M1555RXY2trC3t4ec+bMgUql0ni9iRMnYubMmejcuTPCwsIwduxYREVFoU+fPuWeu1Pi8uXLKCoqKjU2mZubo1WrVhybSI3n2JBOjBgxAkFBQcjNzYWlpSWioqLQtWtXODs7l/ucqKgoDBw4UP1lPHz4cKxbtw5hYWEaswcAkJ2djdq1a5d6jT59+uDgwYNPzda6dWvcvHnzme8hODgYX3755VP7REZGYvjw4Rg1apS6rVGjRvj999/RqFGjZx7jjz/+wNq1a/Hzzz8/dQ12jRo18MEHH6Bjx46wsLDAyZMnsXr1asTExCAuLk79C9aWLVtw5MgRHD9+XGMduaenJ95//32cPn0anTp1Kvc4KSkpAAAnJ6dSjzk5OeHu3bvPfE9ERFWVMYxNzZo1AwD8/vvvcHFxUbeXzOTcuXPnmccAgF27diEgIEB9v127dti4caPGe7527RpMTU0xduxYfPLJJ/Dy8sKuXbvUGxWEhoYCKN4c59tvv0VUVJTG7Fj37t3h4+OD7du3P3XW7FljU8l7I2JhQzoxbNgwTJ8+Hfv27YOPjw/27duHlStXltv/jz/+wOXLl9VfgkDxsoGFCxfi0KFD6Nevn0Z/qVSKvXv3lnqdWrVqPTNbVFQUcnNzn9nveQoTW1tbeHh4oGPHjujZsydSU1OxaNEiDBo0CCdPnnxmnqlTp6Jv377o3bv3U/tNmzZN4/6QIUPQvn17jBw5Ev/73/8we/ZsAMUnuDZv3hxubm4aO6v16NEDAHD06NGnFjYln0tZJ9FKpdLn+tWRiKiqMoax6c0330SDBg3w8ccfw8rKCm3btsW5c+fw2WefwczM7LmOARQXHYcPH0ZGRgZ+/fVXXLp0qdTmNllZWVCpVFi0aBFmzZoFoHh8Sk9PR1hYGD799FPY2tpi+/btkMlk6NWrl8bY1LZtW9jY2ODo0aNPLWyeNTY973siw8fChnSidu3a8Pb2xpYtW5CTkwOlUomhQ4eW2z8yMhLW1tZo1KgR/vnnHwDFX1YNGzZEVFRUqcHD1NQU3t7eL5Stc+fOL/S8JxUVFcHb21u9e1gJb29veHh4YOnSpVi8eHG5z//hhx9w+vRpJCQkvNDxR4wYgY8++ghHjhxRFzbXrl3DlStXyvzFEADS0tIAFJ/XU1BQoG63tLSETCZT/yJZ1vk4eXl5z33eEBFRVWQMY5NUKsX+/fsxbNgwDBkyBEBxQbBkyRIsWLBAY2fNp6lTp476HNKhQ4di4cKF6NWrF65du6Y+h8XS0hLZ2dkaMztAcfF38OBBXLhwAW+88QauXbsGuVwOBweHMo9VMjbJ5XKNIsXc3Bw1a9bk2ETPjYUN6cyIESMwfvx4pKamom/fvuWeGC8IAqKjo5GdnQ13d/dSj6elpSErK+u5v4yf5f79+1Aqlc/sZ2Nj89RjnjhxAgkJCVixYoVGe5MmTdC8eXP8/vvvT339mTNnws/PD+bm5rhx4waA/07KTE5ORkFBwVOXRwBAvXr1kJ6err6vUqnQokWLUpke7w8AgwcPxvHjx9XtY8aMwaZNm9TT/CkpKeq+JVJSUp57+2oioqrK0McmAPDw8EBCQgISExPx6NEjuLu7w9LSEjNmzEDXrl1fKN/QoUPx2Wef4aefflKfE+rs7Ixr166VuYkOAPXGACqVCg4ODuWem1TyY9y0adOwefNmdXvXrl1x7NgxjbHpSSkpKc8cK8l4sLAhnXnrrbcwceJEnD179qm7sJRcQ2Du3Llo3ry5xmOPHj3ChAkT8OOPP2qcx/IyXn31Va2sYy45cb+sgaiwsPCZF0JLTk7Gli1bSl0TAADatGkDLy8vXLx4sdznC4KAGzduoHXr1uo2V1dXXLp0CT179oREIin3ucuXL9fYiaZkUGjVqhUAIC4uTqOIuXv3Lm7fvv3cGyIQEVVVhj42lZBIJPDw8FDf//nnn6FSqV54RqlkJkUul6vb2rZti2vXruHOnTsaS+RKzscsKVhcXV1x5MgRdO7c+amzK5988onG51mjRg0AxeeJmpmZIS4uDsOGDVM/XlBQgIsXL2q0kXFjYUM6Y2Njg/DwcNy4cQO+vr7l9iuZ6p85c2aZV2deunQpoqKitDZ4aGsdc9OmTQEAW7duhY+Pj7o9Pj4ef//9t0YRkJOTg1u3bqFWrVrqtda7d+8u9Zpbt27FDz/8gO+++w6vvPKKuv3+/fullpeFh4fj/v37GsceNmwYfv75Z6xfv75UEZKbmwuVSgVra2u0bdu2zPfk4eEBNzc3rFu3DhMnTlRvaBAeHg6JRPLUJRtERPrA0MemsuTm5mLOnDlwcnLSWDZW1tj04MED2Nvbl/pxrOTCo4/vTDZ8+HBs3boVGzZswIIFCwAUz85ERESgZs2a6rFm2LBh+N///od58+Zh4cKFGq9bVFSErKwsVK9eHe7u7mXOjslkMnh7eyMyMhJz5syBra0tAOD7779HVlYW/Pz8KvyZkGFiYUM6NWbMmKc+np+fj507d6JXr15lDhwAMGDAAISFhSEtLU09vV1UVITIyMgy+7/11luwtrYu95jaWsfctm1b9OrVC5s3b4ZCoUDv3r2RkpKCVatWwdLSEtOnT1f3jYmJQffu3TV+aRs0aFCp1yyZoenbt6/GyaYNGjTA8OHD0aJFC0ilUpw6dQpbt25Fq1atNLaJHj16NLZt24b3338fR48eRefOnaFUKvHXX39h27ZtOHToUKntMp+0dOlSDBgwAL1794a/vz8SEhLwzTff4L333iv1q2XJ1bf//PNPAMWDzKlTpwAAn3/++XN9jkRElc2QxyaguJBwdnaGu7s7FAoFNm7ciH///Rf79+9XFwVA2WNTZGQk1qxZg0GDBqFRo0bIzMzEoUOHcPjwYfj6+qo3owGAgQMHomfPnggNDcWDBw/g5eWFH3/8EadOncLatWvVJ/t37doVEydORGhoKC5evIjevXujWrVquHbtGrZv346wsLBn/nC2YMECdOrUCV27dsWECRNw+/ZtLF++HL1799b4gQ8AvvnmG2RkZKhnjvbu3Yvbt28DAD788EPIZLKX/oypihLv2qBkaEqu7hwbG/vUfo9f3Xnnzp0CAGHDhg3l9j927JgAQAgLCxMEofjqzgDKvSUlJWntPT1LTk6OMHfuXMHd3V2wtLQUZDKZ0L9/f+HChQsa/Y4ePSoAEIKDg5/6esHBwQIA4f79+xrt7733nuDu7i7Y2toK1apVExo3bizMmjVLUCgUpV6joKBAWLx4seDh4SFYWFgINWrUENq2bSuEhIRoXLH5aXbv3i20atVKsLCwEF555RXh888/FwoKCkr1e9q/AxFRVWCMY9PixYsFNzc3QSqVCjVq1BAGDBhQalwShLLHptjYWMHPz0+oX7++YGFhIVhbWwtt2rQRVqxYIRQWFpZ6jczMTGHatGmCo6OjYG5uLrRo0UKIjIwsM9e6deuEtm3bCpaWloKtra3QokUL4ZNPPhHu3r37XO/r5MmTQqdOnQSpVCrUrl1bmDJlSpnjYIMGDarEvwNVPokgPOUS5kRERERERHrAROwAREREREREL4uFDRERERER6T0WNkREREREpPdY2BARERERkd5jYUNERERERHqPhQ0REREREem9KneBTpVKhbt378LW1rbUVW+JiEi3BEFAZmYmnJ2dYWLC375KcGwiIhJHRcalKlfY3L17F/Xq1RM7BhGRUUtOTsYrr7widowqg2MTEZG4nmdcqnKFja2tLYDi8HZ2diKnISIyLgqFAvXq1VN/F1Mxjk1EROKoyLhU5Qqbkil+Ozs7Dh5ERCLhcitNHJuIiMT1POMSF1ATEREREZHeq3Bhc+LECfj6+sLZ2RkSiQQ//vijxuO7du1C7969YW9vD4lEgosXL2opKhERERERUdkqXNhkZ2fDy8sLq1evLvfxLl26YPHixS8djoiIiIiI6HlU+Bybvn37om/fvuU+Pnr0aADAjRs3XjgUERERERFRRYi+eUB+fj7y8/PV9xUKhYhpiIiIiIhIH4m+eUBoaChkMpn6xusEEBFRRTzr3E9BEPDFF1/AyckJlpaW8Pb2xrVr18QJS0REOiN6YRMUFAS5XK6+JScnix2JiIj0yLPO/VyyZAlWrlyJNWvW4Ny5c7C2tkafPn2Ql5dXyUmJiEiXRF+KZmFhAQsLC7FjEBGRnnrauZ+CIODrr7/G559/joEDBwIAvvvuO9SpUwc//vgj/P39KzMqERHpkOgzNkRE2qJUCThz/SF+ungHZ64/hFIliB2JRJaUlITU1FR4e3ur22QyGTp06IAzZ86U+7z8/HwoFAqNGxERVW0VnrHJysrCP//8o76flJSEixcvombNmqhfvz7S09Nx69Yt3L17FwDw999/AwAcHR3h6OiopdhERJoOJqQgZG8iUuT/LS9ykkkR7OsOH08nEZORmFJTUwEAderU0WivU6eO+rGyhIaGIiQkRKfZiIhIuyo8YxMXF4fWrVujdevWAIDAwEC0bt0aX3zxBQBgz549aN26Nfr16wcA8Pf3R+vWrbFmzRotxiYi+s/BhBRMiozXKGoAIFWeh0mR8TiYkCJSMtJXPP+TiEj/VHjGplu3bhCE8pd3vPPOO3jnnXdeJhMR0XNTqgSE7E1EWd9KAgAJgJC9iejl7ghTE0klpyOxlawUuHfvHpyc/pu5u3fvHlq1alXu83j+JxGR/uE5NkSk12KS0kvN1DxOAJAiz0NMUnrlhaIqw8XFBY6Ojvj111/VbQqFAufOnUPHjh1FTEZERNom+q5oREQvIy3z+bbsfd5+pH+ede7n9OnTMX/+fDRp0gQuLi6YM2cOnJ2dMWjQIPFCExFVcQ8fPoQgCKhVq5bYUZ4bCxsi0msOtlKt9iP9ExcXh+7du6vvBwYGAgDGjBmDTZs24ZNPPkF2djYmTJiAjIwMdOnSBQcPHoRUyv9PEBGV5cSJExg5ciS8vLywd+9eSCT6sZSbhQ0R6bX2LjXhJJMiVZ5X5nk2EgCOMinau9Ss7GhUSZ517qdEIsHcuXMxd+7cSkxFRKR/ioqKMH/+fMybNw8qlQpWVlZIS0srtbNkVcVzbIhIr5maSBDs6w6guIh5XMn9YF93bhxARET0FMnJyejRowdCQkKgUqnwzjvv4Pz583pT1AAsbIjIAPh4OiF8VBs4yjSXFjnKpAgf1YbXsSEiInqKH3/8EV5eXjh58iRsbW0RFRWFiIgI2NjYiB2tQrgUjYgMgo+nE3q5OyImKR1pmXlwsC1efsaZGiIiovLl5+fjo48+wqNHj9CuXTts3boVrq6uYsd6ISxsiMhgmJpI0NHVXuwYREREesPCwgLR0dHYsWMH5s+fD3Nzc7EjvTAWNkRERERERkIQBHz77bcAgPHjxwMA2rdvj/bt24sZSytY2BARERERGYGMjAxMmDAB27dvh4WFBbp164YmTZqIHUtrWNgQERERERm4M2fOICAgADdv3oSZmRnmzZunt+fSlIeFDRERERGRgVIqlVi8eDG++OILKJVKNGrUCNHR0Qax9OxJLGyIiIiIiAyQSqXCm2++iV9++QUAEBAQgDVr1sDOzk7kZLrB69gQERERERkgExMTvP7667CyskJERASioqIMtqgBWNgQERERERmM/Px8JCcnq+8HBQXh8uXLeOeddyCRGPa13VjYEBEREREZgL///huvvfYa+vXrh9zcXACAqakpGjVqJHKyysHChoiIiIhIjwmCgE2bNqFt27a4ePEiUlJScPXqVbFjVToWNkREREREekqhUGDUqFEYO3YssrOz0b17d1y6dAleXl5iR6t0LGyIiIiIiPRQbGwsWrdujS1btsDU1BQLFizA4cOH4ezsLHY0UXC7ZyIiIiIiPTR79mz8+++/aNCgAbZs2YJOnTqJHUlUnLEhIiIiItJDmzZtwrhx43Dx4kWjL2oAFjZERERERHrhl19+wdy5c9X369Wrhw0bNqB69erihapCuBSNiIiIiKgKKygowOeff46lS5cCADp27IhevXqJnKrqYWFDRERERFRFXb9+HQEBAYiNjQUATJ48GV26dBE5VdXEwoaIiIiIqAqKiorCpEmTkJmZiRo1amDDhg146623xI5VZbGwISIiIiKqYqZNm4aVK1cCALp06YKoqCjUr19f5FRVGzcPICIiIiKqYrp06QITExMEBwfj6NGjLGqeA2dsiIiIiMggKVUCYpLSkZaZBwdbKdq71ISpiUTsWGUSBAE3b95Ew4YNAQB+fn7w8vJC06ZNxQ2mR1jYEBEREZHBOZiQgpC9iUiR56nbnGRSBPu6w8fTScRkpd2/fx9jx45FbGwsLl26BEdHRwBgUVNBXIpGRERERAblYEIKJkXGaxQ1AJAqz8OkyHgcTEgRKVlpv/32G7y8vLB//37I5XLExMSIHUlvsbAhIiIiIoOhVAkI2ZsIoYzHStpC9iZCqSqrR+UpLCzEZ599Bm9vb6SkpKB58+aIiYnBgAEDRM2lz1jYEBEREZHBiElKLzVT8zgBQIo8DzFJ6ZUX6gk3btxA165dsXDhQgiCgPHjxyM2NhYtW7YULZMh4Dk2RERERKQTYpy8n5ZZflHzIv10YcmSJThz5gxkMhnWrVuHYcOGiZbFkLCwISIiIiKtE+vkfQdbqVb7vYzyCrslS5ZAoVBg/vz56l3Q6OWxsCEiIiIirSo5ef/Js1hKTt4PH9VGZ8VNe5eacJJJkSrPK/M8GwkAR1lxkaFLjxd2BfdvIOvSIbi/9SG+HOgJH08nREZG6vT4xojn2BARERGR1oh98r6piQTBvu4AiouYx5XcD/Z11+mSuJLC7m5GLjLj9yNl8wxknt+La8d3Vbld2QwJCxsiIiIi0pqqcPK+j6cTwke1gaNMc7mZo0yq09ki4L/Crig3E/d3L0D64XBAWQjLRu1g5fY6gKqxK5shqnBhc+LECfj6+sLZ2RkSiQQ//vijxuOCIOCLL76Ak5MTLC0t4e3tjWvXrmkrLxERERFVYVXl5H0fTyecmtUD0eNfQ5h/K0SPfw2nZvXQ+cU5Y5LSkZQQh5SID5F77SxgYoYaPcaj9tBgmFrJqsSubIaqwoVNdnY2vLy8sHr16jIfX7JkCVauXIk1a9bg3LlzsLa2Rp8+fZCXJ97OE0RERERUOarSyfumJhJ0dLXHwFZ10dHVXuc7sgHApg1rcS/6UygzH8CshjMcRy+D3asDIZFoHlvMXdkMVYULm759+2L+/Pl46623Sj0mCAK+/vprfP755xg4cCBatmyJ7777Dnfv3i01s0NERNqlVAk4c/0hfrp4B2euP+Qyh8dkZmZi+vTpaNCgASwtLdGpUyfExsaKHYvIIJWcvF9eCSFB8e5ouj55XyztX30VkEhg7dkTTu+EwcKxcZn9KqOwMzZa3RUtKSkJqamp8Pb2VrfJZDJ06NABZ86cgb+/vzYPR0RE/0+sbVX1xXvvvYeEhAR8//33cHZ2RmRkJLy9vZGYmIi6deuKHY/IoJScvD8pMh4SQGMTgco6eb+y3bx5Ew0aNAAAvDPQG6umrofcwkHUXdmMkVY3D0hNTQUA1KlTR6O9Tp066seelJ+fD4VCoXEjIqLnV7L7zpMn65Zsq2rsu+/k5uZi586dWLJkCd544w00btwYX375JRo3bozw8HCx4xEZJDFP3q9Mubm5+OCDD9CsWTNcunQJQHFht+hdHwDi7cpmrES/jk1oaChCQkLEjkFEpJeeta2qBMW77/RydzTaQbSoqAhKpRJSqeYfWJaWljh16pRIqYgMn4+nE3q5O5Z5gUpDkJiYCH9/f1y+fBkA8Ntvv8HLywvAf4XdkzPpjpxJ1ymtFjaOjo4AgHv37sHJ6b9/sHv37qFVq1ZlPicoKAiBgYHq+wqFAvXq1dNmLCIig1WRbVU7utpXXrAqxNbWFh07dsS8efPQvHlz1KlTB9HR0Thz5gwaNy577Xt+fj7y8/PV97magOjFlJy8b0gEQcC3336LadOmITc3Fw4ODvjuu+/Qp08fjX6GXthVRVpdiubi4gJHR0f8+uuv6jaFQoFz586hY8eOZT7HwsICdnZ2GjciIno+VWVb1aru+++/hyAIqFu3LiwsLLBy5UoEBATAxKTsYTA0NBQymUx94w9uRAQAGRkZGD58OCZMmIDc3Fz06tULly5dKlXUlBBjVzZjVuHCJisrCxcvXsTFixcBFG8YcPHiRdy6dQsSiQTTp0/H/PnzsWfPHly+fBlvv/02nJ2dMWjQIC1HJyKiqrStalXm6uqK48ePIysrC8nJyYiJiUFhYSEaNWpUZv+goCDI5XL1LTk5uZITE1FVtHnzZmzfvh1mZmZYsmQJDh48qF6xROKr8FK0uLg4dO/eXX2/ZBnZmDFjsGnTJnzyySfIzs7GhAkTkJGRgS5duuDgwYOl1jYTEdHLK9lWNVWex913noO1tTWsra3x6NEjHDp0CEuWLCmzn4WFBSwsLCo5HRFVdR988AEuXbqE999/H+3btxc7Dj1BIghClbrQgUKhgEwmg1wu57I0IqLnULIrGlD2tqoV2YHIUL+DDx06BEEQ0KxZM/zzzz+YOXMmpFIpTp48iWrVqj3z+Yb6uRDR0929exdz587FV199BUtLS7HjGKWKfP9q9RwbIiKqfMayrerLkMvlmDJlCtzc3PD222+jS5cuOHTo0HMVNURknH7++Wd4eXlh7dq1mD17tthx6DlwxoaIyEAoVcJL777D7+Cy8XMhMh75+fmYPXs2vv76awBA69atER0djWbNmokbzEhV5PtX9OvYEBFR8bVWli9fjgkTJqBGjRov9BqGuK0qEb0cbfzgYUyuXr0Kf39/XLhwAQAwbdo0LF68mOfc6QkWNkREIktLS0NAQAB+++03nDp1Cnv27IFEwj88iOjlHExIKXWBSCdeILJcBw4cgJ+fH7Kzs1GrVi1ERESgf//+Ysd6KcZW2LKwISIS0dmzZzF06FDcuXMH1tbWGDVqFIsaInppJZuKPHm+Qao8D5Mi43n+XRk8PT1hbm6O9u3bIzIyEs7OzmJHeinGWNhy8wAiIhEIgoDVq1fjjTfewJ07d9CsWTPExMRg+PDhYkcjIj2nVAkI2ZtY5hbwJW0hexOhVFWp06xF8fg1qurVq4fTp0/j8OHDBlHUTIqM1yhqgP8K24MJKSIl0y0WNkRElSw7OxujR4/GBx98gMLCQgwZMgQxMTFwd3cXOxoRGYCYpPRSf9A+TgCQIs9DTFJ65YWqYlQqFZYtWwZXV1fs3btX3e7m5gZTU1MRk708Yy5sWdgQEVWyvLw8nDx5Eqampli2bBm2b9/OnbaISGvSMssval6kn6G5d+8e3nzzTcycOROFhYXYt2+f2JG0ypgLW55jQ0RUyezt7bFz507k5OTgjTfeEDsOERkYB1vpsztVoJ8h+eWXXzB69GikpaXB0tISYWFheO+998SOpVXGXNhyxoaISMeKioowe/ZsbNy4Ud3Wrl07FjVEpBPtXWrCSSZFeduQSFB8Enl7l5qVGUtUBQUF+OSTT9CnTx+kpaXB09MTcXFxGD9+vMFt2GLMhS0LGyIiHUpLS0Pv3r2xePFiTJkyBXfu3BE7EhEZOFMTCYJ9i8/Ze/JP9pL7wb7uBr3t75N+++03LF26FAAwefJkgz6v0ZgLWxY2REQ6cubMGbRp0wZHjx6FtbU1Nm/ejLp164odi4iMgI+nE8JHtYGjTPNXeUeZ1Ci3evbx8cHMmTOxa9curF69GpaWlmJH0hljLmwlgiBUqS0RFAoFZDIZ5HI5T6YlIr1UspVzYGAgCgsL4ebmhl27dqF58+ZiR3smfgeXjZ8L6Stju0BjiaysLHz66acICgqCk5NxFXElDOU6NhX5/uXmAUREWiQIAsaMGYPvv/8eAODn54cNGzbA1tZW5GREZIxMTSTo6GovdoxKdeHCBfj7++Pq1au4evUqDhw4YHDn0TwPH08n9HJ3NKrCloUNEZEWSSQSuLq6wtTUFEuXLsX06dONckAlIqpsgiAgLCwMs2bNQkFBAV555RV8+umnRv0dbGyFLQsbIiItyMvLg1RavJZ9zpw5GDRoELy8vERORURkHO7fv4+xY8di//79AICBAwdiw4YNsLc3nj/qiZsHEBG9lKKiIsyaNQudOnVCbm4uAMDExIRFDRFRJbl8+TK8vLywf/9+WFhYYPXq1di9ezeLGiPEGRsiohd07949BAQE4OjRowCAPXv2YPjw4SKnIiIyLi4uLrCzs0P16tWxdetWtGzZUuxIJBIWNkREL+D06dPw8/PD3bt3YW1tjY0bN2LYsGFixyIiMgp3796Fo6MjTExMYGNjg/3798PR0RHW1tZiRyMRcSkaEVEFCIKAVatWoWvXrrh79y7c3NwQGxvLooaIqJJs374d7u7u+Prrr9Vtrq6uLGqIhQ0RUUXMnz8fU6dORVFREfz8/BATE6MX16chItJ3OTk5mDBhAoYNGwa5XI6ffvoJKpVK7FhUhbCwISKqgDFjxsDR0RErVqzADz/8wOvTEBFVgsuXL6Ndu3ZYv349JBIJgoKCcOTIEZiY8E9Z+g/PsSEieoYrV66oZ2Xq16+Pa9euwcbGRuRURESGTxAEhIeHIzAwEPn5+XB0dERkZCR69uwpdjSqgljmEhGVo2QrZw8PD+zZs0fdzqKGiKhyXLt2DdOnT0d+fj7efPNN/PHHHyxqqFycsSEiKsO9e/fg7++PY8eOAQDOnz+PAQMGiBuKiMjING3aFMuWLYNSqcS0adO49IyeioUNEdETHt/K2cbGBhs3boSfn5/YsYiIDJ5SqcSCBQswYMAAtGrVCgAwdepUcUOR3mDZS0T0/wRBwMqVK9VbOTdv3hwxMTEsaoiIKkFycjJ69OiB4OBg+Pv7Iz8/X+xIpGdY2BAR/b9Tp05h2rRpKCoqwrBhw7iVMxFRJfnxxx/RqlUrnDhxAjY2NpgzZw4sLCzEjkV6hkvRiIj+3+uvv45p06ahYcOGmDZtGiQSidiRiIgMWm5uLj7++GP873//AwC0a9cO0dHRaNy4scjJSB+xsCEio/bTTz+hY8eOcHBwAACNK1kTEZHupKWlwdvbG5cvXwYAfPzxx1iwYAHMzc1FTkb6ikvRiMgoFRUVYebMmRg0aBD8/f1RVFQkdiQiIqNSq1YtODg4wMHBAQcOHMDSpUtZ1NBL4YwNERmd1NRU+Pv74/jx4wCAtm3bipyIiAyVUiUgJikdaZl5cLCVor1LTZiaGO8y14yMDJibm8PKygomJiaIjIwEADg6OoqcjAwBCxsiMiq///47/Pz8kJKSAltbW0RERGDIkCFixyIiA3QwIQUhexORIs9TtznJpAj2dYePp5OIycRx5swZjBgxAn369MGaNWsAsKAh7eJSNCIyCoIgICwsDN26dUNKSgrc3d0RGxvLooaIdOJgQgomRcZrFDUAkCrPw6TIeBxMSBEpWeVTKpVYuHAhXn/9ddy4cQOHDx9GRkaG2LGoEihVAs5cf4ifLt7BmesPoVQJOj0eZ2yIyCjk5ORg9erVKCoqgr+/P9avXw8bGxuxYxGRAVKqBITsTURZf8IJACQAQvYmope7o8EvS7t79y5Gjx6N3377DQAQEBCA8PBwyGQykZORrokxY8kZGyIyCtbW1ti1axdWrlyJLVu2sKghIp2JSUovNVPzOAFAijwPMUnplRdKBPv374eXlxd+++03WFlZISIiAlFRUSxqjIBYM5acsSEig7Vjxw48ePAA77//PgDA09MTnp6eIqciIkOXlll+UfMi/fRRZmYmxowZg4cPH6JVq1bYunUrmjVrJnYsqgRizlhyxoaIDE5RURE+/vhj+Pn54cMPP8SFCxfEjkRERsTBVqrVfvqoZHOWqVOn4uzZsyxqjIiYM5Y6KWwyMzMxffp0NGjQAJaWlujUqRNiY2N1cSgiIg2pqano2bMnli9fDgCYMWMGWrRoIXIqEptSqcScOXPg4uICS0tLuLq6Yt68eRAE3Z7ISsapvUtNOMmkKO+3aAmKzzVo71KzMmPplCAI2Lx5M/bu3atu8/X1RVhYGCwsLERMRpVNzBlLnSxFe++995CQkIDvv/8ezs7OiIyMhLe3NxITE1G3bl1dHJKICKdOnYKfnx9SU1Nha2uLTZs2YfDgwWLHoipg8eLFCA8Px+bNm+Hh4YG4uDiMHTsWMpkMU6dOFTseGRhTEwmCfd0xKTIeEkBjSU5JsRPs624wGwcoFApMnjwZUVFRqFmzJhISEuDkZHzbWVMxMWcstT5jk5ubi507d2LJkiV444030LhxY3z55Zdo3LgxwsPDtX04IiIAwKpVq9C9e3ekpqaq/3BlUUMlTp8+jYEDB6Jfv35o2LAhhg4dit69eyMmJkbsaGSgfDydED6qDRxlmn+8OcqkCB/VxmCuYxMbG4s2bdogKioKpqamCAwMhIODg9ixSERizlhqfcamqKgISqUSUqnmf8iWlpY4depUqf75+fnIz89X31coFNqORERGoKCgAEVFRQgICMD69ethbW0tdiSqQjp16oR169bh6tWraNq0KS5duoRTp05hxYoVYkcjA+bj6YRe7o6ISUpHWmYeHGyL/5gzhJkalUqFFStWICgoCEVFRahfvz6io6PRqVMnsaORyMScsdR6YWNra4uOHTti3rx5aN68OerUqYPo6GicOXMGjRs3LtU/NDQUISEh2o5BREZApVLBxKR44jkwMBBubm548803IZHo/x8NpF2zZ8+GQqGAm5sbTE1NoVQqsWDBAowcObLM/vzRjbTF1ESCjq72YsfQqoKCAgwcOBAHDx4EAAwZMgTr169HjRo1RE5GVUXJjOWT17Fx1Mfr2Hz//fcQBAF169aFhYUFVq5ciYCAAPUfII8LCgqCXC5X35KTk3URiYgMzI4dO/Daa68hMzMTACCRSNCvXz8WNVSmbdu2ISoqClu2bEF8fDw2b96MZcuWYfPmzWX2Dw0NhUwmU9/q1atXyYmJqi5zc3M0bNgQUqkUa9euxfbt21nUUCk+nk44NasHose/hjD/Voge/xpOzeqh02WYEkGHW8JkZ2dDoVDAyckJw4cPR1ZWFvbv3//U5ygUCshkMsjlctjZ2ekqGhHpqcLCQsyePVu9hGju3LmYM2eOyKkMh6F+B9erVw+zZ8/GlClT1G3z589HZGQk/vrrr1L9y5qxqVevnsF9LkTPq7CwEJmZmahZs/i8iNzcXNy4cQPNmzcXORkZuoqMSzq9QKe1tTWsra3x6NEjHDp0CEuWLNHl4YjIwKWkpGD48OE4efIkAOCTTz5BUFCQyKlIH+Tk5JRaNWBqagqVSlVmfwsLC25RS/T/rl+/joCAANjZ2eGXX36BiYkJLC0tWdRQlaOTwubQoUMQBAHNmjXDP//8g5kzZ8LNzQ1jx47VxeGIqgylSjDIk0SrgpMnT2LYsGHqrZw3b96Mt956S+xYpCd8fX2xYMEC1K9fHx4eHrhw4QJWrFiBcePGiR2NqErbsmUL3n//fWRmZqJ69eq4evUq3NzcxI5FVCadFDZyuRxBQUG4ffs2atasiSFDhmDBggWoVq2aLg5HVCUcTEgpdZKck45PkjMWO3bsgL+/P5RKJTw8PLBr1y40bdpU7FikR1atWoU5c+Zg8uTJSEtLg7OzMyZOnIgvvvhC7GhEVVJWVhY+/PBDbNq0CQDQpUsXREVFoX79+uIGI3oKnZ5j8yIMdX03GbaDCSmYFBmPJ/9jKpmrMaRrFoghNTUVbdq0Qffu3bFu3Tpu5axD/A4uGz8XMiYXLlyAv78/rl69ChMTE3z++eeYM2cOzMx0egYDUZmqzDk2RMZAqRIQsjexVFEDFO/dLgEQsjcRvdwduSytAtLS0tQXeXN0dERcXBycnJy46xkRkQ4JgoCxY8fi6tWrqFu3LqKiotC1a1exYxE9F51s90xkTGKS0jWWnz1JAJAiz0NMUnrlhdJz27dvh6urK6Kjo9Vtzs7OLGqIiHRMIpFg8+bN8PPzw6VLl1jUkF5hYUP0ktIyyy9qXqSfMSssLERgYCCGDRuGrKwsbNmyBVVstSwRkcE5evQo1q1bp77v5eWFbdu2wd7esC4sSoaPhQ3RS3KwlWq1n7FKSUlBjx498NVXXwEAZs2ahd27d3OWhohIR4qKivD555+jZ8+emDJlCuLj48WORPRSeI4N0Utq71ITTjIpUuV5ZZ5nIwHgKCve+pnK9vhWznZ2dti8eTMGDRokdiwiIoN148YNjBgxAmfOnAEAvPPOO2jWrJnIqYheDmdsiF6SqYkEwb7uAP7bBa1Eyf1gX3duHFCOpKQk9OjRA6mpqfD09ERcXByLGiIiHdqxYwdatWqFM2fOwM7ODlu3bsX69eu54yTpPRY2RFrg4+mE8FFt4CjTXG7mKJNyq+dncHFxQWBgIEaOHImzZ8+iSZMmYkciIjJYU6dOhZ+fH+RyOV577TVcvHgRw4cPFzsWkVZwKRqRlvh4OqGXuyNiktKRlpkHB9vi5WecqSktMTERdnZ2eOWVVwAAoaGhkEgkPJ+GiEjHXFxcIJFIMHv2bISEhPDi6WRQWNgQaZGpiQQdXbmLzNP88MMPePfdd9GiRQscP34c5ubmMDHh5DERkS4IgoAHDx6gdu3aAIBp06bh9ddfR7t27URORqR9/GuCiCpFYWEhpk+fDn9/f2RnZ8PS0hLZ2dlixyIiMljp6ekYMmQIunTpgqysLACAiYkJixoyWCxsiEjn7t69i+7duyMsLAwAMHv2bPzyyy+oUaOGyMmIiAzTyZMn4eXlhd27dyMpKQmnT58WOxKRzrGwISKdOn78ONq0aYPff/8ddnZ22L17N0JDQ2FmxpWwRETaplQqERISgm7duuH27dto0qQJzp49i969e4sdjUjn+JcFEemMSqVCYGAg7t27hxYtWmDnzp3c9YyISEeSk5MxatQonDhxAgAwZswYrFq1Cra2tiInI6ocnLEhIp0xMTHBDz/8gIkTJ+LMmTMsaoiIdOjjjz/GiRMnYGNjg8jISGzatIlFDRkVztgQkVYlJibi999/x/jx4wEAjRs3xpo1a0RORURk+MLCwpCVlYWwsDA0btxY7DhElY4zNkSkNVu3bkX79u0xceJE/Prrr2LHISIyaFeuXEFoaKj6vqOjI/bv38+ihowWCxsiemkFBQWYNm0aAgICkJ2dje7du6Nly5ZixyIiMkiCIODbb79F27Zt8emnn2Lnzp1iRyKqErgUjYheyt27d+Hn56feSjQoKAjz5s2DqampyMmIiAxPRkYGJk6ciG3btgEAevXqhc6dO4uciqhqYGFDRC/s2LFjGD58ONLS0mBnZ4fvvvsOAwcOFDsWEZFBOnv2LAICAnDjxg2YmZlhwYIF+Pjjj2FiwgU4RAALGyJ6CVevXkVaWhpatmyJnTt3cl03EZGOfPPNN5g+fTqUSiVcXFwQHR2NDh06iB2LqEphYUNEL2z8+PEwNTVFQEAArKysxI5DRGSwGjRoAKVSiYCAAISHh0Mmk4kdiajK4dwlET23P//8E3379sWjR48AABKJBO+++666qFGqBJy5/hA/XbyDM9cfQqkSxIxLRKTXHjx4oP7fvr6+OHv2LKKioljUEJWDMzZE9Fyio6Px3nvvIScnBx9//DE2bNig8fjBhBSE7E1EijxP3eYkkyLY1x0+nk6VHZeISG/l5+dj9uzZ+O6773DhwgXUr18fALj0jOgZOGNDRE9VUFCAqVOnYsSIEcjJyYG3tzcWLVqk0edgQgomRcZrFDUAkCrPw6TIeBxMSKnMyEREavo2k3z16lV07NgRX3/9NdLT07F3716xIxHpDc7YEFG57ty5g2HDhqm3cv70008xd+5cja2clSoBIXsTUdafCgIACYCQvYno5e4IUxNJpeQmIgL0ayZZEAR89913mDJlCrKzs2Fvb4+IiAj4+vqKHY1Ib3DGhojKdP78ebRp0wanT5+GTCbDTz/9hAULFpS6Pk1MUnqpmZrHCQBS5HmISUrXcWIiov/o00yyQqHA6NGj8c477yA7OxvdunXDpUuXWNQQVRALGyIqU8OGDWFpaYmWLVsiLi4OAwYMKLNfWmb5Rc2L9CMielnPmkkGimeSq8qytOXLlyMqKgqmpqaYN28ejhw5grp164odi0jvcCkaEanl5ubC0tISAGBvb4/Dhw+jbt26T93K2cFW+lyv/bz9iIheVkVmkju62ldesHLMnj0b58+fR1BQEDp37ix2HCK9xRkbIgJQvJVzq1at8O2336rbmjRp8szr07R3qQknmRTlnT0jQfGa9vYuNbUXlojoKar6TPK9e/fw+eefQ6lUAgAsLS2xb98+FjVEL4mFDREhOjoa7du3x9WrV7FkyRIUFBQ893NNTSQI9nUHgFLFTcn9YF93bhxARJWmKs8k//LLL/Dy8sKCBQuwePHiSj8+kSFjYUNkxMrayvn06dMwNzev0Ov4eDohfFQbOMo0/0hwlEkRPqpNldt9iIgMW1WcSS4oKMCsWbPQp08f3Lt3Dx4eHhg4cGClHZ/IGPAcGyIjdefOHfj5+eHMmTMAgM8++wwhISGldj17Xj6eTujl7oiYpHSkZebBwbb4jwbO1BBRZSuZSZ4UGQ8JoLGJgBgzydevX8eIESMQExMDAJg0aRKWL1+uPqeRiLSDhQ2REVIoFGjXrh1SU1Mhk8nw/fffa2VbUVMTSZU4EZeIqGQm+cnr2DhW8nVs9u3bhxEjRiAzMxPVq1fHhg0bMHjw4Eo5NpGxYWFDZITs7OwwefJk7Ny5Ezt37oSrq6vYkYiItK4qzCQ3aNAABQUF6NKlC6KiolC/fv1KOzaRsZEIglA1NnH/fwqFAjKZDHK5HHZ2dmLHITIYcrkccrlcPaiqVCrk5+dzKQRp4Hdw2fi5UEWkp6ejZs3/zt+JiYlBmzZtYGbG35OJKqoi37/cPIDIgChVAs5cf4ifLt7BmesP1Refu3z5Ml599VUMGDAAubm5AAATExMWNUREWiQIAsLCwlC/fn2cO3dO3d6+fXsWNUSVgP+VERmIgwkppdaSO8mkeF3yF1bP+wQ5OTmoV68ekpOT0bRpUxGTElW+hg0b4ubNm6XaJ0+ejNWrV4uQiAzN/fv3MXbsWOzfvx8AEBkZiQ4dOoicisi4aH3GRqlUYs6cOXBxcYGlpSVcXV0xb948VLEVb0QG5WBCCiZFxmsUNYKyEH/u+BpLgz5ATk4OevXqhfj4eBY1ZJRiY2ORkpKivh0+fBgA4OfnJ3IyMgRHjx6Fl5cX9u/fDwsLC6xatQorV64UOxaR0dH6jM3ixYsRHh6OzZs3w8PDA3FxcRg7dixkMhmmTp2q7cMRGT2lSkDI3kSN7UyLFA/w4KdFyL/7FwCgbveR2Ld/E8yrcZKWjFPt2rU17i9atAiurq7o2rWrSInIEBQVFeHLL7/EwoULIQgC3NzcsHXrVnh5eYkdjcgoaf2vnNOnT2PgwIHo168fgOLp/+joaPXe7USkXTFJ6RozNQCQ/stq5N/9CyYW1rDv/xHMGrfH+VtybsVMhOILJUZGRiIwMBASSdm7Y+Xn5yM/P199X6FQVFY80iPbtm3DggULAADvvvsuwsLCYG1tLXIqIuOl9aVonTp1wq+//oqrV68CAC5duoRTp06hb9++2j4UEQFIy8wr1Vaz9yRIG7SC4zthsGrcvtx+RMboxx9/REZGBt55551y+4SGhkImk6lv9erVq7yApDcCAgIwYsQIbN26Fd9++y2LGiKRaX3GZvbs2VAoFHBzc4OpqSmUSiUWLFiAkSNHltmfv4oRvRwHWylU+dnIvR4La/duAAAzOwfU8Z9fqh8RARs2bEDfvn3h7Oxcbp+goCAEBgaq7ysUChY3hJycHISGhuKTTz6Bra0tJBIJoqKixI5FRP9P64XNtm3bEBUVhS1btsDDwwMXL17E9OnT4ezsjDFjxpTqHxoaipCQEG3HIDIa0szbuP99IPIe3oGkmhRWTV7TeFyC4ittt3epWfYLEBmRmzdv4siRI9i1a9dT+1lYWMDCwqKSUpE+uHz5Mvz9/ZGYmIjk5GRs2rRJ7EhE9AStL0WbOXMmZs+eDX9/f7Ro0QKjR4/GjBkzEBoaWmb/oKAg9YUD5XI5kpOTtR2JyGBFRkaic6eOyHt4B6Z2tWFmo1m8lJw9EOzrXqlX2iaqqiIiIuDg4KA+D5ToWQRBQHh4ONq3b4/ExEQ4Ojpi1KhRYsciojJovbDJycmBiYnmy5qamkKlUpXZ38LCAnZ2dho3Inq6/Px8TJkyBaNHj0Zubi569+6NqH2/oYFbS41+jjIpwke1gY+nk0hJiaoOlUqFiIgIjBkzhhdLpOeSnp6OIUOGYPLkycjLy0Pfvn1x6dIleHt7ix2NiMqg9W92X19fLFiwAPXr14eHhwcuXLiAFStWYNy4cdo+FJFRSk5Ohp+fn/qq1nPmzEFwcDBMTU0xtLMHYpLSkZaZBwfb4uVnnKkhKnbkyBHcunWL4xE9lwsXLmDgwIFITk5GtWrVsGjRIkyfPr3Uj7dEVHVovbBZtWoV5syZg8mTJyMtLQ3Ozs6YOHEivvjiC20fisgo/f777zh37hyqV6+OyMhIjSU1piYSbulMVI7evXvzYtH03JydnZGfn4/GjRtj69ataNu2rdiRiOgZJEIV+5ZXKBSQyWSQy+VclkZUjhUrVmDQoEFo1KiR2FHIwPA7uGz8XIzDo0ePUKNGDfX9ixcvwtXVFba2tiKmIjJuFfn+5XwqURWXkZGB8ePH4969e+q2wMBAFjVERFr0008/oXHjxvjhhx/Uba1atWJRQ6RHWNgQVWF//PEH2rVrh2+//fapFxMkIqIXk5eXhw8//BCDBg1Ceno61q1bxyWLRHqKhQ1RFfX999/jtddew/Xr19GgQQPMmzdP7EhERAblypUr6NChA7755hsAwEcffYQDBw5AIuGmK0T6iIUNURWTn5+PyZMn4+2330Zubi769OmD8+fPo127dmJHIyIyCIIgYMOGDWjXrh3++OMP1K5dGz///DOWLVsGc3NzseMR0QviRv5EVUhKSgreeust9VbOX3zxBb744guYmpqKnIyIyHDEx8fjvffeAwB4e3vj+++/h6Ojo8ipiOhlsbAhqkKsra2RkZGB6tWrIyoqCm+++abYkYiIDE7btm0xc+ZM2NvbY+bMmbw2DZGBYGFDJDKVSgWJRAKJRAI7Ozv8+OOPMDc3565nRERaolKpsGLFCvj5+aFBgwYAgCVLloicioi0jT9REIkoIyMDb731FsLCwtRtbm5uLGqIiLQkJSUFvXv3xsyZMzFy5EgolUqxIxGRjrCwIRJJyVbOe/bswZw5c/DgwQOxIxERGZSff/4ZLVu2xK+//gorKyu8++67XHZGZMD4XzeRCL777juNrZyPHTuGWrVqiR2LXpJSJeDM9Yf46eIdnLn+EEoVr4VBJIb8/HwEBgaiX79+ePDgAby8vHD+/HmMHTuWWzkTGTCeY0NUifLz8zFjxgyEh4cDAHx8fBAZGQl7e3uRk9HLOpiQgpC9iUiR56nbnGRSBPu6w8fTScRkRMblzp07GDBgAOLj4wEAU6dOxeLFiyGVSkVORkS6xhkbokqiVCrRs2dPhIeHQyKRIDg4GPv372dRYwAOJqRgUmS8RlEDAKnyPEyKjMfBhBSRkhEZH3t7exQWFsLe3h579uxBWFgYixoiI8EZG6JKYmpqiiFDhiAxMRFRUVHo27ev2JFIC5QqASF7E1HWojMBgARAyN5E9HJ3hKkJl8AQ6UJmZiasrKxgamoKqVSKnTt3wsrKCnXr1hU7GhFVIs7YEOmQSqXCvXv31PenT5+OxMREFjUGJCYpvdRMzeMEACnyPMQkpVdeKCIjEhcXh9atW2PhwoXqtiZNmrCoITJCLGyIdOTRo0cYNGgQunbtCoVCAQCQSCS8urWBScssv6h5kX5E9HxUKhWWL1+OTp064fr169i0aRNyc3PFjkVEImJhQ6QDFy9eRLt27bB3717cuHEDMTExYkciHXGwfb61+8/bj4ie7d69e+jXrx8+/vhjFBYWYsiQIYiLi4OlpaXY0YhIRCxsiLRs8+bN6NixI/799180bNgQv//+O7y9vcWORTrS3qUmnGRSlHf2jATFu6O1d6lZmbGIDNbhw4fh5eWFgwcPQiqVYs2aNdi+fTtq1KghdjQiEhkLGyItyc/Px/vvv4933nkHeXl56Nu3L86fP4+2bduKHY10yNREgmBfdwAoVdyU3A/2defGAURacP/+fQwcOBD37t2Dh4cH4uLiMHHiRF6bhogAsLAh0pqZM2di7dq1kEgk+PLLL7Fv3z7UrMlf6Y2Bj6cTwke1gaNMc7mZo0yK8FFteB0bIi2pXbs2li9fjvfffx+xsbHw8PAQOxIRVSESQRCq1KWxFQoFZDIZ5HI57OzsxI5D9NxSU1PRq1cvLF26FD4+PmLHIREoVQJiktKRlpkHB9vi5Wf6NlPD7+Cy8XMRT3R0NFxcXPDaa6+JHYWIRFCR719ex4boBalUKvzyyy/qIsbR0RGXLl2CiQknQo2VqYkEHV15wVUibcjKysLUqVMRERGBhg0b4uLFi5DJZGLHIqIqjH+BEb2AR48eYcCAAejbty+ioqLU7SxqiIheXsnOkhERETAxMcHbb78Na2trsWMRURXHGRuiCrpw4QKGDBmCpKQkWFhYQKlUih2JiMggCIKAVatWYebMmSgoKEDdunURFRWFrl27ih2NiPQACxuiCoiIiMDkyZORl5eHhg0bYufOnWjTpo3YsYiI9F52djb8/f2xb98+AMCAAQOwceNG2NtzeScRPR+umyF6Dnl5eZg4cSLGjRuHvLw8vPnmmzh//jyLGiIiLbGysoJEIoG5uTlWrVqFH3/8kUUNEVUIZ2wMjCHsylQVnTp1CuvWrYNEIkFISAg+++wznk9DRPSSioqKUFBQoC5qNm7ciDt37sDLy0vsaESkh1jYGJCDCSkI2ZuIFHmeus1JJkWwrzuvo/GSvL29sXDhQrRp0wZ9+vQROw4Rkd67efMmRowYgUaNGuH7778HANSqVQu1atUSORkR6Sv+5GwgDiakYFJkvEZRAwCp8jxMiozHwYQUkZLpJ5VKhSVLluDWrVvqtqCgIBY1RERasHPnTrRq1QqnT5/Gnj17cPPmTbEjEZEBYGFjAJQqASF7E1HWlVZL2kL2JkKpqlLXYq2ySrZynjVrFvz8/FBUVCR2JCIivaVUCThz/SF+ungHRxOSMWHCBAwdOhQZGRno0KEDLl68iAYNGogdk4gMAJeiGYCYpPRSMzWPEwCkyPMQk5TOiwc+w+NbOUulUkyaNAlmZvzPhIjoRTy+RLrg/g082LMEhQ9uQSKRYNasWZg7dy6qVasmdkwiMhD8i80ApGWWX9S8SD9jFRERgUmTJiE/Px8uLi7YtWsXWrVqJXYsIiK9VLJEWgAgqJS4v3MeiuT3YGpdA7X6f4SuI8exqCEireJSNAPgYCvVaj9jk5eXhwkTJmDcuHHIz89Hv379cP78eRY1REQv6Mkl0hITU9T0+RCWrq/CaewqWDZsxSXSRKR1LGwMQHuXmnCSSVHeps4SFO+O1t6lZmXG0hsqlQoxMTGQSCSYN28e9uzZgxo1aogdi4hIb8UkpSMpIQ45V8+o2ywbtoLD0GCYWlfXWCJNRKQtXIpmAExNJAj2dcekyHhIAI1NBEqKnWBfd17PphxWVlbYuXMnrl+/jt69e4sdh4hIrymVSqxaFop70V9BUs0CTg6rUK26Y5l9uUSaiLSJMzYGwsfTCeGj2sBRprnczFEmRfioNryOzWNUKhXmzZuHhQsXqttcXV1Z1BAZuDt37mDUqFGwt7eHpaUlWrRogbi4OLFjGZTbt2+jR48eiF6zHBBUsGraEaaWduX25xJpItImztgYEB9PJ/Ryd0RMUjrSMvPgYFu8/IwzNf9JT0/H6NGj8fPPP0MikWDQoEFwd3cXOxYR6dijR4/QuXNndO/eHQcOHEDt2rVx7do1LjvVop9++gnjxo1Deno6bGxsUKfvB1A26lLmpQgkKP7hjUukiUibWNgYGFMTCbd0LseFCxcwePBg3LhxA1KpFOHh4SxqiIzE4sWLUa9ePURERKjbXFxcRExkOARBwLRp07Bq1SoAQNu2bREdHY3r+TZcIk1ElUrrS9EaNmwIiURS6jZlyhRtH4rouW3cuBEdO3bEjRs30KhRI5w5cwbvvPOO2LGIqJLs2bMH7dq1g5+fHxwcHNC6dWusX79e7FgGQSKRqK/3FRgYiNOnT6NJkyZcIk1ElU4iCIJW91q8f/8+lEql+n5CQgJ69eqFo0ePolu3bs98vkKhgEwmg1wuh51d+etyiZ7Xhx9+iG+++QYA0L9/f3z33XdcfkJUDkP9DpZKi/+4DgwMhJ+fH2JjYzFt2jSsWbMGY8aMKdU/Pz8f+fn56vsKhQL16tUzuM/lRQmCgKysLNja2gIo/rzOnDlT5jivVAlcIk1EL6wi45LWl6LVrl1b4/6iRYvg6uqKrl27avtQRKWUNYC2bNlSvZVzUFAQTEy4ZwaRsVGpVGjXrp1605DWrVsjISGh3MImNDQUISEhlR1TL8jlckycOBHJyck4fvw4zMzMYGFhUe6Pl1wiTUSVRafn2BQUFCAyMhKBgYGQSPjrDOnWwYQUhOxNRIo8D6rCPJhUk8JJJsUX/fvhjz/+gKenp9gRiUgkTk5Opc6pa968OXbu3Flm/6CgIAQGBqrvl8zYGLuzZ88iICAAN27cgJmZGc6cOYPXX39d7FhERAB0vN3zjz/+iIyMjKeey5Cfnw+FQqFxI6qogwkpmBQZj7sZOcg4tQUpGz+AMjcTqfI8TI66gNvgr4VExqxz5874+++/NdquXr2KBg0alNnfwsICdnZ2GjdjplKpsGjRInTp0gU3btyAi4sLTp06xaKGiKoUnRY2GzZsQN++feHs7Fxun9DQUMhkMvWNv4hRRSlVAkL2JqIoNxNpO0Ig/30LijJSkfPXSfVOPCF7E6FUafV0MiLSIzNmzMDZs2excOFC/PPPP9iyZQvWrVvHjW2ew927d9G7d28EBQVBqVTC398fFy5cQIcOHcSORkSkQWeFzc2bN3HkyBG89957T+0XFBQEuVyuviUnJ+sqEhmomKR03Pg7ASmbpyPv3/OQmJnDvt8M2LZ+E0DxNqMp8jzEJKWLG5SIRPPqq69i9+7diI6OhqenJ+bNm4evv/4aI0eOFDtalTdmzBj8+uuvsLKywoYNG7BlyxbIZDKxYxERlaKzc2wiIiLg4OCAfv36PbWfhYUFLCwsdBWDjEDUdxFIjfwUUBbCrLojar/1KcwdGpXql5aZJ0I6Iqoq+vfvj/79+4sdQ++sWrUK7777LjZs2AA3Nzex4xARlUsnhY1KpUJERATGjBmj3tueSBdWr16N1XNnAgAsG7dHrX6BMJHalNnXwVZaZjsREf3n6tWrOHXqFMaNGwcAcHNzw6lTp7gJEBFVeTpZinbkyBHcunVL/aVIpCsBAQFwdXVFvd7j4DD48zKLGgkAJ1nx1s9ERFS+7777Dm3atMH48eNx8uRJdTuLGiLSBzopbHr37g1BENC0aVNdvDwZuUuXLqHkurI1a9bE5cuXsW75fEgkJnhy6C25H+zrzgvCERGVIzMzE6NHj8aYMWOQnZ2NN954A40alV7SS0RUlfFKhaQ3lEolgoOD0bp1a6xfv17dbmlpCR9PJ4SPagNHmeZyM0eZFOGj2sDH06my4xIR6YXz58+jTZs2iIyMhImJCebNm4cjR46gbt26YkcjIqoQngBDeuHhw4cYOXIkDh06BAC4cuVKqT4+nk7o5e6ImKR0pGXmwcG2ePkZZ2qIiMr2zTffIDAwEIWFhahfvz62bNmCzp07ix2LiOiFsLChKi8uLg5Dhw7FzZs3YWlpibVr12L06NFl9jU1kaCjKy/GSUT0PKpVq4bCwkIMHjwY3377LWrUqCF2JCKiF8bChqosQRDw7bff4oMPPkBBQQFcXV2xa9cutGzZUuxoRER6Kzs7G9bW1gCACRMmoEGDBujTpw83CCAivcdzbKjKSkxMxMSJE1FQUIABAwYgLi6ORQ0R0QsqLCzE7Nmz0aJFC2RkZAAo3u3Mx8eHRQ0RGQTO2FCV5eHhgYULF0IQBMyaNQsmJqzDiYhexL///ouAgADExMQAAHbt2sVLMhCRwWFhQ1XKgQMH0KRJEzRu3BgAMHv2bJETERHpt61bt2LixIlQKBSoXr06vv32WwwZMkTsWEREWsefwKlKKNnK+c0338SQIUOQk5MjdiQiIr2WnZ2NcePGISAgAAqFAp07d8alS5dY1BCRweKMDYnuya2cu3TpAlNTU5FTERHpt6CgIEREREAikeDzzz/HF198ATMzDvtEZLj4DUeienIr53Xr1mHUqFFixyIi0nvBwcGIiYnBokWL0K1bN7HjEBHpHJeikSgEQcD69evRuXNn3Lx5E40bN8bZs2dZ1BARvaAHDx4gLCwMgiAAAOzt7XHmzBkWNURkNDhjQ6JQKpXYuHEjCgoKMHDgQGzevBkymUzsWEREeunYsWMYOXIk7t69i+rVq2PMmDEAwG2ciciocMaGRGFmZobt27dj+fLl2LVrF4saIqIXUFRUhDlz5qBHjx64e/cumjVrhlatWokdi4hIFCxsqNLs378fCxYsUN9/5ZVXEBgYyOvTEBG9gJs3b6Jbt26YP38+BEHAuHHjcP78eXh5eYkdjYhIFFyKRjqnVCoREhKCefPmAQA6dOgAb29vkVMREemvffv2YfTo0cjIyICdnR3Wrl0Lf39/sWMREYmKhQ3p1IMHDzBy5Ej88ssvAIApU6bgjTfeEDkVEZF+s7S0hFwuR4cOHbBlyxY0atRI7EhERKJjYUM6Exsbi6FDh+LWrVuwtLTE+vXrMXLkSLFjERHppZycHFhZWQEAevbsiZ9//hk9e/ZEtWrVRE5GRFQ18OQG0omIiAh06dIFt27dQuPGjXHu3DkWNUREL0AQBKxZswYuLi64fv26ut3Hx4dFDRHRY1jYkE5IpVIUFBRg0KBBiIuLQ4sWLcSORESkd9LT0zF06FBMmjQJaWlpWLt2rdiRiIiqLC5FI61RqVTqHc4CAgJQu3Zt9OzZk9dRICJ6AadOncKIESOQnJyMatWqITQ0FDNmzBA7FhFRlcUZG9KKffv2oWXLlrh37566zdvbm0UNEVEFKZVKzJ07F127dkVycjIaN26MM2fO4KOPPuL2+ERET8FvSHopSqUSc+bMga+vL/7880+EhoaKHYmISK+tXbsWwcHBUKlUGD16NOLj49G2bVuxYxERVXlcikYv7MGDBxgxYgQOHz4MAPjggw+wZMkSkVMREem39957Dzt27MDYsWMxevRoseMQEekNFjb0Qh7fytnKygrr1q3jrmdERC8gLy8Pq1evxtSpU1GtWjWYm5vj119/5VJeIqIKYmFDFXb48GH0798fBQUFaNKkCXbt2gVPT0+xYxER6Z2//voL/v7+uHTpEtLT07FgwQIAYFFDRPQCWNhQhb322mtwcXGBu7s7IiIiIJPJxI5ERKRXBEHAxo0bMXXqVOTk5KB27dro3Lmz2LGIiPQaCxt6Lnfv3oWTkxMkEglsbW1x4sQJ1K5dm78qEhFVkFwux8SJE/HDDz8AKN5B8rvvvoOTk5PIyYiI9Bt3RaNn2rt3L9zd3fHVV1+p2xwcHFjUEBFVUHx8PFq3bo0ffvgBZmZmWLRoEQ4dOsSihohIC1jYULmUSiU+++wzDBgwAHK5HD/99BOUSqXYsYiI9Ja1tTXu3buHhg0b4uTJk5g1axavTUNEpCVcikZlun//PkaMGIEjR44AAD788EMsW7YMpqamIicjItIvubm5sLS0BAA0a9YM+/btQ5s2bXh+IhGRlvFnIiolJiYGbdu2xZEjR2BlZYUtW7Zg5cqVMDc3FzsaEZFe+fnnn9GoUSMcP35c3da9e3cWNUREOsDChjQ8ePAAPXr0QHJyMpo2bYpz584hICBA7FhERHolPz8fgYGB6NevH1JTU7F06VKxIxERGTwuRSMNtWrVwoIFC3D8+HFs2rQJdnZ2YkciItIr165dg7+/P+Lj4wEUL+VdsmSJyKmIiAwfZ2wI//zzD65cuaK+P3XqVOzcuZNFDREZjC+//BISiUTj5ubmpvXjfP/992jTpg3i4+Nhb2+PPXv2YOXKlZBKpVo/FhERaeKMjZHbs2cP3n77bdSpUwexsbGws7PjNs5EZJA8PDzUG6IAgJmZdofA3377DW+//TYAoGvXroiKikLdunW1egwiIiofCxsjpVQq8cUXX2DhwoUAigf8nJwcztIQkcEyMzODo6Ojzl6/e/fu8Pf3h7u7Oz799FPuIklEVMm4FM0I3b9/Hz4+PuqiZurUqTh69KhOB3wiIrFdu3YNzs7OaNSoEUaOHIlbt2691OupVCqEh4cjIyMDACCRSLBlyxbMmTOHRQ0RkQhY2BiZc+fOoU2bNjhy5Aisra0RHR2NsLAwbuVMRAatQ4cO2LRpEw4ePIjw8HAkJSXh9ddfR2ZmZpn98/PzoVAoNG6PS0tLQ79+/TB58mSMHz8egiAAAJfyEhGJSCeFzZ07dzBq1CjY29vD0tISLVq0QFxcnC4ORRX05Zdf4vbt22jWrBnOnTsHf39/sSMREelc37594efnh5YtW6JPnz74+eefkZGRgW3btpXZPzQ0FDKZTH2rV6+e+rHDhw+jZcuWOHjwIKRSKXr27FlZb4OIiJ5C64XNo0eP0LlzZ1SrVg0HDhxAYmIili9fjho1amj7UPQCNm/ejPfffx8xMTHw8PAQOw4RkSiqV6+Opk2b4p9//inz8aCgIMjlcvUtOTkZAPDFF1+gd+/euHfvHjw8PBAbG4v333+fMzVERFWA1jcPWLx4MerVq4eIiAh1m4uLi7YPQ8/pn3/+we7duzFz5kwAgIODA8LDw0VORUQkrqysLFy/fh2jR48u83ELCwtYWFiUag8LCwMAvP/++1i+fDmsrKx0mpOIiJ6f1mds9uzZg3bt2sHPzw8ODg5o3bo11q9fX27/Z61jphdX8m/xySefYOvWrWLHISISzccff4zjx4/jxo0bOH36NN566y2YmpoiICCgQq8jk8mwY8cOhIeHs6ghIqpitF7Y/PvvvwgPD0eTJk1w6NAhTJo0CVOnTsXmzZvL7P+0dcz0YoqKivDpp59i4MCBkMvl6Ny5M9544w2xYxERieb27dsICAhAs2bNMGzYMNjb2+Ps2bOoXbt2hV7n999/x5AhQ3SUkoiIXoZEKNnKRUvMzc3Rrl07nD59Wt02depUxMbG4syZM6X65+fnIz8/X31foVCgXr16kMvlvKbKC0hLS0NAQAB+++03AMD06dOxZMkSVKtWTeRkRKQPFAoFZDIZv4OfwM+FiEgcFfn+1fo5Nk5OTnB3d9doa968OXbu3Flm//LWMVPFnTt3DkOHDsXt27dhbW2NDRs2YPjw4WLHIiIiIiLSOa0XNp07d8bff/+t0Xb16lU0aNBA24eiJ9y7d0+9lfOuXbtKFZhERGR8lCoBMUnpSMvMg4OtFO1dasLUhLu4EZHh0XphM2PGDHTq1AkLFy7EsGHDEBMTg3Xr1mHdunXaPhQ9YcCAAYiOjsabb77JpRJERISDCSkI2ZuIFHmeus1JJkWwrzt8PJ1ETEZEpH1a3zzg1Vdfxe7duxEdHQ1PT0/MmzcPX3/9NUaOHKntQxm9a9euoWfPnrh165a6zd/fn0UNERHhYEIKJkXGaxQ1AJAqz8OkyHgcTEgRKRkRkW5ofcYGAPr374/+/fvr4qXp//300094++23oVAo8MEHH2DPnj1iRyIioipCqRIQsjcRZe0OJACQAAjZm4he7o5clkZEBkPrMzakW0VFRZg9ezYGDRoEhUKBzp07Y82aNWLHIiKiKiQmKb3UTM3jBAAp8jzEJKVXXigiIh3TyYwN6Qa3ciYioueRlll+UfMi/YiI9AELGz3x119/wdvbG3fu3IG1tTU2btyIYcOGiR2LiIiqIAdbqVb7ERHpAxY2eqJ+/fqoVasWbG1tsXPnTm7lTERE5WrvUhNOMilS5XllnmcjAeAoK976mYjIULCw0TJtXi8gJycHUqkUJiYmsLKywt69e1G9enXY2tpqOTURERkSUxMJgn3dMSkyHhJAo7gpGZGCfd25cQARGRQWNlqkzesFXL16FYMHD8awYcPwxRdfAADq1aun1bxERGS4fDydED6qTalxyZHXsSEiAyURBKGsWWrRKBQKyGQyyOVyvboeS8n1Ap78MEt+Cwsf1ea5B5Hdu3djzJgxyMzMhLOzM65cuaJXnwUR6S99/Q7WNX3+XLS5koCIqLJV5PuX2z1rwbOuFwAUXy9AqXp6DVlUVIRZs2Zh8ODByMzMxOuvv464uDi9G0SJiKjqMDWRoKOrPQa2qouOrvYsaojIYLGw0QJtXC/g3r176N27N5YsWQIACAwMxK+//gonJy4VICIiIiJ6Fp5jowUve72AgoICdO7cGdevX4eNjQ02btwIPz8/bUYkIiIiIjJonLHRgpe9XoC5uTmCgoLQvHlzxMTEsKghIiIiIqogFjZaUHK9gPJWLUtQvDva49cLyM7Oxt9//62+/+677yI+Ph7NmzfXbVgiIiIiIgPEwkYLSq4XAKBUcVPW9QKuXr2KDh06oE+fPnj48KG6r1TKK0ATEREREb0IFjZaUnK9AEeZZnHiKJNqbPW8a9cutGvXDn/++Sfy8/Nx69YtMeISERERERkUbh6gRT6eTujl7ljm9QKKiorw6aefYunSpQCA119/HT/88AN3PSMiIiIi0gIWNlpWcr2Ax927dw/+/v44duwYAOCjjz5CaGgoqlWrJkJCIiIiIiLDw8KmEnz66ac4duwYbGxsEBERgaFDh4odiYiIiIjIoLCwqQTLli3DvXv3sGzZMri5uYkdh4iIiIjI4HDzAB3IysrCunXrIAgCAKBGjRrYt28fixoiIiIiIh3hjI2W/f333xgyZAj+/PNPCIKAiRMnih2JiIiIiMjgccZGi3bu3IlXX30Vf/75J5ycnODh4SF2JCIiIiIio8DCRguKioowc+ZMDB06FJmZmejatSvi4+PRpUsXsaMRERERERkFFjYvKTU1Fd7e3li2bBkA4OOPP8aRI0fg6OgocjIiIiIiIuPBc2xeUmJiIk6ePMmtnImIiIiIRMTC5iX16NED69atQ+fOnbnrGRERERGRSLgUrYKysrLw3nvv4dq1a+q2d999l0UNEREREZGIOGNTAX/99ReGDBmCxMREXLhwAbGxsTAxYW1IRERERCQ2/lX+nEq2ck5MTISTkxPCwsJY1BARERERVRH8y/wZioqK8PHHH2Po0KHIysriVs5ERERERFUQl6I9RXp6Ot566y2cOHECQPFWzqGhoTAz48dGRERERFSV8C/0p7CxsUFBQQFsbW0RERGBIUOGiB2JiIiIiIjKwKVoTxAEAUqlEgBgbm6OHTt2IDY2lkUNEZGBWLRoESQSCaZPny52FCIi0iIWNo/JzMyEv78/goKC1G1169ZFs2bNRExFRETaEhsbi7Vr16Jly5ZiRyEiIi1jYfP/rly5gg4dOmDbtm34+uuvkZSUJHYkIiLSoqysLIwcORLr169HjRo1xI5DRERaxsIGwPbt29G+fXtcuXIFzs7OOHbsGFxcXMSORUREWjRlyhT069cP3t7ez+ybn58PhUKhcSMioqrNqAubwsJCBAYGYtiwYcjKykK3bt0QHx+PTp06iR2NiIi0aOvWrYiPj0doaOhz9Q8NDYVMJlPf6tWrp+OERET0soy2sBEEAQMHDsRXX30FAJg5cyYOHz6MOnXqiJyMiIi0KTk5GdOmTUNUVBSkUulzPScoKAhyuVx9S05O1nFKIiJ6WVovbL788ktIJBKNm5ubm7YP89IkEgnefvtt2NraYufOnViyZAmvT0NEZIDOnz+PtLQ0tGnTBmZmZjAzM8Px48excuVKmJmZqXfCfJyFhQXs7Ow0bkREVLXp5C95Dw8PHDly5L+DVJGCQRAE3LlzB6+88goAwN/fHz179kTt2rVFTkZERLrSs2dPXL58WaNt7NixcHNzw6xZs2BqaipSMiIi0iadVBxmZmZwdHTUxUu/sMzMTLz33ns4ceIE4uPj4eTkBAAsaoiIDJytrS08PT012qytrWFvb1+qnYiI9JdOzrG5du0anJ2d0ahRI4wcORK3bt3SxWGe25UrV9C+fXts27YNDx48wJkzZ0TNQ0RERERE2qX1GZsOHTpg06ZNaNasGVJSUhASEoLXX38dCQkJsLW1LdU/Pz8f+fn56vva3lJz+/btGDduHLKyslC3bl1s374dHTt21OoxiIhIvxw7dkzsCEREpGVan7Hp27cv/Pz80LJlS/Tp0wc///wzMjIysG3btjL762pLzSe3cu7evTvi4+NZ1BARERERGSCdb/dcvXp1NG3aFP/880+Zj+tqS81Fixapt3KeNWsWfvnlFzg4OGjltYmIiIiIqGrReWGTlZWF69evq0/Wf5KuttScMWMGXnvtNezevRuLFi2qMjuzERERERGR9mn9r/2PP/4Yvr6+aNCgAe7evYvg4GCYmpoiICBA24fSIAgC9uzZgwEDBkAikcDGxganT5+GRCLR6XFJk1IlICYpHWmZeXCwlaK9S02YmvDfgIiIiIh0S+uFze3btxEQEICHDx+idu3a6NKlC86ePavTbZUzMzMxbtw47NixA8uWLcNHH30EACxqKtnBhBSE7E1EijxP3eYkkyLY1x0+nmXP2BERERERaYPWC5utW7dq+yWf6sqVKxg8eDD++usvVKtWDVZWVpV6fCp2MCEFkyLjITzRnirPw6TIeISPasPihoiIiIh0Rufn2OjStm3b8Oqrr+Kvv/5C3bp1ceLECUyaNEnsWEZHqRIQsjexVFEDQN0WsjcRSlVZPYiIiIiIXp5eFjaFhYWYMWMGhg8fjuzsbPTo0QPx8fF47bXXxI5mlGKS0jWWnz1JAJAiz0NMUnrlhSIiIiIio6KXhU1CQgK++eYbAMDs2bNx6NAhbuUsorTM8ouaF+lHRERERFRRerkHcuvWrbF69WrUqVMHAwcOFDuO0XOwlWq1HxERERFRRenFjI0gCPjqq6+QkJCgbpswYQKLmiqivUtNOMmkKG8POgmKd0dr71KzMmMRERERkRGp8oWNQqGAn58fAgMDMXjwYGRnZ4sdiZ5gaiJBsK87AJQqbkruB/u683o2RERERKQzVbqw+fPPP9G+fXvs3LkT1apVw7Rp07idcxXl4+mE8FFt4CjTXG7mKJNyq2ciIiIi0rkqe47Njh07MHXqVGRnZ6Nu3brYsWMHdz2r4nw8ndDL3RExSelIy8yDg23x8jPO1BARERGRrlXZwubdd98FAPTo0QPR0dHc9UxPmJpI0NHVXuwYRERERGRkqvRSNG7lTEREREREz6PKztj88MMPGDZsmNgxiIiIiIhID1TZGRsfHx+xIxARERERkZ6osoUNERERERHR82JhQ0REREREeo+FDRERERER6T0WNkREREREpPdY2BARERERkd5jYUNERERERHqPhQ0REREREek9FjZERERERKT3WNgQEREREZHeY2FDRERERER6j4UNERERERHpPRY2RERERESk98zEDqBNSpWAmKR0pGXmwcFWivYuNWFqIhE7FhERGTGOTURElcNgCpuDCSkI2ZuIFHmeus1JJkWwrzt8PJ1ETEZERMaKYxMRUeUxiKVoBxNSMCkyXmPgAIBUeR4mRcbjYEKKSMmIiMhYcWwiIqpcel/YKFUCQvYmQijjsZK2kL2JUKrK6kFERKR9HJuIiCqf3hc2MUnppX4Ne5wAIEWeh5ik9MoLRURERo1jExFR5dP7wiYts/yB40X6ERERvSyOTURElU/vCxsHW6lW+xERkeEJDw9Hy5YtYWdnBzs7O3Ts2BEHDhzQ2fE4NhERVT69L2zau9SEk0yK8jbOlKB4B5r2LjUrMxYREVUhr7zyChYtWoTz588jLi4OPXr0wMCBA/Hnn3/q5Hgcm4iIKp/eFzamJhIE+7oDQKkBpOR+sK87rxlARGTEfH198eabb6JJkyZo2rQpFixYABsbG5w9e1Ynx+PYRERU+fS+sAEAH08nhI9qA0eZ5pS+o0yK8FFteK0AIiJSUyqV2Lp1K7Kzs9GxY8cy++Tn50OhUGjcKopjExFR5TKYC3T6eDqhl7sjr+5MRERlunz5Mjp27Ii8vDzY2Nhg9+7dcHd3L7NvaGgoQkJCXvqYHJuIiCqPRBCEKrWJvkKhgEwmg1wuh52dndhxiIiMiiF/BxcUFODWrVuQy+XYsWMHvv32Wxw/frzM4iY/Px/5+fnq+wqFAvXq1TPIz4WIqCqryLhkMDM2RERET2Nubo7GjRsDANq2bYvY2FiEhYVh7dq1pfpaWFjAwsKisiMSEdFL0Pk5NosWLYJEIsH06dN1fSgiIqLnplKpNGZliIhIv+l0xiY2NhZr165Fy5YtdXkYIiKipwoKCkLfvn1Rv359ZGZmYsuWLTh27BgOHTokdjQiItISnc3YZGVlYeTIkVi/fj1q1Kihq8MQERE9U1paGt5++200a9YMPXv2RGxsLA4dOoRevXqJHY2IiLREZzM2U6ZMQb9+/eDt7Y358+fr6jBERETPtGHDBrEjEBGRjumksNm6dSvi4+MRGxv7zL5l7TxDRERERERUEVpfipacnIxp06YhKioKUqn0mf1DQ0Mhk8nUt3r16mk7EhERERERGTitX8fmxx9/xFtvvQVTU1N1m1KphEQigYmJCfLz8zUe47UCiIiqDkO+js3L4OdCRCQOUa9j07NnT1y+fFmjbezYsXBzc8OsWbM0ihqg9LUCSuosLkkjIqp8Jd+9VezazaLj2EREJI6KjEtaL2xsbW3h6emp0WZtbQ17e/tS7WXJzMwEAC5JIyISUWZmJmQymdgxqgyOTURE4nqecUmn17F5Ec7OzkhOToatrS0kEkmFn1+ylC05OdlolwsY+2fA98/3z/f/4u9fEARkZmbC2dlZB+n0F8eml8P3z/fP98/3XxnjUqUUNseOHXvuviYmJnjllVde+ph2dnZG+X+exxn7Z8D3z/fP9/9i758zNaVxbNIOvn++f75/vv8X8bzjks4u0ElERERERFRZWNgQEREREZHeM7jCxsLCAsHBwRo7rRkbY/8M+P75/vn+jff9V1XG/u/C98/3z/fP918Z71/r17EhIiIiIiKqbAY3Y0NERERERMaHhQ0REREREek9FjZERERERKT3WNgQEREREZHeM9jCZtGiRZBIJJg+fbrYUSrNnTt3MGrUKNjb28PS0hItWrRAXFyc2LEqhVKpxJw5c+Di4gJLS0u4urpi3rx5MNS9MU6cOAFfX184OztDIpHgxx9/1HhcEAR88cUXcHJygqWlJby9vXHt2jVxwurA095/YWEhZs2ahRYtWsDa2hrOzs54++23cffuXfECa9mz/v0f9/7770MikeDrr7+utHxUPo5NHJs4NnFs4tiku7HJIAub2NhYrF27Fi1bthQ7SqV59OgROnfujGrVquHAgQNITEzE8uXLUaNGDbGjVYrFixcjPDwc33zzDa5cuYLFixdjyZIlWLVqldjRdCI7OxteXl5YvXp1mY8vWbIEK1euxJo1a3Du3DlYW1ujT58+yMvLq+SkuvG095+Tk4P4+HjMmTMH8fHx2LVrF/7++28MGDBAhKS68ax//xK7d+/G2bNn4ezsXEnJ6Gk4NnFs4tjEsYljk47HJsHAZGZmCk2aNBEOHz4sdO3aVZg2bZrYkSrFrFmzhC5duogdQzT9+vUTxo0bp9E2ePBgYeTIkSIlqjwAhN27d6vvq1QqwdHRUVi6dKm6LSMjQ7CwsBCio6NFSKhbT77/ssTExAgAhJs3b1ZOqEpU3vu/ffu2ULduXSEhIUFo0KCB8NVXX1V6NvoPxybjxLFpt/o+x6bSODZpf2wyuBmbKVOmoF+/fvD29hY7SqXas2cP2rVrBz8/Pzg4OKB169ZYv3692LEqTadOnfDrr7/i6tWrAIBLly7h1KlT6Nu3r8jJKl9SUhJSU1M1/huQyWTo0KEDzpw5I2Iy8cjlckgkElSvXl3sKJVCpVJh9OjRmDlzJjw8PMSOQ+DYxLGJYxPHptI4NmmfmU5eVSRbt25FfHw8YmNjxY5S6f7991+Eh4cjMDAQn376KWJjYzF16lSYm5tjzJgxYsfTudmzZ0OhUMDNzQ2mpqZQKpVYsGABRo4cKXa0SpeamgoAqFOnjkZ7nTp11I8Zk7y8PMyaNQsBAQGws7MTO06lWLx4MczMzDB16lSxoxA4NnFs4tgEcGx6Escm3TCYwiY5ORnTpk3D4cOHIZVKxY5T6VQqFdq1a4eFCxcCAFq3bo2EhASsWbPGKAaPbdu2ISoqClu2bIGHhwcuXryI6dOnw9nZ2SjeP5WtsLAQw4YNgyAICA8PFztOpTh//jzCwsIQHx8PiUQidhyjx7GJYxPHJnoSxybdjU0GsxTt/PnzSEtLQ5s2bWBmZgYzMzMcP34cK1euhJmZGZRKpdgRdcrJyQnu7u4abc2bN8etW7dESlS5Zs6cidmzZ8Pf3x8tWrTA6NGjMWPGDISGhoodrdI5OjoCAO7du6fRfu/ePfVjxqBk4Lh58yYOHz5sNL+InTx5Emlpaahfv776u/DmzZv46KOP0LBhQ7HjGR2OTRybODYV49hUjGOTbscmg5mx6dmzJy5fvqzRNnbsWLi5uWHWrFkwNTUVKVnl6Ny5M/7++2+NtqtXr6JBgwYiJapcOTk5MDHRrNNNTU2hUqlESiQeFxcXODo64tdff0WrVq0AAAqFAufOncOkSZPEDVdJSgaOa9eu4ejRo7C3txc7UqUZPXp0qfM4+vTpg9GjR2Ps2LEipTJeHJs4NnFsKsaxiWNTZYxNBlPY2NrawtPTU6PN2toa9vb2pdoN0YwZM9CpUycsXLgQw4YNQ0xMDNatW4d169aJHa1S+Pr6YsGCBahfvz48PDxw4cIFrFixAuPGjRM7mk5kZWXhn3/+Ud9PSkrCxYsXUbNmTdSvXx/Tp0/H/Pnz0aRJE7i4uGDOnDlwdnbGoEGDxAutRU97/05OThg6dCji4+Oxb98+KJVK9frtmjVrwtzcXKzYWvOsf/8nB8tq1arB0dERzZo1q+yoRo9jE8cmjk0cmzg2VeLYpNU91qoYY9pSUxAEYe/evYKnp6dgYWEhuLm5CevWrRM7UqVRKBTCtGnThPr16wtSqVRo1KiR8Nlnnwn5+fliR9OJo0ePCgBK3caMGSMIQvG2mnPmzBHq1KkjWFhYCD179hT+/vtvcUNr0dPef1JSUpmPARCOHj0qdnSteNa//5O43XPVwrGJYxPHJo5NHJt0MzZJBMFAL39LRERERERGw2A2DyAiIiIiIuPFwoaIiIiIiPQeCxsiIiIiItJ7LGyIiIiIiEjvsbAhIiIiIiK9x8KGiIiIiIj0HgsbIiIiIiLSeyxsiIiIiIhI77GwISIiIiIivcfChoiIiIiI9B4LGyIiIiIi0nssbIiIiIiISO+xsCEiIiIiIr3HwoaIiIiIiPQeCxsiIiIiItJ7LGyIiIiIiEjvsbAhIiIiIiK9x8KGiIiIiIj0HgsbIiIiIiLSeyxsiIiIiIhI77GwISIiIiIivcfChoiIiIiI9B4LGyIiIiIi0nssbIiIiIiISO+xsCEiIiIiIr3HwoaIiIiIiPQeCxsiIiIiItJ7LGxIazZt2gSJRAKJRIJTp06VelwQBNSrVw8SiQT9+/cv8zUyMjIglUohkUhw5cqVMvu888476uM8eZNKpVp9T8+ycOFCvPbaa6hduzakUimaNGmC6dOn4/79+8/1/Ly8PISGhsLd3R1WVlaoW7cu/Pz88Oeff5bqe/78efTv3x+Ojo6wsbFBy5YtsXLlSiiVSm2/LZw+fRpdunSBlZUVHB0dMXXqVGRlZWn0ycrKQnBwMHx8fFCzZk1IJBJs2rRJ61mIiF6GMY5NhYWFCAkJQaNGjWBhYYFGjRph/vz5KCoqeu7X2LBhA5o3b64e21atWlWqz+7du9GnTx84OzvDwsICr7zyCoYOHYqEhARtvh01jk30LGZiByDDI5VKsWXLFnTp0kWj/fjx47h9+zYsLCzKfe727dshkUjg6OiIqKgozJ8/v8x+FhYW+Pbbb0u1m5qavlz4Cjp//jxatWoFf39/2Nra4sqVK1i/fj3279+Pixcvwtra+qnPHzlyJPbs2YPx48ejTZs2uHv3LlavXo2OHTvi8uXLaNCggfo4nTp1QpMmTTBr1ixYWVnhwIEDmDZtGq5fv46wsDCtvaeLFy+iZ8+eaN68OVasWIHbt29j2bJluHbtGg4cOKDu9+DBA8ydOxf169eHl5cXjh07prUMRETaZkxj06hRo7B9+3aMGzcO7dq1w9mzZzFnzhzcunUL69ate+bz165di/fffx9DhgxBYGAgTp48ialTpyInJwezZs1S97t8+TJq1KiBadOmoVatWkhNTcXGjRvRvn17nDlzBl5eXlp7Txyb6LkIRFoSEREhABAGDx4s1KpVSygsLNR4fPz48ULbtm2FBg0aCP369SvzNd544w1h8ODBwowZMwQXF5cy+4wZM0awtrbWen5t2bFjhwBAiI6Ofmq/27dvCwCEjz/+WKP9t99+EwAIK1asULeNHz9eMDc3Fx4+fKjR94033hDs7Oy0F14QhL59+wpOTk6CXC5Xt61fv14AIBw6dEjdlpeXJ6SkpAiCIAixsbECACEiIkKrWYiIXpaxjU0xMTECAGHOnDka7R999JEgkUiES5cuPfX5OTk5gr29fanPYuTIkYK1tbWQnp7+1OenpqYKZmZmwsSJE1/sDZSDYxM9Dy5FI60LCAjAw4cPcfjwYXVbQUEBduzYgREjRpT7vFu3buHkyZPw9/eHv78/kpKScPr06cqIrFUNGzYEULx04WkyMzMBAHXq1NFod3JyAgBYWlqq2xQKBaRSKapXr16q7+P9AEClUuHrr7+Gh4cHpFIp6tSpg4kTJ+LRo0fPzK5QKHD48GGMGjUKdnZ26va3334bNjY22LZtm7rNwsICjo6Oz3xNIqKqwFjGppMnTwIA/P39Ndr9/f0hCAJ++OGHpz7/6NGjePjwISZPnqzRPmXKFGRnZ2P//v1Pfb6DgwOsrKxKjYEcm6gysLAhrWvYsCE6duyI6OhodduBAwcgl8tLfdE+Ljo6GtbW1ujfvz/at28PV1dXREVFldv/wYMHpW4KheKZ+R49elTmc5+85eTkPNf7FQQBDx48QGpqqnq63tTUFN26dXvq81xdXfHKK69g+fLl2Lt3L27fvo2YmBi8//77cHFx0fisunXrBoVCgYkTJ+LKlSu4efMm1qxZg127diEoKEjjdSdOnIiZM2eic+fOCAsLw9ixYxEVFYU+ffqgsLDwqZkuX76MoqIitGvXTqPd3NwcrVq1woULF57rMyEiqmqMZWzKz88HgFI/ellZWQEoXtr8NCXf80+OA23btoWJiUmZ40BGRgbu37+Py5cv47333oNCoUDPnj01+nBsokoh9pQRGY6S6f7Y2Fjhm2++EWxtbYWcnBxBEATBz89P6N69uyAIQrnT/S1atBBGjhypvv/pp5+WuWxgzJgxAoAyb3369HlmzgYNGpT7/MdvwcHBz/W+U1JSNJ73yiuvCD/88MNzPffcuXOCq6urxvPbtm2rnkYvUVRUJHzwwQdCtWrV1P1MTU2F8PBwjX4nT54UAAhRUVEa7QcPHiyz/Unbt28XAAgnTpwo9Zifn5/g6OhY5vM43U9EVZWxjU07d+4UAAjff/+9RvuaNWsEAIKnp+dTnz9lyhTB1NS0zMdq164t+Pv7l2pv1qyZOp+NjY3w+eefC0qlUv04xyaqLNw8gHRi2LBhmD59Ovbt2wcfHx/s27cPK1euLLf/H3/8gcuXLyM0NFTdFhAQgIULF+LQoUPo16+fRn+pVIq9e/eWep1atWo9M1tUVBRyc3Of2a9Ro0bP7AMANWvWxOHDh5GXl4cLFy5g165dpXZpKU+NGjXQqlUr+Pn54bXXXsM///yD0NBQ+Pn54fDhw+qddExNTeHq6oo+ffrAz88PUqkU0dHR+PDDD+Ho6IhBgwYBKD7BVSaToVevXnjw4IH6OG3btoWNjQ2OHj361CUXJZ9LWSfRSqXS5/rciIiqKmMYm9588000aNAAH3/8MaysrNC2bVucO3cOn332GczMzJ55jNzcXJibm5f5WHnjQEREBBQKBf79919EREQgNzcXSqUSJibFC4M4NlFlYWFDOlG7dm14e3tjy5YtyMnJgVKpxNChQ8vtHxkZCWtrazRq1Aj//PMPgOIvq4YNGyIqKqrU4GFqagpvb+8Xyta5c+cXel55zM3N1Vn69++Pnj17onPnznBwcCh361AAkMvleP311zFz5kx89NFH6vZ27dqhW7duiIiIwKRJkwAAixYtQlhYGK5duwYbGxsAxQN09+7dMWXKFPTv3x9mZma4du0a5HI5HBwcyjxmWlqa+tiPDwTm5uaoWbOmeulCyVKGx+Xl5ZVa2kBEpE+MYWySSqXYv38/hg0bhiFDhgAoLgiWLFmCBQsWqMeQ8lhaWqKgoKDMx8obBzp27Kj+3/7+/mjevDkAYNmyZQDAsYkqDQsb0pkRI0Zg/PjxSE1NRd++fUud+F5CEARER0cjOzsb7u7upR5PS0tDVlbWM7+Mn9f9+/ef69ovNjY2L3TMTp06wcnJCVFRUU8tbHbu3Il79+5hwIABGu1du3aFnZ0dfv/9d3Vh87///Q89evQolWfAgAEIDAzEjRs30LhxY6hUKjg4OJS7/rt27doAgGnTpmHz5s0axzx27Jh644KUlJRSz01JSYGzs/NzfAJERFWXMYxNHh4eSEhIQGJiIh49egR3d3dYWlpixowZ6Nq161Of6+TkBKVSibS0NI1CpKCgAA8fPnzmOFCjRg306NEDUVFR6sKGYxNVFhY2pDNvvfUWJk6ciLNnzz51F5aSawjMnTtX/StPiUePHmHChAn48ccfMWrUKK3kevXVV3Hz5s1n9gsODsaXX375QsfIy8uDXC5/ap979+4BQKmBTBAEKJVKjQup3bt3r8wBr+SEy5K+rq6uOHLkCDp37vzUX7A++eQTjc+zRo0aAABPT0+YmZkhLi4Ow4YNUz9eUFCAixcvarQREekjYxmbJBIJPDw81Pd//vlnqFSqZ84otWrVCgAQFxeHN998U90eFxcHlUqlfvxpcnNzNcZAjk1UWVjYkM7Y2NggPDwcN27cgK+vb7n9Sqb6Z86cWebVmZcuXYqoqCitDR7aWsecnZ0NiUSi3mmmxM6dO/Ho0SON3VsKCwtx/fp1yGQy9S9PTZs2BQBs3bpVY5Das2cPsrOz0bp1a3Vb06ZNcfjwYTx8+BD29vYAiguibdu2wdbWFq6urgCKl6f973//w7x587Bw4UKNXEVFRcjKykL16tXh7u5e5i+QMpkM3t7eiIyMxJw5c2BrawsA+P7775GVlQU/P7+nfiZERFWdoY9NZcnNzcWcOXPg5OSEgIAAdXtOTg5u3bqFWrVqqc8D6tGjB2rWrInw8HCNwiY8PBxWVlYay++enNUBgBs3buDXX3/VGAM5NlFlYWFDOjVmzJinPp6fn4+dO3eiV69eZQ4cQPFyq7CwMI0v0KKiIkRGRpbZ/6233oK1tXW5x9TWOuZr167B29sbw4cPh5ubG0xMTBAXF4fIyEg0bNgQ06ZNU/e9c+cOmjdvjjFjxmDTpk0AAF9fX3h4eGDu3Lm4efOmevOAb775Bk5OTnj33XfVz589ezZGjRqFDh06YMKECbC0tER0dDTOnz+P+fPno1q1agCKp+0nTpyI0NBQXLx4Eb1790a1atVw7do1bN++HWFhYU9dTw4ACxYsQKdOndC1a1dMmDABt2/fxvLly9G7d2/4+Pho9P3mm2+QkZGBu3fvAoB622oA+PDDDyGTyV76cyYi0jZDHpuA4kLC2dkZ7u7uUCgU2LhxI/7991/s379fXRQAQExMDLp3764xC2RpaYl58+ZhypQp8PPzQ58+fXDy5ElERkZiwYIFqFmzpvr5LVq0QM+ePdGqVSvUqFED165dw4YNG1BYWIhFixap+3Fsokoj8q5sZEAe31LzaR7fUrNkW8oNGzaU2//YsWMCACEsLEwQhKdvqQlASEpK0tp7epr79+8LEyZMENzc3ARra2vB3NxcaNKkiTB9+nTh/v37Gn2TkpIEAMKYMWM02tPT04UZM2YITZs2FSwsLIRatWoJ/v7+wr///lvqeAcPHhS6du0q1KpVSzA3NxdatGghrFmzpsxs69atE9q2bStYWloKtra2QosWLYRPPvlEuHv37nO9t5MnTwqdOnUSpFKpULt2bWHKlCmCQqEo1e9p25NW1r8DEdHTGNvYJAiCsHjxYsHNzU2QSqVCjRo1hAEDBggXLlwo1e/o0aPlbiG9bt06oVmzZoK5ubng6uoqfPXVV4JKpdLoExwcLLRr106oUaOGYGZmJjg7Owv+/v7CH3/8UWYujk2kaxJBEARdF09ERERERES6ZCJ2ACIiIiIiopfFwoaIiIiIiPQeCxsiIiIiItJ7LGyIiIiIiEjvsbAhIiIiIiK9x8KGiIiIiIj0XpW7QKdKpcLdu3dha2sLiUQidhwiIqMiCAIyMzPh7OwMExP+9lWCYxMRkTgqNC6Jexmd0pKTk596gSveeOONN950f0tOThZ7OHhux48fF/r37y84OTkJAITdu3drPB4cHCw0a9ZMsLKyEqpXry707NlTOHv2bIWOwbGJN954403c2/OMSxWesTlx4gSWLl2K8+fPIyUlBbt378agQYPUj3/55ZfYunUrkpOTYW5ujrZt22LBggXo0KHDc72+ra0tACA5ORl2dnYVjUdERC9BoVCgXr166u9ifZCdnQ0vLy+MGzcOgwcPLvV406ZN8c0336BRo0bIzc3FV199hd69e+Off/5B7dq1n+sYHJuIiMRRkXGpwoWNrgeQkil+Ozs7Dh5ERCLRp+VWffv2Rd++fct9fMSIERr3V6xYgQ0bNuCPP/5Az549n+sYHJuIiMT1PONShQubyhhAiIiIdKGgoADr1q2DTCaDl5eX2HGIiEiLdLp5wPMMIPn5+cjPz1ffVygUuoxERERGaN++ffD390dOTg6cnJxw+PBh1KpVq9z+HJuIiPSPTra82bdvH2xsbCCVSvHVV189dQAJDQ2FTCZT3+rVq6eLSEREZMS6d++Oixcv4vTp0/Dx8cGwYcOQlpZWbn+OTURE+kcnhU1FBpCgoCDI5XL1LTk5WReRiIjIiFlbW6Nx48Z47bXXsGHDBpiZmWHDhg3l9ufYRESkf3SyFK1kACkZRJo0aYINGzYgKCioVF8LCwtYWFjoIgYREVGZVCqVxlKzJ3FsIiLSP5Vygc5nDSBEREQvKisrC//884/6flJSEi5evIiaNWvC3t4eCxYswIABA+Dk5IQHDx5g9erVuHPnDvz8/ERMTURE2lbhwoYDCBERVSVxcXHo3r27+n5gYCAAYMyYMVizZg3++usvbN68GQ8ePIC9vT1effVVnDx5Eh4eHmJFJiIiHahwYcMBhIiIqpJu3bpBEIRyH9+1a1clpiEiIrFUuLDhAEJEVDalSkBMUjrSMvPgYCtFe5eaMDXRnwtdEhER6bNKOceGiMjQHUxIQcjeRKTI89RtTjIpgn3d4ePpJGIyIiIi46CT7Z6JiIzJwYQUTIqM1yhqACBVnodJkfE4mJAiUjIiIiLjwcKGiOglKFUCQvYmoqwFuiVtIXsToVSVv4SXiIiIXh4LGyKilxCTlF5qpuZxAoAUeR5iktIrLxQREZEe27lzJ27cuFHh57GwISJ6CWmZ5Rc1L9KPiIjIWOXn5+P999/H0KFDMWLECBQWFlbo+SxsiIhegoOtVKv9iIiIjFW1atWQlJQEiUSC7t27QyKp2M6i3BWNiOgltHepCSeZFKnyvDLPs5EAcJQVb/1MREREmgRBQFFREapVqwYTExN89913SEhIQM+ePSv8WpyxISJ6CaYmEgT7ugMoLmIeV3I/2Ned17MhIiJ6QkZGBoYNG4YpU6ao2+rUqfNCRQ3AwoaI6KX5eDohfFQbOMo0l5s5yqQIH9WG17EhIiJ6wtmzZ9GqVSvs2LEDERERuHr16ku/JpeiERFpgY+nE3q5OyImKR1pmXlwsC1efsaZGiIiMlZKlVBqXJRAwNKlS/H555+jqKgIDRs2xNatW9G0adOXPh4LGyIiLTE1kaCjq73YMYiIiER3MCEFIXsTNS6JYG+SC+HYKlw4cwIAMGzYMKxbtw4ymUwrx2RhQ0REREREWnMwIQWTIuM1NtURBBUur/8IhQ9uwUIqxTerVuHdd9+t8M5nT8NzbIiIiIiISCuUKgEhexNL7RQqkZigerexqFa7IZpN/AZjx2m3qAE4Y0NERERERFoSk5SuXn5WmJGKIvk9WDbwAgBYub4KS5c2kJuYIiYpXevLt1nYEBERERGRVqRlFhc12X+dwsODqyCRSOA0diXM7BwAABITU41+2sTChoiIiIiItEJWTcDDQ98g6+JBAIC5s1uZ/RxspWW2vwwWNkRERERE9NL+/PNPfDB8OLL+/BOABHYd/VC98whITP8rOSQovs5be5eaWj8+CxsiIiIiInop69evx7Rp05Cbm4satRxg3nMqLBu20thEoGSrgGDf/2vvvsOjKvM2jn8nhSQEMhAEkmiAoAiEIE1AyoouXRcLHWlSpam0iKgsIr1jwSCgIiBtl7KgUsRFEEECIihSpIQiJSBlQklCkjnvH7zMGghCYCYnM3N/rmuuyzlzJnNP1PPkd54W7ZJ93rQqmoiIiIiI3JMdO3aQnJxMw4YN2fvrL8x6qzNh1szDzcKsgcS1q0yjmHCXZFCPjYiIiIiIZJvdbsfH51o/ycSJE6lUqRKdO3fGx8eHRkWgfnQY8QnnOH0xhSL5rw0/c0VPzXUqbERERERE5I7Z7XYmTJjA2rVrWblyJb6+vgQGBtK1a9dM5/n6WJy+pPNfUWEjIiIiIiJ3JDExkQ4dOrBmzRoAli5dSvPmzU1OdY3m2IiIiIiIyG19/fXXVKhQgTVr1hAUFMTMmTNp1qyZ2bEcVNiIiIiIiMgtpaWl8frrr9OgQQMSExOJiYlh27ZtdOnSBYvFdXNmskuFjYiIiIiI3FK3bt0YO3YsAD169CA+Pp7o6GiTU91MhY2IiIiIiNzSgAEDCAsL49///jdxcXEEBQWZHSlLWjxAREREREQckpOT+e6772jQoAEA5cuXJyEhgcDAwNu801zqsREREREREQB+/fVXqlatytNPP82WLVscx3N7UQMqbEREREREvJ5hGMyYMYOqVavy66+/UqhQIZKTk82OlS0aiiYiIiIi4sVsNhvdu3dn0aJFADRs2JDPPvuMokWLmpwse9RjIyIiIiLipbZs2ULFihVZtGgRfn5+jBs3jq+++srtihq4i8Jmw4YNNGnShIiICCwWC8uWLXO8lpaWxqBBgyhfvjzBwcFERETQoUMHTpw44czMIiIiDmqXRETu3ubNmzl8+DAlSpRg48aNxMbG4uPjnn0f2U59+fJlKlSowNSpU2967cqVK2zfvp0hQ4awfft2lixZwr59+3jmmWecElZERORGapdERLLHMAzHP7/66quMHz+eHTt2UL16dRNT3TuL8edvlt03WywsXbqU55577pbnbN26lWrVqnHkyBGKFSt225+ZlJSE1WrFZrMREhJyt9FEROQuuPs12BXtErj/70VE5Lqvv/6ad955h6+++or8+fObHee2snP9dXk/k81mw2KxUKBAgSxfT01NJSkpKdNDRETEVW7XLoHaJhHxPGlpabz++us0aNCAjRs3MmbMGLMjOZ1LC5uUlBQGDRpEmzZtbllhjR49GqvV6nhERka6MpKIiHixO2mXQG2TiHiWhIQEHn/8ccaOHQtAjx49eOutt0xO5XwuK2zS0tJo2bIlhmEQFxd3y/MGDx6MzWZzPI4dO+aqSCIi4sXutF0CtU0i4jn+9a9/UalSJX744QesViv//ve/iYuLIygoyOxoTueSfWyuNx5Hjhzhv//971/eFQsICCAgIMAVMURERIDstUugtklEPMOHH35I7969AahRowbz5s2jRIkS5oZyIaf32FxvPPbv38/atWspVKiQsz9CRETkjqldEhFv1axZM8LDwxk8eDDr16/36KIG7qLH5tKlSxw4cMDxPCEhgR07dhAaGkp4eDjNmzdn+/btfPHFF2RkZHDq1CkAQkNDyZMnj/OSi4iIoHZJROQ6wzD47rvvePzxxwEoWrQoe/fu9ZrVHLO93PO3337Lk08+edPxjh078vbbbxMVFZXl+9atW8cTTzxx25+vJTVFRMzjjtdgV7dL4J6/FxHxLjabje7du7No0SLmz59P69atzY7kFNm5/ma7x+aJJ57gr2qhe9gWR0REJNvULomIt9uyZQutW7fm8OHD+Pn5cebMGbMjmcLl+9iIiIiIiIjz2e12xo0bR+3atTl8+DAlSpRg48aNvPzyy2ZHM4VLVkUTERERERHXSUxMpEOHDqxZswaAli1bMn36dKxWq8nJzKMeGxERERERN7N9+3bWrFlDUFAQM2bMYMGCBV5d1IB6bERERERE3E7jxo2ZPHky9evXp1y5cmbHyRXUYyMiIiIikssdPnyYp556iiNHjjiO9e3bV0XNn6iwERERERHJxf79739TsWJFVq5cSa9evcyOk2upsBERERERyYWSk5Pp0aMHLVq0wGazUaNGDaZOnWp2rFxLhY2IiIiISC7z66+/Uq1aNT766CMsFguDBw9m/fr1lChRwuxouZYWDxARERERyUW+//576tevT3JyMkWLFmXu3LnUq1fP7Fi5ngobEREREZFcpEqVKpQqVYrw8HA+++wzihYtanYkt6DCRkRERETEZD///DPlypXD19eXwMBA1q5dS6FChfDx0cyRO6XflIiIiIiISex2O+PGjaNKlSqMHDnScbxw4cIqarJJPTYiIiIiIiZITEykQ4cOrFmzBoB9+/ZhGAYWi8XkZO5JZaCIiIiISA77+uuvqVChAmvWrCEoKIiZM2cyd+5cFTX3QIWNiIiIiEgOSUtLY/DgwTRs2JDExERiYmLYtm0bXbp0UVFzj1TYiIiIiIjkkEOHDjFlyhQMw6BHjx7Ex8cTHR1tdiyPoDk2IiIiIiI5pHTp0sTFxZEvXz6aN29udhyPoh4bEREREREXSU5Opnfv3mzevNlx7MUXX1RR4wLqsRERERERcYFff/2V1q1bs2vXLlauXMnevXvJkyeP2bE8lnpsREREREScyDAMZs6cSdWqVdm1axdFixblo48+UlHjYuqxERERERFxEpvNRvfu3Vm0aBEADRo0YPbs2RQtWtTkZJ5PhY2IiIiIiBOcPHmSWrVqkZCQgJ+fHyNHjmTgwIH4+GiQVE5QYSMiIiIi4gRhYWHExMRgGAYLFiygevXqZkfyKipsRERERETuUmJiInnz5iV//vxYLBZmzZqFj48PBQoUMDua11G/mIiIiIjIXVi7di0VKlSgZ8+eGIYBQGhoqIoak6iwERERERHJhrS0NN544w0aNGhAYmIiO3bswGazmR3L66mwERERERG5Q4cPH6ZOnTqMHj0awzB46aWXiI+PVy9NLqA5NiIiIiIid2Dx4sV06dIFm82G1Wpl5syZNG/e3OxY8v9U2IiIiIiI3MalS5fo06cPNpuNxx57jPnz51OiRAmzY8mfqLAREREREbmNfPnyMWfOHNauXcvw4cPx9/c3O5LcQIWNiIiIiMgNDMPg448/Jn/+/LRq1QqAevXqUa9ePZOTya1ke/GADRs20KRJEyIiIrBYLCxbtizT60uWLKFBgwYUKlQIi8XCjh07nBRVRETkZmqXRMTZbDYbrVu3plu3bnTr1o1jx46ZHUnuQLYLm8uXL1OhQgWmTp16y9dr167N2LFj7zmciIjI7ahdEhFn2rJlC5UqVWLRokX4+fkxZMgQ7r//frNjyR3I9lC0xo0b07hx41u+3r59e+DaUngiIiKupnZJRJzBbrczceJE3njjDdLT0ylRogQLFiygevXqZkeTO6Q5NiIiIiLi1dLT02nSpAmrVq0CoGXLlkyfPh2r1WpyMskO0wub1NRUUlNTHc+TkpJMTCMiIqK2ScTb+Pn5Ua5cOdavX897771Hly5dsFgsZseSbMr2HBtnGz16NFar1fGIjIw0O5KIiHg5tU0ini8tLY0zZ844no8aNYqffvqJrl27qqhxU6YXNoMHD8ZmszkeWnVCRETMprZJxLMdPnyYOnXq8Oyzz5KWlgZAnjx5KF26tMnJ5F6YPhQtICCAgIAAs2OIiIg4qG0S8VyLFy+mS5cu2Gw2rFYre/bs4ZFHHjE7ljhBtgubS5cuceDAAcfzhIQEduzYQWhoKMWKFePcuXMcPXqUEydOALBv3z4AwsLCCAsLc1JsERGRa9QuicidSE5Opl+/fnz00UcAVK9enfnz5xMVFWVyMnEaI5vWrVtnADc9OnbsaBiGYXz66adZvj506NA7+vk2m80ADJvNlt1oIiJyj9zxGuzqdskw3PP3IiL/s2vXLiMmJsbx///rr79uXL161exYcgeyc/21GIZh5FQRdSeSkpKwWq3YbDZCQkLMjiMi4lV0Dc6afi8i7sswDGrXrs2mTZsoUqQIc+bMoUGDBmbHkjuUneuv6YsHiIiIiIi4isVi4ZNPPuG5555j586dKmo8mAobEREREfEo8fHxfPjhh47npUuXZunSpZpX5+FU2IiIiIiIR7Db7YwfP55atWrx8ssvs3HjRrMjSQ4yfblnEREREZF7dfr0aTp06MDq1asBaNGiBTExMSankpykHhsRERERcWvffPMNFSpUYPXq1QQGBjJ9+nQWLlxIgQIFzI4mOUiFjYiIiIi4reHDh1O/fn1OnTpFuXLl2LZtG926dcNisZgdTXKYChsRERERcVtFixbFMAy6d+9OfHw85cqVMzuSmERzbERERETErVy4cMExzKxbt26UK1eOWrVqmRtKTKceGxERERFxC8nJyfTs2ZOKFSty4cIF4No+NSpqBFTYiIiIiIgb+PXXX6lWrRrTpk3jyJEjrFy50uxIksuosBERERGRXMswDGbOnEnVqlXZtWsXRYoUYfXq1bRp08bsaJLLaI6NiIiIiORKNpuN7t27s2jRIgDq16/P7NmzCQsLMzmZ5EbqsRERERGRXGnw4MEsWrQIX19fxowZw6pVq1TUyC2px0ZEREREcqXhw4eza9cuxo4dS40aNcyOI7mcemxEREREJFdITExk0qRJGIYBQKFChdiwYYOKGrkj6rEREREREdOtXbuWdu3akZiYSMGCBenUqZPZkcTNqMdGREREREyTlpbGG2+8QYMGDUhMTKRcuXJUrVrV7FjihtRjIyIiIiKmOHz4MC+88AKbN28GoHv37kyePJm8efOanEzckQobEREREclxX3zxBe3bt+fChQuEhIQwc+ZMWrRoYXYscWMqbEREREQkxwUFBWGz2ahevTrz588nKirK7Eji5lTYiIiIiEiOSE5OJigoCIC6deuyatUqnnzySfz9/U1OJp5AiweIiIiIiEsZhsHHH39MVFQUBw4ccBxv0KCBihpxGhU2IiIiIuIyNpuNF154ga5du5KYmMiHH35odiTxUBqKJiIiIiIusXXrVlq3bs2hQ4fw8/Nj5MiRDBw40OxY4qFU2IiIiIiIU9ntdiZNmsTgwYNJT0+nRIkSzJ8/n8cee8zsaOLBNBRNRERERJzqk08+ITY2lvT0dFq0aMFPP/2kokZcToWNiIiIiDhVhw4dqFOnDh999BELFy6kQIECZkcSL6ChaCIiIiJyT9LT05k+fTrdunXD39+fPHnysG7dOiwWi9nRxIuox0ZERERE7tqRI0eoU6cOvXv3ZujQoY7jKmokp6mwEREREZG7smTJEipWrMimTZsICQmhYsWKZkcSL6bCRkRERESyJTk5mV69etGsWTMuXLhA9erV2bFjBy1btjQ7mngxFTYiIiIicsf27dtH9erViYuLA2DQoEF89913REVFmZxMvF22C5sNGzbQpEkTIiIisFgsLFu2LNPrhmHwz3/+k/DwcIKCgqhXrx779+93Vl4REZFM1C6J5LxDhw5RpEgRVq9ezZgxY/D39zc7kkj2C5vLly9ToUIFpk6dmuXr48aN47333mPatGls2bKF4OBgGjZsSEpKyj2HFRERuZHaJRHXS09Pd/xz6dKlWbJkCTt37qRBgwYmphLJzGIYhnHXb7ZYWLp0Kc899xxw7a5YREQEAwYMYODAgQDYbDaKFi3KrFmzaN269W1/ZlJSElarFZvNRkhIyN1GExGRu+Du12BXtEvg/r8XkXsRHx9P27ZtmTlzJnXq1DE7jniZ7Fx/nTrHJiEhgVOnTlGvXj3HMavVSvXq1dm8eXOW70lNTSUpKSnTQ0RExBnupl0CtU0iAHa7nfHjx1OrVi0OHDjAm2++yT3cDxdxOacWNqdOnQKgaNGimY4XLVrU8dqNRo8ejdVqdTwiIyOdGUlERLzY3bRLoLZJ5PTp0zz11FO89tprpKen06JFC7744gvtTSO5mumrog0ePBibzeZ4HDt2zOxIIiLi5dQ2iTdbu3YtFSpUYPXq1QQGBvLRRx+xcOFCChQoYHY0kb/k58wfFhYWBkBiYiLh4eGO44mJibfcsCkgIICAgABnxhAREQHurl0CtU3ivbZt20aDBg0wDINy5cqxYMECYmJizI4lckec2mMTFRVFWFgY33zzjeNYUlISW7ZsoUaNGs78KBERkdtSuySSPVWqVKFFixZ0796d+Ph4FTXiVrLdY3Pp0iUOHDjgeJ6QkMCOHTsIDQ2lWLFi9O3blxEjRlCqVCmioqIYMmQIERERjhVqREREnEntksi9WbFiBbVr16ZgwYJYLBY+//xz/PycOqhHJEdk+7/abdu28eSTTzqe9+/fH4COHTsya9YsXnvtNS5fvkz37t25cOECtWvXZtWqVQQGBjovtYiIyP9TuyRyd5KTkxkwYABxcXE0a9aMf/3rX1gsFhU14rbuaR8bV9BeASIi5tE1OGv6vYin2bNnD61ateKXX34BYNCgQYwcORJfX1+Tk4lklp3rr0pyERERES9hGAaffvopL7/8MleuXKFIkSLMmTOHBg0amB1N5J6psBERERHxAklJSfTo0YP58+cDUL9+fWbPnu1YPVDE3Zm+j42IiIiIuF56ejobN27E19eXMWPGsGrVKhU14lHUYyMiIiLioa5PpbZYLISGhrJw4UIALXcuHkk9NiIiIiIe6PTp0zz99NPMmjXLcaxGjRoqasRjqbARERER8TDffPMNFSpUYOXKlcTGxnL58mWzI4m4nAobEREREQ+Rnp7Om2++Sf369Tl16hTlypXj22+/JTg42OxoIi6nOTYiIiIiHuDIkSO88MILbNq0CYDu3bszefJk8ubNa3IykZyhwkZERETEzZ0/f54qVapw9uxZQkJCmDFjBi1btjQ7lkiO0lA0ERERETdXsGBBevbsSbVq1dixY4eKGvFKKmxERERE3NCePXs4ePCg4/nQoUPZuHEjUVFRJqYSMY8KGxERERE3YhgGH3/8MVWqVKFly5akpqYC4Ofnh7+/v8npRMyjwkZERETETdhsNl544QW6du1KcnIyoaGhWspZ5P+psBERERFxA1u3bqVy5cosWLAAX19fxowZw+rVqwkNDTU7mkiuoFXRRERERHIxu93OpEmTGDx4MOnp6RQvXpz58+dTo0YNs6OJ5CrqsRERERHJxTIyMvjXv/5Feno6LVq0YMeOHSpqRLKgHhsRERGRXMzf35/58+fzzTff0LVrVywWi9mRRHIlFTYiIiIiuUh6ejpDhw7FMAxGjRoFQMmSJSlZsqTJyURyNxU2IiIiIrnEkSNHeOGFF9i0aRMWi4V27doRHR1tdiwRt6A5NiIiIiK5wJIlS6hYsSKbNm0iJCSEBQsWqKgRyQYVNiIiIiImSk5OplevXjRr1owLFy5QrVo1duzYQcuWLc2OJuJWNBRNRERExCSGYVCvXj02bdoEwGuvvcaIESPw9/c3OZmI+1FhIyIiImISi8VCjx49OHDgALNnz6Zhw4ZmRxJxWxqKJiIiIpKDkpKS+Pnnnx3P27dvz759+1TUiNwjFTYiIiIiOWTr1q1UqlSJxo0b88cffziOFyhQwLxQIh5ChY2IiIiIi9ntdiZOnEjNmjU5dOgQ/v7+nDx50uxYIh5Fc2xEREREXOj06dO8+OKLrFy5EoDmzZszY8YM9dKIOJl6bERERERc5L///S8VK1Zk5cqVBAYGMm3aNBYtWqSiRsQF1GMjIiIi4iIzZ87k5MmTREdHs3DhQmJiYsyOJOKxVNiIiIiIuEhcXBzFixdnyJAh5M2b1+w4Ih5NQ9FEREREnGTJkiV06dIFwzAAsFqtjB49WkWNSA5wSWFz8eJF+vbtS/HixQkKCqJmzZps3brVFR8lIiJyW2qXxNWSk5Pp1asXzZo145NPPmHRokVmRxLxOi4pbLp27crXX3/NnDlz+OWXX2jQoAH16tXj+PHjrvg4ERGRv6R2SVxpz549VK9enbi4OAAGDRpE06ZNTU4l4n0sxvW+UidJTk4mf/78/Oc//+Hpp592HK9SpQqNGzdmxIgRf/n+pKQkrFYrNpuNkJAQZ0YTEZHb8MRr8L22S+CZvxe5d4Zh8Omnn/Lyyy9z5coVihQpwpw5c2jQoIHZ0UQ8Rnauv05fPCA9PZ2MjAwCAwMzHQ8KCmLjxo03nZ+amkpqaqrjeVJSkrMjiYiIF8tuuyRypwYOHMikSZMAqF+/PrNnzyYsLMzkVCLey+lD0fLnz0+NGjUYPnw4J06cICMjg7lz57J58+Ysd9gdPXo0VqvV8YiMjHR2JBER8WLZbZfg2k23pKSkTA+RGzVt2pSAgADGjBnDqlWrVNSImMwlc2zmzJmDYRjcf//9BAQE8N5779GmTRt8fG7+uMGDB2Oz2RyPY8eOuSKSiIh4sey0S6CbbpI1u93OL7/84nheq1YtDh8+zKBBg27535KI5ByX/F/44IMPsn79ei5dusSxY8eIj48nLS2NkiVL3nRuQEAAISEhmR4iIpJ9GXaDzQfP8p8dx9l88CwZdqdOoXRr2WmXQDfd5GanT5/mH//4B9WrV2fPnj2O4+qlEck9XLpBZ3BwMMHBwZw/f57Vq1czbtw4V36ciIjXWrXrJMNW7OakLcVxLNwayNAm0TSKCTcxWe5yp+1SQEAAAQEBTvnMDLtBfMI5Tl9MoUj+QKpFheLrY3HKz5ac8d///pd27dpx8uRJAgMD2bVrF2XLljU7lojcwCWFzerVqzEMg9KlS3PgwAFiY2MpU6YMnTp1csXHiYh4tVW7TtJz7nZu7J85ZUuh59ztxLWr7PXFjVntkgpO95aens7bb7/NqFGjMAyDsmXLsnDhQsqXL292NBHJgkuGotlsNnr37k2ZMmXo0KEDtWvXZvXq1fj7+7vi40REvFaG3WDYit03FTWA49iwFbu9fliaGe3S9YLzz0UN/K/gXLUr64ULJHc4cuQIderUYeTIkRiGQbdu3di2bZuKGpFczCU9Ni1btqRly5au+NEiIvIn8QnnbvrD+c8M4KQthfiEc9R4sFDOBctlcrpdul3BaeFawVk/OkzD0nKp2bNns2nTJkJCQpg+fTqtWrUyO5KI3IZL59iIiIhrnb5466Lmbs4T51DB6f4GDx7M6dOn6dev3y0XmRCR3EVrE4qIuLEi+QNvf1I2zhPnUMHpfvbs2UOHDh0cm4b7+fnx/vvvq6gRcSMqbERE3Fi1qFDCrYHcajCThWuT1atFheZkLK+ngtN9GIbBp59+yqOPPsqcOXN45513zI4kIndJhY2IiBvz9bEwtEk0wE3FzfXnQ5tEax5HDlPB6R6SkpJo27YtnTt35sqVK9StW5c+ffqYHUtE7pIKGxERN9coJpy4dpUJs2a++x9mDdRSzyZRwZn7bd26lcqVKzN//nx8fX0ZNWoUa9asITxc/7+IuCstHiAi4gEaxYRTPzpMG0HmItcLzhv3sQnTPjamW7BgAR06dCAtLY3ixYszf/58atSoYXYsEblHKmxERDyEr49FK2zlMio4c6fq1asTFBTEM888w8yZMylQoIDZkUTECVTYiIiYKDk5mdmzZ/P7778zfPhws+OIC6jgzB0OHTrkWOEsKiqK7du3U7JkSSwWFZkinkJzbERETPDHH3/wzjvvULx4cXr06MGYMWP4/fffzY4l4nHS09N56623ePjhh1mzZo3j+IMPPqiiRsTDqMdGRCQHHTx4kEmTJvHpp5+SnJwMQPHixenfvz8FCxY0OZ2IZzl69CgvvPAC33//PQDr1q2jQYMGJqcSEVdRYSMikkMWL15My5YtsdvtAFSuXJnY2FiaN2+On58uxyLOtHTpUjp37syFCxcICQlhxowZtGzZ0uxYIuJCaklFRFzEbrdz5swZihYtCsCTTz5J3rx5+dvf/sbAgQN58sknNRTGC2TYDS0ekINSUlIYMGAAH374IQDVqlVjwYIFREVFmZxMRFxNhY2IiJOlpqYyd+5cJk6cSMGCBR3DYEJDQzl48CBFihQxOaHklFW7Tt603HO4lnt2qVWrVjmKmtjYWEaMGEGePHlMTiUiOUGFjYiIk5w/f55p06bx3nvvcerUKQBCQkI4duwYkZGRACpqvMiqXSfpOXc7xg3HT9lS6Dl3uzZPdZHnnnuO/v37U79+fRo1amR2HBHJQVoVTUTkHh09epS+ffsSGRnJG2+8walTp7j//vsZP348R48edRQ14j0y7AbDVuy+qagBHMeGrdhNhj2rMyQ7kpKSePnllzlz5ozj2MSJE1XUiHgh9diIiNyjLVu28O677wJQvnx5YmNjadWqlYa/eLH4hHOZhp/dyABO2lKITzinPW7uwbZt22jdujUHDx7k2LFjLFu2zOxIImIiFTYiItlgGAZr1qzh4sWLNG/eHIDnn3+e9u3b07ZtWxo0aKAFAYTTF29d1NzNeZKZ3W5nypQpvP7666SlpVG8eHEGDRpkdiwRMZkKGxGRO3D16lUWLFjAhAkT+OWXX4iIiOCZZ54hT548+Pn5MXv2bLMjSi5SJH+gU8+T/zl9+jQvvvgiK1euBKBZs2bMnDmTAgUKmBtMREynwkZE5C/YbDZmzJjBlClTOH78OADBwcG0bNmS5ORkDTeTLFWLCiXcGsgpW0qW82wsQJj12tLPcud27txJ48aNOXnyJIGBgUyZMoXu3burl1REABU2IiK3tGDBAl566SWSkpIACAsL49VXX+Wll16iYMGCJqeT3MzXx8LQJtH0nLsdC2Qqbq7/CT60SbT2s8mmEiVKEBQURNmyZVm4cCHly5c3O5KI5CIqbERE/iQjIwNfX18ASpcuTVJSEmXLlmXgwIG0bduWgIAAkxOKu2gUE05cu8o37WMTpn1ssiUxMZEiRYpgsViwWq2sWrWK+++/n7x585odTURyGRU2IuL1DMPgm2++YcKECRQrVozp06cDUKlSJb7//nsee+wxfHy0Or5kX6OYcOpHhxGfcI7TF1Mokv/a8DP11NyZpUuX0qVLF0aMGEGvXr0AKFWqlMmpRCS3UkstIl4rLS2NefPmUaVKFerXr8/q1av5/PPPHUPPAGrWrKmiRu6Jr4+FGg8W4tmK91PjwUIqau5ASkoKffr0oWnTppw/f54FCxZgt9vNjiUiuZxaaxHxOpcuXWLKlCk89NBDtG3blp9++om8efPSp08ffvnlF0JCQsyOKOK19u7dS/Xq1Zk6dSoAsbGxrF27VjcYROS2NBRNRDxGht24oyE/kydP5p///CcARYoU4eWXX6Znz54UKqSNEkXMYhgGs2bNok+fPly5coXChQszZ84cGjZsaHY0EXETKmxExCOs2nXypkna4f8/Sbu47wVSUlKoVKkSAD169GDx4sX06tWL9u3bExQUZFZsEfl/v/32G926dSMjI4O6desyZ84cwsO1wIKI3DkVNiLi9lbtOknPudszLalrGAaHf9lK048Hk3xwK3Xq1OHbb78FoHDhwuzYscOMqCJyC6VLl2bkyJHY7XYGDRqkoWcikm0qbETErWXYDYat2O0oagx7Bld+20xS/GKuntx/7aDFQsGCoaSkpBAYqJ3eRXIDu93Ou+++S8OGDYmOjgZg0KBBJqcSEXemwkZE3Fp8wjnH8LPLezdy4dtPSbclAmDxy0NwTF1Cqj7Ha4OaqagRySXOnDlDx44dWblyJTExMWzbtk17RInIPVNhIyJu7fTF/82pMTLSSLcl4hMUQv5KT5O/8tP4Bhe46TwRMc9///tf2rVrx8mTJwkICKB3797kyZPH7Fgi4gFU2IiIW/rtt9+YNGkS+SMeBK4NYwku8zeMtFSCyz2Bj3/m3pki+dVbI2Km9PR0hg0bxsiRIzEMg7Jly7Jw4ULKly9vdjQR8RBOn5mXkZHBkCFDiIqKIigoiAcffJDhw4djGMbt3ywichubNm3i+eefp0yZMnz00Ucs+vgDwvL5YwEsvn7kr9goU1Fj4drqaNWiQk3LLOLtzp49y5NPPsmIESMwDIOuXbuydetWFTUi4lROL2zGjh1LXFwcH3zwAXv27GHs2LGMGzeO999/39kfJSJewm63s2zZMmrVqkWtWrVYtmwZhmHQpEkT5syZw9BnY4BrRcyfXX8+tEm0dnv3crrpZi6r1YrFYiF//vzMnz+fGTNmEBwcbHYsEfEwTh+KtmnTJp599lmefvppAEqUKMH8+fOJj4939keJiJfo27ev4+ZInjx5aN++PQMGDKBs2bKOc+LaWW7axybs//exaRSjvTC83fWbbp999hnlypVj27ZtdOrUCavVyiuvvGJ2PI+UkpKCxWIhICAAPz8/5s2bx9WrVylZsqTZ0UTEQzm9sKlZsybTp0/nt99+4+GHH2bnzp1s3LiRSZMmOfujRMRDnT17lvT0dIoWLQpA27ZtmTNnDj179uTll1/OctO+RjHh1I8OIz7hHKcvplAk/7XhZ+qpEdBNt5y2d+9eWrVqxRNPPMG7774LwAMPPGByKhHxdE4vbF5//XWSkpIoU6YMvr6+ZGRkMHLkSNq2bZvl+ampqaSmpjqeJyUlOTuSiLiJQ4cOMWnSJD755BM6derE1KlTAahevTrHjx8nb968f/l+Xx8LNR4slBNRxc1k96abM9umDLvhNQW3YRjMmjWLPn36cOXKFU6dOsU///lPChXS/5ci4npOL2wWLVrE559/zrx58yhXrhw7duygb9++RERE0LFjx5vOHz16NMOGDXN2DBFxI1u3bmX8+PEsXrwYu90OwM6dO7Hb7Y7dx29X1Ij8lezedHNW27Rq18mbhkiGe+gQyaSkJHr27Mm8efMAqFu3LnPmzFFRIyI5xmI4eeZkZGQkr7/+Or1793YcGzFiBHPnzmXv3r03nZ/VXbHIyEhsNhshISHOjCYiuczXX3/NiBEj2LBhg+NYo0aNGDhwIH//+9+xWDzzrnZulpSUhNVq9bhr8IIFC4iNjWX8+PGZbrpNmjQpy5tuzmibVu06Sc+527mxkb3+X3Vcu8oeU9xs27aN1q1bc/DgQXx9fRk+fDiDBg1y3JgQEblb2WmXnN5jc+XKlZsuZL6+vo67sDcKCAjQbsMiXmrdunVs2LABPz8/XnjhBQYOHKjlX8UlYmNjef3112ndujUA5cuX58iRI4wePTrLwuZe26YMu8GwFbtvKmoADK4VN8NW7KZ+dJjbD0u7cuUKTz31FGfOnKF48eLMmzePmjVrmh1LRLyQ0wubJk2aMHLkSIoVK0a5cuX46aefmDRpEp07d3b2R4lILvNXcwnOnz/PtGnTqFmzJnXq1AHg5ZdfJj09nVdeeUUTi8WlsnvT7V7FJ5zLNPzsRgZw0pZCfMI5t58XljdvXqZOncrChQuZMWMGBQsWNDuSiHgppxc277//PkOGDKFXr16cPn2aiIgIXnrpJf75z386+6NEJBe51VyCHlVC2LFyHjNmzODy5cvUr1/fUdiEh4czbtw4syKLF8npm26nL966qLmb83KbdevWYbfbqVu3LgAtWrSgefPmGj4qIqZyemGTP39+pkyZwpQpU5z9o0Ukl8pqLsHVxIP8snwJL775HRjX7oqXL1+e9u3bYxiG/gCSHJXTN92K5A906nm5RXp6OsOGDWPkyJHcd9997Ny507H8uv6fFhGzOb2wERHvktVcgrOrp3Jpx0rH85AHKzHvvZE81biR/vgRU+T0TbdqUaGEWwM5ZUvJcp6NhWsbyFaLCs2RPM5w9OhRXnjhBb7//nsAnnnmGY9aYEJE3J+WKxGRexKfcI4T5y5hpKc5jgWEPwwWH/KWrUNYxykUbD6c0NLVVNSI1/D1sTC0STTwv1XQrrv+fGiTaLdZOGDp0qVUrFiR77//nvz58zN//nxmzpxJcHCw2dFERBxU2IjIXUtKSmL61Hc5/lFXLv28xnE8OPoJ7n9pBoWfiSUg7CHAfecSiNytRjHhxLWrTNGQzMPNwqyBbrPUc0ZGBn369KFp06acP3+eqlWrsmPHDsfqciIiuYkKGxHJtuPHj/Paa68RGRnJrMnDybj4B5d3r3e8bvHzx89aNNN73G0ugYjzZB6M5uTt41zK19eXS5cuAdeWzN64cSMlS5Y0OZWISNY0x0ZE7tgvv/zCxIkTmTdvHmlp14aelS1bltSyT5ERVTvL97jjXAIRZ7jVBp2JSan0nLs91/baGIZBamoqgYHXbkZ88MEHtG/f3rECmohIbqUeGxG5Y2+99RafffYZaWlp1KlThxUrVrBr1y6mDhuAxc/fI+YSiDjD7TbohGsbdGbYc1fvTVJSEu3bt6dp06aOPX7y5cunokZE3IIKGxHJUnp6OvPnz+fo0aOOY6+99hotWrRgy5YtfPvtt/zjH//Ax8fHMZcgzOq+cwlEnCk7G3TmFtu2baNy5cp8/vnnrFmzhm3btpkdSUQkWzQUTUQyuXTpEh9//DGTJ0/myJEjvPrqq44lcmvVqkWtWrWyfF+jmHDqR4cRn3CO0xdTKJL/2vAz9dSIN3KnDToNw2DKlCkMGjSItLQ0ihUrxrx586hWrZrZ0UREskWFjYgAcOrUKd5//33i4uI4f/48AIULF+aBBx6445/h62OhxoOFXBVRxG24ywadZ86coVOnTnz55ZcANG3alJkzZ1KwYEFTc4mI3A0VNiJC//79mTp1KlevXgWgVKlSDBgwgA4dOhAUFGRyOhH34y4bdDZv3pwNGzYQEBDA5MmT6dGjh/abEhG3pTk2Il7IMIxMS876+Phw9epVatasydKlS9mzZw8vvfSSihqRu+QuG3ROmDCBChUqEB8fT8+ePVXUiIhbU2Ej4kEy7AabD57lPzuOs/ng2ZtWXMrIyODf//43jz32GBs2bHAc79+/P99//z3ff/89zz33HL6+vjkdXcTj5MZFNY4ePcrSpUsdz6tWrcr27dt55JFHcjyLiIizaSiaiIdYteskw1bszrQSU7g1kKFNonm8pJVPP/2USZMmcejQIQAmT55MnTp1AIiIiCAiIsKU3CKeLDctqrF06VK6dOnC5cuX2bJlCxUrVgSu9diKiHgCFTYiHuBWGwEeP5lI65c+xti9iqQL1xYECA0NpXfv3vTp0yfng4p4IbMX1UhJSWHgwIFMnToVuNZLExISYloeERFXUWEj4ub+aiPAUwvfIu10AgAlS5akf//+vPjiiwQHB+dsSBExxd69e2nVqhU///wzALGxsYwYMYI8efKYnExExPlU2Ii4uT9vBJh6fA95ij6Ixe/aHy35Kz3FpZ/XEFKtGZ+N60fth4uYGVVEctBnn31Gr169uHLlCoULF2b27Nk0atTI7FgiIi6jwkbEzZ2yXeHKb5tJil9C6vE9hDbsQ/6K1/54yVehIfkqNMJisXD2SprJSUUkJ504cYIrV65Qt25d5syZQ3h4zi9WICKSk1TYiLip5ORk5syZw8gx4ziTcPDaQV8/Mi6dc5xjsfxvUrDZGwGKiOulp6fj53etaR80aBCRkZG0adNGKx2KiFdQYSPiZgzDYOTIkbz33nucOXMGAN/AfOSr2Jh8VZrgly/zhn+5ZSNAEXEdu93OlClT+Pzzz9m4cSNBQUH4+PjQrl07s6OJiOQYrfEo4mYsFgvff/89Z86coVixYkyePJlF326nYJ2O+GdR1EDu2AhQRFzjzJkzNGnShAEDBrB9+3Zmz55tdiQREVOosBHJ5bZu3UqbNm04fvy449iwYcOYN28eBw4coG/fvjStXirXbQQoIq63bt06KlSowFdffUVAQAAffvgh3bt3NzuWiIgpNBRNJBey2+189dVXTJgwgfXr1wNQrFgxxo4dC0C1atWoVq1apvfkpo0ARcS10tPTeeeddxgxYgSGYVC2bFkWLFjAI488YnY0ERHTqLARyUVSU1P5/PPPmTBhAnv27AHAz8+PF1544Y7Gypu9EaCI5IzXXnuNyZMnA9ClSxfeffdd7U8lIl5PhY1ILmAYBhkZGcTExHDgwAEA8ufPz0svvcSrr77KAw88YHJCEclN+vfvz7Jlyxg1ahStW7c2O46ISK6gOTYiJjp58iRwbUEAPz8/GjduTEREBOPGjePYsWOMHz9eRY2IkJKSwuLFix3PH3jgAfbt26eiRkTkT1TYiJhgx44dtG3blsjISDZt2uQ4Pnz4cBISEoiNjcVqtZqYUERyi3379vHYY4/RvHlzli9f7jju7+9vYioRkdxHhY2IE2XYDTYfPMt/dhxn88GzZNgNx2uGYbBmzRrq169PpUqVmDdvHhkZGaxevdpxjtVqJU+ePGZEF5FcxjAMZs2aReXKldm5cyeFCxcmMFAb7YqI3Irm2Ig4yapdJxm2YjcnbSmOY+HWQN5q/DDnd61n/Pjx/PzzzwD4+vrSsmVLBg4cSOXKlc2KLCK51MWLF+nZsyeff/45AH//+9+ZO3cu4eFaul1E5FZU2Ig4wapdJ+k5dzvGDcdP2VLoPe8nUua9QeLxYwQHB9O1a1f69u1LiRIlzIgqIrncjz/+SOvWrTlw4AC+vr688847DBo0CF9fX7OjiYjkaipsRO5Rht1g2IrdjqIm/eIfXNq5BmuNFuDrj8XHl3w12tCnYgi9e/WiYMGCpuYVkdzt0KFDHDhwgGLFijFv3jxq1apldiQREbegwkbkHsUnnOOkLYWrZw6TFL+Uy7vXgz0dP2tR8pWviwGkP/g4dVs/pqJGxAtl2I3bbpxrGAYWy7VjLVq0YPr06TRr1ozQ0FAzIouIuCWnFzYlSpTgyJEjNx3v1asXU6dOdfbHiZjKMAzWfvMNiYvGkZLwo+N4QGQMftbCmc49fTHlxreLiIe71dy7oU2iaRRzbb7MunXr6N+/P1999ZVjDk23bt1MySsi4s6cXths3bqVjIwMx/Ndu3ZRv359WrRo4eyPEjHVpUuXeOKJJ/jxx/8vaCw+5H24BiHVmhIQUfqm84vk12pGImYx46bbX8296zl3Ox+0foQtS2YwYsQIDMNg6NChTJ8+3SVZRES8gdMLm8KFM9+lHjNmDA8++CB16tRx9keJ5Lj09HT8/K79b5MvXz6sVitBQUGEPFIfvwpN8Ct484pFFiDMem34iYiYI6dvut049+7PDCAj6TRtnnuKi0d2AdClSxcmT57skiwiIt7CpfvYXL16lblz59K5c2fH2GERd3Tq1CnefPNNihUrRmJiouN4XFwcR48eZdbMafgXDOfG/8qvPx/aJPqmMfUiknMKFy5MWFiY4/HFF1+49Kbb9bl3Wbny22ZOfPoKF4/sIm9wPubPn8/MmTMJDg52SRYREW/h0sJm2bJlXLhwgRdffPGW56SmppKUlJTpIZJb7N27l65du1K8eHFGjRrFyZMn+eyzzxyvP/zww9x33300igknrl1lwqyZh5uFWQOJa1fZMZZeRMyXEzfdbjWn7vLubzmzdCT2lEvkCS/FxPmraN26tUsyiIh4G5euivbxxx/TuHFjIiIibnnO6NGjGTZsmCtjiGSLYRhs3LiR8ePHs2LFCsfxGjVqEBsbyzPPPJPl+xrFhFM/Ouy2qx+JiLnu9KZbamqq43l2b7rdak5d0EOP4V8okqAHq1Lg8fZUiC6TrZ8rIiK3ZjEMI6shwPfsyJEjlCxZkiVLlvDss8/e8rysGo/IyEhsNhshISGuiCbyl86dO8f9999PSkoKFouFZ599ltjYWGrWrGl2NBGXS0pKwmq1evQ1uGHDhuTJkyfTjYsbvf3221nedLvT30uG3aD22P9y8kIyyQnbCYyqhMVybZCEPS0FX/9AwqyBbBz0d938EBH5C9lpl1w2FO3TTz+lSJEiPP300395XkBAACEhIZkeIjnpypUrLF682PE8NDSUHj160L17d/bs2cPSpUtV1Ih4iCNHjrB27Vq6du36l+cNHjwYm83meBw7dixbn+PrYyH278X444uJnP7XUC5uXeZ4zcc/EAPNvRMRcTaXDEWz2+18+umndOzY0bGClEhuc+bMGT744AOmTp3K2bNniY+Pp2rVqgBanUjEQ2XnpltAQMBdf86PP/7Iyy1bcPloAlh8MAz7Xf8sERG5My6pOtauXcvRo0fp3LmzK368yD3Zv38/kyZNYtasWaSkXJvgGxUVxdmzZ01OJiKulBM33QzDYMqUKQwaNIi0tDR8QwpzX5PXCHygbKbzLMCwFbupHx2mXhsRESdxyZW9QYMGuGjqjshfyrAbt5y8f+bMGXr06MHSpUsd/31WrVqV2NhYnn/+efUuing4V990O3PmDJ06deLLL78EIO/DNQlt/Aq+gfluOtcATtpSiE84R40HC7kkj4iIt9FfcuIxVu06ybAVuzPtHRFuDWRok2gaxYRToEABtm7dimEYPP3008TGxvL4449rjyURL+Hqm25Hjx5lzZo1BAQE8GL/oazMKH/b68utloUWEZHsU2EjHmHVrpP0nLvdscu3kX6VS7v+S+K+7+lxbijTOlajUUw4M2fO5IEHHiA6OtrUvCLieapUqcLHH39MhQoVuBx8P6tm/HDb99xqWWgREck+FTbi9jLsBsNW7MYAMpKTuPjTV1z88QvsVy4AcHnf9wxbkY/60WE0aNDA1Kwi4jmOHTtG586dGTduHJUqVQKgffv2wLXrUrg1kFO2FLLqI7JwbQPfalGhORdYRMTDuWy5Z5GcEp9wjqNHDnPu62kcj+uE7bu52K9cwDekMAX/3o2gB6s6xrKLiDjDf/7zHypWrMjatWt56aWXbhri5utjYWiTaz3DNw5Gu/5cyz2LiDiXemzE7e3cvZcT07vD/y+n6l+kJNbqTclbujYW3//9J66x7CJyr1JSUnjzzTf54IMPAHj00UeZP39+lnNpGsWEE9eu8k1z/8L+NPdPREScR4WNuB273c7evXsd82QqRJch4IFoLH55CKnWlMDiFbL8I0Nj2UXkXtWtW5ddu3YBMGDAAEaNGkWePHlueX6jmHDqR4fdcrVGERFxHhU24jZSU1OZN28eEyZMICEhgaNHj3LfffdRLSqUCl3HcvqKobHsIuJSu3bt4r777mP27Nk0btz4jt7j62PRks4iIjlAc2wk17tw4QJjxowhKiqKzp07s3v3bvz8/Pjpp5+Aa380DGt6beKuxrKLiCs9/vjj7Ny5846LGhERyTkqbCTXOn36NP379ycyMpLBgwdz8uRJIiIiGDt2LMeOHaN+/fqOc6+PZQ+zZh5uFmYNJK5dZY1lFxGnWLZsGREREdl6T4bdYPPBs/xnx3E2HzxLhl0bWIuIuIKGokmulZGRwdSpU7l69SoxMTEMHDiQNm3a3HI8u8ayi4ir+fr6Zuv8220cLCIizqPCRnIFwzBYu3Yt69evZ8SIEQCEh4czZswYypQpQ6NGjW67gzdoLLuI5B43bhx83SlbCj3nbldvsoiIk6mwEVOlpaWxcOFCJkyYwM6dOwFo0aIFFSpUAKBfv35mxhMRuSt/3jj4RgbX5v8NW7Gb+tFh6lUWEXESFTZiiosXLzJjxgymTJnCsWPHAAgODqZLly7cd999JqcTEbk38QnnMg0/u5EBjo2D1cssIuIcKmzEqTLsxm3nuPz444/UrVsXm80GQNGiRXnllVfo0aMHoaFakllE3N+dbgisjYNFRJxHhY04zV9Nkq1dIj/58uUDICYmhrx58xIeHs7AgQNp27YtgYHaPFNEPMedbgisjYNFRJxHhY04RVaTZA3DIOHneJrOHETB9HMcPbQfX19fAgIC2LhxIyVKlMDHRyuOi4jnqRYVSrg1kFO2FG0cLCKSQ1TYyD27cZKsYc/gyt6NJG1dytVTBwBItljYtPkH/la7FgAlS5Y0Ka2IiOv5+lgY2iSannO3Y4FMxY02DhYRcQ0VNnLPrk+StV9N5tLPX5O07T9k2BIBsPgFEFy+HiFVn8MvvIzJSUVEcs71jYNvHKIbpn1sRERcQoWN3LPrk1+vJh7k/DfTAfAJCiF/lSbkr/QUvnmtmc4TEfEW2jhYRCTnqLCRu7Z3715+/vlnIqvUBSDggXLkja5D4APlCI6pi49/QKbzNUlWRLyRNg4WEckZKmwkWwzD4Pvvv2f8+PEsX76c4OBgDh856pgkW7hJ7E3v0SRZEREREXE1LUkldyQjI4PFixdTo0YN/va3v7F8+XIsFgv16tXj8qWLDG0SDfxvUux1miQrIiIiIjlBPTZyW5s2baJjx44cOHBthbOAgAA6dOjAgAEDKF26NADFQZNkRURERMQ0KmwkS4ZhYLFc62GJjIzk8OHDhIaG0qtXL/r06UPRokVveo8myYqIiIiIWVTYSCYHDhxg4sSJnD17lkWLFgHXCpsvv/ySWrVqERwc/Jfv1yRZERERETGDChsB4IcffmD8+PEsXboUw7i2ldz+/fspVaoUAA0aNDAznoiIiIjIX9LiAV7MbrezfPly/va3v1GjRg2WLFmCYRg89dRTrFu3joceesjsiCIiIiIid0Q9Nl5s3rx5tG/fHgB/f3/atWvHgAEDKFeunMnJRERERESyRz02HibDbrD54Fn+s+M4mw+eJcNuOF47d+4cP/30k+N5s2bNKFWqFIMGDeLw4cN88sknKmpERERExC2px8aDrNp18qbllsOtgbxUKR/bv/qcjz/+mMjISHbv3o2Pjw9BQUHs3bsXHx/VtyIiIiLi3lTYeIhVu07Sc+52jD8dSz25n5//s4ROb34Phh2AwMBATp06RUREBICKGhERERHxCCpsPECG3WDYit2Ooib1xD7Or59F6tFfHOdYH6rCgg9G0bBBfcf+NCIiIiIinsIlt+uPHz9Ou3btKFSoEEFBQZQvX55t27a54qMEiE84l2n4mT0t5VpR4+NLcLknCe/0HgWaDcP6UBUVNSIiIiLikZxe2Jw/f55atWrh7+/PypUr2b17NxMnTqRgwYLO/igBbDYb096fhG3LYsexwGKPUOCJTtz/0kzu+8cA8hQpCcDpiym3+jEiIh5PN91ERDyb04eijR07lsjISD799FPHsaioKGd/jNc7duwYU6ZMYcaMGVy8eBFLnrzkr9gYn4C8WCwWrNWb3fSeIvkDTUgqImK+6zfdnnzySVauXEnhwoXZv3+/brqJiHgQpxc2y5cvp2HDhrRo0YL169dz//3306tXL7p165bl+ampqaSmpjqeJyUlOTuSR9m5cycTJkxgwYIFpKenA1CuXDmSyzxFhp9/lu+xAGHWQKpFheZgUhGR3EM33UREPJ/Th6IdOnSIuLg4SpUqxerVq+nZsyevvPIKn332WZbnjx49GqvV6nhERkY6O5LH+OCDD6hYsSJz584lPT2dJ598kq+++opffvmFqW/3w+Lrz40zaK4/H9okGl8fza8REe+0fPlyHn30UVq0aEGRIkWoVKkSM2bMuOX5qampJCUlZXqIiEjuZjEMw7j9aXcuT548PProo2zatMlx7JVXXmHr1q1s3rz5pvOz6rGJjIzEZrMREhLizGhuJy0tjQsXLlC4cGEAEhISKFOmDM8//zwDBw7k0UcfzXT+rfaxGdokmkYx4TmaXUTcU1JSElar1eOuwYGB14bi9u/fnxYtWrB161ZeffVVpk2bRseOHW86/+2332bYsGE3Hfe034uISG6XnXbJ6YVN8eLFqV+/PjNnznQci4uLY8SIERw/fvy27/fURjU7Ll68yIwZM5gyZQqPPvooS5Yscbz2xx9/cN99993yvRl2g/iEc5y+mEKR/NeGn6mnRkTulKdeg3XTTUTEPWWnXXL6HJtatWqxb9++TMd+++03ihcv7uyP8jgnTpzgvffeY9q0adhsNgDS09O5ePEi+fPnB/jLogbA18dCjQcLuTyriIg7CQ8PJzo6OtOxsmXLsnjx4izPDwgIICAgICeiiYiIkzh9jk2/fv344YcfGDVqFAcOHGDevHlMnz6d3r17O/ujPMaePXvo1KkTJUqUYOzYsdhsNkqXLs2MGTM4dOiQo6gREZG7o5tuIiKez+k9NlWrVmXp0qUMHjyYd955h6ioKKZMmULbtm2d/VEe4+uvv2bWrFkA1K5dm9jYWP7xj3/g4+OS/VNFRLxOv379qFmzJqNGjaJly5bEx8czffp0pk+fbnY0ERFxEqfPsblXnjq++7r09HQWL15MSEgIjRs3BuDy5cv07NmTXr168dhjj5mcUES8mSdfg7/44gsGDx7M/v37iYqKon///rfciuBGnvx7ERHJzUxdPOBeuXvjcavJ+5cvX+aTTz5h8uTJJCQkUL58eXbu3InFoon9IpJ7uPs12FXu5feiRV1ERO6eqYsHeLOsllsu5JPMw39sZPW/Z3P+/Hng2gIAzZo14+rVq5qcKiLiwbQMv4hIzlFh4ySrdp2k59zt/Ln7K2nbco58+ynbM9IAeOihhxgwYAAdOnQgb9685gQVEZEckVW7AHDKlkLPuduJa1dZxY2IiBOpsHGCDLvBsBW7sRsG2DOw+F77tfqH3g8ZaQRElKb4E635ZdZb5PHXr1xExNNdbxeyGuttABZg2Ird1I8O07A0EREn0V/ZTrD5wBkOxH9DUvwSgopXpMDj7QEIjKpMWPuJ5Al/mFSLhR+P2rTHjIiIF4hPOJdp+NmNDOCkLYX4hHNqF0REnESFzT1ITk5m1qxZDB89jj+OHQYgI+kM1tovYPHxxWKxEBBR2nH+6Yu3buRERMRz3On1Xu2CiIjzqLC5C3/88QdTp07lgw8+4I8//gDAJzAf+So9TUiVf2Dx8c3yfUXyB+ZkTBERMcmdXu/VLoiIOI8Km7swdOhQPvzwQwBKlChB3379+PxcSc6kWLIcT20BwqzXlvgUERHPVy0qlHBrIKdsKWoXRERyiLa2vwNbtmxh7969jud9+/alWrVqLFiwgP379/PqK6/wTvMqwLXG6s+uPx/aJFoTREVEvISvj4WhTaL/8hy1CyIizqXC5hbsdjvLly/n8ccf57HHHmPo0KGO10qVKsWWLVto1aoVfn7XOr0axYQT164yYdbMwwrCrIFa0lNExAs1igmn++NR3Fi7+Fig++NRahdERJxMQ9FukJKSwty5c5k4caKjl8bf35+QkBDsdjs+PreuBRvFhFM/Okw7TIuICKt2nWT6hoSbhqIZBkzfkEClYgVV3IiIOJEKmz/56KOPGDp0KImJiQCEhITQo0cPXnnlFe6///47+hm+PhYt3Ski4uW0j42ISM5TYfMnly5dIjExkQceeIC+ffvSrVs3QkJCzI4lIiJuRvvYiIjkPK8tbH788UfGjx9P06ZNadmyJQDdunUjLCyMli1b4u/vb3JCERFxV9rHRkQk53lUYZNhN/5yfothGKxatYrx48ezbt06APbv30+LFi2wWCyEhITQtm1bs+KLiIiH0D42IiI5z2MKm1W7TjJsxe5MXf/h1kCGNonm7w8XYt68eUyYMIFff/0VAF9fX1q3bs3AgQOxWDS+WUREnEf72IiI5DyPKGxW7TpJz7nbb2o8TtlS6Dl3O/dvj+P7r78EIF++fHTv3p1XX32VYsWK5XxYERHxeNf3sek5dzsWyNQ+aX8zERHXcPt9bLJaeSY96Qz2lEuOY2fCqhMeHs6YMWM4duwYEydOVFEjIiIupf3NRERyltv32Px55ZmrpxNIil/C5T0bsNZsTYFabTCAlPCKzF+7jTrREeaGFRERr6L9zUREco7bFzaJSckkH95B0pbFpBz+yXE87cwRxz9bLD5cuJrVKGcRERHX0v5mIiI5w60Lm3/961+8OXQ4p/f8cu2AxYe8pWsRUq0pAeGlMp2rlWdERERERDyXWxc2K1euZP+eX/DxDyT4kfrkf/RZ/AuEZTpHK8+IiIiZbrcVgYiIOIfbFDYnTpzg/fffp02bNjzyyCMAxMbGUrJkSR5+4nkGfXEY0MozIiKSe/zVVgRaPEBExLlyfWGze/duJkyYwNy5c0lLS+P3339nzpw5AJQtW5a33noLgJACoTc1HmFqPERExCS324pAK6OJiDhXri1svvvuO+Li4vjyyy8dx2rXrk2rVq2yPF8rz4iISG6R1VYE1xlcG1EwbMVu6keHqZ0SEXGSXFvY/OMf/wDAYrHw/PPPExsby2OPPfaX79HKMyIikhv8eSuCrBjASVsK8Qnn1G6JiDhJri1sAgIC6Ny5M/369aNUqVK3f4OIiEgucfrirYuauzlPRERuL9cWNrt376ZkyZJmxxAREcm2O91iQFsRiIg4j4/ZAW7lvvvuMzuCiIjIXakWFUq4NZBbzZ6xcG11NG1FICLiPLm2sBEREXFXvj4WhjaJBripuNFWBCIirqHCRkRExAUaxYQT164yYdbMw83CrIFa6llExAWcPsfm7bffZtiwYZmOlS5dmr179zr7o0RERHI1bUUgIpJzXLJ4QLly5Vi7du3/PsQv165RICIi4lLaikBEJGe4ZCian58fYWFhjocWAhARETO9/fbbWCyWTI8yZcqYHUtERJzIJV0p+/fvJyIigsDAQGrUqMHo0aMpVqxYluempqaSmprqeJ6UlOSKSCIi4uU0mkBExLM5vcemevXqzJo1i1WrVhEXF0dCQgJ/+9vfuHjxYpbnjx49GqvV6nhERkY6O5KIiIhGE4iIeDinFzaNGzemRYsWPPLIIzRs2JCvvvqKCxcusGjRoizPHzx4MDabzfE4duyYsyOJiIg4RhOULFmStm3bcvTo0Vuem5qaSlJSUqaHiIjkbi5f7rlAgQI8/PDDHDhwIMvXAwICCAkJyfQQERFxJo0mEBHxfC4vbC5dusTBgwcJD9d6/SIiYg6NJhAR8XxOnzk5cOBAmjRpQvHixTlx4gRDhw7F19eXNm3aOPujRERE7sqdjCYICAjI4VQiInIvnN5j8/vvv9OmTRtKly5Ny5YtKVSoED/88AOFCxd29keJiIjcFY0mEBHxPE7vsVmwYME9vd8wDEDLPouImOH6tff6tdhT3OtoArVNIiLmyE67lOsW8b8+kVMTNUVEzHPx4kWsVqvZMZzm+miCs2fPUrhwYWrXrp2t0QRqm0REzHUn7ZLFyGW35ex2OydOnCB//vxYLJZsvz8pKYnIyEiOHTvmtSusefvvQN9f31/f/+6/v2EYXLx4kYiICHx8XL6+jNtQ23RnvOV7gvd8V31Pz+KO3zM77VKu67Hx8fHhgQceuOefo6Wj9TvQ99f31/e/u+/vST01zqK2KXu85XuC93xXfU/P4m7f807bJd2OExERERERt6fCRkRERERE3J7HFTYBAQEMHTrUq/cf8Pbfgb6/vr++v/d+/9zKW/69eMv3BO/5rvqensXTv2euWzxAREREREQkuzyux0ZERERERLyPChsREREREXF7KmxERERERMTtqbARERERERG357GFzZgxY7BYLPTt29fsKDnm+PHjtGvXjkKFChEUFET58uXZtm2b2bFyREZGBkOGDCEqKoqgoCAefPBBhg8fjqeujbFhwwaaNGlCREQEFouFZcuWZXrdMAz++c9/Eh4eTlBQEPXq1WP//v3mhHWBv/r+aWlpDBo0iPLlyxMcHExERAQdOnTgxIkT5gV2stv9+/+zHj16YLFYmDJlSo7lk//x1GuTt1yDvOla4y3XlTv5nnv27OGZZ57BarUSHBxM1apVOXr0aM6HvQe3+56XLl2iT58+PPDAAwQFBREdHc20adPMCetEHlnYbN26lY8++ohHHnnE7Cg55vz589SqVQt/f39WrlzJ7t27mThxIgULFjQ7Wo4YO3YscXFxfPDBB+zZs4exY8cybtw43n//fbOjucTly5epUKECU6dOzfL1cePG8d577zFt2jS2bNlCcHAwDRs2JCUlJYeTusZfff8rV66wfft2hgwZwvbt21myZAn79u3jmWeeMSGpa9zu3/91S5cu5YcffiAiIiKHksmNPPXa5C3XIG+61njLdeV23/PgwYPUrl2bMmXK8O233/Lzzz8zZMgQAgMDczjpvbnd9+zfvz+rVq1i7ty57Nmzh759+9KnTx+WL1+ew0mdzPAwFy9eNEqVKmV8/fXXRp06dYxXX33V7Eg5YtCgQUbt2rXNjmGap59+2ujcuXOmY02bNjXatm1rUqKcAxhLly51PLfb7UZYWJgxfvx4x7ELFy4YAQEBxvz5801I6Fo3fv+sxMfHG4Bx5MiRnAmVg271/X///Xfj/vvvN3bt2mUUL17cmDx5co5nE++4NnnLNcibrjXecl3J6nu2atXKaNeunTmBXCSr71muXDnjnXfeyXSscuXKxptvvpmDyZzP43psevfuzdNPP029evXMjpKjli9fzqOPPkqLFi0oUqQIlSpVYsaMGWbHyjE1a9bkm2++4bfffgNg586dbNy4kcaNG5ucLOclJCRw6tSpTP8PWK1WqlevzubNm01MZh6bzYbFYqFAgQJmR8kRdrud9u3bExsbS7ly5cyO49W88drkzdcgT77WeMN1xW638+WXX/Lwww/TsGFDihQpQvXq1f9yWJ67qlmzJsuXL+f48eMYhsG6dev47bffaNCggdnR7omf2QGcacGCBWzfvp2tW7eaHSXHHTp0iLi4OPr3788bb7zB1q1beeWVV8iTJw8dO3Y0O57Lvf766yQlJVGmTBl8fX3JyMhg5MiRtG3b1uxoOe7UqVMAFC1aNNPxokWLOl7zJikpKQwaNIg2bdoQEhJidpwcMXbsWPz8/HjllVfMjuL1vPHa5K3XIE+/1njDdeX06dNcunSJMWPGMGLECMaOHcuqVato2rQp69ato06dOmZHdJr333+f7t2788ADD+Dn54ePjw8zZszg8ccfNzvaPfGYwubYsWO8+uqrfP311243DtIZ7HY7jz76KKNGjQKgUqVK7Nq1i2nTpnlFYbNo0SI+//xz5s2bR7ly5dixYwd9+/YlIiLCK76/ZC0tLY2WLVtiGAZxcXFmx8kRP/74I++++y7bt2/HYrGYHcfr6drkHTz9WuMt1xW73Q7As88+S79+/QCoWLEimzZtYtq0aR5X2Pzwww8sX76c4sWLs2HDBnr37k1ERIRbj3rymKFoP/74I6dPn6Zy5cr4+fnh5+fH+vXree+99/Dz8yMjI8PsiC4VHh5OdHR0pmNly5Z1u1U87lZsbCyvv/46rVu3pnz58rRv355+/foxevRos6PluLCwMAASExMzHU9MTHS85g2u/6Fx5MgRvv76a4+8g5qV7777jtOnT1OsWDHHtfDIkSMMGDCAEiVKmB3P63jjtcnbrkHecK3xluvKfffdh5+fn8f/PZWcnMwbb7zBpEmTaNKkCY888gh9+vShVatWTJgwwex498Rjemzq1q3LL7/8kulYp06dKFOmDIMGDcLX19ekZDmjVq1a7Nu3L9Ox3377jeLFi5uUKGdduXIFH5/Mdbqvr6/j7os3iYqKIiwsjG+++YaKFSsCkJSUxJYtW+jZs6e54XLI9T809u/fz7p16yhUqJDZkXJM+/btb7rb1rBhQ9q3b0+nTp1MSuW9vPHa5E3XIG+51njLdSVPnjxUrVrV4/+eSktLIy0tzSOvTR5T2OTPn5+YmJhMx4KDgylUqNBNxz1Rv379qFmzJqNGjaJly5bEx8czffp0pk+fbna0HNGkSRNGjhxJsWLFKFeuHD/99BOTJk2ic+fOZkdziUuXLnHgwAHH84SEBHbs2EFoaCjFihWjb9++jBgxglKlShEVFcWQIUOIiIjgueeeMy+0E/3V9w8PD6d58+Zs376dL774goyMDMe4/tDQUPLkyWNWbKe53b//G/+48vf3JywsjNKlS+d0VK/nqdcmb7kGedO1xluuK7f7nrGxsbRq1YrHH3+cJ598klWrVrFixQq+/fZb80Lfhdt9zzp16hAbG0tQUBDFixdn/fr1zJ49m0mTJpmY2glMXpXNpbxpuWfDMIwVK1YYMTExRkBAgFGmTBlj+vTpZkfKMUlJScarr75qFCtWzAgMDDRKlixpvPnmm0ZqaqrZ0Vxi3bp1BnDTo2PHjoZhXFtudciQIUbRokWNgIAAo27dusa+ffvMDe1Ef/X9ExISsnwNMNatW2d2dKe43b//G3nCsqzuylOvTd5yDfKma423XFfu5Ht+/PHHxkMPPWQEBgYaFSpUMJYtW2Ze4Lt0u+958uRJ48UXXzQiIiKMwMBAo3Tp0sbEiRMNu91ubvB7ZDEMN9/+WEREREREvJ7HLB4gIiIiIiLeS4WNiIiIiIi4PRU2IiIiIiLi9lTYiIiIiIiI21NhIyIiIiIibk+FjYiIiIiIuD0VNiIiIiIi4vZU2IiIiIiIiNtTYSMiIiIiIm5PhY2IiIiIiLg9FTYiIiIiIuL2VNiIiIiIiIjb+z9+xmG8tEwC9gAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -686,17 +704,17 @@ "from sklearn.linear_model import HuberRegressor\n", "\n", "reg = HuberRegressor()\n", - " \n", + "\n", "fig, axes = plt.subplots(2, 2, figsize=(10, 10))\n", "\n", "for (x, y), ax in zip(anscombe_quartet, axes.ravel()):\n", " reg.fit(x[:, None], y)\n", " y_pred = reg.predict(x[:, None])\n", " ax.scatter(x, y)\n", - " \n", + "\n", " xlim = ax.get_xlim()\n", " t = np.arange(*xlim)\n", - " ax.plot(t, reg.coef_ * t + reg.intercept_, 'k--')\n", + " ax.plot(t, reg.coef_ * t + reg.intercept_, \"k--\")\n", " ax.set_xlim(xlim)\n", " ax.set_title(f\"MAE = {mean_absolute_error(y_pred, y):.2e}\")" ] @@ -726,8 +744,11 @@ "source": [ "data, target = shuffle(data, target, random_state=0)\n", "\n", - "print(cross_val_score(regressor, data, target, cv=5,\n", - " scoring='neg_mean_absolute_error'))" + "print(\n", + " cross_val_score(\n", + " regressor, data, target, cv=5, scoring=\"neg_mean_absolute_error\"\n", + " )\n", + ")" ] }, { @@ -774,7 +795,7 @@ "\n", "cv = KFold(n_splits=5, shuffle=True)\n", "\n", - "print('usual training')\n", + "print(\"usual training\")\n", "mse_list = []\n", "mape_list = []\n", "for train_idx, test_idx in cv.split(X, y):\n", @@ -783,22 +804,24 @@ " y_pred = est.predict(X[test_idx])\n", " mse_list.append(mean_squared_error(y_true, y_pred))\n", " mape_list.append(mean_absolute_percentage_error(y_true, y_pred))\n", - "print('MSE:', np.mean(mse_list))\n", - "print('MAPE:', np.mean(mape_list))\n", + "print(\"MSE:\", np.mean(mse_list))\n", + "print(\"MAPE:\", np.mean(mape_list))\n", "\n", - "print('')\n", + "print(\"\")\n", "\n", - "print('weighted training')\n", + "print(\"weighted training\")\n", "mse_list = []\n", "mape_list = []\n", "for train_idx, test_idx in cv.split(X, y):\n", - " est.fit(X[train_idx], y[train_idx], sample_weight=1.0/np.abs(y[train_idx]))\n", + " est.fit(\n", + " X[train_idx], y[train_idx], sample_weight=1.0 / np.abs(y[train_idx])\n", + " )\n", " y_true = y[test_idx]\n", " y_pred = est.predict(X[test_idx])\n", " mse_list.append(mean_squared_error(y_true, y_pred))\n", " mape_list.append(mean_absolute_percentage_error(y_true, y_pred))\n", - "print('MSE:', np.mean(mse_list))\n", - "print('MAPE:', np.mean(mape_list))" + "print(\"MSE:\", np.mean(mse_list))\n", + "print(\"MAPE:\", np.mean(mape_list))" ] }, { @@ -845,17 +868,19 @@ "\n", "pipeline = make_pipeline(StandardScaler(), LinearRegression())\n", "\n", - "print('weighted training')\n", + "print(\"weighted training\")\n", "mse_list = []\n", "mape_list = []\n", "for train_idx, test_idx in cv.split(X, y):\n", - " pipeline.fit(X[train_idx], y[train_idx], sample_weight=1.0/np.abs(y[train_idx]))\n", + " pipeline.fit(\n", + " X[train_idx], y[train_idx], sample_weight=1.0 / np.abs(y[train_idx])\n", + " )\n", " y_true = y[test_idx]\n", " y_pred = est.predict(X[test_idx])\n", " mse_list.append(mean_squared_error(y_true, y_pred))\n", " mape_list.append(mean_absolute_percentage_error(y_true, y_pred))\n", - "print('MSE:', np.mean(mse_list))\n", - "print('MAPE:', np.mean(mape_list))" + "print(\"MSE:\", np.mean(mse_list))\n", + "print(\"MAPE:\", np.mean(mape_list))" ] }, { @@ -882,6 +907,7 @@ ], "source": [ "import sklearn\n", + "\n", "sklearn.set_config(enable_metadata_routing=True)\n", "\n", "scaler = StandardScaler().set_fit_request(sample_weight=False)\n", @@ -889,17 +915,19 @@ "\n", "pipeline = make_pipeline(scaler, reg)\n", "\n", - "print('weighted training')\n", + "print(\"weighted training\")\n", "mse_list = []\n", "mape_list = []\n", "for train_idx, test_idx in cv.split(X, y):\n", - " pipeline.fit(X[train_idx], y[train_idx], sample_weight=1.0/np.abs(y[train_idx]))\n", + " pipeline.fit(\n", + " X[train_idx], y[train_idx], sample_weight=1.0 / np.abs(y[train_idx])\n", + " )\n", " y_true = y[test_idx]\n", " y_pred = est.predict(X[test_idx])\n", " mse_list.append(mean_squared_error(y_true, y_pred))\n", " mape_list.append(mean_absolute_percentage_error(y_true, y_pred))\n", - "print('MSE:', np.mean(mse_list))\n", - "print('MAPE:', np.mean(mape_list))" + "print(\"MSE:\", np.mean(mse_list))\n", + "print(\"MAPE:\", np.mean(mape_list))" ] }, { @@ -930,13 +958,13 @@ } ], "source": [ - "import numpy as np \n", + "import numpy as np\n", "import scipy.stats as stats\n", "import matplotlib.pyplot as plt\n", "\n", "fig, ax = plt.subplots(figsize=(10, 5), ncols=2)\n", "stats.probplot(y, dist=\"norm\", plot=ax[0])\n", - "stats.probplot(np.log(1+ y), dist=\"norm\", plot=ax[1])\n", + "stats.probplot(np.log(1 + y), dist=\"norm\", plot=ax[1])\n", "plt.show()" ] }, @@ -950,9 +978,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python (myenv)", + "display_name": "DataCamp", "language": "python", - "name": "myenv" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -964,7 +992,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/05_imbalance_learning/01-imbalanced_learning.ipynb b/05_imbalance_learning/01-imbalanced_learning.ipynb index 72b50c5..0854fbc 100644 --- a/05_imbalance_learning/01-imbalanced_learning.ipynb +++ b/05_imbalance_learning/01-imbalanced_learning.ipynb @@ -11,7 +11,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -34,9 +34,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Requirement already satisfied: imbalanced-learn in /Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages (0.12.4)\n", + "Requirement already satisfied: numpy>=1.17.3 in /Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages (from imbalanced-learn) (1.26.4)\n", + "Requirement already satisfied: scipy>=1.5.0 in /Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages (from imbalanced-learn) (1.14.1)\n", + "Requirement already satisfied: scikit-learn>=1.0.2 in /Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages (from imbalanced-learn) (1.6.0)\n", + "Requirement already satisfied: joblib>=1.1.1 in /Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages (from imbalanced-learn) (1.4.2)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in /Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages (from imbalanced-learn) (3.5.0)\n" + ] + } + ], "source": [ "!pip install -U imbalanced-learn" ] @@ -65,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -74,18 +87,437 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
ageworkclassfnlwgteducationeducation-nummarital-statusoccupationrelationshipracesexcapital-gaincapital-losshours-per-weeknative-countryclass
025Private22680211th7Never-marriedMachine-op-inspctOwn-childBlackMale0040United-States<=50K
138Private89814HS-grad9Married-civ-spouseFarming-fishingHusbandWhiteMale0050United-States<=50K
228Local-gov336951Assoc-acdm12Married-civ-spouseProtective-servHusbandWhiteMale0040United-States>50K
344Private160323Some-college10Married-civ-spouseMachine-op-inspctHusbandBlackMale7688040United-States>50K
418?103497Some-college10Never-married?Own-childWhiteFemale0030United-States<=50K
\n", + "
" + ], + "text/plain": [ + " age workclass fnlwgt education education-num marital-status \\\n", + "0 25 Private 226802 11th 7 Never-married \n", + "1 38 Private 89814 HS-grad 9 Married-civ-spouse \n", + "2 28 Local-gov 336951 Assoc-acdm 12 Married-civ-spouse \n", + "3 44 Private 160323 Some-college 10 Married-civ-spouse \n", + "4 18 ? 103497 Some-college 10 Never-married \n", + "\n", + " occupation relationship race sex capital-gain \\\n", + "0 Machine-op-inspct Own-child Black Male 0 \n", + "1 Farming-fishing Husband White Male 0 \n", + "2 Protective-serv Husband White Male 0 \n", + "3 Machine-op-inspct Husband Black Male 7688 \n", + "4 ? Own-child White Female 0 \n", + "\n", + " capital-loss hours-per-week native-country class \n", + "0 0 40 United-States <=50K \n", + "1 0 50 United-States <=50K \n", + "2 0 40 United-States >50K \n", + "3 0 40 United-States >50K \n", + "4 0 30 United-States <=50K " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "df.head()" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "

Categorial variable

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
workclasseducationmarital-statusoccupationrelationshipracesexnative-countryclass
count488424884248842488424884248842488424884248842
unique916715652422
topPrivateHS-gradMarried-civ-spouseProf-specialtyHusbandWhiteMaleUnited-States<=50K
freq33906157842237961721971641762326504383237155
\n", + "
" + ], + "text/plain": [ + " workclass education marital-status occupation relationship \\\n", + "count 48842 48842 48842 48842 48842 \n", + "unique 9 16 7 15 6 \n", + "top Private HS-grad Married-civ-spouse Prof-specialty Husband \n", + "freq 33906 15784 22379 6172 19716 \n", + "\n", + " race sex native-country class \n", + "count 48842 48842 48842 48842 \n", + "unique 5 2 42 2 \n", + "top White Male United-States <=50K \n", + "freq 41762 32650 43832 37155 " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "

Numerical variable

" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
agefnlwgteducation-numcapital-gaincapital-losshours-per-week
count48842.0000004.884200e+0448842.00000048842.00000048842.00000048842.000000
mean38.6435851.896641e+0510.0780891079.06762687.50231440.422382
std13.7105101.056040e+052.5709737452.019058403.00455212.391444
min17.0000001.228500e+041.0000000.0000000.0000001.000000
25%28.0000001.175505e+059.0000000.0000000.00000040.000000
50%37.0000001.781445e+0510.0000000.0000000.00000040.000000
75%48.0000002.376420e+0512.0000000.0000000.00000045.000000
max90.0000001.490400e+0616.00000099999.0000004356.00000099.000000
\n", + "
" + ], + "text/plain": [ + " age fnlwgt education-num capital-gain capital-loss \\\n", + "count 48842.000000 4.884200e+04 48842.000000 48842.000000 48842.000000 \n", + "mean 38.643585 1.896641e+05 10.078089 1079.067626 87.502314 \n", + "std 13.710510 1.056040e+05 2.570973 7452.019058 403.004552 \n", + "min 17.000000 1.228500e+04 1.000000 0.000000 0.000000 \n", + "25% 28.000000 1.175505e+05 9.000000 0.000000 0.000000 \n", + "50% 37.000000 1.781445e+05 10.000000 0.000000 0.000000 \n", + "75% 48.000000 2.376420e+05 12.000000 0.000000 0.000000 \n", + "max 90.000000 1.490400e+06 16.000000 99999.000000 4356.000000 \n", + "\n", + " hours-per-week \n", + "count 48842.000000 \n", + "mean 40.422382 \n", + "std 12.391444 \n", + "min 1.000000 \n", + "25% 40.000000 \n", + "50% 40.000000 \n", + "75% 45.000000 \n", + "max 99.000000 " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "display(HTML(\"

Categorial variable

\"))\n", "display(df.describe(exclude=np.number))\n", @@ -102,7 +534,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -111,9 +543,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Counter({' <=50K': 37155, ' >50K': 11687})" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "counter = Counter(df['class'])\n", "counter" @@ -129,9 +572,20 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3.179173440574998" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "counter[' <=50K'] / counter[' >50K']" ] @@ -145,7 +599,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -159,9 +613,438 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
DummyClassifier(strategy='most_frequent')
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + ], + "text/plain": [ + "DummyClassifier(strategy='most_frequent')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from sklearn.dummy import DummyClassifier\n", "\n", @@ -178,16 +1061,27 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([' <=50K'], dtype='" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAGwCAYAAACgi8/jAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAU1ZJREFUeJzt3XtcVHX+P/DXyGVAhJGLMIwiWSlewFIwQCvxBpKgZpsa7oS7hpUly1eofmWb9C0h81q5ua7bV1ExateovJG0pkWCF5ISJbRCxeSmjsNFHWDm/P5wOTmCCpwxDsPr+Xicx8M5530+8zkuG2/fn8tRCIIggIiIiMgKdevoDhARERHdKUx0iIiIyGox0SEiIiKrxUSHiIiIrBYTHSIiIrJaTHSIiIjIajHRISIiIqtl29Ed6IpMJhPOnTsHZ2dnKBSKju4OERG1kSAIqKmpgUajQbdud6ZmcPXqVdTX11ukLXt7ezg4OFikrc6GiU4HOHfuHHx8fDq6G0REJFFpaSn69Olj8XavXr2Kfr49UF5ptEh7arUaJSUlXTLZYaLTAZydnQEAp7+7Cy49OHpI1unRAQEd3QWiO6YRDcjBTvG/55ZWX1+P8kojTuffBRdnab8nqmtM8A08hfr6eiY69PtoGq5y6dFN8g8wkVzZKuw6ugtEd85/X550p6cf9HBWoIeztO8woWtPkWCiQ0REJFNGwQSjxDdSGgWTZTrTSTHRISIikikTBJggLdORen9nx3ETIiIislqs6BAREcmUCSZIHXiS3kLnxkSHiIhIpoyCAKMgbehJ6v2dHYeuiIiIyGqxokNERCRTnIwsHRMdIiIimTJBgJGJjiQcuiIiIiKrxYoOERGRTHHoSjomOkRERDLFVVfSceiKiIiIrBYrOkRERDJl+u8htY2ujIkOERGRTBktsOpK6v2dHRMdIiIimTIKsMDbyy3Tl86Kc3SIiIhItGbNGgwdOhQuLi5wcXFBaGgodu3aJV6fPXs2FAqF2RESEmLWhsFgwPz58+Hh4QEnJydMnjwZZ8+eNYvR6XTQarVQqVRQqVTQarW4dOmSWcyZM2cQHR0NJycneHh4ID4+HvX19W16HiY6REREMmWy0NEWffr0wVtvvYXDhw/j8OHDGDt2LKZMmYJjx46JMRMnTkRZWZl47Ny506yNhIQEZGZmIiMjAzk5OaitrUVUVBSMRqMYExMTg4KCAmRlZSErKwsFBQXQarXidaPRiEmTJqGurg45OTnIyMjA1q1bkZiY2Kbn4dAVERGRTJmggBEKyW20RXR0tNnnxYsXY82aNcjLy8OQIUMAAEqlEmq1usX79Xo9PvjgA2zatAnjx48HAGzevBk+Pj748ssvERERgaKiImRlZSEvLw/BwcEAgHXr1iE0NBTFxcXw8/PD7t27cfz4cZSWlkKj0QAAli9fjtmzZ2Px4sVwcXFp1fOwokNERNQFVFdXmx0Gg+G29xiNRmRkZKCurg6hoaHi+b1798LT0xMDBgxAXFwcKisrxWv5+floaGhAeHi4eE6j0cDf3x/79+8HAOTm5kKlUolJDgCEhIRApVKZxfj7+4tJDgBERETAYDAgPz+/1c/NRIeIiEimTIJlDgDw8fER58OoVCqkpqbe9HuPHj2KHj16QKlU4plnnkFmZiYGDx4MAIiMjER6ejr27NmD5cuX49ChQxg7dqyYOJWXl8Pe3h6urq5mbXp5eaG8vFyM8fT0bPa9np6eZjFeXl5m111dXWFvby/GtAaHroiIiGTKaIGhq6b7S0tLzYZ7lErlTe/x8/NDQUEBLl26hK1btyI2Nhb79u3D4MGDMWPGDDHO398fQUFB8PX1xY4dOzBt2rSbtikIAhSK357l+j9LibkdVnSIiIi6gKZVVE3HrRIde3t73HvvvQgKCkJqairuu+8+vPPOOy3Gent7w9fXFydPngQAqNVq1NfXQ6fTmcVVVlaKFRq1Wo2KiopmbVVVVZnF3Fi50el0aGhoaFbpuRUmOkRERDLVVNGRekglCMJN5/RcuHABpaWl8Pb2BgAEBgbCzs4O2dnZYkxZWRkKCwsxcuRIAEBoaCj0ej0OHjwoxhw4cAB6vd4sprCwEGVlZWLM7t27oVQqERgY2Oq+c+iKiIhIpkyCAiZB4qqrNt7/yiuvIDIyEj4+PqipqUFGRgb27t2LrKws1NbWIjk5GY899hi8vb1x6tQpvPLKK/Dw8MCjjz4KAFCpVJgzZw4SExPh7u4ONzc3JCUlISAgQFyFNWjQIEycOBFxcXFYu3YtAGDu3LmIioqCn58fACA8PByDBw+GVqvF0qVLcfHiRSQlJSEuLq7VK64AJjpERER0nYqKCmi1WpSVlUGlUmHo0KHIysrChAkTcOXKFRw9ehQbN27EpUuX4O3tjTFjxuCjjz6Cs7Oz2MbKlStha2uL6dOn48qVKxg3bhw2bNgAGxsbMSY9PR3x8fHi6qzJkydj9erV4nUbGxvs2LED8+bNw6hRo+Do6IiYmBgsW7asTc+jEIQu/v72DlBdXQ2VSgXdibvh4szRQ7JOEZr7O7oLRHdMo9CAvfgMer2+TdWF1mr6PbGvsDd6SPw9UVtjwmj/X+9YX+WOFR0iIiKZMqIbjBKn0xpvH2LVmOgQERHJlGCBOTqCxPs7O46bEBERkdViRYeIiEimLLlhYFfFRIeIiEimjEI3GAWJc3S6+JIjDl0RERGR1WJFh4iISKZMUMAksSZhQtcu6TDRISIikinO0ZGOQ1dERERktVjRISIikinLTEbm0BURERHJ0LU5OhJf6smhKyIiIiLrxIoOERGRTJks8K4rrroiIiIiWeIcHemY6BAREcmUCd24j45EnKNDREREVosVHSIiIpkyCgoYBYkbBkq8v7NjokNERCRTRgtMRjZy6IqIiIjIOrGiQ0REJFMmoRtMElddmbjqioiIiOSIQ1fSceiKiIiIrBYrOkRERDJlgvRVUybLdKXTYqJDREQkU5bZMLBrD9507acnIiIiq8aKDhERkUxZ5l1XXbumwUSHiIhIpkxQwASpc3S4MzIRERHJECs60nXtpyciIiKrxooOERGRTFlmw8CuXdNgokNERCRTJkEBk9R9dLr428u7dppHREREVo0VHSIiIpkyWWDoqqtvGMhEh4iISKYs8/byrp3odO2nJyIiIqvGig4REZFMGaGAUeKGf1Lv7+yY6BAREckUh66k69pPT0RERFaNFR0iIiKZMkL60JPRMl3ptFjRISIikqmmoSupR1usWbMGQ4cOhYuLC1xcXBAaGopdu3aJ1wVBQHJyMjQaDRwdHREWFoZjx46ZtWEwGDB//nx4eHjAyckJkydPxtmzZ81idDodtFotVCoVVCoVtFotLl26ZBZz5swZREdHw8nJCR4eHoiPj0d9fX2bnoeJDhERkUw1vdRT6tEWffr0wVtvvYXDhw/j8OHDGDt2LKZMmSImM2+//TZWrFiB1atX49ChQ1Cr1ZgwYQJqamrENhISEpCZmYmMjAzk5OSgtrYWUVFRMBp/qy/FxMSgoKAAWVlZyMrKQkFBAbRa7W/PbjRi0qRJqKurQ05ODjIyMrB161YkJia26XkUgiAIbbqDJKuuroZKpYLuxN1wcWauSdYpQnN/R3eB6I5pFBqwF59Br9fDxcXF4u03/Z54OXciHHrYSWrram0DUkOzUFpaatZXpVIJpVLZqjbc3NywdOlS/PnPf4ZGo0FCQgJeeuklANeqN15eXliyZAmefvpp6PV69OrVC5s2bcKMGTMAAOfOnYOPjw927tyJiIgIFBUVYfDgwcjLy0NwcDAAIC8vD6Ghofjxxx/h5+eHXbt2ISoqCqWlpdBoNACAjIwMzJ49G5WVla3+e+dvWSIiIpkSoIBJ4iH8d46Pj4+POEykUqmQmpp62+83Go3IyMhAXV0dQkNDUVJSgvLycoSHh4sxSqUSo0ePxv79+wEA+fn5aGhoMIvRaDTw9/cXY3Jzc6FSqcQkBwBCQkKgUqnMYvz9/cUkBwAiIiJgMBiQn5/f6r9DTkYmIiKSqfYMPbXUBoAWKzo3c/ToUYSGhuLq1avo0aMHMjMzMXjwYDEJ8fLyMov38vLC6dOnAQDl5eWwt7eHq6trs5jy8nIxxtPTs9n3enp6msXc+D2urq6wt7cXY1qDiQ4REVEX0DS5uDX8/PxQUFCAS5cuYevWrYiNjcW+ffvE6wqF+UowQRCanbvRjTEtxbcn5nY4dEVERCRTJkFhkaOt7O3tce+99yIoKAipqam477778M4770CtVgNAs4pKZWWlWH1Rq9Wor6+HTqe7ZUxFRUWz762qqjKLufF7dDodGhoamlV6boWJDhERkUwZ//v2cqmHVIIgwGAwoF+/flCr1cjOzhav1dfXY9++fRg5ciQAIDAwEHZ2dmYxZWVlKCwsFGNCQ0Oh1+tx8OBBMebAgQPQ6/VmMYWFhSgrKxNjdu/eDaVSicDAwFb3nUNXREREJHrllVcQGRkJHx8f1NTUICMjA3v37kVWVhYUCgUSEhKQkpKC/v37o3///khJSUH37t0RExMDAFCpVJgzZw4SExPh7u4ONzc3JCUlISAgAOPHjwcADBo0CBMnTkRcXBzWrl0LAJg7dy6ioqLg5+cHAAgPD8fgwYOh1WqxdOlSXLx4EUlJSYiLi2vTSjcmOkRERDLV3qGnG9toi4qKCmi1WpSVlUGlUmHo0KHIysrChAkTAAAvvvgirly5gnnz5kGn0yE4OBi7d++Gs7Oz2MbKlStha2uL6dOn48qVKxg3bhw2bNgAGxsbMSY9PR3x8fHi6qzJkydj9erV4nUbGxvs2LED8+bNw6hRo+Do6IiYmBgsW7asTc/DfXQ6APfRoa6A++iQNfu99tF5PudRKCXuo2OobcDqBzPvWF/ljr9liYiIyGpx6IqIiEimjIICRolDV1Lv7+yY6BAREclUR8zRsTZMdIiIiGRKaMfbx1tqoyvr2k9PREREVo0VHSIiIpkyQgEjJM7RkXh/Z8dEh4iISKZMgvQ5NqYuvokMh66IiIjIarGiQ7KzLc0dOzZ6oKLUHgDg63cVs/6nHCPG1gC4+UZ0T736Kx6fVwUA2LnZHV9luuKno464XGuDrUVH0UNlNIt/8oHBqDhrb3Zu+nMVmLPwt/eqtPRd898qRdSTF9r7eEQWFxV7Ho8/WwU3zwacPuGAv7+mQeHBHh3dLbIAkwUmI0u9v7NjokOy08u7AX9+5Rw0d9UDALL/5YrkP/XD33afwF1+V/FhQaFZ/KE9LliZ6IMHJ+nFc1evdENQWDWCwqrxf6mam37Xky+UIXLWb0mLo5OpWUziyjMIGlMtfnZyNjaLIeoooyfr8Mzr57D6ld44dtAJk7QX8GZ6CeLC/FD1q/3tGyBZM0EBk8Q5NlLv7+y6VJoXFhYGhUJhdsycOdMsRqfTQavVQqVSQaVSQavV4tKlS+L1U6dOQaFQoKCgQDxXU1ODsLAwDBw4EKWlpb/T01ivkPBqPDCuBn3uMaDPPQb86f+Vw8HJhB/zuwMA3DwbzY7cL1S4b1QtvH3rxTamxVVhxvxKDAy8fMvvcuxhMmurpUSnh4vRLEbp2MUHvElWps09jy8+dEPWFneU/uSAvy/qjapzdqw6Ev1Xp0p0TCYTfv31V0ltxMXFoaysTDya3praJCYmBgUFBcjKykJWVhYKCgqg1Wpv2l5VVRXGjBmD2tpa5OTkwMfHR1L/yJzRCOz9tCcMl7thUFBds+u6Klsc/I8LIma27z/q//qbJ/4wxB/PjvfDlne80FDf/F8+f3u1Nx4f4o/5kQOwfaM7TM1zIaIOYWtnQv+hl5G/z9nsfP4+Zwxu4f8v1Pk07Yws9ejKOsXQ1Y8//oi0tDRs2rQJjz/+OFauXNnutrp37w61Wt3itaKiImRlZSEvLw/BwcEAgHXr1iE0NBTFxcXiq+OblJaWYsKECfD29sbnn39u9uZWkqakyAEJ0f1Rb+gGRycTXvugBL4DDM3isj92g2MPIx58RN9CK7c29akq3BtwGT1URhQf6Y71qRpUnLHH/yz/rSoX+2IZ7n+wBkoHAUdyeuAfr2tQfdEWMQkVkp6PyBJc3IywsQUunTf/T/mlKlu4ejZ2UK/IkjhHRzrZPr1Op8OaNWsQEhICf39/5Ofn46233sLixYvFmJSUFPTo0eOWxzfffGPWbnp6Ojw8PDBkyBAkJSWhpqZGvJabmwuVSiUmOQAQEhIClUqF/fv3m7VTXFyMUaNGYeDAgcjKyrplkmMwGFBdXW120K31uceA97OL8c72E4h68jyW/cUXp08om8V9keGGsY/qYO/Q9uGkaXOrMDS0DncPvorIWRcxf0kpsj50R/VFGzEmJqECg4Mu4x7/K/jDM1V48oVy/GuNp6RnI7I04YYff4UCAEdYiQDIrKJjMpmwa9cupKWl4fPPP8eAAQOg1WqRmZkJb2/vZvHPPPMMpk+ffss2e/fuLf551qxZ6NevH9RqNQoLC/Hyyy/j+++/R3Z2NgCgvLwcnp7Nf4l5enqivLzc7NyTTz6JkSNHYuvWrbCxsWl2z/VSU1Px+uuv3zKGzNnZC+jd79qcmwH3XUFxQXd8+s9e+MvbZ8WYoweccPZnB7zy91MW+c5Bw6/N5zl3SgkXt5bn9gwafhmXa2ygq7KFay/+i5k6VvVFGxgb0exnUeXRCF2VrP7zTu1kggXeddXFJyPL6v8JZ86cQVRUFFxdXbFlyxZMmzbtlvFubm5wc3NrdftxcXHin/39/dG/f38EBQXhu+++w/DhwwEACkXzHwhBEJqdnzJlCjIzM7F169bbJlsvv/wyFixYIH6urq7mXJ52aKg3L0B+8aE7+g+9jHuGXLVI+z8VOgIA3Dwbbhlj72CCkwtXXlHHa2zohpM/dMfwh2uwP0slnh/+cA1yv1Dd4k7qLAQLrLoSmOjIR58+ffDhhx8iLS0NM2bMQEhICJ588kk8/vjj6NmzZ7P4lJQUpKSk3LLNXbt24aGHHmrx2vDhw2FnZ4eTJ09i+PDhUKvVqKhoPveiqqoKXl5eZudeeeUVDB06FLNmzYIgCJgxY8ZN+6BUKqFUNh92oZb9X6o3RoytRi9NA67UdsPez3rih/098Gb6z2JMXU03fL1NhbmLzrXYxsVKW+gq7XCu5Nry2pIfHdDdyYRevevh4mrE8cPd8eN3TrhvZC2cXIwoLuiOtckahITr4dnnWqKTt9sFF6tsMTjwMuwdTPj+2x7YsMQbj8y6AHslxwVIHj75hwdeeLcUJ35wRNFhJzzyxwvw7N2AHRvdO7prZAF8e7l0skp0bG1tMXPmTMycORNlZWXYtGkTVq1ahfnz5yM6OhparRaRkZGws7MD0PahqxsdO3YMDQ0N4rBYaGgo9Ho9Dh48iAceeAAAcODAAej1eowcObLZ/a+++ipsbW0xa9YsmEwmPPHEE+19dLrOpSpbLJ3vi4uVtujubES/QVfxZvrPCBxdK8bs+8wVEBQYM1XXYhs7Nnpg84rfJp0nPdofwLU9ccJnXISdvYB9n/fE5hVqNNQr4Nm7HpExF/H4vN8SXRs7Ads3eOAfyUqYTIC3bz2efKEMk2efv0NPTtR2+z53hbOrEbP+pwJuno04XeyAV//YD5XcQ4cIAKAQhBunscnP4cOHsWHDBmRkZCA2NhbLly9vcxs///wz0tPT8cgjj8DDwwPHjx9HYmIiHB0dcejQIXGeTWRkJM6dOycuO587dy58fX2xbds2ANf20enXrx+OHDmC+++/HwCwdOlSvPzyy0hLS8OsWbNu25fq6mqoVCroTtwNF2fZzgcnkuRmO1gTWYNGoQF78Rn0ej1cXFws3n7T74lHs/8EOydpSWtDXT0yJ6y/Y32VO1lVdG4mKCgIQUFBWLFiBc6ePXv7G1pgb2+P//znP3jnnXdQW1sLHx8fTJo0CYsWLTKbTJyeno74+HiEh4cDACZPnozVq1ffsu0XXngBNjY2iI2NhclkuuW+O0RERK3FoSvpOkVFx9qwokNdASs6ZM1+r4rOlN1/tkhF57Pw/2NFh4iIiOSF77qSjokOERGRTHHoSjqOmxAREZHVYkWHiIhIpljRkY6JDhERkUwx0ZGOQ1dERERktVjRISIikilWdKRjokNERCRTAqQvD+/qm+Ux0SEiIpIpVnSk4xwdIiIislqs6BAREckUKzrSMdEhIiKSKSY60nHoioiIiKwWKzpEREQyxYqOdEx0iIiIZEoQFBAkJipS7+/sOHRFREREVosVHSIiIpkyQSF5w0Cp93d2rOgQERHJVNMcHalHW6SmpmLEiBFwdnaGp6cnpk6diuLiYrOY2bNnQ6FQmB0hISFmMQaDAfPnz4eHhwecnJwwefJknD171ixGp9NBq9VCpVJBpVJBq9Xi0qVLZjFnzpxBdHQ0nJyc4OHhgfj4eNTX17f6eZjoEBERkWjfvn147rnnkJeXh+zsbDQ2NiI8PBx1dXVmcRMnTkRZWZl47Ny50+x6QkICMjMzkZGRgZycHNTW1iIqKgpGo1GMiYmJQUFBAbKyspCVlYWCggJotVrxutFoxKRJk1BXV4ecnBxkZGRg69atSExMbPXzcOiKiIhIpjpiMnJWVpbZ5/Xr18PT0xP5+fl4+OGHxfNKpRJqtbrFNvR6PT744ANs2rQJ48ePBwBs3rwZPj4++PLLLxEREYGioiJkZWUhLy8PwcHBAIB169YhNDQUxcXF8PPzw+7du3H8+HGUlpZCo9EAAJYvX47Zs2dj8eLFcHFxue3zsKJDREQkU5YcuqqurjY7DAZDq/qg1+sBAG5ubmbn9+7dC09PTwwYMABxcXGorKwUr+Xn56OhoQHh4eHiOY1GA39/f+zfvx8AkJubC5VKJSY5ABASEgKVSmUW4+/vLyY5ABAREQGDwYD8/PxW9Z+JDhERkUw1VXSkHgDg4+MjzoVRqVRITU1txfcLWLBgAR588EH4+/uL5yMjI5Geno49e/Zg+fLlOHToEMaOHSsmT+Xl5bC3t4erq6tZe15eXigvLxdjPD09m32np6enWYyXl5fZdVdXV9jb24sxt8OhKyIioi6gtLTUbKhHqVTe9p7nn38eP/zwA3JycszOz5gxQ/yzv78/goKC4Ovrix07dmDatGk3bU8QBCgUvw2lXf9nKTG3wooOERGRTAkWGLZqqui4uLiYHbdLdObPn4/PP/8cX331Ffr06XPLWG9vb/j6+uLkyZMAALVajfr6euh0OrO4yspKsUKjVqtRUVHRrK2qqiqzmBsrNzqdDg0NDc0qPTfDRIeIiEimBACCIPFo63cKAp5//nl88skn2LNnD/r163fbey5cuIDS0lJ4e3sDAAIDA2FnZ4fs7GwxpqysDIWFhRg5ciQAIDQ0FHq9HgcPHhRjDhw4AL1ebxZTWFiIsrIyMWb37t1QKpUIDAxs1fNw6IqIiIhEzz33HLZs2YLPPvsMzs7OYkVFpVLB0dERtbW1SE5OxmOPPQZvb2+cOnUKr7zyCjw8PPDoo4+KsXPmzEFiYiLc3d3h5uaGpKQkBAQEiKuwBg0ahIkTJyIuLg5r164FAMydOxdRUVHw8/MDAISHh2Pw4MHQarVYunQpLl68iKSkJMTFxbVqxRXAig4REZFsNe2MLPVoizVr1kCv1yMsLAze3t7i8dFHHwEAbGxscPToUUyZMgUDBgxAbGwsBgwYgNzcXDg7O4vtrFy5ElOnTsX06dMxatQodO/eHdu2bYONjY0Yk56ejoCAAISHhyM8PBxDhw7Fpk2bxOs2NjbYsWMHHBwcMGrUKEyfPh1Tp07FsmXLWv08CkEQ2lrVIomqq6uhUqmgO3E3XJyZa5J1itDc39FdILpjGoUG7MVn0Ov1ra4stEXT74mh/0qCTffbTxq+FeNlA354fNkd66vc8bcsERERWS3O0SEiIpIpk6CAQuLOyG1915W1YaJDREQkU00rp6S20ZVx6IqIiIisFis6REREMtURL/W0Nkx0iIiIZIqJjnRMdIiIiGSKk5Gl4xwdIiIislqs6BAREckUV11Jx0SHiIhIpq4lOlLn6FioM50Uh66IiIjIarGiQ0REJFNcdSUdEx0iIiKZEv57SG2jK+PQFREREVktVnSIiIhkikNX0jHRISIikiuOXUnGRIeIiEiuLFDRQRev6HCODhEREVktVnSIiIhkijsjS8dEh4iISKY4GVk6Dl0RERGR1WJFh4iISK4EhfTJxF28osNEh4iISKY4R0c6Dl0RERGR1WJFh4iISK64YaBkTHSIiIhkiquupGtVovPuu++2usH4+Ph2d4aIiIjIklqV6KxcubJVjSkUCiY6REREltTFh56kalWiU1JScqf7QURERDfg0JV07V51VV9fj+LiYjQ2NlqyP0RERNREsNDRhbU50bl8+TLmzJmD7t27Y8iQIThz5gyAa3Nz3nrrLYt3kIiIiKi92pzovPzyy/j++++xd+9eODg4iOfHjx+Pjz76yKKdIyIi6toUFjq6rjYvL//000/x0UcfISQkBArFb395gwcPxs8//2zRzhEREXVp3EdHsjZXdKqqquDp6dnsfF1dnVniQ0RERNTR2pzojBgxAjt27BA/NyU369atQ2hoqOV6RkRE1NVxMrJkbR66Sk1NxcSJE3H8+HE0NjbinXfewbFjx5Cbm4t9+/bdiT4SERF1TXx7uWRtruiMHDkS3377LS5fvox77rkHu3fvhpeXF3JzcxEYGHgn+khERETULu1611VAQADS0tIs3RciIiK6jiBcO6S20ZW1K9ExGo3IzMxEUVERFAoFBg0ahClTpsDWlu8IJSIishiuupKszUNXhYWFGDBgAGJjY5GZmYlPPvkEsbGx6N+/P44ePXon+khERES/k9TUVIwYMQLOzs7w9PTE1KlTUVxcbBYjCAKSk5Oh0Wjg6OiIsLAwHDt2zCzGYDBg/vz58PDwgJOTEyZPnoyzZ8+axeh0Omi1WqhUKqhUKmi1Wly6dMks5syZM4iOjoaTkxM8PDwQHx+P+vr6Vj9PmxOdp556CkOGDMHZs2fx3Xff4bvvvkNpaSmGDh2KuXPntrU5IiIiupmmychSjzbYt28fnnvuOeTl5SE7OxuNjY0IDw9HXV2dGPP2229jxYoVWL16NQ4dOgS1Wo0JEyagpqZGjElISEBmZiYyMjKQk5OD2tpaREVFwWg0ijExMTEoKChAVlYWsrKyUFBQAK1WK143Go2YNGkS6urqkJOTg4yMDGzduhWJiYmtfh6FILRt9M7R0RGHDx/GkCFDzM4XFhZixIgRuHLlSlua65Kqq6uhUqmgO3E3XJzb/boxIlmL0Nzf0V0gumMahQbsxWfQ6/VwcXGxePtNvyd83vlfdHN0uP0Nt2C6chWlf3mt3X1t2j9v3759ePjhhyEIAjQaDRISEvDSSy8BuFa98fLywpIlS/D0009Dr9ejV69e2LRpE2bMmAEAOHfuHHx8fLBz505ERESgqKgIgwcPRl5eHoKDgwEAeXl5CA0NxY8//gg/Pz/s2rULUVFRKC0thUajAQBkZGRg9uzZqKysbNXztPm3rJ+fHyoqKpqdr6ysxL333tvW5oiIiOhmLLiPTnV1tdlhMBha1QW9Xg8AcHNzAwCUlJSgvLwc4eHhYoxSqcTo0aOxf/9+AEB+fj4aGhrMYjQaDfz9/cWY3NxcqFQqMckBgJCQEKhUKrMYf39/MckBgIiICBgMBuTn57eq/61KdK7/i0lJSUF8fDz+/e9/4+zZszh79iz+/e9/IyEhAUuWLGnVlxIREdHvy8fHR5wLo1KpkJqaett7BEHAggUL8OCDD8Lf3x8AUF5eDgDw8vIyi/Xy8hKvlZeXw97eHq6urreMaelNC56enmYxN36Pq6sr7O3txZjbadUyqZ49e5q93kEQBEyfPl081zT6FR0dbTb2RkRERBJYcMPA0tJSs6EepVJ521uff/55/PDDD8jJyWl27cbXPgmCcNtXQd0Y01J8e2JupVWJzldffdWqxoiIiMiCLLi83MXFpU1zdObPn4/PP/8cX3/9Nfr06SOeV6vVAK5VW7y9vcXzlZWVYvVFrVajvr4eOp3OrKpTWVmJkSNHijEtTYWpqqoya+fAgQNm13U6HRoaGppVem6mVYnO6NGjW9UYERERdW6CIGD+/PnIzMzE3r170a9fP7Pr/fr1g1qtRnZ2NoYNGwYAqK+vx759+8QpLIGBgbCzs0N2djamT58OACgrK0NhYSHefvttAEBoaCj0ej0OHjyIBx54AABw4MAB6PV6MRkKDQ3F4sWLUVZWJiZVu3fvhlKpbPXbGNq9w9/ly5dx5syZZmvZhw4d2t4miYiI6HodsGHgc889hy1btuCzzz6Ds7OzOBdGpVLB0dERCoUCCQkJSElJQf/+/dG/f3+kpKSge/fuiImJEWPnzJmDxMREuLu7w83NDUlJSQgICMD48eMBAIMGDcLEiRMRFxeHtWvXAgDmzp2LqKgo+Pn5AQDCw8MxePBgaLVaLF26FBcvXkRSUhLi4uJaXZ1qc6JTVVWFP/3pT9i1a1eL1zlHh4iIyEI6INFZs2YNACAsLMzs/Pr16zF79mwAwIsvvogrV65g3rx50Ol0CA4Oxu7du+Hs7CzGr1y5Era2tpg+fTquXLmCcePGYcOGDbCxsRFj0tPTER8fL67Omjx5MlavXi1et7GxwY4dOzBv3jyMGjUKjo6OiImJwbJly1r9PG3eR2fWrFk4deoUVq1ahTFjxiAzMxMVFRV48803sXz5ckyaNKktzXVJ3EeHugLuo0PW7HfbR2fZG5bZRyfpr3esr3LX5orOnj178Nlnn2HEiBHo1q0bfH19MWHCBLi4uCA1NZWJDhERkaVYcNVVV9XmckJdXZ247t3NzQ1VVVUArr3R/LvvvrNs74iIiLowhWCZoytr187ITS/3uv/++7F27Vr8+uuv+Pvf/262zIyIiIioo7V56CohIQFlZWUAgEWLFiEiIgLp6emwt7fHhg0bLN0/IiKirqsDJiNbmzYnOrNmzRL/PGzYMJw6dQo//vgj+vbtCw8PD4t2joiIiEiKdu+j06R79+4YPny4JfpCRERE11FA+hybrj0VuZWJzoIFC1rd4IoVK9rdGSIiIiJLalWic+TIkVY11toXbNE1Yf87Bzb20vZHIJIrN+R2dBeIOj8uL5eML/UkIiKSK05Glozb8hIREZHVkjwZmYiIiO4QVnQkY6JDREQkU5bY2Zg7IxMRERFZKVZ0iIiI5IpDV5K1q6KzadMmjBo1ChqNBqdPnwYArFq1Cp999plFO0dERNSlCRY6urA2Jzpr1qzBggUL8Mgjj+DSpUswGo0AgJ49e2LVqlWW7h8RERFRu7U50Xnvvfewbt06LFy4EDY2NuL5oKAgHD161KKdIyIi6sqaJiNLPbqyNs/RKSkpwbBhw5qdVyqVqKurs0iniIiICNwZ2QLaXNHp168fCgoKmp3ftWsXBg8ebIk+EREREcA5OhbQ5orOCy+8gOeeew5Xr16FIAg4ePAgPvzwQ6SmpuKf//znnegjERERUbu0OdH505/+hMbGRrz44ou4fPkyYmJi0Lt3b7zzzjuYOXPmnegjERFRl8QNA6Vr1z46cXFxiIuLw/nz52EymeDp6WnpfhERERH30ZFM0oaBHh4eluoHERERkcW1OdHp168fFIqbz+D+5ZdfJHWIiIiI/ssSy8NZ0WmbhIQEs88NDQ04cuQIsrKy8MILL1iqX0RERMShK8nanOj85S9/afH83/72Nxw+fFhyh4iIiIgsxWJvL4+MjMTWrVst1RwRERFxHx3JLPb28n//+99wc3OzVHNERERdHpeXS9fmRGfYsGFmk5EFQUB5eTmqqqrw/vvvW7RzRERERFK0OdGZOnWq2edu3bqhV69eCAsLw8CBAy3VLyIiIiLJ2pToNDY24q677kJERATUavWd6hMREREBXHVlAW2ajGxra4tnn30WBoPhTvWHiIiI/qtpjo7Uoytr86qr4OBgHDly5E70hYiIiMii2jxHZ968eUhMTMTZs2cRGBgIJycns+tDhw61WOeIiIi6vC5ekZGq1YnOn//8Z6xatQozZswAAMTHx4vXFAoFBEGAQqGA0Wi0fC+JiIi6Is7RkazViU5aWhreeustlJSU3Mn+EBEREVlMqxMdQbiWEvr6+t6xzhAREdFvuGGgdG2ao3Ort5YTERGRhXHoSrI2JToDBgy4bbJz8eJFSR0iIiIispQ2JTqvv/46VCrVneoLERERXacjhq6+/vprLF26FPn5+SgrK0NmZqbZWxFmz56NtLQ0s3uCg4ORl5cnfjYYDEhKSsKHH36IK1euYNy4cXj//ffRp08fMUan0yE+Ph6ff/45AGDy5Ml477330LNnTzHmzJkzeO6557Bnzx44OjoiJiYGy5Ytg729faufp02JzsyZM+Hp6dmWW4iIiKi9OmDoqq6uDvfddx/+9Kc/4bHHHmsxZuLEiVi/fr34+cbEIyEhAdu2bUNGRgbc3d2RmJiIqKgo5Ofnw8bGBgAQExODs2fPIisrCwAwd+5caLVabNu2DQBgNBoxadIk9OrVCzk5Obhw4QJiY2MhCALee++9Vj9PqxMdzs8hIiKyfpGRkYiMjLxljFKpvOmroPR6PT744ANs2rQJ48ePBwBs3rwZPj4++PLLLxEREYGioiJkZWUhLy8PwcHBAIB169YhNDQUxcXF8PPzw+7du3H8+HGUlpZCo9EAAJYvX47Zs2dj8eLFcHFxadXztHpn5KZVV0RERPQ7ESx0AKiurjY7pLzOae/evfD09MSAAQMQFxeHyspK8Vp+fj4aGhoQHh4untNoNPD398f+/fsBALm5uVCpVGKSAwAhISFQqVRmMf7+/mKSAwAREREwGAzIz89vdV9bneiYTCYOWxEREf2OLPmuKx8fH6hUKvFITU1tV58iIyORnp6OPXv2YPny5Th06BDGjh0rJk7l5eWwt7eHq6ur2X1eXl4oLy8XY1rKKTw9Pc1ivLy8zK67urrC3t5ejGmNNr8CgoiIiH4nFpyjU1paajbco1Qq29Vc0xsSAMDf3x9BQUHw9fXFjh07MG3atJt3479vUGjS0pSY9sTcTptf6klERESdj4uLi9nR3kTnRt7e3vD19cXJkycBAGq1GvX19dDpdGZxlZWVYoVGrVajoqKiWVtVVVVmMTdWbnQ6HRoaGppVem6FiQ4REZFcWXCOzp1y4cIFlJaWwtvbGwAQGBgIOzs7ZGdnizFlZWUoLCzEyJEjAQChoaHQ6/U4ePCgGHPgwAHo9XqzmMLCQpSVlYkxu3fvhlKpRGBgYKv7x6ErIiIimeqIfXRqa2vx008/iZ9LSkpQUFAANzc3uLm5ITk5GY899hi8vb1x6tQpvPLKK/Dw8MCjjz4KAFCpVJgzZw4SExPh7u4ONzc3JCUlISAgQFyFNWjQIEycOBFxcXFYu3YtgGvLy6OiouDn5wcACA8Px+DBg6HVarF06VJcvHgRSUlJiIuLa/WKK4CJDhEREV3n8OHDGDNmjPh5wYIFAIDY2FisWbMGR48excaNG3Hp0iV4e3tjzJgx+Oijj+Ds7Czes3LlStja2mL69OnihoEbNmwQ99ABgPT0dMTHx4ursyZPnozVq1eL121sbLBjxw7MmzcPo0aNMtswsC0UAteN/+6qq6uhUqlw3x8Xw8beoaO7Q3RHuK3P7eguEN0xjUID9uIz6PX6NlUXWqvp98TA+SmwUUr7PWE0XMWP771yx/oqd6zoEBERyRTfXi4dJyMTERGR1WJFh4iISK464F1X1oaJDhERkVwx0ZGMQ1dERERktVjRISIikinFfw+pbXRlTHSIiIjkikNXkjHRISIikikuL5eOc3SIiIjIarGiQ0REJFccupKMiQ4REZGcdfFERSoOXREREZHVYkWHiIhIpjgZWTomOkRERHLFOTqSceiKiIiIrBYrOkRERDLFoSvpmOgQERHJFYeuJOPQFREREVktVnSIiIhkikNX0jHRISIikisOXUnGRIeIiEiumOhIxjk6REREZLVY0SEiIpIpztGRjokOERGRXHHoSjIOXREREZHVYkWHiIhIphSCAIUgrSQj9f7OjokOERGRXHHoSjIOXREREZHVYkWHiIhIprjqSjomOkRERHLFoSvJOHRFREREVosVHSIiIpni0JV0THSIiIjkikNXkjHRISIikilWdKTjHB0iIiKyWqzoEBERyRWHriRjokNERCRjXX3oSSoOXREREZHVYkWHiIhIrgTh2iG1jS6MFR0iIiKZalp1JfVoi6+//hrR0dHQaDRQKBT49NNPza4LgoDk5GRoNBo4OjoiLCwMx44dM4sxGAyYP38+PDw84OTkhMmTJ+Ps2bNmMTqdDlqtFiqVCiqVClqtFpcuXTKLOXPmDKKjo+Hk5AQPDw/Ex8ejvr6+Tc/DRIeIiIhEdXV1uO+++7B69eoWr7/99ttYsWIFVq9ejUOHDkGtVmPChAmoqakRYxISEpCZmYmMjAzk5OSgtrYWUVFRMBqNYkxMTAwKCgqQlZWFrKwsFBQUQKvViteNRiMmTZqEuro65OTkICMjA1u3bkViYmKbnodDV0RERHJlwVVX1dXVZqeVSiWUSmWz8MjISERGRrbclCBg1apVWLhwIaZNmwYASEtLg5eXF7Zs2YKnn34aer0eH3zwATZt2oTx48cDADZv3gwfHx98+eWXiIiIQFFREbKyspCXl4fg4GAAwLp16xAaGori4mL4+flh9+7dOH78OEpLS6HRaAAAy5cvx+zZs7F48WK4uLi06vFZ0SEiIpIphckyBwD4+PiIw0QqlQqpqalt7k9JSQnKy8sRHh4unlMqlRg9ejT2798PAMjPz0dDQ4NZjEajgb+/vxiTm5sLlUolJjkAEBISApVKZRbj7+8vJjkAEBERAYPBgPz8/Fb3mRUdIiKiLqC0tNSsCtJSNed2ysvLAQBeXl5m5728vHD69Gkxxt7eHq6urs1imu4vLy+Hp6dns/Y9PT3NYm78HldXV9jb24sxrcFEh2Rp2F3noH3oewzUVKGXy2UkbY7AvqJ+4vUxg3/Bow8cxyDNefR0uopZq/+AE2UezdoJ8CnHsxMOwt+nEo3GbjhR5o6/pE2CofHaj35f90uIj8zDfX3LYWtjxM8VbliT/QDyS3oDAKKG/YhFf9jbYh/DU2Khq3O0/MMTtVFU7Hk8/mwV3DwbcPqEA/7+mgaFB3t0dLfIEiw4dOXi4tLq4Z7bUSgU5l8hCM3ONevGDTEtxbcn5naY6JAsOdo34kSZO7bl++HtWbubXXewb8QPp9X4T+E9ePXRfS22EeBTjndn78SGfcOwbPuDaDB2Q3/1BZiE3/4PsvLJnThzoSee/SAahkYbPDHyKFY+uQuPLo/BhdruyD56L3JP9jVrd9FjX8HetpFJDsnC6Mk6PPP6Oax+pTeOHXTCJO0FvJlegrgwP1T9at/R3SOJ5PauK7VaDeBatcXb21s8X1lZKVZf1Go16uvrodPpzKo6lZWVGDlypBhTUVHRrP2qqiqzdg4cOGB2XafToaGhoVml51a6zByd5ORkKBQKs6Ppf7AmrVkyd9ddd2HVqlVm9yQmJsLZ2Rl79uz5PR6lS9h/oi/+/uUD+Or43S1e31UwAP/8KggHf+p90zb+55H9+CjXH2lfD8MvlW4ovdATe47dgwajDQBA1f0K+npUI23fMPxU4Y7SCz2x+otgONo34m7PiwAAQ6MtLtR2Fw+jSYGgu3/FZ/mDLP/QRO0wbe55fPGhG7K2uKP0Jwf8fVFvVJ2zQ9STFzq6a2QJTfvoSD0spF+/flCr1cjOzhbP1dfXY9++fWISExgYCDs7O7OYsrIyFBYWijGhoaHQ6/U4ePCgGHPgwAHo9XqzmMLCQpSVlYkxu3fvhlKpRGBgYKv73GkrOlevXkVNTQ169erV6nuGDBmCL7/8UvxsY2Njdr1pydyGDRswYMAAvPnmm5gwYQKKi4vh7OzcrD2j0Yi4uDhs27YNe/bswYgRI9r/QGRRrk5XENC3Elnf98cHczPR270ap6t64v3sB/D96Wv/CtFfdsAvla6YNKwYP57zQIPRBtMeOI4LNY4oOtfyz9WkYSdwtcEWewpbTsCIfk+2dib0H3oZH602n+uQv88Zg4PqOqhX1NnV1tbip59+Ej+XlJSgoKAAbm5u6Nu3LxISEpCSkoL+/fujf//+SElJQffu3RETEwMAUKlUmDNnDhITE+Hu7g43NzckJSUhICBAXIU1aNAgTJw4EXFxcVi7di0AYO7cuYiKioKfnx8AIDw8HIMHD4ZWq8XSpUtx8eJFJCUlIS4urk1DcJ020amoqED//v3xyCOPIDY2FpMmTYK9/a3LtLa2ts2qOE1as2TuegaDAU888QQOHTqEr7/+GoMG3fxf+AaDAQaDQfx84xI/srzebtf+juPGHca7u0JRXOaBScOK8f6ft2Hmu9NReqEnAAWeXz8Jy/74Bfa99gFMggIX6xwRnzYJtVdbnqQ3OfBHfPHDveIcH6KO5OJmhI0tcOm8+c/jpSpbuHo2dlCvyJI6Yujq8OHDGDNmjPh5wYIFAIDY2Fhs2LABL774Iq5cuYJ58+ZBp9MhODgYu3fvNisIrFy5Era2tpg+fTquXLmCcePGYcOGDWYFhvT0dMTHx4ursyZPnmy2d4+NjQ127NiBefPmYdSoUXB0dERMTAyWLVvWpufptP+19vX1RW5uLjZu3Iinn34aJpMJMTExiI2NvWlJ6+TJk9BoNFAqlQgODkZKSgruvvvav8xvt2Tu+kSntrYWkyZNQmlpKb799lv07du32XddLzU1Fa+//roFnppaq9t//5+deXAwtn03EABwoswDI+75FZMDi/G33cEABLw0OQe6WgfErZsCQ6MtpgYVYYV2F2LXTMOFGiezNgN8ynG3lw6L/j32934colu6cWRCoUCXf2O11eiAt5eHhYVBuMVwl0KhQHJyMpKTk28a4+DggPfeew/vvffeTWPc3NywefPmW/alb9++2L59+237fCudeo5OYGAg3nnnHZw7dw7r169HWVkZRo0ahYCAACxbtsxsolNwcDA2btyIL774AuvWrUN5eTlGjhyJCxeujWPfasncjcvY3njjDRQUFOCbb765bZIDAC+//DL0er14lJaWSn10uo3zNd0BACWV5ssbT1W6Qq26tnvniLt/xYN+p7Hwown44Yw3is/1wpLPH4ahwQZRw040a3NK0I8oPueOH28yrEX0e6u+aANjI+Day7x6o/JohK6q0/47lsiiOnWi08TW1hbR0dH417/+hVOnTsHb2xsvvPCC2WZIkZGReOyxx8Qxwh07dgC4Njx1vdYsmQsPD0ddXR1SUlJa1T+lUiku67Pk8j66uXM6Z1RWd4dvr0tm5/t6XELZpWvlVQf7a78crl+FBQCCoIDihlqvo30Dxgf8zEnIJCuNDd1w8ofuGP5wjdn54Q/X4Phhp5vcRZ1JR7zrytpYRcovCAK++eYbbNq0Cf/617/g6uqK1157DXPmzLnpPU5OTggICMDJkycBtG7JXJNx48YhPj4eU6ZMgdFovGVpjtrH0b4BPu568bPGtRoDvM9Df1mJCr0zXByvQt2zFh7O1yZc+npcAgBcqLm2OgpQYPM392PuuMM4UeaOE2UeiBpeDN9el/DSh9eGJ38444WaK0okP7YH//wqEIYGW0wdUQSNaw2+LTav1E0I+Ak23UzIKuj/uzw/UWt98g8PvPBuKU784Iiiw0545I8X4Nm7ATs2und018gS+PZyyTp1onPixAls2rQJmzdvxvnz5/GHP/wBn376KUaPHn3bzYQMBgOKiorw0EMPATBfMjds2DAAvy2ZW7JkSbP7J0yYgO3btyM6OhomkwmrV69u0wZGdGuDeldi7VPbxM8LJuUCALZ/NwCvbx2LhweeMtvIL2XmtdV0//hPINbtubb67cP9Q2Fva8SCR/bDpbsBJ8vc8fz6KPx6UQUA0F92RHzaI3h2wkG8P2cbbLuZ8EulG5LSJ+Jkufnmg1MCf8TeY/1Qc5NJykQdZd/nrnB2NWLW/1TAzbMRp4sd8Oof+6GSe+gQAejEic6ZM2cwaNAghIWF4fXXX8djjz0GJ6ebl2qTkpIQHR2Nvn37orKyEm+++Saqq6sRGxsL4NqQ1e2WzN1o7Nix2LFjB6KioiAIAv72t78x2bGQ70p6Y8TCZ256ffuRgdh+ZOBt20n7ehjSvh520+tFv3oifkPUbduZ849HbxtD1FG2p3lge1rzncGp85PbhoGdUadNdDw8PFBSUtKqycAAcPbsWTzxxBM4f/48evXqhZCQEOTl5cHX11eMac2SuRuFhYVh586dmDRpEkwmE9asWcNkh4iILKMDVl1Zm06b6HTv3r3VSQ4AZGRk3DamNUvmTp061ezcww8/jJqamubBRERE1KE6baJDRERk7Th0JR0THSIiIrkyCdcOqW10YUx0iIiI5IpzdCSzig0DiYiIiFrCig4REZFMKWCBOToW6UnnxUSHiIhIrrgzsmQcuiIiIiKrxYoOERGRTHF5uXRMdIiIiOSKq64k49AVERERWS1WdIiIiGRKIQhQSJxMLPX+zo6JDhERkVyZ/ntIbaML49AVERERWS1WdIiIiGSKQ1fSMdEhIiKSK666koyJDhERkVxxZ2TJOEeHiIiIrBYrOkRERDLFnZGlY6JDREQkVxy6koxDV0RERGS1WNEhIiKSKYXp2iG1ja6MiQ4REZFccehKMg5dERERkdViRYeIiEiuuGGgZEx0iIiIZIqvgJCOQ1dERERktVjRISIikitORpaMiQ4REZFcCQCkLg/v2nkOEx0iIiK54hwd6ThHh4iIiKwWKzpERERyJcACc3Qs0pNOixUdIiIiuWqajCz1aIPk5GQoFAqzQ61WX9clAcnJydBoNHB0dERYWBiOHTtm1obBYMD8+fPh4eEBJycnTJ48GWfPnjWL0el00Gq1UKlUUKlU0Gq1uHTpUrv/qm6GiQ4RERGZGTJkCMrKysTj6NGj4rW3334bK1aswOrVq3Ho0CGo1WpMmDABNTU1YkxCQgIyMzORkZGBnJwc1NbWIioqCkajUYyJiYlBQUEBsrKykJWVhYKCAmi1Wos/C4euiIiI5MoEQGGBNtrI1tbWrIrTRBAErFq1CgsXLsS0adMAAGlpafDy8sKWLVvw9NNPQ6/X44MPPsCmTZswfvx4AMDmzZvh4+ODL7/8EhERESgqKkJWVhby8vIQHBwMAFi3bh1CQ0NRXFwMPz+/9j/vDVjRISIikqmmVVdSDwCorq42OwwGw02/9+TJk9BoNOjXrx9mzpyJX375BQBQUlKC8vJyhIeHi7FKpRKjR4/G/v37AQD5+floaGgwi9FoNPD39xdjcnNzoVKpxCQHAEJCQqBSqcQYS2GiQ0RE1AX4+PiI82FUKhVSU1NbjAsODsbGjRvxxRdfYN26dSgvL8fIkSNx4cIFlJeXAwC8vLzM7vHy8hKvlZeXw97eHq6urreM8fT0bPbdnp6eYoylcOiKiIhIriy4M3JpaSlcXFzE00qlssXwyMhI8c8BAQEIDQ3FPffcg7S0NISEhAAAFArz8TRBEJqda94N85iW4lvTTluxokNERCRXFlx15eLiYnbcLNG5kZOTEwICAnDy5Elx3s6NVZfKykqxyqNWq1FfXw+dTnfLmIqKimbfVVVV1axaJBUTHSIiIropg8GAoqIieHt7o1+/flCr1cjOzhav19fXY9++fRg5ciQAIDAwEHZ2dmYxZWVlKCwsFGNCQ0Oh1+tx8OBBMebAgQPQ6/VijKVw6IqIiEiuOuClnklJSYiOjkbfvn1RWVmJN998E9XV1YiNjYVCoUBCQgJSUlLQv39/9O/fHykpKejevTtiYmIAACqVCnPmzEFiYiLc3d3h5uaGpKQkBAQEiKuwBg0ahIkTJyIuLg5r164FAMydOxdRUVEWXXEFMNEhIiKSrw5YXn727Fk88cQTOH/+PHr16oWQkBDk5eXB19cXAPDiiy/iypUrmDdvHnQ6HYKDg7F79244OzuLbaxcuRK2traYPn06rly5gnHjxmHDhg2wsbERY9LT0xEfHy+uzpo8eTJWr14t8WGbUwhCF3/bVweorq6GSqXCfX9cDBt7h47uDtEd4bY+t6O7QHTHNAoN2IvPoNfrzSb4WkrT74nxAxbA1qZ1c2luptFowJcnVtyxvsod5+gQERGR1eLQFRERkVx1wBwda8NEh4iISK5MAqCQmKiYunaiw6ErIiIislqs6BAREckVh64kY6JDREQkWxZIdNC1Ex0OXREREZHVYkWHiIhIrjh0JRkTHSIiIrkyCZA89MRVV0RERETWiRUdIiIiuRJM1w6pbXRhTHSIiIjkinN0JGOiQ0REJFecoyMZ5+gQERGR1WJFh4iISK44dCUZEx0iIiK5EmCBRMciPem0OHRFREREVosVHSIiIrni0JVkTHSIiIjkymQCIHEfHFPX3keHQ1dERERktVjRISIikisOXUnGRIeIiEiumOhIxqErIiIislqs6BAREckVXwEhGRMdIiIimRIEEwSJbx+Xen9nx0SHiIhIrgRBekWGc3SIiIiIrBMrOkRERHIlWGCOThev6DDRISIikiuTCVBInGPTxefocOiKiIiIrBYrOkRERHLFoSvJmOgQERHJlGAyQZA4dNXVl5dz6IqIiIisFis6REREcsWhK8mY6BAREcmVSQAUTHSk4NAVERERWS1WdIiIiORKEABI3Uena1d0mOgQERHJlGASIEgcuhKY6BAREZEsCSZIr+hweTkRERGR6P3330e/fv3g4OCAwMBAfPPNNx3dpXZjokNERCRTgkmwyNEWH330ERISErBw4UIcOXIEDz30ECIjI3HmzJk79JR3FhMdIiIiuRJMljnaYMWKFZgzZw6eeuopDBo0CKtWrYKPjw/WrFlzhx7yzuIcnQ7QNDHMWH+1g3tCdOc0Cg0d3QWiO6YR136+7/RE30Y0SN4vsKmv1dXVZueVSiWUSqXZufr6euTn5+P//b//Z3Y+PDwc+/fvl9aRDsJEpwPU1NQAAAo/fqODe0JERFLU1NRApVJZvF17e3uo1WrklO+0SHs9evSAj4+P2blFixYhOTnZ7Nz58+dhNBrh5eVldt7Lywvl5eUW6cvvjYlOB9BoNCgtLYWzszMUCkVHd8fqVVdXw8fHB6WlpXBxceno7hBZHH/Gf3+CIKCmpgYajeaOtO/g4ICSkhLU19dbpD1BEJr9vrmxmnO9G2Nbur+zYKLTAbp164Y+ffp0dDe6HBcXF/4SIKvGn/Hf152o5FzPwcEBDg4Od/Q7buTh4QEbG5tm1ZvKyspmVZ7OgpORiYiICMC1IbPAwEBkZ2ebnc/OzsbIkSM7qFfSsKJDREREogULFkCr1SIoKAihoaH4xz/+gTNnzuCZZ57p6K61CxMdsnpKpRKLFi265Xg0UWfGn3GypBkzZuDChQv43//9X5SVlcHf3x87d+6Er69vR3etXRRCV38JBhEREVktztEhIiIiq8VEh4iIiKwWEx0iIiKyWkx0iIiIyGox0aEuJSwsDAqFwuyYOXOmWYxOp4NWq4VKpYJKpYJWq8WlS5fE66dOnYJCoUBBQYF4rqamBmFhYRg4cCBKS0t/p6ehriw5ObnZz7JarTaLEQQBycnJ0Gg0cHR0RFhYGI4dO2YWc9ddd2HVqlVm9yQmJsLZ2Rl79uz5PR6F6I5iokOdislkwq+//iqpjbi4OJSVlYnH2rVrza7HxMSgoKAAWVlZyMrKQkFBAbRa7U3bq6qqwpgxY1BbW4ucnJxm75Mhao2rV6+iqqqqTfcMGTLE7Gf56NGjZtfffvttrFixAqtXr8ahQ4egVqsxYcIE8X17NzIajZgzZw42btyIPXv2YOzYse1+HiK5YKJDncKPP/6Il19+GX379sWyZcsktdW9e3eo1WrxuH4b96KiImRlZeGf//wnQkNDERoainXr1mH79u0oLi5u1lZpaSkeeughODs746uvvoKHh4ekvlHXVVFRgd69e2Pq1KnIzMxs1TuObG1tzX6We/XqJV4TBAGrVq3CwoULMW3aNPj7+yMtLQ2XL1/Gli1bmrVlMBjw+OOPIzs7G19//TVGjBhh0ecj6ihMdEi2dDod1qxZg5CQEPj7+yM/Px9vvfUWFi9eLMakpKSgR48etzy++eYbs3bT09Ph4eGBIUOGICkpyexft7m5uVCpVAgODhbPhYSEQKVSYf/+/WbtFBcXY9SoURg4cCCysrLg7Ox8h/4mqCvw9fVFbm4ufH198fTTT0Oj0SA+Ph75+fk3vefkyZPQaDTo168fZs6ciV9++UW8VlJSgvLycoSHh4vnlEolRo8e3exnuba2FpMmTcKxY8fw7bffYtCgQZZ/QKIOwp2RSVZMJhN27dqFtLQ0fP755xgwYAC0Wi0yMzPh7e3dLP6ZZ57B9OnTb9lm7969xT/PmjUL/fr1g1qtRmFhIV5++WV8//334ntdysvL4enp2awNT0/PZi+5e/LJJzFy5Ehs3boVNjY27XlcIjOBgYEIDAzE8uXLsWvXLmzcuBGjRo1C//79ERsbC61WK75YMTg4GBs3bsSAAQNQUVGBN998EyNHjsSxY8fg7u4u/rze+CJGLy8vnD592uzcG2+8AWdnZxw/frzFn3+izoyJDsnKmTNnEBUVBVdXV2zZsgXTpk27Zbybmxvc3Nxa3X5cXJz4Z39/f/Tv3x9BQUH47rvvMHz4cACAQqFodp8gCM3OT5kyBZmZmdi6dettky2itrC1tUV0dDSio6NRXl6OJ598Ei+88ALOnj0rThyOjIwU4wMCAhAaGop77rkHaWlpWLBggXjtxp/bln6Ww8PD8eWXXyIlJcVsYjKRNeDQFclKnz598OGHHyI4OBgzZszAQw89hHXr1pmterpee4aurjd8+HDY2dnh5MmTAAC1Wo2KiopmcVVVVc3+ZfzKK69g0aJFmDVrFj766KP2PzTRDQRBwNdff424uDgMHDgQJ0+exGuvvWaWwNzIyckJAQEBZj/LAJpVIisrK5v9LI8bNw6ff/45/vGPf2D+/PkWfhqijsWKDsmKra0tZs6ciZkzZ6KsrAybNm3CqlWrMH/+fERHR0Or1SIyMhJ2dnYA2j50daNjx46hoaFBHBYLDQ2FXq/HwYMH8cADDwAADhw4AL1ej5EjRza7/9VXX4WtrS1mzZoFk8mEJ554or2PToQTJ05g06ZN2Lx5M86fP48//OEP+PTTTzF69OgWK43XMxgMKCoqwkMPPQQA4hBtdnY2hg0bBgCor6/Hvn37sGTJkmb3T5gwAdu3b0d0dDRMJhNWr1592+8k6hQEok7g0KFDwnPPPSe4u7sLCxYsaFcbP/30k/D6668Lhw4dEkpKSoQdO3YIAwcOFIYNGyY0NjaKcRMnThSGDh0q5ObmCrm5uUJAQIAQFRUlXi8pKREACEeOHBHPvf3224KNjY2wefPmdj8jdW2nT58WunXrJowdO1ZIS0sTamtrbxmfmJgo7N27V/jll1+EvLw8ISoqSnB2dhZOnTolxrz11luCSqUSPvnkE+Ho0aPCE088IXh7ewvV1dVijK+vr7By5Urx81dffSU4OTkJzz77rGAymSz+nES/NyY61KkYDAbh559/bte9Z86cER5++GHBzc1NsLe3F+655x4hPj5euHDhglnchQsXhFmzZgnOzs6Cs7OzMGvWLEGn04nXW0p0BEEQli9fLtjY2AgbN25sV/+oa6urqxNOnz7d6vgZM2YI3t7egp2dnaDRaIRp06YJx44dM4sxmUzCokWLBLVaLSiVSuHhhx8Wjh49ahZzY6IjCIKwb98+oUePHsLTTz/NZIc6PYUgCEJHV5WIiIiI7gRORiYiIiKrxUSHiIiIrBYTHSIiIrJaTHSIiIjIajHRISIiIqvFRIeIiIisFhMdIiIislpMdIiIiMhqMdEh6qKSk5Nx//33i59nz56NqVOn/u79OHXqFBQKBQoKCm4ac9ddd7XprdobNmxAz549JfdNoVDg008/ldwOEXUcJjpEMjJ79mwoFAooFArY2dnh7rvvRlJSEurq6u74d7/zzjvYsGFDq2Jbk5wQEckB315OJDMTJ07E+vXr0dDQgG+++QZPPfUU6urqsGbNmmaxDQ0N4pvcpVKpVBZph4hITljRIZIZpVIJtVoNHx8fxMTEYNasWeLwSdNw0//93//h7rvvhlKphCAI0Ov1mDt3Ljw9PeHi4oKxY8fi+++/N2v3rbfegpeXF5ydnTFnzhxcvXrV7PqNQ1cmkwlLlizBvffeC6VSib59+2Lx4sUAgH79+gEAhg0bBoVCgbCwMPG+9evXY9CgQXBwcMDAgQPx/vvvm33PwYMHMWzYMDg4OCAoKAhHjhxp89/RihUrEBAQACcnJ/j4+GDevHmora1tFvfpp59iwIABcHBwwIQJE1BaWmp2fdu2bQgMDISDgwPuvvtuvP7662hsbGxzf4hIvpjoEMmco6MjGhoaxM8//fQTPv74Y2zdulUcOpo0aRLKy8uxc+dO5OfnY/jw4Rg3bhwuXrwIAPj444+xaNEiLF68GIcPH4a3t3ezBORGL7/8MpYsWYK//vWvOH78OLZs2QIvLy8A15IVAPjyyy9RVlaGTz75BACwbt06LFy4EIsXL0ZRURFSUlLw17/+FWlpaQCAuro6REVFwc/PD/n5+UhOTkZSUlKb/066deuGd999F4WFhUhLS8OePXvw4osvmsVcvnwZixcvRlpaGr799ltUV1dj5syZ4vUvvvgCf/zjHxEfH4/jx49j7dq12LBhg5jMEZGV6OC3pxPRdWJjY4UpU6aInw8cOCC4u7sL06dPFwRBEBYtWiTY2dkJlZWVYsx//vMfwcXFRbh69apZW/fcc4+wdu1aQRAEITQ0VHjmmWfMrgcHBwv33Xdfi99dXV0tKJVKYd26dS32s6SkRAAgHDlyxOy8j4+PsGXLFrNzb7zxhhAaGioIgiCsXbtWcHNzE+rq6sTra9asabGt6/n6+gorV6686fWPP/5YcHd3Fz+vX79eACDk5eWJ54qKigQAwoEDBwRBEISHHnpISElJMWtn06ZNgre3t/gZgJCZmXnT7yUi+eMcHSKZ2b59O3r06IHGxkY0NDRgypQpeO+998Trvr6+6NWrl/g5Pz8ftbW1cHd3N2vnypUr+PnnnwEARUVFeOaZZ8yuh4aG4quvvmqxD0VFRTAYDBg3blyr+11VVYXS0lLMmTMHcXFx4vnGxkZx/k9RURHuu+8+dO/e3awfbfXVV18hJSUFx48fR3V1NRobG3H16lXU1dXByckJAGBra4ugoCDxnoEDB6Jnz54oKirCAw88gPz8fBw6dMisgmM0GnH16lVcvnzZrI9E1Hkx0SGSmTFjxmDNmjWws7ODRqNpNtm46Rd5E5PJBG9vb+zdu7dZW+1dYu3o6Njme0wmE4Brw1fBwcFm12xsbAAAgiC0qz/XO336NB555BE888wzeOONN+Dm5oacnBzMmTPHbIgPuLY8/EZN50wmE15//XVMmzatWYyDg4PkfhKRPDDRIZIZJycn3Hvvva2OHz58OMrLy2Fra4u77rqrxZhBgwYhLy8PTz75pHguLy/vpm32798fjo6O+M9//oOnnnqq2XV7e3sA1yogTby8vNC7d2/88ssvmDVrVovtDh48GJs2bcKVK1fEZOpW/WjJ4cOH0djYiOXLl6Nbt2vTDD/++ONmcY2NjTh8+DAeeOABAEBxcTEuXbqEgQMHArj291ZcXNymv2si6nyY6BB1cuPHj0doaCimTp2KJUuWwM/PD+fOncPOnTsxdepUBAUF4S9/+QtiY2MRFBSEBx98EOnp6Th27BjuvvvuFtt0cHDASy+9hBdffBH29vYYNWoUqqqqcOzYMcyZMweenp5wdHREVlYW+vTpAwcHB6hUKiQnJyM+Ph4uLi6IjIyEwWDA4cOHodPpsGDBAsTExGDhwoWYM2cOXn31VZw6dQrLli1r0/Pec889aGxsxHvvvYfo6Gh8++23+Pvf/94szs7ODvPnz8e7774LOzs7PP/88wgJCRETn9deew1RUVHw8fHB448/jm7duuGHH37A0aNH8eabb7b9fwgikiWuuiLq5BQKBXbu3ImHH34Yf/7znzFgwADMnDkTp06dEldJzZgxA6+99hpeeuklBAYG4vTp03j22Wdv2e5f//pXJCYm4rXXXsOgQYMwY8YMVFZWArg2/+Xdd9/F2rVrodFoMGXKFADAU089hX/+85/YsGEDAgICMHr0aGzYsEFcjt6jRw9s27YNx48fx7Bhw7Bw4UIsWbKkTc97//33Y8WKFViyZAn8/f2Rnp6O1NTUZnHdu3fHSy+9hJiYGISGhsLR0REZGRni9YiICGzfvh3Z2dkYMWIEQkJCsGLFCvj6+rapP0QkbwrBEoPmRERERDLEig4RERFZLSY6REREZLWY6BAREZHVYqJDREREVouJDhEREVktJjpERERktZjoEBERkdViokNERERWi4kOERERWS0mOkRERGS1mOgQERGR1fr/8Cu6o80Y0pkAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "from sklearn.metrics import ConfusionMatrixDisplay\n", "\n", @@ -312,9 +1251,26 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The recall of the dummy model is 0.0\n", + "The precision of the dummy model is 0.0\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/metrics/_classification.py:1565: UndefinedMetricWarning: Precision is ill-defined and being set to 0.0 due to no predicted samples. Use `zero_division` parameter to control this behavior.\n", + " _warn_prf(average, modifier, f\"{metric.capitalize()} is\", len(result))\n" + ] + } + ], "source": [ "from sklearn.metrics import precision_score\n", "from sklearn.metrics import recall_score\n", @@ -334,9 +1290,18 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The sensitivity of the dummy model is 0.0\n", + "The specificity of the dummy model is 1.0\n" + ] + } + ], "source": [ "from imblearn.metrics import sensitivity_score\n", "from imblearn.metrics import specificity_score\n", @@ -364,7 +1329,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -378,7 +1343,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -407,9 +1372,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Most Frequent Classifier
Test Accuracy: 75.94%
Balanced accuracy: 50.00%
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "dummy_clf = DummyClassifier(strategy='most_frequent')\n", "dummy_clf.name = \"Most Frequent Classifier\"\n", @@ -437,7 +1415,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ @@ -454,7 +1432,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -480,9 +1458,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Logistic Regression
Test Accuracy: 85.19%
Balanced accuracy: 76.56%
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "evaluate_classifier(model_lr)" ] @@ -496,9 +1487,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Logistic Regression with balanced weights
Test Accuracy: 80.71%
Balanced accuracy: 81.66%
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "model_lr_balanced = clone(model_lr)\n", "model_lr_balanced.set_params(\n", @@ -518,7 +1522,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -531,7 +1535,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -551,18 +1555,44 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Random Forest
Test Accuracy: 84.83%
Balanced accuracy: 77.03%
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "evaluate_classifier(model_rf)" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Balanced Random Forest
Test Accuracy: 84.35%
Balanced accuracy: 77.38%
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "model_rf_balanced = clone(model_rf)\n", "model_rf_balanced.set_params(\n", @@ -582,9 +1612,22 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Balanced Subsample Random Forest
Test Accuracy: 84.49%
Balanced accuracy: 77.51%
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "model_rf_subbalanced = clone(model_rf)\n", "model_rf_subbalanced.set_params(\n", @@ -613,7 +1656,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -623,7 +1666,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -637,9 +1680,34 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
Logistic Regression from rebalanced undersampled data
Test Accuracy: 80.78%
Balanced accuracy: 81.81%
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "evaluate_classifier(model_lr_undersampled)" ] @@ -653,7 +1721,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -662,7 +1730,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -676,9 +1744,34 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
Logistic Regression from rebalanced oversampled data
Test Accuracy: 80.72%
Balanced accuracy: 81.69%
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "evaluate_classifier(model_lr_oversampled)" ] @@ -695,7 +1788,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ @@ -704,7 +1797,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ @@ -718,9 +1811,32 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:474: FutureWarning: `BaseEstimator._validate_data` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation.validate_data` instead. This function becomes public and is part of the scikit-learn developer API.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/_tags.py:354: FutureWarning: The SMOTE or classes from which it inherits use `_get_tags` and `_more_tags`. Please define the `__sklearn_tags__` method, or inherit from `sklearn.base.BaseEstimator` and/or other appropriate mixins such as `sklearn.base.TransformerMixin`, `sklearn.base.ClassifierMixin`, `sklearn.base.RegressorMixin`, and `sklearn.base.OutlierMixin`. From scikit-learn 1.7, not defining `__sklearn_tags__` will raise an error.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
Logistic Regression from SMOTE sampled data
Test Accuracy: 80.76%
Balanced accuracy: 81.63%
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "evaluate_classifier(model_lr_smote)" ] @@ -748,7 +1864,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -765,9 +1881,648 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/imblearn/ensemble/_forest.py:577: FutureWarning: The default of `sampling_strategy` will change from `'auto'` to `'all'` in version 0.13. This change will follow the implementation proposed in the original paper. Set to `'all'` to silence this warning and adopt the future behaviour.\n", + " warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/imblearn/ensemble/_forest.py:589: FutureWarning: The default of `replacement` will change from `False` to `True` in version 0.13. This change will follow the implementation proposed in the original paper. Set to `True` to silence this warning and adopt the future behaviour.\n", + " warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/imblearn/ensemble/_forest.py:601: FutureWarning: The default of `bootstrap` will change from `True` to `False` in version 0.13. This change will follow the implementation proposed in the original paper. Set to `False` to silence this warning and adopt the future behaviour.\n", + " warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:474: FutureWarning: `BaseEstimator._validate_data` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation.validate_data` instead. This function becomes public and is part of the scikit-learn developer API.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/_tags.py:354: FutureWarning: The BalancedRandomForestClassifier or classes from which it inherits use `_get_tags` and `_more_tags`. Please define the `__sklearn_tags__` method, or inherit from `sklearn.base.BaseEstimator` and/or other appropriate mixins such as `sklearn.base.TransformerMixin`, `sklearn.base.ClassifierMixin`, `sklearn.base.RegressorMixin`, and `sklearn.base.OutlierMixin`. From scikit-learn 1.7, not defining `__sklearn_tags__` will raise an error.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/deprecation.py:151: FutureWarning: 'force_all_finite' was renamed to 'ensure_all_finite' in 1.6 and will be removed in 1.8.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:484: FutureWarning: `BaseEstimator._check_n_features` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_n_features` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/base.py:493: FutureWarning: `BaseEstimator._check_feature_names` is deprecated in 1.6 and will be removed in 1.7. Use `sklearn.utils.validation._check_feature_names` instead.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/_tags.py:354: FutureWarning: The BalancedRandomForestClassifier or classes from which it inherits use `_get_tags` and `_more_tags`. Please define the `__sklearn_tags__` method, or inherit from `sklearn.base.BaseEstimator` and/or other appropriate mixins such as `sklearn.base.TransformerMixin`, `sklearn.base.ClassifierMixin`, `sklearn.base.RegressorMixin`, and `sklearn.base.OutlierMixin`. From scikit-learn 1.7, not defining `__sklearn_tags__` will raise an error.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/_tags.py:354: FutureWarning: The BalancedRandomForestClassifier or classes from which it inherits use `_get_tags` and `_more_tags`. Please define the `__sklearn_tags__` method, or inherit from `sklearn.base.BaseEstimator` and/or other appropriate mixins such as `sklearn.base.TransformerMixin`, `sklearn.base.ClassifierMixin`, `sklearn.base.RegressorMixin`, and `sklearn.base.OutlierMixin`. From scikit-learn 1.7, not defining `__sklearn_tags__` will raise an error.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/_tags.py:354: FutureWarning: The BalancedRandomForestClassifier or classes from which it inherits use `_get_tags` and `_more_tags`. Please define the `__sklearn_tags__` method, or inherit from `sklearn.base.BaseEstimator` and/or other appropriate mixins such as `sklearn.base.TransformerMixin`, `sklearn.base.ClassifierMixin`, `sklearn.base.RegressorMixin`, and `sklearn.base.OutlierMixin`. From scikit-learn 1.7, not defining `__sklearn_tags__` will raise an error.\n", + " warnings.warn(\n", + "/Users/tristanwaddington/anaconda3/envs/DataCamp/lib/python3.11/site-packages/sklearn/utils/_tags.py:354: FutureWarning: The BalancedRandomForestClassifier or classes from which it inherits use `_get_tags` and `_more_tags`. Please define the `__sklearn_tags__` method, or inherit from `sklearn.base.BaseEstimator` and/or other appropriate mixins such as `sklearn.base.TransformerMixin`, `sklearn.base.ClassifierMixin`, `sklearn.base.RegressorMixin`, and `sklearn.base.OutlierMixin`. From scikit-learn 1.7, not defining `__sklearn_tags__` will raise an error.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/html": [ + "
Balanced Random Forest
Test Accuracy: 81.18%
Balanced accuracy: 82.51%
" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "evaluate_classifier(model_balanced_rf)" ] @@ -783,7 +2538,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ @@ -793,9 +2548,21 @@ }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "ename": "TypeError", + "evalue": "BaggingClassifier.__init__() got an unexpected keyword argument 'base_estimator'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[44], line 3\u001b[0m\n\u001b[1;32m 1\u001b[0m model_bagging \u001b[38;5;241m=\u001b[39m make_pipeline(\n\u001b[1;32m 2\u001b[0m preprocessor_rf,\n\u001b[0;32m----> 3\u001b[0m \u001b[43mBaggingClassifier\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 4\u001b[0m \u001b[43m \u001b[49m\u001b[43mbase_estimator\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mHistGradientBoostingClassifier\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 5\u001b[0m \u001b[43m \u001b[49m\u001b[43mn_estimators\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m10\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrandom_state\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;241;43m42\u001b[39;49m\n\u001b[1;32m 6\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 7\u001b[0m )\n\u001b[1;32m 8\u001b[0m model_bagging\u001b[38;5;241m.\u001b[39mname \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBagging Model\u001b[39m\u001b[38;5;124m\"\u001b[39m\n", + "\u001b[0;31mTypeError\u001b[0m: BaggingClassifier.__init__() got an unexpected keyword argument 'base_estimator'" + ] + } + ], "source": [ "model_bagging = make_pipeline(\n", " preprocessor_rf,\n", @@ -852,7 +2619,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "DataCamp", "language": "python", "name": "python3" }, @@ -866,7 +2633,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.6" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/09_trees_gradient_boosting/01-grow_a_tree.ipynb b/09_trees_gradient_boosting/01-grow_a_tree.ipynb index ff53af5..d898ad0 100644 --- a/09_trees_gradient_boosting/01-grow_a_tree.ipynb +++ b/09_trees_gradient_boosting/01-grow_a_tree.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -73,15 +73,13 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "from sklearn.datasets import make_blobs\n", "\n", - "X, y = make_blobs(\n", - " centers=[[0, 0], [1, 1]], random_state=61526, n_samples=100\n", - ")" + "X, y = make_blobs(centers=[[0, 0], [1, 1]], random_state=61526, n_samples=100)" ] }, { @@ -93,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -111,12 +109,12 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbcAAAGwCAYAAAAqkitTAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAT8VJREFUeJzt3Xt4U1W+P/53mja9QBsuLW2laXoBRUdwtKKAZqTejs7ggYkFFBlRO985jMrQFpkZ0BFQsP4USj063kaBwzAgpY14OY4zHG2hCjwDKIqKiLW0BUoviG2x92T9/mASmpK2SZqdnb3zfj1PHm2ym6ydlP3JWuuzPksjhBAgIiJSkRC5G0BERORrDG5ERKQ6DG5ERKQ6DG5ERKQ6DG5ERKQ6DG5ERKQ6DG5ERKQ6oXI3wJ9sNhtOnjyJ6OhoaDQauZtDREQeEEKgpaUFF110EUJC+u+bBVVwO3nyJAwGg9zNICKiQaipqUFSUlK/xwRVcIuOjgZw7o2JiYmRuTVEROSJ5uZmGAwGx7W8P0EV3OxDkTExMQxuREQK5c60EhNKiIhIdRjciIhIdRjciIhIdYJqzo2ISOlsNhs6OzvlboZkdDrdgGn+7mBwIyJSiM7OTlRWVsJms8ndFMmEhIQgNTUVOp1uUM/D4EZEpABCCNTW1kKr1cJgMPikdxNo7IU2amtrkZycPKhiGwxuREQK0N3djdbWVlx00UWIioqSuzmSiYuLw8mTJ9Hd3Y2wsDCvn0d9oZ+ISIWsVisADHq4LtDZz89+vt5icCMiUhC118X11flxWJIogFitVpSXl6O2thaJiYkwmUzQarVyN4tIcRjciAKExWJBTm4eaqqrHPcZko0oXFsAs9ksY8uIlIfDkkQBwGKxICsrC6d18UiYuxqG3G1ImLsap3XxyMrKgsVikbuJRIrC4EYkM6vVipzcPESmT0Ss+TGEjx6HEF0kwkePQ6z5MUSmT0RO3qJBT7ATAef+3srKyrBlyxaUlZX57e/qxRdfRGpqKiIiIpCRkYHy8nJJX4/BjUhm5eXlqKmuQsykWdBonP9JajQhiJk0EzVVxyS/GJD6WSwWjElLQWZmJubMmYPMzEyMSUuRfGRg69atyMnJwaOPPopPP/0UJpMJt99+O6qrqyV7TQY3IpnV1tYCAMLijC4fD4s1Oh1H5A370Pf4iDrsyY5Cy5Jo7MmOwvjIOsmHvgsKCpCdnY1f//rXuPTSS1FYWAiDwYCXXnpJstdkcCOSWWJiIgCgq6HK5eNdjVVOxxF5ymq1YlHuQkwbG4rtd0VgUlIohuo0mJQUiu2zIzDt4lA8kpcjyRBlZ2cnDhw4gFtvvdXp/ltvvRW7d+/2+evZMbgRycxkMsGQbETz3iII4VwzUAgbmvdug8GYApPJJFMLSenKy8txrPo4lprCENJrHVmIRoMl14WhsqpGkqHvxsZGWK1WxMfHO90fHx+PU6dO+fz17BjciGSm1WpRuLYAbRX70GhZiY4Th2HraEXHicNotKxEW8U+FBas4Xo38pp9SPvyUa7/huz3Szn03XtxthBC0gXpXOdGFADMZjOKi4vPrXPbtNhxv8GYgsLiYq5zo0GxD2l/UW/FpKQLL/tf1FudjvOl2NhYaLXaC3pp9fX1F/TmfIk9N6IAYTabUfldBUpLS7F582aUlpaisuJbBjYaNJPJhJTkJDz1URdsQjg9ZhMC+R93IdVokGToW6fTISMjAzt27HC6f8eOHZgyZYrPX8+OPTeiAKLVajF16lS5m0Eqo9VqsWbtc8jKysKMre1Ycl0YLh+lxRf1VuR/3IV3v+lGcXGhZEPfeXl5+NWvfoWrr74akydPxquvvorq6mrMnz9fktcDGNyIiIKCfeh7Ue5CTFl33HF/qtGA4uJCSUcIZs+ejdOnT+OJJ55AbW0tLr/8crz33nswGl0vf/EFjRC9+qgq1tzcDL1ej6amJsTExMjdHCIit7W3t6OystJR5cNbgV6cu7/z9OQazp4bEVEQCZahbyaUEBGR6jC4ERGR6jC4ERGR6jC4ERGR6jC4ERGR6jC4ERGR6jC4ERGR6jC4ERGR6jC4ERGRpHbt2oU77rgDF110ETQaDbZv3y75azK4EREFEavVirKyMmzZsgVlZWWS7L7d248//ogrrrgCL7zwguSvZafY4Jafnw+NRoOcnBy5m0JEpAgWiwWpaenIzMzEnDlzkJmZidS0dFgsFklf9/bbb8fKlSv9un2TIoPbvn378Oqrr2LChAlyN4WISBEsFguysrJwWhePhLmrYcjdhoS5q3FaF4+srCzJA5y/KS64nT17Fvfccw/+8pe/YPjw4f0e29HRgebmZqcbEVGwsVqtyMnNQ2T6RMSaH0P46HEI0UUifPQ4xJofQ2T6ROTkLfLLEKW/KC64PfTQQ/jFL36Bm2++ecBj8/PzodfrHTeDweCHFhIRBZby8nLUVFchZtIsaDTOl32NJgQxk2aipuoYysvLZWqh7ykquL3xxhv45JNPkJ+f79bxS5YsQVNTk+NWU1MjcQuJiAJPbW0tACAszvXmoGGxRqfj1EAx+7nV1NRg4cKF+Oc//+n2Rn3h4eEIDw+XuGVERIEtMTERANDVUIXw0eMueLyrscrpODVQTM/twIEDqK+vR0ZGBkJDQxEaGoqdO3fiv//7vxEaGqqqsWIiIl8ymUwwJBvRvLcIQticHhPChua922AwpsBkMkny+mfPnsXBgwdx8OBBAEBlZSUOHjyI6upqSV4PUFDP7aabbsKhQ4ec7rv//vsxbtw4/OEPfwiobdKJiAKJVqtF4doCZGVlodGyEjGTZiIs1oiuxio0792Gtop9KCwuluw6un//fmRmZjp+zsvLAwDMmzcPGzZskOQ1FRPcoqOjcfnllzvdN2TIEIwcOfKC+4mIyJnZbEZxcTFycvNQs2mx436DMQWFxcWSrkGbOnUqhBCSPb8rigluREQ0OGazGdOnT0d5eTlqa2uRmJgIk8mkypEvRQe3srIyuZtARKQoWq0WU6dOlbsZklNMQgkREZG7GNyIiEh1GNyIiBTE34kZ/uar82NwIyJSAHvSR2dnp8wtkZb9/Aab5KLohBIiomARGhqKqKgoNDQ0ICwsDCEh6uub2Gw2NDQ0ICoqCqGhgwtPDG5ERAqg0WiQmJiIyspKVFVVyd0cyYSEhCA5ORkajWZQz8PgRkSkEDqdDmPHjlX10KROp/NJr5TBjYhIQUJCQtwuHh/M1DdoS0REQY/BjYiIVIfBjYiIVIfBjYiIVIfBjYiIVIfBjYiIVIfBjYiIVIfBjYiIVIfBjYiIVIfBjYiIVIflt4jILVarFeXl5aitrUViYiJMJtOgtyUhkgqDGxENyGKxICc3DzXV56vRG5KNKFxbALPZLGPLiFzjsCQR9ctisSArKwundfFImLsahtxtSJi7Gqd18cjKyoLFYpG7iUQX0Ai171neQ3NzM/R6PZqamhATEyN3c4gCntVqRWpaOk7r4hFrfgwazfnvw0LY0GhZiZFd9ais+JZDlCQ5T67h7LkRUZ/Ky8tRU12FmEmznAIbAGg0IYiZNBM1VcdQXl4uUwuJXGNwI6I+1dbWAgDC4owuHw+LNTodRxQoGNyIqE+JiYkAgK6GKpePdzVWOR1HFCgY3IioTyaTCYZkI5r3FkEIm9NjQtjQvHcbDMYUmEwmmVpI5BqDGxH1SavVonBtAdoq9qHRshIdJw7D1tGKjhOH0WhZibaKfSgsWMNkEgo4XOdGRP0ym80oLi4+t85t02LH/QZjCgqLi7nOjQISlwIQkVtYoYTk5sk1nD03InKLVqvF1KlT5W4GkVs450ZERKrD4EZERKrD4EZERKrD4EZERKrD4EZERKrDbEkikhSXEJAcGNyISDLc5JTkwmFJIpIENzklObFCCRH5HDc5JSlws1IikhU3OSW5MbgRkc9xk1OSm2KC20svvYQJEyYgJiYGMTExmDx5Mv7+97/L3SwicoGbnJLcFBPckpKS8PTTT2P//v3Yv38/brzxRkyfPh1ffvml3E0jol64ySnJTdEJJSNGjMCzzz6L7Oxsl493dHSgo6PD8XNzczMMBgMTSoj8wJ4tGZk+ETGTZiIs1oiuxio0792Gtop9KOZecOQh1SeUWK1WvPHGG/jxxx8xefLkPo/Lz8+HXq933AwGgx9bSRTc7Jucjuysw6lNi1FTOAunNi3GyK56BjaSnKJ6bocOHcLkyZPR3t6OoUOHYvPmzfj5z3/e5/HsuRHJjxVKyFc86bkpKrh1dnaiuroaP/zwA0pKSvDaa69h586duOyyy9z6fa5zIyJSLtUGt95uvvlmpKen45VXXnHreAY3IiLlUv2cm50QwmnYkYiICFBQ4eSlS5fi9ttvh8FgQEtLC9544w2UlZXh/fffl7tpREQUYBQT3Orq6vCrX/0KtbW10Ov1mDBhAt5//33ccsstcjeNiIgCjGKC2+uvvy53E4iISCEUE9yIpMA0dSJ1YnCjoMWNNInUS9HZkkTe4kaaROqm6HVunuI6NwK4kSaRUgXNOjcib/hiI02r1YqysjJs2bIFZWVlsFqtUjebiDzAOTcKOoPdSJNzdUSBjz03CjqD2UiTc3VEysA5Nwo63s65ca6OSF6ccyPqh1arReHaArRV7EOjZSU6ThyGraMVHScOo9GyEm0V+1BYsOaCAOWLuToi8g/OuVFQsm+kmZObh5pNix33G4wpKOxjI83BztURkf8wuFHQMpvNmD59utsVSnrO1YWPHnfB4/3N1RGRf3HOjchNnHMjkhfn3Igk4O1cHRH5H4cliTzgzVwdEfkfhyWJvMDdBIj8z5NrOHtuRF7QarWYOnWq3M0goj5wzo2IiFSHwY2IiFSHwY2IiFSHwY2IiFSHCSVEFLCYlUreYnAjooDEffNoMDgsSUQBh/vm0WBxETcRBRTW8KS+sLYkESkW980jX2BwI6KAwn3zyBcY3IgooPTcN88V7ptH7mBwI6KAYjKZYEg2onlvEYSwOT0mhA3Ne7fBYEyByWSSqYWkBAxuRBRQuG8e+QLXuRFRwOG+eTRYXApARAGLFUqoJ+7nRkSqwH3zyFuccyMiItVhcCMiItVhcCMiItVhcCMiItVhcCMiItVhcCMiItVhcCMiItXhOjeiXrhwmEj5GNyIerBYLOdKPlWfr0hvSDaicG0BSz4RKYhihiXz8/MxceJEREdHY9SoUZgxYwaOHDkid7NIRSwWC7KysnBaF4+EuathyN2GhLmrcVoXj6ysLFgsFrmbGHCsVivKysqwZcsWlJWVwWq1yt0kIgAKqi1522234a677sLEiRPR3d2NRx99FIcOHcJXX32FIUOGuPUcrC1JfbFarUhNS8dpXTxizY857QAthA2NlpUY2VWPyopvOUT5b+zlkr95cg1XTHDrraGhAaNGjcLOnTvxs5/9zK3fYXCjvpSVlSEzMxMJc1cjfPS4Cx7vOHEYpzYtRmlpKWsd4nwvNzJ9ImImzUJYnBFdDVVo3luEtop9KGblfpKAJ9dwxQxL9tbU1AQAGDFiRJ/HdHR0oLm52elG5EptbS0AICzO6PLxsFij03HBzGq1Iic3D5HpExFrfgzho8chRBeJ8NHjEGt+DJHpE5GTt4hDlCQrRQY3IQTy8vJw/fXX4/LLL+/zuPz8fOj1esfNYDD4sZWkJImJiQCAroYql493NVY5HRfMysvLUVNdhZhJs5yGbwFAowlBzKSZqKk6hvLycplaSKTQ4Pbwww/j888/x5YtW/o9bsmSJWhqanLcampq/NRCUhqTyQRDshHNe4sghM3pMSFsaN67DQZjCkwmk0wtDBzs5ZISKG4pwIIFC/D2229j165dSEpK6vfY8PBwhIeH+6llpGRarRaFawuQlZWFRstKxEyaibBYI7oaq9C8dxvaKvahsLiYySRw7uW6mp+UopfLtYfkKcUklAghsGDBArz55psoKyvD2LFjPX4OJpTQQFxmABpTUFiwhgkS/+bvzFJmZZKdLNmSZ86cwTvvvIN7773XF093gQcffBCbN2/GW2+9hUsuucRxv16vR2RkpFvPweBG7mAvYWDO2ZIX9nJ9lS3JrEzqSZbg9tlnn+Gqq66SLENKo9G4vH/9+vW477773HoOBjci35G6l8u1h9SbJ9dwt+fcBkqjb2lpcfepvKKQ0VOioGE2mzF9+nTJern2rMyEuQv6zsrctBjl5eVce0gXcDu4DRs2rM/eE3Au+PT3OBEpW1/DtVIFFmZl0mC4Hdyio6Px6KOP4tprr3X5+NGjR/Ff//VfPmsYkdQ4t+Y+OZI65MjKJPVwO7hdddVVAIAbbrjB5ePDhg3j0CEpBjPw3NczqSNh7gJHUsfpvUXIysqSLKnDvvbw9N4il3NuXHtI/XF7EfecOXMQERHR5+MJCQlYtmyZTxpFJCVW/3efnKW27GsP2yr2odGyEh0nDsPW0YqOE4fRaFl5bu1hwRr2tsklxaxz8wVmSxIz8DwTCAWlufaQ7IKicDKRN1gX0TOBkNRhNptR+V0FSktLsXnzZpSWlqKy4lsGNuqXV+W3Hn74YTzxxBP9VuQnCkSBcLFWkkBJ6pAyK5PUye2e2/Hjxx3/v3nzZpw9exYAMH78eBYkJsVg9X/PsKA0KZXbwW3cuHEwGo2YM2cO2tvbHQHt2LFj6OrqkqyBRL7Ei7VnmNRBSuV2cGtqasK2bduQkZEBm82Gn//857j44ovR0dGBf/zjHzh16pSU7STyCV6sPWc2m1FcXIyRnXU4tWkxagpn4dSmxRjZVc/ajhSw3M6WbG9vdywFGD58OA4cOIDa2lrcfPPNuPzyy/HVV18hKSkJR44ckbTBg8FsSbJTQgZeoC0yD7T2UPCRpLZkTEwMrrzySlx33XXo7OxEa2srrrvuOoSGhmLr1q1ISkrCv/71r0E3nsgfpK6LOFgWiwWLchfiWPX5ue6U5CSsWfucbMGXSR2kJG4Ht5MnT2LPnj3YvXs3uru7cfXVV2PixIno7OzEJ598AoPBgOuvv17KthL5lDsXazl6K/ZF5tPGhmJLdhQuH6XFF/VWPPVRnaQVQYjUxKtF3MOHD8euXbtw+PBh3HvvvUhISEBdXR2uueYa7Ny5U4p2+gSHJckTcvSerFYrxqSlYHxEHbbfFYGQHsXIbUJgxtZ2fNGegKMVlQHTyyTyF78s4tbr9Zg1axbCwsLw4YcforKyEg8++KC3T0cUUOy9p/ERddiTHYWWJdHYkx2F8ZF1kpboKi8vx7Hq41hqCnMKbAAQotFgyXVhqKyq4SJzogF4tYj7888/x+jRowEARqMRYWFhSEhIwOzZs33aOCI5WK1WLMpdiGljQ516T5OSQrF9thYztrbjkbwcTJ8+3ee9J/vi8ctHuX5e+/3+XGSu9kQStZ9fsPKq52YwGBAScu5Xv/jiCxgMBp82ikhOcvae7IvHv6h3XYjYfr+/FplbLBakpqUjMzMTc+bMQWZmJlLT0lVTXNpisWBMWorT+Y1JS1HN+QUz1pYk6kXO3pPJZEJKchKe+qgLtl7T4TYhkP9xF1KNBr8sMh9o94QnnngCW7ZsQVlZmSS7AkhNrqFn8g/uCkCDprZhHXsl/D3ZUZiUdOHI/Z6abkxZ1ypZJXxHtuTFoVhyXZgjWzL/4y68+033oLMl3fm8Bto9oaHkSbR99wkgzgU1pe2Fx8QdZeKuAOQ3ahzWkbv3ZK8IcqgtHlPWtSLm6RZMWdeKL9oTBh3Y3P28Bto9QT95FiCsiMtarsi98Ji4o34MbuQ1tQ7raLVarFn7HN79phsztrZjT003WjoE9tSc+/ndb7qxuqBQ0m/0ZrMZ3353zGmbl6MVlYMObO5+Xu7uniA6fvTLxqW+FoiJO+RbDG7kld4ZhZOSQjFUp/l3RmEEpl0cikfychRxoXNFyt6Tu+yLzO+++25MnTp1UMHU08/L3d0TtEOHA5BvLzyr1YqysjKP5/4CLXGHfM+r4PbXv/4V1113HS666CJUVZ37Iy8sLMRbb73l08ZR4AqGYR0pek/eXowHy9PPa6DdE5r2bkOoPh7hST9x3N9zLzx/nOdgMjnlHnom6Xm8zu2ll17C448/jpycHKxatcrxRzts2DAUFhZi+vTpPm8kBR5vh3WUlnziTT3Fvs7RZbFmPyViePp52XdPyMrKQqNlJWImzURYrBFdjVVo2rMNbRX7EDdjCTQh55/P3ps7evQoUtPSLzjPgjWrERsb65PP3j7EGpk+EQlzFyAszoiuhiqc3lvkVoky+9BzVlYWZmxt7yNxR9qhZ5KY8NCll14q3nzzTSGEEEOHDhUVFRVCCCEOHTokRo4c6enT+VVTU5MAIJqamuRuiuKVlpYKAGJPdpQQy2IuuO1+IEoAEKWlpY7fKSkpEYZkowDguBmSjaKkpES+E/GxkpISkZKc5HSOKclJYvHixUKj0YioMdeIhLmrhSF3m0iYu1pEjblGaDQayd8Dbz4v+/n0/sw0ukgRO+OPwviHdx235N+/LaLGXCNi40YJAC7Ps+dzDOaz7+7uFoZko4gac41I/v3bLtthMKaI7u7uAZ/L1eeVajSo6m9STTy5hnu8FCAyMhJff/01jEYjoqOj8dlnnyEtLQ1Hjx7FhAkT0NbWNuiAKxUuBfAdRyp1ZB22zx44lbrnN+2YSbMc37Sb9xahrWKf4ooBu+qdvfXWW46Cx0tN53sCq8o78e63AlFpGS7T6hstKzGyqx6VFd9K1lPw9PPq61yPHj2KZcuWIWrMNU69uea953pzI0bGom1Yap/LBzrrvkNi9p/Rffq415+9falGwtzVCB897oLHO04cxqlNi91eqqG00YRgJulSgNTUVBw8ePCC+//+97/jsssu8/TpSKE8ySi0Wq3Iyc1DZPpExJofQ/jocQjRRSoyyw5wPdeTkpaO+f/1G5cJG7mTwgCbtc+0en8kYgwmA7RnYsvjjz+OkpISlxuXLl++HKcbG/pdPmA9expd9d8N6rN3N5PT3UxHXybuUODwOLgtXrwYDz30ELZu3QohBP71r39h1apVWLp0KRYvXixFGylAuZtRONCaKSku7lIlNPRVteN7XTwaGk9jikFzQcJG3dlz//XVxdhbvsoANZvNqPyuwinRprLiW4wdOxbAwOdpPXsGgPefvbuZnMx0DG4eJ5Tcf//96O7uxu9//3u0trZizpw5GD16NJ577jncddddUrSRfECqoRd3Nv309TftgUi1VY3VasVv5v8WEWlXOw272XshDSVP4s/7P8XiKQLakPMBLjH63P93NVS5HEbz58XYV5u0ukq06Rl0+jtP+/IBwLvP3p7JeXpvkcvhz+a922AwpjDTMch51HPr7u7G//zP/+COO+5AVVUV6uvrcerUKdTU1CA7O1uqNtIgSV1FZKBhHX9+05ZyYfmqVatwuqEe+smz+xx2O97UjfJq516iKVmLUUO1aNqz1WVavb8vxlIMw1mtVlitVowYGYszH74Gm7XL6fG+lg9489nbMznbKvah0bISHScOw9bRio4Th9FoWYm2in0oLFjD4cUg53FCSVRUFA4fPgyj0fW38EAWjAklPXd17pnk8NRHvqlT6I6B6hT6KqFCynqBVqsVo+IT8P3pRhhytyFEF3nBMbaOVtQUzsImcwTuGa9zeu1rX2vF/pPWPhMx/FEvUiquljhowiKgnzwL0VdN+/fygSK0VexH3IwliLpkCoDBf/Yul1YYU1BYsEZRyUnkPk+u4R4PS1577bX49NNPFRncgo2c+5L11N+aKfvFvbC4eNBtsC9U3pId1edC5Snrzi1U9nTtWnl5Ob4/3Qhg4GG3P+/rQtqwEKd1UwdqbVi8eDHe2FqEmk3n56YNxhQU+qBepL93DO/52q7WmzXt2Yofdm3ED7s2njtQE4Kw+DRohw6HraPVJ5+9r4ZYSZ08Dm4PPvggFi1ahOPHjyMjIwNDhgxxenzChAk+axwNjpQXe0/ZkxlycvN8fnG3k7JeoGNxc8woNO0tQpyLHmjTniJEx+hxEkMxZd0Jx2OpRgOKiwthNpuRn5/v04txz575luyoHj3zOrcWMw9G7yzYnnOQQ8bfhPbqQxBd7ecOFjZYT1fjlI8/e28W2VNw8Di42Xfb/t3vfue4T6PRQAgBjUajmHTuYBBoxWGl/qbds16gq61qBlMv0P470T+9HT/s2ogGy0roXVTtWLZsGf70pz/1eY6+vBjL3TO3Z8EmzF3gFOhbj+xG4/b/D5HpE6GfPMupN9dWsQ/Tpk3DokWL2MsiSXkc3CorK6VoB0lAyou9t6T8pn2+XmAdts/WXjDnNph6gY4MvZOHETvjDzhTut6pF6IJiwQQgg3rXsOECRP8Mucjd8/cVRassFnxfenriBwz0al3Gz56HOLu/BMaSp7Eu+/9Hffeey8DG0nK4+DGuTblkPJiH4h61guc/kYbbkvXIjJMg7YugfcrrPjfo1av6wX2nDcEgNhf5MHW0YrOU0fRXnkAHSePIP8mHXYfr5d8ONBO7p65q9T/juNfwtpUB/0di/vMKG2r2IeHFiyA2WxmgCPJeBzcNm7c2O/j9957r9eNId8KxuKwZrMZjzzyCAoKn8O733Q47g8N0+GRR3IHFXDs84YLc/NwfPMfHPcbhoWicFYkzJeGObIy/ZGoI3fP3NV6M/sC7YHWNDbU1XnUo2SJLPKUx0sBhg8f7vRzV1cXWltbodPpEBUVhe+//96nDfSlYFwKALjOpks1GrC6oFB1KdP+qGH5wQcf4Oabb8aKqTr8zBgKU7LWadH2nppuTFnX6nZtQ28Npl6krzi/3zNhbTuLhpIVfdZ9bK/5EnX//mLw2GOPYfny5QO2Tc5sUAosktaWPHPmjNPt7NmzOHLkCK6//nps2bLF60aTdKTYlywQ+auGZX19PQAgb3I4pqaEOgU2wH+JOoGyY3hxcbGj1mRDyQpAE+JywfqPRz5C/bZljp9Xrlw54P5rat3tnaTncc+tL/v378fcuXPx9ddf++LpJBGsPbdg4etq8QO9zp7sKJfDgf7qudkFQs/carXi+eefR25uLoaMvwU/HtpxPlsy1oiWT97FD7s2/vu+2W71qKVclE/K5Mk13GfB7dNPP8UNN9yA5uZmXzydJBjc1MPVHExRURHmzJkzYAWRzZs34+677x7Ua8s9HOiqTXLPSfWsRKMdMRot+94GxL97yZoQRKZlIO7OP7ldoSbQvkSQ/CStUPL22287/SyEQG1tLV544QVcd911nj6dR3bt2oVnn30WBw4cQG1tLd58803MmDFD0tekwNPXjta/zn4AgPQFigMxUcedJRZSB8CeGaWRAPTX342WA+/A1toECFufNTljJs1EzabFFySYuMoGtdoEyqutqG0R0Ic7H0fUk8fBrXcw0Wg0iIuLw4033og1a9b4ql0u/fjjj7jiiitw//33484775T0tSgw9VXu6fTeIixfvhwjY+PQ7Idq8fa5pkW5CzFlnfNwoL0aSSDxV1KGUyWa8n85PebprhC9s0Eth7uQ888u1PzQff4gTQiOHj3qs/aTevhsWNLfNBqNxz03DksqmzsFmKOajqGxoV6yAsWu2iT3cOBAPCme7avzsVqtWLVqFZ777+cdNTk9nQvtOfx77wQtZm1rR+SYiYiZNNup6kn7d/sDZid3Jfw9KJmkc25PPPEEHnnkEURFRTnd39bWhmeffRaPP/645y32gjvBraOjAx0d59c6NTc3w2AwMLgplLsJIytWrMBrr69jtXh4lpTx1ltvuRzuLVxb4PH71rOHHX1NFhrfXQ1dXAri7vRsVwiLxYI777wTkTotNIarEOvBnJ2/9TVc7s37R65JuhRgxYoVOHv27AX3t7a2YsWKFZ4+naTy8/Oh1+sdN4PBIHeTaBDc3fR07NixLneKDsYLjL1E11JTWJ8luiqrarBq1SqXO4yf1sV7nHLfe0lGhOEyjLjx12ir2IeGEs/2XzObzVixYgXaOq2IcTFnByEQnnIVaqqO4fnnn5ettm1fO7R78/6Rb3gc3OwFknv77LPPMGLECJ80yleWLFmCpqYmx62mpkbuJtEgeLLpqRQbcgYCq9WKsrIybNmyBWVlZQNezN0t0fXfz7/gs/WB9oLKMZNmOYJR1CVTEDdjCTobq3Bq02LUFM7CqU2LMbKrfsAhxbFjxwK48EtN65HdOPHqb3Dm/14GAOTm5g64bk4K/lpfSZ5xO7gNHz4cI0aMgEajwcUXX4wRI0Y4bnq9HrfccgtmzZolZVs9Fh4ejpiYGKcbKZe93FPz3qKA2NHa3ywWC1LT0p12VB/oYt4zKcMV+/2nGxucgpGdI5ux6hjKy8vdamdfPeyoS6Zg9G9eRdyd5xZyP/bYY271qF19qWk9shsN2/OhizPK3lNyFcztvHn/yDfczpYsLCyEEAIPPPAAVqxYAb1e73hMp9MhJSUFkydPlqSRJJ9AmiD316angai/LNH+CjW7Uzw7LnYEGhq/H3C498SJEygrKxvwb8FVQWU7TYgW2sihAICbbrrJrc+qdw1LCNHnzgOx5sfQaFmJnLxFktf2tHN3uJxLFvzL44SSnTt3YsqUKQgLC5OqTX06e/Ysvv32WwDAlVdeiYKCAmRmZmLEiBFITk4e8PeZLemZQK3p53LiXsUJI+5kifaXUOHIlrw41OWavOXLl2PZsmUDJurExSegoe6U4/6+kiUG215Xegb38JSrcOb/Xpa8Eo27/FUZh/xYoaStrQ1dXV1O90kZNOx/RL3NmzcPGzZsGPD3Gdzc50n6uBwCqUcpNV9cPPsr0TV9+vQ+g5HN2oXa1x9G95kT/15e4V4x6t4FlX2xJKP3lxqpK9G4S4pgTq5JGtxaW1vx+9//HkVFRTh9+vQFjwfypCmDm3tY0y+wbNmyxSdlxfr7QuAqGLV88i5+2L0VsHZ5XDrL/py+7mH3rGEZSD0lKYI5XUjSpQCLFy/Ghx9+iBdffBHh4eF47bXXsGLFClx00UUD7vVGyuBu+rgSJ8g9zTYMBJ5kifanvwzS3tX9awpn4YddG6EblTJw6aw+kiXMZrPPl2RotVosWLAg4BKLXL1/7maDkjQ8Lr/1zjvvYOPGjZg6dSoeeOABmEwmjBkzBkajEX/7299wzz33SNFO8iO5d3iWSqDOIQ7E1aagdr68mJvNZkyfPh1lZWWYfdfdaBuWishxJpw+ecTrZAl3al56KlATi+zvX7AMlwc6j3tu33//PVJTUwGcm1+zb056/fXXY9euXb5tHcnC3fRxqXZ4loKS9wWzX8zbKvah0eLZImhvXkur1TqWBoRGjwQw+F6jr/mipyRFL16t6yuVyOPglpaWhmPHjgEALrvsMhQVFQE416MbNmyYL9tGMjmfPt4FW68pWXv6eKrRoJj1ZFarFYtyF2La2FBsvysCk5JCMVSnwaSkUGyfHYFpF4fikbycgB6i9OewV8/U9vCkn0Crj0dTAA0B2g1m2NObNYOkLB4nlKxduxZarRa/+93vUFpail/84hewWq3o7u5GQUEBFi5cKFVbB40JJe4bKH1cSfMIatoXzB9Zor2zM+0Lps9tNKr8ZAnn5A/3sj8pMPh1s9Lq6mrs378f6enpuOKKKwbzVJJjcPNMIOzw7Av2bMOWJdEYqruwdFxLh0DM0y1+Sx13JZCWNvRObW/7Zi9O//PPsLW1AD16b7Fxo/DKyy8p6m+BafvKJulmpT21t7cjOTnZrQXUpDxqmSDvvS9Yb/6cQ3QVxHxZjd8XeiZsnNqYh85TFed6OddmwdbZis7ao2ivPIDGk1/7vW2DZS+VlTB3gUcbp5LyeNxzs1qteOqpp/Dyyy+jrq4O33zzDdLS0vCnP/0JKSkpyM7Olqqtg8aeW3DquS/Y9tnyrdtz1ROOix2JhtPfIyoAh8i2bduGu++ZC13yFR6vcQtUvlozSPKQdJ3bqlWrsGHDBjzzzDPQ6XSO+8ePH4/XXnvN89YSSUyr1WLN2ufw7jfdmLG1HXtqutHSIbCn5tzP737TjdUFhZIHtt7Zmh/dH4mzzT8gMu3qgKwmHxcXB2tXp1dr3AKVr9YMUuDzOLht3LgRr776Ku655x6ni8GECRPw9dfKG6ag4GDPNjzUFo8p61oR83QLpqxrxRftCZL3jvrK1uyyadDWaQ3Y4KHGgsDBvrNEMPF4zu3EiRMYM2bMBffbbLYL6kwSBRK55hDtFV+2ZEc5DYnWtpybEQjU4NFfdX9Amb2cQF0ATr7ncXD7yU9+gvLychiNzv8gt23bhiuvvNJnDSOSghQVMwbSV8WXxOhzgS5Qg4e/KqP4m70Xn5Obh5pNix33G4wpKOQyANXwOLgtW7YMv/rVr3DixAnYbDZYLBYcOXIEGzduxLvvvitFG0mBAim1XW59ZWuakrUwDAvF6T1bEesiYUPu4KHmXo5aMoGpb16tc/vHP/6Bp556CgcOHIDNZsNVV12Fxx9/HLfeeqsUbfQZZkv6h1JrOPqCq6AOoM9szeKvOjFzW/u/F0jPCsgF0sXFxXjw4QXOe7n5cP88fhEid3l0DRduqqioEDabzd3DA1JTU5MAIJqamuRuimqVlJQIjUYj7rg4TOzJjhItS6LFnuwoccclYUKj0YiSkhK5myiZkpISkZKcJAA4binJSaKkpOT8+3JJmNj9QJRo/mO02P3AufcFgIgZNtzp9wzGFI/eq+7ublFaWio2b94sSktLRXd3t8/OyZBsdGpb3Kh4UVRUJNnzG5KNqv47Ie95cg13O7iFhISIuro6x8+zZs0Sp06d8q6FMmFwk1Z3d7dISU4Sd1wcJqyPRwuxLMZxsz4eLe64JEykGg0+u/AGEneCuqvgNypupIiPG+l0X/yoWI+CR39B1RfnFDXmGpEwd7Uw5G4TCXNXi6gx1/jki4rUz0/q48k13O1hyZCQEJw6dQqjRo0CAERHR+Ozzz5DWlqamx1K+XFYUlpqquHoCU82dwXgGII7evQoli9fPqjdzqXaMV3qMlUsg0XekHQRN1Ff1LoP3EA82dzVnq05a9YsrH/9Lx7vVNBzm5YPPvgAeTm/k2S3A3uZqphJsyRZgyf18xO5Hdw0Gg00vf7h9v6Zgpsa94FzhzdB3Zvdzntv03LzzTej6ngtphg0/T7H888/7/GeZVIv4FbjAnEKLG4vBRBC4L777kN4eDiAc0WT58+fjyFDhjgdx/2Q1MWTTLbz+8DVYfts7QXDc0rbB85d9mD92aludNk0qG0RSIzWwJSshTZE4zKoexoQe27TkjB3gaMGZdOerVj6wT5cPFIL86VhTs/x3RkboAlBbm6u4z53CzJLvYBbjQvEKbC4Ped2//33u/WE69evH1SDpMQ5N89YLBaPq9WraR84d1mtViQmxONs8w9o6zzfMzIMC0XBLaHY+Ln1gsLMnsxPmkym/uenSp7EyNOfonJBJLQh575QWA53IauoDRHpE6GfPNvjgsycc6NA5Nf93JSEwc19g9nQUS37wLnLYrHgzqwsRKZd7RxI9mxFa8U+AEBJSYnTuXuyU0F5ebnT5qG9dZw4jFObFqN0XhSmpoTCahNIeb4Np0deOahq/s5/A77fpFTq5yf1YXDrA4Obe3zxrTpYFuYO9F41lDyJIc1VOFV78oLzd7eX6+42Lctv0CFvcjg2ftaJh//eMXAwdCNr1WXv3YcLuKV+flIXv21WSurkiw0d5ajhKIeB3iv95Fk41cd7Za9xuCh3Iaasc+7lFhef7+W6Oz+1fGcnlu/sdNzvi2QNqctUsQwWSYXBbQDB0gPpiZls7hvse+XOxd2tAsbJKVi/7jXU19ejrq4Oubm5PkvWkPqLSrB8ESL/YnDrR7DWSGQmm/t88V4NdHF3t4DxTTfdBODcF7KCtYX9BsNR8YmYMmWKN6dMpAicc+uDVJUflECtmWxS9ML9+V55Mj/VV7JG055zCUFAcHxRI3VhQkkf3H1jPCmnpKSLuyfUlskmZS/cn++VJwHaVTCMjw7FmltCkT48JCi+qJG6MLj1wd03JlhrJPamlkw2f/TCA/W96uzsRLJhNEaHnMGzt+pwgzHUsRYuWL6okXowuPXB3TfGnnrdsiQaQ3UXlhhr6RCIeboFmzdvxt133y1lk2Wn9IQaf/bCA/G94hc1UhMuBRikvnZOtlNrjURXlJ7JZq/huCU7qs/6i1PW1fS7rMFdgfheBWsxayLuCuDC+RqJXbD16tiquUaiXc/K854U2w1Ecl/c5X4vg7WYNRGDmwtarRZr1j6Hd7/pxoyt7dhT042WDoE9Ned+fvebbqwuKJR9yEkKFosFY9JSHJXnMzMzMSYtxecFsf110Zfz4t67in9mZiZS09L9Wlw82L+oURDz/V6pgcvTnbhd7XCcajSododgd3aT9tXrSLFztCuO3cEv8e/u4IG0y7Tjc70kTOx+IEo0/zFa7H7AN59rd3e3KC0tFZs3bxalpaWq3GWdAockO3GrgTe1JQMxSUAK/kq8kGP9oL93KgjEdYJSFLMO1iIHJB9mS/aBhZP75o+sOjnXD/pzpwL7e5kwdzV0iWPRcfxLWM+egXbocIQn/QSdtd+4XbjYl3z5RS2YixyQfJgtSR7zR+KFPzMXezObzZg2bRpefPFFVFRUID09HQ8++CB0Op1PXwc4/x51/XAKDe88C2tTneMxrT4ew0xznY7zF19lc1qtVizKXYhpY0OdvqRMSgrF9tlazNjajkfycjB9+nRVjnKQMjC4EQD/LH/wVQD1pgfiquf23No1kgyh2d+j0++uQeSYidDfsfj8ztl7i3D63QKn45RGzi8pRO5itiQB8E9WnS8yF73J5rQPoY2PqMOe7Ci0LInGnuwojI+sQ1ZWls+zF6dMmQJtmA6R6RMRZ34M4aPHIUQXifDR4xBnfgyR6VdDG6ZTbOFiuZdXELmDwY0A+Gf5w2ADqDdBqvcQ2qSkUAzVaf49hBaBaReH4pG8HJ8uRdi9ezesXZ3QT57V5x5v1q5O7N6922ev2ZPUyyy4do6UgMGNHOybZx5qi8eUda2IeboFU9a14ov2BJ8kCAwmgHobpOxDaEtNYX0OoVVWnRtC8xU598PzxzpFrp0jJVBccHvxxReRmpqKiIgIZGRk+PSiROcC3LffHUNpaSk2b96M0tJSHK2o9Nm8lLcB1NsgJccQWs893lyRaj88fw2/BnORA1IORQW3rVu3IicnB48++ig+/fRTmEwm3H777aiurpa7aapiz6q7++67MXXqVJ9fpLwJoN4GKTmG0Ow7ZzfvLYIQNqfHhLChaU8RYuNG+bRn07NnWzIrHO3dwDtHutHeDZTMDPf58KvUvXyiwVLUOrdrr70WV111FV566SXHfZdeeilmzJiB/Pz8AX+f69yUy9t1eFarFaMT43H1sB/w9t1RF6yt+88trTjQNBzHT57yaRC3WCy4MysLkWlXQz951vk93vYUofXfm4WWlJT4LAjY35/8m3R48YANNT90Ox4zDAvFb68KwdIPO32+ti5YihxQYFDlIu7Ozk5ERUVh27Zt+OUvf+m4f+HChTh48CB27tx5we90dHSgo6PD8XNzczMMBgODmwI5FoBH1mH7bPcXgFutViQmxKOx8TSmXazFkuvDz1co+agD735jRVzcSJysrfPpRdn+umebf0Bb5/nekmFYKApuCcXGz619ttebYGHfpkkDIHLMRMRMmu1YftC8dyvavt0HAQTFNk2kXp4EN8UMSzY2NsJqtSI+Pt7p/vj4eJw6dcrl7+Tn50Ov1ztuBoPBH00lCXg7z1NeXo6GxtN46iYdDtXbnIfQ6m1YdaMO9Q2nfT53a3/dHffoUDovCpvNkSidF4XKBZHIukznco5wMMkgo0aNAjQhiEyfiFjzn5yWH8Sa/4TI9ImARnvuOKIgoLhF3JpeyQRCiAvus1uyZAny8vIcP9t7buQ9OYeh7PM8i3IXYso65zJaxcWuy2jZ5+AeviYci6eEo7zaitoWgcRoDUzJWrR2AUs/7PR55qL9+a5ICHW54W3vOcKe5ay2ZEf1KGd1Lhmk9zxW78/BZrMBwoaYybNdLj+ImTzLMRxKFAwUE9xiY2Oh1Wov6KXV19df0JuzCw8PR3h4uD+aFxQCoVCu2WzG9OnT3Q6wvSuvTE1x/pP/or7b6Thf8aTii6flrFx9DrEjRwAYePlBfX29706SKIApZlhSp9MhIyMDO3bscLp/x44diq30oCT+rvLRH0+yOeVak+XJ63qyzKGvz2FsVBMA/y8/IApUigluAJCXl4fXXnsN69atw+HDh5Gbm4vq6mrMnz9f7qapmhxVPnxFrjVZnryuu8scTpw40efnsHNeJCJ1WjTt2epy+UHz3m0wGFO4sJqChqKC2+zZs1FYWIgnnngCP/3pT7Fr1y689957MBpdD8WQb8hR5cOX5FqT5e7rursWr6Ghoc/PIUwbgj9dr0VbxT40Wlai48Rh2Dpa0XHiMBotK9FWsQ+FBWuYpk9BQzFLAXyB69y8Y08zb1kS7TI5oqVDIObploBPM5crGWag13V3mcOTq/Ixd+7cAT+HkbFxON3Y4LjfYExBYcEaLqwmxeN+buRT/tgOxx98tZ+Zr1/XPoSZlZWFGVvb+9gtvBAjRpxLGhnoc9j6xhbHcKcaFlZzoTh5gz03GpC3C6jJMwPtFh6Mn0MgZOhS4FDlIm6SDwvl+sdANTeD7XMIpAxdUh723MhtA/UsyD+C4XNw9FIj6pzW/gHq7aXSwFRZW9IXGNwGj/MfgcG+IWlZWRkAYOrUqZLs4CAXbwtlk7oxoYQkI1dSBjl76623nHpvK1euVNVclBz78JG6cM6NSGGCYS5Kjn34SF04LEmkIMEyFxWMmaE0MGZLEqmU0qvFuCvYMkPJ9xjciBQkmOai5CqbRurAhBIiBVFLtRh3ebrFEZEd59zIa2pbFqCE81HDXJQS3mcKTB5dw0UQaWpqEgBEU1OT3E1RvJKSEpGSnCQAOG4pyUmipKRE7qZ5RUnnU1JSIjQajbjjkjCx+4Eo0fzHaLH7gShxxyVhQqPRBGSb7UpKSoQh2ej0PhuSjQHdZgocnlzDGdzIY46L68VhYk92lGhZEi32ZCvj4uqKEs/HVTBONRoCsq129vc5asw1ImHuamHI3SYS5q4WUWOuCdj3mQKLJ9dwDkuSR/pKRbfaBHZWdWPxjk6ctI1AVfVx6HQ6mVs7MCWn1vtreM8Xr2O1WpGalo7TunjEmh+DRnM+l00IGxotKzGyqx6VFd8G3PtMgYNLAUgyrlLRLYe7MOb5s7hpYxs+qbXiVF0DUpKTFLGYWMmp9fZqMXfffbdkpbcsFgvGpKUgMzMTc+bMQWZmJsakpXj82ZaXl6Omugoxk2Y5BTYA0GhCEDNpJmqqjgXk+0zKxOBGHumdim453IWsojaMH6V1qpaRoT+jiGoZwZRa7ylfVkKxv39hcUaXj4fFGp2OIxosBjfySM9UdKtNYNE/2zHt4lBsvysSk5JCMVSnwaSkULx1VySmXRyKR/JyYLW6LqEUCFjmyTWr1YpFuQsxbWwott8V4fTZbp8d4fFna3//uhqqXD7e1VjldBzRYDG4kUdMJhNSkpPw1Edd2FnVjWM/CCw16RQ3pGfX83xsvaafbUIg/+MupBoNMJlMMrVQHr4erjWZTDAkG9G8twhC2JweE8KG5r3bYDCmBN37TNJhcCOP9CyLtHhHJwD/D+nZt3vZsmULysrKBtUzZJkn13w9XKvValG4tgBtFfvQaFmJjhOHYetoRceJw2i0rERbxT4UFqwJuveZpMPgRh6zl0U6YR0OwL9Der5KcOiJZZ4uJMVwrf19HtlZh1ObFqOmcBZObVqMkV31Qfs+k3S4FIC81tnZiZTkJGToz+CtuyIlT6O3JzhMGxuKpaYwXD5Kiy/qrXjqoy68+033oC+QrJxxnpSVUPg+k7e4E3cfGNx8zxFwLg7FkuvOB5z8j30TcOyUvB5Nqfz12RK5i+vcyG/8NaSn5PVoSsXhWlIy7gpAg+aPyu1cjzZ43gwHuvvZcqiRAg2DG/mEvVqGVIJtqxdfs1gsWJS7EMeqjzvuS0lOwpq1zw3YAxvosx3McxNJhcOSpAhcj+Y9X1Ya8edzEw0GE0pIMZjg4DkpE3GY5EP+xoQSUiUmOHhOykQcJvlQIOOcGymKP5JX1ETKRBwm+VAgY3AjxZE6eUVNpEzEYZIPBTLOuRGpmNSVRqR6biJXOOdGqufL4slqJmVhaBad9h/+vXtBBJGmpiYBQDQ1NcndFBqEkpISkZKcJAA4binJSaKkpETupgUsV+9ZqtHgk/dMyuemc++vIdno9P4ako1B+f56cg3nsCQpitTFk+UmZaUPpT53MLP/vUemT0TMpFkIizOiq6EKzXuL0FaxT/F/755i4eQ+MLgpm9rXVVksFuTk5qGm+vxu1YZkIwrXFgTVBYzOsVqtSE1Lx2ldPGLNj0GjOT+LJIQNjZaVGNlVj8qKbxX59+4NzrmRKql5XZX9G/ppXTwS5q6GIXcbEuauxmldPCt9BKny8nLUVFchZtIsp8AGABpNCGImzURN1TFF/r37A4MbKYZa11VZrVbk5OYhMn0iYs2PIXz0OIToIhE+ehxizY8hMn0icvIWMYkgyNj/jsPijC4fD4s1Oh1HzhjcSDGk2B06EPAbOrli/zvuaqhy+XhXY5XTceSMwY0UQ63Fk/kNnVwxmUwwJBvRvLcIQticHhPChua922Awpiju791fGNxIMdS6rorf0MkVrVaLwrUFaKvYh0bLSnScOAxbRys6ThxGo2Ul2ir2obBgjeL+3v1FMdmSq1atwv/+7//i4MGD0Ol0+OGHHzx+DmZLqoOr/cNSjQasLigMiKxCT9PimRVH/XGZRWtMQWHBmoD4e/cnVS4FWLZsGYYNG4bjx4/j9ddfZ3ALcoG6rsrbjTud1zPNRFisEV2NVWjeuy0o1zORs0D9e/c3j67hEi4ml8T69euFXq/36ndZoYSkVFJSIjQajbjj4jCxJztKtCyJFnuyo8Qdl4QJjUYzYEUJl5UojClBWYmCyBVVVyjZsGEDcnJy3Oq5dXR0oKOjw/Fzc3MzDAYDe27kc75aYM5v6ER986Tnpuotb/Lz87FixQq5m0FBwL7AfEt2VJ8LzKesO7fAvL/teuTczoeBldRE1mzJ5cuXQ6PR9Hvbv3+/18+/ZMkSNDU1OW41NTU+bD3ReUpfYG6xWDAmLQWZmZmYM2cOMjMzMSYthZVRSLFk7bk9/PDDuOuuu/o9JiUlxevnDw8PR3h4uNe/T+QuJW/c2bMY9ZbsqB7FqOuQlZXFZBZSJFXPufXGbMnApfQhMaVu3Kn2YtSkLqosnFxdXY2DBw+iuroaVqsVBw8exMGDB3H27Fm5m0aDpIYhMaUuMFdzMWoKbooJbo8//jiuvPJKLFu2DGfPnsWVV16JK6+8clBzciQ/+5DY+Ig67MmOQsuSaOzJjsL4yDrFVcM3m80oLi7GobZ4TFnXipinWzBlXSu+aE8I2KE9pc8VEvVFccOSg8FhycCi1iExJQ2xlpWVITMzE3uyo1zOFe6p6caUda0oLS2VLYuTyE6VFUp8gcEtsPDCKj+lzhVScFLlnBupD4fE5KfUuUKigTC4kWzUuj+b0ihxrpBoIByWJNlwSMy/BpoLVNJcIQUnlt8iRbAPiWVlZWHG1nYsuS7MsYA4/+MuvPtNN4qLOSTmC+7sViBn6S8iX+OwJMmKQ2LSU9NyCyJ3cViSAgKHxKSh1uUWFJw4LEmKwyExafhqtwIipeGwJJGKcbkFBSv23CgoBMKwpxxtUPJuBUSDwZ4bqV4gFGaWqw0mkwkpyUl46qMu2HpNr9uEQP7HXUg1GmAymSRtB5G/MbiRqgVCpqCcbWAFEgpWzJYk1QqETMFAaAPgep1bqtGA1QWFXG5BisHakkQIjL3KAqENwLn1hN9+dwylpaXYvHkzSktLcbSikoGNVIsJJaRagZApGAhtsONyCwom7LmRagVCYeZAaANRMOKcG6lWIBRmDoQ2EKkF59yIEBiZgoHQBqJgxJ4bqV4gZAoGQhuIlM6TaziDGwWFYK1QQqQmDG59YHAjIlIuzrkREVFQY3AjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVYXAjIiLVCZW7AURESmO1WlFeXo7a2lokJibCZDJBq9XK3SzqQRE9t2PHjiE7OxupqamIjIxEeno6li1bhs7OTrmbRkRBxmKxYExaCjIzMzFnzhxkZmZiTFoKLBaL3E2jHhQR3L7++mvYbDa88sor+PLLL7F27Vq8/PLLWLp0qdxNI6IgYrFYkJWVhfERddiTHYWWJdHYkx2F8ZF1yMrKYoALIBohhJC7Ed549tln8dJLL+G7775z+3eam5uh1+vR1NSEmJgYCVtHRGpjtVoxJi0F4yPqsP2uCIRoNI7HbEJgxtZ2fNGegKMVlRyilIgn13BF9NxcaWpqwogRI/o9pqOjA83NzU43IiJvlJeX41j1cSw1hTkFNgAI0Wiw5LowVFbVoLy8XKYWUk+KDG4VFRV4/vnnMX/+/H6Py8/Ph16vd9wMBoOfWkhEalNbWwsAuHyU616Z/X77cSQvWYPb8uXLodFo+r3t37/f6XdOnjyJ2267DTNnzsSvf/3rfp9/yZIlaGpqctxqamqkPB0iUrHExEQAwBf1VpeP2++3H0fyknXOrbGxEY2Njf0ek5KSgoiICADnAltmZiauvfZabNiwASEhnsVmzrkRkbccc26Rddg+m3NucvDkGi7rOrfY2FjExsa6deyJEyeQmZmJjIwMrF+/3uPARkQ0GFqtFmvWPoesrCzM2NqOJdeF4fJRWnxRb0X+x11495tuFBcXMrAFCEVkS548eRI33HADkpOTsXHjRqc/noSEBLefhz03Ihosi8WCRbkLcaz6uOO+VKMBqwsKYTabZWyZ+nlyDVdEcNuwYQPuv/9+l4950nwGNyLyBVYokYfqgpuvMLgRESlXUKxzIyIi6guDGxERqQ6DGxERqQ6DGxERqQ6DGxERqQ6DGxERqQ6DGxERqQ6DGxERqQ6DGxERqY6shZP9zV6MhZuWEhEpj/3a7U5hraAKbi0tLQDATUuJiBSspaUFer2+32OCqrakzWbDyZMnER0dDU2vbeIDTXNzMwwGA2pqalRRB5PnE/jUdk48n8DmzfkIIdDS0oKLLrpowG3PgqrnFhISgqSkJLmb4ZGYmBhV/CHb8XwCn9rOiecT2Dw9n4F6bHZMKCEiItVhcCMiItVhcAtQ4eHhWLZsGcLDw+Vuik/wfAKf2s6J5xPYpD6foEooISKi4MCeGxERqQ6DGxERqQ6DGxERqQ6DGxERqQ6DmwIcO3YM2dnZSE1NRWRkJNLT07Fs2TJ0dnbK3TSvrVq1ClOmTEFUVBSGDRsmd3M89uKLLyI1NRURERHIyMhAeXm53E3y2q5du3DHHXfgoosugkajwfbt2+Vuktfy8/MxceJEREdHY9SoUZgxYwaOHDkid7O89tJLL2HChAmOhc6TJ0/G3//+d7mb5TP5+fnQaDTIycnx+XMzuCnA119/DZvNhldeeQVffvkl1q5di5dffhlLly6Vu2le6+zsxMyZM/Hb3/5W7qZ4bOvWrcjJycGjjz6KTz/9FCaTCbfffjuqq6vlbppXfvzxR1xxxRV44YUX5G7KoO3cuRMPPfQQ9u7dix07dqC7uxu33norfvzxR7mb5pWkpCQ8/fTT2L9/P/bv348bb7wR06dPx5dffil30wZt3759ePXVVzFhwgRpXkCQIj3zzDMiNTVV7mYM2vr164Ver5e7GR655pprxPz5853uGzdunPjjH/8oU4t8B4B488035W6Gz9TX1wsAYufOnXI3xWeGDx8uXnvtNbmbMSgtLS1i7NixYseOHeKGG24QCxcu9PlrsOemUE1NTRgxYoTczQg6nZ2dOHDgAG699Van+2+99Vbs3r1bplZRX5qamgBAFf9WrFYr3njjDfz444+YPHmy3M0ZlIceegi/+MUvcPPNN0v2GkFVOFktKioq8Pzzz2PNmjVyNyXoNDY2wmq1Ij4+3un++Ph4nDp1SqZWkStCCOTl5eH666/H5ZdfLndzvHbo0CFMnjwZ7e3tGDp0KN58801cdtllcjfLa2+88QY++eQT7Nu3T9LXYc9NRsuXL4dGo+n3tn//fqffOXnyJG677TbMnDkTv/71r2VquWvenI9S9d4ySQgR8NsoBZuHH34Yn3/+ObZs2SJ3UwblkksuwcGDB7F371789re/xbx58/DVV1/J3Syv1NTUYOHChdi0aRMiIiIkfS323GT08MMP46677ur3mJSUFMf/nzx5EpmZmZg8eTJeffVViVvnOU/PR4liY2Oh1Wov6KXV19df0Jsj+SxYsABvv/02du3apbhtrnrT6XQYM2YMAODqq6/Gvn378Nxzz+GVV16RuWWeO3DgAOrr65GRkeG4z2q1YteuXXjhhRfQ0dEBrVbrk9dicJNRbGwsYmNj3Tr2xIkTyMzMREZGBtavXz/gRn1y8OR8lEqn0yEjIwM7duzAL3/5S8f9O3bswPTp02VsGQHnetALFizAm2++ibKyMqSmpsrdJJ8TQqCjo0PuZnjlpptuwqFDh5zuu//++zFu3Dj84Q9/8FlgAxjcFOHkyZOYOnUqkpOTsXr1ajQ0NDgeS0hIkLFl3quursb333+P6upqWK1WHDx4EAAwZswYDB06VN7GDSAvLw+/+tWvcPXVVzt60dXV1Zg/f77cTfPK2bNn8e233zp+rqysxMGDBzFixAgkJyfL2DLPPfTQQ9i8eTPeeustREdHO3rYer0ekZGRMrfOc0uXLsXtt98Og8GAlpYWvPHGGygrK8P7778vd9O8Eh0dfcH855AhQzBy5Ejfz4v6PP+SfG79+vUCgMubUs2bN8/l+ZSWlsrdNLf8+c9/FkajUeh0OnHVVVcpOtW8tLTU5Wcxb948uZvmsb7+naxfv17upnnlgQcecPydxcXFiZtuukn885//lLtZPiXVUgBueUNERKoTeBM3REREg8TgRkREqsPgRkREqsPgRkREqsPgRkREqsPgRkREqsPgRkREqsPgRkREqsPgRkREqsPgRuSl++67z+W2Pj3rNA7Ghg0bMGzYMJ88ly80NDQgLCwMra2t6O7uxpAhQ1BdXe10TEdHBxYsWIDY2FgMGTIE//mf/4njx4/L1GIKZgxuRINw2223oba21ukWiJXou7q6Bv0ce/bswU9/+lNERUXhwIEDLgsr5+Tk4M0338Qbb7yBjz76CGfPnsW0adNgtVoH/fpEnmBwIxqE8PBwJCQkON3s23a88847yMjIQEREBNLS0rBixQp0d3c7fregoADjx4/HkCFDYDAY8OCDD+Ls2bMAgLKyMtx///1oampy9AiXL18O4NxGqdu3b3dqx7Bhw7BhwwYAwLFjx6DRaFBUVISpU6ciIiICmzZtAgCsX78el156KSIiIjBu3Di8+OKLbp/r7t27cd111wEAPvroI8f/2zU1NeH111/HmjVrcPPNN+PKK6/Epk2bcOjQIfzf//2f269D5BM+L8VMFCTmzZsnpk+f7vKx999/X8TExIgNGzaIiooK8c9//lOkpKSI5cuXO45Zu3at+PDDD8V3330nPvjgA3HJJZeI3/72t0IIITo6OkRhYaGIiYkRtbW1ora2VrS0tAghzlW+f/PNN51eT6/XOyrfV1ZWCgAiJSVFlJSUiO+++06cOHFCvPrqqyIxMdFxX0lJiRgxYoTYsGFDn+dYVVUl9Hq90Ov1IiwsTERERAi9Xi90Op0IDw8Xer3e0eYPPvhAABDff/+903NMmDBBPP744568tUSDxuBG5KV58+YJrVYrhgwZ4rhlZWUJIYQwmUziqaeecjr+r3/9q0hMTOzz+YqKisTIkSMdP69fv17o9foLjnM3uBUWFjodYzAYxObNm53ue/LJJ8XkyZP7bFNXV5eorKwUn332mQgLCxMHDx4U3377rRg6dKjYuXOnqKysFA0NDUIIIf72t78JnU53wXPccsst4je/+U2fr0EkBW5WSjQImZmZeOmllxw/DxkyBABw4MAB7Nu3D6tWrXI8ZrVa0d7ejtbWVkRFRaG0tBRPPfUUvvrqKzQ3N6O7uxvt7e348ccfHc8zGFdffbXj/xsaGlBTU4Ps7Gz8v//3/xz3d3d3Q6/X9/kcoaGhSElJQVFRESZOnIgrrrgCH3/8MeLj4/Gzn/3MrXYIIaDRaLw/ESIvMLgRDcKQIUMwZsyYC+632WxYsWIFzGbzBY9FRESgqqoKP//5zzF//nw8+eSTGDFiBD766CNkZ2cPmPyh0Wggem3D6Op3egZIm80GAPjLX/6Ca6+91uk4+xyhKz/5yU9QVVWFrq4u2Gw2DB06FN3d3eju7sbQoUNhNBrx5ZdfAji3K3xnZyfOnDmD4cOHO56jvr4eU6ZM6feciHyNwY1IAldddRWOHDniMvABwP79+9Hd3Y01a9YgJORcXldRUZHTMTqdzmWWYVxcHGprax0/Hz16FK2trf22Jz4+HqNHj8Z3332He+65x+3zeO+999DV1YWbbroJzzzzDDIyMnDXXXfhvvvuw2233YawsDDHsRkZGQgLC8OOHTswa9YsAEBtbS2++OILPPPMM26/JpEvMLgRSeDxxx/HtGnTYDAYMHPmTISEhODzzz/HoUOHsHLlSqSnp6O7uxvPP/887rjjDnz88cd4+eWXnZ4jJSUFZ8+exQcffIArrrgCUVFRiIqKwo033ogXXngBkyZNgs1mwx/+8AenINOX5cuX43e/+x1iYmJw++23o6OjA/v378eZM2eQl5fn8neMRiNOnTqFuro6TJ8+HSEhIfjqq69gNptx0UUXOR2r1+uRnZ2NRYsWYeTIkRgxYgQeeeQRjB8/HjfffLP3byaRN+Se9CNSqv6yJYU4lzE5ZcoUERkZKWJiYsQ111wjXn31VcfjBQUFIjExUURGRor/+I//EBs3bhQAxJkzZxzHzJ8/X4wcOVIAEMuWLRNCCHHixAlx6623iiFDhoixY8eK9957z2VCyaeffnpBm/72t7+Jn/70p0Kn04nhw4eLn/3sZ8JisfR7nlu2bBHXX3+9EEKIXbt2iTFjxvR5bFtbm3j44YfFiBEjRGRkpJg2bZqorq7u9/mJpKARotfgPRERkcJxETcREakOgxsREakOgxsREakOgxsREakOgxsREakOgxsREakOgxsREakOgxsREakOgxsREakOgxsREakOgxsREanO/w+zzE/V5sL1xgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -130,8 +128,10 @@ "for klazz, color in zip(classes, [\"tab:orange\", \"tab:blue\"]):\n", " mask_sample_klazz = y == klazz\n", " ax.scatter(\n", - " X[mask_sample_klazz, 0], X[mask_sample_klazz, 1],\n", - " color=color, label=klazz,\n", + " X[mask_sample_klazz, 0],\n", + " X[mask_sample_klazz, 1],\n", + " color=color,\n", + " label=klazz,\n", " edgecolor=\"black\",\n", " )\n", "plt.axis(\"square\")\n", @@ -149,7 +149,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -160,8 +160,10 @@ " for klazz, color in zip(classes, [\"tab:orange\", \"tab:blue\"]):\n", " mask_sample_klazz = labels == klazz\n", " ax.scatter(\n", - " data[mask_sample_klazz, 0], data[mask_sample_klazz, 1],\n", - " color=color, label=klazz,\n", + " data[mask_sample_klazz, 0],\n", + " data[mask_sample_klazz, 1],\n", + " color=color,\n", + " label=klazz,\n", " edgecolor=\"black\",\n", " )\n", " sns.despine()\n", @@ -174,12 +176,12 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -208,20 +210,18 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "from sklearn.model_selection import train_test_split\n", "\n", - "X_train, X_test, y_train, y_test = train_test_split(\n", - " X, y, random_state=42\n", - ")" + "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -231,7 +231,7 @@ " 0, 1, 1])" ] }, - "execution_count": 12, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -254,12 +254,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -271,9 +271,7 @@ "source": [ "from figures import DecisionBoundaryDisplay\n", "\n", - "display = DecisionBoundaryDisplay.from_estimator(\n", - " clf, X, alpha=0.5\n", - ")\n", + "display = DecisionBoundaryDisplay.from_estimator(clf, X, alpha=0.5)\n", "_ = plot_data(X_train, y_train, ax=display.ax_)" ] }, @@ -298,10 +296,44 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/vw/2kmjpl310zl2lwgnwpxsyw4r0000gn/T/ipykernel_7263/1951368283.py:14: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n", + "/var/folders/vw/2kmjpl310zl2lwgnwpxsyw4r0000gn/T/ipykernel_7263/1951368283.py:14: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n", + "/var/folders/vw/2kmjpl310zl2lwgnwpxsyw4r0000gn/T/ipykernel_7263/1951368283.py:14: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " plt.legend()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(2, 2, figsize=(12, 12), layout=\"constrained\")\n", + "axs = axs.flatten()\n", + "for ax, depth in zip(axs, [3, 5, 8, 10]):\n", + " clf = DecisionTreeClassifier(max_depth=depth)\n", + " clf.fit(X_train, y_train)\n", + " # pred = clf.predict(X_test)\n", + " ax.set_title(f\"Tree with {depth} depth\")\n", + " display = DecisionBoundaryDisplay.from_estimator(clf, X, alpha=0.5, ax=ax)\n", + " _ = plot_data(X_train, y_train, ax=display.ax_)\n", + "plt.show()" + ] }, { "cell_type": "markdown", @@ -312,12 +344,27 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "5adbf5ea0de54982aba79e232d77e963", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(IntSlider(value=0, description='max_depth', max=8), Output()), _dom_classes=('widget-int…" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -327,22 +374,48 @@ }, { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "4970aaf6639c4151878820cd9c2859cb", - "version_major": 2, - "version_minor": 0 - }, + "image/png": "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", "text/plain": [ - "interactive(children=(IntSlider(value=0, description='max_depth', max=8), Output()), _dom_classes=('widget-int…" + "
" ] }, - "execution_count": 14, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ "from figures import plot_tree_interactive\n", + "\n", "plot_tree_interactive()" ] }, @@ -362,7 +435,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -547,7 +620,7 @@ "5 NaN " ] }, - "execution_count": 15, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -567,7 +640,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -588,7 +661,7 @@ "Name: Body Mass (g), Length: 274, dtype: float64" ] }, - "execution_count": 16, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -616,7 +689,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 16, "metadata": {}, "outputs": [ { @@ -625,13 +698,13 @@ "Text(0, 0.5, 'Probability')" ] }, - "execution_count": 17, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -642,7 +715,9 @@ ], "source": [ "_, ax = plt.subplots()\n", - "dataset.groupby(\"Species\").plot.hist(ax=ax, alpha=0.7, legend=True, density=True)\n", + "dataset.groupby(\"Species\").plot.hist(\n", + " ax=ax, alpha=0.7, legend=True, density=True\n", + ")\n", "ax.set_ylabel(\"Probability\")" ] }, @@ -655,22 +730,12 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 17, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/homebrew/Caskroom/miniforge/base/envs/base_env/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", - " with pd.option_context('mode.use_inf_as_na', True):\n", - "/opt/homebrew/Caskroom/miniforge/base/envs/base_env/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", - " with pd.option_context('mode.use_inf_as_na', True):\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -680,8 +745,7 @@ } ], "source": [ - "ax = sns.swarmplot(x=dataset.values, y=[\"\"] * len(dataset),\n", - " hue=dataset.index)\n", + "ax = sns.swarmplot(x=dataset.values, y=[\"\"] * len(dataset), hue=dataset.index)\n", "_ = ax.set_xlabel(dataset.name)" ] }, @@ -694,7 +758,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -704,26 +768,22 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/opt/homebrew/Caskroom/miniforge/base/envs/base_env/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", - " with pd.option_context('mode.use_inf_as_na', True):\n", - "/opt/homebrew/Caskroom/miniforge/base/envs/base_env/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", - " with pd.option_context('mode.use_inf_as_na', True):\n", - "/var/folders/1r/syrjmt51115cyrdggjbwqv6h0000gn/T/ipykernel_69806/905870667.py:6: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + "/var/folders/vw/2kmjpl310zl2lwgnwpxsyw4r0000gn/T/ipykernel_7263/3789175215.py:5: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", " ax.set_title(f\"Body mass threshold: {dataset[random_idx]} grams\")\n", - "/var/folders/1r/syrjmt51115cyrdggjbwqv6h0000gn/T/ipykernel_69806/905870667.py:7: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", + "/var/folders/vw/2kmjpl310zl2lwgnwpxsyw4r0000gn/T/ipykernel_7263/3789175215.py:6: FutureWarning: Series.__getitem__ treating keys as positions is deprecated. In a future version, integer keys will always be treated as labels (consistent with DataFrame behavior). To access a value by position, use `ser.iloc[pos]`\n", " _ = ax.vlines(dataset[random_idx], -1, 1, color=\"red\", linestyle=\"--\")\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -735,8 +795,7 @@ "source": [ "random_idx = rng.choice(dataset.size)\n", "\n", - "ax = sns.swarmplot(x=dataset.values, y=[\"\"] * len(dataset),\n", - " hue=dataset.index)\n", + "ax = sns.swarmplot(x=dataset.values, y=[\"\"] * len(dataset), hue=dataset.index)\n", "ax.set_xlabel(dataset.name)\n", "ax.set_title(f\"Body mass threshold: {dataset[random_idx]} grams\")\n", "_ = ax.vlines(dataset[random_idx], -1, 1, color=\"red\", linestyle=\"--\")" @@ -753,7 +812,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -762,12 +821,26 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "application/vnd.jupyter.widget-view+json": { + "model_id": "236114de3d62479f9cc3abc2649315a3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(FloatSlider(value=0.5, description='proportion', max=1.0), Output()), _dom_classes=('wid…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", "text/plain": [ "
" ] @@ -777,13 +850,39 @@ }, { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "ae631ac2970741b1af9f2eac32476979", - "version_major": 2, - "version_minor": 0 - }, + "image/png": "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", "text/plain": [ - "interactive(children=(FloatSlider(value=0.5, description='proportion', max=1.0), Output()), _dom_classes=('wid…" + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhgAAAEmCAYAAAAgHOlQAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAULNJREFUeJzt3XlYVGX7B/DvLMwMOyLILuCOIKLgAmZqKqam2SaVr7slWbml/fK10nwt2zQtwyW3LC00zSzRojJFcUXIBTcEBWEQAWVfZ87vD3QKQQQc5gzw/VzXXC8cnnPmnvMa5+ZZ7kciCIIAIiIiIj2Sih0AERERNT1MMIiIiEjvmGAQERGR3jHBICIiIr1jgkFERER6xwSDiIiI9I4JBhEREekdEwwiIiLSO7nYARiaVqtFWloaLC0tIZFIxA6HiIio0RAEAXl5eXB2doZUWnMfRbNLMNLS0uDm5iZ2GERERI1WSkoKXF1da2zT7BIMS0tLABU3x8rKSuRoiIiIGo/c3Fy4ubnpnqU1aXYJxt1hESsrKyYYRETUJJWWlmL+/PkAgPfffx8KhUKv16/NFANJc9vsLDc3F9bW1sjJyWGCQURETVJBQQEsLCwAAPn5+TA3N9fLdevyDBV9FUlYWBg8PT2hUqng7++PqKio+7adMGECJBJJlZe3t7cBIyYiIqIHETXBCA8Px8yZMzF//nzExsaib9++GDp0KJKTk6ttv2LFCqjVat0rJSUFtra2eO655wwcOREREdVE1CGSXr16oXv37li1apXumJeXF0aNGoUlS5Y88Pxdu3bh6aefRlJSEtzd3Wv1nhwiISKipq5ZD5GUlpYiJiYGwcHBlY4HBwcjOjq6VtdYv349Bg0aVGNyUVJSgtzc3EovIiIialiiJRiZmZnQaDRwcHCodNzBwQHp6ekPPF+tVmPv3r2YMmVKje2WLFkCa2tr3Ys1MIiIiBqe6MtU713qIghCrZa/bNq0CTY2Nhg1alSN7ebNm4fZs2frvr+7hpeIGk5xmQY380qQmV+CzPxSZOWXILuwFHnF5cgrLkNecTnyi8tRUq5FabkWJRotSso0Va4jlUigkEuhkEuhlEuhMpHBUimHpUoOS5UJLFVy2JorYGephJ25Ei0tFLC3VMJEJvr8daJmT7QEw87ODjKZrEpvRUZGRpVejXsJgoANGzZg7NixD1zbq1QqoVQqHzpeIvqHRisg9VYREjPzcTWzAFezCpF6uwjqnCKk3S5GdkGpaLFJJEArSyWcrE3hYmMK1xam8LAzh0dLc3jamcPBSsltAqjJMzU1xdmzZ3Vfi0G0BEOhUMDf3x+RkZF46qmndMcjIyPx5JNP1njugQMHkJCQgMmTJzd0mETNmiAIuJFbgnh1Di6k5+HindeVm/ko09Q8P1wpl8LOQgk7CwXsLJSwMVPAyrSi58FKJYe5Ug6ViRQKmQzKO70U0nse/OXaih6OUk3F/xaVaZBfXK7rCcktLkdWQUUPSVZ+KbIKSlCmqYj5Rm4J4lJuV4nLTCFDewdLdHKwRAdHS3RytIS3sxVszPRbiIhITFKpVPQSDqIOkcyePRtjx45FQEAAAgMDsXbtWiQnJyM0NBRAxfBGamoqNm/eXOm89evXo1evXvDx8REjbKImK6eoDKeSb+HvlNs4cz0Hp1NzcDOvpNq2CrkUHi3NdD0Dri1M4Wzzz8tKJTd4T4EgCMgqKEXa7SKk3S5C6u1ipGQX4mpWAZIyC3D9VhEKSzX4O+U2/r4n+WhtawZfV2v4ulqjq6sNurrZQGUiM2j8RE2JqAlGSEgIsrKysGjRIqjVavj4+CAiIkK3KkStVlepiZGTk4MdO3ZgxYoVYoRM1KRk5BbjSGIWTlzNxsmrt3DxRh7uXbguk0rQzt4CHR0t0fHOX/wdHCzhYmMKqdS4hhokEsmdXhMlfF1tqvy8tFyL5OwCXEzPx8X0XFxIz8OF9DwkZxfqXr+cVgMATGQSdHGxRg8PW/TwsEXPNrawUpkY+BMR1U9paSk++OADAMB///tfvZcKrw2WCidqRvJLynHkShYOJ2TicEImLmfkV2nj0dIM3Vq3uPPXvA06O1nBVNG0/5LPKSzDmdQcnE69jdMpOYhJvlWl50YmlcDX1Rp92tqhTzs7+Lu3gELOyaRknIyhDgYTDKIm7mpmAf64kIH9FzJwLCmr0twJiQTwdrZCL8+W6OHRAv7utrC35KRoQRCQkl2EE1ezceJqNo4lZSMps6BSGwulHH3b22FAp1YY0LEV7xsZFSYYImCCQU2dIAg4l5aLfWfTsfesGlduVn4wtrY1Q9/2FX+FB7ZpiRbmnNxYG6m3i3Q9P4cTMpGZX3mlTLfWNhjq44ihPk5wszUTKUqiCkwwRMAEg5oiQRAQr87F7rg0RJxVIyW7SPczuVSCnp62eKxTKwzo1Apt7My5TPMhabUCTqfm4M87PUNnUnMq/dzb2QrDujhhZFdnJhskCiYYImCCQU1JSnYhfopLxa64NCT8az6FykSK/h1aYWgXRwzo1IqTExvYjdxi/HouHXvPpONYUha0//qtGuDeAk92c8HwLk6wZW8RGQgTDBEwwaDGrqhUg71n1Qg/kYJjSdm64wq5FIO8WuEJX2f072gPM4XohXqbpaz8EkTG38Duv9NwJDFLtypHLpVgkJcDQnq44dEO9pAZ2QocalqYYIiACQY1VmdTc7D1eDJ+jktDXkk5gIpJmkFtW+JJPxc87uPIngojk55TjJ//TsOuuFScS/tno0VHKxWe8XfB8z1acwiFGgQTDBEwwaDGpLhMg4gzamw+cq1SVUo3W1OM9nfDM/6ucLYRpwww1c2F9FyEn0jBrthU3CosA1CRID7WsRXGBrrj0fb2RldXhBovjUaDU6dOAQC6d+8OmUw/S82ZYNSACQY1Buk5xfj6yFWEn0jR7ethIpNgqI8Tnu/pht6eLfkwaqRKyjX4PT4D3x1PxqGETN1x95ZmGNvbHSE93GDJnigyUkwwasAEg4xZfFou1kUl4ufTabp6FU7WKozp1RohPVqz1kITc+VmPr49eg0/xFxHXnHFsJelUo4XerXGhCAP9k6R0WGCUQMmGGRsBEFA9JUshP2VgMMJWbrjPT1sMekRDwzycoCc2483aYWl5fgxNhXrDyUh8U7dEplUgid8nTCtfzt0dLQUOUJqbEpLS3VbasyYMUNvpcKZYNSACQYZC0EQ8Mf5DKzcn6CbXyGTSjDUxxEv9W2Drm42osZHhqfVCth/MQPropJwJPGfZHNwZwe8NqAd/01QrXGSpwiYYJDYBEHAr+fSseKPBJxXV6wsUMqleL6HG156tA1cW3BVAVWsGgr7KwF7z6brlrr2bW+HmYM6wN+9hbjBkdFjgiECJhgkFkEQ8OeFDCyLvKRbsmiukOE/ge6Y8kgbzq+gaiVk5CFs/xX89HcaNHcqeA3oaI/Zgzuii6u1yNGRsWKCIQImGCSGwwmZ+OTXi7qhEHOFDJMe8cTkRzxhY8bqjvRgyVmF+HJ/An44dV2XaAzxdsAbwR3RwYFzNKgyJhgiYIJBhnRenYsP917AgUs3AVSU8B4f5IGpj7Zl2Wiql6uZBVjxx2XsikuFIABSCfCcvxtmDe4AR2uV2OGRkWCCIQImGGQIabeLsPS3S9gZex2CUFHDYkwvd7w6oB2HQkgvEjLy8Omvl7DvXDqAiuR18iOemNqvLSu6EhMMMTDBoIZUVKrBqgNXsObAFZSUawEAT/g6Ye6QjnBvqZ//wIn+LebaLSyJOI+T124BAOwsFJg7pCOe9XfjfifNGBMMETDBoIYgCAJ+Oa3GkojzSMspBgD09LTFf4d5wY9LC6mBCYKA3+Jv4KO9F5CYWVFHw8fFCgtHeCPAw1bk6EgMGo0GUVFRAIC+ffuyVLghMMEgfbuQnot3d53D8asVO5u62Jhi/nAvDPVxhETCvyDJcErLtdh85CpW/H5ZtyHeyK7OeHu4F1pZcX4GPby6PENFLw8YFhYGT09PqFQq+Pv76zKu+ykpKcH8+fPh7u4OpVKJtm3bYsOGDQaKlugfBSXleH9PPIZ/fgjHr2ZDZSLF7MEd8Mcb/TCsixOTCzI4hVyKKX3bYP/c/ni+hxskEmD332kYuPQANh1O0q0+ITIEUXswwsPDMXbsWISFhaFPnz5Ys2YN1q1bh/j4eLRu3brac5588kncuHEDixcvRrt27ZCRkYHy8nIEBQXV6j3Zg0EPq6JQ1g289/M5qO8Mhzzu7Yh3R3Tm3hFkVM5cz8Hbu87g7+s5AIAuLtZ4/ykf+LraiBsYNbiysjKsXbsWAPDyyy/DxEQ/E38bzRBJr1690L17d6xatUp3zMvLC6NGjcKSJUuqtN+3bx+ef/55JCYmwta2fuOKTDDoYaTnFOPtXWfx+/kbACq2TV800gcDOrUSOTKi6mm0ArYeT8bH+y4gr7gcEgkwIcgDc4I7wlwpFzs8aiDGMMlTtCGS0tJSxMTEIDg4uNLx4OBgREdHV3vO7t27ERAQgI8//hguLi7o0KED5syZg6Kiovu+T0lJCXJzcyu9iOpKEAR8dzwZg5cdwO/nb8BEJsFrA9rht5n9mFyQUZNJJRjb2x1/vtEfT3VzgSAAGw9fxZDlBxF1+abY4VETJlr6mpmZCY1GAwcHh0rHHRwckJ6eXu05iYmJOHToEFQqFX788UdkZmZi2rRpyM7Ovu88jCVLluC9997Te/zUfFzLKsBbO87oNp/q6maDj5/x5Q6X1KjYWyrxWYgfRnVzwX93nsH1W0UYu/44nvN3xdvDO8PajLUzSL9En+R570Q4QRDuOzlOq9VCIpFgy5Yt6NmzJ4YNG4Zly5Zh06ZN9+3FmDdvHnJycnSvlJQUvX8GapoEQcA3R67i8eVROJKYBZWJFG8P98LOV4KYXFCj1a+DPX6d9SgmBHlAIgG2x1xH8PIDumqzRPoiWg+GnZ0dZDJZld6KjIyMKr0adzk5OcHFxQXW1v9s8OPl5QVBEHD9+nW0b9++yjlKpRJKJSsnUt2oc4rw5g+nEXU5EwDQu40tPnrGl8WyqEmwUMqxcKQ3nvB1wps/nEZiZgHGbziOMb1a47/DvDg3g/RCtB4MhUIBf39/REZGVjoeGRl53xUhffr0QVpaGvLz83XHLl26BKlUCldX1waNl5oHQRCwKzYVQz47iKjLmVDKpXj3ic7YOqU3kwtqcgI8bLFnel9MCPIAAGw5loyhK6Jw4k5NF6KHIeoQyezZs7Fu3Tps2LAB58+fx6xZs5CcnIzQ0FAAFcMb48aN07V/8cUX0bJlS0ycOBHx8fE4ePAg5s6di0mTJsHUlMsD6eHkFpdhZngcZobHIbe4HF1drbFnel9MesQTUpZcpibKVCHDwpHe2DKlF5ytVUjOLkTImiNYFnkJ5Rqt2OFRIyZqP1hISAiysrKwaNEiqNVq+Pj4ICIiAu7u7gAAtVqN5ORkXXsLCwtERkbi9ddfR0BAAFq2bInRo0dj8eLFYn0EaiJOJd/CjO9jkZJdBJlUgumPtcerA9pCLhN9mhKRQfRpZ4d9sx7Fwp/OYWdsKj7/4zIOJ2RieYgf3GzNxA6P6kipVOKXX37RfS0GlgqnZk2jFbDqrwR89vtlaLQCXFuYYsXz3eDv3kLs0IhE81NcKt7+8SzySsphqZLjg6e6YERXZ7HDIiPQaAptiYEJBt11M68EM8NjcTihYvnpyK7OWPyUD7e6JgKQkl2IGd/H4lTybQDAmF6t8c4TnaEy0c+mWdQ4McGoARMMAoBjiVl4/btYZOSVwNREhv+N8sEz3V24fwjRv5RrtFjxx2Ws3J8AQQC8na0QNqY7Jzw3AmVlZdiyZQsAYMyYMc2vVLgYmGA0b1qtgDUHE/Hpbxeh0Qpo38oCYWO6o70D61oQ3c/BSzcxMzwO2QWlsFTK8clzvnjcx0nssKgGzbpUOJGh5RaX4eVvTuKjfReg0Qp4qpsLfnqtD5MLogd4tIM99kx/BAHuLZBXUo7Qb0/hg4jzXGVCNWKCQc3C5Rt5GLXyMH4/nwGFXIolT3fBstFdYaZgQSGi2nCyNsV3L/fGy4+2AQCsPZiI8RuPI7ugVOTIyFgxwaAmb9/ZdIz68jASMwvgbK3CD6GBeKFna863IKojE5kU/x3mhbAx3WGmkOFwQhZGfHEIZ1NzxA6NjBATDGqytFoBS3+7iNBvY1BQqkHvNrbY/foj8HW1ETs0okZtWBcn/DitD9xbmiH1dhGeWRWNn+JSxQ6LjAwTDGqSCkvLMW3LKXzxZwIAYPIjnvh2ci/YWXBfGiJ96Ohoid2vPoL+He1RUq7FjO/j8OmvF6HVNqt1A1QDJhjU5KhzivDc6iPYdy4dCpkUS5/rinee6MyqnER6Zm1mgvXje+CV/m0BACv3J2DallMoLC0XOTIyBpzhRk1KXMptvLT5JG7mlaCluQJrx/nD391W7LCImiyZVIL/e7wT2tlbYN7OM9h3Lh3X1xTiq3EBcLLmHlFiUSqV2LZtm+5rMbAOBjUZe8+oMTM8DiXlWnR0sMS68QHcQ4HIgE5ezcbUb2KQVVCKVpZKbJjQAz4u1mKHRXrEOhjU7Kw/lIRpW0+hpFyLxzq1wo5pQUwuiAwswMMWu17tgw4OFsjIK0HImiM4cOmm2GGRSJhgUKOm1QpY9HM8/vdLPAQB+E/v1vhqXAAslBz9IxKDm60ZfnglCH3atURBqQaTNp1A+InkB59IelVeXo7t27dj+/btKC8XZ04Mh0io0Sou02BWeBz2nk0HALw1tBOmPtqG9S2IjEBpuRZv7TiNnbEVy1enP9YOswZ34H+fBsJS4UT1lFNUhnHrj2Pv2YqVIiue90Nov7b85UVkJBRyKZaO7orXH2sHAPj8zwS8teMMy4s3I0wwqNHJyCvG82uP4vjVbFgq5fh6Uk886ecidlhEdA+JRII3gjtiydNdIJUA4SdT8OrWUygu04gdGhkAEwxqVJKzCvHc6iM4r86FnYUS4VMDEdi2pdhhEVENXujZGmFj/KGQSfHruRuYuPEE8orLxA6LGhgTDGo0zqtz8czqaFzLKoSbrSl2vBKIzs6cR0PUGDzu44hNk3rAQinHkcQsvPDVUWTml4gdFjUgJhjUKMSl3EbImiO4mVeCTo6W2BEaBPeW+pm0RESGEdTWDt+/3BstzRU4m5qLkDVHkJ5TLHZY1ECYYJDRO3E1G/9Zdwy5xeXo3toG4VMD0cpKJXZYRFQPPi7W2B4aCGdrFa7cLEDI2iO4fqtQ7LCoAYieYISFhcHT0xMqlQr+/v6Iioq6b9u//voLEomkyuvChQsGjJgM6XBCJsatP478knL0bmOLbyb3grWpidhhEdFDaGNvgfCpgXCzNcW1rEKErDmKq5kFYofVpCgUCmzcuBEbN26EQqEQJQZRE4zw8HDMnDkT8+fPR2xsLPr27YuhQ4ciObnmoiwXL16EWq3Wvdq3b2+giMmQ9l/IwMRNJ1BUpkG/DvbYNLEnzFlAi6hJcLM1w/apQWhjb47U20UYveYIEjLyxA6ryTAxMcGECRMwYcIEmJiI80eZqAnGsmXLMHnyZEyZMgVeXl5Yvnw53NzcsGrVqhrPa9WqFRwdHXUvmUxmoIjJUH6Pv4GXvzmJ0nItBnd2wNpx/lCZ8P9noqbE0VqF8JcD0cnR8k5p8aO4dINJRlMhWoJRWlqKmJgYBAcHVzoeHByM6OjoGs/t1q0bnJycMHDgQOzfv7/GtiUlJcjNza30IuP2x/kbeGVLDMo0Aob7OiFsTHco5UwuiJoie0slvnupN7ydrZBVUIoXvzqKy0wyHlp5eTn27NmDPXv2iFYqXLQEIzMzExqNBg4ODpWOOzg4ID09vdpznJycsHbtWuzYsQM7d+5Ex44dMXDgQBw8ePC+77NkyRJYW1vrXm5ubnr9HKRf+y9k4JVvT1UkF12csCLEDyYy0acKEVEDamGuwJYpvdDZyQqZ+aV44atjSMjIFzusRq2kpARPPPEEnnjiCZSUiLMcWPTf3PeWdhYE4b7lnjt27IiXXnoJ3bt3R2BgIMLCwjB8+HB8+umn973+vHnzkJOTo3ulpKToNX7Sn78uZmDqNzEo1Wgx1McRy5/3g5zJBVGzYGNWkWR4OVkhM78EL3x1FFduMslozET77W1nZweZTFaltyIjI6NKr0ZNevfujcuXL9/350qlElZWVpVeZHwOXc7Ey3eSiyHeDvj8hW7suSBqZu72ZHRytMTNvBK8sJarSxoz0X6DKxQK+Pv7IzIystLxyMhIBAUF1fo6sbGxcHJy0nd4ZEAnr2bjpc3/TOj84oXuTC6ImilbcwW2vtRbN/FzzLpjSLtdJHZYVA+irvmbPXs2xo4di4CAAAQGBmLt2rVITk5GaGgogIrhjdTUVGzevBkAsHz5cnh4eMDb2xulpaX49ttvsWPHDuzYsUPMj0EP4WxqDiZu/Gcp6soXu0EhZ3JB1JzZmivwzeReCFlzBImZBfjPumMInxoIe0ul2KFRHYiaYISEhCArKwuLFi2CWq2Gj48PIiIi4O7uDgBQq9WVamKUlpZizpw5SE1NhampKby9vbFnzx4MGzZMrI9AD+HyjTyMXX8MeSXl6Olhi9X/8edqESICULG65NspvfDc6ookY+z6Y/j+5d6wMROnaBTVnUQQBEHsIAwpNzcX1tbWyMnJ4XwMESVnFeLZ1dHIyCuBr6s1tkzpBUsVK3QSUWVXMwvw3J19iLq62WDLlF6wYMG9ByooKICFhQUAID8/H+bm+tm7qS7PUPZFk8HdzCvBf9YfQ0ZeCTo6WOLriT2ZXBBRtTzszPHt5F6wMTPB3ym3MfWbkygp14gdltFTKBRYuXIlVq5cKVqpcPZgkEHlFZfh+bVHcS4tt2LL9dAgblxGRA90+vptPL/2KApLNXjC1wmfP98NUmn1JQ2o4bAHg4xSSbkGL2+Owbm0XNhZKPDNpF5MLoioVnxdbbBmrD9MZBL8clqNRb/Eo5n9fdzoMMEgg9BoBcwKj8ORxCyYK2TYNLEnPOz0MyZIRM1D3/b2+PS5rgCATdFXEfbXFZEjMl4ajQZ//fUX/vrrL2g04gwpcaYMNThBEPDez+cQcSYdJjIJ1o4LgI+LtdhhEVEj9KSfC7LyS7Hol3h88utF2FsoMboHt4C4V3FxMQYMGABAv5M864I9GNTg1kUlYfORa5BIgM9C/NCnnZ3YIRFRIzbpEU9M698WADDvxzM4eOmmyBFRdZhgUIOKOKPG+xHnAQDzh3nhCV9nkSMioqZg7pCOeKqbCzRaAdO2nMKFdO6UbWyYYFCDibl2C7PC4wAA4wPdMfkRT3EDIqImQyKR4MNnuqCXpy3yS8oxceMJ3MgtFjss+hcmGNQgrmUV4KXNJ1FSrsUgr1Z4d4T3fXfJJSKqD6VchrVjA9DW3hzqnGJM3HgC+SXlYodFdzDBIL27XViKiRtPILugFF1crPH5C90g43p1ImoA1mYm2DSxJ+wsFIhX5+L1raeg0XL5qjFggkF6VabR4tWtp5CYWQAXG1OsHx8AMwUXKxFRw3GzNcO68T2gMpFi/8WbWHJn3heJi7/5Sa/+90s8DidkwUwhw7rxASykRUQG4edmg6XP+eHVraew7lASOjhYNuvlqyYmJvj44491X4uBCQbpzTdHr+mWoy4P8YOXE0uxE5HhDPd1wqUb7bHij8uYv+sMPO3N0cPDVuywRKFQKDB37lxRY+AQCelFdEImFu4+BwCYE9wRwd6OIkdERM3RjIHtMayLI8o0AkK/iUFKdqHYITVbTDDooV3LKsArWyomVj3p56wrgENEZGhSqQSfPtcV3s5WyCooxUubT6KgGa4s0Wg0OHHiBE6cOCFaqXAmGPRQCkvLMfWbGOQUlaGrmw0+esaXy1GJSFRmCjm+GhcAOwslLqTn4c0dp5vdxmjFxcXo2bMnevbsieJiceqD1CvBWLhwIa5du6bvWKiREQQB/7fjDC6k58HOQok1//GHykQmdlhERHC2McXq/3SHXCrBntNqfBWVKHZIzU69Eoyff/4Zbdu2xcCBA7F161bRsiMS1/pDSfj57zTIpRKEjekOR2uuGCEi4xHgYYsFIzoDAD7cewGHEzJFjqh5qVeCERMTg1OnTsHX1xezZs2Ck5MTXnnlFZw4cULf8ZGRir6SiSV7LwAA3h7uhZ6ezXOmNhEZt//0dscz3V2hFYDXtp7C9Vuc9Gko9Z6D4evri88++wypqanYsGEDUlNT0adPH3Tp0gUrVqxATk5Ora4TFhYGT09PqFQq+Pv7IyoqqlbnHT58GHK5HH5+fvX9CFRPabeL8PrWWGi0Ap7q5oLxQR5ih0REVC2JRIL3n/KBj4sVbhWWIfTbGBSXiTPpsbl56EmeWq0WpaWlKCkpgSAIsLW1xapVq+Dm5obw8PAazw0PD8fMmTMxf/58xMbGom/fvhg6dCiSk5NrPC8nJwfjxo3DwIEDHzZ8qqPSci2mbTmFrIJSdHaywgdPdeGkTiIyaioTGVb/xx8tzExwNjUXC346J3ZIzUK9E4yYmBi89tprcHJywqxZs9CtWzecP38eBw4cwIULF7BgwQJMnz69xmssW7YMkydPxpQpU+Dl5YXly5fDzc0Nq1atqvG8qVOn4sUXX0RgYGB9w6d6+nDvBcSl3IaVSo41Y/1hquCkTiIyfq4tzPDFC90hkQDhJ1Ow89R1sUNq8uqVYPj6+qJ3795ISkrC+vXrkZKSgg8//BDt2rXTtRk3bhxu3rx532uUlpYiJiYGwcHBlY4HBwcjOjr6vudt3LgRV65cwYIFC2oVa0lJCXJzcyu9qH72nU3HhsNJAIClo/3gZmsmckRERLX3SHs7zBjYHgAw/8ezuHwjT+SIGo6JiQkWLFiABQsWNK5S4c899xwmTZoEFxeX+7axt7eHVqu9788zMzOh0Wjg4OBQ6biDgwPS09OrPefy5ct46623EBUVBbm8dqEvWbIE7733Xq3a0v1dyyrA3B/+BgC8/GgbDO7s8IAziIiMz+uPtcfJq7dwKCET07acwk+v9WmSGzIqFAosXLhQ1Bjq1YPxzjvv6JILQRAeqoDJveP3giBUO6av0Wjw4osv4r333kOHDh1qff158+YhJydH90pJSal3rM1VcZkGr249hbzicvi7t8DcIR3FDomIqF5kUgk+C/FDK0slLmfk4+1dZ5tdES5DqfccjPXr18PHxwcqlQoqlQo+Pj5Yt25drc+3s7ODTCar0luRkZFRpVcDAPLy8nDy5Em89tprkMvlkMvlWLRoEf7++2/I5XL8+eef1b6PUqmElZVVpRfVzft7zuNsai5amJngixe6wUTGArBE1HjZWyrx+QvdIJUAO0+lYvvJpjcfQ6vV4ty5czh37lyNowkNqd49GDNmzMCIESOwfft2bN++HSNGjMCsWbPw9ttv1+oaCoUC/v7+iIyMrHQ8MjISQUFBVdpbWVnhzJkziIuL071CQ0PRsWNHxMXFoVevXvX5KPQA+86m45ujFVVbl4X4wdnGVOSIiIgeXu82LfFGcEVv7Lu7zyIhI1/kiPSrqKgIPj4+8PHxQVFRkSgx1GvgadWqVfjqq6/wwgsv6I6NHDkSvr6+eP3117F48eJaXWf27NkYO3YsAgICEBgYiLVr1yI5ORmhoaEAKoY3UlNTsXnzZkilUvj4+FQ6v1WrVrreE9I/dU4R3tp5GgAw9dE2GNCxlcgRERHpzyv92uLIlSwcSsjE9O9i8eOrQVDKuTJOX+rVg6HRaBAQEFDluL+/P8rLa79rXUhICJYvX45FixbBz88PBw8eREREBNzd3QEAarX6gTUxqGFotAJmfh+H24Vl8HW11mX6RERNhVQqwbLRXWFrrkC8Ohcf7b0odkhNikSox+yW119/HSYmJli2bFml43PmzEFRURG+/PJLvQWob7m5ubC2tkZOTg7nY9Tgy/0J+OTXizBTyLBnel942pmLHRIRUYP44/wNTP76JABg48QeTaK3tqCgABYWFgCA/Px8mJvr53d4XZ6h9V6bs379evz222/o3bs3AODo0aNISUnBuHHjMHv2bF27e5MQMn6nkm9hWeQlAMCiJ32YXBBRkzbQywETgjywKfoq5m7/G3tnPAp7S6XYYTV69Uowzp49i+7duwMArly5AqCi7oW9vT3Onj2ra8cS0o1PXnEZZnxfsc/IiK7OeKb7/WudEBE1FW8N7YSjiVm4kJ6HN7b/ja8n9uAz7CHVK8HYv3+/vuMgI/G/X+KRkl0E1xameP8pH/4HRkTNgspEhi9e6IYnvjiEg5du4tuj1zA20EPssBq1hy5ocP36daSmpuojFhJZZPwNbDt5HRIJsGy0H6xU4pSXJSISQ3sHS8wb2gkA8H7EeSRlFogcUf2ZmJhgzpw5mDNnjmilwuuVYGi1WixatAjW1tZwd3dH69atYWNjg//973+iFfSgh5OVX4J5d5akvty3DXp62oocERGR4Y0L9ECfdi1RXKbF7G1xKNc0zmeaQqHAJ598gk8++QQKhUKUGOqVYMyfPx8rV67Ehx9+iNjYWJw6dQoffPABvvjiC7zzzjv6jpEamCAI+O+PZ5CZX4qODpaYNbj2pdiJiJoSqVSCT57tCkuVHLHJt7HmYKLYITVa9Vqm6uzsjNWrV2PkyJGVjv/000+YNm2aUQ+ZcJlqVTtPXcfsbX9DLpVg16t94ONiLXZIRESi2hFzHW9sb7y/F7Vara6OVOvWrSGV6meLh7o8Q+v1jtnZ2ejUqVOV4506dUJ2dnZ9LkkiSbtdhAU/nQMAzBzUvtH9R0RE1BCe7u6CId4OKNcKeGPb3ygu04gdUp0UFRXB09MTnp6eopUKr1eC0bVrV6xcubLK8ZUrV6Jr164PHRQZhiAIeGvnGeSVlMPPzQah/dqKHRIRkVGQSCT44KkusLNQ4OKNPHzx52WxQ2p06rVM9eOPP8bw4cPx+++/IzAwEBKJBNHR0UhJSUFERIS+Y6QG8kPMdRy8dBMKuRRLR3eFnLukEhHptLRQYvGoLgj9NgarDyRiqI8Te3nroF5PlH79+uHSpUt46qmncPv2bWRnZ+Ppp5/GxYsX0bdvX33HSA0gI7cY//slHgAwa1AHtLW3EDkiIiLj87iPI4Z3cYJGK2DuD6dR1khXlYihzj0YZWVlCA4Oxpo1a/D+++83REzUwARBwNu7ziK3uBxdXKzxUl9PsUMiIjJaC0d6I/pKJs6rc7H6ryt4fWB7sUNqFOrcg2FiYoKzZ8+ywmMjtueMGr/F34BcKsHHz/pyaISIqAb2lkosGOENAPjizwRcupEnckSNQ72eLOPGjcP69ev1HQsZQHZBqW7VyKsD2sHLiUt1iYge5Ek/Zwzs1AqlGi3e/OE0NNo6V3hoduo1ybO0tBTr1q1DZGQkAgICqmwDyx1Ujdein88hq6CioNarA9qJHQ4RUaMgkUjw/lNdcHzZAcSl3MbGw0mY0reN2GHdl1wux7Rp03Rfi6FehbYGDBhQ48+NeTO05lxo6+Clmxi34TikEmDntD7wc7MROyQiokblu+PJmLfzDExNZPj9jX5wsTEVOySDqsszlLupNhPFZRq889NZABW19plcEBHVXUiAG3aeuo4TV29hwU/nsG58gNghGa16zcGYNGkS8vKqTnIpKCjApEmTHjoo0r8v9yfgWlYhHKyUeCOYe40QEdWHVFoxVCKXSvD7+Rv49Vy62CFVSxAE3Lx5Ezdv3kQ9Bir0ol4Jxtdff11t6dGioiJs3rz5oYMi/UrIyMPqA1cAAAtHeMOS27ATEdVbBwdLvPxoxfyLhbvPIb+kXOSIqiosLESrVq3QqlUrFBYWihJDnRKM3Nxc5OTkQBAE5OXlITc3V/e6desWIiIi0KpVqzoFEBYWBk9PT6hUKvj7+yMqKuq+bQ8dOoQ+ffqgZcuWMDU1RadOnfDZZ5/V6f2aG0EQMP/HsyjTCBjYqRUe93EUOyQiokbv9cfao7WtGdQ5xfgs8pLY4RilOs3BsLGxgUQigUQiQYcOVbvZJRIJ3nvvvVpfLzw8HDNnzkRYWBj69OmDNWvWYOjQoYiPj0fr1q2rtDc3N8drr70GX19fmJub49ChQ5g6dSrMzc3x8ssv1+WjNBs/xFzHsaRsmJrI8N6T3qxfQkSkB6YKGf43ygfjNxzHxsNJeKqbC8uI36NOq0gOHDgAQRDw2GOPYceOHbC1tdX9TKFQwN3dHc7OzrV+8169eqF79+5YtWqV7piXlxdGjRqFJUuW1OoaTz/9NMzNzfHNN9/Uqn1zWkVyq6AUjy39C7cKyzBvaCdM5WZmRER69drWU/jltBpdXa3x47Q+kEqN44+4goICWFhUbAGRn59fpZxEfTXYKpJ+/foBAJKSkuDm5vZQ+8uXlpYiJiYGb731VqXjwcHBiI6OrtU1YmNjER0djcWLF9+3TUlJCUpKSnTf5+bm1i/gRmhp5EXcKixDRwdLTHqE5cCJiPTt3Sc648DFm/j7eg62x6QgpEfV3vfmql7LVN3d3XH79m0cP34cGRkZ0Gorb/4ybty4B14jMzMTGo0GDg4OlY47ODggPb3mWbmurq64efMmysvLsXDhQkyZMuW+bZcsWVKnYZum4lxaDrYeSwYAvPekN0xYDpyISO9aWakwY1B7LN5zHh/vu4jHfZxgbcqJ9EA9E4yff/4ZY8aMQUFBASwtLSuN60skklolGP9u/2+CIDxwnkBUVBTy8/Nx9OhRvPXWW2jXrh1eeOGFatvOmzcPs2fP1n2fm5sLNze3WsfXGAmCgIW7z0ErAE/4OqF3m5Zih0RE1GSND/LA9ydSkJCRj88iL2HhSG+xQzIK9Uow3njjDUyaNAkffPABzMzM6vXGdnZ2kMlkVXorMjIyqvRq3MvTs6K7v0uXLrhx4wYWLlx43wRDqVRCqVTWK8bGavffaThx9RZMTWSYP9xL7HCIiJo0E5kUC0d44z/rj+Gbo9fwQs/W6OhoKWpMcrkc48eP130thnr1m6empmL69On1Ti6Aikmh/v7+iIyMrHQ8MjISQUFBtb6OIAiV5lg0dwUl5fgg4jwA4LXH2sHJunmVsSUiEsMj7e3wuLcjNFoBC3afFa241V1KpRKbNm3Cpk2bRPsju15pzZAhQ3Dy5Em0afNwG73Mnj0bY8eORUBAAAIDA7F27VokJycjNDQUQMXwRmpqqq5415dffonWrVujU6dOACrqYnz66ad4/fXXHyqOpuSLPxNwI7cE7i3NMKUvJ3YSERnK/OFe2H8xA0cTs7HnjBpP+NZ+VWVTVK8EY/jw4Zg7dy7i4+PRpUsXmJhUntAycuTIWl0nJCQEWVlZWLRoEdRqNXx8fBAREQF3d3cAgFqtRnJysq69VqvFvHnzkJSUBLlcjrZt2+LDDz/E1KlT6/MxmpykzAKsP5QIoGJms1IuEzkiIqLmw83WDK/0b4vlv1/G+3vOY2AnB5gqxPk9LAiCroKnmZmZKDWQ6rWbak3LUyUSCTQazUMF1ZCach2MlzefxG/xN9C/oz02TewpdjhERM1OcZkGA5ceQOrtIswe3AHTB7YXJQ5jqINRrzkYWq32vi9jTi6asqOJWfgt/gZkUgne5sROIiJRqExk+L+hFcP4qw9cQUZuscgRiadOCcawYcOQk5Oj+/7999/H7du3dd9nZWWhc+fOeguOakerFfD+noqJnS/0dEO7VuLOXiYias5G+DrBz80GhaUafPZ7892npE4Jxq+//lppxcZHH32E7Oxs3ffl5eW4ePGi/qKjWvnp71ScSc2BhVKOmYO4FTsRkZgkkn96ksNPpOBiep7IEYmjTgnGvdM1xF6GQxXjfZ/sq0jqXunfFnYWzavmBxGRMQrwsMVQH0doBeD9O6UDmhvWj27k1h9KQlpOMVxsTDGZ+40QERmNt4Z2golMgoOXbuLApZtih2NwdUow7m7Vfu8xEkdmfglW/XUFADB3SEeoTLgslYjIWLi3NMe4QA8AwAd7zkOjbV69/nWqgyEIAiZMmKCrClZcXIzQ0FDd8hdW1DSsFb9fRn5JOXxdrTGya/Mu6EJEZIxef6wdfoi5jos38rAj5jpG9zDMXlgymQzPPvus7msx1KkOxsSJE2vVbuPGjfUOqKE1lToYyVmFeGzpXyjXCvjupd4IbMsNzYiIjNFXBxPxfsR5OFur8Oec/o26t7kuz9A69WAYc+LQ3Cz//RLKtQL6trdjckFEZMTGBrrr5sttPZaMSc1kvhwneTZCF9Pz8GNcKgDgzSGdRI6GiIhqojKRYcagioqeX+5PQH5JucgRGQYTjEZo6W8XIQjAUB9HdHG1FjscIiJ6gGf9XeHR0gxZBaXYeCipwd+voKBAtzCjoKCgwd+vOkwwGpnY5Fv4Lf4GpBLgjWAW1SIiagxMZFLMDu4IAFh7MBG3CkpFjqjhMcFoZD79raKo1tPdXVkSnIioEXmiixO8nKyQV1KO1QeviB1Og2OC0YgcTsjE4YQsmMgkmDlInB36iIiofqRSCeYOqeh5/jr6Km408Y3QmGA0EoIg6HovxvRyh2sLM5EjIiKiuhrQsRX83VuguEyLlX8miB1Og2KC0UhEXc5EbPJtqEykeHVAO7HDISKiepBIJJhzZy5G+IkUqHOKRI6o4TDBaAQEQcCKPy4DqOi9sLfkhmZERI1VYNuW6Olpi1KNFmsOJIodToNhgtEIHLmShZhrt6CQSzH10TZih0NERA9pxsCKeXRbjycjowHmYshkMgwbNgzDhg0TrVQ4E4xG4G7vxYs9W6OVlUrkaIiI6GEFtW0Jf/cWKC3XYs1B/fdiqFQq7NmzB3v27IFKJc5zQ/QEIywsDJ6enlCpVPD390dUVNR92+7cuRODBw+Gvb09rKysEBgYiF9//dWA0Rre0cQsHEvKhkImxdR+7L0gImoKJBIJpt/pxdhy7Bpu5jW9zUJFTTDCw8Mxc+ZMzJ8/H7Gxsejbty+GDh2K5OTkatsfPHgQgwcPRkREBGJiYjBgwACMGDECsbGxBo7ccL74s6L3IqSHG5ysTUWOhoiI9OXR9nbwc7NBcZkW66Ka3lyMOu2mqm+9evVC9+7dsWrVKt0xLy8vjBo1CkuWLKnVNby9vRESEoJ33323Vu0b026qJ69m49nVR2Aik+CvuQPgYsMEg4ioKdl/IQMTN52AqYkMh/5vAFpa6GcSf0FBAVq1agUAyMjIgLm5uV6uW5dnqGg9GKWlpYiJiUFwcHCl48HBwYiOjq7VNbRaLfLy8mBra9sQIYru8ztrpJ/1d2NyQUTUBPXvaI8uLtYoKtNgvZ73KCksLERhYaFer1kXoiUYmZmZ0Gg0cHBwqHTcwcEB6enptbrG0qVLUVBQgNGjR9+3TUlJCXJzcyu9GoPT12/j4KWbkEslmNa/rdjhEBFRA/j3XIyvo68ip6hM5Ij0R/RJnhKJpNL3giBUOVad7777DgsXLkR4eLiuG6g6S5YsgbW1te7l5ub20DEbwt1ZxSO7OsPNllU7iYiaqkFerdDRwRIFpRpsPVb9HMTGSLQEw87ODjKZrEpvRUZGRpVejXuFh4dj8uTJ2LZtGwYNGlRj23nz5iEnJ0f3SklJeejYG1pyViH2nlEDAF7myhEioiZNIpHgpTs1jjYeTkJJuUbkiPRDtARDoVDA398fkZGRlY5HRkYiKCjovud99913mDBhArZu3Yrhw4c/8H2USiWsrKwqvYzdukOJ0ApAvw726ORo/PESEdHDGdnVGY5WKmTkleCnuDSxw9ELUYdIZs+ejXXr1mHDhg04f/48Zs2aheTkZISGhgKo6H0YN26crv13332HcePGYenSpejduzfS09ORnp6OnJwcsT6C3mUXlGLbyYpeFlbtJCJqHhRyKSb28QAArD2YCK1WtAWeeiNqghESEoLly5dj0aJF8PPzw8GDBxEREQF3d3cAgFqtrlQTY82aNSgvL8err74KJycn3WvGjBlifQS9++bINRSXaeHjYoXAti3FDoeIiAzkhV6tYaGUIyEjH/svZjzUtaRSKfr164d+/fpBKhXnUS9qHQwxGHMdjOIyDYI+/BPZBaX4/IVuGNnVWeyQiIjIgJZEnMeag4no6WmLbVMDxQ6nikZRB4Oq2h5zHdkFpXBtYYphPo5ih0NERAY2sY8nTGQSHE/KRlzKbbHDeShMMIyERivoSsVOfsQTchn/ryEiam4crVUY2dUFALD24BWRo3k4fIoZicj4dFzLKoS1qQlGBzSOWh1ERKR/L9+Z4L/vbDquZRXU6xoFBQWwt7eHvb09Cgrqd42HxQTDSGyKvgoAGNOrNcyVcnGDISIi0XR0tES/DvbQCsC3R6/V+zqZmZnIzMzUY2R1wwTDCFxMz8PRxGzIpBL8p7e72OEQEZHIJgR5AADCT6SgqLRxFt5igmEENh+5CgAI7uwAZ25qRkTU7PXrYI/WtmbILS7HT3GpYodTL0wwRJZTVIadpyr+8YwL9BA3GCIiMgpSqQRj7/Rof33kGhpjRQkmGCLbEXMdRWUadHCwQO82TXPbeSIiqrvnAlyhMpHivDoXJ6/dEjucOmOCISKtVtBN4BkX6FGrXWSJiKh5sDFTYJRfxZLVzUfqP9lTLEwwRHQoIROJmQWwVMrxVDcXscMhIiIjMzawYphk7xk1MnKLa32eVCpFQEAAAgICRCsVzgRDRHcndz7j78qlqUREVIW3szV6eLRAuVbA1uPJDz7hDlNTU5w4cQInTpyAqak4iweYYIgkJbsQf1yo2MzmboZKRER0r7sLALYcS0ZpuVbcYOqACYZIvj16DYIA9G1vh7b2FmKHQ0RERmqItyPsLZW4mVeCX8+lix1OrTHBEEGZRosdp64DgG4ZEhERUXUUcile6NkaQEXhrdooLCyEh4cHPDw8UFhY2JDh3RcTDBHsv5CBzPxS2Fko8VinVmKHQ0RERu45f1cAwOErmbh+68EJgyAIuHbtGq5dE6+GBhMMEWw7WdF78Ux3F+6aSkRED+Rma4agti0hCMCOmMZR2ZNPNwPLyCvG/osVkzufC3AVORoiImos7u60/cOpFGi1xl/ZkwmGge2KTYVGK6Bbaxu0a2UpdjhERNRIDPF2hKVSjpTsIhxNyhI7nAdigmFAgiDohkfuZqJERES1YaqQYYSfMwBg+51niTFjgmFAcSm3kZCRD5WJFE/4OokdDhERNTJ3/zjde1aN3OIykaOpmegJRlhYGDw9PaFSqeDv74+oqKj7tlWr1XjxxRfRsWNHSKVSzJw503CB6sHd3othPk6wVJmIHA0RETU2XV2t0b6VBYrLtPjlb/V920kkEnTu3BmdO3cWbZ8rUROM8PBwzJw5E/Pnz0dsbCz69u2LoUOHIjm5+nKoJSUlsLe3x/z589G1a1cDR/twiko1+PnvNADAcxweISKiepBIJLpejG0n718Tw8zMDOfOncO5c+dgZmZmqPAqETXBWLZsGSZPnowpU6bAy8sLy5cvh5ubG1atWlVtew8PD6xYsQLjxo2DtbW1gaN9OPvOqZFfUg43W1P08uS27EREVD+jurlAJpUgLuU2Lt/IEzuc+xItwSgtLUVMTAyCg4MrHQ8ODkZ0dLTe3qekpAS5ubmVXmLYdqJieOQ5fzdIpdyWnYiI6sfe8p8ijdtjjHeyp2gJRmZmJjQaDRwcHCodd3BwQHq6/mqtL1myBNbW1rqXm5vhhyfSc4p1S4qe8WftCyIiejh3K3vujkurtiZGYWEhvL294e3t3XxLhd87+UQQBL1OSJk3bx5ycnJ0r5SU2tVx16e9Z9UQBMDfvQVcbMTZNpeIiJqOfh3tYamUIz23GKeSb1X5uSAIiI+PR3x8fPMrFW5nZweZTFaltyIjI6NKr8bDUCqVsLKyqvQytIgzFTN9h3Xh0lQiInp4SrkMgzpXPCv3nLn/ahIxiZZgKBQK+Pv7IzIystLxyMhIBAUFiRSV/t3ILcbJaxXZ5bAujiJHQ0RETcXwO3+07j2TbpSlw+Vivvns2bMxduxYBAQEIDAwEGvXrkVycjJCQ0MBVAxvpKamYvPmzbpz4uLiAAD5+fm4efMm4uLioFAo0LlzZzE+wgPtPfPP8IiTNYdHiIhIP/p2sNMNk8Sm3IK/u3GtUBQ1wQgJCUFWVhYWLVoEtVoNHx8fREREwN3dHUBFYa17a2J069ZN93VMTAy2bt0Kd3d3XL161ZCh11rEmYohIA6PEBGRPt0dJvkxNhV7TqcbXYIhEcSa/SGS3NxcWFtbIycnp8HnY9zILUbvJX9AEIAj8x5jDwYREelVZPwNvLT5JJysVTj8f4/pyiAUFBTAwsICQEWPv7m5uV7ery7PUNFXkTRld4dHure2YXJBRER617e9HSyUcqhzKoZJ7pJIJHB3d4e7u3vzLBXe1HF4hIiIGpLKRIZBXhVFt/ac/mdVppmZGa5evYqrV682z1LhTVlGbjFOXMsGwASDiIgazt1nzN6zaqNaTcIEo4HsPZuuGx5xZnEtIiJqII92sP/XMMltscPRYYLRQPawuBYRERnAv4dJ7hZ2LCoqQo8ePdCjRw8UFRWJEhcTjAaQkVeME1c5PEJERIahGyY5o4YgCNBqtTh58iROnjwJrVYrSkxMMBrAocuZEATA19WawyNERNTgHu1gD5WJFGk5xUjIyBc7HABMMBrE0cSKnVMD27YUORIiImoOVCYy+Lu3APDPM0hsTDAawNHEiuGR3m2YYBARkWH09qx45tx9BomNCYaepd0uQnJ2IWRSCQLuZJNEREQNrXfbuwlGlmhbtP8bEww9O5ZU0TXl42INS5WJyNEQEVFz4etqDZWJFFkFpbhiBPMwmGDo2dErd4dHjGvTGSIiatqU8n/mYZy4dgt2dnaws7MTLR4mGHp29E4PBudfEBGRod2dhxGrLsLNmzdx8+ZNvW10VldMMPQo7XYRrmVx/gUREYnj7jyMY0YwD4MJhh5x/gUREYnp7jyMzPxSXLkp7jwMJhh6pJt/4cn5F0REZHhKuQzdW7eAtqwEIx4fjP79+4tWKlwuyrs2UZx/QUREYuvdpiUOnU/FhdhjuACwVHhjp86pmH8hlQABHpx/QURE4jCWP3KZYOjJsTuV07pw/gUREYmoq5s1lHLxH++iRxAWFgZPT0+oVCr4+/sjKiqqxvYHDhyAv78/VCoV2rRpg9WrVxso0prdrf1uLJkjERE1T0q5DN1a24gdhrgJRnh4OGbOnIn58+cjNjYWffv2xdChQ5GcnFxt+6SkJAwbNgx9+/ZFbGws/vvf/2L69OnYsWOHgSOvigkGEREZix4e4i82EDXBWLZsGSZPnowpU6bAy8sLy5cvh5ubG1atWlVt+9WrV6N169ZYvnw5vLy8MGXKFEyaNAmffvqpgSOvTJ1ThKucf0FEREai579WM4pVD0O0BKO0tBQxMTEIDg6udDw4OBjR0dHVnnPkyJEq7YcMGYKTJ0+irKys2nNKSkqQm5tb6aVvnH9BRETGpIurNSQmSkhMlEgUqR6GaAlGZmYmNBoNHBwcKh13cHBAenp6teekp6dX2768vByZmZnVnrNkyRJYW1vrXm5ubvr5AP/C4REiIjImttZWeP7Lv9B69g78faNElBhEr4MhkUgqfS8IQpVjD2pf3fG75s2bh9mzZ+u+z83N1XuSMX+4F4b4OMLVxlSv1yUiIqqvmYM6YNbgiuqeYhAtwbCzs4NMJqvSW5GRkVGll+IuR0fHatvL5XK0bFl974FSqYRSqdRP0PdhqTLBgI6tGvQ9iIiI6qKnyFWlRRsiUSgU8Pf3R2RkZKXjkZGRCAoKqvacwMDAKu1/++03BAQEwMSEcx+IiIgAoLi4GMOHD8fw4cNRXFwsSgyiDpHMnj0bY8eORUBAAAIDA7F27VokJycjNDQUQMXwRmpqKjZv3gwACA0NxcqVKzF79my89NJLOHLkCNavX4/vvvtOzI9BRERkVDQaDSIiInRfi0HUBCMkJARZWVlYtGgR1Go1fHx8EBERAXd3dwCAWq2uVBPD09MTERERmDVrFr788ks4Ozvj888/xzPPPCPWRyAiIqJqSASxN4w3sNzcXFhbWyMnJwdWVlZih0NERKR3BQUFsLCwAADk5+fD3NxcL9etyzNU9FLhRERE1PQwwSAiIiK9Y4JBREREeid6oS1DuzvlpCFKhhMRERmDgoIC3de5ubl6W0ly99lZm+mbzS7ByMvLA4AGKRlORERkbJydnfV+zby8PFhb11whtNmtItFqtUhLS4OlpWWNJcnr6m4J8pSUFK5O0QPeT/3jPdUv3k/94z3Vr4a4n4IgIC8vD87OzpBKa55l0ex6MKRSKVxdXRvs+lZWVvwPQ494P/WP91S/eD/1j/dUv/R9Px/Uc3EXJ3kSERGR3jHBICIiIr1jgqEnSqUSCxYsaPCdW5sL3k/94z3VL95P/eM91S+x72ezm+RJREREDY89GERERKR3TDCIiIhI75hgEBERkd4xwSAiIiK9Y4JRS2FhYfD09IRKpYK/vz+ioqJqbH/gwAH4+/tDpVKhTZs2WL16tYEibTzqck937tyJwYMHw97eHlZWVggMDMSvv/5qwGiNX13/jd51+PBhyOVy+Pn5NWyAjVBd72lJSQnmz58Pd3d3KJVKtG3bFhs2bDBQtI1DXe/pli1b0LVrV5iZmcHJyQkTJ05EVlaWgaI1bgcPHsSIESPg7OwMiUSCXbt2PfAcgz6bBHqg77//XjAxMRG++uorIT4+XpgxY4Zgbm4uXLt2rdr2iYmJgpmZmTBjxgwhPj5e+OqrrwQTExPhhx9+MHDkxquu93TGjBnCRx99JBw/fly4dOmSMG/ePMHExEQ4deqUgSM3TnW9n3fdvn1baNOmjRAcHCx07drVMME2EvW5pyNHjhR69eolREZGCklJScKxY8eEw4cPGzBq41bXexoVFSVIpVJhxYoVQmJiohAVFSV4e3sLo0aNMnDkxikiIkKYP3++sGPHDgGA8OOPP9bY3tDPJiYYtdCzZ08hNDS00rFOnToJb731VrXt33zzTaFTp06Vjk2dOlXo3bt3g8XY2NT1nlanc+fOwnvvvafv0Bql+t7PkJAQ4e233xYWLFjABOMedb2ne/fuFaytrYWsrCxDhNco1fWefvLJJ0KbNm0qHfv8888FV1fXBouxsapNgmHoZxOHSB6gtLQUMTExCA4OrnQ8ODgY0dHR1Z5z5MiRKu2HDBmCkydPoqysrMFibSzqc0/vpdVqkZeXB1tb24YIsVGp7/3cuHEjrly5ggULFjR0iI1Ofe7p7t27ERAQgI8//hguLi7o0KED5syZg6KiIkOEbPTqc0+DgoJw/fp1REREQBAE3LhxAz/88AOGDx9uiJCbHEM/m5rdZmd1lZmZCY1GAwcHh0rHHRwckJ6eXu056enp1bYvLy9HZmYmnJycGizexqA+9/ReS5cuRUFBAUaPHt0QITYq9bmfly9fxltvvYWoqCjI5fw1cK/63NPExEQcOnQIKpUKP/74IzIzMzFt2jRkZ2dzHgbqd0+DgoKwZcsWhISEoLi4GOXl5Rg5ciS++OILQ4Tc5Bj62cQejFq6d2t3QRBq3O69uvbVHW/O6npP7/ruu++wcOFChIeHo1WrVg0VXqNT2/up0Wjw4osv4r333kOHDh0MFV6jVJd/o1qtFhKJBFu2bEHPnj0xbNgwLFu2DJs2bWIvxr/U5Z7Gx8dj+vTpePfddxETE4N9+/YhKSkJoaGhhgi1STLks4l/ujyAnZ0dZDJZlQw7IyOjSiZ4l6OjY7Xt5XI5WrZs2WCxNhb1uad3hYeHY/Lkydi+fTsGDRrUkGE2GnW9n3l5eTh58iRiY2Px2muvAah4OAqCALlcjt9++w2PPfaYQWI3VvX5N+rk5AQXF5dKW1l7eXlBEARcv34d7du3b9CYjV197umSJUvQp08fzJ07FwDg6+sLc3Nz9O3bF4sXL272vcF1ZehnE3swHkChUMDf3x+RkZGVjkdGRiIoKKjacwIDA6u0/+233xAQEAATE5MGi7WxqM89BSp6LiZMmICtW7dyDPZf6no/rayscObMGcTFxeleoaGh6NixI+Li4tCrVy9DhW606vNvtE+fPkhLS0N+fr7u2KVLlyCVSuHq6tqg8TYG9bmnhYWFkEorP6ZkMhmAf/7yptoz+LOpQaaONjF3l1atX79eiI+PF2bOnCmYm5sLV69eFQRBEN566y1h7NixuvZ3lwLNmjVLiI+PF9avX89lqveo6z3dunWrIJfLhS+//FJQq9W61+3bt8X6CEalrvfzXlxFUlVd72leXp7g6uoqPPvss8K5c+eEAwcOCO3btxemTJki1kcwOnW9pxs3bhTkcrkQFhYmXLlyRTh06JAQEBAg9OzZU6yPYFTy8vKE2NhYITY2VgAgLFu2TIiNjdUt+xX72cQEo5a+/PJLwd3dXVAoFEL37t2FAwcO6H42fvx4oV+/fpXa//XXX0K3bt0EhUIheHh4CKtWrTJwxMavLve0X79+AoAqr/Hjxxs+cCNV13+j/8YEo3p1vafnz58XBg0aJJiamgqurq7C7NmzhcLCQgNHbdzqek8///xzoXPnzoKpqang5OQkjBkzRrh+/bqBozZO+/fvr/H3otjPJm7XTkRERHrHORhERESkd0wwiIiISO+YYBAREZHeMcEgIiIivWOCQURERHrHBIOIiIj0jgkGERER6R0TDCLSCw8PDyxfvlzsMFBYWIhnnnkGVlZWkEgkuH37dp2vYSyfhagxY4JBJKIJEyZAIpFAIpHAxMQEbdq0wZw5c1BQUCB2aPe1adMm2NjYVDl+4sQJvPzyy4YP6B5ff/01oqKiEB0dDbVaXWnzscbg4MGDGDFiBJydnSGRSLBr1y6xQyKqFyYYRCJ7/PHHoVarkZiYiMWLFyMsLAxz5syptm1ZWZmBo6v9+9vb28PMzMyA0VTvypUr8PLygo+PDxwdHRtkG+qGVFBQgK5du2LlypVih0L0UJhgEIlMqVTC0dERbm5uePHFFzFmzBjdX60LFy6En58fNmzYgDZt2kCpVEIQBCQnJ+PJJ5+EhYUFrKysMHr0aNy4cUN3zbvnrVmzBm5ubjAzM8Nzzz1XabhAq9Vi0aJFcHV1hVKphJ+fH/bt26f7+dWrVyGRSLBt2zb0798fKpUK3377LSZOnIicnBxdz8vChQsBVB1WqG2M33zzDTw8PGBtbY3nn38eeXl5Nd6vHTt2wNvbG0qlEh4eHli6dKnuZ/3798fSpUtx8OBBSCQS9O/f/77X2b17NwICAqBSqWBnZ4enn376vm2XLVuGLl26wNzcHG5ubpg2bVqlXVOvXbuGESNGoEWLFjA3N4e3tzciIiIAALdu3cKYMWNgb28PU1NTtG/fHhs3brzvew0dOhSLFy+uMR6ixoAJBpGRMTU1rdRTkJCQgG3btmHHjh2Ii4sDAIwaNQrZ2dk4cOAAIiMjceXKFYSEhFS6zt3zfv75Z+zbtw9xcXF49dVXdT9fsWIFli5dik8//RSnT5/GkCFDMHLkSFy+fLnSdf7v//4P06dPx/nz5zFw4EAsX74cVlZWUKvVUKvV1fa2CIJQqxivXLmCXbt24ZdffsEvv/yCAwcO4MMPP7zvvYmJicHo0aPx/PPP48yZM1i4cCHeeecdbNq0CQCwc+dOvPTSSwgMDIRarcbOnTurvc6ePXvw9NNPY/jw4YiNjcUff/yBgICA+76vVCrF559/jrNnz+Lrr7/Gn3/+iTfffFP381dffRUlJSU4ePAgzpw5g48++ggWFhYAgHfeeQfx8fHYu3cvzp8/j1WrVsHOzu6+70XUZDTYNmpE9EDjx48XnnzySd33x44dE1q2bCmMHj1aEISKXU5NTEyEjIwMXZvffvtNkMlkQnJysu7YuXPnBADC8ePHdefJZDIhJSVF12bv3r2CVCoV1Gq1IAiC4OzsLLz//vuV4unRo4cwbdo0QRAEISkpSQAgLF++vFKbjRs3CtbW1lU+i7u7u/DZZ5/VKUYzMzMhNzdX12bu3LlCr1697nu/XnzxRWHw4MGVjs2dO1fo3Lmz7vsZM2bUuHOsIAhCYGCgMGbMmPv+/N+fpTrbtm0TWrZsqfu+S5cuwsKFC6ttO2LECGHixIk1xnM/AIQff/yxXucSiY09GEQi++WXX2BhYQGVSoXAwEA8+uij+OKLL3Q/d3d3h729ve778+fPw83NDW5ubrpjnTt3ho2NDc6fP6871rp1a7i6uuq+DwwMhFarxcWLF5Gbm4u0tDT06dOnUix9+vSpdA0ANf5lfz+1jdHDwwOWlpa6752cnJCRkVHjdauL+fLly9BoNLWOLy4uDgMHDqx1+/3792Pw4MFwcXGBpaUlxo0bh6ysLN1k3OnTp2Px4sXo06cPFixYgNOnT+vOfeWVV/D999/Dz88Pb775JqKjo2v9vkSNGRMMIpENGDAAcXFxuHjxIoqLi7Fz5060atVK93Nzc/NK7QVBqHbi4v2O33X3Z/9uc2/76q5x7/vXRm1jNDExqRKjVqut03UFQahzfKamprVue+3aNQwbNgw+Pj7YsWMHYmJi8OWXXwL4Z9LrlClTkJiYiLFjx+LMmTMICAjQJYlDhw7FtWvXMHPmTKSlpWHgwIH3ncRL1JQwwSASmbm5Odq1awd3d/cqD9zqdO7cGcnJyUhJSdEdi4+PR05ODry8vHTHkpOTkZaWpvv+yJEjkEql6NChA6ysrODs7IxDhw5VunZ0dHSla1RHoVA8sLegtjHWVefOnauNuUOHDpDJZLW+jq+vL/74449atT158iTKy8uxdOlS9O7dGx06dKh0X+9yc3NDaGgodu7ciTfeeANfffWV7mf29vaYMGECvv32Wyxfvhxr166tdaxEjZVc7ACIqG4GDRoEX19fjBkzBsuXL0d5eTmmTZuGfv36VRrOUKlUGD9+PD799FPk5uZi+vTpGD16NBwdHQEAc+fOxYIFC9C2bVv4+flh48aNiIuLw5YtW2p8fw8PD+Tn5+OPP/5A165dYWZmVmV5am1jrKs33ngDPXr0wP/+9z+EhITgyJEjWLlyJcLCwup0nQULFmDgwIFo27Ytnn/+eZSXl2Pv3r2VJm7e1bZtW5SXl+OLL77AiBEjcPjwYaxevbpSm5kzZ2Lo0KHo0KEDbt26hT///FOXSL377rvw9/eHt7c3SkpK8Msvv9SYZOXn5yMhIUH3fVJSEuLi4mBra4vWrVvX6XMSiYk9GESNzN3iSy1atMCjjz6KQYMGoU2bNggPD6/Url27dnj66acxbNgwBAcHw8fHp9KDePr06XjjjTfwxhtvoEuXLti3bx92796N9u3b1/j+QUFBCA0NRUhICOzt7fHxxx/XO8a66t69O7Zt24bvv/8ePj4+ePfdd7Fo0SJMmDChTtfp378/tm/fjt27d8PPzw+PPfYYjh07Vm1bPz8/LFu2DB999BF8fHywZcsWLFmypFIbjUaDV199FV5eXnj88cfRsWNH3b1WKBSYN28efH198eijj0Imk+H777+/b2wnT55Et27d0K1bNwDA7Nmz0a1bN7z77rt1+oxEYpMI9RnAJCKjtnDhQuzatUu3rJWIyNDYg0FERER6xwSDiIiI9I5DJERERKR37MEgIiIivWOCQURERHrHBIOIiIj0jgkGERER6R0TDCIiItI7JhhERESkd0wwiIiISO+YYBAREZHeMcEgIiIivft/t0R3ux0Ncc4AAAAASUVORK5CYII=", + "text/plain": [ + "
" ] }, "metadata": {}, @@ -793,22 +892,23 @@ "source": [ "from ipywidgets import interact\n", "\n", - "@interact(proportion=(0., 1.0))\n", + "\n", + "@interact(proportion=(0.0, 1.0))\n", "def plot_entropy(proportion=0.5):\n", " ps = np.linspace(0, 1, 100)\n", - " ents = [entropy([p, 1-p]) for p in ps]\n", + " ents = [entropy([p, 1 - p]) for p in ps]\n", " plt.figure(figsize=(6, 3))\n", " plt.plot(ps, ents)\n", - " plt.ylabel('Entropy')\n", - " plt.xlabel('Proportion of class 1')\n", - " plt.axvline(proportion, linestyle='--', color='k')" + " plt.ylabel(\"Entropy\")\n", + " plt.xlabel(\"Proportion of class 1\")\n", + " plt.axvline(proportion, linestyle=\"--\", color=\"k\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "As you can see the entropy is 0 when you have no mixing between classes and it's maximal when you have 50% of each class." + "As you can see the entropy is 0 when you have no mixing between classes (dirac) and it's maximal when you have 50% of each class (uniform distribution)." ] }, { @@ -851,55 +951,50 @@ } ], "source": [ - "parent_entropy = entropy(\n", - " dataset.index.value_counts(normalize=True)\n", - ")\n", + "parent_entropy = entropy(dataset.index.value_counts(normalize=True))\n", "parent_entropy" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.0" + "0.5033378767446246" ] }, - "execution_count": 28, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "left_entropy = entropy(\n", - " dataset[:random_idx].index.value_counts(normalize=True)\n", - ")\n", + "# draw a random threshold and compute the entropy.\n", + "left_entropy = entropy(dataset[:random_idx].index.value_counts(normalize=True))\n", "left_entropy" ] }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.5811158380314033" + "0.06335477530377637" ] }, - "execution_count": 29, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "right_entropy = entropy(\n", - " dataset[random_idx:].index.value_counts(normalize=True)\n", - ")\n", + "right_entropy = entropy(dataset[random_idx:].index.value_counts(normalize=True))\n", "right_entropy" ] }, @@ -912,10 +1007,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 31, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "0.1212240270774031" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ + "# How much the entropy is reduced by the splitting?\n", "parent_entropy - (left_entropy + right_entropy)" ] }, @@ -923,12 +1030,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "However, we should normalize the entropies with the number of samples in each sets." + "However, we should normalize the entropies with the number of samples in each sets. To have balanced nodes, weight the entropy by the number of nodes." ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -943,36 +1050,33 @@ " n_samples_right = labels_right.size\n", "\n", " # normalize with the number of samples\n", - " normalized_entropy_left = ((n_samples_left / n_samples_parent) * \n", - " entropy_left)\n", - " normalized_entropy_right = ((n_samples_right / n_samples_parent) *\n", - " entropy_right)\n", + " normalized_entropy_left = (n_samples_left / n_samples_parent) * entropy_left\n", + " normalized_entropy_right = (\n", + " n_samples_right / n_samples_parent\n", + " ) * entropy_right\n", "\n", - " return (entropy_parent -\n", - " normalized_entropy_left - normalized_entropy_right)" + " return entropy_parent - normalized_entropy_left - normalized_entropy_right" ] }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "0.33161207770508966" + "0.32267568823487636" ] }, - "execution_count": 31, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "information_gain(\n", - " dataset.index,\n", - " dataset[:random_idx].index,\n", - " dataset[random_idx:].index\n", + " dataset.index, dataset[:random_idx].index, dataset[random_idx:].index\n", ")" ] }, @@ -985,25 +1089,29 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "all_information_gain = pd.Series(\n", - " [information_gain(dataset.index, dataset[:idx].index, dataset[idx:].index)\n", - " for idx in range(dataset.size)],\n", + " [\n", + " information_gain(\n", + " dataset.index, dataset[:idx].index, dataset[idx:].index\n", + " )\n", + " for idx in range(dataset.size)\n", + " ],\n", " index=dataset,\n", ")" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1019,22 +1127,12 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 38, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/homebrew/Caskroom/miniforge/base/envs/base_env/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", - " with pd.option_context('mode.use_inf_as_na', True):\n", - "/opt/homebrew/Caskroom/miniforge/base/envs/base_env/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", - " with pd.option_context('mode.use_inf_as_na', True):\n" - ] - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1057,7 +1155,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 39, "metadata": {}, "outputs": [ { @@ -1066,7 +1164,7 @@ "4350.0" ] }, - "execution_count": 35, + "execution_count": 39, "metadata": {}, "output_type": "execute_result" } @@ -1077,32 +1175,22 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 40, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/opt/homebrew/Caskroom/miniforge/base/envs/base_env/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", - " with pd.option_context('mode.use_inf_as_na', True):\n", - "/opt/homebrew/Caskroom/miniforge/base/envs/base_env/lib/python3.10/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n", - " with pd.option_context('mode.use_inf_as_na', True):\n" - ] - }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 36, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1114,10 +1202,16 @@ "source": [ "ax = (all_information_gain * -1).plot(color=\"red\", label=\"Information gain\")\n", "ax = sns.swarmplot(x=dataset.values, y=[\"\"] * len(dataset), hue=dataset.index)\n", - "ax.vlines(\n", - " all_information_gain.idxmax(), -1, 1,\n", - " color=\"red\", linestyle=\"--\"\n", - ")" + "ax.vlines(all_information_gain.idxmax(), -1, 1, color=\"red\", linestyle=\"--\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> Quadratic complexity with this greedy method.\n", + "> Sort the values to scan the dataset in a more efficient way -> $\\mathcal{O}( n \\log n)$.\n", + "> " ] }, { @@ -1129,12 +1223,12 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 42, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1151,26 +1245,441 @@ "X = x.reshape(-1, 1)\n", "\n", "plt.figure()\n", - "plt.xlabel('Feature X')\n", - "plt.ylabel('Target y')\n", + "plt.xlabel(\"Feature X\")\n", + "plt.ylabel(\"Target y\")\n", "_ = plt.scatter(X, y)" ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "
DecisionTreeRegressor(max_depth=2)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" + "
DecisionTreeRegressor(max_depth=2)
In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook.
On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.
" ], "text/plain": [ "DecisionTreeRegressor(max_depth=2)" ] }, - "execution_count": 38, + "execution_count": 43, "metadata": {}, "output_type": "execute_result" } @@ -1184,12 +1693,12 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 44, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1203,8 +1712,8 @@ "y_test = reg.predict(X_test)\n", "\n", "plt.figure()\n", - "plt.plot(X_test.ravel(), y_test, color='tab:blue', label=\"prediction\")\n", - "plt.plot(X.ravel(), y, 'C7.', label=\"training data\")\n", + "plt.plot(X_test.ravel(), y_test, color=\"tab:blue\", label=\"prediction\")\n", + "plt.plot(X.ravel(), y, \"C7.\", label=\"training data\")\n", "_ = plt.legend(loc=\"best\")" ] }, @@ -1261,11 +1770,131 @@ "X_test = np.linspace(-3, 3, 1000).reshape((-1, 1))\n", "y_test = reg.predict(X_test)\n", "plt.figure()\n", - "plt.plot(X_test.ravel(), y_test, color='tab:blue', label=\"prediction\")\n", - "plt.plot(X.ravel(), y, 'C7.', label=\"training data\")\n", + "plt.plot(X_test.ravel(), y_test, color=\"tab:blue\", label=\"prediction\")\n", + "plt.plot(X.ravel(), y, \"C7.\", label=\"training data\")\n", "_ = plt.legend(loc=\"best\")" ] }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "51fd695366244694afd8f0d8820b6987", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(IntSlider(value=1, description='max_depth', max=10, min=1), Output()), _dom_classes=('wi…" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGxCAYAAABfrt1aAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAh5xJREFUeJztnXecVOW9/z9nZnZm+8Auve66IEVAXLCABVADWEDNNVFjVG4s1xvQEH8muaaqMSHJtazR2BKD3sSoSSyAFWyoNCmiIIIgS5EOK7PAsjs7M8/vj5lz5rQ5e6aX/bxfL52dM6c858xwns/5VkkIIUAIIYQQkgUc2R4AIYQQQjovFCKEEEIIyRoUIoQQQgjJGhQihBBCCMkaFCKEEEIIyRoUIoQQQgjJGhQihBBCCMkaFCKEEEIIyRoUIoQQQgjJGhQihOQBTz31FCRJgiRJeO+99wyfCyEwaNAgSJKEiRMnZnx8sZg4cWLax7Nhwwbceeed2LZtm+nxR4wYkfJj7tmzBzNmzECPHj1QXFyMUaNG4cknn0z5cQjpDFCIEJJHVFRUmE54ixcvxpdffomKioosjCq7bNiwAXfddZepEEkHPp8PZ511Ft5++2384Q9/wLx581BfX48bbrgB999/f0bGQEgh4cr2AAgh9rniiivwzDPP4E9/+hMqKyuV5U8++STGjRuH5ubmLI6uc/Doo49i69atWLVqFcaMGQMAmDJlCvbs2YNf/vKX+N73vocuXbpkd5CE5BG0iBCSR1x11VUAgGeffVZZ5vP58MILL+B73/ue6TZ33XUXTj/9dFRVVaGyshL19fV48sknoe53+eGHH6KoqAi33367ZlvZJdSR20EIgT/84Q8YOHAgiouLUV9fj9dff9103ebmZtx+++2ora2F2+1G3759MXv2bBw7dkyzniRJmDVrFh5//HGceOKJ8Hg8GD58OJ577jnN+L71rW8BACZNmqS4r5566inNvlauXImzzz4bpaWlOOGEE/C73/0OoVDI8pxisWTJEvTs2VMRITIXX3wxjh07hjfeeCOh/RLSaRGEkJxn7ty5AoBYuXKluOaaa8Rpp52mfPboo4+KsrIy0dzcLE466SQxYcIEzbYzZswQTz75pFi0aJFYtGiR+PWvfy1KSkrEXXfdpVnvd7/7nQAg5s2bJ4QQYv369aK0tFR897vf7XB8v/rVrwQAcf3114vXX39dPPHEE6Jv376iV69emvEcO3ZMjB49WnTr1k3cf//94q233hIPPvig8Hq94txzzxWhUEhZF4Do37+/GD58uHj22WfF/PnzxdSpUwUA8a9//UsIIcT+/fvFb3/7WwFA/OlPfxLLli0Ty5YtE/v37xdCCDFhwgRRXV0tBg8eLB577DGxaNEi8f3vf18AEE8//bTmHCZMmCDs3BInT54sBgwYYFj++OOPCwDijjvu6HAfhJAoFCKE5AFqIfLuu+8KAGL9+vVCCCFOPfVUMWPGDCGEMBUiaoLBoGhvbxd33323qK6u1kz8oVBIXHjhhaJLly5i/fr1Yvjw4WLo0KHi6NGjlmP7+uuvRXFxsbjssss0y5csWSIAaMYzZ84c4XA4xMqVKzXr/vvf/xYAxGuvvaYsAyBKSkrE3r17lWWBQEAMHTpUDBo0SFn2r3/9SwAQ7777rmFssrhYsWKFZvnw4cPFlClTNMvOPfdc4XQ6Lc9VCCFmz54tHA6H2L59u2b5NddcIwCIm266qcN9EEKi0DVDSJ4xYcIE1NXV4a9//SvWrVuHlStXxnTLAMA777yD888/H16vF06nE0VFRfjlL3+JQ4cOYf/+/cp6kiTh//7v/1BRUYGxY8eisbER//znP1FWVmY5nmXLlqG1tRVXX321Zvn48eMxcOBAzbJXXnkFI0aMwOjRoxEIBJT/pkyZYpoRdN5556Fnz57Ke6fTiSuuuAJbtmzBV1991dGlAgD06tULp512mmbZqFGjsH37ds2yt99+G4FAoMP93XTTTSgqKsLVV1+Nzz77DIcOHcKf/vQnPP/88wAAh4O3VULigf9iCMkzJEnCf/7nf+Lvf/87HnvsMZx44ok4++yzTdf96KOPMHnyZADAn//8ZyxZsgQrV67Ez372MwDA8ePHNetXV1dj+vTpaG1txdSpUzFy5MgOx3Po0CEA4Qlfj37Zvn378Omnn6KoqEjzX0VFBYQQOHjwoOX26mXycTuiurrasMzj8RjO3S7Dhg3DSy+9hO3bt2PEiBHo1q0bfv/73+O+++4DAPTt2zeh/RLSWWHWDCF5yIwZM/DLX/4Sjz32GH7zm9/EXO+5555DUVERXnnlFRQXFyvLX375ZdP1Fy1ahEcffRSnnXYaXnrpJbzwwgv4j//4D8uxyBP93r17DZ/t3bsXNTU1yvtu3bqhpKQEf/3rX0331a1bN8P2ZvtUHzcbXHDBBdi+fTu2bNmCQCCAE088Ef/85z8BAOecc07WxkVIPkIhQkge0rdvX/zoRz/Cxo0bcd1118VcT5IkuFwuOJ1OZdnx48fxt7/9zbDunj178N3vfhcTJkzAokWL8M1vfhPXX3896uvrUVtbG/MYZ5xxBoqLi/HMM89oRMvSpUuxfft2jRC5+OKL8dvf/hbV1dWW+5R5++23sW/fPsU9EwwG8fzzz6Ourg79+vUDELZuyOeVSSRJwuDBgwEAfr8fDz74IEaPHk0hQkicUIgQkqf87ne/63Cdiy66CPfffz++853v4KabbsKhQ4dw7733KpO3TDAYxFVXXQVJkvCPf/wDTqcTTz31FEaPHo0rrrgCH374Idxut+kxunbtittvvx333HMPbrjhBnzrW9/Czp07ceeddxpcK7Nnz8YLL7yAc845Bz/84Q8xatQohEIh7NixAwsXLsT/+3//D6effrqyfrdu3XDuuefiF7/4BcrKyvDII49g48aNmhReuXLqE088gYqKChQXF6O2tjZui8l5552HxYsX24oTueWWWzBx4kRUV1dj69at+OMf/4ivvvoKixcvjuuYhBAwfZeQfECdNWOFWdbMX//6VzFkyBDh8XjECSecIObMmSOefPJJAUA0NjYKIYT42c9+JhwOh3j77bc12y5dulS4XC7xgx/8wPK4oVBIzJkzR/Tv31+43W4xatQosWDBAjFhwgTDeI4ePSp+/vOfiyFDhgi32y28Xq8YOXKk+OEPf6jJkAEgZs6cKR555BFRV1cnioqKxNChQ8UzzzxjOH5DQ4Oora0VTqdTABBz584VQoSzZk466STD+tddd50YOHCgZpnd9F0hhLjkkktE7969RVFRkejVq5eYMWOG2LZtm61tCSFaJCFUVY0IISRHkCQJM2fOxMMPP5ztoRBC0gizZgghhBCSNShECCGEEJI1GKxKCMlJ6DUmpHNAiwghhBBCsgaFCCGEEEKyBoUIIYQQQrJGTseIhEIh7N69GxUVFZAkKdvDIYQQQogNhBA4cuQI+vTp02EjyJwWIrt370b//v2zPQxCCCGEJMDOnTuVdgyxyGkhUlFRASB8IpWVlVkeDSGEEELs0NzcjP79+yvzuBU5LURkd0xlZSWFCCGEEJJn2AmrYLAqIYQQQrIGhQghhBBCsgaFCCGEEEKyRk7HiNhBCIFAIIBgMJjtoZAcxel0wuVyMQWcEEJykLwWIn6/H3v27EFLS0u2h0JynNLSUvTu3RtutzvbQyGEEKIib4VIKBRCY2MjnE4n+vTpA7fbzSdeYkAIAb/fjwMHDqCxsRGDBw/usLgOIYSQzJG3QsTv9yMUCqF///4oLS3N9nBIDlNSUoKioiJs374dfr8fxcXF2R4SIYSQCHn/aMinW2IH/k4IISQ34d2ZEEIIIVmDQoQQQgghWYNCpMCpqalBQ0OD8l6SJLz88stJ7TMV+yCEkFTi8/nQ2NgIn8+X7aGQOMnbYFWSGHv27EHXrl1trXvnnXfi5Zdfxtq1axPeByGEpJs1a9ZgwYIFEEJAkiRMmzYN9fX12R4WsQktInmA3+9P2b569eoFj8eT9X0QQkgqWLHpK8yfPx9CCADhlP358xfgYNPh7A6M2KaghIgQAi3+QFb+k/8R2GHixImYNWsWZs2ahS5duqC6uho///nPlX3U1NTgnnvuwYwZM+D1enHjjTcCAJYuXYpzzjkHJSUl6N+/P2699VYcO3ZM2e/+/fsxbdo0lJSUoLa2Fs8884zh2Hq3yldffYUrr7wSVVVVKCsrw9ixY7FixQo89dRTuOuuu/DJJ59AkiRIkoSnnnrKdB/r1q3Dueeei5KSElRXV+Omm27C0aNHlc9nzJiBSy+9FPfeey969+6N6upqzJw5E+3t7bavGSGEmPHIG2tNlgq8v25rpodCEqSgXDPH24MY/ss3s3LsDXdPQanb/uV8+umncf3112PFihVYtWoVbrrpJgwcOFARHf/7v/+LX/ziF/j5z38OIDzZT5kyBb/+9a/x5JNP4sCBA4qYmTt3LoDwhL9z50688847cLvduPXWW7F///6YYzh69CgmTJiAvn37Yv78+ejVqxfWrFmDUCiEK664AuvXr8cbb7yBt956CwDg9XoN+2hpacHUqVNxxhlnYOXKldi/fz9uuOEGzJo1SxEuAPDuu++id+/eePfdd7FlyxZcccUVGD16tHK+hBCSCF8H3RgoAIeqnmVIACFPefYGReKioIRIPtG/f3888MADkCQJQ4YMwbp16/DAAw8oE/O5556L22+/XVn/2muvxXe+8x3Mnj0bADB48GD88Y9/xIQJE/Doo49ix44deP3117F8+XKcfvrpAIAnn3wSw4YNizmGf/zjHzhw4ABWrlyJqqoqAMCgQYOUz8vLy+FyudCrV6+Y+3jmmWdw/Phx/N///R/KysoAAA8//DCmTZuG3//+9+jZsycAoGvXrnj44YfhdDoxdOhQXHTRRXj77bcpRAghSdEqebAsUIMz3dsBISAALAvUYExxWbaHRmxSUEKkpMiJDXdPydqx4+GMM87QlKQfN24c7rvvPqV539ixYzXrr169Glu2bNG4W4QQSqn7L774Ai6XS7Pd0KFD0aVLl5hjWLt2LU455RRFhCTC559/jpNPPlkRIQBw5plnIhQKYdOmTYoQOemkk+B0Rq9R7969sW7duoSPSwghABAMCXwZ7I6fXjYJNRUh3LVwOzY3HkMoDnc5yS4FJUQkSYrLPZLLqCd2INxb57/+679w6623GtYdMGAANm3aBABx9dspKSlJbpCAEqVuhnp5UVGR4bNQKJT08QkhnRtZb5RVVKC2tgqhogMAjoE6JH8oqGDVfGL58uWG94MHD9ZYDdTU19fjs88+w6BBgwz/ud1uDBs2DIFAAKtWrVK22bRpEw4fPhxzDKNGjcLatWvR1NRk+rnb7VYsNLEYPnw41q5dqwmaXbJkCRwOB0488UTLbQkhJFmCEcXhjMxmcqxIiEIkb6AQyRI7d+7Ebbfdhk2bNuHZZ5/FQw89hB/84Acx1//JT36CZcuWYebMmVi7di02b96M+fPn45ZbbgEADBkyBFOnTsWNN96IFStWYPXq1bjhhhssrR5XXXUVevXqhUsvvRRLlizB1q1b8cILL2DZsmUAwtk7jY2NWLt2LQ4ePIi2tjbDPq6++moUFxfjuuuuw/r16/Huu+/illtuwTXXXKO4ZQghJF0EI4pDtsDKdth4MhlJdqEQyRLXXnstjh8/jtNOOw0zZ87ELbfcgptuuinm+qNGjcLixYuxefNmnH322TjllFPwi1/8Ar1791bWmTt3Lvr3748JEybgm9/8Jm666Sb06NEj5j7dbjcWLlyIHj164MILL8TIkSPxu9/9TrHK/Md//AemTp2KSZMmoXv37nj22WcN+ygtLcWbb76JpqYmnHrqqbj88stx3nnn4eGHH07i6hBCiD1kveGMCBFH5JU6JH+QRA7LxubmZni9Xvh8PlRWVmo+a21tRWNjI2pra/OurfvEiRMxevRoTel1kl7y+fdCCInNGb99G3ubW7Fg1lkY2c+LG55eibc+34/f/8dIXHHqgGwPr9NiNX/roUWEEEJI3iJnxzgis5nsomGMSP5AIUIIISRvCSnBqrJrRruc5D6FkeuaZ7z33nvZHgIhhBQEcrCqQwlWZYxIvkGLCCGEkLxFdsHIQkR20eRw+CPRkTEhMmfOHEiSpJQoJ4QQQpIlpFhEwu8Vi0i2BkTiJiNCZOXKlXjiiScwatSoTByOEEJIJ0EfIyIXdA4xWjVvSLsQOXr0KK6++mr8+c9/RteuXdN9OEIIIZ0IubKqQ1dHhDokf0i7EJk5cyYuuuginH/++R2u29bWhubmZs1/hBBCSCzkllUOnUWEOiR/SGvWzHPPPYc1a9Zg5cqVttafM2cO7rrrrnQOiRBCSAGhuGYMlVUpRfKFtFlEdu7ciR/84Af4+9//bruS5R133AGfz6f8t3PnznQNr6CoqamJq0rre++9B0mSLBvipYunnnoKXbp0yfhxCSGFSdQ1E34f7TWTnfGQ+EmbEFm9ejX279+PMWPGwOVyweVyYfHixfjjH/8Il8tl2tXV4/GgsrJS818hMnHixJRmD61cudKyT42e8ePHY8+ePfB6vSkbQzqJV2gRQjoHQghFcERdM3KMCJVIvpA218x5552HdevWaZb953/+J4YOHYqf/OQnMdvdZwufz4empiZUVVXlxAQthEAwGITL1fFX1L1797j27Xa70atXr0SHRgghOYE6IDXqmjF+RnKbtFlEKioqMGLECM1/ZWVlqK6uxogRI9J12IRYs2YNGhoa8PTTT6OhoQFr1qxJ27FmzJiBxYsX48EHH4QkSZAkCdu2bVPcJW+++SbGjh0Lj8eDDz74AF9++SUuueQS9OzZE+Xl5Tj11FPx1ltvafaptxhIkoS//OUvuOyyy1BaWorBgwdj/vz5yud614zsLnnzzTcxbNgwlJeXY+rUqdizZ4+yTSAQwK233oouXbqguroaP/nJT3Ddddfh0ksvtTzfp556CgMGDEBpaSkuu+wyHDp0SPN5R+c3ceJEbN++HT/84Q+V6wUAhw4dwlVXXYV+/fqhtLQUI0eONO0OTAgpXIIqtaFUVlWCValE8oVOX1nV5/NhwYIFSmCTEAILFiyAz+dLy/EefPBBjBs3DjfeeCP27NmDPXv2oH///srnP/7xjzFnzhx8/vnnGDVqFI4ePYoLL7wQb731Fj7++GNMmTIF06ZNw44dOyyPc9ddd+Hb3/42Pv30U1x44YW4+uqr0dTUFHP9lpYW3Hvvvfjb3/6G999/Hzt27MDtt9+ufP773/8ezzzzDObOnYslS5agubkZL7/8suUYVqxYge9973v4/ve/j7Vr12LSpEm45557NOt0dH4vvvgi+vXrh7vvvlu5XkC4m+6YMWPwyiuvYP369bjppptwzTXXYMWKFZZjIoQUDmr3i1xRNRqsmo0RkUTIaK+ZXOyx0tTUZIiuFkKgqakpLS4ar9cLt9uN0tJSU/fI3XffjW984xvK++rqapx88snK+3vuuQcvvfQS5s+fj1mzZsU8zowZM3DVVVcBAH7729/ioYcewkcffYSpU6eart/e3o7HHnsMdXV1AIBZs2bh7rvvVj5/6KGHcMcdd+Cyyy4DADz88MN47bXXLM/1wQcfxJQpU/A///M/AIATTzwRS5cuxRtvvKGsc/LJJ1ueX1VVFZxOJyoqKjTXq2/fvhqhdMstt+CNN97Av/71L5x++umW4yKEFAYaIaK3iFCJ5A2d3iJSVVWlmPtlJElCVVVVVsYzduxYzftjx47hxz/+MYYPH44uXbqgvLwcGzdu7NAioq5iW1ZWhoqKCuzfvz/m+qWlpYoIAYDevXsr6/t8Puzbtw+nnXaa8rnT6cSYMWMsx/D5559j3LhxmmX694meXzAYxG9+8xuMGjUK1dXVKC8vx8KFCzvcjhBSOGhiRAzBqtkYEUmETt991+v1Ytq0aYp7RpIkTJs2LWsBq2VlZZr3P/rRj/Dmm2/i3nvvxaBBg1BSUoLLL78cfr/fcj9FRUWa95IkISRX/rG5vv6JQi/YOnrisPNEkuj53XfffXjggQfQ0NCAkSNHoqysDLNnz+5wO0JI4WAaIxJ5z6yZ/KHTCxEAqK+vR11dXcayZtxut2n6shkffPABZsyYobhEjh49im3btqVxdEa8Xi969uyJjz76CGeffTaAsEXi448/xujRo2NuN3z4cCxfvlyzTP/ezvmZXa8PPvgAl1xyCb773e8CAEKhEDZv3oxhw4YlcoqEkDwkpBEi8mtyMSK5lkHZGaAQieD1ejP2o6upqcGKFSuwbds2lJeXW7qBBg0ahBdffBHTpk2DJEn4xS9+YWnZSBe33HIL5syZg0GDBmHo0KF46KGH8PXXXxusJGpuvfVWjB8/Hn/4wx9w6aWXYuHChZr4EMDe+dXU1OD999/HlVdeCY/Hg27dumHQoEF44YUXsHTpUnTt2hX3338/9u7dSyFCSCdCbfWQXTOOJGJEVq9ejVdeeUWxjl988cUduqBJ8nT6GJFscPvtt8PpdGL48OHo3r27ZVzDAw88gK5du2L8+PGYNm0apkyZgvr6+gyONsxPfvITXHXVVbj22msxbtw4lJeXY8qUKZZVc8844wz85S9/wUMPPYTRo0dj4cKF+PnPf65Zx8753X333di2bRvq6uqUmim/+MUvUF9fjylTpmDixIno1atXh6nEhJDCQq6qKklR17H8Gq8M+dObn2LefG0G5bwFC/Dxlt0pGy8xRxI5HFrc3NwMr9cLn89nqLLa2tqKxsZG1NbW2i4hT1JHKBTCsGHD8O1vfxu//vWvsz2cDuHvhZDCY19zK07/7dtwOiR8+dsLAQB3LfgMc5dsw8xJdfjRlKG29zXjwVdQ8/Uqw/K+p03FjReekbIxdxas5m89dM0QW2zfvh0LFy7EhAkT0NbWhocffhiNjY34zne+k+2hEUI6KXKwqlPlIpaQWNZMq7MUIRF17cj7cJZUJD1OYg1dM8QWDocDTz31FE499VSceeaZWLduHd566y3GZBBCsoYsRNShatEYkfj21ebwYFmgRtmZgBR+X1Sa/ECJJbSIEFv0798fS5YsyfYwCCFEQRYbTpUZQ25+F2/UQUgAm4PdMfuiszG82oGHl+zF5vVNmhRhkh5oESGEEJKXyMGqWtdMmHjlg5wKXFpegdraWjg8YUtIgEIk7eS9EMnhWFuSQ/B3QkjhERJG14xSWTVOAaHfl8sZ/iMQzHy5hM5G3goRuRJoS0tLlkdC8gH5d6KvIEsIyV9ksaF2zUS778a5r8gGckE0eZ+0iKSfvI0RcTqd6NKli9IPpbS01LK4FumcCCHQ0tKC/fv3o0uXLnA6ndkeEiEkRciuGYfq3i9rknhLvOtFjSvSzpcxIuknb4UIAKUbq1UzN0IAoEuXLqbdjgkh+YtchNmhDlZNsMS7wTVDi0jGyGshIkkSevfujR49eqC9vT3bwyE5SlFRES0hhBQgIatg1TiViD7w1ckYkYyR10JExul0cqIhhJBOhuw2cZgFq8ZpyJB1i0NxzdAikinyNliVEEJI50a2iDhMg1XjtIiEtPEmjBHJHBQihBBC8pKQabBqYhaR6L7C72kRyRwUIoQQQvIOn8+H/bt3ohR+bWVVpcR7fAJC6NN3IzEiwRBjRNJNQcSIEEII6RwcOtqGj1atxorFiwAhcLkH2NI+RPlcSjBrJmhI35WDVWkRSTcUIoQQQvKCzfuO4JsPvo3LitYqlg+HBAxu2wSfzwev16vEiMRdR8SQvht2GNA1k37omiGEEJIXbN5/FGU4rsmSAcIpu01NTZG/k6sjolhEFNcMhUi6oRAhhBCSF7QHQ2gOFRvyYSRJQlVVFQB1ZdX49h27xDtjRNINhQghhJC8IBgSaIEbB6tGKrEgkiRh2rRp8Hq9ANSVVZNN36VFJFMwRoQQQkheIAeOtlYOwOzrzkdTUxOqqqoUEQIk0/ROn74bfk5vZ7Bq2qEQIYQQkhcEVJktXq9XI0BkopVVk0vfZYxI5qBrhhBCSF4g1/SQRYIZ0V4z8e5bG6zKGJHMQSFCCCEkL5DdJLLbxAxHytJ3aRHJFBQihBBC8gJZFLj0+bsqEi1oZkjfZR2RjEEhQgghJC8I6NwnZigl3uMMVzWk7zqjlVV9Ph8aGxvh8/niHDGxA4NVCSGE5AWBoBwjEvsZWglWjTO0Q99AT7a6dD2+Cw0Nb0MIoaQK19fXxzt0YgEtIoQQQvKCgC3XTPg1HouIEEKVNRN+dToklMKP2pbPlZokQgjMX7AgYcsILSvm0CJCCCEkLwjYyJpxKOm79verXlfevrrMg0pHKwxHEgJNTU2mqcNWrFmzBgsWLKBlxQRaRAghhOQFtiwikdd4KquqM2MckX0P6VWB/7lkrGHdEKCUk7eLz+dTRIg8tgVJWFYKDQoRQggheUEwKAerWqXvxp81o071VWucS08fjOnTp6uKpAEf44S4rSFNTU0GYSQilhVC1wwhhJA8QbaIFFkVNEugjoh6XX1GTn19Perq6rChcTeuf24jHJ7SOEYcpqqqCpIkacSIulFfZ4cWEUIIIXmBHCNilb6r1BGJY79mMSJqvF4v+g0YiBa4YxY4swpE9Xq9mDZtWsxGfZ0dWkQIIYTkBXYKmkUrq9rfr9Y1Y75vOXYkaGJpsROIKltWzBr1dXZoESGEEJIXKCXeLeuIhF/jCVYNhcxjRNQ4lfok2v3GE4jq9XpRW1tLEaKDQoQQQkheYM8ikkiwqnF7w34js6XeIsJA1OShECGEEJIX2CnxHs1wSS59V49TJXDUwkMORNWPgYGo9qEQIYQQkhfYKvEeeY3HIiKU8u6x11GLH7VwYSBq8jBYlRBCSF5gp6CZIxGLiOjY0qK2lASF0EyeDERNDgoRQggheYFiEbHVa8Y+soFD72JR41R9pm6ot2LrIfxt+XaVlcRebEjXMjd+NHkIupa54xhpYUIhQgghJKfx+XzhoFB/C4COes2EXxPJmrHrmgnXM3ECAB58ezOWfnnI9rHUjOrrxZWnDUho20KCQoQQQkjOoq7RMRDAYGeNZYl3KaGmdxHXjIVFxBHDItLiDwIArj59AIb2rrR1vOdX7sD6Xc1oC4Q6XrkTQCFCCCEkJ5m/cgtWvzpfCUCVAIxzbUOo9VjMbdRN72RLSkdxG7JoiZW6C+iCVVXWFtklc/6wnpg0tIfl+ch81NiE9bua44pjKWQoRAghhOQkf3/vMwzXLXNIQIlojbmNLCa6tOxCQ8NbltVOZWQxESt1Vz6ufn0AaFcyeSz8OjH2FY/VppBh+i4hhBBLrPqopJNmeIyTtSThjGGx4yokCSiFH/2ObNBUO50/37zaqfw5YB0jIkmSSkAYLSJWGTd6okXXqEQAWkQIIYTEYOuBo3jl3aVo2rAM4TwUCXVjz8F3L5pomWESD1buE79UjGWBGpzp3g6oLBtWbpbBPSpQVdRmIirC1U7NtrWTvit/HgoKjUUkWu3V/nN9Ih2CCxkKEUIIIabc9swyjPp6qWpSF9i8cjFWDh6M04b0S2rfvuPteOWdJdi8cjFkkTP2nPNx8blnKuuEhMDWYHf88vJJ6FcaslWjY0B1KZ6b9Q08+dgmjcUhBJhWO/X5fNj71U6Uwg9J8ljuO2zJ0AqR9lAirpn4A2oLGQoRQgghprQfazZYFhwSsPfAQSBJIfL9uR+ibt9ijcj5aPEi9BlQg/pBfSNLwpSWV6B2oP2S6f16VmPatGlKtk1IAGtwgkbELNlyEOs/WYs965YAELjcA3wWGmS5X9lionHNyI344nLNRLalEgFAIUIIISQGR1GMkNDGToQEUFKRfOVQ39dfm4qc7bv2K0JEnvATcQPJ1U637NyLa/6+AW0OjxK4umF3M278ywe43POJMgaHBIwIboHP54tpdZHTe7UWkfhdM4wR0cJgVUII6YBsBWtmmxZ4sCxQowgBAWBZoAaekvKk933EJBA1JABPebQWh1yvwyqt1gqv14tBJ5yAFrgRDAm0R6wXO79uQaWj1SCEJMCya67TaWIRkYVIHK6ZRGqdFDK0iBBCSAyEEHjlnaVY/eFb4S5qkoTRZ56H6eeeaZnqWSgIAWwOdsfvvvMNVLn8mP3yFmze5zctn263ZofM0ZAbywI1OMu9HUIIReScYyJykrnSxe7o83ZrIAi3y4GjrQE0h4ojkSmq43TQNTdqEYkuk9N348uaCb+mO1g13u8kW1CIEEIKlmRvxH9/fyM2v78o+uQsBNZ88BYa2yrww4tOTu1gcxDZdVBeUYnaXhUIOL8C4Ne4FALBEN5YvAyrPoiKtYnfmIqJ40+33Hd7MITNwe6495opqJRa8T+vbMXmXa2ayTmkpNUmLkXcTgccUtj60OoPorK4CEfbAmiBG0d7nIzKA59qao1Y/U5k8WmWNVOUgGsmHRYR3/F2vLVhH/Zv24h9kfgXQMIFF12E008da1w/B8QKhQghpOAIBEP4cMVKLF70hjLJnD/lQpx5xqlx7WfHnn2mcQy79+9P4Whzl5CuvoZZQ7mZTy9Bz+1va8TaO2++jqreAzCqtnfMfcuddLt4KzGwujeCrj0AWjWTs6xJkskUliQJJUVOHPMHcbw9XI79aFsAAODqUYfZV59reyJ2SkbXjHwezjhcM7L1JB0xIve+uQkvLN+siX8BBF5/9VX07d0L7e3tyrmqy+d3VPQtnVCIEEIKBp/Ph4MHD+FHL36GEUdXaxqgvfn6q9gVqsS3xw+xvb9AUblpsGawKPkYiXxAniZlISCZOEn27T+A3iZibeO23baEiDwpS6pJUyYarBr30DUUR4RIa3vYjXKkNSxEyotd8Hq9ti0BThOLiNwRuMjENRPL2pDOOiKb9x8xjX8BBP7yl79E/gJ2lQ5G35bNmpL4CxYsQF1dXcYtIxQihJC85rg/iDc/24vdX27A/vVLAQiMEMYqmQ4J+GzrLiAeIeIsxvJADc4s2g7ZxL0sMBDDXcWpPIWcRe5KKwdXKoJANX+2SKWmYs1ZUmG5b2UCdzo0x1BbROz0gLFDcVG4U27T4cNoPH4QR4+Eg47LPfFNgbL3RS6AFgoJZYz6GBEra0M6XDOy6Dl82IfmUHH4y1IJnYjXDEA4LqbPsc0GgSdE7KJv6YRChBCS1zy9bBv++PqnhlRMfSBiSADwxGfJCITCcQwXnXkKLhlWibe2HsPmRdsxtJNkO4gYQkColEir5DENOj25qDTmftUTuFx/wzyAMzUWkRK3E4OdB/Dmc38FIOBEuItvRfGwuPajuGYigw+olIQ6fdfn8ykiBDBaG1IdrKoWPacLIOiswfhJk7Hs3YXKGPTX0Cy2tqNg3XRBIUIIyWv2N7fFTMWUJClyIw5bMk4vKolr3/5A+CZeXFaO2tpauPdsA9B5SnMrrpHIe1UYiIKAwOZgd/zqW+eib0kQv3v3K2z+wrrFvWYCj1hEzKwEqbKIVDraMcK1TXkvd/F1h6wDavXog1WDmvOIjrGpqckQ/6G2NkTriMR1eANtgSC+9ce3Mdq3VBPHM861DaOGTcfpJw9HU1MTioqK8OSTT2rGJEkSzj//fLz11lu2g3XTBYUIISSvaQ+GwqZoHZIk4frrr0d7ezvmfd6Mze9/hVPjvPEH5PLduqf2zlKISj5LRQiYTKDy36XlFagd0BWuZV8DaIY/EIy5X/m6AtFrK5lcW6ETQolyzsBiHD6sXeaQgMFxzrlK+q6QLSLR81C7ZqqqqlQiOIza2iC7oZKtrLr9UAv2HzwEh1u73CEBx4/60Ku2VhEW6kqzalfRiBEjmDVDCCHJEAiF0AI3ygafjpYtH2lutP36hcuQuxo3A4hfQMg1ItwuXRxD7If9gkIfLGomCJTMlsh7T8TC4Q/GvkhyYTEgakkwsxLI83SyDfb+89yRaPj0bYMwGF7bJ679KCXeI6cWUJ2HHOsChAupmU388kSfKtdMSAjb9VDkSrN60RFPsG66SKsQmTNnDl588UVs3LgRJSUlGD9+PH7/+99jyBD7wWKEEGKFPKmV9R2Mmy4eHyNLITEBIbtmZP9/1H3QOSwiimtEb7UwWVe+xp6i8LVqa7dwzahEilx/QzK5tvr04UTpSBjYxWGwiAjVZ9p1Y0386v0k+zMKhYAWuLHOOQgnh77s8NxyQXSYkVYhsnjxYsycOROnnnoqAoEAfvazn2Hy5MnYsGEDysrK0nloQkgnIZo+6Yh5o01UQMim9yLlqR2R/SQ62jxDZ+1QFptcR3kdtw2LiOyScEgqkaPs2+T4yUarwloY2CVqEdG6ZoqckukYY/8ew6/JClo5aPgrRy/MvXVa1l0siZJWIfLGG29o3s+dOxc9evTA6tWrcc4556Tz0ISQToLSdMyioFSiAqJdl2JaiM3KrCpr6iubmmTvGq6F7MbyWwSrmjWKM5ucU2URkUnWIqAPVpVdM/GUdwfMrT+JoM5qylVrhx0yGiMiN4yKlR7U1taGtrY25X1zc3NGxkUIyV/09SjMMAuEtIPs9onWuggvLxTXzEcrV+H1115VTPoXX3wxxowZo3xurKxqEqwK+bPwqyxELLNmIt+ZWjyauSuUfScdrpoa5OHKrpmgiaCyQ6rqiKRaqGWLjHXfFULgtttuw1lnnYURI0aYrjNnzhxF1Xm9XvTv3z9TwyOE5CkBRSxYWUQik1yc+27XTZjp7BGSaX70j+V45ZVXNLUu5i9YgK/2HVLWUU7TVrBqJEbEFS4eZiVEZIHnUs2gZiIvVZVVU0Us10w8nXeB1GVfRUvg58gFSpCMCZFZs2bh008/xbPPPhtznTvuuAM+n0/5b+fOnZkaHiEkTzEz8+tJ1BQuixw57kE+RCFYRD7dstO09sqnX34FIDxJ6guamZVhF7qiY3ZcM0qjOJUVSzIRi/pg2WyjDlb1+XzYtXM7SuHXCCpb+9Fl3yRKrgm1RMmIa+aWW27B/Pnz8f777yvpdGZ4PB54PJ5MDIkQUiCYmfn1JBsjYpVimq8cQYlpafaS8i4AtOdoqKxqUkdExk6wqnxd1bEVpgGcMYJls4U83rc/WIFVL34CALjcA3wmBse1n1RlX6Wq4Fu2SatFRAiBWbNm4cUXX8Q777yD2tradB6OENIJCQSNT9d6Er3x64NVUxVkmAu0wI1lgRqNJWJZoAae0nBGo/oco5VVY7u4DDEi7UH4fD40NjYq8YEyAROLiHllVW2wbLYp97hQCj8q9n+iLHNIwIjgZsM5WpGq7CtRIDEiabWIzJw5E//4xz8wb948VFRUYO/evQDCkcslJfGVWiaEEDPaddVPzUjUJ68PVk11j5BsEgqFS7Pfe80UVEqtmP3yFmze51cCMdVnGK2sGn6xCij1RIRIYP9WPPDAq+E1JAlTL7gIZ5w2NvyZiRUr2lBP7fbRfZZlbp8yBH1dRyG+0C6XgLiaxaXKIhK9PjlygRIkrRaRRx99FD6fDxMnTkTv3r2V/55//vl0HpYQ0omwYxGRZ7J4ffLRjJzCC1aVT6GiogK1tbUIOMNl8uVz01hEIpc2mr6rEgu6a1Fc5EQp/Oh3ZEP0KELg9ddeVawGASWuRy1EYltEcmWePbFnBWZfdIph4o+3WVyqsq+i3ZGT2k3WSatFpJBy7QkhuYk+jsOMRC0Zfn36bmR5Idzb9IGo+qd0sxgR8wlPOxmeOagbxvdzw3FQu5YEgZ07d6KpqQlHj4RX1tYRMVoJYnX/zSapqNKauvRd7f7yFfaaIYTkNQEbWTPx3vjlIl/OwHEADsUiYvbUng6sioylCr21waFLTVULEWNlVePf8n6qyty475qz0NCwSiPYQgJ44YUXlG7Ig50D4XJWGo4hFCOKMUYlV0i2SmuqK6vm2vWJFwoRQmySicmBxI/efWJG1ANgfePftPcI3luyAnvWLQEgMFUAS501GY0RWbNmjWmX1FRjtIiE35u5ZqKVVY3BqmZFx/RWgxDCk2VUXAiMc23DBkRrRemvrVrs5eITfzKVTGXRl6o6Irl4feKBQoQQC4QQeH7lTjRuXI+2rR8py08563xccv5ZWRwZkVGKY1lWVu3YktEeDOGax97FVLFGVUkUGOfahmDrMQBlaY0RWb/Lh5v/+gHODazSBNfOn78AdXV1KRe/BouIzjWiiRGRtK+mvWZ0c6HaanDfq5+i28GPNZ87JKC2IqR6r02NFibHLxRS1cU512JoEiVjBc0IyUfW72rG3S+uxvEvP9IsX/PhW3Gl65H0ocSIWGbNdJyl0NoehMN/zJAK6ZAAyX8s/HfkjpmOGJGlXx5E4PgRk1RMgaamppQfT1+V06nro6M+Q70Q0e4ntnvA6/WitrYWv/rOOYaNJUnCHZeeqnkPmFtE8j0rRE/KXDOsrEpI4dPc2o5KR6tpBcp0TA4kfsxqUuixU7chEBRoDhUb1lFnRKSzjkhbewjNoWKD80ggdn+uZJDjCxw6kSHXIROqp3W9a0Y/vo7oXtUV06dNU66f7HKq6tpFWUextkTea11DNg6SR7DXjBa6ZgixQAgok4P633oI6ZkciH3kmB1X8DgAp2XWjJ2md+3BkFLk6yz3dtOMCEeKTOpmtAXCx5cGjIW0c3U4tkIAB6pGpCUmSZ9xYeWasVNZtaOH8o4CPK2sBPn+xK8n1b1mGCNCSAETEgItcKOxdBjqjm9UJod1zkEMWM0i6oDOC+SAUltZMxZCJDIzb0dP/Hv2ZaYTZjqDVdsCQQCAp3cdvv8fZ+PVlZtxz1s7MaqkV8qPBajiCyLv9X10TCurKlYLdYqt0K0VG6sAT32MSOewiKQoaybPrw+FCCEWyLeJg54+eOi/puKTLbtw8782oaSsPKvj6sz8+e31+OqD+ZrJcZxrG9qOHwFQarqNneBAdbXPWBNmOnvNtLaHj+9xOeH1etGlZ1+0YF9arC+AMb7AUEdEta5+ojOtrJrkZKi3WmnTh/N8ptURbZ6X3H7k30a+W4wYI0KIBUognhR+muvdrz9a4C6IEt/5SIs/gL++vc4wLTkkINByJOZ2diwZZq3p9aSqIqYZikXEJacKy5NV6o8lTKwNereTOiNDHdsR3t64z2SnQn1mk1nWTqGQqqDnQokRoRAhxAL9016mCloRc9oDAr4YAaV9enaPuZ1iybDYdyAyA8tN26z2kx4hIltE0l+zxKxGh/54ZvEHpvNdijI38q2OSDKkutdMvl8fChFCLIh2t5SfCLXLSWaRY3bUXWPtlNi2ExwYUCwiHQuRdHz9bbJrpsgJINpyPpQG1WtWo0M5nk6IqKc4fWaL/u9kkN0vyulq0ndTdJAcIVV1RKxSp/MJxogQYoH+ZpzOiYh0jDxJbg52jxlQaobdgmZAenrW2MHgmnGkzzVjVqMjlmvE7GlbLWRSNRkq7gUbWTv5jtXvKJ4Kzuw1Q0gnIJoQYG6+JplFPYHGU2Jbvk1bfW926pGk0zWnd83IBcaCaQhWNctIMbpGjBkZilZQ7St1waraa6sJlk1u1zlHrAeaeMv7202dznXomiHEAn2Ko1mvDZI5oq6y+LazU0DKXoVWRPaTzhiR9Ltm1BiyZnRN7zRCxMQ3E7UaJhsjEruOSb5PtHrMfkefbN2D+fPnq7KGwuX9d+0/FHM/LPFOSCcgGgwWfk1n1gTpmERN0XayFAI2etakwzXn8/nQ2NiIUFu4jLynKP1ZM6YWEYfOImEzWDVVtSxiVVZVZ+0UCmYVep9861OTNQVeXv6F8hvRt5Wwcp/lE3TNEGKBodaCo+Mna5I+Er3x2inNLmfNWHfxTW3WjNoUPwrAUWeNMWsmDT8286wZc4uERogoYiH1YzJYCUyCZQsFMwvdoYAbXYTW2hcSwO7du9DQsNDSXZPvQoQWEUIs0btmNItJhknUFG3HkuEPZLaOyNufbNOY4iWEC7OF2loAGLNYUomZZUjfj8fqWidS4r0jjJVVtcsLCbMsrqOhIiwL1Gg6DK4O9INr73qtu2bBAsUyUiiuGVpECLEgpLvJprOOBOmYRHtr2Gp6F5KzZuzUEYnr8Kb8Yd5KjDPsH3AqnX4zkzUjn5McHKvEiEQ+115pY4xUykanm5wLpXy5GWZut+PtQWwOdscdl05EbaVAU8CNN+a+b7QIiXA3Zq/Xy8qqhHQGjGWww+8pRLJDopUko0/bHceIWLpmUlQREwD2txcZBY0kYXhtHwBqYZD0oQyYVVbVu6+UwGDVxY7W0VHvTLt9ouhFXihF+81FFMua6rtt8YfTt7t09aK2thZjBvfFLRecYtg2JKINN/UxbPkKhQghFgida0Z5asvKaEii5no76bvRrJnMWESOCY+hMNt0VWE22TUTTEtBs+jfRpGtfbUdrJrkmAzpw6HERGc+YOZ2a20PC5GSSEE7ALj67KGYPn26JrV5RbBW+Y3os/ryFbpmCLFA7/9W+7Hl4DGSORL1idup/2GnjkgqLWJCCGwOdscj118AV3uLSadfa9dMPIWv9JjXEdFbRMLL1ZfaLFg1XTEiyjHzfpo1YnauxyMWkVK3U7NufX096urqsHXXXlz9fxtwXHIrn+krP+crFCKEWBB94og8tao+E6Iw/de5jJm7wA52BITcfdfKNRMtzZ0KIRJ+rajwope3p+Fz2TBjdqx4C1/pMaus6tDVLYmKPuP1MG96l9w/Bnlr+TsulIZuZuiDnoUQOG5iEZHxer0Y4CxGC7YAqocgves4X6FrhhAbyJOC+smD7pnMk3gdkdhZM3KNhuPHjgLIXB2RjiZaZwyLiM/nU0RIeCwCC1SZFHYwCwSNlTWjHp9ZQT8lqDXJudBQWbVAJlkz9NantkBIOe9it1GIAFF3DhB110X/PaRpoBmCFhFCLNBXjVRPgCEh4CxAs3Euk2gdkVgWEbVlAQAGO2tQ5Ogb934SoaNgTL2FQqapqckQLCtUmRR2MMs+0ruCzCur6naA1DWAjFXHpAB1iEbQ+nw+7Ni9D6XwowVuU4sIoLUCBoWAC4VzjShECLHA8OSo+gfPzJnMI2cZxPsEKJlYMtZ+uRvz5s/XSMlxrm1oCw2NuZ9UBauaZa3occY4VlVVVcQsH/1AkiQlk8IOZtYOp2I10goRs4JmaszTfOPHWFnVePxCQb7u3pav8MADiwEIXO4BPgrWxoxRcqofgiL/DqJZM/l9jeiaIcQCfeqk+sZNHZJ5EreIGLMUXln5hWHydEhAt6L2mPtJVUEzs6wVPbGyZrxeL6ZNm6bJtpmmyraJ5/jquA79uZlWVjVzzaRIiRiLfBXG074ZbpcDpfBjZHAL5PN0SMBpLmMZdxmnziICMFiVkE6B/olDEyNCIZJxEg1gNPEowO8sBYRuX5KEGeeOiLmfVMWImGWtGI5lUdBMzqRINmtGGyOitcDYrawqk3Swqq5uSiFbRE7q48XlI7xwbNEudwAxXWzq66DEiCj+vXSNNDPQIkKIBUJ3M1bfE+mayTyJFrkys4i0O0vCJbURtSxMnzYN3au6xrWfRDDLWjEeK7JuDD+Q1xsufBWvCAFixYhoj2cahGqwWqg+SjpYNXJ8i/ThQsHpkPD/po0xfPdWLja1RUT/HeW7WKNFhBAL9DdDZs1kF8UiEucjlJlLpT0YwuZgd1xydj0uGlJhy7KQqmBVdR2OWHNIrKyZVGAWiBpt6Bjb7K9YlpT9CMNniaJYmyLvrdKHCwHZxaZPw471G1RbzuTfBLNmCOkERINV5afm6Ge0iGSeRH3iZkGmct2Q4rJy1NbW2tqPncJodlD/dGKdizrlONXF88ziP2KVWNcGq2rHkMp/AobKqgVcR0QmHhebJElwSOHvRbGIsLIqIYWP0D1xqP3gIg09QIg1idcRCb8KjUUk/LdVJVXDfjTByomLAzsxIposCQFY1FlL+PhmdUSCyiQXfm/imVE+U+uQVPWaUfZtYrUpRLxer233mtMhIRQUhhTrfHfNMEaEEAv0hmfNRETnTMaRnwTjve+aWUT8SiXVeISIVhwkSjwWESD1/WbMEl30jQEtg1Xl1xS6ZpR9F9gkm0qUWi82qt/mExQihFigvxmnaiIiiZGwRcQkyNJOSXfjftTfv/EHIFdp7ajKqR23niY4McVuQLNS+bGyZszqiChiQbXPVPWaUSqrpqiZXiGhNMvTZRbluQ6ha4YQKwyuGcaIZBWRcNyA0SKSiGtGUq2q7hL78c6v8cVnn2LTR4sRnp4lXHTxxTh17BjT/ajHEdMiog5OTLHqNRN0tiqr6vajqYeSpGQwxojIx8/zWTaF6AOYCyWOhhYRQiyImrCjKZ7KZ9QhGSdZi4haPCbrmpF39a/VO3HNo4vx+Yr3oHJa4NVXXolpGbFTWVVTNyLlFpHwq9Y1ox2beWVVi+uedPquedZMvBlShYxSW0ZXaTHf3Vf8igmxwiKoL1U9Noh9EvWJmxUik10zrrhcM8axbNx7BJWOVhNBEe7/YkY8lVWB1HT7VWN2HR0Gs79xHWOwaurGFUsIJWtpKSSi1XbD76MxU/l9jShECLHAzAebqhROEj+JmqJNC5pFXDPuJINVDx71ozlUDL1JQCB2cap4s2ZS75oxXsdYTefMxicLEK2gSm5M+sqqibvhChdjsGp4eZ7rEAoRQqwQZk+O8pMbs2YyTqKZFLEKmgHxWUTUh5UDUw8f9qEFbvQffZZGpPq6jYyZlmmrsqrDKHpShWlBMzl9VxeIal5Z1bjPZOdCvRCKHj/PZ9kUImvm6DUqDLHGYFVCLDBLcwzfGAUtIlkgYYuIIyoQZNqTiBEZ7DyAPz/6MCAETgCw11mDISddjMsnjcW/l27EfYt3Y3xFv5j7sTuBOB0SgiGRhqwZRI5vDFaN1vEwyZrRNb2z42Kyi5KRE3mfaKp2IeOMYRFhjAghBUz0ydHoJ0+13550TKKZFMraplkz8aXvlsKPca5t0fghAONc21CCNni9XlR074MWuC3dKWa/K/PjhV/T55oxiRFRsoGMY9QPV1OqPskx6WNECmWSTSVOpz6zqTBSnClECLEgZPIPnTfG7CF/H844TSJmMSKBBCwiToeEaUMrDJYMhwR4HW26Y8Xej13Ljj4mIBX4fD7s370TpfDrjgXNsUytgZFXU9dMqmJEWEckJrJFJFriPbw8391XdM0QYgNtUF/4lXVEMk+iAYzm6bvx1xEBgJ9edioaGpZoq4pKErp3qwZg9OObYXcCcTqMAioZ1qxZozRZu9wDbAwNVj7Tu2biDlZNUjJERU7s9OHOTjR9Vx9QnN/XiEKEEAtMXTPMmskaCbtmzJreheKvrAp03DXVjhXDzNJmhvwE/K9VX6G63G17jEVOB6ac1AvdKzzKMp/Pp4w5PE5gmH8zfD4fvF6vxjXj8/lweN9XKIU/RmXVyKvtEXWMobJqgWSEpBJjQbPw8ny/RhQihFhgNmHoy1yTzJF4+m70b5/Ph6amJrgCxwG44raIANZdU52OjoWI3af9YrcTR9oCePjdLXGP8eMdh3Hft09W3jc1NRl+s1JkudfrVa7R0V2b8cADrwAIW032HB+uWl+XoqyxCsU9RA0OlSXJ5/Ph0N6w+yjf3Q6pRF/inVkzhHQClNusab2FjA+n05N4ZdVotktDQwOEELhIApY6a+BKQIgAsbumOk3iUfToWwfE4u7pJ+HVdXviGtdXXx/H2p2HceBom2Z5VVUVJEnSiAcRWQ4AJUVOlMKP2paNyu/dIQF9mjcoVhOrXjPJIoucwP6teOCBNyALoe3+YSk8Sn4Tqww/XTOEFDDmZa7lz6hEMo1ZSqkd1NkuapP/ONc2tB07AnQpSdkY9X58M+z69i8Y2RsXjOxt67iypWf1vnKs3XkY7QFtGXC9SykkgC3FQxQx9Y3hPbF+VFeEvtDuV201MWTNpLCgWXFECA1u3aQRQjXHPleEUGcnahERmtd8j+ilECHEArPIfSWoz+Y+5AlCb8InYeK5Plat6a2oLHHhnIHFcOzTLndIANqOxbezDoj68WOvo1hLUjSBqINQAQmDnQPRHuxqWE92KX2wvhE/XtCIPt5o5deK4iL84KJT0LB5sSEQV18h1rygWXInM+HE7vjO6K4IbNTvNyqEOjt6kSt/DbSIEFLAWFWgtJPJoJ4g5KDG+vr6NIw0/xBCYOH7y7HsvYXhCy1JGD9pMiafMy7mNrJvPP7KqhJ+/53xaGj4yDDJVlebl2FPFCXWwdIiElk3BROIPggVEBjn2oYNfvOCal6vF1U9+6EFuwyuoY4CcaEraIYUWkRK3E7ccsEpaNjUsRDqrMhx1YXWfZdChBALogWDjNUUrHRIIBjCHxZ8jLa1CzRpifMXLEBdXR2f7gD8+e3P8NUHb0ZvokLgw7ffxF7RBddOMI8LSObG2/EkmxrMapYYSd0EYhaE6pAAR3tLzG2shJBVIK4xaya17slMfUf5it41UyiNASlECLFAiRFRxTPasYis2XEY8z/6AlP1GZdC0MwcYdvufXCbFAbb+tVeAB0JkcRuvFaTbKqwkzWTaBqyGWZBqCEBHIUn5jYdWfNiBeIqmtG0jkhqyMR3lK8Yg1ULwyLCyqqEWKAyECt/mbWU19PaHkRzqNjwvKjOUujshNxlhsyjkADanKWxt0nBBO71elFbW5u2Cc5O1kwqTeqyFUG+JpIkYVmgBsdE7LojicYWGEu8qz9L3WyY7u8oX9GL3FQK2mxCiwghFpgFR+rN02YIAC1wY1vZMJzQslHJUvjMNaigb67xBJ4KVymWBWpwZtF2hK+YhGWBgRjp6PhJPpefAO1kzaS6NLfairDP78LcuZ+ir0W0rHId43wUlXRuSU0sR3y7Igmgr7TLyqqEdALMkhvsxADInzUV98Ufb5qKNZt3Yua/N6PcXZGuoWaVYEhgxcpVWPTGa4pv/+KLL8aYMWNibhMSApuD3TH97FNw8ZBKvL31GDYv2o4TdWmn2m3Cr7l8441OFrHXSYegkt0prXuaAQD+YOzraB77ZB+hewXyv7pnPhCt2ht+L1//fL/2dM0QYoGZCVv+07pgVXSi8Xq96NV3AFrgLsgiaG2BIC6890288dqrqj4h4cBcn88Xczv5UriKy1FbW4uyikoAgN9CiIgEn+QziZ2OuekMMpRL1rdbCpHwa7xCSPlnYPLbz3f3QD4gi9y2Y0fR2NgIEUk9z2ULoR1oESHEAmHlmrHYTt9CPbp94SmRPYdb4Tv8NRy6kAQJwL4DB2O6aPSp0e5IhdM2K4tISP4+cvfOa6fXTKJCwA5yyXp9QTM1CffsibwqFpHC+znnNA5JwmDnAXzxzkpsBuAGMNhZA0kaku2hJUUOP1cQkn2sXDNWlVX1sSXyk28hWkQEEA7MNQk8La/sEns7XR8fT1H4duQPBGNuk1+uGTu/j3RYRCJCxEaMSLyH14831em7xBqvsx3jXNuUfzMSwtWBi0Wb1WY5D4UIIRYolVVVN2A7vWb0Lh35ybcQy8KHhEAL3PhYqtN0uV0WqIGntDzmdvprZMsikg/BqnHEEKVDT8lCxB8Mxfy9JdujRFU7DUD+xyjkC98e2cXw23dIwBl9Ywd45wN0zRBigVllVQs3uWo77YRpx52Tr8jnutPRE3/7wXQ0NTXhkr98guZgkb2Ayci18RQ5AQBt7R3HNjhzeOaLpljGXidey0482UhuVRO/QEgoMSNqkq0/odQRibzP3W+jsBha0wdv6GrGSJKEfr26Z3FUyUMhQogF0Z5S8QWr6n3wiqWgAH0z6klVztwIOjcBwaB14KnuvccVfZKPfazcjxGx45qJp7JqvG0CilzRnbYHQ4qFRE3CMSL6yqoFUsciXyjUyrMUIoRYEHXNRJfFZXqPvNcH+RUSZlYjt8uBY35rIaK3CrhdsmvGToxI4uNNN3aCVe0KAX0fGSEEFnTQJkAtPNoDIhzRqMOsmaMdlDoihuUkUxRi5VkKEUKsMAlWlWyoCr0P3k411nzFzEoRFRVxuGZki4itGJHcnfqUFgBWQiRkFLhmmPWRER20CXCpVFos61KiQb/Gyqrpi3UhsYlVgj9fYbAqIRYoAZWqm7udYFV95cqoSbvwlIhZAKktIRJ5VbJmVNv4fD40NjYa6pDkQx0RJUbEqs5M5LUjISD3kVHTUTdaSZI6rCWS6HXUx0cV4M+ZZAFaRAixQHlyVS2TbLhm9BaRgk7fNXm6lgMm7RUnC2/ncYWDVfsG9qKhocEQE+Hz+dD29V6Uwp/TMQn2XDP2YkQSjQkocjrQHgzim48shcskWLXFH3Z/JV5ZVR+smrvfB8l9MiJEHnnkEfzv//4v9uzZg5NOOgkNDQ04++yzM3FoQpJCmUrMsmYsttO7K6JZM4WnRMzcJe6IqLDOmgm/ylu5XQ6Uwo8x0lZNL5N58+dj1dZ92L3+IwACl3sA0eQEMDLFZ5Ia7ASrxlNZNZGYgME9K/DJzsPY29xqud4J3cs63JcavVtS6L9EQhIg7ULk+eefx+zZs/HII4/gzDPPxOOPP44LLrgAGzZswIABA9J9eEKSwmzCkM3ZtrJmIu/tNMrLV8zOyU68h7Jd5OJUlblxQoWAo127ngRg17oVyjV0SAB2fgyfb0JO+snt9JoxC/C1It6YgOdvOgMb9x6xXMflkDC8d6XtfQJRYa2UEaEOISkg7ULk/vvvx/XXX48bbrgBANDQ0IA333wTjz76KObMmaNZt62tDW1t0Qpxzc3N6R4eIZYIkzRLO5VV9XUaOkOwqjrewB1X4Gn4fZHTgb/ePAmPPrxOc20FzCZs64DNbBKfayY9U3hxkROj+3dJ+X5jjTaHPWUkD0hryJff78fq1asxefJkzfLJkydj6dKlhvXnzJmjKH+v14v+/func3iEdEjiBc3Cr45O4ZoJv6on1WhNkNipuGbxBT2qu2LatGma+iuTv/GNuAM2s4latMbKnElnZdW0EiPomjEiJBnSahE5ePAggsEgevbsqVnes2dP7N2717D+HXfcgdtuu01539zcTDFCsopZu3R1GfNY6GNE7GTa5CvCLEYkEqx67MgRNDY2msY2xHJPmMVElJSU5E0RJ6dKiQSFgMNkkk62xHq2YdYMSSUZCVY1NEqK3Ez0eDweeDz5XTOfFBbRNMvoMqVOhK3KqpFXeX8FeOfWx8MAYdfMYOcBbHlnFbbAvCKoVZlxfUxEPhVxUqd6B0MCkcr1GsxcfvmAvqAZ64iQVJBWIdKtWzc4nU6D9WP//v0GK0khE0+fCJJbhEwe2yUb8R6G9ExFvKR6hNlHX5gMADyiDeNc2zTrzJs/H/7S7jhjaNjKGW/qZ74UcVL3wYklVkOR0JlcTkM2I2aJ9+wMhxQIaRUibrcbY8aMwaJFi3DZZZcpyxctWoRLLrkknYfOGeLtE0FyC7MbrbqTbiyRqS9Yla8meDuYxYgMLAvBpztlCcC7n2yNCpECncWcOouIGfkaI6IfbjTxKc9OhOQUaXfN3HbbbbjmmmswduxYjBs3Dk888QR27NiBm2++Od2Hzjo//+cKODe8rjHLz5s/H7Un1KFrl9x/siPqG210mXzT3de4EQ0vvm8qMvVxE+rbdCzXZL5iFiPyvfNG4oF1b2vMRiEBwFOhfY+C0yGa6xCKkTRkt7JqrhEr6Dq/zoLkGmkvlHzFFVegoaEBd999N0aPHo33338fr732GgYOHJjuQ2cVIQTeWrvV8A9UArBh265sDIkkgFlQoQSgFH40rl5saEYmlyQP6WZZzeRUYO4ZfTwMEHajTFdlvwASlgVqAHeJsk6+TsYdobaI+Jo7KFWfp6euLjgHgEqEJEVGglW///3v4/vf/34mDpUzCAE0h4oRErp0PgGUVXTJ2rg6I8nE6ESzZqKM6ufF9u3bjA3AVM3I9O4K9brhfRbOnTsasKg9J3WA6bOfNGHz8r2YpN4uT90THSH/ex/sPIC5j//J1GIW1an5dfL68RaYpiZZgr1m0kRICLTAjWWBGpzl3g4hBEIAlgVqcFVpebaHV/AIIfDmZ/uwecOnOLRhGSJlsXDWeVNw/tlnxLGf8Kt6svzphcNw+chqPDf3C10WTLS2hT7bRuoEFhGr7BfHxnChQrO6GoUmRCRJQpnkxzjXNkOp+oG1J6C6a5e4K6vmCvrmjTSIkFSQwz0s8xv5frs52B3X3zwL1113HRYXnYbNwe6WFRdJali1/Wvc9vdlOPDZUqiTDT94+w2DmdwKs6d9SZIwZEBPTeGtkACqho9TLC6GGBHJuM9CwU6V0GjKc3zb5Ssjqh0GYSYBWPdl2C2br+duUhElvDzPzoPkFhQicRCrNbkZ6snG661EbW0tAs5iANaln0lqOHTUj0pHq+lk0NTUZHs/Vk+u9fX1mD17No70PxP/bjsZpb0HKZ/psyK0waq2D58X2Il3iBZ0U5VuL7DroObh751j+NGEBOCKWEPNyuLnBbF6zVCHkCSga8YGre1BPPvaYmz/+APIJv7+o8/CFRdMQLnH/BKqb7LyTVgOYgtQiKQdIQSaQ8XQR2MIIK7S4B358r1eL0R5d7TAr/nO9dupn3wLbQK2UxPD7KPoJFZ4s1j3qq6YPm2akrovEHbLnu8q1ayXbzEiMorLKfI+P8+C5AoUIjb46zufYe+a91VPfALbP/4Af3J0xU+mm9cEUT/56YWIVUVOkhpCAmiBG3u8J6Fv84ZwjI4APi8aHFfAqp3KkfJEGtSkqmqtBIXsmjFLcdYjmVhEDEXfCgx1sO7/vNqIzV8dR4s/3Hsn3+uIGNJ38+1ESE5BIWKDg4eaDDdLhwQcbvo65jZqo4f8b1SxiAQLayLKReQbfXNZP/zv9yZjzeadmPnvzahQ1bGwhY1gvEhbFY3LTZ/2W9jpu/HEiKiuUeQ1X60CdpCDdd0l+wEcR4s/ACBqRcq7GJEYlVUJSYZ881BmhZC7zDB5hAQQdJfF3EadTaEIERvtwUlqUNeo8Hq96NNvIFrgjvva26l1oVi6NEIkdgxAofWbsRMjIosNzeXvRPEFpe5ww5lMW0TiiWuzgzF915jeTki80CJig1BRCZYFanBm0XbIMSLLAgMxylUSexuLGJFggU1EuYg+ayXR+Bw7E4bD1DUj/2XPIpLP/YiiBc06toho42gK2zWjpswdvtXKFpFMFHNLR3uJaGXVyGsnEpMkfVCI2CAYEtgc7I4Lxo/GZcO9eHPzUWx+ZwdGWggKYREjEoxV95mkDL2AcMnXPk63mB3NGI39MR7fLEZE7V4PhgRWrlqNN19/NW/7ESnX2mIduSOtMHHNdIbn6ZKIReRYWxA+nw9HD+xGKfxpE2E+n08RIUC08m9dXV1KhK7RNVP43yFJHxQiNpBvtEXFZaitrYXrq62a5ebbRP+W/4lGhUhahklU6DM5ErWIRAMxrZ72zVwz2s+0OiT84eEWPy554C1M8H+kaaQ3b37qJoxMYFYGX4/8kTZ9Nz8DNhOhLJJdd3T3ZjQ0PAshBC73AL4jAsCpKT9eU1OTwQWorvybKKrcr8j/O893SNIHY0RsIMcVyE910ZoIsbcxixFx0SKSMaKm7/Cry2kdnxPLl27HfWDmmtHHTZi5ZjbtPYK2Yz6TWicirlon2cZOTQyzGJFCbXpnRqnbiVL4Edi6UvPb6HJwXcriN9RUVVUZxLMkSXGlrpuhD1ZVlie1V9LZoUXEBrIFQ36qNnu606NuBCbfEBy0iGQMfSZH1CJivPiWvvQ4smbUFhF93ISx10xYuJjVOgkhvlonarIRa2LHImIWI5KJOIlcYWRfLyodrQbLgSw6U/1deb1eTFPVMZF/18keRy9uGCNCUgGFiA3kSU3OepFvnFZGfrPW6C6LyZCkFr1FwhV5XA+JsGBwOCQc9wfx42eXo6pxUbQ+ghCYr/Klx2ropiYqMI01MpTKqiYWERGpdbK1ZCgGtW5Sap184ojfLbOzqQXLPlqFDcvfhRxQ/Y2pF+LMM1Jv9tcTPdeO3Vcad0Encs2cN6wnamaeh7/95QuNGkuFlSIW6jomqRamjLcnqYSuGRsYXTPh5VZpmGZmZxY0yxz6rBV1a3bZhbKi8RBWbtphtHaIqGvEzhOf08RVp+++q96HLG7k39XB4r6YPXs2zr/k2/h328nYLvXs+ARVHDzahovuW4j1y96Buq/OwjdeTYvZX48dF4tpjIjus0Knrm8PTFf1J0qVlcIKr9eL2tralB9D/g1Hm951ki+RpAVaRGwQVCwi4fdKlUgLw4b8D1U9EbGgWeaIugvCry6VEAkEBYqc4dL9HblG4nna106yxtgShyQhKIQyNsXS5ghPGL37OdGCRrjiDKjdffg4SsXxmH110u2isVVHxMSKaOfaFhrptFJkAkNBMwarkhRAIWID2ffvNASr2osRkWFBs8wRK0YEkF1jTviDAi1wY593BHo3f6a4RpYHalBZWQnAXptzM9eMWR8VSfdZrMyaeH8dbYGQuaASiceaxEM8MSLqn35nbSEvV1vNR2TLh2J366TfIUktFCI2iOWasdITsngxs4iwoFn60Vc2VVtE5O/THwibtI57B2D2976BPfsP4JtPrkML3GjxB1HmcdlyHygCU13QLGR8UozlmnGoTPWRFeLCHwiZxposC9SgrDzOkvYJkLDVyESskdwmZtYMv0OSBBQiNogZrGpZ0Cz8qrGImDw5k/Sg736rtYhohYjb5YDX60VlZSXaHF8AIYEjrYGwELHhA7fKmtHGiEgAhPKZPjXYrB+LHdoC4bLhvrJ+mH3zBdi17wAu/2tYUAVCAi5nXLuLm+i5xl7HLK6qM1VWLRT0XxXvZCQVUIjYQG8RsZO+axUjQiGSfsyyVpwOCcGQUFlEwhO42+VQ1in3uOA73o59h5pwvKkNjvYWAB1MshZZM+rt1Jk56nWUtHCd2dsusqDyRASVp7QcLdgEAGgPhlBclF4lYitOQBHvJh/RsJ93RINVeS8jyUMhYgM5tlRvEbF0zZhYRFwUIhnDLG5BFiKKRSRS0MXjjCaPVRS70MO/Gy/97c+AEOgNYLCzJu6sGRn18R26yThWrZF47+1tKssOABSpzicTgdFm1h89pt13bWQkkdxC+a6E5oXfIUkKChEbGIJVZVO8ZbCq0SJi9uRM0oOZRcLlkOBHtN+MXzeBA0BVUQCjXds0hczGubYhcLwl5rHM4h/M+q/ohYb8O3DqhEj8rhnZIhK2fDgdEiQpfJz2DNSsMauZo8dMvGeqAy1JHTGDVfkdkiRgHREbGFwz0D7ZmmHWRyNa0IxCJN3EsogA0YJyshBRWxBOqDS6YRwSUOlojXks64JmRotISOeakYWtWYqrHRSLiOo8Mml9MwvM1WMWI6I8TdM1kzdIhu9RFtz8DkniUIjYIFpHRGdCt5gyrCbCEIVI2lGsChauMX/EMqK2iNxx6VjtRggLhHNG1sY8llxfRpM1YxasGnkVyjq6rBnoVrCJEiNSpBYi4b9zxTVjJt47U9O7QoUWEZIKKERsEHXNhN9Hu61abGOSSZBoB1gSP/IV1pTYj3yBZlkzMj27VWH69PiqX5oJTH1BtfDO5M8iFpGQdox26tOYIWfNaCwiEXXUnoHGRnbiBMy774ZfO0OvmUIhltWO3yBJBsaI2CCoe3K1V9DMaJpnQbPMEStGBFBbRIwTOBB/9UvZNdNRi3t9nIRiadNlYyWcNaOyiBTpRFc6STRGhIGO+Uu0siohyUMhYgNjZdXwcqsHV7NgRWfEXM6CZunHOkYktkVEJp7qlw5FYEaXmQnR6J/a1Ef596RP77VLNEYkmqYri65MWETsBJ2aW0SM/0ZIbqN3L7IoHUkFFCI2UCwiypNrxxYR84kwsj9aRNKOWQBl1CKiDVb1mAiReHCa/B7M4iYMFhGda0YysRpY4fP50NTUhLaWowC0gkqxiORIjIjZZ2Yp7iS30QerUkySVEAhYgN5wojWEQm/tydEossUiwiFSNrR1+gAohaRI81H0NjoQ6D1GABzi0g8xF/QTL+O1jVjhzVr1mDBggUQIhwyPdhZA49rsPJ5JuORzKx/esy77xqtRiS30X9TItYHhMQBhYgNYje9s9jGxDSvjlGQn2bzsQNnLhHrOpp1v3U5HBjsPID3XngKgEA1whN4kTNJi4hZXRmTp329Jc1YWVW1uRAxJ+hFnzTiw/nzlfUlhGudOIOnKOvIwaqBTASrxmERUQd4s2Fa/qEPVuV3SFIBhYgNDMGqkYnHypdv5jeXn5z3fLkBD6z5NxDpl/qNqRfizDNOTfm4c4VUi65gSGDe2l3Ytmk9mjctV5aPP3cKJp8zDoC5u6AYbTjZtU15L0/gkv94UuOxKmim7TUTflUsIjr3kXrdkIimBet5efkmdDeMAejmalfeFzmyEKxqoefMUt4ZX5DH6H5W/A5JMlCI2EBvEbHjyzdLHy0pcqIUfvQ8/JmmaMTCN17DiGEnFqRlRO1CkFNh6+vrk9rnki0H8fN/rsTlnk80Fo8l77yJ008eDq/Xa+q7PqFSwOHT7sshAdVuf1LjiQarGmNENMGqkVel+25kHX3WDCBP7uY391ZHCUJC5/aRJFw4NuqayWT6rtm56jHNmmHTu7xDLygV91q2BkQKAtYRsUE0zTL8Xj+hmGF2k730lD64eEiF4cYrQaCpqSlVw80JjrYF8Mt/fYR58+drAtvmL1gAn8/XwdbWfN3iR6Wj1eQ6QrmOZq6xn3/zNEMghiRJOG3IgKTGE60jEl1mFiOi7zWjT3tVV6e0smO0O0uwLFCjnIss8Lp0iQpZV0aDVTsWFKysWhjo45yYv0tSAYWIDeSbuaGOiK2CZtGbbG9vCX72zVMNT44CEqqqqlI44uyzeNMBLPz4S+MUI5IXXcGQQHOo2HAPFIByHc3iFqq7dsH0afEVK7ODYhHpoFhXrF4zihBR/Wu0DoQW2BzsjmHfuBLXXXcdZs+ebbAyFenK2aeTaJxAbEFhZkVkVc48xHDvMl1MSFzQNWMDfVChrYJmir1au9zr9WLatGmKuyIkgObuIwvOLdMWCCpiQROECSQtugIhgRa4cahqJLp/vV65jluKhyjX0ayyLRB/sTI7OE2yZqIZIdH1jL1mtGPUBqvGPp68fXFpOWpr+1qOKbMFzWKvI+nWBdj0Lh/RW0TsiFBCOoJCxAb6J1c7Bc3MYkRk5Mnw30s34r7FuzG+ol8qh5sTCAG0wI2DVSPRQyUWtpcPS3ryl0Veq3cAZl93PpZt2I7b5n2JHuVdVMePPcnFU6zMDmZZM7IhwixuQl7LkDVjc0bW/x7NyEYdkbhjRCKvnMTyD0OMCL9CkgR0zdgg1oRhp8R7rKdEr9eLim590AK37QJW+YR8SkfL+4ddB+dfin+3nYz97j5J71udxeT1etGjb3+0wK15+jfLWkkX1lkzqvV0giWaNSMZ1rX+bWmPa4Y6WNXn86GxsTHp2JzY4+n4WptlmtE1k3/o3YuEpAJaRGwQ1GXNxFfQzOrm3LGgyVfUFgmv14vqXv3Qgl1xly83Q5/F5FKCRa2zVtKFeYl37WeAsQOtMQhaFaxqZW3TbWeG3H33w+Ur8dkrnyojmHLhhRh3WmpTxWO5wdSYx4hkTiyS1KD8hiPvmYJNUgEtIjYwCBGHdkIxw464kG/chVhpNWp2j7ym8Fxly4dDF7NjHiya9OE6RN19V7Y+OAMtALRxH/peM3qxoknftTieHZFVUexCKfzwHvhUtVTgzddeS7llxI553izTjIGO+Yf+uyq8OxfJBrSI2EC+8SdW4r1jv3kBGkRUlUXtB/jaRRYzsiUkGiwaXSeTgZDyuXVr24WGhnchhEAvhKu2WvWaCeliPdRjtbpOdmJEZp07CN7A18Bm/SfhrKVUxsgkXlk18h2lbCQk3RiDVfkdkuShRcQGeouInYJmit/c4goXtGtGV+jIacOKZBclZkfSChGzzq6ZMPs7HRJK4ceg45s0N+Zxrm1KPxt5WXhs0IzXtI6IDdeMlbWnrns5fnhxvYnVJPWp4vpYFzPM42giI+IslocI1f/5HZLkoBCxQDazu0UrAFX33cjnyVtEwq8F6ZrRTTJ2rEh2iemayVKMSM9KDyodrYabsUMCytCqvNc3fjPEiOjznGOguHQ68DvJqeIa4TxgTMpTxe3FiIRfNe14TIrOkdzG8D1STJIUQNeMCau3f40Pl3+Erz9fDkDgEiewTNSoXDP2Y0Ss/n0Wsmsmekr2rUh2CcV0zajjDzq2GqSKgdVluP+aM7Hw+S+gURCShAkja1Vvtd+3Xqxqe80k55qRkVPFn3xrHf6y8gAu6ZJcFVkz7LjBTHvNyJ+lfEQkXeiDVfXLCUkEWkR0tAWCuPEv7+PQhmWAajIb59qG9tajkffyhNKxRSRec3WhYLSIpDJGJLJPXdaMqUUkQzfI8cMGYPp0bdXW6bqy6/oy50GdZcemQcRWSXU1Xq8X5d17owVutLWnrtKqbDGEvyUyHju/ddVCZlzkH4Zg1czFYpHChRYRHa3+ENzBFjic2uUOCQi0HAHQTWVij72fePpvFKQQ0cWIKOeaApOI4tKQLQmyEDGNEUn6cLbpqGqr/mlS/xsxNr0zR/7IGcfd3+MK/6DbAskLkVBI4JV3l2DNh28DIvxND3bWQJIGx9zGbq0VkttE45wiMSKFd+siWYBCREdQhPuYmHU3lYP8bJV4jyOTIAPFLzNObItI8vsORlIvZJeMPCFr6ojorCaZwqpqq96/rtRDUVlRZOyI3HgsCR5X2PjZFgja3iYW9726FkdWvaUpTT/OtQ2S/5SY2yhDVceIyJ/RrJ93CIQtYl/v24VS+PkNkqSgENERjPQxWRaowVnu7Zr29fIEE62QGXs/ViXGZaKZJIWnRPSTjD5QMxlk10y0rktkeY73MdFX5DULqJWksFCx6uwcTMCS4CmShUjyFpFd+w6gi0lgbn2v2LcTM+sfK6vmH/Jv1b/3SzzwwOsABC73ADtbh2d3YCSvoRDRId8ot4oe+Pfsy0zN7LZiRCKvVk+tHU3OPp8vpc3ZMopOCERTbJPftb7kvlP5PsJWBodDsuz1ky30RoGg7jzkdYR6JROUINc4lIjimmkPJf278jtLTS2GowfF7plkFqyci2KRWFNc5AinqrduUn7QDgkYcHQDfD5f/t2nSE5AIaIjoDKXxzKz24ntsBcjIgdZRpcFQwJLthzEl5+vw/aPPwAi/WvTUZo7nehrRNgRb3aRG7nJ+3SpirUEhYADkq2spUyj7zVjFsfikMJjtxd/FL9rpuzoDjQ0LNRY+urr6+M4C6DdWYxlgRqcWbQdgNFiaIaZO9OOWCe5xcQhPfDtUV2AL7TLJSDlhfJI54FCRIe+j4kZ9gqahV+tJgsz18z8T3bhZ8+vxOWeT1QTlMAbr72G4UNOzJt/6NHCXnJqanh5Klwz8j5cOtcMEBZyRU57dVwyjRILERmbPmsGME9z1RNN37V/bI/LiVL4MeDo56o+IQILFixAXV1dXL+rYEhgc7A7rptyOs7sX2zLshINclQtFNrPSO5T7nHhhxfVo2Hz+5r7ljqGjpB4YfquDn0VVTPsBKvaiRExc83sPtyKSkerYZKRIqW58wXljJSMkFQGq2oncPV3FY2/yD2zv16M2WmMZ0YiIstT5AgXXTPsK/7flXz9i8sqUFtba0vEmFnEMtkhmaQOfaE8OxYxQqygRUSHnUBA06c7HfH039DUvwiFs3YEtE+KAsirJw6he9qN9hpJQ/qu6hrL1zIXLSKQtCJDnzWjWsWW289KLOvxuBymvytJkuAqrcDhFn9kPSdK3E7TfRiPb/vwpinvQvcZyR86SlUnJB4oRHTYcc3YiXewk2Jp1n8lEMnaCfWvh+urjyEi8QKHqkfm1T92vf8/la6ZYCRGxOU0sYiEtMfJpUlOH6xqNkazUuh6Ejk3j8uJFrixtL0G41zb4JDComBZ+0DMfWCFsl6RU8IT147FpCE9Yu5LjtFxWjVS0mEaI5KDcTzEPlap6oTEA4WIDrNMBj32CpqFX+MtaKa4HbqdgNmXT8D8j77AnLe/wpiyPh0PPofQTzIprSOiM+mrLQqBiBLJRYuI/vuW68dos2Y6Hq9SWTaOc6vpVooTe5bji33ArqAXlY5WNIeK0QI3AKAU/vCyYDHWbP/aUojoLVJ2iMa+RMlkPyBCSO5CIaJDn5Fhhp2uuXayNuQbsLr+RVQIOeD1elHZvQ9asD9vG+MpWTMp7DQctVpF9y3X35CvXy5W7ZS/79ZjR2OWRrdjOUqks7DH5cSbs88xFYIff7wGr77yimJ9a93rBjAk5r7sxFHpsbIiUocQ0rmhENGhz8gwI9ozxGJHdrJmlLiJ6DL5Jq93O+RbGXhjjIh2eTIo3XdV19YpSQgIoVxLO71+Mo1DAgY7D+Dj11bhYwhUIVwaXZs103GwaiIxGvK+nbrL4fP5FBEij7F96yr4fGfFNLsnJkTksYdfNRkXtvdCCClEmDWjwyylUo+9Eu8dx4iYPSXqO6uaiZV8INoMSxtQmpIYEROxqO83k4sxIkXBNoxzbYOsUiWES6MHW48p6+jjSMyQfyOpEFlNTU0mVgrrTBpFLMchRPRBuOpD5pJYJIRkHgoRHXYyEuxlNoRfLbNvIp8FTYSIfJM3c9/kA3qLiNm5JopZQLG+34ydOi6Zpldxu+H34JCASqlVeW/nt5XK+JeqqiqDEBCwrglhR6zr0Vt61OeXS+4zQkjmoRDRofQxsWHJsNeYLPY6ZmXPA/qGbvnqmpH/kGNEVBNRstVVzSZC+TpF03dzL0bk/00bA4MjQpJw7sl1qrf2XTOpODd9TYiQAAL9TrHMhlBcM3EIIb1FTH16bHpHSOeGQkSHLATsuGaA2JOqMFk31n60rpnwa1SIhN+nov5GJtE/tWuvWXL7NnMNyH8GFItI6twXqaJvj2pMn64tBDV92jR06RKd9KPDtWNtS8251dfXY/bs2ehy8vn4d9vJaO8y0HJ9O5llevQxQkKrRAghnRgGq+qQYzHsBKsC4UlBHwAI2MtskPejzojRt7jPW9eMKg4C0D49hyL9YBJFn74LAK6IYtM/cefaHNdRISg71jbl/FNo7vF6vSir7oMW+JTMMT1yszxn4DiA+ISIbPXQV74FcstqRQjJPBQiOswmOT1qU3JYcBjXDSkBhbGP5TB1zWif9vM2WFXJWom8qmxvyRp3zLI29FVqczFGRMaqEJQSrGpxjdLldpKvZ8DkC1qzZg0WLFgAIQTOABBy1sQnRFQWEZ/Ph737D6IUfrTAnVNWK0JI5qEQ0WGr6V0Hk6rP50PLoT0ohd9W1oz66VB//HyNEZGJNr3TWkSSwUyIyC4sQ4xInjkf7TS9k39z8cRo2KHIKQsRrer1+XyKCAGi2T7+40cBdLW1b1l0DxT70NDQACEELvcAywI1OWe1IoRklrTdprdt24brr78etbW1KCkpQV1dHX71q1/B7/en65Bx4fP50NjYCJ/Pp1keT/ouYJxU16xZg4aGBuxfsxCXez5BsW+7xX7Cr/oS74DaNaMdV76gb/qnvpxmOiTW92GGqRDRibp8bagm2bCApTJ9V41csl3vmjFL8XVIwPEjHX9X6vVL4cdpzkaNRWecaxuOHmlOcuSEkHwmbRaRjRs3IhQK4fHHH8egQYOwfv163HjjjTh27BjuvffedB3WFktXrMTCN14Lz4iShMlTL8T4008FoC5fHXt79aTq8zVjz5HDaJFK8Kd3t6D79rc0RbxK934Cn2+SqSnerOmdfpLVT7D5gt41o2lMZyLe5CduuZNnfX29YZ9yjIJDjlFQVyQ1ZM2k7FQyiuKaiWEREWmMrXA5jL9HIJriq+2cC1R67VlDAKBnRTHG9XPDcVC73CEBLUd8QLf8aehICEktaRMiU6dOxdSpU5X3J5xwAjZt2oRHH300q0LE5/Nh4euvQQlnFAJvvv4qhpw4GNVdu9iqGilPqoOdB/Dow3+EPG3sD/RED90VlSLFoUyFiInbxSBETOJI8oHocLWWHSB6vnt9rbju8fdwxrHlqhgCgXnz56NH34Ho17MaALDHdxzz31qCPeuWABA4EcBBXUVS+TodPdKMxsbDiljJP4tI+DWWkFL/DlJ9bnI133bdj01O8ZXFYghhl8p3vZW29+1wSLj/mrPQ0LBKW1VVsq5ZQggpfDIaI+Lz+SxvOm1tbWhra1PeNzen3mQbrhipvdFKAHbu2R+XECmFP1IlM7qP4c59hnWtbrRmrpmYBc3yTIlYWURExO2wclsTfIe/huTWbisBWP3FTkWIzP7bMgw58KFyveQYBbQfV7ZxOiQMdh7A2/96CoBAHYB9zpq8EyLqeitmaLJNUmwSidZiMfqF1Nk+Vz69HvuCjrivrV7QyNYvdnAlpHOTMSHy5Zdf4qGHHsJ9990Xc505c+bgrrvuSus4YpmZSyq8kb87FiJulwNXndwVwU3a5Q4JOOOMcVixYrmtG63sWlC7KvR9VPI1WLWj9F0AaA+G0Bwqhj7vKCQAT3n0afv4kcOmFUlry6MTZinaUK8ThuNc29B+/GgKziZzdOSaUQvS1LtmwjEi7THSd+Vsn2PiCwCBuLJmZDpKXyaEdD7iDla98847IUmS5X+rVq3SbLN7925MnToV3/rWt3DDDTfE3Pcdd9wBn8+n/Ldz5874z6gDDJUkETYzFxWXATD2eonFrReeYggWlCQJ48adgdmzZ+O6667D7NmzTWMd1OsDuqwZuY+KU842iSzPc4uImWsmEBRogRtfV4+MVhRF+Ptwl5Qp6x9FicE1JUkSenbvpryfXFduKlYGVuRX3nNHlVXVy9PlmunI+pZIrxk1Xq8XtbW1FCGEEAAJWERmzZqFK6+80nKdmpoa5e/du3dj0qRJGDduHJ544gnL7TweDzweT7xDihv1U9m1z2zAzlagLRCesOx2Fu3IzGznJqt2zcj7kDMW5AwGh4nVJB+IFhSLupgkKXyu8jznj5SRbesyELOvPR9NTU340YKt2Ly7VakwCwCtcGNZoAZnubfHtDRdN2kEGj55yxB/cELfXmk9z1TTUa8Z9fJELBJWyMLCrI6ImkR6zRBCSCziFiLdunVDt27dOl4RwK5duzBp0iSMGTMGc+fOhSOHijrIZmZR1AjguFGI2HjaTNbMrJ5I5Aqt+uPna7Cq/OiuvowOSUJQCEUsBCJqo8jpUL6PkGs3gFZtAK8Q2Bzsjt9ceT66u9tNr3WhxB9E64iYE9QIrdQeW65OGwhaW5HMuh8TQkiipC1GZPfu3Zg4cSIGDBiAe++9FwcOHFA+69Urd55SPa7wzbetPQgg/j4aVlUyO0Lt2gkJASckw/GVomd5pkSiFpEoDgkIInqN5ViEImdUoCrCS5PSHH4tr6hEbZ/YmRqFEH8gW5BiumZUGiHlrpkY6bua4wth231JCCF2SJsQWbhwIbZs2YItW7agX79+ms+S7b6aSjwuJ4Coa8ZOZdVUoe1ZE7ES6Eu8yxVDc+ia2SEaIxI9yfDfQrHutIdki4h+Ha0FSMQhDpMRhrlA1F3XsWsm1ULAqsR79PjRv2kRIYSkgrT5SmbMmAERMcPr/8slPEXhS9AqW0Qy6P/WuGZC8muhWESM43XqzqU9IAfmOgzrBHWuGSAqygoZddCuGelsFqeUeLdwzWiydihECCEpoBPc2q1RXDNyjEjkPpvqPh5mmJWK15d4t9ONNRfRZ80Axrop7ZEJz92BaybaQLDwJz4lfTfG9y2LMklKY4l3ix+bWojQIkIISQUUIjrXjFzMKROuGbOUVvn4UddMnhY0i7yqOxXrm/y1684VMM8aSVeTt1yko6wZeXE64jOUrJkYdUQAraUqE/9GCCGFD4WIYhGRXTPh5Zm4yWqKfEWOq3cNmZWBzwfMLCL6SVZ2zRS5jBYRq/47hUxHdUSUgnvpECJK910LIRKkECGEpBYKkaKwReTYkSNobGxEe2u4Eme2XDP6YlGODp6Q9cTTxTad6CurAkZRJbebL3IYrSbq0w2p3BGFjt3Kqum4FtGsGYsYEbVFpDN8IYSQtJPRXjO5iMflwGDnAez+cCWe/jC8bLCzBg7HgLQfW30fb2724fD+o3AGWwFEJ20leNOGa8ZuF9uMYBojoo13aVfVEdGvE9S4ZjqPRcSq14zP58OuHbtRCj+EVJLyY8sl3ptbA7jyiWWm66jLvzNYlRCSCihEQq2a5nVAuEdJKDAs7ceWJAkOCahzHMBTTzwCIQTOAuBw1kQtIjYLmm3cvg/z5s9XBTuGu9g2F1Vj4siB6TuJGCgxIpLa2hF+jfaaMcmakdOVzVwzneAJ3Kz7buPBY1i+chU2rXgPgMDlHmC1OCHlx+5a5obb5YA/EMLyrU2W6/bxFqf8+ISQzkmnFyInVAI7TXqU9CvLTExGudSOca5t0ZgKhIVQW8tRAF207puQiPkU+ubHW6D/RALw8vJN2REiwsQ1o6Tvht9HLSJmrhljsGpnyJqRkV0ze32tmHbfQnzT/Yki5BwSMEbaCp/Pl9KaKd6SIrxyy1n4Yt+RDtc9ZUDXlB2XENK56fRC5PLxQ9Hw0RuGHiVXnJV+iwgA9Cxuh0PnkndIgDCJVQkKAYdBbkQ+KypDSOiLpAGtztSb8O2gXE5T14xc4t1YWdWhC1ZVp/F2JteMfNpffd2CcqnV2NAPQFNTU8qLt53YswIn9qxI6T4JIcSKTh+squ/Gm+keJT+77DTjQknCkIG9AQDq9jxWAatBVzGWBWoQnfklLAvUIJAtIaKMwuiakU/DbxEjIk/E6liRTqBDVK6Z8Hn7AyE0h4oNoauSJKGqqiqzgyOEkDTQ6S0iQHZ7lEwcORCV7dNjNmvTumZi76c9GG4MN/HUkfjOyVX4cEcrnnp9KwbGrNGZXszTd/UWkUgdEZVrRv5TXkdTSbQTKBF907u2YAgtcGN72TDUtmzM64Z+hBBiBoVIhGz2KLESQmp3hFW/GaVKaUkZamtr8dHBHQCyV5HVPH03/Hr0aDMaG79GqK0FgLayqtE1E92+MwSr6mNk/JFCe81l/TD7pql53dCPEELMoBDJEWIJIbNaI2boU2Elk6DPTGJe4l3CYOcBLHp+LgCBGgC7nTUai4jeNZPOJm+5iL7EuyxE3C5H3jf0I4QQMyhEchxN8KmFeUOpUioLkcjybNdjVceIFIs2nK5KlZYzhIKtLcoyp859o4kR6QwRTbo6IrIQKeoMHf8IIZ0S3t1yHI1rxkqI6BrIZbtZnpK+qxJSk2pKjdkfEjCgPBh9r2t6p8ma6QQWEX2tFTmg1+PiP1VCSGHCu1uOI0mSqkdL7PX8upoc+uyLVBBP+Xil9odq2X9POdlQC0SSJJzQt5fyXp6Ig0qwKlSfFb4Q0VuyFIFJIUIIKVDomskDHJKEoBC2YkRcSoxIascQb/l4YVLjXU6VjpUhBEQtQLIlRG0F6hxZM+auGTddM4SQAoVCJA9wShKCEPD5fGg5tMc0a0Iul250zSRvEXls0TrsWaIvH78A/QbWoke1eYVNYWIRATpOlY4VrNoZipkB6lor4fNuC9AiQggpbChE8gCHAxiMA3j2r4/FtEgoWTMu7YSdCs/MvBWbcLpumQSBlZt24KLxMYSIvJ6JfrDK/tA3vZOFSCfRIUpwr3z9/BQihJACh3e3PKBM8kf60YSnJ7mh3f5DXyvrxE7fTf74zaFiQ3xKSADFZbFTSaMWkfgUhOyBULJmQrIQ6TRKBICx+qzb6czSgAghJL1QiOQBI6qdBouABGDNFzuV9+26vi367ItkaIEbywI1UXEDYFmgBkUlZRZbGbNm7BBtjKctaNbZXDNK1kyWLCLxBCYTQkgy0DWTB9x/7Vl46I+rNeaNkABC7qgQ0Kfv6k38yRASwOZgd9x37RRUoBU/nLcFm/f6LSu9xooR6YhoZVX52J3LIpILrpl4A5MJISQZaBHJA6q7dsF0VWM+2SLRKnmUdfSFr5R5OwVKRLZOVFRUora2FiFXiWa5GWaVVe0Qq6BZJzGIKNerreUIGhsb4T8e7sLsdmbmAvh8PkWEAGE34IIFC2gZIYSkDVpE8gR1tsn97+/G5s8Pw3e8Xfm8XddALpWuGX3AqJ1iaUqvmTiViH7cotNlzYTL4K9/cyU+A1AMYLCzBm7X0Iwcv6mpyVB7RgiBpqYmlpcnhKQFWkTyCK/Xi9raWlRUVgIAfMfbFV++o70VgLoUeGpdM0BUgDh1jenMSFT/KJVVlWBV7bELHTkwWT5buQy+J+TPyPGrqqpMi85VVVVl5PiEkM4HLSJ5iLekCACw58sNeGDJs4AQGA8AzppojEgKLSKKe8Rh39pilb5rhZK+GxEgStZMJ7GIfHtkV3ywU7vMIQFjehVl5Ph2is4RQkgqoRDJQ7qUFKEUfnh2f6JEg8pPzu2tRwF4Ve3kkz+eiOGasWMRiT99V5c1I7tmOolFZOyQ/vjwdUnjHpEkCf17d8/YGDoqOkcIIamErpk8ZNLQHhjSxRjA6ZCASqkNQGq778ZyzVhbRJJM3+2kBc1ki4TsHsmWRUJ2A1KEEELSDS0ieciJPSvw1H+fi4aGTw1Pzt27VQMIV2MFUtP0Tp9Ca0eIKK1m4jyWvuldZ3PNALRIEEI6F7SI5CkdPTkr9SiS1CFCCGUfshaQdHEcpttBXje+48kiRz6mbI3pLFkzMrRIEEI6C7SI5DGWT85yqfAknTPqMBDFIiIHq1rGiERcM3HaRPTxJ52toBkhhHQ2KETynFgN5KKl0pPbv9r9IrtH7MWIhIk/RiT8qjS9C3WuGBFCCOls0DVToKQqWFWdGWPImrFR4j1eoq4ZbWXVzuaaIYSQzgKFSIEiWyKSDVYVJq4ZfWM60+2UccQnICS9a6aTFTQjhJDOBoVIgZKqOiJq94vT4JqJvV00RiQ+1Pv2+Xw4tHcnSuGnECGEkAKFMSIFStQ1k5wSCWrSg8OvDjsl3nXb2EUuXFbi246GhlchhMDlHmCHf1h8OyKEEJIX0CJSqCiumeR2I1TBroasmTTUEZEkoBR+dD24TlPRdeCxz9kBlhBCChAKkQJFX6E0UTSuGV2MiLVFJLHuu/2rSlHpaDVYUiSEO8MSQggpLChECpSUZc1YuGasY0S029jljBOq8dCMs6G3pbADLCGEFCYUIgWKYolIUbCqJEX36bRhbREJumYA4NQT+2H69Oz3WyGEEJJ+GKxaoDjsxHHYQN5c3f3WXrBqgiaRCOy3QgghnQMKkQIlRQaRaNM5laBwOrSfmZGMRUQmVtVYQgghhQNdMwVLaoNV1YaNaI2S1KfvEkII6VxQiBQosmsm+e678v5Urpk4SrzH2/SOEEJI54JCpECRUlRZVXa/qHu9OJUYEastjZYUQgghRA+FSIEStYik3jVjq/tuCmJECCGEFD4UIgWK7BJJNlg1ZOKakf+00/SOPWIIIYRYQSFSoEhxxoj4fD40NjYayqjLFhWNa8ZWjAhNIoQQQjqG6bsFihRHHZE1a9ZgwYIFEEIoxcPq6+sBRMWGw8w1Y6fpXfxDJ4QQ0omgRaRAseuaeeb9jZg3f75iwRBCYN78Bfj6cNgyEooEpEqJZs3QNUMIIcQCCpECxa5r5un31hmsFhIEVn2xA0DUouI0ESKWvWaUfRFCCCGxoRApUOwUHQOAw0GPQVCEBOAsroj8beaaiaxnWVmV6buEEEI6hkKkQLFb4v2ocGNZoCZadwTAskANnMVlAKJWDynOXjP6cRBCCCFmMFi1QJHn/44sIsGQwOZgdzw04wJ4Qi340YKt2Ly7Ff5AODgkZJE1Y+maYWVVQgghNqAQKVAkG2Ih/Hl4hUpvJfp06QmHey+AVrRHyqaGQkbXTDRGJPbOzQqhEUIIIXromilQosGqHVtEgKjFo8gVfo1aRMLrOeJ0zSRbWp4QQkjngEKkQFFcMxbrCCEMQsMdiUT1B7WuGYfGNRN+tUzfVXrN0CRCCCEkNhQiBYrDRtM7tUFDsYjIQiQQ2zUjryuEsKjIGn6lDCGEEGIFY0QKFDuuGbVrRQ5AdbvCQkSJETHtNRNZ9/B2NDS8YlqRVakjQiVCCCHEAlpEChQ5W8UqWFUdbOqI/BLceouIUkdE5ZpxSCiFH979n2oqss5fsCBqGWHWDCGEEBtQiBQo0ToiHWe2AFF3i94iovSaUf1S6rqXo9LRarR2CIGmpibNcWkRIYQQYgWFSIFip8S72jUjWzz0MSLCxCJyWm0Vnvqvcw0qQwCoqqrSHJc6hBBCiBUUIgWKrWDVUPRvvUXEHxSadfTZL0MH9sT0adM09Uo2e4bA6/WGjwt5u2TOghBCSKHDYNUCxY5rRp1+G8siElSa3hm3r6+vR11dHT7atAM/eHELupZ4lc+iQbJUIoQQQmKTEYtIW1sbRo8eDUmSsHbt2kwcstMjB4nad82EX/UxImauGTVerxf9BwxEC9xoCwSV5bSIEEIIsUNGhMiPf/xj9OnTJxOHIhFkYWGnDLtDUqXkOqOVVX0+Hw7v24VS+GMKEQDwuJwAgLb2qK+HMSKEEELskHbXzOuvv46FCxfihRdewOuvv57uwxEZG9139eXdgahFBIe2oqHhJQghcLkH2Hc8EHM/xUXhbVpNLSKUIoQQQmKTViGyb98+3HjjjXj55ZdRWlra4fptbW1oa2tT3jc3N6dzeAVNPK4ZtbWjyOlAKfzw7P4EIrLYIQG9fJ/B55usBKOqKY5YRNqDAsGQCAsbueldKk6GEEJIwZI214wQAjNmzMDNN9+MsWPH2tpmzpw58Hq9yn/9+/dP1/AKHnVJ9ljVVeXFaovIyf27oKqoTbM9EBYUco0QPZ6i6M9IjhNhjAghhBA7xC1E7rzzTkiSZPnfqlWr8NBDD6G5uRl33HGH7X3fcccd8Pl8yn87d+6Md3gkgtolEssqEs2Iia5bP6Ar/nXrZINLRZIkpUaIHjlGBABa2+UgV3m7uIdOCCGkExG3a2bWrFm48sorLdepqanBPffcg+XLl8Pj8Wg+Gzt2LK6++mo8/fTThu08Ho9hfZIY6vk/lndGcc3ozB+9u1dh2rRpWLBggaaPjJlbBghbVIqcEtqDQmURkV0zVCKEEEJiE7cQ6datG7p169bhen/84x9xzz33KO93796NKVOm4Pnnn8fpp58e72FJnKjjPkJCwGkiCOSsGafeD4NojZCmpiZUVVXFFCEyxS4n2oMBHPrah9amvXAFW8MfUIcQQgixIG3BqgMGDNC8Ly8vBwDU1dWhX79+6ToskdHEiJivYhasqkaO1bGDp8iJXoE9+NdTj0ECcDKAY84a6hBCCCGWsLJqgaLWFrFqiUTTd5M/XndPAKe2b1OEhwRgnGsbpPbjye+cEEJIwZIxIVJTUxMze4OkHqsCZDKhDqqmxsPM8b2xapF+DEC/0pD5BoQQQgjY9K5g0QSrJuiaiYezR9SYZtp0qzbPtCGEEEIACpGCRR+saoZVsGq8eL1eTFN14+0o04YQQggBGCNSsKiNE7EcYiGTgmbJEG+mDSGEEEIh0gmIFZsTdc2k7ljxZNoQQgghdM0UKFrXjPk6IZOmd4QQQkgmoRApUCQbpVWDKcyaIYQQQhKBQqRA0eqQjuqIUIgQQgjJDhQiBYot10wKs2YIIYSQRKAQKVA0WTMxg1XDr3TNEEIIyRYUIgWKurhYR913aREhhBCSLShEChhZi3RY0IwWEUIIIVmCQqSAUeRFBzEi1CGEEEKyBYVIASO7Z8x0iM/nw+F9u1AKP10zhBBCsgYrqxYwDgkIwuiaWbNmDRYsWAAhBC73AAdbgtkZICGEkE4PhUgBI0ECIHCkuRmtTXtxOOjBHS9+itNblituG4cEdP96PXy+b7A0OyGEkIxDIVLISMBg5wE8+9fHlBTe8kBPSC7DamhqaqIQIYQQknEoRAqYMqkN45zboPbMDHfuM6wnSRKqqqoyODJCCCEkDINVC5ie7oChs65DAgaPHKMEskqShGnTptEaQgghJCvQIlLA/PSbp+Kdf63XLpQkXHz+OcD556CpqQlVVVUUIYQQQrIGhUgBc85JA1HeNl3JkNFbPyhACCGEZBsKkQKnvr4edXV1tH4QQgjJSShEOgFer5cChBBCSE7CYFVCCCGEZA0KEUIIIYRkDQoRQgghhGQNChFCCCGEZA0KEUIIIYRkDQoRQgghhGQNChFCCCGEZA0KEUIIIYRkDQoRQgghhGQNChFCCCGEZA0KEUIIIYRkjZzuNSOEAAA0NzdneSSEEEIIsYs8b8vzuBU5LUSOHDkCAOjfv3+WR0IIIYSQeDly5EiHTVclYUeuZIlQKITdu3ejoqICkiSldN/Nzc3o378/du7cicrKypTuu9DgtbIPr5V9eK3sw2sVH7xe9knXtRJC4MiRI+jTpw8cDusokJy2iDgcDvTr1y+tx6isrOQP1Sa8VvbhtbIPr5V9eK3ig9fLPum4Vh1ZQmQYrEoIIYSQrEEhQgghhJCs0WmFiMfjwa9+9St4PJ5sDyXn4bWyD6+VfXit7MNrFR+8XvbJhWuV08GqhBBCCClsOq1FhBBCCCHZh0KEEEIIIVmDQoQQQgghWYNChBBCCCFZg0KEEEIIIVmDQgTA9OnTMWDAABQXF6N379645pprsHv37mwPK+fYtm0brr/+etTW1qKkpAR1dXX41a9+Bb/fn+2h5SS/+c1vMH78eJSWlqJLly7ZHk7O8cgjj6C2thbFxcUYM2YMPvjgg2wPKed4//33MW3aNPTp0weSJOHll1/O9pByljlz5uDUU09FRUUFevTogUsvvRSbNm3K9rBykkcffRSjRo1SqqmOGzcOr7/+etbGQyECYNKkSfjnP/+JTZs24YUXXsCXX36Jyy+/PNvDyjk2btyIUCiExx9/HJ999hkeeOABPPbYY/jpT3+a7aHlJH6/H9/61rfw3//939keSs7x/PPPY/bs2fjZz36Gjz/+GGeffTYuuOAC7NixI9tDyymOHTuGk08+GQ8//HC2h5LzLF68GDNnzsTy5cuxaNEiBAIBTJ48GceOHcv20HKOfv364Xe/+x1WrVqFVatW4dxzz8Ull1yCzz77LDsDEsTAvHnzhCRJwu/3Z3soOc8f/vAHUVtbm+1h5DRz584VXq8328PIKU477TRx8803a5YNHTpU/M///E+WRpT7ABAvvfRStoeRN+zfv18AEIsXL872UPKCrl27ir/85S9ZOTYtIjqamprwzDPPYPz48SgqKsr2cHIen8+HqqqqbA+D5BF+vx+rV6/G5MmTNcsnT56MpUuXZmlUpNDw+XwAwPtTBwSDQTz33HM4duwYxo0bl5UxUIhE+MlPfoKysjJUV1djx44dmDdvXraHlPN8+eWXeOihh3DzzTdneygkjzh48CCCwSB69uypWd6zZ0/s3bs3S6MihYQQArfddhvOOussjBgxItvDyUnWrVuH8vJyeDwe3HzzzXjppZcwfPjwrIylYIXInXfeCUmSLP9btWqVsv6PfvQjfPzxx1i4cCGcTieuvfZaiE5S/T7eawUAu3fvxtSpU/Gtb30LN9xwQ5ZGnnkSuVbEHEmSNO+FEIZlhCTCrFmz8Omnn+LZZ5/N9lByliFDhmDt2rVYvnw5/vu//xvXXXcdNmzYkJWxuLJy1Awwa9YsXHnllZbr1NTUKH9369YN3bp1w4knnohhw4ahf//+WL58edZMVZkk3mu1e/duTJo0CePGjcMTTzyR5tHlFvFeK2KkW7ducDqdBuvH/v37DVYSQuLllltuwfz58/H++++jX79+2R5OzuJ2uzFo0CAAwNixY7Fy5Uo8+OCDePzxxzM+loIVIrKwSATZEtLW1pbKIeUs8VyrXbt2YdKkSRgzZgzmzp0Lh6NgjWqmJPO7ImHcbjfGjBmDRYsW4bLLLlOWL1q0CJdcckkWR0byGSEEbrnlFrz00kt47733UFtbm+0h5RVCiKzNeQUrROzy0Ucf4aOPPsJZZ52Frl27YuvWrfjlL3+Jurq6TmENiYfdu3dj4sSJGDBgAO69914cOHBA+axXr15ZHFlusmPHDjQ1NWHHjh0IBoNYu3YtAGDQoEEoLy/P7uCyzG233YZrrrkGY8eOVSxrO3bsYLyRjqNHj2LLli3K+8bGRqxduxZVVVUYMGBAFkeWe8ycORP/+Mc/MG/ePFRUVCgWN6/Xi5KSkiyPLrf46U9/igsuuAD9+/fHkSNH8Nxzz+G9997DG2+8kZ0BZSVXJ4f49NNPxaRJk0RVVZXweDyipqZG3HzzzeKrr77K9tByjrlz5woApv8RI9ddd53ptXr33XezPbSc4E9/+pMYOHCgcLvdor6+nmmWJrz77rumv6Hrrrsu20PLOWLdm+bOnZvtoeUc3/ve95R/e927dxfnnXeeWLhwYdbGIwnRSSIyCSGEEJJzdC4HPyGEEEJyCgoRQgghhGQNChFCCCGEZA0KEUIIIYRkDQoRQgghhGQNChFCCCGEZA0KEUIIIYRkDQoRQgghhGQNChFCCCGEZA0KEUIIIYRkDQoRQgghhGSN/w9w6x4oVEKnoQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %load solutions/01-interactive_tree_regression.py\n", + "\n", + "from ipywidgets import interact\n", + "\n", + "\n", + "@interact(max_depth=(1, 10))\n", + "def plot_tree(max_depth=1):\n", + " reg = DecisionTreeRegressor(max_depth=max_depth)\n", + " reg.fit(X, y)\n", + " X_test = np.linspace(-3, 3, 1000).reshape((-1, 1))\n", + " y_test = reg.predict(X_test)\n", + "\n", + " plt.figure()\n", + " plt.title(f\"Max depth: {max_depth}\")\n", + " plt.plot(X_test.ravel(), y_test, color=\"tab:blue\", label=\"prediction\")\n", + " plt.plot(X.ravel(), y, \"C7.\", label=\"training data\")\n", + " _ = plt.legend(loc=\"best\")\n" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1280,6 +1909,13 @@ "where $l$ is the leaf considered." ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> Changing the loss is just changing the way the split is done. Only need a linear algo to compute the losses between the splits. " + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1307,12 +1943,12 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 49, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGdCAYAAAAvwBgXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABbJklEQVR4nO3dd3hUZfYH8O8kpJeB0EsgMYiAghhADCBFERDNAoqKImUXQZSyWX6IYqNYWBUFBAuIC6hYWCmCK1KUJh0CShcwEDRBSmRCeru/Pw4z6cn0e+/M9/M88zBJJjPvDJO55573vOc1KIqigIiIiEgFPmoPgIiIiLwXAxEiIiJSDQMRIiIiUg0DESIiIlINAxEiIiJSDQMRIiIiUg0DESIiIlINAxEiIiJSTQ21B1CVoqIipKSkICwsDAaDQe3hEBERkRUURcG1a9fQqFEj+PhUnfPQdCCSkpKCyMhItYdBREREdjh//jyaNGlS5W00HYiEhYUBkCcSHh6u8miIyOkyM4FGjeR6SgoQEqLueIjIKdLT0xEZGWk5jldF04GIeTomPDycgQiRJ/L1Lb4eHs5AhMjDWFNWwWJVIiIiUo2mMyJE5OFq1ACGDy++TkReh3/5RKSegABgyRK1R0FEKtJ9IKIoCgoKClBYWKj2UMiL+fr6okaNGlxmTkRkI10HInl5eUhNTUVWVpbaQyFCcHAwGjZsCH9/f7WHoh+KApj/foODAQZyRF5Ht4FIUVERkpKS4Ovri0aNGsHf359no6QKRVGQl5eHS5cuISkpCTfeeGO1DXzouqwsIDRUrmdkcNUMkRfSbSCSl5eHoqIiREZGIjg4WO3hkJcLCgqCn58fzp07h7y8PAQGBqo9JCIiXdD9aRvPPEkr+F4kIrIdPzmJiIhINQxEdOLChQu45557EBISgpo1a6o9HKstWbJEN+PV01iJiDwFAxEVjBgxAgMGDLDpd2bPno3U1FQcOnQIv/76q2sG5qCoqCjMmTOn1PceeeQRzY63LD2NlYhKM5lMSEpKgslkUnsoZCPdFqt6mzNnzqB9+/a48cYb7b6P/Px8+Pn5OXFU1QsKCkJQUJBbH9NeehorERVLTEzE2rVroSgKDAYD4uPjERsbq/awyErMiGhAjx49MGHCBEyePBkRERFo0KABpk2bZvl5VFQUVqxYgU8++QQGgwEjRowAACQnJ6N///4IDQ1FeHg4Hn74Yfz555+W35s2bRratWuH//znP7jhhhsQEBBg+UNdsGAB7r//fgQHB6NVq1bYtWsXTp8+jR49eiAkJARxcXE4c+aM5b7OnDmD/v37o379+ggNDUXHjh2xadOmUs/h3Llz+Ne//gWDwWBZSl3RdMcHH3yAmJgY+Pv746abbsKnn35a6ucGgwGLFi3CwIEDERwcjBtvvBFr1qyp8jVMTU3Ffffdh6CgIERHR+Pzzz8vl6F555130KZNG4SEhCAyMhJPP/00MjIyLD8vO1bz6/fpp58iKioKRqMRgwcPxrVr16ocC9nA1xcYNEguJTfAI7KSyWSyBCGALKdfu3YtMyM64lmBiKLItuJqXK7/Edhr6dKlCAkJwZ49e/Dmm29ixowZ2LhxIwBg37596Nu3Lx5++GGkpqZi7ty5UBQFAwYMQFpaGrZu3YqNGzfizJkzeOSRR0rd7+nTp7F8+XKsWLEChw4dsnz/lVdewbBhw3Do0CG0bNkSjz32GJ588klMmTIF+/fvBwCMGzfOcvuMjAz069cPmzZtwsGDB9GnTx/Ex8cjOTkZALBy5Uo0adIEM2bMQGpqKlJTUyt8nqtWrcI///lP/N///R+OHDmCJ598En//+9+xefPmUrebPn06Hn74Yfzyyy/o168fhgwZgrS0tEpfv2HDhiElJQVbtmzBihUrsHDhQly8eLHUbXx8fPDuu+/iyJEjWLp0KX788UdMnjy5yv+XM2fOYPXq1fj222/x7bffYuvWrfj3v/9d5e+QDQIDgf/+Vy5c8kx2SEtLswQhZoqiVPl5QRqjaJjJZFIAKCaTqdzPsrOzlWPHjinZ2dnF38zIUBQJCdx/yciw+nkNHz5c6d+/v+Xr7t27K127di11m44dOyrPPvus5ev+/fsrw4cPt3y9YcMGxdfXV0lOTrZ87+jRowoAZe/evYqiKMrUqVMVPz8/5eLFi6XuG4Dy4osvWr7etWuXAkD5+OOPLd/74osvlMDAwCqfR+vWrZV58+ZZvm7WrJkye/bsUrdZvHixYjQaLV937txZGTVqVKnbPPTQQ0q/fv0qHV9GRoZiMBiUdevWVTiO48ePKwCUffv2Wb536tQpBUC58ZS0fPlypXbt2pWOderUqUpwcLCSnp5u+d4zzzyjdOrUqcL7q/A9SUQudfXqVWXatGnK1KlTLZdp06YpV69eVXtoXq2q43dZnpUR0bG2bduW+rphw4blzuhLOn78OCIjIxEZGWn5XuvWrVGzZk0cP37c8r1mzZqhbt26VT5e/fr1AQBt2rQp9b2cnBykp6cDADIzMzF58mTLY4SGhuLEiROWjIi1jh8/ji5dupT6XpcuXUqNuez4QkJCEBYWVunrcfLkSdSoUaPUnHDz5s1Rq1atUrfbvHkz7rnnHjRu3BhhYWEYNmwYrly5gszMzErHGxUVhbCwMMvX1f2/EJF7GY1GxMfHW6aDzTUiRqNR5ZGRtTyrWDU4WNpEq/XYDihbRGowGFBUVFTp7ZXrtR7VfT+kkpbZJR/PfPuKvmcewzPPPIP169dj1qxZaN68OYKCgjBo0CDk5eVV99TKKTvuip6LLa+HUsm0WMnvnzt3Dv369cOYMWPwyiuvICIiAj/99BNGjhyJ/Pz8Ssdq6/8L2Sgzky3eyWGxsbGIiYlBWloaIiIiGITojGcFIgaD13yQtW7dGsnJyTh//rwlK3Ls2DGYTCa0atXK6Y+3fft2jBgxAgMHDgQgNSNnz54tdRt/f/9qd0Fu1aoVfvrpJwwbNszyvZ07dzo05pYtW6KgoAAHDx5E+/btAUhtzNWrVy232b9/PwoKCvD2229bOqAuX77c7sckIm0xGo0MQHSKUzM61atXL7Rt2xZDhgxBYmIi9u7di2HDhqF79+7o0KGD0x+vefPmWLlyJQ4dOoSff/4Zjz32WLnMQFRUFLZt24Y//vgDly9frvB+nnnmGSxZsgQffvghTp06hXfeeQcrV67EpEmT7B5by5Yt0atXL4wePRp79+7FwYMHMXr0aAQFBVkyLTExMSgoKMC8efPw22+/4dNPP8WHH35o92MSEZFzMBDRKYPBgNWrV6NWrVro1q0bevXqhRtuuAFfffWVSx5v9uzZqFWrFjp37oz4+Hj06dOn3Dr9GTNm4OzZs4iJiamwLgUABgwYgLlz5+Ktt97CzTffjAULFmDx4sXo0aOHQ+P75JNPUL9+fXTr1g0DBw7EqFGjEBYWZtl8rl27dnjnnXfwxhtv4JZbbsGyZcswc+ZMhx6TiIgcZ1Aqm2DXgPT0dBiNRphMJoSHh5f6WU5ODpKSkhAdHc2dTqmc33//HZGRkdi0aRPuvvtutzwm35N2YI0IkUeq6vhdlmfViJDX+vHHH5GRkYE2bdogNTUVkydPRlRUFLp166b20IiIqAoMRMgj5Ofn4/nnn8dvv/2GsLAwdO7cGcuWLXN7S3siIrINAxHyCH369EGfPn3UHgbZytcX6Nev+DoReR0GIkSknsBA4H//U3sURKQirpohIiIi1bgtEJk5cyYMBgMSEhLc9ZBERESkcW4JRPbt24eFCxeW20+FiLxcZqYs2Q0JketE5HVcHohkZGRgyJAh+Oijj8ptQkZEhKwsuRCRV3J5IDJ27Fjcd9996NWrV7W3zc3NRXp6eqkLEREReS6XBiJffvklEhMTrW6lPXPmTMvGRUajsdQW92SfqKgozJkzx/K1uTW8I5xxH0RERIALA5Hz58/jn//8Jz777DOr211PmTIFJpPJcjl//ryrhue1UlNTce+991p122nTpqFdu3YO3QcREVFVXNZH5MCBA7h48aJlW3YAKCwsxLZt2zB//nzk5ubCt0wDo4CAAAQEBLhqSLqVl5cHf39/p9xXgwYNNHEfREREgAszInfffTcOHz6MQ4cOWS4dOnTAkCFDcOjQoXJBiDfp0aMHxo0bh3HjxqFmzZqoXbs2XnzxRZj3H4yKisKrr76KESNGwGg0YtSoUQCAnTt3olu3bggKCkJkZCQmTJiAzBIrDS5evIj4+HgEBQUhOjoay5YtK/fYZadVfv/9dwwePBgREREICQlBhw4dsGfPHixZsgTTp0/Hzz//DIPBAIPBgCVLllR4H4cPH8Zdd92FoKAg1K5dG6NHj0ZGRobl5yNGjMCAAQMwa9YsNGzYELVr18bYsWORn5/vxFeViIj0yGUZkbCwMNxyyy2lvhcSEoLatWuX+76zKIqC7PxCl9x3dYL8fGEwGKy+/dKlSzFy5Ejs2bMH+/fvx+jRo9GsWTNL0PHWW2/hpZdewosvvghADvZ9+vTBK6+8go8//hiXLl2yBDOLFy8GIAf88+fP48cff4S/vz8mTJiAixcvVjqGjIwMdO/eHY0bN8aaNWvQoEEDJCYmoqioCI888giOHDmC77//Hps2bQIAGI3GcveRlZWFvn374o477sC+fftw8eJFPPHEExg3bpwlcAGAzZs3o2HDhti8eTNOnz6NRx55BO3atbM8X/JSPj5A9+7F14nI63hUi/fs/EK0fnm9Ko99bEYfBPtb/3JGRkZi9uzZMBgMuOmmm3D48GHMnj3bcmC+6667MGnSJMvthw0bhscee8zSEO7GG2/Eu+++i+7du+ODDz5AcnIy1q1bh927d6NTp04AgI8//hitWrWqdAyff/45Ll26hH379iEiIgIA0Lx5c8vPQ0NDUaNGjSqnYpYtW4bs7Gx88sknCLm+hfv8+fMRHx+PN954A/Xr1wcA1KpVC/Pnz4evry9atmyJ++67Dz/88AMDEW8XFARs2aL2KIhIRW4NRLbwA8fijjvuKJVBiYuLw9tvv43CQsnodOjQodTtDxw4gNOnT5eablEUBUVFRUhKSsKvv/6KGjVqlPq9li1bombNmpWO4dChQ7jtttssQYg9jh8/jltvvdUShABAly5dUFRUhJMnT1oCkZtvvrnUdFzDhg1x+PBhux+XiIg8g0dlRIL8fHFshjo7sAb5ObfmpeSBHQCKiorw5JNPYsKECeVu27RpU5w8eRIAbJoeCgoKcmyQkGCosscs+X0/P79yPysqKnL48YmISN88KhAxGAw2TY+oaffu3eW+vvHGGyst4o2NjcXRo0dLTZ2U1KpVKxQUFGD//v24/fbbAQAnT57E1atXKx1D27ZtsWjRIqSlpVWYFfH397dkaCrTunVrLF26FJmZmZbgaceOHfDx8UGLFi2q/F0iZGYCUVFy/exZafVORF6F1WEqOX/+PCZOnIiTJ0/iiy++wLx58/DPf/6z0ts/++yz2LVrF8aOHYtDhw7h1KlTWLNmDcaPHw8AuOmmm9C3b1+MGjUKe/bswYEDB/DEE09UmfV49NFH0aBBAwwYMAA7duzAb7/9hhUrVmDXrl0AZPVOUlISDh06hMuXLyM3N7fcfQwZMgSBgYEYPnw4jhw5gs2bN2P8+PEYOnSoZVqGqEqXL8uFSANMJhOSkpJgMpnUHorXYCCikmHDhiE7Oxu33347xo4di/Hjx2P06NGV3r5t27bYunUrTp06hTvvvBO33XYbXnrpJTRs2NBym8WLFyMyMhLdu3fHAw88gNGjR6NevXqV3qe/vz82bNiAevXqoV+/fmjTpg3+/e9/W7IyDz74IPr27YuePXuibt26+OKLL8rdR3BwMNavX4+0tDR07NgRgwYNwt1334358+c78OoQEblfYmIi5syZg6VLl2LOnDlITExUe0hewaCYm1doUHp6OoxGI0wmE8LDw0v9LCcnB0lJSYiOjra6c6tW9OjRA+3atSvVep30T8/vSdVkZgKhoXI9I4NTM6Qak8mEOXPmoOQh0WAwICEhocLWBVS1qo7fZTEjQkREXi8tLQ1lz8sVRUFaWppKI/IeDESIiMjrRURElFsBaDAYHGpvQNbRxxITD8N+KkRE2mI0GhEfH4+1a9da2hLEx8dzWsYNGIgQkXp8fABzEz62eCeVxcbGIiYmxtLSgEGIezAQISL1BAUB+/apPQoiC6PRyADEzXgKQkRERKphIEJERESqYSBCROrJypIW71FRcp2IvA5rRIhIPYoCnDtXfJ2IvA4zIh4gKirKpi6tW7ZsgcFgqHJDPFdZsmQJatas6fbHJSIibWIgooIePXogISHBafe3b9++KvepKatz585ITU3VTWW4rYEWERHpB6dmNEpRFBQWFqJGjer/i+rWrWvTffv7+6NBgwb2Do2IiMhpmBG5zl1bP48YMQJbt27F3LlzYTAYYDAYcPbsWct0yfr169GhQwcEBARg+/btOHPmDPr374/69esjNDQUHTt2xKZNm0rdZ9mMgcFgwKJFizBw4EAEBwfjxhtvxJo1ayw/Lzs1Y54uWb9+PVq1aoXQ0FD07dsXqamplt8pKCjAhAkTULNmTdSuXRvPPvsshg8fjgEDBlT5fJcsWYKmTZsiODgYAwcOxJUrV0r9vLrn16NHD5w7dw7/+te/LK8XAFy5cgWPPvoomjRpguDgYLRp06bC3YGJiEjbGIjAvVs/z507F3FxcRg1ahRSU1ORmpqKyMhIy88nT56MmTNn4vjx42jbti0yMjLQr18/bNq0CQcPHkSfPn0QHx+P5OTkKh9n+vTpePjhh/HLL7+gX79+GDJkSJWbN2VlZWHWrFn49NNPsW3bNiQnJ2PSpEmWn7/xxhtYtmwZFi9ejB07diA9PR2rV6+ucgx79uzBP/7xDzz99NM4dOgQevbsiVdffbXUbap7fitXrkSTJk0wY8YMy+sFyE637du3x7fffosjR45g9OjRGDp0KPbs2VPlmIjIM7jr5JFcz+unZkwmk2VvAUCmRNauXYuYmBiX1FAYjUb4+/sjODi4wumRGTNm4J577rF8Xbt2bdx6662Wr1999VWsWrUKa9aswbhx4yp9nBEjRuDRRx8FALz++uuYN28e9u7di759+1Z4+/z8fHz44YeIiYkBAIwbNw4zZsyw/HzevHmYMmUKBg4cCACYP38+vvvuuyqf69y5c9GnTx8899xzAIAWLVpg586d+P777y23ufXWW6t8fhEREfD19UVYWFip16tx48alAqXx48fj+++/x3//+1906tSpynGRhhgMQOvWxdeJrJCYmFhuT5jY2Fi1h0V28vqMiNa2fu5g3nfjuszMTEyePBmtW7dGzZo1ERoaihMnTlSbEWnbtq3lekhICMLCwnDx4sVKbx8cHGwJQgCgYcOGltubTCb8+eefuP322y0/9/X1Rfv27ascw/HjxxEXF1fqe2W/tvf5FRYW4rXXXkPbtm1Ru3ZthIaGYsOGDdX+HmlMcDBw9KhcgoPVHg3pQGUnj8yM6JfXZ0TMWz+XDEbU3Po5JCSk1NfPPPMM1q9fj1mzZqF58+YICgrCoEGDkJeXV+X9+Pn5lfraYDCgqKjIptuXDdDKbpFd9udlVfdzwP7n9/bbb2P27NmYM2cO2rRpg5CQECQkJFT7e0Skb1WdPOplJSCV5vUZEfPWz+aDrDu2fvb390dhYaFVt92+fTtGjBiBgQMHok2bNmjQoAHOnj3rsrFVxGg0on79+ti7d6/le4WFhTh48GCVv9e6dWvs3r271PfKfm3N86vo9dq+fTv69++Pxx9/HLfeeituuOEGnDp1yo5nR0R6Yj55LEnNk0dynNdnRAD3b/0cFRWFPXv24OzZswgNDa3yD6h58+ZYuXKlJVh66aWXqsxsuMr48eMxc+ZMNG/eHC1btsS8efPw119/lftAKGnChAno3Lkz3nzzTQwYMAAbNmwoVR8CWPf8oqKisG3bNgwePBgBAQGoU6cOmjdvjhUrVmDnzp2oVasW3nnnHVy4cAGtWrVyyfMnF8nKAjp2lOv79nF6hqplPnksWyPCbIh+eX1GxMxoNCI6Ototb+ZJkybB19cXrVu3Rt26dausa5g9ezZq1aqFzp07Iz4+Hn369FGlKOvZZ5/Fo48+imHDhiEuLg6hoaHo06cPAgMDK/2dO+64A4sWLcK8efPQrl07bNiwAS+++GKp21jz/GbMmIGzZ88iJibG0jPlpZdeQmxsLPr06YMePXqgQYMG1S4lJg1SFODYMbmwxTtZKTY2FgkJCRg+fDgSEhJYqKpzBsWaiXyVpKenw2g0wmQyITw8vNTPcnJykJSUhOjo6CoPhuQaRUVFaNWqFR5++GG88sorag9HE/ietENmJhAaKtczMoAyNVJEpE9VHb/L4tQMWeXcuXPYsGEDunfvjtzcXMyfPx9JSUl47LHH1B4aERHpGKdmyCo+Pj5YsmQJOnbsiC5duuDw4cPYtGkTazKIiMghzIiQVSIjI7Fjxw61h0FERB6GGREiIqIqsJ28azEjQkTqMRiAZs2KrxNpDNvJu57uMyIaXvRDXobvRTsEBwNnz8qFPURIY5zdTp6ZlYrpNiNibkmelZWFoKAglUdDJO9FoHy7fCLSJ2e2k2dmpXK6DUR8fX1Rs2ZNy8ZswcHBVXb5JHIVRVGQlZWFixcvombNmvD19VV7SETkBM7ai8zdu7zrjW4DEQCWbeGr2lWWyF1q1qxpeU+SlbKzgW7d5Pq2bQCzm6Qhzmonz436qqbrQMRgMKBhw4aoV68e8vPz1R4OeTE/Pz9mQuxRVATs3198nUhjnLEXmdZ2edcaXQciZr6+vjwIEBGRSxiNxmoDEJPJVGmwwo36quYRgQgREZFarClEdfcu73qi++W7REREarFlia87d3nXEwYiREREdqqqEJWsw0CEiIjITuZC1JJYiGobBiJEpK46deRCpEPmQlRzMMJCVNuxWJWI1BMSAly6pPYoiBzCQlTHMBAhIiJykDVLfKlinJohIiJN42Zxno0ZESJST3Y2cO+9cn3dOrZ4p3K4WZznYyBCROopKgK2bi2+TlSCo5vFVdXtlLSDgQgREWmSI5vFMZOiH6wRISKiKqlVo2Fvjw5bup2S+pgRISKiSrk6s+CKzeIcyaSQ+zEQISKiCjlao1EdV20WZ86klAxGKsuksI5EfQxEiIioQq7MLNgS5Njao8PaTArrSLSBgQgRqSs4WO0RUCVsySzYytXTJ9VlUlyd7SHrsViViNQTEgJkZsolJETt0VTKWxtquXIfFXdsFmc0GhEdHV3heLlrrnYwI0JEVAVvT99bW6Nha62FvYWozuLKbI9W6KX+hYEIEXksRz+Imb4X1dVo2BusqblZnNqBkKtZ+3+ihWCFgQgRqScnB3jwQbm+YgUQGOi0u3ZGJoPLQKvnaLCm5mZxnrprbmX/J/Xq1UN+fr7luWol28dAhIjUU1gIfPdd8XUHmc/u/Pz8nJLJ8Ib0vaP0Hqy5MhBSK9tQ2f/Jxx9/bAk6evXqhU2bNmki28dAhIg8Qsmzu4rYc3D09PS9M+gpWHNnYODubEPJ51bR/wmAUkHHxo0by92HWgEkAxEi0r2yqeiK2Htw9NT0vbPoJVhzZ2Dg7tqiip5byf+TymglgGQgQkS6V1EqGij+oHX04KhmHYMeaD1Yc3dg4M7pqsqeW0JCAhISEixTleZpGbOy0zNqBpAMRIhI9yqbHhg5cmSp4jxyHS0Ha+6uY3HndFVVz61kD5WKslaxsbG45ZZbVA8gXRqIzJw5EytXrsSJEycQFBSEzp0744033sBNN93kyoclIi9T2fRAkyZN1B4aaYC761jcOV1l7XOrLGulhQDSoFQ1geSgvn37YvDgwejYsSMKCgrwwgsv4PDhwzh27BhCrOiimJ6eDqPRCJPJhPDwcFcNk4jUkpkJhIbK9YwMh7uraqEnAmmTGktV3fV+1Moy3JJsOX67NBAp69KlS6hXrx62bt2Kbt26VXt7BiJEROQsnhyoau252XL8dmuNiHmfBi0u6yIi8kZaO4C5khamIVxFz8/NbYGIoiiYOHEiunbtiltuuaXC2+Tm5iI3N9fydXp6uruGR0TkdbSY0ifv47bdd8eNG4dffvkFX3zxRaW3mTlzpiWqMxqNiIyMdNfwiEgNOTnAQw/JJSdH7dF4lcqWfXrbDsOkPrcEIuPHj8eaNWuwefPmKqvYp0yZApPJZLmcP3/eHcMjIrUUFgJffy0XJ7R4J+tVteyTqmcymZCUlMTAzQlcOjWjKArGjx+PVatWYcuWLYiOjq7y9gEBAQgICHDlkIiICPpqza41nNJyLpdmRMaOHYvPPvsMn3/+OcLCwnDhwgVcuHAB2dnZrnxYIiKqhrnXhcFgAACX9LrwxKwBp7Scz6UZkQ8++AAA0KNHj1LfX7x4MUaMGOHKhyYiomq4sjW7p2YN9L7bsBa5fGqGiIi0yxXLPt29t4s7cUrL+dy2aoaIiLxDZVmD8+fP636qxh1TWt6Gm94REZWhdpMvtR/fURVlDQBgxYoVHjFVo/XdhvWGgQiRlfR+cNCk4GDZY8Z8XQPUrm1Q+/Gdoeymb2aeNFWj506mWsNAhMgKnnBw0CSDweGN7pxJ7doGtR/fmUpmDTIzM/H111+X+jkLPMmMNSJE1eByPe+hdpMvtR/f2YxGI6KjoxEZGWmpqTBjgSeZMRAhqoanHRw0JTcXGDFCLiX2mVKLubahJHceMNV+fFdhgSdVhVMzRNXgcj0XKigAli6V6++9B9jQWdkVNTtlaxvcfcBU+/FdiQWeVBmDouFmH+np6TAajTCZTAgPD1d7OOTFWCPiIpmZQGioXM/IsLpexNX/H2oXJqv9+ESOsuX4zYwIkRV4Nqcd7ijoVHtFhNqPT+RODESIrMSDg2uk+wfjm5t7IHNnMuDvX+3tc/+6UGHNzpLNRxBQq4GrhknksSJrBeO+tg1Ve3wGIkSkqqXt4/F2t6HAD79Zdftg5GFQAOBToqazSAEW7L6ILFx1zSCJPFi3FnUZiBCR97oYWgsA0Kp+CG5uUsuq38n7ywcBKYdggAIFBuQ1bod+taJcOEoiz3VT/TBVH5+BCBGpKttPVsrE31wPT/dubeVv3QqTqQdrdsjjeGOhMgMRIlJPcDByBj0CnExDYHCgTb/Kmh3yNN66Oo8NzYhIPQYDcnzkfCjIn+dF5L28uYMz//KJSFU5+UUAgCA/X5VHog5vTMVTedV1cPbk9wgDESJST24usk/+CvhGIBBFao/G7bw1FU/lVdbBOSUlBZ988olHv0c4NUNE6ikoQPblvwAAgT6abfLsEt6ciqfyKtqPp1evXti0aZPHv0eYESEiVeXUkCZm3jY1U1Uq3hPT71S9sh2cveU9wkCEiFSVc335bqCfdyVouZkiVaTsajBveI94118+EWlOTg0JRIJqeFdGpKJUvKfstEvO4S3vEWZEiEhV2TW8MyMCOLaZIlfbeAdv2HCTgQgRqUZRFGT7SyMzbwxEAPsas3G1jXfx9OZ93vmXT0SakFtYvGQ36MlRwNGjbh+DyWRCUlKSblYicLUNeRpmRIhINTm5BZbrgWu/AdasAoYMAaZNA2JiXP74eswseMtKCm/BKTYGIkSkouxF/wHQCjWKCuE3cACwYgXw2WfAl18CffoARiMQFAQEBgIBAUB+PpCdLZecHKBxY+DNN+VnNqossxATE6PpAwJX23gOPQbCrsBAhIjUcfUqchZ+DAyehcAaPsDXXwP79wMvvgisXw/873/W3U9ICPD66zY/vF4zC+aVFGUPYFoeM5Wn10DYFRiIEJE6Zs9GdlYuACCwMA/IywM6dAC+/x7YvRs4eFCyHubsR04O4O9fnCG5cgWYORN44w3gb38D7rjDpofXc2bBG1ZSeDq9BsKuwECEiNzv8mXgnXeQE94YABBk+kumXfylyyruuMO6wOL8eZnKGT5cApfgYKuHoPfMgqevpPB0eg6EnY2BCBE5x6VLwIgRQL16wMsvA9HRld/2jTeAjAzkdGgFAAgsyLXvMd99F9i8Gfj1V2DKFGDuXJt+nZkFUoveA2FnMihlc0Makp6eDqPRCJPJhPDwcLWHQ0SVyc8H7rkH2LpVvvbzA55+GnjhBaBu3dK3TUmRFTE5Ofhh0SqMPOWHtqm/Ys37o6Xew1br1wN9+8r1H34A7rrLsedC5EaeumrGluM3MyJE5LiEBAlCwsKAjh2BH3+U7MR//gNMmAA0by7TLgEBUpSakwN07oycNrcCp44hMN/OjAggq2uefBJYsAD4+9+Bw4cBnriQTnCKjYEIETlq4ULg/fcBgwFYtgyIjwc2bgSefVbqNl57reLfe+01ZBdIQ7PAgjzHxjBrFrBhA5CUBEyeDHz4oWP3R0Ruw0CEiOy3fTswdqxcf/VVCUIAmaa5+25g+XLJgGRlyaqY3Fz5t2dPoEcP5Gz7FQAQ5EhGBABCQ4HFi4EePYBFi4CJE4EWLRy7Tzt4apqdyJUYiBCRfZKTgQcfBAoKgIcflmLRknx8gMGD5VKJnHwnZUQAoHt34L77pP/I9OmSnXEjNqcisg/3miEi2xUVSYBx6RLQrp3UglzfqtwW2Yp8BAX1v1/6gzhqxgz594svgCNHHL8/K3H/FyL7MRAhItstWADs2iVTIqtW2bfaBUDO9U3vAuvVkQyKo2JjJUujKMDUqY7fn5Wqak5FRFVjIEJEtklJAZ57Tq6//joQFWX3XWXnXQ9E/HydMLDrZsyQ7MzKlcCBA8673yqYm1OV5K3NqYhsxUCEiGwzYQKQng7cfrv0CnFAdq7UhgTt2CZFrM7QurXs4AsAL73knPusgMlkQlJSEkwmk6U5lTkY8ebmVES2YrEqEVlv7VrZIdfXV5bt+jqWycjNLQAABG38HpgypLjFu6OmTpU6kXXrgB07gC5dnHO/11VWmMourUS2Y0aEiKyTkVG8VHfiRODWWx2+y+z8QgBAYL6TsiFmzZtLczPA6VmRqgpTjUYjoqOjGYQQ2YCBCBFZ56WXZJO5qCinFYLmWBqaOdhHpCIvvSQZls2bgU2bnHa3ei9MLTmlRKQFnJohouodPiwbzAHABx/YvUqmrGxn9hEpq2lTaf0+b550ed23zykrc/S8ayp7nZAWMSNCRNWbNUt6hzzwQPEGc05gnpoJys9x2n2W8uKLssQ4MVG6vDqBXgtTbel1wqwJuRMzIkRUtdRUKfwEJLPgRLnXp2YcbvFemXr1ZO+Zl1+WnYAfeACm7GyHC0r1WJha1ZRSyfFrIWvCVvnehYEIEVXt/feB/Hygc2dZsutElmJVV0zNmE2cCLz3HvDbb0icOxdrs7KccpDV266p1kwpVZY1iYmJcdtz1UIgRO7FqRkiqlx2dvFOtv/6l9PvPqdADniBixcBgYFOv38AUs8ybRpMYWFYe+2ax7Zhr246xZopJbULcdkq3zsxI0LkYrpOM3/2GXD5MtCsGTBggNPvPju/EMHIg6lOTZgyMlz3+owcibRly6CUKVataGpCj6zNIlQ3paR2Ia6100fkWRiIELmQrtPMigLMmSPXJ0wAajj/46JRwQXcHpCEjd/8jE2ufH38/BAxdiwMx46VCkb0stqlKrZOp1Q1pWTOmpR9z7orCFA7ECJ1cGqGyEV0n2beuBE4dkxWnYwc6fS7/+uqCbf7JsHn+hYtrn59jI88gvhjx2AokgJZA4D4Ll10f6bt7OmU2NhYJCQkYPjw4UhISLA+MNywQbJmDux6rNcVSeQYZkSIXET3aebZs+XfkSMBF4z3wsVLliDEzKWvj8GA2IQExMTHI81oRERaGozTp0sX1nvukVU1jRs7/3FdzBVZBLsKcadPB3buBH76SRrItWtn12PrcUUSOYYZESIX0fWOrMePA99/L7vYjh/vkocICjOiqHSc5vrXp2tXGDdtQvSQITDefLPslXP6tDRpa9dOnrPOaCKLkJUlDeMA4MoV4K67gP377b47tsr3LsyIELmI2vPtDnnnHfm3f38gJsbqX7OlMLdGYAh2FUQhrsZZ+BjceABt314ugOwivG2btIM/dAi4917plfLKK4Cfn2vH4USqZxH27JEl3g0byhYAu3YBd98NrF8P3HGHe8dCusNAhMiFVD9A2GPNGmDRIrk+caLVv2ZrYW5OfiFOFdZFeqYvvlz9EiJ274axQQNHR2+b8HDg/vuBXr2ASZOk38gbb0hw8sUXslpIJ1Tta7J1q/zbowewYAFw333A9u0y5fXdd8Cdd6ozLtIFTs0QuZiu0szHjwOPPy7Xx461+gBiT2FuzvV9Zgz5RYg+dw7GsDDHxu6IwEBg/nzg66+lHmbXLjmT//139cakJ9u2yb/duwNhYcC6dUDPnrJj8113Sf1Njova+HshT2vBz0CEiMTVqzIVc+2aHFDMxapWsGflRvE+My5q726PBx8EDh4EWrcGLlyQVSBZWWqPStvy8iRwA4Bu3eTfkBDg22+Bhx4CCgqA118Hbr21OGAhuyUmJmLOnDlYunQp5syZg8TERLWH5DAGIkQEFBYCjz4KnDolu9b+97821UjYU5ibnSeBSIAr27vbIzpaDqK1awMHDsiqoTJBFpWwf79kO+rUAVq2LP5+cLBsNLhiBdCgAfDrrxLgPvUU8Ndf6o1Xx3TfEqASDESISFLn338PBAUBq1cDdeva9Ov2rNzIMWdEbowBNm92XYt3e0RHyzRNjRrAl18C//632iPSLnOWo1s3WWVV1gMPyJTfE0/I1x9+KAXQs2cDuRrKhumA2i34XYWBCJG3W7xYCjTN12+7za67sbURlmXDu9q1pMjR19eux3WZHj2AefPk+gsvSBGvSjRdE1AyEKlMzZrARx8BP/4I3HyzZEQmTgRatZJAjxknq+i6JUAVGIiQZyssBFatAs6dU3sk2vTVV8VnqlOmAI884tDd2VKYm3u9WDXIX2MBSEljxshUgqIAQ4ZIp1k3c1lNQEEB8MsvwMcfA598Yl8wUFAgDcyAqgMRs549ZZn0Rx/JUt+kJJkS7N698umawkJg8mSp17l40fYxehBN9IxxAS7fJc+VmwsMHSr1DrVryxLDm29We1TasXatrJApKgKefBJ47TW3PrylWPVcEvDeXmD0aG327pg7V6YWtmwBRoyQwkxnZm8URXY5Dg4u9yNb95Gp1rVrxcuTDxwoXYi7a5csX/ax4fz055/lPo1GoG1b636nRg0Jfh99VPrVvPmmLPXt3Vu2FahZs/i2hYXA3/8OfPqpfP3bbzKNV7u29WP0MLpsCVANZkTIM2VkAPHxEoQA0u3xnnukiyZJC+5Bg+SM9vHHgfffr3h+34XMgUjA3t3AuHGy+kKL/PyAZcvkYLtvX/F0jTPk5UnPDaMRePnlcq+B02sC/vEPCTi3b5cgJCwM6NpV/u8//FAC0ut78VjFPC3TtavtwVlIiDSS27lTAov9+4E+fQDz9FPJIMTXV4phDx+WgOXqVdsey8PoqiWAFRiIkOe5ckW6Om7cKB92X30FtGkDpKbK95OT1R6hun76SZbp5uUBAwdKXYgtZ8FOYilWLShfsKi5mohGjeTMHQBefBE4e9bx+ywqkgPtunUSEL7yCnD77ZJluM6pNQHLl0sBrq+vtLQ/dkwO6Nu3y9SMj480svvHPyQIMPvzT+mx8vLL5ZcyW1MfUp02bYAffgAiIoC9e6W77dWrpYOQL7+UjGbdukBiItC3r3TFJY/glk+f999/H9HR0QgMDET79u2xfft2dzwsebo9e+QDqW9fmct/4w3g88/lQ3HvXvlg+/FH4OGHJShp0UKCkF69pEeEt1EUYOFCyQxlZcnr9sUXkipXQWV9RCqriVA9OHniCWnwlplZXDfiiGeflfdrjRpykK9dW4KQDh0kKMnPd15NwMWL0qAOAJ5/Xv5eWrUqDkAff1zG4usLLF0KDB8uAWrv3hKEjR8vYxoxovh5FxVJEAM4FogA0mNk0yagVi2ZIoqJKR2EDBokvV02bZK/6z17JJOUkeHY45ImGJSyeT8n++qrrzB06FC8//776NKlCxYsWIBFixbh2LFjaNq0aZW/m56eDqPRCJPJhPDwcFcOk/Tm66+l/qOybo2NG8u25K1bF3/v/Hk5kJw7B9xwg/Q8yMqS+fnsbJnjnjAB6NjRPc/BnUwmqcFYvly+7tdPpq0qqEtwl6nfHMHSXecwbueXmLT9MyAjA6aCAsyZM6fcTrK9evXCpk2brG4f7zInTshBMy9Ppmsee8y++5kzB/jXv+T6J5/Ie/nPPyXAWbVKvt+1q9Tx1Kxp0x4+5SiKNBZbsULe4/v2Af7+Fd92xQpg8GDJ0JTUoYMESfn5wKuvyiqiI0ckmxEcLBkMZ9T3HDggJwpXr5YOQkpKTJRurSaTBNXfflv58/Emb7wh01wNGkghcMOGEkRGR8vnnZv/1m05frs8EOnUqRNiY2PxwQcfWL7XqlUrDBgwADNnzqzydxmIUDmKAsyaJVX0gJwVPfCAVN+fPSv/RkTIPH5F+4ScOSPBSGpq5Y/RpYscJAYM0N6SUnvs3SsHl6QkOfueOVOWTqowHVPSs1//gq/2n8czW5di7O7/AhkZSLp4EUuXLi1324q2uU9ISFBnjvyVVySDUbeuFLHaWji5fLn8fyiK9Cd59tninymKHHyfekoOtLfdJhvH2djXpZSvvpLHq1FD3gvVLc/+5hvJkDRrJgWlgwdLhuKjjySYNd/m998ly9Krl2QcneXAAXmNn3hC9gGqyJ49Ms2amQkMGwYsWeL2GidNuXgRqF+/6ts0biz/jzfcAERGAk2aFP/btKnUKTmRLcdvl+Zk8/LycODAATz33HOlvt+7d2/s3Lmz3O1zc3ORW6LBTbqr5gCPHJH0pNFYfKlZU/7YO3YsnbIk7cjPl6LGhQvl63Hj5MzSlmAhJkbOqL79Vn4vOFiaePn4yAHiyy+BHTvk0qSJfGhHRRVfOneWMw4tUhTJAu3fL9mf5GS5nDghc/5RUfL8OnVSe6QAShSrluisaq6JqKhAs+zXaWlp6gQizz4rB/ejR4FRoyRD0KpV9QdCRZED5pgxcn3cuOKA2sxgkIN/69Zytn/woCxt3bRJzm4B+TtYtkxWuAQGAgkJlQfNf/5ZPCXzwgvW9Yjp31/qL8o+n1GjJCvy3nuylNm8As3RaZmy2reXpnpV6dRJMnrx8ZJRatpUghdvZV7S3bix/D+lpMjJ1h9/yMmXySTX//ij4jb7nTvLZ55KXBqIXL58GYWFhahfJlKrX78+LlQwRz9z5kxMnz7dlUMSycmS8qyM0SgbXsXFyR9c8+auHxNVzZxe/uYb+YCcM0emUezRoEFx74yS7r9fzlDff19WEPz+e/lNzxo2lKkdLS0zLSwEVq6UA+Ivv1R8m4cekgCu5NJIleVUUCNirokouYtvyWkZM1WbOPn7S1Fn584yjbJqlbwv7rpLsgP33y8rPEq6dk2yHMuWydeDBsl7uLLg5dZbpf6iVy/Jutx5p+xiu3mzvEdL9sX56Sepf5o8WTIZubkSwBw4IAHTlStyf88/b/1zrGxcs2dLkevmzZKVAJwfiFjr3ntlp98nnpD3fmRkccbG25gDke7dgalTS/9MUYC0NFkxeOqUvHd+/11OVsz/Rka6f8wluHRqJiUlBY0bN8bOnTsRFxdn+f5rr72GTz/9FCdOnCh1+4oyIpGRkc6fmklOlnbWJlPx5epV+f7+/aUrw41GSWe2aOG8xyfbLVokkX5goHy4/u1vrn28rCz5gC855fPtt5IK3rJF/uDVVlgoBYavvy5ZDwAIDZWz4xtukLPEpk3lekyMKkOsqrZh6Md7sP3UZbzTAnigPmTp5vXC2bK/l5iYWCo4Ua1GpKSVKyVg3b69dK1SjRpSgzN0qAQlx49Lo7hTpyRrMWMG8Nxz1mVdz56VKYjffiv9/Xr1gP/7PynWnD+/uBlYWJh8r+THup+ffIa1a+foMxaXL0vm+OxZCcquXpWsolqmTQOmT5fX85tvKp/O8WSDBkl9z6xZ8r6wVWGh06ehbSqtUFwoNzdX8fX1VVauXFnq+xMmTFC6detW7e+bTCYFgGIymVw1xPLy8xXlwAFFmT9fUdq1UxRAUVq3VpT0dPeNgUr74w9FMRrl/+Kdd9Qbx+OPyxgmT1ZvDCU98YSMB1CUmjUVZdo0RblyRe1RWRw4cECZNm2aMnXqVGXatGnKgQMHSv180Ac7lGbPfqv875cUq+7v6tWrym+//aZcvXrVFcO1X3a2ovz4o6I8/3zxZ0bJ/xd/f7keGakoP/1k+/3/8Yd8BgGK0qSJorz7rqJkZRX/PD1dUd5+W1EaNy5+3MhIRRkwQFFeeUVRDh923nM1++UXRWnUSN6DaisqUpR//EOet6+votx4o6L06aMoTz2lKG+9pSgnT6o9QteLjpbn/+OPao/Ewpbjt1uKVdu3b4/333/f8r3WrVujf//+2i9WvXBB5itTUqQg8uuv7SqIcqjineS1X7VKeizs3KleAekXX8gqiTZtKp8CcZf162X5rcEgaelx4wANFXSbTKYKV7+ULDCNn/cTDv9hwuIRHdGzZT21hup8R4/K0tNly4qn9vr3B/7zHymktkd6ukyFdOsGBARUfJu8PGmfHhUlGRNXUxTtFIjm50tR7cqV5X8WGCjF6yNHame8zvTXX8Xvq7/+0sz0q2aKVQFg4sSJGDp0KDp06IC4uDgsXLgQycnJGDNmjKsf2nENGki6q1s3eYPPnGnbPCugzZSynqxYIUFIjRoyPaPmKpbevSX9e/iwZV5VlSDz2rXiufDx421+T7pDVR1Bza+TZdO7HzYCu/OlHktLtTf2uvlmqeN47TUpDExPl6lERw6C4eFSvFoVf38J1t1FSwd1Pz85UTx/XqaxzJetW2WKddQomVL98EOZvvQkBw/KvzfcoJkgxFYuD0QeeeQRXLlyBTNmzEBqaipuueUWfPfdd2hW0dJKLbrjDqkSHz1aOiredpsUSVnB6ftEeJu//pIzfUA2ZGvTRt3x1K4tH/S7dwPff4/E9u3VCTJfeEHqmZo1c/v+MNaqaPVL2QJTc7Fq4GszgNRfpaDWEwIRM19f2eSN3MNgKK6L6tFDvldUBLz1lvzNLFsmNYDLl1u/L44emAtVdXyC65Y1qk8//TTOnj2L3NxcHDhwAN3UqrK216hRsgeDokhqPinJql9z+j4R3mbSJJkea9VKPki0oF8/AIBp06YKg0yXd/3csUOKEwFZBaPRsztrOoJWtGrG06jeDdbb+fjIcustW2Rp68mTsvR31qzyTdv0ygMCEe6+a625c2X+dc8eyZDMmlXtr1hzVkiVWLFC5tQNBpmSqWxe3ApOnT65917g5ZeRdvgwlFatSv2o7NSD0+XkyFJFRZFW2717u+ZxnKS6XUKz865nREr0EfEknJbVkK5d5fN7+HBZBv3MM9JTZ9Ei560mUosHBCLs2mWtgADgn/+U61Z2EXTaPhHeRFGAt9+WND0gUzOdO9t9d5XtW2K32FigXj1E/P47ys6QuzzIfPVVWaZbv768RjpQ2S6hiqIgp0B2ea1o0zu9q2xalpkRFdWpI0vwP/5YaikOHJDW9VOmyBYPenTtGvDrr3LdmmZ1GsVAxBZ33y3//vKLdCy0QmxsLBISEjB8+HAkJCTwjKgqeXlSizNpkgQkTz7p0AHXJQcDHx+gb18Yr11DfG6u+4LMo0dlLwlAMnI6z6rlFyooLJL/l0APnJrhtKxGGQyyu/CxY9J7o7BQCotvu63Urse68fPP8lnZpIl7Vkq5CKdmbGAKCEBar16I2LMHxk2bpMrfCkajkVmQ6qSlyQfD5s1ysH/nHemc6kBlvjUrN+zSrx/wySeIXbsWMTt2uH7VjKLI3jcFBbL64sEHXfM4bmReMQMAgR6YEeG0rMY1bCgt4levBp5+urh25J13pAOullYEVcUDpmUAZkSsZknxd+mCOQkJSNy1S+0heY6//pKN5jZvluLLNWtkGszBDwPzwaAkpxwM7rlHgqWjR2E0mSqcenCqb7+V6UB/f/mg9AC51wMRHwPgX+ghRYMlcFpWJwYMkKxCv37SGn/sWJkWvnpV7ZFZx0MCEWZErFAuxe/jg7UREYgxmfjB4qiiIsksnTgh6cXvvnPaMt2K9i1xysEgIkL2IdqxA1i3TqaQXCUvr7hlc0KCaq3anc2cEQny84Vh+XL5pgMFyVpUXbEuaUTdurL32Jw50np/xQpZot+ihRSImy+NGkk28sEHtTMNwkDEe1SY4vfxQdrBgzCa16uTfaZPl4N5YKBkQpzcK8RlB4N773VPIDJvnuxRUr++dpYwO0FOvhSqBvr5FhcmeyBOy+qEjw8wcaJsLjh4sDRD++OP0rc5fhz44QcpoO/ZE3j4YbmtWh2Ns7Ol1gXQfSDCqRkrVJjiLypChLmjHdln7VrZAAyQnhguqvqubOWGQ8xN7TZtkpSuK1y8WPz6vP66plq4O8rSVdVPxU65XoB9TGzUsaN0Kl2+XJb3rl4tG6T++KM0RuvYUbK4P/wgJyCRkbIUuOwu3e5w+LAU29arJ9kaHWMgYoVy870A4r/9FsYfflB3YHqhKPLHW9KpU7JlOSBnGEOHun9cjmjXTrYAyMyU3Vcrc/as7A5qPnOpRIUHjBdflPbgsbHSN8SDWHqI+PlI0eB//+s5DaY0wulL171FeLhk6R55RPYI6tNHMiCTJskuxr/9JittWraUv89Zs4DoaGDYMOncWvazzlVKTsvopbi2EpyasVKpFH9qKozTp8v67bw8KSKkip05I+nOjAyZdrn1VrnMmyd/xF266KYnRik+PpIVWbxY0rMvvSTV9ub3QnY28Oab8oGVkwN88IF8iFWwtUHijh1Yu3EjFFwPcsPDERsaKs2WAGmmZ82W8TqSU3C9RsTXICluQN4jNTz/I8kd+xNxewkXio6Wbq3PPCNTs2+9JXvafPqpXOrWBe66C+jVS1o+REe7ZhweUh8CMBCxiWW+t1kzebNduiRFTXprWe8uOTlykElNla937pSLWYMGcias10DupZeAXbuk0DYhAXj3Xdn7JTBQltuePSu3CwmRaZb4eKkrCQuz3IUpORlrN2yAcv2MRgGw9upVxEybBqOiyFlZ165uf2qulpNXXKzqTdzVbdVlS9epmI8PcN99ctm3T06o1q6V48JXX8kFkBOxadMkq1I2c5GeDvzvfzK1k55efPHxkc+Lfv0q/3xkIOLlfHwk0v3yS6kRqCoQ+fNPOfv38QGmTlV391h3mzRJ/lhq15YddM+fl2ZwP/8sB+b33pP1/Bpg11lqdLTM0y5eDLz8sqRsH320+OdNmsiH0x13SI+Cw4fl5998I++DK1eQNnIklC5dSt2t4uODtG7dYMzK0me2yArmjEign2dleqriziwF+5i4WceOcjzIy5NtQH74QS67d8vU7d13y3Fi+nQ5sdi4UbInq1dX3tX1P/+RFXqPPCJT13fcURzI5OXJ5wnAQMSr3XOPvPE2biwuKCwpNVVS8wsWFL/R2raVpl3eYPlyCTQA+YO78065/thj6o2pEg6dpdaoIZsiPvaY9Ph48035kJg0CXj+ecmGABJ8dO8uZz/PPCPLBHv1QsTZszDExUEpMfViMBgQsWwZYMfByR1pf2fIzru+aqaG9wQi7sxSuGzpOlXN318+68xZkD/+kOnZhQuBbdskKxIWJq3ZzW66SQIZo1HqU8LD5UTtyy/lOPLBB3KJiZHPmccek2xzXp60qo+KUunJOo9BKfuXoSHp6ekwGo0wmUwI19qKgfPnZbtpHx/gyhV5QwDyBnr1VXnjmVdTmKdxYmOlmEnnhUXVOn1anuu1a7KPw+uvqz2iSplMJsyZM6fcmWNCQoJ9H9pXr8oHREV9BpYvl7MbQKalLlwAGjRA4kcfYe2BAw6n6/W0ydrHPyXhlW+P4W8318O7w26Xb2ZkFAduHsjp7zUrH1MPganH+/13CUg++kg+H+rUkezo0KGy301Fx4TCQsmqfPopsHIlkJVV/DPz58ddd8ltNMiW47f3nI44W2SkRLJFRdIRtKBApmBatJB/c3MllbZunayYCA6WaYoNG9QeuWvl5EjF+bVrkoKsKFukIU7fE6RmzcqbHT38MPDKK3L9wgXZlnzrVsTef7/D+xHpbZO1nHzvm5pRo9uqS5auk+2aNAHmzweSkqROLCVFaso6dqz8xNTXV3bY/vRTOcH9/HPg/vslC3vhgtymfXv3PQcX4tSMI+65R/YoeP99qf8wz9nddptsUNarV/GbbPRo6dw3c6YsB/NUCQmy3XadOpJa1PgqCLfPpb/wgpz5790rq2JuuAGA442v9FacmJPvncWq7Lbq5Ro1sq/nR0iIZFAefVQy8F9/LbV2Eyc6f4wq0PZRQuvuuUei3E2b5OuICFk1MWpU+aLU//s/qZnYulVWjjiwtb1mLVokNTEGg0TxjRurPaJquX0u3WCQFK2T6a040dJHJMBPin0B/a6eshG7rZJDatd2bTdnFTAQcUSPHvKmSEuTN8arr8rXFWnSRBrefPyxZEXWrnXrUF1uzx7ZMAqQ6Zi+fdUdjw084SxVb8WJllUzAX4e16yNiGzDQMQR4eHAgQNSJ2JN05rJk2VJ1rffyjLWtm1dP0Z3+PNP2QgqL092s3z+ebVHZDNPOEvVU0BlXjUT5O9dUzNEVJ73VIq5SrNm1nfOa9GieIOvsun5nBw5oFe0iOn0abl9hw5AaKgsAZs+XaZ5cnIqf7xr1yTw6d0bGDOm4vt2VH6+PKc//pCWx0uXekQXUL3u0aGX4kRLRsQHsqT5f/9ji3ciL8WMiLs995ws4/zqK1l6deyYdOdMTJSMQlCQFDDGxMjKnB07pPizpC1b5AJIF8+2bYFWrYovgYFSYf3117IXitngwTKd5Ez/93/SsCcsTJrzaG2ZtR30tAxWryydVQ2KrAQAvKbFOxGVxr96d7vtNtmjZN06KWotKzsbOHpULma+vhK0DBoky7327i0ORi5ckK/37q348Vq0kCLa3btlzxJnBiJLl8pSZQD47DNZzqxz3KPDPbK9cPkuEVWMgYgaXntNlvrWqQPExckKmrg4yYAkJ8tGcWfOyF4lLVpI3UWdOsW/f9ttUhyrKLLx3uHDwPHjsufJ8eOy5vzee4G//13u9/hx4OabgTVrZB27MzZh2revuHL75ZeBv/3N8fvUAL0tg9UrSx8RL+qsSkQVYyCihttuk86sFWneXC7WMBgkC1FdJqJ1a1lqvHGjLCGeNcu28Zb155/AAw9I07b4eOmh4iH0tgxWr7LzrxerelkfESIqj6cj3uKf/5R/Fy2SuXh7mYtTf/9dAqDPPvOI4lQzNbpfeqNcTs0Q0XXMiHiLe++VTMvp09Js7Kmn7Luff/3L44pTy9LTMli9yvbSzqpEVB5PR7yFjw8wfrxcf/dd6X1iq4ULi3fUXbZMlut6KL0sg9UrSyDCGhEir8dPAW8yYoRkMk6cKG5Lb42iItkjxVycOn261IaQqvTa6wQoLlYNCA6UbRLmz/eaFu9EVBqnZrxJeLispHn3XVnK27t39b9jMgFDhkjDKUD6hrz4omvH6WKesDW6nnudKIqCHHOxanBA8dYAROSVGIioRLWD4fjx0vvju++AU6eAG2+s/LYnTwL9+8u/gYHARx8Bjz/uvrFawdbXUc8HcDO99zrJLSieFmSNCBExEFGBqgfD5s2B++6T/W5GjZJMR0hI+dv98IMs0U1Plw37Vq8G2re36yFdFXTZ+jrq/QBupvdeJ+add4HrLd7NXYLvvLP8rtVE5PEYiLiZJg6Gr7wi+9Rs3Sq1HmvXlg5Gli+XzEd+PtC1q7SKr1/frodyVdBlz+uo9wO4md57nZgLVf19feCblyt7JwGyrLyioJiIPBqLVd2sqoOh27RrB6xfL4WrmzdLMGLek2b+fNmTxtwvZNMmu4OQyoIFZxRX2vM6mg/gJenpAG6m914nlkJV9hAhIjAj4naaOZuNi5NgpE8fCUbuv1++N3Om/HzsWClodSBV7soMhD2vo/kAXjZDo5cDeEl67nXCHiJEVBIDETfT1MGwZDBSckffGTNkZUyZ7IGtXBl02fs66vkAXpbRaNTl+M0ZkSB/BiJExEBEFZo6GJYMRjIzgfffL+4X4iBXB132vo56PYB7CvPS3cAaDESIiIGIajR1MIyLkyW66enVb6BnI1cHXZp6HTVKa31TzKtmApkRISIwECGzhg3l4gIMFtSjxb4pOQXXAxG2dyciMBAhciotZR80sVS8AuaMSJC/L+DnB7z5pvzAz0+1MRGRehiIEDmJ1rIPWu2bklNy1Yy/P/DMM6qNhYjUx9wokRO4smeKvbTaN8VSrMrlu0QEBiJV0vPupuRemmhUV4ZWG5+Z+4gE+vkChYXAvn1yKSys5jeJyBNxaqYSWkuzk7ZpplFdGZpaKn5dqamZnBzg9tvlB2zxTuSVmBGpgBbT7KRtWs0+ADK26Ohop4/F3oxhcUaEHz9ExIxIhbRa5EfapsXsg6s4kjHMYYt3IiqBpyQV0GqRH2mfq7IPWuJoxpDFqp6BNXTkLMyIVEBT+8EQaYyjGUN2VtU/1tCRMzEQqYQW0uxaao5FnsPR95WjhbncfVfftNooj/SLgUgV1GxNzjMOcgVnvK8czRjmsFhV11hDR87GQESDeMZBruDM95UjGcNSxap+fsDUqfIDtnjXBa0uVSf9YiCiQTzjIFdw9vvK3oyhuVjV0uJ92jSb74PUwxo6cjYGIhrEMw5yBa28r8w1IgGsEdEtLdTQkefgJK0Gabk5FumXVt5XpYpVi4qAo0flUlTk1nGQY7xhqTq5BzMiGsUzDnKFyt5X7lyhVapYNTsbuOUW+QFbvBN5JQYiGqbmqh1yHbWXZZd9X7l7hZalWNXfFwCzIETejoEIkRtpbVm2u1doFRQWIb9QHivIzxdQGIgQeTuvDERMWfk4dfGa2sMgL5OdeQ0/rF0LlDnoZwbURlBImCpjupx6vsKVNLuOnUOdhk2c/njmFTPA9RbveflOfwwi0hevDER+/v0qhv1nr9rDIC/TwCcdff3LH/SfWbYTF4rCVRlTMPIwKADwKbG1UpECTPzmDLJw3mWPazAAATV8gDyXPQQR6YRXBiJB/r6IrsOiOHIv/yJfKFlAye0UFQDGmrUQ5BOo0qhCcCr/JrTIPQnD9fGcCrwJ9cNqufRRe99cv9zGkkTknbwyEOkYFYHNk3qoPQzyQomJ9UrViPwtPh7TNdC6X+0CWiLyXl4ZiBCpRavLsq1ZoeWSYMXPD5g0qfg6EXkdBiJEbqbHZdnOXO1TLqB56y0nj5aI9ISBiAswzU2exJlLfLW2fJmI1OeyFu9nz57FyJEjER0djaCgIMTExGDq1KnIy9NGmbzJZEJSUhJMJpNT7zcxMRFz5szB0qVLMWfOHCQmJjr1/j2Vq/4/yHFVbZZni8oCGtPRo8DZs2zxTuSlXJYROXHiBIqKirBgwQI0b94cR44cwahRo5CZmYlZs2a56mGt4qo0MwC3NofyFNb+fzDTpA5nbZZXaUBz330wnjvHFu9EXsplgUjfvn3Rt29fy9c33HADTp48iQ8++EDVQMSVaea4uDinbrPuDaz9/2Cwoh5nbfteaUBjY2aFiDyLW2tETCZTlWdRubm5yM3NtXydnp7u9DFUlWa25YO1ogPozp07NbHNup5Y8//h7GCFbOeM1T4VBjS9e8M4bZrzB0xEuuG2QOTMmTOYN28e3n777UpvM3PmTEyfPt2l43BlmhkA4uLisGvXLofOHL2JNf8fzgxWyH7OWO1TLqCpwXp5Im9nc7HqtGnTYDAYqrzs37+/1O+kpKSgb9++eOihh/DEE09Uet9TpkyByWSyXM6fd36LafNZmbmro6Np5pIMBgM6deqEhIQEDB8+HAkJCTwjr4Y1/x+VvdbWBiukLUajEdHR0QwQiQiAHRmRcePGYfDgwVXeJioqynI9JSUFPXv2RFxcHBYuXFjl7wUEBCAgIMDWIdnMZWnmEgdQfshar7r/D2tqFJyV6SIiIvcyKBXNLzjJH3/8gZ49e6J9+/b47LPP4Ovra9Pvp6enw2g0wmQyITxcnU3BqsPiSPep7rVmjYgOZWYCoaFynatmiDyGLcdvl03QpqSkoEePHmjatClmzZqFS5cuWX7WoEEDVz2s2+mxS6ZeVfdaa7V9OlWhRg3g6aeLrxOR13HZX/6GDRtw+vRpnD59Gk2aNCn1MxcmYcjLMTDUmYAA4L331B4FEanIZZ1VR4wYAUVRKrwQERERAdxrhojUpCjA5ctyvU4doMzqKCLyfAxEiEg9WVlAvXpyncWqRF7JZVMzRERERNVhIHKdp+z+6inPg4iIvAOnZqCN/hPO6EeihedBrsOeNUTkibw+ENHCHiXOCCC08DzIdRhkEpGn8vqpGbX3KKksgLB1akXt50Gu46z3CBGRFnl9IGLNhmqu5KwAQu3nQa7DIJOIPJnXByLO2o3XXs4KINR+HuQ6Hh1k1qgBDB8uF7Z4J/JKLt30zlHu3PROzUJAZ87/s6DRM7FGhIj0xJbjNwMRjfCmAMKbnqsz8XUjIr3QxO67ZBtv2ayNZ/b288j3iKJId1UACA5mi3ciL+T1NSLkPlz9QeVkZQGhoXIxByRE5FUYiJDbcPUHERGVxUCErOZo+3iPXv1BRER2YY0IWcUZtR3mJcZl78fj6h6IiMhqDER0RK1VE85sHx8bG4uYmBiu/iAiIgAMRHRDzdUmVdV22BNIeOTqDyIisgtrRHRA7dUmrO0gIiJXYSCiA2qvNmH7eO/jaGGy1Xx9gUGD5OLr69rHIiJN4tSMDpgzEiWDEXdnJFjb4T3cOg0YGAj897+uuW8i0gVmRHRAKxkJo9GI6OhoBiFu4LaMRAWPy6ZzROROzIjoBDMS3sOTCpOJiKrDjIiOVJSRUOvMmVxD7YyE2wuTMzNlfxmDQa4TkddhRkTHuIGc51E7I8Gmc0TkbgxEdMqZTcZIO1iYTETehlMzOqX2kl5yDRYmE5G3YUZEp7Rw5kyuwYwEEXkTZkR0SitnzuQazEgQkbdgRkTHeOZMRER6x0BE57iBHOmary/Qr1/xdSLyOgxEiEg9gYHA//6n9iiISEWsESEiIiLVMBAhzWLXWCIiz8epGdIkdo31EpmZQL16cv3iRSAkRN3xEJHbMSNCmqP2fivkZllZciEir8RAhDSHXWOJiLwHAxHSHLfvAEtERKphIEKaw66xRETeg8WqpEnsGktE5B0YiJBmsWssEZHnYyBCROrx8QG6dy++TkReh4EIEaknKAjYskXtURCRingKQkRERKphIEJERESqYSBCROrJzATq1pVLZqbaoyEiFbBGhABIW3UulSVVXL6s9giISEUMRIgbzBERkWo4NePluMEcERGpiYGIl+MGc0REpCYGIl6OG8wREZGaGIh4OW4wR0REamKxKnGDOVKPjw/QoUPxdSLyOgxECAA3mCOVBAUB+/apPQoiUhFPQYiIiEg1DESIiIhINQxEyCEmkwlJSUnsO0L2ycoCoqLkkpWl9miISAWsESG7sSMrOUxRgHPniq8TkddhRoTswo6sRETkDAxEyC7syEpERM7AQITswo6sRETkDAxEyC7syEpERM7AYlWyGzuyEhGRo9ySEcnNzUW7du1gMBhw6NAhdzwkuYnRaER0dDSDELKPwQC0bi2XMlN9ROQd3BKITJ48GY0aNXLHQ5ETsUcIuVxwMHD0qFyCg9UeDRGpwOVTM+vWrcOGDRuwYsUKrFu3ztUPR07CHiFEROQOLg1E/vzzT4waNQqrV69GsBVnO7m5ucjNzbV8nZ6e7srhUSUq6xESExPDKRgiInIql03NKIqCESNGYMyYMehg3ua7GjNnzrTsAms0GhEZGemq4VEV2COE3CYrC7j5ZrmwxTuRV7I5EJk2bRoMBkOVl/3792PevHlIT0/HlClTrL7vKVOmwGQyWS7nz5+3dXjkBOwRQm6jKMCxY3Jhi3cir2RQyp76VuPy5cu4fPlylbeJiorC4MGDsXbt2lIHtMLCQvj6+mLIkCFYunRptY+Vnp4Oo9EIk8mE8PBwW4ZJDmKNCLlFZiYQGirXMzKAkBB1x0NETmHL8dvmQMRaycnJpWo8UlJS0KdPH3z99dfo1KkTmjRpUu19MBBRl8lksrlHiD2/Q16MgQiRR7Ll+O2yYtWmTZuW+jr0+odNTEyMVUEIqc9cq2MtZlGIiMhWbPFOTsHdeImIyB5ua/EeFRVVbiUGeY6qVtpwioaIiCrDvWbIKcwrbUoGI1xpQ9UyGIBmzYqvE5HX4dQMOQV34yW7BAcDZ8/KhS3eibwSMyLkNNyNl4iIbMVAhJzK1pU2RETk3Tg1Q0Tqyc4GOnaUS3a22qMhIhUwI0JE6ikqAvbvL75ORF6HGREiIiJSDQMRIiIiUg0DESIiIlINAxEiIiJSDQMRIiIiUg1XzRCRuurUUXsERKQiBiJeymQysQMqqS8kBLh0Se1REJGKGIh4ocTERKxduxaKolj2hImNjVV7WERE5IVYI+IFTCYTkpKSYDKZYDKZLEEIACiKgrVr18JkMqk8SiIi8kbMiHi4stmPuLg4SxBipigK0tLSOEVD7pedDdx7r1xftw4IClJ3PETkdgxEPFhF2Y+dO3fCYDCUCkYMBgMiIiLUGiZ5s6IiYOvW4utE5HU4NePB0tLSymU/ACAuLg4GgwEALDUizIYQEZEamBHxYBERERVmPzp16oROnTpx1QwREamOGREPZjQaER8fX2H2w2g0Ijo6mkEIERGpihkRDxcbG4uYmBhmP4iISJMYiHgBcwaEiIhIaxiIEJG6goPVHgERqYiBCBGpJyQEyMxUexREpCIWqxIREZFqGIgQERGRahiIEJF6cnKA++6TS06O2qMhIhWwRoSI1FNYCHz3XfF1IvI6zIgQERGRahiIEBERkWoYiBAREZFqGIgQERGRahiIEBERkWo0vWrGvH19enq6yiMhIpco2VU1PZ0rZ4g8hPm4bT6OV0XTgci1a9cAAJGRkSqPhIhcrlEjtUdARE527dq1ajddNSjWhCsqKSoqQkpKCsLCwmAwGJx63+np6YiMjMT58+cRHh7u1Pv2NHytrMfXynp8razH18o2fL2s56rXSlEUXLt2DY0aNYKPT9VVIJrOiPj4+KBJkyYufYzw8HC+Ua3E18p6fK2sx9fKenytbMPXy3queK2qy4SYsViViIiIVMNAhIiIiFTjtYFIQEAApk6dioCAALWHonl8razH18p6fK2sx9fKNny9rKeF10rTxapERETk2bw2I0JERETqYyBCREREqmEgQkRERKphIEJERESqYSAC4G9/+xuaNm2KwMBANGzYEEOHDkVKSoraw9Kcs2fPYuTIkYiOjkZQUBBiYmIwdepU5OXlqT00TXrttdfQuXNnBAcHo2bNmmoPR3Pef/99REdHIzAwEO3bt8f27dvVHpLmbNu2DfHx8WjUqBEMBgNWr16t9pA0a+bMmejYsSPCwsJQr149DBgwACdPnlR7WJr0wQcfoG3btpYmZnFxcVi3bp1q42EgAqBnz55Yvnw5Tp48iRUrVuDMmTMYNGiQ2sPSnBMnTqCoqAgLFizA0aNHMXv2bHz44Yd4/vnn1R6aJuXl5eGhhx7CU089pfZQNOerr75CQkICXnjhBRw8eBB33nkn7r33XiQnJ6s9NE3JzMzErbfeivnz56s9FM3bunUrxo4di927d2Pjxo0oKChA7969kVlyY0UCADRp0gT//ve/sX//fuzfvx933XUX+vfvj6NHj6ozIIXK+eabbxSDwaDk5eWpPRTNe/PNN5Xo6Gi1h6FpixcvVoxGo9rD0JTbb79dGTNmTKnvtWzZUnnuuedUGpH2AVBWrVql9jB04+LFiwoAZevWrWoPRRdq1aqlLFq0SJXHZkakjLS0NCxbtgydO3eGn5+f2sPRPJPJhIiICLWHQTqSl5eHAwcOoHfv3qW+37t3b+zcuVOlUZGnMZlMAMDPp2oUFhbiyy+/RGZmJuLi4lQZAwOR65599lmEhISgdu3aSE5OxjfffKP2kDTvzJkzmDdvHsaMGaP2UEhHLl++jMLCQtSvX7/U9+vXr48LFy6oNCryJIqiYOLEiejatStuueUWtYejSYcPH0ZoaCgCAgIwZswYrFq1Cq1bt1ZlLB4biEybNg0Gg6HKy/79+y23f+aZZ3Dw4EFs2LABvr6+GDZsGBQvaTpr62sFACkpKejbty8eeughPPHEEyqN3P3sea2oYgaDodTXiqKU+x6RPcaNG4dffvkFX3zxhdpD0aybbroJhw4dwu7du/HUU09h+PDhOHbsmCpjqaHKo7rBuHHjMHjw4CpvExUVZblep04d1KlTBy1atECrVq0QGRmJ3bt3q5aqcidbX6uUlBT07NkTcXFxWLhwoYtHpy22vlZUXp06deDr61su+3Hx4sVyWRIiW40fPx5r1qzBtm3b0KRJE7WHo1n+/v5o3rw5AKBDhw7Yt28f5s6diwULFrh9LB4biJgDC3uYMyG5ubnOHJJm2fJa/fHHH+jZsyfat2+PxYsXw8fHY5NqFXLkfUXC398f7du3x8aNGzFw4EDL9zdu3Ij+/furODLSM0VRMH78eKxatQpbtmxBdHS02kPSFUVRVDvmeWwgYq29e/di79696Nq1K2rVqoXffvsNL7/8MmJiYrwiG2KLlJQU9OjRA02bNsWsWbNw6dIly88aNGig4si0KTk5GWlpaUhOTkZhYSEOHToEAGjevDlCQ0PVHZzKJk6ciKFDh6JDhw6WzFpycjLrjcrIyMjA6dOnLV8nJSXh0KFDiIiIQNOmTVUcmfaMHTsWn3/+Ob755huEhYVZMm5GoxFBQUEqj05bnn/+edx7772IjIzEtWvX8OWXX2LLli34/vvv1RmQKmt1NOSXX35RevbsqURERCgBAQFKVFSUMmbMGOX3339Xe2ias3jxYgVAhRcqb/jw4RW+Vps3b1Z7aJrw3nvvKc2aNVP8/f2V2NhYLrOswObNmyt8Dw0fPlztoWlOZZ9NixcvVntomvOPf/zD8rdXt25d5e6771Y2bNig2ngMiuIlFZlERESkOd41wU9ERESawkCEiIiIVMNAhIiIiFTDQISIiIhUw0CEiIiIVMNAhIiIiFTDQISIiIhUw0CEiIiIVMNAhIiIiFTDQISIiIhUw0CEiIiIVMNAhIiIiFTz/5DOy9YIvbeIAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -1332,6 +1968,7 @@ " right_variance = np.var(y_right)\n", " return orig_variance - (left_variance + right_variance)\n", "\n", + "\n", "all_information_gain = [\n", " information_gain_mse(y, y[:idx], y[idx:]) for idx in range(len(X))\n", "]\n", @@ -1347,9 +1984,9 @@ "\n", "plt.figure()\n", "plt.plot(X.ravel(), all_information_gain, color=\"red\", label=\"Information gain\")\n", - "plt.axvline(X[best_idx, 0], color='r', linestyle='--')\n", - "plt.plot(X.ravel(), y_pred, color='tab:blue', label=\"prediction\")\n", - "plt.plot(X.ravel(), y, 'C7.', label=\"training data\")\n", + "plt.axvline(X[best_idx, 0], color=\"r\", linestyle=\"--\")\n", + "plt.plot(X.ravel(), y_pred, color=\"tab:blue\", label=\"prediction\")\n", + "plt.plot(X.ravel(), y, \"C7.\", label=\"training data\")\n", "_ = plt.legend(loc=\"best\")" ] }, @@ -1362,15 +1999,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[4.23346034 1.73100472 1.32492611]\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "reg = DecisionTreeRegressor(max_depth=1)\n", "reg.fit(X, y)\n", "print(reg.tree_.impurity)\n", "\n", "from sklearn.tree import plot_tree\n", + "\n", "_ = plot_tree(reg)" ] }, @@ -1385,9 +2041,9 @@ "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python (myenv)", + "display_name": "DataCamp", "language": "python", - "name": "myenv" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -1399,7 +2055,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/09_trees_gradient_boosting/01b-grow_a_forest.ipynb b/09_trees_gradient_boosting/01b-grow_a_forest.ipynb index aa5d877..104cc91 100644 --- a/09_trees_gradient_boosting/01b-grow_a_forest.ipynb +++ b/09_trees_gradient_boosting/01b-grow_a_forest.ipynb @@ -25,7 +25,7 @@ "source": [ "We saw that by increasing the depth of the tree, we are going to get an over-fitted model. A way to bypass the choice of a specific depth it to combine several trees together.\n", "\n", - "Let's start by training several trees on slightly different data. The slightly different dataset could be generated by randomly sampling with replacement. In statistics, this called a boostrap sample. We will use the iris dataset to create such ensemble and ensure that we have some data for training and some left out data for testing." + "Let's start by training several trees on slightly different data. The slightly different dataset could be generated by randomly sampling with replacement. In statistics, this called a **boostrap** sample. We will use the iris dataset to create such ensemble and ensure that we have some data for training and some left out data for testing." ] }, { @@ -56,11 +56,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def bootstrap_idx(X):\n", + " # Draw from the dataset with the exact same number of points with replacement.\n", " indices = np.random.choice(\n", " np.arange(X.shape[0]), size=X.shape[0], replace=True\n", " )\n", @@ -69,24 +70,24 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "array([ 52, 39, 37, 50, 108, 5, 61, 37, 53, 73, 33, 32, 105,\n", - " 27, 0, 44, 25, 105, 78, 14, 22, 29, 21, 75, 12, 105,\n", - " 90, 111, 17, 73, 108, 106, 36, 69, 59, 3, 76, 90, 59,\n", - " 33, 54, 82, 87, 105, 41, 15, 27, 37, 17, 46, 84, 35,\n", - " 33, 88, 69, 52, 101, 73, 7, 39, 71, 56, 99, 44, 94,\n", - " 108, 72, 3, 51, 57, 47, 8, 4, 97, 15, 89, 46, 52,\n", - " 25, 98, 23, 43, 14, 67, 92, 18, 90, 88, 10, 62, 76,\n", - " 101, 58, 16, 50, 87, 34, 110, 1, 52, 69, 63, 21, 77,\n", - " 109, 57, 34, 59, 4, 37, 108, 91])" + "array([ 23, 73, 15, 9, 73, 93, 32, 78, 44, 44, 85, 86, 101,\n", + " 98, 34, 36, 79, 6, 80, 37, 55, 105, 81, 97, 90, 104,\n", + " 44, 55, 92, 62, 72, 99, 4, 91, 20, 6, 75, 106, 6,\n", + " 97, 2, 87, 70, 1, 79, 41, 38, 22, 47, 99, 39, 41,\n", + " 102, 1, 32, 2, 11, 9, 36, 91, 68, 35, 15, 29, 17,\n", + " 70, 9, 43, 10, 83, 61, 11, 40, 99, 14, 74, 67, 32,\n", + " 36, 27, 3, 73, 76, 85, 92, 99, 9, 7, 26, 63, 72,\n", + " 89, 75, 80, 100, 44, 49, 35, 33, 65, 13, 96, 22, 89,\n", + " 51, 109, 59, 105, 29, 36, 63, 11])" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -97,100 +98,38 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "Counter({50: 1,\n", - " 60: 2,\n", - " 107: 1,\n", - " 91: 1,\n", - " 110: 2,\n", - " 104: 3,\n", - " 46: 1,\n", - " 28: 1,\n", - " 34: 2,\n", - " 15: 2,\n", - " 7: 1,\n", - " 52: 2,\n", - " 0: 1,\n", - " 73: 1,\n", - " 22: 2,\n", - " 24: 3,\n", - " 80: 1,\n", - " 27: 3,\n", - " 62: 1,\n", - " 90: 1,\n", - " 36: 1,\n", - " 25: 1,\n", - " 51: 1,\n", - " 37: 1,\n", - " 82: 2,\n", - " 13: 3,\n", - " 61: 1,\n", - " 58: 1,\n", - " 14: 1,\n", - " 69: 3,\n", - " 106: 1,\n", - " 23: 4,\n", - " 86: 2,\n", - " 31: 3,\n", - " 48: 1,\n", - " 75: 1,\n", - " 2: 1,\n", - " 66: 1,\n", - " 97: 2,\n", - " 20: 1,\n", - " 89: 1,\n", - " 95: 1,\n", - " 17: 2,\n", - " 30: 2,\n", - " 94: 2,\n", - " 18: 2,\n", - " 1: 1,\n", - " 83: 2,\n", - " 111: 1,\n", - " 72: 4,\n", - " 92: 3,\n", - " 56: 1,\n", - " 21: 1,\n", - " 70: 1,\n", - " 35: 1,\n", - " 54: 1,\n", - " 105: 1,\n", - " 32: 2,\n", - " 53: 1,\n", - " 63: 1,\n", - " 12: 3,\n", - " 43: 1,\n", - " 96: 1,\n", - " 47: 2,\n", - " 108: 1,\n", - " 8: 1,\n", - " 78: 1,\n", - " 100: 1,\n", - " 65: 1,\n", - " 3: 1,\n", - " 4: 2,\n", - " 33: 1,\n", - " 85: 1})" + "[(15, 4),\n", + " (95, 3),\n", + " (43, 3),\n", + " (51, 3),\n", + " (77, 3),\n", + " (3, 3),\n", + " (52, 3),\n", + " (82, 3),\n", + " (78, 3),\n", + " (97, 3)]" ] }, - "execution_count": 4, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from collections import Counter\n", - "Counter(bootstrap_idx(X_train))" + "\n", + "Counter(bootstrap_idx(X_train)).most_common(10)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -201,7 +140,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -210,21 +149,21 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Classes distribution in the original data: Counter({2: 38, 0: 37, 1: 37})\n", - "Classes distribution in the bootstrap: Counter({2: 40, 1: 40, 0: 32})\n" + "Classes distribution in the original data: Counter({0: 38, 1: 37, 2: 37})\n", + "Classes distribution in the bootstrap: Counter({0: 39, 2: 38, 1: 35})\n" ] } ], "source": [ - "print(f'Classes distribution in the original data: {Counter(y_train)}')\n", - "print(f'Classes distribution in the bootstrap: {Counter(y_train_bootstrap)}')" + "print(f\"Classes distribution in the original data: {Counter(y_train)}\")\n", + "print(f\"Classes distribution in the bootstrap: {Counter(y_train_bootstrap)}\")" ] }, { @@ -264,7 +203,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "0.9736842105263158\n" + "0.9473684210526315\n" ] } ], @@ -284,11 +223,18 @@ " treei.fit(X_train_i, y_train_i)\n", " ypred_list.append(treei.predict(X_test))\n", " tree_list.append(treei)\n", - " \n", - "ypred,_ = mode(np.array(ypred_list), axis=0, keepdims=False)\n", + "\n", + "ypred, _ = mode(np.array(ypred_list), axis=0, keepdims=False)\n", "print(accuracy_score(y_test, ypred))" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "> Bootstraping regularizes the overfitting on the subtrees." + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -302,7 +248,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, "outputs": [ { @@ -315,7 +261,10 @@ ], "source": [ "from sklearn.ensemble import BaggingClassifier\n", - "clf = BaggingClassifier(estimator=DecisionTreeClassifier(max_depth=3), n_estimators=5)\n", + "\n", + "clf = BaggingClassifier(\n", + " estimator=DecisionTreeClassifier(max_depth=3), n_estimators=5\n", + ")\n", "clf.fit(X_train, y_train)\n", "print(clf.score(X_test, y_test))" ] @@ -347,14 +296,14 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "0.9736842105263158\n" + "1.0\n" ] } ], @@ -373,13 +322,13 @@ " indices = np.random.choice(\n", " np.arange(X.shape[1]), size=int(np.sqrt(X.shape[1])), replace=False\n", " )\n", - " X_train_i = X_train_i[:,indices]\n", + " X_train_i = X_train_i[:, indices]\n", " treei = DecisionTreeClassifier(max_depth=max_depth)\n", " treei.fit(X_train_i, y_train_i)\n", - " ypred_list.append(treei.predict(X_test[:,indices]))\n", + " ypred_list.append(treei.predict(X_test[:, indices]))\n", " tree_list.append(treei)\n", - " \n", - "ypred,_ = mode(np.array(ypred_list), axis=0, keepdims=False)\n", + "\n", + "ypred, _ = mode(np.array(ypred_list), axis=0, keepdims=False)\n", "print(accuracy_score(y_test, ypred))" ] }, @@ -396,7 +345,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -409,6 +358,7 @@ ], "source": [ "from sklearn.ensemble import RandomForestClassifier\n", + "\n", "clf = RandomForestClassifier(n_estimators=5)\n", "clf.fit(X_train, y_train)\n", "print(clf.score(X_test, y_test))" @@ -416,14 +366,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "39fefe1be5ca4d3ca24ba3ac018a7f42", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(IntSlider(value=0, description='max_depth', max=8), Output()), _dom_classes=('widget-int…" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "from figures import plot_forest_interactive\n", + "\n", "plot_forest_interactive()" ] }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.ensemble import HistGradientBoostingClassifier" + ] + }, { "cell_type": "code", "execution_count": null, @@ -434,9 +410,9 @@ ], "metadata": { "kernelspec": { - "display_name": "Python (myenv)", + "display_name": "DataCamp", "language": "python", - "name": "myenv" + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -448,7 +424,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/09_trees_gradient_boosting/02-gradient_boosting_pure_python.ipynb b/09_trees_gradient_boosting/02-gradient_boosting_pure_python.ipynb index 80f2923..5f9a3f9 100644 --- a/09_trees_gradient_boosting/02-gradient_boosting_pure_python.ipynb +++ b/09_trees_gradient_boosting/02-gradient_boosting_pure_python.ipynb @@ -25,9 +25,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading data...\n" + ] + } + ], "source": [ "import pandas as pd\n", "\n", @@ -52,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -70,9 +78,31 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Start training...\n", + "Training until validation scores don't improve for 5 rounds.\n", + "Iter 0, Train's L2: 0.3252607366, Valid's L2: 0.3243806612, Elapsed: 4.08 secs\n", + "Iter 1, Train's L2: 0.1910394119, Valid's L2: 0.2334865415, Elapsed: 4.08 secs\n", + "Iter 2, Train's L2: 0.1819084918, Valid's L2: 0.2283040383, Elapsed: 3.90 secs\n", + "Iter 3, Train's L2: 0.1796346779, Valid's L2: 0.2271376883, Elapsed: 3.94 secs\n", + "Iter 4, Train's L2: 0.1790838384, Valid's L2: 0.2270600664, Elapsed: 4.02 secs\n", + "Iter 5, Train's L2: 0.1789199061, Valid's L2: 0.2269796320, Elapsed: 3.79 secs\n", + "Iter 6, Train's L2: 0.1788711223, Valid's L2: 0.2269556204, Elapsed: 3.73 secs\n", + "Iter 7, Train's L2: 0.1788565487, Valid's L2: 0.2269488359, Elapsed: 4.23 secs\n", + "Iter 8, Train's L2: 0.1788521823, Valid's L2: 0.2269468050, Elapsed: 4.18 secs\n", + "Iter 9, Train's L2: 0.1788508808, Valid's L2: 0.2269462217, Elapsed: 4.31 secs\n", + "Training finished. Elapsed: 40.25 secs\n", + "Start predicting...\n", + "The MSE of prediction is: 0.22694622173977055\n" + ] + } + ], "source": [ "from sklearn.metrics import mean_squared_error\n", "from tinygbt import GBT\n", @@ -97,9 +127,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Starting training...\n", + "Saving model...\n", + "Starting predicting...\n", + "The MSE of prediction is: 0.21796435968378255\n" + ] + } + ], "source": [ "import lightgbm as lgb\n", "\n", @@ -126,7 +167,8 @@ " lgb_train,\n", " num_boost_round=10,\n", " valid_sets=lgb_eval,\n", - " early_stopping_rounds=5)\n", + " # early_stopping_rounds=5\n", + " )\n", "\n", "print('Saving model...')\n", "# save model to file\n", @@ -149,9 +191,17 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The MSE of prediction is: 0.19818811241253062\n" + ] + } + ], "source": [ "# from sklearn.experimental import enable_hist_gradient_boosting # uncomment this for sklearn < 1.0\n", "from sklearn.ensemble import HistGradientBoostingRegressor\n", @@ -183,9 +233,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training until validation scores don't improve for 5 rounds.\n", + "Iter 0, Train's L2: 0.3334921218, Valid's L2: 0.3336843212, Elapsed: 5.15 secs\n", + "Iter 1, Train's L2: 0.1915670834, Valid's L2: 0.2341459312, Elapsed: 5.20 secs\n", + "Training finished. Elapsed: 10.35 secs\n", + " \n", + "*** Profile stats marshalled to file '/var/folders/vw/2kmjpl310zl2lwgnwpxsyw4r0000gn/T/tmp41a6tgu4'.\n", + "Embedding SnakeViz in this document...\n", + "\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "%load_ext snakeviz\n", "\n", @@ -221,7 +300,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "DataCamp", "language": "python", "name": "python3" }, @@ -235,7 +314,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.6" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/09_trees_gradient_boosting/figures/decision_bounary.py b/09_trees_gradient_boosting/figures/decision_bounary.py index 73c15f6..e1bb60a 100644 --- a/09_trees_gradient_boosting/figures/decision_bounary.py +++ b/09_trees_gradient_boosting/figures/decision_bounary.py @@ -2,7 +2,7 @@ from matplotlib import cm from matplotlib.colors import ListedColormap -from sklearn.utils import check_matplotlib_support +# from sklearn.utils import check_matplotlib_support from sklearn.utils import _safe_indexing @@ -121,7 +121,7 @@ def plot(self, plot_method="contourf", ax=None, **kwargs): ------- display: :class:`~sklearn.inspection.DecisionBoundaryDisplay` """ - check_matplotlib_support("DecisionBoundaryDisplay.plot") + # check_matplotlib_support("DecisionBoundaryDisplay.plot") import matplotlib.pyplot as plt # noqa if plot_method not in ("contourf", "contour", "pcolormesh"): @@ -132,11 +132,12 @@ def plot(self, plot_method="contourf", ax=None, **kwargs): if ax is None: _, ax = plt.subplots() - top = cm.get_cmap('Oranges_r', 128) - bottom = cm.get_cmap('Blues', 128) - newcolors = np.vstack((top(np.linspace(0, 1, 128)), - bottom(np.linspace(0, 1, 128)))) - cmap = ListedColormap(newcolors, name='OrangeBlue') + top = cm.get_cmap("Oranges_r", 128) + bottom = cm.get_cmap("Blues", 128) + newcolors = np.vstack( + (top(np.linspace(0, 1, 128)), bottom(np.linspace(0, 1, 128))) + ) + cmap = ListedColormap(newcolors, name="OrangeBlue") kwargs["cmap"] = kwargs.get("cmap", cmap) plot_func = getattr(ax, plot_method) @@ -161,7 +162,7 @@ def from_estimator( plot_method="contourf", response_method="auto", ax=None, - **kwargs + **kwargs, ): """Plot Decision Boundary. @@ -206,7 +207,7 @@ def from_estimator( ------- display: :class:`~sklearn.inspection.DecisionBoundaryDisplay` """ - check_matplotlib_support("plot_decision_boundary") + # check_matplotlib_support("plot_decision_boundary") if not grid_resolution > 1: raise ValueError("grid_resolution must be greater than 1") @@ -252,4 +253,4 @@ def from_estimator( xlabel=xlabel, ylabel=ylabel, ) - return display.plot(ax=ax, plot_method=plot_method, **kwargs) \ No newline at end of file + return display.plot(ax=ax, plot_method=plot_method, **kwargs)