DataWhale集成学习笔记-task03

视频：bilibili

（a） 训练均方误差与测试均方误差：

在回归中，我们最常用的评价指标为均方误差，即：$MSE=\frac{1}{N}\sum _{i=1}^N(y_i-\hat{f}(x_i){)}^2$，其中$\hat{f}(x_i)$是样本$x_i$应用建立的模型$\hat{f}$预测的结果。
如果我们所用的数据是训练集上的数据，那么这个误差为训练均方误差，如果我们使用测试集的数据计算的均方误差，我们称为测试均方误差。
我们的目标是使得我们建立的模型在测试集上的测试误差最小。

在模型建立阶段，我们是不能得到测试数据的，一个模型的训练均方误差最小时，不能保证测试均方误差同时也很小。对于这种想法构造的模型，一般在训练误差达到最小时，测试均方误差一般很大！如图：

可以看到：当我们的模型的训练均方误差达到很小时，测试均方误差反而很大，但是我们寻找的最优的模型是测试均方误差达到最小时对应的模型，因此基于训练均方误差达到最小选择模型本质上是行不同的。正如上右图所示：模型在训练误差很小，但是测试均方误差很大时，我们称这种情况叫模型的过拟合。

（b）偏差-方差的权衡：

从上图的测试均方误差曲线可以看到：测试均方误差曲线呈现U型曲线，这表明了在测试误差曲线中有两种力量在互相博弈。可以证明:
$$E{\left(y_0-\hat{f}\left(x_0\right)\right)}^2=\mathrm{Var}\left(\hat{f}\left(x_0\right)\right)+{\left[\mathrm{Bias}\left(\hat{f}\left(x_0\right)\right)\right]}^2+\mathrm{Var}(\epsilon )$$
也就是说，我们的测试均方误差的期望值可以分解为$\hat{f}(x_0)$的方差、$\hat{f}(x_0)$的偏差平方和误差项$ϵ$的方差。推导：知乎
$\mathrm{Var}(\epsilon )$为建模任务的难度，这个量在我们的任务确定后是无法改变的，也叫做不可约误差。

那么模型的方差和偏差的平方和究竟是什么呢？所谓模型的方差就是：用不同的数据集去估计fff时，估计函数的改变量。举个例子：我们想要建立一个线性回归模型，可以通过输入中国人身高去预测我们的体重。但是显然我们没有办法把全中国13亿人做一次人口普查，拿到13亿人的身高体重去建立模型。我们能做的就是从13亿中抽1000个样本进行建模，我们对这个抽样的过程重复100遍，就会得到100个1000人的样本集。我们使用线性回归模型估计参数就能得到100个线性回归模型。由于样本抽取具有随机性，我们得到的100个模型不可能参数完全一样，那么这100个模型之间的差异就叫做方差。

也可以理解为测试数据结果和测试均值之间的误差，显然，我们希望得到一个稳定的模型，也就是在不同的样本集估计的模型都不会相差太大，即要求f的方差越小越好。一般来说，模型的复杂度越高，f的方差就会越大。
如加入二次项的模型的方差比线性回归模型的方差要大。

（C）测试误差估计

们要选择一个测试误差达到最小的模型。但是实际上我们很难对实际的测试误差做精确的计算，因此我们要对测试误差进行估计，估计的方式有两种：训练误差修正与交叉验证。

训练误差修正：

前面的讨论我们已经知道，模型越复杂，训练误差越小，测试误差先减后增。因此，我们先构造一个特征较多的模型使其过拟合，此时训练误差很小而测试误差很大，那这时我们加入关于特征个数的惩罚。

当我们的训练误差随着特征个数的增加而减少时，惩罚项因为特征数量的增加而增大，抑制了训练误差随着特征个数的增加而无休止地减小。具体的数学量如下：
$C_p=\frac{1}{N}(RSS+2d{\hat{\sigma }}^2)$，其中d为模型特征个数，$RSS=\sum _{i=1}^N(y_i-\hat{f}(x_i){)}^2$，${\hat{\sigma }}^2$为模型预测误差的方差的估计值，即残差的方差。
AIC赤池信息量准则：$AIC=\frac{1}{d{\hat{\sigma }}^2}(RSS+2d{\hat{\sigma }}^2)$
BIC贝叶斯信息量准则：$BIC=\frac{1}{n}(RSS+log(n)d{\hat{\sigma }}^2)$
BIC惩罚最重

交叉验证：

前面讨论的对训练误差修正得到测试误差的估计是间接方法，这种方法的桥梁是训练误差，而交叉验证则是对测试误差的直接估计。
交叉验证比训练误差修正的优势在于：能够给出测试误差的一个直接估计。在这里只介绍K折交叉验证：我们把训练样本分成K等分，然后用K-1个样本集当做训练集，剩下的一份样本集为验证集去估计由K-1个样本集得到的模型的精度，这个过程重复K次取平均值得到测试误差的一个估计$C{V}_{(K)}=\frac{1}{K}\sum _{i=1}^{K}MS{E}_i$。5折交叉验证如下图：（蓝色的是训练集，黄色的是验证集）

(d)特征选择

我们做特征选择的目标就是：
从p个特征中选择{1~p}个特征，使得对应的模型的测试误差的估计最小。

最优子集选择：

(i) 记不含任何特征的模型为$M_0$，计算这个$M_0$的测试误差。
(ii) 在$M_0$基础上增加一个变量，计算p个模型的RSS，选择RSS最小的模型记作$M_1$，并计算该模型$M_1$的测试误差。
(iii) 再增加变量，计算p-1个模型的RSS，并选择RSS最小的模型记作$M_2$，并计算该模型$M_2$的测试误差。
(iv) 重复以上过程知道拟合的模型有p个特征为止，并选择p+1个模型$\{M_0,M_1,...,M_p\}$中测试误差最小的模型作为最优模型。

向前逐步选择(Forward-stepwise selection)：

最优子集选择虽然在原理上很直观，但是随着数据特征维度p的增加，子集的数量为$2^p$，计算效率非常低下且需要的计算内存也很高，在大数据的背景下显然不适用。因此，我们需要把最优子集选择的运算效率提高，因此向前逐步选择算法的过程如下：
(i) 记不含任何特征的模型为$M_0$，计算这个$M_0$的测试误差。
(ii) 在$M_0$基础上增加一个变量，计算p个模型的RSS，选择RSS最小的模型记作$M_1$，并计算该模型$M_1$的测试误差。
(iii) 在最小的RSS模型下继续增加一个变量，选择RSS最小的模型记作$M_2$，并计算该模型$M_2$的测试误差。
(iv) 以此类推，重复以上过程知道拟合的模型有p个特征为止，并选择p+1个模型$\{M_0,M_1,...,M_p\}$中测试误差最小的模型作为最优模型。
向前选择复杂度是一个等差数列之和

(e) 压缩估计(正则化)：

还可以对回归的系数进行约束或者加罚的技巧对p个特征的模型进行拟合，显著降低模型方差，这样也会提高模型的拟合效果。具体来说，就是将回归系数往零的方向压缩，这也就是为什么叫压缩估计的原因了。

- 岭回归(L2正则化的例子)：

在线性回归中，我们的损失函数为$J(w)=\sum _{i=1}^N(y_i-w_0-\sum _{j=1}^p{w}_j{x}_{ij}{)}^2$，我们在线性回归的损失函数的基础上添加对系数的约束或者惩罚，即：
$$\begin{gathered} J(w)=\sum _{i=1}^N(y_i-w_0-\sum _{j=1}^p{w}_j{x}_{ij}{)}^2+\lambda \sum _{j=1}^p{w}_j^2,其中，\lambda \ge 0 \\ \hat{w}=(X^{T}X+\lambda I{)}^{-1}{X}^{T}Y \end{gathered}$$
调节参数$\lambda$的大小是影响压缩估计的关键，$\lambda$越大，惩罚的力度越大，系数则越趋近于0，在这个时候各个特征向量之间变成线性无关的，在统计学上这是一种消除共线性的方法
选择合适的$\lambda$对模型精度来说十分重要。岭回归通过牺牲线性回归的无偏性降低方差，有可能使得模型整体的测试误差较小，提高模型的泛化能力。其中的有偏性是指对系数的估计是有偏的。

- Lasso回归(L1正则化的例子)：

岭回归的一个很显著的特点是：将模型的系数往零的方向压缩，但是岭回归的系数只能呢个趋于0但无法等于0，换句话说，就是无法做特征选择。能否使用压缩估计的思想做到像特征最优子集选择那样提取出重要的特征呢？答案是肯定的！我们只需要对岭回归的优化函数做小小的调整就行了，我们使用系数向量的L1范数替换岭回归中的L2范数：
$$J(w)=\sum _{i=1}^N(y_i-w_0-\sum _{j=1}^p{w}_j{x}_{ij}{)}^2+\lambda \sum _{j=1}^p|w_j|,其中，\lambda \ge 0$$
为什么Losso能做到特征选择而岭回归却不能呢个做到呢？(如图：左边为lasso，右边为岭回归)\

椭圆形曲线为RSS等高线，菱形和圆形区域分别代表了L1和L2约束，Lsaao回归和岭回归都是在约束下的回归，因此最优的参数为椭圆形曲线与菱形和圆形区域相切的点。但是Lasso回归的约束在每个坐标轴上都有拐角，因此当RSS曲线与坐标轴相交时恰好回归系数中的某一个为0，这样就实现了特征提取。反观岭回归的约束是一个圆域，没有尖点，因此与RSS曲线相交的地方一般不会出现在坐标轴上，因此无法让某个特征的系数为0，因此无法做到特征提取。

(f) 降维：

到目前为止，我们所讨论的方法对方差的控制有两种方式：一种是使用原始变量的子集，另一种是将变量系数压缩至零。但是这些方法都是基于原始特征$x_1,...,x_p$得到的。

现在我们探讨一类新的方法：将原始的特征空间投影到一个低维的空间实现变量的数量变少，如：将二维的平面投影至一维空间。

机器学习领域中所谓的降维就是指采用某种映射方法，将原高维空间中的数据点映射到低维度的空间中。降维的本质是学习一个映射函数
f : x->y，其中x是原始数据点的表达，目前最多使用向量表达形式。
y是数据点映射后的低维向量表达，通常y的维度小于x的维度（当然提高维度也是可以的）。
f可能是显式的或隐式的、线性的或非线性的。
而通过降维,我们希望减少 冗余信息
所造成的误差,提高识别（或其他应用）的精度。又或者希望通过降维算法来寻找数据内部的本质结构特征。
在很多算法中，降维算法成为了数据预处理的一部分，如PCA
主成分分析(PCA)：
主成分分析的思想：通过最大投影方差
将原始空间进行重构，即由特征相关重构为无关，即落在某个方向上的点(投影)的方差最大。在进行下一步推导之前，我们先把样本均值和样本协方差矩阵推广至矩阵形式：
样本均值Mean:$\bar{x}=\frac{1}{N}\sum _{i=1}^N{x}_i=\frac{1}{N}{X}^T{1}_N,其中1_N=(1,1,...,1{)}_N^T$
样本协方差矩阵$S^2=\frac{1}{N}\sum _{i=1}^N(x_i-\bar{x})(x_i-\bar{x}{)}^T=\frac{1}{N}{X}^{T}HX,其中，H=I_N-\frac{1}{N}{1}_N{1}_N^T$
最大投影方差的步骤：
(i) 中心化：$x_i-\bar{x}$
(ii) 计算每个点$x_1,...,x_N$至$u_1$方向上的投影：$(x_i-\bar{x})u_1,||u_1||=1$
(iii) 计算投影方差：$J=\frac{1}{N}\sum _{i=1}^N[(x_i-\bar{x}{)}^T{u}_1{]}^2,||u_1||=1$
(iv) 最大化投影方差求$u_1$：
$$\begin{gathered} {\bar{u}}_1=argma{x}_{u_1}\frac{1}{N}\sum _{i=1}^N[(x_i-\bar{x}{)}^T{u}_1{]}^2 \\ s.t.u_1^T{u}_1=1(u_1往后不带向量符号) \end{gathered}$$
得到：
$$\begin{gathered} J=\frac{1}{N}\sum _{i=1}^N[(x_i-\bar{x}{)}^T{u}_1{]}^2=\frac{1}{N}\sum _{i=1}^N[u_1^T(x_i-\bar{x})(x_i-\bar{x}{)}^T{u}_1] \\ =u_1^T[\frac{1}{N}\sum _{i=1}^N(x_i-\bar{x})(x_i-\bar{x}{)}^T]u_1=u_1^T{S}^2{u}_1 \end{gathered}$$
即：
$$\begin{gathered} {\hat{u}}_1=argma{x}_{u_1}{u}_1^T{S}^2{u}_1,s.t.u_1^T{u}_1=1 \\ L(u_1,\lambda )=u_1^T{S}^2{u}_1+\lambda (1-u_1^T{u}_1) \\ \frac{\partial L}{\partial u_1}=2S^2{u}_1-2\lambda u_1=0 \\ 即：S^2{u}_1=\lambda u_1 \end{gathered}$$
可以看到：$\lambda$为$S^2$的特征值，$u_1$为$S^2$的特征向量。因此我们只需要对中心化后的协方差矩阵进行特征值分解，得到的特征向量即为投影方向。如果需要进行降维，那么只需要取p的前M个特征向量即可。

(g) 对模型超参数进行调优(调参)：

---

在刚刚的讨论中，我们似乎对模型的优化都是对模型算法本身的改进，比如：岭回归对线性回归的优化在于在线性回归的损失函数中加入L2正则化项从而牺牲无偏性降低方差。但是，大家是否想过这样的问题：在L2正则化中参数$\lambda$应该选择多少？是0.01、0.1、还是1？到目前为止，我们只能凭经验或者瞎猜，能不能找到一种方法找到最优的参数$\lambda$？

事实上，找到最佳参数的问题本质上属于最优化的内容，因为从一个参数集合中找到最佳的值本身就是最优化的任务之一，我们脑海中浮现出来的算法无非就是：梯度下降法、牛顿法等无约束优化算法或者约束优化算法，但是在具体验证这个想法是否可行之前，我们必须先认识两个最本质概念的区别。

• 参数与超参数：

  我们很自然的问题就是岭回归中的参数$\lambda$和参数w之间有什么不一样？事实上，参数w是我们通过设定某一个具体的$\lambda$后使用类似于最小二乘法、梯度下降法等方式优化出来的，我们总是设定了$\lambda$是多少后才优化出来的参数w。因此，类似于参数w一样，使用最小二乘法或者梯度下降法等最优化算法优化出来的数我们称为参数，类似于$\lambda$一样，我们无法使用最小二乘法或者梯度下降法等最优化算法优化出来的数我们称为超参数。
  模型参数是模型内部的配置变量，其值可以根据数据进行估计。

  • 进行预测时需要参数。

  • 它参数定义了可使用的模型。

  • 参数是从数据估计或获悉的。

  • 参数通常不由编程者手动设置。

  • 参数通常被保存为学习模型的一部分。

  • 参数是机器学习算法的关键，它们通常由过去的训练数据中总结得出 。
    模型超参数是模型外部的配置，其值无法从数据中估计。

  • 超参数通常用于帮助估计模型参数。

  • 超参数通常由人工指定。

  • 超参数通常可以使用启发式设置。

  • 超参数经常被调整为给定的预测建模问题。

    我们前面(4)部分的优化都是基于模型本身的具体形式的优化，那本次(5)调整的内容是超参数，也就是取不同的超参数的值对于模型的性能有不同的影响。

网格搜索GridSearchCV()：链接

网格搜索结合管道：链接

网格搜索的思想非常简单，比如你有2个超参数需要去选择，那你就把所有的超参数选择列出来分别做排列组合。举个例子：$\lambda =0.01,0.1,1.0$和$\alpha =0.01,0.1,1.0$
，然后针对每组超参数分别建立一个模型，然后选择测试误差最小的那组超参数。换句话说，我们需要从超参数空间中寻找最优的超参数，很像一个网格中找到一个最优的节点，因此叫网格搜索。

- 随机搜索 RandomizedSearchCV() ：链接

网格搜索相当于暴力地从参数空间中每个都尝试一遍，然后选择最优的那组参数，这样的方法显然是不够高效的，因为随着参数类别个数的增加，需要尝试的次数呈指数级增长。有没有一种更加高效的调优方式呢？那就是使用随机搜索的方式，这种方式不仅仅高校，而且实验证明，随机搜索法结果比稀疏化网格法稍好(有时候也会极差，需要权衡)。参数的随机搜索中的每个参数都是从可能的参数值的分布中采样的。与网格搜索相比，这有两个主要优点：

• 可以独立于参数数量和可能的值来选择计算成本。
• 添加不影响性能的参数不会降低效率。

作业

1.用具体案例解释偏差和方差
2.偏差与方差和误差之间的关系
3.训练误差和测试误差之间的联系和区别，如何估计测试误差
4.岭回归和Lasso回归的异同点
5.如果使用PCA降维前是一个三维的椭球，那么把该图形降维成二维是什么图形
椭圆
6.用对偶理论和核函数对PCA进行非线性扩展，使得PCA变成非线性降维：
这个比较超出范围，等我有时间好好研究研究
7.本教程讲述的三种模型简化方法之间的异同点
8.用sklearn对一组数据先进行特征简化（三种方式）再使用回归模型，最后用网格搜索调参观察三种方法的优劣
在波士顿房价的数据上特征提取，压缩估计表现差不多，但是压缩估计有调参的需求
降维可能更适用于分类。回归结果不ok

方法	特征提取	压缩估计	降维
模型在测试集上的得分	0.6864610310143215	0.6839314673968357	0.3564415499973883

# 用sklearn对一组数据先进行特征简化（三种方式）再使用回归模型，最后用网格搜索调参观察三种方法的优劣
boston = datasets.load_boston()     # 返回一个类似于字典的类
X = boston.data
y = boston.target
from sklearn.model_selection import train_test_split
x_train, x_test,  y_train, y_test = train_test_split(X,y, test_size=0.25, random_state=42)

特征提取的方法

#定义向前逐步回归函数
def forward_select_AIC(data,target):
    variate=set(data.columns)  #将字段名转换成字典类型
    variate.remove(target)  #去掉因变量的字段名
    selected=[]
    current_score,best_new_score=float('inf'),float('inf')  #目前的分数和最好分数初始值都为无穷大（因为AIC越小越好）
    #循环筛选变量
    while variate:
        aic_with_variate=[]
        for candidate in variate:  #逐个遍历自变量
            formula="{}~{}".format(target,"+".join(selected+[candidate]))  #将自变量名连接起来
            aic=ols(formula=formula,data=data).fit().aic  #利用ols训练模型得出aic值
            aic_with_variate.append((aic,candidate))  #将第每一次的aic值放进空列表
        aic_with_variate.sort(reverse=True)  #降序排序aic值
        best_new_score,best_candidate=aic_with_variate.pop()  #最好的aic值等于删除列表的最后一个值，以及最好的自变量等于列表最后一个自变量
        if current_score>best_new_score:  #如果目前的aic值大于最好的aic值
            variate.remove(best_candidate)  #移除加进来的变量名，即第二次循环时，不考虑此自变量了
            selected.append(best_candidate)  #将此自变量作为加进模型中的自变量
            current_score=best_new_score  #最新的分数等于最好的分数
            print("aic is {},continuing!".format(current_score))  #输出最小的aic值
        else:
            print("for selection over!")
            break
    formula="{}~{}".format(target,"+".join(selected))  #最终的模型式子
    print("final formula is {}".format(formula))
    model=ols(formula=formula,data=data).fit()
    return(model)
features = boston.feature_names
boston_data = pd.DataFrame(x_train,columns=features)
boston_data["Price"] =  y_train
model=forward_select_AIC(boston_data,target="Price")
lin_reg = linear_model.LinearRegression()       # 创建线性回归的类
x_train_exact=x_train[:,[0,1,3,4,5,6,7,8,9,10,11,12]]
x_test_exact=x_test[:,[0,1,3,4,5,6,7,8,9,10,11,12]]
lin_reg.fit(x_train_exact,y_train)        # 输入特征X和因变量y进行训练
print("模型系数：",lin_reg.coef_)             # 输出模型的系数
print("模型常数项：",lin_reg.intercept_)  
print("模型在测试集上的得分：",lin_reg.score(x_test_exact,y_test))    # 输出模型的决定系数R^2

压缩估计

from sklearn import linear_model
reg_rid = linear_model.Ridge()
param_range = [0.001,0.01,0.02,0.04,0.06,0.08,0.1,0.2]
param_grid = {"alpha":param_range}
gs = GridSearchCV(estimator=reg_rid,
                                      param_grid = param_grid,
                                   scoring = 'r2',
                                         cv = 10)       # 10折交叉验证
gs = gs.fit(x_train,y_train)
print("网格搜索最优得分：",gs.best_score_)
print("网格搜索最优参数组合：\n",gs.best_params_)
reg_rid = linear_model.Ridge(alpha=0.08)
reg_rid.fit(x_train,y_train)        # 输入特征X和因变量y进行训练
print("模型系数：",reg_rid.coef_)             # 输出模型的系数
print("模型常数项：",reg_rid.intercept_)  
print("模型在测试集上的得分：",reg_rid.score(x_test,y_test))    # 输出模型的决定系数R^2

降维

from sklearn.decomposition import PCA
pca_line = PCA().fit(X)
plt.plot(np.arange(0,13,1),np.cumsum(pca_line.explained_variance_ratio_))
X_dr=PCA(n_components=4).fit_transform(X)
x_dr_train, x_dr_test,  y_dr_train, y_dr_test = train_test_split(X_dr,y, test_size=0.25, random_state=42)
lin_reg = linear_model.LinearRegression()       # 创建线性回归的类
lin_reg.fit(x_dr_train,y_dr_train)        # 输入特征X和因变量y进行训练
print("模型系数：",lin_reg.coef_)             # 输出模型的系数
print("模型常数项：",lin_reg.intercept_)  
print("模型在测试集上的得分：",lin_reg.score(x_dr_test,y_dr_test))    # 输出模型的决定系数R^2

9.逐步回归法代码

#定义向前逐步回归函数
def forward_select(data,target):
    variate=set(data.columns)  #将字段名转换成字典类型
    variate.remove(target)  #去掉因变量的字段名
    selected=[]
    current_score,best_new_score=float('inf'),float('inf')  #目前的分数和最好分数初始值都为无穷大（因为AIC越小越好）
    #循环筛选变量
    while variate:
        aic_with_variate=[]
        for candidate in variate:  #逐个遍历自变量
            formula="{}~{}".format(target,"+".join(selected+[candidate]))  #将自变量名连接起来
            aic=ols(formula=formula,data=data).fit().aic  #利用ols训练模型得出aic值
            aic_with_variate.append((aic,candidate))  #将第每一次的aic值放进空列表
        aic_with_variate.sort(reverse=True)  #降序排序aic值
        best_new_score,best_candidate=aic_with_variate.pop()  #最好的aic值等于删除列表的最后一个值，以及最好的自变量等于列表最后一个自变量
        if current_score>best_new_score:  #如果目前的aic值大于最好的aic值
            variate.remove(best_candidate)  #移除加进来的变量名，即第二次循环时，不考虑此自变量了
            selected.append(best_candidate)  #将此自变量作为加进模型中的自变量
            current_score=best_new_score  #最新的分数等于最好的分数
            print("aic is {},continuing!".format(current_score))  #输出最小的aic值
        else:
            print("for selection over!")
            break
    formula="{}~{}".format(target,"+".join(selected))  #最终的模型式子
    print("final formula is {}".format(formula))
    model=ols(formula=formula,data=data).fit()
    return(model)
import statsmodels.api as sm #最小二乘
from statsmodels.formula.api import ols #加载ols模型
forward_select(data=boston_data,target="Price")
lm=ols("Price~LSTAT+RM+PTRATIO+DIS+NOX+CHAS+B+ZN+CRIM+RAD+TAX",data=boston_data).fit()
lm.summary()

10.SVR的随机搜索和网格搜索

# 我们先来对未调参的SVR进行评价： 
from sklearn.svm import SVR     # 引入SVR类
from sklearn.pipeline import make_pipeline   # 引入管道简化学习流程
from sklearn.preprocessing import StandardScaler # 由于SVR基于距离计算，引入对数据进行标准化的类
from sklearn.model_selection import GridSearchCV  # 引入网格搜索调优
from sklearn.model_selection import cross_val_score # 引入K折交叉验证
from sklearn import datasets

boston = datasets.load_boston()     # 返回一个类似于字典的类
X = boston.data
y = boston.target
features = boston.feature_names
pipe_SVR = make_pipeline(StandardScaler(), SVR())

score1 = cross_val_score(estimator=pipe_SVR,X = X,y = y,
                                                     scoring = 'r2',
                                                      cv = 10)       # 10折交叉验证
print("CV accuracy: %.3f +/- %.3f" % ((np.mean(score1)),np.std(score1)))

# 下面我们使用网格搜索来对SVR调参：
from sklearn.pipeline import Pipeline
pipe_svr = Pipeline([("StandardScaler",StandardScaler()),
                                                         ("svr",SVR())])
param_range = [0.0001,0.001,0.01,0.1,1.0,10.0,100.0,1000.0]
param_grid = [{"svr__C":param_range,"svr__kernel":["linear"]},  # 注意__是指两个下划线，一个下划线会报错的
                            {"svr__C":param_range,"svr__gamma":param_range,"svr__kernel":["rbf"]}]
gs = GridSearchCV(estimator=pipe_svr,
                                                     param_grid = param_grid,
                                                     scoring = 'r2',
                                                      cv = 10)       # 10折交叉验证
gs = gs.fit(X,y)
print("网格搜索最优得分：",gs.best_score_)
print("网格搜索最优参数组合：\n",gs.best_params_)

# 下面我们使用随机搜索来对SVR调参：
from sklearn.model_selection import RandomizedSearchCV
from scipy.stats import uniform  # 引入均匀分布设置参数
pipe_svr = Pipeline([("StandardScaler",StandardScaler()),
                                                         ("svr",SVR())])
distributions = dict(svr__C=uniform(loc=1,scale=4),    # 构建连续参数的分布
                     svr__kernel=["linear","rbf"],                                   # 离散参数的集合
                    svr__gamma=uniform(loc=0, scale=4))

rs = RandomizedSearchCV(estimator=pipe_svr,
                                                     param_distributions = distributions,
                                                     scoring = 'r2',
                                                      cv = 10)       # 10折交叉验证
rs = rs.fit(X,y)
print("随机搜索最优得分：",rs.best_score_)
print("随机搜索最优参数组合：\n",rs.best_params_)

结果

	网格搜索	随机搜索
网格搜索最优得分：	0.6081303070817127	0.3986252778171015
网格搜索最优参数组合：	{‘svr__C’: 1000.0, ‘svr__gamma’: 0.001, ‘svr__kernel’: ‘rbf’}	{‘svr__C’: 4.739742135836545, ‘svr__gamma’: 0.09309434330454813, ‘svr__kernel’: ‘rbf’}

也用到了同样的参数进行分析，但是随机搜索速度比较快，但是当网格搜索的梯度比较大的时候，网格搜索可能结果更好