Python 没有数据洗牌的分类器堆栈的交叉验证返回垃圾

作为后续行动， 我试图交叉验证一堆模型

手册 首先，我手动执行所有步骤，以确保一切按预期进行：

from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.naive_bayes import GaussianNB
from sklearn.metrics import roc_auc_score

X, y = make_classification(n_samples=10000, n_features=40,
                           n_clusters_per_class=10,
                           n_informative=25,
                           random_state=12, shuffle=False)

logit = LogisticRegression(solver="saga",random_state=12).fit(X,y)
logit_yhat = logit.predict_proba(X)[:,1]
print("logit",roc_auc_score(y, logit_yhat))
randf = RandomForestClassifier(n_estimators=10,max_depth=5,min_samples_split=10, random_state=12).fit(X,y)
randf_yhat = randf.predict_proba(X)[:,1]
print("randf",roc_auc_score(y, randf_yhat))
gaunb = GaussianNB().fit(X,y)
gaunb_yhat = gaunb.predict_proba(X)[:,1]
print("gaunb",roc_auc_score(y, gaunb_yhat))
gbcdt = GradientBoostingClassifier(random_state=12).fit(X,y)
gbcdt_yhat = gbcdt.predict_proba(X)[:,1]
print("gbcdt",roc_auc_score(y, gbcdt_yhat))

scores = np.transpose(np.array((logit_yhat, randf_yhat, gaunb_yhat, gbcdt_yhat)))
aggregator = LogisticRegression(solver="saga",random_state=12).fit(scores, y)
aggregator_yhat = aggregator.predict_proba(scores)[:,1]
print("aggregator",aggregator.coef_,roc_auc_score(y, aggregator_yhat))

这张照片是：

logit 0.6913163859713081
randf 0.7871255096874669
gaunb 0.7032834038916749
gbcdt 0.8527915275109933
aggregator [[-3.95961856  5.70858186 -2.45036885 13.3983472 ]] 0.8799606190093959

pipe [[-3.95961856  5.70858186 -2.45036885 13.3983472 ]] 0.8799606190093959

到目前为止还不错

使用管道 现在，我创建一个管道并检查它是否执行相同的操作：

from sklearn.base import BaseEstimator, TransformerMixin, clone
class PredictProbaTransformer(BaseEstimator, TransformerMixin):
    def __init__(self, clf):
        self.clf = clf

    def transform(self, X):
        "Return predict_proba(X)."
        print("transform")
        return self.clf.predict_proba(X)[:,[1]]

    def fit_transform(self, X, y=None, **fit_params):
        print("fit_transform")
        return self.clf.fit(X, y, **fit_params).predict_proba(X)[:,[1]]

from sklearn.pipeline import Pipeline, FeatureUnion
pipe = Pipeline([("stack",FeatureUnion([
    ("logit",PredictProbaTransformer(clone(logit))),
    ("randf",PredictProbaTransformer(clone(randf))),
    ("gaunb",PredictProbaTransformer(clone(gaunb))),
    ("gbcdt",PredictProbaTransformer(clone(gbcdt))),
])), ("aggregator",LogisticRegression(solver="saga",random_state=12))]).fit(X,y)
pipe_yhat = pipe.predict_proba(X)[:,1]
print("pipe",pipe.named_steps["aggregator"].coef_,roc_auc_score(y, pipe_yhat))

这张照片是：

logit 0.6913163859713081
randf 0.7871255096874669
gaunb 0.7032834038916749
gbcdt 0.8527915275109933
aggregator [[-3.95961856  5.70858186 -2.45036885 13.3983472 ]] 0.8799606190093959

pipe [[-3.95961856  5.70858186 -2.45036885 13.3983472 ]] 0.8799606190093959

与“手册”部分中的

聚合器

行相同-很好

交叉验证 当我试图交叉验证

管道时，我得到了一些奇怪的结果：

from sklearn.model_selection import cross_validate
pipe_scores = pd.DataFrame(cross_validate(
    pipe, X=X, y=y, return_train_score=True, cv=10, scoring="roc_auc"))

打印10次（因为
cv=10
）这12行：

fit_transform --- 4 times
transform     --- 8 times

因为它为每个训练阶段调用
fit_transform
4次（针对
stack
中的4个分类器），然后为测试数据中的相同4个分类器调用
transform
4次，然后对训练数据再调用4次（即使它在训练阶段已经这样做了）

最重要的：
pipe\u分数。descripe（）
是

        fit_time  score_time  test_score  train_score
count  10.000000   10.000000   10.000000    10.000000
mean    3.329516    0.006074    0.482034     0.895046
std     0.068609    0.000594    0.081499     0.006657
min     3.212703    0.005362    0.299673     0.886333
25%     3.276795    0.005602    0.451310     0.891166
50%     3.350762    0.006122    0.504630     0.892991
75%     3.370433    0.006331    0.519399     0.898570
max     3.425937    0.007302    0.586310     0.906820

奇怪的是，所有的
train\u分数都超过了我在考试中得到的88%
手动运行

然而，为什么
测试分数看起来是完全随机的
（平均值和中值约为50%，对应于“抛硬币”分类器）

避免这种奇怪现象的解决方法是通过


将
shuffle=True
（而不是
False
）传递给
或传递（而不是
10
）到

那么分数是多少

        fit_time  score_time  test_score  train_score
count  10.000000   10.000000   10.000000    10.000000
mean    3.400829    0.005355    0.774932     0.887762
std     0.125579    0.000444    0.011324     0.003578
min     3.211147    0.004896    0.763047     0.883219
25%     3.333121    0.005074    0.767166     0.884810
50%     3.376660    0.005153    0.772864     0.886907
75%     3.484209    0.005516    0.781219     0.890338
max     3.602676    0.006194    0.799907     0.893941

PS.
shuffle
in同时影响列和行，而in只影响行，不影响列。
只有行洗牌很重要：如果我按

X = X[:, np.random.permutation(X.shape[1])]

之后，我得到了相同和不明显的不同，并且返回随机
测试分数
至于为什么所有
训练分数
都高于88%，这是因为交叉验证时，你训练的训练数据为0.9。因此，您的模型可以（过度）更适合此数据。至于为什么在不洗牌的情况下，
test\u分数
会这么小，我认为这是因为在不洗牌的情况下交叉验证时，并非所有（10个）聚类都出现在训练数据集中（占所有数据的0.9），因为在数据集中，它们也没有洗牌。
至于为什么它会打印变换
8次，请参阅。对于测试分数，在上述所有示例中（无交叉验证），您是在相同的数据上进行培训和评分（
X
，
y
）。交叉验证中，列车和试验数据不同。尝试使用不同的列车测试数据作为上限代码。也许可以试着调整超链接-params@VivekKumar：谢谢你的链接。当我手动调用
KFold
时，我得到了相同的结果，我认为你对
test\u score
s的解释站不住脚（但我可能误解了你）。我不确定
“当我手动调用KFold时，我得到了相同的结果”
。你在测试褶皱上也得到同样的结果（大约88%）吗？你能显示那个代码吗？@VivekKumar:是的，
测试
和
训练
的结果相同，来自
训练索引，skf中的测试索引。分割（X，y）：…
和
交叉验证
训练分数
听起来似乎合理，
测试分数
没有那么多-它们是完全随机的。洗牌是如何对行为产生如此巨大的影响的？！这是因为
shuffle
与shuffling功能相关，而不是
make_classification
中的样本。这就是为什么它会产生如此巨大的影响。诸如
RandomForestClassifier
和
GradientBoostingClassifier
之类的模型对功能顺序非常敏感。抱歉，修复了答案
GradientBoostingClassifier
实际上尝试选择尽可能最好的分割，因此不取决于它们的顺序。事实上，减少每个类的
n个簇数
并增加
cv
会得到合理的
测试分数
。谢谢