Метрики оценки контролируемого обучения

В реальном машинном обучении мы столкнемся с множеством различных метрик оценки, иногда нам нужно создать свои собственные метрики оценки, основанные на проблеме, но в этой записной книжке мы увидим некоторые из наиболее часто используемых метрик оценки.

В классификации чаще всего используются следующие показатели:

• Точность
• Точность
• Отзывать
• F1-счет
• Площадь под кривой или (площадь под кривой ROC(рабочая характеристика приемника)) AUC
• Потеря журнала

Вышеупомянутые показатели также могут применяться для многоклассовой классификации. мы увидим реализацию этих показателей на бинарном и мультиклассовом уровнях в этой записной книжке.

Прежде чем читать эту статью, пожалуйста, обратитесь к записной книжке kaggle ниже, чтобы вы могли запустить код и отредактировать его в соответствии с вашим предположением.

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

Построение модели

Загрузка набора данных о раке молочной железы из sklearn

# the data is in the type of dict in this cell will check the key 
# and value assoicated with it

for key in dataset.keys():
    print(key)
##### output #######
data
target
frame
target_names
DESCR
feature_names
filename
print("Total no of features: ",len(dataset['feature_names']) ,'\n\n')

for index, feature in enumerate(dataset['feature_names'], start=1):
    print(index, feature)
Total no of features:  30 


1 mean radius
2 mean texture
3 mean perimeter
4 mean area
5 mean smoothness
6 mean compactness
7 mean concavity
8 mean concave points
9 mean symmetry
10 mean fractal dimension
11 radius error
12 texture error
13 perimeter error
14 area error
15 smoothness error
16 compactness error
17 concavity error
18 concave points error
19 symmetry error
20 fractal dimension error
21 worst radius
22 worst texture
23 worst perimeter
24 worst area
25 worst smoothness
26 worst compactness
27 worst concavity
28 worst concave points
29 worst symmetry
30 worst fractal dimension
# Loading the dataset in pandas dataframe for analysis the dataset

data = pd.DataFrame(dataset['data'],  columns= dataset['feature_names'])
data['target'] = pd.Series(dataset.target)

# to check the shape of the entire dataset

data.shape
(569, 31)
# Check if dataset is blanced or not that is to check if both the class label are partially equal or not 

data.target.value_counts().sort_values().plot(kind = 'bar')
print(data.target.value_counts())
1    357
0    212
Name: target, dtype: int64

Наблюдения. Из приведенного выше анализа мы можем сделать вывод, что это проблема бинарной классификации и наличие 30 признаков, все из которых имеют тип с плавающей запятой, и у нас есть всего 569 экземпляров без нулевых значений. на основе 30 значений, которые нам нужно классифицировать, есть ли у человека рак молочной железы или нет

X = data.drop(['target'],axis=1)

y = data[['target']]

X.shape, y.shape
### output #########
((569, 30), (569, 1))

X = data.drop(['target'],axis=1)

y = data[['target']]

X.shape, y.shape
#### output ######3333
((569, 30), (569, 1))
# spliting the data into train and test 
from sklearn.model_selection import train_test_split

x_train, x_test, y_train,  y_test = train_test_split(X,y, test_size=0.33, random_state=42)
x_train.shape, x_test.shape
((381, 30), (188, 30))
# Training the model

from sklearn.neighbors import KNeighborsClassifier

model = KNeighborsClassifier(n_neighbors=3)
model.fit(x_train,y_train.values.ravel())  # .values will give the values in an array. (shape: (n,1) and .ravel will convert that array shape to (n, )

y_pred = model.predict(x_test)
(y_pred)
array([0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1,
       0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1,
       1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1,
       0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0,
       1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1,
       0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0,
       0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1,
       1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1,
       0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1])
y_test = (y_test.values.ravel())

Теперь у нас есть y_test и y_predicted, поэтому здесь мы узнаем, какие метрики следует использовать на основе данных и цели. Начнем с простых показателей точности.

Точность:

Точность — это простая и очень простая метрика, которая обычно используется в машинном обучении. Он определяет, насколько точна наша модель.

Например, если у нас есть 100 общих тестовых точек из этих 50 точек как положительных и 50 как отрицательных, наша модель классифицирует 90 точек данных (Xq или экземпляры) как положительные, тогда точность нашей модели составляет 90%. если только 73 точки являются правильными точками, то это 73% точности.

Его также можно определить как количество правильно классифицированных баллов по отношению к общему количеству баллов.

Точность = количество правильно классифицированных баллов / общее количество. очков

Пользовательская функция точности

custom_accuracy = accuracy(y_test,y_pred)
print(accuracy(y_test,y_pred))
0.9414893617021277
from sklearn.metrics import accuracy_score

print(accuracy_score(y_test, y_pred))
sklearn_accuracy = accuracy_score(y_test, y_pred)
0.9414893617021277
# Check both custom and sklean accuracy is same or not
custom_accuracy == sklearn_accuracy # True means we have not made any mistakes in the implementation.
True

Примечание: мы не можем использовать точность в качестве метрики, когда у нас есть данные о дисбалансе (распределение с асимметрией метки).

Как упоминалось выше, если мы используем точность в качестве метрики для данных о дисбалансе, предположим, что у нас есть 90 положительных точек, а 10 отрицательных точек поддерживают нашу модель, выдающую положительные результаты для любого запроса (Xq) или точки экземпляра как положительные, это очень глупая модель, что каждый ее ввод просто верните их как положительные, тогда мы также получим точность 90, поскольку она будет предсказывать все точки как положительные. поэтому нам нужно улучшить показатели.

Точность:

Прежде чем узнать о точности, нам нужно понять несколько терминов:

• Истинно положительный (TP): в данном случае, если наша модель предсказывает положительное значение и фактическое значение также положительное, то оно считается истинно положительным.
• Истинно отрицательное значение (TN). Если для данного экземпляра наша модель предсказывает отрицательное значение, а фактическое значение также отрицательное, то оно считается истинно отрицательным.

Вкратце: если ваша модель правильно предсказывает положительный класс, то это действительно положительный результат, а если ваша модель правильно предсказывает отрицательный класс как отрицательный, то это истинно отрицательный результат

• Ложное срабатывание (FP). Если для данного экземпляра наша модель предсказывает положительное значение, а фактическое значение отрицательное, то это считается ложноположительным.
• Flase-отрицательный (FN): для данного экземпляра, если наша модель предсказывает отрицательное значение, а фактическое значение положительное, то это ложноотрицательное значение.

Вкратце: если ваша модель неправильно предсказывает положительный класс, это ложноположительный результат, если ваша модель неправильно предсказывает отрицательный класс, то это ложноотрицательный результат.

Давайте реализуем все вышеперечисленные четыре термина:

Примечание. Если вы хотите описать точность, используя приведенные выше термины, мы можем записать ее как показатель точности = (TP+TN)/(TP+TN+FP+FN).

Давайте реализуем точную оценку, используя TP, TN, FP и FN.

Мы можем быстро проверить правильность этой функции, сравнив ее с точностью нашей ранее реализованной и scikit-learn версии.

# custom accuracy,    verion 2 accuracy using tf/tn/fp/fn,  sklean accuracy
accuracy(y_test, y_pred), accuracy_v2(y_test, y_pred), accuracy_score(y_test, y_pred)
(0.9414893617021277, 0.9414893617021277, 0.9414893617021277)

Теперь давайте начнем изучать percision

Точность = TP/(TP + FP)

Точность — это отношение истинных положительных результатов (TP) ко всем положительным результатам, предсказанным моделью (TP + FP).

Допустим, мы создаем новую модель на новом искаженном наборе данных, и наша модель правильно идентифицировала 80 нераковых заболеваний из 90 и 8 раковых из 10. Таким образом, мы успешно идентифицировали 88 правильных случаев из 100. Таким образом, точность составляет 0,88 или 88%.

Но из этих 100 образцов 10 экземпляров данных, не связанных с раком, ошибочно классифицируются как имеющие рак, а 2 больных раком ошибочно классифицируются как не имеющие рака.

Таким образом, мы имеем:

• TP : 8
• TN : 80
• FP : 10
• FN : 2

Итак, наша точность равна 8/(8+10) = 0,444. Это означает, что наша модель корректна в 44,4% случаев, когда пытается идентифицировать положительные образцы.

Теперь, когда мы реализовали TP, TN, FP и FN, мы можем легко реализовать точность в python.

from sklearn.metrics import precision_score
precision(y_test, y_pred), precision_score(y_test, y_pred)
(0.9583333333333334, 0.9583333333333334)

Итак, мы можем сделать вывод, что наша пользовательская точность и точность sklearn одинаковы.

Чем большее количество FP предсказывает наша модель, тем ниже значение Recall. Говоря математическим языком, больший знаменатель ведет к меньшей дроби.

Это хороший показатель эффективности?

Ответ опять же сильно зависит от поставленной задачи.

Давайте возьмем немного менее удручающий пример, когда мы хотим определить, есть ли у пациента рак молочной железы или нет.

Если мы ошибочно идентифицируем неракового пациента как больного, мы увеличиваем ошибку ложного срабатывания (FP). Если мы ошибочно идентифицируем больного раком как человека, не страдающего раком, мы увеличиваем число ложноотрицательных результатов (FN).

В этом случае стоимость FP выше, чем стоимость FN, потому что каждый случай FP заставит нас пропустить пациента с раком, в то время как мы можем иметь дело с пациентом без рака, проведя больше тестов на пациенте, но мы не можем пропустить пациента с раком.

Следовательно, в данном случае мы хотим получить каждого больного раком. Другими словами, нам нужно свести к минимуму количество больных раком, не страдающих раком.

Когда нам нужно быть более уверенными в истинных положительных результатах (TP и ), свести к минимуму ложные положительные результаты (FP = 0) и , мы стремимся к идеальной точности, т. Е. Точность = 1 (или 100%).

Точность говорит нам, насколько точно мы идентифицируем конкретную метку. Например, сколько из тех, кого мы назвали больными, на самом деле больны? (Здесь больной — это положительное подтверждение, а здоровый — отрицательное подтверждение).

Напомним или чувствительность:

Отзыв (или чувствительность) — это отношение истинных положительных результатов (TP) ко всем правильным прогнозам в вашем наборе данных (TP + FN). Ложноотрицательные результаты включены сюда, потому что на самом деле они также являются правильными прогнозами.

Отзыв = TP/(TP + FN)

from sklearn.metrics import recall_score

recall(y_test, y_pred), recall_score(y_test,y_pred)
(0.9504132231404959, 0.9504132231404959)

Итак, из вышесказанного мы можем сказать, что наши значения пользовательского отзыва и отзыва sklearn одинаковы.

Чем большее количество FN предсказывает наша модель, тем ниже значение Recall.

Это хороший показатель эффективности?

Ответ опять же сильно зависит от поставленной задачи.

Возьмем неудачный, но реалистичный пример, связанный с пандемией COVID-19:

Если мы ошибочно идентифицируем пораженных коронавирусом пациентов как здоровых, мы увеличиваем ошибку False Negative (FN). Если мы ошибочно идентифицируем здоровых людей как больных коронавирусом, мы увеличиваем число ложноположительных результатов (FP).

В этом случае стоимость FN выше, чем стоимость FP, потому что каждый случай FN будет продолжать распространять вирус, а FP — нет.

Следовательно, в этом случае нам необходимо выявить каждую инфекцию COVID-19!

Когда нам нужно исключить ложноотрицательные результаты (FN = 0), мы стремимся к идеальному отзыву, т. е. отзыву = 1 (или 100%). Другими словами, высокочувствительная модель будет помечать почти всех, у кого есть заболевание, и не будет генерировать много ложноотрицательных результатов.

Для хорошей модели наши значения точности и полноты должны быть высокими. мы видим, что в приведенной выше модели у нас есть как точность, так и высокая запоминаемость рекламы.

Большая часть модели предсказывает вероятность, и когда мы предсказываем, мы обычно выбираем этот порог равным 0,5. этот порог не всегда идеален, и в зависимости от этого порога наше значение точности и полноты может резко измениться, если для каждого выбранного нами порога мы вычисляем значения точности и полноты, мы можем создать банк между этими наборами значений. этот график или кривая известна как кривая точности-отзыва.

Прежде чем рассматривать кривую точность-отзыв, давайте предположим два списка.

y_true_1 = [0,1,1,0,0,1,0,0,1,1,1,0,0,0,0,1,0,0,0,1,0]
y_pred_1 = [0.25385164, 0.47153354, 0.52181292, 0.74550538, 0.05293734,
       0.02329051, 0.78833001, 0.1690708 , 0.70097403, 0.51098548,
       0.07442634, 0.55349556, 0.2294754 , 0.37426226, 0.16770641,
       0.27747923, 0.82226646, 0.62389247, 0.41162855, 0.01400135,
       0.46683325]

Итак, y_true — это наши цели, а y_pred — это значения вероятности для выборки, которой присваивается значение 1. Итак, теперь мы смотрим на вероятности в прогнозе, а не на прогнозируемое значение (которое в большинстве случаев рассчитывается с порогом 0,5). )

precisions = []
recalls = []
# how we calculated threshold will be explained further
thresholds = [0.49344837, 0.6820013 , 0.13756598, 0.4702898 , 0.87279533,
       0.6297947 , 0.33575179, 0.50324857, 0.1237034 , 0.43555069,
       0.66494372, 0.60502148, 0.55022514, 0.57837422]

# for every threshold, calculate predictions in binary
# and uppend calculated prcision ad recalls
# to their respective lists
for i in thresholds:
    temp_prediction = [1 if x >= i else 0 for x in y_pred_1]
    p = precision(y_true_1, temp_prediction)
    r = recall(y_true_1, temp_prediction)
    precisions.append(p)
    recalls.append(r)

Теперь мы можем построить эти значения точности и отзыва

import matplotlib.pyplot as plt
plt.figure(figsize=(7,7))
plt.plot(sorted(recalls), sorted(precisions))
plt.xlabel('Recalls', fontsize=15)
plt.ylabel('Precisions', fontsize=15)
plt.show();

Эта кривая точного отзыва сильно отличается от того, что вы могли видеть в Интернете. Это потому, что мы взяли несколько точек экземпляра.

Вы заметите, что сложно выбрать значение порога, которое дает как хорошую точность, так и полноту и значения. если порог слишком высок, у вас меньшее количество истинно положительных и большое количество ложноотрицательных результатов. Это уменьшает ваш отзыв; однако ваша оценка точности будет высокой. Если вы уменьшите порог слишком низко, количество ложных срабатываний сильно возрастет, а точность будет меньше.

И точность, и полнота варьируются от 0 до 1, и чем ближе к 1, тем лучше.

F1-Оценка:

F1-score — это показатель, который сочетает в себе точность и полноту. Он определяется как простое средневзвешенное (гармоническое среднее) точности и полноты.

F1-Score = 2*точность x полнота/(точность + полнота)

Мы также можем найти оценку f1 на основе tp/fp и fn, используя приведенное ниже уравнение.

F1-Score = 2TP/(2TP+FP+FN)

def f1(y_true, y_pred):
    '''
    Function to calculate f1 score
    :param y_true: list of true values.
    :param y_pred: list of predicted values.
    :return: f1 score
    '''
    
    p = precision(y_true, y_pred)
    r = recall(y_true, y_pred)
    f1 = 2*p*r/(p+r)
    
    
    return f1
from sklearn.metrics import f1_score 
f1(y_test, y_pred), f1_score(y_test, y_pred)
(0.9543568464730291, 0.9543568464730291)

Из приведенного выше видно, что наши пользовательские значения f1-score и sklearn f1-score одинаковы.

Вместо того, чтобы смотреть на точность и полноту по отдельности, вы также можете просто посмотреть на счет f1.

• Так же, как и для точности, полноты и достоверности, показатель F1 также находится в диапазоне от 0 до 1. Идеальная модель прогнозирования имеет показатель F1, равный 1. вспомнить) вместо точности.

Другие важные термины

TPR или True положительный показатель, что то же самое, что отзыв.

TPR = TP/(TP + FN)

TPR или Recall также известен как чувствительность.

def tpr(y_true, y_pred):
    '''
    Function that return TPR 
    :param y_true: list of true values.
    :param y_pred: list of predicited values.
    :return tpr value
    '''
    tp = true_positive(y_true, y_pred)
    fn = false_negative(y_true, y_pred)
    try:
        tpr = tp/(tp+fn)
    except:
        tpr = 0
        
    return tpr

FPR или ложноположительный показатель, который определяется как

FPR = FP/(TN + FP)

def fpr(y_true, y_pred):
    '''
    Function to return fpr
    :param y_true: list of true values.
    :param y_pred: list of predictied values.
    :return: fpr value
    '''
    
    fp = false_positive(y_true, y_pred)
    tn = true_negative(y_true, y_pred)
    try:
        fpr = fp/(tn+fp)
    except:
        fpr = 0
    return fpr

1- FPR известен как специфичность или отрицательная скорость или TNR.

Терминов много, но наиболее важными из них являются только TPR и FPR.

Площадь под кривой или (площадь под ROC (кривая рабочей характеристики приемника) AUC

Предположим, что у нас всего 15 выборок и их целевые значения двоичные:

Фактические цели: [0, 0,0,0,1,0,1,0,0,1,0,1,0,0,1,0,1]

мы обучаем модель, такую ​​как случайный лес, и можем получить вероятность того, что выборка будет положительной.

Прогнозируемые вероятности для 1: [0,1, 0,3, 0,2, 0,6, 0,8, 0,05, 0,9, 0,5, 0,3, 0,66, 0,3, 0,2, 0,85, 0,15, 0,99]

Для типичного порога ›=0,5 мы можем оценить все вышеуказанные значения точности, полноты/TPR, F1 и FPR. Но мы можем сделать то же самое, если выберем значение порога равным 0,4 или 0,6. На самом деле мы можем выбрать любое значение от 0 до 1 и рассчитать все метрики, описанные выше.

Давайте посчитаем только два значения, через: TPR и FPR.

tpr_list = []
fpr_list = []

# actual target 
y_true = [0, 0,0,0,1,0,1,0,0,1,0,1,0,0,1]

# predicted probabilities of a sample being 1
y_pred = [0.1, 0.3, 0.2, 0.6, 0.8, 0.05, 0.9, 0.5, 0.3, 0.66, 0.3, 0.2, 0.85, 0.15, 0.99] 


# Hand made threshold
threshold = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.85, 0.9, 0.99, 1.0 ]

# loop over all threshold
for thresh in threshold:
    
    # calculate predictions for a given threshold
    temp_pred = [1 if x >= thresh else 0 for x in y_pred]
    
    # calculate trp
    temp_tpr = tpr(y_true, list(temp_pred))
    
    # calculate fpr
    temp_fpr = fpr(y_true, list(temp_pred))
    
    # append tpr and fpr to listss
    tpr_list.append(temp_tpr)
    fpr_list.append(temp_fpr)
df = pd.DataFrame({'Threshold':threshold, 'tpr':tpr_list, 'fpr':fpr_list})
df

Порог tpr fpr 0 0,00 1,0 1,0 1 0,10 1,0 0,9 2 0,20 1,0 0,7 3 0,30 0,8 0,6 4 0,40 0,8 0,3 5 0,50 0,8 0,3 6 0,60 0,8 0,2 7 0,70 0 0,6 0,1 8 0,80 0,6 0,1 9 0,85 0,4 0,1 10 0,90 0,4 0,0 11 0,99 0,2 0,0 12 1,00 0,0 0,0

Если мы построим приведенную выше таблицу как TPR по оси Y и FPR по оси X, мы получим кривую, как показано ниже.

plt.figure(figsize=(7,7))
plt.fill_between(fpr_list, tpr_list, alpha=0.4)
plt.plot(fpr_list, tpr_list, lw=3)
plt.xlim(0, 1.0)
plt.ylim(0, 1.0)
plt.xlabel('FPR', fontsize=15)
plt.ylabel('TPR', fontsize=15)
plt.show()

Эта кривая также известна как рабочая характеристика приемника (ROC). А если вычислить площадь под ROC-кривой. мы вычисляем другую метрику, которая очень часто используется, когда у вас есть набор данных с искаженными двоичными целями.

Этот показатель известен как Площадь под кривой ROC или Площадь под кривой или просто AUC. Есть много способов рассчитать площадь под кривой ROC.

from sklearn.metrics import roc_auc_score
roc_auc_score(y_true, y_pred)
0.8300000000000001

Диапазон значений AUC от 0 до 1

• AUC = 1 означает, что у вас идеальная модель. В большинстве случаев это означает, что вы допустили какую-то ошибку при проверке и должны пересмотреть свой конвейер обработки и проверки данных. если вы не допустили ошибок, поздравляю, у вас есть лучшая модель для набора данных, на котором вы ее построили.
• AUC = 0 означает, что ваша модель очень плохая (или очень хорошая!) Попробуйте инвертировать метки.
• AUC = 0,5 означает, что ваши прогнозы случайны. поэтому для любой проблемы бинарной классификации, если я предскажу все цели как 0,5, я получу AUC 0,5.

После расчета вероятностей и AUC вы захотите сделать прогнозы на тестовом наборе. В зависимости от проблемы и варианта использования вы можете захотеть иметь либо вероятностные, либо фактические классы. если вы хотите иметь вероятности, это легко. Они у вас уже есть. Если вы хотите иметь классы, вам нужно выбрать порог. В случае бинарной классификации вы можете сделать что-то вроде следующего.

Прогноз = вероятность ›= порог

Это означает, что предсказание представляет собой новый список, содержащий только бинарные переменные. Элемент в прогнозе равен 1, если вероятность больше или равна заданному порогу, в противном случае значение равно 0.

Мы можем использовать кривую ROC, чтобы выбрать этот порог! Кривая ROC покажет вам, как порог влияет на частоту ложных срабатываний и истинных срабатываний и, следовательно, на ложноположительные и истинные срабатывания. вам следует выбрать порог, который лучше всего подходит для вашей задачи и наборов данных.

Потеря журнала:

В случае проблемы бинарной классификации. мы определяем потерю журнала как:

Журнал потерь = -1,0 x (цель x log (прогноз) + (1-цель) x log (1-прогноз))

где цель равна 0 или 1, а прогноз — это вероятность того, что выборка принадлежит классу 1.

Для нескольких выборок в наборе данных логарифмическая потеря по всем выборкам представляет собой простое среднее значение всех отдельных логарифмических потерь. ОДНА вещь, которую следует помнить, это то, что потеря журнала довольно сильно наказывает за неправильное или далекое предсказание.

то есть потеря журнала наказывает вас за то, что вы очень уверены и очень ошибаетесь.

log_loss(y_true, y_proba)
0.49882711861432294
from sklearn.metrics import log_loss
log_loss(y_true, y_proba)
0.49882711861432294

Таким образом, наша реализация верна. Реализация потери журнала проста, интерпретация может показаться немного сложной. Возможно, вы помните, что потеря журнала наказывает гораздо больше, чем другие показатели.

Мультиклассовая классификация:

Есть три разных способа расчета, которые время от времени могут сбивать с толку. Предположим, что в первую очередь нас интересует точность. мы знаем, что точность зависит от истинных срабатываний и ложных срабатываний.

- Макро усредненная точность:

Рассчитайте точность для всех по отдельности, а затем усредните их.

- Микроусредненная точность:

Рассчитайте истинные положительные и ложные положительные результаты по классам, а затем используйте это для расчета общей точности.

- Взвешенная точность:

То же, что и макрос, но в данном случае это средневзвешенное значение, зависящее от количества элементов в каждом классе.

Давайте сравним нашу реализацию со sklean, чтобы узнать, правильно ли мы ее реализовали.

from sklearn import metrics
y_true = [0,1,2,0,1,2,0,2,2]
y_pred = [0,2,1,0,2,1,0,0,2]
macro_precision(y_true, y_pred), metrics.precision_score(y_true, y_pred, average='macro')
(0.3611111111111111, 0.3611111111111111)
micro_precision(y_true, y_pred), metrics.precision_score(y_true, y_pred, average='micro')
(0.4444444444444444, 0.4444444444444444)
weighted_prediction(y_true, y_pred), metrics.precision_score(y_true, y_pred, average='weighted')
(0.39814814814814814, 0.39814814814814814)

Точно так же мы можем реализовать отзыв, f1-оценку, AUC и логарифмическую потерю для мультикласса.

Матрица путаницы:

Матрица путаницы — это матрица N x N, используемая для оценки производительности модели классификации, где N — количество целевых классов. Матрица сравнивает фактические целевые значения с предсказанными моделью машинного обучения.

Матрицы путаницы широко используются, потому что они дают лучшее представление о производительности модели, чем точность классификации. Для получения дополнительной информации, пожалуйста, проверьте ссылку ниже

Справочные ссылки:

1. https://medium.com/analytics-vidhya/what-is-a-confusion-matrix-d1c0f8feda5
2. https://medium.com/@fardinahsan146/accuracy-is-not-accurate-6eb321f2999c
3. https://medium.datadriveninvestor.com/9-types-of-performance-evaluation-for-classification-machine-learning-modeling-c6e73e97e528
4. https://scikit-learn.org/stable/modules/classes.html#module-sklearn.metrics
5. https://www.amazon.in/Approaching-Almost-Machine-Learning-Problem-ebook/dp/B089P13QHT