Interprétabilité de l'IA avec LIME et SHAP : guide pratique (2026)

Table des matières

1. →Pourquoi l'interprétabilité est importante
2. →Le paysage de l'interprétabilité
3. →LIME : explications locales interprétables
4. →SHAP : attribution de caractéristiques par théorie des jeux
5. →LIME vs SHAP : quand utiliser lequel
6. →Guide d'implémentation
7. →Exigences réglementaires
8. →Techniques avancées
9. →Pièges courants
10. →FAQ

Pourquoi l'interprétabilité est importante

Les modèles de machine learning prennent de plus en plus de décisions qui affectent la vie des gens — approbations de prêts, diagnostics médicaux, décisions d'embauche, recommandations de contenu. Pourtant, beaucoup de ces modèles sont des « boîtes noires » qui fournissent des prédictions sans explications.

Le problème de la boîte noire

Exemple : Un utilisateur soumet une demande de prêt avec :

• →Âge : 35 ans
• →Revenu : 75 000 $
• →Dettes : 20 000 $
• →Historique de crédit : 5 ans

Le modèle renvoie : PRÊT REFUSÉ

❓ Question : Pourquoi le prêt a-t-il été refusé ? 🤷 Réponse : Le modèle ne fournit aucune explication.

Cette opacité crée des problèmes :

Interprétabilité vs Explicabilité

Ces termes sont souvent utilisés de manière interchangeable, mais il existe une distinction :

Interprétabilité : Comprendre comment un modèle fonctionne en interne

• →Quelles caractéristiques comptent ?
• →Comment les caractéristiques interagissent-elles ?
• →Quels motifs le modèle a-t-il appris ?

Explicabilité : Communiquer le comportement du modèle aux humains

• →Pourquoi le modèle a-t-il fait cette prédiction ?
• →Qu'est-ce qui changerait la prédiction ?
• →Cette prédiction est-elle fiable ?

LIME et SHAP sont principalement des outils d'explicabilité — ils aident à communiquer pourquoi les prédictions ont été faites, même si nous ne comprenons pas entièrement les mécanismes internes du modèle.

Le paysage de l'interprétabilité

Avant de plonger dans LIME et SHAP, comprenons où ils se situent dans la boîte à outils plus large de l'interprétabilité :

Types de méthodes d'interprétabilité

Par portée :

• →Globale : Expliquer le comportement global du modèle (importance des caractéristiques, frontières de décision)
• →Locale : Expliquer les prédictions individuelles (LIME, SHAP par prédiction)

Par moment :

• →Intrinsèque : Intégrée à l'architecture du modèle (arbres de décision, modèles linéaires, poids d'attention)
• →Post-hoc : Appliquée après l'entraînement (LIME, SHAP, cartes de saillance)

Par dépendance au modèle :

• →Spécifique au modèle : Ne fonctionne qu'avec certains modèles (Tree SHAP, visualisation de l'attention)
• →Agnostique au modèle : Fonctionne avec n'importe quel modèle (LIME, Kernel SHAP)

Vue d'ensemble des méthodes clés

*SHAP dispose d'implémentations agnostiques (Kernel SHAP) et spécifiques (Tree SHAP, Deep SHAP).

LIME : explications locales interprétables

LIME (Local Interpretable Model-agnostic Explanations) a été introduit par Ribeiro, Singh et Guestrin en 2016. L'idée centrale est élégamment simple :

« Intuitivement, une explication est une approximation linéaire locale du comportement du modèle. » — "Why Should I Trust You?": Explaining the Predictions of Any Classifier

L'intuition de LIME

Les modèles complexes peuvent avoir un comportement global complexe, mais localement — dans le voisinage d'une seule prédiction — ils sont souvent approximativement linéaires.

Modèle global : La frontière de décision est complexe et non linéaire, avec des courbes et des motifs irréguliers séparant les différentes classes.

Approximation locale : Lorsque nous zoomons sur un point de prédiction unique (★), la frontière complexe ressemble presque à une ligne droite. LIME exploite cela en ajustant un modèle linéaire simple juste dans ce voisinage local.

Comment fonctionne LIME

ALGORITHME LIME :

ENTRÉE :
    - f : Modèle boîte noire à expliquer
    - x : Instance à expliquer
    - N : Nombre d'échantillons à générer

SORTIE :
    - Explication : Poids des caractéristiques pour cette prédiction

PROCESSUS :

1. PERTURBER : Générer N échantillons proches de x
   POUR i = 1 à N :
       x'[i] = perturber(x)  # Modifier aléatoirement les caractéristiques
       y'[i] = f(x'[i])      # Obtenir les prédictions du modèle
       w[i] = proximité(x, x'[i])  # Pondérer par la distance à x

2. AJUSTER : Entraîner un modèle interprétable sur les échantillons perturbés
   g = entraîner_modèle_linéaire(x', y', poids=w)
   
   # g est un modèle simple (régression linéaire, arbre de décision)
   # qui approxime f localement autour de x

3. EXPLIQUER : Extraire les contributions des caractéristiques de g
   explication = g.coefficients  # Pour un modèle linéaire
   
   RETOURNER explication

Pseudo-code d'implémentation LIME

PSEUDO-CODE : LIME pour données tabulaires

def expliquer_instance(modèle, instance, nb_échantillons=5000):
    """
    Expliquer une seule prédiction avec LIME
    
    Args:
        modèle : Modèle boîte noire avec méthode predict()
        instance : Point de données à expliquer (tableau numpy)
        nb_échantillons : Nombre d'échantillons perturbés
    
    Retourne :
        Dictionnaire associant caractéristiques à scores d'importance
    """
    
    # Étape 1 : Générer des échantillons perturbés
    perturbations = []
    prédictions = []
    poids = []
    
    POUR i dans range(nb_échantillons):
        # Créer une version perturbée
        perturbé = instance.copie()
        
        # Activer/désactiver aléatoirement des caractéristiques
        masque = masque_binaire_aléatoire(len(instance))
        perturbé = appliquer_masque(perturbé, masque, données_entraînement)
        
        perturbations.ajouter(masque)  # Stocker la représentation binaire
        prédictions.ajouter(modèle.predict(perturbé))
        
        # Pondérer par similarité avec l'instance originale
        distance = distance_hamming(masque, vecteur_uns)
        poids_val = exp(-distance / largeur_noyau)
        poids.ajouter(poids_val)
    
    # Étape 2 : Ajuster un modèle linéaire pondéré
    X = tableau(perturbations)
    y = tableau(prédictions)
    w = tableau(poids)
    
    # Régression ridge pondérée
    modèle_linéaire = Ridge(alpha=1.0)
    modèle_linéaire.fit(X, y, sample_weight=w)
    
    # Étape 3 : Extraire l'explication
    noms_caractéristiques = obtenir_noms_caractéristiques()
    explication = {}
    
    POUR i, coef dans enumerate(modèle_linéaire.coef_):
        explication[noms_caractéristiques[i]] = coef
    
    RETOURNER explication


# Exemple d'utilisation
instance = [35, 75000, 20000, 5]  # Âge, Revenu, Dettes, Historique
explication = expliquer_instance(modèle_prêt, instance)

# Sortie :
# {
#   "Âge": 0.02,
#   "Revenu": 0.45,      # Fort positif
#   "Dettes": -0.38,     # Fort négatif
#   "Historique": 0.15
# }

LIME pour différents types de données

Données tabulaires : Perturber en remplaçant les valeurs des caractéristiques par des échantillons de la distribution d'entraînement

Texte : Perturber en supprimant des mots et en observant les changements de prédiction

ORIGINAL : "Ce film était absolument fantastique et merveilleux !"
PRÉDICTION : Positif (0.95)

PERTURBATIONS :
"Ce film était absolument [MASQUE] et merveilleux !" -> 0.82
"Ce film était [MASQUE] fantastique et merveilleux !" -> 0.91
"Ce [MASQUE] était absolument fantastique et [MASQUE] !" -> 0.78
...

EXPLICATION :
"fantastique" -> +0.25 (mot positif le plus important)
"merveilleux" -> +0.18
"absolument" -> +0.08

Images : Perturber en masquant des superpixels (régions cohérentes)

IMAGE ORIGINALE : Photo de chat
PRÉDICTION : Chat (0.92)

PERTURBATIONS :
[Masquer les oreilles] -> 0.71    # Les oreilles comptent
[Masquer les yeux] -> 0.65        # Les yeux comptent beaucoup
[Masquer l'arrière-plan] -> 0.89  # L'arrière-plan compte peu

EXPLICATION : Carte de chaleur montrant les oreilles et les yeux comme les plus importants

SHAP : attribution de caractéristiques par théorie des jeux

SHAP (SHapley Additive exPlanations) a été introduit par Lundberg et Lee en 2017. Il ancre l'attribution des caractéristiques dans la théorie des jeux, fournissant des explications théoriquement cohérentes.

« SHAP attribue à chaque caractéristique une valeur d'importance pour une prédiction particulière. » — A Unified Approach to Interpreting Model Predictions

Les valeurs de Shapley expliquées

SHAP est basé sur les valeurs de Shapley de la théorie des jeux coopératifs. L'intuition :

LE JEU : Prédire la sortie est un « jeu »
LES JOUEURS : Les caractéristiques sont les « joueurs »
LE GAIN : La valeur de la prédiction est le « gain »

QUESTION : Comment distribuer équitablement le crédit entre les joueurs ?

RÉPONSE DE SHAPLEY :
Considérer chaque coalition (sous-ensemble) possible de joueurs.
Pour chaque coalition, mesurer la contribution marginale de chaque joueur.
Moyenner sur tous les ordres possibles.

FORMEL :
φᵢ = Σ |S|!(|N|-|S|-1)! / |N|! × [f(S ∪ {i}) - f(S)]
     S⊆N\{i}

OÙ :
- φᵢ : Valeur de Shapley pour la caractéristique i
- S : Un sous-ensemble de caractéristiques n'incluant pas i
- N : Toutes les caractéristiques
- f(S) : Sortie du modèle avec uniquement les caractéristiques dans S

Pourquoi les valeurs de Shapley ?

Les valeurs de Shapley satisfont de manière unique quatre propriétés souhaitables :

Aucune autre méthode d'attribution ne satisfait les quatre propriétés.

Pseudo-code SHAP

PSEUDO-CODE : Kernel SHAP (agnostique au modèle)

def valeurs_shap(modèle, instance, données_référence, nb_échantillons=2000):
    """
    Calculer les valeurs SHAP pour une instance
    
    Args:
        modèle : Modèle boîte noire
        instance : Point de données à expliquer
        données_référence : Jeu de données de référence
        nb_échantillons : Nombre d'échantillons de coalition
    
    Retourne :
        Valeurs SHAP pour chaque caractéristique
    """
    
    nb_caractéristiques = len(instance)
    
    # Valeur attendue (prédiction de référence)
    référence = moyenne([modèle.predict(x) pour x dans données_référence])
    
    # Échantillonner des coalitions (sous-ensembles de caractéristiques)
    coalitions = []
    prédictions = []
    poids = []
    
    POUR i dans range(nb_échantillons):
        # Coalition aléatoire (masque binaire)
        taille_coalition = entier_aléatoire(0, nb_caractéristiques)
        coalition = sous_ensemble_aléatoire(nb_caractéristiques, taille_coalition)
        
        # Créer une instance avec les caractéristiques de coalition depuis l'instance,
        # les caractéristiques hors coalition depuis la référence
        instance_masquée = instance.copie()
        échantillon_référence = choix_aléatoire(données_référence)
        
        POUR j dans range(nb_caractéristiques):
            SI j pas dans coalition:
                instance_masquée[j] = échantillon_référence[j]
        
        coalitions.ajouter(masque_binaire(coalition, nb_caractéristiques))
        prédictions.ajouter(modèle.predict(instance_masquée))
        
        # Poids du noyau de Shapley
        k = len(coalition)
        SI k == 0 OU k == nb_caractéristiques:
            poids_val = 1e6  # Poids très élevé pour coalitions vides/pleines
        SINON:
            poids_val = (nb_caractéristiques - 1) / (binomial(nb_caractéristiques, k) * k * (nb_caractéristiques - k))
        poids.ajouter(poids_val)
    
    # Résoudre la régression linéaire pondérée
    X = tableau(coalitions)
    y = tableau(prédictions) - référence
    w = tableau(poids)
    
    # Contrainte : les coefficients doivent sommer à (prédiction - référence)
    prédiction_modèle = modèle.predict(instance)
    
    valeurs_shap = régression_pondérée_contrainte(X, y, w,
                                                   contrainte_somme=prédiction_modèle - référence)
    
    RETOURNER valeurs_shap, référence


# Exemple de sortie
vals_shap, base = valeurs_shap(modèle_prêt, candidat, données_entraînement)

# Interprétation :
# Prédiction de base : 0.60 (probabilité moyenne d'approbation)
# 
# Valeurs SHAP :
#   Revenu : +0.25      (le revenu augmente l'approbation de 0.25)
#   Dettes : -0.15      (la dette diminue l'approbation de 0.15)
#   Âge : +0.03         (l'âge augmente légèrement l'approbation)
#   Historique : +0.07   (l'historique augmente l'approbation)
#
# Prédiction finale : 0.60 + 0.25 - 0.15 + 0.03 + 0.07 = 0.80

Types de visualisation SHAP

1. Graphique de force : Montre comment les caractéristiques poussent la prédiction depuis la valeur de base

En partant de la prédiction de base (0.60), chaque caractéristique pousse la prédiction vers le haut ou vers le bas :

• →Revenu : +0.25 (pousse vers le haut)
• →Historique : +0.07 (pousse vers le haut)
• →Âge : +0.03 (pousse vers le haut)
• →Dettes : -0.15 (pousse vers le bas)
• →Prédiction finale : 0.80

2. Graphique résumé : Vue globale de l'importance des caractéristiques sur toutes les prédictions

Montre la distribution des valeurs SHAP pour chaque caractéristique à travers le jeu de données, révélant quelles caractéristiques ont le plus d'impact globalement.

3. Graphique de dépendance : Comment la valeur d'une caractéristique affecte sa valeur SHAP

Montre la relation entre la valeur réelle d'une caractéristique (axe x) et sa valeur SHAP (axe y), révélant les relations non linéaires.

Tree SHAP : calcul exact rapide

Pour les modèles à base d'arbres (Random Forest, XGBoost, LightGBM), Tree SHAP calcule les valeurs de Shapley exactes en temps polynomial :

Où : T = Nombre d'arbres, L = Maximum de feuilles, D = Profondeur maximale

Exemple : Pour un modèle avec 100 arbres, profondeur 10 et 20 caractéristiques :

• →Kernel SHAP : ~1 million d'évaluations
• →Tree SHAP : ~100 000 évaluations (10x plus rapide)

LIME vs SHAP : quand utiliser lequel

Tableau comparatif

Cadre de décision

Utilisez LIME quand :

• →Vous avez besoin d'explications rapides et intuitives
• →La cohérence exacte n'est pas critique
• →Vous expliquez à des parties prenantes non techniques
• →Vous travaillez avec du texte ou des images
• →Vous prototypez ou explorez

Utilisez SHAP quand :

• →Vous avez besoin d'explications théoriquement fondées
• →La cohérence entre les explications est importante
• →Vous voulez des explications globales + locales
• →Vous travaillez avec des modèles d'arbres (Tree SHAP est rapide)
• →Vous devez satisfaire des exigences réglementaires
• →Les caractéristiques doivent sommer à la prédiction

Utilisez les deux quand :

• →Vous voulez valider les explications
• →Différentes parties prenantes ont besoin de vues différentes
• →Vous construisez un système d'explication complet

Recommandations pratiques

Guide d'implémentation

Configuration de LIME

PSEUDO-CODE : Configuration et utilisation de LIME

# Installation (conceptuel)
# pip install lime

# Pour données tabulaires
class ExplicateurLIMETabulaire:
    def __init__(self, données_entraînement, noms_caractéristiques, noms_classes):
        """
        Initialiser l'explicateur LIME avec le contexte des données d'entraînement
        """
        self.données_entraînement = données_entraînement
        self.noms_caractéristiques = noms_caractéristiques
        self.noms_classes = noms_classes
        
        # Calculer les statistiques pour la perturbation
        self.moyennes = calculer_moyennes(données_entraînement)
        self.écarts_types = calculer_écarts_types(données_entraînement)
        self.types_caractéristiques = inférer_types(données_entraînement)
    
    def expliquer_instance(self, instance, fn_prédiction, nb_caractéristiques=10):
        """
        Générer l'explication pour une seule instance
        """
        # Générer des échantillons perturbés
        échantillons = self.générer_perturbations(instance, n=5000)
        
        # Obtenir les prédictions pour les échantillons
        prédictions = fn_prédiction(échantillons)
        
        # Calculer les poids des échantillons
        poids = self.calculer_poids(instance, échantillons)
        
        # Ajuster le modèle linéaire local
        explication = self.ajuster_modèle_local(échantillons, prédictions, poids)
        
        # Retourner les caractéristiques principales
        RETOURNER explication.top_caractéristiques(nb_caractéristiques)


# Exemple d'utilisation
explicateur = ExplicateurLIMETabulaire(
    données_entraînement=X_train,
    noms_caractéristiques=['âge', 'revenu', 'dettes', 'historique'],
    noms_classes=['refusé', 'approuvé']
)

explication = explicateur.expliquer_instance(
    instance=candidat,
    fn_prédiction=modèle.predict_proba,
    nb_caractéristiques=4
)

# Affichage
print("Prédiction : Approuvé (0.80)")
print("Explication :")
POUR caractéristique, poids dans explication:
    direction = "↑" si poids > 0 sinon "↓"
    print(f"  {caractéristique}: {direction} {abs(poids):.3f}")

# Sortie :
# Prédiction : Approuvé (0.80)
# Explication :
#   revenu : ↑ 0.342
#   dettes : ↓ 0.256
#   historique : ↑ 0.124
#   âge : ↑ 0.045

Configuration de SHAP

PSEUDO-CODE : Configuration et utilisation de SHAP

# Installation (conceptuel)
# pip install shap

# Pour tout modèle (Kernel SHAP)
class ExplicateurKernelSHAP:
    def __init__(self, fn_prédiction, données_référence):
        """
        Initialiser l'explicateur SHAP avec les données de référence
        
        données_référence : Jeu de données de référence (typiquement 100-1000 échantillons)
        """
        self.fn_prédiction = fn_prédiction
        self.référence = données_référence
        self.valeur_attendue = moyenne(fn_prédiction(données_référence))
    
    def expliquer(self, instances):
        """
        Calculer les valeurs SHAP pour les instances
        """
        valeurs_shap = []
        
        POUR instance dans instances:
            valeurs = self.calculer_valeurs_shap(instance)
            valeurs_shap.ajouter(valeurs)
        
        RETOURNER tableau(valeurs_shap)
    
    def calculer_valeurs_shap(self, instance):
        # Implémente l'algorithme Kernel SHAP
        # (Voir le pseudo-code dans la section SHAP ci-dessus)
        ...


# Pour modèles d'arbres (Tree SHAP - beaucoup plus rapide)
class ExplicateurTreeSHAP:
    def __init__(self, modèle_arbre):
        """
        Initialiser avec un modèle à base d'arbres
        Supporte : XGBoost, LightGBM, RandomForest, etc.
        """
        self.modèle = modèle_arbre
        self.valeur_attendue = self.calculer_valeur_base()
    
    def expliquer(self, instances):
        """
        Calculer les valeurs SHAP exactes en utilisant la structure d'arbre
        """
        # Utilise un algorithme en temps polynomial
        RETOURNER self.algorithme_tree_shap(instances)


# Exemple d'utilisation
explicateur = ExplicateurTreeSHAP(modèle_xgboost)
valeurs_shap = explicateur.expliquer(X_test)

# Visualisation
def graphique_résumé(valeurs_shap, X_test, noms_caractéristiques):
    """
    Créer un graphique résumé montrant l'importance des caractéristiques
    """
    # Trier les caractéristiques par valeur SHAP absolue moyenne
    importance = moyenne(abs(valeurs_shap), axe=0)
    idx_triés = trier_indices(importance)[::-1]
    
    POUR idx dans idx_triés[:10]:
        print(f"{noms_caractéristiques[idx]}: {importance[idx]:.4f}")
        
        # Tracer la distribution des valeurs SHAP pour cette caractéristique
        graphique_essaim(valeurs_shap[:, idx], X_test[:, idx])


# Graphique de force pour une prédiction unique
def graphique_force(valeurs_shap, instance, valeur_attendue, noms_caractéristiques):
    """
    Montrer comment les caractéristiques poussent la prédiction depuis la valeur de base
    """
    prédiction = valeur_attendue + somme(valeurs_shap)
    
    print(f"Valeur de base : {valeur_attendue:.3f}")
    print(f"Prédiction : {prédiction:.3f}")
    print("\nContributions des caractéristiques :")
    
    POUR i, (nom, valeur) dans enumerate(zip(noms_caractéristiques, valeurs_shap)):
        SI abs(valeur) > 0.01:  # Afficher uniquement les caractéristiques significatives
            flèche = "→↑" si valeur > 0 sinon "→↓"
            print(f"  {nom}: {flèche} {valeur:+.3f}")

Considérations de production

CHECKLIST PRODUCTION :

1. MISE EN CACHE
   - Pré-calculer les valeurs SHAP pour les cas courants
   - Mettre en cache les statistiques des données de référence
   - Stocker les objets explicateurs entre les requêtes

2. LATENCE
   - LIME : ~100-500ms par explication
   - Kernel SHAP : ~1-5s par explication
   - Tree SHAP : ~10-50ms par explication
   
   Si la latence compte, utilisez Tree SHAP ou pré-calculez

3. MÉMOIRE
   - Données de référence pour SHAP : ~1000 échantillons typiquement
   - Statistiques des données d'entraînement LIME : ~10Ko par caractéristique
   
   Envisagez l'échantillonnage pour les grands jeux de données

4. COHÉRENCE
   - Fixer les graines aléatoires pour un LIME reproductible
   - Utiliser des données de référence cohérentes pour SHAP
   - Documenter la méthodologie d'explication

5. SURVEILLANCE
   - Journaliser les distributions d'explications au fil du temps
   - Alerter sur les changements inattendus d'importance des caractéristiques
   - Suivre les échecs de génération d'explications

Exigences réglementaires

Exigences d'explicabilité du règlement européen sur l'IA

Le règlement européen sur l'IA (en vigueur 2024-2026) impose l'explicabilité pour les systèmes d'IA à haut risque :

« Il n'est souvent pas possible de savoir pourquoi un système d'IA a pris une décision ou une prédiction... Il peut donc devenir difficile d'évaluer si quelqu'un a été injustement désavantagé. » — Considérants du règlement européen sur l'IA

Exigences de conformité

LES SYSTÈMES D'IA À HAUT RISQUE DOIVENT :

1. TRANSPARENCE
   - Fournir des informations claires sur l'utilisation de l'IA
   - Expliquer la logique impliquée dans la prise de décision
   - Informer les personnes concernées de leurs droits

2. DOCUMENTATION
   - Maintenir des journaux des décisions IA
   - Documenter la méthodologie d'explication
   - Enregistrer l'importance des caractéristiques pour les audits

3. SUPERVISION HUMAINE
   - Permettre la compréhension humaine des sorties IA
   - Permettre l'intervention dans les décisions automatisées
   - Fournir une révision humaine significative

4. DROITS DES PERSONNES CONCERNÉES
   - Droit à l'explication pour les décisions automatisées
   - Droit à la révision humaine
   - Droit de contester les décisions IA

LIME/SHAP pour la conformité

STRATÉGIE DE CONFORMITÉ :

POUR chaque décision IA à haut risque :
    
    1. GÉNÉRER L'EXPLICATION
       explication = explicateur_shap.expliquer(instance)
       # ou
       explication = explicateur_lime.expliquer_instance(instance)
    
    2. JOURNALISER POUR L'AUDIT
       journal_audit.enregistrer({
           "horodatage": maintenant(),
           "id_décision": id_unique,
           "prédiction": sortie_modèle,
           "explication": explication,
           "caractéristiques_principales": explication.top(5),
           "version_modèle": modèle.version
       })
    
    3. PRÉSENTER À L'UTILISATEUR (si demandé)
       explication_utilisateur = formater_pour_humains(explication)
       
       # Exemple de sortie :
       # "Votre demande de prêt a été évaluée principalement sur :
       #  - Votre niveau de revenu (facteur positif)
       #  - Votre endettement actuel (facteur négatif)
       #  - La durée de votre historique de crédit (facteur positif)
       #  
       #  Vous pouvez demander une révision humaine de cette décision."
    
    4. PERMETTRE LA CONTESTATION
       SI utilisateur.demande_révision():
           acheminer_vers_réviseur_humain(id_décision, explication)

Cadre de gestion des risques IA du NIST

Le NIST AI RMF fournit des orientations sur l'interprétabilité :

Fonctions du NIST AI RMF :

Techniques avancées

Valeurs d'interaction SHAP

Au-delà des attributions individuelles, SHAP peut mesurer les interactions entre caractéristiques :

INTERACTIONS SHAP :

SHAP standard : Combien la caractéristique i contribue-t-elle ?
Interaction SHAP : Combien les caractéristiques i et j contribuent-elles ensemble,
                   au-delà de leurs contributions individuelles ?

PSEUDO-CODE :
valeurs_interaction = explicateur_shap.shap_interaction_values(X)

# valeurs_interaction[échantillon, caractéristique_i, caractéristique_j]
# Diagonale : effets principaux
# Hors diagonale : effets d'interaction

EXEMPLE :
# Âge seul : +0.05
# Revenu seul : +0.20
# Interaction Âge × Revenu : +0.10
# 
# Interprétation : Un revenu élevé compte davantage pour les candidats plus jeunes

Ancres : explications basées sur des règles

Les ancres complètent LIME/SHAP avec des explications basées sur des règles :

EXPLICATION LIME :
"Le revenu a contribué +0.34 à la probabilité d'approbation"

EXPLICATION ANCRE :
"SI revenu > 60000 ET dettes < 15000 ALORS approuvé
 (avec 95% de précision)"

PSEUDO-CODE :
def trouver_ancre(modèle, instance, seuil_précision=0.95):
    """
    Trouver la règle minimale qui garantit la prédiction
    """
    règles = []
    précision_actuelle = 0
    
    TANT QUE précision_actuelle < seuil_précision:
        # Ajouter la règle la plus informative
        meilleure_règle = trouver_meilleure_règle(instance, règles, modèle)
        règles.ajouter(meilleure_règle)
        
        # Mesurer la précision de l'ensemble de règles actuel
        précision_actuelle = évaluer_précision(règles, modèle)
    
    RETOURNER règles

Explications contrefactuelles

Quel changement minimal inverserait la prédiction ?

EXPLICATION CONTREFACTUELLE :

Original : Prêt REFUSÉ
"Si votre revenu était de 65 000 $ au lieu de 50 000 $,
 votre prêt aurait été APPROUVÉ"

PSEUDO-CODE :
def trouver_contrefactuel(modèle, instance, classe_cible):
    """
    Trouver la perturbation minimale qui change la prédiction
    """
    # Partir de l'instance originale
    contrefactuel = instance.copie()
    
    # Optimiser pour inverser la prédiction avec un changement minimal
    POUR itération dans range(max_itérations):
        # Calculer le gradient vers la classe cible
        gradient = calculer_gradient(modèle, contrefactuel, classe_cible)
        
        # Mettre à jour le contrefactuel
        contrefactuel += taux_apprentissage * gradient
        
        # Encourager des changements minimaux
        contrefactuel = projeter_dans_plage_valide(contrefactuel)
        
        SI modèle.predict(contrefactuel) == classe_cible:
            break
    
    # Rapporter les changements
    changements = []
    POUR i, (orig, nouveau) dans enumerate(zip(instance, contrefactuel)):
        SI abs(orig - nouveau) > seuil:
            changements.ajouter((noms_caractéristiques[i], orig, nouveau))
    
    RETOURNER changements

Pièges courants

Piège 1 : Traiter les explications comme une vérité absolue

PROBLÈME :
Les explications sont des approximations, pas la logique réelle du modèle.
LIME et SHAP peuvent être en désaccord, et les deux peuvent se tromper.

ATTÉNUATION :
- Utiliser plusieurs méthodes d'explication
- Valider les explications avec des experts du domaine
- Tester la fidélité des explications (les caractéristiques comptent-elles vraiment ?)

Piège 2 : Ignorer la corrélation des caractéristiques

PROBLÈME :
Quand les caractéristiques sont corrélées, l'attribution peut être distribuée
arbitrairement entre elles.

EXEMPLE :
- La taille et le poids sont corrélés
- SHAP peut attribuer l'importance à l'un arbitrairement
- La "vraie" importance est partagée

ATTÉNUATION :
- Utiliser les valeurs d'interaction SHAP
- Regrouper les caractéristiques corrélées
- Être prudent dans l'interprétation des caractéristiques corrélées individuelles

Piège 3 : Mauvaises données de référence (SHAP)

PROBLÈME :
Les explications SHAP dépendent des données de référence.
Mauvaise référence = mauvaises explications.

MAUVAIS :
référence = jeu_entraînement_complet  # Peut inclure des sous-groupes non pertinents

BON :
référence = sous_population_pertinente  # Ex. même démographie

ATTÉNUATION :
- Choisir les données de référence avec soin
- Considérer plusieurs points de référence
- Documenter le choix des données de référence

Piège 4 : Instabilité (LIME)

PROBLÈME :
Les explications LIME peuvent varier selon la graine aléatoire.
Exécuter deux fois peut donner des réponses différentes.

ATTÉNUATION :
- Fixer la graine aléatoire pour la reproductibilité
- Exécuter plusieurs fois et moyenner
- Utiliser SHAP si la cohérence est critique
- Rapporter les intervalles de confiance

Piège 5 : Coût de calcul (SHAP)

PROBLÈME :
Kernel SHAP est coûteux : O(2^n) pour n caractéristiques

SYMPTÔMES :
- L'explication prend des minutes
- Erreurs de mémoire pour les grands jeux de données
- Problèmes de latence en production

ATTÉNUATION :
- Utiliser Tree SHAP pour les modèles d'arbres (O(TLD²))
- Limiter le nombre d'échantillons de référence
- Pré-calculer les explications hors ligne
- Échantillonner les caractéristiques pour les données haute dimension

FAQ

Q : LIME et SHAP sont-ils fidèles au modèle ? R : Pas parfaitement. LIME est une approximation locale qui peut manquer les non-linéarités. SHAP est théoriquement cohérent mais peut donner des attributions trompeuses pour les caractéristiques corrélées. Validez toujours avec les connaissances du domaine et plusieurs méthodes.

Q : Puis-je utiliser LIME/SHAP pour le deep learning ? R : Oui, mais avec des réserves. Kernel SHAP fonctionne avec n'importe quel modèle mais est lent. Deep SHAP utilise des approximations basées sur les gradients. Pour les images, envisagez les cartes de saillance ou les gradients intégrés en complément de LIME.

Q : Combien d'échantillons de référence faut-il pour SHAP ? R : Typiquement 100-1000 échantillons. Plus c'est mieux pour la précision mais plus lent. Rendements décroissants après ~1000. Assurez-vous que la référence est représentative de la distribution de vos données.

Q : Faut-il des explications pour chaque prédiction ? R : Pas nécessairement. Considérez : (1) Les décisions à enjeux élevés nécessitent des explications, (2) Les exigences réglementaires peuvent imposer la journalisation, (3) Les explications à la demande peuvent suffire pour les cas à faible risque.

Q : Comment expliquer à des utilisateurs non techniques ? R : Concentrez-vous sur : (1) Quels facteurs ont le plus compté, (2) Dans quel sens chaque facteur a poussé la décision, (3) Quels changements pourraient mener à un résultat différent. Évitez le jargon technique comme « valeurs SHAP ».

Q : Les explications peuvent-elles être détournées ou manipulées ? R : Oui. Des exemples adversariaux existent pour les explications. Quelqu'un pourrait créer des entrées donnant des explications trompeuses. Surveillez les motifs inhabituels et utilisez plusieurs méthodes d'explication.

Conclusion

L'interprétabilité est essentielle pour un déploiement responsable de l'IA. LIME et SHAP fournissent des approches complémentaires pour comprendre les prédictions des modèles, chacune avec des forces distinctes.

Points clés à retenir :

1. →LIME est rapide et intuitif — Idéal pour des explications locales rapides et les parties prenantes non techniques
2. →SHAP est rigoureux et cohérent — Idéal pour la conformité, le débogage et la solidité théorique
3. →Utilisez les deux quand c'est possible — Différentes méthodes mettent en lumière différents motifs
4. →Les explications sont des approximations — Validez avec les connaissances du domaine
5. →Les exigences réglementaires croissent — Planifiez l'explicabilité dès le départ

À mesure que les systèmes d'IA deviennent plus répandus dans les décisions à enjeux élevés, l'interprétabilité passe de « nice to have » à exigence essentielle. LIME et SHAP sont des outils fondamentaux dans ce paysage.

📚 Série Ingénierie IA responsable

← Précédent : RLHF et IA constitutionnelle Suivant → : Red teaming automatisé avec PyRIT

🚀 Prêt à maîtriser l'IA responsable ?

Nos modules de formation couvrent l'implémentation pratique des techniques de sécurité IA, du prompt engineering à la gouvernance en production.

📚 Explorer nos modules de formation | Commencer le Module 0

Références :

• →Ribeiro, Singh, Guestrin (2016). "Why Should I Trust You?": Explaining the Predictions of Any Classifier
• →Lundberg, Lee (2017). A Unified Approach to Interpreting Model Predictions
• →LIME Documentation
• →SHAP Documentation
• →NIST AI Risk Management Framework
• →EU AI Act

Dernière mise à jour : 29 janvier 2026 Partie 3 de la série Ingénierie IA responsable