scikit-learn cross_val_predict 准确度分数是如何计算的？

Question

cross_val_predict（参见doc，v0.18）是否使用k-fold 方法（如下面的代码所示）计算每个折叠的准确度并最终取平均值？

cv = KFold(len(labels), n_folds=20)
clf = SVC()
ypred = cross_val_predict(clf, td, labels, cv=cv)
accuracy = accuracy_score(labels, ypred)
print accuracy

Answer 1

不，它没有！

根据cross validation doc 页面，cross_val_predict 不返回任何分数，而只返回基于此处描述的某种策略的标签：

函数 cross_val_predict 有一个类似的接口 cross_val_score, 但返回，对于输入中的每个元素， 该元素在测试中获得的预测 设置。只有交叉验证策略将所有元素分配给 测试集只能使用一次（否则会引发异常）。

因此通过调用accuracy_score(labels, ypred)您只是在计算通过上述特定策略预测的标签与真实标签相比的准确度得分。这再次在同一文档页面中指定：

然后可以使用这些预测来评估分类器：

predicted = cross_val_predict(clf, iris.data, iris.target, cv=10) 
metrics.accuracy_score(iris.target, predicted)

请注意，此计算的结果可能略有不同 从使用 cross_val_score 获得的那些元素被分组 以不同的方式。

如果您需要不同折叠的准确度分数，您应该尝试：

>>> scores = cross_val_score(clf, X, y, cv=cv)
>>> scores                                              
array([ 0.96...,  1.  ...,  0.96...,  0.96...,  1.        ])

然后对于所有折叠的平均准确度，使用scores.mean()：

>>> print("Accuracy: %0.2f (+/- %0.2f)" % (scores.mean(), scores.std() * 2))
Accuracy: 0.98 (+/- 0.03)

---

如何计算每一折的Cohen kappa系数和混淆矩阵？

为了计算 Cohen Kappa coefficient 和混淆矩阵，我假设您的意思是真实标签和每个折叠的预测标签之间的 kappa 系数和混淆矩阵：

from sklearn.model_selection import KFold
from sklearn.svm.classes import SVC
from sklearn.metrics.classification import cohen_kappa_score
from sklearn.metrics import confusion_matrix

cv = KFold(len(labels), n_folds=20)
clf = SVC()
for train_index, test_index in cv.split(X):
    clf.fit(X[train_index], labels[train_index])
    ypred = clf.predict(X[test_index])
    kappa_score = cohen_kappa_score(labels[test_index], ypred)
    confusion_matrix = confusion_matrix(labels[test_index], ypred)

---

cross_val_predict 返回什么？

它使用 KFold 将数据拆分为 k 部分，然后进行 i=1..k 迭代：

• 将i'th部分作为测试数据，其他部分作为训练数据
• 用训练数据训练模型（除i'th之外的所有部分）
• 然后通过使用这个经过训练的模型，预测i'th 部分的标签（测试数据）

在每次迭代中，预测i'th 部分数据的标签。最后 cross_val_predict 合并所有部分预测的标签，并作为最终结果返回。

这段代码一步一步地展示了这个过程：

X = np.array([[0], [1], [2], [3], [4], [5]])
labels = np.array(['a', 'a', 'a', 'b', 'b', 'b'])

cv = KFold(len(labels), n_folds=3)
clf = SVC()
ypred_all = np.chararray((labels.shape))
i = 1
for train_index, test_index in cv.split(X):
    print("iteration", i, ":")
    print("train indices:", train_index)
    print("train data:", X[train_index])
    print("test indices:", test_index)
    print("test data:", X[test_index])
    clf.fit(X[train_index], labels[train_index])
    ypred = clf.predict(X[test_index])
    print("predicted labels for data of indices", test_index, "are:", ypred)
    ypred_all[test_index] = ypred
    print("merged predicted labels:", ypred_all)
    i = i+1
    print("=====================================")
y_cross_val_predict = cross_val_predict(clf, X, labels, cv=cv)
print("predicted labels by cross_val_predict:", y_cross_val_predict)

结果是：

iteration 1 :
train indices: [2 3 4 5]
train data: [[2] [3] [4] [5]]
test indices: [0 1]
test data: [[0] [1]]
predicted labels for data of indices [0 1] are: ['b' 'b']
merged predicted labels: ['b' 'b' '' '' '' '']
=====================================
iteration 2 :
train indices: [0 1 4 5]
train data: [[0] [1] [4] [5]]
test indices: [2 3]
test data: [[2] [3]]
predicted labels for data of indices [2 3] are: ['a' 'b']
merged predicted labels: ['b' 'b' 'a' 'b' '' '']
=====================================
iteration 3 :
train indices: [0 1 2 3]
train data: [[0] [1] [2] [3]]
test indices: [4 5]
test data: [[4] [5]]
predicted labels for data of indices [4 5] are: ['a' 'a']
merged predicted labels: ['b' 'b' 'a' 'b' 'a' 'a']
=====================================
predicted labels by cross_val_predict: ['b' 'b' 'a' 'b' 'a' 'a']

Answer 2

正如文档sklearn.model_selection.cross_val_predict 中所写：

将这些预测传递给评估是不合适的 公制。采用 cross_validate 测量泛化误差。

Answer 3

我想在之前的开发人员贡献的内容之上添加一个快速简单的答案选项。

如果您对 F1 进行微观平均，您基本上会获得准确率。例如，这将是：

from sklearn.model_selection import cross_val_score, cross_val_predict
from sklearn.metrics import precision_recall_fscore_support as score    

y_pred = cross_val_predict(lm,df,y,cv=5)
precision, recall, fscore, support = score(y, y_pred, average='micro') 
print(fscore)

这在数学上是有效的，因为微平均值为您提供了混淆矩阵的加权平均值。

祝你好运。

Answer 4

从github 上的cross_val_predict 代码可以看出，该函数计算每个折叠的预测并将它们连接起来。预测是基于从其他折叠中学习的模型进行的。

这是您的代码和代码中提供的示例的组合

from sklearn import datasets, linear_model
from sklearn.model_selection import cross_val_predict, KFold
from sklearn.metrics import accuracy_score

diabetes = datasets.load_diabetes()
X = diabetes.data[:400]
y = diabetes.target[:400]
cv = KFold(n_splits=20)
lasso = linear_model.Lasso()
y_pred = cross_val_predict(lasso, X, y, cv=cv)
accuracy = accuracy_score(y_pred.astype(int), y.astype(int))

print(accuracy)
# >>> 0.0075

最后，回答你的问题：“不，准确率不是每次折叠的平均值”