【解决（几乎）任何机器学习问题】:交叉验证

在上⼀章中，我们没有建⽴任何模型。原因很简单，在创建任何⼀种机器学习模型之前，我们必须知道什么是交叉检验，以及如何根据数据集选择最佳交叉检验数据集。

那么，什么是交叉检验，我们为什么要关注它？

关于什么是交叉检验，我们可以找到多种定义。我的定义只有⼀句话：交叉检验是构建机器学习模型过程中的⼀个步骤，它可以帮助我们确保模型准确拟合数据，同时确保我们不会过拟合。但这⼜引出了另⼀个词：过拟合。

要解释过拟合，我认为最好先看⼀个数据集。有⼀个相当有名的红酒质量数据集（ red wine quality dataset）。这个数据集有11个不同的特征，这些特征决定了红酒的质量。

这些属性包括：

固定酸度（fixed acidity）

挥发性酸度（volatile acidity）

柠檬酸（citric acid）

残留糖（residual sugar）

氯化物（chlorides）

游离⼆氧化硫（free sulfur dioxide）

⼆氧化硫总量（total sulfur dioxide）

密度（density）

PH值（pH）

硫酸盐（sulphates）

酒精（alcohol）

根据这些不同特征，我们需要预测红葡萄酒的质量，质量值介于0到10之间。

让我们看看这些数据是怎样的。

import pandas as pd

df = pd . read_csv ( "winequality-red.csv" )

我们可以将这个问题视为分类问题，也可以视为回归问题。为了简单起⻅，我们选择分类。然⽽，这个数据集值包含6种质量值。因此，我们将所有质量值映射到0到5之间。

quality_mapping = {
    3: 0,
    4: 1,
    5: 2,
    6: 3,
    7: 4,
    8: 5
}
df.loc[:, "quality"] = df.quality.map(quality_mapping)

当我们看⼤这些数据并将其视为⼀个分类问题时，我们脑海中会浮现出很多可以应⽤的算法，也许，我们可以使⽤神经⽹络。但是，如果我们从⼀开始就深⼊研究神经⽹络，那就有点牵强了。所以，让我们从简单的、我们也能可视化的东西开始：决策树。

在开始了解什么是过拟合之前，我们先将数据分为两部分。这个数据集有1599个样本。我们保留

1000个样本⽤于训练，599个样本作为⼀个单独的集合。

以下代码可以轻松完成划分：

df = df.sample(frac=1).reset_index(drop=True)
df_train = df.head(1000)
df_test = df.tail(599)

现在，我们将在训练集上使⽤scikit-learn训练⼀个决策树模型。

from sklearn import tree
from sklearn import metrics

clf = tree.DecisionTreeClassifier(max_depth=3)

cols = ['fixed acidity',
        'volatile acidity',
        'citric acid',
        'residual sugar',
        'chlorides',
        'free sulfur dioxide',
        'total sulfur dioxide',
        'density',
        'pH',
        'sulphates',
        'alcohol']
clf.fit(df_train[cols], df_train.quality)

请注意，我将决策树分类器的最⼤深度（max_depth）设为3。该模型的所有其他参数均保持默认值。现在，我们在训练集和测试集上测试该模型的准确性：

train_predictions = clf.predict(df_train[cols])

test_predictions = clf.predict(df_test[cols])

train_accuracy = metrics.accuracy_score(
    df_train.quality, train_predictions
)
test_accuracy = metrics.accuracy_score(
    df_test.quality, test_predictions
)

训练和测试的准确率分别为58.9%和54.25%。现在，我们将最⼤深度（max_depth）增加到7，并重复上述过程。这样，训练准确率为76.6%，测试准确率为57.3%。在这⾥，我们使⽤准确率，主要是因为它是最直接的指标。对于这个问题来说，它可能不是最好的指标。我们可以根据最⼤深度（max_depth）的不同值来计算这些准确率，并绘制曲线图。

from sklearn import tree
from sklearn import metrics
import matplotlib
import matplotlib.pyplot as plt
import seaborn as sns

# 设置 matplotlib 字体大小
matplotlib.rc('xtick', labelsize=20)
matplotlib.rc('ytick', labelsize=20)

# 用于在 Jupyter Notebook 中显示图形
%matplotlib inline

# 初始化训练集和测试集的准确率列表
train_accuracies = [0.5]
test_accuracies = [0.5]

# 循环尝试不同的决策树深度
for depth in range(1, 25):
    clf = tree.DecisionTreeClassifier(max_depth=depth)
    
    # 特征列名
    cols = [
        'fixed acidity',
        'volatile acidity',
        'citric acid',
        'residual sugar',
        'chlorides',
        'free sulfur dioxide',
        'total sulfur dioxide',
        'density',
        'pH',
        'sulphates',
        'alcohol'
    ]
    
    # 使用训练集训练模型
    clf.fit(df_train[cols], df_train.quality)
    
    # 进行训练集和测试集的预测
    train_predictions = clf.predict(df_train[cols])
    test_predictions = clf.predict(df_test[cols])
    
    # 计算训练集和测试集的准确率
    train_accuracy = metrics.accuracy_score(df_train.quality, train_predictions)
    test_accuracy = metrics.accuracy_score(df_test.quality, test_predictions)
    
    # 将准确率添加到列表中
    train_accuracies.append(train_accuracy)
    test_accuracies.append(test_accuracy)

# 绘制准确率随最大深度变化的图像
plt.figure(figsize=(10, 5))
sns.set_style("whitegrid")
plt.plot(train_accuracies, label="train accuracy")
plt.plot(test_accuracies, label="test accuracy")
plt.legend(loc="upper left", prop={'size': 15})
plt.xticks(range(0, 26, 5))
plt.xlabel("max_depth", size=20)
plt.ylabel("accuracy", size=20)
plt.show()

这将⽣成如图 2 所⽰的曲线图。

我们可以看到，当最⼤深度（max_depth）的值为14时，测试数据的得分最⾼。随着我们不断增加这个参数的值，测试准确率会保持不变或变差，但训练准确率会不断提⾼。这说明，随着最⼤深度（max_depth）的增加，决策树模型对训练数据的学习效果越来越好，但测试数据的性能却丝毫没有提⾼。

这就是所谓的过拟合。

模型在训练集上完全拟合，⽽在测试集上却表现不佳。这意味着模型可以很好地学习训练数据，但⽆法泛化到未⻅过的样本上。在上⾯的数据集中，我们可以建⽴⼀个最⼤深度（max_depth）⾮常⾼的模型，它在训练数据上会有出⾊的结果，但这种模型并不实⽤，因为它在真实世界的样本或实时数据上不会提供类似的结果。

有⼈可能会说，这种⽅法并没有过拟合，因为测试集的准确率基本保持不变。过拟合的另⼀个定义是，当我们不断提⾼训练损失时，测试损失也在增加。这种情况在神经⽹络中⾮常常⻅。

每当我们训练⼀个神经⽹络时，都必须在训练期间监控训练集和测试集的损失。如果我们有⼀个⾮常⼤的⽹络来处理⼀个⾮常⼩的数据集（即样本数⾮常少），我们就会观察到，随着我们不断训练，训练集和测试集的损失都会减少。但是，在某个时刻，测试损失会达到最⼩值，之后，即使训练损失进⼀步减少，测试损失也会开始增加。我们必须在验证损失达到最⼩值时停⽌训练。

这是对过拟合最常⻅的解释。

奥卡姆剃⼑⽤简单的话说，就是不要试图把可以⽤简单得多的⽅法解决的事情复杂化。换句话说，最简单的解决⽅案就是最具通⽤性的解决⽅案。⼀般来说，只要你的模型不符合奥卡姆剃⼑原则，就很可能是过拟合。

现在我们可以回到交叉检验。

在解释过拟合时，我决定将数据分为两部分。我在其中⼀部分上训练模型，然后在另⼀部分上检查其性能。这也是交叉检验的⼀种，通常被称为 "暂留集"（hold-out set ）。当我们拥有⼤量数据，⽽模型推理是⼀个耗时的过程时，我们就会使⽤这种（交叉）验证。

交叉检验有许多不同的⽅法，它是建⽴⼀个良好的机器学习模型的最关键步骤。选择正确的交叉检验取决于所处理的数据集，在⼀个数据集上适⽤的交叉检验也可能不适⽤于其他数据集。不过，有⼏种类型的交叉检验技术最为流⾏和⼴泛使⽤。

其中包括：

k折交叉检验

分层k折交叉检验

暂留交叉检验

留⼀交叉检验

分组k折交叉检验交叉检验是将训练数据分层⼏个部分，我们在其中⼀部分上训练模型，然后在其余部分上进⾏测试。请看图4。

图 4 和图 5 说明，当你得到⼀个数据集来构建机器学习模型时，你会把它们分成两个不同的集：训练集和验证集。很多⼈还会将其分成第三组，称之为测试集。不过，我们将只使⽤两个集。如

你所⻅，我们将样本和与之相关的⽬标进⾏了划分。我们可以将数据分为 k 个互不关联的不同集

合。这就是所谓的 k 折交叉检验。

我们可以使⽤scikit-learn中的KFold将任何数据分割成k个相等的部分。每个样本分配⼀个从0到k-1的值。

import pandas as pd
from sklearn import model_selection

if __name__ == "__main__":
    # 读取训练数据集
    df = pd.read_csv("train.csv")
    
    # 创建一个新列 "kfold" 并初始化为 -1
    df["kfold"] = -1
    
    # 随机打乱数据集
    df = df.sample(frac=1).reset_index(drop=True)
    
    # 初始化 KFold 分割器，将数据集分成 5 折
    kf = model_selection.KFold(n_splits=5)
    
    # 遍历每一折并为相应的样本分配折叠索引
    for fold, (trn_, val_) in enumerate(kf.split(X=df)):
        df.loc[val_, 'kfold'] = fold
    
    # 将带有折叠索引的数据集保存为 CSV 文件
    df.to_csv("train_folds.csv", index=False)

⼏乎所有类型的数据集都可以使⽤此流程。例如，当数据图像时，您可以创建⼀个包含图像 ID，图像位置和图像标签的 CSV，然后使⽤上述流程。

另⼀种重要的交叉检验类型是分层 k 折交叉检验。如果你有⼀个偏斜的⼆元分类数据集，其中正样本占 90%，负样本只占 10%，那么你就不应该使⽤随机 k 折交叉。对这样的数据集使⽤简单的k折交叉检验可能会导致折叠样本全部为负样本。在这种情况下，我们更倾向于使⽤分层 k 折交叉检验。分层 k 折交叉检验可以保持每个折中标签的⽐例不变。因此，在每个折叠中，都会有相同的 90% 正样本和 10% 负样本。因此，⽆论您选择什么指标进⾏评估，都会在所有折叠中得到相似的结果。

修改创建 k 折交叉检验的代码以创建分层 k 折交叉检验也很容易。我们只需将

model_selection.KFold更改为 model_selection.StratifiedKFold ，并在 kf.split(...) 函数中指定要分层的⽬标列。我们假设 CSV 数据集有⼀列名为 "target" ，并且是⼀个分类问题。

import pandas as pd
from sklearn import model_selection

if __name__ == "__main__":
    # 读取训练数据集
    df = pd.read_csv("train.csv")
    
    # 创建一个新列 "kfold" 并初始化为 -1
    df["kfold"] = -1
    
    # 随机打乱数据集
    df = df.sample(frac=1).reset_index(drop=True)
    
    # 提取目标变量列
    y = df.target.values
    
    # 初始化 StratifiedKFold 分割器，将数据集分成 5 折，并保持目标变量的分布相同
    kf = model_selection.StratifiedKFold(n_splits=5)
    
    # 遍历每一折并为相应的样本分配折叠索引
    for fold, (train_idx, val_idx) in enumerate(kf.split(X=df, y=y)):
        df.loc[val_idx, 'kfold'] = fold
    
    # 将带有折叠索引的数据集保存为 CSV 文件
    df.to_csv("train_folds.csv", index=False)

对于葡萄酒数据集，我们来看看标签的分布情况。

b = sns . countplot ( x = 'quality' , data = df )

b . set_xlabel ( "quality" , fontsize = 20 )

b . set_ylabel ( "count" , fontsize = 20 )

请注意，我们继续上⾯的代码。因此，我们已经转换了⽬标值。从图 6 中我们可以看出，质量偏差很⼤。有些类别有很多样本，有些则没有那么多。如果我们进⾏简单的k折交叉检验，那么每个折叠中的⽬标值分布都不会相同。因此，在这种情况下，我们选择分层 k 折交叉检验。

规则很简单，如果是标准分类问题，就盲⽬选择分层k折交叉检验。

但如果数据量很⼤，该怎么办呢？假设我们有 100万个样本。5倍交叉检验意味着在 800k 个样本上进⾏训练，在 200k 个样本上进⾏验证。根据我们选择的算法，对于这样规模的数据集来说，训练甚⾄验证都可能⾮常昂贵。在这种情况下，我们可以选择暂留交叉检验。

创建保持结果的过程与分层 k 折交叉检验相同。对于拥有 100 万个样本的数据集，我们可以创建 10 个折叠⽽不是 5 个，并保留其中⼀个折叠作为保留样本。这意味着，我们将有 10 万个样本被保留下来，我们将始终在这个样本集上计算损失、准确率和其他指标，并在 90 万个样本上进训练。

在处理时间序列数据时，暂留交叉检验也⾮常常⽤。假设我们要解决的问题是预测⼀家商店 2020 年的销售额，⽽我们得到的是 2015-2019 年的所有数据。在这种情况下，你可以选择 2019 年的所有数据作为保留数据，然后在 2015年⾄ 2018 年的所有数据上训练你的模型。

在图 7 所⽰的⽰例中，假设我们的任务是预测从时间步骤 31 到 40 的销售额。我们可以保留 21 ⾄

30 步的数据，然后从 0 步到 20 步训练模型。需要注意的是，在预测 31 步⾄ 40 步时，应将 21步⾄ 30步的数据纳⼊模型，否则，模型的性能将⼤打折扣。

在很多情况下，我们必须处理⼩型数据集，⽽创建⼤型验证集意味着模型学习会丢失⼤量数据。在这种情况下，我们可以选择留⼀交叉检验，相当于特殊的 k 则交叉检验其中 k=N ，N 是数据集的样本数。这意味着在所有的训练折叠中，我们将对除 1 之外的所有数据样本进⾏训练。这种类型的交叉检验的折叠数与数据集中的样本数相同。

需要注意的是，如果模型的速度不够快，这种类型的交叉检验可能会耗费⼤量时间，但由于这种交叉检验只适⽤于⼩型数据集，因此并不重要。

现在我们可以转向回归问题了。回归问题的好处在于，除了分层 k 折交叉检验之外，我们可以在回归问题上使⽤上述所有交叉检验技术。也就是说，我们不能直接使⽤分层 k 折交叉检验，但有⼀些⽅法可以稍稍改变问题，从⽽在回归问题中使⽤分层 k 折交叉检验。⼤多数情况下，简单的k 折交叉检验适⽤于任何回归问题。但是，如果发现⽬标分布不⼀致，就可以使⽤分层 k 折交叉检验。

要在回归问题中使⽤分层 k 折交叉检验，我们必须先将⽬标划分为若⼲个分层，然后再以处理分类问题的相同⽅式使⽤分层 k 折交叉检验。选择合适的分层数有⼏种选择。如果样本量很（>10k，> 100k），那么就不需要考虑分层的数量。只需将数据分为 10 或 20层即可。如果样本数不多，则可以使⽤ Sturge's Rule 这样的简单规则来计算适当的分层数。

其中是数据集中的样本数。该函数如图8所⽰。

让我们制作⼀个回归数据集样本，并尝试应⽤分层 k 折交叉检验，如下⾯的 python 代码段所⽰。

import numpy as np
import pandas as pd
from sklearn import datasets
from sklearn import model_selection

def create_folds(data):
    # 初始化新列 "kfold" 并将其全部赋值为 -1
    data["kfold"] = -1
    
    # 随机打乱数据集
    data = data.sample(frac=1).reset_index(drop=True)
    
    # 计算分箱数量
    num_bins = int(np.floor(1 + np.log2(len(data))))
    
    # 将目标变量分到对应的分箱中
    data.loc[:, "bins"] = pd.cut(
        data["target"], bins=num_bins, labels=False
    )
    
    # 初始化 StratifiedKFold 分割器，保持分箱后的分布相同
    kf = model_selection.StratifiedKFold(n_splits=5)
    
    # 遍历每一折并为相应的样本分配折叠索引
    for fold, (train_idx, val_idx) in enumerate(kf.split(X=data, y=data.bins.values)):
        data.loc[val_idx, 'kfold'] = fold
    
    # 删除创建的分箱列
    data = data.drop("bins", axis=1)
    return data

if __name__ == "__main__":
    # 生成模拟数据
    X, y = datasets.make_regression(
        n_samples=15000, n_features=100, n_targets=1
    )
    
    # 将模拟数据转换为 DataFrame 格式
    df = pd.DataFrame(
        X,
        columns=[f"f_{i}" for i in range(X.shape[1])]
    )
    
    # 将目标变量添加到 DataFrame 中
    df.loc[:, "target"] = y
    
    # 使用 create_folds 函数创建带有折叠索引的数据集
    df = create_folds(df)

交叉检验是构建机器学习模型的第⼀步，也是最基本的⼀步。如果要做特征⼯程，⾸先要拆分数据。如果要建⽴模型，⾸先要拆分数据。如果你有⼀个好的交叉检验⽅案，其中验证数据能够代

表训练数据和真实世界的数据，那么你就能建⽴⼀个具有⾼度通⽤性的好的机器学习模型。

本章介绍的交叉检验类型⼏乎适⽤于所有机器学习问题。不过，你必须记住，交叉检验也在很⼤

程度上取决于数据，你可能需要根据你的问题和数据采⽤新的交叉检验形式。

例如，假设我们有⼀个问题，希望建⽴⼀个模型，从患者的⽪肤图像中检测出⽪肤癌。我们的任

务是建⽴⼀个⼆元分类器，该分类器接收输⼊图像并预测其良性或恶性的概率。

在这类数据集中，训练数据集中可能有同⼀患者的多张图像。因此，要在这⾥建⽴⼀个良好的交

叉检验系统，必须有分层的 k 折交叉检验，但也必须确保训练数据中的患者不会出现在验证数据

中。幸运的是，scikit-learn 提供了⼀种称为 GroupKFold 的交叉检验类型。在这⾥，患者可以被

视为组。但遗憾的是，scikit-learn ⽆法将 GroupKFold 与 StratifiedKFold 结合起来。所以你需

要⾃⼰动⼿。我把它作为⼀个练习留给读者的练习。