[PYTHON] Versuchen Sie, die Leistung des Modells für maschinelles Lernen / Klassifizierung zu bewerten
1. Zuallererst
Dieses Mal werde ich die Leistung des Klassifizierungsmodells bewerten, das für maschinelles Lernen beim Erstellen von Code verwendet wird.
2. Datensatz
Der verwendete Datensatz sind die Brustkrebsdaten, die mit sklearn geliefert werden.
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.svm import SVC
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.pipeline import Pipeline
from sklearn.model_selection import train_test_split
from sklearn import metrics
from sklearn.metrics import accuracy_score
# -----------Datensatzvorbereitung--------------
dataset = load_breast_cancer()
X = pd.DataFrame(dataset.data, columns=dataset.feature_names)
y = pd.Series(dataset.target, name='y')
X_train,X_test,y_train,y_test=train_test_split(X, y, test_size=0.3, random_state=1)
print('X_train.shape = ', X_train.shape)
print('X_test.shape = ', X_test.shape)
print(y_test.value_counts())
Teilen Sie den Datensatz durch Trainingsdaten: Testdaten = 7: 3. Die Testdaten sind 171 und die Merkmalsmenge beträgt 30 Elemente. Von den 171 Daten ** 1: 108 für normale Probanden und 0: 63 für Krebspatienten **.
3. Klassifizierungsmodell
Diesmal werden acht Klassifizierungsmodelle verwendet. Später werden wir es zur Vereinfachung der Verwendung in Form einer Pipeline zusammenstellen. Hyperparameter sind die Standardeinstellung.
# ----------Pipeline-Einstellungen----------
pipelines = {
'1.KNN':
Pipeline([('scl',StandardScaler()),
('est',KNeighborsClassifier())]),
'2.Logistic':
Pipeline([('scl',StandardScaler()),
('est',LogisticRegression(solver='lbfgs', random_state=1))]), # solver
'3.SVM':
Pipeline([('scl',StandardScaler()),
('est',SVC(C=1.0, kernel='linear', class_weight='balanced', random_state=1, probability=True))]),
'4.K-SVM':
Pipeline([('scl',StandardScaler()),
('est',SVC(C=1.0, kernel='rbf', class_weight='balanced', random_state=1, probability=True))]),
'5.Tree':
Pipeline([('scl',StandardScaler()),
('est',DecisionTreeClassifier(random_state=1))]),
'6.Random':
Pipeline([('scl',StandardScaler()),
('est',RandomForestClassifier(random_state=1, n_estimators=100))]), ###
'7.GBoost':
Pipeline([('scl',StandardScaler()),
('est',GradientBoostingClassifier(random_state=1))]),
'8.MLP':
Pipeline([('scl',StandardScaler()),
('est',MLPClassifier(hidden_layer_sizes=(3,3),
max_iter=1000,
random_state=1))])
}
1.KNN Es ist eine ** k-Nachbarschaftsmethode ** (k-nächster Nachbar), die k Stichproben findet, die den Daten, die Sie klassifizieren möchten, am nächsten sind, und die Daten durch eine Mehrheit von k Stichproben klassifiziert.
2.Logistic Es ist die ** logistische Regression **, die das Ergebnis des internen Produkts des Merkmalsvektors und des Gewichtsvektors in eine Wahrscheinlichkeit umwandelt und diese klassifiziert.
3.SVM Es handelt sich um eine ** Support Vector Machine **, die zum Zwecke der Maximierung des Spielraums klassifiziert wird.
4.K-SVM Es handelt sich um eine ** Kernel Support Vector Machine **, die Trainingsdaten mithilfe einer Projektionsfunktion in einen höherdimensionalen Merkmalsraum umwandelt und nach SVM klassifiziert.
5.Tree Es ist ein Klassifizierungsmodell von ** Decision Tree **.
6.Random Es handelt sich um eine ** zufällige Gesamtstruktur **, die aus zufällig ausgewählten Features mehrere Entscheidungsbäume erstellt und die Vorhersagen aller Entscheidungsbäume im Durchschnitt ausgibt.
7.GBoost Es ist ** Gradient Boosting ** (Gradinet Boosting), das die Vorhersagegenauigkeit verbessert, indem der nachfolgende Baum versucht, die Informationen (Residuen) zu erklären, die die vorhandene Baumgruppe nicht erklären kann.
8.MLP Es ist ein ** mehrschichtiges Perzeptron **, eine Art neuronales Netzwerk mit Vorwärtsausbreitung.
4. Genauigkeit
# -------- accuracy ---------
scores = {}
for pipe_name, pipeline in pipelines.items():
pipeline.fit(X_train, y_train)
scores[(pipe_name,'train')] = accuracy_score(y_train, pipeline.predict(X_train))
scores[(pipe_name,'test')] = accuracy_score(y_test, pipeline.predict(X_test))
print(pd.Series(scores).unstack())
Genauigkeit von Trainingsdaten und Testdaten. Wenn wir uns die Genauigkeit der Testdaten ansehen, die die Generalisierungsleistung zeigt, können wir sehen, dass ** 2.Logistic ** mit 0,970760 am besten ist.
5. Verwirrungsmatrix
Die Klassifizierungsergebnisse sind in vier Kategorien unterteilt: ** wahr positiv, falsch negativ, falsch positiv und richtig negativ **, und die quadratische Matrix ist **. Es heißt Confusion Matrix **.
Das Folgende ist ein Beispiel für das Vorhersageergebnis des Krebs-Screenings, ausgedrückt durch Confusion Matrix.
Die Genauigkeit wird durch (TP + TN) / (TP + FN + FP + TN) ausgedrückt. Bei der Krebsvorsorge ist es jedoch wichtig, den Anstieg des FP in gewissem Maße zu berücksichtigen und festzustellen, wie viel FN gesenkt werden kann. Es ist ein Standpunkt.
# ---------- Confusion Matrix ---------
from sklearn.metrics import confusion_matrix
import seaborn as sns
for pipe_name, pipeline in pipelines.items():
cmx_data = confusion_matrix(y_test, pipeline.predict(X_test))
df_cmx = pd.DataFrame(cmx_data)
plt.figure(figsize = (3,3))
sns.heatmap(df_cmx, fmt='d', annot=True, square=True)
plt.title(pipe_name)
plt.xlabel('predicted label')
plt.ylabel('true label')
plt.show()
Die Ausgabe des Codes ist acht, aber als Vertreter können Sie anhand der Verwirrungsmatrix von 2.Lostic feststellen, dass 2 von 63 Krebspatienten fälschlicherweise normal klassifiziert sind.
6.accuracy, recall, precision, f1-score
Die folgenden vier Indikatoren können aus der Verwirrungsmatrix abgerufen werden.
Ein Code, der vier Anzeigen anzeigt. In diesem Datensatz ist 0 ein Krebspatient und 1 eine normale Person. Daher wird pos_label = 0 zu den Argumenten Rückruf, Präzision und f1-Score hinzugefügt.
# ------- accuracy, precision, recall, f1_score for test_data------
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score
scores = {}
for pipe_name, pipeline in pipelines.items():
scores[(pipe_name,'1.accuracy')] = accuracy_score(y_test, pipeline.predict(X_test))
scores[(pipe_name,'2.recall')] = recall_score(y_test, pipeline.predict(X_test), pos_label=0)
scores[(pipe_name,'3.precision')] = precision_score(y_test, pipeline.predict(X_test), pos_label=0)
scores[(pipe_name,'4.f1_score')] = f1_score(y_test, pipeline.predict(X_test), pos_label=0)
print(pd.Series(scores).unstack())
In diesem Vergleich ist es in erster Linie unwahrscheinlich, dass ein Krebspatient mit einer normalen Person verwechselt wird (hoher Rückruf). 2-4 sind Kandidaten, und unter diesen ist es unwahrscheinlich, dass eine normale Person mit einem Krebspatienten verwechselt wird (hohe Präzision). ), ** 2.Logistic ** scheint das Beste zu sein.
7. ROC-Kurve, AUC
Zunächst werde ich die ROC-Kurve und die AUC anhand konkreter Beispiele erläutern.
# --------ROC-Kurve, AUC -----------
for pipe_name, pipeline in pipelines.items():
fpr, tpr, thresholds = metrics.roc_curve(y_test, pipeline.predict_proba(X_test)[:, 0], pos_label=0) # 0:Klassifizierung von Krebspatienten
auc = metrics.auc(fpr, tpr)
plt.figure(figsize=(3, 3), dpi=100)
plt.plot(fpr, tpr, label='ROC curve (AUC = %.4f)'%auc)
x = np.arange(0, 1, 0.01)
plt.plot(x, x, c = 'red', linestyle = '--')
plt.legend()
plt.title(pipe_name)
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.grid(True)
plt.show()
Die Ausgabe des Codes ist acht, aber als Repräsentant können Sie bei Betrachtung der ROC-Kurve und der AUC von ** 2.Lostic ** feststellen, dass sie der idealen Klassifizierungsgenauigkeit ziemlich nahe kommt.
Recommended Posts