SHAP (SHapley Additive exPlanations)

Fonctions :

shap.initjs()

La fonction shap.initjs() est utilisée pour initialiser le code JavaScript nécessaire pour afficher les graphiques interactifs produits par la bibliothèque SHAP (SHapley Additive exPlanations). Cette fonction charge les scripts JavaScript dans l'environnement Jupyter (ou d'autres environnements compatibles), permettant ainsi une visualisation interactive des résultats d'explications des modèles de machine learning. Elle est généralement utilisée avant de générer des visualisations interactives avec SHAP, telles que des graphiques de valeur de Shapley pour l'interprétation des prédictions.
Importation :
```
import shap
```
Attributs :

Aucun attribut spécifique n'est directement associé à shap.initjs(), car c'est une fonction d'initialisation de l'environnement graphique pour les visualisations.
Exemple de code :
```
import shap
import xgboost
import shap
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# Charger un jeu de données pour l'exemple
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)
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 XGBoost
model = xgboost.XGBClassifier()
model.fit(X_train, y_train)

# Initialiser les visualisations interactives SHAP
shap.initjs()

# Calculer les valeurs SHAP pour les prédictions du modèle
explainer = shap.Explainer(model, X_train)
shap_values = explainer(X_test)

# Afficher un résumé des valeurs SHAP
shap.summary_plot(shap_values, X_test)
```
Explication du code :
1. Jeu de données et modèle : Nous générons un jeu de données de classification avec make_classification() et le divisons en ensembles d'entraînement et de test. Un modèle XGBoost est ensuite entraîné sur les données d'entraînement.
2. Initialisation de SHAP : Avant de générer des graphiques interactifs, nous appelons shap.initjs() pour charger les scripts nécessaires au rendu interactif dans l'environnement.
3. Calcul des valeurs SHAP : Un objet Explainer est créé pour expliquer les prédictions du modèle XGBoost sur l'ensemble de test. La méthode explainer(X_test) calcule les valeurs de Shapley, qui sont ensuite utilisées pour visualiser l'impact de chaque caractéristique sur la prédiction.
4. Visualisation : Nous utilisons shap.summary_plot() pour afficher un graphique résumant l'importance de chaque caractéristique dans les prédictions du modèle, en utilisant les valeurs SHAP calculées.
Sortie attendue :
- Un graphique interactif dans un environnement Jupyter montrant l'importance de chaque caractéristique pour les prédictions, avec la possibilité d'explorer les données de manière dynamique.
Applications :
- Interprétation des modèles : shap.initjs() est essentiel pour afficher des visualisations interactives des explications des modèles, ce qui permet une meilleure compréhension de leur comportement et de leurs décisions.
- Explications locales et globales : Les valeurs SHAP peuvent être utilisées pour obtenir des explications locales sur les prédictions individuelles (par exemple, pourquoi un modèle a fait une certaine prédiction pour un échantillon) ainsi que des explications globales sur l'impact global des caractéristiques.

shap.TreeExplainer()

La fonction shap.TreeExplainer() est utilisée pour expliquer les prédictions d'un modèle d'arbre de décision ou d'un modèle d'ensembles d'arbres, comme les modèles de Random Forest, XGBoost, LightGBM, CatBoost, et d'autres. Elle permet de calculer les valeurs de Shapley, une méthode de jeu coopératif qui attribue à chaque caractéristique une importance relative dans la prédiction d'un modèle. Ce type d'explication est utile pour comprendre l'impact de chaque caractéristique sur les résultats d'un modèle de manière précise et transparente.

Importation :

import shap

Attributs :

Paramètre	Type	Valeur par défaut	Description
model	Modèle de machine learning	None	Le modèle que l'on souhaite expliquer. Cela peut être un modèle d'arbre de décision comme XGBoost, LightGBM, CatBoost, ou un modèle de forêt aléatoire.
data	array-like ou pandas DataFrame	None	Les données d'entraînement ou de test que le modèle a utilisées pour ses prédictions.
feature_perturbation	str	'tree_path_dependent'	La méthode de perturbation des caractéristiques. 'tree_path_dependent' est souvent utilisé pour des modèles d'arbres, tandis que d'autres méthodes peuvent être choisies pour d'autres types de modèles.
link	str ou callable	'identity'	La fonction de lien utilisée pour transformer les prédictions. 'identity' signifie que les valeurs de sortie sont directement utilisées.

Exemple de code :

import shap
import xgboost
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split

# Générer des données d'exemple
X, y = make_classification(n_samples=1000, n_features=20, random_state=42)
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 XGBoost
model = xgboost.XGBClassifier()
model.fit(X_train, y_train)

# Créer un explainer SHAP pour le modèle d'arbre
explainer = shap.TreeExplainer(model)

# Calculer les valeurs SHAP pour l'ensemble de test
shap_values = explainer.shap_values(X_test)

# Visualiser l'impact des caractéristiques sur les prédictions
shap.summary_plot(shap_values, X_test)

Explication du code :

Données et modèle : Nous générons un jeu de données de classification avec 1000 échantillons et 20 caractéristiques, puis nous le divisons en ensembles d'entraînement et de test. Un modèle XGBoost est entraîné sur ces données.
Création de l'explainer : Un objet TreeExplainer est créé pour expliquer les prédictions du modèle XGBoost. L'objet explainer sera ensuite utilisé pour calculer les valeurs de Shapley, qui expliquent l'impact de chaque caractéristique sur la prédiction du modèle.
Calcul des valeurs SHAP : Nous appelons explainer.shap_values() pour calculer les valeurs de Shapley pour les prédictions faites par le modèle sur l'ensemble de test.
Visualisation : Nous utilisons shap.summary_plot() pour afficher un graphique résumant l'importance de chaque caractéristique sur les prédictions du modèle, à l'aide des valeurs de Shapley.

Sortie attendue :

Un graphique interactif qui montre l'importance de chaque caractéristique pour les prédictions du modèle. Ce graphique permet de voir comment chaque caractéristique influence les prédictions, avec une visualisation des interactions et des effets de chaque caractéristique.

Applications :

Interprétation des modèles d'arbres : La fonction TreeExplainer est particulièrement utile pour expliquer des modèles d'arbres comme XGBoost, LightGBM, ou CatBoost. Elle fournit des explications détaillées et interprétables des prédictions.
Évaluation de l'importance des caractéristiques : L'utilisation des valeurs de Shapley aide à comprendre l'impact des différentes caractéristiques dans le modèle, facilitant l'interprétation et l'explication des résultats des modèles.
Transparence des modèles : SHAP est utilisé pour augmenter la transparence des modèles de machine learning, en particulier pour les modèles complexes comme ceux utilisant des ensembles d'arbres.

shap.KernelExplainer()

La fonction shap.KernelExplainer() est utilisée pour expliquer les prédictions d'un modèle de machine learning en utilisant des méthodes basées sur les noyaux (kernel methods). Elle est particulièrement utile pour des modèles complexes qui ne sont pas intrinsèquement transparents, comme les modèles de type "boîte noire" (par exemple, les SVMs ou les réseaux de neurones). Le KernelExplainer utilise une approche par approximation des valeurs de Shapley pour obtenir une explication des prédictions en fonction des caractéristiques du modèle. Il s'agit d'une méthode générique qui peut être appliquée à tout modèle, à condition d'avoir une fonction de prédiction.

Importation :

import shap

Attributs :

Paramètre	Type	Valeur par défaut	Description
model	Callable	None	Le modèle de machine learning à expliquer. Il doit être une fonction callable, c'est-à-dire une fonction qui prend un ensemble de caractéristiques en entrée et renvoie une prédiction.
data	array-like, pandas DataFrame	None	Les données d'entraînement (ou de test) qui seront utilisées pour l'explication. Ces données doivent être en même format que les données d'entrée utilisées pour entraîner le modèle.
link	str ou callable	'identity'	La fonction de lien utilisée pour transformer les prédictions. Par défaut, 'identity' est utilisé pour ne pas transformer les valeurs de sortie.
feature_perturbation	str	'interventional'	La méthode utilisée pour perturber les caractéristiques dans le processus de calcul des valeurs de Shapley. 'interventional' est la méthode par défaut où les caractéristiques sont perturbées de manière indépendante.

Exemple de code :

import shap
import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Charger un jeu de données d'exemple (Iris)
X, y = load_iris(return_X_y=True)
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 régression logistique
model = LogisticRegression(max_iter=200)
model.fit(X_train, y_train)

# Créer un explainer SHAP avec KernelExplainer
explainer = shap.KernelExplainer(model.predict_proba, X_train)

# Calculer les valeurs SHAP pour l'ensemble de test
shap_values = explainer.shap_values(X_test)

# Visualiser l'impact des caractéristiques sur les prédictions
shap.summary_plot(shap_values, X_test)

Explication du code :

Jeu de données et modèle : Nous chargeons le jeu de données Iris, qui contient des informations sur des fleurs, puis nous divisons les données en ensembles d'entraînement et de test. Un modèle de régression logistique est entraîné sur les données d'entraînement.
Création de l'explainer : Nous créons un objet KernelExplainer en passant la fonction de prédiction du modèle (model.predict_proba) et les données d'entraînement (X_train). La fonction predict_proba est utilisée car elle renvoie les probabilités des différentes classes (pour un problème de classification multiclasse).
Calcul des valeurs SHAP : Nous appelons explainer.shap_values() pour calculer les valeurs de Shapley pour les prédictions faites par le modèle sur l'ensemble de test.
Visualisation : Nous utilisons shap.summary_plot() pour afficher un graphique résumant l'importance de chaque caractéristique sur les prédictions du modèle.

Sortie attendue :

Un graphique interactif montrant l'impact de chaque caractéristique sur les prédictions du modèle. Ce graphique peut être utilisé pour comprendre comment chaque caractéristique influence les prédictions, et il peut également aider à identifier les caractéristiques les plus importantes.

Applications :

Modèles de type boîte noire : KernelExplainer est particulièrement utile pour expliquer des modèles complexes tels que les réseaux de neurones, les SVMs ou tout autre modèle dont l'interprétation est difficile. Il permet de comprendre l'impact des caractéristiques sur les prédictions sans avoir besoin d'une structure explicite dans le modèle.
Explication globale et locale : Il peut être utilisé pour des explications globales (comment les caractéristiques influencent les prédictions de manière générale) ainsi que pour des explications locales (comment les caractéristiques influencent une prédiction particulière).
Interprétation des résultats dans des contextes critiques : Cette fonction est utile dans des domaines où la compréhension des décisions du modèle est importante, comme la médecine ou la finance, où la transparence du modèle est cruciale.

shap.summary_plot()

La fonction shap.summary_plot() est utilisée pour afficher un graphique résumant l'importance des caractéristiques dans un modèle de machine learning en utilisant les valeurs de Shapley. Ce graphique montre à quel point chaque caractéristique contribue aux prédictions du modèle. Il peut être utilisé pour observer l'impact global des différentes caractéristiques sur les prédictions, ainsi que les interactions entre elles. Le graphique peut être affiché sous différentes formes, notamment un graphique en points (scatter) ou un graphique de type barplot pour une vue d'ensemble de l'importance des caractéristiques.

Importation :

import shap

Attributs :

Paramètre	Type	Valeur par défaut	Description
shap_values	array-like	None	Les valeurs de Shapley calculées par l'explainer. Ce paramètre représente l'impact de chaque caractéristique sur les prédictions du modèle.
features	array-like, pandas DataFrame	None	Les données d'entrée qui ont été utilisées pour calculer les valeurs de Shapley. Cela peut être un tableau numpy ou un DataFrame pandas représentant les caractéristiques du jeu de données.
max_display	int	20	Le nombre maximal de caractéristiques à afficher sur le graphique. Par défaut, les 20 caractéristiques les plus importantes sont affichées.
plot_type	str	'dot'	Le type de graphique à afficher. 'dot' est le type par défaut, où chaque point représente l'impact d'une caractéristique sur une prédiction individuelle. D'autres types de graphiques comme 'bar' peuvent être utilisés pour afficher un graphique de type barplot.
color	str	'coolwarm'	La palette de couleurs utilisée pour le graphique. Par défaut, 'coolwarm' est utilisé pour colorier les points en fonction de leur valeur.

Exemple de code :

import shap
import xgboost
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Charger un jeu de données d'exemple (Iris)
X, y = load_iris(return_X_y=True)
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 XGBoost
model = xgboost.XGBClassifier()
model.fit(X_train, y_train)

# Créer un explainer SHAP pour le modèle XGBoost
explainer = shap.TreeExplainer(model)

# Calculer les valeurs SHAP pour l'ensemble de test
shap_values = explainer.shap_values(X_test)

# Visualiser l'impact des caractéristiques sur les prédictions
shap.summary_plot(shap_values, X_test)

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 XGBoost est ensuite entraîné sur les données d'entraînement.
Création de l'explainer : Un objet TreeExplainer est créé pour expliquer les prédictions du modèle XGBoost.
Calcul des valeurs SHAP : Nous appelons explainer.shap_values() pour calculer les valeurs de Shapley sur l'ensemble de test. Ces valeurs permettent d'évaluer l'impact de chaque caractéristique sur la prédiction du modèle.
Visualisation : Nous utilisons shap.summary_plot() pour afficher un graphique récapitulant l'importance de chaque caractéristique sur les prédictions du modèle. Le graphique affiché montre la distribution des valeurs de Shapley pour chaque caractéristique et leur impact sur les prédictions globales.

Sortie attendue :

Un graphique interactif affichant les caractéristiques les plus importantes du modèle, où chaque point représente l'impact d'une caractéristique sur une prédiction. La couleur des points est généralement utilisée pour représenter la valeur de la caractéristique, et la distribution des points montre l'impact de cette caractéristique sur les prédictions du modèle.
- Scatter plot (dot plot) : Par défaut, shap.summary_plot() affiche un graphique en points, où chaque point correspond à un échantillon du jeu de test, et l'axe des x représente la valeur de la caractéristique pour chaque échantillon. La couleur du point représente la valeur de la caractéristique (par exemple, rouge pour des valeurs élevées, bleu pour des valeurs faibles).
- Bar plot : Si vous préférez afficher les caractéristiques par ordre d'importance, vous pouvez utiliser plot_type='bar', ce qui affichera un graphique en barres montrant la somme des valeurs de Shapley pour chaque caractéristique.

Applications :

Interprétation des modèles complexes : Le summary_plot permet d'expliquer de manière visuelle et intuitive l'impact de chaque caractéristique sur les prédictions du modèle. Il aide à identifier les caractéristiques les plus importantes et à comprendre comment elles influencent les résultats.
Analyse de l'importance des caractéristiques : Le graphique montre non seulement l'importance des caractéristiques, mais aussi la distribution de leur influence, ce qui peut aider à comprendre les interactions entre les différentes caractéristiques et leur impact sur les prédictions.
Amélioration de la transparence du modèle : Cette visualisation est particulièrement utile dans des contextes où la transparence des décisions du modèle est cruciale, comme dans les domaines médical, financier, ou juridique.

shap.force_plot()

La fonction shap.force_plot() est utilisée pour afficher une visualisation interactive des valeurs de Shapley pour une seule prédiction. Contrairement à shap.summary_plot(), qui présente l'impact global des caractéristiques sur l'ensemble des prédictions, shap.force_plot() se concentre sur l'explication d'une prédiction individuelle. Il montre comment les différentes caractéristiques contribuent à la prédiction pour un exemple spécifique en affichant les valeurs de Shapley pour chaque caractéristique et en visualisant l'impact de celles-ci de manière visuelle.

Importation :

import shap

Attributs :

Paramètre	Type	Valeur par défaut	Description
shap_values	array-like	None	Les valeurs de Shapley calculées pour une instance spécifique ou un ensemble d'instances. Ce paramètre représente l'impact de chaque caractéristique sur la prédiction.
features	array-like, pandas DataFrame	None	Les données d'entrée qui ont été utilisées pour calculer les valeurs de Shapley. Ce paramètre peut être un tableau numpy ou un DataFrame pandas représentant les caractéristiques du jeu de données.
matplotlib	bool	True	Si `True`, la visualisation sera rendue via matplotlib. Si `False`, un affichage interactif sera utilisé (par exemple, dans un notebook Jupyter).
show	bool	True	Si `True`, la fonction affichera la visualisation immédiatement.

Exemple de code :

import shap
import xgboost
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

# Charger un jeu de données d'exemple (Iris)
X, y = load_iris(return_X_y=True)
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 XGBoost
model = xgboost.XGBClassifier()
model.fit(X_train, y_train)

# Créer un explainer SHAP pour le modèle XGBoost
explainer = shap.TreeExplainer(model)

# Calculer les valeurs SHAP pour un échantillon spécifique (par exemple, la première ligne du test)
shap_values = explainer.shap_values(X_test)

# Visualiser l'impact des caractéristiques sur la prédiction pour l'exemple donné
shap.force_plot(shap_values[0], X_test[0], matplotlib=True)

Explication du code :

Données et modèle : Le jeu de données Iris est chargé et divisé en ensembles d'entraînement et de test. Un modèle XGBoost est ensuite entraîné sur les données d'entraînement.
Création de l'explainer : Un objet TreeExplainer est créé pour expliquer les prédictions du modèle XGBoost. Ce modèle permet de calculer les valeurs de Shapley qui expliquent comment chaque caractéristique contribue à la prédiction du modèle.
Calcul des valeurs SHAP : Les valeurs de Shapley pour l'échantillon spécifique (la première instance du jeu de test ici) sont calculées avec explainer.shap_values(). Ces valeurs indiquent l'impact de chaque caractéristique sur la prédiction pour cet échantillon.
Visualisation : La fonction shap.force_plot() est utilisée pour afficher l'impact de chaque caractéristique sur la prédiction pour cette instance spécifique. L'argument matplotlib=True permet d'afficher la visualisation via matplotlib. Si vous travaillez dans un environnement Jupyter, vous pouvez également obtenir une visualisation interactive en définissant matplotlib=False.

Sortie attendue :

Un graphique interactif montrant l'impact des différentes caractéristiques sur la prédiction du modèle pour une instance spécifique. Ce graphique illustre comment chaque caractéristique influence la prédiction, qu'elle augmente ou diminue la probabilité de la classe prédite. Chaque caractéristique a une valeur de Shapley associée, et le graphique peut être visualisé comme un graphique de force où les contributions positives et négatives sont représentées par des flèches.

Applications :

Interprétation des prédictions individuelles : shap.force_plot() est particulièrement utile pour comprendre pourquoi un modèle a fait une certaine prédiction pour un échantillon spécifique. Cela peut être essentiel pour la validation du modèle et pour garantir que ses décisions sont expliquables.
Analyse des biais du modèle : En utilisant cette fonction, vous pouvez vérifier comment les différentes caractéristiques influencent les prédictions et si le modèle prend des décisions biaisées en fonction de certaines caractéristiques.
Amélioration de la transparence du modèle : Comme shap.summary_plot(), shap.force_plot() permet d'augmenter la transparence des décisions du modèle, ce qui est particulièrement important dans des secteurs où l'explicabilité des modèles est cruciale.

SHAP (SHapley Additive exPlanations)

Fonctions :

shap.initjs()

Importation :

Attributs :

Exemple de code :

Explication du code :

shap.TreeExplainer()

Importation :

Attributs :

Exemple de code :

Explication du code :

shap.KernelExplainer()

Importation :

Attributs :

Exemple de code :

Explication du code :

shap.summary_plot()

Importation :

Attributs :

Exemple de code :

Explication du code :

shap.force_plot()

Importation :

Attributs :

Exemple de code :

Explication du code :