— factory / algos ML / explication globale des modèles

IMPORTANCE PAR PERMUTATION.

Pour savoir si une variable compte pour un modèle, on la mélange au hasard entre les lignes et on regarde de combien la performance se dégrade. Si le modèle ne voit pas la différence, il ne s'en servait pas. Simple, applicable à tout modèle, c'est la façon la plus honnête de dire quelles variables comptent vraiment.

ExplicabilitéImportance des variablesModèle agnostiqueAssuranceNiveau : débutant

FICHE D'IDENTITÉ

notes sur 5 · usage entreprise

PerformanceMesure fiable si calculée sur des données de test

Interprétabilité« Sans cette variable, l'erreur augmente de tant » : clair

VitesseAutant de prédictions que de variables x répétitions

Facilité de réglageSeuls la métrique et le nombre de répétitions à choisir

Tolérance aux données brutesFaussée par les variables très corrélées entre elles

EN 30 SECONDES

Pour savoir si un joueur est indispensable à l'équipe, on le remplace par un joueur tiré au hasard et on regarde le score. Si l'équipe perd nettement, il comptait. Sinon, il faisait de la figuration.

1. On mesure la performance de référence

Le modèle entraîné prédit un jeu de test, et on calcule l'erreur avec la métrique métier.

2. On mélange une variable

On permute au hasard les valeurs d'une seule colonne entre les lignes. Le lien entre cette variable et la cible est cassé, tout le reste est intact.

3. On mesure la dégradation, et on répète

L'écart d'erreur est l'importance de la variable. On répète le mélange plusieurs fois pour obtenir une moyenne et un écart-type, puis on passe à la variable suivante.

LE CAS MÉTIER

tarification · assurance auto

EN ENTRÉE

Un modèle de fréquence de sinistres

Une Random Forest prédit le nombre de sinistres par an de 6 000 contrats, d'après l'âge du conducteur, la puissance, la zone et le bonus-malus. On ajoute une variable de bruit pur, sans aucun lien avec la sinistralité, comme témoin.

EN SORTIE

Un classement des variables, avec son incertitude

Sur le jeu d'exemple, l'âge du conducteur arrive très loin devant, suivi du bonus-malus puis de la zone. La puissance ne se distingue pas nettement du bruit : son effet est faible. La variable témoin a une importance quasi nulle, comme attendu.

CE QU'ON MESURE

Le piège de l'importance intégrée

L'importance « par impureté » fournie par défaut par les forêts donne 19 % de l'importance totale à la variable de bruit, devant la zone et la puissance. Elle favorise les variables continues aux nombreuses valeurs. La permutation sur données de test ne tombe pas dans ce piège.

QUAND LE SORTIR, QUAND L'ÉVITER

OUI

Savoir quelles variables comptent pour un modèle, quel que soit l'algorithme
Nettoyer un modèle : une variable d'importance nulle peut souvent être retirée
Détecter une fuite de données : une variable anormalement dominante
Présenter le modèle à un comité en langage clair

NON

Variables très corrélées (âge et ancienneté du permis) : chacune paraît peu importante, grouper les variables avant de permuter
Expliquer une prédiction individuelle : utiliser SHAP ou LIME
Savoir dans quel sens joue une variable : utiliser la dépendance partielle
Conclure à un lien de cause à effet : l'importance mesure l'usage fait par le modèle, pas la causalité

LES 4 CHOIX QUI COMPTENT

Noms donnés pour R (ranger, calcul intégré sur les données hors du sac) et Python (scikit-learn, sur un jeu de test).

Données : test ou hors du sac

Calculée sur les données d'entraînement, l'importance récompense aussi ce que le modèle a appris par cœur. Utiliser un jeu de test, ou les observations hors du sac (OOB) d'une forêt.

Métrique : scoring

La dégradation se mesure avec la métrique qui compte : déviance de Poisson pour une fréquence, AUC pour un score, erreur en euros pour un montant.

Répétitions : n_repeats

Le mélange est aléatoire. 10 à 30 répétitions donnent une moyenne et un écart-type ; une importance plus petite que son écart-type ne se distingue pas de zéro.

Variables catégorielles et corrélées

Une variable codée en plusieurs colonnes (zone) doit être mélangée d'un bloc. Pour des variables corrélées, les permuter ensemble ou n'en garder qu'une.

LE CODE MINIMAL

jeu d'exemple : sinistres.csv ↓

# Ce qui pèse sur la sinistralité : importance par permutation en R
library(ranger)

sin <- read.csv("sinistres.csv")
sin$zone <- factor(sin$zone)
sin$frequence <- sin$nb_sinistres / sin$exposition  # fréquence annuelle
set.seed(42)
sin$bruit <- rnorm(nrow(sin))                       # variable témoin, sans aucun lien
formule <- frequence ~ age_conducteur + puissance_cv + zone + bonus_malus + bruit

# Contrats tirés en proportion de leur exposition ; chaque variable est mélangée
# sur les contrats que l'arbre n'a pas vus (hors du sac, OOB) et on mesure la dégradation
perm <- ranger(formule, data = sin, num.trees = 300, min.node.size = 50,
               case.weights = sin$exposition, importance = "permutation", seed = 42)
impur <- ranger(formule, data = sin, num.trees = 300, min.node.size = 50,
                case.weights = sin$exposition, importance = "impurity", seed = 42)

resultat <- data.frame(permutation = importance(perm), impurete = importance(impur))
print(round(resultat[order(-resultat$permutation), ], 5))

# Ce qui pèse sur la sinistralité : importance par permutation en Python
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestRegressor
from sklearn.inspection import permutation_importance
from sklearn.model_selection import train_test_split

sin = pd.read_csv("sinistres.csv")
X = sin[["age_conducteur", "puissance_cv", "bonus_malus"]].copy()
X["zone"] = sin["zone"].map({"rural": 0, "periurbain": 1, "urbain": 2})   # une seule colonne à mélanger
X["bruit"] = np.random.default_rng(42).normal(size=len(X))   # variable témoin, sans aucun lien
y = sin["nb_sinistres"] / sin["exposition"]
X_train, X_test, y_train, y_test, w_train, w_test = train_test_split(
    X, y, sin["exposition"], test_size=0.3, random_state=42)

modele = RandomForestRegressor(n_estimators=300, min_samples_leaf=50, random_state=42)
modele.fit(X_train, y_train, sample_weight=w_train)

# On mélange chaque variable 20 fois sur les contrats de test et on mesure la dégradation
perm = permutation_importance(modele, X_test, y_test, sample_weight=w_test, n_repeats=20,
                              scoring="neg_mean_poisson_deviance", random_state=42)
resultat = pd.DataFrame({"perte_moyenne": perm.importances_mean, "ecart_type": perm.importances_std,
                         "importance_impurete": modele.feature_importances_}, index=X.columns)
print(resultat.sort_values("perte_moyenne", ascending=False).round(4))

QUESTIONS FRÉQUENTES

Qu'est-ce que l'importance par permutation ?

C'est une mesure de l'importance d'une variable pour un modèle déjà entraîné. On mélange au hasard les valeurs de cette variable, on recalcule la performance du modèle, et la perte de performance donne l'importance. La méthode a été proposée par Breiman en 2001 pour les forêts aléatoires, puis généralisée à tous les modèles.

Quelle différence entre importance par permutation et feature_importances_ ?

feature_importances_, dans scikit-learn, mesure la baisse d'impureté apportée par chaque variable dans les arbres, sur les données d'entraînement. Elle est rapide mais favorise les variables continues ou à nombreuses modalités, même sans lien réel avec la cible. L'importance par permutation, calculée sur des données de test, n'a pas ce biais.

Une importance par permutation négative, est-ce possible ?

Oui. Cela signifie que le modèle fait un peu mieux quand la variable est mélangée, ce qui arrive par hasard quand la variable est inutile. Une petite valeur négative, du même ordre que l'écart-type, doit se lire comme une importance nulle.