hyperopt-调参模块

超参数优化是实现模型性能最大化的重要步骤。为此大神们专门开发了几个Python包。scikitt -learn提供了一些选项,GridSearchCV和RandomizedSearchCV是两个比较流行的选项。在scikitt之外,Optunity、Spearmint和hyperopt包都是为优化设计的。在这篇文章中,我将重点介绍hyperopt软件包,它提供了能够超越随机搜索的算法,并且可以找到与网格搜索相媲美的结果,同时也能找到更少的模型。

接口说明

具体的详细文档: http://www.coxlab.org/pdfs/2013_bergstra_hyperopt.pdf

  1. fmin接口:需要定义一个概率分布,确保能在变化的超参中找到一个可信的值。就像scipy中的optimize.minimize借口。因此需要我们提供一个优化的目标函数。很多优化算法都要假设在一个向量空间里面搜索最佳值,hyperopt可以对搜索空间进一步细化,比如说使用log话活着均匀分布随机获取之类。

  2. hyperopt需要定义的主要有四个地方:

  • 1.需要最小化的目标函数
  • 2.优化所需要搜索的搜索空间
  • 3.一个存放搜索过程计算结果的数据库(利用结果进行分析)
  • 4.所使用的搜索算法

第一步:定义目标函数
比如假设我们优化一个二次函数,即q(x,y)=x2+y2,如下:

1
2
3
def q(args):
x,y = args
return x ** 2+ y ** 2

第二步:确定一个搜索空间
比如我们需要在[0,1]内搜索x,,则我们可以写成:

1
2
from hyperopt import hp
space = [hp.uniform("x",0,1),hp.normal("y",0,1)]

接下来,对搜索空间的表达式进行说明。主要通过hyperopt .hp模块,比如:

1
fmin(q,space = hp.uniform(‘a’,0,1))

其中hp.uniform的第一位置表示标签,即“a”,在自定义空间中,每一个超参都必须有一个类似这样的标签。其他超参选择分布说明如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
hp.choice(label,options):
返回options中的一个,因此options应该是一个列表或者元组。
hp.pchoice(label,p_options):
按照概率集p_options来选择option之间的一个,一次为(prob,option)形式
hp.uniform(label,low,high):
从low和high按照均匀分布产生数据
hp.quniform(label,low,high,q):
按照round(exp(uniform(low,high))/q)*q产生,
hp.loguniform(label,low,high):
从exp(uniform(low,high)),当搜索空间限制在[exp(low),exp(high)]之间
hp.normal(label,mu,sigma):
从一个正态分布中产生数据,主要适用于无限制的变量
hp.lognormal(label, mu, sigma) :
从exp(normal(mu, sigma)).产生 ,该变量限制为正数
hp.randint(label, upper):
从[0,upper)中随机产生一个整数

第三步:选择一个搜索算法
目前主要有两个算法:algo=hyperopt.tpe.suggest 和algo=hyperopt.rand.suggest 使用方法如下:

1
2
3
4
5
6
7
8
from hyperopt import hp, fmin, rand, tpe, space_eval
best = fmin(q, space, algo=rand.suggest)
print best
# => XXX
print space_eval(space, best)
# => XXX
best = fmin(q, space, algo=tpe.suggest)
print best

如果有多个需要优化的超参:则可以有不同写法,比如:

1
2
3
4
5
6
7
8
9
10
11
12
from hyperopt import hp
list_space = [
hp.uniform(’a’, 0, 1),
hp.loguniform(’b’, 0, 1)]
#or
tuple_space = (
hp.uniform(’a’, 0, 1),
hp.loguniform(’b’, 0, 1))
#or
dict_space = {
’a’: hp.uniform(’a’, 0, 1),
’b’: hp.loguniform(’b’, 0, 1)}

可以使用hyperopt.pyll.stochastic从搜索空间中抽样,比如:

1
2
3
4
5
6
7
from hyperopt.pyll.stochastic import sample
print sample(list_space)
# => [0.13, .235]
print sample(nested_space)
# => [[{’case’: 1, ’a’, 0.12}, {’case’: 2, ’b’: 2.3}],
# ’extra_literal_string’,
# 3]

也可以在搜索空间定义表达式(这样的话就可以随意的构造你的搜索空间中的值,而不局限于在某一个向量空间中,如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from hyperopt.pyll import scope
def foo(x):
return str(x) * 3
expr_space = {
’a’: 1 + hp.uniform(’a’, 0, 1),
’b’: scope.minimum(hp.loguniform(’b’, 0, 1), 10),
’c’: scope.call(foo, args=(hp.randint(’c’, 5),)),
}
#当然也可以通过装饰器来增加scope类,比如:
from hyperopt.pyll import scope
@scope.define
def foo(x):
return str(x) * 3
# -- This will print "000"; foo is called as usual.
print foo(0)
expr_space = {
'a': 1 + hp.uniform('a', 0, 1),
'b': scope.minimum(hp.loguniform('b', 0, 1), 10),
'c': scope.foo(hp.randint('cbase', 5)),
}

接下来,主要看下几个常用的分类算法的使用方式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from hyperopt import hp
from hyperopt.pyll import scope
from sklearn.naive_bayes import GaussianNB
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier\
as DTree
scope.define(GaussianNB) #贝叶斯模型中三种模型之高斯模型
scope.define(SVC) #支持向量机
scope.define(DTree, name='DTree') #决策树
C = hp.lognormal('svm_C', 0, 1) #惩罚项参数
space = hp.pchoice('estimator', [ #这里可以选择哪个作为模型来对数据进行训练
(0.1, scope.GaussianNB()),
(0.2, scope.SVC(C=C, kernel='linear')), #线性核的svm
(0.3, scope.SVC(C=C, kernel='rbf',width=hp.lognormal('svm_rbf_width', 0, 1))),
(0.4, scope.DTree(criterion=hp.choice('dtree_criterion',['gini', 'entropy']),
max_depth=hp.choice('dtree_max_depth',
[None, hp.qlognormal('dtree_max_depth_N',
2, 2, 1)])))])

第四步,存储搜索结果:trials结构,用法主要如下:

1
2
3
4
5
from hyperopt import (hp, fmin, space_eval,Trials)
trials = Trials() #使用Trials类即可
best = fmin(q, space, trials=trials)
print trials.trials
#其中关于trials的结果说明,主要是dict格式,其中说明如下:

tid:整型,主要hitrial的识别(就是每一次调整的id)
results:格式为dict形式,有loss,status等
misc:格式为dict形式,有indxs和vals

定义的目标函数,需要返回的事字典的形式:如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import time
from hyperopt import fmin, Trials
from hyperopt import STATUS_OK, STATUS_FAIL
def f(x):
try:
return {'loss': x ** 2,
'time': time.time(),
'status': STATUS_OK }
except Exception, e:
return {'status': STATUS_FAIL,
'time': time.time(),
'exception': str(e)}
trials = Trials()
fmin(f, space=hp.uniform('x', -10, 10),trials=trials)
print trials.trials[0]['results']

案例

主要使用xgboost,lightgbm,rf的用法

加载模块

1
2
3
4
5
6
7
8
9
import numpy as np
import pandas as pd
from hyperopt import hp, tpe
from hyperopt.fmin import fmin
from sklearn.model_selection import cross_val_score, StratifiedKFold
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import make_scorer
import xgboost as xgb
import lightgbm as lgbm

数据集

1
2
3
df = pd.read_csv('../input/train.csv')
X = df.drop(['id', 'target'], axis=1)
Y = df['target']

评估指标

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def gini(truth, predictions):
g = np.asarray(np.c_[truth, predictions, np.arange(len(truth)) ], dtype=np.float)
g = g[np.lexsort((g[:,2], -1*g[:,1]))]
gs = g[:,0].cumsum().sum() / g[:,0].sum()
gs -= (len(truth) + 1) / 2.
return gs / len(truth)
def gini_xgb(predictions, truth):
truth = truth.get_label()
return 'gini', -1.0 * gini(truth, predictions) / gini(truth, truth)
def gini_lgb(truth, predictions):
score = gini(truth, predictions) / gini(truth, truth)
return 'gini', score, True
def gini_sklearn(truth, predictions):
return gini(truth, predictions) / gini(truth, truth)
gini_scorer = make_scorer(gini_sklearn, greater_is_better=True, needs_proba=True)

Random Forest

在这一部分中,我们将使用hyperopt库来优化random forest classsifier。hyperopt库的目的与gridsearch类似,但是它没有对参数空间进行彻底的搜索,而是对一些精心选择的数据点进行评估,然后根据建模来推断出最优的解决方案。实际上,这意味着需要更少的迭代来找到一个好的解决方案。

随机森林的工作原理是通过许多决策树的平均预测来实现的——这个想法是,通过平均许多树,每棵树的错误都被解决了。每一种决策树都可能有点过分,通过平均它们的最终结果应该是好的。

调整的重要参数是:

树的数量(n_estimators)
树的深度(max_depth)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def objective(params):
params = {'n_estimators': int(params['n_estimators']), 'max_depth': int(params['max_depth'])}
clf = RandomForestClassifier(n_jobs=4, class_weight='balanced', **params)
score = cross_val_score(clf, X, Y, scoring=gini_scorer, cv=StratifiedKFold()).mean()
print("Gini {:.3f} params {}".format(score, params))
return score
space = {
'n_estimators': hp.quniform('n_estimators', 25, 500, 25),
'max_depth': hp.quniform('max_depth', 1, 10, 1)
}
best = fmin(fn=objective,
space=space,
algo=tpe.suggest,
max_evals=10)
1
2
3
4
5
6
7
8
9
10
Gini -0.218 params {'n_estimators': 50, 'max_depth': 1}
Gini -0.243 params {'n_estimators': 175, 'max_depth': 4}
Gini -0.237 params {'n_estimators': 475, 'max_depth': 3}
Gini -0.252 params {'n_estimators': 450, 'max_depth': 6}
Gini -0.236 params {'n_estimators': 300, 'max_depth': 3}
Gini -0.251 params {'n_estimators': 225, 'max_depth': 6}
Gini -0.237 params {'n_estimators': 450, 'max_depth': 3}
Gini -0.254 params {'n_estimators': 400, 'max_depth': 8}
Gini -0.243 params {'n_estimators': 450, 'max_depth': 4}
Gini -0.252 params {'n_estimators': 450, 'max_depth': 6}

则最好的参数如下:

1
print("Hyperopt estimated optimum {}".format(best))

1
Hyperopt estimated optimum {'max_depth': 8.0, 'n_estimators': 400.0}

xgboost

类似于上面的调优,现在我们将使用hyperopt来优化xgboost参数!

XGBoost也是一种基于决策树的集合,但不同于随机森林。这些树不是平均的,而是增加的。决策树经过训练,可以纠正前几棵树的残差。这个想法是,许多小型决策树都经过了训练,每个决策树都添加了一些信息来提高总体预测。

我最初将树的数量固定在250,而学习速率是0.05(用一个快速的实验来确定)——然后我们可以为其他参数找到好的值。稍后我们可以重新迭代这个。

最重要的参数是:

  • 树的数量(n_estimators)
  • 学习速率-后树的影响较小(learning_rate)
  • 树深度(max_depth)
  • gamma-过拟合参数。
  • colsample_bytree-减少过度拟合。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
def objective(params):
params = {
'max_depth': int(params['max_depth']),
'gamma': "{:.3f}".format(params['gamma']),
'colsample_bytree': '{:.3f}'.format(params['colsample_bytree']),
}

clf = xgb.XGBClassifier(
n_estimators=250,
learning_rate=0.05,
n_jobs=4,
**params
)

score = cross_val_score(clf, X, Y, scoring=gini_scorer, cv=StratifiedKFold()).mean()
print("Gini {:.3f} params {}".format(score, params))
return score

space = {
'max_depth': hp.quniform('max_depth', 2, 8, 1),
'colsample_bytree': hp.uniform('colsample_bytree', 0.3, 1.0),
'gamma': hp.uniform('gamma', 0.0, 0.5),
}

best = fmin(fn=objective,
space=space,
algo=tpe.suggest,
max_evals=10)
1
2
3
4
5
6
7
8
9
10
Gini -0.268 params {'max_depth': 2, 'gamma': '0.221', 'colsample_bytree': '0.835'}
Gini -0.268 params {'max_depth': 2, 'gamma': '0.231', 'colsample_bytree': '0.545'}
Gini -0.271 params {'max_depth': 8, 'gamma': '0.114', 'colsample_bytree': '0.498'}
Gini -0.275 params {'max_depth': 3, 'gamma': '0.398', 'colsample_bytree': '0.653'}
Gini -0.268 params {'max_depth': 2, 'gamma': '0.285', 'colsample_bytree': '0.512'}
Gini -0.278 params {'max_depth': 4, 'gamma': '0.368', 'colsample_bytree': '0.514'}
Gini -0.272 params {'max_depth': 8, 'gamma': '0.049', 'colsample_bytree': '0.359'}
Gini -0.279 params {'max_depth': 6, 'gamma': '0.361', 'colsample_bytree': '0.349'}
Gini -0.279 params {'max_depth': 5, 'gamma': '0.112', 'colsample_bytree': '0.806'}
Gini -0.279 params {'max_depth': 4, 'gamma': '0.143', 'colsample_bytree': '0.487'}
1
print("Hyperopt estimated optimum {}".format(best))
1
Hyperopt estimated optimum {'colsample_bytree': 0.4870213995434902, 'gamma': 0.14316677782970882, 'max_depth': 4.0}

lightgbm

LightGBM与xgboost非常相似,它也使用了梯度增强树方法。所以以上的解释大多也站得住脚。

调整的重要参数是:

Number of estimators
Tree complexity - in lightgbm that is controlled by number of leaves (num_leaves)
Learning rate
Feature fraction

我们将把估计数固定到500,学习速率为0.01(用实验方法选择),并使用hyperopt调整剩下的参数。然后,我们可以重新访问,以获得更好的结果!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
def objective(params):
params = {
'num_leaves': int(params['num_leaves']),
'colsample_bytree': '{:.3f}'.format(params['colsample_bytree']),
}

clf = lgbm.LGBMClassifier(
n_estimators=500,
learning_rate=0.01,
**params
)

score = cross_val_score(clf, X, Y, scoring=gini_scorer, cv=StratifiedKFold()).mean()
print("Gini {:.3f} params {}".format(score, params))
return score

space = {
'num_leaves': hp.quniform('num_leaves', 8, 128, 2),
'colsample_bytree': hp.uniform('colsample_bytree', 0.3, 1.0),
}

best = fmin(fn=objective,
space=space,
algo=tpe.suggest,
max_evals=10)
1
2
3
4
5
6
7
8
9
10
Gini -0.273 params {'num_leaves': 62, 'colsample_bytree': '0.447'}
Gini -0.273 params {'num_leaves': 72, 'colsample_bytree': '0.934'}
Gini -0.272 params {'num_leaves': 60, 'colsample_bytree': '0.481'}
Gini -0.270 params {'num_leaves': 26, 'colsample_bytree': '0.400'}
Gini -0.274 params {'num_leaves': 72, 'colsample_bytree': '0.544'}
Gini -0.273 params {'num_leaves': 106, 'colsample_bytree': '0.802'}
Gini -0.275 params {'num_leaves': 126, 'colsample_bytree': '0.568'}
Gini -0.270 params {'num_leaves': 26, 'colsample_bytree': '0.463'}
Gini -0.273 params {'num_leaves': 102, 'colsample_bytree': '0.699'}
Gini -0.273 params {'num_leaves': 110, 'colsample_bytree': '0.774'}
1
print("Hyperopt estimated optimum {}".format(best))
1
Hyperopt estimated optimum {'colsample_bytree': 0.567579584507837, 'num_leaves': 126.0}

比较一下随机森林和XGBoost的超选择参数是很有趣的。随机森林最终有375棵深度为7的树,其中XGBoost有250个深度5。这符合随机森林平均许多复杂(独立训练的)树木获得良好结果的理论,其中xgboost和lightgbm(促进)增加了许多简单的树(在残差上训练)。

结果比较

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
rf_model = RandomForestClassifier(
n_jobs=4,
class_weight='balanced',
n_estimators=325,
max_depth=5
)
xgb_model = xgb.XGBClassifier(
n_estimators=250,
learning_rate=0.05,
n_jobs=4,
max_depth=2,
colsample_bytree=0.7,
gamma=0.15
)
lgbm_model = lgbm.LGBMClassifier(
n_estimators=500,
learning_rate=0.01,
num_leaves=16,
colsample_bytree=0.7
)
models = [
('Random Forest', rf_model),
('XGBoost', xgb_model),
('LightGBM', lgbm_model),
]
for label, model in models:
scores = cross_val_score(model, X, Y, cv=StratifiedKFold(), scoring=gini_scorer)
print("Gini coefficient: %0.4f (+/- %0.4f) [%s]" % (scores.mean(), scores.std(), label))
1
2
3
Gini coefficient: -0.2478 (+/- 0.0018) [Random Forest]
Gini coefficient: -0.2684 (+/- 0.0015) [XGBoost]
Gini coefficient: -0.2682 (+/- 0.0017) [LightGBM]
-------------本文结束感谢您的阅读-------------
;