Как рассчитывается оценка scikit-learn cross_val_predict?

Ответ 1

Нет!

Согласно странице документа перекрестной проверки, 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 coefficient матрицы и матрицы путаницы я предположил, что вы имеете в виду коэффициент Каппа и матрицу путаницы между истинными метками и метками, предсказанными в каждом случае

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']

Ответ 2

Как вы можете видеть из кода cross_val_predict на github, функция вычисляет для каждого сгиба прогнозы и объединяет их. Прогнозы сделаны на основе модели, изученной из других сгибов.

Вот комбинация вашего кода и пример, приведенный в коде

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

Наконец, чтобы ответить на ваш вопрос: "Нет, точность не усредняется для каждого раза"

Ответ 3

Как написано в документации sklearn.model_selection.cross_val_predict:

Нецелесообразно передавать эти прогнозы в метрику оценки. Используйте cross_validate для измерения ошибки обобщения.

Ответ 4

Я хотел бы добавить опцию для быстрого и простого ответа, помимо того, что делали предыдущие разработчики.

Если вы возьмете микро-среднее значение 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)

Это работает математически, поскольку микро-среднее дает средневзвешенное значение матрицы путаницы.

Удачи.