学习目标：

在学习网格搜索，交叉验证之后，对模型优化的效果进行图形化的评价的两种工具：

• 验证曲线： 由于训练集的评分已经被用于参数调优，因此该评分用于评估效果已经不再客观，需要使用验证集的评分用于评估。
  sklearn.model_ selection.validation_ curve(
  estimator, X, y
  param_ name : string, 在模型搜索中需要改变的参数
  param_ range : array-like, shape (n_ values,), 相应参数的具体值列表

  groups = None : array-like, with shape (n_ samples, )
  拆分为训练/测试集时用到的样本分组标签
  cv = None : int, 交互验证时的分组方法，为None时按照三组拆分

  scoring = None, n_ jobs = 1，pre_ dispatch = ‘all’, verbose = 0
  )返回:
  train_ scores : array, shape (n_ ticks, n_ cv folds)， 测试集的模型评分
  test_ scores : array, shape (n_ ticks, n_ cv folds)， 验证集的模型评分

• 学习曲线： 学习曲线用于评估多大的样本量用于训练才能达到最佳效果.
  sklearn.model_ selection.learning_ curve(
  estimator, X, y, groups = None
  train_ sizes = array([ 0.1，0.325， 0.55， 0.775， 1. ]) :
  模型拟合时用于训练集的相对/绝对样本数，用整数表示绝对样本数
  cv = None, scoring = None
  exploit_ incremental_ learning = False :是否使用增量学习策略
  n_ jobs = 1, pre_ dispatch = ‘all’, verbose = 0
  shuffle = False, random state = None
  )返回: .
  train_ sizes_ abs : array, shape = (n_ unique ticks,), 训练集大小
  train_ scores : array, shape (n_ ticks, n_ cv_ folds)， 训练集评分
  test_ scores : array, shape (n_ ticks, n cv folds),验证集评分

验证曲线：

1、导入验证曲线函数：

from sklearn.model_selection import validation_curve

2、导入波士顿房价数据集并实例化：

from sklearn.datasets import load_boston

实例化:

boston = load_boston()

3、导入sklearn的岭回归模块:

from sklearn.linear_model import Ridge

4、将原始数据打乱为随机顺序:

#导入numpy库并将原始波士顿房价数据集打乱
import numpy as np
np.random.seed(666)
X,y = boston.data, boston.target
indices = np.arange(y.shape[0])
np.random.shuffle(indices)
X,y = X[indices],y[indices]

5、返回评价结果：

train_scores,test_scores = validation_curve(Ridge(),
                                            X,y,
                                            "alpha",
                                            np.logspace(-10,10,200)
                                            )

（数据量过大，在此仅显示部分信息）

6、验证集的模型评分：

print(test_scores)

结果为：

（仅显示部分结果）

7、绘制验证曲线：

import matplotlib.pyplot as plt
%matplotlib inline
plt.scatter(np.logspace(-10,10,200),np.mean(test_scores,axis = 1))

结果为：

学习曲线：

• 用于评估多大的样本量用于训练才能达到最佳效果

• 在初期，增加样本量会使得模型评分持续改善，但改善速度逐渐放缓

• 如果在增加训练集大小时，训练分值和验证分值都已经收敛到一个很低的
  平稳值，则继续增加训练数据并不会改善模型效果

• 如果训练样本最大化时，训练分值仍然明显高于验证分值，说明模型存在
  过拟合，此时增加训练样本很可能会改善模型的泛化能力

1、导入学习曲线模块：

from sklearn.model_selection import learning_curve

2、设置训练集大小：

size = np.linspace(0.1,1,10)

3、返回评价结果：

train_sizes,train_scores,test_scores = learning_curve(Ridge(),
                                            X,y,
                                            train_sizes = size,
                                            cv = 10)

4、训练集大小：

print(train_sizes)

结果为：

[ 45  91 136 182 227 273 318 364 409 455]

5、训练集评分：

print(train_scores)

6、验证集评分：

print(test_scores)

7、绘制学习曲线：

plt.scatter(train_sizes,np.mean(train_scores,axis = 1))
plt.scatter(train_sizes,np.mean(test_scores,axis = 1))

结果为：

8、更改训练集大小进行验证：

• 8.1更改训练集大小为100：

size = np.linspace(0.1,1,100)
plt.scatter(train_sizes,np.mean(train_scores,axis = 1),s = 2)
plt.scatter(train_sizes,np.mean(test_scores,axis = 1),s = 2)

结果为：

• 8.2更改训练集大小为1000：

size = np.linspace(0.1,1,1000)
plt.scatter(train_sizes,np.mean(train_scores,axis = 1),s = 2)
plt.scatter(train_sizes,np.mean(test_scores,axis = 1),s = 2)

结果为：

python sklearn 验证曲线

下载文件地址：
链接: https://pan.baidu.com/s/1VdjCSw9MfKZ1WAcaiDyi8w 提取码: wtck

验证参数max_depth

"""
    验证曲线 对超参数 进行逐一验证  以验证取得最佳 超参数
"""
import numpy as np
import sklearn.preprocessing as sp
import sklearn.ensemble as se
import sklearn.model_selection as ms
import matplotlib.pyplot as mp

# 读取数据
lines = np.loadtxt(r".\car.txt", delimiter=',', dtype='str')
print(lines.shape)

# 整理样本空间 并编码 （对列执行标签编码）
train_x, train_y = [], []
encoders = []  # 标签编码数组
for index, row in enumerate(lines.T):
    encoder = sp.LabelEncoder()
    if index < (len(lines.T) - 1):  # 训练样本 X
        train_x.append(encoder.fit_transform(row))
    else:
        train_y = encoder.fit_transform(row)  # 训练样本结果 Y
    encoders.append(encoder)

train_x = np.array(train_x).T  # 转置
train_y = np.array(train_y)

print(train_x.shape, train_y.shape)
print(train_x[0], train_y[0])

# 随机森林分类模型
model = se.RandomForestClassifier(
    max_depth=9, n_estimators=140, random_state=7)

# 验证曲线  参数max_depth 分别使用 1-10 验证结果
# 最好效果为 9
train_scores, test_scores = ms.validation_curve(
    model, train_x, train_y, "max_depth", np.arange(1, 11, 1), cv=5)
print(test_scores.mean(axis=1))

# 绘制验证曲线
mp.grid(linestyle=":")
mp.plot(np.arange(1, 11, 1),
        test_scores.mean(axis=1),
        "o-", color="dodgerblue", label="Validation Curve")
mp.legend()
mp.show()

验证参数 n_estimators

"""
    验证曲线 对超参数 进行逐一验证  以验证取得最佳 超参数
"""
import numpy as np
import sklearn.preprocessing as sp
import sklearn.ensemble as se
import sklearn.model_selection as ms
import matplotlib.pyplot as mp

# 读取数据
lines = np.loadtxt(r".\car.txt", delimiter=',', dtype='str')
print(lines.shape)

# 整理样本空间 并编码 （对列执行标签编码）
train_x, train_y = [], []
encoders = []  # 标签编码数组
for index, row in enumerate(lines.T):
    encoder = sp.LabelEncoder()
    if index < (len(lines.T) - 1):  # 训练样本 X
        train_x.append(encoder.fit_transform(row))
    else:
        train_y = encoder.fit_transform(row)  # 训练样本结果 Y
    encoders.append(encoder)

train_x = np.array(train_x).T  # 转置
train_y = np.array(train_y)

print(train_x.shape, train_y.shape)
print(train_x[0], train_y[0])

# 随机森林分类模型
model = se.RandomForestClassifier(
    max_depth=9, n_estimators=140, random_state=7)

# 验证曲线 n_estimators 分别使用 100-200 验证结果
train_scores, test_scores = ms.validation_curve(model, train_x, train_y, "n_estimators",
                                                np.arange(100, 200, 10), cv=5)
print(test_scores.mean(axis=1))

# 绘制验证曲线
mp.grid(linestyle=":")
mp.plot(np.arange(100, 200, 10),
        test_scores.mean(axis=1),
        "o-", color="dodgerblue", label="Validation Curve")
mp.legend()
mp.show()

         最近在复盘优达学城的机器学习项目， 重新写了一下波斯顿放假预测的项目，除了模型的选择及网格搜索进行选择参数的相关知识外，还着重复习了关于学习曲线和复杂度曲线（验证曲线）

        首先学习曲线和复杂度曲线（验证曲线）的区别，学习曲线是指在参数值确定的情况下，训练集和验证集的得分情况的对比，复杂度曲线（验证集曲线）是展示某个参数在取不同值时候，训练集与测试集得分情况的对比。

        学习曲线的X轴是数据的数量，y轴是得分；复杂度曲线（验证曲线）的x轴是一个参数的值:比如max_depth（1,2,3,4,5,6,7,8,9,10），y轴是训练集和测试集在各个参数取值情况下的得分

 上面两张图分别是学习曲线和复杂度曲线

下面来说一下学习曲线或者验证曲线的数据集合的划分

1 ShuffleSplit 划分

上面的两个图中就是用ShuffleSplit 方式对数据集合进行划分的，代码如下:

cv = ShuffleSplit(features.shape[0], n_iter = 10, test_size = 0.2, random_state = 0)
train_sizes = np.rint(np.linspace(1, data.shape[0]*0.8 - 1, 9)).astype(int)

train_sizes, train_score, test_score = curves.learning_curve(
    XGBRegressor(), X, y, cv=cv, train_sizes=train_sizes,scoring =score_fun
    )

train_score_mean = np.mean(train_score,axis=1)
strain_score_std = np.std(train_score)
test_score_mean = np.mean(test_score,axis=1)
test_score_stu = np.stu(train_score,axis=1)

在学习曲线函数中，通过cv 参数来设置划分的数据集，有几种方式:

（1）如上边代码，cv 是按照某种方式划分好的数据集

（2）cv=10，这种cv 是数字格式，是直接采用n-fold 的交叉检验的方式进行，直接设置n的值即可

（3）自己手动划分

#数据集合中有490条数据 index 是从0-489
train_index = np.arange(0,391)
test_index = np.arange(391,489)

#构建cv 集合
test_cv = [[train_index,test_index]]

#学习曲线 cv参数传入test_cv
sizes,train_scores,test_scores = curves.learning_curve(regressor,features,prices,cv=test_cv,train_sizes=train_sizes)

下面看下学习曲线的画法，代码如下：

sizes,train_scores,test_scores = curves.learning_curve(regressor,features,prices,cv=cv,train_sizes=train_sizes)

train_std = np.std(train_scores, axis = 1)
train_mean = np.mean(train_scores, axis = 1)
test_std = np.std(test_scores, axis = 1)
test_mean = np.mean(test_scores, axis = 1)

depth = 4
ax = fig.add_subplot(2,2,1)
ax.plot(sizes, train_mean, 'o-', color = 'r', label = 'Training Score')
ax.plot(sizes, test_mean, 'o-', color = 'g', label = 'Training Score')
ax.fill_between(sizes, train_mean - train_std,train_mean + train_std, alpha = 0.15, color = 'r')
 ax.fill_between(sizes, test_mean - test_std, test_mean + test_std, alpha = 0.15, color = 'g')
    
 ax.set_ylabel('Score')
 ax.set_title('max_depth = %s'%(depth))
 ax.set_ylim([-0.05, 1.05])

 来看下这三种划分方式的学习曲线情况：

（1）shuffleSplit 划分：cv=ShuffleSplit（.......） cv=cv,对于这个数据集 很适合

(2) cv=10 交叉验证 n-fold 划分方式

可以看出学习曲线变化很大

（3） 手动划分 test_cv=[[train_index,test_index]] ,cv=test_cv

由此可以看出，对于同一个数据集，划分的方式不同，其验证曲线会有很大差别 。