Quickstart

Search…
🚀
Quickstart
Quick start guide to PyCaret
PyCaret 3.0-rc is now available. pip install --pre pycaret to try it. Check out this example Notebook.
Introduction
Select your use case:
​Classification​
​Regression​
​Clustering​
​Anomaly Detection​
​Natural Language Processing​
​Association Rules Mining​
​Time Series (beta)​
Classification
PyCaret’s Classification Module is a supervised machine learning module that is used for classifying elements into groups. The goal is to predict the categorical class labels which are discrete and unordered. Some common use cases include predicting customer default (Yes or No), predicting customer churn (customer will leave or stay), the disease found (positive or negative). This module can be used for binary or multiclass problems. It provides several pre-processing features that prepare the data for modeling through the setup function. It has over 18 ready-to-use algorithms and several plots to analyze the performance of trained models. 
Setup
This function initializes the training environment and creates the transformation pipeline. Setup function must be called before executing any other function. It takes two mandatory parameters: data and target. All the other parameters are optional.
from pycaret.datasets import get_data
data = get_data('diabetes')
from pycaret.classification import *
s = setup(data, target = 'Class variable')
When the setup is executed, PyCaret's inference algorithm will automatically infer the data types for all features based on certain properties. The data type should be inferred correctly but this is not always the case. To handle this, PyCaret displays a prompt, asking for data types confirmation, once you execute the setup. You can press enter if all data types are correct or type quit to exit the setup.
Ensuring that the data types are correct is really important in PyCaret as it automatically performs multiple type-specific preprocessing tasks which are imperative for machine learning models.
Alternatively, you can also use numeric_features and categorical_features parameters in the setup to pre-define the data types.
Output truncated for display
Compare Models
This function trains and evaluates the performance of all the estimators available in the model library using cross-validation. The output of this function is a scoring grid with average cross-validated scores. Metrics evaluated during CV can be accessed using the get_metrics function. Custom metrics can be added or removed using add_metric and remove_metric function.
best = compare_models()
print(best)
Analyze Model
This function analyzes the performance of a trained model on the test set. It may require re-training the model in certain cases.
evaluate_model(best)
evaluate_model can only be used in Notebook since it uses ipywidget . You can also use the plot_model function to generate plots individually.
plot_model(best, plot = 'auc')
plot_model(best, plot = 'confusion_matrix')
Predictions
This function predicts the Label and the Score (probability of predicted class) columns using a trained model. When data is None, it predicts label and score on the test set (created during the setup function).
predict_model(best)
The evaluation metrics are calculated on the test set. The second output is the pd.DataFrame with predictions on the test set (see the last two columns). To generate labels on the unseen (new) dataset, simply pass the dataset in the predict_model function
predictions = predict_model(best, data=data)
predictions.head()
Score means the probability of the predicted class (NOT the positive class). If Label is 0 and Score is 0.90, it means 90% probability of class 0. If you want to see the probability of both the classes, simply pass raw_score=True in the predict_model function.
predictions = predict_model(best, data=data, raw_score=True)
predictions.head()
Save the model
save_model(best, 'my_best_pipeline')
To load the model back in environment:
loaded_model = load_model('my_best_pipeline')
print(loaded_model)
Regression
PyCaret’s Regression Module is a supervised machine learning module that is used for estimating the relationships between a dependent variable (often called the ‘outcome variable’, or ‘target’) and one or more independent variables (often called ‘features’, ‘predictors’, or ‘covariates’). The objective of regression is to predict continuous values such as predicting sales amount, predicting quantity, predicting temperature, etc. It provides several pre-processing features that prepare the data for modeling through the setup function. It has over 25 ready-to-use algorithms and several plots to analyze the performance of trained models. 
Setup
This function initializes the training environment and creates the transformation pipeline. Setup function must be called before executing any other function. It takes two mandatory parameters: data and target. All the other parameters are optional.
from pycaret.datasets import get_data
data = get_data('insurance')
from pycaret.regression import *
s = setup(data, target = 'charges')
When the setup is executed, PyCaret's inference algorithm will automatically infer the data types for all features based on certain properties. The data type should be inferred correctly but this is not always the case. To handle this, PyCaret displays a prompt, asking for data types confirmation, once you execute the setup. You can press enter if all data types are correct or type quit to exit the setup.
Ensuring that the data types are correct is really important in PyCaret as it automatically performs multiple type-specific preprocessing tasks which are imperative for machine learning models.
Alternatively, you can also use numeric_features and categorical_features parameters in the setup to pre-define the data types.
Output truncated for display
Compare Models
This function trains and evaluates the performance of all the estimators available in the model library using cross-validation. The output of this function is a scoring grid with average cross-validated scores. Metrics evaluated during CV can be accessed using the get_metrics function. Custom metrics can be added or removed using add_metric and remove_metric function.
best = compare_models()
print(best)
Analyze Model
This function analyzes the performance of a trained model on the test set. It may require re-training the model in certain cases.
evaluate_model(best)
evaluate_model can only be used in Notebook since it uses ipywidget . You can also use the plot_model function to generate plots individually.
plot_model(best, plot = 'residuals')
plot_model(best, plot = 'feature')
Predictions
This function predicts Label using the trained model. When data is None, it predicts label and score on the test set (created during the setup function).
predict_model(best)
The evaluation metrics are calculated on the test set. The second output is the pd.DataFrame with predictions on the test set (see the last two columns). To generate labels on the unseen (new) dataset, simply pass the dataset in the predict_model function.
predictions = predict_model(best, data=data)
predictions.head()
Save the model
save_model(best, 'my_best_pipeline')
To load the model back in the environment:
loaded_model = load_model('my_best_pipeline')
print(loaded_model)
Clustering
PyCaret’s Clustering Module is an unsupervised machine learning module that performs the task of grouping a set of objects in such a way that objects in the same group (also known as a cluster) are more similar to each other than to those in other groups. It provides several pre-processing features that prepare the data for modeling through the setup function. It has over 10 ready-to-use algorithms and several plots to analyze the performance of trained models. 
Setup
This function initializes the training environment and creates the transformation pipeline. Setup function must be called before executing any other function. It takes one mandatory parameter: data. All the other parameters are optional.
from pycaret.datasets import get_data
data = get_data('jewellery')
from pycaret.clustering import *
s = setup(data, normalize = True)
When the setup is executed, PyCaret's inference algorithm will automatically infer the data types for all features based on certain properties. The data type should be inferred correctly but this is not always the case. To handle this, PyCaret displays a prompt, asking for data types confirmation, once you execute the setup. You can press enter if all data types are correct or type quit to exit the setup.
Ensuring that the data types are correct is really important in PyCaret as it automatically performs multiple type-specific preprocessing tasks which are imperative for machine learning models.
Alternatively, you can also use numeric_features and categorical_features parameters in the setup to pre-define the data types.
Output truncated for display
Create Model
This function trains and evaluates the performance of a given model. Metrics evaluated can be accessed using the get_metrics function. Custom metrics can be added or removed using the add_metric and remove_metric function. All the available models can be accessed using the models function.
kmeans = create_model('kmeans')
print(kmeans)
Analyze Model
This function analyzes the performance of a trained model.
evaluate_model(kmeans)
evaluate_model can only be used in Notebook since it uses ipywidget . You can also use the plot_model function to generate plots individually.
plot_model(kmeans, plot = 'elbow')
plot_model(kmeans, plot = 'silhouette')
Assign Model
This function assigns cluster labels to the training data, given a trained model.
result = assign_model(kmeans)
result.head()
Predictions
This function generates cluster labels using a trained model on the new/unseen dataset.
predictions = predict_model(kmeans, data = data)
predictions.head()
Save the model
save_model(kmeans, 'kmeans_pipeline')
To load the model back in the environment:
loaded_model = load_model('kmeans_pipeline')
print(loaded_model)
Anomaly Detection
PyCaret’s Anomaly Detection Module is an unsupervised machine learning module that is used for identifying rare items, events, or observations that raise suspicions by differing significantly from the majority of the data. Typically, the anomalous items will translate to some kind of problems such as bank fraud, a structural defect, medical problems, or errors. It provides several pre-processing features that prepare the data for modeling through the setup function. It has over 10 ready-to-use algorithms and several plots to analyze the performance of trained models. 
Setup
This function initializes the training environment and creates the transformation pipeline. The setup function must be called before executing any other function. It takes one mandatory parameter only: data. All the other parameters are optional.
from pycaret.datasets import get_data
data = get_data('anomaly')
from pycaret.anomaly import *
s = setup(data)
When the setup is executed, PyCaret's inference algorithm will automatically infer the data types for all features based on certain properties. The data type should be inferred correctly but this is not always the case. To handle this, PyCaret displays a prompt, asking for data types confirmation, once you execute the setup. You can press enter if all data types are correct or type quit to exit the setup.
Ensuring that the data types are correct is really important in PyCaret as it automatically performs multiple type-specific preprocessing tasks which are imperative for machine learning models.
Alternatively, you can also use numeric_features and categorical_features parameters in the setup to pre-define the data types.
Output truncated for display
Create Model
This function trains an unsupervised anomaly detection model. All the available models can be accessed using the models function.
iforest = create_model('iforest')
print(iforest)
models()
Analyze Model
plot_model(iforest, plot = 'tsne')
plot_model(iforest, plot = 'umap')
Assign Model
This function assigns anomaly labels to the dataset for a given model. (1 = outlier, 0 = inlier).
result = assign_model(iforest)
result.head()
Predictions
This function generates anomaly labels using a trained model on the new/unseen dataset.
predictions = predict_model(iforest, data = data)
predictions.head()
Output from predict_model(iforest, data = data)
Save the model
save_model(iforest, 'iforest_pipeline')
Output from save_model(iforest, 'iforest_pipeline')
To load the model back in the environment:
loaded_model = load_model('iforest_pipeline')
print(loaded_model)
Output from load_model('iforest_pipeline')
Natural Language Processing
PyCaret’s Natural Language Processing is an unsupervised machine learning module that is used for training topic models on text data. There are several techniques that are used to analyze text data and Topic Modeling is one of them. A topic model is a type of statistical model for discovering abstract topics in a collection of documents. 
Setup
This function initializes the training environment and creates the text transformation pipeline. The setup function must be called before executing any other function.
# load dataset
from pycaret.datasets import get_data
data = get_data('kiva')
Sample from dataset
# print first document
print(data['en'][0])
Output from print(data['en'][0])
# init setup
from pycaret.nlp import *
s = setup(data, target = 'en')
Output from setup(...)
Create Model
This function trains an unsupervised topic model. All the available models can be accessed using the models function.
models()
Output from models()
To train a model:
lda = create_model('lda')
print(lda)
Output from print(lda)
Analyze Model
plot_model(lda, plot = 'frequency')
Output from plot_model(...)
plot_model(lda, plot = 'sentiment')
Output from plot_model(...)
Alternatively, you can also use the evaluate_model function.
evaluate_model(lda)
Output from evaluate_model(lda)
Assign Model
This function assigns topic labels to the dataset for a given model.
lda_results = assign_model(lda)
lda_results.head()
Output from assign_model(lda)
Save the model
save_model(lda, 'my_lda_model')
Output from save_model(..)
To load the model back in the environment:
loaded_model = load_model('my_lda_model')
Association Rules Mining
PyCaret's association rule module is a supervised machine learning module that is used for discovering interesting relations between variables in the dataset. This module automatically transforms any transactional database into a shape that is acceptable for the apriori algorithm. Apriori is an algorithm for frequent itemset mining and association rule learning over relational databases.
Setup
from pycaret.datasets import get_data
data = get_data('france')
Sample rows from the dataset
from pycaret.arules import * 
arules = setup(data, transaction_id = 'InvoiceNo', item_id = 'Description')
Output from setup(...)
Create Model
create_model(metric = 'confidence', threshold = 0.3)
Output from create_model(...)
Analyze Model
plot_model(model, plot = '3d')
Output from plot_model(...)
Time Series
PyCaret's new time series module is now available in 3.0-rc. Staying true to the simplicity of PyCaret, it is consistent with our existing API and fully loaded with functionalities. Statistical testing, model training and selection (30+ algorithms), model analysis, automated hyperparameter tuning, experiment logging, deployment on cloud, and more. All of this with only a few lines of code.
Setup
This function initializes the training environment and creates the transformation pipeline. Setup function must be called before executing any other function.
# loading dataset
from pycaret.datasets import get_data
data = get_data('airline')
Output from get_data('airline')
from pycaret.time_series import *
s = setup(data, fh = 3, fold = 5, session_id = 123)
Output from setup(...)
Compare Models
This function trains and evaluates the performance of all the estimators available in the model library using cross-validation. The output of this function is a scoring grid with average cross-validated scores. Metrics evaluated during CV can be accessed using the get_metrics function. Custom metrics can be added or removed using add_metric and remove_metric function.
best = compare_models()
Output from compare_models()
Analyze Model
plot_model(best, plot = 'forecast', data_kwargs = {'fh' : 24})
Output from plot_model(...)
plot_model(best, plot = 'diagnostics')
Output from plot_model(best, plot = 'diagnostics')
plot_model(best, plot = 'insample')
Output from plot_model(best, plot = 'insample')
Predictions
# finalize model
final_best = finalize_model(best)
predict_model(best, fh = 24)
Output from predict_model(best, fh = 24)
Save the model
save_model(final_best, 'my_final_best_model')
Output from save_model(...)
To load the model back in the environment:
loaded_model = load_model('my_final_best_model')
print(loaded_model)
Output from load_model(...)
GET STARTED - Previous
Installation
Next - GET STARTED
Tutorials
Last modified 3mo ago
Export as PDF
Copy link
Edit on GitHub
On this page
Introduction
Classification
Setup
Compare Models
Analyze Model
Predictions
Save the model
Regression
Setup
Compare Models
Analyze Model
Predictions
Save the model
Clustering
Setup
Create Model
Analyze Model
Assign Model
Predictions
Save the model
Anomaly Detection
Setup
Create Model
Analyze Model
Assign Model
Predictions
Save the model
Natural Language Processing
Setup
Create Model
Analyze Model
Assign Model
Save the model
Association Rules Mining
Setup
Create Model
Analyze Model
Time Series
Setup
Compare Models
Analyze Model
Predictions
Save the model