ROC-Kurventipps in Python

In den letzten Jahren hat die Entwicklung der Datenwissenschaft und des maschinellen Lernens die Programmiersprache Python zu einer der beliebtesten Sprachen von Datenwissenschaftlern und Ingenieuren für maschinelles Lernen gemacht. Python bietet eine große Anzahl von Bibliotheken und Frameworks wie NumPy, Pandas, Scikit-learn usw., die die Erstellung hochwertiger Modelle für maschinelles Lernen erleichtern.

ROC-Kurve (Receiver Operating Characteristic Curve) ist ein wichtiges Werkzeug beim maschinellen Lernen. Sie wird zur Bewertung der Leistung von Klassifizierungsalgorithmen verwendet und hilft uns, die Klassifizierungsfähigkeit und Robustheit des Algorithmus zu verstehen. In Python können wir ROC-Kurven auf verschiedene Arten zeichnen, um die Bewertung von Klassifizierungsalgorithmen zu erleichtern. In diesem Artikel werden Techniken zum Zeichnen von ROC-Kurven in Python vorgestellt und gezeigt, wie Sie mit der Scikit-learn-Bibliothek und der Matplotlib-Bibliothek eine schöne ROC-Kurve erstellen.

Wie funktioniert die ROC-Kurve?

ROC-Kurve ist eines der am häufigsten verwendeten Tools zur Leistungsbewertung binärer Klassifikatoren. Diese Kurve veranschaulicht die Leistung des Klassifikators, indem sie die Beziehung zwischen der Falsch-Positiv-Rate und der Richtig-Positiv-Rate darstellt. Die Falsch-Positiv-Rate ist das Verhältnis der Falsch-Positiv-Klassen zu allen Negativklassen, und die Richtig-Positiv-Rate ist das Verhältnis der Wahr-Klassen zu allen Positivklassen. Die X-Achse der ROC-Kurve ist die Falsch-Positiv-Rate, während die Y-Achse die Richtig-Positiv-Rate ist.

Normalerweise handelt es sich bei dem Klassifizierungsproblem um ein binäres Beurteilungsproblem, bei dem positive und negative Beispiele als „1“ bzw. „0“ bezeichnet werden. Der Klassifikator kann die Instanz entsprechend einem bestimmten Schwellenwert als positives oder negatives Beispiel klassifizieren. Wenn der Schwellenwert des Klassifikators zu hoch ist, werden viele Instanzen fälschlicherweise als negative Beispiele klassifiziert. Dies erhöht die Falsch-Negativ-Rate und kann dazu führen, dass der Klassifikator Instanzen übersieht. Im Gegenteil: Wenn der Schwellenwert des Klassifikators zu niedrig ist, führt dies dazu, dass eine große Anzahl von Instanzen als positive Beispiele klassifiziert wird, die Falsch-Positiv-Rate steigt und es zu Fehleinschätzungen kommen kann. Um einen optimalen Klassifikator zu implementieren, müssen wir diese beiden Fehlertypen abwägen.

Eine ideale ROC-Kurve beginnt an dem Punkt, an dem die Richtig-Positiv-Rate gleich 1 und die Falsch-Positiv-Rate gleich 0 ist. An diesem Punkt wird der Schwellenwert auf den Maximalwert gesetzt. Wenn wir den Schwellenwert erhöhen, bleibt die Wahr-Positiv-Rate gleich, aber die Falsch-Positiv-Rate steigt. Daher gelten an jedem Punkt der ROC-Kurve eine höhere Richtig-Positiv-Rate und eine niedrige Falsch-Positiv-Rate als bessere Leistung als eine höhere Falsch-Positiv-Rate.

Techniken für ROC-Kurven

Es gibt verschiedene Techniken zum Zeichnen von ROC-Kurven in Python. Hier sind einige allgemeine Tipps:

1. Verwenden Sie die Scikit-learn-Bibliothek

Scikit-learn bietet praktische Funktionen zur Berechnung der True- und False-Positive-Ausgaben unter Festlegung verschiedener Schwellenwerte und gibt die Ergebnisse der False-Positive-Rate und der True-Positive-Rate zurück. Sobald wir diese Ausgaben haben, können wir sie als ROC-Kurven visualisieren. Hier ist ein Beispiel für die Berechnung und Darstellung einer ROC-Kurve mithilfe der Scikit-learn-Bibliothek:

from sklearn.metrics import roc_curve
from sklearn.metrics import auc

fpr, tpr, thresholds = roc_curve(y_test, y_pred_prob)
roc_auc = auc(fpr, tpr)

plt.figure()
plt.plot(fpr, tpr, color='darkorange', lw=2, label='ROC curve (area = %0.2f)' % roc_auc)
plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('False Positive Rate')
plt.ylabel('True Positive Rate')
plt.title('Receiver Operating Characteristic (ROC) Curve')
plt.legend(loc="lower right")
plt.show()

In diesem Beispiel gehen wir davon aus, dass wir einen binären Klassifikator angepasst und die Wahrscheinlichkeiten mithilfe des Testsatzes berechnet haben. y_test ist die Klassifizierungsbezeichnung der Testdaten und y_pred_prob ist die vom Klassifikator vorhergesagte Wahrscheinlichkeit. In diesem Beispiel werden fpr und tpr berechnet und die auc-Funktion in Scikit-learn verwendet, um die Fläche unter der ROC-Kurve zu berechnen. Wir können Matplotlib verwenden, um die ROC-Kurve zu zeichnen. Das Diagramm zeigt die Richtig-Positiv-Rate auf der Y-Achse und die Falsch-Positiv-Rate auf der X-Achse.

2. Benutzerdefinierte Darstellung mithilfe der Matplotlib-Bibliothek

Wenn Sie das Erscheinungsbild der ROC-Kurve noch weiter anpassen möchten, können Sie mit Matplotlib Ihr eigenes Diagramm erstellen. Hier ist ein Beispiel, das zeigt, wie man mit Matplotlib eine ROC-Kurve zeichnet:

import numpy as np
import matplotlib.pyplot as plt

# Generate some data
N      = 50
x_true = np.random.randn(N)
x_false= np.random.randn(N)

# Add some noise
x_true = x_true + np.random.randn(N) * 0.3
x_false= x_false + np.random.randn(N) * 0.3

# Create labels and predictions
y_true = np.ones(N)
y_false= np.zeros(N)
y_pred = np.concatenate([x_true, x_false])
y_true = np.concatenate([y_true, y_false])

# Determine threshold for each point
thresholds = np.sort(y_pred)
tpr_all    = []
fpr_all    = []
for threshold in thresholds:
    y_pred_bin = (y_pred >= threshold).astype(int)
    tn, fp, fn, tp = confusion_matrix(y_true, y_pred_bin).ravel()
    tpr = tp / (tp + fn)
    fpr = fp / (fp + tn)
    tpr_all.append(tpr)
    fpr_all.append(fpr)    

plt.figure()
plt.plot(fpr_all, tpr_all)
plt.plot([0, 1], [0, 1], '--', color='grey')
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("ROC Curve")
plt.show()

In diesem Beispiel haben wir zunächst einige simulierte Daten generiert und sie dann durch Hinzufügen von Rauschen realistischer gemacht. Als Nächstes erstellten wir Beschriftungen und Vorhersagen für die kombinierten Daten und berechneten die Wahr- und Falsch-Positiv-Raten und Schwellenwerte für jeden Punkt. Schließlich verwenden wir Matplotlib, um die ROC-Kurve zu zeichnen. Dieses Beispiel veranschaulicht, wie Sie mithilfe der Python-Programmierung eine ROC-Kurve zeichnen und zeigt außerdem, wie Sie ein benutzerdefiniertes Diagramm zeichnen.

Fazit

ROC-Kurve ist ein wichtiges Instrument zur Bewertung der Leistung eines Klassifikators. In Python können ROC-Kurven sowohl mit den Bibliotheken Scikit-learn als auch Matplotlib gezeichnet werden. Scikit-learn bietet praktische Funktionen zur Berechnung von ROC-Kurven, während Matplotlib hochgradig anpassbare Zeichenwerkzeuge bereitstellt. Die beschriebenen Beispiele veranschaulichen zwei Techniken zum Zeichnen von ROC-Kurven. Unabhängig davon, ob Sie Bibliotheksfunktionen oder benutzerdefinierte Diagramme verwenden möchten, können diese Techniken bei der Bewertung der Leistung eines Klassifikators für reale Daten hilfreich sein.

Das obige ist der detaillierte Inhalt vonROC-Kurventipps in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!