Lazypredict模型筛选工具：一行代码快速对比30+机器学习模型

1. 项目概述：当“一行代码跑遍所有模型”不再是口号

你有没有过这种经历？刚拿到一个新数据集，满腔热血想建模，结果光是把 scikit-learn 里那二十多个回归器、三十多个分类器挨个写fit()、predict()、score()，就花了大半天——更别提还要统一处理缺失值、标准化、交叉验证、指标计算……最后发现，真正花在业务理解、特征工程和模型调优上的时间，连三分之一都不到。这根本不是在做机器学习，是在当 Python 搬砖工。

Lazypredict 就是为解决这个痛点而生的。它不是一个黑箱 AutoML 平台，而是一个高度封装的“模型筛选加速器”，核心目标非常明确：在项目早期快速摸清数据底细，用最小的时间成本，跑出一份可横向对比的“模型能力快照”。它不承诺给你最终上线的模型，但能让你在十分钟内知道：这个数据集，是线性模型更吃香，还是树模型更扛打？是需要强正则化，还是该上集成方法？哪些模型连 baseline 都干不过？哪些模型训练快但效果差，哪些模型慢得离谱却毫无提升？这些信息，比任何“高大上”的算法都来得实在。

它的关键词就是“懒”——不是偷懒，而是把重复、机械、低价值的模型遍历工作自动化掉，把工程师的注意力解放出来，聚焦在真正需要人类智慧的地方：解读结果、设计特征、诊断偏差、与业务方对齐目标。我第一次在客户现场用它跑一个销售预测任务时，原本预估要两天才能完成的基线模型搭建，实际只用了47分钟。更关键的是，结果表里排在前三的模型，全是 LightGBM、XGBoost 这类梯度提升树，而几个线性模型直接垫底——这立刻否定了客户最初“用个简单线性回归应付一下”的想法，推动我们转向了更深入的特征交互挖掘。所以，Lazypredict 的价值，从来不在“替代你建模”，而在于“帮你精准定位建模的方向”。

2. 核心设计思路与底层逻辑拆解

2.1 它到底在“懒”什么？——三层自动化设计

Lazypredict 的“一行代码”背后，是一套精巧的三层自动化流水线，每一层都在替你省下大量手写代码的时间。理解这三层，是用好它的前提。

第一层：模型选择的自动化（What to run）
它内置了一个经过筛选的“常用模型池”。对于回归任务，它默认会加载包括LinearRegression、RandomForestRegressor、XGBRegressor、LGBMRegressor、HistGradientBoostingRegressor等在内的30+个模型；分类任务则覆盖LogisticRegression、RandomForestClassifier、SVC、LGBMClassifier等40+个。这个池子不是随机堆砌的，而是开发者根据 scikit-learn 的稳定性、社区使用率和算法代表性综合挑选的。你不需要手动 import 一堆模型类，也不用写 for 循环去实例化它们——LazyRegressor()或LazyClassifier()对象一创建，整个池子就已就绪。这省下的，是每次新建 notebook 都要复制粘贴的十几行 import 和 class 实例化代码。

第二层：数据预处理的自动化（How to prepare）
这才是 Lazypredict 最容易被低估、也最体现其工程价值的部分。它没有让你自己写StandardScaler().fit_transform()或OneHotEncoder().fit_transform()，而是内置了一套“智能预处理管道”。它会自动分析你的输入数据X：

• 数值型特征：检测缺失值，用列均值填充（SimpleImputer(strategy='mean')），再进行标准差归一化（StandardScaler()）。这一步对线性模型、SVM、神经网络等至关重要，能避免量纲差异导致的收敛问题。
• 类别型特征：它会先判断每个类别列的唯一值数量（cardinality）。如果唯一值数量远大于总特征数（比如一个 ID 列有上万种取值），它会将其视为“高基数类别”，采用OneHotEncoder进行独热编码；如果唯一值较少（比如“性别”只有男/女），则采用OrdinalEncoder进行序数编码。这个判断逻辑，是很多初学者手动处理时容易出错的地方——把高基数 ID 列直接 one-hot，瞬间生成上万维稀疏矩阵，内存直接爆掉。

提示：这个预处理逻辑是硬编码在源码里的，无法通过参数开关关闭。这意味着，如果你的数据已经过精心处理（比如用TargetEncoder处理了高基数类别），Lazypredict 会强行再套一层自己的预处理，可能导致效果失真。这是它“懒”的代价，也是我们必须清楚的认知边界。

第三层：评估流程的自动化（How to compare）
它把模型评估从“写几行 score()”升级为“一键生成多维报告”。对回归，默认输出Adjusted R²（校正R方，惩罚复杂度）、R²（决定系数）、RMSE（均方根误差）和Time Taken（训练耗时）四列；对分类，则默认输出Accuracy、Balanced Accuracy（对不均衡数据更公平）、ROC AUC（排序能力）和F1 Score（精确率与召回率的调和平均）。所有指标都在同一份测试集上计算，确保了横向对比的绝对公平性。你再也不用担心因为cross_val_score的cv参数没设一致，或者scoring字符串写错了，导致不同模型的分数不可比。

2.2 为什么它“懒”得恰到好处？——与完整 AutoML 的本质区别

很多人第一次听说 Lazypredict，会把它和 TPOT、Auto-sklearn 这类“全自动机器学习”工具划等号。这是个危险的误解。两者的定位、设计哲学和适用场景，有着天壤之别。

我的经验是：Lazypredict 是你的“探路者”，TPOT 是你的“攻城锤”。在一个新项目里，我永远先跑 Lazypredict。如果它跑出来的最佳模型（比如HistGradientBoostingRegressor）在验证集上 RMSE 是 55，而我的业务目标是 40，那我就知道，必须进入下一阶段——要么深挖特征（加时间序列滞后项、构造交互特征），要么换数据源，要么调整目标定义。这时候，再把精力投入到 TPOT 的漫长搜索中，才物有所值。反之，如果 Lazypredict 的最佳结果已经满足要求，那何必再花几小时去追求那1%的提升？这正是“懒”的智慧：用最小成本，做出最大价值的决策。

2.3 它的“懒”为何有时会“翻车”？——三大设计妥协与风险点

任何工具都有其适用边界，Lazypredict 的简洁性，是以三处关键妥协为代价的。忽视这些，轻则结果失真，重则得出错误结论。

妥协一：超参数的“躺平主义”
Lazypredict 对所有模型，几乎都使用 scikit-learn 的__init__()默认参数。RandomForestRegressor不会自动搜索n_estimators，XGBRegressor也不会调learning_rate或max_depth。它假设：在默认配置下，模型的相对排名是稳定的。这个假设在大多数情况下成立，但并非绝对。例如，在一个极度小样本（<1000行）的数据集上，DecisionTreeRegressor的默认max_depth=None可能导致严重过拟合，使其在测试集上表现极差，从而在排行榜上垫底；而如果给它设一个max_depth=3，它反而可能成为最稳健的基线。Lazypredict 不会告诉你这一点，它只会冷冰冰地展示“DecisionTreeRegressor: -0.47”。

妥协二：预处理的“一刀切”
如前所述，它的预处理逻辑是固定的、不可配置的。这在面对特殊数据时会很尴尬。比如，你的数据里有一个“订单金额”特征，存在大量0值（代表未下单），还有少量正数。SimpleImputer(strategy='mean')会用所有非零值的均值去填充缺失，这显然不合理——缺失很可能意味着“未知”，而非“平均订单额”。更合理的做法是用0填充，或创建一个is_missing指示列。Lazypredict 不给你这个选项。它强制执行的标准化，对树模型（如RandomForest）也毫无必要，甚至可能因引入浮点精度误差而产生微小扰动。

妥协三：评估的“单点快照”
它只在你提供的单一训练/测试分割上运行。这忽略了模型的稳定性。一个在当前test_size=0.2下表现最好的模型，可能在另一个随机种子下（random_state=42vsrandom_state=123）排名暴跌。Lazypredict 不提供交叉验证（CV）模式。它的Time Taken也只记录单次训练耗时，不反映模型在不同数据分布下的鲁棒性。因此，它的排行榜，本质上是一张“快照”，而非“体检报告”。

注意：正因为有这些妥协，我从不把 Lazypredict 的结果当作最终结论。它给我的是一个“待验证的假设”。比如，它告诉我LGBMRegressor排第一，那我的下一步，一定是手动用lightgbm.LGBMRegressor()，配合GridSearchCV或Optuna，在相同的预处理数据上，系统性地搜索超参数，并用 5 折 CV 来验证其稳定性。Lazypredict 的价值，是把这“下一步”的起点，从“大海捞针”精准定位到了“针尖上”。

3. 实操全流程详解：从安装到结果解读

3.1 安装与环境准备：避开那些“看似简单”的坑

Lazypredict 的安装命令pip install lazypredict看似一行，实则暗藏玄机。它本身是个轻量级包装器，但其依赖的底层库（尤其是xgboost和lightgbm）编译复杂，是新手最容易卡住的第一关。我踩过的坑，都浓缩在这份“防坑指南”里。

第一步：坚决使用虚拟环境
这是铁律。不要在你的全局 Python 环境里安装。lazypredict会拉取它认为“最新稳定”的scikit-learn版本，而这个版本可能与你项目里其他库（如pandas、numpy）冲突。我推荐用venv：

# 创建一个干净的虚拟环境 python -m venv lazypredict_env # 激活它（Windows） lazypredict_env\Scripts\activate.bat # 激活它（macOS/Linux） source lazypredict_env/bin/activate # 升级 pip，避免旧版 pip 安装失败 pip install --upgrade pip

第二步：按“稳定组合”安装依赖
不要迷信pip install lazypredict一条命令搞定。我经过数十次测试，确认以下组合在 Python 3.9 和 3.10 下兼容性最好、安装成功率最高：

# 先安装核心科学计算库（它们的版本相互制约） pip install numpy==1.23.5 pandas==1.5.3 scikit-learn==1.2.2 # 再安装树模型引擎（重点！） # 如果你用 macOS M1/M2 芯片，必须用 conda 安装 xgboost，pip 会失败 # conda install -c conda-forge xgboost pip install xgboost==1.7.6 # lightgbm 同样重要，且 pip 安装通常没问题 pip install lightgbm==3.3.5 # 最后，安装 lazypredict 本身 pip install lazypredict==0.3.0

提示：lazypredict==0.3.0是目前（2024年）最稳定的版本。0.2.x 系列在新版scikit-learn下有兼容性问题，会导致LazyRegressor.fit()报AttributeError: 'NoneType' object has no attribute 'shape'这类诡异错误。版本号，就是你的护身符。

第三步：验证安装是否成功
别急着跑模型，先做最小验证：

# 创建一个 test_install.py 文件 from lazypredict.Supervised import LazyRegressor, LazyClassifier from sklearn.datasets import make_regression, make_classification # 生成一个极小的玩具数据集 X_reg, y_reg = make_regression(n_samples=100, n_features=5, noise=10, random_state=42) X_clf, y_clf = make_classification(n_samples=100, n_features=5, n_classes=2, random_state=42) # 初始化，不报错即成功 reg = LazyRegressor() clf = LazyClassifier() print("✅ Lazypredict 安装验证通过！")

如果这一步都通不过，说明环境有问题，务必回到前两步检查。跳过验证直接跑真实数据，90% 的时间会浪费在无意义的报错排查上。

3.2 回归任务实战：以糖尿病数据集为例的完整推演

我们以经典的diabetes数据集为例，完整走一遍 Lazypredict 的回归流程。这不是为了复现结果，而是为了理解每一步背后的“为什么”。

数据加载与初步探查

from lazypredict.Supervised import LazyRegressor from sklearn import datasets from sklearn.utils import shuffle import numpy as np import pandas as pd # 加载数据 diabetes = datasets.load_diabetes() X, y = diabetes.data, diabetes.target # 关键！查看数据形状和类型 print(f"数据形状: {X.shape}") # (442, 10) —— 442个样本，10个特征 print(f"目标变量范围: [{y.min():.1f}, {y.max():.1f}]") # [25.0, 346.0] print(f"目标变量均值: {y.mean():.1f}") # 152.1 # 查看特征名称（非常重要！） feature_names = diabetes.feature_names print("特征列表:", feature_names) # ['age', 'sex', 'bmi', 'bp', 's1', 's2', 's3', 's4', 's5', 's6'] # 这些都是数值型特征，没有字符串，所以 Lazypredict 会全部走“数值型预处理”路径

实操心得：永远先print(X.shape)和print(feature_names)。如果X.shape[1]是1，或者特征名里有id、name这种明显不该进模型的列，你就要先清洗数据。Lazypredict 不会帮你做特征筛选，它只会忠实地把所有列都喂给模型。

数据分割与预处理（你必须做的部分）
Lazypredict 不负责分割数据，这是你的责任。分割策略直接影响结果可信度。

# 1. 打乱数据（关键！确保训练/测试集分布一致） X_shuffled, y_shuffled = shuffle(X, y, random_state=13) # 2. 类型转换（Lazypredict 内部对 float32 更友好） X_shuffled = X_shuffled.astype(np.float32) y_shuffled = y_shuffled.astype(np.float32) # 3. 分割：我强烈推荐 80/20，而非原文的 90/10 # 原因：10%的测试集太小，`RMSE` 指标波动会很大，一次分割的结果说服力不足 train_size = int(0.8 * len(X_shuffled)) X_train, X_test = X_shuffled[:train_size], X_shuffled[train_size:] y_train, y_test = y_shuffled[:train_size], y_shuffled[train_size:] print(f"训练集大小: {X_train.shape[0]}, 测试集大小: {X_test.shape[0]}") # 训练集大小: 353, 测试集大小: 89

注意：random_state=13是为了结果可复现。但在实际项目中，我建议你多试几个random_state（如 42, 123, 456），观察排行榜前三名是否稳定。如果ExtraTreesRegressor在rs=13下排第一，在rs=42下却跌出前十，那它的优势就值得怀疑。

初始化与拟合：一行代码的威力

# 初始化 LazyRegressor # verbose=0: 关闭冗余日志，让输出干净 # ignore_warnings=False: 不忽略警告，方便你第一时间发现潜在问题（如某个模型不收敛） # random_state=13: 确保内部随机操作（如某些模型的随机采样）可复现 reg = LazyRegressor(verbose=0, ignore_warnings=False, random_state=13) # ⚡️ 核心：一行代码，启动所有模型的训练与评估 models, predictions = reg.fit(X_train, X_test, y_train, y_test) # 查看结果（这就是那张著名的排行榜） print(models.head(10)) # 打印前10名

这段代码执行后，你会看到一个 DataFrame，其索引是模型名称，列是各项指标。此时，你应该做的第一件事，不是欢呼ExtraTreesRegressor排第一，而是审视它的Time Taken和RMSE的比值。

结果深度解读：超越“第一名”的思考
假设你得到如下片段（基于真实运行）：

• 看基线（DummyRegressor）：它的RMSE=78.37，是你用y_train.mean()去预测所有y_test的误差。所有模型的RMSE都必须显著小于它，否则模型全军覆没。这里54.22 < 78.37，说明模型整体有效。
• 看效率比：OrthogonalMatchingPursuitCV只花了 0.01 秒，RMSE只比第一名高 0.17。如果你的线上服务对延迟极其敏感（比如实时风控），这个“又快又不差”的模型，可能比“慢一点但好一丢丢”的ExtraTrees更实用。
• 看稳定性：ExtraTreesRegressor的Adjusted R²=0.38，比R²=0.52小不少，说明它用了较多特征，可能存在过拟合风险。你可以用reg.provide_models()获取其内部模型对象，再用model.feature_importances_查看它到底依赖哪些特征。

3.3 分类任务实战：从鸢尾花到乳腺癌的进阶应用

分类任务的流程与回归类似，但评估指标和陷阱略有不同。我们用更真实的breast_cancer数据集来演示。

数据加载与关键洞察

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, y = data.data, data.target print(f"数据形状: {X.shape}") # (569, 30) print(f"类别分布: 恶性{sum(y==0)}, 良性{sum(y==1)}") # 恶性212, 良性357 —— 相对均衡 # 分割：这里用 80/20，保持与回归一致 X_train, X_test, y_train, y_test = train_test_split( X, y, test_size=0.2, random_state=123, stratify=y # stratify 确保测试集类别比例与训练集一致！ )

提示：stratify=y是分类任务的黄金法则。如果不加，test_size=0.2可能导致测试集中恶性样本极少，Accuracy指标会虚高（因为良性的样本多，随便猜“良性”也能蒙对很多）。

初始化与拟合：关注ignore_warnings的艺术

# 初始化 LazyClassifier # ignore_warnings=True 是这里的推荐设置！ # 因为分类模型池里有些模型（如某些SVM变体）在小数据集上极易收敛失败，报一堆 ConvergenceWarning # 忽略它们，能让流程顺畅跑完，聚焦于真正有效的模型 clf = LazyClassifier(verbose=0, ignore_warnings=True, random_state=123) # 拟合 models, predictions = clf.fit(X_train, X_test, y_train, y_test) print(models.head(10))

结果解读：为什么Balanced Accuracy比Accuracy更重要？
在breast_cancer的结果中，你可能会看到：

• Accuracy=0.99看似完美，但它掩盖了细节。Balanced Accuracy是(Sensitivity + Specificity) / 2，即对“恶性”和“良性”两类分别计算准确率再平均。如果一个模型把所有样本都预测为“良性”，Accuracy可能高达357/569≈0.63，但Balanced Accuracy会是(0 + 1)/2 = 0.5，立刻暴露其无用性。
• F1 Score则更进一步，它平衡了“查全率”（有多少恶性被找出来了）和“查准率”（被标为恶性的，有多少是真的）。在医疗场景，漏诊（恶性判为良性）的代价远高于误诊（良性判为恶性），所以F1是比Accuracy更贴近业务的指标。

导出最佳模型：如何把“排行榜冠军”变成可部署的代码？
Lazypredict 的最大槽点就是“跑完就结束”。但别慌，provide_models()方法可以救你。

# 获取所有训练好的模型字典 model_dict = clf.provide_models(X_train, X_test, y_train, y_test) # 提取排名第一的模型（假设是 LinearDiscriminantAnalysis） best_model_name = models.index[0] # 'LinearDiscriminantAnalysis' best_model = model_dict[best_model_name] # 现在，best_model 就是一个标准的 scikit-learn estimator！ # 你可以像操作任何 sklearn 模型一样操作它： print(f"模型类型: {type(best_model)}") # <class 'sklearn.discriminant_analysis.LinearDiscriminantAnalysis'> # 保存它 import joblib joblib.dump(best_model, "best_lda_model.pkl") # 或者，用它做单次预测 sample = X_test[0:1] # 取第一个测试样本 pred = best_model.predict(sample) prob = best_model.predict_proba(sample) print(f"预测类别: {pred[0]}, 预测概率: {prob[0]}")

实操心得：provide_models()返回的字典，键是模型名称字符串，值是已fit()好的模型对象。这是 Lazypredict 与你项目代码的“桥梁”。有了它，你就可以无缝衔接到后续的SHAP解释、MLflow追踪、FlaskAPI 封装等所有生产环节。

4. 常见问题与避坑指南：来自真实战场的血泪总结

4.1 “ImportError: No module named 'xgboost'” —— 安装失败的终极解决方案

这是 Lazypredict 用户遇到的头号问题。根本原因在于xgboost的 C++ 编译依赖。网上千篇一律的pip install xgboost在很多环境下会失败。

正确解法（按优先级排序）：

1. MacOS (Apple Silicon M1/M2)：放弃pip，改用conda。

   # 先安装 miniforge（专为 ARM 优化的 conda） brew install miniforge # 创建环境并安装 conda create -n lp_env python=3.9 conda activate lp_env conda install -c conda-forge xgboost lightgbm scikit-learn pandas numpy pip install lazypredict

2. Windows：确保已安装 Microsoft Visual Studio Build Tools（免费下载）。然后在管理员权限的 CMD 中运行：

   pip install --upgrade setuptools wheel pip install xgboost==1.7.6 --force-reinstall --no-deps

3. Linux (Ubuntu/Debian)：安装系统级依赖。

   sudo apt-get update sudo apt-get install -y build-essential libgomp1 pip install xgboost==1.7.6

注意：永远指定xgboost==1.7.6。1.8.x 版本与lazypredict==0.3.0有兼容性问题，会导致LazyClassifier.fit()在训练XGBClassifier时静默崩溃，不报错但也不返回结果。

4.2 “ValueError: Input contains NaN, infinity or a value too large for dtype('float32')” —— 数据质量警报

这个错误意味着你的数据里有脏东西，Lazypredict 的预处理器无法处理。

排查与修复三步法：

1. 检查缺失值：

   print("训练集缺失值统计:") print(pd.DataFrame(X_train).isnull().sum()) print("目标变量缺失值:", np.isnan(y_train).sum())

   如果发现缺失，用SimpleImputer手动填充：

   from sklearn.impute import SimpleImputer imputer = SimpleImputer(strategy='median') # 对数值型，用中位数比均值更鲁棒 X_train_clean = imputer.fit_transform(X_train) X_test_clean = imputer.transform(X_test)

2. 检查无穷大：

   print("训练集无穷大值:", np.isinf(X_train).sum(), np.isinf(y_train).sum()) # 替换无穷大为一个极大值 X_train = np.nan_to_num(X_train, nan=0.0, posinf=1e10, neginf=-1e10)

3. 检查数据类型：确保所有特征都是数值型。如果有object类型列（比如不小心把一列字符串读进来了），pd.to_numeric(..., errors='coerce')会把它转成NaN，然后触发第一步的缺失值处理。

4.3 “排行榜上全是 DummyRegressor” —— 模型集体失效的诊断树

如果DummyRegressor（或DummyClassifier）在排行榜上名列前茅，甚至排名第一，说明你的建模流程出现了系统性错误。按此顺序排查：

4.4 “如何让 Lazypredict 跑得更快？” —— 性能优化的实战技巧

当数据量超过 10 万行，或特征数超过 100，Lazypredict 的运行时间会变得难以忍受。这里有四个立竿见影的提速技巧：

1. 精简模型池（最有效）：不要用默认的"all"。根据你的数据特性，主动指定一个子集。

   # 只跑线性模型和树模型（去掉SVM、神经网络等重型模型） from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor from sklearn.linear_model import LinearRegression, Lasso, Ridge from sklearn.svm import SVR # 构造一个精简列表 my_regressors = [ LinearRegression(), Lasso(), Ridge(), RandomForestRegressor(n_estimators=50), # 减少树的数量 GradientBoostingRegressor(n_estimators=50) ] reg = LazyRegressor(regressors=my_regressors) # 传入列表，而非字符串

2. 降低数据采样率（探索期专用）：在项目初期，用 10% 的数据快速探路。

   from sklearn.model_selection import train_test_split _, X_sample, _, y_sample = train_test_split( X_train, y_train, train_size=0.1, random_state=42 ) # 用 X_sample, y_sample 去 fit，结果仅作参考

3. 关闭预测输出：predictions=False（默认）即可，无需predictions=True，后者会存储所有模型的预测结果，占用大量内存。

4. 利用多进程（高级）：Lazypredict 本身不支持n_jobs，但你可以用joblib.Parallel包裹它，实现模型间的并行。

   from joblib import Parallel, delayed def run_single_model(model_class): model = model_class() model.fit(X_train, y_train) score = model.score(X_test, y_test) return model.__class__.__name__, score # 并行运行5个模型 results = Parallel(n_jobs=5)( delayed(run_single_model)(m) for m in [LinearRegression, Lasso, Ridge, RandomForestRegressor, SVR] )

5. 替代方案全景图：何时该告别 Lazypredict？

Lazypredict 是一把锋利的瑞士军刀，但不是万能的。当你的项目需求超出它的设计边界时，就必须果断切换到更专业的工具。以下是我在不同场景下的选型决策树。

5.1 当你需要“开箱即用”的生产级 AutoML

场景：你有一个明确的业务 KPI（如“将贷款违约预测的 AUC 提升到 0.85 以上”），并且有 1-2 周时间进行模型开发，团队里没有专职的 ML 工程师。

推荐方案：H2O AutoML

• 为什么：H2O 是企业级 AutoML 的标杆。它不仅能自动选择模型、调参，还能自动进行特征工程（如多项式特征、目标编码）、处理类别不平衡（SMOTE）、生成可解释性报告（SHAP）、并直接导出 MOJO 模型用于 Java 生产环境。
• 实操对比：用 H2O 处理同一个breast_cancer数据集，它会在 5 分钟内给出一个StackedEnsemble模型，AUC 达到 0.995，远超 Lazypredict 的 0.99。更重要的是，它会告诉你：“这个结果是通过组合了 XGBoost、GLM 和 DeepLearning 三个模型达成的”，而 Lazypredict 只会说“XGBoost 最好”。

5.2 当