[PYTHON] Versuchen Sie, die Leistung des Modells für maschinelles Lernen / Regression zu bewerten

1. Zuallererst

Dieses Mal werde ich die Leistung des Regressionsmodells bewerten, das für maschinelles Lernen beim Schreiben des Codes verwendet wird.

2. Datensatz

Der verwendete Datensatz ist der Boston-Eigenheimpreis, der mit sklearn geliefert wird.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_boston
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression,Ridge
from sklearn.tree import DecisionTreeRegressor
from sklearn.ensemble import RandomForestRegressor,GradientBoostingRegressor
from sklearn.pipeline import Pipeline
from sklearn.metrics import r2_score
from sklearn.model_selection import cross_val_score
from sklearn.utils import shuffle

# --------Datensatz laden---------
dataset = load_boston()
X = pd.DataFrame(dataset.data, columns=dataset.feature_names)
y = pd.Series(dataset.target, name='y')
print('X.shape = ', X.shape)
print(X.join(y).head())

Die Daten sind insgesamt 506, die Merkmalsmenge beträgt 13 Artikel und y ist der Zielhauspreis.

3. Regressionsmodell

Diesmal werden fünf Regressionsmodelle verwendet. Später werden wir es zur Vereinfachung der Verwendung in Form einer Pipeline zusammenstellen. Hyperparameter sind die Standardeinstellung.

# ----------Pipeline-Einstellungen-----------
pipelines = {
  '1.Linear': Pipeline([('std',StandardScaler()),
                        ('est',LinearRegression())]),
     
  '2.Ridge' : Pipeline([('std',StandardScaler()),
                        ('est',Ridge(random_state=0))]),

  '3.Tree'  : Pipeline([('std',StandardScaler()),
                        ('est',DecisionTreeRegressor(random_state=0))]),

  '4.Random': Pipeline([('std',StandardScaler()),
                        ('est',RandomForestRegressor(random_state=0, n_estimators=100))]),  
     
  '5.GBoost': Pipeline([('std',StandardScaler()),
                        ('est',GradientBoostingRegressor(random_state=0))])
}

1.Linear ** Lineares Regressionsmodell (linear) ** unter Verwendung der Methode der kleinsten Quadrate.

2.Ridge Es handelt sich um ein ** Ridge-Regressionsmodell (Ridge) **, das das Übertraining unterdrückt, indem dem linearen Regressionsmodell L2-Regularisierungselemente hinzugefügt werden.

3.Tree Dies ist ein Regressionsmodell, das auf dem ** Entscheidungsbaum ** basiert.

4.Random Es ist ** Random Forest **, der aus zufällig ausgewählten Features mehrere Entscheidungsbäume erstellt und die Vorhersagen aller Entscheidungsbäume im Durchschnitt ausgibt.

5.GBoost ** Gradient Boosting **, das die Vorhersagegenauigkeit verbessert, indem nachfolgende Bäume Informationen (Residuen) erklären können, die von vorhandenen Baumgruppen nicht erklärt werden können.

4. Bewertungsindex

Verwenden Sie ** R2_score ** als Fehlerindex. Dies ist, um wie viel der vorhergesagte und gemessene quadratische Fehler Σ kleiner gemacht werden kann als der gemessene und gemessene durchschnittliche quadratische Fehler Σ.

Wenn die Vorhersage alle mit der tatsächlichen Messung übereinstimmt, kann der Index 1 sein, und wenn die Vorhersage zu schlecht ist, kann der Index negativ sein.

5. Holdout-Methode

Zunächst wird die Holdout-Methode durchgeführt, bei der es sich um eine allgemeine Methode zur Bewertung der Leistung eines Modells handelt. Die Generalisierungsleistung wird untersucht, indem die Daten in ** Trainingsdaten unterteilt werden: Testdaten = 8: 2 **, Training mit den Trainingsdaten und anschließende Auswertung mit unbekannten Testdaten.

# -----------Holdout-Methode-----------
X_train,X_test,y_train,y_test = train_test_split(X, y, test_size=0.20, random_state=1)  

scores = {}
for pipe_name, pipeline in pipelines.items():
    pipeline.fit(X_train, y_train)
    scores[(pipe_name,'train')] = r2_score(y_train, pipeline.predict(X_train))
    scores[(pipe_name,'test')] = r2_score(y_test, pipeline.predict(X_test))
print(pd.Series(scores).unstack())

Als Ergebnis der Auswertung mit unbekannten Testdaten war ** 5.GBoost ** am genauesten (0,924750).

In den Trainingsdaten wird der genaueste (1.0000) ** 3.Tree ** in den Testdaten deutlich auf (0.821282) zurückgesetzt, was darauf hinweist, dass er in Übertraining geraten ist.

** 2.Ridge ** sollte eine verbesserte Version von ** 1.Linear ** sein, aber die Testdaten zeigen eine leichte Umkehrung der Genauigkeit. Dies liegt daran, dass die Genauigkeitsmessung nach der Holdout-Methode etwas variiert und wir die Leistung später nach der strengeren k-Fold-Methode vergleichen werden.

6. Restgrundstück

Restdiagramme werden erstellt, um die Modellleistung zu visualisieren. Dies zeichnet Trainingsdaten und Testdaten mit ** vorhergesagtem Wert ** auf der horizontalen Achse und ** Differenz zwischen vorhergesagtem Wert und tatsächlichem Wert ** auf der vertikalen Achse auf.

# -------------Restgrundstück------------
for pipe_name, est in pipelines.items():
    y_train_pred = est.predict(X_train)
    y_test_pred = est.predict(X_test)
    plt.scatter(y_train_pred, y_train_pred - y_train, c = 'blue', alpha=0.5, marker = 'o', label = 'train')
    plt.scatter(y_test_pred, y_test_pred - y_test, c = 'red', marker ='x', label= 'test' )
    plt.hlines(y = 0, xmin = 0, xmax = 50, color = 'black')
    plt.ylim([-20, 20])
    plt.xlabel('Predicted values')
    plt.ylabel('Residuals')        
    plt.title(pipe_name)
    plt.legend()
    plt.show()

Als Ausgabe des Codes werden 5 Residuen von 1.Linear bis 5.GBoost dargestellt, aber hier werden nur 3 typische Residuen angehoben.

** Lineares Regressionsmodell **. Sowohl die Trainingsdaten als auch die Testdaten weisen fast die gleiche Restvariation auf.

** Entscheidungsbaum **. Während die Trainingsdaten einen vollständigen Rest von Null aufweisen (Genauigkeit 100%), weisen die Testdaten eine große Restschwankung auf. Dies ist ein typisches Überlernen.

** Gradientenverstärkung **. Die Variation der Residuen wird sowohl in den Trainingsdaten als auch in den Testdaten unterdrückt.

7. k-hold-Methode

Die ** k-Hold-Methode ** (Überprüfung der k-Teilungskreuzung) ermöglicht eine strengere Modellbewertung als die Holdout-Methode.

Das spezifische Verfahren besteht darin, zuerst die Daten in k Teile zu teilen, sie einzeln auszuwählen, um Testdaten zu erstellen, und die verbleibenden k-1 Teile als Trainingsdaten zu verwenden.

Dann besteht die ** k-Hold-Methode ** darin, mit den Trainingsdaten zu trainieren, die Genauigkeitsmessung mit den Testdaten k-mal zu wiederholen und den Durchschnitt der erhaltenen Genauigkeit als Genauigkeit des Modells zu verwenden. Hier ist k = 5 (angegeben durch cv = 5)....

# -------------- k-Faltmethode--------------
X_shuffle, y_shuffle =shuffle(X, y, random_state= 1)  #Daten mischen

scores={}
for pipe_name, est in pipelines.items():  
    cv_results = cross_val_score(est, X_shuffle, y_shuffle, cv=5, scoring='r2')    
    scores[(pipe_name,'avg')] = cv_results.mean()
    scores[(pipe_name,'score')] = np.round(cv_results,5)  # np.rund ist die Zifferneinstellung
print(pd.Series(scores).unstack())

Die fünf Zahlen ** Punktzahl ** in [] neben ** Durchschnitt ** sind die jedes Mal berechnete Genauigkeit. Wenn Sie sich ** 1.Linear ** ansehen, können Sie sehen, dass es von ** Minimum 0,64681 bis Maximum 0,76342 ** variiert. Durch Mittelung dieser Zahlen wird eine strikte Modellbewertung durchgeführt.

Sie können sehen, dass ** 2.Ridge ** etwas genauer ist als ** 1.Linear **.

Letztendlich war das beste Modell für die Immobilienpreise in Boston ** 5.GBoost **.