Tutoriel de sélection de variables en Python : guide du débutant

Pour aller plus loin en Python, suivez le cours gratuit de DataCamp Intro to Python for Data Science.

Vous avez tous déjà vu des jeux de données. Parfois petits, mais bien souvent extrêmement volumineux. Traiter des données très larges devient vite un défi, au point de créer des goulots d’étranglement côté calcul.

Qu’est-ce qui rend ces jeux de données si gros ? Les variables (features). Plus vous avez de variables, plus le jeu de données grossit. Pas toujours, certes : on trouve des jeux avec beaucoup de variables mais peu d’instances. Mais ce n’est pas notre sujet. Vous vous demandez peut‑être comment traiter ce type de données avec un ordinateur standard sans tourner en rond.

Dans un jeu de données de grande dimension, certaines variables sont totalement non pertinentes, insignifiantes ou peu utiles. Leur contribution au modèle prédictif est souvent inférieure à celle des variables clés, voire nulle. Ces variables posent plusieurs problèmes qui pénalisent l’apprentissage efficace :

• Allocation de ressources inutile pour ces variables.
• Ces variables agissent comme du bruit et peuvent dégrader fortement les performances du modèle d’apprentissage automatique.
• Le modèle met plus de temps à s’entraîner.

Quelle est la solution ? La plus économique : la sélection de variables.

La sélection de variables consiste à extraire les variables les plus pertinentes d’un jeu de données. Dans bien des cas, elle améliore aussi les performances d’un modèle d’apprentissage.

Intéressant, n’est‑ce pas ?

Vous avez eu une introduction informelle à la sélection de variables et à son importance en data science et en machine learning. Dans cet article, vous allez voir :

• Introduction à la sélection de variables et compréhension de son importance
• Différence entre sélection de variables et réduction de dimension
• Les différents types de méthodes de sélection de variables
• Mise en œuvre de différentes méthodes de sélection avec scikit-learn

Introduction à la sélection de variables

La sélection de variables est aussi appelée sélection de variables explicatives ou sélection d’attributs.

En bref, c’est le processus qui vise à choisir les variables les plus importantes/pertinentes d’un jeu de données.

Comprendre l’importance de la sélection de variables

L’intérêt de la sélection de variables apparaît clairement lorsque vous travaillez avec un jeu de données qui contient un très grand nombre de variables — on parle alors de jeu de données de grande dimension. La grande dimension augmente fortement le temps d’entraînement du modèle et peut le complexifier au point de conduire au surapprentissage (overfitting).

Souvent, dans un ensemble de variables de grande dimension, certaines sont redondantes : elles ne sont que des déclinaisons d’autres variables essentielles. Ces variables redondantes n’apportent pas efficacement au modèle. Il faut donc clairement extraire les variables les plus importantes et pertinentes pour obtenir de meilleures performances prédictives.

« L’objectif de la sélection de variables est triple : améliorer les performances de prédiction, fournir des modèles plus rapides et plus économiques, et offrir une meilleure compréhension du processus sous‑jacent qui a généré les données. »

-An Introduction to Variable and Feature Selection

Voyons maintenant la différence entre la réduction de dimension et la sélection de variables.

On confond parfois sélection de variables et réduction de dimension. Pourtant, elles diffèrent. Les deux visent à réduire le nombre d’attributs, mais la réduction de dimension crée de nouvelles combinaisons d’attributs (on parle parfois de transformation de variables), tandis que la sélection de variables inclut ou exclut des attributs existants sans les modifier.

Exemples de méthodes de réduction de dimension : analyse en composantes principales (ACP), décomposition en valeurs singulières (SVD), analyse discriminante linéaire (LDA), etc.

Pour résumer l’importance de la sélection de variables :

• Elle permet à l’algorithme d’apprendre plus vite.
• Elle réduit la complexité du modèle et facilite son interprétation.
• Elle peut améliorer la précision si le bon sous‑ensemble est choisi.
• Elle réduit le surapprentissage.

Dans la section suivante, vous verrez les grandes familles de méthodes de sélection : filtres (Filter), enveloppes (Wrapper) et méthodes intégrées (Embedded).

Méthodes par filtre (Filter)

L’illustration suivante décrit au mieux les méthodes de sélection par filtre :

Source : Analytics Vidhya

Les méthodes par filtre s’appuient sur les propriétés statistiques générales des données pour évaluer et choisir un sous‑ensemble de variables, sans utiliser d’algorithme d’apprentissage. Elles utilisent des critères d’évaluation tels que des mesures de distance, d’information, de dépendance ou de cohérence. Elles reposent souvent sur un classement des variables selon un score, afin d’écarter les variables non pertinentes avant toute phase de modélisation.

On utilise généralement les méthodes par filtre en prétraitement. La sélection est indépendante de tout algorithme d’apprentissage. Les variables sont classées d’après des scores statistiques qui mesurent leur corrélation avec la variable cible. La « corrélation » est très contextuelle et dépend du type de données. Le tableau suivant propose des coefficients adaptés selon le type de données (ici continues et catégorielles).

Source : Analytics Vidhya

Exemples de méthodes par filtre : test du chi‑deux, gain d’information, scores de coefficient de corrélation.

Passons maintenant aux méthodes par enveloppe.

Méthodes par enveloppe (Wrapper)

Comme pour les filtres, voici une infographie qui aide à mieux comprendre les méthodes par enveloppe :

Source : Analytics Vidhya

Comme vous le voyez, une méthode par enveloppe requiert un algorithme d’apprentissage et utilise ses performances comme critère d’évaluation. Elle recherche l’ensemble de variables le mieux adapté à l’algorithme et vise à améliorer la performance. Pour évaluer les variables, on utilise la précision prédictive pour la classification et la qualité des groupes pour le clustering.

Exemples : sélection progressive (forward selection), élimination régressive (backward elimination), élimination récursive de variables (RFE), etc.

• Sélection progressive (Forward selection) : on démarre avec un ensemble vide. La meilleure variable est ajoutée à chaque itération.
• Élimination régressive (Backward elimination) : on démarre avec l’ensemble complet et on retire, à chaque étape, la pire variable restante.
• Combinaison des deux : on peut combiner sélection progressive et élimination régressive : à chaque étape, on ajoute la meilleure variable et on retire la pire parmi les restantes.
• Élimination récursive de variables (RFE) : RFE effectue une recherche gloutonne pour trouver le meilleur sous‑ensemble. Il crée des modèles de façon itérative, identifie à chaque itération la meilleure ou la pire variable, puis continue avec les variables restantes jusqu’à exploration complète. Il classe ensuite les variables selon l’ordre d’élimination. Au pire, pour N variables, RFE explore de façon gloutonne jusqu’à 2^N combinaisons.

Parfait !

Voyons maintenant les méthodes intégrées.

Méthodes intégrées (Embedded)

Les méthodes intégrées sont itératives au sens où elles tiennent compte de chaque itération de l’entraînement et extraient les variables qui contribuent le plus à une itération donnée. Les méthodes de régularisation sont les plus courantes : elles pénalisent une variable selon un seuil appliqué à son coefficient.

C’est pourquoi les méthodes de régularisation sont aussi dites « pénalisées » : elles ajoutent des contraintes à l’optimisation d’un algorithme prédictif (comme une régression) pour favoriser des modèles moins complexes (moins de coefficients).

Exemples : LASSO, Elastic Net, régression Ridge, etc.

Différences entre méthodes par filtre et par enveloppe

Il peut être difficile de distinguer leurs fonctionnements. Voici les principaux écarts :

• Les filtres n’intègrent pas de modèle d’apprentissage pour juger une variable, alors que les enveloppes entraînent un modèle et utilisent ses performances pour décider si une variable est essentielle.
• Les filtres sont beaucoup plus rapides car ils n’entraînent pas de modèles. Les enveloppes sont coûteuses en calcul et peu adaptées aux jeux massifs.
• Les filtres peuvent échouer à trouver le meilleur sous‑ensemble s’il n’y a pas assez de données pour modéliser les corrélations. Les enveloppes, plus exhaustives, peuvent souvent proposer un meilleur sous‑ensemble.
• Utiliser des variables issues d’une méthode par enveloppe dans votre modèle final peut mener au surapprentissage, car le modèle a déjà appris avec ces variables, ce qui biaise la capacité réelle de généralisation. Les variables issues de filtres conduisent plus rarement à ce problème.

Vous avez vu l’importance de la sélection de variables et sa différence avec la réduction de dimension, ainsi que les principales familles de méthodes. Très bien !

Voici maintenant quelques pièges fréquents lors de la mise en œuvre :

Point d’attention important

Vous avez compris l’intérêt d’intégrer la sélection de variables dans votre pipeline. Reste à bien la positionner.

Concrètement, incluez l’étape de sélection avant d’alimenter le modèle, surtout si vous utilisez des méthodes d’estimation de la précision comme la validation croisée. Ainsi, la sélection s’effectue sur chaque pli juste avant l’entraînement. Si vous sélectionnez d’abord les variables sur tout le jeu, puis faites la sélection de modèle et l’entraînement sur ces variables, c’est une erreur majeure.

Si vous sélectionnez les variables sur l’ensemble des données puis validez par cross‑validation, alors les données de test de chaque pli ont aussi servi au choix des variables, ce qui biaise l’évaluation des performances.

Assez de théorie ! Passons au code.

Étude de cas en Python

Pour cette étude de cas, vous utiliserez le jeu de données Pima Indians Diabetes. Sa description est disponible ici.

Il s’agit d’une tâche de classification : prédire si une personne est diabétique à partir de 8 variables.

Le jeu compte 768 observations. Commencez par le charger. Avant cela, importez les dépendances nécessaires — vous en ajouterez d’autres au fil de l’eau.

import pandas as pd
import numpy as np

Maintenant que les dépendances sont importées, chargez le jeu Pima Indians dans un DataFrame avec Pandas.

data = pd.read_csv("diabetes.csv")

Le jeu est chargé dans l’objet DataFrame data. Jetons un œil aux données.

data.head()

On observe 8 variables et une cible binaire, 1 indiquant que la personne est diabétique, 0 le contraire. Le jeu contient des valeurs manquantes. Certaines colonnes ont des zéros là où c’est irréaliste (par exemple un indice de masse corporelle ou une pression artérielle à zéro).

Pour ce tutoriel, nous utiliserons la version prétraitée du jeu.

# load data
url = "https://raw.githubusercontent.com/jbrownlee/Datasets/master/pima-indians-diabetes.data.csv"
names = ['preg', 'plas', 'pres', 'skin', 'test', 'mass', 'pedi', 'age', 'class']
dataframe = pd.read_csv(url, names=names)

Les données sont désormais dans un DataFrame nommé dataframe.

Convertissons‑le en tableau NumPy pour accélérer les calculs. Séparons aussi variables explicatives et étiquette.

array = dataframe.values
X = array[:,0:8]
Y = array[:,8]

Parfait ! Vos données sont prêtes.

Commençons par appliquer un test statistique chi‑deux (pour des variables non négatives) afin de sélectionner 4 meilleures variables. Vous avez vu que le chi‑deux relève des méthodes par filtre. Pour en comprendre les bases, cette vidéo est une excellente introduction.

La bibliothèque scikit‑learn propose la classe SelectKBest, compatible avec plusieurs tests statistiques, dont le chi‑deux.

# Import the necessary libraries first
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2

Les bibliothèques sont importées. Passons à l’action.

# Feature extraction
test = SelectKBest(score_func=chi2, k=4)
fit = test.fit(X, Y)

# Summarize scores
np.set_printoptions(precision=3)
print(fit.scores_)

features = fit.transform(X)
# Summarize selected features
print(features[0:5,:])

[ 111.52  1411.887   17.605   53.108 2175.565  127.669    5.393  181.304]
[[148.    0.   33.6  50. ]
 [ 85.    0.   26.6  31. ]
 [183.    0.   23.3  32. ]
 [ 89.   94.   28.1  21. ]
 [137.  168.   43.1  33. ]]

Interprétation :

Vous voyez les scores de chaque attribut et les 4 attributs retenus (ceux avec les plus hauts scores) : plas, test, mass et age. Ces scores vous aident à identifier les meilleures variables pour entraîner le modèle.

P.S. : La première ligne représente les noms des variables. Pour le prétraitement, les noms ont été encodés numériquement.

Ensuite, vous allez mettre en œuvre l’élimination récursive de variables (RFE), une méthode par enveloppe.

L’élimination récursive (RFE) retire des attributs de façon itérative et construit un modèle sur les attributs restants.

Elle utilise la précision du modèle pour identifier les attributs (et leurs combinaisons) qui contribuent le plus à la prédiction de la cible.

Vous trouverez plus d’informations sur la classe RFE dans la documentation scikit‑learn.

# Import your necessary dependencies
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression

Nous utiliserons RFE avec une Logistic Regression pour sélectionner les 3 meilleures variables. Le choix de l’algorithme importe peu tant qu’il est performant et stable.

# Feature extraction
model = LogisticRegression()
rfe = RFE(model, 3)
fit = rfe.fit(X, Y)
print("Num Features: %s" % (fit.n_features_))
print("Selected Features: %s" % (fit.support_))
print("Feature Ranking: %s" % (fit.ranking_))

Num Features: 3
Selected Features: [ True False False False False  True  True False]
Feature Ranking: [1 2 3 5 6 1 1 4]

RFE a sélectionné preg, mass et pedi.

Ces variables sont indiquées par True dans le tableau support et par « 1 » dans le tableau ranking, ce qui traduit leur importance.

Passons maintenant à la régression Ridge, une technique de régularisation qui sert aussi de méthode intégrée de sélection.

Cet article explique très bien la régression Ridge. À lire.

# First things first
from sklearn.linear_model import Ridge

Nous allons utiliser Ridge pour examiner les coefficients et le R².

Voir aussi la documentation officielle de scikit‑learn sur Ridge.

ridge = Ridge(alpha=1.0)
ridge.fit(X,Y)

Ridge(alpha=1.0, copy_X=True, fit_intercept=True, max_iter=None,
   normalize=False, random_state=None, solver='auto', tol=0.001)

Pour mieux lire les résultats, écrivons une petite fonction d’aide pour afficher joliment les coefficients.

# A helper method for pretty-printing the coefficients
def pretty_print_coefs(coefs, names = None, sort = False):
    if names == None:
        names = ["X%s" % x for x in range(len(coefs))]
    lst = zip(coefs, names)
    if sort:
        lst = sorted(lst,  key = lambda x:-np.abs(x[0]))
    return " + ".join("%s * %s" % (round(coef, 3), name)
                                   for coef, name in lst)

Passons les coefficients du modèle Ridge à cette fonction pour voir le résultat.

print ("Ridge model:", pretty_print_coefs(ridge.coef_))

Ridge model: 0.021 * X0 + 0.006 * X1 + -0.002 * X2 + 0.0 * X3 + -0.0 * X4 + 0.013 * X5 + 0.145 * X6 + 0.003 * X7

Vous retrouvez l’ensemble des coefficients associés aux variables. Cela vous aide encore à repérer les variables essentielles. À garder en tête avec Ridge :

• Aussi appelée régularisation L2.
• Pour des variables corrélées, les coefficients ont tendance à être proches.
• Des coefficients négatifs signalent une contribution limitée. Dans des cas plus complexes avec de nombreuses variables, ces scores aident à la décision finale de sélection.

Cette étude de cas se termine ici. Les méthodes utilisées vous aident à comprendre les variables d’un jeu de données de manière approfondie. Quelques points clés :

• La sélection de variables fait partie du prétraitement, souvent l’étape la plus chronophage d’un pipeline de machine learning.
• Ces techniques vous permettent d’aborder le sujet de façon plus systématique et adaptée au machine learning, avec une meilleure interprétation des variables.

En résumé

Dans cet article, vous avez couvert un sujet statistique majeur : la sélection de variables. Vous avez vu ses variantes et comment les utiliser pour identifier les variables importantes d’un jeu de données.

Poursuivez en combinant une mesure de corrélation avec une méthode par enveloppe et observez l’effet. Vous pourriez même créer votre propre mécanisme de sélection. C’est ainsi que l’on pose les bases d’une petite recherche. Certains chercheurs exploitent aussi des approches de soft computing pour sélectionner les variables — un champ d’étude à part entière. Testez les algorithmes existants sur différents jeux et forgez vos conclusions.

Pourquoi ces méthodes traditionnelles restent‑elles pertinentes ?

La question est légitime. Des architectures de réseaux de neurones (par exemple les CNN) savent extraire des variables significatives, mais avec des limites. Utiliser un CNN sur des données tabulaires classiques — qui n’ont pas les propriétés spécifiques d’une image (translations, bords, position, contours, etc.) — n’est pas un choix judicieux. De plus, avec peu de données et de ressources, entraîner un CNN sur des tableaux peut être une perte de temps. Dans ces situations, les méthodes étudiées ici sont particulièrement utiles.

Pour aller plus loin :

• Feature Selection for Knowledge Discovery and Data Mining
• Subspace, Latent Structure, and Feature Selection: Statistical and Optimization Perspectives Workshop
• Feature Selection: Problem statement and Uses
• Using genetic algorithms for feature selection in Data Analytics

Voici les références utilisées pour rédiger ce tutoriel :

• Data Mining: Concepts and Techniques; Jiawei Han Micheline Kamber Jian Pei.
• An introduction to feature selection
• Article Analytics Vidhya sur la sélection de variables
• Hierarchical and Mixed Model - cours DataCamp
• Feature Selection For Machine Learning in Python
• Outlier Detection in Stream Data by Machine Learning and Feature Selection Methods
• S. Visalakshi and V. Radha, "A literature review of feature selection techniques and applications: Review of feature selection in data mining," 2014 IEEE International Conference on Computational Intelligence and Computing Research, Coimbatore, 2014, pp. 1-6.

N’hésitez pas à poser vos questions dans les commentaires !