Examples¶
This page contains detailed examples of how to use Lazy Predict in various scenarios.
Classification Example¶
Basic Classification¶
Here's a basic example using the breast cancer dataset:
from lazypredict.Supervised import LazyClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
# Load data
data = load_breast_cancer()
X = data.data
y = data.target
# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123)
# Create classifier
clf = LazyClassifier(verbose=0, ignore_warnings=True, custom_metric=None)
# Fit and get models
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
print(models)
Classification with Custom Metric¶
You can use custom metrics for model evaluation:
from sklearn.metrics import f1_score
def custom_f1(y_true, y_pred):
return f1_score(y_true, y_pred, average='weighted')
clf = LazyClassifier(verbose=0, ignore_warnings=True, custom_metric=custom_f1)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
Advanced Classification Options¶
Use advanced options like categorical encoding, timeout, and cross-validation:
clf = LazyClassifier(
verbose=1, # Show progress
ignore_warnings=True, # Suppress warnings
custom_metric=None, # Use default metrics
predictions=True, # Return predictions
classifiers='all', # Use all available classifiers
categorical_encoder='onehot', # Encoding strategy
timeout=60, # Max time per model in seconds
cv=5 # Cross-validation folds
)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
Regression Example¶
Basic Regression¶
Here's an example using the diabetes dataset:
from lazypredict.Supervised import LazyRegressor
from sklearn.datasets import load_diabetes
from sklearn.model_selection import train_test_split
# Load data
diabetes = load_diabetes()
X = diabetes.data
y = diabetes.target
# Split data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123)
# Create and fit regressor
reg = LazyRegressor(verbose=0, ignore_warnings=True, custom_metric=None)
models, predictions = reg.fit(X_train, X_test, y_train, y_test)
print(models)
Working with Pandas DataFrames¶
Lazy Predict works seamlessly with pandas DataFrames:
import pandas as pd
# Your DataFrame
df = pd.DataFrame(X, columns=diabetes.feature_names)
# Split features and target
X = df
y = pd.Series(diabetes.target)
# Rest remains the same
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
reg = LazyRegressor(verbose=0, ignore_warnings=True)
models, predictions = reg.fit(X_train, X_test, y_train, y_test)
Categorical Feature Encoding¶
Lazy Predict supports multiple categorical encoding strategies:
OneHot Encoding (Default)¶
import pandas as pd
from lazypredict.Supervised import LazyClassifier
from sklearn.model_selection import train_test_split
# Load data with categorical features
df = pd.read_csv('data_with_categories.csv')
X = df.drop('target', axis=1)
y = df['target']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
# Default onehot encoding
clf = LazyClassifier(categorical_encoder='onehot', verbose=0)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
Ordinal Encoding¶
Useful for ordered categorical features or when one-hot encoding creates too many features:
clf = LazyClassifier(categorical_encoder='ordinal', verbose=0)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
Target Encoding¶
Target encoding requires the category-encoders package:
clf = LazyClassifier(categorical_encoder='target', verbose=0)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
Binary Encoding¶
Binary encoding is efficient for high-cardinality features:
# Requires category-encoders package
clf = LazyClassifier(categorical_encoder='binary', verbose=0)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
Comparing Encoders¶
import pandas as pd
results = {}
for encoder in ['onehot', 'ordinal', 'target', 'binary']:
try:
clf = LazyClassifier(
categorical_encoder=encoder,
verbose=0,
ignore_warnings=True
)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
results[encoder] = models.head(3)
print(f"\n{encoder.upper()} Encoding Results:")
print(models.head(3))
except Exception as e:
print(f"{encoder}: {e}")
Using with MLflow¶
Lazy Predict has built-in MLflow integration for experiment tracking. You can enable it by setting the MLflow tracking URI:
import os
os.environ['MLFLOW_TRACKING_URI'] = 'sqlite:///mlflow.db' # Local SQLite tracking
# Or for remote tracking:
# os.environ['MLFLOW_TRACKING_URI'] = 'http://your-mlflow-server:5000'
# MLflow tracking will be automatically enabled
reg = LazyRegressor(verbose=0, ignore_warnings=True)
models, predictions = reg.fit(X_train, X_test, y_train, y_test)
The following metrics and artifacts will be automatically logged to MLflow:
- Model metrics (R-squared, RMSE, etc.)
- Training time
- The model name and the estimator's hyperparameters
- Model signatures
- A custom metric, as
custom_metric(if provided) - Model artifacts for each trained model (not registered in the model registry)
You can view the results in the MLflow UI:
For Databricks Users¶
If you're using Databricks, MLflow tracking is automatically configured:
# MLflow tracking will use Databricks tracking URI automatically
reg = LazyRegressor(verbose=0, ignore_warnings=True)
models, predictions = reg.fit(X_train, X_test, y_train, y_test)
Getting Model Objects¶
You can access the trained model objects:
# Get all trained models
model_dictionary = reg.provide_models(X_train, X_test, y_train, y_test)
# Access specific model
random_forest = model_dictionary['RandomForestRegressor']
# Make predictions with a specific model. The pipelines expect a DataFrame with
# the training columns; reg.predict() also converts NumPy input for you.
predictions = reg.predict(X_test)["RandomForestRegressor"]
Model Timeout¶
Set a maximum time limit for each model to prevent long-running models from blocking:
# Limit each model to 60 seconds
clf = LazyClassifier(timeout=60, verbose=1)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
# Models that exceed the timeout will be skipped
# Check for skipped models in the verbose output
This is particularly useful when:
- Working with large datasets where some models might take very long
- Running experiments with time constraints
- Preventing specific slow models from blocking the entire pipeline
GPU Acceleration¶
Lazy Predict supports GPU acceleration for models that support it.
Enable GPU with the use_gpu=True parameter:
from lazypredict.Supervised import LazyClassifier, LazyRegressor
# Classification with GPU
clf = LazyClassifier(verbose=0, ignore_warnings=True, use_gpu=True)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
# Regression with GPU
reg = LazyRegressor(verbose=0, ignore_warnings=True, use_gpu=True)
models, predictions = reg.fit(X_train, X_test, y_train, y_test)
Supported GPU backends:
- XGBoost — uses
device="cuda" - LightGBM — uses
device="gpu" - CatBoost — uses
task_type="GPU" - cuML (RAPIDS) — GPU-native scikit-learn replacements added automatically
- LSTM / GRU — PyTorch models use CUDA device
- TimesFM — placed on CUDA device for inference
cuML (RAPIDS) GPU Acceleration¶
When cuML is installed and
use_gpu=True, GPU-accelerated versions of common scikit-learn models are
automatically added to the benchmark:
# cuML models are added automatically when use_gpu=True
clf = LazyClassifier(use_gpu=True, verbose=0, ignore_warnings=True)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)
# Results will include cuML_LogisticRegression, cuML_RandomForestClassifier, etc.
cuML GPU models added:
- Classifiers: LogisticRegression, RandomForestClassifier, KNeighborsClassifier, SVC
- Regressors: LinearRegression, Ridge, Lasso, ElasticNet, RandomForestRegressor, KNeighborsRegressor, SVR
Time Series Forecasting with GPU¶
from lazypredict.TimeSeriesForecasting import LazyForecaster
fcst = LazyForecaster(
verbose=0,
ignore_warnings=True,
use_gpu=True, # GPU for XGBoost, LightGBM, CatBoost, LSTM, GRU, TimesFM
)
scores, predictions = fcst.fit(y_train, y_test)
Note
GPU acceleration requires a CUDA-capable GPU and PyTorch installed with CUDA support. If CUDA is not available, models automatically fall back to CPU with a warning.
Using Local Foundation Model Weights¶
If you are offline, behind a firewall, or in an air-gapped environment, you can point to a local directory containing pre-downloaded model weights instead of downloading from Hugging Face:
from lazypredict.TimeSeriesForecasting import LazyForecaster
fcst = LazyForecaster(
verbose=0,
ignore_warnings=True,
foundation_model_path="/path/to/timesfm-2.5-200m-pytorch",
)
scores, predictions = fcst.fit(y_train, y_test)
To download the model for later offline use:
# Download once (requires internet)
python -c "
from huggingface_hub import snapshot_download
snapshot_download('google/timesfm-2.5-200m-pytorch', local_dir='./timesfm-local')
"
# Then use the local path in air-gapped environments
fcst = LazyForecaster(foundation_model_path="./timesfm-local")
Intel Extension Acceleration¶
For improved performance on Intel CPUs, install Intel Extension for Scikit-learn:
Patch scikit-learn before importing lazypredict, so that the accelerated estimators are the ones lazypredict collects:
from sklearnex import patch_sklearn
patch_sklearn()
from lazypredict.Supervised import LazyClassifier
Changed in 0.4.0
Earlier versions called patch_sklearn() automatically on import lazypredict,
which changed scikit-learn for the whole Python process. The patch is now opt-in.
Time Series Forecasting¶
Basic Forecasting¶
Benchmark 20+ forecasting models with a single call:
import numpy as np
from lazypredict.TimeSeriesForecasting import LazyForecaster
# Generate sample data with trend + seasonality
np.random.seed(42)
t = np.arange(200)
y = 10 + 0.05 * t + 3 * np.sin(2 * np.pi * t / 12) + np.random.normal(0, 1, 200)
y_train, y_test = y[:180], y[180:]
fcst = LazyForecaster(verbose=0, ignore_warnings=True, predictions=True)
scores, predictions = fcst.fit(y_train, y_test)
print(scores)
Forecasting with Seasonal Period¶
By default the seasonal period is auto-detected via ACF. Override it manually:
fcst = LazyForecaster(
seasonal_period=12, # monthly data with yearly cycle
verbose=0,
ignore_warnings=True,
)
scores, predictions = fcst.fit(y_train, y_test)
Forecasting with Exogenous Variables¶
Pass optional exogenous features to models that support them (SARIMAX, AutoARIMA, ML models):
# Create exogenous features
X_train = np.column_stack([np.sin(t[:180]), np.cos(t[:180])])
X_test = np.column_stack([np.sin(t[180:]), np.cos(t[180:])])
fcst = LazyForecaster(verbose=0, ignore_warnings=True)
scores, predictions = fcst.fit(y_train, y_test, X_train, X_test)
Forecasting with Cross-Validation¶
Use expanding-window time series cross-validation:
fcst = LazyForecaster(
cv=5, # 5-fold TimeSeriesSplit
verbose=0,
ignore_warnings=True,
)
scores, predictions = fcst.fit(y_train, y_test)
# scores will contain CV Mean and CV Std columns for each metric
Selecting Specific Forecasters¶
Run only a subset of models:
fcst = LazyForecaster(
# Holt and AutoARIMA need lazypredict[timeseries], LSTM_TS lazypredict[deeplearning]
forecasters=["Holt", "AutoARIMA", "Ridge_TS", "LSTM_TS"],
verbose=0,
ignore_warnings=True,
)
scores, predictions = fcst.fit(y_train, y_test)
Custom Forecasting Metric¶
Add a custom metric alongside the defaults:
def median_absolute_error(y_true, y_pred):
return float(np.median(np.abs(y_true - y_pred)))
fcst = LazyForecaster(
custom_metric=median_absolute_error,
verbose=0,
ignore_warnings=True,
)
scores, predictions = fcst.fit(y_train, y_test)
# scores will include a 'median_absolute_error' column