2. Multivariate Analyse in Python 6-3. Ridge-Regression / Lasso-Regression (Scikit-Learn) [Funktionsweise der Regularisierung]

Ich möchte die Unterschiede in der Wirksamkeit der Regularisierung für die Ridge-Regression und die Lasso-Regression genauer untersuchen.
Generieren Sie 50 Regularisierungsparameter $ λ $ und wiederholen Sie die Schätzung 50 Mal, wobei Sie $ λ $ für jedes Regressionsmodell austauschen.
Beobachten Sie dabei, wie sich der geschätzte Koeffizient für jede Variable ändert.

⑴ Bibliothek importieren

#Datenverarbeitungs- / Berechnungs- / Analysebibliothek
import numpy as np
import pandas as pd

#Grafikzeichnungsbibliothek
import matplotlib.pyplot as plt
%matplotlib inline

#Bibliothek für maschinelles Lernen
import sklearn
from sklearn.linear_model import Ridge, Lasso #Klasse zur Generierung von Regressionsmodellen

#Ein Modul, das matplotlib mit dem japanischen Display kompatibel macht
!pip install japanize-matplotlib
import japanize_matplotlib

⑵ Datenerfassung und Lesen

#Daten bekommen
url = 'https://raw.githubusercontent.com/yumi-ito/sample_data/master/ridge_lasso_50variables.csv'

#Lesen Sie die erfassten Daten als DataFrame-Objekt
df = pd.read_csv(url)

print(df)

In diesen Dummy-Daten ist die 0. Spalte die Zielvariable y, und die 1. und nachfolgende erklärende Variable in der Spalte sind insgesamt 50. Die Anzahl der Proben beträgt 150.
Da es bereits standardisiert wurde, hat jede Variable einen Durchschnitt von 0 und eine Standardabweichung von 1.
Auch die Zielvariable y, die absichtlich erstellt wurde. Sie wird berechnet, indem der korrekte Koeffizient der ersten Variablen x_1 auf "5" gesetzt und das Rauschen hinzugefügt wird, das der Normalverteilung folgt. Ob die richtige Antwort "5" geschätzt werden kann oder nicht, ist ebenfalls ein Problem.

#Erstellen Sie eine erklärende Variable x, indem Sie die Spalte "y" löschen
x = df.drop('y', axis=1)

#Extrahieren Sie die Spalte "y", um die Zielvariable y zu erstellen
y = df['y']

(3) Erzeugung des Regularisierungsparameters λ

# λ(alpha)Generieren Sie 50 Wege
num_alphas = 50
alphas = np.logspace(-2, 0.7, num_alphas)

print(alphas)

numpy.logspace () ist eine Funktion mit einer Wendung, die ** eine logarithmische Basis von 10 annimmt und zu einer Sequenz gleicher Differenz ** wird.
Geben Sie im Argument "(Startwert, Endwert, zu generierende Zahl)" an. Wenn Sie jedoch den Logarithmus tatsächlich verwenden, lautet dieser wie folgt.

np.log10(alphas)

Startwert -2, Endwert 0,7, alle 50 Spalten mit gleicher Differenznummer.
Wenn es sich um eine Sequenz mit gleicher Differenz handelt, scheint numpy.arange () gut zu sein, aber ich mache das, weil es notwendig ist, ** log scale ** zu verwenden, wenn ich später visualisiere.

Logistische Skala

Der Wert der logarithmischen Skala verdoppelt sich für jede Skala. Ein logarithmischer Graph verwendet entweder die x-Achse, die y-Achse oder beide Achsen.
Gewöhnliche Skalen werden lineare Skalen genannt, aber wenn Sie sie in logarithmische Skalen konvertieren ...
Da es sich anfühlt, als ob die Achsenskala auf der geraden Linie der Zahl eng komprimiert ist, ist es einfacher, Daten visuell zu vergleichen, die in der Anzahl der Stellen weit voneinander entfernt sind.

⑷ Schätzung durch Gratregression

#Variable, die den Regressionskoeffizienten speichert
ridge_coefs = []

#Wiederholen Sie die Schätzung der Gratregression, während Sie Alpha austauschen
for a in alphas:
    ridge = Ridge(alpha = a, fit_intercept = False)
    ridge.fit(x, y)
    ridge_coefs.append(ridge.coef_)

Wiederholen Sie die Schätzung der Gratregression, während Sie "alpha" austauschen, und fügen Sie den Regressionskoeffizienten zu "ridge_coefs" hinzu.
Das Argument fit_intercept = False von Ridge (), das das Modell des Modells generiert, gibt an, ob der Abschnitt berechnet werden soll. Wenn es auf False gesetzt ist, wird der Abschnitt nicht berechnet, dh der Abschnitt 0 durchläuft immer den Ursprung. Wird sein.

#Konvertieren Sie die akkumulierten Regressionskoeffizienten in ein Numpy-Array
ridge_coefs = np.array(ridge_coefs)

print("Arrangementform:", ridge_coefs.shape)
print(ridge_coefs)

In einem 50 x 50-Array werden für jeden Parameter 50 Sätze mit 50 Koeffizienten erhalten.
Visualisiere das. Platzieren Sie die Parameter auf der x-Achse, verwenden Sie jedoch "log_alphas", eine logarithmische Konvertierung von "Alphas" und "Minus".
Die Funktion plt.text (), die Text im Diagramm anzeigt, verwendet (x, y," str ") als Argumente, um Koordinaten und Zeichenfolgen anzugeben.

#Protokollkonvertierung von Alphas(-log10)
log_alphas = -np.log10(alphas)

#Festlegen der Größe des Diagrammbereichs
plt.figure(figsize = (8,6))

#Ein gestrichelter Liniendiagramm mit λ auf der x-Achse und Koeffizienten auf der y-Achse
plt.plot(log_alphas, ridge_coefs)

#Erklärende Variable x_Show 1
plt.text(max(log_alphas) + 0.1, np.array(ridge_coefs)[0,0], "x_1", fontsize=13)

#Geben Sie den x-Achsenbereich an
plt.xlim([min(log_alphas) - 0.1, max(log_alphas) + 0.3])

#Achsenbeschriftung
plt.xlabel("Regularisierungsparameter λ(-log10)", fontsize=13)
plt.ylabel("Regressionskoeffizienten", fontsize=13)

#Linie skalieren
plt.grid()

Da die x-Achse $ -log_ {10} $ ist, erhöht sich der Wert des Regularisierungsparameters $ λ $, wenn Sie sich nach links bewegen, und die Strafe wird stärker.
Da die Zielvariable y basierend auf der erklärenden Variablen x_1 generiert wird, zeigt nur die Variable x_1 die Linearität für sich.
Der Absolutwert des Koeffizienten ist zur linken Seite hin kleiner und die Strafe zur rechten Seite hin weniger, so dass ersichtlich ist, dass der Koeffizient mit einem größeren Absolutwert eher geschätzt wird.

⑸ Schätzung durch Lasso-Regression

Wiederholen Sie die Schätzung der Lasso-Regression 50 Mal unter Verwendung der gleichen Regularisierungsparameter (Alphas) wie die Ridge-Regression.

#Variable, die den Regressionskoeffizienten speichert
lasso_coefs = []

#Wiederholen Sie die Schätzung der Lasso-Regression, während Sie Alpha austauschen
for a in alphas:
    lasso = Lasso(alpha = a, fit_intercept = False)
    lasso.fit(x, y)
    lasso_coefs.append(lasso.coef_)

#Konvertieren Sie die akkumulierten Regressionskoeffizienten in ein Numpy-Array
lasso_coefs = np.array(lasso_coefs)

print("Arrangementform:", lasso_coefs.shape)
print(lasso_coefs)

Zeichnen Sie auf ähnliche Weise ein Einwegdiagramm mit der x-Achse von $ -log_ {10} $.

#Festlegen der Größe des Diagrammbereichs
plt.figure(figsize = (8,6))

#Ein gestrichelter Liniendiagramm mit λ auf der x-Achse und Koeffizienten auf der y-Achse
plt.plot(log_alphas, lasso_coefs)

#Erklärende Variable x_Show 1
plt.text(max(log_alphas) + 0.1, np.array(lasso_coefs)[0,0], "x_1", fontsize=13)

#Geben Sie den x-Achsenbereich an
plt.xlim([min(log_alphas) - 0.1, max(log_alphas) + 0.3])

#Achsenbeschriftung
plt.xlabel("Regularisierungsparameter λ(-log10)", fontsize=13)
plt.ylabel("Regressionskoeffizienten", fontsize=13)

#Linie skalieren
plt.grid()

Mit Ausnahme der Variablen x_1 beträgt der Koeffizient fast 0.
Bei anderen Variablen sind Koeffizienten ungleich Null in der Nähe des schwächsten Parameters ganz rechts leicht zu sehen.

Zusammenfassung

** Ridge-Regression ** tendiert dazu, für eine Reihe von Variablen insgesamt einen kleinen absoluten Koeffizienten zu schätzen. ** Lasso-Regression ** neigt dazu, ** teilweise Koeffizienten ungleich Null für eine kleine Anzahl von Variablen zu haben und alle anderen Koeffizienten sind 0 **.
Bei der Lasso-Regression sind die meisten Koeffizienten 0, sodass gesagt werden kann, dass dies der Berechnung des Regressionskoeffizienten und der gleichzeitigen Reduzierung der Dimension entspricht.