Jaka jest najlepsza miara wydajności używana w równoważeniu zestawu danych przy użyciu techniki SMOTE

Użyłem techniki smote do nadpróbkowania mojego zestawu danych, a teraz mam zrównoważony zestaw danych. Problem, z którym się spotkałem, polega na tym, że wskaźniki wydajności; precyzja, przywołanie, pomiar F1, dokładność w niezrównoważonym zbiorze danych są lepiej wykonywane niż w zbalansowanym zbiorze danych.

Jakiego pomiaru mogę użyć, aby wykazać, że zestaw danych bilansujących może poprawić wydajność modelu?

Uwaga: roc_auc_score jest lepszy w zbalansowanym zestawie danych niż roc_auc_score z niezrównoważonym zestawem danych Czy można to uznać za dobry pomiar wydajności? po wyjaśnieniu zaimplementowałem kod i otrzymałem te wyniki

import pandas as pd
import numpy as np
from sklearn import preprocessing
import matplotlib.pyplot as plt 
plt.rc("font", size=14)
from sklearn.svm import LinearSVC
from sklearn.svm import SVC
from sklearn.cross_validation import train_test_split,StratifiedShuffleSplit,cross_val_score
import seaborn as sns
from scipy import interp
from time import *
from sklearn import metrics
X=dataCAD.iloc[:,0:71]
y= dataCAD['Cardio1']
# Split the dataset in two equal parts
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=0)
print(y_test.value_counts())
model=SVC(C=0.001, kernel="rbf",gamma=0.01, probability=True)
t0 = time()
clf = model.fit(X_train,y_train)
y_pred = clf.predict(X_test)
t = time() - t0
print("=" * 52)
print("time cost: {}".format(t))
print()
print("confusion matrix\n", metrics.confusion_matrix( y_test, y_pred))
cf=metrics.confusion_matrix(y_test, y_pred)
accuracy=(cf.item((0,0))/50)+(cf.item((1,1))/14)
print("model accuracy \n",accuracy/2)
print()
print("\t\tprecision_score: {}".format(metrics.precision_score( y_test, y_pred, average='macro')))
print()
print("\t\trecall_score: {}".format(metrics.recall_score(y_test, y_pred, average='macro')))
print()
print("\t\tf1_score: {}".format(metrics.f1_score(y_test, y_pred, average='macro')))
print()
print("\t\troc_auc_score: {}".format(metrics.roc_auc_score( y_test, y_pred, average='macro')))

Wyniki:

Name: Cardio1, dtype: int64
====================================================
time cost: 0.012008905410766602

confusion matrix
 [[50  0]
 [14  0]]
model accuracy 
 0.5

        precision_score: 0.390625

        recall_score: 0.5

        f1_score: 0.43859649122807015

        roc_auc_score: 0.5

Zrównoważony zestaw danych

X_train1,y_train1 = sm.fit_sample(X_train, y_train.ravel())
df= pd.DataFrame({'Cardio1': y_train1})
df.groupby('Cardio1').Cardio1.count().plot.bar(ylim=0)
plt.show()
print(X_train1.shape)
print(y_train1.shape)
#model=SVC(C=0.001, kernel="rbf",gamma=0.01, probability=True)
model=SVC(C=10, kernel="sigmoid",gamma=0.001, probability=True)
t0 = time()
clf = model.fit(X_train1,y_train1)
y_pred = clf.predict(X_test)
t = time() - t0
print("=" * 52)
print("time cost: {}".format(t))
print()
print("confusion matrix\n", metrics.confusion_matrix(y_test, y_pred))
cf=metrics.confusion_matrix(y_test, y_pred)
accuracy=(cf.item((0,0))/50)+(cf.item((1,1))/14)
print("model accuracy \n",accuracy/2)
print()
#print("\t\taccuracy: {}".format(metrics.accuracy_score( y_test, y_pred)))
print()
print("\t\tprecision_score: {}".format(metrics.precision_score( y_test, y_pred, average='macro')))
print()
print("\t\trecall_score: {}".format(metrics.recall_score(y_test, y_pred, average='macro')))
print()
print("\t\tf1_score: {}".format(metrics.f1_score(y_test, y_pred, average='macro')))
print()
print("\t\troc_auc_score: {}".format(metrics.roc_auc_score( y_test, y_pred, average='macro')))

Wyniki:

(246, 71)
(246,)
====================================================
time cost: 0.05353999137878418

confusion matrix
 [[ 0 50]
 [ 0 14]]
model accuracy 
 0.5


        precision_score: 0.109375

        recall_score: 0.5

        f1_score: 0.1794871794871795

        roc_auc_score: 0.5

Nie znalazłem żadnych skutecznych wyników. Czy powinienem wdrożyć model przy użyciu weryfikacji krzyżowej?

Przede wszystkim, dla jasności, nie powinieneś oceniać wydajności swoich modeli na zbalansowanym zbiorze danych. To, co powinieneś zrobić, to podzielić zestaw danych na pociąg i zestaw testów z idealnie takim samym stopniem nierównowagi. Ocena powinna być wykonywana wyłącznie na zestawie testowym, a równoważenie na zestawie szkoleniowym.

Jeśli chodzi o twoje pytanie, każda metryka uśredniona dla makr powinna dobrze działać, aby udowodnić, że twoja technika bilansowania jest skuteczna. Aby obliczyć taką metrykę (powiedzmy dokładność dla uproszczenia), wystarczy obliczyć dokładności każdej klasy indywidualnie, a następnie je uśrednić .

Przykład :
Przeszkoliliśmy dwa modele m1im2 pierwszy bez zrównoważenia zestawu danych, a drugi po użyciu bili do zrównoważenia zestawu danych.

Rzeczywiste wartości: 0, 0, 0, 0, 0, 0, 0, 0, 1, 1
Przewidywane m1: 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 <- przewiduje tylko klasę większości
Przewidywane m2:1, 0, 0, 1, 0, 1, 0, 0, 1, 1

Jak normalnie obliczalibyśmy dokładność?

$acc = \frac{correct \, predictions}{total \, predictions}$

Jak nasze dwa modele radzą sobie z tym wskaźnikiem?

$acc_1 = \frac{8}{10} = 80\%$
$acc_2 = \frac{7}{10} = 70\%$

Zgodnie z tym wskaźnikiem wydajności m2jest lepszy niż m1. Jednak niekoniecznie tak jest, ponieważ m1tylko przewiduje się większość klasy! Aby pokazać, jak m2jest lepszy m1, potrzebujemy metryki, która traktuje dwie klauzule jako równe.

Spróbujemy teraz obliczyć dokładność uśrednioną na poziomie makro. W jaki sposób? Najpierw obliczymy dokładność dla każdej klasy osobno, a następnie uśrednimy je:

• m1
  $acc_1^0 = \frac{8}{8} = 100\%$m10
  $acc_1^1 = \frac{0}{2} = 0\%$ <- m1dokładność w klasie1
  $macro\_acc_1 = \frac{acc_1^0 + acc_1^1}{2} = \frac{100\% + 0\%}{2} = 50\%$

• Dla m2:
  $acc_2^0 = \frac{5}{8} = 62.5\%$<- m2dokładność w klasie0
  $acc_2^1 = \frac{2}{2} = 100\%$ <- m2dokładność w klasie1
  $macro\_acc_2 = \frac{acc_2^0 + acc_2^1}{2} = \frac{62.5\% + 100\%}{2} = 81.25\%$

Uwagi :

• Uśrednianie makr można zastosować do dowolnej metryki, którą jednak chcesz, jednak jest to najczęściej w metrach macierzy pomieszania (np. Precyzja, przywołanie, f1).

• Nie musisz tego samodzielnie wdrażać, wiele bibliotek już go ma (np. F1_score sklearn ma parametr o nazwie average, który można ustawić na "macro")