Visualisez les effets de l'apprentissage profond / de la régularisation

1.Tout d'abord

J'ai commencé à étudier l'apprentissage profond. Cette fois, je résumerai brièvement la régularisation.

2. Création de données

Basé sur l'équation $ y = -x ^ 3 + x ^ 2 + x $, x est la valeur obtenue en divisant -10 à 10 par 50, et y est le résultat de la substitution de x dans l'équation et de l'ajout d'un nombre aléatoire de 0 à 0,05. Créez les données en tant que valeur.

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

#Génération de données
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()

Ce sont les données créées. On suppose que le trait plein est la valeur vraie (valeur de l'équation) et le point est la valeur réellement observée (y plus le bruit).

3. Introduction de la régression polypoly

Le surapprentissage est plus susceptible de se produire lorsque le degré de liberté augmente, nous osons donc introduire une régression polynomiale à 30 dimensions.

#affichage graphique
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()

#Paramètres d'affichage
xs = np.linspace(-10, 10, 200)  

#Introduction de la régression polypoly
poly = PolynomialFeatures(degree=30, include_bias=False)  
X_poly = poly.fit_transform(X[:, np.newaxis])   

Après avoir défini l'affichage et l'affichage du graphique, PolynomialFeatures est instancié et ajusté. La dimension est de 30 dimensions (degré = 30).

4. Aucune régularisation

Tout d'abord, effectuez une régression polymorphe sans régularisation.

#Pas de régularisation
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')

En raison du degré élevé de liberté avec un polynôme à 30 dimensions, il est possible de passer de nombreux points de manière adroite, et cela tombe dans un surapprentissage typique. C'est loin d'être la vraie valeur, et les performances de généralisation ne peuvent pas être attendues avec cela.

5. Régularisation L2

La régularisation L2 est une technique connue pour la régression Ridge, qui limite le coefficient pour qu'il ne devienne pas trop grand, et ajoute la norme L2 du paramètre à la perte (C est une constante). L(W)+c|w|^2

#Régularisation L2
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')

Eh bien, j'ai l'impression d'avoir pu bien rentrer.

6. Régularisation L1

La régularisation L1 est une technique connue pour la régression Lasso, qui limite également le coefficient pour qu'il ne devienne pas trop grand, en ajoutant la norme L1 du paramètre à la perte (C est une constante). L(W)+c|w|

#Régularisation L1
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')

La forme est très proche d'un ajustement parfait. Par rapport à la régularisation L1, la régularisation L2 semble pouvoir mieux revenir.

7. Comparaison des coefficients de dimension

Comparez 30 coefficients dimensionnels pour chacun sans régularisation, régularisation L2 et régularisation L1 (disposés à partir de la dimension la plus basse).

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)

Vous pouvez voir que L2 a un coefficient plus petit que Pas de régularisation. L1 est également une expression (expression creuse) avec de nombreux points complètement 0.

Je suis heureux que la régularisation L1 puisse supprimer le surapprentissage et réduire les dimensions.