Explainer LIME pour textes : interprétation des modèles NLP

Fonctions :

• LimeTextExplainer()

  LimeTextExplainer() fait partie de la bibliothèque LIME (Local Interpretable Model-agnostic Explanations), qui est utilisée pour expliquer les modèles de machine learning sur des données textuelles. Cette classe est spécifiquement conçue pour générer des explications locales sur les prédictions faites par des modèles de texte, en approximant la fonction du modèle avec un modèle local simple, comme une régression logistique, sur un échantillon perturbé.

  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 (si disponibles). Cela permet de rendre l'explication plus compréhensible en affichant les prédictions par classe.
  bow_model	callable	None	Un modèle de type bag-of-words qui transforme les données textuelles en une représentation que le modèle sous-jacent peut comprendre. Par exemple, un `CountVectorizer` ou `TfidfVectorizer` de Scikit-learn.
  verbose	bool	False	Si `True`, affiche des informations supplémentaires pendant l'explication du processus.
  feature_selection	str	'none'	Méthode de sélection des caractéristiques pour la génération d'explications. Peut être `'none'`, `'auto'` ou `'forward'` pour sélectionner les meilleures caractéristiques lors de la génération de perturbations.
  kernel_width	float	0.75	Largeur du noyau utilisée pour générer des perturbations autour du texte à expliquer.
  random_state	int, RandomState instance, or None	None	Un état aléatoire pour assurer la reproductibilité des résultats (facultatif).
  stop_words	str, list of str, or None	'english'	Liste de mots à ignorer lors de l'explication du texte, souvent utilisé pour exclure les mots courants comme "le", "la", "et", etc.

  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.linear_model import LogisticRegression
  from sklearn.feature_extraction.text import CountVectorizer
  
  # Charger le jeu de données 20 Newsgroups
  newsgroups = fetch_20newsgroups(subset='train')
  X_train, X_test, y_train, y_test = train_test_split(newsgroups.data, newsgroups.target, test_size=0.2, random_state=42)
  
  # Créer un modèle de régression logistique
  vectorizer = CountVectorizer(stop_words='english')
  X_train_vec = vectorizer.fit_transform(X_train)
  model = LogisticRegression(max_iter=1000)
  model.fit(X_train_vec, y_train)
  
  # Créer un explainer LIME pour les données textuelles
  explainer = LimeTextExplainer(class_names=newsgroups.target_names, bow_model=vectorizer)
  
  # Sélectionner un échantillon du jeu de données de test à expliquer
  sample_text = X_test[0]
  
  # Générer une explication pour la prédiction du modèle sur cet échantillon
  explanation = explainer.explain_instance(sample_text, model.predict_proba)
  
  # Visualiser l'explication
  explanation.show_in_notebook()

  Explication du code :

  
   	
  
  Chargement et préparation des données :
  Le jeu de données 20 Newsgroups est utilisé, contenant des articles de nouvelles classés dans 20 catégories différentes. Les données sont divisées en ensembles d'entraînement et de test avec train_test_split.
  
   	
  
  Entraînement du modèle :
  Un modèle de régression logistique est utilisé pour la classification des documents, et il est entraîné à l'aide de l'ensemble d'entraînement. Le texte est vectorisé à l'aide du CountVectorizer de Scikit-learn, qui transforme chaque document en une représentation basée sur le nombre de mots dans chaque classe.
  
   	
  
  Création de l'explainer :
  Un objet LimeTextExplainer est créé avec les classes cibles (newsgroups.target_names) et le modèle bow_model (le vectoriseur de mots CountVectorizer) pour transformer les textes en représentation de type bag-of-words.
  
   	
  
  Explication d'un échantillon spécifique :
  L'explication est générée pour un document de test spécifique (sample_text) en utilisant la fonction explain_instance() qui génère une approximation locale pour expliquer la prédiction du modèle.
  
   	
  
  Visualisation de l'explication :
  La méthode show_in_notebook() affiche l'explication dans un format interactif dans un notebook Jupyter, montrant l'importance de chaque mot pour la prédiction du modèle.
  
  
  Sortie attendue :
  
  
   	
  
  Une visualisation interactive indiquant quelles sont les caractéristiques (mots) qui ont le plus influencé la prédiction du modèle pour cet exemple particulier. Les mots seront affichés avec des poids positifs ou négatifs en fonction de leur impact sur la prédiction.
  
  
  Applications :
  
  
   	
  
  Interprétabilité des modèles de texte : LimeTextExplainer permet de comprendre comment un modèle de machine learning prend des décisions sur des données textuelles.
  
   	
  
  Détection de biais : Cette méthode peut aider à vérifier si le modèle prend des décisions basées sur des caractéristiques non pertinentes ou biaisées dans les textes.
  
   	
  
  Amélioration des modèles : Les développeurs peuvent utiliser ces explications pour affiner et ajuster leurs modèles en fonction des décisions prises sur des mots spécifiques dans les textes.