[PYTHON] Visualisieren Sie die Auswirkungen von Deep Learning / Regularisierung

1. Zuallererst

Ich fing an, tiefes Lernen zu studieren. Dieses Mal werde ich die Regularisierung kurz zusammenfassen.

2. Datenerstellung

Basierend auf der Gleichung $ y = -x ^ 3 + x ^ 2 + x $ ist x der Wert, der durch Teilen von -10 bis 10 durch 50 erhalten wird, und y ist das Ergebnis des Einsetzens des x in die Gleichung und des Hinzufügens einer Zufallszahl von 0 bis 0,05. Erstellen Sie die Daten als Wert.

from sklearn.preprocessing import PolynomialFeatures
from sklearn import linear_model
import numpy as np
import matplotlib.pyplot as plt

#Datengenerierung
np.random.seed(0)
X = np.linspace(-10, 10, 50)
Y_truth = 0.001 * (-X **3 + X**2 + X)
Y = Y_truth + np.random.normal(0, 0.05, len(X))

plt.figure(figsize=(5, 5))
plt.plot(X, Y_truth, color='gray')
plt.plot(X, Y, '.', color='k')
plt.show()

Dies sind die erstellten Daten. Es wird angenommen, dass die durchgezogene Linie der wahre Wert (Wert der Gleichung) ist und der Punkt der tatsächlich beobachtete Wert ist (y plus Rauschen).

3. Einführung der Polypoly-Regression

Overlearning tritt mit zunehmendem Freiheitsgrad eher auf, daher wagen wir die Einführung einer 30-dimensionalen Polynomregression.

#Grafikanzeige
def graph(Y_lr, name):
    plt.figure(figsize=(6, 6))
    plt.plot(X, Y_truth, color='gray', label='truth')
    plt.plot(xs, Y_lr, color='r', markersize=2, label=name)
    plt.plot(X, Y, '.', color='k')
    plt.legend()
    plt.ylim(-1, 1)
    plt.show()

#Bildschirmeinstellungen
xs = np.linspace(-10, 10, 200)  

#Einführung der Polypoly-Regression
poly = PolynomialFeatures(degree=30, include_bias=False)  
X_poly = poly.fit_transform(X[:, np.newaxis])   

Nach dem Einstellen der Diagrammanzeige und -anzeige werden PolynomialFeatures instanziiert und angepasst. Die Abmessung beträgt 30 Abmessungen (Grad = 30).

4. Keine Regularisierung

Führen Sie zunächst eine polymorphe Regression ohne Regularisierung durch.

#Keine Regularisierung
lr0 = linear_model.LinearRegression(normalize=True)
lr0.fit(X_poly, Y)
Y_lr0 = lr0.predict(poly.fit_transform(xs[:, np.newaxis]))
graph(Y_lr0, 'No Regularization')

Aufgrund seines hohen Freiheitsgrades mit einem 30-dimensionalen Polynom ist es möglich, viele Punkte geschickt zu durchlaufen, was zu einem typischen Überlernen führt. Es ist weit vom wahren Wert entfernt, und eine Generalisierungsleistung ist damit nicht zu erwarten.

5. L2-Regularisierung

Die L2-Regularisierung ist eine für die Ridge-Regression bekannte Technik, die den Koeffizienten begrenzt, damit er nicht zu groß wird, und die L2-Norm des Parameters zum Verlust hinzufügt (C ist eine Konstante). L(W)+c|w|^2

#L2-Regularisierung
lr2 = linear_model.Ridge(normalize=True, alpha=0.5)
lr2.fit(X_poly, Y)
Y_lr2 = lr2.predict(poly.fit_transform(xs[:, np.newaxis]))
graph(Y_lr2, 'L2')

Nun, ich habe das Gefühl, dass ich gut zurückkehren konnte.

6. L1-Regularisierung

Die L1-Regularisierung ist eine für die Lasso-Regression bekannte Technik, die auch den Koeffizienten begrenzt, damit er nicht zu groß wird, indem die L1-Norm des Parameters zum Verlust addiert wird (C ist eine Konstante). L(W)+c|w|

#L1-Regularisierung
lr1 = linear_model.LassoLars(normalize=True, alpha=0.001)
lr1.fit(X_poly, Y)
Y_lr1 = lr1.predict(poly.fit_transform(xs[:, np.newaxis]))
graph(Y_lr1, 'L1')

Die Form kommt einer perfekten Passform sehr nahe. Im Vergleich zur L1-Regularisierung scheint die L2-Regularisierung besser zurückkehren zu können.

7. Vergleich der Dimensionskoeffizienten

Vergleichen Sie 30 dimensionale Koeffizienten für keine Regularisierung, L2-Regularisierung und L1-Regularisierung (angeordnet von der niedrigsten Dimension).

import pandas as pd
result = []
for i in range(len(lr0.coef_)):
      tmp = lr0.coef_[i], lr2.coef_[i], lr1.coef_[i]
      result.append(tmp)
df = pd.DataFrame(result)
df.columns = ['No Regularization', 'L2', 'L1']
print(df)

Sie können sehen, dass L2 einen kleineren Koeffizienten als No Regularization hat. L1 ist auch ein Ausdruck (spärlicher Ausdruck) mit vielen vollständig 0 Punkten.

Ich bin froh, dass die L1-Regularisierung Überlernen unterdrücken und Dimensionen reduzieren kann.