lazypredict

Lazy Predict provides specialized classes for different machine learning tasks:

Future versions (v0.4.0+) are planned to introduce the following features:

• Simplified Fit API: Support for fit(X, y) without requiring test data.
• Model Serialization: Support for saving and loading trained models.
• Advanced Resource Controls: New parameters for max_models, n_jobs (to avoid hardcoded -1), and memory_limit to better manage system resources during training.

Install explainability extras to use SHAP or InterpretML:

• pip install lazypredict[explain] (for SHAP)
• pip install lazypredict[interpret] (for InterpretML/EBM)

Permutation Importance

Use explain_permutation to compute importance for all models in a dictionary.

SHAP Values

Use explain_shap for a single model from your model dictionary.

from lazypredict.explainability import explain_permutation, explain_shap

# Permutation Importance
importance_df = explain_permutation(
    models=model_dict,
    X_test=X_test,
    y_test=y_test,
    n_repeats=10,
    random_state=42,
)

# SHAP Values
shap_df = explain_shap(
    model=model_dict["RandomForestRegressor"],
    X_test=X_test,
    feature_names=feature_names,
)

To develop on Lazy Predict, clone the repository and install the package in editable mode with all dependencies and development tools.

git clone https://github.com/shankarpandala/lazypredict
cd lazypredict
pip install -e ".[all,dev]"

# Run tests
pytest tests/

To use MLflow for experiment tracking, install the mlflow extra and set the MLFLOW_TRACKING_URI environment variable in your Python script before running your estimators.

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

When using LazyForecaster, you can avoid downloading weights from Hugging Face by providing a local path to the model weights via the foundation_model_path parameter. This is useful for air-gapped or offline environments.

from lazypredict.TimeSeriesForecasting import LazyForecaster

# Use local weights
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)

For improved performance on Intel CPUs, install scikit-learn-intelex. Lazy Predict will automatically detect and use it for acceleration.

pip install scikit-learn-intelex

Control the output of the lazypredict logger using the standard Python logging module.

import logging

# Show info-level messages from all models
logging.getLogger("lazypredict").setLevel(logging.INFO)

# Suppress everything
logging.getLogger("lazypredict").setLevel(logging.ERROR)

# Log to file
handler = logging.FileHandler("lazypredict.log")
logging.getLogger("lazypredict").addHandler(handler)

To ensure code quality, apply the following branch protection rules in GitHub Settings:

For master branch:

• Require pull request reviews (minimum 1 reviewer).
• Require status checks to pass: lint, test-fast, and test-full.
• Require branches to be up to date.
• Do not allow bypassing.

For dev branch:

• Require status checks to pass: lint and test-fast.
• Allow bypassing for maintainers.

To enable hyperparameter tuning capabilities using Optuna or FLAML, install the corresponding extras via pip.

pip install lazypredict[tune]    # Optuna (default)
pip install lazypredict[flaml]   # FLAML alternative

Lazy Predict supports several encoding strategies via the categorical_encoder parameter.

• 'onehot': Default strategy.
• 'ordinal': Useful for ordered features or reducing feature dimensionality.
• 'target': Requires the category-encoders package.
• 'binary': Efficient for high-cardinality features; requires category-encoders package.

To use target or binary encoding, install the dependency:

pip install category-encoders