2. Analyse multivariée décrite dans Python 6-3. Régression Ridge / Régression Lasso (scikit-learn) [Fonctionnement de la régularisation]

• Je voudrais examiner de plus près les différences d'efficacité de la régression pour la régression des crêtes et la régression au lasso.
• Générez 50 paramètres de régularisation $ λ $ et répétez l'estimation 50 fois, en échangeant $ λ $ pour chaque modèle de régression.
• Dans le processus, observez comment le coefficient estimé pour chaque variable change.

⑴ Bibliothèque d'importation

#Bibliothèque de traitement / calcul / analyse de données
import numpy as np
import pandas as pd

#Bibliothèque de dessins graphiques
import matplotlib.pyplot as plt
%matplotlib inline

#Bibliothèque d'apprentissage automatique
import sklearn
from sklearn.linear_model import Ridge, Lasso #Classe pour la génération de modèles de régression

#Un module qui rend matplotlib compatible avec l'affichage japonais
!pip install japanize-matplotlib
import japanize_matplotlib

⑵ Acquisition et lecture de données

#Obtenez des données
url = 'https://raw.githubusercontent.com/yumi-ito/sample_data/master/ridge_lasso_50variables.csv'

#Lire les données acquises en tant qu'objet DataFrame
df = pd.read_csv(url)

print(df)

• Dans ces données fictives, la 0ème colonne est la variable objective y, et la 1ère variable explicative et les suivantes de la colonne sont au total 50. Le nombre d'échantillons est de 150.
• Puisqu'elle a déjà été normalisée, chaque variable a une moyenne de 0 et un écart-type de 1.
• Aussi, la variable objective y, qui a été créée intentionnellement. Il est calculé en fixant le coefficient correct de la première variable x_1 à "5" et en y ajoutant le bruit qui suit la distribution normale. La question de savoir si la bonne réponse «5» peut être estimée ou non est également un problème.

#Créez la variable explicative x en supprimant la colonne "y"
x = df.drop('y', axis=1)

#Extraire la colonne "y" pour créer la variable objectif y
y = df['y']

(3) Génération du paramètre de régularisation λ

# λ(alpha)Générer 50 façons
num_alphas = 50
alphas = np.logspace(-2, 0.7, num_alphas)

print(alphas)

• numpy.logspace () est une fonction avec une torsion qui ** prend une base logarithmique de 10 et devient une séquence de différence égale **.
• Spécifiez (valeur de départ, valeur de fin, nombre à générer) dans l'argument, mais lorsque vous prenez réellement le logarithme, ce sera comme suit.

np.log10(alphas)

• Valeur de départ -2, valeur finale 0,7, toutes les 50 colonnes de nombres de différence égaux.
• S'il s'agit d'une séquence d'égalité, numpy.arange () semble être bon, mais je le fais car il est nécessaire d'utiliser ** l'échelle log ** lors de la visualisation ultérieure.

Échelle logistique

• La valeur de l'échelle logarithmique double pour chaque échelle. Un graphique logarithmique est un graphique qui utilise soit l'axe des x, l'axe des y ou les deux axes.

• Les échelles ordinaires sont appelées échelles linéaires, mais si vous les convertissez en échelles logarithmiques ...

• Comme on a l'impression que l'échelle de l'axe est compressée étroitement sur la ligne droite numérique, il est plus facile de comparer visuellement des données éloignées dans le nombre de chiffres.

⑷ Estimation par régression des crêtes

#Variable qui stocke le coefficient de régression
ridge_coefs = []

#Répétez l'estimation de la régression des crêtes en échangeant alpha
for a in alphas:
    ridge = Ridge(alpha = a, fit_intercept = False)
    ridge.fit(x, y)
    ridge_coefs.append(ridge.coef_)

• Répétez l'estimation de la régression des crêtes en échangeant ʻalpha, et ajoutez le coefficient de régression à ridge_coefs`.
• L'argument fit_intercept = False de Ridge (), qui génère le modèle du modèle, spécifie s'il faut calculer la section. S'il est défini sur False, la section n'est pas calculée, c'est-à-dire que la section 0 passe toujours par l'origine. Sera.

#Convertir les coefficients de régression accumulés en un tableau numpy
ridge_coefs = np.array(ridge_coefs)

print("Forme d'arrangement:", ridge_coefs.shape)
print(ridge_coefs)

• Dans un tableau 50 x 50, 50 ensembles de 50 coefficients sont obtenus pour chaque paramètre.
• Visualisez ceci. Placez les paramètres sur l'axe des x, mais utilisez log_alphas, qui est une conversion logarithmique de ʻalphas` et moins.
• La fonction plt.text (), qui affiche le texte dans le graphique, utilise (x, y," str ") comme arguments pour spécifier les coordonnées et la chaîne de caractères.

#Conversion de journal des alphas(-log10)
log_alphas = -np.log10(alphas)

#Spécifier la taille de la zone graphique
plt.figure(figsize = (8,6))

#Un graphique en traits pointillés avec λ sur l'axe des x et des coefficients sur l'axe des y
plt.plot(log_alphas, ridge_coefs)

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

#Spécifiez la plage de l'axe x
plt.xlim([min(log_alphas) - 0.1, max(log_alphas) + 0.3])

#Étiquette d'axe
plt.xlabel("Paramètre de régularisation λ(-log10)", fontsize=13)
plt.ylabel("Coefficient de régression", fontsize=13)

#Ligne d'échelle
plt.grid()

• Puisque l'axe des x est $ -log_ {10} $, la valeur du paramètre de régularisation $ λ $ augmente à mesure que vous vous déplacez vers la gauche, et la pénalité devient plus forte.
• Puisque la variable objectif y est générée à partir de la variable explicative x_1, seule la variable x_1 montre la linéarité par elle-même.
• La valeur absolue du coefficient est plus petite vers le côté gauche, et la pénalité est plus lâche vers le côté droit, donc on peut voir que le coefficient avec une valeur absolue plus grande est plus susceptible d'être estimé.

⑸ Estimation par régression Lasso

• Répéter l'estimation de la régression Lasso 50 fois, en utilisant les mêmes paramètres de régularisation (alphas) que la régression de crête.

#Variable qui stocke le coefficient de régression
lasso_coefs = []

#Répétez l'estimation de la régression Lasso en échangeant alpha
for a in alphas:
    lasso = Lasso(alpha = a, fit_intercept = False)
    lasso.fit(x, y)
    lasso_coefs.append(lasso.coef_)

#Convertir les coefficients de régression accumulés en un tableau numpy
lasso_coefs = np.array(lasso_coefs)

print("Forme d'arrangement:", lasso_coefs.shape)
print(lasso_coefs)

• De même, dessinez un graphique à sens unique avec l'axe des x de $ -log_ {10} $.

#Spécifier la taille de la zone graphique
plt.figure(figsize = (8,6))

#Un graphique en traits pointillés avec λ sur l'axe des x et des coefficients sur l'axe des y
plt.plot(log_alphas, lasso_coefs)

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

#Spécifiez la plage de l'axe x
plt.xlim([min(log_alphas) - 0.1, max(log_alphas) + 0.3])

#Étiquette d'axe
plt.xlabel("Paramètre de régularisation λ(-log10)", fontsize=13)
plt.ylabel("Coefficient de régression", fontsize=13)

#Ligne d'échelle
plt.grid()

• Sauf pour la variable x_1, le coefficient est presque 0.
• Pour les autres variables, les coefficients non nuls sont légèrement visibles près du paramètre le plus faible à l'extrême droite.

Résumé

• ** La régression de crête ** tend à «** le petit coefficient absolu global est estimé ** pour un certain nombre de variables. ** La régression Lasso ** tend à ** avoir partiellement des coefficients non nuls pour un petit nombre de variables et tous les autres coefficients à 0 **.
• Dans la régression Lasso, la plupart des coefficients sont 0, donc on peut dire que cela équivaut à calculer le coefficient de régression et à réduire la dimension en même temps.