0. Introduction

En apprentissage automatique, la ** courbe ROC ** et la ** AUC (Area Under the Curve) de la courbe ROC sont utilisées comme indicateurs de la qualité du classificateur lorsque deux classes sont classées à l'aide d'un certain classificateur. Area) ** est utilisé.

Grosso modo La courbe ROC montre "combien les deux distributions pourraient être séparées en utilisant le classificateur". Vous pouvez également comparer plusieurs courbes ROC en utilisant le montant AUC.

Explication de la signification et des propriétés des courbes AUC et ROC d'une manière facile à comprendre - Mathématiques apprises avec des exemples concrets
[Indice d'évaluation de la courbe d'apprentissage automatique-ROC et AUC](https://techblog.gmo-ap.jp/2018/12/14/%E6%A9%9F%E6%A2%B0%E5%AD%A6 % E7% BF% 92% E3% 81% AE% E8% A9% 95% E4% BE% A1% E6% 8C% 87% E6% A8% 99-roc% E6% 9B% B2% E7% B7% 9A % E3% 81% A8auc /)

Selon le modèle utilisé pour l'entraînement, certaines courbes ROC peuvent être dessinées et d'autres non. Un modèle dans lequel la sortie (valeur de retour) est donnée avec une probabilité lors de l'utilisation de model.predict () etc. peut dessiner une courbe ROC, mais un modèle dans lequel la sortie est binaire ne peut pas dessiner une courbe ROC.

Cette fois, je vais jouer avec cette courbe ROC en utilisant scicit-learn.

1. Essayez de préparer les données pour le moment

Comme mentionné au début, la courbe ROC ne peut être dessinée que si la sortie est probabiliste, nous supposons donc une telle sortie. Ensuite, vous aurez y_true et y_pred comme ceux ci-dessous.

`In[1]`


%matplotlib inline
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from sklearn import metrics

`In[2]`


y_true = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
          1, 1, 1, 1, 1, 1, 1, 1, 1, 1]

y_pred = [0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.5, 0.65, 0.7,
         0.35, 0.45, 0.5, 0.55, 0.6, 0.65, 0.7, 0.75, 0.8, 0.9]

df = pd.DataFrame({'y_true':y_true, 'y_pred':y_pred})
df

Le bloc de données ressemble à ce qui précède.

Visualisons la distribution de ceci.

`In[3]`


x0 = df[df['y_true']==0]['y_pred']
x1 = df[df['y_true']==1]['y_pred']

fig = plt.figure(figsize=(6,5)) #
ax = fig.add_subplot(1, 1, 1)
ax.hist([x0, x1], bins=10, stacked=True)

plt.xticks(np.arange(0, 1.1, 0.1), fontsize = 13) #Les étiquettes d'axe sont plus faciles à écrire avec arange
plt.yticks(np.arange(0, 6, 1), fontsize = 13)

plt.ylim(0, 4)
plt.show()

C'est comme ça. C'est un exemple de distribution partiellement quantifiée, comme c'est souvent le cas.

2. Dessinez une courbe ROC

ROC La documentation de roc_curve () est ici (https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html). Il existe trois valeurs de retour.

fpr (taux de faux positifs)
tpr (taux vraiment positif)
thres (seuils)

Si vous décidez d'un seuil et déterminez s'il est positif ou négatif en fonction de celui-ci, vous pouvez trouver le taux de faux positifs et le taux de vrais positifs. Les trois valeurs de retour ci-dessus en sont une liste.

AUC auc représente la zone courbe de la courbe ROC obtenue ci-dessus. Renvoie une valeur comprise entre 0 et 1.

`In[4]`


fpr, tpr, thres = metrics.roc_curve(y_true, y_pred)
auc = metrics.auc(fpr, tpr)
print('auc:', auc)

`Out[4]`


auc: 0.8400000000000001

`In[5]`


plt.figure(figsize = (5, 5)) #Comment donner le rapport de taille pour un seul graphique
plt.plot(fpr, tpr, marker='o')
plt.xlabel('FPR: False Positive Rete', fontsize = 13)
plt.ylabel('TPR: True Positive Rete', fontsize = 13)
plt.grid()
plt.show()

Vous pouvez maintenant dessiner la courbe ROC.

3. Essayez différentes distributions

Maintenant, dessinons une courbe ROC avec différentes distributions.

3.1. Distribution entièrement séparable (AUC = 1,0)

Dessinons une courbe ROC avec une distribution qui peut être complètement séparée en définissant un certain seuil.

`In[6]`


y_pred = [0, 0.15, 0.2, 0.2, 0.25,
          0.3, 0.35, 0.4, 0.4, 0.45,
          0.5, 0.55, 0.55, 0.65, 0.7,
          0.75, 0.8, 0.85, 0.9, 0.95]
          
y_true = [0, 0, 0, 0, 0,
          0, 0, 0, 0, 0,
          1, 1, 1, 1, 1,
          1, 1, 1, 1, 1]

df = pd.DataFrame({'y_true':y_true, 'y_pred':y_pred})
x0 = df[df['y_true']==0]['y_pred']
x1 = df[df['y_true']==1]['y_pred']

`In[7]`


#Calculez AUC etc.
fpr, tpr, thres = metrics.roc_curve(y_true, y_pred)
auc = metrics.auc(fpr, tpr)

#Monter(fig)Création
fig = plt.figure(figsize = (12, 4))
fig.suptitle(' AUC = ' + str(auc), fontsize = 16)
fig.subplots_adjust(wspace=0.5, hspace=0.6) #Ajuster l'espacement entre les graphiques

#Graphique à gauche(ax1)Création
ax1 = fig.add_subplot(1, 2, 1)
ax1.hist([x0, x1], bins=10, stacked = True)
ax1.set_xlim(0, 1)
ax1.set_ylim(0, 5)

#Graphique à droite(ax2)Création
ax2 = fig.add_subplot(1, 2, 2)
ax2.plot(fpr, tpr, marker='o')
ax2.set_xlabel('FPR: False Positive Rete', fontsize = 13)
ax2.set_ylabel('TPR: True Positive Rete', fontsize = 13)
ax2.set_aspect('equal')
ax2.grid()

plt.show();

#Monter
## fig, ax = plt.subplots(2, 2, figsize=(6, 4))
## ...

#la gauche
## ax[0].set_
## ...

#Côté droit
## ax[1].set_
## ...  #Mais possible

C'est devenu une telle courbe ROC.

3.2. Distribution très difficile à séparer (ASC ≒ 0,5)

Ensuite, dessinons la courbe ROC de la distribution difficile à séparer.

`In[8]`


y_pred = [0, 0.15, 0.2, 0.2, 0.25,
          0.3, 0.35, 0.4, 0.4, 0.45,
          0.5, 0.55, 0.55, 0.65, 0.7,
          0.75, 0.8, 0.85, 0.9, 0.95]
          
y_true = [0, 1, 0, 1, 0,
          1, 0, 1, 0, 1,
          0, 1, 0, 1, 0,
          1, 0, 1, 0, 1]

df = pd.DataFrame({'y_true':y_true, 'y_pred':y_pred})
x0 = df[df['y_true']==0]['y_pred']
x1 = df[df['y_true']==1]['y_pred']

`In[9]`


#Calculez AUC etc.
fpr, tpr, thres = metrics.roc_curve(y_true, y_pred)
auc = metrics.auc(fpr, tpr)

#Monter(fig)Création
fig = plt.figure(figsize = (12, 4))
fig.suptitle(' AUC = ' + str(auc), fontsize = 16)
fig.subplots_adjust(wspace=0.5, hspace=0.6) #Ajuster l'espacement entre les graphiques

#Graphique à gauche(ax1)Création
ax1 = fig.add_subplot(1, 2, 1)
ax1.hist([x0, x1], bins=10, stacked = True)
ax1.set_xlim(0, 1)
ax1.set_ylim(0, 5)

#Graphique à droite(ax2)Création
ax2 = fig.add_subplot(1, 2, 2)
ax2.plot(fpr, tpr, marker='o')
ax2.set_xlabel('FPR: False Positive Rete', fontsize = 13)
ax2.set_ylabel('TPR: True Positive Rete', fontsize = 13)
ax2.set_aspect('equal')
ax2.grid()

plt.show();

C'est devenu une telle courbe ROC.

4. Examinez la valeur de retour de la fonction roc_curve ()

Examinons le contenu de la fonction roc_curve (). Vous pouvez voir qu'il s'agit de seuils fpr, tpr, comme expliqué précédemment. Le 0e seuil s est 1,95, qui est le premier seuil plus 1 et semble être conçu pour inclure une paire où fpr et tpr sont tous deux égaux à 0.

`In[10]`


print(fpr.shape, tpr.shape, thres.shape)
ROC_df = pd.DataFrame({'fpr':fpr, 'tpr':tpr, 'thresholds':thres})
ROC_df

Dans le premier exemple, examinons l'argument drop_intermeditate. C'est False par défaut, mais vous pouvez le définir sur True pour supprimer les points qui ne sont pas liés à la forme de la courbe ROC.

`In[11]`


y_pred = [0, 0.15, 0.2, 0.2, 0.25,
          0.3, 0.35, 0.4, 0.4, 0.45,
          0.5, 0.55, 0.55, 0.65, 0.7,
          0.75, 0.8, 0.85, 0.9, 0.95]
          
y_true = [0, 0, 0, 0, 0,
          0, 0, 0, 0, 0,
          1, 1, 1, 1, 1,
          1, 1, 1, 1, 1]

fpr, tpr, thres = metrics.roc_curve(y_true, y_pred, drop_intermediate =True)
print(fpr.shape, tpr.shape, thres.shape)

`Out[11]`


(10,) (10,) (10,)

Par conséquent, le nombre réel de points est également réduit.

5. Résumé

Cette fois, j'ai résumé la courbe ROC lors de la visualisation du résultat de l'apprentissage automatique.

Nous recherchons des questions et des articles!

[PYTHON] [Scikit-learn] J'ai joué avec la courbe ROC

0. Introduction

1. Essayez de préparer les données pour le moment

In[1]

In[2]

In[3]

2. Dessinez une courbe ROC

In[4]

Out[4]

In[5]