[PYTHON] Différence entre la régression linéaire, la régression Ridge et la régression Lasso

■ Présentation

Cette fois, en régression linéaire, régression Ridge et régression Lasso Je vais résumer les articles sur chaque fonctionnalité et différence.

■ Préparation des données du module

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

from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Ridge, Lasso
from sklearn.linear_model import RidgeCV
from yellowbrick.regressor import AlphaSelection

mglearn est un module de visualisation de l'utilisation des données et des graphiques.

Cette fois, nous utiliserons l'ensemble de données amélioré de Boston. Contrairement aux données d'origine, le nombre d'entités est de 104.

X, y = mglearn.datasets.load_extended_boston()

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=0)

print('X:', X.shape)
print('y:', y.shape)
print('X_train:', X_train.shape)
print('y_train:', y_train.shape)
print('X_test:', X_test.shape)
print('y_test:', y_test.shape)

# X: (506, 104)
# y: (506,)
# X_train: (379, 104)
# y_train: (379,)
# X_test: (127, 104)
# y_test: (127,)

1. Régression linéaire

lr = LinearRegression().fit(X_train, y_train)

#Coefficient de décision (un indice qui mesure la précision de la prédiction des modèles de régression)
print('Train set score: {}'.format(lr.score(X_train, y_train)))
print('Test set score: {}'.format(lr.score(X_test, y_test)))

# Train set score: 0.9520519609032729
# Test set score: 0.6074721959665842

le score est un coefficient de décision (un indice qui mesure la précision de la prédiction d'un modèle de régression).

Dans la régression linéaire, la précision de la prédiction des données d'entraînement disponibles est élevée, Pour les données de test (données inconnues), la précision des prévisions a tendance à être faible.

Si vous le comparez au sport (baseball), vous vous entraînez généralement à frapper des balles droites. Pensez-vous que vous ne serez pas du tout capable de gérer des balles courbes dans le jeu réel?

Dans la pratique et Kaggle, les performances de généralisation (capacité à répondre à la production) pour les données inconnues sont importantes. Pour ces données, nous pouvons voir que le modèle de régression linéaire n'est pas adapté.

2. Régression de crête

Trop d'adaptation aux données d'entraînement comme avant La baisse des performances de généralisation pour tester les données est appelée «surapprentissage».

Pour éviter cela, la régression Ridge est utilisée pour la régularisation (paramètre: alpha).

Le surapprentissage est plus susceptible de se produire si le coefficient de régression (valeur de chaque montant de caractéristique) est élevé ou varie. L'augmentation du paramètre alpha amènera le coefficient de régression à approcher 0.

ridge = Ridge(alpha=1).fit(X_train, y_train)

print('Training set score: {}'.format(ridge.score(X_train, y_train)))
print('Test set score: {}'.format(ridge.score(X_test, y_test)))

# Training set score: 0.885796658517094
# Test set score: 0.7527683481744752

L'adaptation aux données d'entraînement est réduite, mais les performances de généralisation aux données de test sont améliorées. L'alpha de la régression Ridge est 1 par défaut, alors essayez également d'autres valeurs.

ridge10 = Ridge(alpha=10).fit(X_train, y_train)

print('Training set score: {:.2f}'.format(ridge10.score(X_train, y_train)))
print('Test set score: {:.2f}'.format(ridge10.score(X_test, y_test)))

# Training set score: 0.79
# Test set score: 0.64

La précision de prédiction pour les données de test est inférieure à celle lorsque alpha = 1.

ridge01 = Ridge(alpha=0.1).fit(X_train, y_train)

print('Training set score: {}'.format(ridge.score(X_train, y_train)))
print('Test set score: {}'.format(ridge.score(X_test, y_test)))

# Training set score: 0.885796658517094
# Test set score: 0.7527683481744752

C'est à peu près la même précision de prédiction que lorsque alpha = 1.

Ici, à propos de l'ampleur et de la variation de chaque coefficient de régression Comparons 3 modèles avec alpha = 0,1, 1, 10.

plt.plot(ridge10.coef_, 's', label='Ridge alpha=10')
plt.plot(ridge.coef_, 's', label='Ridge alpha=1')
plt.plot(ridge01.coef_, 's', label='Ridge alpah=0.1')

plt.plot(lr.coef_, 'o', label='LinearRegression')
plt.xlabel('Coefficient index')
plt.ylabel('Coefficient magnitude')

plt.hlines(0, 0, len(lr.coef_))
plt.ylim(-25, 25)

plt.legend()

Axe horizontal: 104 éléments Axe vertical: amplitude de chaque coefficient de régression dans le modèle

On peut voir que le score est plus élevé lorsqu'il y a une certaine variation dans les données, comme alpha = 0,1, 1. Cependant, si la variation est trop grande (surapprentissage) comme la régression linéaire, ou si la régularisation est trop forte comme alpha = 10. Le score du coefficient de décision sera faible.

Plus tôt, j'ai substitué quelques alphas et comparé les scores. Il existe également un moyen de se renseigner à l'avance sur l'alpha optimal.

Tout d'abord, pour le paramètre alpha, définissez la plage pour rechercher la valeur. Effectuez une validation croisée des données d'entraînement avec RidgeCV et tracez les valeurs optimales avec Alpha Selection.

alphas = np.logspace(-10, 1, 500)

ridgeCV = RidgeCV(alphas = alphas)

alpha_selection = AlphaSelection(ridgeCV)
alpha_selection.fit(X_train, y_train)

alpha_selection.show()
plt.show()

À partir de là, nous avons trouvé la valeur optimale du paramètre (alpha) pour cette régression Ridge.

ridge0069 = Ridge(alpha=0.069).fit(X_train, y_train)

print('Training set score: {}'.format(ridge.score(X_train, y_train)))
print('Test set score: {}'.format(ridge.score(X_test, y_test)))

# Training set score: 0.885796658517094
# Test set score: 0.7527683481744752

Quand je l'ai essayé, le score était aussi élevé que lorsque alpha = 0,1, 1.

Ensuite, traçons la courbe d'apprentissage comme une comparaison entre la régression linéaire et la régression Ridge (alpha = 1).

mglearn.plots.plot_ridge_n_samples()

Axe horizontal: taille des données (total) Axe vertical: coefficient de décision

Le score des données d'entraînement est élevé car la régression linéaire est sujette au surentraînement. Dans les données de test, les performances de généralisation sont presque nulles.

Cependant, si la taille des données est suffisante On peut voir qu'elle a les mêmes performances de généralisation que la régression Ridge.

3. Régression par lasso

Similaire à la régression Ridge, elle contraint le coefficient à s'approcher de 0, La méthode de multiplication est légèrement différente et la régression Lasso a certains coefficients qui sont complètement nuls.

Nombre de fonctionnalités utilisées: Nombre de fonctionnalités utilisées

lasso = Lasso().fit(X_train, y_train)

print('Training set score: {:.2f}'.format(lasso.score(X_train, y_train)))
print('Test set score: {:.2f}'.format(lasso.score(X_test, y_test)))
print('Number of features used: {}'.format(np.sum(lasso.coef_ != 0)))

# Training set score: 0.29
# Test set score: 0.21
# Number of features used: 4

lasso001 = Lasso(alpha=0.01, max_iter=100000).fit(X_train, y_train)

print('Traing set score: {:.2f}'.format(lasso001.score(X_train, y_train)))
print('Test set score: {:.2f}'.format(lasso001.score(X_test, y_test)))
print('Number of features used: {}'.format(np.sum(lasso001.coef_ != 0)))

# Traing set score: 0.90
# Test set score: 0.77
# Number of features used: 33

lasso00001 = Lasso(alpha=0.0001, max_iter=100000).fit(X_train, y_train)

print('Training set score: {:.2f}'.format(lasso00001.score(X_train, y_train)))
print('Test set score: {:.2f}'.format(lasso00001.score(X_test, y_test)))
print('Number of features used: {}'.format(np.sum(lasso00001.coef_ != 0)))

# Training set score: 0.95
# Test set score: 0.64
# Number of features used: 96

Basé sur une fonction d'erreur conçue pour que les caractéristiques moins importantes aient tendance à être 0 Nous formons et déterminons les fonctionnalités à utiliser réellement.

Dans ce cas, si le nombre d'entités est aussi grand que 96 ou trop petit que 4 Vous pouvez voir que les performances de généralisation sont faibles.

À propos de Lasso (alpha = 0,0001) et Ridge (alpha = 1) Comparons l'ampleur et la variation du coefficient de régression.

plt.plot(lasso.coef_, 's', label='Lasso alpha=1')
plt.plot(lasso001.coef_, '^', label='Lasso alpha=0.01')
plt.plot(lasso00001.coef_, 'v', label='Lasso alpha=0.0001')

plt.plot(ridge01.coef_, 'o', label='Ridge alpha=0.1')
plt.legend(ncol=2, loc=(0, 1.05))
plt.ylim(-25, 25)
plt.xlabel('Coefficient index')
plt.ylabel('Coefficient magnitude')

Axe horizontal: 104 éléments Axe vertical: amplitude de chaque coefficient de régression dans le modèle

En regardant la figure ci-dessus, il est encore nécessaire d'avoir une certaine variation dans les coefficients. Le lasso (alpha = 0,0001) est aussi dispersé que Ridge (alpha = 1) Vous pouvez voir que le score du coefficient de décision est également proche.

■ Conclusion

Si vous pensez à la régression linéaire, premier modèle avec la régression Ridge Si vous trouvez qu'il y a des fonctionnalités inutiles, vous devriez essayer la régression Lasso.

ElasticNet (qui a à la fois des paramètres Ridge et Lasso) est précis, mais fastidieux à ajuster.

■ Références

・ Apprentissage automatique à partir de Python --O'Reilly Japan