# Quickstart
## 🚀 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.
### 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 required parameters: `data` and `target`. All the other parameters are optional.
{% code lineNumbers="true" %}
```python
# load sample dataset
from pycaret.datasets import get_data
data = get_data('diabetes')
```
{% endcode %}
PyCaret 3.0 has two API's. You can choose one of it based on your preference. The functionalities and experiment results are consistent.
#### Functional API
{% code lineNumbers="true" %}
```python
from pycaret.classification import *
s = setup(data, target = 'Class variable', session_id = 123)
```
{% endcode %}
#### OOP API
{% code lineNumbers="true" %}
```python
from pycaret.classification import ClassificationExperiment
s = ClassificationExperiment()
s.setup(data, target = 'Class variable', session_id = 123)
```
{% endcode %}
### 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.
{% code lineNumbers="true" %}
```python
# functional API
best = compare_models()
# OOP API
best = s.compare_models()
```
{% endcode %}
```python
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.
{% code lineNumbers="true" %}
```python
# functional API
evaluate_model(best)
# OOP API
s.evaluate_model(best)
```
{% endcode %}
`evaluate_model` can only be used in Notebook since it uses `ipywidget` . You can also use the `plot_model` function to generate plots individually.
{% code lineNumbers="true" %}
```python
# functional API
plot_model(best, plot = 'auc')
# OOP API
s.plot_model(best, plot = 'auc')
```
{% endcode %}
{% code lineNumbers="true" %}
```python
# functional API
plot_model(best, plot = 'confusion_matrix')
# OOP API
s.plot_model(best, plot = 'confusion_matrix')
```
{% endcode %}
### Predictions
This function scores the data and returns `prediction_label` and `prediction_score` probability of the predicted class). When `data` is None, it predicts label and score on the test set (created during the `setup` function).
{% code lineNumbers="true" %}
```python
# functional API
predict_model(best)
# OOP API
s.predict_model(best)
```
{% endcode %}
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 `data` parameter under `predict_model` function.
{% code lineNumbers="true" %}
```python
# functional API
predictions = predict_model(best, data=data)
predictions.head()
# OOP API
predictions = s.predict_model(best, data=data)
predictions.head()
```
{% endcode %}
{% hint style="info" %}
`Score` means the probability of the predicted class (NOT the positive class). If `prediction_label` is 0 and `prediction_score` is 0.90, this 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.
{% endhint %}
{% code lineNumbers="true" %}
```python
# functional API
predictions = predict_model(best, data=data, raw_score=True)
predictions.head()
# OOP API
predictions = s.predict_model(best, data=data, raw_score=True)
predictions.head()
```
{% endcode %}
### Save the model
{% code lineNumbers="true" %}
```python
# functional API
save_model(best, 'my_best_pipeline')
# OOP API
s.save_model(best, 'my_best_pipeline')
```
{% endcode %}
#### To load the model back in environment:
{% code lineNumbers="true" %}
```python
# functional API
loaded_model = load_model('my_best_pipeline')
print(loaded_model)
# OOP API
loaded_model = s.load_model('my_best_pipeline')
print(loaded_model)
```
{% endcode %}
## 🚀 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.
### 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 required parameters: `data` and `target`. All the other parameters are optional.
{% code lineNumbers="true" %}
```python
# load sample dataset
from pycaret.datasets import get_data
data = get_data('insurance')
```
{% endcode %}
PyCaret 3.0 has two API's. You can choose one of it based on your preference. The functionalities and experiment results are consistent.
#### Functional API
{% code lineNumbers="true" %}
```python
from pycaret.regression import *
s = setup(data, target = 'charges', session_id = 123)
```
{% endcode %}
#### OOP API
{% code lineNumbers="true" %}
```python
from pycaret.regression import RegressionExperiment
s = RegressionExperiment()
s.setup(data, target = 'charges', session_id = 123)
```
{% endcode %}
### 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.
{% code lineNumbers="true" %}
```python
# functional API
best = compare_models()
# OOP API
best = s.compare_models()
```
{% endcode %}
{% code lineNumbers="true" %}
```python
print(best)
```
{% endcode %}
### 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.
{% code lineNumbers="true" %}
```python
# functional API
evaluate_model(best)
# OOP API
s.evaluate_model(best)
```
{% endcode %}
`evaluate_model` can only be used in Notebook since it uses `ipywidget` . You can also use the `plot_model` function to generate plots individually.
{% code lineNumbers="true" %}
```python
# functional API
plot_model(best, plot = 'residuals')
# OOP API
s.plot_model(best, plot = 'residuals')
```
{% endcode %}
{% code lineNumbers="true" %}
```python
# functional API
plot_model(best, plot = 'feature')
# OOP API
s.plot_model(best, plot = 'feature')
```
{% endcode %}
### Predictions
This function predicts `prediction_label` using the trained model. When `data` is None, it predicts label and score on the test set (created during the `setup` function).
{% code lineNumbers="true" %}
```python
# functional API
predict_model(best)
# OOP API
s.predict_model(best)
```
{% endcode %}
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.
{% code lineNumbers="true" %}
```python
# functional API
predictions = predict_model(best, data=data)
predictions.head()
# OOP API
predictions = s.predict_model(best, data=data)
predictions.head()
```
{% endcode %}
### Save the model
{% code lineNumbers="true" %}
```python
# functional API
save_model(best, 'my_best_pipeline')
# OOP API
s.save_model(best, 'my_best_pipeline')
```
{% endcode %}
#### To load the model back in the environment:
{% code lineNumbers="true" %}
```python
# functional API
loaded_model = load_model('my_best_pipeline')
print(loaded_model)
# OOP API
loaded_model = s.load_model('my_best_pipeline')
print(loaded_model)
```
{% endcode %}
## 🚀 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.
### Setup
This function initializes the training environment and creates the transformation pipeline. Setup function must be called before executing any other function. It takes only one required parameter: `data`. All the other parameters are optional.
{% code lineNumbers="true" %}
```python
# load sample dataset
from pycaret.datasets import get_data
data = get_data('jewellery')
```
{% endcode %}
PyCaret 3.0 has two API's. You can choose one of it based on your preference. The functionalities and experiment results are consistent.
#### Functional API
{% code lineNumbers="true" %}
```python
from pycaret.clustering import *
s = setup(data, normalize = True)
```
{% endcode %}
#### OOP API
{% code lineNumbers="true" %}
```python
from pycaret.clustering import ClusteringExperiment
s = ClusteringExperiment()
s.setup(data, normalize = True)
```
{% endcode %}
### 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.
{% code lineNumbers="true" %}
```python
# functional API
kmeans = create_model('kmeans')
# OOP API
kmeans = s.create_model('kmeans')
```
{% endcode %}
```python
print(kmeans)
```
### Analyze Model
This function analyzes the performance of a trained model.
{% code lineNumbers="true" %}
```python
# functional API
evaluate_model(kmeans)
# OOP API
s.evaluate_model(kmeans)
```
{% endcode %}
`evaluate_model` can only be used in Notebook since it uses `ipywidget` . You can also use the `plot_model` function to generate plots individually.
{% code lineNumbers="true" %}
```python
# functional API
plot_model(kmeans, plot = 'elbow')
# OOP API
s.plot_model(kmeans, plot = 'elbow')
```
{% endcode %}
{% code lineNumbers="true" %}
```python
# functional API
plot_model(kmeans, plot = 'silhouette')
# OOP API
s.plot_model(kmeans, plot = 'silhouette')
```
{% endcode %}
### Assign Model
This function assigns cluster labels to the training data, given a trained model.
{% code lineNumbers="true" %}
```python
# functional API
result = assign_model(kmeans)
result.head()
# OOP API
result = s.assign_model(kmeans)
result.head()
```
{% endcode %}
### Predictions
This function generates cluster labels using a trained model on the new/unseen dataset.
{% code lineNumbers="true" %}
```python
# functional API
predictions = predict_model(kmeans, data = data)
predictions.head()
# OOP API
predictions = s.predict_model(kmeans, data = data)
predictions.head()
```
{% endcode %}
### Save the model
{% code lineNumbers="true" %}
```python
# functional API
save_model(kmeans, 'kmeans_pipeline')
# OOP API
s.save_model(kmeans, 'kmeans_pipeline')
```
{% endcode %}
#### To load the model back in the environment:
{% code lineNumbers="true" %}
```python
# functional API
loaded_model = load_model('kmeans_pipeline')
print(loaded_model)
# OOP API
loaded_model = s.load_model('kmeans_pipeline')
print(loaded_model)
```
{% endcode %}
## 🚀 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.
### 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 only one required parameter only: `data`. All the other parameters are optional.
{% code lineNumbers="true" %}
```python
# load sample dataset
from pycaret.datasets import get_data
data = get_data('anomaly')
```
{% endcode %}
PyCaret 3.0 has two API's. You can choose one of it based on your preference. The functionalities and experiment results are consistent.
#### Functional API
{% code lineNumbers="true" %}
```python
from pycaret.anomaly import *
s = setup(data, session_id = 123)
```
{% endcode %}
#### OOP API
{% code lineNumbers="true" %}
```python
from pycaret.anomaly import AnomalyExperiment
s = AnomalyExperiment()
s.setup(data, session_id = 123)
```
{% endcode %}
### Create Model
This function trains an unsupervised anomaly detection model. All the available models can be accessed using the `models` function.
{% code lineNumbers="true" %}
```python
# functional API
iforest = create_model('iforest')
print(iforest)
# OOP API
iforest = s.create_model('iforest')
print(iforest)
```
{% endcode %}
{% code lineNumbers="true" %}
```python
# functional API
models()
# OOP API
s.models()
```
{% endcode %}
### Analyze Model
{% code lineNumbers="true" %}
```python
# functional API
plot_model(iforest, plot = 'tsne')
# OOP API
s.plot_model(iforest, plot = 'tsne')
```
{% endcode %}
{% code lineNumbers="true" %}
```python
# functional API
plot_model(iforest, plot = 'umap')
# OOP API
s.plot_model(iforest, plot = 'umap')
```
{% endcode %}
### Assign Model
This function assigns anomaly labels to the dataset for a given model. (1 = outlier, 0 = inlier).
{% code lineNumbers="true" %}
```python
# functional API
result = assign_model(iforest)
result.head()
# OOP API
result = s.assign_model(iforest)
result.head()
```
{% endcode %}
### Predictions
This function generates anomaly labels using a trained model on the new/unseen dataset.
{% code lineNumbers="true" %}
```python
# functional API
predictions = predict_model(iforest, data = data)
predictions.head()
# OOP API
predictions = s.predict_model(iforest, data = data)
predictions.head()
```
{% endcode %}
### Save the model
{% code lineNumbers="true" %}
```python
# functional API
save_model(iforest, 'iforest_pipeline')
# OOP API
s.save_model(iforest, 'iforest_pipeline')
```
{% endcode %}
To load the model back in the environment:
{% code lineNumbers="true" %}
```python
# functional API
loaded_model = load_model('iforest_pipeline')
print(loaded_model)
# OOP API
loaded_model = s.load_model('iforest_pipeline')
print(loaded_model)
```
{% endcode %}
## 🚀 Time Series
PyCaret Time Series module is a powerful tool for analyzing and predicting time series data using machine learning and classical statistical techniques. This module enables users to easily perform complex time series forecasting tasks by automating the entire process from data preparation to model deployment.
PyCaret Time Series Forecasting module supports a wide range of forecasting methods such as ARIMA, Prophet, and LSTM. It also provides various features to handle missing values, time series decomposition, and data visualizations.
### Setup
This function initializes the training environment and creates the transformation pipeline. Setup function must be called before executing any other function.
{% code lineNumbers="true" %}
```python
# load sample dataset
from pycaret.datasets import get_data
data = get_data('airline')
```
{% endcode %}
PyCaret 3.0 has two API's. You can choose one of it based on your preference. The functionalities and experiment results are consistent.
#### Functional API
{% code lineNumbers="true" %}
```python
from pycaret.time_series import *
s = setup(data, fh = 3, fold = 5, session_id = 123)
```
{% endcode %}
Output truncated
#### OOP API
{% code lineNumbers="true" %}
```python
from pycaret.time_series import TSForecastingExperiment
s = TSForecastingExperiment()
```
{% endcode %}
Output truncated
### 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.
{% code lineNumbers="true" %}
```python
# functional API
best = compare_models()
# OOP API
best = s.compare_models()
```
{% endcode %}
### Analyze Model
{% code lineNumbers="true" %}
```python
# functional API
plot_model(best, plot = 'forecast', data_kwargs = {'fh' : 24})
# OOP API
s.plot_model(best, plot = 'forecast', data_kwargs = {'fh' : 24})
```
{% endcode %}
{% code lineNumbers="true" %}
```python
# functional API
plot_model(best, plot = 'diagnostics')
# OOP API
s.plot_model(best, plot = 'diagnostics')
```
{% endcode %}
{% code lineNumbers="true" %}
```python
# functional API
plot_model(best, plot = 'insample')
# OOP API
s.plot_model(best, plot = 'insample')
```
{% endcode %}
### Predictions
{% code lineNumbers="true" %}
```python
# functional API
final_best = finalize_model(best)
predict_model(best, fh = 24)
# OOP API
final_best = s.finalize_model(best)
s.predict_model(best, fh = 24)
```
{% endcode %}
### Save the model
{% code lineNumbers="true" %}
```python
# functional API
save_model(final_best, 'my_final_best_model')
# OOP API
s.save_model(final_best, 'my_final_best_model')
```
{% endcode %}
#### To load the model back in the environment:
{% code lineNumbers="true" %}
```python
# functional API
loaded_model = load_model('my_final_best_model')
print(loaded_model)
# OOP API
loaded_model = s.load_model('my_final_best_model')
print(loaded_model)
```
{% endcode %}
