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": "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" + }, + "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 00000000..5660b610 Binary files /dev/null and b/topic/machine-learning/classification-automl/automl_classification_with_pycaret_files/automl_classification_with_pycaret_5_0.png differ diff --git a/topic/machine-learning/classification-automl/automl_classification_with_pycaret_files/automl_classification_with_pycaret_7_0.png b/topic/machine-learning/classification-automl/automl_classification_with_pycaret_files/automl_classification_with_pycaret_7_0.png new file mode 100644 index 00000000..69fc770d Binary files /dev/null and b/topic/machine-learning/classification-automl/automl_classification_with_pycaret_files/automl_classification_with_pycaret_7_0.png differ 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 00000000..521a8d01 Binary files /dev/null and b/topic/machine-learning/classification-automl/automl_classification_with_pycaret_files/automl_classification_with_pycaret_9_0.png differ 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