J'ai écrit un graphe comme R glmnet en Python pour une modélisation clairsemée avec Lasso

Je voulais écrire un graphique qui ressemble à un tracé avec R glmnet en Python

Le problème de la régression Lasso en Python

Pour le moment, il y a des gens qui utilisent Scikit-Learn dans Python pour calculer la régression Lasso. Je calcule aussi avec Python. Cependant, je me sens envieux quand je vois le graphique de «Lasso» de la personne qui calcule avec «glmnet» de «R». Le graphe de R est un tel graphe. .. Réimprimé de Comment effectuer une estimation parcellaire par LASSO avec le package R / glmnet.

C'est facile à comprendre, n'est-ce pas? Il est facile de voir comment le coefficient de régression change lorsque $ λ $ (Scikit-Learn dans Pyhon est ʻalpha) change. Mais ceci n'est pas implémenté dans Scikit-Learn`.

J'ai aussi fait un tel graphique! !! J'ai pensé, j'ai fait un script de python cette fois. Vous ne pouvez pas faire de modélisation éparse sans un tel graphique. Même si vous ne donnez que le score et le coefficient de régression avec Scikit-Learn, il semble que vous n'ayez pas vu la capacité de la modélisation clairsemée effectuée avec Lasso.

J'ai essayé de faire un graphique qui semble sortir avec glmnet avec Python

C'est pourquoi je l'ai fait moi-même en utilisant l'instruction For.

J'ai réfléchi à diverses choses, mais de manière solide, j'ai répété la régression Lasso en mettant la valeur numérique créée avec numpy dans l'instruction For dans alpha ( lambda), et j'ai calculé le coefficient de régression et le score. J'ai calculé.

# -*- coding: utf-8 -*-
 
from sklearn import datasets
from sklearn.model_selection import train_test_split
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import Lasso


#Charger le jeu de données Boston
boston = datasets.load_boston()

alpha_lasso = []
coef_list = []
intercept_list = []
train_score = []
test_score = []

#print(boston['feature_names'])
#Quantité de caractéristiques distincte et variable d'objectif
X = boston['data']
y = boston['target']
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.8,random_state = 0)

#Déterminez la plage de recherche

lasso_1 = np.linspace(0.01,100,1000)

for i in lasso_1:
    #Modèle de régression Lasso formé et créé
    Lasso_regr = Lasso(alpha = i, max_iter=10000)

    Lasso_regr.fit(X_train,y_train)
    pre_train = Lasso_regr.predict(X_train)
    pre_test = Lasso_regr.predict(X_test)


    #Voir les résultats
    print("alpha=",i)
    print("Convient aux données d'entraînement")
    print("Exactitude des données d'entraînement=", Lasso_regr.score(X_train, y_train))
    print("Convient aux données de test")
    print("Exactitude des données de test=", Lasso_regr.score(X_test, y_test))

    alpha_lasso.append(i)
    coef_list.append(Lasso_regr.coef_)
    intercept_list.append(Lasso_regr.intercept_)
    train_score.append(Lasso_regr.score(X_train, y_train))
    test_score.append(Lasso_regr.score(X_test, y_test))

df_count = pd.Series(alpha_lasso,name = 'alpha')
df_coef= pd.DataFrame(coef_list,columns = boston.feature_names)
df_inter = pd.Series(intercept_list,name = 'intercept')
df_train_score = pd.Series(train_score,name = 'trian_score')
df_test_score = pd.Series(test_score,name = 'test_score')

#Maintenant, faites un graphique de l'alpha et du coefficient de régression
plt.plot(df_count,df_coef)
plt.xscale('log')
plt.legend(labels = df_coef.columns,loc='lower right',fontsize=7)
plt.xlabel('alpha')
plt.ylabel('coefficient')
plt.title('alpha vs cosfficent graph like R/glmnet')

plt.show()

#Maintenant, faites un graphique de l'alpha et du coefficient de régression
df_score = pd.concat([df_train_score,df_test_score], axis=1)
plt.plot(df_count,df_score)
plt.xscale('log')
plt.legend(labels = df_score.columns,loc='lower right',fontsize=8)
plt.xlabel('alpha')
plt.ylabel('r2_score')
plt.title('alpha vs score(train/test)')

plt.show()

Ceci est le graphique terminé.

En comparant le graphique qui épargne le coefficient de régression avec le graphique du score de cette manière, vous pouvez voir d'un coup d'œil combien d '«alpha» doit être fait. Je pense que 0,5 est meilleur que la valeur par défaut 1. S'il est plus grand que cela, le score baissera, et s'il est plus petit que cela, le score n'augmentera pas, mais la quantité de fonctionnalités jugée inutile lorsque clairsemée sera incluse. On a donc l'impression que 0,5 est juste.

Si vous calculez avec Lasso et la modélisation clairsemée! !!

Si vous calculez avec Lasso et la modélisation creuse, vous pouvez voir que ces deux graphiques sont également inclus dans Python.