Ridge Return (pour les débutants) -Code Edition-

Cette fois, je vais résumer l'implémentation (code) de la régression Ridge.

■ Procédure de régression Ridge

Passez aux 7 étapes suivantes.

1. Préparation du module
2. Préparation des données
3. Rechercher des paramètres
4. Créez un modèle
5. Calcul de la valeur prévue
6. Graphique résiduel
7. Évaluation du modèle

1. Préparation du module

Tout d'abord, importez les modules requis.

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

#Module pour lire le jeu de données
from sklearn.datasets import load_boston

#Module qui sépare les données d'entraînement et les données de test
from sklearn.model_selection import train_test_split

#Module de normalisation (normalisation distribuée)
from sklearn.preprocessing import StandardScaler

#Module de recherche de paramètre (alpha)
from sklearn.linear_model import RidgeCV

#Module de traçage des paramètres (alpha)
from yellowbrick.regressor import AlphaSelection

#Module qui effectue la régression Ridge (méthode du carré minimum + terme de régularisation L2)
from sklearn.linear_model import Ridge

#Lecture de l'ensemble de données Boston
boston = load_boston()

#Diviser en variable objective et variable explicative
X, y = boston.data, boston.target

#Standardisation (normalisation distribuée)
SS = StandardScaler()
X = SS.fit_transform(X)

#Divisez en données d'entraînement et en données de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.3, random_state=123)

En normalisation, par exemple, lorsqu'il y a des quantités de caractéristiques à 2 et 4 chiffres (variables explicatives), l'influence de ces dernières devient grande. L'échelle est alignée en définissant la moyenne sur 0 et la variance sur 1 pour toutes les quantités d'entités.

Dans random_state, la valeur de départ est fixée de sorte que le résultat de la division des données soit le même à chaque fois.

3. Rechercher des paramètres

La régression Ridge ajoute un terme de régularisation à l'équation des moindres carrés pour éviter le surentraînement. L'augmentation de l'alpha rend la régularisation plus forte et la diminution la rend plus faible.

La recherche de grille et la validation croisée sont effectuées sur les données d'entraînement pour trouver l'alpha optimal.

#Définir l'intervalle de recherche pour le paramètre (alpha)
alphas = np.logspace(-10, 1, 500)

#Validation croisée des données d'entraînement pour trouver l'alpha optimal
ridgeCV = RidgeCV(alphas = alphas)

#Tracer alpha
visualizer = AlphaSelection(ridgeCV)
visualizer.fit(X_train, y_train)

visualizer.show()
plt.show()

Résultat de sortie
D'après ce qui précède, l'alpha optimum = 8,588 a été trouvé.

4. Créez un modèle

Nous allons créer un modèle de régression Ridge en utilisant le paramètre (alpha) obtenu précédemment.

#Créer une instance de régression Ridge
ridge = Ridge(alpha = 8.588)

#Générer un modèle à partir des données d'entraînement (méthode du carré minimum + terme de régularisation)
ridge.fit(X_train, y_train)

#Section de sortie
print(ridge.intercept_)

#Coefficient de régression de sortie (gradient)
print(ridge.coef_)

Résultat de sortie

lr.intercept_: 22.564747201001634

lr.coef_: [-0.80818323  0.81261982  0.24268597  0.10593523 -1.39093785  3.4266411
 -0.23114806 -2.53519513  1.7685398  -1.62416829 -1.99056814  0.57450373
 -3.35123162]

lr.intercept_: section (poids $ w_0 $) lr.coef_: coefficient de régression / gradient (poids $ w_1 $ ~ $ w_ {13} $)

Par conséquent, une valeur numérique concrète dans la formule du modèle (formule de retour) a été obtenue.

$ y = w_0 + w_1x_1+w_2x_2+ \cdots + w_{12}x_{12} + w_{13}x_{13}$

5. Calcul de la valeur prévue

Placez les données de test (X_test) dans la formule du modèle créé et recherchez la valeur prédite (y_pred).

y_pred = lr.predict(X_test)
y_pred

Résultat de sortie

y_pred: [15.25513373 27.80625237 39.25737057 17.59408487 30.55171547 37.48819278
 25.35202855 ..... 17.59870574 27.10848827 19.12778747 16.60377079 22.13542152]

Résiduel: différence entre la valeur prédite et la valeur de réponse correcte (y_pred --y_test)

#Création d'objets de dessin et de sous-tracés
fig, ax = plt.subplots()

#Graphique résiduel
ax.scatter(y_pred, y_pred - y_test, marker = 'o')

# y =Tracez la ligne droite rouge de 0
ax.hlines(y = 0, xmin = -10, xmax = 50, linewidth = 2, color = 'red')
 
#Définir l'étiquette de l'axe
ax.set_xlabel('y_pred')
ax.set_ylabel('y_pred - y_test')

#Titre du graphique ajouté
ax.set_title('Residual Plot')

plt.show()

Résultat de sortie

Les données sont bien équilibrées au-dessus et en dessous de la ligne rouge (y_pred --y_test = 0). Il peut être confirmé qu'il n'y a pas de biais important dans la sortie de la valeur prédite.

7. Évaluation du modèle

Cette fois, nous évaluerons en utilisant le coefficient de détermination.

#Score pour les données d'entraînement
print(ridge.score(X_train, y_train))

#Score par rapport aux données de test
print(ridge.score(X_test, y_test))

Résultat de sortie

Train Score: 0.763674626990198
Test Score: 0.6462122981958535

Cette fois, pour les débutants, je n'ai résumé que l'implémentation (code). En regardant le timing dans le futur, je voudrais écrire un article sur la théorie (formule mathématique).

Merci pour la lecture.

Références: Nouveau manuel d'analyse de données utilisant Python (Matériel pédagogique principal de test d'analyse des données de certification d'ingénieur Python 3)