LIME Tabulaire : explication locale d’une prédiction

Après avoir initialisé un LimeTabularExplainer, la méthode centrale pour comprendre une prédiction spécifique est explain_instance(). Cette fonction permet d’obtenir une interprétation locale, c’est-à-dire une explication détaillée des facteurs qui ont le plus influencé la décision du modèle sur une seule instance (un exemple précis de données).

La méthode génère des perturbations autour de cette instance — en modifiant légèrement ses valeurs — pour analyser comment le modèle répond à ces variations. Ensuite, elle construit un modèle simple (comme une régression linéaire) qui approxime le comportement du modèle complexe dans ce voisinage local.

Objectifs de `explain_instance()`

Identifier les variables clés qui ont orienté la prédiction.
Quantifier l’impact positif ou négatif de chaque variable.
Fournir une explication claire et accessible, même pour des utilisateurs non experts.

Comment ça fonctionne ?

La fonction reçoit une instance sous forme de vecteur de valeurs.
Elle génère un ensemble de données synthétiques proches de cette instance en perturbant ses features.
Elle interroge le modèle sur ces données perturbées.
Elle construit un modèle local simple pour expliquer la prédiction d’origine.

Fonctions :

LimeTabularExplainer.explain_instance()

explain_instance() est une méthode de la classe LimeTabularExplainer qui permet de générer une explication locale pour une instance spécifique dans un modèle tabulaire. Elle fonctionne en perturbant les caractéristiques de l'instance à expliquer, puis en évaluant ces perturbations à l'aide du modèle de machine learning, afin d'approximativement expliquer la prédiction du modèle en utilisant un modèle local simple (comme la régression linéaire ou la régression logistique).

Importation :

from lime.lime_tabular import LimeTabularExplainer

Attributs :

Paramètre	Type	Valeur par défaut	Description
training_data	array-like, shape (n_samples, n_features)	None	Les données d'entraînement utilisées pour générer des perturbations autour de l'instance à expliquer. Ce sont les données utilisées pour créer l'explainer.
feature_names	list of str	None	Les noms des caractéristiques dans les données.
class_names	list of str	None	Les noms des classes du modèle (si disponible), utilisées pour rendre l'explication plus compréhensible.
mode	str	'classification'	Le mode d'explication, soit 'classification' (pour des modèles de classification), soit 'regression' (pour des modèles de régression).
categorical_features	list of ints	None	Les indices des caractéristiques catégorielles dans les données d'entraînement.
discretize_continuous	bool	False	Si `True`, les caractéristiques continues sont discrétisées avant l'explication.
kernel_width	float	0.75	La largeur du noyau utilisée pour la perturbation de l'instance à expliquer.
random_state	int, RandomState instance, or None	None	Une valeur pour assurer la reproductibilité des résultats (facultatif).
verbose	bool	False	Si `True`, affiche des informations détaillées sur le processus de génération de l'explication.

Exemple de code :

from lime.lime_tabular import LimeTabularExplainer
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
import numpy as np

# Charger les données Iris
iris = load_iris()
X = iris.data
y = iris.target

# Diviser les données en ensembles d'entraînement et de test
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Entraîner un modèle de Random Forest
model = RandomForestClassifier(n_estimators=100, random_state=42)
model.fit(X_train, y_train)

# Créer un explainer LIME pour les données tabulaires
explainer = LimeTabularExplainer(training_data=X_train, 
                                 feature_names=iris.feature_names,
                                 class_names=iris.target_names,
                                 mode='classification')

# Choisir une instance à expliquer
instance = X_test[0]

# Générer l'explication pour l'instance
explanation = explainer.explain_instance(instance, model.predict_proba)

# Visualiser l'explication
explanation.show_in_notebook()

Explication du code :

Chargement des données :
Le jeu de données Iris est chargé à partir de sklearn.datasets. Ce jeu de données contient des mesures de fleurs d'iris et les étiquettes des trois espèces d'iris.
Division des données :
Les données sont divisées en ensembles d'entraînement et de test à l'aide de train_test_split.
Entraînement du modèle :
Un modèle de RandomForestClassifier est entraîné sur l'ensemble d'entraînement.
Création de l'explainer :
Un LimeTabularExplainer est créé pour expliquer les prédictions du modèle. L'explainer est configuré pour des données tabulaires avec des noms de caractéristiques et de classes spécifiés.
Explication d'une instance :
Une instance du jeu de test est sélectionnée et l'explication est générée en appelant explain_instance(), qui utilise le modèle pour prédire les probabilités et explique la prédiction pour cette instance spécifique.
Visualisation de l'explication :
La méthode show_in_notebook() est utilisée pour afficher l'explication sous forme graphique dans un notebook Jupyter. Cela montre l'importance des différentes caractéristiques pour la prédiction du modèle.

Sortie attendue :

Une visualisation interactive indiquant l'impact des différentes caractéristiques (features) sur la prédiction de l'instance sélectionnée. Chaque caractéristique sera associée à une valeur indiquant son poids dans la prédiction.

Applications :

Interprétabilité des modèles complexes : LimeTabularExplainer aide à rendre compréhensible les décisions prises par des modèles complexes, comme les forêts aléatoires ou les réseaux de neurones.
Amélioration des modèles : En analysant les explications, on peut mieux comprendre quelles caractéristiques influencent le plus les prédictions, ce qui peut aider à affiner le modèle.
Détection des biais : Cette approche permet de vérifier si le modèle repose sur des caractéristiques non pertinentes ou biaisées.