本教程重点在于传授如何使用Hyperopt对xgboost进行自动调参。但是这份代码也是我一直使用的代码模板之一，所以在其他数据集上套用该模板也是十分容易的。

同时因为xgboost，lightgbm，catboost。三个类库调用方法都比较一致，所以在本部分结束之后，我们有理由相信，你将会学会在这三个类库上使用hyperopt。除此之外要额外说明的是，本文并不涉及交叉验证的问题，交叉验证请查看其他教程。

什么是Hyperopt？

Hyperopt：是python中的一个用于"分布式异步算法组态/超参数优化"的类库。使用它我们可以拜托繁杂的超参数优化过程，自动获取最佳的超参数。广泛意义上，可以将带有超参数的模型看作是一个必然的非凸函数，因此hyperopt几乎可以稳定的获取比手工更加合理的调参结果。尤其对于调参比较复杂的模型而言，其更是能以远快于人工调参的速度同样获得远远超过人工调参的最终性能。

文档地址？

目前中文文档的地址由本人FontTian在2017年翻译，但是hyperopt文档本身确实写的不怎么样。所以才有了这份教程。源代码请前往Github教程地址下载下载。

• 中文文档地址
• FontTian的博客
• Hyperopt官方文档地址

教程

获取数据

这里我们使用UCI的红酒质量数据集，除此之外我还额外增加了两个特征。

from hyperopt import fmin, tpe, hp, partial
import numpy as np
from sklearn.model_selection import train_test_split, cross_val_score
from sklearn.metrics import mean_squared_error, zero_one_loss
import xgboost as xgb
import pandas as pd

def GetNewDataByPandas():
    wine = pd.read_csv("../data/wine.csv")
    wine['alcohol**2'] = pow(wine["alcohol"], 2)
    wine['volatileAcidity*alcohol'] = wine["alcohol"] * wine['volatile acidity']
    y = np.array(wine.quality)
    X = np.array(wine.drop("quality", axis=1))

    columns = np.array(wine.columns)

    return X, y, columns

分割数据并转换

首先将数据分割为三份，一部分用于预测，训练数据则同样分成额外的两部分用于evallist参数。

同时为了加快速度和减少内存，我们将数据转换为xgboost自带的读取格式。

# Read wine quality data from file
X, y, wineNames = GetNewDataByPandas()

# split data to [[0.8,0.2],01]
x_train_all, x_predict, y_train_all, y_predict = train_test_split(X, y, test_size=0.10, random_state=100)

x_train, x_test, y_train, y_test = train_test_split(x_train_all, y_train_all, test_size=0.2, random_state=100)

dtrain = xgb.DMatrix(data=x_train,label=y_train,missing=-999.0)
dtest = xgb.DMatrix(data=x_test,label=y_test,missing=-999.0)

evallist = [(dtest, 'eval'), (dtrain, 'train')]

定义参数空间

使用hyperopt自带的函数定义参数空间，但是因为其randint()方法产生的数组范围是从0开始的，所以我额外定义了一个数据转换方法，对原始参数空间进行一次转换。

关于hyperopt中定义参数区间需要使用的函数请参考：

• 中文地址，请点击这里
• 英文地址，请点击这里

# 自定义hyperopt的参数空间
space = {"max_depth": hp.randint("max_depth", 15),
         "n_estimators": hp.randint("n_estimators", 300),
         'learning_rate': hp.uniform('learning_rate', 1e-3, 5e-1),
         "subsample": hp.randint("subsample", 5),
         "min_child_weight": hp.randint("min_child_weight", 6),
         }

def argsDict_tranform(argsDict, isPrint=False):
    argsDict["max_depth"] = argsDict["max_depth"] + 5
    argsDict['n_estimators'] = argsDict['n_estimators'] + 150
    argsDict["learning_rate"] = argsDict["learning_rate"] * 0.02 + 0.05
    argsDict["subsample"] = argsDict["subsample"] * 0.1 + 0.5
    argsDict["min_child_weight"] = argsDict["min_child_weight"] + 1
    if isPrint:
        print(argsDict)
    else:
        pass

    return argsDict

创建模型工厂与分数获取器

xgboost模型工厂用于生产我们需要的model，而分数获取器则是为了解耦。这样在实际的测试工作中更加套用代码和修改。

def xgboost_factory(argsDict):
    argsDict = argsDict_tranform(argsDict)
    
    params = {'nthread': -1,  # 进程数
              'max_depth': argsDict['max_depth'],  # 最大深度
              'n_estimators': argsDict['n_estimators'],  # 树的数量
              'eta': argsDict['learning_rate'],  # 学习率
              'subsample': argsDict['subsample'],  # 采样数
              'min_child_weight': argsDict['min_child_weight'],  # 终点节点最小样本占比的和
              'objective': 'reg:linear',
              'silent': 0,  # 是否显示
              'gamma': 0,  # 是否后剪枝
              'colsample_bytree': 0.7,  # 样本列采样
              'alpha': 0,  # L1 正则化
              'lambda': 0,  # L2 正则化
              'scale_pos_weight': 0,  # 取值>0时,在数据不平衡时有助于收敛
              'seed': 100,  # 随机种子
              'missing': -999,  # 填充缺失值
              }
    params['eval_metric'] = ['rmse']

    xrf = xgb.train(params, dtrain, params['n_estimators'], evallist,early_stopping_rounds=100)

    return get_tranformer_score(xrf)

def get_tranformer_score(tranformer):
    
    xrf = tranformer
    dpredict = xgb.DMatrix(x_predict)
    prediction = xrf.predict(dpredict, ntree_limit=xrf.best_ntree_limit)
  
    return mean_squared_error(y_predict, prediction)

调用Hyperopt开始调参

之后我们调用hyperopt进行自动调参即可，同时通过返回值获取最佳模型的结果。

# 开始使用hyperopt进行自动调参
algo = partial(tpe.suggest, n_startup_jobs=1)
best = fmin(xgboost_factory, space, algo=algo, max_evals=20, pass_expr_memo_ctrl=None)

[15:23:32] /workspace/src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 142 extra nodes, 0 pruned nodes, max_depth=10
[0]	eval-rmse:5.03273	train-rmse:4.90203
Multiple eval metrics have been passed: 'train-rmse' will be used for early stopping.

Will train until train-rmse hasn't improved in 100 rounds.
[15:23:32] /workspace/src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 172 extra nodes, 0 pruned nodes, max_depth=10
[1]	eval-rmse:4.77384	train-rmse:4.64767

...

[15:24:04] /workspace/src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 192 extra nodes, 0 pruned nodes, max_depth=15
[299]	eval-rmse:0.570382	train-rmse:0.000749

展示结果

展示我们获取的最佳参数，以及该模型在训练集上的最终表现，如果想要使用交叉验证请参考其他教程。

RMSE = xgboost_factory(best)
print('best :', best)
print('best param after transform :')
argsDict_tranform(best,isPrint=True)
print('rmse of the best xgboost:', np.sqrt(RMSE))

[15:24:52] /workspace/src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 428 extra nodes, 0 pruned nodes, max_depth=14
[0]	eval-rmse:5.02286	train-rmse:4.89385
Multiple eval metrics have been passed: 'train-rmse' will be used for early stopping.

Will train until train-rmse hasn't improved in 100 rounds.
[15:24:52] /workspace/src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 680 extra nodes, 0 pruned nodes, max_depth=14
[1]	eval-rmse:4.75938	train-rmse:4.63251

...

[298]	eval-rmse:0.583923	train-rmse:0.000705
[15:24:54] /workspace/src/tree/updater_prune.cc:74: tree pruning end, 1 roots, 22 extra nodes, 0 pruned nodes, max_depth=7
[299]	eval-rmse:0.583926	train-rmse:0.000704
best : {'learning_rate': 0.05385158551863543, 'max_depth': 14, 'min_child_weight': 2, 'n_estimators': 173, 'subsample': 0.8}
best param after transform :
{'learning_rate': 0.051077031710372714, 'max_depth': 19, 'min_child_weight': 3, 'n_estimators': 323, 'subsample': 0.5800000000000001}
rmse of the best xgboost: 0.5240080946197716

1、hyperopt干什么

这个python库可以在给定的参数空间中随机取点，每一组参数训练一个模型，最后记录和比较所有模型的表现，给出表现最好的一组参数。

它兼容大部分的机器学习任务，不需要对你的模型做什么太大的修改（只需要改一下超参数的写法，把超参数写到字典里面，例如lr改成params['lr']）。

2、hyperopt的使用

a) 安装并导入需要的程序

pip install hyperopt

from hyperopt import hp, STATUS_OK, Trials, fmin

b) 定义参数空间

space = {
    'lr':hp.loguniform('lr',-9,-5),
    'lambda_l2':hp.loguniform('lambda_l2',-5,0),
    'batch_size'hp.choice('batch_size',[8,16])
}

严格地说这里的参数指的是机器学习任务中的超参数，即训练过程中不进行梯度下降的部分。

参数空间是一个字典，在参数空间中，我定义了学习率lr，L2正则化系数lambda_l2，以及minibatch的大小batch_size。

其中，学习率和正则化系数的取值范围是一个均匀对数的范围，例如hp.loguniform('lr',-9,-5)就意味着取值范围是exp(-9)到exp(-5)，指数在 [-9, -5] 之间均匀分布。注意这里确实是自然指数，不是10为底的指数。

minibatch大小的取值范围则是离散的，从给定的8和16中二选一。（你可可以把这个列表改成你需要的那些值）

除了loguniform和choice，hp中的参数空间还有：uniform（线性空间中均匀随机取值）、quniform（线性离散取值）、qloguniform等

c) 把调参的任务描述为一个以参数为输入的函数

例如，在我的参数空间中有lr, lambda_l2, batch_size这三个参数，我希望最后得到一个最小化测试集的f1指数的模型，可以写成如下的方式（我的代码其实就是训练模型并输出测试集上的f1指数，你把中间的部分改成你的训练代码就行，注意要把参数换成params['batch_size']这种形式）：

def trainAmodel(params): #params={'lr':??, 'lambda_l2':??, 'batch_size':??}
    global X_train,X_test,Y_test,Y_train
    print('Params testing: ', params)
    # 创建模型 & 训练模型
    model_v1 = V1_utils.modelV1(X_train.shape[1:],params)
    opt = tensorflow.keras.optimizers.Adam(lr=params['lr'])
    model_v1.compile(loss="binary_crossentropy", metrics=['accuracy'], optimizer=opt)
    steps_per_epoch = (np.shape(X_train)[0] + params['batch_size'] - 1) // params['batch_size']
    history = model_v1.fit_generator(generator=data_generator(X_train, Y_train, params['batch_size']),
                                     steps_per_epoch=steps_per_epoch,
                                     epochs=30,
                                     verbose=0,
                                     validation_data=(X_test[::20], Y_test[::20]),
                                     )
    # 评估模型
    testres = model_v1.predict_generator(pre_generator(X_test, 4), verbose=0)
    testf1s, cache = V1_utils.fmeasure(Y_test, cvres)
    p, r = cache
    print("f1 = {}, precision = {}, recall = {}".format(testf1s, p, r))
    # 返回关心的指标（越小越好），状态
    return {
        'loss':-testf1s,
        'status':STATUS_OK
    }

注意，fmin默认是把指标越小认为表现越好，所以如果指标是f1指数、正确率这种越大越好的，可以加上负号，就变成越小越好。

另外，如果你希望在中途保存表现最好的模型，可以保存最好的表现，实时对比，如果更好就保存新的模型（我就不写了）。

d) 最后调用fmin开始跑不同参数下的模型，并保存。

trials = Trials()
best = fmin(trainAmodel, space, algo=tpe.suggest, max_evals=50, trials=trials)

import numpy as np
filename= 'model/v1/log_v1_4.npz'
np.savez(filename,trails=trials,best=best)

fmin的参数:

max_evals：要跑多少个模型，这个视你的需要，跑的越多肯多越有可能找到表现更好的模型，但是也意味着耗时增加。

algo：我还不清楚，应该是选择参数的算法？我直接用的suggest，也许选择一些算法能提高搜索效率。

3、结果

trials中会保留每一次训练的超参数、模型表现，我们可以根据这些画出模型在参数空间中的表现，帮助我们选择最后的超参数。例如我的这个结果：