[PYTHON] Essayez d'évaluer les performances du modèle d'apprentissage automatique / de classification

1.Tout d'abord

Cette fois, j'évaluerai les performances du modèle de classification utilisé pour l'apprentissage automatique lors de la création de code.

2. Ensemble de données

L'ensemble de données utilisé sont les données sur le cancer du sein fournies avec sklearn.

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

# -----------Préparation du jeu de données--------------
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())

Divisez l'ensemble de données par les données d'entraînement: données de test = 7: 3. Les données de test sont de 171 et la quantité de caractéristiques est de 30. Sur les 171 données, ** 1: 108 pour les sujets normaux et 0: 63 pour les patients atteints de cancer **.

3. Modèle de classification

Il existe huit modèles de classification utilisés cette fois. Plus tard, nous le rassemblerons sous la forme d'un pipeline pour en faciliter l'utilisation. Les hyper paramètres sont les paramètres par défaut.

# ----------Paramètres du pipeline----------
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 Il s'agit d'une méthode ** k de voisinage ** (k-plus proche voisin) qui trouve k échantillons les plus proches des données que vous souhaitez classer à partir des données d'apprentissage et classe les données par une majorité de k échantillons.

2.Logistic C'est la ** régression logistique ** qui convertit le résultat du produit interne du vecteur caractéristique et du vecteur poids en probabilité et le classe.

3.SVM C'est une ** Machine Vectorielle de Support ** qui classe dans le but de maximiser la marge.

4.K-SVM Il s'agit d'une ** machine à vecteurs de support du noyau ** qui transforme les données d'entraînement en un espace de fonctionnalités de plus grande dimension à l'aide d'une fonction de projection et les classe par SVM.

5.Tree Il s'agit d'un modèle de classification par ** Arbre de décision **.

6.Random Il s'agit d'une ** forêt aléatoire ** qui crée plusieurs arbres de décision à partir d'entités sélectionnées au hasard et produit en moyenne les prédictions de tous les arbres de décision.

7.GBoost C'est le ** boosting de gradient ** (Gradinet Boosting) qui améliore la précision de la prédiction par l'arbre suivant en essayant d'expliquer les informations (résiduelles) que le groupe d'arbres existant ne peut pas expliquer.

8.MLP Il s'agit d'un ** perceptron multicouche **, qui est un type de réseau neuronal à propagation directe.

4. précision

# -------- 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())  

Précision des données d'entraînement et des données de test. En regardant la précision des données de test, qui montre les performances de généralisation, nous pouvons voir que ** 2.Logistic ** est le meilleur à 0,970760.

5. Matrice de confusion

Les résultats de la classification sont divisés en quatre catégories: ** vrai positif, faux négatif, faux positif et vrai négatif **, et la matrice carrée est **. Elle s'appelle la matrice de confusion **.

Ce qui suit est un exemple du résultat de prédiction du dépistage du cancer exprimé par Confusion Matrix.

La précision est exprimée par (TP + TN) / (TP + FN + FP + TN), mais dans le cas du dépistage du cancer, il est important de prêter attention à l'augmentation de la PF dans une certaine mesure et à la quantité de FN pouvant être abaissée. C'est un point de vue.

# ---------- 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()

La sortie du code est huit, mais à titre représentatif, si vous regardez la matrice de confusion de 2.Lostic, vous pouvez voir que 2 patients cancéreux sur 63 sont classés par erreur normalement.

6.accuracy, recall, precision, f1-score Les quatre indicateurs suivants peuvent être obtenus à partir de la matrice de confusion. Un code qui affiche quatre indicateurs. Dans cet ensemble de données, 0 est un patient atteint de cancer et 1 est une personne normale, donc pos_label = 0 est ajouté aux arguments de rappel, de précision et de score f1.

# ------- 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())

Dans cette comparaison, avant tout, il est peu probable qu'un patient cancéreux soit confondu avec une personne normale (rappel élevé) 2-4 sont des candidats, et parmi eux, il est peu probable qu'une personne normale soit confondue avec un patient cancéreux (haute précision). ), ** 2.Logistic ** semble être le meilleur.

7. Courbe ROC, AUC

Tout d'abord, j'expliquerai la courbe ROC et l'AUC avec des exemples concrets.

# --------Courbe ROC, 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:Classification des patients cancéreux
    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()

La sortie du code est huit, mais à titre représentatif, si vous regardez la courbe ROC et l'AUC de ** 2.Lostic **, vous pouvez voir qu'elle est assez proche de la précision de classification idéale.