Explicabilite des modeles avec LIME et SHAP
Theorie 60 min
Pourquoi l'explicabilite est importante
Imaginez qu'une banque rejette votre demande de credit. Vous demandez pourquoi, et on vous repond : « L'algorithme a dit non. » Accepteriez-vous cela ? Bien sur que non — vous voudriez savoir quels facteurs ont conduit a la decision. C'est le cœur de l'explicabilite des modeles.
L'analogie du diagnostic medical
Un bon medecin ne se contente pas de dire « vous avez la condition X ». Il explique :
- Quels symptomes ont conduit au diagnostic (importance des caracteristiques)
- Son niveau de confiance (probabilite de prediction)
- Les alternatives envisagees (autres classes)
- Ce qui changerait le diagnostic (raisonnement contrefactuel)
Un modele IA explicable fonctionne de la meme maniere — il vous indique non seulement ce qu'il a predit, mais pourquoi.
Quatre piliers de l'explicabilite
| Pilier | Description | Partie prenante |
|---|---|---|
| Confiance | Les utilisateurs et les parties prenantes doivent faire confiance aux decisions du modele | Utilisateurs finaux, direction |
| Reglementation | Les lois exigent des explications pour les decisions automatisees (loi europeenne sur l'IA, RGPD article 22) | Juridique, conformite |
| Debogage | Comprendre pourquoi un modele echoue aide a le corriger | Data scientists, ingenieurs ML |
| Equite | Detecter si un modele discrimine en fonction d'attributs proteges | Equipes ethique, auditeurs |
Loi europeenne sur l'IA — L'imperatif legal
La loi europeenne sur l'IA (en vigueur en 2025) classe les systemes d'IA par niveau de risque. Les systemes a haut risque (sante, finance, recrutement, application de la loi) DOIVENT fournir des explications pour leurs decisions. Le non-respect peut entrainer des amendes allant jusqu'a 35 millions d'euros ou 7 % du chiffre d'affaires mondial.
Modeles boite noire vs. boite blanche
Modeles boite blanche (intrinsequement interpretables)
Ces modeles sont suffisamment simples pour etre compris directement :
| Modele | Comment interpreter |
|---|---|
| Regression lineaire | Les coefficients montrent l'impact direct des caracteristiques : price = 200 × sqft + 50000 × bedrooms - 10000 × age |
| Arbre de decision | Suivre les branches de l'arbre : si age > 30 ET revenu > 50k → approuver |
| Regression logistique | Les rapports de cotes montrent comment chaque caracteristique modifie la probabilite |
Modeles boite noire (opaques)
Ces modeles sont trop complexes pour etre inspectes directement :
| Modele | Pourquoi c'est une boite noire |
|---|---|
| Random Forest | Des centaines d'arbres, chacun avec des divisions differentes |
| Gradient Boosting (XGBoost, LightGBM) | Des milliers d'arbres sequentiels, interactions complexes |
| Reseaux de neurones | Des millions de parametres, transformations non lineaires |
| Modeles d'ensemble | Combinaison de plusieurs modeles differents |
Le compromis explicabilite-precision
Voir le spectre d'interpretabilite
La solution
Les methodes d'explicabilite post-hoc comme LIME et SHAP permettent d'expliquer les modeles boite noire sans sacrifier la precision. Vous obtenez le meilleur des deux mondes : des modeles puissants + des explications interpretables.
Explications locales vs. globales
| Type | Question repondue | Portee | Exemple |
|---|---|---|---|
| Locale | « Pourquoi le modele a-t-il predit ce resultat precis pour cette entree precise ? » | Une seule prediction | « Ce credit a ete refuse car le ratio dette/revenu du demandeur est de 0,85 » |
| Globale | « Quelles caracteristiques comptent en general pour toutes les predictions ? » | Ensemble du jeu de donnees | « Le revenu et le score de credit sont les deux caracteristiques les plus importantes globalement » |
LIME — Local Interpretable Model-agnostic Explanations
Comment LIME fonctionne
LIME explique les predictions individuelles en construisant un modele simple et interpretable (comme une regression lineaire) autour du point de prediction.
L'intuition : Meme si le modele global est complexe, la frontiere de decision pres d'un point specifique peut etre approximativement lineaire.
Algorithme LIME etape par etape
Analogie : Expliquer une decision a un enfant
Imaginez expliquer a un enfant de 5 ans pourquoi vous avez choisi un restaurant :
- Pensez a ce que vous avez considere (caracteristiques) : prix, distance, note, cuisine
- Modifiez legerement un facteur a la fois (perturbations) : « Et si c'etait moins cher ? Et si c'etait plus loin ? »
- Observez comment votre decision change (predictions sur les perturbations)
- Resumez en termes simples (modele lineaire) : « Je l'ai surtout choisi parce qu'il est proche et pas cher »
Implementation LIME
import lime
import lime.lime_tabular
import numpy as np
import joblib
model = joblib.load("models/model_v1.joblib")
X_train = np.load("data/X_train.npy")
feature_names = ["feature_1", "feature_2", "feature_3", "feature_4", "feature_5"]
class_names = ["Class 0", "Class 1"]
explainer = lime.lime_tabular.LimeTabularExplainer(
training_data=X_train,
feature_names=feature_names,
class_names=class_names,
mode="classification",
random_state=42,
)
instance = X_train[0]
explanation = explainer.explain_instance(
data_row=instance,
predict_fn=model.predict_proba,
num_features=5,
num_samples=1000,
)
print("Prediction:", model.predict([instance])[0])
print("Prediction probabilities:", model.predict_proba([instance])[0])
print("\nFeature contributions:")
for feature, weight in explanation.as_list():
direction = "↑ pushes toward Class 1" if weight > 0 else "↓ pushes toward Class 0"
print(f" {feature}: {weight:+.4f} ({direction})")
Exemple de sortie :
Prediction: 1
Prediction probabilities: [0.15 0.85]
Feature contributions:
feature_2 > 3.2: +0.2845 (↑ pushes toward Class 1)
feature_1 <= 5.5: +0.1923 (↑ pushes toward Class 1)
feature_4 <= 0.5: +0.1456 (↑ pushes toward Class 1)
feature_5 > 2.0: +0.1102 (↑ pushes toward Class 1)
feature_3 <= 1.8: +0.0834 (↑ pushes toward Class 1)
Visualisation des explications LIME
fig = explanation.as_pyplot_figure()
fig.tight_layout()
fig.savefig("lime_explanation.png", dpi=150, bbox_inches="tight")
explanation.save_to_file("lime_explanation.html")
Forces et limites de LIME
| Forces | Limites |
|---|---|
| ✅ Independant du modele — fonctionne avec n'importe quel modele | ⚠️ Les explications peuvent varier entre les executions (echantillonnage) |
| ✅ Sortie intuitive — facile a communiquer | ⚠️ Suppose la linearite locale — peut manquer les interactions |
| ✅ Fonctionne pour les donnees tabulaires, texte et images | ⚠️ La generation de perturbations est quelque peu arbitraire |
| ✅ Rapide pour les predictions individuelles | ⚠️ Pas d'explication globale par defaut |
SHAP — SHapley Additive exPlanations
Fondement en theorie des jeux
SHAP est base sur les valeurs de Shapley de la theorie des jeux cooperatifs (prix Nobel d'economie 1953). La question a laquelle il repond :
Si un groupe de joueurs (caracteristiques) travaille ensemble pour obtenir un gain (prediction), comment repartir equitablement le credit entre eux ?
L'analogie de l'addition de pizza
Imaginez que quatre amis commandent une pizza qui coute 40 € :
- Alice a commande les garnitures cheres (+12 €)
- Bob a commande du fromage en plus (+5 €)
- Charlie a commande la taille grande (+8 €)
- Diana n'a rien commande de special (+0 €)
La valeur de Shapley repartit equitablement le cout en fonction de la contribution marginale de chaque personne — ce qu'elle a ajoute dans chaque ordre possible.
Proprietes SHAP (garanties mathematiques)
| Propriete | Description |
|---|---|
| Exactitude locale | Les valeurs SHAP s'additionnent pour donner la difference entre la prediction et la valeur de base |
| Absence | Les caracteristiques qui n'affectent pas la prediction ont une valeur SHAP = 0 |
| Coherence | Si une caracteristique contribue plus dans le modele B que dans le modele A, sa valeur SHAP est plus elevee |
| Equite | Base sur une theorie des jeux rigoureuse — la seule methode avec ces garanties |
Implementation SHAP
import shap
import joblib
import numpy as np
import matplotlib.pyplot as plt
model = joblib.load("models/model_v1.joblib")
X_train = np.load("data/X_train.npy")
X_test = np.load("data/X_test.npy")
feature_names = ["feature_1", "feature_2", "feature_3", "feature_4", "feature_5"]
explainer = shap.TreeExplainer(model)
shap_values = explainer.shap_values(X_test)
print("SHAP values shape:", np.array(shap_values).shape)
print("Base value (expected value):", explainer.expected_value)
Visualisations SHAP
Force Plot (prediction unique)
instance_idx = 0
shap.initjs()
shap.force_plot(
base_value=explainer.expected_value[1],
shap_values=shap_values[1][instance_idx],
features=X_test[instance_idx],
feature_names=feature_names,
matplotlib=True,
)
plt.savefig("shap_force_plot.png", dpi=150, bbox_inches="tight")
Le force plot montre comment chaque caracteristique pousse la prediction de la valeur de base vers la prediction finale :
- Les caracteristiques rouges poussent la prediction vers le haut (vers la classe 1)
- Les caracteristiques bleues poussent la prediction vers le bas (vers la classe 0)
- Barres plus larges = contribution plus forte
Summary Plot (importance globale des caracteristiques)
shap.summary_plot(
shap_values[1],
features=X_test,
feature_names=feature_names,
show=False,
)
plt.tight_layout()
plt.savefig("shap_summary_plot.png", dpi=150, bbox_inches="tight")
Le summary plot montre :
- Axe Y : Caracteristiques classees par importance (en haut = plus importantes)
- Axe X : Valeur SHAP (impact sur la prediction)
- Couleur : Valeur de la caracteristique (rouge = elevee, bleu = faible)
Waterfall Plot (prediction unique detaillee)
shap_explanation = shap.Explanation(
values=shap_values[1][instance_idx],
base_values=explainer.expected_value[1],
data=X_test[instance_idx],
feature_names=feature_names,
)
shap.waterfall_plot(shap_explanation, show=False)
plt.tight_layout()
plt.savefig("shap_waterfall_plot.png", dpi=150, bbox_inches="tight")
Bar Plot (valeurs SHAP absolues moyennes)
shap.summary_plot(
shap_values[1],
features=X_test,
feature_names=feature_names,
plot_type="bar",
show=False,
)
plt.tight_layout()
plt.savefig("shap_bar_plot.png", dpi=150, bbox_inches="tight")
Dependence Plot (interaction des caracteristiques)
shap.dependence_plot(
ind="feature_1",
shap_values=shap_values[1],
features=X_test,
feature_names=feature_names,
interaction_index="feature_2",
show=False,
)
plt.tight_layout()
plt.savefig("shap_dependence_plot.png", dpi=150, bbox_inches="tight")
LIME vs. SHAP — Comparaison detaillee
| Aspect | LIME | SHAP |
|---|---|---|
| Fondement | Approximation lineaire locale | Valeurs de Shapley (theorie des jeux) |
| Garanties theoriques | ❌ Aucune garantie formelle | ✅ Exactitude locale, coherence, absence |
| Portee | Local uniquement | Local + Global |
| Vitesse | ⚡ Rapide (instance unique) | 🐢 Plus lent (toutes les instances pour le global) |
| Stabilite | ⚠️ Peut varier entre les executions | ✅ Deterministe pour les modeles arborescents |
| Support des modeles | N'importe quel modele (independant du modele) | N'importe quel modele (KernelSHAP), optimise pour les arbres (TreeSHAP) |
| Sortie | Poids d'importance des caracteristiques | Attributions additives des caracteristiques |
| Visualisation | Graphique en barres, rapport HTML | Force plot, summary, waterfall, dependence |
| Ideal pour | Explications rapides pour une prediction | Analyse rigoureuse, conformite reglementaire |
| Installation | pip install lime | pip install shap |
Quand utiliser lequel
- Utilisez LIME lorsque vous avez besoin d'une explication rapide et approximative pour une prediction
- Utilisez SHAP lorsque vous avez besoin d'explications rigoureuses et theoriquement fondees — notamment pour la conformite reglementaire
- Utilisez les deux en production : LIME pour les explications en temps reel, SHAP pour les audits periodiques du modele
Methodes d'importance des caracteristiques
Au-dela de LIME et SHAP, il existe d'autres facons de comprendre l'importance des caracteristiques :
Importance integree (modeles arborescents)
import pandas as pd
importances = model.feature_importances_
feature_importance_df = pd.DataFrame({
"feature": feature_names,
"importance": importances,
}).sort_values("importance", ascending=False)
print(feature_importance_df.to_string(index=False))
Importance par permutation
from sklearn.inspection import permutation_importance
result = permutation_importance(
model, X_test, y_test,
n_repeats=10,
random_state=42,
)
for i in result.importances_mean.argsort()[::-1]:
print(f"{feature_names[i]}: {result.importances_mean[i]:.4f} "
f"± {result.importances_std[i]:.4f}")
Comparaison des methodes d'importance
| Methode | Base | Avantages | Inconvenients |
|---|---|---|---|
| Integree (Gini/Gain) | Reduction d'impurete pendant l'entrainement | Rapide, pas de calcul supplementaire | Biaisee vers les caracteristiques a forte cardinalite |
| Permutation | Baisse de precision quand la caracteristique est melangee | Independante du modele, non biaisee | Lente pour les grands jeux de donnees, caracteristiques correlees |
| SHAP | Attribution equitable par la theorie des jeux | Theoriquement solide, gere les interactions | Couteuse en calcul |
| LIME | Approximation lineaire locale | Rapide, intuitive | Instable, local uniquement |
Courbes de dependance partielles (PDP)
Les PDP montrent comment une caracteristique affecte les predictions en moyenne, en gardant toutes les autres caracteristiques constantes :
from sklearn.inspection import PartialDependenceDisplay
fig, ax = plt.subplots(1, 3, figsize=(15, 4))
PartialDependenceDisplay.from_estimator(
model, X_test,
features=[0, 1, 2],
feature_names=feature_names,
ax=ax,
kind="both",
)
fig.tight_layout()
fig.savefig("partial_dependence_plots.png", dpi=150, bbox_inches="tight")
Communiquer les resultats aux parties prenantes
Differentes audiences ont besoin de differents niveaux de detail :
Pour les dirigeants
« Notre modele approuve ou refuse les demandes de credit principalement en fonction du revenu (40 % d'influence), du score de credit (30 %) et de l'historique d'emploi (15 %). Les autres caracteristiques ont un impact mineur. »
Pour les regulateurs
« Pour la demande n° 12345, le modele a predit un refus avec 92 % de confiance. Les principaux facteurs contributifs etaient :
- Ratio dette/revenu de 0,85 (au-dessus du seuil de 0,60) : contribution SHAP = -0,28
- Score de credit de 580 (en dessous de la moyenne de 720) : contribution SHAP = -0,22
- Duree d'emploi de 3 mois (en dessous de la mediane de 24 mois) : contribution SHAP = -0,15 »
Pour les data scientists
Partagez l'analyse SHAP complete :
- Summary plots pour l'importance globale des caracteristiques
- Force plots pour les predictions individuelles
- Dependence plots pour les interactions entre caracteristiques
- Tests statistiques pour la stabilite des caracteristiques
Modele de rapport d'explicabilite
# Model Explainability Report
## Model Overview
- **Model type**: Random Forest Classifier
- **Training data**: 10,000 samples, 5 features
- **Performance**: Accuracy 92%, F1 0.91
## Global Feature Importance (SHAP)
| Rank | Feature | Mean |SHAP| | Direction |
|------|-----------|-----------|------------------------|
| 1 | Income | 0.245 | Higher → more likely approved |
| 2 | Credit | 0.198 | Higher → more likely approved |
| 3 | Employment| 0.112 | Longer → more likely approved |
| 4 | Age | 0.067 | Moderate impact |
| 5 | Zip Code | 0.023 | Minimal impact |
## Individual Explanation (Sample #12345)
[Force plot image]
[Waterfall plot image]
## Fairness Analysis
- No significant bias detected for protected attributes
- Gender SHAP value: 0.002 (negligible)
Points cles a retenir
Points cles a retenir
- L'explicabilite n'est pas optionnelle — elle est exigee par la reglementation (loi europeenne sur l'IA) et essentielle pour la confiance
- LIME explique les predictions individuelles en ajustant un modele interpretable local autour du point de prediction
- SHAP utilise la theorie des jeux (valeurs de Shapley) pour repartir equitablement le credit entre les caracteristiques — avec des garanties mathematiques
- Utilisez les explications locales pour justifier les decisions individuelles ; utilisez les explications globales pour comprendre le comportement global du modele
- SHAP est prefere pour la conformite reglementaire en raison de ses garanties theoriques
- Differentes parties prenantes ont besoin de formats d'explication differents : les dirigeants veulent des resumes, les regulateurs veulent des details
- Combinez l'explicabilite avec l'analyse d'equite pour detecter et attenuer les biais
- Integrez l'explicabilite dans votre cycle de vie du developpement de modeles, et non comme une reflexion apres coup