[PYTHON] Ridge Return (für Anfänger) -Code Edition-

Dieses Mal werde ich die Implementierung (den Code) der Ridge-Regression zusammenfassen.

■ Ridge-Regressionsverfahren

Fahren Sie mit den nächsten 7 Schritten fort.

1. Vorbereitung des Moduls
2. Datenaufbereitung
3. Suchen Sie nach Parametern
4. Erstellen Sie ein Modell
5. Berechnung des vorhergesagten Wertes
6. Restgrundstück
7. Modellbewertung

1. Vorbereitung des Moduls

Importieren Sie zunächst die erforderlichen Module.

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

#Modul zum Lesen des Datensatzes
from sklearn.datasets import load_boston

#Modul, das Trainingsdaten und Testdaten trennt
from sklearn.model_selection import train_test_split

#Modul zur Standardisierung (verteilte Normalisierung)
from sklearn.preprocessing import StandardScaler

#Modul zur Suche nach Parametern (Alpha)
from sklearn.linear_model import RidgeCV

#Modul zum Zeichnen von Parametern (Alpha)
from yellowbrick.regressor import AlphaSelection

#Modul, das die Ridge-Regression durchführt (Minimum-Square-Methode + L2-Regularisierungsterm)
from sklearn.linear_model import Ridge

#Boston-Datensatz lesen
boston = load_boston()

#Teilen Sie in objektive Variable und erklärende Variable
X, y = boston.data, boston.target

#Standardisierung (verteilte Normalisierung)
SS = StandardScaler()
X = SS.fit_transform(X)

#Teilen Sie in Trainingsdaten und Testdaten
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state=123)

Bei der Standardisierung beispielsweise wird der Einfluss der letzteren groß, wenn es zweistellige und vierstellige Merkmalsgrößen (erklärende Variablen) gibt. Die Skala wird ausgerichtet, indem der Durchschnitt für alle Merkmalsgrößen auf 0 und die Varianz auf 1 gesetzt wird.

In random_state ist der Startwert so festgelegt, dass das Ergebnis der Datenteilung jedes Mal das gleiche ist.

3. Suchen Sie nach Parametern

Die Ridge-Regression fügt der Gleichung der kleinsten Quadrate einen Regularisierungsterm hinzu, um ein Übertraining zu vermeiden. Durch Erhöhen des Alphas wird die Regularisierung stärker und durch Verringern wird sie schwächer.

An den Trainingsdaten werden eine Rastersuche und eine Kreuzvalidierung durchgeführt, um das optimale Alpha zu finden.

#Stellen Sie das Suchintervall für den Parameter (Alpha) ein.
alphas = np.logspace(-10, 1, 500)

#Überprüfen Sie die Trainingsdaten gegenseitig, um das optimale Alpha zu finden
ridgeCV = RidgeCV(alphas = alphas)

#Plot Alpha
visualizer = AlphaSelection(ridgeCV)
visualizer.fit(X_train, y_train)

visualizer.show()
plt.show()

Ausgabeergebnis
Aus dem Obigen wurde das optimale Alpha = 8,588 gefunden.

4. Erstellen Sie ein Modell

Wir werden ein Modell der Ridge-Regression unter Verwendung des zuvor erhaltenen Parameters (Alpha) erstellen.

#Erstellen Sie eine Instanz der Ridge-Regression
ridge = Ridge(alpha = 8.588)

#Generieren Sie ein Modell aus Trainingsdaten (Minimum-Square-Methode + Regularisierungsterm)
ridge.fit(X_train, y_train)

#Ausgabeabschnitt
print(ridge.intercept_)

#Ausgangsregressionskoeffizient (Gradient)
print(ridge.coef_)

Ausgabeergebnis

lr.intercept_: 22.564747201001634

lr.coef_: [-0.80818323  0.81261982  0.24268597  0.10593523 -1.39093785  3.4266411
 -0.23114806 -2.53519513  1.7685398  -1.62416829 -1.99056814  0.57450373
 -3.35123162]

lr.intercept_: section (Gewicht $ w_0 $) lr.coef_: Regressionskoeffizient / Gradient (Gewicht $ w_1 $ ~ $ w_ {13} $)

Daher wurde ein konkreter numerischer Wert in der Modellformel (Rückgabeformel) erhalten.

$ y = w_0 + w_1x_1+w_2x_2+ \cdots + w_{12}x_{12} + w_{13}x_{13}$

5. Berechnung des vorhergesagten Wertes

Fügen Sie die Testdaten (X_test) in die erstellte Modellformel ein und ermitteln Sie den vorhergesagten Wert (y_pred).

y_pred = lr.predict(X_test)
y_pred

Ausgabeergebnis

y_pred: [15.25513373 27.80625237 39.25737057 17.59408487 30.55171547 37.48819278
 25.35202855 ..... 17.59870574 27.10848827 19.12778747 16.60377079 22.13542152]

Rest: Differenz zwischen vorhergesagtem Wert und korrektem Antwortwert (y_pred --y_test)

#Erstellen von Zeichnungsobjekten und Nebenhandlungen
fig, ax = plt.subplots()

#Restgrundstück
ax.scatter(y_pred, y_pred - y_test, marker = 'o')

# y =Zeichnen Sie die rote Gerade von 0
ax.hlines(y = 0, xmin = -10, xmax = 50, linewidth = 2, color = 'red')
 
#Stellen Sie die Achsenbeschriftung ein
ax.set_xlabel('y_pred')
ax.set_ylabel('y_pred - y_test')

#Grafiktitel hinzugefügt
ax.set_title('Residual Plot')

plt.show()

Ausgabeergebnis

Die Daten sind oberhalb und unterhalb der roten Linie gut ausbalanciert (y_pred --y_test = 0). Es kann bestätigt werden, dass die Ausgabe des vorhergesagten Werts keine große Verzerrung aufweist.

7. Modellbewertung

Dieses Mal werden wir anhand des Bestimmungskoeffizienten bewerten.

#Punktzahl für Trainingsdaten
print(ridge.score(X_train, y_train))

#Punktzahl gegen Testdaten
print(ridge.score(X_test, y_test))

Ausgabeergebnis

Train Score: 0.763674626990198
Test Score: 0.6462122981958535

Dieses Mal habe ich für Anfänger nur die Implementierung (Code) zusammengefasst. Mit Blick auf das Timing in der Zukunft möchte ich einen Artikel über Theorie (mathematische Formel) schreiben.

Danke fürs Lesen.

Referenzen: Neues Lehrbuch zur Datenanalyse mit Python (Hauptlehrmaterial für den Test zur Analyse der Zertifizierung von Python 3-Ingenieuren)