Hyperopt简单入门
前言
本文将介绍一种快速有效的方法用于实现机器学习模型的调参。有两种常用的调参方法：
- 网格搜索
- 随机搜索
每一种都有自己的优点和缺点，
- 网格搜索速度慢，但在搜索整个搜索空间方面效果很好，
- 而随机搜索很快，但可能会错过搜索空间中的重要点。
幸运的是，还有第三种选择：贝叶斯优化。
本文我们将重点介绍贝叶斯优化的一个实现：一个名为hyperopt的Python模块。
一般而言，使用hyperopt的过程可以概括为：
- 用于最小化的目标函数
- 搜索空间
- 存储搜索过程中所有点组合以及效果的方法
- 要使用的搜索算法
下面，我们将针对这几点进行具体的介绍。
目标函数
一个简单的例子
假设你有一个定义在某个范围内的函数，并且想把它最小化。也就是说，你想找到产生最低输出值的输入值。
from hyperopt import fmin, tpe, hp
best = fmin(
fn=lambda x: x,
space=hp.uniform('x', -2.5, 2.5),
algo=tpe.suggest,
max_evals=100)
print(best)
输出结果：
{'x': -2.499684360290122}
- fn:函数fmin首先接受一个函数来最小化，记为fn，在这里用一个匿名函数lambda x: x来指定。该函数可以是任何有效的值返回函数，例如回归中的平均绝对误差。
- space:是指定搜索空间，在本例中，它是-2.5到2.5之间的连续数字范围，由hp.uniform('x', -2.5, 2.5)指定。hp.uniform是一个内置的hyperopt函数，它有三个参数：名称x，范围的下限和上限。
- algo:指定搜索算法，本例中tpe表示 tree of Parzen estimators。该主题超出了本文的范围，但有数学背景的读者可以细读这篇文章。algo参数也可以设置为hyperopt.random，但是这里我们没有涉及，因为它是众所周知的搜索策略。但在未来的文章中我们可能会涉及。
- max_evals:指定fmin函数将执行的最大评估次数。这个fmin函数将返回一个python字典。
以下是该函数的图。红点是我们试图找到的点。
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# 为随机数固定一个数值
np.random.RandomState(seed=42)
plt.rcParams["font.sans-serif"] = ['SimHei'] # 用于正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False # 用来正常显示负号
x = np.linspace(-2.5, 2.5, 256, endpoint=True) # 绘制X轴（-2.5,2.5）的图像
f = x # y值
plt.plot(x, f, "b-", lw=2.5, label="f(x)")
plt.scatter(best['x'], best['x'], 50, color='red')
plt.title('f(x) = x')
plt.legend()
plt.show()
更复杂的例子-单独定义目标函数
我们这里展示一个更为复杂的例子——\(f(x) = sin^2(x-2)e^{-x^2}\)，并且将fn定义为python中的函数。同时这里我们还需要通过负号将最大化问题转化为最小化问题。
from hyperopt import fmin, tpe, hp
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
def fun_change(x):
y = (np.sin(x - 2))**2 * (np.e)**(-x**2)
return -y
best = fmin(
fn=fun_change,
space=hp.uniform('x', -2.5, 2.5),
algo=tpe.suggest,
max_evals=100)
print(best)
x = np.linspace(-2.5, 2.5, 256, endpoint=True) # 绘制X轴（-2.5,2.5）的图像
f = (np.sin(x - 2))**2 * (np.e)**(-x**2) # y值
plt.plot(x, f, "b-", lw=2.5, label="f(x)")
plt.scatter(best['x'], -fun_change(best['x']), 50, color='red')
plt.title('$f(x) = sin^2(x-2)e^{-x^2}$')
plt.legend()
plt.show()
{'x': 0.23933244883577937}
使用上面的方法，我们就可以传入更加复杂的函数，或者某个其他类库中单独定义的函数，如sklearn中的SVC，RF，亦或是XGBoost或者LightGBM，并在对该函数进行搜索。不过假如真的使用sklearn中的机器学习模型的话，那就会存在另外一个问题，很明显，一般的机器学习模型都不止一个超参数。那么我们又应该怎么传入更多的超参数呢。
注：不过假如想要完美的使用xgb或者lgb,还存在其他问题，这个我们会在其他文章里详细描述使用方法
搜索空间
hyperopt模块包含一些方便的函数来指定输入参数的范围。我们已经见过hp.uniform。最初，这些是随机搜索空间，但随着hyperopt更多的学习（因为它从目标函数获得更多反馈），通过它认为提供给它最有意义的反馈，会调整并采样初始搜索空间的不同部分。
以下内容将在本文中使用：
- hp.choice(label, options):从列表中选择，该函数可以用于传入字符串参数。其中options应是python列表或元组。
- hp.uniform(label, low, high):返回位于
[low,hight]之间的均匀分布的值。在优化时，这个变量被限制为一个双边区间。 - hp.normal(label, mu, sigma):返回正态分布的实数值，其平均值为 \(\mu\) ，标准偏差为 σ。优化时，这是一个无边界的变量。
import hyperopt.pyll.stochastic
space = {
'x': hp.uniform('x', 0, 1),
'y': hp.normal('y', 0, 1),
'name': hp.choice('name', ['alice', 'bob']),
}
print(hyperopt.pyll.stochastic.sample(space))
输出结果：
{'y': -1.4012610048810574, 'x': 0.7258615424906184, 'name': 'alice'}
而对于数个传入的超参数，很明显假设这也是一个函数的话，其极大概率是非凸的，而如贝叶斯优化等现代优化算法则是专门处理此类问题的。在搜索一开始的时候，hyperopt会默认进行随机搜索，但是Hyperopt会在搜索过程中对函数的输出进行预估，然后不断地根据之前的结果，调整搜索空间。
def fun_change(space):
f = space['x'] + space['y']
return -f
space = {
"x": hp.uniform('x', -2.5, 2.5),
"y": hp.uniform('y', -2.5, 2.5),
}
best = fmin(fn=fun_change, space=space, algo=tpe.suggest, max_evals=1000)
print(best)
输出结果：
{'x': 2.499691365281102, 'y': 2.49972323784047}
通过Trials捕获信息
如果能看到hyperopt黑匣子内发生了什么是极好的。Trials对象使我们能够做到这一点。我们只需要导入一些东西。
from hyperopt import fmin, tpe, hp, STATUS_OK, Trials
fspace = {
'x': hp.uniform('x', -5, 5)
}
def f(params):
x = params['x']
val = x**2
return {'loss': val, 'status': STATUS_OK}
trials = Trials()
best = fmin(fn=f, space=fspace, algo=tpe.suggest, max_evals=5, trials=trials)
print('best:', best)
输出结果：
best: {'x': -0.92834265742143}
trials.trials[0](misc,杂项)
trials.trials[1]
trials.trials[2]
trials.trials[3]
trials.trials[4]
STATUS_OK和Trials是新导入的。Trials对象允许我们在每个时间步存储信息。然后我们可以将它们打印出来，并在给定的时间步查看给定参数的函数评估值。Trials对象将数据存储为BSON对象，其工作方式与JSON对象相同。BSON来自pymongo模块。我们不会在这里讨论细节，这是对于需要使用MongoDB进行分布式计算的hyperopt的高级选项，因此需要导入pymongo。
回到上面的输出,
- tid是时间id，即时间步，其值从0到max_evals-1。它随着迭代次数递增。
- 'x'是键'vals'的值，其中存储的是每次迭代参数的值。
- 'loss'是键'result'的值，其给出了该次迭代目标函数的值。
最初算法从整个范围中均匀地选择值，但随着时间的推移以及参数对目标函数的影响了解越来越多，该算法越来越聚焦于它认为会取得最大收益的区域-一个接近零的范围。它仍然探索整个解空间，但频率有所下降。
实例
在本节中，我们将介绍2个使用hyperopt在经典数据集Iris上调参的完整示例。我们将涵盖SVM，决策树。需要注意的是，由于我们试图最大化交叉验证的准确率，而hyperopt只知道如何最小化函数，所以必须对准确率取负。最小化函数f与最大化f的负数是相等的。
对于这项任务，我们将使用经典的Iris数据集。数据集有有4个输入特征和3个输出类别。数据被标记为属于类别0，1或2，其映射到不同种类的鸢尾花。输入有4列：萼片长度，萼片宽度，花瓣长度和花瓣宽度。输入的单位是厘米。我们将使用这4个特征来学习模型，预测三种输出类别之一。
决策树调参例子
from sklearn import datasets
from sklearn.preprocessing import normalize, scale
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import cross_val_score
# 这里的warnings实在太多了，我们加入代码不再让其显示
import warnings
warnings.filterwarnings("ignore")
from hyperopt import Trials,hp,fmin,tpe
iris = datasets.load_iris()
X = iris.data
y = iris.target
def hyperopt_model_score_dtree(params):
X_ = X[:]
if 'normalize' in params:
if params['normalize'] == 1:
X_ = normalize(X_)
del params['normalize']
if 'scale' in params:
if params['scale'] == 1:
X_ = scale(X_)
del params['scale']
clf = DecisionTreeClassifier(**params)
return cross_val_score(clf, X_, y).mean()
space_dtree = {
'max_depth': hp.choice('max_depth', range(1, 20)),
'max_features': hp.choice('max_features', range(1, 5)),
'criterion': hp.choice('criterion', ["gini", "entropy"]),
'scale': hp.choice('scale', [0, 1]),
'normalize': hp.choice('normalize', [0, 1])
}
def fn_dtree(params):
acc = hyperopt_model_score_dtree(params)
return -acc
# 为可视化做准备
trials = Trials()
best = fmin(fn=fn_dtree, space=space_dtree,
algo=tpe.suggest, max_evals=1000, trials=trials)
print(best)
输出结果：
{'criterion': 0, 'max_depth': 9, 'max_features': 3, 'normalize': 1, 'scale': 0}
params = {'criterion': "gini", 'max_depth': 9, 'max_features': 3}
clf = DecisionTreeClassifier(**params)
print(cross_val_score(clf, X, y).mean())
输出结果：
0.9666666666666668
这里要注意的是：假如构建参数空间使用'hp.choice'函数的，那么在模型中返回的将是传入列表或者数组的index（索引）,而且是从0开始的，在测试最终结果时候一定要注意这一点。为了检测标准化和归一化时候有用，我们这里额外添加了两个参数"scale"和"normalize"，而其对于分类决策树的影响则定义于目标函数部分。
目前看，hyperopt对于我们已经是个黑箱。但是我们也可以通过传入Trials来获取搜索过程中的结果。而通过可视化该结果，我们也可以对参数和模型的关系有更好地了解。我们可以看到，对于不同的scale，normalize和criterion值，性能几乎没有差别。这在进行进一步的搜索的时候，将会非常有用。因为我们可以通过图像获得一个更小的参数搜索范围。
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
parameters = ['max_depth', 'max_features', 'criterion', 'scale',
'normalize'] # decision tree
cols = len(parameters)
f, axes = plt.subplots(nrows=1, ncols=cols, figsize=(20, 5))
cmap = plt.cm.jet
for i, val in enumerate(parameters):
xs = np.array([t['misc']['vals'][val] for t in trials.trials]).ravel()
ys = [-t['result']['loss'] for t in trials.trials]
ys = np.array(ys)
axes[i].scatter(
xs,
ys,
s=20,
linewidth=0.01,
alpha=0.5,
c=cmap(float(i) / len(parameters)))
axes[i].set_title(val)
SVM调参例子
同样的事情，我们再做一次，模型替代为SVM。
from sklearn.svm import SVC
def hyperopt_model_score_svm(params):
X_ = X[:]
if 'normalize' in params:
if params['normalize'] == 1:
X_ = normalize(X_)
del params['normalize']
if 'scale' in params:
if params['scale'] == 1:
X_ = scale(X_)
del params['scale']
clf = SVC(**params)
return cross_val_score(clf, X_, y).mean()
space_svm = {
'C': hp.uniform('C', 0, 20),
'kernel': hp.choice('kernel', ['linear', 'sigmoid', 'poly', 'rbf']),
'gamma': hp.uniform('gamma', 0, 20),
'scale': hp.choice('scale', [0, 1]),
'normalize': hp.choice('normalize', [0, 1])
}
def f_svm(params):
acc = hyperopt_model_score_svm(params)
return -acc
trials = Trials()
best = fmin(f_svm, space_svm, algo=tpe.suggest, max_evals=1000, trials=trials)
print('best:')
输出结果：
{'C': 4.863643141054704, 'gamma': 8.341907026924783, 'kernel': 0, 'normalize': 0, 'scale': 0}
可视化：
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
parameters = ['C', 'kernel', 'gamma', 'scale', 'normalize']
cols = len(parameters)
f, axes = plt.subplots(nrows=1, ncols=cols, figsize=(20, 5))
cmap = plt.cm.jet
for i, val in enumerate(parameters):
xs = np.array([t['misc']['vals'][val] for t in trials.trials]).ravel()
ys = [-t['result']['loss'] for t in trials.trials]
axes[i].scatter(
xs,
ys,
s=20,
linewidth=0.01,
alpha=0.25,
c=cmap(float(i) / len(parameters)))
axes[i].set_title(val)
axes[i].set_ylim([0.9, 1.0])
params = {'C': 4.863643141054704, 'gamma': 8.341907026924783, 'kernel': 'linear'}
clf = SVC(**params)
print(cross_val_score(clf, normalize(X), y).mean())
输出结果：
0.9733333333333334
是时候把所有东西合为一体了
自动调整一个模型的参数（如SVM或决策树）非常有趣并且具有启发性，但同时调整它们并取得全局最佳模型则更有用。这使我们能够一次比较所有参数和所有模型，也就是说将模型本身也作为超参数进行优化，返回的结果将是最好的那个模型以及其最佳参数组合。代码如下：
from sklearn import datasets
from sklearn.model_selection import cross_val_score
# 这里的warnings实在太多了，我们加入代码不再让其显示
import warnings
warnings.filterwarnings("ignore")
from sklearn.tree import DecisionTreeClassifier
from sklearn.svm import SVC
from sklearn.naive_bayes import BernoulliNB
from sklearn.neighbors import KNeighborsClassifier
from hyperopt import fmin, tpe, hp,STATUS_OK, Trials
digits = datasets.load_digits()
X = digits.data
y = digits.target
def hyperopt_train_test(params):
t = params['type']
del params['type']
if t == 'naive_bayes':
clf = BernoulliNB(**params)
elif t == 'svm':
clf = SVC(**params)
elif t == 'dtree':
clf = DecisionTreeClassifier(**params)
elif t == 'knn':
clf = KNeighborsClassifier(**params)
else:
return 0
return cross_val_score(clf, X, y).mean()
space = hp.choice('classifier_type', [
{
'type': 'naive_bayes',
'alpha': hp.uniform('alpha', 0.0, 2.0)
},
{
'type': 'svm',
'C': hp.uniform('C', 0, 10.0),
'kernel': hp.choice('kernel', ['linear', 'rbf']),
'gamma': hp.uniform('gamma', 0, 20.0)
},
{
'type': 'dtree',
'max_depth': hp.choice('max_depth', range(1, 20)),
'max_features': hp.choice('max_features', range(1, 5)),
'criterion': hp.choice('criterion', ["gini", "entropy"]),
},
{
'type': 'knn',
'n_neighbors': hp.choice('knn_n_neighbors', range(1,50))
}
])
count = 0
best = 0
def f(params):
global best, count
count += 1
acc = hyperopt_train_test(params.copy())
if acc > best:
print(f'new best:{acc}')
print(f'iters:{count},acc:{acc}, using:{params}')
best = acc
if count % 50 == 0:
print(f'iters:{count}, acc:{acc}, using:{params}')
return -acc
trials = Trials()
best = fmin(f, space, algo=tpe.suggest, max_evals=300, trials=trials)
输出结果：
print('best:',best)
输出结果：
在这次测试中，我们明显的看到了一个问题。因为我们给出的不同模型的参数空间很宽泛，所以也就很可能会出现单个模型的初始的随机搜索效果会很差。而因为Hyperopt自身的运行机制，其之后的注意力很有可能更多的放在第一个获得较好优化结果的模型上，而这样很有可能会错过真正的最佳模型。
params = {'n_neighbors': 1}
clf = KNeighborsClassifier(**params)
print("best score",cross_val_score(clf, X, y).mean())
输出结果：
选择搜索算法
之前我们选择的优化参数都是tpe。这是一种带有启发性的搜索算法。类似于遗传算法，粒子群算法。有时候算法可能在一开始就陷入局部最优的区域之中。一种比较好的解决方案就是选择其他搜索函数-随机搜索。但是也正是因为随机搜索缺乏启发性，所以随机搜索想要获得较好的结果也往往需要更多的搜索次数，因此,搜索算法的具体使用，请按照实际情况选择。
随机搜索：algo=hyperopt.random.suggest
