Explainer LIME pour données tabulaires : initialisation et configuration

Fonctions :

• LimeTabularExplainer()

  LimeTabularExplainer() fait partie de la bibliothèque LIME (Local Interpretable Model-agnostic Explanations), qui permet d'expliquer des modèles de machine learning en fournissant des explications locales et interprétables. Ce classeur est utilisé pour les modèles qui fonctionnent avec des données tabulaires. Il génère des explications locales des prédictions d'un modèle en approximant la fonction du modèle avec un modèle local simple (souvent une régression linéaire ou une régression logistique) qui est plus facile à interpréter.

  Importation :

  from lime.lime_tabular import LimeTabularExplainer

  Attributs :

  Paramètre	Type	Valeur par défaut	Description
  training_data	array-like, pandas DataFrame	None	Les données d'entraînement utilisées pour ajuster le modèle local. Cela sert à aider l'explainer à comprendre la distribution des données et à générer des explications efficaces.
  mode	string	'classification'	Le mode du modèle, soit 'classification' soit 'regression'. Ce paramètre détermine si l'explication est destinée à un modèle de classification ou de régression.
  training_labels	array-like	None	Les étiquettes des données d'entraînement (si disponibles). Elles sont utilisées pour les explications des modèles supervisés.
  feature_names	list of str	None	Les noms des caractéristiques pour les données tabulaires, utilisés pour rendre les explications plus lisibles.
  categorical_features	list of int	None	Les indices des caractéristiques catégorielles dans les données. LIME les traite de manière différente des caractéristiques continues.
  categorical_names	dict	None	Un dictionnaire où les clés sont les indices des caractéristiques catégorielles et les valeurs sont des listes des noms possibles des catégories.
  kernel_width	float	0.75	La largeur du noyau utilisé pour générer les perturbations autour de l'exemple à expliquer. Cela influence la quantité de perturbations générées pour approximations locales.
  verbose	bool	False	Si `True`, affiche des informations supplémentaires pendant le processus d'explication.

  Exemple de code :

  📋 Copy

  import numpy as np
  import pandas as pd
  from lime.lime_tabular import LimeTabularExplainer
  from sklearn.ensemble import RandomForestClassifier
  from sklearn.model_selection import train_test_split
  
  # Charger un jeu de données exemple (par exemple, Iris)
  from sklearn.datasets import load_iris
  data = load_iris()
  X = pd.DataFrame(data.data, columns=data.feature_names)
  y = pd.Series(data.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 classification (RandomForest)
  model = RandomForestClassifier(n_estimators=100, random_state=42)
  model.fit(X_train, y_train)
  
  # Créer un explainer LIME
  explainer = LimeTabularExplainer(
      training_data=X_train.values,
      training_labels=y_train.values,
      feature_names=X.columns,
      mode='classification'
  )
  
  # Sélectionner un échantillon à expliquer
  sample = X_test.iloc[0]
  
  # Générer une explication locale pour la prédiction de ce sample
  explanation = explainer.explain_instance(sample.values, model.predict_proba)
  
  # Visualiser l'explication
  explanation.show_in_notebook()

  Explication du code :

  
   	
  
  Données et modèle :
  Le jeu de données Iris est chargé, puis divisé en ensembles d'entraînement et de test. Un modèle de classification RandomForest est ensuite entraîné sur les données d'entraînement.
  
   	
  
  Création de l'explainer :
  Un objet LimeTabularExplainer est créé avec les données d'entraînement (X_train) et les étiquettes d'entraînement (y_train). Le paramètre mode='classification' spécifie que l'explication est destinée à un modèle de classification. Les noms des caractéristiques sont également passés pour améliorer la lisibilité des explications.
  
   	
  
  Explication d'un échantillon spécifique :
  Une instance spécifique de l'ensemble de test (sample) est sélectionnée pour obtenir une explication. La fonction explain_instance() génère des perturbations autour de cet échantillon et apprend un modèle local pour expliquer la prédiction.
  
   	
  
  Visualisation de l'explication :
  La fonction show_in_notebook() affiche l'explication dans un format interactif dans un notebook Jupyter. Cette explication montre comment chaque caractéristique de l'exemple a contribué à la prédiction du modèle.
  
  
  Sortie attendue :
  
  
   	
  
  Une visualisation interactive montrant l'importance des différentes caractéristiques pour l'exemple spécifique. L'explication est basée sur un modèle local simple qui approximera le modèle complexe autour de l'exemple à expliquer. Les caractéristiques les plus importantes pour la prédiction sont généralement mises en évidence.
  
  
  Applications :
  
  
   	
  
  Interprétation des prédictions : LimeTabularExplainer permet d'expliquer de manière transparente les prédictions d'un modèle complexe en utilisant des modèles simples locaux.
  
   	
  
  Explication pour les utilisateurs finaux : Utile pour les applications où l'explicabilité des décisions du modèle est importante, par exemple, dans le domaine de la santé ou des finances.
  
   	
  
  Validation des modèles : Permet aux développeurs de vérifier si le modèle prend des décisions basées sur des caractéristiques pertinentes et non biaisées.