Régression linéaire, RIDGE et LASSO

 Le modèle de régression linéaire est un des piliers de l'apprentissage automatique. Simple et facile à mettre en œuvre, il n'est pourtant pas le seul de ce type.

Pour commencer savez vous à quoi sert la queue d'un cerf-volant ?

Son rôle premier n'est pas décoratif, la queue sert à lester l'arrière du cerf volant et ainsi le stabiliser. Sans elle le cerf-volant serait trop réactif et incontrôlable. 

Il en est de même pour les modèles d'apprentissage: ils ont besoin d'une régulation pour être moins sensibles aux variations des données. C'est ce que nous allons voir avec les modèles RIDGE et LASSO.

Un modèle de régression linéaire consiste à trouver l'équation d'une droite qui traverse au plus prés un nuage de point.

Construction d'un jeu de données. 

Je vais utiliser le générateur de données de SKLEARN pour construire une jeu de données se prêtant à une régression linéaire. Les principaux paramètres à choisir sont:

• La taille du jeu de données
• Le nombre de facteurs déterminants 
• Le niveau de distorsion

 

from  sklearn.datasets import make_regression
 
X,y = make_regression(n_samples=100, 
                      n_features=3,
                      bias = 1,
                      n_informative=1, 
                      noise=30, 
                      random_state=1) 

Ici nous aurons 3 facteurs dont 2 sans trop d'information pour le modèle.

On peut le visualiser par l'affichage des corrélations

Seul de le dernier facteur (numeroté 2 ) affiche une corrélation avec le résultat (y) : en bas à droite.

J'isole des données de test avec la méthode split de SKLEARN:

Modélisation.

Je vais appliquer successivement une regression linéaire, Ridge et Lasso et comparer les pentes de la droite des modèles.

# Les imports
from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Ridge
from sklearn import linear_model
 
# regression linéaire
reg = LinearRegression()
reg.fit(X_train,y_train)
 
# regression ridge
ridg = Ridge(alpha=10.0)
ridg.fit(X_train, y_train)
 
# regression Lasso
lasso = linear_model.Lasso(alpha=5)
lasso.fit(X_train, y_train)

On va tout d'abord vérifier que seul un facteur sur les trois est significatif:

X2 est bien le facteur dominant.

Dans le cadre de la régression linéaire , l'apprentissage va consister à déterminer la combinaison des coefficient des trois facteurs qui minimise les distances entre les points de mesure et le point calculé.

Si, on a trop de données ou à l'inverse très peu, le modèle va se comporter comme un cerf-volant sans queue. Il sera sensible aux variations des données à prédire. 

Aussi les modèles Ridge et Lasso visent à ajouter des contraintes sur la valeurs des coefficients. Mathématiquement le modèle Ridge va ajouter une régulation dite L2 et le modèle Lasso , une régulation L1.

L1 et L2 sont comme les handicaps pour les courses de chevaux:  une contrainte afin de réduire les inégalités.

La méthode générale pour calculer les coefficients restent les mêmes, on ajoutera en plus des contraintes ne concernant que les coefficients.

Le modèle RIDGE.

Ridge va tenter d'obtenir des coefficient plus petit afin d'adoucir la pente de la droite.

Cela se traduira pour une variation des X, une moindre variation du 'y'.

Illustration: 

Le modèle Lasso. 

Il va plus loin , il peut donner un coefficient égal à 0 pour un facteur et ainsi réduire le nombre de facteur d'un modèle.

Illustration pour le premier facteur:

 

Au niveau du score des modèles: ils sont proches, le Ridge est meilleur mais le Lasso sera peut être plus efficace dans le temps.

Cet article (lien )pour aller plus loin.

Conclusion:

Il ne faut pas hésiter à comparer plusieurs modèles, SKLEARN est votre ami, il simplifie grandement les choses.

Le notebook portant le code est sur github.