Dernière fois Cours d'apprentissage automatique à l'Université de Tsukuba: étudier sklearn tout en intégrant le script Python au devoir (10) https://github.com/legacyworld/sklearn-basic

Exercice 5.4 Création de courbes ROC et réglage des paramètres de régularisation

Commentaire sur Youtube: 6e (1) 58 minutes 30 secondes Les données iris (Ayame) de sklearn sont utilisées, mais les conditions suivantes sont utilisées pour simplifier.

--Utilisez uniquement la largeur sépale et la longueur sépale -Ne pas utiliser la largeur / longueur des pétales

Ne considérez que si virginica ou non
En fait, il existe 3 types: setosa, versicolor et virginica.

5.4_irisdata.png

Cliquez ici pour le code source

`python:Homework_5.4.py`


import numpy as np
import matplotlib.pyplot as plt
from sklearn import svm,metrics
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris  
iris = load_iris()
# sepal width(Largeur unilatérale),sepal length(Longueur unilatérale)Utiliser seulement
features = [0,1]
#Considérez simplement si virginica ou non
target = 2
X = iris.data[:,features]
y = iris.target
# y =Pas 2(Pas virginica)Si-1
y[np.where(np.not_equal(y,target))] = -1
y[np.where(np.equal(y,target))] = 1
#Dessiner des données uniquement
plt.figure(0,figsize=(5,5))
plt.scatter(X[:, 0][np.where(y==1)], X[:, 1][np.where(y==1)], color='b',label=iris.target_names[target])
plt.scatter(X[:, 0][np.where(y==-1)], X[:, 1][np.where(y==-1)], color='r',label=f"not {iris.target_names[target]}")
plt.xlabel(iris.feature_names[features[0]])
plt.ylabel(iris.feature_names[features[1]])
plt.legend()
plt.savefig("5.4_irisdata.png ")
# SVM (C=0.01)
clf = svm.SVC(kernel='linear', C=0.01)
clf.fit(X, y)

#Courbe ROC
fpr,tpr,th = metrics.roc_curve(y,clf.decision_function(X))
plt.clf()
plt.plot(fpr,tpr)
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC")
plt.savefig("5.4_ROC_curve.png ")
#Le taux de faux positifs est de 0.Taux de vrais positifs près de 2
index = np.where(fpr>=0.2)[0].tolist()[0]
print(f"FPR = {fpr[index-1]} TPR = {tpr[index-1]}")
print(f"FPR = {fpr[index]} TPR = {tpr[index]}")

#Dessiner en changeant la section
for i in range(0,110,10):
    dec = clf.decision_function(X)
    #Déplacer la section de la valeur maximale à la valeur minimale
    intercept = np.max(dec) - i/100*(np.max(dec)-np.min(dec))
    #TPR et FPR
    TP = np.where((np.signbit(dec-intercept)==False) & (np.signbit(y)==False))
    FP = np.where((np.signbit(dec-intercept)==False) & (np.signbit(y)==True))
    FPR = len(FP[0])/len(y)
    TPR = len(TP[0])/len(y)
    #Index de mauvaise prédiction
    index = np.where(np.signbit(dec-intercept)!=np.signbit(y))
    x_miss = X[index]
    y_miss = y[index]
    #dessin
    plt.clf()
    plt.figure(0,figsize=(5,5))
    plt.scatter(X[:, 0][np.where(y==1)], X[:, 1][np.where(y==1)], color='b',label=iris.target_names[target])
    plt.scatter(X[:, 0][np.where(y==-1)], X[:, 1][np.where(y==-1)], color='r',label=f"not {iris.target_names[target]}")
    plt.xlabel(iris.feature_names[features[0]])
    plt.ylabel(iris.feature_names[features[1]])
    plt.title(f"Decision boundary Moved {i}% {-intercept:.3f}\nFPR = {FPR:.3f} TPR = {TPR:.3f}")
    #Tracer la frontière de décision
    xlim = plt.xlim()
    ylim = plt.ylim()
    #Faire une grille 30x30
    xx = np.linspace(xlim[0], xlim[1], 30)
    yy = np.linspace(ylim[0], ylim[1], 30)
    YY, XX = np.meshgrid(yy, xx)
    xy = np.vstack([XX.ravel(), YY.ravel()]).T
    #Classification dans chaque réseau
    Z = clf.decision_function(xy).reshape(XX.shape)-intercept
    #Tracer des limites de décision à l'aide du niveau des lignes de contour=0 lui correspond
    plt.contour(XX,YY,Z,levels=[0])
    plt.scatter(x_miss[:,0][np.where(y_miss==1)],x_miss[:,1][np.where(y_miss==1)],color='b',s=100,linewidth=1, facecolors='none', edgecolors='k')
    plt.scatter(x_miss[:,0][np.where(y_miss==-1)],x_miss[:,1][np.where(y_miss==-1)],color='b',s=100,linewidth=1, facecolors='none', edgecolors='k')
    plt.legend()
    plt.savefig(f"5.4_decision_boundary_{i}.png ")

#C à 0.01 à 1,Score AUC lors du passage à 000
c_values = [0.01,0.02,0.05,0.1,0.2,0.5,1,2,5,10,100,1000]
aucs = []
# TRAIN/VALICATION/Divisé en 3 pour TEST
X_tr_val,X_test,y_tr_val,y_test = train_test_split(X,y,test_size=0.2,random_state=1)
X_tr,X_val,y_tr,y_val = train_test_split(X_tr_val,y_tr_val,test_size=0.2,random_state=1)
print(len(X_tr_val),len(X_test),len(X_tr),len(X_val))
for c_value in c_values:
    clf = svm.SVC(kernel='linear',C=c_value).fit(X_tr,y_tr)
    dec = clf.decision_function(X_val)
    auc = metrics.roc_auc_score(y_val,dec)
    aucs.append(auc)

#Recalculé avec le meilleur C
best_c_index = np.argmax(aucs)
best_clf = svm.SVC(kernel='linear', C=c_values[best_c_index]).fit(X_tr_val,y_tr_val)
test_predict = best_clf.predict(X_test)
print(f"Best value of parameter C c_values[best_c_index]")

plt.clf()
plt.plot(c_values,aucs,label="AUC Scores")
plt.plot(c_values[best_c_index],aucs[best_c_index],marker ='o',markersize=10,label="Best Score")
plt.legend()
plt.xscale("log")
plt.savefig("5.4_AUC.png ")

Courbe ROC

Dans la conférence, la section (seuil) a été déplacée, mais dans ce programme, la section est dessinée tous les 10%. L'explication de la raison pour laquelle vous faites cela est très détaillée ici. https://qiita.com/TsutomuNakamura/items/ef963381e5d2768791d4

Les prédictions lors du déplacement des sections et leurs erreurs (encerclées) sont indiquées ci-dessous. 5 (2).png 5 (3).png

Plus le seuil est élevé, plus la précision est élevée. En d'autres termes, quelque chose qui n'est pas virginica n'est pas fait virginica, mais il y a plus de cas où la virginica n'est pas virginica. Au contraire, si le seuil est abaissé, la virginica peut être correctement jugée comme virginica, mais la non-virginica sera également virginica.

Le premier est un jugement pénal (certains criminels peuvent être ignorés, mais les fausses accusations ne sont pas autorisées) Ce dernier est le jugement du dépistage du cancer (une tumeur bénigne qui n'est pas un cancer est également considérée comme un cancer et rend le patient encore plus effrayé, mais il n'y a pas de problème car les dommages sont seulement effrayants)

La courbe ROC ressemble à ceci 5.4_ROC_curve.png

Maintenant ce problème dans le défi "Lorsque la probabilité de prédire la virginica même si elle n'est pas virginica est réduite à 0,2 ou moins, quelle est la probabilité maximale de prédire correctement les données virginica comme virginica?" En bref, quelle est la valeur maximale de True Positive Rate lorsque False Positve Rate <= 0,2? En d'autres termes. Ceci est la sortie à l'intérieur du programme

FPR = 0.18 TPR = 0.8
FPR = 0.2 TPR = 0.8

Lorsque le FPR est d'environ 0,2, le TPR est d'environ 0,8, donc la probabilité de faire une prédiction correcte est de 80%.

AUC Le dernier problème est de déplacer les paramètres de régularisation et de tracer l'AUC. Tout d'abord, à titre de préparation, les données sont divisées en trois parties.

--X_tr_val, y_tr_val: 120 pièces

Données pour SVC à nouveau une fois que le meilleur C est décidé --X_test, y_test: 30 pièces --Données pour le calcul final de la précision_score --X_tr, y_tr: 96 pièces
Données de formation pour trouver le C optimal --X_val, y_val: 24 pièces
Données pour la délivrance du score AUC

Graphique AUC 5.4_AUC.png

prédire_proba et fonction_décision

Dans la conférence, predict_proba est utilisé dans la partie AUC, mais j'ai utilisé la fonction decision_function parce que j'ai vu des articles qui avaient parfois des erreurs. https://qiita.com/rawHam/items/3bcb6a68a533f2b82a85

Messages passés

Cours d'apprentissage automatique à l'Université de Tsukuba: Étudiez sklearn tout en intégrant le script Python à la tâche (11)

Exercice 5.4 Création de courbes ROC et réglage des paramètres de régularisation

python:Homework_5.4.py

Courbe ROC

prédire_proba et fonction_décision

Messages passés

`python:Homework_5.4.py`