SHAP et LIME : Techniques XAI

L’explicabilité IA (XAI – eXplainable AI) n’est plus une option. L’AI Act exige que les systèmes à haut risque puissent expliquer leurs décisions. Impossible de dire « l’algorithme a décidé » sans justification.

Deux techniques dominent le marché : SHAP (SHapley Additive exPlanations) et LIME (Local Interpretable Model-agnostic Explanations). Chacune a ses forces et ses limites.

Ce guide vous explique comment fonctionnent ces techniques, quand les utiliser, et comment les implémenter pour répondre aux exigences de l’AI Act.

Par Loïc Gros-Flandre

Directeur de Modernee – Agence IA & Fondateur de Soignant Voice Application médical. Expert en conformité IA et transformation digitale des entreprises.

🎯 Spécialiste AI Act • 💼 XAI • 🔍 Explicabilité ML

📊 SHAP : Les Valeurs de Shapley Expliquées

SHAP (SHapley Additive exPlanations) est basé sur la théorie des jeux. Il répond à la question : quelle est la contribution de chaque feature à cette prédiction spécifique ?

Photo par Campaign Creators sur Unsplash

🎲 Le Concept des Valeurs de Shapley

Imaginez un jeu coopératif. Plusieurs joueurs (features) contribuent à un gain (prédiction). Les valeurs de Shapley calculent la contribution équitable de chaque joueur.

La formule considère toutes les coalitions possibles de features. Pour chaque feature, elle calcule la différence moyenne de prédiction avec et sans cette feature.

✅ Propriétés Garanties par SHAP

• 📐 Additivité — Somme des SHAP = différence prédiction vs baseline
• ⚖️ Symétrie — Features identiques → mêmes SHAP values
• 🔢 Dummy — Feature sans impact → SHAP = 0
• 📊 Cohérence — Modèle plus dépendant d’une feature → SHAP plus élevée

🔧 Types d’Explainers SHAP

« SHAP est le gold standard de l’explicabilité. C’est la méthode que les régulateurs comprennent et attendent. »

— Data Scientist Senior, Big Four audit

🍋 LIME : Approximation Locale Interprétable

LIME (Local Interpretable Model-agnostic Explanations) prend une approche différente. Il perturbe les données autour du point à expliquer et ajuste un modèle linéaire simple.

Photo par Scott Graham sur Unsplash

🔄 Comment Fonctionne LIME

LIME suit un processus en 4 étapes :

📊 LIME pour Différents Types de Données

🌍 Explications Locales vs Globales

L’AI Act exige deux types d’explications : comprendre une décision individuelle ET le comportement général du modèle.

📍 Explication Locale (Individuelle)

Répond à : « Pourquoi CE client a été refusé ? »

• 👤 Une prédiction spécifique
• 📋 Features qui ont influencé CETTE décision
• ⚖️ Droit à l’explication (Article 22 RGPD)
• 🛠️ SHAP waterfall plot, LIME explanation

🌐 Explication Globale (Modèle)

Répond à : « Comment le modèle prend-il ses décisions en général ? »

• 📊 Comportement moyen sur toutes les prédictions
• 🏆 Features les plus importantes globalement
• 📚 Documentation technique AI Act
• 🛠️ SHAP summary plot, feature importance

⚔️ SHAP vs LIME : Le Comparatif Complet

Voici le comparatif détaillé pour choisir la bonne technique selon votre contexte.

Photo par Carlos Muza sur Unsplash

💻 Implémentation Python : SHAP et LIME

Voici comment implémenter SHAP et LIME dans vos projets Python.

📦 Installation

pip install shap
pip install lime
                

📊 Exemple SHAP avec XGBoost

import shap
import xgboost as xgb

# Entraîner le modèle
model = xgb.XGBClassifier()
model.fit(X_train, y_train)

# Créer l'explainer TreeSHAP (rapide pour arbres)
explainer = shap.TreeExplainer(model)

# Calculer les SHAP values
shap_values = explainer.shap_values(X_test)

# Visualisation globale (importance features)
shap.summary_plot(shap_values, X_test)

# Visualisation locale (une prédiction)
shap.waterfall_plot(shap.Explanation(
    values=shap_values[0], 
    base_values=explainer.expected_value,
    data=X_test.iloc[0]
))
                

🍋 Exemple LIME avec Tabular

from lime.lime_tabular import LimeTabularExplainer

# Créer l'explainer LIME
explainer = LimeTabularExplainer(
    X_train.values,
    feature_names=X_train.columns.tolist(),
    class_names=['Refusé', 'Accepté'],
    mode='classification'
)

# Expliquer une prédiction
explanation = explainer.explain_instance(
    X_test.iloc[0].values,
    model.predict_proba,
    num_features=10
)

# Afficher
explanation.show_in_notebook()
                

📋 Documentation Explicabilité pour l’AI Act

L’AI Act exige une documentation formelle de l’explicabilité. Voici ce qu’il faut inclure.

📄 Éléments Obligatoires

• 1️⃣ Méthode utilisée — SHAP, LIME, ou autre avec justification
• 2️⃣ Explications globales — Top 10 features + visualisations
• 3️⃣ Exemples locaux — 3-5 cas représentatifs documentés
• 4️⃣ Limites — Instabilité, approximations, cas non couverts
• 5️⃣ Procédure utilisateur — Comment fournir une explication sur demande
• 6️⃣ Logs — Conservation des explications générées (10 ans)

❓ Questions Fréquentes – SHAP et LIME

✅ Conclusion : SHAP et LIME, Piliers de l’IA Explicable

L’explicabilité n’est plus optionnelle. SHAP et LIME sont les outils standards pour répondre aux exigences de l’AI Act et offrir aux utilisateurs des explications compréhensibles.

Implémentez l’explicabilité dans vos systèmes avant l’entrée en vigueur de l’AI Act.