超参数优化 - 随机网格搜索

1. 超参数优化与枚举网络的理论极限

1.1 超参数优化HPO(HypeParameter Optimization)

1.2 网格搜索的理论极限与缺点

1.3 枚举网格搜索

2. 随机网格搜索 RandomizedSearchCV

1. 超参数优化与枚举网络的理论极限

1.1 超参数优化HPO(HypeParameter Optimization)

每一个机器学习算法都会有超参数，而超参数的设置很大程度上影响了算法实际的使用效果，因此调参是机器学习算法工程师最为基础和重要的任务。现代机器学习与深度学习算法的超参数量众多，不仅实现方法异常灵活、算法性能也受到更多的参数的复合影响，因此当人工智能浪潮来临时，可以自动选择超参数的超参数优化HPO领域也迎来了新一轮爆发。

在算法的世界中，我们渴望一切流程最终都走向完美自动化，专门研究机器学习自动化的学科被称为AutoML，而超参数自动优化是AutoML中最成熟、最深入、也是最知名的方向。理论上来说，当算力与数据足够时，HPO的性能一定是超过人类的。HPO能够降低人为工作量，并且HPO得出的结果比人为搜索的复现可能性更高，所以HPO可以极大程度提升科学研究的复现性和公平性。当代超参数优化算法主要可以分为：基于网格的各类搜索（Grid）、基于贝叶斯优化的各类优化算法（Baysian）、基于梯度的各类优化（Gradient-based）、基于种群的各类优化（进化算法，遗传算法等）。其中，各类网格搜索方法与基于贝叶斯的优化方法是最为盛行的，贝叶斯优化方法甚至可以被称为是当代超参数优化中的SOTA模型。这些模型对于复杂集成算法的调整有极大的作用与意义。

1.2 网格搜索的理论极限与缺点

在所有超参数优化的算法当中，枚举网格搜索是最为基础和经典的方法。在搜索开始之前，我们需要人工将每个超参数的备选值一一列出，多个不同超参数的不同取值之间排列组合，最终将组成一个参数空间（parameter space）。枚举网格搜索算法会将这个参数空间当中所有的参数组合代入模型进行训练，最终选出泛化能力最强的组合作为模型的最终超参数。

对网格搜索而言，如果参数空间中的某一个点指向了损失函数真正的最小值，那枚举网格搜索时一定能够捕捉到该最小值以及对应的参数（相对的，假如参数空间中没有任意一点指向损失函数真正的最小值，那网格搜索就一定无法找到最小值对应的参数组合）。

参数空间越大、越密，参数空间中的组合刚好覆盖损失函数最小值点的可能性就会越大。这是说，极端情况下，当参数空间穷尽了所有可能的取值时，网格搜索一定能够找到损失函数的最小值所对应的最优参数组合，且该参数组合的泛化能力一定是强于人工调参的。但是，参数空间越大，网格搜索所需的算力和时间也会越大，当参数维度上升时，网格搜索所需的计算量更是程指数级上升的。以随机森林为例：

$\bullet$ 只有1个参数n_estimators，备选范围是[50,100,150,200,250,300]，需要建模6次。
$\bullet$ 增加参数max_depth，且备选范围是[2,3,4,5,6]，需要建模30次。
$\bullet$ 增加参数min_sample_split，且备选范围为[2,3,4,5]，需要建模120次。

同时，参数优化的目标是找出令模型泛化能力最强的组合，因此需要交叉验证来体现模型的泛化能力，假设交叉验证次数为5，则三个参数就需要建模600次。在面对超参数众多、且超参数取值可能无限的人工神经网络、融合模型、集成模型时，伴随着数据和模型的复杂度提升，网格搜索所需要的时间会急剧增加，完成一次枚举网格搜索可能需要耗费几天几夜。因此，我们急需寻找到一种更加高效的超参数搜索方法。本文将介绍基于网格进行改进的超参数优化方法——随机网格搜索，并将其结果与网格搜索进行时间/空间/效果上的对比。

1.3 枚举网格搜索

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestRegressor as RFR
from sklearn.model_selection import cross_validate,KFold

data=pd.read_csv('F:\\Jupyter Files\\机器学习进阶\\集成学习\\datasets\\House Price\\train_encode.csv',encoding='utf-8')
data.drop('Unnamed: 0', axis=1, inplace=True)
X=data.iloc[:,:-1]
y=data.iloc[:,-1]

# 参数空间
param_grid_simple = {"criterion": ["squared_error","poisson"]
                     , 'n_estimators': [*range(20,100,5)]
                     , 'max_depth': [*range(10,25,2)]
                     , "max_features": ["log2","sqrt",16,32,64,"auto"]
                     , "min_impurity_decrease": [*np.arange(0,5,10)]
                    }

#直接使用循环计算
no_option = 1
for i in param_grid_simple:
    no_option *= len(param_grid_simple[i])
no_option

#模型，交叉验证，网格搜索
reg = RFR(random_state=1412,verbose=True)
cv = KFold(n_splits=5,shuffle=True,random_state=1412)
search = GridSearchCV(estimator=reg
                     ,param_grid=param_grid_simple
                     ,scoring = "neg_mean_squared_error"
                     ,verbose = True
                     ,cv = cv)

# 【TIME WARNING: 50.06min】
start = time.time()
search.fit(X,y)
print(time.time() - start)

search.best_estimator_

abs(search.best_score_)**0.5 #交叉验证下在验证集的最好结果

29251.284326350575

ad_reg = RFR(n_estimators=85, max_depth=23, max_features=16, random_state=1412)
cv = KFold(n_splits=5,shuffle=True,random_state=1412)
result_post_adjusted = cross_validate(ad_reg,X,y,cv=cv,scoring="neg_mean_squared_error"
                          ,return_train_score=True
                          ,verbose=True)

#评估指标RMSE
def RMSE(cvresult,key):
    return (abs(cvresult[key])**0.5).mean()

RMSE(result_post_adjusted,"train_score")

11000.81099038192

RMSE(result_post_adjusted,"test_score")

28572.070208366855

HPO方法	枚举网格搜索
搜索空间/全域空间	1536/1536
运行时间（分钟）	50.06(单线程)
搜索最优（RMSE）	29251.284
重建最优（RMSE）	28572.070

2. 随机网格搜索 RandomizedSearchCV

2.1 随机网格搜索的基本原理

在枚举网格搜索时我们提到，伴随着数据和模型的复杂度提升，网格搜索所需要的时间急剧增加。以随机森林算法为例，如果使用过万的数据，搜索时间则会立刻上升好几个小时。因此，我们急需寻找到一种更加高效的超参数搜索方法。首先，当所使用的算法确定时，决定枚举网格搜索运算速度的因子一共有两个：① 参数空间的大小（参数空间越大，需要建模的次数越多）；② 数据量的大小（数据量越大，每次建模时需要的算力和时间越多）。

因此，sklearn中的网格搜索优化方法主要包括两类，其一是调整搜索空间，其二是调整每次训练的数据。其中，调整参数空间的具体方法，是放弃原本的搜索中必须使用的全域超参数空间，改为挑选出部分参数组合，构造超参数子空间，并只在子空间中进行搜索。

以下图的二维空间为例，在这个n_estimators与max_depth共同组成的参数空间中，n_estimators的取值假设为[50,100,150,200,250,300]，max_depth的取值假设为[2,3,4,5,6]，则枚举网格搜索必须对30种参数组合都进行搜索。当我们调整搜索空间，我们可以只抽样出橙色的参数组合作为“子空间”，并只对橙色参数组合进行搜索。如此一来，整体搜索所需的计算量就大大下降了，原本需要30次建模，现在只需要8次建模。

fig, [ax1, ax2] = plt.subplots(1,2,dpi=300)
n_e_list = [*range(50,350,50)]
m_d_list = [*range(2,7)]
comb = pd.DataFrame([(n_estimators, max_depth) for n_estimators in n_e_list for max_depth in m_d_list])

ax1.scatter(comb.iloc[:,0],comb.iloc[:,1],cmap="Blues")
ax1.set_xticks([*range(50,350,50)])
ax1.set_yticks([*range(2,7)])
ax1.set_xlabel("n_estimators")
ax1.set_ylabel("max_depth")
ax1.set_title("GridSearch")

ax2.scatter(comb.iloc[:,0],comb.iloc[:,1],cmap="Blues")
ax2.scatter([50,250,200,200,300,100,150,150],[4,2,6,3,2,3,2,5],cmap="red",s=20,linewidths=5)
ax2.set_xticks([*range(50,350,50)])
ax2.set_yticks([*range(2,7)])
ax2.set_xlabel("n_estimators")
ax2.set_ylabel("max_depth")
ax2.set_title("RandomSearch");

在sklearn中，随机抽取参数子空间并在子空间中进行搜索的方法叫做随机网格搜索RandomizedSearchCV。由于搜索空间的缩小，需要枚举和对比的参数组的数量也对应减少，整体搜索耗时也将随之减少，因此：

① 当设置相同的全域空间时，随机搜索的运算速度比枚举网格搜索快很多。

② 当设置相同的训练次数时，随机搜索可以覆盖的空间比枚举网格搜索大很多。

③ 同时，随机网格搜索得出的最小损失与枚举网格搜索得出的最小损失很接近。

可以说，是提升了运算速度，又没有过多地伤害搜索的精度。不过，随机网格搜索在实际运行时，并不是先抽样出子空间，再对子空间进行搜索，而是仿佛“循环迭代”一般，在这一次迭代中随机抽取1组参数进行建模，下一次迭代再随机抽取1组参数进行建模，由于这种随机抽样是不放回的，因此不会出现两次抽中同一组参数的问题。我们可以控制随机网格搜索的迭代次数，来控制整体被抽出的参数子空间的大小，这种做法往往被称为“赋予随机网格搜索固定的计算量，当全部计算量被消耗完毕之后，随机网格搜索就停止”。

2.2 随机网格搜索的实现

from sklearn.model_selection import RandomizedSearchCV

class sklearn.model_selection.RandomizedSearchCV(estimator, param_distributions, *, n_iter=10, scoring=None, n_jobs=None, refit=True, cv=None, verbose=0, pre_dispatch='2*n_jobs', random_state=None, error_score=nan, return_train_score=False)

全部参数解读如下，其中加粗的是随机网格搜索独有的参数：

Name	Description
estimator	调参对象，某评估器
param_distributions	全域参数空间，可以是字典或者字典构成的列表
n_iter	迭代次数，迭代次数越多，抽取的子参数空间越大
scoring	评估指标，支持同时输出多个参数
n_jobs	设置工作时参与计算的线程数
refit	挑选评估指标和最佳参数，在完整数据集上进行训练
cv	交叉验证的折数
verbose	输出工作日志形式
pre_dispatch	多任务并行时任务划分数量
random_state	随机数种子
error_score	当网格搜索报错时返回结果，选择'raise'时将直接报错并中断训练过程，其他情况会显示警告信息后继续完成训练
return_train_score	在交叉验证中是否显示训练集中参数得分

#打包成函数方便后续使用
#评估指标RMSE
def RMSE(cvresult,key):
    return (abs(cvresult[key])**0.5).mean()

#计算参数空间大小
def count_space(param):
    no_option = 1
    for i in param_grid_simple:
        no_option *= len(param_grid_simple[i])
    print(no_option)
    
#在最优参数上进行重新建模验证结果
def rebuild_on_best_param(ad_reg):
    cv = KFold(n_splits=5,shuffle=True,random_state=1412)
    result_post_adjusted = cross_validate(ad_reg,X,y,cv=cv,scoring="neg_mean_squared_error"
                                          ,return_train_score=True
                                          ,verbose=True)
    print("训练RMSE:{:.3f}".format(RMSE(result_post_adjusted,"train_score")))
    print("测试RMSE:{:.3f}".format(RMSE(result_post_adjusted,"test_score")))

# 相同的全域参数空间
param_grid_simple = {"criterion": ["squared_error","poisson"]
                     , 'n_estimators': [*range(20,100,5)]
                     , 'max_depth': [*range(10,25,2)]
                     , "max_features": ["log2","sqrt",16,32,64,"auto"]
                     , "min_impurity_decrease": [*np.arange(0,5,10)]
                    }
#计算全域参数空间大小，这是我们能够抽样的最大值
count_space(param_grid_simple)

#建立回归器、交叉验证
reg = RFR(random_state=1412,verbose=True)
cv = KFold(n_splits=5,shuffle=True,random_state=1412)
#定义随机搜索
search = RandomizedSearchCV(estimator=reg
                            ,param_distributions=param_grid_simple
                            ,n_iter = 800 #子空间的大小是全域空间的一半左右
                            ,scoring = "neg_mean_squared_error"
                            ,verbose = True
                            ,cv = cv
                            ,random_state=1412
                           )
#训练随机搜索评估器
#=====【TIME WARNING: 1297.368000984192s】=====#
import time
start = time.time()
search.fit(X,y)
print(time.time() - start)

#查看模型结果
search.best_estimator_

abs(search.best_score_)**0.5

29251.284326350575

#根据最优参数重建模型
ad_reg = RFR(max_depth=24, max_features=16, min_impurity_decrease=0,
                      n_estimators=85,  random_state=1412,
                      verbose=True)
rebuild_on_best_param(ad_reg)

训练RMSE:11031.299
测试RMSE:28639.969

HPO方法	枚举网格搜索	随机网格搜索
搜索空间/全域空间	1536/1536	800/1536
运行时间（分钟）	50.06(单线程)	21.62(单线程) (↓)
搜索最优（RMSE）	29179.698	29251.284
重建最优（RMSE）	28572.070	28639.969(↑)

很明显，在相同参数空间、相同模型的情况下，随机网格搜索的运算速度是普通网格搜索的一半，当然，这与子空间是全域空间的一半有很大的联系。由于随机搜索只是降低搜索的次数，并非影响搜索过程本身，因此其运行时间基本就等于n_iter/全域空间组合数 * 网格搜索的运行时间。

2.3 随机网格搜索的理论极限

虽然通过缩小子空间可以提升搜索的速度，但是随机网格搜索的精度看起来并没有削减太多，随机网格搜索可以得到和网格搜索一样好的结果吗？它也像网格搜索一样，可以得到最优的参数组合吗？为什么缩小参数空间之后，随机网格搜索的结果还与网格搜索一致？

在机器学习算法当中，有非常多通过随机来提升运算速度（比如Kmeans，随机挑选样本构建簇心，小批量随机梯度下降，通过随机来减少每次迭代需要的样本）、或通过随机来提升模型效果的操作（比如随机森林，比如极度随机树）。两种随机背后的原理完全不同，而随机网格搜索属于前者，这一类机器学习方法总是伴随着“从某个全数据集/全域中进行抽样”的操作，而这种操作能够有效的根本原因在于：

① 抽样出的子空间可以一定程度上反馈出全域空间的分布，且子空间相对越大（含有的参数组合数越多），子空间的分布越接近全域空间的分布。

② 当全域空间本身足够密集时，很小的子空间也能获得与全域空间相似的分布。

③ 如果全域空间包括了理论上的损失函数最小值，那一个与全域空间分布高度相似的子空间很可能也包括损失函数的最小值，或包括非常接近最小值的一系列次小值。

这里借助matplotlib工具库mplot3d中的一组默认数据可视化抽象的概念：

from mpl_toolkits.mplot3d import axes3d
p1, p2, MSE = axes3d.get_test_data(0.05)
len(p1) #120 参数1的取值有120个
len(p2) #120 参数2的取值有120个
MSE.shape #(120, 120) 损失函数值，总共14400个点
#绘制P1与P2的参数空间 - 这是一个呈现出14400个点的密集空间
plt.figure(dpi=300)
plt.scatter(p1,p2,s=0.2)
plt.xticks(fontsize=9)
plt.yticks(fontsize=9);

ps：自动获取数据的功能get_test_data，可以自动生成符合某一分布的数据。现假设这一组数据中有两个参数，p1与p2，两个参数组成的参数组合对应着损失函数值MSE。参数0.05是指参数空间中点与点之间的距离，该数字越小，取出来的样本越多。

#参数与损失共同构建的函数
p1, p2, MSE = axes3d.get_test_data(0.05)
plt.figure(dpi=300)
ax = plt.axes(projection="3d")
ax.plot_wireframe(p1,p2,MSE,rstride=2,cstride=2,linewidth=0.5)
ax.view_init(2, -15)
ax.zaxis.set_tick_params(labelsize=7)
ax.xaxis.set_tick_params(labelsize=7)
ax.yaxis.set_tick_params(labelsize=7);

np.min(MSE) #整个参数空间中，可获得的MSE最小值

-73.39620971601681

现从该空间上抽取子空间：

ps：现从空间中抽取n个组合，n越大子空间越大。总共有14400个组合，对被抽中的点来说，损失函数的值就是MSE，对没有抽中的点来说，损失函数值是空值。因此，只需要找出没有抽中的点，并让它的损失函数值MSE为空就可以了。

import numpy as np
n = 100
#从0~14400中生成(14400-n)个随机数，形成没有被抽到子空间中的点的索引
unsampled = np.random.randint(0,14400,14400-n)
p1, p2, MSE = axes3d.get_test_data(0.05)

#拉平MSE，并将所有没抽中的点的损失函数变为空值
MSE = MSE.ravel()
MSE[unsampled] = np.nan
MSE = MSE.reshape((120,120))
#设置完毕空值后，记得把MSE恢复成原来的结构，否则绘图报错

#参数与损失共同构建的函数
plt.figure(dpi=300)
ax = plt.axes(projection="3d")
ax.view_init(2, -15)
ax.plot_wireframe(p1,p2,MSE,rstride=2,cstride=2,linewidth=0.5)
ax.zaxis.set_tick_params(labelsize=7)
ax.xaxis.set_tick_params(labelsize=7)
ax.yaxis.set_tick_params(labelsize=7);

#求出当前损失函数上的最小值
#注意此时因为MSE中含有了空值，因此要先排除空值影响，否则min函数会返回空值
MSE = MSE.ravel().tolist()
MSE = [x for x in MSE if str(x) != 'nan']
print(np.min(MSE))

-73.24243733589367

通过图像可以验证如下事实：

① 抽样出的子空间可以一定程度上反馈出全域空间的分布，且子空间相对越大（含有的参数组合数越多），子空间的分布越接近全域空间的分布。

② 当全域空间本身足够密集时，很小的子空间也能获得与全域空间相似的分布。

不过，由于随机网格搜索计算更快，所以在相同计算资源的前提下，我们可以对随机网格搜索使用更大/更密集的全域空间，因此随机搜索可能得到比网格搜索更好的效果：

#创造参数空间 - 让整体参数空间变得更密
param_grid_simple = {'n_estimators': [*range(80,100,1)]
                     , 'max_depth': [*range(10,25,1)]
                     , "max_features": [*range(10,20,1)]
                     , "min_impurity_decrease": [*np.arange(0,5,10)]
                    }
#计算全域参数空间大小，这是我们能够抽样的最大值
count_space(param_grid_simple)  #3000
#建立回归器、交叉验证
reg = RFR(random_state=1412,verbose=True)
cv = KFold(n_splits=5,shuffle=True,random_state=1412)

#定义随机搜索
search = RandomizedSearchCV(estimator=reg
                            ,param_distributions=param_grid_simple
                            ,n_iter = 1536 #使用与枚举网格搜索类似的拟合次数
                            ,scoring = "neg_mean_squared_error"
                            ,verbose = True
                            ,cv = cv
                            ,random_state=1412)
#训练随机搜索评估器
#=====【TIME WARNING】=====#
start = time.time()
search.fit(X,y)
end = time.time() - start
print(end/60) #33.02493980725606min

#查看最佳评估器
search.best_estimator_

abs(search.best_score_)**0.5 #交叉验证下在验证集的最好结果

29012.90569846546

rebuild_on_best_param(search.best_estimator_)

训练RMSE:11208.818
测试RMSE:28346.673

HPO方法	枚举网格搜索	随机网格搜索	随机网格搜索(大空间)
搜索空间/全域空间	1536/1536	800/1536	1536/3000
运行时间（分钟）	50.06(单线程)	21.62(单线程) (↓)	33.02(单线程) (↓)
搜索最优（RMSE）	29179.698	29251.284	29012.906(↓)
重建最优（RMSE）	28572.070	28639.969(↑)	28346.673(↓)

可以发现，当全域参数空间增大之后，随即网格搜索可以使用与小空间上的网格搜索相近的时间来探索更密集/更大的空间，从而获得更好的结果。除了可以容忍更大的参数空间之外，随机网格搜索还可以接受连续性变量作为参数空间的输入。

2.4 连续性随机网格搜索的实现

连续性的参数空间：

对于网格搜索来说，参数空间中的点是分布均匀、间隔一致的，因为网格搜索无法从某种“分布”中提取数据，只能使用组合好的参数组合点，而随机搜索却可以接受“分布”作为输入。如上图所示，对于网格搜索来说，如果损失函数的最低点很不幸的、位于两组参数之间，在这种情况下，枚举网格搜索是100%不可能找到最小值的。但对于随机网格搜索来说，由于是一段分布上随机选择参数点，因此在同样的参数空间中，取到更好的值的可能性更大。

import scipy #使用scipy来帮助我们建立分布
scipy.stats.uniform(loc=1,scale=100)

ps：uniform是均匀分布，默认生成[0,1]之间的数字，可以使用loc来调整起点，scale来调整终点。我们还可以选择其他的分布，比如指数分布expon, gamma分布, 或者是randint。注意scipy这里并不是像np.linspace()一样生成一段离散的数字，而是直接生成一个分布对象。并且，我们并没有在分布对象中指定尺寸，也就是说，在这段分布上究竟要取几个随机的参数备选值，是由随机搜索自己决定的。理论上来说，我们给出的n_iter越大，任意参数的分布上可能被取到的点就越多。因此，当参数空间中包含某个分布的时候，我们无法估计全域参数空间的大小。

在之前调整随机森林的时候，我们给出的所有参数都是只能接纳正整数的参数，在这里可以使用scipy.stats.randint，不过randint并不是严格意义上的连续分布。严格来说，连续型搜索更适用于学习率，C，alpha这样的参数（无上限，以浮点数为主），随机森林的参数中最接近这个定义的是min_impurity_decrease，表示决策树在分枝是可以容忍的最小的不纯度下降量。现借着这个参数，使用均匀分布来进行随机网格搜索。

param_grid_simple = {'n_estimators': [*range(80,100,1)]
                     , 'max_depth': [*range(10,25,1)]
                     , "max_features": [*range(10,20,1)]
                     , "min_impurity_decrease": scipy.stats.uniform(0,50)
                    }
#建立回归器、交叉验证
reg = RFR(random_state=1412,verbose=True)
cv = KFold(n_splits=5,shuffle=True,random_state=1412)

#定义随机搜索
search = RandomizedSearchCV(estimator=reg
                            ,param_distributions=param_grid_simple
                            ,n_iter = 1536 #还是使用1536这个搜索次数
                            ,scoring = "neg_mean_squared_error"
                            ,verbose = True
                            ,cv = cv
                            ,random_state=1412)
#训练随机搜索评估器
#=====【TIME WARNING】=====#
start = time.time()
search.fit(X,y)
end = time.time() - start
print(end/60) #32.72446912527084min

#查看最佳评估器
search.best_estimator_

abs(search.best_score_)**0.5

29113.405359664695

rebuild_on_best_param(search.best_estimator_)

训练RMSE:11296.682
测试RMSE:28455.434

HPO方法	枚举网格搜索	随机网格搜索	随机网格搜索 (大空间)	随机网格搜索 (连续型)
搜索空间/全域空间	1536/1536	800/1536	1536/3000	1536/无限
运行时间（分钟）	50.06(单线程)	21.62(单线程) (↓)	33.02(单线程) (↓)	32.72(单线程)
搜索最优（RMSE）	29179.698	29251.284	29012.906(↓)	29113.405
重建最优（RMSE）	28572.070	28639.969(↑)	28346.673(↓)	28455.434

在本次搜索当中，由于之前已经知道最好的可能的min_impurity_decrease的值为0，因此强行向更大的数拓展搜索空间可能会导致模型效果下降(没有抽到min_impurity_decrease=0的点)。不过在随机森林当中，min_impurity_decrease是唯一可以使用分布进行搜索的参数，因此在这里我们就容忍了这部分表现上升。

理论上来说，当枚举网格搜索所使用的全域参数空间足够大/足够密集时，枚举网格搜索的最优解是随机网格搜索的上限，因此理论上随机网格搜索不会得到比枚举网格搜索更好的结果。但现实中的问题是，由于枚举网格搜索的速度太慢，因此枚举网格搜索的全域参数空间往往无法设置得很大，也无法设置得很密集，因此网格搜索的结果很难接近理论上的最优值。当随机网格搜索将空间设置更大、更密集时，就可以捕获更广空间的分布，也自然就可能捕获到理论上的最优值了。