Lazy Predict

Lazy Predict helps build a lot of basic models without much code and helps understand which models work better without any parameter tuning.

• Free software: MIT license
• Documentation: https://shankarpandala.github.io/lazypredict/

Features

• Over 40 built-in machine learning models
• Automatic model selection for classification, regression, and time series forecasting
• 20+ forecasting models: statistical (ETS, ARIMA, Theta), ML (Random Forest, XGBoost, etc.), deep learning (LSTM, GRU), and pretrained foundation models (TimesFM)
• Automatic seasonal period detection via ACF
• Multiple categorical encoding strategies (OneHot, Ordinal, Target, Binary)
• Built-in MLflow integration for experiment tracking
• GPU acceleration: XGBoost, LightGBM, CatBoost, cuML (RAPIDS), LSTM/GRU, TimesFM
• Support for Python 3.10 through 3.14
• Custom metric evaluation support
• Configurable timeout and cross-validation
• Intel Extension for Scikit-learn acceleration support (opt-in)

Installation

pip (PyPI)

pip install lazypredict

conda (conda-forge)

conda install -c conda-forge lazypredict

Optional extras (pip only)

Install with boosting libraries (XGBoost, LightGBM, CatBoost):

pip install lazypredict[boost]

Install the target/binary categorical encoders (category-encoders):

pip install lazypredict[encoders]

Install with time series forecasting support:

pip install lazypredict[timeseries]          # statsmodels + pmdarima
pip install lazypredict[timeseries,deeplearning]  # + LSTM/GRU via PyTorch
pip install lazypredict[timeseries,foundation]    # + Google TimesFM (PyTorch)

Install with all optional dependencies:

pip install lazypredict[all]

Usage

To use Lazy Predict in a project:

import lazypredict

Classification

Example:

from lazypredict.Supervised import LazyClassifier
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split

data = load_breast_cancer()
X = data.data
y = data.target

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=123)

clf = LazyClassifier(verbose=0, ignore_warnings=True, custom_metric=None)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)

print(models)

Advanced Options

# With categorical encoding, timeout, cross-validation, and GPU
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: 'onehot', 'ordinal', 'target', 'binary'
    timeout=60,                         # Max time per model in seconds
    cv=5,                               # Cross-validation folds (optional)
    use_gpu=True                        # Enable GPU acceleration
)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)

Parameters:

• verbose (int): 0 for silent, 1 for progress display
• ignore_warnings (bool): Suppress scikit-learn warnings
• custom_metric (callable): Custom evaluation metric
• predictions (bool): Return prediction DataFrame
• classifiers (str/list): 'all' or list of classifier names
• categorical_encoder (str): Encoding strategy for categorical features
  • 'onehot': One-hot encoding (default)
  • 'ordinal': Ordinal encoding
  • 'target': Target encoding (requires category-encoders)
  • 'binary': Binary encoding (requires category-encoders)
• timeout (int/float): Maximum training time per model in seconds (None for no limit). Slow models are interrupted on Linux/macOS and listed in errors as TimeoutException
• cv (int): Number of cross-validation folds (None to disable)
• use_gpu (bool): Enable GPU acceleration for supported models (default False)

Output on the breast cancer split above (scikit-learn 1.9, with xgboost and lightgbm installed; times are machine-dependent):

Regression

Example:

from lazypredict.Supervised import LazyRegressor
from sklearn import datasets
from sklearn.utils import shuffle
import numpy as np

diabetes  = datasets.load_diabetes()
X, y = shuffle(diabetes.data, diabetes.target, random_state=13)
X = X.astype(np.float32)

offset = int(X.shape[0] * 0.9)

X_train, y_train = X[:offset], y[:offset]
X_test, y_test = X[offset:], y[offset:]

reg = LazyRegressor(verbose=0, ignore_warnings=False, custom_metric=None)
models, predictions = reg.fit(X_train, X_test, y_train, y_test)

print(models)

Advanced Options

# With categorical encoding, timeout, and GPU
reg = LazyRegressor(
    verbose=1,                          # Show progress
    ignore_warnings=True,               # Suppress warnings
    custom_metric=None,                 # Use default metrics
    predictions=True,                   # Return predictions
    regressors='all',                   # Use all available regressors
    categorical_encoder='ordinal',      # Encoding: 'onehot', 'ordinal', 'target', 'binary'
    timeout=120,                        # Max time per model in seconds
    use_gpu=True                        # Enable GPU acceleration
)
models, predictions = reg.fit(X_train, X_test, y_train, y_test)

Parameters:

• verbose (int): 0 for silent, 1 for progress display
• ignore_warnings (bool): Suppress scikit-learn warnings
• custom_metric (callable): Custom evaluation metric
• predictions (bool): Return prediction DataFrame
• regressors (str/list): 'all' or list of regressor names
• categorical_encoder (str): Encoding strategy for categorical features
  • 'onehot': One-hot encoding (default)
  • 'ordinal': Ordinal encoding
  • 'target': Target encoding (requires category-encoders)
  • 'binary': Binary encoding (requires category-encoders)
• timeout (int/float): Maximum training time per model in seconds (None for no limit). Slow models are interrupted on Linux/macOS and listed in errors as TimeoutException
• use_gpu (bool): Enable GPU acceleration for supported models (default False)

Output on the diabetes split above:

Time Series Forecasting

LazyForecaster benchmarks 20+ forecasting models on your time series in a single call:

import numpy as np
from lazypredict.TimeSeriesForecasting import LazyForecaster

# Generate sample data (or use your own)
np.random.seed(42)
t = np.arange(200)
rng = np.random.default_rng(42)
y = 10 + 0.05 * t + 3 * np.sin(2 * np.pi * t / 12) + rng.normal(0, 1, 200)

y_train, y_test = y[:180], y[180:]

fcst = LazyForecaster(verbose=0, ignore_warnings=True)
scores, predictions = fcst.fit(y_train, y_test)
print(scores)

Output with lazypredict[timeseries,boost] installed (seasonal period 12 detected; times are machine-dependent):

With Exogenous Variables

# Optional 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:])])

scores, predictions = fcst.fit(y_train, y_test, X_train, X_test)

Advanced Options

fcst = LazyForecaster(
    verbose=1,                          # Show progress
    ignore_warnings=True,               # Suppress model errors
    predictions=True,                   # Return forecast values
    seasonal_period=12,                 # Override auto-detection
    cv=3,                               # Time series cross-validation
    timeout=30,                         # Max seconds per model
    sort_by="RMSE",                     # Sort metric (MAE, MAPE, SMAPE, MASE, R-Squared)
    forecasters="all",                  # Or a list, e.g. ["Holt", "Ridge_TS"] (Holt needs [timeseries])
    max_models=10,                      # Limit number of models
    use_gpu=True,                       # GPU acceleration for supported models
    foundation_model_path="/path/to/timesfm-weights",  # Local model weights (offline)
)
scores, predictions = fcst.fit(y_train, y_test)

Parameters:

• verbose (int): 0 for silent, 1 for progress display
• ignore_warnings (bool): Suppress per-model exceptions
• predictions (bool): Return a second DataFrame of forecasted values
• seasonal_period (int/None): Seasonal cycle length; None auto-detects via ACF
• cv (int/None): Number of TimeSeriesSplit folds for cross-validation
• timeout (int/float/None): Maximum seconds per model for training and forecasting; slow models are interrupted on Linux/macOS and listed in errors
• sort_by (str): Metric to sort by ("RMSE", "MAE", "MAPE", "SMAPE", "MASE", "R-Squared")
• forecasters (str/list): "all" or a list of model names
• n_lags (int): Number of lag features for ML/DL models (default 10)
• n_rolling (tuple): Rolling-window sizes for feature engineering (default (3, 7))
• max_models (int/None): Limit total models to train
• custom_metric (callable): Additional metric f(y_true, y_pred) -> float
• use_gpu (bool): Enable GPU acceleration for supported models (default False)
• foundation_model_path (str): Local path to pre-downloaded foundation model weights (e.g. TimesFM)

Available model categories:

• Baselines: Naive, SeasonalNaive
• Statistical (statsmodels): SimpleExpSmoothing, Holt, HoltWinters_Add, HoltWinters_Mul, Theta, SARIMAX
• Statistical (pmdarima): AutoARIMA
• ML (sklearn): LinearRegression_TS, Ridge_TS, Lasso_TS, ElasticNet_TS, KNeighborsRegressor_TS, DecisionTreeRegressor_TS, RandomForestRegressor_TS, GradientBoostingRegressor_TS, AdaBoostRegressor_TS, ExtraTreesRegressor_TS, BaggingRegressor_TS, SVR_TS, XGBRegressor_TS, LGBMRegressor_TS, CatBoostRegressor_TS
• Deep Learning (torch): LSTM_TS, GRU_TS
• Foundation (timesfm): TimesFM

GPU Acceleration

Enable GPU acceleration for supported models with use_gpu=True:

from lazypredict.Supervised import LazyClassifier, LazyRegressor

# Classification with GPU
clf = LazyClassifier(use_gpu=True, verbose=0, ignore_warnings=True)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)

# Regression with GPU
reg = LazyRegressor(use_gpu=True, verbose=0, ignore_warnings=True)
models, predictions = reg.fit(X_train, X_test, y_train, y_test)

# Time Series with GPU
from lazypredict.TimeSeriesForecasting import LazyForecaster
fcst = LazyForecaster(use_gpu=True, verbose=0, ignore_warnings=True)
scores, predictions = fcst.fit(y_train, y_test)

Supported GPU backends:

• XGBoost — device="cuda"
• LightGBM — device="gpu"
• CatBoost — task_type="GPU"
• cuML (RAPIDS) — GPU-native scikit-learn replacements (auto-discovered when installed)
• LSTM / GRU — PyTorch CUDA
• TimesFM — PyTorch CUDA

Falls back to CPU automatically if no CUDA GPU is available.

Categorical Encoding

Lazy Predict supports multiple categorical encoding strategies:

from lazypredict.Supervised import LazyClassifier
import pandas as pd
from sklearn.model_selection import train_test_split

# Example 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)

# Try different encoders
for encoder in ['onehot', 'ordinal', 'target', 'binary']:
    clf = LazyClassifier(
        categorical_encoder=encoder,
        verbose=0,
        ignore_warnings=True
    )
    models, predictions = clf.fit(X_train, X_test, y_train, y_test)
    print(f"\n{encoder.upper()} Encoding Results:")
    print(models.head())

Note: Target and binary encoders require the category-encoders package:

pip install lazypredict[encoders]

pandas category, string and (pandas 3) str columns are treated as categorical features alongside object columns.

Intel Extension Acceleration

For improved performance on Intel CPUs, install Intel Extension for Scikit-learn:

pip install scikit-learn-intelex

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.

MLflow Integration

Lazy Predict includes built-in MLflow integration. Enable it by setting the MLflow tracking URI:

import os
os.environ['MLFLOW_TRACKING_URI'] = 'sqlite:///mlflow.db'

# 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)

Each model gets its own MLflow run (nested under your active run, if any) with:

• Model metrics (R-squared, RMSE, etc.)
• Training time
• The model name and the estimator's hyperparameters as parameters
• A custom metric, as custom_metric
• The fitted pipeline as an artifact (not registered in the model registry)

Lazy Predict does not call mlflow.autolog(); enable it yourself if you want autologging for the rest of your code.