Importance des variables en R : avec vip et DALEX

Q: Comment calculer l’importance des variables en R ?

La voie la plus rapide est le package vip : ajustez votre modèle (pour une forêt aléatoire, avec importance = "permutation"), puis vip::vi(fit) pour la table classée et vip::vip(fit) pour le diagramme en barres. Pour l’importance agnostique au modèle qui fonctionne sur n’importe quel modèle, utilisez vip(fit, method = "permute", metric = ..., pred_wrapper = ...) ou DALEX : enveloppez le modèle avec explain() et appelez model_parts(). Les trois classent les prédicteurs selon la contribution de chacun aux prédictions.

Q: Comment fonctionne l’importance par permutation en R ?

L’importance par permutation mélange les valeurs d’un prédicteur (rompant son lien avec l’issue), re-score le modèle, et mesure de combien la performance chute — une forte chute signifie que le modèle s’est appuyé sur cette variable. En R, vip::vi(fit, method = "permute", metric = "roc_auc", pred_wrapper = ...) ou DALEX::model_parts() font cela, en faisant la moyenne sur plusieurs mélanges (nsim / B). Comme elle a seulement besoin que le modèle prédise, elle fonctionne pour n’importe quel modèle, pas seulement les arbres.

Q: Que fait le package vip en R ?

vip (“variable importance plots”) calcule et visualise l’importance des caractéristiques pour les modèles ajustés. vi(fit) renvoie la table d’importance ; vip(fit) trace le diagramme en barres classé. Il lit l’importance intégrée d’un modèle (forêt aléatoire, xgboost, coefficients glmnet) ou calcule l’importance par permutation agnostique au modèle via method = "permute". Il s’intègre bien à tidymodels — passez directement un workflow ajusté.

Découvrez quelles variables pèsent vraiment sur les prédictions d’un modèle — et classez-les avec un seul diagramme en barres

Un guide pratique de l’importance des variables en R : sur quels prédicteurs un modèle s’appuie, et dans quelle mesure. Découvrez l’importance spécifique au modèle (impureté et permutation d’une forêt aléatoire, coefficients glmnet) face à l’importance par permutation agnostique au modèle — mélangez une variable, mesurez la chute de performance, ce qui fonctionne pour N’IMPORTE QUEL modèle. Calculez et tracez le classement d’importance de deux façons : le package vip (vip(), vi()) et la voie agnostique au modèle de DALEX (model_parts()), lisez le diagramme en barres et comprenez les mises en garde (variables corrélées, l’importance n’est pas la causalité). Sur les données PimaIndiansDiabetes2.

Date de publication

25 juin 2026

Modifié

7 juillet 2026

L’essentiel à retenir

L’importance des variables répond à la question la plus posée à propos de tout modèle : quelles variables pèsent vraiment sur ses prédictions, et dans quelle mesure ? Un diagramme en barres classé est la sortie emblématique — le levier qui transforme une boîte noire en quelque chose que vous pouvez expliquer.
L’importance spécifique au modèle lit les rouages internes du modèle : l’impureté (Gini) d’une forêt aléatoire ou son importance par permutation intégrée, l’ampleur des coefficients d’un glmnet. Rapide, mais liée à ce seul type de modèle — et l’importance par impureté est biaisée en faveur des prédicteurs à forte cardinalité.
L’importance par permutation agnostique au modèle fonctionne pour n’importe quel modèle : mélangez les valeurs d’une variable, re-scorez, et mesurez de combien la performance chute. Une forte chute signifie que le modèle s’est appuyé sur cette variable. Elle est intuitive, fiable, et permet de comparer une forêt et un modèle linéaire sur un pied d’égalité.
Deux packages font le travail : vip (vip() pour tracer, vi() pour la table) lit l’importance spécifique au modèle ou par permutation ; DALEX (explain() + model_parts()) est la voie agnostique au modèle qui passe par un explicateur unifié.
Des mises en garde qui comptent : l’importance n’est pas la causalité, des variables corrélées se partagent (et donc diluent) leur importance mutuelle, et l’échelle dépend de la fonction de perte. Lisez le classement, pas les chiffres exacts.

Introduction

Vous avez ajusté un modèle — une forêt aléatoire, disons — et il prédit bien le diabète. La question suivante que votre collègue (ou votre relecteur, ou vous-même plus tard) posera n’est pas quelle est sa précision ? mais pourquoi prédit-il cela ? Sur quelles mesures le modèle s’appuie-t-il réellement — glucose, IMC, âge ? — et lesquelles ne font guère bouger l’aiguille ? Y répondre transforme un prédicteur opaque en quelque chose que vous pouvez expliquer, en quoi avoir confiance et sur quoi agir. C’est le cœur de l’explicabilité des modèles, et l’importance des variables en est l’outil le plus direct.

L’importance des variables (alias importance des caractéristiques) classe les prédicteurs selon la contribution de chacun aux prédictions du modèle. Il en existe deux grandes familles. Les mesures spécifiques au modèle lisent les rouages internes d’un modèle particulier — l’impureté de split d’une forêt aléatoire, la taille des coefficients d’une régression pénalisée — elles sont donc rapides mais définies pour ce seul type de modèle. L’importance par permutation agnostique au modèle contourne cela : elle mélange une variable à la fois et mesure de combien la performance du modèle chute, ce qui fonctionne pour n’importe quel modèle et est simple à appréhender. Cette leçon ajuste un modèle sur de vraies données cliniques, puis l’explique des deux façons avec les deux packages de référence — vip et DALEX — trace le diagramme en barres emblématique de l’importance, et détaille les mises en garde qui vous gardent honnête.

C’est le levier “the runtime is the judge” en action : nous ne nous contentons pas d’affirmer quelles variables comptent, nous le calculons, de façon exécutable, à partir d’un modèle ajusté sur des données que vous pouvez réexécuter.

Quand y recourir

Recourez à l’importance des variables chaque fois que vous devez expliquer un modèle ajusté : pour vérifier qu’il s’appuie sur des prédicteurs sensés (et non sur une colonne d’identifiant fuyante), pour élaguer les variables faibles, pour communiquer le modèle à une partie prenante non technique, ou pour comparer ce à quoi deux modèles différents prêtent attention. Utilisez l’importance spécifique au modèle quand elle est peu coûteuse et que vous faites confiance au type de modèle (p. ex. l’importance par permutation d’une forêt) ; utilisez l’importance par permutation agnostique au modèle quand vous voulez une méthode qui fonctionne sur tous vos modèles — ou quand le modèle n’a aucune importance native du tout.

Les données

Nous utilisons le jeu de données PimaIndiansDiabetes2 du package mlbench : 768 femmes d’origine Pima, avec pour objectif de prédire le diabetes (une issue binaire pos/neg) à partir de huit prédicteurs cliniques — nombre de grossesses (pregnant), glucose plasmatique, pressure artérielle, épaisseur du pli cutané du triceps, insulin sérique, indice de mass corporelle, la fonction pedigree du diabète, et age.

Cette version comporte des valeurs manquantes (notées NA là où une mesure est invraisemblable, p. ex. un glucose à zéro). Nous écartons les lignes incomplètes, ce qui laisse 392 enregistrements complets, puis nous séparons en un ensemble d’entraînement (80 %, pour ajuster le modèle) et un ensemble de test (20 %, mis de côté). Nous stratifions sur diabetes pour que les deux ensembles conservent le même équilibre positif/négatif, et nous fixons une graine pour la reproductibilité :

library(rsample)
data("PimaIndiansDiabetes2", package = "mlbench")

# Drop rows with missing measurements
pima <- na.omit(PimaIndiansDiabetes2)

set.seed(123)
split      <- initial_split(pima, prop = 0.80, strata = diabetes)
train_data <- training(split)
test_data  <- testing(split)

c(complete = nrow(pima), train = nrow(train_data), test = nrow(test_data))

complete    train     test 
     392      313       79

# The stratified split preserves the class balance
prop.table(table(train_data$diabetes))


      neg       pos 
0.6677316 0.3322684

head(pima, 4)

  pregnant glucose pressure triceps insulin mass pedigree age diabetes
4        1      89       66      23      94 28.1    0.167  21      neg
5        0     137       40      35     168 43.1    2.288  33      pos
7        3      78       50      32      88 31.0    0.248  26      pos
9        2     197       70      45     543 30.5    0.158  53      pos

Soit 313 patients pour apprendre, 79 mis de côté, et 8 prédicteurs à classer. Environ un tiers des patients sont diabétiques positifs. Nous ajusterons un seul modèle — une forêt aléatoire — et passerons le reste de la leçon à l’expliquer.

Ajuster un modèle à expliquer

L’importance des variables explique un modèle ajusté, il nous en faut donc un d’abord. Une forêt aléatoire est le choix naturel ici : elle capture automatiquement les effets non linéaires et les interactions, ne nécessite aucune mise à l’échelle, et est un classifieur prêt à l’emploi performant. Nous l’ajustons via le workflow tidymodels avec le moteur ranger, en lui demandant l’importance par permutation pour que la forêt suive aussi à quel point chaque prédicteur compte. (Pour la forêt elle-même — le bagging, l’erreur OOB, le réglage de mtry — voir forêt aléatoire ; ici c’est juste le modèle que nous expliquons.)

library(rsample)
library(parsnip)
library(workflows)
library(recipes)
data("PimaIndiansDiabetes2", package = "mlbench")
pima <- na.omit(PimaIndiansDiabetes2)

set.seed(123)
split      <- initial_split(pima, prop = 0.80, strata = diabetes)
train_data <- training(split)

# A plain recipe (forests need no preprocessing) + a 500-tree ranger forest
rec     <- recipe(diabetes ~ ., data = train_data)
rf_spec <- rand_forest(trees = 500) |>
  set_engine("ranger", importance = "permutation") |>
  set_mode("classification")

rf_fit <- workflow() |>
  add_recipe(rec) |>
  add_model(rf_spec) |>
  fit(data = train_data)

rf_fit

══ Workflow [trained] ══════════════════════════════════════════════════════════
Preprocessor: Recipe
Model: rand_forest()

── Preprocessor ────────────────────────────────────────────────────────────────
0 Recipe Steps

── Model ───────────────────────────────────────────────────────────────────────
Ranger result

Call:
 ranger::ranger(x = maybe_data_frame(x), y = y, num.trees = ~500,      importance = ~"permutation", num.threads = 1, verbose = FALSE,      seed = sample.int(10^5, 1), probability = TRUE) 

Type:                             Probability estimation 
Number of trees:                  500 
Sample size:                      313 
Number of independent variables:  8 
Mtry:                             2 
Target node size:                 10 
Variable importance mode:         permutation 
Splitrule:                        gini 
OOB prediction error (Brier s.):  0.1495451

La forêt est ajustée. Comme nous avons défini importance = "permutation" sur le moteur, il a calculé l’importance par permutation de chaque prédicteur pendant l’ajustement — la chute moyenne de performance lorsque les valeurs de ce prédicteur sont mélangées. Lisons maintenant ce classement.

Importance spécifique au modèle avec vip

Le package vip (“variable importance plots”) est la voie la plus rapide vers un classement. Son vi() renvoie la table d’importance ; son vip() trace le diagramme en barres directement à partir d’un modèle ajusté. Comme notre forêt suit déjà l’importance par permutation, vip se contente de la lire :

library(rsample)
library(parsnip)
library(workflows)
library(recipes)
library(vip)
data("PimaIndiansDiabetes2", package = "mlbench")
pima <- na.omit(PimaIndiansDiabetes2)

set.seed(123)
split      <- initial_split(pima, prop = 0.80, strata = diabetes)
train_data <- training(split)

rec     <- recipe(diabetes ~ ., data = train_data)
rf_spec <- rand_forest(trees = 500) |>
  set_engine("ranger", importance = "permutation") |>
  set_mode("classification")
rf_fit  <- workflow() |> add_recipe(rec) |> add_model(rf_spec) |> fit(data = train_data)

# The importance table: one row per predictor, ranked by importance
vi(rf_fit)

# A tibble: 8 × 2
  Variable Importance
  <chr>         <dbl>
1 glucose     0.0524 
2 age         0.0220 
3 insulin     0.0183 
4 pregnant    0.0106 
5 mass        0.00804
6 triceps     0.00699
7 pedigree    0.00585
8 pressure    0.00183

vi() renvoie une table nette — chaque prédicteur avec son score d’Importance — déjà triée du plus au moins important. glucose est en tête de liste avec une marge nette, puis age et insulin. Cela correspond à l’histoire clinique : le glucose plasmatique et l’âge sont des marqueurs de risque du diabète classiques. pressure et pedigree se situent près du bas — la forêt s’en sert à peine.

La figure emblématique est le diagramme en barres de l’importance. vip() le trace en un seul appel ; nous le colorons dans l’azur de la marque et soignons les étiquettes :

library(rsample)
library(parsnip)
library(workflows)
library(recipes)
library(vip)
library(ggplot2)
data("PimaIndiansDiabetes2", package = "mlbench")
pima <- na.omit(PimaIndiansDiabetes2)

set.seed(123)
split      <- initial_split(pima, prop = 0.80, strata = diabetes)
train_data <- training(split)

rec     <- recipe(diabetes ~ ., data = train_data)
rf_spec <- rand_forest(trees = 500) |>
  set_engine("ranger", importance = "permutation") |>
  set_mode("classification")
rf_fit  <- workflow() |> add_recipe(rec) |> add_model(rf_spec) |> fit(data = train_data)

# vip() draws the ranked bar plot straight from the fitted model
vip(rf_fit, num_features = 8, geom = "col",
    aesthetics = list(fill = "#3a86d4", width = 0.7)) +
  labs(title = "Variable importance (random forest, Pima diabetes)",
       subtitle = "Permutation importance: the drop in performance when each predictor is shuffled") +
  theme_minimal()

Variable-importance bar plot from the random forest on the Pima diabetes data: horizontal bars ordered by permutation importance, with glucose far ahead at the top, then age and insulin, and pressure and pedigree shortest at the bottom — showing which predictors the model relies on most.

Lisez-le de haut en bas : plus la barre est longue, plus la performance du modèle chute lorsque vous mélangez ce prédicteur — c’est-à-dire plus il en dépend. glucose domine avec une large marge ; age et insulin suivent ; pressure et pedigree se font à peine remarquer. Cette seule image est ce qui rend un modèle explicable — et c’est le graphique à mettre sous les yeux d’une partie prenante qui veut savoir ce que le modèle « regarde ».

Importance par impureté vs par permutation — laquelle la forêt rapporte-t-elle ?

Une forêt aléatoire peut rapporter deux mesures spécifiques au modèle. L’importance par impureté (Gini) somme la réduction d’impureté de nœud due aux splits de chaque prédicteur — elle est gratuite (calculée pendant l’entraînement) mais biaisée en faveur des prédicteurs à forte cardinalité et continus, et calculée sur les données d’entraînement. L’importance par permutation (ce que nous avons demandé avec importance = "permutation") mélange chaque prédicteur sur des données out-of-bag tenues à l’écart et mesure la chute de précision — plus lente mais fiable. Quand les deux divergent, préférez la permutation. Définissez set_engine("ranger", importance = "impurity") pour voir l’autre.

Importance par permutation agnostique au modèle avec vip

L’importance par permutation intégrée de la forêt est pratique, mais elle n’existe que parce que ranger la calcule. Qu’en est-il d’un modèle sans importance native — un SVM, un modèle des k plus proches voisins, un ensemble sur mesure ? La réponse est l’importance par permutation agnostique au modèle : la même idée, mais appliquée de l’extérieur, à n’importe quel modèle ajusté. La recette est simple :

Scorez le modèle sur un jeu de données (ici, les prédictions face aux vraies étiquettes) — c’est la référence.
Mélangez la colonne d’un prédicteur (détruisant son lien avec l’issue) et re-scorez.
La chute de performance est l’importance de ce prédicteur. Répétez pour chaque prédicteur.

vip fait cela avec method = "permute", en lui donnant une métrique, une enveloppe de prédiction et les données. Comme le résultat dépend des mélanges aléatoires, nous faisons la moyenne sur plusieurs répétitions et fixons une graine :

library(rsample)
library(parsnip)
library(workflows)
library(recipes)
library(vip)
data("PimaIndiansDiabetes2", package = "mlbench")
pima <- na.omit(PimaIndiansDiabetes2)

set.seed(123)
split      <- initial_split(pima, prop = 0.80, strata = diabetes)
train_data <- training(split)

rec     <- recipe(diabetes ~ ., data = train_data)
rf_spec <- rand_forest(trees = 500) |>
  set_engine("ranger") |>          # no built-in importance needed — we permute from outside
  set_mode("classification")
rf_fit  <- workflow() |> add_recipe(rec) |> add_model(rf_spec) |> fit(data = train_data)

# A prediction wrapper returning the positive-class probability, and an AUC metric
pred_prob <- function(object, newdata) {
  predict(object, new_data = newdata, type = "prob")$.pred_pos
}

set.seed(123)
vi_perm <- vi(rf_fit, method = "permute",
              target = "diabetes", metric = "roc_auc", event_level = "first",
              pred_wrapper = pred_prob, nsim = 25, train = train_data)
vi_perm

# A tibble: 8 × 3
  Variable Importance   StDev
  <chr>         <dbl>   <dbl>
1 pressure   -0.00947 0.00121
2 pregnant   -0.0107  0.00170
3 triceps    -0.0131  0.00140
4 mass       -0.0189  0.00268
5 pedigree   -0.0191  0.00250
6 age        -0.0332  0.00460
7 insulin    -0.0334  0.00507
8 glucose    -0.0855  0.0120

Cela a calculé l’importance sans toucher aux rouages internes de la forêt — il a mélangé chaque colonne, demandé au workflow ajusté de prédire, et mesuré la chute de ROC AUC, répétée 25 fois. Le message principal est le même qu’ avant : glucose domine, avec age et insulin ensuite (l’ordre exact du milieu peut bouger un peu, car une métrique différente et une nouvelle série de mélanges mesurent des choses subtilement différentes — lisez le classement, pas les écarts infimes). Le point crucial est que ce code exact fonctionnerait sur n’importe quel modèle doté d’une méthode predict — remplacez la forêt par un SVM ou un kNN et l’importance se calcule quand même. Cette universalité est tout l’ attrait de l’approche par permutation. La colonne StDev montre la stabilité de chaque estimation à travers les 25 mélanges.

La voie DALEX : un explicateur unifié

L’autre grande boîte à outils agnostique au modèle est DALEX (“Descriptive mAchine Learning EXplanations”). Sa conception est différente et mérite d’être connue : vous enveloppez votre modèle une fois dans un explicateur, et chaque explication — importance des variables, dépendance partielle, profils de décomposition — découle de cet unique objet. Pour l’importance, vous appelez model_parts(), qui est l’importance par permutation sous le capot :

library(rsample)
library(parsnip)
library(workflows)
library(recipes)
library(DALEX)
data("PimaIndiansDiabetes2", package = "mlbench")
pima <- na.omit(PimaIndiansDiabetes2)

set.seed(123)
split      <- initial_split(pima, prop = 0.80, strata = diabetes)
train_data <- training(split)

rec     <- recipe(diabetes ~ ., data = train_data)
rf_spec <- rand_forest(trees = 500) |> set_engine("ranger") |> set_mode("classification")
rf_fit  <- workflow() |> add_recipe(rec) |> add_model(rf_spec) |> fit(data = train_data)

# Build the explainer once: model + data + a numeric 0/1 outcome
y_num <- ifelse(train_data$diabetes == "pos", 1, 0)
explainer <- explain(
  rf_fit,
  data = subset(train_data, select = -diabetes),
  y = y_num,
  predict_function = function(m, d) predict(m, new_data = d, type = "prob")$.pred_pos,
  label = "random forest",
  verbose = FALSE
)

# Permutation variable importance (averaged over several permutations)
set.seed(123)
vip_dalex <- model_parts(explainer, B = 25)
vip_dalex

       variable mean_dropout_loss         label
1  _full_model_         0.2284692 random forest
2      pressure         0.2607675 random forest
3      pregnant         0.2670655 random forest
4       triceps         0.2699222 random forest
5      pedigree         0.2737970 random forest
6          mass         0.2811900 random forest
7           age         0.3030346 random forest
8       insulin         0.3067687 random forest
9       glucose         0.3521863 random forest
10   _baseline_         0.5637251 random forest

model_parts() rapporte le dropout_loss de chaque variable — la perte du modèle après que cette variable a été permutée, moyennée sur B = 25 mélanges. (Ici la perte est le RMSE entre la probabilité prédite et l’issue 0/1, le défaut de DALEX pour un y numérique ; vous pouvez le changer avec l’argument loss_function — c’est le classement qui compte.) Une variable dont la permutation pousse la perte vers le haut le plus est la plus importante. _full_model_ est la perte sans rien de mélangé (la référence) et _baseline_ est la perte avec tout mélangé (le pire cas) — chaque variable réelle se situe entre les deux. glucose fait de nouveau bouger la perte le plus, avec une marge nette.

DALEX fournit sa propre méthode plot(), qui dessine l’importance sous forme de diagramme en barres avec la référence marquée. Nous l’utilisons directement, puis la restylons aux couleurs maison :

library(rsample)
library(parsnip)
library(workflows)
library(recipes)
library(DALEX)
library(ggplot2)
data("PimaIndiansDiabetes2", package = "mlbench")
pima <- na.omit(PimaIndiansDiabetes2)

set.seed(123)
split      <- initial_split(pima, prop = 0.80, strata = diabetes)
train_data <- training(split)

rec     <- recipe(diabetes ~ ., data = train_data)
rf_spec <- rand_forest(trees = 500) |> set_engine("ranger") |> set_mode("classification")
rf_fit  <- workflow() |> add_recipe(rec) |> add_model(rf_spec) |> fit(data = train_data)

y_num <- ifelse(train_data$diabetes == "pos", 1, 0)
explainer <- explain(rf_fit, data = subset(train_data, select = -diabetes), y = y_num,
                     predict_function = function(m, d) predict(m, new_data = d, type = "prob")$.pred_pos,
                     label = "random forest", verbose = FALSE)
set.seed(123)
vip_dalex <- model_parts(explainer, B = 25)

# DALEX's own plot, with the brand colour
plot(vip_dalex) +
  labs(title = "Permutation variable importance (DALEX)") +
  theme_minimal()

DALEX permutation variable-importance bar plot for the random forest on the Pima diabetes data: bars showing the RMSE loss after permuting each feature, with glucose producing the largest loss increase at the top, then insulin and age, confirming glucose as the top driver as the vip package did.

Même variable de tête, package différent — une vérification croisée rassurante. glucose mène ici aussi, avec insulin et age juste derrière ; l’ordre du milieu diffère légèrement du graphique vip parce qu’une perte différente (RMSE ici vs la chute d’AUC plus tôt) et de nouveaux mélanges pondèrent les variables un peu différemment. C’est exactement pourquoi vous lisez le classement et la taille des écarts, pas l’ordre exact des quasi-égalités — glucose est sans ambiguïté premier sous chaque méthode, ce qui est la conclusion qui compte. La longueur de la barre est la perte lorsque la variable est permutée, et la ligne en pointillés est la référence du modèle complet. La vraie valeur du schéma DALEX est que cet unique objet explicateur est aussi le point d’entrée vers la dépendance partielle & ICE et les valeurs SHAP — construisez l’ explicateur une fois, expliquez le modèle de bien des façons.

Interpréter l’importance — et ses mises en garde

Un graphique d’importance des variables est puissant, mais il est aussi facile à sur-interpréter. Gardez quatre choses à l’esprit :

L’importance n’est pas la causalité. Une variable à forte importance est une variable sur laquelle le modèle s’appuie pour prédire — pas nécessairement une cause de l’issue. Le fait que glucose se classe premier ne prouve pas que le glucose cause le diabète ici ; cela signifie que les prédictions de ce modèle en dépendent fortement. L’importance décrit le modèle, pas le monde.
Les variables corrélées se partagent l’importance. Si deux prédicteurs sont fortement corrélés, le modèle peut utiliser l’un ou l’autre, donc permuter juste l’un ne nuit guère à la performance (l’autre porte encore le signal) — et les deux paraissent moins importants que la paire ne l’est réellement. Quand vous voyez deux variables liées toutes deux classées au milieu, soupçonnez cela. (L’importance groupée de DALEX et SHAP gèrent cela plus gracieusement.)
L’échelle dépend de la perte. L’importance par permutation se mesure en unités de la métrique choisie (chute d’AUC, hausse de RMSE, …). Les chiffres ne sont pas comparables entre métriques ou entre modèles à pertes différentes. Lisez le classement et les écarts relatifs, pas les valeurs absolues.
Spécifique au modèle ≠ agnostique au modèle. L’importance par impureté d’une forêt, son importance par permutation, et une passe de permutation DALEX peuvent classer les variables un peu différemment — elles mesurent des choses subtilement différentes. Quand une décision en dépend, préférez la permutation sur des données tenues à l’écart et confirmez avec une seconde méthode.

L’importance par permutation, formellement (optionnel)

Soit un modèle $f$ atteignant une performance de référence $L_0$ sur un jeu de données, mesurée par une perte $L$ (plus bas est mieux ; p. ex. $1 - \mathrm{AUC}$, ou RMSE). Pour un prédicteur $j$, l’importance par permutation demande : de combien le modèle fait-il pire lorsque la variable $j$ est rendue non informative ?

Prenez la matrice des variables, permutez aléatoirement la colonne du prédicteur $j$ (de sorte que ses valeurs ne s’alignent plus sur les lignes), et réévaluez le modèle pour obtenir une perte permutée $L_j$. L’importance du prédicteur $j$ est l’augmentation de la perte :

\[ \mathrm{VI}_j = L_j - L_0 . \]

Si $j$ portait un vrai signal utilisé par le modèle, le mélanger gonfle la perte, donc $\mathrm{VI}_j$ est grand ; si le modèle ne s’est jamais appuyé sur $j$, la perte bouge à peine et $\mathrm{VI}_j \approx 0$. Comme un seul mélange est bruité, nous répétons la permutation $B$ fois et faisons la moyenne :

\[ \overline{\mathrm{VI}}_j = \frac{1}{B} \sum_{b=1}^{B} \left( L_j^{(b)} - L_0 \right) . \]

Certaines implémentations rapportent le ratio $L_j / L_0$ au lieu de la différence, et DALEX rapporte la perte permutée $L_j$ elle-même (avec $L_0$ tracée comme ligne de référence) plutôt que la différence — mais l’ ordre des variables est le même. La méthode ne fait aucune hypothèse sur $f$ : elle a seulement besoin de prédire, donc elle fonctionne pour n’importe quel modèle. C’est exactement pourquoi elle est l’importance agnostique au modèle canonique.

Quelle méthode devrais-je utiliser ?

Un repère de décision rapide :

Un modèle avec une bonne importance intégrée (forêt aléatoire, gradient boosting) ? Lisez-la directement avec vip(fit) — rapide, et l’importance par permutation de la forêt est fiable. Évitez l’importance brute par impureté quand les prédicteurs diffèrent fortement en cardinalité.
N’importe quel autre modèle, ou la comparaison de plusieurs modèles ? Utilisez l’importance par permutation agnostique au modèle (vip(..., method = "permute") ou DALEX::model_parts()) — une méthode, chaque modèle, des données tenues à l’écart.
Des variables corrélées, ou vous voulez des attributions par prédiction ? Recourez aux valeurs SHAP, qui répartissent le crédit entre variables corrélées plus équitablement et expliquent les prédictions individuelles.
Vous voulez la forme de l’effet d’une variable, pas seulement son rang ? C’est la dépendance partielle & ICE.

🟢 Avec un agent IA

Vous avez un modèle ajusté et voulez savoir sur quoi il s’appuie réellement ? Demandez à Prova “calcule l’importance des variables pour ce modèle et trace le classement” — elle répond avec du code vip / DALEX que vous pouvez exécuter sur votre propre modèle et vos données, puis vous aide à lire le diagramme en barres, à repérer la dilution par variables corrélées, et à choisir entre importance spécifique au modèle et agnostique au modèle. The runtime is the judge. Ask Prova →

Problèmes courants

vip() renvoie la mauvaise chose ou un graphique vide. vip, ranger, randomForest et caret exportent tous un assistant de style importance/vi, donc le mauvais peut être dans la portée. Appelez vip::vip() / vip::vi() avec l’espace de noms, et pour l’importance spécifique au modèle, ajustez le moteur avec importance = "permutation" (ou "impurity") — sans cela il n’y a rien à lire.
L’importance par permutation donne des chiffres différents à chaque exécution. Les mélanges sont aléatoires. Définissez set.seed() avant vi(..., method = "permute") / model_parts(), et augmentez nsim / B pour faire la moyenne sur davantage de permutations et obtenir une estimation plus stable (surveillez la colonne StDev).
DALEX::explain() échoue sur l’issue ou les prédictions. Pour un classifieur binaire, passez un y numérique 0/1 et une predict_function qui renvoie la probabilité de la classe positive (un simple vecteur numérique), pas l’étiquette factorielle ni le data frame complet de probabilités. Construisez-la comme function(m, d) predict(m, new_data = d, type = "prob")$.pred_pos.
Deux prédicteurs corrélés paraissent tous deux sans importance. Permuter l’un ne nuit guère parce que l’autre porte encore le signal — la dilution par variables corrélées classique. Vérifiez les corrélations entre variables, regroupez les variables liées, ou utilisez SHAP, qui partage le crédit plus équitablement.
Une variable fuyante domine le classement. Si un prédicteur est d’une importance invraisemblable, soupçonnez une fuite (un identifiant, une mesure postérieure à l’issue). La forte importance d’une variable qui « ne devrait pas » compter est un signal d’alarme invitant à enquêter sur les données, pas un résultat à rapporter.

Questions fréquentes

Comment calculer l’importance des variables en R ?

La voie la plus rapide est le package vip : ajustez votre modèle (pour une forêt aléatoire, avec importance = "permutation"), puis vip::vi(fit) pour la table classée et vip::vip(fit) pour le diagramme en barres. Pour l’importance agnostique au modèle qui fonctionne sur n’importe quel modèle, utilisez vip(fit, method = "permute", metric = ..., pred_wrapper = ...) ou DALEX : enveloppez le modèle avec explain() et appelez model_parts(). Les trois classent les prédicteurs selon la contribution de chacun aux prédictions.

Comment obtenir l’importance des caractéristiques en R ?

« Importance des caractéristiques » et « importance des variables » désignent la même chose. Utilisez vip::vip(fit) pour la tracer à partir d’un modèle ajusté (les forêts aléatoires, le gradient boosting et glmnet portent tous une importance intégrée), ou calculez-la pour n’importe quel modèle avec l’importance par permutation — vip(fit, method = "permute", ...) ou DALEX::model_parts(). La sortie est un classement des prédicteurs du plus au moins influent, mieux lu comme un diagramme en barres.

Comment fonctionne l’importance par permutation en R ?

L’importance par permutation mélange les valeurs d’un prédicteur (rompant son lien avec l’issue), re-score le modèle, et mesure de combien la performance chute — une forte chute signifie que le modèle s’est appuyé sur cette variable. En R, vip::vi(fit, method = "permute", metric = "roc_auc", pred_wrapper = ...) ou DALEX::model_parts() font cela, en faisant la moyenne sur plusieurs mélanges (nsim / B). Comme elle a seulement besoin que le modèle prédise, elle fonctionne pour n’importe quel modèle, pas seulement les arbres.

Que fait le package vip en R ?

vip (“variable importance plots”) calcule et visualise l’importance des caractéristiques pour les modèles ajustés. vi(fit) renvoie la table d’importance ; vip(fit) trace le diagramme en barres classé. Il lit l’importance intégrée d’un modèle (forêt aléatoire, xgboost, coefficients glmnet) ou calcule l’importance par permutation agnostique au modèle via method = "permute". Il s’intègre bien à tidymodels — passez directement un workflow ajusté.

L’importance des variables signifie-t-elle qu’une variable cause l’issue ?

Non. L’importance des variables vous dit sur quelles variables le modèle s’appuie pour prédire, pas quelles variables causent l’issue. Un prédicteur à forte importance peut être corrélé à la vraie cause, ou propre à ce modèle. L’importance décrit le comportement du modèle, pas le mécanisme sous-jacent — ne lisez jamais un classement comme une affirmation causale.

Testez vos connaissances

Exercice : classer l’importance d’une forêt aléatoire sur les données iris

Ajustez un classifieur à forêt aléatoire sur les données iris (prédire Species à partir des quatre mesures florales) via un workflow tidymodels avec importance = "permutation", puis utilisez vip pour produire la table classée d’importance et le diagramme en barres. Quelles deux mesures pilotent la prédiction de l’espèce ?

Indice

La forme est identique à la forêt de la leçon, avec iris et Species. Vous aurez besoin de parsnip, workflows, recipes et vip. Ajustez avec rand_forest(trees = 500) |> set_engine("ranger", importance = "permutation") |> set_mode("classification"), puis vi(fit) et vip(fit).

Solution

library(parsnip); library(workflows); library(recipes); library(vip); library(ggplot2)

rec     <- recipe(Species ~ ., data = iris)
rf_spec <- rand_forest(trees = 500) |>
  set_engine("ranger", importance = "permutation") |>
  set_mode("classification")
rf_fit  <- workflow() |> add_recipe(rec) |> add_model(rf_spec) |> fit(data = iris)

vi(rf_fit)                                   # the ranked table
vip(rf_fit, geom = "col",
    aesthetics = list(fill = "#3a86d4")) +   # the bar plot
  theme_minimal()

Petal.Length et Petal.Width ressortent loin devant — les mesures des pétales séparent les trois espèces d’iris presque parfaitement, tandis que les mesures des sépales contribuent bien moins. Le classement correspond à ce que vous verriez dans un nuage de points de la longueur vs la largeur des pétales.

Vérification rapide. Vous calculez l’importance par permutation agnostique au modèle pour deux prédicteurs fortement corrélés et les deux ressortent avec une faible importance, même si vous soupçonnez qu’au moins l’un est réellement utile. Que se passe-t-il, et que feriez-vous ?

Afficher la réponse

C’est la dilution par variables corrélées. Quand deux prédicteurs portent la même information, permuter l’un ne nuit guère à la performance — le modèle s’appuie simplement sur son jumeau corrélé — donc chacun paraît sans importance en isolation, même si la paire compte. Ne concluez pas que l’une ou l’autre variable est inutile. Vérifiez la corrélation entre elles, envisagez de les regrouper (ou d’en supprimer une), et utilisez une méthode qui partage le crédit plus équitablement à travers les variables corrélées, comme les valeurs SHAP ou l’importance groupée de DALEX.

Conclusion

Vous avez expliqué un modèle ajusté de bout en bout sur les données PimaIndiansDiabetes2 : vous avez ajusté une forêt aléatoire, puis classé ses prédicteurs de deux façons — l’importance spécifique au modèle lue directement depuis la forêt avec vip::vi()/vip(), et l’importance par permutation agnostique au modèle (mélangez une variable, mesurez la chute) calculée à la fois avec le method = "permute" de vip et avec l’explain() + model_parts() de DALEX. Les trois se sont accordées sur le titre — glucose pilote ce modèle avec une large marge, avec age et insulin ensuite — même là où les méthodes ont mélangé un peu différemment les quasi-égalités classées au milieu. Vous avez tracé le diagramme en barres de l’importance emblématique, et appris les mises en garde qui gardent la lecture honnête — l’importance n’est pas la causalité, les variables corrélées se diluent mutuellement, et l’échelle dépend de la métrique, donc lisez le classement, pas les chiffres exacts. La règle pratique : utilisez l’importance intégrée quand vous lui faites confiance, l’importance par permutation quand vous avez besoin d’une méthode pour n’importe quel modèle, et ne confondez jamais « le modèle s’appuie dessus » avec « cela cause l’ issue ».

Ensuite, voyez comment l’effet d’une variable infléchit réellement la prédiction dans la dépendance partielle & ICE, ou répartissez le crédit d’une prédiction unique entre les variables avec les valeurs SHAP.

Leçons connexes

Valeurs SHAP — répartir le crédit d’une prédiction unique entre les variables, plus juste sur les prédicteurs corrélés. · Dépendance partielle & ICE — la forme de l’effet d’une variable, pas seulement son rang. · Forêt aléatoire — le modèle que nous avons expliqué ici, avec sa propre importance intégrée. · Construire & valider des modèles avec tidymodels — le workflow séparation → recipe → ajustement que cette leçon réutilise.
Pour aller plus loin : valeurs SHAP · dépendance partielle & ICE · forêt aléatoire · construire des modèles avec tidymodels. · Explicabilité & confiance — la série complète. · Machine Learning — le pilier.

Vous préférez un livre ? Machine Learning Essentials est disponible en PDF téléchargeable — toutes les leçons de cette série, hors ligne et à vous.

Obtenir le livre (PDF) →Les leçons restent gratuites en ligne.

Cette page vous a-t-elle été utile ?

Prouvez que vous savez le faire. Maîtrisez toute la série Explicabilité des modèles en R — suivez votre parcours, construisez des projets et obtenez un certificat.

Commencer gratuitement →

Passez à Pro — Prova illimité sur vos propres données et un certificat vérifiable qui atteste la compétence.

dès 15 $/mois facturé annuellement

Passer à Pro →

✓ Vous êtes Pro — continuez. The runtime is the judge.

Prêt à passer à la vitesse supérieure ?

Essayez sur vos propres données avec Prova — the runtime is the judge.Ouvrir Prova →

Note

Cette leçon est reproductible : chaque score d’importance, table et figure a été produit par le code montré — copiez n’importe quel bloc et exécutez-le pour les reproduire. The runtime is the judge.

Références

Breiman, L. (2001). Random Forests. Machine Learning, 45(1), 5–32. (L’idée de l’importance par permutation.)
Greenwell, B. M., & Boehmke, B. C. (2020). Variable Importance Plots — An Introduction to the vip Package. The R Journal, 12(1), 343–366.
Biecek, P. (2018). DALEX: Explainers for Complex Predictive Models in R. Journal of Machine Learning Research, 19(84), 1–5.
Molnar, C. (2022). Interpretable Machine Learning: A Guide for Making Black Box Models Explainable (2nd ed.). Free online.
Kuhn, M., & Silge, J. Tidy Modeling with R. Free online (CC BY-NC-SA). (Chapter 18 — Explaining Models and Predictions.)

Réutilisation

CC BY-NC-SA 4.0

Citation

BibTeX

@online{2026,
  author = {},
  title = {Importance des variables en R : avec vip et DALEX},
  date = {2026-06-25},
  url = {https://www.datanovia.com/learn/machine-learning/explainability/variable-importance},
  langid = {fr}
}

Veuillez citer ce travail comme suit :

“Importance des variables en R : avec vip et DALEX.” 2026. June 25. https://www.datanovia.com/learn/machine-learning/explainability/variable-importance.