0. Einleitung

Beim maschinellen Lernen werden die ** ROC-Kurve ** und ** AUC (Fläche unter der Kurve) der ROC-Kurve als Indikatoren für die Güte des Klassifikators verwendet, wenn zwei Klassen unter Verwendung eines bestimmten Klassifikators klassifiziert werden. Bereich) ** wird verwendet.

Grob gesagt Die ROC-Kurve zeigt, "wie stark die beiden Verteilungen mithilfe des Klassifikators getrennt werden könnten". Sie können auch mehrere ROC-Kurven mit dem Betrag AUC vergleichen.

Erklärung der Bedeutung und Eigenschaften von AUC- und ROC-Kurven auf leicht verständliche Weise - Mathematik anhand konkreter Beispiele
[Bewertungsindex der ROC-Kurve für maschinelles Lernen und der 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 /)

Abhängig vom für das Training verwendeten Modell können einige ROC-Kurven gezeichnet werden, andere nicht. Ein Modell, bei dem die Ausgabe (Rückgabewert) bei Verwendung von model.predict () usw. durch die Wahrscheinlichkeit gegeben ist, kann eine ROC-Kurve zeichnen, ein Modell, bei dem die Ausgabe binär ist, kann jedoch keine ROC-Kurve zeichnen.

Dieses Mal werde ich mit dieser ROC-Kurve mit scicit-learn spielen.

1. Versuchen Sie, die Daten vorerst vorzubereiten

Wie eingangs erwähnt, kann die ROC-Kurve nur gezeichnet werden, wenn die Ausgabe probabilistisch ist. Daher nehmen wir eine solche Ausgabe an. Dann haben Sie y_true und y_pred wie die folgenden.

`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

Der Datenrahmen sieht wie oben aus.

Lassen Sie uns die Verteilung davon visualisieren.

`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) #Achsenbeschriftungen sind mit Arange einfacher zu schreiben
plt.yticks(np.arange(0, 6, 1), fontsize = 13)

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

Es ist so. Dies ist ein Beispiel für eine teilweise quantifizierte Verteilung, wie dies häufig der Fall ist.

2. Zeichnen Sie eine ROC-Kurve

ROC Die Dokumentation zu roc_curve () finden Sie hier (https://scikit-learn.org/stable/modules/generated/sklearn.metrics.roc_curve.html). Es gibt drei Rückgabewerte.

fpr (False Positive Rate)
tpr (True Positive Rate)
Thres (Schwellen)

Wenn Sie einen Schwellenwert festlegen und anhand dessen bestimmen, ob er positiv oder negativ ist, können Sie die falsch positive Rate und die wahr positive Rate ermitteln. Die obigen drei Rückgabewerte sind eine Liste von ihnen.

AUC auc repräsentiert den gekrümmten Bereich der oben erhaltenen ROC-Kurve. Gibt einen Wert von 0 bis 1 zurück.

`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)) #So geben Sie das Größenverhältnis für ein einzelnes Diagramm an
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()

Jetzt können Sie die ROC-Kurve zeichnen.

3. Probieren Sie verschiedene Distributionen aus

Zeichnen wir nun eine ROC-Kurve mit verschiedenen Verteilungen.

3.1 Vollständig trennbare Verteilung (AUC = 1,0)

Zeichnen wir eine ROC-Kurve mit einer Verteilung, die durch Festlegen eines bestimmten Schwellenwerts vollständig getrennt werden kann.

`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]`


#AUC usw. berechnen
fpr, tpr, thres = metrics.roc_curve(y_true, y_pred)
auc = metrics.auc(fpr, tpr)

#Montieren(fig)Schaffung
fig = plt.figure(figsize = (12, 4))
fig.suptitle(' AUC = ' + str(auc), fontsize = 16)
fig.subplots_adjust(wspace=0.5, hspace=0.6) #Passen Sie den Abstand zwischen den Diagrammen an

#Grafik links(ax1)Schaffung
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)

#Grafik rechts(ax2)Schaffung
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();

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

#links
## ax[0].set_
## ...

#Rechte Seite
## ax[1].set_
## ...  #Aber möglich

Es wurde eine solche ROC-Kurve.

3.2. Verteilung, die sehr schwer zu trennen ist (AUC ≒ 0,5)

Als nächstes zeichnen wir die ROC-Kurve der Verteilung, die schwer zu trennen ist.

`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]`


#AUC usw. berechnen
fpr, tpr, thres = metrics.roc_curve(y_true, y_pred)
auc = metrics.auc(fpr, tpr)

#Montieren(fig)Schaffung
fig = plt.figure(figsize = (12, 4))
fig.suptitle(' AUC = ' + str(auc), fontsize = 16)
fig.subplots_adjust(wspace=0.5, hspace=0.6) #Passen Sie den Abstand zwischen den Diagrammen an

#Grafik links(ax1)Schaffung
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)

#Grafik rechts(ax2)Schaffung
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();

Es wurde eine solche ROC-Kurve.

4. Untersuchen Sie den Rückgabewert der Funktion roc_curve ()

Untersuchen wir den Inhalt der Funktion roc_curve (). Sie können sehen, dass es sich um fpr, tpr, Schwellenwerte handelt, wie zuvor erläutert. Die 0. Schwelle s ist 1,95, was die 1. Schwelle plus 1 ist und so konzipiert zu sein scheint, dass sie ein Paar enthält, bei dem sowohl fpr als auch tpr 0 sind.

`In[10]`


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

Schauen wir uns im ersten Beispiel das Argument drop_intermeditate an. Dies ist standardmäßig False. Sie können es jedoch auf True setzen, um Punkte zu entfernen, die nicht mit der Form der ROC-Kurve zusammenhängen.

`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,)

Daher wird auch die tatsächliche Anzahl von Punkten reduziert.

5. Zusammenfassung

Dieses Mal habe ich die ROC-Kurve zusammengefasst, als ich das Ergebnis des maschinellen Lernens visualisierte.

Wir suchen Fragen und Artikel!

[PYTHON] [Scikit-learn] Ich habe mit der ROC-Kurve gespielt

0. Einleitung

1. Versuchen Sie, die Daten vorerst vorzubereiten

In[1]

In[2]

In[3]

2. Zeichnen Sie eine ROC-Kurve

In[4]

Out[4]

In[5]