From db0826ade09ac0fd7ee25e3a1c4ef8016ead592f Mon Sep 17 00:00:00 2001 From: andnig Date: Mon, 6 Nov 2023 13:16:09 +0100 Subject: [PATCH] ML: Add AutoML classification example using PyCaret --- .../classification-automl/.gitignore | 6 + .../classification-automl/README.md | 71 + .../automl_classification_with_pycaret.ipynb | 3472 +++++++++++++++++ .../automl_classification_with_pycaret.md | 2237 +++++++++++ .../automl_classification_with_pycaret.py | 75 + ...automl_classification_with_pycaret_5_0.png | Bin 0 -> 16947 bytes ...automl_classification_with_pycaret_7_0.png | Bin 0 -> 192266 bytes ...automl_classification_with_pycaret_9_0.png | Bin 0 -> 19001 bytes .../classification-automl/requirements.txt | 7 + 9 files changed, 5868 insertions(+) create mode 100644 topic/machine-learning/classification-automl/.gitignore create mode 100644 topic/machine-learning/classification-automl/README.md create mode 100644 topic/machine-learning/classification-automl/automl_classification_with_pycaret.ipynb create mode 100644 topic/machine-learning/classification-automl/automl_classification_with_pycaret.md create mode 100644 topic/machine-learning/classification-automl/automl_classification_with_pycaret.py create mode 100644 topic/machine-learning/classification-automl/automl_classification_with_pycaret_files/automl_classification_with_pycaret_5_0.png create mode 100644 topic/machine-learning/classification-automl/automl_classification_with_pycaret_files/automl_classification_with_pycaret_7_0.png create mode 100644 topic/machine-learning/classification-automl/automl_classification_with_pycaret_files/automl_classification_with_pycaret_9_0.png create mode 100644 topic/machine-learning/classification-automl/requirements.txt diff --git a/topic/machine-learning/classification-automl/.gitignore b/topic/machine-learning/classification-automl/.gitignore new file mode 100644 index 00000000..a1b90766 --- /dev/null +++ b/topic/machine-learning/classification-automl/.gitignore @@ -0,0 +1,6 @@ +.env +.env.local +*.log +catboost_info/ +mlruns/ +model/ diff --git a/topic/machine-learning/classification-automl/README.md b/topic/machine-learning/classification-automl/README.md new file mode 100644 index 00000000..2642450b --- /dev/null +++ b/topic/machine-learning/classification-automl/README.md @@ -0,0 +1,71 @@ +# AutoML with Pycaret and CrateDB + +This folder provides examples, tutorials and runnable code on how to use CrateDB +with Pycaret to automatically create high-performing machine learning models. + +The tutorials and examples focus on being easy to understand and use. They +should be a good starting point for your own projects. + +## About Pycaret + +[Pycaret] is a Python library that makes it easy to create and train machine +learning models in python. The outstanding feature of Pycaret is its AutoML +capabilities. + +Pycaret is a high-level interface on top of popular machine learning +frameworks. Among them are scikit-learn, xgboost, ray, lightgbm and many more. + +Pycaret provides a simple low-code interface to utilize these libraries without +needing to know the details of the underlying model architectures and +parameters. + +The general concept of Pycaret - and for the matter of fact for AutoML in +general - is rather simple: One takes the raw data, splits it into a training +and a test set and then trains a number of different models on the training +set. The models are then evaluated on the test set and the best performing +model is selected. This process gets repeated for tuning the hyperparameters +of the best models. Again, this process is highly empirical. The parameters are +changed, the model is retrained and evaluated again. This process is repeated +until the best performing parameters are found. + +Modern algorithms for executing all these experiments are - among other - +GridSearch, RandomSearch and BayesianSearch. For a quick introduction into +these methods, see this +[Introduction to hyperparameter tuning][Introduction to hyperparameter tuning] + +In the past, all these try-and-error experiments had to be done manually - +which is a tedious and time-consuming task. Pycaret automates this process +and provides a simple interface to execute all these experiments in a +straightforward way. This notebook shows how. + +## What's inside + +[![Made with Jupyter](https://img.shields.io/badge/Made%20with-Jupyter-orange?logo=Jupyter)](https://jupyter.org/try) [![Made with Markdown](https://img.shields.io/badge/Made%20with-Markdown-1f425f.svg?logo=Markdown)](https://commonmark.org) + +This folder provides guidelines and runnable code to get started with [Pycaret] +and [CrateDB]. + +- [readme.md](readme.md): The file you are currently reading contains a + walkthrough about how to get started with the Pycaret framework and CrateDB, + and guides you to corresponding example programs on how to train different + models. + +- [requirements.txt](requirements.txt): Pulls the required dependencies to + run the example programs. + +- `automl_classification_with_pycaret.ipynb` [![Open on GitHub](https://img.shields.io/badge/Open%20on-GitHub-lightgray?logo=GitHub)](automl_classification_with_pycaret.ipynb) [![Open in Collab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/crate/cratedb-examples/blob/feature%2Fpycaret_example/topic/machine-learning/classification-automl/automl_classification_with_pycaret.ipynb) + + This notebook explores the Pycaret framework and shows how to use it to + train different classification models - using a user churn dataset as an + example. The notebook demonstrates the usage of Pycaret to automatically train + and benchmark a multitude of models and at the end select the best performing + model. The notebook also shows how to use CrateDB as storage for both the raw + data and the expirement tracking and model registry data. + +- Accompanied to the Jupyter Notebook files, there are also basic variants of + the above examples, + [automl_classification_with_pycaret.py](automl_classification_with_pycaret.py). + +[Pycaret]: https://github.com/pycaret/pycaret +[CrateDB]: https://github.com/crate/crate +[Introduction to hyperparameter tuning]: https://medium.com/analytics-vidhya/comparison-of-hyperparameter-tuning-algorithms-grid-search-random-search-bayesian-optimization-5326aaef1bd1 diff --git a/topic/machine-learning/classification-automl/automl_classification_with_pycaret.ipynb b/topic/machine-learning/classification-automl/automl_classification_with_pycaret.ipynb new file mode 100644 index 00000000..2838dc04 --- /dev/null +++ b/topic/machine-learning/classification-automl/automl_classification_with_pycaret.ipynb @@ -0,0 +1,3472 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Create a classification model with CrateDB, Pycaret and MLflow\n", + "\n", + "This notebook guides you through the process of creating a classification\n", + "machine learning model with CrateDB and Pycaret. The exciting part: we're\n", + "using automatic machine learning model selection, benchmarking and \n", + "hyperparameter tuning - commonly known as AutoML.\n", + "\n", + "## CrateDB\n", + "\n", + "CrateDB is a distributed SQL database that makes it simple to store and analyze\n", + "huge amounts of time series data in real-time. It provides a robust SQL\n", + "interface and a number of anlaytics features that are predestined for machine\n", + "learning tasks.\n", + "\n", + "Two additional features stand out:\n", + "\n", + "1. CrateDB allows to store both relational data like strings, floats and \n", + " timestamps as well as complex object types. This makes it easy to store\n", + " the raw data required for machine learning model creation as well as the\n", + " metadata that is often required to make sense of the data.\n", + "\n", + "1. CrateDB offes first-class time partitioning support. This allows to store\n", + " tremendous amounts of data in a single table and still be able to query\n", + " it in a performant way. This is especially useful for time series data\n", + " like sensor data, user tracking data or log data.\n", + "\n", + "## Pycaret\n", + "\n", + "Pycaret is a Python library that makes it easy to create and train machine\n", + "learning models in python. The outstanding feature of Pycaret is its AutoML\n", + "capabilities. \n", + "\n", + "Pycaret is a high-level interface on top of popular machine learning\n", + "frameworks. Among them are scikit-learn, xgboost, ray, lightgbm and many more.\n", + "\n", + "Pycaret provides a simple low-code interface to utilize these libraries without\n", + "needing to know the details of the underlying model architectures and\n", + "parameters. \n", + "\n", + "The general concept of Pycaret - and for the matter of fact for AutoML in\n", + "general - is rather simple: One takes the raw data, splits it into a training\n", + "and a test set and then trains a number of different models on the training\n", + "set. The models are then evaluated on the test set and the best performing\n", + "model is selected. This process gets repeated for tuning the hyperparameters\n", + "of the best models. Again, this process is highly empirical. The parameters are\n", + "changed, the model is retrained and evaluated again. This process is repeated\n", + "until the best performing parameters are found.\n", + "\n", + "Modern algorithms for executing all these experiments are - among other - \n", + "GridSearch, RandomSearch and BayesianSearch. For a quick introduction into\n", + "these methods, see \n", + "[this article](https://medium.com/analytics-vidhya/comparison-of-hyperparameter-tuning-algorithms-grid-search-random-search-bayesian-optimization-5326aaef1bd1).\n", + "\n", + "In the past, all these try-and-error experiments had to be done manually - \n", + "which is a tedious and time-consuming task. Pycaret automates this process\n", + "and provides a simple interface to execute all these experiments in a\n", + "straightforward way. This notebook shows how.\n", + "\n", + "## The dataset\n", + "\n", + "The dataset used to demonstrate the use of Pycaret and CrateDB for training \n", + "machine learning models is a churn dataset of a telecom provider.\n", + "\n", + "It includes various attributes relating to customer demographics, services \n", + "subscribed to, billing information, and churn status.\n", + "\n", + "- `customerID`: A unique identifier for each customer.\n", + "- `gender`: The customer's gender (e.g., Male, Female).\n", + "- `SeniorCitizen`: Indicates whether the customer is a senior citizen (1) or \n", + " not (0).\n", + "- `Partner`: Indicates whether the customer has a partner (Yes) or not (No).\n", + "- `Dependents`: Indicates whether the customer has dependents (Yes) or not \n", + " (No).\n", + "- `tenure`: The total amount of time that the customer has been with the \n", + " company.\n", + "- `PhoneService`: Indicates whether the customer has a phone service (Yes) \n", + " or not (No).\n", + "- `MultipleLines`: Indicates whether the customer has multiple lines (Yes), \n", + " no multiple lines (No), or no phone service.\n", + "- `InternetService`: The type of internet service the customer has (DSL, \n", + " Fiber optic, or None).\n", + "- `OnlineSecurity`: Indicates whether the customer subscribes to an additional\n", + " online security service (Yes, No, or No internet service).\n", + "- `DeviceProtection`: Whether the customer has a device protection plan (Yes, \n", + " No, or No internet service).\n", + "- `TechSupport`: Indicates whether the customer has tech support services (Yes, \n", + " No, or No internet service).\n", + "- `StreamingTV`: Indicates if the customer has streaming TV service (Yes, No, \n", + " or No internet service).\n", + "- `StreamingMovies`: Indicates if the customer has streaming movies service \n", + " (Yes, No, or No internet service).\n", + "- `Contract`: The type of contract the customer has (Month-to-month, One year, \n", + " Two years).\n", + "- `PaperlessBilling`: Indicates whether the customer has paperless billing (Yes) \n", + " or not (No).\n", + "- `PaymentMethod`: The customer's payment method (Electronic check, \n", + " Mailed check, Credit card (automatic), etc.).\n", + "- `MonthlyCharges`: The amount charged to the customer each month.\n", + "- `TotalCharges`: The total amount charged to the customer over the time they \n", + " have been with the company.\n", + "- `Churn`: Indicates whether the customer has churned (Yes) or not (No).\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Getting started\n", + "\n", + "First, install the required dependencies. \n", + "\n", + "```bash\n", + "pip install -r requirements.txt\n", + "```\n", + "\n", + "> **Note:** As of time of this writing, Pycaret requires Python 3.8, 3.9 or \n", + "> 3.10.\n", + "\n", + "Secondly, we need a CrateDB instance to store and serve the data. The easiest\n", + "way to get started is to use the free CrateDB cloud offering. You can sign up\n", + "for a free account at https://console.cratedb.cloud.\n", + "\n", + "[Deploy a cluster](https://cratedb.com/docs/cloud/en/latest/tutorials/deploy/stripe.html#deploy-cluster)\n", + "and we're ready to go.\n", + "\n", + "Finally, create a file `.env` with the following content:\n", + "\n", + "```env\n", + "CRATE_HOST= # set this to localhost if you're running crate locally\n", + "CRATE_USER= # set this to crate if you're running crate locally\n", + "CRATE_PASSWORD= # set this to \"\" if you're running crate locally\n", + "CRATE_SSL=true # set this to false if you're running crate locally\n", + "```\n", + "\n", + "You can find your cratedb credentials in your \n", + "[CrateDB Cloud Console](https://cratedb.com/docs/cloud/en/latest/reference/overview.html#cluster).\n", + "\n", + "### Creating demo data\n", + "\n", + "For convenience, this notebook comes with an accompanying csv dataset which we \n", + "can quickly import in our database. Upload the csv file to your CrateDB cloud\n", + "cluster, as described [here](https://cratedb.com/docs/cloud/en/latest/reference/overview.html#import).\n", + "To follow this notebook, choose `pycaret_churn` for your database name.\n", + "\n", + "This will automatically create a new crate table and import the data.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Alternative data import using code\n", + "\n", + "If you prefer to use code to import your data, please execute the following lines which read the CSV\n", + "file into a pandas data frame, automatically creates the table in CrateDB and loads the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import dotenv\n", + "import sqlalchemy as sa\n", + "import pandas as pd\n", + "if os.path.exists(\".env\"):\n", + " dotenv.load_dotenv(\".env\", override=True)\n", + "\n", + "dburi = f\"crate://{os.environ['CRATE_USER']}:{os.environ['CRATE_PASSWORD']}@{os.environ['CRATE_HOST']}:4200?ssl={os.environ['CRATE_SSL']}\"\n", + "engine = sa.create_engine(dburi, echo=True)\n", + "df = pd.read_csv(\"https://github.com/crate/cratedb-datasets/raw/main/machine-learning/automl/churn-dataset.csv\")\n", + "\n", + "with engine.connect() as conn:\n", + " df.to_sql(\"pycaret_churn\", conn, index=False, chunksize=1000, if_exists=\"replace\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Model creation\n", + "Now that our data and environment is set up, we can start creating our model.\n", + "\n", + "The first step is to import the required libraries and to load our data from\n", + "the database." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import dotenv\n", + "import sqlalchemy as sa\n", + "import pandas as pd\n", + "import plotly\n", + "import plotly.express as plotly_express\n", + "import plotly.graph_objects as go\n", + "import mlflow_cratedb # We need this import to use the CrateDB MLflow store\n", + "\n", + "if os.path.exists(\".env\"):\n", + " dotenv.load_dotenv(\".env\", override=True)\n", + "\n", + "dburi = f\"crate://{os.environ['CRATE_USER']}:{os.environ['CRATE_PASSWORD']}@{os.environ['CRATE_HOST']}:4200?ssl={os.environ['CRATE_SSL']}\"\n", + "engine = sa.create_engine(dburi, echo=True)\n", + "\n", + "with engine.connect() as conn:\n", + " with conn.execute(sa.text(\"SELECT * FROM pycaret_churn\")) as cursor:\n", + " data = pd.DataFrame(cursor.fetchall(), columns=cursor.keys())\n", + "\n", + "# We set the MLFLOW_TRACKING_URI to our CrateDB instance. We'll see later why\n", + "os.environ[\n", + " \"MLFLOW_TRACKING_URI\"\n", + "] = f\"{dburi}&schema=mlflow\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, let's have a quick glance on how our dataset looks like.\n", + "As we already know from chapter [The dataset](#the-dataset), the feature\n", + "to predict is `Churn` . Let's have a look at the distribution of this feature.\n", + "\n", + "> **Note:** knowing the distribution of the target feature is important to know\n", + "> whether the dataset is imbalanced - meaning that it has much more samples of\n", + "> one class than of the other. This is important to know because it can lead to\n", + "> biased models - so we can accommodate for this in our model creation process." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set plotly to png render mode to render static pngs instead of\n", + "# interactive plots. Remove this line to get interactivity.\n", + "plotly.io.renderers.default = 'png'\n", + "\n", + "# Count the number of customers that churned and did not churn\n", + "churn_counts = data[\"Churn\"].value_counts()\n", + "\n", + "# Calculate the percentage of customers that churned and did not churn\n", + "churn_percentages = churn_counts / churn_counts.sum() * 100\n", + "\n", + "# Create a bar chart\n", + "bar_data = go.Bar(\n", + " x=churn_percentages.index,\n", + " y=churn_percentages.values,\n", + " text=[f\"{value:.1f}%\" for value in churn_percentages.values],\n", + " textposition='auto', # to position the text inside the bars\n", + " marker_color=[\"#0f77b4\", \"red\"]\n", + ")\n", + "\n", + "# Define layout\n", + "layout = go.Layout(\n", + " title=\"Percentage of customers churned?\",\n", + " xaxis=dict(\n", + " title=\"Churn\",\n", + " tickvals=churn_percentages.index,\n", + " ticktext=[\"Non-Churned\", \"Churned\"]\n", + " ),\n", + " yaxis=dict(\n", + " title=\"Percentage of Customers\"\n", + " ),\n", + " showlegend=False,\n", + " width=800,\n", + ")\n", + "\n", + "# Create figure\n", + "fig = go.Figure(data=[bar_data], layout=layout)\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The plot reveals that our dataset is indeed skewed towards non-churned users.\n", + "Let's keep this in mind for later.\n", + "\n", + "With that out of the way, we can dig deeper into the dataset to get a better\n", + "understanding of the data we're dealing with. These next steps are not strictly\n", + "necessary for creating a model, but they help us to understand the data and\n", + "to better verify our models performance.\n", + "\n", + "As a general guideline, a Data Scientist is tasked with investigating the \n", + "influence of features on the target variable. Let's start with tenure - as it\n", + "might be reasonable to argue that a clients tenue might influence the churn." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# sort by Churn so that the Churned customers are plotted on top,\n", + "# otherwise the plot is not readable\n", + "data = data.sort_values(by=\"Churn\", ascending=True)\n", + "fig = plotly_express.scatter(x=data[\"tenure\"],\n", + " y=data[\"TotalCharges\"],\n", + " color=data[\"Churn\"],\n", + " template=\"presentation\",\n", + " opacity=0.5,\n", + " facet_col=data[\"Contract\"],\n", + " title=\"Customer Churn\",\n", + " labels={\n", + " \"x\": \"Tenure\",\n", + " \"y\": \"Total Charges\"\n", + " },\n", + " width=1500)\n", + "\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It's quite obvious, that most people seem to churn with month-to-month \n", + "contracts. Also, the longer the tenure, the less likely it is that a customer \n", + "churns (generally speaking).\n", + "Another interesting angle might be too look at whether users with specific \n", + "services - like internet service - are more likely to churn. " + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAH0CAYAAADfWf7fAAAgAElEQVR4Xuydd3xUxRqG383uJkBCb1IEQUEQUUAExasgUhRpShGlS++9hd4C0oXQkQ7SpKs0AQUBpSO9iQgiKL0nW+5vTkhMIMDmbOZkZ897/rnX5MyZb55vhnkyO2fW4na73eBFAiRAAiRAAiRAAiRAAn5KwELh9dPMslkkQAIkQAIkQAIkQAIaAQovOwIJkAAJkAAJkAAJkIBfE6Dw+nV62TgSIAESIAESIAESIAEKL/sACZAACZAACZAACZCAXxOg8Pp1etk4EiABEiABEiABEiABCi/7AAmQAAmQAAmQAAmQgF8ToPD6dXrZOBIgARIgARIgARIgAQov+wAJkAAJkAAJkAAJkIBfE6Dw+nV62TgSIAESIAESIAESIAEKL/sACZAACZAACZAACZCAXxOg8Pp1etk4EiABEiABEiABEiABCi/7AAmQAAmQAAmQAAmQgF8ToPD6dXrZOBIgARIgARIgARIgAQov+wAJkAAJkAAJkAAJkIBfE6Dw+nV62TgSIAESIAESIAESIAEKL/sACZAACZAACZAACZCAXxOg8Pp1etk4EiABEiABEiABEiABCi/7AAmQAAmQAAmQAAmQgF8ToPD6dXrZOBIgARIgARIgARIgAQov+wAJkAAJkAAJkAAJkIBfE6Dw+nV62TgSIAESIAESIAESIAEKL/sACZAACZAACZAACZCAXxOg8Pp1etk4EiABEiABEiABEiABCi/7AAmQAAmQAAmQAAmQgF8ToPD6dXrZOBIgARIgARIgARIgAQov+wAJkAAJkAAJkAAJkIBfE6Dw+nV62TgSIAESIAESIAESIAEKL/sACZAACZAACZAACZCAXxOg8Pp1etk4EiABEiABEiABEiABCi/7AAmQAAmQAAmQAAmQgF8ToPD6dXrZOBIgARIgARIgARIgAQov+wAJkAAJkAAJkAAJkIBfE6Dw+nV62TgSIAESIAESIAESIAEKL/sACZAACZAACZAACZCAXxOg8Pp1etk4EiABEiABEiABEiAB5YW3RffROP/3v1g5c7DfZfN+RCSKlGuClvWroFXDj3ymfaMmL8JXX3+HQ5tn+kxMegI5eOx3fNKsP0b1a4XypV7X8wiWIQESIAESIAESUICAzwrv5as3MHPhGvy4Yz/++vsfuFxu5MiWGaVKFELd6uWQPm0qDS+F1/he5qnwrt28Ex37jdcCXDZ9EPLmzh4n2EFj5uDr5T9g5/eTkCJ5skRtyMaf92Lxqs347chp3Lx1B6lSpsCrL72AGpVKoeSbr2p1qSi8dVoPxtnzF/HTsrHx8ipUtjGKFcqHKcM7JypPPowESIAESIAEVCbgk8J74PAptOgxGtdv3Mb/ir2Ml1/MDastACd/P4+fduzX5OjHpV9SeJOo5+kR3jJvv4YvB7aRLrziD6NeX0zDirU/45mM6fDuW4WROWNaXLt+C9t2HcTx0+fQt1MD1KxUisKbRP2H1ZIACZAACZCA0QR8TniFmFRp2BPi4/yJQzug8Mt54jC5cu0mhHAN6tbIcOG9ey8CyZMFGpYj1bc0RK/w5nshB46ePItvpg2A+P/Rl4wV3slzVmHsV9+gcrm30L9zAwQG2uPk64cte3Dj1m189MHbhgrvnbv3kSJ5kNd9xxdXeI0eF15D5ANIgARIgARMR8DnhHf8jGWYMGuFJrRCSp52RW9pGDeoLcLGzsXuA8c0yalUtgQ6t6gFu80a84iPG/VGhnSpH/m4d/iEBZi9ZC1+2zgj5t6i7zdF1fff1gRt9uK1+OPcRbSoXwVBgXaMmLQQy2cMwpS5q7Dll98QGenAG6+9hH6dGiBj+jRxQhar1ONnLscPW3bj3yvXkSljWlQq+yZa1K8aJzZx39Dw+fhh626t/P+KvYLOzWuibK3OHu3hXb1+u7aqefz0n7h+4xYyZkiLCqWLo1WDqnGkb8aC7xMU/7ofdyF8xjLtY/Rsz2RA0zqVcOrMeY/28EYL75DQJhj85Vzto/Zxg9s9VXi37zqk9YHDx88gICAAhQq8gLaNq6FgvlxP7A63bt/Fu9U7aDkWe7rtdtsT7/9vS0NLXLh0BfOWbsA/l68hT67sCG1bO84fW0PGzcPClZuwb/20OM/cvG0fWoWOwZxxoShSMG+cP8JEfxg9ZbHWDtGGr0Z1RXS/euWl3Jg271uNq8hVszqVUL1iyad1d+gRXtGuRas24dxf/8BqDUCWzOlRtfz/0LDWBzH1edpPHzcumterrK2gT5q9EidOn9P+YBV5eL1QPgzo8rlWLy8SIAESIAESSCoCPie8QkqFBGxfNeGpwiKgCeE9duosLLDgzaIFtH2iv+49ik3b9qJD0xpo/NmHuoU3VcpgBAUGos3nHyNL5nRIFhSIHbsPa8L4bNZM+LDMGyj5xqvaS3MDx8xGwXy5MXlYp5j6bt+5h1rN++Piv1dRs/K72h7kYyfPYvHqzSj7TlGM7NtSu9fpdKFOm8E4ePQ0Pq1aBs/nzKLtXb5w8bL2EbwnL63VbjUIWZ9Jj5fyPKetJO46cAzf/fALPnzvDQzr3Twmpmjh9SR+wbB16Jea9Is/Pm7evoM5i9chU4a0OPH7uae+tBYtvOPD2uPg0d8xcfYKLJrcDwVefE6LJ74V3h+370frnmM0vtU+LKn9MbFw5UZte8ussaFPlF6xetu291i0a1xNE/OnXdHCWzB/bghZrljmTbjhxpwl67SiGxaOilmVTajw7j90UpM8EcfL+XJpAvhGkZc04U2TOiVShaRA688/Roa0qTBv2QaIP1jmT+iNV196/olhJ1R4F63chP6jZmn9oHiRl+BwOHDqjwv4+5/LGDuwrVaXp/1U3Cvij29cWK1W1GzaFy/lfQ4Vy5bQPgk5d+EfiJwsnNxX+0ORFwmQAAmQAAkkFQGfE95X32uE/HlyYMGkvh4xEcIr9vVG78uMLvRpy4G4fOU61i0YoVt4HQ4n1nw9XNsLGn1FC2OT2hXRvkn1mJ+LF+yGT1yA9QtGIOszGbSfj5y0CHOXrseiyX21VcPoa9Gqzeg/cmaM/AnZ6TZ4Mnp3qIdaVUprt7ndbrTtNRbi5StPhDe+j8zF6uK0+d/ih8WjYtqQkPg/qN0NLpdLe+Es+uN4sVpZo2k/LcanndIQW3hfeyWvtlpdpGAeTBjSIV7hFW2uUKcbRFtWzgpD6pTB2n1C/CvW66HJlFhJfdwlVty/nPYNJn3REW8Xf+Wp/SdaeHNky4SlXw2K2a4iVu2bdxuJsB5NUKX8W9pzEiq8ok+KP2jef7dYnDiEMFosAVi3YDjSpk6p/S4iIhKlqrdH6beKxGzVeVzwCRXelj1G45/L17F4SlTO4rs87aeirIg/vnER3f9//W4SglMk7guIT00kbyABEiABEiCBpxDwKeGN3rMqtgd8NbKrR8kTwvvr3iPY+f1kBARYYsqMmboEX339LfaunwabNWpbQ0K3NBR+OS+mjoj7tnu0MD68H/WXvUfweYcvMH10NxQvnF+rr8wnnfDCc1nx5YOVtOjgxIra21XboHPzT7SPlTv1n4CfdhzAtpXhcVa1d+0/hvrthngkvLFhOZxObdX40LHfUbdNmLaNoPRbhbVbPI3/9NkLqFSvhyb1Qu5jXw07DNVW0RMivOJ0DbFNQWxZEX/MiO0JD6/wRtcpPh4Xq+qxr15ffIVl32/B9tUTtNXR+K7ol+nmjOupifXTrmjhfbiNQkALl2uCFvWqoPXnUcfBJVR4d+w5jN1rpsTpk9HC+OZrBeJs7RA/r9c2TKtn9tjHC734fUKFt9ugydofhOKTh1ces3rsaT+Njj++cbFk9Y/oO2IGBnb9XNsKFHssPi0P/D0JkAAJkAAJyCbgU8IrGqtnhffPvy5h9ewhcVhFi93PK8KRJnWI9ruECm+F997Q9h/GvqKfu2X5OKRLE7VCJ65oeRrdvzXKlSyqfRQvjoh60vV5rQro1LwmarUYgHv3IrR9wbEvsee35MftPBJesfIq9tru+e2EdgxX7Cv2SqWn8Uevco4Z0FrbfhH7Eh+Ri4/KEyq8YttA2U864dUCz2PSF50eEd7oOr/o1UzbXhD7il5BfPgPjdj36F3hHdGnBT4oXTxOfWIlU2zj6NmurvbzhArvmT8v4Pt5wx5Jv3hulfL/01bzY1/iD7e/Lv6LFTOefJ60J8Ir/uCK3lojTjZp0mU4Lv17TduDXaLoyyjzzmv4X7GCWvUJ6afifhF/fONCvLjWuNMw7Dt0UluZL14kP0qVKIwP3i32yIuDTxwU/CUJkAAJkAAJSCDgc8L70ee9tL1/28Qe3lgvnD2u7Y87hzda7LauGBfz0XG1xn2083sfPqNUyMz8ZRvifWmtV/so4Ym+4nuu+N3DZ7pGr1a/W6IwmtSJu0Ia/axM6dNoLxCJfb7ifrF1IPblqfCKF64q1++BbM9kRL0a5ZA9SyYEBdnx5/lL2laJ2C8Aehr/ll8OoHm3UdpRYuJIsdiXXuEVz4g+RUHsV121blucc3ifJLzRcS/9aiBefP7ZeLvDhi270a73uHhXpeMr8KRzeKNfzorOv3ihcMGKjY+8tBa9bzi+l9bi+zKUh58bHZen50k36jgMB46c1s4ufvgSK/viD8b33i4Ssz9X3CO2iGz5ZT9+3nkQ23Ye1F7QE4IvRD8h/TRaeMUK7sPjQvxOHAm3c/9RbUVZ7HUXJ3PkypFF25v8uFV5Cf+m8ZEkQAIkQAIk8AgBnxPecdOXam96izf7xdFST7sSIrzio/i7d+8/sj9YvJj14459iSq8Iu53q7fXTm0QL2o96fJ2S8P8ZT9g8JdzsGr2EOTOkSWmKrH/t03PL3UJr4wtDSIwsZ2jbK1OKJA3F3JmzxxHeJ+0paH3sOlY+t1PT9zSIFa2S9fooL1Ut2Lm4JitLI9jnxDhjd6OsWvNlDhH081avBbDxn8d7ykNMoQ3msPGxaO184VjX+JFwqoNe2lfzNK99WfxNlvskxYnZogv/BCfKIi95Z7206cJ78MVrtn0q7ZdJ7RtHdT+uMzThjJ/TwIkQAIkQALSCPic8Ipzdqs0CIXT5dJWYl9+Me5RVOJtffEyVr/ODTQoCRFescdw5bpt+GHRqJjtCL+fvQCxqizqi+9YMr0rvCI2cdzZzEVr4v3qWrHqBri1L9EQK53dw6agb8f62mkO0ZdYrRSrlk97aU2sPA4cPTtGYER5sYe3cedh2l5bPSu80S+Qud1R35IWff6wWLUTK+XiSuiWhuh2TZ23GmKPdfT5vNHftBZVZ3fcvXcfq2aFIeWDvbp//3MFFet2115ae9oe12gxrfbhO+jdof4jnxKIY8Su3biFqu//74nn8D68Ert6w3aI/bDixAmxH1lc9+5HaCzO/Pm3YcK7/qddaN8nHPVrlEfXVp/G9BXBrs/wGdofBdNGdNFOLBHX9Zu3Y17+i75Z3CPEOXqvs6f99EnCG189YqvR+591RdtG1dCs7tNPzZD2rxwfTAIkQAIkYHoCPie8IiNiH2DL7qO1Y7BKvlFIO9ZJHPF08sx5bPp5L5InC3rqN63F99F99IreC7my4aP338bV6zex5Nsfkf2ZjDh84kyiC6/Ysyr2XIq4K5Z9E6/kfx4RkZE4deYvrPtxp3YuqxB68VF07ZaDcOTkH/jsozLaKm3UVyr/69GxZOIYtyoNeyFLpnQxK2nfbtihfVwtBFWP8Io8bNy6B216jdXE9OMKb+PmrbvaecWZ0if8WLJoSRTPFbJfrlZnjb+4Yn+1cPSxZDmzP6PVKU4EEEJ/9fotTXafdhavEP3QoVO1Y77EaRnv/a8IMmVIo33T2vbdh7UzcT35prWHhVfsUS1Xq1PUEXLVy8FmDdDqCA5ODvHNgEZtaRDbBpp1HamdeVuscD68Xig/XE4Xtu8+pI0bsX9c7COPvsS+dbFtRpwDLFa+xRF6c79Zp0nwyplh2kuSnvbTJwmv+IRh/+FTeKf4q8iWJYP2zMWrf9SOGBT7rp/PmdX0/9gSAAmQAAmQQNIR8EnhFTjE/tUZC7/HT9v3a5O0G0DObJm1r4oVH9lGvzCWkBVe8Vzxpr/YMnHxnyt47tks2hca7N5/7LFfPOHNCq+oT0z8YkVTfIHDhYv/IkWKZMiRNZP2Qk+damUREpxcy74QsiHh8zShF5d4qUic4uDpF09s/fU3bdX09B9/aSuj5Uu9rq1iiiPE9AqviGPt5l8RPn0ZxGpdtiwZdX3xROxV0eiuPn3Bd9qxbQ8Lr/jvqC+eWI7Dx//Q3vZ/tcALaNeoGsR5uZ5eYm/t4tWb8NvR37WX+ITgvfrSC6hRqRRKvvmq9piEbGkQ9wuxFV9uIv6ISJc2FT6t+h7EH09iS4xRwiviEKdIzFi4Bt/+sEPLi7hyPfuMtgVIjI3YX/Igtrus2fQLTv9xAbdu30GG9Gm0I9vECRTiD4Hoy9N++rg9yELAv172g8b06rWbSJ0qRDuXunn9yo98SuNpDnkfCZAACZAACSQWAZ8V3sRqIJ9DAiRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1+xSzgSRAAiRAAiRAAiRgbgIUXnPnn60nARIgARIgARIgAb8nQOH1MsV/Xb7r5RNYnARIgARIgARIwGgCWdMnN7pK1peEBCi8XsKn8HoJkMVJgARIgARIIAkIUHiTAHoSVknh9RI+hddLgCxOAiRAAiRAAklAgMKbBNCTsEoKr5fwKbxeAmRxEiABEiABEkgCAhTeJICehFVSeL2ET+H1EiCLkwAJkAAJkEASEKDwJgH0JKySwuslfAqvlwBZnARIgARIgASSgACFNwmgJ2GVFF4v4VN4vQTI4iRAAiRAAiSQBAQovEkAPQmrpPB6CZ/C6yVAFicBEiABEiCBJCBA4U0C6ElYJYXXS/gUXi8BsjgJkAAJkAAJJAEBmcIbee8ebh49Cosz0rOW2QKRquArsAZYPLufdyWYAIU3wcjiFqDwegmQxUmABEiABEggCQjIFN6712/gzsD2sJ497lHLnMXeQ8r2fRFoC/Do/oTe1Kn/BBQpmBe1Py6T0KJ+cz+F18tUUni9BMjiJEACJEACJJAEBPxNeNf9uAvTF3yH46f+RPLkQSiYLzea16uMQgVeAIUXMIXwzlmyDsvXbMWJ38+hWoV30LdTgzhD69Qff6HXF1/hyIk/kDN7ZvTt2ABFCuaJuWf8jGWYt2wDHA4nKpYtgdC2tWGzWrXfU3iT4F8pVkkCJEACJEACXhLwJ+FdtGozhk9YgC4ta6HkG69qwrt91yHs2H1Ic57EFF6H0xnjQF6mwNDiphBe8VeP3W7Fmo2/IkXyoDjC63K5Ual+D5R+qwia1a2EFWu3YvyM5Vi3YARCgpNj9frtGD5xAaaN7IKQ4BRo1nUkKpQurv3VROE1tK+yMhIgARIgARJINAL+Irz37kegVLX26NisJmpWKhWHj9vthsVi0YQ3R7bMOHD4FPYdOomX8j6HEX1aIHPGtNr9BUs3xKYlY5AhXWrtv4eMm4cUyZOhXeNqWLhiIzZt24vUqUJw8OjvqFu9HHbuO4r0aVPj1Jnz+OfyNe13sZ+XaElKxAeZQnijeQ0aMwdOpzOO8O49eAKNOw3HzyvDkSwoULv1/c+6olWDqqhUrgQadx6u7XtpWb+K9rtV67Zh/MzlWDN/GIU3ETsiH0UCJEACJEACRhLwF+Hd89tx1G0Thl++nagt1MV3CeEV94UPbo88ubIhdOg0BKdIhv6dG3okvAPHzMGM0d3weqF8EBLdecBEHDp2BvPG90L6tKkwNHw+7t67H/M8I/PoaV2mF97FqzdjwfKN+GbagBhm7fuEa1sbOjStof3V1KdjfZR+q7D2e7EtomrDXtizbiqCAu3c0uBpT+N9JEACJEACJOBDBPxFeDdu3YOugyZh15opj6UrhPfZrJnQvkl17Z6tv/6GL6d9g8VT+nkkvCvW/oz5E3rHPF887/mcWdGyQVXtZ9t2HcToKUtinudDaY4JxfTCO2vxWojOMuvLHjFQxH5esdrbq31dFKvQXPuLqFjhfNrvL1y6gjI1O2LrinFImzolbt51+GJeGRMJkAAJkAAJkMATCKRMbpPGx8hTGjxd4Y19SoMo03vYdHw7Z6hHwrtt1yF8ObBNHOF90vOkgfXiwaYXXm9XeG/e8fCMPZ1Juh/phHv5LJ2lWYwE/JeApWp9BNmjXh5V9eL4VjVzjFs2ASPGd8oUdmnNMFJ4o/fwdmpeEzUqPn4P75MEVSzuLZ8+CFmfyaAx6TZ4MrJmzhCzh3f77sMYM6A1hVdaj0nkBz9uD2+TzsOxbeV4BAZGdf4PanfT9uxG7+Et+sqLMS+piZfYwmcsM24Pr9uNFC3LJTIJPo4E1CdwZ8I6wKL4Ie0c3+p3RLZACgEjxre/bGkQCVi0chNGTFqIri0/Rck3X0VQUCB27D6M7eKUho71Hzml4eEV3nptw7RTqMRLb2fPX0KNpn3x2UdlKLxSerfEh4ojNJxOl7apWry01rNdXVitAdqxGuLn4pSG8qWKoWmdSli17meMmboEa78ejpQhKbSX1EZNWYTpo7ppm8Gbdhmh3WvYKQ2cECX2DD5aZQJGTIjS+XB8S0fMCtQkYMT49ifhFVleu3knZohzeE+f044leyX/89rpU/Gdw/uw8IpjWcV2TuFFWTKnR6DdhmxZMlJ4VRs+YmP2lLmr4oTd6NMK2hEe4hLHavT84iscPXlWO7ajX6f62skM0Vf49GWYvzyJzuHlhKhad2O8BhEwYkKU3hSOb+mIWYGaBIwY3/4mvGpm2rioTbWHVwZW6V88wQlRRtr4TD8gYMSEKB0Tx7d0xKxATQJGjG+Zwht57x5uHD2CAKeHL7bbApGq4CuwBii+TcuHuxuF18vkUHi9BCip+LTbNuyOtOK624K0AW68H+RApWTOmNom3LbjcGQALroD0C7FffwvyPXYSO64gGl37NgbGQCXxYKXbU40SRGJNAHAXTcw/FYgzjgsuA8LsgW48FkKBwrZo573p9MCUVek24IyQQ68/yAGpxvodTMQ7YMjkdnqlkTBvx9rxIQonSCF12vEYizVuvbo2aMVgiLRMMWTZWPqbTvWRdgwOOV95LVFjVkx3iffsWv/fgRb3Pg4mQPlH4xbMd7H3ArENTfwrNWNVikitEP9xTX1jh35rE68/YR/S7xurIkeYMT4lim8JkqVMk2l8HqZKgqvlwAlFT8SaUH6ADdSWIC/XAEYdtOO1sERKBQYJZff37Mih9WNybdtqJnc8UThnXnbhiPOAHQLiUQg3Bh3JxApLG60C45EpBs46hCi64bdAuxzWDHpth1TUt9DcICQYTtKBzrwst2F9jeSY0TKqJ+vumfFPTdQI/l/Ei4Jhd8+1ogJUTo8Cm+iII6I9TdjBIAW14IQGhKB/PbH/zF50mHBjDuBOO20oH/KiBjhFeP3b6cFHUIi8JfTgrBbgTHP+u6eFZddFtRN4cAXtwJRNtCBIoEunHIEYN4dK/qkkntqT6LAUuQhRoxvCq8inSGRwqTwegmSwuslQAOKX3eJ1dQgVAz6b6UmutqO14PwcbLIJwqvkOVcNleMnG65b8WKezaMSH3/kehPOSzofiMIo1Lf11aAutwIQteQCGQMcKP3zSA0TRGBYAsw5KYdYakiNEnmpY+AEROivsgSUIrCmwBYnt364/0ALLprx/g0j47P6Ce43G6E3ghCk2AHet8MRL8HwrOJcc0AACAASURBVOtwu9HwWnL0CLmPlx7I8sTbUaf3tAiOxMw7duSyulAyyIkFd21Ia3GjbJADfW8GoVmKCGSXd6yrZ433o7uMGN8UXj/qMB40hcLrAaQn3ULh9RKgxOLz7tiwMcKGmy7gmQAXBqaKQOqAuBV6Irz7Iiz45p4dHYIjEGiBtsKb88HWhein9b0ZiD8cAbgNC4rZHegSErXSM/aWHUXsTm2Lg5BfIcJiBendoKif8dJPwIgJUX90Hpak8HoIyvPb+t8MxEs25xM/PRGf8Jx1WtAs2IHPriaLEd4LTgva3kiGmanvIPjBXkpx71ax7SHVffxw3wrxR63Y0jTgVhCqJ3PgnMuCf10W1E7u4V5Nz5ti6juNGN8UXnN1MQqvl/mm8HoJUGJxsRfvths45gjAKWcAPk3u0IQ19uWJ8IoV4vDbduxzRC3f5LU60StlBJLHepaQalHXjggrgizABw/2/P3rjNrbd8dtQYVkDm11d/19KxqliMS0O4G44YK2r7dEILc2JLQrGDEhJjSmBN9P4U0wsicV+MdlQevrQRiX6h4yPeY7Sa6KT3xuBGFoqvtIGYA4wvu7w4KuN5NhUZo7MXtzxYrxint27Y/VSLcbM+8E4ozTgoJ2Fz4IcmDQrSD0D7mPhfdsOO20Ir/Vqe3j5+UdASPGN4XXuxypVprC62XGKLxeAjSouHg5JV2AC9Ue2jPrifAOvmmH+FCzeXAkhPLOu2vDBVcA+qQUuwUfvdpfj/p48+H9g2KyFFsrugRHYNk9O3LbXHjT7kSXm0EYlvK+treXl+cEjJgQPY9G550UXp3g4i+25K4NByMD0C9V/GNTlPryth0v2VwoGxT1R2ZCVngfrjX8lh3FAp0Qn+fsjrCibUgkhtwMxAdBkTHvCyRqA030MCPGN4XXRB0KAIXXy3xTeL0EaFDxKbdtcLiBliFxV148Ed5m18Te20i8Fhi1BeEPB9D5ZnJ8neYObPF801e7B/uCSz70tvY3d62wWyyonEzsG4zazyv2+Q64YUedFA7ktvG0hoR0ByMmxITEo+teCq8ubI8r1OZ6EKolc6DUA5mN777GV4OivqHPHTXeriMAIRY3aiaL1PbjNriWHD1TRiD/g1MbxBYkcafYwxv7OuIIwPK7VvRIGRmzn1ec5iDGufgkKfapMInaSJM8zIjxLVN479x349gpB5wefnhns7lR8EU7jyWT2L8pvF7CpfB6CVBCcbGVYXOEFUUDXdppCmLFJ/x2IJoFR+LtB1sHxGqrGxZ0uxGIqskceDPQBRvcCLBYID4WFfv26iSP1P57xK1AbXIUE54Vbsy7F4iDkRaMTh2hvZ0t9u/ltTm1+XNDhA3L79owKvU9PBPrI9VLTmDUrUAMThUBqyVqb29RuxOvBzrR/noyhKW6/8j+Yglo/OqRRkyI0oFReBMNsTiZRZyoMDXNfSSLtd3o4fEstijF3j3f6noydAq+jwJ2t1ZOvKQmxrTYsy9OeBl8MxDdQ+7H+cTm4WMFxd7e02Jvb7ADY27Z8WagE8Uf/IGcaA002YOMGN8yhffqTRdGjXfgwgXP3kx+paAbzRvYEGhT46O+hSs2YvvuwxgzoLUyPZPC62WqKLxeApRQXBz3NfKWHSedVtx3QTvntlyQI2Zfraiy941AHHXG3eQXGnIfhe0uHHcEoOfNICxIc1eTU7Hnb/oduybO4hzeXAEuNAyORE6rW5vkxB7dc84AiH+mnrWK0xwcePWhF9LEEUaVgiJj3vwWxx2Nvx2ICLcb7wQ5uRqkox8YMSHqCCthRSi8CeP1hLuFqAqRbfXQSuzD4/nhR8Te0iB+F3UObyB2RwZofzCLFePoc3ijy4pjBe+7Laj+4EW1+243xtwOgpDpTAFubWuDGtqSaPgT/UFGjG9/Et7KDXriwsXLWL9gBNKkDtHy8d0Pv2DGwu+xeEo/XflZ9+MuTBdfVXzqT+2rigvmy43m9SprX1VM4dWFVO1CFF6188fo1SVgxIQonQ6FVzpiVqAmASPGt78J77+Xr+HjD99B5+afeC28i1ZtxvAJC9ClZS2UfONVTXi37zqEHbsPoW+nBokqvA6nEzbrY94yTcTuyxVeL2FSeL0EyOIkoJOAEROiztA8L0bh9ZwV7zQVASPGt78Jb4XSxfHV19/h+3lfIEO61I+s8J49fxH9R83CoWNntN+3bvgR3n+32CP96t79CJSq1h4dm9VEzUql4vze7XZrJ5iIFd6tOw9qz1m9fhsypEuDgV0/R9FXX9TuL1i6ITYtGaP9XlxDxs1DiuTJ0K5xNZw+ewF1Wg9Cg5rv49sfdiB/npyIjHQgfdrUOHXmPP65fA2pU4VgRJ8WyJwxbaL1ewqvlygpvF4CZHES0EnAiAlRZ2ieF6Pwes6Kd5qKgBHj29+Et1WDqti8bR9ShiRHaNs6cYTX6XShasOeKFfqdTSvWxkHjpxG824jMXtsqCacsa89vx1H3TZh+OXbiQgJfvRru8W9QnjDxs5DWGgTlCv5Ohat3IS536zXZNsT4a1Urwdaf/4RWtSrAiHRnQdM1ER83vheSJ82FYaGz8fde/fRv3PDROv3FF4vUVJ4vQTI4iSgk4ARE6LO0DwvRuH1nBXvNBUBI8a3PwrvS3lz4uNGvbFy1hDs/e1EzB7e347+jqadh2PLinEx2wd6D5uOVCEptG0Lsa+NW/eg66BJ2LVmymP7nBDeFWt/xvwJvbV77kdEoki5Jtj5/SRtJfdpK7yV64di99opCAqM+ibDTv0n4PmcWdGyQVXtv7ftOojRU5bo3n8cX+AUXi//CaHwegmQxUlAJwEjJkSdoXlejMLrOSveaSoCRoxvfxTe8qVeR78RM+Fyu/BGkQIxwisk9suvvsGKGYNj+tGk2Stx8sx5betA7MvTFd6HT2mILblPE946rQZh26rxMdUK4S1SMC9qf1xG+5mIQQj5t3OGJlq/p/B6iZLC6yVAFicBnQSMmBB1huZ5MQqv56x4p6kIGDG+/VV4L1y6gkr1uqNJ7UrYsGW3tkqakBXe6D28nZrXRI2Kj9/D+yThLVahOZZPH4Ssz2TQ+m23wZORNXOGOHt4t62k8Co1qCm8SqWLwfoRASMmROm4KLzSEbMCNQkYMb79VXhFxsPGzsXq9duRLUtGTXjFHt4qDXtCvNjWpE4l/HbkNJp1HYlZX3bHS3mfe6STiD25IyYtRNeWn6Lkm68iKCgQO3YfxnZxSkPH+vGe0hB7Vbde2zBULFtCe+nt7PlLqNG0Lz77qAyFV83hGBU1hVfl7DF2lQkYMSFK50PhlY6YFahJwIjx7c/C+++V6yj/aRfkzpk1Zh/smT//xgBxSsPxqFMaxH7ZD99747EdZO3mnZghzuE9fU47luyV/M+jWd1Kjz2HN7bwHjnxB3p98ZW2XzhL5vQItNs0+Y59SgNXeBUbmxRexRLGcP2GgBETonRYbjfs386RXg0rIAHVCER+WDfqK6AlXv4kvBIx+c2juYfXy1RSeL0EyOIkoJOAvwhvn4FRbynzIgES+I/AgN6RSgvvnftuHD0ZCZfLM2m32dwo+KId1gDP7mdfSTgBCm/CmcUpQeH1EiCLk4BOAhReneBYjAQUIKC68CqA2HQhUni9TDmF10uALE4COglQeHWCYzESUIAAhVeBJCkWIoXXy4RReL0EyOIkoJMAhVcnOBYjAQUIUHgVSJJiIVJ4vUwYhddLgCxOAjoJUHh1gmMxElCAAIVXgSQpFiKF18uEUXi9BMjiJKCTAIVXJzg/KJY5E1Cnhg25n7Pgxk3gm1VO7Nrr0lqWMT1QrZIVeV8IQGAgcPqMGwuWOvHX3+7HtjxXDgs++diK55614PYdYPl3TmzZHvW8LJmBhp/ZkCO7BRf/cWPOQidO/h71LPG7z2vbYLMBP213YdOWqDIBAUCP9jZMnuXAv5f9AHgSNIHCmwTQ/bxKCq+XCabwegmQxUlAJwEKr05wihcTMjmghx17D7iwao0Tz+WwoF0zG8JGO3D+ghsv5LbghVwW7PvNhbv3gKoVrMifNwDdB0TG2/LUqaKet/J7J3bvdyEoEEiWzII//nRrp2INDLVrz1q91okSxQNQ5QMruvWLxL37QMtGNmzZ7sTRE24M6mlHvy8icfcuUPbdACQLBFatjRJgXgknQOFNODOWeDIBCq+XPYTC6yVAFicBnQQovDrBKV4s6zMW9O9uQ8sukYh84LDNG9pw5aobi5Y7H2mdENqRA+3o0DMSN2892vhPqloRHAxMn/do2edzWdCppQ3tQv+rK6x3lBzv2OVCn642hE914MpVoFs7G2YvcODOXUQJ+CgHHI8+UnH6xoVP4TWOtVlqovB6mWkKr5cAWZwEdBKg8OoEp3ixbFks6NfNhhadI+FwRDVGCG+K5MCoCQ9+EKuNRV61oHZ1GzqJc13jucTWA7FF4eX8FqRJbdH+/9xFDly9Brz9ZgDe/V8ABgz/77ktPrfh4iU3lq52olEdKw4cduPQERf6dbOjd1gkGnxqxdZfXDh09PFbKBRPgSHhU3gNwWyqSii8XqabwuslQBYnAZ0EKLw6wSlezBoADOxpx697orY0iP23HVvacPa8G0PHxBXe9GmB0I52fP2NA7v2xS+gw/rZtT24YyY6tD26dWpakT6dBcPGOlC2VAAKFQzA8HH/PVcIbUQkMH+JE2lTA3U+sSE4ObB+s1Nb3S35lhXzlzi0PcYhIcDGLa6Y/cWKozc0fAqvobhNURmF18s0U3i9BMjiJKCTAIVXJzg/KCa2NXxazaq9SHbhohsX/nYjWTJg8sz/9hCIrQzd2trxw09O/PDT4/fSDu5px4HDLixcFlVWvPQ2pI8drbpEothrT17hjY3SagVCO0RtcfiwvBVnzrqxc68L/bvZ0X941N5eXp4ToPB6zop3ekaAwusZp8feReH1EiCLk4BOAhReneD8sFinVjb8dtiFdZuixDZVyijZ3bLDiTU/PPnFMbEd4upVNxY+2P8rhFfs023dNRLZs0WtHrfrHhmzH3dwL7u2siz28Ma+PiwXoG2xWLvRFbOf98JFaOWXrHTi7DlucUhI16PwJoQW7/WEAIXXE0pPuIfC6yVAFicBnQQovDrB+UGx3DktuHw1SiCj9tla0WNgJCIigJBg8QJZ1CkOK9f8t+Ibvd83XVrgvXesmoS63UDBlyzasWMjxjvwz79u1BVbGtJaMDzcoZ3SMCjUjp37XPhunRNvvh6AjytZ0b1/pHYCRPSVPl3UPuIhox1wuaDt7d1/0IW9v0Wd3hA2Kv4X5vwgFdKaQOGVhta0D6bwepl6Cq+XAFmcBHQSoPDqBOcHxapUsOK9dwJgtwEnTru1PbpiNVVcJYoF4PPa1kda2X+YA3+ed0PIcmhHG5p2iNTkVFxlSgbggzJWBNqBYyfdmLvYgWvXo36nncNb24Yc2Sy49I8bsxc5cfJ03NXa1o1tWLfJieOnon6eOaOQ3qjzebfvcmH9g5VnP0BvWBMovIahNk1FFF4vU03h9RIgi5OATgIUXp3gWIwEFCBA4VUgSYqFSOH1MmEUXi8BsjgJ6CRA4dUJjsVIQAECFF4FkqRYiBReLxNG4fUSIIuTgE4CFF6d4FiMBBQgQOFVIEmKhUjh9TJhFF4vAbI4CegkQOHVCY7FSEABAhReBZKkWIgUXi8TRuH1EiCLk4BOAhReneBYjAQUIEDhVSBJioVI4fUyYRReLwGyOAnoJEDh1QmOxUhAAQIUXgWSpFiIFF4vE0bh9RIgi5OATgIUXp3gWIwEFCBA4VUgSYqFSOH1MmEUXi8BsjgJ6CRA4dUJjsVIQAECFF4FkqRYiBReLxNG4fUSIIuTgE4CFF6d4FiMBBQgQOFVIEmKhUjh9TJhFF4vAbI4CegkQOHVCY7FSEABAhReBZKkWIgUXi8TRuH1EiCLk4BOAhReneBYjAQUIEDhVSBJioVI4fUyYRReLwGyOAnoJEDh1QmOxUhAAQIUXgWSpFiIFF4vE0bh9RIgi5OATgIUXp3gWIwEFCBA4VUgSYqFSOH1MmEUXi8BsjgJ6CRA4dUJjsVIQAECFF4FkqRYiBReLxNG4fUSIIuTgE4CFF6d4FiMBBQgQOFVIEmKhUjh9TJhFF4vAbI4CegkQOHVCY7FSEABAhReBZKkWIgUXi8TRuH1EiCLk4BOAhReneBYjAQUIEDhVSBJioVI4fUyYRReLwGyOAnoJEDh1QmOxUhAAQIUXgWSpFiIFF4vE0bh9RIgi5OATgIUXp3gWIwEFCBA4VUgSYqFSOEFsHHrHoyZ9g3O/XUJmTOmRfN6VVCl/FsxqRw/YxnmLdsAh8OJimVLILRtbdisVu33FF7FejzD9RsCFF6/SSUbQgKPEKDwslMkNgHTC+/V6zfxbrX26NOxPiqVLYFf9h5B69AxWDp9EHLnyILV67dj+MQFmDayC0KCU6BZ15GoULo4mterTOFN7N7I55FAAghQeBMAi7eSgGIEKLyKJUyBcE0vvEdPnkWNpn1x4IfpsFgsWso+qN0VnZvXwntvF0HjzsNRpGBetKxfRfvdqnXbMH7mcqyZP4zCq0AHZ4j+S4DC67+5ZctIgMLLPpDYBEwvvC6XG026DMeH772BSuXewi97DqPb4MlYOTMM6dOmQqkHq7+l3yqssT/x+zlUbdgLe9ZNRVCgnVsaErtH8nkk4CEBCq+HoHgbCShIgMKrYNJ8PGTTC6/Ij9i2MGD0LNy+cw92mxWDujdGxTJvaqkrVqE5wge3R7HC+bT/vnDpCsrU7IitK8YhbeqUuBfhlJriu/cdsDR6T2odfDgJqEjA/dUPSB5kUzH0mJjF+O7SK0DpNjB4EpBBYPggl/TxnSww6l0cXuYgYHrhPXD4FOq1G4Lwwe1QvMhLOHbqLFp0G4VR/Vrh9UL5nrrCe+VmhNSe4nC4ENisjNQ6+HASUJFAxOQNsNnUlkUxvkP7cdJVsf8xZrkEwvo5pY/vdCkD5TaCT/cpAqYX3iWrf8TClZuweEq/mMS07xOOXDmyoF3jatoe3qKvvBjzkppYDQ6fsYx7eH2qGzMYMxLglgYzZp1tNgsBbmkwS6aNa6fphVe8tFa71SCMDxPbFvJrK7xCcvt0qIfypYppL6mNmrII00d1Q0hwcjTtMkL7OU9pMK6TsiYSiI8AhZf9ggT8lwCF139zm1QtM73wCvAr1v6MKXNX4cLFy0iXJiU+rvAOWjaoGpOT8OnLMH85z+FNqk7KekmAwss+QALmIkDhNVe+jWgthddLyvziCS8BsjgJ6CTAFV6d4FiMBBQgQOFVIEmKhUjh9TJhFF4vAbI4CegkQOHVCY7FSEABAhReBZKkWIgUXi8TRuH1EiCLk4BOAhReneBYjAQUIEDhVSBJioVI4fUyYRReLwGyOAnoJEDh1QmOxUhAAQIUXgWSpFiIFF4vE0bh9RIgi5OATgIUXp3gWIwEFCBA4VUgSYqFSOH1MmEUXi8BsjgJ6CRA4dUJjsVIQAECFF4FkqRYiBReLxNG4fUSIIuTgE4CFF6d4FiMBBQgQOFVIEmKhUjh9TJhFF4vAbI4CegkQOHVCY7FSEABAhReBZKkWIgUXi8TRuH1EiCLk4BOAhReneBYjAQUIEDhVSBJioUoXXj/+vtfWAICkCVTOg3NgcOn8P2mX/F8zqyo9uE7sFgsiiGLGy6FV+n0MXiFCVB4FU4eQyeBpxCg8LKLJDYB6cJbu9UgfPZxGXz43hv45/I1fFC7K/LkfhZ/nPsbDWq+j6Z1KiV2mwx9HoXXUNysjARiCFB42RlIwH8JUHj9N7dJ1TLpwlv8wxZYPKU/cmTLhHlLN2DV+m1YMLEPtu86hH4jZ2Lt18OTqu2JUi+FN1Ew8iEkkGACFN4EI2MBElCGAIVXmVQpE6h04S1crgm+m/uFtqWhTc8vkT/vc2hZvwou/nMV5T/rgn3rpykDK75AKbxKp4/BK0yAwqtw8hg6CTyFAIWXXSSxCUgX3mqN+6DCe2+gVIlCqNm0H2Z+2QMF8+XS9vK26TUWPy79MrHbZOjzKLyG4mZlJBBDgMLLzkAC/kuAwuu/uU2qlkkX3p927Ee7PuGIiIhE2XeKYsyA1lpbx371DY6cOIuJQzskVdsTpV4Kb6Jg5ENIIMEEKLwJRsYCJKAMAQqvMqlSJlDpwitI3Ll7D5ev3sCzWTPFgDl++hyCUyRDtmcyKAMrvkApvEqnj8ErTIDCq3DyGDoJPIUAhZddJLEJSBVesar72vtN8cu3E5EiebLEjt0nnkfh9Yk0MAgTEqDwmjDpbLJpCFB4TZNqwxoqVXhFK0rX6IBVs4Zoq7n+eFF4/TGrbJMKBCi8KmSJMZKAPgIUXn3cWOrxBKQL79R5q/HXxcvo1upTJAsK9LtcUHj9LqVskCIEKLyKJIphkoAOAhReHdBY5IkEpAtvrRYDcOT4HwgMtOPZrBm1/419iTN5Vb4ovCpnj7GrTIDCq3L2GDsJPJkAhZc9JLEJSBfeSbNXPjHm5vUqJ3abDH0ehddQ3KyMBGIIUHjZGUjAfwlQeP03t0nVMunCm1QNM6peCq9RpFkPCcQlQOFljyAB/yVA4fXf3CZVywwRXofTiYNHf8ef5y+hUrkSWluv37yt7ekNemiLQ1KB0FsvhVcvOZYjAe8IUHi948fSJODLBCi8vpwdNWOTLrx//3MFLbuPxumzFxAZ6cChzTM1Uj3CpiJlSAqEtq2tJrkHUVN4lU4fg1eYAIVX4eQxdBJ4CgEKL7tIYhOQLrzt+4TDZrMirHtjFC7XJEZ4t/76G74In49Vs4ckdpsMfR6F11DcrIwEYghQeNkZSMB/CVB4/Te3SdUy6cJbonIrzBkbiuefy4YCpRrECO/Z85dQtWFP7Fk3Nananij1UngTBSMfQgIJJkDhTTAyFiABZQhQeJVJlTKBShfeou83xcLJ/fB8zqxxhHf3geNoHToG21dPUAZWfIFSeJVOH4NXmACFV+HkMXQSeAoBCi+7SGITkC68LbqPRu6cWdClRa0Y4b156w5ahY5BhnSpMapfq8Ruk6HPo/AaipuVkUAMAQovOwMJ+C8BCq//5japWiZdeMXLavXahCFn9szYd+gkyr5TFDv3H4U1IABzw3shR7ZMSdX2RKmXwpsoGPkQEkgwAQpvgpGxAAkoQ4DCq0yqlAlUuvAKEv9euY5Fqzbj8LEzcLldeCnPc6hVtbS2wqv6ReFVPYOMX1UCFF5VM8e4SeDpBCi8T2fEOxJGwBDhTVhIat1N4VUrX4zWfwhQeP0nl2wJCTxMgMLLPpHYBKQL70879iMkODmKFMyrxT5v6QYs/e4nvPBcNoS2q4PUKYMTu02GPs8I4bV/O8fQNrEyElCBQOSHdQGLRYVQHx+j240+A+1qt4HRk4AEAhReCVBN/kjpwlu5QU90a/Up3nr9ZRw/fQ41mvRFg0/ex6/7jmonNwzq1kjpFBghvJwQle4iDF4SASMmREmh//dYCq90xKxATQJGjO+s6ZOrCYdR6yIgXXhfK98Uq+cMRZZM6TBh1gocOvY7xoe1x9GTZ9Gs60j8uPRLXYH7SiEKr69kgnGYjYARE6J0phRe6YhZgZoEjBjfFF41+4beqKULb7EKzbFocj889+wzqNsmDOVLvY461criwsXL+KBON+xbP01v7D5RjsLrE2lgECYkYMSEKB0rhVc6YlagJgEjxjeFV82+oTdq6cLbuPNwpEkVgqKvvoiwsXPx3dwvkD1LRmzfdQh9R8zAugUj9MbuE+UovD6RBgZhQgJGTIjSsVJ4pSNmBWoSMGJ8U3jV7Bt6o5YuvGf+/Bu9h32Fv/6+rO3drVu9nBZr/5Ezce9+JIaENtEbu0+Uo/D6RBoYhAkJGDEhSsdK4ZWOmBWoScCI8U3hVbNv6I1auvDqDUyVchRe383Um68HoGI5K9KnBy5fBqbOceDMWbcWcKGCFnz8oRUZMlhw7Rqwaq0T23e64m1M/rwWVHrfipzPWnD1GtBrcGTMfeJ3nVrZHik3fpoDe39zI0tm4PPaNthswE/bXdi0JaqOgACgR3sbJs9y4N/LvsvQlyMzYkKU3n4Kr3TErEBNAkaMbwqvmn1Db9TShPd+xH9SEDu4QLsNFtWPEorVIAqv3q4nt9wrBSxo8KkNs7524PQfbqRLa8Gt225cvgKEBAMjBtoxd6ET23e5kC+PBW2a2tBvaCT+vvRoXLlzWpAxgwWpUgElS1jjCK/oylbrf2Xy5LagVWMbOvaMhBgCLRvZsGW7E0dPuDGopx39vojE3btA2XcDkCxQiHb8ki2Xjn883YgJUTopCq90xKxATQJGjG8Kr5p9Q2/U0oS3QKkG8cYUGGhHzmyZ0ejTCqhUroTeuH2mHIXXZ1IRJ5A+XWzY8KML2359VCizZ7VA/L5ph//+KAvrZcfiFVGrso+7XnvVgo8q2uII78P3Nvg0yn5nfu3U/rdPVxvCpzpw5SrQrZ0Nsxc4cOcu0K6ZDWGjHHBE3cZLBwEjJkQdYSWsCIU3Ybx4t2kIGDG+Kbym6U5aQ6UJ76p12+IleePWbRw4chrfb/wFQ0ObocJ7xZUmTuH1vfTZrMDEkXYsXe3Ee+9Yte8m2LXPhcUrnHA4or6roEMLG37d7dK2MeTLa0GTejb0DovEzVuPb8/ThDfQDowabMfYyQ4cPxUlzo3qWHHgsBuHjrjQr5tdq0NI8dZfXDh09PFy7XtUfS8iIyZE6a2m8EpHzArUJGDE+Kbwqtk39EYtTXifFtCk2Sux6ee9WDi579Nu9enfU3h9Lz0Z0gND+9hx4rQbE6c7tC0HYkV17wE3VnwftaRa/LUA1KlpRfJk0FZZZ8xz4pfdT95e8DThFXuGK39gRY8B/60cp00N1PnEhuDkwPrNTm11t+RbVsxf4kCdGjaEhAAbt7iway+3NiS0JxkxISY0Zu+wywAAIABJREFUpgTfT+FNMDIWMAcBI8Y3hdccfSm6lUkmvIeOnUHDDkPx63eTlCZO4fW99KVOBYwcaEf4NAf2Pdii8L83AlDqrQAMGulArpwWdGtrw7ipDhw97kb2bBZNiCfN+G9lNr5WPU14xctrx0+6HrsvV4h3aIeoLQ4flrdqL9Dt3OtC/2529B8etbeXl+cEjJgQPY9G550UXp3gWMzfCRgxvim8/t6L4rYvyYR3z2/H0b5POH5aNlZp4hRe30zfmDA7Zsx3YP/BqG0DsYX37Tej5HfgCEdM8C0+t+HCRTeWf/v4TbVPEt50aaNWlXsMjNRejIvv+rBcgLalYu1GV8x+3gsXgY4tbViy0omz57jFISG9yYgJMSHx6LqXwqsLGwv5PwEjxjeF1//7UewWJonwOp0u9Aibgms3bmHK8M5KE6fw+mb6qle2IvdzFkz46sGWhuZiS4MLq9a4IF5aEyut2grvCTeezWpBx1Y2zF3kwK594kQHaHt/hYS63VF7fsXqbJFXAlDlAyv6fhGp/dwZy40rlg9A/jwBGB7+n0THJpM+HdC8oQ1DRjvgckXt7d1/0KW9JCdObwgb9eT9w75JOWmjMmJClN5CCq90xKxATQJGjG8Kr5p9Q2/U0oS397Dp8cZ089YdHDp+Bv9cvoa54T3x8ou59MbuE+UovD6RhkeCEC+u1a5hRdHCAYiMBH7d48IS8dLaA0kV+20/LGfV5Fa8qLZ1h1OTYXGJY8hCO0ad4iDkNL6zdsVRZ+KUhehLnPKwep0z3lMhxD2tG9uwbpMz5mW2zBmF9EadzyuORlu/iXt4E9qTjJgQExpTgu+n8CYYGQuYg4AR45vCa46+FN1KacJbq8WAeEmGBCdH7hxZUKdaWeTIlll52hRe5VPIBihKwIgJUToaCq90xKxATQJGjG8Kr5p9Q2/U0oRXb0CqlaPwqpYxxusvBIyYEKWzovBKR8wK1CRgxPim8KrZN/RGTeHVS+5BOQqvlwBZnAR0EjBiQtQZmufFKLyes+KdpiJgxPim8JqqS8n74gmzYKTwmiXTbKevETBiQpTeZgqvdMSsQE0CRoxvCq+afUNv1Fzh1UuOK7xekmNxEvCOgBEToncRelCawusBJN5iRgJGjG8Kr7l6FoXXy3xzhddLgCxOAjoJGDEh6gzN82IUXs9Z8U5TETBifFN4TdWl5GxpaNF9NEb2bYkUyYOwat02VCpXwqepOpxOjJ32DZav2Ypbt+8ib+7smDGmB5InC9TiHj9jGeYt2wCHw4mKZUsgtG1t2MTBrAAovD6dWgbnxwSMmBCl46PwSkfMCtQkYMT4pvCq2Tf0Ri1lhbdg6YbYsmwc0qQOQYFSDXBo80y98RlSbviEBdh94Bh6daiHLJnS49ipsyj6yosIDLRj9frtGD5xAaaN7IKQ4BRo1nUkKpQujub1KlN4DckOKyGB+AkYMSFKZ0/hlY6YFahJwIjxTeFVs2/ojVqK8Faq1wPvvPEqihZ6Ea1Dv8T4sPaPja9UiUJ6Y0+Ucpev3kC5Wp2xbPog5MiW6ZFnNu48HEUK5kXL+lW034kV6/Ezl2PN/GEU3kTJAB9CAvoIGDEh6ossAaUovAmAxVvNRMCI8U3hNVOPgpwtDb/uPYqh4fNw9vxF3L0XAbvd9liq+9ZPS1LiP+88iP4jZ6LsO0Wx5NsfkS5NSjT85APUrPyuFlepau3Rp2N9lH6rsPbfJ34/h6oNe2HPuqkICrRzS0OSZo+Vm5mAEROidL4UXumIWYGaBIwY3xReNfuG3qilrPDGDsbXtzQs/e4niK9Brv1xGXRoWhNHT/6Bpl1GIDysPYoXzo9iFZojfHB7FCucT2vWhUtXUKZmR2xdMQ5pU6eE0+XWy96jcrfuRqJTqMWje3kTCZiJwMgwN0KS25VuMse30ulj8BIJGDG+rQGcWyWm0OceLV14xYponlzZfa7h0QF9+8MOdB04CTtWT0DKkBTaj7sNnowM6VKjS4taT13hvXj1ntS2uVxu9B7w+BVyqZXz4STgwwQG9nEgQPEJi+PbhzsYQ0tSAkaM78xpkyVpG1m5sQSkC69ozrkL/2DOknU4/ccFrXXPP5cV9aqXQ9ZnMhjb2nhqO/n7eVRp2POxwiv28IoX2KJfUhMvsYXPWMY9vEmeOQZgdgJGfOQpnTG3NEhHzArUJGDE+OaWBjX7ht6opQvvjj2H0bzbKOTMnhlFXs6jxbnn4AmcPX8Jk7/oFLNVQG8DEqNcreb9UejlPOjYtAaOnfoTn3ccpr1oJ7YxiJfURk1ZhOmjuiEkOLm23aF8qWI8pSExwPMZJOAFASMmRC/C86wohdczTrzLdASMGN8UXnN1K+nCW7NZPxQq8AJ6tKkNiyVqv4zb7caQcfOw/9ApLJzcN8mJ//X3v9o+3r0HTyBj+jRoUrsiqlcsGRNX+PRlmL+c5/AmeaIYAAnEImDEhCgdOIVXOmJWoCYBI8Y3hVfNvqE3aunCW6hMIyydPgi5c2SJE+PpsxfwcaPeSOpTGvSCiy7HL57wliDLk4A+AkZMiPoiS0ApCm8CYPFWMxEwYnxTeM3UoyQdSxYb4TsftUW/zg1jjvWK/t3Gn/dqx4H9uPRLpYlTeJVOH4NXmIARE6J0PBRe6YhZgZoEjBjfFF41+4beqKWv8IpvMVux9me0b1Idr72SV4tTbB0YPWUxqr7/Njo1r6k3dp8oR+H1iTQwCBMSMGJClI6VwisdMStQk4AR45vCq2bf0Bu1dOGNjHTgy6++wdxv1kP8f3GJr+ytW60s2jSqBrvNqjd2nyhH4fWJNDAIExIwYkKUjpXCKx0xK1CTgBHjm8KrZt/QG7V04Y0O7H5EJP48fwnivbVns2bSpNcfLgqvP2SRbVCRgBETonQuFF7piFmBmgSMGN8UXjX7ht6oDRNevQH6ejkKr69niPH5KwEjJkTp7Ci80hGzAjUJGDG+Kbxq9g29UVN49ZJ7UI7C6yVAFicBnQSMmBB1huZ5MQqv56x4p6kIGDG+Kbym6lKg8HqZbwqvlwBZnAR0EjBiQtQZmufFKLyes+KdpiJgxPim8JqqS1F4vU03hddbgixPAvoIGDEh6ossAaUovAmAxVvNRMCI8U3hNVOPMuAcXn/HSeH19wyzfb5KwIgJUXrbKbzSEbMCNQkYMb4pvGr2Db1RG7KlYe3mnViy+kf8+dclrJk/TIt1zpJ1yJUjC/5XrKDe2H2iHIXXJ9LAIExIwIgJUTpWCq90xKxATQJGjG8Kr5p9Q2/U0oV36Xc/YdiEBdq5uxNmrcChzTO1WOct3YDN2/Zh6ojOemP3iXIUXp9IA4MwIQEjJkTpWCm80hGzAjUJGDG+Kbxq9g29UUsX3kr1emhfMFGuZFEUKNUgRniPnPgDzbqOxE/LxuqN3SfKUXh9Ig0MwoQEjJgQpWOl8EpHzArUJGDE+Kbwqtk39EYtXXgLlW2Mb+cMRbZnMsQR3t/PXsBHn/fCvg1f6Y3dJ8pReH0iDQzChASMmBClY6XwSkfMCtQkYMT4pvCq2Tf0Ri1deMt/2gW92tfF28VfiSO8sxev1fb1rpwVpjd2nyhH4fWJNDAIExIwYkKUjpXCKx0xK1CTgBHjm8KrZt/QG7V04Z2x4HssWrUJvTvUQ5POI7B8xiBs3LoXk+esRJeWtfBp1ff0xu4T5Si8PpEGBmFCAkZMiNKxUnilI2YFahIwYnxTeNXsG3qjli68brcb42csx4yF3+Pe/QgtzqBAOxp9WgGtGn6kN26fKUfh9ZlUMBCTETBiQpSOlMIrHTErUJOAEeObwqtm39AbtXThjQ5MyK7Yt+tyuZE7Z1YkTxaoN2afKkfh9al0MBgTETBiQpSOk8IrHTErUJOAEeObwqtm39AbtWHCqzdAXy9H4fX1DDE+fyVgxIQonR2FVzpiVqAmASPGN4VXzb6hN2rpwtt72PR4Y7NYorY25MiWGe+/WwwZ06fR24YkLUfhTVL8rNzEBIyYEKXjpfBKR8wK1CRgxPim8KrZN/RGLV14uw6chE3b9iEkOBny58mpxSnO4L11+x7eLPoSjp86h8tXb2DOuFDkeyGH3nYkWTkKb5KhZ8UmJ2DEhCgdMYVXOmJWoCYBI8Y3hVfNvqE3aunCO2bqEly9flM7pcFmtWpxOpxODBw9G2lTp0Sbzz9G/1Ezce6vfzB9dDe97UiychTeJEPPik1OwIgJUTpiCq90xKxATQJGjG8Kr5p9Q2/U0oW3ROVW+HpCH+TMnjlOjGf+/Bu1Ww/CzyvCcfrsBdRuORDbV0/Q244kK0fhTTL0rNjkBIyYEKUjpvBKR8wK1CRgxPim8KrZN/RGLV14X/+gGcYNboc3irwUJ8Yduw+jTa8vsfP7ybhw6Qoq1w/Fzu8n6W1HkpWj8CYZelZscgJGTIjSEVN4pSNmBWoSMGJ8U3jV7Bt6o5YuvD2HTsMvew6jQ7OaeCV/bi3OA0dOY9SkRXizaAEM6tYIazf/iqnzvsWSqf31tiPJylF4kww9KzY5ASMmROmIKbzSEbMCNQkYMb4pvGr2Db1RSxfeu/ciMHLSQixZvRmRDqcWp91mRfWKpdCp+SfaebzHTv0J8QUVfGktnjRyQtTbt1nOzwkYMSFKR8jxLR0xK1CTgBHjm8KrZt/QG7V04Y0OTIjvuQuXYIEF2bJk5BdPeJoxToiekuJ9JiNgxIQoHSnHt3TErEBNAkaMbwqvmn1Db9SGCa/eAH29HLc0+HqGGJ+/EjBiQpTOjsIrHTErUJOAEeObwqtm39AbtSHCu3bzTny/8RdcuHgZkQ5HnFiXfjVQb+w+UY7C6xNpYBAmJGDEhCgdK4VXOmJWoCYBI8Y3hVfNvqE3aunCO2fJOoTPWIZaVUpj2vxv0frzj7Qvnvhp+340+OQDtG9SXW/sPlGOwusTaWAQJiRgxIQoHSuFVzpiVqAmASPGN4VXzb6hN2rpwluhTje0bVRN+/rgAqUa4NDmmVqs3/3wCzZt24PhvVvojd0nylF4fSINDMKEBIyYEKVjpfBKR8wK1CRgxPim8KrZN/RGLV14C5drgtWzhyDbMxkg/v+WZWMREpxci7fMJ52wYeFIvbH7RDkKr0+kgUGYkIARE6J0rBRe6YhZgZoEjBjfFF41+4beqKUL73s1OmLsoLYo8OJzEKu9vdvX087fvXb9Fio3CMVPy8bqjd0nylF4fSINDMKEBIyYEKVjpfBKR8wK1CRgxPim8KrZN/RGLV14uw2ejNw5sqJZ3UqYOm81Ziz8Hm8XewX7D59C0Vdf1L54QuWLwqty9hi7ygSMmBCl86HwSkfMCtQkYMT4pvCq2Tf0Ri1deO/cvQ+H04lUISm0L5dY+t0W7Dt0ErlzZEHtj8sgMNCuN3afKEfh9Yk0MAgTEjBiQpSOlcIrHTErUJOAEeObwqtm39AbtXThPX32gia3D19Opwt/nL8Y7+/0NiYpylF4k4I66yQBwIgJUTpnCq90xKxATQJGjG8Kr5p9Q2/U0oU39skMsYO8ev0m/lelTcypDXobkNTlKLxJnQHWb1YCRkyI0tlSeKUjZgVqEjBifFN41ewbeqNOMuE9//e/qNIgFLvWTNEbu0+Uo/D6RBoYhAkJGDEhSsdK4ZWOmBWoScCI8U3hVbNv6I1amvAOGTdPi2nuN+tRp1rZOPG5XC4cOHwaQUF2zB4bqjd2nyhH4fWJNDAIExIwYkKUjpXCKx0xK1CTgBHjm8KrZt/QG7U04W3RfbQW00879uOdN16NE5/dbkX2ZzKibvVyyJI5vd7YfaIchdcn0sAgTEjAiAlROlYKr3TErEBNAkaMbwqvmn1Db9TShDc6oNAhUxHWo4ne+Hy+HIXX51PEAP2UgBETonR0FF7piFmBmgSMGN8UXjX7ht6opQuv3sBUKUfhVSVTjNPfCBgxIUpnRuGVjpgVqEnAiPFN4VWzb+iNWrrwXr9xG+OmL8WOPYdx+cp1uNzuOLH+8u1EvbH7RDkKr0+kgUGYkIARE6J0rBRe6YhZgZoEjBjfFF41+4beqKULb9veY/H3pSv4uMI7SJs65SNxli/1ut7YfaIchdcn0sAgTEjAiAlROlYKr3TErEBNAkaMbwqvmn1Db9TShbf4hy2wbsEIpE4ZrDdGny5H4fXp9DA4PyZgxIQoHR+FVzpiVqAmASPGN4VXzb6hN2rpwlvmk05YNWsIkicL1BujT5ej8Pp0ehicHxMwYkKUjo/CKx0xK1CTgBHjm8KrZt/QG7V04Z2zZB3+/OsSurT8FHabVW+cPluOwuuzqWFgfk7AiAlROkIKr3TErEBNAkaMbwqvmn1Db9TShbdWiwE4euIPpEieDNmzZkRAQECcWBdM7KM3dp8oR+H1iTQwCBMSMGJClI6VwisdMStQk4AR45vCq2bf0Bu1dOGdNHvlE2NrXq+y3th9ohyF1yfSwCBMSMCICVE6VgqvdMSsQE0CRoxvCq+afUNv1NKFV29gqpSj8KqSKcbpbwSMmBClM6PwSkfMCtQkYMT4pvCq2Tf0Rm2I8DqcThw8+jv+PH8JlcqV0GK9fvM2kgUFIijQrjd2nyhH4fWJNDAIExIwYkKUjpXCKx0xK1CTgBHjm8KrZt/QG7V04f37nyto2X00Tp+9gMhIBw5tnqnF2iNsKlKGpEBo29p6Y/eJchRen0gDgzAhASMmROlYKbzSEbMCNQkYMb4pvGr2Db1RSxfe9n3CYbNZEda9MQqXaxIjvFt//Q1fhM/HqtlD9Mae6OW+3/gLOg+YiPZNqqNJ7Yoxzx8/YxnmLdsAh8OJimVLaJJus0adOEHhTfQ08IEk4BEBIyZEjwLx5iYKrzf0WNaPCRgxvim8ftyB4mmadOEtUbkV5owNxfPPZUOBUg1ihPfs+Uuo2rAn9qyb6hPEb9+5h0+a90eg3YYPShePEd7V67dj+MQFmDayC0KCU6BZ15GoULo4ol+2o/D6RPoYhAkJGDEhSsdK4ZWOmBWoScCI8U3hVbNv6I1auvAWfb8pFk7uh+dzZo0jvLsPHEfr0DHYvnqC3tgTtdyQcfOQJXN6bNt5EK8XyhcjvI07D0eRgnnRsn4Vrb5V67Zh/MzlWDN/GFd4EzUDfBgJJIyAERNiwiLScTeFVwc0FjEDASPGN4XXDD3pvzZKF94W3Ucjd84s6NKiVozw3rx1B61CxyBDutQY1a9VkhM/evIsQodMxaIp/bT9xrGFt1S19ujTsT5Kv1VYi/PE7+dQtWEvbWVavHB38eo9qfG7XG70HmCTWgcfTgIqEhjYx4GAAIuKocfEzPGtdPoYvEQCRozvzGmTSWwBH+1rBKQLr3hZrV6bMOTMnhn7Dp1E2XeKYuf+o7AGBGBueC/kyJYpSZm43W7UbjUI7ZvUQLHC+dC0y4g4wlusQnOED26v/U5cFy5dQZmaHbF1xTikTZ0STpdbavy37kaiU6jak7pUQHy4aQmMDHMjJLnap7xwfJu2+7LhTyFgxPi2Kv4HMztRwghIF14Rzr9XrmPRqs04fOwMXG4XXsrzHGpVLa2t8Cb1tXj1Zvy69wiG926hhfKw8D5thZd7eJM6g6zfrASM+MhTOltuaZCOmBWoScCI8c0tDWr2Db1RGyK8eoMzolyn/hPw886D2stq4rpx8zbsdhtKlSikSbDYw1v0lRdjXlITL7GFz1jGPbxGJId1kMATCBgxIUpPAIVXOmJWoCYBI8Y3hVfNvqE3aunCu3rDdu0LJsq8/VqcGNf/tAuRkU5UeK+43tgTpZzYT3w/IjLmWV0GTkShAnnQ4JP3kTplsPaS2qgpizB9VDeEBCfXVoDLlyrGUxoShT4fQgL6CRgxIeqPzsOSFF4PQfE2sxEwYnxTeM3Vq6QLb4U63dC7fT28WbRAHLLbdh1E2Nh5WO1D5/CKAB/e0iB+Fj59GeYv5zm85hoabK2vEzBiQpTOgMIrHTErUJOAEeObwqtm39AbtXThLVSmEVbPGYrsWTLGifHPvy6hUv1Q7Fs/TW/sPlGOe3h9Ig0MwoQEjJgQpWOl8EpHzArUJGDE+Kbwqtk39EYtXXjf+agtBndvjLeLvxInxi2/HNCOAtuyfJze2H2iHIXXJ9LAIExIwIgJUTpWCq90xKxATQJGjG8Kr5p9Q2/U0oW3/6hZ2ikIYwa0Rp5c2bU4xVm24iuHixXKh76dGuiN3SfKUXh9Ig0MwoQEjJgQpWOl8EpHzArUJGDE+Kbwqtk39EYtXXjFS2Hiyyf2HjyBdGlSanFeuXYTRQrmwYQhHZAyJIXe2H2iHIXXJ9LAIExIwIgJUTpWCq90xKxATQJGjG8Kr5p9Q2/UUoU30uHE3t9OoGD+XDhw5DSOHP8DsAD58+TUVnctFvW/UIHCq7frsRwJeEfAiAnRuwg9KE3h9QASbzEjASPGN4XXXD1LqvCKr80sUr4Jdq+ZAqs1wC/JUnj9Mq1slAIEjJgQpWOg8EpHzArUJGDE+Kbwqtk39EYtVXhFUJXrh2LysE7Ikjm93hh9uhyF16fTw+D8mIARE6J0fBRe6YhZgZoEjBjfFF41+4beqKUL77ofd2HuN+vQvkl1vJArO4IC7XFiffi/9TYkqcpReJOKPOs1OwEjJkTpjCm80hGzAjUJGDG+Kbxq9g29UUsX3gKlnnwKw6HNM/XG7hPlKLw+kQYGYUICRkyI0rFSeKUjZgVqEjBifFN41ewbeqOWLrx7fjv+xNiKFMyrN3afKEfh9Yk0MAgTEjBiQpSOlcIrHTErUJOAEeObwqtm39AbtXTh1RuYKuUovKpkinH6GwEjJkTpzCi80hGzAjUJGDG+Kbxq9g29URsivH/9/S++/WEHzp6/hIFdP9di3bH7sPYiW87smfXG7hPlKLw+kQYGYUICRkyI0rFSeKUjZgVqEjBifFN41ewbeqOWLrziCyeadB6OAi/mwq79xxC9Z3fM1CUQIjysd3O9sftEOQqvT6SBQZiQgBETonSsFF7piFmBmgSMGN8UXjX7ht6opQtv7VaD8O5bhdH4sw8hXmCLFt49v51A10GTsGHhSL2x+0Q5Cq9PpIFBmJCAEROidKwUXumIWYGaBIwY3xReNfuG3qilC2/R95ti2fRBeDZrpjjC++dfl1CpXg/s2/CV3th9ohyF1yfSwCBMSMCICVE6VgqvdMSsQE0CRoxvCq+afUNv1NKF939V2mDi0A4omD93HOEV5/MODZ+HjYtH643dJ8pReH0iDQzChASMmBClY6XwSkfMCtQkYMT4pvCq2Tf0Ri1dePuPnIm/Ll7G6P6t8PoHzbUtDdp2hoETUbbk6+jW6lO9sftEOQqvT6SBQZiQgBETonSsFF7piFmBmgSMGN8UXjX7ht6opQvvrdt30bLHaBw4chqRkQ6kThWM6zdu4/VC+TBhSAekSB6kN3afKEfh9Yk0MAgTEjBiQpSOlcIrHTErUJOAEeObwqtm39AbtXThjQ5MO6Hh+Bm4XW7kz5sTxQrlg8Vi0Ru3z5Sj8PpMKhiIyQgYMSFKR0rhlY6YFahJwIjxTeFVs2/ojVqq8G78eS82bt2D+xERKFY4P6p/WNIvJDc2bAqv3q7HciTgHQEjJkTvIvSgNIXXA0i8xYwEjBjfFF5z9Sxpwrv0u5/Qe9h0PPfsM0gWFIijJ8+ifo3y6Kr4nt2HuweF11wDhq31HQJGTIjSW0vhlY6YFahJwIjxTeFVs2/ojVqa8FZt2AslihaIEVwhwANGzcLONVNgt1n1xutz5Si8PpcSBmQSAkZMiNJRUnilI2YFahIwYnxTeNXsG3qjlia8Rco1wdzwnngp73NabPcjIiF+tmb+MO1MXn+5KLz+kkm2QzUCRkyI0plQeKUjZgVqEjBifFN41ewbeqOWJrziW9VWzR6C3DmyxMRWsHRDLP1qIPLkyq43Xp8rR+H1uZQwIJMQMGJClI6SwisdMStQk4AR45vCq2bf0Bu1VOH9tOp7SJs6JCa2CbNW4JMqpZE+TcqYn7Vq+JHe2H2iHIXXJ9LAIExIwIgJUTpWCq90xKxATQJGjG8Kr5p9Q2/U0oS3zCedPIppw8KRHt3nqzdReH01M4zL3wkYMSFKZ0jhlY6YFahJwIjxTeFVs2/ojVqa8OoNSLVyFF7VMsZ4/YWAEROidFYUXumIWYGaBIwY3xReNfuG3qgpvHrJPShH4fUSIIuTgE4CRkyIOkPzvBiF13NWvNNUBIwY3xReU3UpUHi9zDeF10uALE4COgkYMSHqDM3zYhRez1nxTlMRMGJ8U3hN1aUovN6mm8LrLUGWJwF9BIyYEPVFloBSFN4EwOKtZiJgxPim8JqpR4HC6226KbzeEmR5EtBHwIgJUV9kCShF4U0ALN5qJgJGjG8Kr5l6FIXX62xTeL1GyAeQwP/bu/N4m4vHj+PvLLfs0Z72FBVF31LRghRljRDKFpJ930KKbrJlF75ZI7Rc5NtCtChaSDvtfZWUpL1k/T3m49v5udfVPZ/53DMc8zr//H7f7sznM/OcmTNvnzvnXCsBFxuiVcPCVCLwhtGirEcCLtY3gdejCSUCb+TRJvBGJuQCCFgJuNgQrRoWphKBN4wWZT0ScLG+CbweTSgCb/TBJvBGN+QKCNgIuNgQbdoVqg6BNxQXhf0RcLG+Cbz+zCfTU76lIeJ4E3gjAlIdAUsBFxuiZdPir0bgjd+Kkl4JuFjfBF6vphSBN+pwE3ijClIfATsBFxuiXctC1CLwhsCiqE8CLtY3gdenGcUT3sijTeCNTMgFELAScLEhWjUsTCUCbxgtynok4GJ9E3g9mlAcaYg+2ATe6IZcAQEbARcbok27QtUh8IbiorA/Ai7WN4HXn/lkesoZ3ojjTeCNCEh1BCwFXGyIlk2LvxqBN34rSnol4GJ9E3i9mlIE3qjDTeCNKkh9BOwEXGyIdi0LUYvAGwKLoj4JuFjfBF6fZhRPeCOPNoH9mg7cAAAgAElEQVQ3MiEXQMBKwMWGaNWwMJUIvGG0KOuRgIv1TeD1aEJxpCH6YBN4oxtyBQRsBFxsiDbtClWHwBuKi8L+CLhY3wRef+aT6SlneCOON4E3IiDVEbAUcLEhWjYt/moE3vitKOmVgIv1TeD1akoReKMON4E3qiD1EbATcLEh2rUsRC0Cbwgsivok4GJ9E3h9mlE84Y082gTeyIRcAAErARcbolXDwlQi8IbRoqxHAi7WN4HXownFkYbog03gjW7IFRCwEXCxIdq0K1QdAm8oLgr7I+BifRN4/ZlPpqec4Y043gTeiIBUR8BSwMWGaNm0+KsReOO3oqRXAi7WN4HXqylF4I063ATeqILUR8BOwMWGaNeyELUIvCGwKOqTgIv1TeD1aUbxhDfyaBN4IxNyAQSsBFxsiFYNC1OJwBtGi7IeCbhY3wRejyYURxqiDzaBN7ohV0DARsDFhmjTrlB1CLyhuCjsj4CL9U3g9Wc+mZ5yhjfieBN4IwJSHQFLARcbomXT4q9G4I3fipJeCbhY3wRer6YUgXfDxs0aNeUxrX7nI/25bbsuPP8s9WnfWMXOLBqbCeOnpWl22vPauXOXql9XTn07NlaunDmDnxN4/Vow9PbQEXCxISa8twTehBNzg+QUcLG+CbzJOTdsW+39E9633vtYa9//VBXLl1H+vHk0btqTem3Nh1oyd3hgunjpKg2bOFf/HtFD+fPl1R09R+jGSpepTZOaBF7bWUc9BLJBwMWGmA3N/OdLEHgTTswNklPAxfom8Cbn3LBttfeBNyPc5i0/qeLNnfVy2hgdU7igWnYfpotLnau2TWsFRZ9aslLjpy/Qs3OGEnhtZx31EMgGARcbYjY0k8CbcERucDgKuFjfBN7DceYcuE8E3gw2S15arftGz9KLT4zSEUccoQp1O2tA16aqVL5MUPKTL75W7eb99NaSKToyJTdHGvxaL/T2EBJwsSEmvLs84U04MTdITgEX65vAm5xzw7bVBN595L75dosath0UnNGtUqFs8JOyN7bRuPs6q2yZEsH/3rR5qyrX76pXFo5V4UIFtPXX7bb2cdXbuXO3+g7ce16YFwII/L9A6sBdypUrR1KTsL6TevhofAIFXKzvIgVSEtgDLn2oCRB4/zci5ihD006palznOt1a97rYOGX1hHfb9l0JHdM//9qpHv2Se1NPKBAX91Zg2ODdynNkrqTuP+s7qYePxidQwMX6PiqFh0kJHMJD7tIEXklbtv6sJh1TVefGq9WyUbV0g2TO8F5yYfHYh9TMh9jGTUvjDO8hN5VpkG8CLn7lmXBTjjQknJgbJKeAi/XNkYbknBu2rfY+8G796Vc17ZiqSlderLbNasccU3LnCs7wmg+pjZw8X1NH9lL+fHnUusfw4LgD39JgO+Woh0D2CLjYELOnpf9wFQJvwom5QXIKuFjfBN7knBu2rfY+8KY9s0L9Hnh4P78n/n2vShQ7Lfjv46amac4CvofXdpJRD4FECLjYEBPR7nTXJPAmnJgbJKeAi/VN4E3OuWHbau8Dry3c3/X4wxNRBamPgJ2Aiw3RrmUhahF4Q2BR1CcBF+ubwOvTjOJPC0cebQJvZEIugICVgIsN0aphYSoReMNoUdYjARfrm8Dr0YQSgTfyaBN4IxNyAQSsBFxsiFYNC1OJwBtGi7IeCbhY3wRejyYUgTf6YBN4oxtyBQRsBFxsiDbtClWHwBuKi8L+CLhY3wRef+aT6SlneCOON4E3IiDVEbAUcLEhWjYt/moE3vitKOmVgIv1TeD1akoReKMON4E3qiD1EbATcLEh2rUsRC0Cbwgsivok4GJ9E3h9mlE84Y082gTeyIRcAAErARcbolXDwlQi8IbRoqxHAi7WN4HXownFkYbog03gjW7IFRCwEXCxIdq0K1QdAm8oLgr7I+BifRN4/ZlPpqec4Y043gTeiIBUR8BSwMWGaNm0+KsReOO3oqRXAi7WN4HXqylF4I063ATeqILUR8BOwMWGaNeyELUIvCGwKOqTgIv1TeD1aUbxhDfyaBN4IxNyAQSsBFxsiFYNC1OJwBtGi7IeCbhY3wRejyYURxqiDzaBN7ohV0DARsDFhmjTrlB1CLyhuCjsj4CL9U3g9Wc+mZ5yhjfieBN4IwJSHQFLARcbomXT4q9G4I3fipJeCbhY3wRer6YUgTfqcBN4owpSHwE7ARcbol3LQtQi8IbAoqhPAi7WN4HXpxnFE97Io03gjUzIBRCwEnCxIVo1LEwlAm8YLcp6JOBifRN4PZpQHGmIPtgE3uiGXAEBGwEXG6JNu0LVIfCG4qKwPwIu1jeB15/5ZHrKGd6I403gjQhIdQQsBVxsiJZNi78agTd+K0p6JeBifRN4vZpSBN6ow03gjSpIfQTsBFxsiHYtC1GLwBsCi6I+CbhY3wRen2YUT3gjjzaBNzIhF0DASsDFhmjVsDCVCLxhtCjrkYCL9U3g9WhCcaQh+mATeKMbcgUEbARcbIg27QpVh8AbiovC/gi4WN8EXn/mk+kpZ3gjjjeBNyIg1RGwFHCxIVo2Lf5qBN74rSjplYCL9U3g9WpKEXijDjeBN6og9RGwE3CxIdq1LEQtAm8ILIr6JOBifRN4fZpRPOGNPNoE3siEXAABKwEXG6JVw8JUIvCG0aKsRwIu1jeB16MJxZGG6INN4I1uyBUQsBFwsSHatCtUHQJvKC4K+yPgYn0TeP2ZT6annOGNON4E3oiAVEfAUsDFhmjZtPirEXjjt6KkVwIu1jeB16spReCNOtwE3qiC1EfATsDFhmjXshC1CLwhsCjqk4CL9U3g9WlG8YQ38mgTeCMTcgEErARcbIhWDQtTicAbRouyHgm4WN8EXo8mFEcaog82gTe6IVdAwEbAxYZo065QdQi8obgo7I+Ai/VN4PVnPpmecoY34ngTeCMCUh0BSwEXG6Jl0+KvRuCN34qSXgm4WN8EXq+mFIE36nATeKMKUh8BOwEXG6Jdy0LUIvCGwKKoTwIu1jeB16cZxRPeyKNN4I1MyAUQsBJwsSFaNSxMJQJvGC3KeiTgYn0TeD2aUBxpiD7YBN7ohlwBARsBFxuiTbtC1SHwhuKisD8CLtY3gdef+WR6yhneiONN4I0ISHUELAVcbIiWTYu/GoE3fitKeiXgYn0TeL2aUgTeqMNN4I0qSH0E7ARcbIh2LQtRi8AbAouiPgm4WN8EXp9mFE94I482gTcyIRdAwErAxYZo1bAwlQi8YbQo65GAi/VN4PVoQnGkIfpgE3ijG3IFBGwEXGyINu0KVYfAG4qLwv4IuFjfBF5/5pPpKWd4I443gTciINURsBRwsSFaNi3+agTe+K0o6ZWAi/VN4PVqShF4ow43gTeqIPURsBNwsSHatSxELQJvCCyK+iTgYn0TeH2aUTzhjTzaBN7IhFwAASsBFxuiVcPCVCLwhtGirEcCLtY3gdejCcWRhuiDTeCNbsgVELARcLEh2rQrVB0CbyguCvsj4GJ9E3j9mU+mp5zhjTjeBN6IgFRHwFLAxYZo2bT4qxF447eipFcCLtY3gderKUXgjTrcBN6ogtRHwE7AxYZo17IQtQi8IbAo6pOAi/VN4PVpRvGEN/JoE3gjE3IBBKwEXGyIVg0LU4nAG0aLsh4JuFjfBF6PJhRHGqIPNoE3uiFXQMBGwMWGaNOuUHUIvKG4KOyPgIv1TeD1Zz6ZnnKGN+J4E3gjAlIdAUsBFxuiZdPir0bgjd+Kkl4JuFjfBF6vphSBN+pwE3ijClIfATsBFxuiXctC1CLwhsCiqE8CLtY3gdenGcUT3sijTeCNTMgFELAScLEhWjUsTCUCbxgtynok4GJ9E3g9mlAcaYg+2ATe6IZcAQEbARcbok27QtUh8IbiorA/Ai7WN4HXn/lkesoZ3ojjTeCNCEh1BCwFXGyIlk2LvxqBN34rSnol4GJ9E3i9mlIE3qjDTeCNKkh9BOwEXGyIdi0LUYvAGwKLoj4JuFjfBF6fZhRPeCOPNoE3MiEXQMBKwMWGaNWwMJUIvGG0KOuRgIv1TeD1aEJxpCH6YBN4oxtyBQRsBFxsiDbtClWHwBuKi8L+CLhY3wRef+aT6SlneOMY7/HT0jQ77Xnt3LlL1a8rp74dGytXzpxBTQJvHIAUQSABAi42xAQ0O/0lCbwJJ+YGySngYn0TeJNzbti2msCbhdzipas0bOJc/XtED+XPl1d39ByhGytdpjZNahJ4bWcd9RDIBgEXG2I2NPOfL0HgTTgxN0hOARfrm8CbnHPDttUE3izkWnYfpotLnau2TWsFJZ9aslLjpy/Qs3OGEnhtZx31EMgGARcbYjY0k8CbcERucDgKuFjfBN7DceYcuE8E3izGu0LdzhrQtakqlS8TlPzki69Vu3k/vbVkio5Myc2RBr/WC709hARcbIgJ7y5PeBNOzA2SU8DF+ibwJufcsG01gTcLubI3ttG4+zqrbJkSQclNm7eqcv2uemXhWBUuVMDWPe56v/6xQ136xF2cggh4I/Dg/VKBvLmTur+s76QePhqfQIHDYX0nkIdLWwgQeCM+4bUwpwoCCCCAAAIIIICAQwECbxbY5gzvJRcWj31IzXyIbdy0tNgZXodjxa0QQAABBBBAAAEELAQIvFmgmQ+pjZw8X1NH9lL+fHnUusdwValQNhaALcypggACCCCAAAIIIOBQgMAbB/a4qWmasyDz7+GNozpFEMgWgbRnVmjJS6s1cUiXbLkeF0EAgeQT2PjtFtVq1lern52cfI2nxQgcRAEC70HE9/XWNZvdpVaNqqnG9eWyJOg1eJJKFDtNzW+5IcuyiShQ8ebOGntfJ5Usfmaml9+5a5dGT3lC/1m2Slt/+lXHHXO0yl9SUgO7N8v25ny+YZO+2rhZ11xxUbZfmwsikJWAWbebvvtBS+cO19GF8gfFn172uqbNe0aPTR6YVfX9fj541Cz9tX2HBvVskWVd3gf+n+j3P7bpP8teU/0aFbJ0owACCPy/AIGX2eBcwFXg3bNnj3bv3qOcOXNY9zGrwDt17tN68ukVGjmwnU4/5QR98+0WrVrzoRrddG3oe5rw/Pdf8AtdmQoIJFjArNstP/ykOtWuVvc2DZIq8EZdW7wPJHhycXkEHAgQeB0gc4v0AvsGXvPU8tb2g9WsftXg1/W//vaHbrv5et1a9zotfO5VDXpwhnLnyqV8+fLo6ssv0oAuTbRl689KHfOI3li7XkcdlRKUb1qvSnCTbvdM0DGFC+mTL77S15u2aHxqZ7XsNlRN6lXR0pdW65fffleZkufo3p4tYuHy/Y++0JCxc4LvWD7p+GPUu30jXf6v83XvgzP12FMvqMjRBZU7dy51aFFHtaqUT9cZc7+iJx6rrnfUz3SYd+zYGXzI0XzY0TzNuvaqi9W7fWPlOSpF8xYu1wsr16pQwfx6f/0Xali7ksZOTdMj4+7SOWeeElzPPDW+tn5XPT9vhF5+7Z10Rxo2b/lJQ8bN0Ztvr9OuXbtV6cqLNbjX7UG9RUte1ZRHFuv7rT/rguJn6N4eLYJ28kLAVsCsW/NXJh9+9Gk9M/sBHVuk0H5PeDds/E73jJyhDz76Mvh5++Y3qWrFspnect8nvNn9PpBxbZn3iAnTFxwW7wPb/tqe7kgD7wO2M5p6vgkQeH0b8UOgvxkDb40mfdTjzlvUrEFVfff9j6rRtI8WTrtPJ51wjDL+KtM8tW3cbnAQWju2rKsftv4s800avdo1Cn7VbwLoOx98qjkTBuj4Y4+WKX9NnU5B+eF3tw16f1v7wbr15utVvfIV+uHHX2Tuf3e3pqp81SV6672P1WnAWC2anhps2Fk92Zn95FJNmvWU7mxaS5dcVFzFziiqI444IqY8ctL8IMwO7d9GefMcpb73T1HRk44N+ms25UGjZmnag710aekSQVv7D50a3Ldzq5uDa8xJW6YXV67V5GHdte8ZXvPk+pY771HJEmep2x31lTtXTr23/gv968Jz9cob76n/0Ic1cUhXFTuzqGY9tkTPvvCG5j40IF3bDoGpQBOSSMCs23bNauvFlW+rQP486tvx1nSB1/yjq3bzu3R9hUvV5raaenfd52rTa4Rmjumr8845fb+eZgy82fk+kNnaOlzeB/Y9w8v7QBItIJp60AUIvAd9CPxrQMbAe1PzflqzZHLsiasJtK0aV1eFcqX3C7zrP92gJh1TteqpCbGjCiZ0midKqX1aBYH31JOPjwVGo3v1TR014u62Qag0r1FTHpd58tqj7S2a9fgSvfrm+3roga6xgejUf2xw75tuuCrLwGtC6qIlK7XouVf17rrPglBrwu8ttSoF17uieltNHt5DpUrsPQP88edfq22fB4MntmZTNk+x50zoH7v3qtUf6O7h07Rk7vDgvxmL+jUrBk+W9w286z75r5p1HqIVaWOUkpL+jy906DdGZUoWU4tbbgyuYdp4Ze0Omj9pIE95/Vtu2dbjvwPv+eeerjq399eiGfdr7XufxM7wmn9wte4+TCsWjo2tZfMPuIL58wZrLeMrY+DNzveBzNbW4fI+sG/g5X0g26Y3F/JAgMDrwSAfal3M7EjDykXjY828vetQ1a12jW689rL9Au/yV9eq68Dx6YKbCa8lzjlNYwZ1DALvxaXOUeM618WuZza6h0f2jB0TeGjmIn33/Vbd3a2ZHhj/qBY8s0JFCheMlf9z219qcnOV4IlzVk9497U1T7ieX7FaPQdN0vTRvYP7XVbtTp1W9ATlyLH3qa8Jn+bYxooFY4PAu3L1Bxo9qEPsMuaJTXDPwR2DJ701mvbVy2ljlC/vUekCr3EwwX3R9Pv2G966LQdo60+/BOH775e5p/nw3UXnn32oTQfakyQCfwfeKhUu1cDh07V7z25dfvEFscC7/JW3NPrhJ4Lfzvz9Mmvt0y83aviAO7MMvOZoU3a9D2S2tg6X94F9Ay/vA0myeGjmISFA4D0khsGvRoQJvL1TJ6v4WafGvqXBPNG4o+cIvfTk6Ex/Pb838J6rxnUqxxV4Zzz2XHAEwnzoLLPXtfW6avTgDgf8lobM6tRs2jc4g2yezJrAO2d8P519RtH9ippN2XzAbdS97dP9LHXMbJlTESbwrvtkg0YO3HsUI7MnvK8sGBucL9731b7vaJUvW1INa4f/4JxfM5HehhHYN/CaP7Feo0lvtWpcQ8+vWBN8S0PUJ7z/FHjDvg9ktrb+KfAm0/tAZk94eR8IM5Mp66sAgdfXkT+I/Q4TeIdNmKs//twWPI01L/MEtHH7wcFZ1bZNa+nIlBR9+dUm/fHnXyp13ln/e8Ibf+D9/oefVLtFP/XrdJsqX32J9uzeHZw9NB/wMmeI67UeqOYNbgieNmf2MkcizBGKiy44O2jLshVrgvOz5pjC+eeeoREPzde6T/8bfJjsxOOKyHzA5KPPvtJVl5UKnvBmFnjf/fAzmWMJ5sNsnVvWDT6MljHwmifFDdrcEzyx7dK6XvAr5L/P8K54/V3dM2K6Rg3qoAvOPUO//f6nVq5+P/iDKbwQsBXYN/Caa5gPjpoPYxY96bgg8JrfcNRqvveDba1uraH31n0e/ON0xujewVrI+MrsQ2sHesIb9n0gbOBNpveBfQMv7wO2s5l6PgoQeH0c9YPc5zCB13x6u9vA8TJPlCqWK6P7+7YKvqXBbICr1nyg7Tt26oxTTwy+QaH8pSVDB15D8eHHX2rYxLla/8kG5ciZIzhv279L0yD0Ln15te4fOzsI1N3a1Fe96um/+3Lx86v0aNqy4Ne2u3bt0umnnKjbG1aLBWRz3MJ8qM18a8KPP/+mE44rrHo1KgTfKnGgwGvaVLVRT/38y2/BcYa/n+Bm/MMT5gN+JnS8+c56aY/SfUuD+X7UyY88JbM5mg8YlS1znob0bX2QR57bJ7NAxsBr1mGVhj101uknx76H98uvvtW95lsaPt77LQ1tm9VWtWsvz7TbYQJv2PeBsIE3md4HMv7hCd4HknlV0XaXAgRel9rcCwEEEEAAAQQQQMC5AIHXOTk3RAABBBBAAAEEEHApQOB1qc29EEAAAQQQQAABBJwLEHidk3NDBBBAAAEEEEAAAZcCBF6X2twLAQQQQAABBBBAwLkAgdc5OTdEAAEEEEAAAQQQcClA4HWpzb0QQAABBBBAAAEEnAsQeJ2Tc0MEEEAAAQQQQAABlwIEXpfa3AsBBBBAAAEEEEDAuQCB1zk5N0QAAQQQQAABBBBwKUDgdanNvRBAAAEEEEAAAQScCxB4nZNzQwQQQAABBBBAAAGXAgRel9rcCwEEEEAAAQQQQMC5AIHXOTk3RAABBBBAAAEEEHApQOB1qc29EEAAAQQQQAABBJwLEHidk3NDBBBAAAEEEEAAAZcCBF6X2twLAQQSKtDhrtE64bgi6tf5toTe52BevNfgSUpJya1BPVsEzfChzwfTm3sjgMDhIUDgPTzGkV4gcMgIvPzaO5r8yGJ9+uVG7dq1Sycdf4z+deG5urtbs4S38ZEnlqpQgXyqcX25hN2rcoNu2vTdD7HrH1ukkC7/1/nqcectMv9/ol8E3kQLc30EEDgcBQi8h+Oo0icEDpLA2vc/UZOOqbqlViXVvL68cufOpS82bNLSl9do5MC21q3asWNncK1D4WUCb4UrSqtRncras3u3/rtxs1JHz1LxYqdpfGrnhDeRwJtwYm6AAAKHoQCB9zAcVLqEwMESGP3vJ/TU0pV6ft6If2zC5xs2afjEuXrz7fXBr+fLli6hXu0b6cTjigT1bu86VGeedpL++HObXlz1ts4969Tg6akJvqMHdYhde/fuParcoKua1q+qpvWq7Pfr/T179mjm40s0d8Fybfpui44uVEDVr7tC3ds0CK7x2+9/asRD8/T8ijXa9td2FT/7NHW/s4FKX1DsgO03gfemqleqXfObYmXGTU3T4/95SS8+MSr4b/ePna0NGzdr4pAusTLzFi7XtHnP6tk5Q4P/9tDMRUHfql17uWY89lzQlssvPl/39GgePKU2r7+279B9o2fpmeVvKCUll+pVr6Bvvt2iI49MOeCRBps+Haz5wn0RQAABVwIEXlfS3AcBDwQeXbBMQyfM1czRfVTqvLMy7fGWrT+rdvN+wbGDm6tdHZSZOHNR8CR43qS7lStnziDwrn7nIw3o2lQ1ry+nHTt36s23P1KnAWP1ctoYFcyfN6j3+tp1atltqF54fFQQiDOeZx3z8BMyxxx6tm2osmVKaOtPv+qDj75U4zqVg/pNO92vlNy51b7FTSpcqICWvPSmHpq5UIump+rkE4/NtP0ZA6853mDaVfTEY/XgPe1DBV5zr/o1K6pL6/ravmOHWnUfpovOP1t3ddp7BnnIuDl6ZvnrSu3TSiefcEwQkpe/ulZVK5Y9YOC16ZMHU5MuIoCA5wIEXs8nAN1HIDsFtm/fod6pU/Tci28EgdGEt3KXXKAbKl2uPEelBLeaMGOhXnn9Xc2Z0D92a1OvbLU7NX1U7+Dpqgm85vXwyJ6xMjt37VKFOp3VpXU91f1fUO4/dKq+3bxVU4Z3D8rtG3j/3LZd5Wu2U7c2DWIBd9++mkDdsvswvbpwnPLlPSr2o2adh6j8pSXVqnH1Awbe777fqpw5c2rP7j0y7SpV4kxNGtpdhQrufTIb7xPemY89p5fSxih3rpxBvbkLlwcBffHM+4MnzlfUaKe7uzZV7apXBj83T3yvrddVFcuXyTTw2vYpO+cA10IAAQQORQEC76E4KrQJgSQX2LzlJ73x9jq9++FnevaFN5Q3z1F6dGL/4Clq+76j9cLKtZn2cEjf1sGTXxN4i51ZVH06NE5XbvCoWfrsvxs17cHeMiH56jqd1Ldj4+C8cMbA++HHX6pe64FaNCNVZ59+8n73M8cIho5/NNN21Lnx6ligzFgg3RnePXu0+fsfNW5amnLkyKEZo/soR44j4g68y199S/MnDYzd4rkX39TA4dO0avEEffrFRtVqfpeefuQBnX7KCbEybXqN0HHHFM408Nr2KcmnG81HAAEEshQg8GZJRAEEEIgi8MOPv6hKw+5q2ai62jSpqbZ9HgyOEYy6d++v/zN7mcB7QfEz1PWO+ul+/PYHn+rW9vdp2fyRenfdZ+p932StWDAmCNQZA685ulD/jgMH3unzntWUOYuDJ7xhXpmd4V3/6QbVbTkgCOLm6MQD4x/Vl199m+4M75y0ZTJPdDOe4Z07cUC6wDtg2FS9/p+JscC7dO7wdMcrzFNscxY5s68ls+1TmP5TFgEEEEhGAQJvMo4abUYgiQTMB8euqdNJtapcqW5t6st8wOvRhcv03Jxhyp8vT6jAawpXbdRTDWpWlAm/R6bk1tD+bWLXCHOkwZz/bdHlAT0y7i6VKXlO3KL/FHgfeqCrrrrsQk2ZvVjLXnlL+4bZ1DGzZb6yLd7Aa440XF69rUbd014VypUO2mcsb2jcS5eWLpFp4LXtU9ydpyACCCCQpAIE3iQdOJqNwKEoMGnWU/rmuy265orSOuWk44JvHjDfTvD08tc0Y3RfXVzqHJkPrd3Uol9wZKFDizo6/tjC+vqb74Nvd+jZrmHwDQUHesJr+jx26pPBMYmN327R2MEdg4D59yvjh9ZGTXlcc9KeV692jYKQ+POvv+v99Z+rYe1rg/DYvMsDwXV6tWuoEsVO09Yffwm+OaFs6fOC79bN7HWgIw0bNn6nxbOGBO1/b/0XatT2Xs0e108Xnn+21rz7sdr3HaVCBfPHHXjNvc1ZYFPXnFE+umB+mSe4IyfPV+2qV2UaeG37dCjOJdqEAAIIZKcAgTc7NbkWAp4LmKeu5kNX5v+aYJs/b54g2N7e8MZ0wdR8ZdeDk+frtTUfatv2HTrp+CIqd0lJ9Wh7S/DU9p8CrzkqUO223ipydAG98MSo4FsdDhR4TQCcNu8ZzVv4QvDhtiKFC6jGdeViRyXM156NefjJ4NsZfmepHU8AAAMfSURBVNj6i44pUlClLzhHnVrWTXdudt9hzfiHJ8y5ZPONFJ1b3aziZ58aK2qOL0yf/2zwVWplSp2jEsVO16LnXg0VeM1TXnNueenLq1UgXx5dWfZC/fLb78qXN88Bv6XBpk+eT1u6jwACHggQeD0YZLqIAAIIIIAAAgj4LEDg9Xn06TsCCCCAAAIIIOCBAIHXg0GmiwgggAACCCCAgM8CBF6fR5++I4AAAggggAACHggQeD0YZLqIAAIIIIAAAgj4LEDg9Xn06TsCCCCAAAIIIOCBAIHXg0GmiwgggAACCCCAgM8CBF6fR5++I4AAAggggAACHggQeD0YZLqIAAIIIIAAAgj4LEDg9Xn06TsCCCCAAAIIIOCBAIHXg0GmiwgggAACCCCAgM8CBF6fR5++I4AAAggggAACHggQeD0YZLqIAAIIIIAAAgj4LEDg9Xn06TsCCCCAAAIIIOCBAIHXg0GmiwgggAACCCCAgM8CBF6fR5++I4AAAggggAACHggQeD0YZLqIAAIIIIAAAgj4LEDg9Xn06TsCCCCAAAIIIOCBAIHXg0GmiwgggAACCCCAgM8CBF6fR5++I4AAAggggAACHggQeD0YZLqIAAIIIIAAAgj4LEDg9Xn06TsCCCCAAAIIIOCBAIHXg0GmiwgggAACCCCAgM8CBF6fR5++I4AAAggggAACHggQeD0YZLqIAAIIIIAAAgj4LEDg9Xn06TsCCCCAAAIIIOCBAIHXg0GmiwgggAACCCCAgM8CBF6fR5++I4AAAggggAACHggQeD0YZLqIAAIIIIAAAgj4LEDg9Xn06TsCCCCAAAIIIOCBAIHXg0GmiwgggAACCCCAgM8CBF6fR5++I4AAAggggAACHggQeD0YZLqIAAIIIIAAAgj4LEDg9Xn06TsCCCCAAAIIIOCBAIHXg0GmiwgggAACCCCAgM8CBF6fR5++I4AAAggggAACHggQeD0YZLqIAAIIIIAAAgj4LEDg9Xn06TsCCCCAAAIIIOCBAIHXg0GmiwgggAACCCCAgM8CBF6fR5++I4AAAggggAACHgj8Hw1dDdYjkaQGAAAAAElFTkSuQmCC" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "internet_users = data[data[\"InternetService\"] != \"No\"]\n", + "no_internet_users = data[data[\"InternetService\"] == \"No\"]\n", + "\n", + "# Compute the number of users who churned and didn't churn for each group\n", + "internet_churn_count = internet_users[\"Churn\"].value_counts()\n", + "no_internet_churn_count = no_internet_users[\"Churn\"].value_counts()\n", + "\n", + "# Calculate percentages\n", + "no_internet_nochurn_perc = no_internet_churn_count[0] / (no_internet_churn_count[0] + no_internet_churn_count[1]) * 100\n", + "no_internet_churn_perc = no_internet_churn_count[1] / (no_internet_churn_count[0] + no_internet_churn_count[1]) * 100\n", + "internet_nochurn_perc = internet_churn_count[0] / (internet_churn_count[0] + internet_churn_count[1]) * 100\n", + "internet_churn_perc = internet_churn_count[1] / (internet_churn_count[0] + internet_churn_count[1]) * 100\n", + "\n", + "# Create a bar chart using Plotly\n", + "fig = go.Figure()\n", + "fig.add_trace(go.Bar(\n", + " x=[\"Internet Service\", \"No Internet Service\"],\n", + " y=[internet_nochurn_perc, no_internet_nochurn_perc],\n", + " name=\"No Churn\",\n", + " text=[f\"{internet_nochurn_perc:.2f}%\", f\"{no_internet_nochurn_perc:.2f}%\"], # Add data labels\n", + " textposition=\"inside\" # Set data label position inside the bars\n", + "))\n", + "fig.add_trace(go.Bar(\n", + " x=[\"Internet Service\", \"No Internet Service\"],\n", + " y=[internet_churn_perc, no_internet_churn_perc],\n", + " name=\"Churn\",\n", + " text=[f\"{internet_churn_perc:.2f}%\", f\"{no_internet_churn_perc:.2f}%\"], # Add data labels\n", + " textposition=\"inside\" # Set data label position inside the bars\n", + "))\n", + "\n", + "fig.update_layout(\n", + " xaxis=dict(title=\"Service Bundle\"),\n", + " yaxis=dict(title=\"Percentage of Users\"),\n", + " title=\"Churned and No Churn Users\",\n", + " barmode=\"stack\"\n", + ")\n", + "\n", + "fig.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It's very interesting to find, that users without internet service have very \n", + "low churn rates. It seems, that the internet service might be a problem in terms\n", + "of churn. \n", + "However, we must not jump to premature conclusions - as causality is not proven \n", + "here. (Users with internet service might in general be more tech-savvy and \n", + "therefore look for better alternatives more often).\n", + "\n", + "In real-world settings, the Data Scientist continues this exploratory analyses\n", + "for any of the features they deem worthy of further investigation. For the sake\n", + "of brevity, we'll skip this step here and continue with the model creation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Model traning\n", + "\n", + "We use Pycaret to train a model for us. Pycaret will automatically select the\n", + "best performing model class and tune the hyperparameters for us.\n", + "\n", + "1. Set up Pycaret. This step allows for automatic data preprocessing. In our \n", + " case we tell Pycaret:\n", + " - to ignore the customerID column (as it's the\n", + " user identifier, therefore different for each and every entry and does by \n", + " definition not contribute to whether a user chursn)\n", + " - target the Churn column, as that's the feature we want to predict\n", + " - automatically fix the imbalance in our dataset - as we found, that we have\n", + " more non-churned users than churned users" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 DescriptionValue
0Session id6247
1TargetChurn
2Target typeBinary
3Target mappingNo: 0, Yes: 1
4Original data shape(7043, 21)
5Transformed data shape(9357, 41)
6Transformed train set shape(7244, 41)
7Transformed test set shape(2113, 41)
8Ignore features1
9Ordinal features5
10Numeric features3
11Categorical features16
12PreprocessTrue
13Imputation typesimple
14Numeric imputationmean
15Categorical imputationmode
16Maximum one-hot encoding25
17Encoding methodNone
18Fix imbalanceTrue
19Fix imbalance methodSMOTE
20Fold GeneratorStratifiedKFold
21Fold Number10
22CPU Jobs-1
23Use GPUFalse
24Log ExperimentMlflowLogger
25Experiment Nameclf-default-name
26USI0073
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pycaret.classification import *\n", + "\n", + "s = setup(\n", + " data,\n", + " target=\"Churn\",\n", + " ignore_features=[\"customerID\"],\n", + " log_experiment=True,\n", + " fix_imbalance=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using setup, Pycaret automatically creates a training and test dataset, \n", + "transforms categorical data to numerical ones (required for most machine \n", + "learning models), and uses \n", + "[SMOTE](https://imbalanced-learn.org/stable/references/generated/imblearn.over_sampling.SMOTE.html)\n", + "- an oversampling technique - to fix the imbalance in our dataset. These steps \n", + "would require tens of lines of code and quite intricate knowledge of the\n", + "modelling process. Pycaret does all this for us.\n", + "\n", + "The next step is already to train and evaluate models. In this case, we train \n", + "and validate 15 (!) models - all with a single line of code.\n", + "\n", + "(The \"lightgbm\" is excluded, as the training for this type of model takes quite\n", + "long. For production scenarios, it might be worth to include it.)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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", + "
Initiated. . . . . . . . . . . . . . . . . .12:17:24
Status. . . . . . . . . . . . . . . . . .Selecting Estimator
Estimator. . . . . . . . . . . . . . . . . .Logistic Regression
\n", + "
" + ], + "text/plain": [ + " \n", + " \n", + "Initiated . . . . . . . . . . . . . . . . . . 12:17:24\n", + "Status . . . . . . . . . . . . . . . . . . Selecting Estimator\n", + "Estimator . . . . . . . . . . . . . . . . . . Logistic Regression" + ] + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 ModelAccuracyAUCRecallPrec.F1KappaMCCTT (Sec)
lrLogistic Regression0.78110.82740.35030.66570.45700.33710.36500.2320
nbNaive Bayes0.77260.80890.32280.64200.41530.29940.33090.1460
qdaQuadratic Discriminant Analysis0.74480.79250.11460.57370.18710.11500.16600.0320
rfRandom Forest Classifier0.76570.78340.36260.60060.44250.30910.32870.0880
knnK Neighbors Classifier0.69270.76870.75770.45380.56720.35190.37990.1740
catboostCatBoost Classifier0.74060.75660.08490.57770.14690.08520.14093.8830
etExtra Trees Classifier0.74080.75020.11620.55100.18930.10930.15620.0810
xgboostExtreme Gradient Boosting0.74500.73350.32870.52480.38340.24440.26090.0660
ldaLinear Discriminant Analysis0.73940.71080.07950.56190.13850.07850.13170.0350
gbcGradient Boosting Classifier0.70650.70960.41270.48180.40330.22600.24550.1320
adaAda Boost Classifier0.57670.69740.71940.37200.47950.19900.22430.0670
dtDecision Tree Classifier0.62130.57030.45750.37910.37340.13120.14380.0330
dummyDummy Classifier0.73470.50000.00000.00000.00000.00000.00000.0320
svmSVM - Linear Kernel0.71830.00000.58230.50840.48310.32520.36790.0380
ridgeRidge Classifier0.73940.00000.07950.56190.13850.07850.13170.0300
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# \"sort\" defines, which metric is used to rate the models. In this case, the\n", + "# \"AUC\" metric is used which is a good metric to start with for classification\n", + "# taks. The \"n_select\" parameter defines how many models are selected.\n", + "# The \"exclude\" parameter defines which models are excluded from the\n", + "# comparison. The \"lightgbm\" model is excluded, as the training for this\n", + "# type of model takes quite long.\n", + "# For production scenarios, it might be worth to include it.\n", + "best_models = compare_models(sort=\"AUC\", exclude=[\"lightgbm\"], n_select=3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pycaret automatically outputs the performance metrics for each benchmarked\n", + "model.\n", + "Please note that the found numeric values for each of the metrics are not\n", + "fully deterministic - meaning they can change from run to run. Pycaret uses \n", + "cross-validation to evaluate the models. This means that the training and test \n", + "set are split into different chunks for each iteration. \n", + "This leads to slightly different performance metrics. Cross-validation is\n", + "generally a good idea, as it helps to avoid overfitting.\n", + "\n", + "> **NOTE:** This is yet another aspect of training machine learning models \n", + "> which is often overlooked by beginners - which is automatically taken care of \n", + "> by Pycaret.\n", + "\n", + "Judging from the output generating, the Logistic Regression model seems to be\n", + "the best performing model architecture - by quite a margin.\n", + "However we are not done yet - another important step is to tune the\n", + "hyperparameters of the winning models to further improve their performance.\n", + "By setting `n_select=3` in the above benchmarking call, we told Pycaret to\n", + "select the 8 best performing models from the benchmarking run. We can now use\n", + "all 3 of them to tune their hyperparameters. It's quite common, that the model\n", + "ranking shifts after hyperparameter tuning.\n", + "\n", + "Again, hyperparameter tuning is just a single line of code.\n", + "\n", + "> **NOTE:** The `tune_model` function provides a parameter `fold` which defines\n", + "> how many folds to use for cross-validation. The default is 10. This means\n", + "> that the training set is split into 10 chunks and each chunk is used as a\n", + "> test set once. This is a good default value. However, it can be increased\n", + "> to 15 or 20 to further improve the model performance. However, this comes\n", + "> at the cost of increased training time. See [this article](https://cran.r-project.org/web/packages/cvms/vignettes/picking_the_number_of_folds_for_cross-validation.html#:~:text=When%20performing%20cross%2Dvalidation%2C%20it,common%20to%20use%2010%20folds.)\n", + "> for a primer on how folds impact model performance. (Do not overthink this\n", + "> this aspect. More is better, but with diminishing returns. 10 is good\n", + "> for almost anything.)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.76470.82400.16790.75860.27500.19770.2790
10.74440.83240.10690.60870.18180.11130.1718
20.75660.82940.16790.66670.26830.18070.2431
30.76880.81200.20610.72970.32140.23150.2992
40.74650.82830.16030.58330.25150.15470.2018
50.76060.82830.18320.68570.28920.19950.2628
60.75860.78270.16030.70000.26090.17960.2503
70.75050.77450.16030.61760.25450.16290.2168
80.73630.81690.10770.50000.17720.09240.1316
90.76670.87010.16920.75860.27670.19980.2808
Mean0.75540.81990.15900.66090.25570.17100.2337
Std0.01010.02540.02900.07910.04250.04030.0503
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 10 folds for each of 10 candidates, totalling 100 fits\n", + "Original model was better than the tuned model, hence it will be returned. NOTE: The display metrics are for the tuned model (not the original one).\n" + ] + }, + { + "data": { + "text/html": [], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.78900.81350.32820.72880.45260.34440.3866
10.76270.82730.23660.64580.34640.23770.2826
20.76670.82510.26720.64810.37840.26420.3036
30.76880.78420.36640.60760.45710.32150.3381
40.77690.81360.37400.63640.47120.34160.3610
50.76880.82320.25950.66670.37360.26400.3083
60.76470.77510.19080.71430.30120.21300.2807
70.74850.76840.31300.54670.39810.25370.2694
80.78300.80550.38460.64940.48310.35690.3766
90.79920.85550.53850.64220.58580.45460.4577
Mean0.77280.80910.32590.64860.42470.30520.3365
Std0.01380.02530.09320.04830.07760.06870.0564
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 10 folds for each of 10 candidates, totalling 100 fits\n", + "Original model was better than the tuned model, hence it will be returned. NOTE: The display metrics are for the tuned model (not the original one).\n" + ] + }, + { + "data": { + "text/html": [], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.73830.82730.74050.50520.60060.41620.4330
10.78900.84810.70990.58490.64140.49390.4986
20.78700.84160.74050.57740.64880.49930.5073
30.72820.81810.71760.49210.58390.39230.4077
40.76270.82830.72520.53980.61890.45190.4623
50.76470.85400.79390.53890.64200.47610.4960
60.73830.81170.68700.50560.58250.39830.4083
70.71600.78360.71760.47720.57320.37310.3905
80.72410.83410.76150.48530.59280.39930.4225
90.77890.86680.81540.55500.66040.50520.5257
Mean0.75270.83140.74090.52610.61440.44060.4552
Std0.02570.02240.03740.03650.03020.04780.0464
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Fitting 10 folds for each of 10 candidates, totalling 100 fits\n" + ] + } + ], + "source": [ + "# Run `tune_model` for each model in `best_models`\n", + "tuned_models = [tune_model(model) for model in best_models]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pycaret outputs the cross-validation performance metrics for each model.\n", + "You might notice that for some of the models the metrics for the tuned model\n", + "are worse than for the untuned model. This is quite common - oftentimes the \n", + "default model parameters - especially for rather simple model architectures - \n", + "are already quite good. However, there are no indicators for this - so running\n", + "the hyperparameter tuning is always a good idea." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We could call it a day, however modern ML approaches have one more trick up\n", + "their sleeves: combining multiple models.\n", + "\n", + "There are multiple approaches, the two most common ones are:\n", + "- **ensemble learning**: in general, \n", + " combines multiple models of the same architecture\n", + "- **blending models**: in general, combines multiple models of different \n", + " architectures\n", + "\n", + "> **NOTE:** As for hyperparameter tuning, combining models does not always lead\n", + "> to better results. But it's worth a try." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ensemble learning\n", + "\n", + "[Ensemble learning](https://towardsdatascience.com/ensemble-methods-bagging-boosting-and-stacking-c9214a10a205) \n", + "is an approach in machine learning that involves training multiple models, often\n", + "referred to as \"weak learners\". These models are then aggregated to improve \n", + "performance. The core idea is that by properly combining these weaker models, \n", + "one can achieve more precise and stable outcomes.\n", + "Ensemble\n", + "\n", + "There are two common approaches to ensemble learning: [bagging](https://pycaret.gitbook.io/docs/get-started/functions/optimize#method-bagging) \n", + "and [boosting](https://pycaret.gitbook.io/docs/get-started/functions/optimize#method-boosting).\n", + "\n", + "Both methods are implemented in Pycaret and can be used - once again - with \n", + "a single line of code." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.79510.83200.35110.74190.47670.36900.4089
10.76670.83760.26720.64810.37840.26420.3036
20.76670.83720.27480.64290.38500.26860.3056
30.79510.82340.41220.69230.51670.39720.4187
40.77690.82950.37400.63640.47120.34160.3610
50.77890.83790.39690.63410.48830.35660.3726
60.77690.79070.33590.65670.44440.32260.3510
70.76470.78210.33590.60270.43140.29780.3181
80.80320.82980.41540.72000.52680.41370.4387
90.79920.87280.44620.68240.53950.41820.4337
Mean0.78240.82730.36100.66580.46580.34500.3712
Std0.01380.02410.05650.04060.05310.05350.0493
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.78900.81450.37400.69010.48510.36690.3941
10.76880.82260.25950.66670.37360.26400.3083
20.76060.82440.27480.61020.37890.25620.2875
30.77280.78460.39690.61180.48150.34440.3576
40.77080.81430.39690.60470.47930.34030.3527
50.76270.82170.22140.65910.33140.22830.2788
60.75460.77630.12210.72730.20920.14370.2258
70.75460.76580.21370.60870.31640.20680.2491
80.78090.80690.43080.62220.50910.37400.3845
90.79920.85710.46920.67030.55200.42780.4391
Mean0.77140.80880.31600.64710.41170.29520.3278
Std0.01390.02550.10720.03980.10150.08430.0652
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.74040.82790.71760.50810.59490.41200.4253
10.78300.84770.70990.57410.63480.48290.4884
20.78700.84190.71760.58020.64160.49250.4981
30.73430.81710.72520.50000.59190.40460.4200
40.75860.82780.74810.53260.62220.45220.4662
50.76060.85190.79390.53330.63800.46940.4901
60.73230.81440.68700.49720.57690.38830.3992
70.72010.78110.74810.48280.58680.38970.4111
80.73020.83380.74620.49240.59330.40390.4234
90.78090.86780.81540.55790.66250.50860.5287
Mean0.75270.83110.74090.52590.61430.44040.4551
Std0.02340.02270.03700.03350.02750.04340.0423
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "bagged = [ensemble_model(i, method=\"Bagging\") for i in tuned_models]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Boosting works similar to Bagging (at least when using Pycaret), however \n", + "models that do not provide probability estimates cannot be used for Boosting." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/html": [], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.74850.84610.74810.51850.61250.43520.4513
10.77890.85340.73280.56470.63790.48260.4911
20.78090.85490.74810.56650.64470.49070.5006
30.71810.81860.74050.48020.58260.38400.4045
40.75460.83500.77860.52580.62770.45470.4742
50.75660.85570.82440.52680.64290.47150.4987
60.72820.81570.72520.49220.58640.39480.4113
70.71400.79780.76340.47620.58650.38530.4105
80.75250.85270.80770.51980.63250.45890.4843
90.77480.87050.83080.54820.66060.50250.5268
Mean0.75070.84000.77000.52190.62140.44600.4653
Std0.02300.02150.03660.03050.02650.04200.0413
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "text/html": [], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.73430.57790.00000.00000.00000.00000.0000
10.73020.59640.01530.33330.02920.00610.0170
20.72210.56300.00760.12500.0144-0.0167-0.0409
30.57000.78080.92370.37460.53300.24910.3398
40.73630.59930.01530.66670.02990.01820.0710
50.72820.60330.01530.28570.02900.00210.0054
60.73020.56250.00760.25000.0148-0.0009-0.0032
70.73830.56850.02290.75000.04440.02920.0992
80.73230.61560.01540.33330.02940.00630.0175
90.73230.63760.01540.33330.02940.00630.0175
Mean0.71540.61050.10380.34520.07540.03000.0523
Std0.04870.06130.27330.21180.15300.07390.1027
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Can't apply boosting.\n" + ] + } + ], + "source": [ + "def try_ensemble_model(model):\n", + " try:\n", + " print(type(model))\n", + " # Attempt to ensemble the model with Boosting method\n", + " return ensemble_model(model, method=\"Boosting\")\n", + " except Exception as e:\n", + " print(\"Can't apply boosting.\")\n", + " return None \n", + "\n", + "boosted = [try_ensemble_model(i) for i in tuned_models]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Blending models\n", + "\n", + "Blending models is a technique that combines multiple models of different\n", + "architectures. The idea is to combine the strengths of different models to\n", + "achieve better performance. In a nutshell, a meta-learner model is trained\n", + "which takes the predictions of the base models as input and outputs the final\n", + "prediction. It basically combines the outputs of the base models to a final\n", + "prediction.\n", + "\n", + "In the example below tuned models as base models.\n", + "An even better approach would be to hand-pick the best performing models from \n", + "all of our experiments above - but for the sake of brevity we'll stick with\n", + "the first 5 of our tuned models." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.77690.82920.52670.58970.55650.40800.4092
10.79110.84410.38170.69440.49260.37480.4014
20.77890.83850.41980.62500.50230.36710.3791
30.77690.81910.44270.61050.51330.37330.3814
40.77480.82610.48850.59260.53560.38880.3919
50.79110.84830.50380.63460.56170.42690.4318
60.75860.80800.29770.59090.39590.26510.2894
70.75660.78330.47330.54870.50820.34760.3493
80.79110.82900.53850.61950.57610.43840.4403
90.81740.87730.61540.66670.64000.51800.5187
Mean0.78130.83030.46880.61730.52820.39080.3993
Std0.01670.02370.08440.03950.06070.06230.0570
\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "blend = blend_models(estimator_list = tuned_models)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Wrap up: Getting the best model\n", + "We've come a long way. We've trained 15 models, tuned their hyperparameters,\n", + "combined them using ensemble learning and blending models. The avid reader\n", + "might remark, that that was quite a lot of work. However, one has to keep in\n", + "mind, that first - all of this was done with just a view lines of code and \n", + "more importantly - all of this is the same for almost any classification\n", + "machine learning task - making it highly reusable.\n", + "\n", + "The missing step is to identify the best model from all of our experiments.\n", + "While we could manually look at all the mean performance metrics and pick the \n", + "best one, Pycaret provides a function to do this for us." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "best_model = automl(optimize = 'AUC')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pycaret also provides methods to investigate the model in more detail. The \n", + "main tool you want to use is `evaluate_model`. This function provides a number\n", + "of plots that help to understand the model performance - from AUC curves to\n", + "confusion matrices, learning curves and model dimensions.\n", + "\n", + "> **NOTE:** These next features are optimized for jupyter notebooks." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b91ff79476254bb2b70ae7242164d0dc", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "interactive(children=(ToggleButtons(description='Plot Type:', icons=('',), options=(('Pipeline Plot', 'pipelin…" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "evaluate_model(best_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Finalizing\n", + "\n", + "Up until now we have trained and evaluated our model on the training data - \n", + "whereas our input dataset was split in training and test data.\n", + "This means, our test data were not used for training the model (which is a good \n", + "thing, as we need a test set vor validation). \n", + "\n", + "However, now that we know which model works best, we should retrain it on the \n", + "whole dataset to get as many training data as possible. This can in some cases \n", + "improve model quality. For that, Pycaret provides the `finalize_model` method." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "final_model = finalize_model(best_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Saving the model\n", + "\n", + "To use this newly built model for predicting new data, we can export it using\n", + "either the `deploy_model` or `save_model` methods. For more details on them\n", + "see the [Pycaret documentation](https://pycaret.gitbook.io/docs/get-started/functions/deploy)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "if not os.path.exists(\"model\"):\n", + " os.makedirs(\"model\")\n", + "# Save the model to disk\n", + "_ = save_model(final_model, \"model/classification_model\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Predicting on unseen data\n", + "\n", + "To use the model for prediction, we can use the `predict_model` method. This\n", + "method takes the model and the data to predict as input and outputs the\n", + "predictions for these new data." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [], + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
genderSeniorCitizenPartnerDependentstenurePhoneServiceMultipleLinesInternetServiceOnlineSecurityOnlineBackup...TechSupportStreamingTVStreamingMoviesContractPaperlessBillingPaymentMethodMonthlyChargesTotalChargesprediction_labelprediction_score
4962Female0YesYes72YesYesFiber opticYesYes...YesYesYesTwo yearYesCredit card (automatic)116.4000028543.25No0.5494
2110Female0YesNo56YesYesFiber opticNoNo...YesYesYesTwo yearNoBank transfer (automatic)103.1999975744.35No0.5249
513Female0NoNo53YesNoFiber opticNoYes...NoYesYesOne yearYesMailed check100.3000035200.8No0.5132
957Female0NoNo42YesNoDSLNoNo...YesNoYesTwo yearNoCredit card (automatic)66.5000002762.75No0.5409
503Male0NoNo1YesYesDSLNoNo...NoNoNoMonth-to-monthYesCredit card (automatic)49.79999949.8Yes0.5266
..................................................................
4622Male0NoNo45YesNoNoNo internet serviceNo internet service...No internet serviceNo internet serviceNo internet serviceOne yearNoBank transfer (automatic)18.850000867.3No0.5728
422Male1NoNo1YesNoFiber opticNoNo...NoYesNoMonth-to-monthYesElectronic check79.09999879.1Yes0.5557
6256Female1YesNo12YesNoDSLYesNo...YesYesYesOne yearYesElectronic check79.199997943.85Yes0.5049
5348Male0NoNo25YesNoFiber opticYesNo...YesYesYesMonth-to-monthYesElectronic check105.5000002686.05Yes0.5191
2629Female0YesYes72YesNoNoNo internet serviceNo internet service...No internet serviceNo internet serviceNo internet serviceTwo yearNoBank transfer (automatic)20.1000001460.85No0.6083
\n", + "

2113 rows × 21 columns

\n", + "
" + ], + "text/plain": [ + " gender SeniorCitizen Partner Dependents tenure PhoneService \\\n", + "4962 Female 0 Yes Yes 72 Yes \n", + "2110 Female 0 Yes No 56 Yes \n", + "513 Female 0 No No 53 Yes \n", + "957 Female 0 No No 42 Yes \n", + "503 Male 0 No No 1 Yes \n", + "... ... ... ... ... ... ... \n", + "4622 Male 0 No No 45 Yes \n", + "422 Male 1 No No 1 Yes \n", + "6256 Female 1 Yes No 12 Yes \n", + "5348 Male 0 No No 25 Yes \n", + "2629 Female 0 Yes Yes 72 Yes \n", + "\n", + " MultipleLines InternetService OnlineSecurity OnlineBackup \\\n", + "4962 Yes Fiber optic Yes Yes \n", + "2110 Yes Fiber optic No No \n", + "513 No Fiber optic No Yes \n", + "957 No DSL No No \n", + "503 Yes DSL No No \n", + "... ... ... ... ... \n", + "4622 No No No internet service No internet service \n", + "422 No Fiber optic No No \n", + "6256 No DSL Yes No \n", + "5348 No Fiber optic Yes No \n", + "2629 No No No internet service No internet service \n", + "\n", + " ... TechSupport StreamingTV StreamingMovies \\\n", + "4962 ... Yes Yes Yes \n", + "2110 ... Yes Yes Yes \n", + "513 ... No Yes Yes \n", + "957 ... Yes No Yes \n", + "503 ... No No No \n", + "... ... ... ... ... \n", + "4622 ... No internet service No internet service No internet service \n", + "422 ... No Yes No \n", + "6256 ... Yes Yes Yes \n", + "5348 ... Yes Yes Yes \n", + "2629 ... No internet service No internet service No internet service \n", + "\n", + " Contract PaperlessBilling PaymentMethod \\\n", + "4962 Two year Yes Credit card (automatic) \n", + "2110 Two year No Bank transfer (automatic) \n", + "513 One year Yes Mailed check \n", + "957 Two year No Credit card (automatic) \n", + "503 Month-to-month Yes Credit card (automatic) \n", + "... ... ... ... \n", + "4622 One year No Bank transfer (automatic) \n", + "422 Month-to-month Yes Electronic check \n", + "6256 One year Yes Electronic check \n", + "5348 Month-to-month Yes Electronic check \n", + "2629 Two year No Bank transfer (automatic) \n", + "\n", + " MonthlyCharges TotalCharges prediction_label prediction_score \n", + "4962 116.400002 8543.25 No 0.5494 \n", + "2110 103.199997 5744.35 No 0.5249 \n", + "513 100.300003 5200.8 No 0.5132 \n", + "957 66.500000 2762.75 No 0.5409 \n", + "503 49.799999 49.8 Yes 0.5266 \n", + "... ... ... ... ... \n", + "4622 18.850000 867.3 No 0.5728 \n", + "422 79.099998 79.1 Yes 0.5557 \n", + "6256 79.199997 943.85 Yes 0.5049 \n", + "5348 105.500000 2686.05 Yes 0.5191 \n", + "2629 20.100000 1460.85 No 0.6083 \n", + "\n", + "[2113 rows x 21 columns]" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "predict_model(final_model, s.X_test)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Experiment tracking with MLflow and Pycaret\n", + "\n", + "MLflow is an open source platform for managing the end-to-end machine learning\n", + "lifecycle. It is the defacto standard for experiment tracking in the machine\n", + "learning community. It provides a simple interface to track experiments,\n", + "parameters, metrics and artifacts. It also provides a simple UI to browse\n", + "experiments and registered models.\n", + "\n", + "MLflow needs a storage backend to store all these information. CrateDB offers\n", + "exactly that - support for MLflow. Therefore we can use CrateDB as our storage\n", + "engine for the full Machine Learning lifecycle - from storing the raw data to\n", + "storing the experiment and model metadata.\n", + "\n", + "Last but not least, Pycaret also provides first-class support for MLflow. \n", + "This means that all the experiments we've run above are automatically tracked \n", + "in MLflow. This is especially useful for production scenarios, where we want \n", + "to keep track of all the experiments we've run and the models we've created.\n", + "As we've seen we run many experiments - them automatically being tracked is\n", + "a huge time saver.\n", + "\n", + "### Configuring MLflow to use CrateDB\n", + "\n", + "Before we can use CrateDB as our MLflow backend, we need to set the \n", + "`MLFLOW_TRACKING_URI` environment variable to our crate database.\n", + "(We already did that at the very beginning our this demo)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "os.environ[\n", + " \"MLFLOW_TRACKING_URI\"\n", + "] = f\"crate://{os.environ['CRATE_USER']}:{os.environ['CRATE_PASSWORD']}@{os.environ['CRATE_HOST']}:4200?ssl=true&schema=mlflow\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now if we run the above experiments again, they are tracked in CrateDB using\n", + "MLflow.\n", + "\n", + "### Registering trained models\n", + "\n", + "Tracking experiments is one thing, but we also want to keep track of the models\n", + "we've created. For that, we can use the `log_model` method. This method\n", + "takes the trained model and a name as input and registers the model in MLflow \n", + "and subsequently in CrateDB.\n", + "\n", + "Make sure to first run `save_model` as described above." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from mlflow.sklearn import log_model\n", + "\n", + "_ = log_model(\n", + " sk_model=final_model,\n", + " artifact_path=\"model/classification_model\",\n", + " registered_model_name=f\"classification-model\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Summary\n", + "\n", + "In this demonstration example we have seen how to use CrateDB and Pycaret to\n", + "train a machine learning model. We've seen how to use Pycaret to train and\n", + "evaluate multiple models, how to tune their hyperparameters and how to combine\n", + "them using ensemble learning and blending models. We've alos seen how to use \n", + "MLflow to track our experiments and how to register our trained models.\n", + "\n", + "All these steps used to be a lot of work and required a good amount of know-how\n", + "about the entire machine learning ecosystem. One needs to know the available\n", + "model architectures, state-of-the-art benchmarking and tuning techniques and\n", + "how to combine models. This is a lot of work and requires a lot of experience.\n", + "By using Pycaret, all of this is reduced to a few lines of code. This makes\n", + "machine learning applicable for a much broader audience.\n", + "\n", + "While this demo explained some of the details around the model training process,\n", + "these are the main lines required to train a classification model.\n", + "\n", + "```python\n", + "from pycaret.classification import *\n", + "s = setup(data, target = 'Churn', ignore_features = ['customerID'], fix_imbalance=True)\n", + "best_models = compare_models(sort=\"AUC\", exclude=[\"lightgbm\"], n_select=3)\n", + "tuned_models = [tune_model(model) for model in best_models]\n", + "blend = blend_models(estimator_list = tuned_models)\n", + "bagged = [ensemble_model(i, method=\"Bagging\") for i in tuned_models]\n", + "best_model = automl(optimize = 'AUC')\n", + "final_model = finalize_model(best_model)\n", + "```\n", + "\n", + "This demo also showed how CrateDB can be utilized as the main storage engine for\n", + "end to end machine learning workflows. From storing the raw data to storing the\n", + "experiment and model metadata, CrateDB can be used as a single piece of data\n", + "infrastructure for the entire model lifecycle." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "crate", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/topic/machine-learning/classification-automl/automl_classification_with_pycaret.md b/topic/machine-learning/classification-automl/automl_classification_with_pycaret.md new file mode 100644 index 00000000..ec9f8b15 --- /dev/null +++ b/topic/machine-learning/classification-automl/automl_classification_with_pycaret.md @@ -0,0 +1,2237 @@ +# Create a classification model with CrateDB, Pycaret and MLflow + +This notebook guides you through the process of creating a classification +machine learning model with CrateDB and Pycaret. The exciting part: we're +using automatic machine learning model selection, benchmarking and +hyperparameter tuning - commonly known as AutoML. + +## CrateDB + +CrateDB is a distributed SQL database that makes it simple to store and analyze +huge amounts of time series data in real-time. It provides a robust SQL +interface and a number of anlaytics features that are predestined for machine +learning tasks. + +Two additional features stand out: + +1. CrateDB allows to store both relational data like strings, floats and + timestamps as well as complex object types. This makes it easy to store + the raw data required for machine learning model creation as well as the + metadata that is often required to make sense of the data. + +1. CrateDB offes first-class time partitioning support. This allows to store + tremendous amounts of data in a single table and still be able to query + it in a performant way. This is especially useful for time series data + like sensor data, user tracking data or log data. + +## Pycaret + +Pycaret is a Python library that makes it easy to create and train machine +learning models in python. The outstanding feature of Pycaret is its AutoML +capabilities. + +Pycaret is a high-level interface on top of popular machine learning +frameworks. Among them are scikit-learn, xgboost, ray, lightgbm and many more. + +Pycaret provides a simple low-code interface to utilize these libraries without +needing to know the details of the underlying model architectures and +parameters. + +The general concept of Pycaret - and for the matter of fact for AutoML in +general - is rather simple: One takes the raw data, splits it into a training +and a test set and then trains a number of different models on the training +set. The models are then evaluated on the test set and the best performing +model is selected. This process gets repeated for tuning the hyperparameters +of the best models. Again, this process is highly empirical. The parameters are +changed, the model is retrained and evaluated again. This process is repeated +until the best performing parameters are found. + +Modern algorithms for executing all these experiments are - among other - +GridSearch, RandomSearch and BayesianSearch. For a quick introduction into +these methods, see +[this article](https://medium.com/analytics-vidhya/comparison-of-hyperparameter-tuning-algorithms-grid-search-random-search-bayesian-optimization-5326aaef1bd1). + +In the past, all these try-and-error experiments had to be done manually - +which is a tedious and time-consuming task. Pycaret automates this process +and provides a simple interface to execute all these experiments in a +straightforward way. This notebook shows how. + +## The dataset + +The dataset used to demonstrate the use of Pycaret and CrateDB for training +machine learning models is a churn dataset of a telecom provider. + +It includes various attributes relating to customer demographics, services +subscribed to, billing information, and churn status. + +- `customerID`: A unique identifier for each customer. +- `gender`: The customer's gender (e.g., Male, Female). +- `SeniorCitizen`: Indicates whether the customer is a senior citizen (1) or + not (0). +- `Partner`: Indicates whether the customer has a partner (Yes) or not (No). +- `Dependents`: Indicates whether the customer has dependents (Yes) or not + (No). +- `tenure`: The total amount of time that the customer has been with the + company. +- `PhoneService`: Indicates whether the customer has a phone service (Yes) + or not (No). +- `MultipleLines`: Indicates whether the customer has multiple lines (Yes), + no multiple lines (No), or no phone service. +- `InternetService`: The type of internet service the customer has (DSL, + Fiber optic, or None). +- `OnlineSecurity`: Indicates whether the customer subscribes to an additional + online security service (Yes, No, or No internet service). +- `DeviceProtection`: Whether the customer has a device protection plan (Yes, + No, or No internet service). +- `TechSupport`: Indicates whether the customer has tech support services (Yes, + No, or No internet service). +- `StreamingTV`: Indicates if the customer has streaming TV service (Yes, No, + or No internet service). +- `StreamingMovies`: Indicates if the customer has streaming movies service + (Yes, No, or No internet service). +- `Contract`: The type of contract the customer has (Month-to-month, One year, + Two years). +- `PaperlessBilling`: Indicates whether the customer has paperless billing (Yes) + or not (No). +- `PaymentMethod`: The customer's payment method (Electronic check, + Mailed check, Credit card (automatic), etc.). +- `MonthlyCharges`: The amount charged to the customer each month. +- `TotalCharges`: The total amount charged to the customer over the time they + have been with the company. +- `Churn`: Indicates whether the customer has churned (Yes) or not (No). + +## Getting started + +First, install the required dependencies. + +```bash +pip install -r requirements.txt +``` + +> **Note:** As of time of this writing, Pycaret requires Python 3.8, 3.9 or +> 3.10. + +Secondly, we need a CrateDB instance to store and serve the data. The easiest +way to get started is to use the free CrateDB cloud offering. You can sign up +for a free account at https://console.cratedb.cloud. + +[Deploy a cluster](https://cratedb.com/docs/cloud/en/latest/tutorials/deploy/stripe.html#deploy-cluster) +and we're ready to go. + +Finally, create a file `.env` with the following content: + +```env +CRATE_HOST= # set this to localhost if you're running crate locally +CRATE_USER= # set this to crate if you're running crate locally +CRATE_PASSWORD= # set this to "" if you're running crate locally +CRATE_SSL=true # set this to false if you're running crate locally +``` + +You can find your cratedb credentials in your +[CrateDB Cloud Console](https://cratedb.com/docs/cloud/en/latest/reference/overview.html#cluster). + +### Creating demo data + +For convenience, this notebook comes with an accompanying csv dataset which we +can quickly import in our database. Upload the csv file to your CrateDB cloud +cluster, as described [here](https://cratedb.com/docs/cloud/en/latest/reference/overview.html#import). +To follow this notebook, choose `pycaret_churn` for your database name. + +This will automatically create a new crate table and import the data. + +### Alternative data import using code + +If you prefer to use code to import your data, please execute the following lines which read the CSV +file into a pandas data frame, automatically creates the table in CrateDB and loads the data. + +```python +import os +import dotenv +import sqlalchemy as sa +import pandas as pd +if os.path.exists(".env"): + dotenv.load_dotenv(".env", override=True) + +dburi = f"crate://{os.environ['CRATE_USER']}:{os.environ['CRATE_PASSWORD']}@{os.environ['CRATE_HOST']}:4200?ssl={os.environ['CRATE_SSL']}" +engine = sa.create_engine(dburi, echo=True) +df = pd.read_csv("https://github.com/crate/cratedb-datasets/raw/main/machine-learning/automl/churn-dataset.csv") + +with engine.connect() as conn: + df.to_sql("pycaret_churn", conn, index=False, chunksize=1000, if_exists="replace") +``` + +## Model creation + +Now that our data and environment is set up, we can start creating our model. + +The first step is to import the required libraries and to load our data from +the database. + +```python +import os +import dotenv +import sqlalchemy as sa +import pandas as pd +import plotly +import plotly.express as plotly_express +import plotly.graph_objects as go +import mlflow_cratedb # We need this import to use the CrateDB MLflow store + +if os.path.exists(".env"): + dotenv.load_dotenv(".env", override=True) + +dburi = f"crate://{os.environ['CRATE_USER']}:{os.environ['CRATE_PASSWORD']}@{os.environ['CRATE_HOST']}:4200?ssl={os.environ['CRATE_SSL']}" +engine = sa.create_engine(dburi, echo=True) + +# Insert the data into CrateDB +with engine.connect() as conn: + with conn.execute(sa.text("SELECT * FROM pycaret_churn")) as cursor: + data = pd.DataFrame(cursor.fetchall(), columns=cursor.keys()) + +# We set the MLFLOW_TRACKING_URI to our CrateDB instance. We'll see later why +os.environ[ + "MLFLOW_TRACKING_URI" +] = f"{dburi}&schema=mlflow" +``` + +Next, let's have a quick glance on how our dataset looks like. +As we already know from chapter [The dataset](#the-dataset), the feature +to predict is `Churn` . Let's have a look at the distribution of this feature. + +> **Note:** knowing the distribution of the target feature is important to know +> whether the dataset is imbalanced - meaning that it has much more samples of +> one class than of the other. This is important to know because it can lead to +> biased models - so we can accommodate for this in our model creation process. + +![png](automl_classification_with_pycaret_files/automl_classification_with_pycaret_5_0.png) + +The plot reveals that our dataset is indeed skewed towards non-churned users. +Let's keep this in mind for later. + +With that out of the way, we can dig deeper into the dataset to get a better +understanding of the data we're dealing with. These next steps are not strictly +necessary for creating a model, but they help us to understand the data and +to better verify our models performance. + +As a general guideline, a Data Scientist is tasked with investigating the +influence of features on the target variable. Let's start with tenure - as it +might be reasonable to argue that a clients tenue might influence the churn. + +![png](automl_classification_with_pycaret_files/automl_classification_with_pycaret_7_0.png) + +It's quite obvious, that most people seem to churn with month-to-month +contracts. Also, the longer the tenure, the less likely it is that a customer +churns (generally speaking). +Another interesting angle might be too look at whether users with specific +services - like internet service - are more likely to churn. + +![png](automl_classification_with_pycaret_files/automl_classification_with_pycaret_9_0.png) + +It's very interesting to find, that users without internet service have very +low churn rates. It seems, that the internet service might be a problem in terms +of churn. +However, we must not jump to premature conclusions - as causality is not proven +here. (Users with internet service might in general be more tech-savvy and +therefore look for better alternatives more often). + +In real-world settings, the Data Scientist continues this exploratory analyses +for any of the features they deem worthy of further investigation. For the sake +of brevity, we'll skip this step here and continue with the model creation. + +# Model traning + +We use Pycaret to train a model for us. Pycaret will automatically select the +best performing model class and tune the hyperparameters for us. + +1. Set up Pycaret. This step allows for automatic data preprocessing. In our + case we tell Pycaret: + - to ignore the customerID column (as it's the + user identifier, therefore different for each and every entry and does by + definition not contribute to whether a user chursn) + - target the Churn column, as that's the feature we want to predict + - automatically fix the imbalance in our dataset - as we found, that we have + more non-churned users than churned users + +```python +from pycaret.classification import * + +s = setup( + data, + target="Churn", + ignore_features=["customerID"], + log_experiment=True, + fix_imbalance=True, +) +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 DescriptionValue
0Session id6247
1TargetChurn
2Target typeBinary
3Target mappingNo: 0, Yes: 1
4Original data shape(7043, 21)
5Transformed data shape(9357, 41)
6Transformed train set shape(7244, 41)
7Transformed test set shape(2113, 41)
8Ignore features1
9Ordinal features5
10Numeric features3
11Categorical features16
12PreprocessTrue
13Imputation typesimple
14Numeric imputationmean
15Categorical imputationmode
16Maximum one-hot encoding25
17Encoding methodNone
18Fix imbalanceTrue
19Fix imbalance methodSMOTE
20Fold GeneratorStratifiedKFold
21Fold Number10
22CPU Jobs-1
23Use GPUFalse
24Log ExperimentMlflowLogger
25Experiment Nameclf-default-name
26USI0073
+ +Using setup, Pycaret automatically creates a training and test dataset, +transforms categorical data to numerical ones (required for most machine +learning models), and uses +[SMOTE](https://imbalanced-learn.org/stable/references/generated/imblearn.over_sampling.SMOTE.html) + +- an oversampling technique - to fix the imbalance in our dataset. These steps + would require tens of lines of code and quite intricate knowledge of the + modelling process. Pycaret does all this for us. + +The next step is already to train and evaluate models. In this case, we train +and validate 15 (!) models - all with a single line of code. + +(The "lightgbm" is excluded, as the training for this type of model takes quite +long. For production scenarios, it might be worth to include it.) + +```python +# "sort" defines, which metric is used to rate the models. In this case, the +# "AUC" metric is used which is a good metric to start with for classification +# taks. The "n_select" parameter defines how many models are selected. +# The "exclude" parameter defines which models are excluded from the +# comparison. The "lightgbm" model is excluded, as the training for this +# type of model takes quite long. +# For production scenarios, it might be worth to include it. +best_models = compare_models(sort="AUC", exclude=["lightgbm"], n_select=3) + +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 ModelAccuracyAUCRecallPrec.F1KappaMCCTT (Sec)
lrLogistic Regression0.78110.82740.35030.66570.45700.33710.36500.2320
nbNaive Bayes0.77260.80890.32280.64200.41530.29940.33090.1460
qdaQuadratic Discriminant Analysis0.74480.79250.11460.57370.18710.11500.16600.0320
rfRandom Forest Classifier0.76570.78340.36260.60060.44250.30910.32870.0880
knnK Neighbors Classifier0.69270.76870.75770.45380.56720.35190.37990.1740
catboostCatBoost Classifier0.74060.75660.08490.57770.14690.08520.14093.8830
etExtra Trees Classifier0.74080.75020.11620.55100.18930.10930.15620.0810
xgboostExtreme Gradient Boosting0.74500.73350.32870.52480.38340.24440.26090.0660
ldaLinear Discriminant Analysis0.73940.71080.07950.56190.13850.07850.13170.0350
gbcGradient Boosting Classifier0.70650.70960.41270.48180.40330.22600.24550.1320
adaAda Boost Classifier0.57670.69740.71940.37200.47950.19900.22430.0670
dtDecision Tree Classifier0.62130.57030.45750.37910.37340.13120.14380.0330
dummyDummy Classifier0.73470.50000.00000.00000.00000.00000.00000.0320
svmSVM - Linear Kernel0.71830.00000.58230.50840.48310.32520.36790.0380
ridgeRidge Classifier0.73940.00000.07950.56190.13850.07850.13170.0300
+ +Pycaret automatically outputs the performance metrics for each benchmarked +model. +Please note that the found numeric values for each of the metrics are not +fully deterministic - meaning they can change from run to run. Pycaret uses +cross-validation to evaluate the models. This means that the training and test +set are split into different chunks for each iteration. +This leads to slightly different performance metrics. Cross-validation is +generally a good idea, as it helps to avoid overfitting. + +> **NOTE:** This is yet another aspect of training machine learning models +> which is often overlooked by beginners - which is automatically taken care of +> by Pycaret. + +Judging from the output generating, the Logistic Regression model seems to be +the best performing model architecture - by quite a margin. +However we are not done yet - another important step is to tune the +hyperparameters of the winning models to further improve their performance. +By setting `n_select=3` in the above benchmarking call, we told Pycaret to +select the 8 best performing models from the benchmarking run. We can now use +all 3 of them to tune their hyperparameters. It's quite common, that the model +ranking shifts after hyperparameter tuning. + +Again, hyperparameter tuning is just a single line of code. + +> **NOTE:** The `tune_model` function provides a parameter `fold` which defines +> how many folds to use for cross-validation. The default is 10. This means +> that the training set is split into 10 chunks and each chunk is used as a +> test set once. This is a good default value. However, it can be increased +> to 15 or 20 to further improve the model performance. However, this comes +> at the cost of increased training time. See [this article](https://cran.r-project.org/web/packages/cvms/vignettes/picking_the_number_of_folds_for_cross-validation.html#:~:text=When%20performing%20cross%2Dvalidation%2C%20it,common%20to%20use%2010%20folds.) +> for a primer on how folds impact model performance. (Do not overthink this +> this aspect. More is better, but with diminishing returns. 10 is good +> for almost anything.) + +```python +# Run `tune_model` for each model in `best_models` +tuned_models = [tune_model(model) for model in best_models] +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.76470.82400.16790.75860.27500.19770.2790
10.74440.83240.10690.60870.18180.11130.1718
20.75660.82940.16790.66670.26830.18070.2431
30.76880.81200.20610.72970.32140.23150.2992
40.74650.82830.16030.58330.25150.15470.2018
50.76060.82830.18320.68570.28920.19950.2628
60.75860.78270.16030.70000.26090.17960.2503
70.75050.77450.16030.61760.25450.16290.2168
80.73630.81690.10770.50000.17720.09240.1316
90.76670.87010.16920.75860.27670.19980.2808
Mean0.75540.81990.15900.66090.25570.17100.2337
Std0.01010.02540.02900.07910.04250.04030.0503
+ + Fitting 10 folds for each of 10 candidates, totalling 100 fits + Original model was better than the tuned model, hence it will be returned. NOTE: The display metrics are for the tuned model (not the original one). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.78900.81350.32820.72880.45260.34440.3866
10.76270.82730.23660.64580.34640.23770.2826
20.76670.82510.26720.64810.37840.26420.3036
30.76880.78420.36640.60760.45710.32150.3381
40.77690.81360.37400.63640.47120.34160.3610
50.76880.82320.25950.66670.37360.26400.3083
60.76470.77510.19080.71430.30120.21300.2807
70.74850.76840.31300.54670.39810.25370.2694
80.78300.80550.38460.64940.48310.35690.3766
90.79920.85550.53850.64220.58580.45460.4577
Mean0.77280.80910.32590.64860.42470.30520.3365
Std0.01380.02530.09320.04830.07760.06870.0564
+ + Fitting 10 folds for each of 10 candidates, totalling 100 fits + Original model was better than the tuned model, hence it will be returned. NOTE: The display metrics are for the tuned model (not the original one). + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.73830.82730.74050.50520.60060.41620.4330
10.78900.84810.70990.58490.64140.49390.4986
20.78700.84160.74050.57740.64880.49930.5073
30.72820.81810.71760.49210.58390.39230.4077
40.76270.82830.72520.53980.61890.45190.4623
50.76470.85400.79390.53890.64200.47610.4960
60.73830.81170.68700.50560.58250.39830.4083
70.71600.78360.71760.47720.57320.37310.3905
80.72410.83410.76150.48530.59280.39930.4225
90.77890.86680.81540.55500.66040.50520.5257
Mean0.75270.83140.74090.52610.61440.44060.4552
Std0.02570.02240.03740.03650.03020.04780.0464
+ + Fitting 10 folds for each of 10 candidates, totalling 100 fits + +Pycaret outputs the cross-validation performance metrics for each model. +You might notice that for some of the models the metrics for the tuned model +are worse than for the untuned model. This is quite common - oftentimes the +default model parameters - especially for rather simple model architectures - +are already quite good. However, there are no indicators for this - so running +the hyperparameter tuning is always a good idea. + +We could call it a day, however modern ML approaches have one more trick up +their sleeves: combining multiple models. + +There are multiple approaches, the two most common ones are: + +- **ensemble learning**: in general, + combines multiple models of the same architecture +- **blending models**: in general, combines multiple models of different + architectures + +> **NOTE:** As for hyperparameter tuning, combining models does not always lead +> to better results. But it's worth a try. + +### Ensemble learning + +[Ensemble learning](https://towardsdatascience.com/ensemble-methods-bagging-boosting-and-stacking-c9214a10a205) +is an approach in machine learning that involves training multiple models, often +referred to as "weak learners". These models are then aggregated to improve +performance. The core idea is that by properly combining these weaker models, +one can achieve more precise and stable outcomes. +Ensemble + +There are two common approaches to ensemble learning: [bagging](https://pycaret.gitbook.io/docs/get-started/functions/optimize#method-bagging) +and [boosting](https://pycaret.gitbook.io/docs/get-started/functions/optimize#method-boosting). + +Both methods are implemented in Pycaret and can be used - once again - with +a single line of code. + +```python +bagged = [ensemble_model(i, method="Bagging") for i in tuned_models] +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.79510.83200.35110.74190.47670.36900.4089
10.76670.83760.26720.64810.37840.26420.3036
20.76670.83720.27480.64290.38500.26860.3056
30.79510.82340.41220.69230.51670.39720.4187
40.77690.82950.37400.63640.47120.34160.3610
50.77890.83790.39690.63410.48830.35660.3726
60.77690.79070.33590.65670.44440.32260.3510
70.76470.78210.33590.60270.43140.29780.3181
80.80320.82980.41540.72000.52680.41370.4387
90.79920.87280.44620.68240.53950.41820.4337
Mean0.78240.82730.36100.66580.46580.34500.3712
Std0.01380.02410.05650.04060.05310.05350.0493
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.78900.81450.37400.69010.48510.36690.3941
10.76880.82260.25950.66670.37360.26400.3083
20.76060.82440.27480.61020.37890.25620.2875
30.77280.78460.39690.61180.48150.34440.3576
40.77080.81430.39690.60470.47930.34030.3527
50.76270.82170.22140.65910.33140.22830.2788
60.75460.77630.12210.72730.20920.14370.2258
70.75460.76580.21370.60870.31640.20680.2491
80.78090.80690.43080.62220.50910.37400.3845
90.79920.85710.46920.67030.55200.42780.4391
Mean0.77140.80880.31600.64710.41170.29520.3278
Std0.01390.02550.10720.03980.10150.08430.0652
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.74040.82790.71760.50810.59490.41200.4253
10.78300.84770.70990.57410.63480.48290.4884
20.78700.84190.71760.58020.64160.49250.4981
30.73430.81710.72520.50000.59190.40460.4200
40.75860.82780.74810.53260.62220.45220.4662
50.76060.85190.79390.53330.63800.46940.4901
60.73230.81440.68700.49720.57690.38830.3992
70.72010.78110.74810.48280.58680.38970.4111
80.73020.83380.74620.49240.59330.40390.4234
90.78090.86780.81540.55790.66250.50860.5287
Mean0.75270.83110.74090.52590.61430.44040.4551
Std0.02340.02270.03700.03350.02750.04340.0423
+ +Boosting works similar to Bagging (at least when using Pycaret), however +models that do not provide probability estimates cannot be used for Boosting. + +```python +def try_ensemble_model(model): + try: + print(type(model)) + # Attempt to ensemble the model with Boosting method + return ensemble_model(model, method="Boosting") + except Exception as e: + print("Can't apply boosting.") + return None + +boosted = [try_ensemble_model(i) for i in tuned_models] +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.74850.84610.74810.51850.61250.43520.4513
10.77890.85340.73280.56470.63790.48260.4911
20.78090.85490.74810.56650.64470.49070.5006
30.71810.81860.74050.48020.58260.38400.4045
40.75460.83500.77860.52580.62770.45470.4742
50.75660.85570.82440.52680.64290.47150.4987
60.72820.81570.72520.49220.58640.39480.4113
70.71400.79780.76340.47620.58650.38530.4105
80.75250.85270.80770.51980.63250.45890.4843
90.77480.87050.83080.54820.66060.50250.5268
Mean0.75070.84000.77000.52190.62140.44600.4653
Std0.02300.02150.03660.03050.02650.04200.0413
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.73430.57790.00000.00000.00000.00000.0000
10.73020.59640.01530.33330.02920.00610.0170
20.72210.56300.00760.12500.0144-0.0167-0.0409
30.57000.78080.92370.37460.53300.24910.3398
40.73630.59930.01530.66670.02990.01820.0710
50.72820.60330.01530.28570.02900.00210.0054
60.73020.56250.00760.25000.0148-0.0009-0.0032
70.73830.56850.02290.75000.04440.02920.0992
80.73230.61560.01540.33330.02940.00630.0175
90.73230.63760.01540.33330.02940.00630.0175
Mean0.71540.61050.10380.34520.07540.03000.0523
Std0.04870.06130.27330.21180.15300.07390.1027
+ +### Blending models + +Blending models is a technique that combines multiple models of different +architectures. The idea is to combine the strengths of different models to +achieve better performance. In a nutshell, a meta-learner model is trained +which takes the predictions of the base models as input and outputs the final +prediction. It basically combines the outputs of the base models to a final +prediction. + +In the example below tuned models as base models. +An even better approach would be to hand-pick the best performing models from +all of our experiments above - but for the sake of brevity we'll stick with +the first 5 of our tuned models. + +```python +blend = blend_models(estimator_list = tuned_models) +``` + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
 AccuracyAUCRecallPrec.F1KappaMCC
Fold       
00.77690.82920.52670.58970.55650.40800.4092
10.79110.84410.38170.69440.49260.37480.4014
20.77890.83850.41980.62500.50230.36710.3791
30.77690.81910.44270.61050.51330.37330.3814
40.77480.82610.48850.59260.53560.38880.3919
50.79110.84830.50380.63460.56170.42690.4318
60.75860.80800.29770.59090.39590.26510.2894
70.75660.78330.47330.54870.50820.34760.3493
80.79110.82900.53850.61950.57610.43840.4403
90.81740.87730.61540.66670.64000.51800.5187
Mean0.78130.83030.46880.61730.52820.39080.3993
Std0.01670.02370.08440.03950.06070.06230.0570
+ +## Wrap up: Getting the best model + +We've come a long way. We've trained 15 models, tuned their hyperparameters, +combined them using ensemble learning and blending models. The avid reader +might remark, that that was quite a lot of work. However, one has to keep in +mind, that first - all of this was done with just a view lines of code and +more importantly - all of this is the same for almost any classification +machine learning task - making it highly reusable. + +The missing step is to identify the best model from all of our experiments. +While we could manually look at all the mean performance metrics and pick the +best one, Pycaret provides a function to do this for us. + +```python +best_model = automl(optimize = 'AUC') +``` + +Pycaret also provides methods to investigate the model in more detail. The +main tool you want to use is `evaluate_model`. This function provides a number +of plots that help to understand the model performance - from AUC curves to +confusion matrices, learning curves and model dimensions. + +> **NOTE:** These next features are optimized for jupyter notebooks. + +```python +evaluate_model(best_model) +``` + +## Finalizing + +Up until now we have trained and evaluated our model on the training data - +whereas our input dataset was split in training and test data. +This means, our test data were not used for training the model (which is a good +thing, as we need a test set vor validation). + +However, now that we know which model works best, we should retrain it on the +whole dataset to get as many training data as possible. This can in some cases +improve model quality. For that, Pycaret provides the `finalize_model` method. + +```python +final_model = finalize_model(best_model) +``` + +## Saving the model + +To use this newly built model for predicting new data, we can export it using +either the `deploy_model` or `save_model` methods. For more details on them +see the [Pycaret documentation](https://pycaret.gitbook.io/docs/get-started/functions/deploy). + +```python +if not os.path.exists("model"): + os.makedirs("model") +# Save the model to disk +_ = save_model(final_model, "model/classification_model") +``` + + Transformation Pipeline and Model Successfully Saved + +## Predicting on unseen data + +To use the model for prediction, we can use the `predict_model` method. This +method takes the model and the data to predict as input and outputs the +predictions for these new data. + +```python +predict_model(final_model, s.X_test) +``` + +## Experiment tracking with MLflow and Pycaret + +MLflow is an open source platform for managing the end-to-end machine learning +lifecycle. It is the defacto standard for experiment tracking in the machine +learning community. It provides a simple interface to track experiments, +parameters, metrics and artifacts. It also provides a simple UI to browse +experiments and registered models. + +MLflow needs a storage backend to store all these information. CrateDB offers +exactly that - support for MLflow. Therefore we can use CrateDB as our storage +engine for the full Machine Learning lifecycle - from storing the raw data to +storing the experiment and model metadata. + +Last but not least, Pycaret also provides first-class support for MLflow. +This means that all the experiments we've run above are automatically tracked +in MLflow. This is especially useful for production scenarios, where we want +to keep track of all the experiments we've run and the models we've created. +As we've seen we run many experiments - them automatically being tracked is +a huge time saver. + +### Configuring MLflow to use CrateDB + +Before we can use CrateDB as our MLflow backend, we need to set the +`MLFLOW_TRACKING_URI` environment variable to our crate database. +(We already did that at the very beginning our this demo). + +```python +os.environ[ + "MLFLOW_TRACKING_URI" +] = f"crate://{os.environ['CRATE_USER']}:{os.environ['CRATE_PASSWORD']}@{os.environ['CRATE_HOST']}:4200?ssl=true&schema=mlflow" +``` + +Now if we run the above experiments again, they are tracked in CrateDB using +MLflow. + +### Registering trained models + +Tracking experiments is one thing, but we also want to keep track of the models +we've created. For that, we can use the `log_model` method. This method +takes the trained model and a name as input and registers the model in MLflow +and subsequently in CrateDB. + +Make sure to first run `save_model` as described above. + +```python +from mlflow.sklearn import log_model + +_ = log_model( + sk_model=final_model, + artifact_path="model/classification_model", + registered_model_name=f"classification-model", +) +``` + +# Summary + +In this demonstration example we have seen how to use CrateDB and Pycaret to +train a machine learning model. We've seen how to use Pycaret to train and +evaluate multiple models, how to tune their hyperparameters and how to combine +them using ensemble learning and blending models. We've alos seen how to use +MLflow to track our experiments and how to register our trained models. + +All these steps used to be a lot of work and required a good amount of know-how +about the entire machine learning ecosystem. One needs to know the available +model architectures, state-of-the-art benchmarking and tuning techniques and +how to combine models. This is a lot of work and requires a lot of experience. +By using Pycaret, all of this is reduced to a few lines of code. This makes +machine learning applicable for a much broader audience. + +While this demo explained some of the details around the model training process, +these are the main lines required to train a classification model. + +```python +from pycaret.classification import * +s = setup(data, target = 'Churn', ignore_features = ['customerID'], fix_imbalance=True) +best_models = compare_models(sort="AUC", exclude=["lightgbm"], n_select=3) +tuned_models = [tune_model(model) for model in best_models] +blend = blend_models(estimator_list = tuned_models) +bagged = [ensemble_model(i, method="Bagging") for i in tuned_models] +best_model = automl(optimize = 'AUC') +final_model = finalize_model(best_model) +``` + +This demo also showed how CrateDB can be utilized as the main storage engine for +end to end machine learning workflows. From storing the raw data to storing the +experiment and model metadata, CrateDB can be used as a single piece of data +infrastructure for the entire model lifecycle. diff --git a/topic/machine-learning/classification-automl/automl_classification_with_pycaret.py b/topic/machine-learning/classification-automl/automl_classification_with_pycaret.py new file mode 100644 index 00000000..a2ecb96c --- /dev/null +++ b/topic/machine-learning/classification-automl/automl_classification_with_pycaret.py @@ -0,0 +1,75 @@ +import os +import dotenv +import sqlalchemy as sa +import pandas as pd +import mlflow_cratedb # We need this import to use the CrateDB MLflow store +from pycaret.classification import * +from mlflow.sklearn import log_model + +if os.path.exists(".env"): + dotenv.load_dotenv(".env", override=True) + + +def fetch_data(): + dburi = f"crate://{os.environ['CRATE_USER']}:{os.environ['CRATE_PASSWORD']}@{os.environ['CRATE_HOST']}:4200?ssl={os.environ['CRATE_SSL']}" + engine = sa.create_engine(dburi, echo=True) + + with engine.connect() as conn: + with conn.execute(sa.text("SELECT * FROM pycaret_churn")) as cursor: + data = pd.DataFrame(cursor.fetchall(), columns=cursor.keys()) + os.environ["MLFLOW_TRACKING_URI"] = f"{dburi}&schema=mlflow" + + +def run_experiment(data): + s = setup( + data, + target="Churn", + ignore_features=["customerID"], + log_experiment=True, + fix_imbalance=True, + ) + + best_models = compare_models(sort="AUC", exclude=["lightgbm"], n_select=3) + tuned_models = [tune_model(model) for model in best_models] + _ = [ensemble_model(i, method="Bagging") for i in tuned_models] + + def try_ensemble_model(model): + try: + print(type(model)) + # Attempt to ensemble the model with Boosting method + return ensemble_model(model, method="Boosting") + except Exception as e: + print("Can't apply boosting.") + return None + + _ = [try_ensemble_model(i) for i in tuned_models] + _ = blend_models(estimator_list=tuned_models) + best_model = automl(optimize="AUC") + + evaluate_model(best_model) + final_model = finalize_model(best_model) + + if not os.path.exists("model"): + os.makedirs("model") + + # Save the model to disk + _ = save_model(final_model, "model/classification_model") + predict_model(final_model, s.X_test) + + _ = log_model( + sk_model=best_model, + artifact_path="model/classification_model", + registered_model_name=f"classification-model", + ) + + +def main(): + """ + Provision dataset, and run experiment. + """ + df = fetch_data() + run_experiment(df) + + +if __name__ == "__main__": + main() diff --git a/topic/machine-learning/classification-automl/automl_classification_with_pycaret_files/automl_classification_with_pycaret_5_0.png b/topic/machine-learning/classification-automl/automl_classification_with_pycaret_files/automl_classification_with_pycaret_5_0.png new file mode 100644 index 0000000000000000000000000000000000000000..5660b610114b9a1e7a9df2c5341cd891fbb06001 GIT binary patch literal 16947 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
    xQ`<$(!d+s{-(Z}==U2m~ij6IX#w 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¥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%0DLK-~6WtLK0f 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 literal 0 HcmV?d00001 diff --git a/topic/machine-learning/classification-automl/automl_classification_with_pycaret_files/automl_classification_with_pycaret_9_0.png b/topic/machine-learning/classification-automl/automl_classification_with_pycaret_files/automl_classification_with_pycaret_9_0.png new file mode 100644 index 0000000000000000000000000000000000000000..521a8d014cbdb2242cdf2dae0e21eee426318540 GIT binary patch literal 19001 zcmdSBV{m0b*D!kGWa0@Ywr$(CIk9cq$xLk9ww;M>dty8J&OGl^b#LAK_pAHW{c~!c z?%qqi(5t)Gj!=*jhyRB44FCYZOG=0+0RW(#00786G$^n|f!iV+0FVMmiU_K>ubnSV zTTMCO0Iub4F-uunM8B4Dxi!#~D zX#YuTsfHSVYk9uOZ$C6yI{^{VB}blS{h^NA;&9VOxu*?T>;u8r|pRz;Sn41*SPz_t*2#Sl=)M zsDEhWM)rW2-G&FaF@plwgkHPJ{!~G4sF0B)C^j~=j`!8BQ%<+HNiN9q;|DngIrqR0 zBr&;YOrRpeH?cl}SQdad>Q?8QMmBE5#!mn!A;?zptuZ9Y_4U~JeZAh!dq|SL>)Sz5 z&)0j1G{^|a%y4E$N!5&tRIpP(yZ^wgRWr_gR1IisDZNgU(P!jEuj1?aQ%)kAe9QG1 zldJrAb^7(|1r!k8&HQq+q;!^Wl)sh^u@u>)E^H&JW^=twbDBCN5*n+F*V`pAm|m^P z)6GIW-dnCW7{)J)j|R1`*9UAm>1Z!kTpqB@J`jXjuMstXl`SNZfOjf4B0KqKU+BJB z_3%+Mhz-lb1fc!;Hs%eEqc^2y`iV~o z@QG5jd0{jlrv6evvMKnZY0Dn#w7%AC`wkv7TCX^)%&&H~6D&>XAZqBVHBJSOf>H-X zM|RVC#X`8RpqGSwJinl5j4-TU325G&sa}#A@!fUtfHz5Tr5qsZ$wCMjoWsYSG9mC^@}<02mH~0RdL0#~WdfYkWr6 zSmu_}jx(Cbb?*%BHoKE70#s4hh^aOs7!&#i+4fuq>v3aj@F?QbIXXEb3jV{8ctpWA%-h=5lFHQ7D zh2z8eVHEc`2DM9C5UD^qeYg0~`uIA@579y1i>?ML9pC`==ZT-SPWi;*>bj*Z#o#x` zZd|i#bt`r?t5FVhUz4KdK%Cgh>A}H#uMMaDq1gg~%QT~k`R!>dtB2~f%y%ZlJ2~WJ zzONXfTOkJ1(7?dJJ<-5RBKQRPlATD&B56!QOzai za13%U9uzUyR0&dEpGdYM`;cGvi(QHmV3Vv>jk#)xdAYf{?uNPC1%0DPyN@Zud6B^Y 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 Zz3bDb)qC^wgMbw!gQu&X%Q~loCIBI>f~o)j literal 0 HcmV?d00001 diff --git a/topic/machine-learning/classification-automl/requirements.txt b/topic/machine-learning/classification-automl/requirements.txt new file mode 100644 index 00000000..02b07112 --- /dev/null +++ b/topic/machine-learning/classification-automl/requirements.txt @@ -0,0 +1,7 @@ +crate[sqlalchemy] +mlflow-cratedb==2.7.1 +plotly<5.19 +pycaret[analysis,models,tuner,parallel,test]==3.1.0 +python-dotenv<2 +tqdm<5 +werkzeug==2.2.3