Affichage des articles dont le libellé est datascience. Afficher tous les articles
Affichage des articles dont le libellé est datascience. Afficher tous les articles

lundi 28 août 2023

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.






jeudi 22 juin 2023

Traitement des données pour l'apprentissage automatique: suite

 Dans un article précédent, j'ai commencé à exposer des techniques pour réduire les données à traiter pour un dispositif d'apprentissage automatique. (voir article).

Continuons notre cheminement : comment éliminer les facteurs moins utiles ou encore comment supprimer des données non conformes (erreur de mesure etc.) 

Analyse des corrélations.

Il est possible d'obtenir la corrélation deux à deux des facteurs avec Pandas avec la méthode corr()


Une valeur proche de zéro est un signe de facteurs indépendants. 


On peut aussi avoir une confirmation visuelle par les lignes suivantes:

corrélation 2 à 2
A noter le ';' en fin d'instruction permettant de cacher les méta-informations de Matplotlib

Garder pour un apprentissage 2 facteurs qui sont fortement corrélés n'apportera pas d'informations nouvelles. Aussi, on peut supprimer un des deux facteurs sans risque d'appauvrir les informations.

Eliminations des valeurs aux extrémités.


Pour cela plusieurs solutions sont proposées

La méthode par l'écart type ou la déviation standard.

On ne conservera que les valeurs comprises dans une fourchette dont les extrémités sont calculées à partir de la moyenne et de l'écart type.  Il est possible de jouer sur l'amplitude de la fourchette.


Ici , on a pris 2 fois l'ecart type de chaque coté pour obtenir l'amplitude de la fourchette.
2 valeurs seulement sont éliminées à droite de la moyenne.

La méthode par la médiane et les quantiles.

La méthode quantile de Pandas permet de séparer les facteurs en jeux de données de même nombre (quantile(0.5)
Il faut donc calculer le quantile pour 0.25 puis 0.75
Exemple:

L'intervalle interquartile sera donné par quantile(0.75) - quantile(0.25)

On pourra déterminer une borne inférieure et supérieure: 
borne int = quant25 - irq * 1,2
et 
borne sup = quant75 + irq * 1.2
(1.2  à 1.5 sont des coefficients généralement utilisés)


Méthode avec LocalOutlierFactor   de sklearn


Utilisation :


Apres filtrage les valeurs retenues sont en rouge: 












samedi 22 avril 2023

Datascience: préparation des données, comment détecter les données hors champ

 Dans la continuation de l'article sur le nettoyage des données, je vais aborder l'étape suivante dans la préparation des données: réduire les données à traiter en se concentrant sur les données représentatives.

 

La réduction ou la suppression de facteur est un enjeu primordial car cela réduira la taille des calculs à effectuer  

Suppression des doublons.

Une première tache sera de supprimer les lignes en double, une ligne doublée n'apporte pas d'information supplémentaire et peuvent même introduire un biais. 

Pandas offre des méthodes pour détecter les doublons et supprimer les lignes: duplicated() et drop_duplicates()

Exemple:


Suppression des données non informatives.

La première des techniques est de supprimer les facteurs présentant une variance nulle ou faible.

Exemple:  une colonne qui ne contiendrait qu'une valeur , aurait une variance nulle et n'apporterait aucune information utilisable.

La colonne x5 contient qu'une valeur pour toutes les lignes. On peut la supprimer.





La méthode nunique()  de Pandas est utile pour détecter les colonnes inutiles et les supprimer avec la méthode drop().

Avec SKLearn.

Sklearn offre une méthode puissante basée sur le seuil de la variance:  VarianceThreshold()

Création d'un jeu de données

from sklearn.datasets import make_regression
X, y = make_regression(n_samples=20, n_features=4,n_informative = 2,  noise=3, random_state=42)
data = pd.DataFrame(X, columns=['x1', 'x2', 'x3', 'x4'])
data.insert(4, 'x5', 0.2)
data.head() #=>
 



Réduction des dimensions
from sklearn.feature_selection import VarianceThreshold
from sklearn import set_config
# nouveau dans sklearn sortie vers Pandas
#set_config(transform_output = "pandas")
print('format avant:', data.shape)
variance = VarianceThreshold().set_output(transform= 'pandas')
dt2 = variance.fit_transform(data.iloc[:,:4])
print('format apres:',dt2.shape)
 
#=>
#format avant: (20, 5)
#format apres: (20, 4)


Il est possible de fournir à VarianceThreshold un seuil de variance et ainsi elargir le champ de
la suppression.
Dans le prochain article on verra comment supprimer les valeurs hors limite qui viennent perturber
l'entrainement des modèles.