Evidential Deep Learning – Guide Complet

Résumé

L’Evidential Deep Learning (EDL) est une approche révolutionnaire qui transforme la manière dont les réseaux de neurones quantifient l’incertitude de leurs prédictions. Contrairement aux modèles d’apprentissage profond classiques qui produisent des probabilités ponctuelles souvent surconfiantes, l’EDL va plus loin : il distingue l’incertitude aléatoire (inhérente aux données, irréductible) de l’incertitude épistémique (liée au manque de connaissances, réductible par l’apprentissage). Cette distinction fondamentale repose sur la théorie de Dempster-Shafer et les distributions de Dirichlet, permettant au modèle de dire non seulement « je prédis la classe A avec 70 % de confiance », mais aussi « j’ai observé suffisamment de preuves pour étayer cette prédiction ». Cette capacité à exprimer un doute fondé est cruciale dans des domaines sensibles comme la médecine, la conduite autonome ou la détection de fraude, où une prédiction erronée faite avec une confiance injustifiée peut avoir des conséquences désastreuses. Dans ce guide complet, nous explorerons les fondements mathématiques de l’EDL, son intuition profonde, son implémentation pratique en Python avec PyTorch, ainsi que ses avantages, ses limites et ses cas d’application concrets.

Principe Mathématique de l’Evidential Deep Learning

La théorie de Dempster-Shafer : fondement théorique

La théorie de Dempster-Shafer, développée par Arthur Dempster dans les années 1960 puis généralisée par Glenn Shafer, est un cadre mathématique permettant de représenter et de combiner des preuves incertaines. Contrairement à la théorie de probabilité classique de Kolmogorov qui attribue des probabilités à des événements individuels, la théorie de Dempster-Shafer associe des masses de croyance à des sous-ensembles d’un espace de discernement.

Soit un espace de discernement (\Omega = {C_1, C_2, \ldots, C_K}) représentant (K) classes possibles. Une fonction de masse (m : 2^{\Omega} \to [0,1]) satisfait :

$$\sum_{A \subseteq \Omega} m(A) = 1, \quad m(\emptyset) = 0$$

La masse (m(A)) représente la quantité de preuve exactement allouée au sous-ensemble (A), sans pouvoir être attribuée à un sous-ensemble plus petit. Cette flexibilité permet d’exprimer une ignorance totale en attribuant toute la masse à (\Omega) lui-même, ce qui est impossible dans le formalisme bayésien classique.

Modélisation par distribution de Dirichlet

Pour un problème de classification à (K) classes, l’EDL modélise la distribution subjective du modèle comme une distribution de Dirichlet de paramètre (\boldsymbol{\alpha} = (\alpha_1, \alpha_2, \ldots, \alpha_K)), où chaque (\alpha_k > 0) :

$$p(\mathbf{p} \mid \boldsymbol{\alpha}) = \frac{1}{B(\boldsymbol{\alpha})} \prod_{k=1}^{K} p_k^{\alpha_k – 1}$$

avec (B(\boldsymbol{\alpha})) la fonction bêta multivariée et (\mathbf{p}) le vecteur de probabilités sur le simplexe.

Les paramètres de Dirichlet sont obtenus à partir de la sortie du réseau de neurones (f_\theta(\mathbf{x})) via une fonction d’activation positive (Softplus ou ReLU) suivie d’un décalage :

$$\alpha_k = f_\theta(\mathbf{x})_k + 1$$

Le « +1 » garantit que tous les paramètres sont strictement positifs, condition nécessaire pour une distribution de Dirichlet valide.

Preuve et décomposition de l’incertitude

La force de preuve (evidence strength) est définie comme la somme des paramètres de Dirichlet :

$$S = \sum_{k=1}^{K} \alpha_k$$

L’evidence (preuve) collectée pour chaque classe est :

$$e_k = \alpha_k – 1 = f_\theta(\mathbf{x})_k$$

La probabilité prédite pour la classe (k) s’obtient en prenant l’espérance de la distribution de Dirichlet :

$$\hat{p}_k = \frac{\alpha_k}{S} = \frac{e_k + 1}{S}$$

La beauté de l’EDL réside dans sa capacité à décomposer l’incertitude totale en deux composantes :

• Incertitude épistémique (connaissance du modèle) :
  $$u = \frac{K}{S}$$
• Incertitude aléatoire (variabilité inhérente aux données) :
  $$\hat{p}_k = \frac{\alpha_k}{S}$$

Quand (S) est grand (beaucoup de preuves), l’incertitude épistémique (u) tend vers zéro : le modèle est sûr de sa prédiction. Quand (S) est petit (peu de preuves), (u) est élevé : le modèle reconnaît son ignorance.

Règle de fusion de Dempster

Un avantage majeur de la théorie de Dempster-Shafer est sa capacité à combiner des preuves provenant de sources multiples. La règle de fusion de Dempster permet de combiner deux fonctions de masse (m_1) et (m_2) :

$$m_{12}(A) = \frac{1}{1 – K} \sum_{B \cap C = A} m_1(B) \cdot m_2(C)$$

où (K = \sum_{B \cap C = \emptyset} m_1(B) \cdot m_2(C)) mesure le conflit entre les sources. Cette règle est particulièrement utile lorsque plusieurs modèles ou capteurs doivent être combinés pour prendre une décision collective, comme dans les systèmes de perception multi-capteurs des véhicules autonomes.

Implémentation de la fonction de perte EDL

La fonction de perte de l’EDL combine deux termes. Le premier est une adaptation de la vraisemblance marginale sous Dirichlet :

$$\mathcal{L}{EDL}(\boldsymbol{\alpha}) = \sum y_k \left[ \psi(S) – \psi(\alpha_k) \right]$$}^{K

où (\mathbf{y}) est le vecteur one-hot de la vérité terrain, et (\psi) est la fonction digamma (dérivée du logarithme de la fonction gamma).

Le second terme est une régularisation de Kullback-Leibler qui pénalise l’attribution de preuves fortes aux mauvaises classes, surtout en début d’entraînement :

$$\mathcal{L}_{KL} = \lambda_t \cdot KL\left[ D(\mathbf{p} \mid \tilde{\boldsymbol{\alpha}}) \,|\, D(\mathbf{p} \mid \mathbf{1}) \right]$$

où (\tilde{\boldsymbol{\alpha}} = \mathbf{y} + (1 – \mathbf{y}) \odot \boldsymbol{\alpha}) est le paramètre de Dirichlet avec les preuves des classes incorrectes conservées, et (D(\mathbf{p} \mid \mathbf{1})) est une distribution uniforme a priori.

Le coefficient d’annealing (\lambda_t) évolue au cours de l’entraînement :

$$\lambda_t = \min\left(1.0, \frac{t}{T_{anneal}}\right)$$

où (t) est l’époque courante et (T_{anneal}) le nombre d’époques d’annealing. Cette stratégie progressive évite que le modèle ne rejette trop agressivement toute evidence dès le début.

La fonction de perte totale s’écrit :

$$\mathcal{L} = \mathcal{L}{EDL} + \mathcal{L}$$

Intuition : l’analogie du médecin

Pour comprendre la différence fondamentale entre un réseau de neurones classique et un modèle d’Evidential Deep Learning, imaginons deux médecins confrontés à un cas clinique rare.

Le médecin classique (réseau de neurones traditionnel) : Il observe les symptômes et déclare : « Le patient a la maladie A avec 70 % de probabilité. » Ce chiffre semble précis, mais le médecin ne vous dit pas sur quoi il se base. Est-ce qu’il a traité des centaines de cas similaires ? Ou est-ce qu’il devine pratiquement au hasard ? Un softmax classique normalise toujours ses sorties pour qu’elles somment à 1, ce qui donne l’illusion d’une information complète alors que le modèle peut être totalement ignorant.

Le médecin EDL : Il déclare : « J’ai observé 3 cas similaires dans ma carrière. 2 étaient la maladie A, 1 était la maladie B. Ma confiance dans le diagnostic A est de 70 %, mais mon incertitude épistémique est élevée car j’ai peu d’expérience sur ce type de cas. Je vous recommande un examen complémentaire. »

C’est exactement ce que fait l’EDL : il compte les preuves. Quand les paramètres de Dirichlet sont élevés ((\alpha_1 = 21, \alpha_2 = 2)), le modèle dit : « J’ai vu 23 cas similaires, 20 étaient A et 3 étaient B. Je suis confiant. » Quand les paramètres sont faibles ((\alpha_1 = 2.1, \alpha_2 = 1.2)), il dit : « J’ai vu à peine 3 cas, dont 2 A et 1 B. Je ne suis pas sûr de moi, méfiez-vous de ma prédiction. »

Cette capacité à quantifier son propre doute est ce qui distingue l’Evidential Deep Learning de l’apprentissage profond traditionnel. Le modèle ne se contente pas de prédire ; il évalue la qualité de sa propre prédiction.

Implémentation Python avec PyTorch

Modèle EDL avec tête de Dirichlet

Voici une implémentation complète d’un modèle d’Evidential Deep Learning utilisant PyTorch. Le modèle repose sur un réseau neuronal suivi d’une couche de Dirichlet qui produit les paramètres (\boldsymbol{\alpha}).

import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np


class EDLModel(nn.Module):
    """
    Modèle d'Evidential Deep Learning avec tête de Dirichlet.
    Le réseau produit des logits qui sont transformés par Softplus
    pour obtenir les paramètres alpha de la distribution de Dirichlet.
    """

    def __init__(self, input_dim, hidden_dims, num_classes):
        super(EDLModel, self).__init__()
        self.num_classes = num_classes

        # Construction du réseau principal
        layers = []
        prev_dim = input_dim
        for h_dim in hidden_dims:
            layers.append(nn.Linear(prev_dim, h_dim))
            layers.append(nn.ReLU())
            layers.append(nn.Dropout(0.3))
            prev_dim = h_dim

        # Tête de preuve : produit les evidences (non négatives)
        self.evidence_layer = nn.Linear(prev_dim, num_classes)

        self.network = nn.Sequential(*layers)

    def forward(self, x):
        """
        Retourne les paramètres alpha de la distribution de Dirichlet.
        alpha_k = evidence_k + 1, avec evidence = Softplus(logits).
        """
        features = self.network(x)
        evidence = F.softplus(self.evidence_layer(features))
        alpha = evidence + 1.0
        return alpha

    def predict(self, x):
        """
        Prédiction avec décomposition de l'incertitude.
        Retourne : probabilités, incertitude épistémique, evidence strength.
        """
        alpha = self.forward(x)
        S = alpha.sum(dim=-1, keepdim=True)

        # Probabilités prédites (espérance de la distribution de Dirichlet)
        probabilities = alpha / S

        # Incertitude épistémique (inversement proportionnelle à la force de preuve)
        epistemic_uncertainty = self.num_classes / S

        # Evidence strength totale
        evidence_strength = S.sum(dim=-1)

        return probabilities, epistemic_uncertainty, evidence_strength

Fonction de perte EDL avec régularisation KL

def edl_loss(alpha, target, epoch, annealing_factor=10.0):
    """
    Fonction de perte de l'Evidential Deep Learning avec régularisation KL.

    Arguments :
        alpha            : Paramètres de Dirichlet [batch_size, num_classes]
        target           : Labels cible sous forme one-hot [batch_size, num_classes]
        epoch            : Époque courante pour l'annealing
        annealing_factor : Facteur d'annealing (nombre d'époques de transition)

    Retourne :
        Perte totale (EDL + KL régulée)
    """
    S = alpha.sum(dim=-1, keepdim=True)

    # --- Terme de vraisemblance EDL ---
    # On utilise la fonction digamma pour calculer la perte
    # L_EDL = sum_k { y_k * [psi(S) - psi(alpha_k)] }
    target = target.float()
    log_prob = torch.sum(
        target * (torch.digamma(alpha) - torch.digamma(S)),
        dim=-1,
        keepdim=True
    )
    loss_likelihood = -log_prob.mean()

    # --- Régularisation KL avec annealing progressif ---
    # L'annealing évite une régularisation trop agressive en début d'entraînement
    annealing_coef = min(1.0, epoch / annealing_factor)

    # alpha_tilde : on garde les alpha de la classe correcte,
    # on remplace les alpha des classes incorrectes
    alpha_tilde = (1.0 - target) * alpha + target

    # KL divergence entre Dirichlet(alpha_tilde) et Dirichlet(1,1,...,1)
    S_tilde = alpha_tilde.sum(dim=-1, keepdim=True)

    kl_term = torch.lgamma(S_tilde) - \
              torch.sum(torch.lgamma(alpha_tilde), dim=-1, keepdim=True) + \
              torch.sum(
                  (alpha_tilde - 1.0) * (
                      torch.digamma(alpha_tilde) - torch.digamma(S_tilde)
                  ),
                  dim=-1,
                  keepdim=True
              )

    loss_kl = (annealing_coef * kl_term).mean()

    # --- Perte totale ---
    total_loss = loss_likelihood + loss_kl
    return total_loss, loss_likelihood, loss_kl

Boucle d’entraînement

def train_edl(model, dataloader, num_epochs=50, annealing_factor=10.0, lr=1e-3):
    """
    Boucle d'entraînement complète pour un modèle EDL.

    Arguments :
        model             : Modèle EDL
        dataloader        : DataLoader PyTorch (données d'entraînement)
        num_epochs        : Nombre d'époques
        annealing_factor  : Facteur d'annealing pour la régularisation KL
        lr                : Taux d'apprentissage
    """
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)

    for epoch in range(num_epochs):
        model.train()
        total_loss = 0.0
        correct = 0
        total = 0

        for inputs, labels in dataloader:
            optimizer.zero_grad()

            # Conversion des labels en one-hot
            batch_size = inputs.size(0)
            num_classes = model.num_classes
            one_hot = F.one_hot(labels, num_classes).float()

            # Forward pass
            alpha = model(inputs)

            # Calcul de la perte EDL
            loss, nll, kl = edl_loss(alpha, one_hot, epoch, annealing_factor)

            # Backward pass
            loss.backward()
            optimizer.step()

            total_loss += loss.item()
            correct += (alpha.argmax(dim=-1) == labels).sum().item()
            total += batch_size

        avg_loss = total_loss / len(dataloader)
        accuracy = correct / total
        print(f"Époque {epoch+1}/{num_epochs} | "
              f"Perte: {avg_loss:.4f} | "
              f"Précision: {accuracy:.2%} | "
              f"KL: {kl.item():.4f}")

    return model

Détection d’échantillons hors distribution (OOD)

L’un des avantages majeurs de l’EDL est sa capacité naturelle à détecter les données hors distribution (Out-Of-Distribution, OOD). Voici comment l’implémenter :

def detect_ood(model, dataloader, threshold=None):
    """
    Détection d'échantillons hors distribution basée sur l'incertitude épistémique.
    Les échantillons OOD présentent normalement une faible evidence strength S,
    ce qui se traduit par une incertitude épistémique élevée.

    Arguments :
        model        : Modèle EDL entraîné
        dataloader   : DataLoader des données à tester
        threshold    : Seuil d'incertitude (par défaut déterminé automatiquement)

    Retourne :
        is_ood        : Booléen indiquant si chaque échantillon est OOD
        uncertainties : Incertitude épistémique de chaque échantillon
    """
    model.eval()
    all_uncertainties = []

    with torch.no_grad():
        for inputs, _ in dataloader:
            _, epistemic, _ = model.predict(inputs)
            all_uncertainties.append(epistemic.numpy())

    uncertainties = np.concatenate(all_uncertainties, axis=0)

    # Seuil automatique basé sur la moyenne + 2 écarts-types
    if threshold is None:
        threshold = uncertainties.mean() + 2 * uncertainties.std()

    is_ood = uncertainties > threshold

    print(f"Seuil OOD : {threshold:.4f}")
    print(f"Échantillons OOD détectés : {is_ood.sum()} / {len(is_ood)}")

    return is_ood, uncertainties

Hyperparamètres Clés

annealing_factor

Ce paramètre contrôle la vitesse à laquelle la régularisation KL est introduite pendant l’entraînement. Une valeur typique se situe entre 5 et 20 époques.

• Valeur faible (≤ 5) : La régularisation KL atteint sa pleine puissance rapidement. Cela peut accélérer la convergence mais risque d’empêcher le modèle de collecter suffisamment de preuves pour les classes rares.
• Valeur élevée (≥ 20) : La régularisation se met en place progressivement, laissant le modèle explorer plus librement au début. Recommandé lorsque les classes sont déséquilibrées ou lorsque le domaine est complexe.

Recommandation : commencez avec (T_{anneal} = 10) et ajustez en fonction de la convergence du terme KL.

KL_lambda (implémenté via annealing)

Le coefficient de pondération de la régularisation KL. Dans l’implémentation standard, il est géré par l’annealing progressif plutôt que par un hyperparamètre fixe. Cependant, on peut aussi introduire un facteur multiplicatif explicite :

$$\mathcal{L} = \mathcal{L}{EDL} + \lambda \cdot \lambda_t \cdot KL$$

• (\lambda_{KL} = 1.0) : pondération standard
• (\lambda_{KL} = 0.5) : régularisation plus douce
• (\lambda_{KL} = 2.0) : régularisation plus forte, utile quand le modèle a tendance à surapprendre

num_classes

Le nombre de classes influence directement le calcul de l’incertitude épistémique (u = K/S). Pour un même niveau de preuve (S), un problème avec plus de classes aura une incertitude plus élevée. Il est essentiel de bien calibrer le seuil OOD en fonction de ce paramètre.

5 Avantages de l’Evidential Deep Learning

1. Distinction entre incertitude aléatoire et épistémique : Contrairement au dropout de Monte-Carlo ou aux ensembles profonds qui nécessitent plusieurs passages forward, l’EDL obtient cette décomposition en un seul passage, ce qui le rend extrêmement efficient en temps de calcul.
2. Détection naturelle des données OOD : Les échantillons hors distribution présentent systématiquement une faible evidence strength (S) et donc une incertitude épistémique élevée. Cette propriété émerge naturellement de la formulation mathématique sans nécessiter de mécanisme supplémentaire.
3. Pas de sampling coûteux : Les approches bayésiennes classiques comme le Monte-Carlo Dropout ou les ensembles profonds (Deep Ensembles) nécessitent 10 à 100 passages forward pour estimer l’incertitude. L’EDL produit sa propre évaluation d’incertitude en un seul passage forward, ce qui le rend compatible avec les applications temps réel.
4. Combinaison de preuves multiples : Grâce à la règle de fusion de Dempster, l’EDL permet de combiner rigoureusement les prédictions de plusieurs modèles ou capteurs, en tenant compte du conflit entre sources et de la fiabilité relative de chacune.
5. Interprétabilité des prédictions : L’evidence collectée pour chaque classe fournit une mesure compréhensible du « nombre de cas similaires observés ». Un médecin peut comprendre « j’ai vu 45 cas comme celui-ci, 42 étaient bénins » bien plus facilement qu’une probabilité softmax opaque.

4 Limites de l’Evidential Deep Learning

1. Sensibilité à la qualité de l’entraînement : La régularisation KL et l’annealing doivent être soigneusement calibrés. Un (T_{anneal}) mal choisi peut conduire à un modèle soit trop conservateur (rejet systématique d’evidence), soit trop confiant (ignorer les cas ambigus).
2. Difficulté avec les données fortement déséquilibrées : Quand une classe est extrêmement rare, le modèle peut avoir du mal à accumuler suffisamment de preuves pour cette classe, surtout avec la régularisation KL qui tend à écraser les evidence des classes non observées dans le lot.
3. Limitations théoriques de la règle de Dempster : La règle de fusion de Dempster peut produire des résultats contre-intuitifs en cas de conflit élevé entre sources. Des alternatives comme la règle de fusion de Yager ou la théorie DSmT existent mais compliquent l’implémentation.
4. Calibration des seuils OOD dépendante du domaine : Bien que l’incertitude épistémique soit un bon indicateur OOD, le choix du seuil optimal dépend fortement du domaine d’application et de la distribution des données d’entraînement. Un seuil universel n’existe pas, et la calibration nécessite un ensemble de validation représentatif.

4 Cas d’Usage Concrets

1. Diagnostic Médical avec Rejet OOD

En diagnostic médical assisté par intelligence artificielle, la capacité à reconnaître un cas jamais rencontré est littéralement une question de vie ou de mort. Un modèle EDL entraîné sur des radiographies pulmonaires peut :

• Fournir un diagnostic avec une incertitude faible pour les pathologies courantes (pneumonie, nodules bénins) qu’il a vues en grand nombre pendant l’entraînement.
• Rejeter automatiquement les cas présentant des anomalies rares ou inédites (incertitude épistémique élevée), en les redirigeant vers un radiologue humain pour examen approfondi.

Cette approche réduit considérablement les faux négatifs dangereux, car le modèle sait « avouer son ignorance » plutôt que de produire une prédiction faussement confiante.

2. Incertitude en Conduite Autonome

Les véhicules autonomes traitent des données provenant de multiples capteurs (caméras, LiDAR, radar). L’EDL permet de :

• Quantifier l’incertitude de classification des objets (piéton, véhicule, panneau) en temps réel.
• Combiner les preuves de différents capteurs via la règle de Dempster pour obtenir une estimation robuste, même si un capteur est défaillant ou perturbé (pluie, brouillard, éblouissement).
• Déclencher des mesures de sécurité (ralentissement, alerte au conducteur) lorsque l’incertitude épistémique dépasse un seuil critique, par exemple face à un objet non identifié sur la route.

3. Détection de Fraude Financière

Dans le domaine bancaire et financier, l’EDL apporte des avantages décisifs :

• Les transactions frauduleuses évoluent constamment : les fraudeurs adaptent leurs méthodes. Un modèle EDL détecte naturellement les nouvelles méthodes de fraude grâce à son niveau élevé d’incertitude épistémique pour des patterns jamais observés.
• Il distingue les transactions atypiques mais légitimes (un client voyageant à l’étranger) des véritables fraudes, en ajustant sa confiance en fonction de la quantité de preuves disponibles pour chaque pattern.
• Il fournit aux analystes une mesure explicite de confiance accompagnant chaque décision, facilitant la révision humaine des cas ambigus.

4. Imagerie Médicale Avancée

Au-delà du diagnostic de radiographie, l’EDL s’applique avec succès à l’imagerie médicale dans sa diversité :

• Segmentation d’organes : En segmentation d’images IRM ou CT, l’EDL peut produire des cartes d’incertitude pixel par pixel, indiquant les zones où la segmentation est peu fiable (interfaces tissu/air, artéfacts). Ces cartes guident les radiologues vers les régions nécessitant une vérification manuelle attentive.
• Classification de lésions dermatologiques : Un modèle EDL peut différencier avec fiabilité les lésions bénignes des mélanomes tout en signalant les lésions atypiques nécessitant un complément d’analyse histologique.
• Analyse de pathologies oculaires : Dans l’analyse de fond d’œil pour la détection de rétinopathie diabétique, l’EDL quantifie la confiance du modèle et rejette les images de qualité insuffisante ou les cas aux manifestations inhabituelles.

Pour Aller Plus Loin

Si l’Evidential Deep Learning vous intéresse, voici d’autres articles qui explorent des concepts complémentaires :

• 135. VAE – Variational Autoencoder : Un autre modèle probabiliste profond qui utilise les distributions latentes pour la génération et la reconstruction d’images.
• 015. Descente de Gradient : L’algorithme fondamental d’optimisation sur lequel repose l’entraînement de tous les réseaux de neurones, y compris les modèles EDL.
• 073. Perceptron Multicouche (MLP) : L’architecture de base des réseaux profonds qui constitue la colonne vertébrale de la plupart des modèles d’Evidential Deep Learning décrits dans ce guide.

Voir aussi

• Maîtriser les Numbers Steps en Python : Guide Complet pour Optimiser Vos Algorithmes
• Emballage de Cercles II en Python : Techniques Avancées et Solutions Optimisées