11. 常见陷阱和推荐做法#

本章旨在说明在使用 scikit-learn 时出现的一些常见陷阱和反模式。它提供了**不**应该做什么的示例，以及相应的正确示例。

11.1. 不一致的预处理#

scikit-learn 提供了一个数据集转换库，可以用于清理（参见数据预处理）、减少（参见无监督降维）、扩展（参见核近似）或生成（参见特征提取）特征表示。如果这些数据转换在训练模型时使用，那么它们也必须应用于后续数据集，无论是测试数据还是生产系统中的数据。否则，特征空间将会改变，模型将无法有效执行。

对于以下示例，我们创建一个具有单个特征的合成数据集

>>> from sklearn.datasets import make_regression
>>> from sklearn.model_selection import train_test_split

>>> random_state = 42
>>> X, y = make_regression(random_state=random_state, n_features=1, noise=1)
>>> X_train, X_test, y_train, y_test = train_test_split(
...     X, y, test_size=0.4, random_state=random_state)

错误

训练数据集已缩放，但测试数据集未缩放，因此模型在测试数据集上的性能低于预期

>>> from sklearn.metrics import mean_squared_error
>>> from sklearn.linear_model import LinearRegression
>>> from sklearn.preprocessing import StandardScaler

>>> scaler = StandardScaler()
>>> X_train_transformed = scaler.fit_transform(X_train)
>>> model = LinearRegression().fit(X_train_transformed, y_train)
>>> mean_squared_error(y_test, model.predict(X_test))
62.80...

正确

我们不应该将未转换的 X_test 传递给 predict，而是应该像转换训练数据一样转换测试数据

>>> X_test_transformed = scaler.transform(X_test)
>>> mean_squared_error(y_test, model.predict(X_test_transformed))
0.90...

或者，我们建议使用 Pipeline，这使得将转换与估计器链接起来更加容易，并减少了忘记转换的可能性

>>> from sklearn.pipeline import make_pipeline

>>> model = make_pipeline(StandardScaler(), LinearRegression())
>>> model.fit(X_train, y_train)
Pipeline(steps=[('standardscaler', StandardScaler()),
                ('linearregression', LinearRegression())])
>>> mean_squared_error(y_test, model.predict(X_test))
0.90...

Pipeline 还有助于避免另一个常见陷阱：将测试数据泄漏到训练数据中。

11.2. 数据泄漏#

当在构建模型时使用了在预测时不可用的信息时，就会发生数据泄漏。这会导致过于乐观的性能估计，例如来自交叉验证的估计，因此当模型用于实际新数据（例如在生产过程中）时，性能会更差。

一个常见的原因是未将测试和训练数据子集分开。测试数据绝不应用于做出关于模型的选择。**一般规则是永远不要在测试数据上调用** fit。虽然这听起来很明显，但在某些情况下很容易被忽略，例如在应用某些预处理步骤时。

尽管训练和测试数据子集都应该接受相同的预处理转换（如上一节所述），但重要的是这些转换**只能**从训练数据中学习。例如，如果你有一个归一化步骤，其中你除以平均值，那么平均值应该是训练子集的平均值，**而不是**所有数据的平均值。如果测试子集包含在平均值计算中，则来自测试子集的信息会影响模型。

11.2.1. 如何避免数据泄漏#

以下是一些避免数据泄漏的技巧

始终先将数据拆分为训练和测试子集，尤其是在任何预处理步骤之前。
在使用 fit 和 fit_transform 方法时，切勿包含测试数据。使用所有数据，例如 fit(X)，可能导致过于乐观的分数。

相反，transform 方法应该在训练和测试子集上都使用，因为相同的预处理应该应用于所有数据。这可以通过在训练子集上使用 fit_transform 并在测试子集上使用 transform 来实现。
scikit-learn pipeline 是防止数据泄漏的好方法，因为它确保在正确的数据子集上执行适当的方法。pipeline 是用于交叉验证和超参数调整功能的理想选择。

下面详细介绍了在预处理期间发生数据泄漏的示例。

11.2.2. 预处理期间的数据泄漏#

注意

我们在这里选择用特征选择步骤来说明数据泄漏。然而，这种泄漏风险与 scikit-learn 中几乎所有转换都相关，包括（但不限于）StandardScaler、SimpleImputer 和 PCA。

scikit-learn 中提供了许多特征选择功能。它们可以帮助删除不相关、冗余和噪声特征，并提高模型构建时间和性能。与任何其他类型的预处理一样，特征选择**只能**使用训练数据。在特征选择中包含测试数据会对模型产生乐观偏差。

为了演示，我们将创建这个具有 10,000 个随机生成特征的二元分类问题

>>> import numpy as np
>>> n_samples, n_features, n_classes = 200, 10000, 2
>>> rng = np.random.RandomState(42)
>>> X = rng.standard_normal((n_samples, n_features))
>>> y = rng.choice(n_classes, n_samples)

错误

使用所有数据执行特征选择会导致准确率分数远高于偶然性，即使我们的目标是完全随机的。这种随机性意味着我们的 X 和 y 是独立的，因此我们期望准确率在 0.5 左右。然而，由于特征选择步骤“看到”了测试数据，模型具有不公平的优势。在下面的不正确示例中，我们首先使用所有数据进行特征选择，然后将数据拆分为训练和测试子集进行模型拟合。结果是准确率分数远高于预期

>>> from sklearn.model_selection import train_test_split
>>> from sklearn.feature_selection import SelectKBest
>>> from sklearn.ensemble import HistGradientBoostingClassifier
>>> from sklearn.metrics import accuracy_score

>>> # Incorrect preprocessing: the entire data is transformed
>>> X_selected = SelectKBest(k=25).fit_transform(X, y)

>>> X_train, X_test, y_train, y_test = train_test_split(
...     X_selected, y, random_state=42)
>>> gbc = HistGradientBoostingClassifier(random_state=1)
>>> gbc.fit(X_train, y_train)
HistGradientBoostingClassifier(random_state=1)

>>> y_pred = gbc.predict(X_test)
>>> accuracy_score(y_test, y_pred)
0.76

正确

为了防止数据泄漏，一个好的做法是**首先**将数据拆分为训练和测试子集。然后可以使用仅训练数据集执行特征选择。请注意，无论何时使用 fit 或 fit_transform，我们都只使用训练数据集。现在的分数是我们对数据所期望的，接近偶然性

>>> X_train, X_test, y_train, y_test = train_test_split(
...     X, y, random_state=42)
>>> select = SelectKBest(k=25)
>>> X_train_selected = select.fit_transform(X_train, y_train)

>>> gbc = HistGradientBoostingClassifier(random_state=1)
>>> gbc.fit(X_train_selected, y_train)
HistGradientBoostingClassifier(random_state=1)

>>> X_test_selected = select.transform(X_test)
>>> y_pred = gbc.predict(X_test_selected)
>>> accuracy_score(y_test, y_pred)
0.5

在这里，我们再次建议使用 Pipeline 将特征选择和模型估计器链接起来。pipeline 确保在执行 fit 时只使用训练数据，而测试数据只用于计算准确率分数

>>> from sklearn.pipeline import make_pipeline
>>> X_train, X_test, y_train, y_test = train_test_split(
...     X, y, random_state=42)
>>> pipeline = make_pipeline(SelectKBest(k=25),
...                          HistGradientBoostingClassifier(random_state=1))
>>> pipeline.fit(X_train, y_train)
Pipeline(steps=[('selectkbest', SelectKBest(k=25)),
                ('histgradientboostingclassifier',
                 HistGradientBoostingClassifier(random_state=1))])

>>> y_pred = pipeline.predict(X_test)
>>> accuracy_score(y_test, y_pred)
0.5

pipeline 也可以输入到交叉验证函数中，例如 cross_val_score。同样，pipeline 确保在拟合和预测期间使用正确的数据子集和估计器方法

>>> from sklearn.model_selection import cross_val_score
>>> scores = cross_val_score(pipeline, X, y)
>>> print(f"Mean accuracy: {scores.mean():.2f}+/-{scores.std():.2f}")
Mean accuracy: 0.43+/-0.05

11.3. 控制随机性#

一些 scikit-learn 对象本质上是随机的。这些通常是估计器（例如 RandomForestClassifier）和交叉验证拆分器（例如 KFold）。这些对象的随机性通过它们的 random_state 参数控制，如词汇表中所述。本节扩展了词汇表条目，并描述了与这个微妙参数相关的良好实践和常见陷阱。

注意

推荐摘要

为了获得交叉验证 (CV) 结果的最佳鲁棒性，在创建估计器时传递 RandomState 实例，或者将 random_state 保持为 None。将整数传递给 CV 拆分器通常是最安全的选择，并且是首选；将 RandomState 实例传递给拆分器有时可能有助于实现非常特定的用例。对于估计器和拆分器，传递整数与传递实例（或 None）会导致微妙但显著的差异，尤其是在 CV 过程中。在报告结果时理解这些差异非常重要。

为了在多次执行中获得可重现的结果，请删除所有使用 random_state=None 的情况。

11.3.1. 使用 `None` 或 `RandomState` 实例，以及对 `fit` 和 `split` 的重复调用#

random_state 参数根据以下规则确定对 fit（对于估计器）或对 split（对于 CV 拆分器）的多次调用是否会产生相同的结果

如果传递整数，多次调用 fit 或 split 总是会产生相同的结果。
如果传递 None 或 RandomState 实例：每次调用 fit 和 split 都会产生不同的结果，并且连续调用会探索所有熵源。None 是所有 random_state 参数的默认值。

我们在这里说明了这些规则对于估计器和 CV 拆分器的适用性。

注意

由于传递 random_state=None 等同于传递来自 numpy 的全局 RandomState 实例（random_state=np.random.mtrand._rand），我们在这里不会明确提及 None。适用于实例的所有内容也适用于使用 None。

11.3.1.1. 估计器#

传递实例意味着多次调用 fit 不会产生相同的结果，即使估计器在相同数据和相同超参数上拟合

>>> from sklearn.linear_model import SGDClassifier
>>> from sklearn.datasets import make_classification
>>> import numpy as np

>>> rng = np.random.RandomState(0)
>>> X, y = make_classification(n_features=5, random_state=rng)
>>> sgd = SGDClassifier(random_state=rng)

>>> sgd.fit(X, y).coef_
array([[ 8.85418642,  4.79084103, -3.13077794,  8.11915045, -0.56479934]])

>>> sgd.fit(X, y).coef_
array([[ 6.70814003,  5.25291366, -7.55212743,  5.18197458,  1.37845099]])

从上面的代码片段中我们可以看到，重复调用 sgd.fit 产生了不同的模型，即使数据是相同的。这是因为估计器的随机数生成器 (RNG) 在调用 fit 时被消耗（即变异），并且这个变异的 RNG 将用于后续对 fit 的调用。此外，rng 对象在所有使用它的对象之间共享，因此这些对象变得有些相互依赖。例如，共享相同 RandomState 实例的两个估计器将相互影响，正如我们稍后在讨论克隆时将看到的。在调试时记住这一点很重要。

如果我们向 SGDClassifier 的 random_state 参数传递了一个整数，我们将每次都获得相同的模型，因此分数相同。当我们传递一个整数时，在所有对 fit 的调用中都使用相同的 RNG。内部发生的情况是，尽管 RNG 在调用 fit 时被消耗，但在 fit 开始时它总是重置为其原始状态。

11.3.1.2. CV 拆分器#

当传递 RandomState 实例时，随机 CV 拆分器具有类似的行为；多次调用 split 会产生不同的数据拆分

>>> from sklearn.model_selection import KFold
>>> import numpy as np

>>> X = y = np.arange(10)
>>> rng = np.random.RandomState(0)
>>> cv = KFold(n_splits=2, shuffle=True, random_state=rng)

>>> for train, test in cv.split(X, y):
...     print(train, test)
[0 3 5 6 7] [1 2 4 8 9]
[1 2 4 8 9] [0 3 5 6 7]

>>> for train, test in cv.split(X, y):
...     print(train, test)
[0 4 6 7 8] [1 2 3 5 9]
[1 2 3 5 9] [0 4 6 7 8]

我们可以看到，从第二次调用 split 开始，拆分是不同的。如果你通过多次调用 split 来比较多个估计器的性能，这可能会导致意想不到的结果，正如我们将在下一节中看到的那样。

11.3.2. 常见陷阱和微妙之处#

虽然控制 random_state 参数的规则看似简单，但它们确实有一些微妙的含义。在某些情况下，这甚至可能导致错误的结论。

11.3.2.1. 估计器#

不同的 random_state 类型导致不同的交叉验证过程

根据 random_state 参数的类型，估计器的行为会有所不同，尤其是在交叉验证过程中。考虑以下代码片段

>>> from sklearn.ensemble import RandomForestClassifier
>>> from sklearn.datasets import make_classification
>>> from sklearn.model_selection import cross_val_score
>>> import numpy as np

>>> X, y = make_classification(random_state=0)

>>> rf_123 = RandomForestClassifier(random_state=123)
>>> cross_val_score(rf_123, X, y)
array([0.85, 0.95, 0.95, 0.9 , 0.9 ])

>>> rf_inst = RandomForestClassifier(random_state=np.random.RandomState(0))
>>> cross_val_score(rf_inst, X, y)
array([0.9 , 0.95, 0.95, 0.9 , 0.9 ])

我们看到 rf_123 和 rf_inst 的交叉验证分数不同，这是意料之中的，因为我们没有传递相同的 random_state 参数。然而，这些分数之间的差异比看起来更微妙，并且 cross_val_score **在每种情况下执行的交叉验证过程都显著不同**

由于 rf_123 传递了一个整数，因此每次调用 fit 都使用相同的 RNG：这意味着随机森林估计器的所有随机特征在 CV 过程的 5 个折叠中的每个折叠中都相同。特别是，估计器的（随机选择的）特征子集在所有折叠中都相同。
由于 rf_inst 传递了一个 RandomState 实例，因此每次调用 fit 都从不同的 RNG 开始。因此，随机特征子集在每个折叠中都会有所不同。

虽然在折叠中具有恒定的估计器 RNG 并非本质上错误，但我们通常希望 CV 结果对于估计器的随机性具有鲁棒性。因此，传递实例而不是整数可能更可取，因为它允许估计器 RNG 在每个折叠中变化。

注意

在这里，cross_val_score 将使用非随机化的 CV 拆分器（这是默认设置），因此两个估计器将在相同的拆分上进行评估。本节与拆分中的变异性无关。此外，无论我们是向 make_classification 传递整数还是实例，对于我们的说明目的都不相关：重要的是我们传递给 RandomForestClassifier 估计器的内容。

11.3.2.2. CV 拆分器#

当传递 RandomState 实例时，每次调用 split 时，CV 拆分器都会产生不同的拆分。在比较不同的估计器时，这可能导致高估估计器之间性能差异的方差

>>> from sklearn.naive_bayes import GaussianNB
>>> from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
>>> from sklearn.datasets import make_classification
>>> from sklearn.model_selection import KFold
>>> from sklearn.model_selection import cross_val_score
>>> import numpy as np

>>> rng = np.random.RandomState(0)
>>> X, y = make_classification(random_state=rng)
>>> cv = KFold(shuffle=True, random_state=rng)
>>> lda = LinearDiscriminantAnalysis()
>>> nb = GaussianNB()

>>> for est in (lda, nb):
...     print(cross_val_score(est, X, y, cv=cv))
[0.8  0.75 0.75 0.7  0.85]
[0.85 0.95 0.95 0.85 0.95]

直接比较 LinearDiscriminantAnalysis 估计器与 GaussianNB 估计器**在每个折叠上**的性能是错误的：**评估估计器的拆分是不同的**。确实，cross_val_score 将内部在相同的 KFold 实例上调用 cv.split，但拆分每次都会不同。对于任何通过交叉验证执行模型选择的工具（例如 GridSearchCV 和 RandomizedSearchCV）也是如此：跨对 search.fit 的不同调用，分数在折叠之间不可比较，因为 cv.split 将被多次调用。然而，在对 search.fit 的单次调用中，折叠之间的比较是可能的，因为搜索估计器只调用 cv.split 一次。

为了在所有场景中获得可比较的折叠结果，应该向 CV 拆分器传递一个整数：cv = KFold(shuffle=True, random_state=0)。

注意

虽然不建议使用 RandomState 实例进行折叠比较，但只要使用足够的折叠和数据，可以期望平均分数允许得出结论，判断哪个估计器更好。

注意

在这个示例中，重要的是传递给 KFold 的内容。无论我们是向 make_classification 传递 RandomState 实例还是整数，对于我们的说明目的都不相关。此外，LinearDiscriminantAnalysis 和 GaussianNB 都不是随机估计器。

11.3.3. 一般建议#

11.3.3.1. 在多次执行中获得可重现的结果#

为了在多次*程序执行*中获得可重现（即恒定）的结果，我们需要删除所有使用默认值 random_state=None 的情况。推荐的方法是在程序顶部声明一个 rng 变量，并将其传递给接受 random_state 参数的任何对象

>>> from sklearn.ensemble import RandomForestClassifier
>>> from sklearn.datasets import make_classification
>>> from sklearn.model_selection import train_test_split
>>> import numpy as np

>>> rng = np.random.RandomState(0)
>>> X, y = make_classification(random_state=rng)
>>> rf = RandomForestClassifier(random_state=rng)
>>> X_train, X_test, y_train, y_test = train_test_split(X, y,
...                                                     random_state=rng)
>>> rf.fit(X_train, y_train).score(X_test, y_test)
0.84

我们现在保证此脚本的结果始终为 0.84，无论我们运行多少次。将全局 rng 变量更改为不同的值应该会影响结果，这是预期的。

也可以将 rng 变量声明为整数。然而，这可能导致交叉验证结果的鲁棒性降低，正如我们将在下一节中看到的那样。

注意

我们不建议通过调用 np.random.seed(0) 来设置全局 numpy 种子。有关讨论，请参阅此处。

11.3.3.2. 交叉验证结果的鲁棒性#

当我们通过交叉验证评估随机估计器性能时，我们希望确保估计器能够对新数据产生准确的预测，但我们也希望确保估计器对其随机初始化具有鲁棒性。例如，我们希望 SGDClassifier 的随机权重初始化在所有折叠中始终良好：否则，当我们训练该估计器在新数据上时，我们可能会运气不好，随机初始化可能导致性能不佳。同样，我们希望随机森林对其每棵树将使用的随机选择特征集具有鲁棒性。

出于这些原因，最好通过让估计器在每个折叠上使用不同的 RNG 来评估交叉验证性能。这可以通过向估计器初始化传递 RandomState 实例（或 None）来完成。

当我们传递一个整数时，估计器将在每个折叠上使用相同的 RNG：如果估计器表现良好（或不好），如 CV 所评估的，那可能只是因为我们对该特定种子很幸运（或不幸）。传递实例会导致更稳健的 CV 结果，并使各种算法之间的比较更公平。它还有助于限制将估计器的 RNG 视为可以调整的超参数的诱惑。

无论我们是向 CV 拆分器传递 RandomState 实例还是整数，只要只调用一次 split，对鲁棒性就没有影响。当多次调用 split 时，折叠之间的比较就不可能了。因此，向 CV 拆分器传递整数通常更安全，并涵盖大多数用例。