Einführung

Ich habe Regularisierung als Entwicklung einer multiplen Regressionsanalyse studiert. Dieses Mal werde ich die Gratregression (L2-Regularisierung) zusammenfassen.

Referenz

Um die Gratregression (L2-Regularisierung) zu verstehen, bezog ich mich auf Folgendes.

Essenz des maschinellen Lernens Koichi Kato (Autor) Herausgeber; SB Creative Co., Ltd.
Arten und Zwecke der Regularisierung L1-Regularisierung L2-Regularisierung
Höfliche Theorie und Implementierung der Ridge- und Lasso-Regression von Anfang an

Übersicht über die Ridge-Regression (L2-Regularisierung)

Überprüfung der multiplen Regressionsanalyse

Die Ridge-Regression ist eine Verlustfunktion, wenn eine multiple Regressionsanalyse mit einem hinzugefügten Regularisierungsterm durchgeführt wird. Die multiple Regressionsanalyse leitet die optimale Regressionsgleichung ab, indem die Gewichte ermittelt werden, die die Verlustfunktion minimieren, z.

L = \sum_{n=1}^{n} (y_{n} -\hat{y}_{n} )^2

$ y_ {n} $ ist der gemessene Wert -Vorhergesagter Wert von $ \ hat {y} _ {n} $

In Vektorform ausgedrückt sieht es so aus.

L = (\boldsymbol{y}-X\boldsymbol{w})^T(\boldsymbol{y}-X\boldsymbol{w})

$ \ boldsymbol {y} $ ist ein Vektor der gemessenen Werte der Zielvariablen
$ \ boldsymbol {w} $ ist ein vektorisierter Regressionskoeffizient beim Erstellen einer multiplen Regressionsgleichung.
$ X $ ist eine Matrix von Messwerten erklärender Variablen mit $ n $ Anzahl von Stichproben und $ m $ Anzahl von Variablen.

Es ist in Ordnung, wenn das Gewicht $ \ boldsymbol {w} $ erhalten wird, das das obige $ L $ minimiert. Wenn das obige $ L $ durch $ \ boldsymbol {w} $ differenziert und als $ 0 $ festgelegt wird, ist dies wie folgt.

-2X^T\boldsymbol{y}+2\boldsymbol{w}X^TX = 0

Durch Lösen dieses Problems kann das Gewicht $ \ boldsymbol {w} $ erhalten werden.

Ridge-Regression (L2-Regularisierung)

L = (\boldsymbol{y} - X\boldsymbol{w})^T (\boldsymbol{y} - X\boldsymbol{w}) + \lambda|| \boldsymbol{w} ||_{2}

Das Obige ist die Gratregression(L2-Regularisierung)Es wird die Formel der Verlustfunktion von. Regularisierungsterm für die Verlustfunktion der multiplen Regressionsanalyse$\lambda|| \boldsymbol{w} ||_{2} $Es ist in Form von Hinzufügen. Die Ridge-Regression (L2-Regularisierung) wird durchgeführt, indem das Quadrat der L2-Norm des Gewichts $ \ boldsymbol {w} $ wie oben beschrieben addiert wird.

Was ist die L2-Norm?

Die Quadratwurzel der Summe der Quadrate der Differenz zwischen den Vektorkomponenten (der sogenannte "gewöhnliche Abstand", der euklidische Abstand) ist die L2-Norm. Die Norm ist ein Index, der "Größe" anzeigt, und andere L1-Normen und L∞-Normen werden verwendet.

Effekt der L2-Regularisierung

Durch Hinzufügen eines Regularisierungsterms zur Verlustfunktion wird die Größe des Gewichts $ \ boldsymbol {w} $ verringert. Für eine normale multiple Regressionsanalyse müssen nur folgende Begriffe minimiert werden: $(\boldsymbol{y} - X\boldsymbol{w})^T (\boldsymbol{y} - X\boldsymbol{w})$ Wenn hier eine Regularisierung hinzugefügt wird, muss diese einschließlich der folgenden Elemente minimiert werden. $\lambda|| \boldsymbol{w} ||_{2}$ Da das Gewicht $ \ boldsymbol {w} $ einen stärkeren Einfluss auf die Verlustfunktion hat, wird der Wert des Gewichts $ \ boldsymbol {w} $ verkleinert. Der Grad wird durch die Größe von $ \ lambda $ gesteuert.

Die folgende Abbildung wird häufig zur Erklärung der Gratregression (L2-Regularisierung) verwendet. Da es schwer zu verstehen ist, ob es so ist, wie es ist, wird in der Abbildung eine Erklärung hinzugefügt. Das Folgende ist eine zweidimensionale Darstellung der Konturlinien des Wertes der Verlustfunktion, wenn es zwei Arten von Gewichtsparametern gibt. In der Abbildung sehen Sie, wie der Gewichtswert durch Hinzufügen des Regularisierungsterms verringert wird.

図1.png

Ableitung von Gewichten für die Gratregression (L2-Regularisierung)

L = (\boldsymbol{y} - X\boldsymbol{w})^T (\boldsymbol{y} - X\boldsymbol{w}) + \lambda|| \boldsymbol{w} ||_{2}

Berechnen Sie, indem Sie die obige Verlustfunktion mit dem Gewicht $ \ boldsymbol {w} $ differenzieren und als $ 0 $ platzieren.

-2X^T\boldsymbol{y}+2\boldsymbol{w}X^TX+2\lambda\boldsymbol{w} = 0 \\
(X^TX+\lambda I)\boldsymbol{w} - X^T\boldsymbol{y} = 0 \\
(X^TX+\lambda I)\boldsymbol{w} = X^T\boldsymbol{y} \\
\boldsymbol{w} = (X^TX+\lambda I)^{-1}X^T\boldsymbol{y}

Hier konnten wir das Gewicht $ \ boldsymbol {w} $ ableiten.

Ridge-Regression implementieren (L2-Regularisierung)

Implementierung

Das Folgende ist das Ergebnis der Selbstimplementierung des Ridge-Regressionsmodells (L2-Regularisierung).


import numpy as np

class RidgeReg:

    def __init__(self, lambda_ = 1.0):
        self.lambda_ = lambda_
        self.coef_ = None
        self.intercept_ = None

    def fit(self, X, y):
        #Fügen Sie der ersten Zeile der erklärenden Variablenmatrix eine Spalte mit allen Werten 1 hinzu, um die Abschnittsberechnung einzuschließen
        X = np.insert(X, 0, 1, axis=1)
        #Erstellen Sie eine Einheitsmatrix
        i = np.eye(X.shape[1])
        #Berechnungsformel zur Berechnung des Gewichts
        temp = np.linalg.inv(X.T @ X + self.lambda_ * i) @ X.T @ y
        #Dies ist der Wert des Regressionskoeffizienten
        self.coef_ = temp[1:]
        #Dies ist der Abschnittswert
        self.intercept_ = temp[0]
        
    def predict(self, X):
        #Gibt den vom Ridge-Regressionsmodell vorhergesagten Wert zurück
        return (X @ self.coef_ + self.intercept_)

Überprüfung

Stellen Sie sicher, dass das oben selbst implementierte Modell mit den sklearn-Ergebnissen übereinstimmt. Dieses Mal werden wir anhand des Bostoner Immobilienpreisdatensatzes überprüfen. Einzelheiten zum Inhalt des Datensatzes finden Sie in Artikel zur Überprüfung der multiplen Regressionsanalyse.

Modell von sklearn

from sklearn.datasets import load_boston
import pandas as pd
from sklearn.preprocessing import StandardScaler

#Daten lesen
boston = load_boston()

#Einmal in das Pandas-Datenrahmenformat konvertiert
df = pd.DataFrame(boston.data, columns=boston.feature_names)

#Holen Sie sich die Zielvariable (Wert, den Sie erwarten möchten)
target = boston.target

df['target'] = target

from sklearn.linear_model import Ridge

X = df[['INDUS', 'CRIM']].values
X = StandardScaler().fit_transform(X)
y = df['target'].values

clf = Ridge(alpha=1)

clf.fit(X, y)

print(clf.coef_)
print(clf.intercept_)

Klicken Sie hier für die Ausgabe. Von oben sind die Regressionskoeffizienten und Abschnitte des Modells.

[-3.58037552 -2.1078602 ]
22.532806324110677

Selbstimplementiertes Modell

X = df[['INDUS', 'CRIM']].values
X = StandardScaler().fit_transform(X)
y = df['target'].values

linear = RidgeReg(lambda_ = 1)

linear.fit(X,y)

print(linear.coef_)
print(linear.intercept_)