优化

PyCaret 中的优化函数

tune_model

此函数用于调优模型的超参数。此函数的输出是一个评分网格，其中包含按 fold 进行交叉验证的分数。最佳模型根据 optimize 参数中定义的指标进行选择。可以使用 get_metrics 函数访问交叉验证期间评估的指标。可以使用 add_metric 和 remove_metric 函数添加或删除自定义指标。

示例

# load dataset
from pycaret.datasets import get_data 
boston = get_data('boston') 

# init setup
from pycaret.regression import * 
reg1 = setup(data = boston, target = 'medv')

# train model
dt = create_model('dt')

# tune model
tuned_dt = tune_model(dt)

tune_model(dt) 的输出

比较超参数。

# default model
print(dt)

# tuned model
print(tuned_dt)

模型调优前后的超参数

增加迭代次数

超参数调优本质上是一种优化，受迭代次数的限制，这最终取决于你可用的时间和资源。迭代次数由 n_iter 定义。默认情况下，它设置为 10。

# load dataset
from pycaret.datasets import get_data 
boston = get_data('boston') 

# init setup
from pycaret.regression import * 
reg1 = setup(data = boston, target = 'medv')

# train model
dt = create_model('dt')

# tune model
tuned_dt = tune_model(dt, n_iter = 50)

tune_model(dt, n_iter = 50) 的输出

10 次和 50 次迭代的比较

n_iter = 10

n_iter = 50

选择评估指标

调优模型超参数时，你必须知道要优化哪个指标。可以在 optimize 参数下定义。默认情况下，对于分类实验，它设置为 Accuracy，对于回归实验，设置为 R2。

# load dataset
from pycaret.datasets import get_data 
boston = get_data('boston') 

# init setup
from pycaret.regression import * 
reg1 = setup(data = boston, target = 'medv')

# train model
dt = create_model('dt')

# tune model
tuned_dt = tune_model(dt, optimize = 'MAE')

tune_model(dt, optimize = 'MAE') 的输出

传递自定义网格

PyCaret 库中的所有模型都已定义超参数的调优网格。但是，如果需要，可以使用 custom_grid 参数通过传递自定义网格来定义自己的搜索空间。

# load dataset
from pycaret.datasets import get_data 
boston = get_data('boston') 

# init setup
from pycaret.regression import * 
reg1 = setup(boston, target = 'medv')

# train model
dt = create_model('dt')

# define search space
params = {"max_depth": np.random.randint(1, (len(boston.columns)*.85),20),
          "max_features": np.random.randint(1, len(boston.columns),20),
          "min_samples_leaf": [2,3,4,5,6]}
          
# tune model
tuned_dt = tune_model(dt, custom_grid = params)

tune_model(dt, custom_grid = params) 的输出

更改搜索算法

PyCaret 与许多不同的库无缝集成，用于超参数调优。这使你可以访问许多不同类型的搜索算法，包括随机搜索、贝叶斯搜索、Optuna、TPE 等。所有这些都只需更改一个参数即可实现。默认情况下，PyCaret 使用 sklearn 中的 RandomGridSearch，你可以通过在 tune_model 函数中使用 search_library 和 search_algorithm 参数来更改它。

# load dataset
from pycaret.datasets import get_data 
boston = get_data('boston') 

# init setup
from pycaret.regression import * 
reg1 = setup(boston, target = 'medv')

# train model
dt = create_model('dt')

# tune model sklearn
tune_model(dt)

# tune model optuna
tune_model(dt, search_library = 'optuna')

# tune model scikit-optimize
tune_model(dt, search_library = 'scikit-optimize')

# tune model tune-sklearn
tune_model(dt, search_library = 'tune-sklearn', search_algorithm = 'hyperopt')

scikit-learn

optuna

scikit-optimize

tune-sklearn

访问调优器

默认情况下，PyCaret 的 tune_model 函数只返回调优器选择的最佳模型。有时你可能需要访问调优器对象，因为它可能包含重要的属性，你可以使用 return_tuner 参数。

# load dataset
from pycaret.datasets importh get_data 
boston = get_data('boston') 

# init setup
from pycaret.regression import * 
reg1 = setup(boston, target = 'medv')

# train model
dt = create_model('dt')

# tune model and return tuner
tuned_model, tuner = tune_model(dt, return_tuner=True)

tune_model(dt, return_tuner=True) 的输出

type(tuned_model), type(tuner)

type(tuned_model), type(tuner) 的输出

print(tuner)

print(tuner) 的输出

自动选择更好的模型

通常情况下，tune_model 不会提升模型性能。实际上，它可能会使性能比使用默认超参数的模型更差。当你不是在 Notebook 中主动实验，而是有一个 Python 脚本运行 create_model --> tune_model 或 compare_models --> tune_model 的工作流时，这可能会带来问题。为了解决这个问题，你可以使用 choose_better。当设置为 True 时，它将始终返回性能更好的模型，这意味着如果超参数调优没有提升性能，它将返回输入模型。

# load dataset
from pycaret.datasets import get_data 
boston = get_data('boston') 

# init setup
from pycaret.regression import * 
reg1 = setup(boston, target = 'medv')

# train model
dt = create_model('dt')

# tune model
dt = tune_model(dt, choose_better = True)

tune_model(dt, choose_better = True) 的输出

注意：choose_better 不影响屏幕上显示的评分网格。评分网格始终显示调优器选择的最佳模型的性能，无论输出性能是否小于输入性能。

ensemble_model

此函数对给定的评估器进行集成。此函数的输出是一个评分网格，其中包含按 fold 进行的 CV 分数。可以使用 get_metrics 函数访问 CV 期间评估的指标。可以使用 add_metric 和 remove_metric 函数添加或删除自定义指标。

示例

# load dataset
from pycaret.datasets import get_data 
boston = get_data('boston') 

# init setup
from pycaret.regression import * 
reg1 = setup(boston, target = 'medv')

# train model
dt = create_model('dt')

# ensemble model
bagged_dt = ensemble_model(dt)

ensemble_model(dt) 的输出

type(bagged_dt)
# >>> sklearn.ensemble._bagging.BaggingRegressor

print(bagged_dt)

print(bagged_dt) 的输出

更改 fold 参数

# load dataset
from pycaret.datasets import get_data 
boston = get_data('boston') 

# init setup
from pycaret.regression import * 
reg1 = setup(boston, target = 'medv')

# train model
dt = create_model('dt')

# ensemble model
bagged_dt = ensemble_model(dt, fold = 5)

ensemble_model(dt, fold = 5) 的输出

此函数返回的模型与上面相同，但是，性能评估是使用 5 折交叉验证完成的。

方法：Bagging

Bagging，也称为 Bootstrap aggregating，是一种机器学习集成元算法，旨在提高统计分类和回归中使用的机器学习算法的稳定性和准确性。它还可以减少方差并帮助避免过拟合。虽然它通常应用于决策树方法，但它可以用于任何类型的方法。Bagging 是模型平均方法的一个特例。

方法：Boosting

Boosting 是一种主要用于减少监督学习中偏差和方差的集成元算法。Boosting 属于将弱学习器转换为强学习器的机器学习算法家族。弱学习器被定义为与真实分类仅轻微相关的分类器（它可以比随机猜测更好地标记示例）。相反，强学习器是与真实分类任意良好相关的分类器。

选择方法

使用 ensemble_model 集成机器学习模型有两种可能的方式。可以在 method 参数中定义。

# load dataset
from pycaret.datasets import get_data 
boston = get_data('boston') 

# init setup
from pycaret.regression import * 
reg1 = setup(boston, target = 'medv')

# train model
dt = create_model('dt')

# ensemble model
boosted_dt = ensemble_model(dt, method = 'Boosting')

ensemble_model(dt, method = 'Boosting') 的输出

type(boosted_dt)
# >>> sklearn.ensemble._weight_boosting.AdaBoostRegressor

print(boosted_dt)

print(boosted_dt) 的输出

增加评估器数量

默认情况下，PyCaret 对 Bagging 和 Boosting 都使用 10 个评估器。可以通过更改 n_estimators 参数来增加数量。

# load dataset
from pycaret.datasets import get_data 
boston = get_data('boston') 

# init setup
from pycaret.regression import * 
reg1 = setup(boston, target = 'medv')

# train model
dt = create_model('dt')

# ensemble model
ensemble_model(dt, n_estimators = 100)

ensemble_model(dt, n_estimators = 100) 的输出

自动选择更好的模型

通常情况下，ensemble_model 不会提升模型性能。实际上，它可能会使性能比没有集成时更差。当你不是在 Notebook 中主动实验，而是有一个 Python 脚本运行 create_model --> ensemble_model 或 compare_models --> ensemble_model 的工作流时，这可能会带来问题。为了解决这个问题，你可以使用 choose_better。当设置为 True 时，它将始终返回性能更好的模型，这意味着如果集成没有提升性能，它将返回输入模型。

# load dataset
from pycaret.datasets import get_data 
boston = get_data('boston') 

# init setup
from pycaret.regression import * 
reg1 = setup(boston, target = 'medv')

# train model
lr = create_model('lr')

# ensemble model
ensemble_model(lr, choose_better = True)

ensemble_model(lr, choose_better = True) 的输出

请注意，当 choose_better = True 时，从 ensemble_model 返回的模型是简单的 LinearRegression，而不是 BaggedRegressor。这是因为集成后模型性能没有提升，因此返回了输入模型。

blend_models

此函数为在 estimator_list 参数中传递的选定模型训练一个软投票/多数规则分类器。此函数的输出是一个评分网格，其中包含按 fold 进行的 CV 分数。可以使用 get_metrics 函数访问 CV 期间评估的指标。可以使用 add_metric 和 remove_metric 函数添加或删除自定义指标。

示例

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a few models
lr = create_model('lr')
dt = create_model('dt')
knn = create_model('knn')

# blend models
blender = blend_models([lr, dt, knn])

blend_models([lr, dt, knn]) 的输出

type(blender)
# >>> sklearn.ensemble._voting.VotingClassifier

print(blender)

print(blender) 的输出

更改 fold 参数

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a few models
lr = create_model('lr')
dt = create_model('dt')
knn = create_model('knn')

# blend models
blender = blend_models([lr, dt, knn], fold = 5)

blend_models([lr, dt, knn], fold = 5) 的输出

此函数返回的模型与上面相同，但是，性能评估是使用 5 折交叉验证完成的。

动态输入评估器

你还可以使用compare_models函数自动生成输入评估器列表。这样做的好处是完全无需更改脚本。每次都会将排名前 N 的模型用作输入列表。

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# blend models
blender = blend_models(compare_models(n_select = 3))

blend_models(compare_models(n_select = 3)) 的输出

注意这里发生了什么。我们将 compare_models(n_select = 3 作为输入传递给了 blend_models。内部发生的事情是，首先执行了 compare_models 函数，然后将排名前 3 的模型作为输入传递给了 blend_models 函数。

print(blender)

print(blender) 的输出

在此示例中，根据 compare_models 评估，排名前 3 的模型是 LogisticRegression、LinearDiscriminantAnalysis 和 RandomForestClassifier。

更改方法

当 method = 'soft' 时，它根据预测概率之和的 argmax 预测类别标签，这对于良好校准的分类器集成是推荐的方法。

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a few models
lr = create_model('lr')
dt = create_model('dt')
knn = create_model('knn')

# blend models
blender_soft = blend_models([lr,dt,knn], method = 'soft')

blend_models([lr,dt,knn], method = 'soft') 的输出

当 method = 'hard' 时，它使用输入模型的预测（硬标签）而不是概率。

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a few models
lr = create_model('lr')
dt = create_model('dt')
knn = create_model('knn')

# blend models
blender_hard = blend_models([lr,dt,knn], method = 'hard')

blend_models([lr,dt,knn], method = 'hard') 的输出

默认方法设置为 auto，这意味着它将尝试使用 soft 方法，如果不支持则回退到 hard，这可能在你输入模型中有一个不支持 predict_proba 属性时发生。

注意：方法参数仅在分类模块中可用。

更改权重

默认情况下，在混合模型时，所有输入模型都被赋予相同的权重，但你可以明确传递每个输入模型的权重。

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a few models
lr = create_model('lr')
dt = create_model('dt')
knn = create_model('knn')

# blend models
blender_weighted = blend_models([lr,dt,knn], weights = [0.5,0.2,0.3])

blend_models([lr,dt,knn], weights = [0.5,0.2,0.3]) 的输出

你还可以使用 tune_model 调优混合器的权重。

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a few models
lr = create_model('lr')
dt = create_model('dt')
knn = create_model('knn')

# blend models
blender_weighted = blend_models([lr,dt,knn], weights = [0.5,0.2,0.3])

# tune blender
tuned_blender = tune_model(blender_weighted)

tune_model(blender_weighted) 的输出

print(tuned_blender)

print(tuned_blender) 的输出

自动选择更好的模型

通常情况下，blend_models 不会提升模型性能。实际上，它可能会使性能比没有混合时更差。当你不是在 Notebook 中主动实验，而是有一个 Python 脚本运行 compare_models --> blend_models 的工作流时，这可能会带来问题。为了解决这个问题，你可以使用 choose_better。当设置为 True 时，它将始终返回性能更好的模型，这意味着如果混合模型没有提升性能，它将返回性能最佳的单个输入模型。

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a few models
lr = create_model('lr')
dt = create_model('dt')
knn = create_model('knn')

# blend models
blend_models([lr,dt,knn], choose_better = True)

blend_models([lr,dt,knn], choose_better = True) 的输出

请注意，由于 choose_better=True，此函数返回的最终模型是 LogisticRegression，而不是 VotingClassifier，因为 Logistic Regression 的性能在所有给定的输入模型和混合器中得到了最大的优化。

stack_models

此函数在 estimator_list 参数中传递的选定评估器之上训练一个元模型。此函数的输出是一个评分网格，其中包含按 fold 进行的 CV 分数。可以使用 get_metrics 函数访问 CV 期间评估的指标。可以使用 add_metric 和 remove_metric 函数添加或删除自定义指标。

示例

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a few models
lr = create_model('lr')
dt = create_model('dt')
knn = create_model('knn')

# stack models
stacker = stack_models([lr, dt, knn])

stack_models([lr, dt, knn]) 的输出

更改 fold 参数

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a few models
lr = create_model('lr')
dt = create_model('dt')
knn = create_model('knn')

# stack models
stacker = stack_models([lr, dt, knn], fold = 5)

stack_models([lr, dt, knn], fold = 5) 的输出

此函数返回的模型与上面相同，但是，性能评估是使用 5 折交叉验证完成的。

动态输入评估器

你还可以使用compare_models函数自动生成输入评估器列表。这样做的好处是完全无需更改脚本。每次都会将排名前 N 的模型用作输入列表。

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# stack models
stacker = stack_models(compare_models(n_select = 3))

stack_models(compare_models(n_select = 3)) 的输出

注意这里发生了什么。我们将 compare_models(n_select = 3 作为输入传递给了 stack_models。内部发生的事情是，首先执行了 compare_models 函数，然后将排名前 3 的模型作为输入传递给了 stack_models 函数。

print(stacker)

print(stacker) 的输出

在此示例中，根据 compare_models 评估，排名前 3 的模型是 LogisticRegression、RandomForestClassifier 和 LGBMClassifier。

更改方法

有几种不同的方法可以明确选择用于堆叠，或者传递 auto 以自动确定。当设置为 auto 时，它将按顺序为每个模型调用 predict_proba、decision_function 或 predict 函数。或者，你可以明确定义方法。

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a few models
lr = create_model('lr')
dt = create_model('dt')
knn = create_model('knn')

# stack models
stacker = stack_models([lr, dt, knn], method = 'predict')

stack_models([lr, dt, knn], method = 'predict') 的输出

更改元模型

如果没有明确传递 meta_model，则分类实验使用 LogisticRegression，回归实验使用 LinearRegression。你也可以传递一个特定的模型作为元模型。

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a few models
lr = create_model('lr')
dt = create_model('dt')
knn = create_model('knn')

# train meta-model
lightgbm = create_model('lightgbm')

# stack models
stacker = stack_models([lr, dt, knn], meta_model = lightgbm)

stack_models([lr, dt, knn], meta_model = lightgbm) 的输出

print(stacker.final_estimator_)

print(stacker.final_estimator_) 的输出

重新堆叠

堆叠模型有两种方式。(i) 仅使用输入模型的预测作为元模型的训练数据，(ii) 预测和原始训练数据都用于训练元模型。

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a few models
lr = create_model('lr')
dt = create_model('dt')
knn = create_model('knn')

# stack models
stacker = stack_models([lr, dt, knn], restack = False)

stack_models([lr, dt, knn], restack = False) 的输出

optimize_threshold

此函数优化已训练模型的概率阈值。它以 grid_interval 参数定义的步长，迭代不同 probability_threshold 下的性能指标。此函数将显示每个概率阈值下的性能指标图，并根据 optimize 参数定义的指标返回最佳模型。

示例

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a model
knn = create_model('knn')

# optimize threshold
optimized_knn = optimize_threshold(knn)

optimize_threshold(knn) 的输出

print(optimized_knn)

print(optimized_knn) 的输出

calibrate_model

此函数使用保序回归或逻辑回归校准给定模型的概率。此函数的输出是一个评分网格，其中包含按 fold 进行的 CV 分数。可以使用 get_metrics 函数访问 CV 期间评估的指标。可以使用 add_metric 和 remove_metric 函数添加或删除自定义指标。

示例

# load dataset
from pycaret.datasets import get_data
diabetes = get_data('diabetes')

# init setup
from pycaret.classification import *
clf1 = setup(data = diabetes, target = 'Class variable')

# train a model
dt = create_model('dt')

# calibrate model
calibrated_dt = calibrate_model(dt)

calibrate_model(dt) 的输出

print(calibrated_dt)

print(calibrated_dt) 的输出

校准前与校准后

校准前

校准后