懒人预测

懒人预测可以帮助你在无需编写大量代码的情况下构建许多基础模型，并且无需进行任何超参数调优就能了解哪些模型效果更好。

• 自由软件：MIT 许可证
• 文档：https://lazypredict.readthedocs.io

特性

• 内置超过40种机器学习模型
• 自动选择分类、回归以及时间序列预测的模型
• 20多种预测模型：统计类（ETS、ARIMA、Theta）、机器学习类（随机森林、XGBoost等）、深度学习类（LSTM、GRU）以及预训练的基础模型（TimesFM）
• 通过自相关函数（ACF）自动检测季节性周期
• 多种类别编码策略（OneHot、Ordinal、Target、Binary）
• 内置MLflow集成，用于实验跟踪
• GPU加速：XGBoost、LightGBM、CatBoost、cuML（RAPIDS）、LSTM/GRU、TimesFM
• 支持Python 3.9至3.13版本
• 支持自定义指标评估
• 可配置的超时时间和交叉验证
• 支持Intel Extension for Scikit-learn加速

安装

pip (PyPI)

pip install lazypredict

conda (conda-forge)

conda install -c conda-forge lazypredict

可选扩展（仅限pip）

安装包含提升库（XGBoost、LightGBM、CatBoost）的版本：

pip install lazypredict[boost]

安装支持时间序列预测的版本：

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

安装所有可选依赖的版本：

pip install lazypredict[all]

使用方法

在项目中使用懒人预测：

import lazypredict

分类

示例：

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)

高级选项

# 使用分类编码、超时、交叉验证和 GPU
clf = LazyClassifier(
    verbose=1,                          # 显示进度
    ignore_warnings=True,               # 抑制警告
    custom_metric=None,                 # 使用默认指标
    predictions=True,                   # 返回预测结果
    classifiers='all',                  # 使用所有可用的分类器
    categorical_encoder='onehot',       # 编码方式：'onehot'、'ordinal'、'target'、'binary'
    timeout=60,                         # 每个模型的最大运行时间（秒）
    cv=5,                               # 交叉验证折数（可选）
    use_gpu=True                        # 启用 GPU 加速
)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)

参数说明：

• verbose (int): 0 表示静默，1 表示显示进度。
• ignore_warnings (bool): 抑制 scikit-learn 的警告信息。
• custom_metric (callable): 自定义评估指标。
• predictions (bool): 是否返回预测结果 DataFrame。
• classifiers (str/list): 可以是 'all' 或者指定的分类器名称列表。
• categorical_encoder (str): 处理分类特征的编码策略。
  • 'onehot': one-hot 编码（默认）。
  • 'ordinal': 序号编码。
  • 'target': 目标编码（需要 category-encoders 库）。
  • 'binary': 二进制编码（需要 category-encoders 库）。
• timeout (int): 每个模型的最大运行时间（秒），设置为 None 表示无限制。
• cv (int): 交叉验证的折数，设置为 None 表示不进行交叉验证。
• use_gpu (bool): 对支持的模型启用 GPU 加速（默认为 False）。

模型	精确率	平衡准确率	ROC AUC	F1 分数	耗时
LinearSVC	0.989474	0.987544	0.987544	0.989462	0.0150008
SGDClassifier	0.989474	0.987544	0.987544	0.989462	0.0109992
MLPClassifier	0.985965	0.986904	0.986904	0.985994	0.426
Perceptron	0.985965	0.984797	0.984797	0.985965	0.0120046
LogisticRegression	0.985965	0.98269	0.98269	0.985934	0.0200036
LogisticRegressionCV	0.985965	0.98269	0.98269	0.985934	0.262997
SVC	0.982456	0.979942	0.979942	0.982437	0.0140011
CalibratedClassifierCV	0.982456	0.975728	0.975728	0.982357	0.0350015
PassiveAggressiveClassifier	0.975439	0.974448	0.974448	0.975464	0.0130005
LabelPropagation	0.975439	0.974448	0.974448	0.975464	0.0429988
LabelSpreading	0.975439	0.974448	0.974448	0.975464	0.0310006
RandomForestClassifier	0.97193	0.969594	0.969594	0.97193	0.033
GradientBoostingClassifier	0.97193	0.967486	0.967486	0.971869	0.166998
QuadraticDiscriminantAnalysis	0.964912	0.966206	0.966206	0.965052	0.0119994
HistGradientBoostingClassifier	0.968421	0.964739	0.964739	0.968387	0.682003
RidgeClassifierCV	0.97193	0.963272	0.963272	0.971736	0.0130029
RidgeClassifier	0.968421	0.960525	0.960525	0.968242	0.0119977
AdaBoostClassifier	0.961404	0.959245	0.959245	0.961444	0.204998
ExtraTreesClassifier	0.961404	0.957138	0.957138	0.961362	0.0270066
KNeighborsClassifier	0.961404	0.95503	0.95503	0.961276	0.0560005
BaggingClassifier	0.947368	0.954577	0.954577	0.947882	0.0559971
BernoulliNB	0.950877	0.951003	0.951003	0.951072	0.0169988
LinearDiscriminantAnalysis	0.961404	0.950816	0.950816	0.961089	0.0199995
GaussianNB	0.954386	0.949536	0.949536	0.954337	0.0139935
NuSVC	0.954386	0.943215	0.943215	0.954014	0.019989
DecisionTreeClassifier	0.936842	0.933693	0.933693	0.936971	0.0170043
NearestCentroid	0.947368	0.933506	0.933506	0.946801	0.0160074
ExtraTreeClassifier	0.922807	0.912168	0.912168	0.922462	0.01099lassified as "not applicable" in this context.
DummyClassifier	0.512281	0.489598	0.489598	0.518924	0.01199lassified as "not applicable" in this context.

回归

示例：

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)

高级选项

# 使用分类编码、超时设置和 GPU
reg = LazyRegressor(
    verbose=1,                          # 显示进度
    ignore_warnings=True,               # 抑制警告
    custom_metric=None,                 # 使用默认指标
    predictions=True,                   # 返回预测结果
    regressors='all',                   # 使用所有可用回归模型
    categorical_encoder='ordinal',      # 编码方式：'onehot'、'ordinal'、'target'、'binary'
    timeout=120,                        # 每个模型的最大运行时间（秒）
    use_gpu=True                        # 启用 GPU 加速
)
models, predictions = reg.fit(X_train, X_test, y_train, y_test)

参数说明：

• verbose (int): 0 表示静默，1 表示显示进度。
• ignore_warnings (bool): 是否抑制 scikit-learn 的警告信息。
• custom_metric (callable): 自定义评估指标。
• predictions (bool): 是否返回预测结果的 DataFrame。
• regressors (str/list): 可以是 'all' 或者指定回归模型名称的列表。
• categorical_encoder (str): 处理分类特征的编码策略：
  • 'onehot': 独热编码（默认）。
  • 'ordinal': 序号编码。
  • 'target': 目标编码（需要 category-encoders 库）。
  • 'binary': 二进制编码（需要 category-encoders 库）。
• timeout (int): 每个模型的最大运行时间（秒），设置为 None 表示无限制。
• use_gpu (bool): 是否启用 GPU 加速（默认为 False），仅支持部分模型。

模型	调整后 R-Squared	R-Squared	RMSE	时间耗时
ExtraTreesRegressor	0.378921	0.520076	54.2202	0.121466
OrthogonalMatchingPursuitCV	0.374947	0.517004	54.3934	0.0111742
Lasso	0.373483	0.515873	54.457	0.00620174
LassoLars	0.373474	0.515866	54.4575	0.0087235
LarsCV	0.3715	0.514341	54.5432	0.0160234
LassoCV	0.370413	0.513501	54.5903	0.0624897
PassiveAggressiveRegressor	0.366958	0.510831	54.7399	0.00689793
LassoLarsIC	0.364984	0.509306	54.8252	0.0108321
SGDRegressor	0.364307	0.508783	54.8544	0.0055306
RidgeCV	0.363002	0.507774	54.9107	0.00728202
Ridge	0.363002	0.507774	54.9107	0.00556874
BayesianRidge	0.362296	0.507229	54.9411	0.0122972
LassoLarsCV	0.361749	0.506806	54.9646	0.0175984
TransformedTargetRegressor	0.361749	0.506806	54.9646	0.00604773
LinearRegression	0.361749	0.506806	54.9646	0.00677514
Lars	0.358828	0.504549	55.0903	0.00935149
ElasticNetCV	0.356159	0.502486	55.2048	0.0478678
HuberRegressor	0.355251	0.501785	55.2437	0.0129263
RandomForestRegressor	0.349621	0.497434	55.4844	0.2331
AdaBoostRegressor	0.340416	0.490322	55.8757	0.0512381
LGBMRegressor	0.339239	0.489412	55.9255	0.0396187
HistGradientBoostingRegressor	0.335632	0.486625	56.0779	0.0897055
PoissonRegressor	0.323033	0.476889	56.6072	0.00953603
ElasticNet	0.301755	0.460447	57.4899	0.00604224
KNeighborsRegressor	0.299855	0.458979	57.5681	0.00757337
OrthogonalMatchingPursuit	0.292421	0.453235	57.8729	0.00709486
BaggingRegressor	0.291213	0.452301	57.9223	0.0302746
GradientBoostingRegressor	0.247009	0.418143	59.7011	0.136803
TweedieRegressor	0.244215	0.415984	59.8118	0.00633955
XGBRegressor	0.224263	0.400567	60.5961	0.339694
GammaRegressor	0.223895	0.400283	60.6105	0.0235181
RANSACRegressor	0.203535	0.38455	61.4004	0.0653253
LinearSVR	0.116707	0.317455	64.6607	0.0077076
ExtraTreeRegressor	0.00201902	0.228833	68.7304	0.00626636
NuSVR	-0.0667043	0.175728	71.0575	0.0143399
SVR	-0.0964128	0.152772	72.0402	0.0114729
DummyRegressor	-0.297553	-0.00265478	78.3701	0.00592971
DecisionTreeRegressor	-0.470263	-0.136112	83.4229	0.00749898
GaussianProcessRegressor	-0.769174	-0.367089	91.5109	0.0770502
MLPRegressor	-1.86772	-1.21597	116.508	0.235267
KernelRidge	-5.03822	-3.6659	169.061	0.0243919

时间序列预测

LazyForecaster 可以在一次调用中对您的时间序列数据进行 20 多种预测模型的基准测试：

import numpy as np
from lazypredict.TimeSeriesForecasting import LazyForecaster

# 生成示例数据（或使用您自己的数据）
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)
scores, predictions = fcst.fit(y_train, y_test)
print(scores)

模型	MAE	RMSE	MAPE	SMAPE	MASE	R-Squared	时间耗时
Holt	0.8532	1.0285	6.3241	6.1758	0.6993	0.7218	0.03
SARIMAX	0.8791	1.0601	6.5012	6.3414	0.7205	0.7045	0.12
Ridge_TS	0.9124	1.0843	6.7523	6.5721	0.7478	0.6912	0.01
...	...	...	...	...	...	...	...

带有外生变量的情况

# 可选的外生特征
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)

高级选项

fcst = LazyForecaster(
    verbose=1,                          # 显示进度
    ignore_warnings=True,               # 抑制模型错误
    predictions=True,                   # 返回预测值
    seasonal_period=12,                 # 覆盖自动检测
    cv=3,                               # 时间序列交叉验证
    timeout=30,                         # 每个模型的最大训练秒数
    sort_by="RMSE",                     # 排序指标（MAE、MAPE、SMAPE、MASE、R-Squared）
    forecasters="all",                  # 或者列出：["Holt", "AutoARIMA", "LSTM_TS"]
    max_models=10,                      # 限制模型数量
    use_gpu=True,                       # 对支持的模型启用 GPU 加速
    foundation_model_path="/path/to/timesfm-weights",  # 本地模型权重（离线）
)
scores, predictions = fcst.fit(y_train, y_test)

参数：

• verbose (int): 0 表示静默，1 表示显示进度
• ignore_warnings (bool): 抑制每个模型的异常
• predictions (bool): 返回包含预测值的第二个 DataFrame
• seasonal_period (int/None): 季节性周期长度；设置为 None 时会通过 ACF 自动检测
• cv (int/None): 用于交叉验证的 TimeSeriesSplit 折叠数
• timeout (int/float/None): 每个模型的最大训练时间（秒）
• sort_by (str): 用于排序的指标（"RMSE", "MAE", "MAPE", "SMAPE", "MASE", "R-Squared"）
• forecasters (str/list): "all" 或模型名称列表
• n_lags (int): 用于 ML/DL 模型的滞后特征数量（默认 10）
• n_rolling (tuple): 用于特征工程的滑动窗口大小（默认 (3, 7)）
• max_models (int/None): 限制训练的总模型数量
• custom_metric (callable): 自定义评估指标 f(y_true, y_pred) -> float
• use_gpu (bool): 对支持的模型启用 GPU 加速（默认 False）
• foundation_model_path (str): 预先下载的基础模型权重的本地路径（例如 TimesFM）

可用的模型类别：

• 基准模型: Naive, SeasonalNaive
• 统计模型 (statsmodels): SimpleExpSmoothing, Holt, HoltWinters_Add, HoltWinters_Mul, Theta, SARIMAX
• 统计模型 (pmdarima): AutoARIMA
• 机器学习 (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
• 深度学习 (torch): LSTM_TS, GRU_TS
• 基础模型 (timesfm): TimesFM

GPU 加速

通过设置 use_gpu=True，可以为支持的模型启用 GPU 加速：

from lazypredict.Supervised import LazyClassifier, LazyRegressor

# 分类任务并使用 GPU
clf = LazyClassifier(use_gpu=True, verbose=0, ignore_warnings=True)
models, predictions = clf.fit(X_train, X_test, y_train, y_test)

# 回归任务并使用 GPU
reg = LazyRegressor(use_gpu=True, verbose=0, ignore_warnings=True)
models, predictions = reg.fit(X_train, X_test, y_train, y_test)

# 时间序列预测并使用 GPU
from lazypredict.TimeSeriesForecasting import LazyForecaster
fcst = LazyForecaster(use_gpu=True, verbose=0, ignore_warnings=True)
scores, predictions = fcst.fit(y_train, y_test)

支持的 GPU 后端：

• XGBoost — device="cuda"
• LightGBM — device="gpu"
• CatBoost — task_type="GPU"
• cuML (RAPIDS) — 基于 GPU 的 scikit-learn 替代品（安装后自动识别）
• LSTM / GRU — PyTorch CUDA
• TimesFM — PyTorch CUDA

如果没有可用的 CUDA GPU，则会自动回退到 CPU。

分类编码

Lazy Predict 支持多种分类编码策略：

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

# 包含分类特征的示例
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)

# 尝试不同的编码方法
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()} 编码结果:")
    print(models.head())

注意： 目标编码和二进制编码需要安装 category-encoders 包：

pip install category-encoders

Intel 扩展加速

为了在 Intel CPU 上获得更好的性能，可以安装 Intel Extension for Scikit-learn：

pip install scikit-learn-intelex

Lazy Predict 会自动检测并利用它来加速计算。

MLflow 集成

Lazy Predict 内置了 MLflow 集成。可以通过设置 MLflow 追踪 URI 来启用：

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

# MLflow 追踪将自动启用
reg = LazyRegressor(verbose=0, ignore_warnings=True)
models, predictions = reg.fit(X_train, X_test, y_train, y_test)

自动跟踪的内容包括：

• 模型指标（R-squared、RMSE 等）
• 训练时间
• 模型参数
• 模型工件

LazyPredict 快速上手指南

LazyPredict 是一个高效的 Python 库，旨在通过极少的代码自动构建和评估超过 40 种机器学习模型（涵盖分类、回归及时间序列预测），帮助开发者快速筛选出表现最佳的算法，无需手动调参。

1. 环境准备

在开始之前，请确保您的开发环境满足以下要求：

• 操作系统：Windows, macOS, 或 Linux
• Python 版本：3.9 - 3.13
• 前置依赖：建议预先安装 scikit-learn, pandas, numpy。
  • 若需使用 GPU 加速或时间序列深度模型，请确保已安装对应的 CUDA 驱动及 PyTorch/TensorFlow 环境。

2. 安装步骤

您可以选择 pip 或 conda 进行安装。国内用户推荐使用清华源或阿里源以加速下载。

基础安装

仅安装核心功能（包含基础分类与回归模型）：

# 使用 pip (推荐国内镜像)
pip install lazypredict -i https://pypi.tuna.tsinghua.edu.cn/simple

# 或使用 conda
conda install -c conda-forge lazypredict

可选扩展安装

根据需求安装额外功能模块：

安装提升树模型支持 (XGBoost, LightGBM, CatBoost):

pip install lazypredict[boost] -i https://pypi.tuna.tsinghua.edu.cn/simple

安装时间序列预测支持:

# 统计模型 (ARIMA, ETS 等)
pip install lazypredict[timeseries] -i https://pypi.tuna.tsinghua.edu.cn/simple

# 深度学习模型 (LSTM, GRU)
pip install lazypredict[timeseries,deeplearning] -i https://pypi.tuna.tsinghua.edu.cn/simple

# 基础大模型 (Google TimesFM, 仅限 Python 3.10-3.11)
pip install lazypredict[timeseries,foundation] -i https://pypi.tuna.tsinghua.edu.cn/simple

安装所有依赖:

pip install lazypredict[all] -i https://pypi.tuna.tsinghua.edu.cn/simple

3. 基本使用

LazyPredict 的核心用法非常简洁，只需几行代码即可对比多种模型的效果。

分类任务示例

以下示例展示了如何使用 LazyClassifier 在乳腺癌数据集上自动训练并评估所有可用的分类器。

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)

输出说明： 程序将输出一个 DataFrame，包含每个模型的准确率 (Accuracy)、平衡准确率、ROC AUC、F1 分数以及训练耗时，按性能自动排序。

回归任务示例

以下示例展示了如何使用 LazyRegressor 处理糖尿病数据集的回归问题。

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)

# 划分数据集 (90% 训练，10% 测试)
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)

输出说明： 结果将展示各模型的调整后 R 平方 (Adjusted R-Squared)、R 平方、RMSE (均方根误差) 及训练耗时。

进阶配置提示

若需启用 GPU 加速、设置超时限制或使用特定编码策略，可在初始化时传入参数：

clf = LazyClassifier(
    verbose=1,                   # 显示进度条
    categorical_encoder='onehot',# 分类特征编码方式: 'onehot', 'ordinal', 'target', 'binary'
    timeout=60,                  # 单个模型最大运行时间 (秒)
    use_gpu=True                 # 启用支持的模型的 GPU 加速
)