Scikit-learn: как получить истинно положительный, истинно отрицательный, ложноположительный и ложноотрицательный
Я новичок в машинном обучении и в научении.
Моя проблема:
(Пожалуйста, исправьте любой тип неправильного представления)
У меня есть набор данных, который является большим JSON, я извлекаю его и храню в trainList переменная.
Я предварительно обработал его, чтобы иметь возможность работать с ним.
Как только я это сделаю, я начну классификацию:
- Я использую метод перекрестной проверки kfold для получения средней точности и тренирую классификатор.
- Я делаю прогнозы и получаю матрицу точности и путаницы в этом сгибе.
- После этого я хотел бы получить значения True Positive(TP), True Negative(TN), False Positive(FP) и False Negative(FN). Я бы использовал эти параметры для получения чувствительности и специфичности, а также их и общее количество TP для HTML, чтобы показать диаграмму с TP каждого ярлыка.
Код:
Переменные у меня на данный момент:
trainList #It is a list with all the data of my dataset in JSON form
labelList #It is a list with all the labels of my data
Большая часть метода:
#I transform the data from JSON form to a numerical one
X=vec.fit_transform(trainList)
#I scale the matrix (don't know why but without it, it makes an error)
X=preprocessing.scale(X.toarray())
#I generate a KFold in order to make cross validation
kf = KFold(len(X), n_folds=10, indices=True, shuffle=True, random_state=1)
#I start the cross validation
for train_indices, test_indices in kf:
X_train=[X[ii] for ii in train_indices]
X_test=[X[ii] for ii in test_indices]
y_train=[listaLabels[ii] for ii in train_indices]
y_test=[listaLabels[ii] for ii in test_indices]
#I train the classifier
trained=qda.fit(X_train,y_train)
#I make the predictions
predicted=qda.predict(X_test)
#I obtain the accuracy of this fold
ac=accuracy_score(predicted,y_test)
#I obtain the confusion matrix
cm=confusion_matrix(y_test, predicted)
#I should calculate the TP,TN, FP and FN
#I don't know how to continue
20 ответов
Если у вас есть два списка, которые имеют прогнозные и фактические значения; как вы это делаете, вы можете передать их функции, которая будет вычислять TP, FP, TN, FN примерно так:
def perf_measure(y_actual, y_hat):
TP = 0
FP = 0
TN = 0
FN = 0
for i in range(len(y_hat)):
if y_actual[i]==y_hat[i]==1:
TP += 1
if y_hat[i]==1 and y_actual[i]!=y_hat[i]:
FP += 1
if y_actual[i]==y_hat[i]==0:
TN += 1
if y_hat[i]==0 and y_actual[i]!=y_hat[i]:
FN += 1
return(TP, FP, TN, FN)
Отсюда я думаю, что вы сможете рассчитать процентные ставки для вас, а также другие показатели эффективности, такие как специфичность и чувствительность.
В случае мультикласса все, что вам нужно, можно найти из матрицы путаницы. Например, если ваша матрица путаницы выглядит так:
Тогда то, что вы ищете, для каждого класса, может быть найдено так:
Используя pandas/numpy, вы можете сделать это для всех классов одновременно, вот так:
FP = confusion_matrix.sum(axis=0) - np.diag(confusion_matrix)
FN = confusion_matrix.sum(axis=1) - np.diag(confusion_matrix)
TP = np.diag(confusion_matrix)
TN = confusion_matrix.values.sum() - (FP + FN + TP)
# Sensitivity, hit rate, recall, or true positive rate
TPR = TP/(TP+FN)
# Specificity or true negative rate
TNR = TN/(TN+FP)
# Precision or positive predictive value
PPV = TP/(TP+FP)
# Negative predictive value
NPV = TN/(TN+FN)
# Fall out or false positive rate
FPR = FP/(FP+TN)
# False negative rate
FNR = FN/(TP+FN)
# False discovery rate
FDR = FP/(TP+FP)
# Overall accuracy
ACC = (TP+TN)/(TP+FP+FN+TN)
Согласно научной документации,
http://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html
По определению запутанная матрица C такова, что C[i, j] равно числу наблюдений, о которых известно, что они находятся в группе i, но которые, согласно прогнозам, находятся в группе j.
Таким образом, в бинарной классификации число истинных негативов равно C[0,0], ложных негативов - C[1,0], истинных позитивов - C[1,1], а ложных срабатываний - C[0,1].
CM = confusion_matrix(y_true, y_pred)
TN = CM[0][0]
FN = CM[1][0]
TP = CM[1][1]
FP = CM[0][1]
Единственный вкладыш, который извлекает истинные позитивы и т. Д. Из матрицы путаницы, - это разболтать ее:
from sklearn.metrics import confusion_matrix
y_true = [1, 1, 0, 0]
y_pred = [1, 0, 1, 0]
tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
print(tn, fp, fn, tp) # 1 1 1 1
Вы можете получить все параметры из матрицы путаницы. Структура матрицы смешения (которая является матрицей 2X2) выглядит следующим образом
TP|FP
FN|TN
Так
TP = cm[0][0]
FP = cm[0][1]
FN = cm[1][0]
TN = cm[1][1]
Более подробная информация на https://en.wikipedia.org/wiki/Confusion_matrix
На всякий случай кто-то ищет то же самое в MULTI-CLASS Example
def perf_measure(y_actual, y_pred):
class_id = set(y_actual).union(set(y_pred))
TP = []
FP = []
TN = []
FN = []
for index ,_id in enumerate(class_id):
TP.append(0)
FP.append(0)
TN.append(0)
FN.append(0)
for i in range(len(y_pred)):
if y_actual[i] == y_pred[i] == _id:
TP[index] += 1
if y_pred[i] == _id and y_actual[i] != y_pred[i]:
FP[index] += 1
if y_actual[i] == y_pred[i] != _id:
TN[index] += 1
if y_pred[i] != _id and y_actual[i] != y_pred[i]:
FN[index] += 1
return class_id,TP, FP, TN, FN
В библиотеке метрик scikit-learn есть метод confusion_matrix, который дает желаемый результат.
Вы можете использовать любой классификатор, который вы хотите. Здесь я использовал KNeighbors в качестве примера.
from sklearn import metrics, neighbors
clf = neighbors.KNeighborsClassifier()
X_test = ...
y_test = ...
expected = y_test
predicted = clf.predict(X_test)
conf_matrix = metrics.confusion_matrix(expected, predicted)
>>> print conf_matrix
>>> [[1403 87]
[ 56 3159]]
Документы: http://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html
это отлично работает
Источник - https://scikit-learn.org/stable/modules/generated/sklearn.metrics.confusion_matrix.html
tn, fp, fn, tp = confusion_matrix(y_test, predicted).ravel()
Я написал версию, которая работает, используя только NumPy. Я надеюсь, что это поможет вам.
import numpy as np
def perf_metrics_2X2(yobs, yhat):
"""
Returns the specificity, sensitivity, positive predictive value, and
negative predictive value
of a 2X2 table.
where:
0 = negative case
1 = positive case
Parameters
----------
yobs : array of positive and negative ``observed`` cases
yhat : array of positive and negative ``predicted`` cases
Returns
-------
sensitivity = TP / (TP+FN)
specificity = TN / (TN+FP)
pos_pred_val = TP/ (TP+FP)
neg_pred_val = TN/ (TN+FN)
Author: Julio Cardenas-Rodriguez
"""
TP = np.sum( yobs[yobs==1] == yhat[yobs==1] )
TN = np.sum( yobs[yobs==0] == yhat[yobs==0] )
FP = np.sum( yobs[yobs==1] == yhat[yobs==0] )
FN = np.sum( yobs[yobs==0] == yhat[yobs==1] )
sensitivity = TP / (TP+FN)
specificity = TN / (TN+FP)
pos_pred_val = TP/ (TP+FP)
neg_pred_val = TN/ (TN+FN)
return sensitivity, specificity, pos_pred_val, neg_pred_val
В scikit версии 0.22 это можно сделать так
from sklearn.metrics import multilabel_confusion_matrix
y_true = ["cat", "ant", "cat", "cat", "ant", "bird"]
y_pred = ["ant", "ant", "cat", "cat", "ant", "cat"]
mcm = multilabel_confusion_matrix(y_true, y_pred,labels=["ant", "bird", "cat"])
tn = mcm[:, 0, 0]
tp = mcm[:, 1, 1]
fn = mcm[:, 1, 0]
fp = mcm[:, 0, 1]
Ты можешь попробовать sklearn.metrics.classification_report как показано ниже:
import sklearn
y_true = [1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0]
y_pred = [1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0]
print sklearn.metrics.classification_report(y_true, y_pred)
выход:
precision recall f1-score support
0 0.80 0.57 0.67 7
1 0.50 0.75 0.60 4
avg / total 0.69 0.64 0.64 11
Если в вашем классификаторе более одного класса, вы можете использовать pandas-ml в этой части. Матрица путаницы панд-мл дает более подробную информацию. Проверь это
Хотя это не относится к scikit-learn, вы также можете сделать следующее:
tp = sum(y_test & pred)
fp = sum(1-y_test & pred )
tn = sum(1-y_test & 1-pred)
fn = sum(y_test & 1-pred)
def getTPFPTNFN(y_true, y_pred):
TP, FP, TN, FN = 0, 0, 0, 0
for s_true, s_pred in zip (y_true, y_pred):
if s_true == 1:
if s_pred == 1:
TP += 1
else:
FN += 1
else:
if s_pred == 0:
TN += 1
else:
FP += 1
return TP, FP, TN, FN
Я думаю, что оба ответа не совсем верны. Например, предположим, что у нас есть следующие массивы;
y_actual = [1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0]
y_predic = [1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0]
Если мы вычисляем значения FP, FN, TP и TN вручную, они должны выглядеть следующим образом:
FP: 3 FN: 1 TP: 3 TN: 4
Однако, если мы используем первый ответ, результаты выдаются следующим образом:
FP: 1 FN: 3 TP: 3 TN: 4
Они не верны, потому что в первом ответе False Positive должен быть там, где фактическое значение равно 0, но прогнозируемое значение равно 1, а не наоборот. То же самое относится и к ложному отрицанию.
И, если мы используем второй ответ, результаты вычисляются следующим образом:
FP: 3 FN: 1 TP: 4 TN: 3
Истинно положительные и истинно отрицательные числа не верны, они должны быть противоположными.
Я прав с моими вычислениями? Пожалуйста, дайте мне знать, если я что-то упустил.
#False positive cases
train = pd.merge(X_train, y_train,left_index=True, right_index=True)
y_train_pred = pd.DataFrame(y_train_pred)
y_train_pred.rename(columns={0 :'Predicted'}, inplace=True )
train = train.reset_index(drop=True).merge(y_train_pred.reset_index(drop=True),
left_index=True,right_index=True)
train['FP'] = np.where((train['Banknote']=="Forged") & (train['Predicted']=="Genuine"),1,0)
train[train.FP != 0]
Ни один из приведенных до сих пор ответов не работал для меня, поскольку иногда у меня возникала матрица путаницы только с одной записью. Следующий код может решить эту проблему:
from sklearn.metrics import confusion_matrix
CM = confusion_matrix(y, y_hat)
try:
TN = CM[0][0]
except IndexError:
TN = 0
try:
FN = CM[1][0]
except IndexError:
FN = 0
try:
TP = CM[1][1]
except IndexError:
TP = 0
try:
FP = CM[0][1]
except IndexError:
FP = 0
Обратите внимание, что «y» - это истина, а «y_hat» - это предсказание.
#FalseNegatives
test = pd.merge(Variables_test, Banknote_test,left_index=True, right_index=True)
Banknote_test_pred = pd.DataFrame(banknote_test_pred)
Banknote_test_pred.rename(columns={0 :'Predicted'}, inplace=True )
test = test.reset_index(drop=True).merge(Banknote_test_pred.reset_index(drop=True), left_index=True, right_index=True)
test['FN'] = np.where((test['Banknote']=="Genuine") & (test['Predicted']=="Forged"),1,0)
test[test.FN != 0]
Вот исправление в глючном коде invoketheshell (который в настоящее время отображается как принятый ответ):
def performance_measure(y_actual, y_hat):
TP = 0
FP = 0
TN = 0
FN = 0
for i in range(len(y_hat)):
if y_actual[i] == y_hat[i]==1:
TP += 1
if y_hat[i] == 1 and y_actual[i] == 0:
FP += 1
if y_hat[i] == y_actual[i] == 0:
TN +=1
if y_hat[i] == 0 and y_actual[i] == 1:
FN +=1
return(TP, FP, TN, FN)
Я попробовал некоторые ответы и обнаружил, что они не работают.
Это работает для меня:
from sklearn.metrics import classification_report
print(classification_report(y_test, predicted))