LIME Texte : explication d’une prédiction sur des données textuelles

Fonctions :

• LimeTextExplainer.explain_instance()

  explain_instance() est une méthode de la classe LimeTextExplainer qui permet de générer une explication locale pour une instance de texte spécifique dans un modèle de classification de texte. L'idée est de perturber le texte d'entrée en générant des versions modifiées (en ajoutant, supprimant ou remplaçant des mots), puis d'évaluer ces perturbations avec le modèle pour approximer les décisions du modèle à l'aide d'un modèle simple, comme une régression logistique.

  Importation :

  from lime.lime_text import LimeTextExplainer

  Attributs :

  Paramètre	Type	Valeur par défaut	Description
  class_names	list of str	None	Les noms des classes du modèle. Ces noms sont utilisés pour rendre l'explication plus lisible pour l'utilisateur.
  bow_model	bool	True	Indique si le modèle de classification utilisé est basé sur un sac de mots (bag of words).
  feature_selection	str	'none'	La méthode de sélection des caractéristiques à utiliser pour l'explication. Peut être 'none' ou 'auto'.
  kernel_width	float	0.75	La largeur du noyau utilisé pour générer des perturbations autour de l'instance à expliquer.
  stop_words	str or list of str	'english'	Liste de mots à ignorer dans l'explication (comme les mots vides) ou une chaîne indiquant une langue ('english').

  Exemple de code :

  📋 Copy

  from lime.lime_text import LimeTextExplainer
  from sklearn.datasets import fetch_20newsgroups
  from sklearn.model_selection import train_test_split
  from sklearn.naive_bayes import MultinomialNB
  from sklearn.feature_extraction.text import CountVectorizer
  
  # Charger le jeu de données 20 newsgroups
  newsgroups = fetch_20newsgroups(subset='train')
  X = newsgroups.data
  y = newsgroups.target
  
  # Vectorisation des données textuelles
  vectorizer = CountVectorizer(stop_words='english')
  X_vectorized = vectorizer.fit_transform(X)
  
  # Diviser les données en ensembles d'entraînement et de test
  X_train, X_test, y_train, y_test = train_test_split(X_vectorized, y, test_size=0.2, random_state=42)
  
  # Entraîner un modèle Naive Bayes
  model = MultinomialNB()
  model.fit(X_train, y_train)
  
  # Créer un explainer LIME pour les données textuelles
  explainer = LimeTextExplainer(class_names=newsgroups.target_names)
  
  # Choisir une instance à expliquer
  instance = X_test[0]
  instance_text = X_test[0].toarray()
  
  # Générer l'explication pour l'instance
  explanation = explainer.explain_instance(instance_text, model.predict_proba)
  
  # Visualiser l'explication
  explanation.show_in_notebook()

  Explication du code :

  
   	
  
  Chargement des données :
  Le jeu de données 20newsgroups est chargé à partir de sklearn.datasets. Il contient des articles de presse répartis en 20 catégories.
  
   	
  
  Vectorisation du texte :
  Les données textuelles sont vectorisées en utilisant CountVectorizer de sklearn, qui transforme le texte brut en une matrice de caractéristiques numériques en utilisant un modèle de sac de mots (bag of words).
  
   	
  
  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 Naive Bayes Multinomial est entraîné sur l'ensemble d'entraînement.
  
   	
  
  Création de l'explainer :
  Un LimeTextExplainer est créé pour expliquer les prédictions d'un modèle sur des données textuelles. L'explainer est configuré avec les noms de classes du jeu de données.
  
   	
  
  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 mots dans le texte pour la prédiction du modèle.
  
  
  Sortie attendue :
  
  
   	
  
  Une visualisation interactive indiquant l'impact des différents mots de l'instance sur la prédiction. Chaque mot sera associé à un poids indiquant son importance pour la décision prise par le modèle.
  
  
  Applications :
  
  
   	
  
  Interprétabilité des modèles de texte : LimeTextExplainer aide à rendre compréhensible les décisions prises par des modèles complexes sur des données textuelles, comme Naive Bayes ou des réseaux de neurones.
  
   	
  
  Amélioration des modèles : En analysant les explications, on peut mieux comprendre quelles caractéristiques textuelles influencent le plus les prédictions, ce qui peut aider à affiner le modèle.
  
   	
  
  Détection des biais : Cela permet également de vérifier si le modèle repose sur des mots non pertinents ou biaisés.