LIME (Local Interpretable Model-agnostic Explanations)

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 :

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.

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 :

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.

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.

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 :

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.

explanation.as_list()

as_list() est une méthode de l'objet Explanation dans LIME, utilisée pour obtenir l'explication d'une instance sous forme de liste. Cette liste contient des tuples, où chaque tuple est composé d'un mot (ou d'une caractéristique) et de son poids associé, représentant l'importance de chaque caractéristique (comme un mot) dans la prédiction du modèle. L'ordre des éléments dans la liste est trié par la magnitude du poids, de sorte que les caractéristiques les plus influentes sont placées en premier.

Attributs :

La méthode as_list() n'a pas de paramètres supplémentaires, mais elle retourne un objet de type list qui contient des tuples.
Exemple de code :
```
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)

# Obtenir l'explication sous forme de liste
explanation_list = explanation.as_list()

# Afficher l'explication sous forme de liste
for word, weight in explanation_list:
    print(f"{word}: {weight}")
```
Explication du code :
- Préparation des données : Le même jeu de données 20newsgroups est utilisé, avec des étapes de vectorisation, de division en ensembles d'entraînement et de test, ainsi que l'entraînement d'un modèle Naive Bayes comme dans l'exemple précédent.
- Explication de l'instance : L'instance du jeu de test est choisie, et l'explication est générée à l'aide de la méthode explain_instance().
- Conversion de l'explication en liste : La méthode as_list() est utilisée pour convertir l'explication sous forme de liste. Cette liste contient des tuples de mots et de poids associés. Le poids représente l'importance de chaque mot dans la décision du modèle, et les mots sont triés par ordre d'importance.
- Affichage des résultats : Le résultat est imprimé, où chaque ligne montre un mot suivi de son poids d'importance dans la prédiction.

LIME (Local Interpretable Model-agnostic Explanations)

Fonctions :

LimeTabularExplainer()

Importation :

Attributs :

Exemple de code :

Explication du code :

LimeTextExplainer()

Importation :

Attributs :

Exemple de code :

Explication du code :

LimeTabularExplainer.explain_instance()

Importation :

Attributs :

Exemple de code :

Explication du code :

LimeTextExplainer.explain_instance()

Importation :

Attributs :

Exemple de code :

Explication du code :

explanation.as_list()

Attributs :

Exemple de code :

Explication du code :