Wie bewerten Sie die Leistung eines maschinellen Lernmodells in Python?

Auswählen geeignete Bewertungsindikatoren: Die Klassifizierungsaufgabe verwendet Genauigkeit, Genauigkeit, Rückruf, F1-Score, ROC-AuC und Verwirrungsmatrix, und die Regressionsaufgabe verwendet Mae, MSE, RMSE und R². 2. Verwenden Sie Scikit-Learn, um die Indikatoren zu berechnen, und implementieren Sie die Bewertung des Klassifizierungs- und Regressionsmodells durch Funktionen im sklearn.metrics-Modul; 3.. Verwenden Sie die Quervalidierung (wie Cross_val_Score), um eine robustere Leistungsbewertung durchzuführen, um Abweichungen zu vermeiden, die durch einzelne Teilung verursacht werden. 4. visualisieren Sie optional die Modellleistung durch ROC -Kurven und Verwirrungsmatrix -Thermogramme; Der Schlüssel zur Bewertung des Modells besteht darin, geeignete Indikatoren basierend auf dem Problem auszuwählen und Kreuzvalidierung und visuelle umfassende Analyse zu kombinieren, um den Modelleffekt genau zu beurteilen und falsche Schlussfolgerungen zu vermeiden, die durch den Missbrauch von Indikatoren verursacht werden.

Bei der Bewertung der Leistung eines maschinellen Lernens in Python beinhaltet die Auswahl der richtigen Metriken und Tools basierend auf der Art des Problems-der Klassifizierung, der Regression oder anderer-und der Verwendung von Bibliotheken wie scikit-learn um sie zu berechnen. Hier erfahren Sie, wie man es effektiv macht.

1. Wählen Sie die richtigen Bewertungsmetriken aus

Der erste Schritt ist die Auswahl geeigneter Metriken basierend auf Ihrer Aufgabe:

Für Klassifizierungsaufgaben:

• Genauigkeit : Anteil der korrekten Vorhersagen. Gut, wenn der Unterricht ausgeglichen ist.
• Präzision, Rückruf, F1-Score : Informativer für unausgeglichene Datensätze.
  • Präzision : Wie viele sind von allen vorhergesagten positiven positiven positiven Positiven?
  • Rückruf (Empfindlichkeit) : Wie viele wurden von allen tatsächlichen positiven Positiven richtig vorhergesagt?
  • F1-Score : Harmonische Mittel zur Präzision und Rückruf.
• ROC-AuC : misst, wie gut ein Modell Vorhersagen einräumt; Nützlich für die binäre Klassifizierung mit Wahrscheinlichkeitsausgaben.
• Verwirrungsmatrix : zeigt wahre Positive, falsch positive Aspekte usw. für eine detaillierte Analyse.

Für Regressionsaufgaben:

• Mittlerer absoluter Fehler (MAE) : Durchschnittliche absolute Differenz zwischen vorhergesagten und tatsächlichen Werten.
• Mittlerer quadratischer Fehler (MSE) : Bestrafte größere Fehler.
• Root Mean Squared Fehler (RMSE) : MSE auf der ursprünglichen Skala.
• R² (R-Quadrat) : Anteil der durch das Modell erklärten Variation (näher an 1 ist besser).

2. Verwenden Sie Scikit-Learn, um Metriken zu berechnen

Sobald Ihr Modell trainiert und Vorhersagen getätigt werden, verwenden Sie sklearn.metrics :

Beispiel: Klassifizierung

 Aus sklearn.model_selection importieren train_test_split
aus sklearn.ensemble import randomforestclassifierer
von sklearn.metrics importieren Sie Accuracy_Score, precision_recall_fscore_support, ROC_AUC_SCORE, Confusion_Matrix
von sklearn.datasets import make_classification

# Beispieldaten generieren
X, y = make_classification (n_samples = 1000, n_features = 10, n_classeses = 2, random_state = 42)
X_train, x_test, y_train, y_test = train_test_split (x, y, test_size = 0.3, random_state = 42)

# Zugmodell
Modell = RandomforestClassifier (Random_State = 42)
model.fit (x_train, y_train)
y_pred = model.predict (x_test)
y_prob = model.Predict_Proba (x_test) [:, 1] # Wahrscheinlichkeit für die positive Klasse

# Auswerten
accuracy = accuracy_score (y_test, y_pred)
Präzision, Rückruf, F1, _ = precision_recall_fscore_support (y_test, y_pred, durchschnitt = 'binär')
AUC = ROC_AUC_SCORE (y_test, y_prob)
cm = confusion_matrix (y_test, y_pred)

print (f "Genauigkeit: {Genauigkeit: .3f}")
print (f "precision: {precision: .3f}, rechnen Sie: {rechnen: .3f}, f1: {f1: .3f}")
print (f "roc-auc: {auc: .3f}")
print ("Verwirrungsmatrix:")
Druck (cm)

Beispiel: Regression

 von sklearn.ensemble import randomforestregressor
von sklearn.metrics import Mean_absolute_error, messine_squared_error, r2_score
von sklearn.datasets import make_regression

# Beispieldaten generieren
X, y = make_regression (n_samples = 1000, n_features = 5, rauschen = 0,1, random_state = 42)
X_train, x_test, y_train, y_test = train_test_split (x, y, test_size = 0.3, random_state = 42)

# Zugmodell
reg_model = randomforestregressor (random_state = 42)
reg_model.fit (x_train, y_train)
y_pred = reg_model.predict (x_test)

# Auswerten
mae = Mean_absolute_error (y_test, y_pred)
MSE = Mean_Squared_error (y_test, y_pred)
RMSE = MSE ** 0.5
r2 = r2_score (y_test, y_pred)

print (f "mae: {mae: .3f}")
print (f "mse: {mse: .3f}")
print (f "rmse: {rmse: .3f}")
print (f "r²: {r2: .3f}")

3.. Kreuzvalidierung für eine robuste Bewertung

Verwenden Sie anstelle eines einzelnen Zugtests eine Kreuzvalidierung, um eine zuverlässigere Schätzung zu erhalten:

 von sklearn.model_selection import cross_val_score

# Zur Klassifizierung
cv_accuracy = cross_val_score (Modell, x, y, cv = 5, Scoring = 'Genauigkeit')
print (f "CV-Genauigkeit: {cv_accuracy.mean () :. 3f} ( /- {cv_accuracy.std () * 2: .3f})")

# Für die Regression
cv_r2 = cross_val_score (reg_model, x, y, cv = 5, Scoring = 'R2')
print (f "cv r²: {cv_r2.mean () :. 3f} ( /- {cv_r2.std () * 2: .3f})")

Häufige Bewertungsoptionen: 'accuracy' , 'precision' , 'recall' , 'f1' , 'roc_auc' , 'r2' , 'neg_mean_squared_error' , usw.

Visualisieren Sie die Leistung (optional, aber hilfreich)

• ROC -Kurve :

  aus sklearn.metrics importieren Sie ROC_CURVE
  matplotlib.pyplot als pLT importieren

fpr, tpr, _ = roc_curve(y_test, y_prob) plt.plot(fpr, tpr, label=f"ROC Curve (AUC = {auc:.2f})") plt.plot([0, 1], [0, 1], 'k--') plt.xlabel("False Positive Rate") plt.ylabel("True Positive Rate") Plt.title ("ROC -Kurve") plt.Legend () plt.show ()

- ** Verwirrungsmatrix Heatmap **:
`` `Python
Importieren Sie Seeborn als SNS
sns.heatmap (cm, Annot = true, fmt = 'd', cmap = 'Blues')
PLT.TITLE ("Verwirrungsmatrix")
Plt.ylabel ("tatsächlich")
pt.xlabel ("vorhergesagt")
Plt.Show ()

Grundsätzlich ist die Bewertung eines Modells in Python auf:

• Auswahl der richtigen Metrik für Ihr Problem,
• Verwenden von scikit-learn -Funktionen, um es zu berechnen,
• Validierung mit Kreuzvalidierung,
• Und optional visualisierende Ergebnisse.

Es ist nicht kompliziert, aber die Auswahl der falschen Metrik (z.

Das obige ist der detaillierte Inhalt vonWie bewerten Sie die Leistung eines maschinellen Lernmodells in Python?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!