Appliquéintermédiaire

Importance des Features & Sélection

“Savoir sur quelles caractéristiques votre modèle s'appuie réellement — puis lui faire plus (ou moins) confiance”

Importance par permutation vs impureté (Gini), attribution unifiée SHAP, importance drop-colonne, et comment les features corrélées divisent les scores — avec graphique interactif.

35 min

6 diagrammes

6 Concepts Couverts

Prérequis

→Random Forest

→Gradient Boosting

Concepts Couverts

Permutation ImportanceGini ImportanceSHAPDrop-ColumnFeature SelectionCorrelation Bias

Précédent: Optimisation des Hyperparamètres Suivant: Dépendance Partielle & Courbes ICE

∑Formules Clés

Importance par Permutation

Chute de précision quand la caractéristique j est mélangée aléatoirement — agnostique au modèle, fonctionne après l'entraînement

Importance par Impureté de Gini

Diminution pondérée de l'impureté à travers tous les splits sur la caractéristique j — rapide mais biaisée vers la cardinalité

SHAP (noyau)

Valeur de Shapley : contribution marginale moyenne de chaque caractéristique sur toutes les coalitions de caractéristiques

Importance par Suppression de Colonne

Étalon-or mais coûteux — réentraîner une fois par caractéristique

▶Simulation Interactive

Loading visualization…

🎯

Pourquoi l'Importance des Caractéristiques Est Indispensable

motivation

Les modèles ML sont souvent des boîtes noires — ils produisent des sorties mais cachent leur raisonnement. Les méthodes d'importance des caractéristiques lèvent ce voile. Elles répondent à : sur quelles entrées le modèle s'appuie-t-il le plus ? Cela importe pour trois raisons : (1) Débogage : si votre modèle s'appuie fortement sur 'bruit_aléatoire', vous avez un problème de fuite de données. (2) Confiance : les régulateurs, les médecins et les agents de crédit doivent comprendre les décisions du modèle — l'article 22 du RGPD impose l'explicabilité pour les décisions automatisées. (3) Sélection de caractéristiques : les scores d'importance guident la réduction de dimensionnalité. Supprimer les caractéristiques sans importance réduit le coût d'inférence et prévient le surapprentissage.

Un modèle de scoring de crédit qui s'appuie fortement sur le code_postal pourrait être équitable sur les données d'entraînement mais servir de proxy pour la race — l'analyse d'importance révèle cela avant le déploiement.

💡

Deux Philosophies : Que Signifie 'Important' ?

intuition

Il y a fondamentalement deux écoles : (A) L'importance structurelle demande « combien cette caractéristique a-t-elle aidé à construire le modèle ? » — l'importance d'impureté des arbres est l'exemple canonique, calculée à partir des statistiques de division lors de l'entraînement. Elle est rapide mais a un biais connu : elle gonfle l'importance des caractéristiques continues à haute cardinalité comme le code_postal. (B) L'importance fonctionnelle demande « de combien les prédictions du modèle se dégradent-elles si je casse cette caractéristique ? » — l'importance par permutation mélange chaque caractéristique indépendamment et mesure la baisse de précision. Elle est agnostique au modèle et attribue correctement une importance quasi nulle aux caractéristiques de bruit aléatoire. Les deux approches sont souvent en désaccord — et ce désaccord est informatif.

Si l'importance par impureté dit que code_postal est important mais que l'importance par permutation dit quasi nulle, le modèle a appris des corrélations fallacieuses de la cardinalité plutôt que du signal.

⚙️

Importance par Permutation : Étape par Étape

algorithm

Entraînez votre modèle sur (X_train, y_train). Calculez la métrique de base (ex. précision) sur X_val.

Pour la caractéristique j dans {1, …, p} : mélangez la colonne j dans X_val (remplacez par une permutation aléatoire), calculez la métrique sur les données mélangées, restaurez la colonne j.

Importance de j = métrique de base − métrique mélangée. Une forte baisse = caractéristique importante.

Répétez K fois (par défaut K=5 dans sklearn) et faites la moyenne pour réduire la variance des mélanges aléatoires.

Triez les caractéristiques par score d'importance. Les caractéristiques avec des scores négatifs (le modèle s'améliore quand elles sont mélangées) indiquent des caractéristiques nuisibles ou avec fuite.

</>

Importance des Caractéristiques : Permutation & Impureté

code

python66 lines

from sklearn.ensemble import RandomForestClassifier
from sklearn.inspection import permutation_importance
from sklearn.model_selection import train_test_split
import pandas as pd
import numpy as np

class="tok-comment"># ── Jeu de données tabulaire synthétique ──────────────────────────────────────
np.random.seed(class="tok-num">42)
n = class="tok-num">1000
X = pd.DataFrame({
    class="tok-str">"revenu":          np.random.normal(class="tok-num">50, class="tok-num">15, n),
    class="tok-str">"age":             np.random.randint(class="tok-num">18, class="tok-num">70, n),
    class="tok-str">"score_credit":    np.random.normal(class="tok-num">650, class="tok-num">80, n),
    class="tok-str">"montant_pret":    np.random.normal(class="tok-num">20, class="tok-num">8, n),
    class="tok-str">"anciennete":      np.random.exponential(class="tok-num">5, n),
    class="tok-str">"nb_comptes":      np.random.poisson(class="tok-num">3, n),
    class="tok-str">"bruit_aleatoire": np.random.randn(n),           class="tok-comment"># vraiment inutile
    class="tok-str">"code_postal":     np.random.randint(class="tok-num">0, class="tok-num">10000, n), class="tok-comment"># bruit haute cardinalité
})
y = (
    class="tok-num">0.4 * (X[class="tok-str">"revenu"] > class="tok-num">55)
    + class="tok-num">0.3 * (X[class="tok-str">"score_credit"] > class="tok-num">660)
    + class="tok-num">0.2 * (X[class="tok-str">"age"] > class="tok-num">35)
    + class="tok-num">0.1 * np.random.rand(n)
) > class="tok-num">0.5

X_train, X_val, y_train, y_val = train_test_split(X, y, test_size=class="tok-num">0.2, random_state=class="tok-num">42)

class="tok-comment"># ── class="tok-num">1. Entraîner la forêt aléatoire ───────────────────────────────────────────
rf = RandomForestClassifier(n_estimators=class="tok-num">100, random_state=class="tok-num">42)
rf.fit(X_train, y_train)

class="tok-comment"># ── class="tok-num">2. Importance par impureté (Gini) — rapide, intégrée ─────────────────────
imp_impurete = pd.Series(rf.feature_importances_, index=X.columns)
print(class="tok-str">"Importance par impureté :")
print(imp_impurete.sort_values(ascending=False).round(class="tok-num">3))
class="tok-comment"># ATTENTION : code_postal (haute cardinalité) peut sembler gonflé ici

class="tok-comment"># ── class="tok-num">3. Importance par permutation — agnostique, honnête ──────────────────────
perm = permutation_importance(
    rf, X_val, y_val,
    n_repeats=class="tok-num">10,       class="tok-comment"># mélanger class="tok-num">10 fois, prendre moyenne ± écart-type
    scoring=class="tok-str">"accuracy",
    random_state=class="tok-num">42,
    n_jobs=-class="tok-num">1
)
imp_perm = pd.DataFrame({
    class="tok-str">"moyenne":     perm.importances_mean,
    class="tok-str">"ecart_type":  perm.importances_std,
}, index=X.columns).sort_values(class="tok-str">"moyenne", ascending=False)

print(class="tok-str">"\nImportance par permutation :")
print(imp_perm.round(class="tok-num">3))
class="tok-comment"># bruit_aleatoire et code_postal seront proches de zéro ou négatifs

class="tok-comment"># ── class="tok-num">4. Comparer les deux méthodes ─────────────────────────────────────────────
comparaison = pd.DataFrame({
    class="tok-str">"impurete":    imp_impurete,
    class="tok-str">"permutation": perm.importances_mean,
}).sort_values(class="tok-str">"permutation", ascending=False)
print(class="tok-str">"\nComparaison (triée par permutation) :")
print(comparaison.round(class="tok-num">3))

class="tok-comment"># ── class="tok-num">5. Sélection via l'importance par permutation ────────────────────────────
selectionnees = imp_perm[imp_perm[class="tok-str">"moyenne"] > class="tok-num">0.01].index.tolist()
print(fclass="tok-str">"\nCaractéristiques sélectionnées ({len(selectionnees)}) : {selectionnees}")

∑

SHAP : Attribution Unifiée des Caractéristiques

math

SHAP (SHapley Additive exPlanations) unifie LIME, l'importance des caractéristiques et les mécanismes d'attention sous un cadre axiomatique unique. Chaque prédiction est décomposée en une somme de contributions par caractéristique (ϕ_j) plus une valeur de base. Contrairement à l'importance par permutation (globale), SHAP est local — il explique les prédictions individuelles. TreeSHAP calcule les valeurs Shapley exactes pour les ensembles d'arbres en temps polynomial via un algorithme basé sur les chemins, le rendant pratique pour les forêts aléatoires et XGBoost en production.

SHAP garantit : Σϕⱼ = f(x) − E[f(X)] ; TreeSHAP en O(TLD²)

⚠️

Les Caractéristiques Corrélées Divisent l'Importance Injustement

pitfall

Quand deux caractéristiques sont très corrélées (ex. revenu et score_credit), l'importance par permutation sous-estime les deux. Mélanger le revenu laisse score_credit intact, donc le modèle récupère la plupart du signal. L'importance conjointe réelle est partagée entre elles, mais chaque importance individuelle semble faible. Solution : utilisez l'importance par suppression de colonne ou SHAP avec regroupement conscient des corrélations. Sachez aussi que l'importance par permutation dépend du jeu de validation — les scores changent avec des divisions différentes.

N'interprétez jamais une importance par permutation quasi nulle comme 'inutile' pour des caractéristiques corrélées sans vérifier d'abord les corrélations deux à deux.

?Vérification des Connaissances

La progression est sauvegardée dans votre navigateur — aucun compte requis.

Optimisation des Hyperparamètres

Dépendance Partielle & Courbes ICE

Besoin d'un ingénieur IA ou data scientist ?

Je conçois des modèles ML sur mesure, des agents IA, de la vision par ordinateur et de l'automatisation — de l'idée à la production.

Me contacter Voir les services