Épistémique vs Aléatoire : Mesurer ce qu'un modèle de rendement ne sait pas

Chaque règle de dimensionnement de position dans ce blog réduit l'incertitude à un seul scalaire. Kelly divise par la variance. Prédiction conforme divise par la largeur de l'intervalle. Ciblage de volatilité divise par une prévision GARCH. Les trois sont correctes, et les trois rejettent une distinction qui compte pour le trading : la différence entre un marché bruyant et un modèle ignorant.

Ce n'est pas le même risque. Le bruit de marché est priced — c'est ce pour quoi vous êtes compensé pour le supporter. L'ignorance du modèle n'est pas priced, n'est pas compensée, et est précisément l'état dans lequel votre estimation d'edge est la moins fiable. Une règle de dimensionnement qui pénalise les deux également laisse quelque chose sur la table.

Cet article porte sur la rendre mesurable. Concrètement :

$\sigma^2_{\text{eff}} = \sigma^2_{\text{alea}} + \lambda \cdot \sigma^2_{\text{epi}}, \qquad \lambda > 1$

Mettez cela dans le dénominateur Kelly au lieu de la variance totale. Le reste de l'article explique comment estimer les deux composantes (MC Dropout, deep ensembles), et à quoi ressemble la division sur de vraies données.

La Thèse : Deux incertitudes demandent deux réponses

L'asymétrie dans la ligne "action de trading" est tout l'argument. Une variance aléatoire élevée est un inconnu connu : vous pouvez dimensionner pour elle, la couvrir, et vous attendre à être payé une prime de risque pour la détenir. Une variance épistémique élevée est un inconnu inconnu : le modèle extrapole, son estimation de moyenne $\mu$ est aussi suspecte que son estimation de variance, et il n'y a pas de prime attachée à avoir tort sur vos propres paramètres.

Un modèle qui confond les deux fera soit un sur-trading dans des régimes inconnus (ignorant l'incertitude épistémique) soit un sous-trading dans des régimes familiers mais bruyants (sur-pénalisant l'incertitude aléatoire). Kelly standard, appliqué à $\sigma^2_{\text{total}}$, fait les deux selon la composante qui domine.

La Décomposition

L'incertitude épistémique vient de l'incertitude sur les paramètres du modèle $\theta$. Au lieu d'un seul $\theta^*$ (comme dans le maximum de vraisemblance), nous maintenons une distribution $p(\theta \mid \mathcal{D})$ et intégrons :

$p(y \mid x, \mathcal{D}) = \int p(y \mid x, \theta)\, p(\theta \mid \mathcal{D})\, d\theta$

La propagation induite par l'intégration sur $\theta$ est épistémique. Elle diminue à mesure que $\mathcal{D}$ grandit pour couvrir la région d'entrée.

L'incertitude aléatoire est le bruit conditionnel du processus de génération de données. Dans un réseau neuronal, elle est modélisée par une deuxième tête de sortie émettant une variance dépendante de l'entrée :

$p(y \mid x, \theta) = \mathcal{N}\bigl(y;\, \mu_\theta(x),\, \sigma^2_\theta(x)\bigr)$

Cette tête hétéroscédastique estime le même objet que GARCH estime classiquement — variance conditionnelle dépendante de l'état qui est élevée la nuit et basse aux heures de pointe. Si vous voulez les empiriques de cet objet sur le crypto, GARCH(1,1) pour la volatilité du crypto le couvre proprement, y compris pourquoi la prévision conditionnelle en direct (pas la variance d'échantillon inconditionnelle) appartient dans le dénominateur Kelly. La tête NN est juste un autre estimateur de la même quantité, ajusté conjointement avec la moyenne.

Ce que GARCH ne peut pas vous donner est l'autre terme. C'est à cela que sert le reste de cet article.

Où cela se situe par rapport à ce qui est déjà publié

Deux articles précédents couvrent un terrain adjacent et méritent d'être lus en premier, car celui-ci ne les répète pas délibérément :

• Prédiction conforme pour le dimensionnement de position conscient du risque vous donne des intervalles avec une garantie de couverture d'échantillon fini, sans hypothèse distributionnelle, plus un dimensionnement inverse-largeur et un filtre no-trade de ratio d'edge. C'est l'outil le plus fort si vous voulez juste un intervalle correctement dimensionné.
• Temporal Fusion Transformers émettent directement des quantiles et avertissent déjà que les quantiles de perte pinball ne sont pas automatiquement calibrés hors échantillon.

Le compromis est propre. Conforme vous donne une garantie mais un nombre — la largeur de l'intervalle n'est pas décomposable, donc il ne peut pas vous dire pourquoi elle s'est élargie. Les méthodes bayésiennes vous donnent une décomposition mais pas de garantie — les intervalles MC Dropout sont aussi bons que le posterior approximatif. Cet article concerne l'achat de la décomposition ; vous devriez probablement garder conforme dessus pour la couverture.

Méthode 1 : Inférence Variationnelle (Bayes by Backprop)

Un réseau neuronal bayésien place un prior $p(\theta)$ sur les poids et cherche le posterior $p(\theta \mid \mathcal{D}) \propto p(\mathcal{D} \mid \theta) p(\theta)$. Le normaliseur nécessite une intégration sur chaque configuration de poids, ce qui est intraitable pour quoi que ce soit avec plus d'une poignée de paramètres.

L'inférence variationnelle remplace le posterior intraitable par une famille gérable $q_\phi(\theta)$ — typiquement un gaussien factorisé $q_\phi(\theta) = \prod_j \mathcal{N}(\theta_j; \mu_j, \sigma_j^2)$ — et minimise

$\text{KL}\bigl(q_\phi(\theta) \,\|\, p(\theta \mid \mathcal{D})\bigr)$

Puisque cela implique le posterior inconnu, nous maximisons à la place la Borne Inférieure de Preuve :

$\mathcal{L}(\phi) = \mathbb{E}_{q_\phi(\theta)}\bigl[\log p(\mathcal{D} \mid \theta)\bigr] - \text{KL}\bigl(q_\phi(\theta) \,\|\, p(\theta)\bigr)$

Le premier terme pousse $q_\phi$ à expliquer les données ; le second le garde près du prior. Bayes by Backprop (Blundell et al., 2015) rend cela différentiable avec l'astuce de reparamétrage : échantillonner $\epsilon \sim \mathcal{N}(0, I)$, définir $\theta = \mu + \sigma \odot \epsilon$.

En pratique, VI double le nombre de paramètres, augmente la variance du gradient (chaque passe avant utilise des poids différents), et l'hypothèse de champ moyen ignore les corrélations de poids, ce qui tend à sous-estimer l'incertitude épistémique. Pour un stack de trading où vous avez déjà un modèle déterministe entraîné, les deux méthodes moins coûteuses ci-dessous sont généralement le meilleur point d'entrée.

Méthode 2 : MC Dropout

Gal et Ghahramani (2016) ont montré qu'un réseau entraîné avec dropout et évalué avec dropout toujours actif au temps de test est une procédure d'inférence variationnelle approximative dans un processus gaussien profond. Le dropout induit déjà une distribution sur les sous-réseaux ; le garder actif pendant l'inférence et exécuter $T$ passes avant échantillonne à partir de ce posterior implicite.

Cela n'existe nulle part ailleurs dans ce blog. Le code publié ici utilise dropout uniquement comme régularisateur au moment de l'entraînement (modélisation de spread, TFT à dropout=0.1–0.3). Le garder actif pendant l'inférence est un changement d'une ligne avec une signification complètement différente.

Statistiques Prédictives

Étant donné $T$ passes avant stochastiques produisant $\{\hat{y}_t\}_{t=1}^{T}$ et des variances par passe $\hat{\sigma}_t^2(x)$ :

Moyenne prédictive :

$\bar{y} = \frac{1}{T} \sum_{t=1}^T \hat{y}_t$

Épistémique (désaccord entre les passes) :

$\sigma^2_{\text{epi}} = \frac{1}{T} \sum_{t=1}^T (\hat{y}_t - \bar{y})^2$

Aléatoire (moyenne du bruit prédit) :

$\sigma^2_{\text{alea}} = \frac{1}{T} \sum_{t=1}^T \hat{\sigma}_t^2$

La décomposition est exactement la loi de la variance totale : variance de la moyenne conditionnelle, plus moyenne de la variance conditionnelle. La variance prédictive totale est leur somme.

Implémentation PyTorch

import torch
import torch.nn as nn
import numpy as np

class MCDropoutNet(nn.Module):
    """
    Réseau de prédiction de rendement avec MC Dropout pour l'estimation d'incertitude.
    Émet à la fois la moyenne prédite et la log-variance (aléatoire).
    """
    def __init__(self, input_dim: int, hidden_dim: int = 128, dropout_p: float = 0.1):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Dropout(p=dropout_p),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Dropout(p=dropout_p),
        )
        self.head_mu = nn.Linear(hidden_dim, 1)        # rendement prédit
        self.head_logvar = nn.Linear(hidden_dim, 1)    # log(variance aléatoire)

    def forward(self, x: torch.Tensor):
        h = self.net(x)
        return self.head_mu(h), self.head_logvar(h)


def heteroscedastic_loss(mu, log_var, target):
    """Log-vraisemblance négative pour un gaussien avec variance apprise, dépendante de l'entrée."""
    precision = torch.exp(-log_var)
    return torch.mean(0.5 * precision * (target - mu) ** 2 + 0.5 * log_var)


@torch.no_grad()
def mc_predict(model: MCDropoutNet, x: torch.Tensor, n_samples: int = 100):
    """
    Inférence MC Dropout : garder dropout actif, collecter T passes avant，
    décomposer la variance prédictive en parties épistémique et aléatoire.
    """
    model.train()  # PAS eval() — c'est ce qui garde dropout actif
    mus, log_vars = [], []
    for _ in range(n_samples):
        mu, log_var = model(x)
        mus.append(mu)
        log_vars.append(log_var)

    mus = torch.stack(mus)            # (T, batch, 1)
    log_vars = torch.stack(log_vars)  # (T, batch, 1)

    pred_mean = mus.mean(dim=0)
    epistemic_var = mus.var(dim=0)              # Var sur les passes
    aleatoric_var = log_vars.exp().mean(dim=0)  # E sur les passes

    return {
        "mean": pred_mean.squeeze(-1),
        "epistemic_std": epistemic_var.sqrt().squeeze(-1),
        "aleatoric_std": aleatoric_var.sqrt().squeeze(-1),
        "total_std": (epistemic_var + aleatoric_var).sqrt().squeeze(-1),
    }

L'entraînement utilise la perte hétéroscédastique, ce qui donne un sens à la tête de variance. Notez la structure autorégulatrice : le terme 0.5 * precision * (target - mu)**2 veut une petite variance, le terme 0.5 * log_var la punit, et le point d'équilibre est le niveau de bruit conditionnel.

model = MCDropoutNet(input_dim=50, hidden_dim=128, dropout_p=0.1)
optimizer = torch.optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)

for epoch in range(200):
    model.train()
    for x_batch, y_batch in train_loader:
        mu, log_var = model(x_batch)
        loss = heteroscedastic_loss(mu, log_var, y_batch)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

L'erreur qui tue silencieusement la méthode : appeler model.eval() dans mc_predict. Désactive dropout, chaque passe retourne la valeur identique, epistemic_var s'effondre à exactement zéro, et votre règle de dimensionnement revient silencieusement à Kelly simple sur variance aléatoire. Échoue sans erreur. Assurez-vous que epistemic_var > 0 dans votre chemin d'inférence.

Choisir le nombre de passes avant

• $T = 30$ : limite inférieure raisonnable pour une moyenne stable
• $T = 100$ : défaut utilisable pour moyenne et variance
• $T = 500{+}$ : rendements décroissants à moins que vous n'ayez besoin de quantiles de queue

Méthode 3 : Deep Ensembles

Cinq réseaux neuronaux entraînés indépendamment combinent leurs prédictions pendant que leur désaccord forme un halo épistémique

Lakshminarayanan et al. (2017) entraînent $M$ réseaux indépendants à partir de différentes initialisations aléatoires et agrègent. Bien que pas formellement bayésien, les deep ensembles battent constamment des méthodes plus principées sur les benchmarks de calibration d'incertitude.

$p(y \mid x) \approx \frac{1}{M} \sum_{m=1}^M p(y \mid x, \theta_m^*)$

Le désaccord entre membres est l'estimation épistémique. Les ensembles apparaissent ailleurs dans ce blog comme dispositifs d'agrégation — détection d'anomalies, détection de régime HMM, bootstrap de bloc EnbPI conforme — mais jamais comme estimateur d'incertitude via la dispersion inter-membres. C'est l'utilisation ici.

Implémentation d'Ensemble

La diversité vient de l'entraînement indépendant, pas de construire $M$ objets. Un ensemble de membres non entraînés ou entraînés identiquement retourne soit du bruit soit une variance épistémique nulle :

class DeepEnsemble:
    def __init__(self, input_dim: int, n_models: int = 5, hidden_dim: int = 128):
        self.models = []
        for seed in range(n_models):
            torch.manual_seed(seed)          # init différent par membre
            self.models.append(
                MCDropoutNet(input_dim, hidden_dim, dropout_p=0.0)
            )

    def fit(self, train_loader, epochs: int = 200, lr: float = 1e-3):
        """Chaque membre est entraîné indépendamment. C'est d'où vient la diversité
        -- init différent, ordre de shuffle différent. Sauter cela
        donne epistemic_var == 0 (membres identiques) ou du bruit pur (non entraîné)."""
        for seed, model in enumerate(self.models):
            torch.manual_seed(1000 + seed)   # différent stream de shuffle/dropout
            opt = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-4)
            model.train()
            for _ in range(epochs):
                for x_batch, y_batch in train_loader:
                    mu, log_var = model(x_batch)
                    loss = heteroscedastic_loss(mu, log_var, y_batch)
                    opt.zero_grad()
                    loss.backward()
                    opt.step()
        return self

    @torch.no_grad()
    def predict(self, x: torch.Tensor):
        mus, variances = [], []
        for model in self.models:
            model.eval()                     # correct ici : pas d'échantillonnage dropout
            mu, log_var = model(x)
            mus.append(mu.squeeze(-1))
            variances.append(log_var.exp().squeeze(-1))

        all_mus = torch.stack(mus)
        all_vars = torch.stack(variances)

        epistemic_var = all_mus.var(dim=0)   # dispersion À TRAVERS les membres
        aleatoric_var = all_vars.mean(dim=0)

        return {
            "mean": all_mus.mean(dim=0),
            "epistemic_std": epistemic_var.sqrt(),
            "aleatoric_std": aleatoric_var.sqrt(),
            "total_std": (epistemic_var + aleatoric_var).sqrt(),
        }

Notez que model.eval() est correct dans DeepEnsemble.predict et faux dans mc_predict. La source de stochasticité diffère : les ensembles l'obtiennent de l'entraînement indépendant, MC Dropout des masques dropout en direct.

Compromis : MC Dropout vs Deep Ensembles

Un hybride pragmatique : entraînez un petit ensemble ($M = 3{-}5$) où chaque membre utilise aussi MC Dropout, capturant à la fois le désaccord inter-modèle et la stochasticité intra-modèle.

Le bénéfice : Dimensionnement asymétrique

Voici la contribution réelle. Kelly gaussien est $f^* = \mu / \sigma^2$; la dérivation, la parabole de croissance, le tableau de probabilité de drawdown et les quatre raisons de lancer Kelly fractionnaire plutôt que complet sont tous dans Le Critère de Kelly pour les Stratégies, et ne sont pas répétés ici. Prenez $f^* = \mu / \sigma^2$ à une fraction de quart-Kelly comme donné.

La modification est le dénominateur. Au lieu de la variance prédictive totale :

$\sigma^2_{\text{eff}} = \sigma^2_{\text{alea}} + \lambda \cdot \sigma^2_{\text{epi}}, \qquad \lambda > 1$

L'argument pour $\lambda > 1$ : la variance aléatoire est le bruit du marché, elle est priced, et la supporter est comment une stratégie gagne. La variance épistémique est votre ignorance — elle ne porte pas de prime, et pire, elle est corrélée avec votre estimation $\mu$ étant fausse. Quand $\sigma_{\text{epi}}$ est grand, le numérateur de Kelly est peu fiable en même temps que le dénominateur, donc l'erreur de dimensionnement se compose. La pénaliser superlinéairement par rapport au bruit de marché est l'expression directe de cela.

def uncertainty_adjusted_position_size(
    pred_mean: float,
    epistemic_std: float,
    aleatoric_std: float,
    max_position: float = 1.0,
    lam: float = 2.0,                   # pénalité épistémique ; accordez sur validation
    max_epi_ratio: float = 0.5,         # abstenez-vous au-dessus de ce ratio epi/alea
    base_kelly_fraction: float = 0.25,
) -> float:
    """Dimensionnement Kelly où la variance épistémique est plus fortement pénalisée que la aléatoire."""
    effective_var = aleatoric_std ** 2 + lam * epistemic_std ** 2
    if effective_var < 1e-10:
        return 0.0

    position = (pred_mean / effective_var) * base_kelly_fraction

    epi_ratio = epistemic_std / (aleatoric_std + 1e-8)
    if epi_ratio > max_epi_ratio:
        position *= max(0.0, 1.0 - epi_ratio)

    return float(np.clip(position, -max_position, max_position))

La porte mérite une note. Mettre des positions à zéro sous un seuil de confiance n'est pas nouveau ici — l'article conforme spécifie et code le filtre général no-trade comme $e_t = |\hat{\mu}| / w_t$ avec un seuil min_edge, y compris comment choisir le seuil et la lecture géométrique d'un intervalle traversant zéro. Voir prédiction conforme pour cette machinerie. Ce qui est nouveau est le dénominateur : le gate sur $\sigma_{\text{epi}} / \sigma_{\text{alea}}$ tire spécifiquement quand le modèle est plus confus sur ses propres paramètres que le marché est bruyant — un état que le gate d'incertitude totale ne peut pas détecter, car un régime calme mais inconnu peut avoir une variance totale faible et un ratio épistémique terrible.

Calibration : Déléguez cela

Une estimation d'incertitude n'est utile que si calibrée : un intervalle nominal de 95% devrait contenir la vérité ~95% du temps. Ne lancez pas votre propre vérification de fiabilité de quantile gaussien — un intervalle paramétrique sur des résidus de rendement à queue lourde est exactement le mode d'échec que prédiction conforme existe pour éviter, et il expédie un evaluate() fonctionnel qui rapporte l'objectif vs la couverture empirique avec une garantie d'échantillon fini derrière. Le post TFT fait le même point pour les têtes de quantile.

Le re-escalade post-hoc ($\tilde{\sigma} = \alpha \sigma + \beta$ ajusté sur un ensemble de validation) est la correction bon marché, et c'est le cousin faible de l'Inférence Conforme Adaptative, qui maintient un niveau de mauvaise couverture en ligne $\alpha_t$ avec une borne de couverture long-terme plutôt qu'un re-escalade statique. ACI est l'option plus forte ; la seule raison de préférer le re-escalade linéaire est qu'il préserve le ratio épistémique/aléatoire, ce que la largeur unique d'ACI ne fait pas.

Ce qui doit être mesuré avant publication

Les méthodes ci-dessus sont établies. L'affirmation que la division achète quelque chose en trading ne l'est pas, et ce blog ne publie pas de règles de dimensionnement sur la seule argumentation. La barre :

1. Ensemble de données et objectif. Nommez l'instrument, la taille de bougie, la plage de dates explicite, l'ensemble de fonctionnalités et l'objectif de prédiction.

2. La division elle-même. Quelle fraction de la variance prédictive totale est épistémique vs aléatoire, et comment ce ratio se déplace entre une fenêtre calme nommée et une volatile nommée. C'est le graphique d'argent et il n'existe pas encore. L'hypothèse qui vaut la peine d'être falsifiée : le ratio monte avant la volatilité réalisée, car l'inconnu précède la turbulence.

3. Couverture vs conforme. Couverture mesurée hors échantillon des intervalles MC Dropout contre nominal, comparée aux intervalles split-conformes de l'article publié sur les mêmes données. Ce face-à-face est lui-même un nouveau résultat et le pont naturel entre les deux articles.

4. Est-ce que $\lambda$ achète quelque chose ? Balayez la pénalité épistémique sur validation et rapportez le PnL et le drawdown maximum contre la ligne de base $\lambda = 1$. Si ça n'achète rien, dites-le — Le Négatif Honnête est le modèle pour ce résultat et c'est un résultat publiable.

5. Coût d'inférence. Mesuré, sur le matériel cible, à chaque $T$.

Toute évaluation ici s'exécute sous la discipline walk-forward — $\lambda$ est un hyperparamètre, et un $\lambda$ accordé sur l'échantillon complet n'est pas un résultat.

Conseils pratiques pour la production

1. Chauffez le prior. Avec l'inférence variationnelle, initialisez la moyenne variationnelle depuis un réseau déterministe pré-entraîné plutôt qu'au hasard. Réduit typiquement de moitié le temps de convergence.

2. Surveillez l'effondrement de variance. Les variances apprises $\sigma_j$ peuvent dériver vers presque zéro, revenant silencieusement le BNN à un réseau déterministe. Surveillez la moyenne $\sigma_j$ pendant l'entraînement ; ajoutez un recuit KL si nécessaire.

3. Recalibrez sur une base roulante, pas sur un ensemble de validation fixe. Les marchés sont non stationnaires et une calibration ajustée une fois se dégrade. Soit ré-entraînez sur une fenêtre roulante sous la discipline Walk-Forward, soit laissez ACI absorber la vétusté du modèle en ligne — le post conforme couvre directement le compromis fréquence de ré-entraînement.

4. La diversité de l'ensemble compte. Différentes graines, différents shuffles, optionnellement différents hyperparamètres par membre. La diversité d'initialisation est le conducteur principal de la qualité de l'ensemble, c'est pourquoi la boucle fit() ci-dessus n'est pas optionnelle.

5. Enregistrez la décomposition, pas seulement le total. Stockez les deux composantes à côté des résultats réalisés. Sans cela vous ne pouvez pas répondre à la seule question qui compte dans la revue : quand le dimensionneur a réduit l'exposition, était-ce parce que le marché était bruyant ou parce que le modèle était perdu — et avait-il raison ?

6. Incertitude comme caractéristique. Les statistiques épistémiques roulantes peuvent être elles-mêmes prédictives de drawdowns. Plausible, non mesuré, et vaut un article séparé.

Limitations et avertissements honnêtes

• Les posteriors approximatifs sont encore approximatifs. MC Dropout et VI donnent une vue limitée du posterior vrai. Mieux que rien, pas vérité terrain, et aucune garantie de couverture n'est attachée à aucun.
• La calibration se dégrade exactement quand vous en avez besoin. Dans un régime vraiment nouveau le modèle peut encore être miscalibré — il a juste tendance à être moins miscalibré qu'un déterministe. Les estimations d'incertitude d'une entrée hors distribution sont elles-mêmes des sorties hors distribution.
• La variance aléatoire peut absorber le signal épistémique. Si la tête hétéroscédastique est assez flexible, elle apprend à expliquer l'incertitude du modèle comme du bruit de données, s'effondrant $\sigma_{\text{epi}}$ vers zéro et vainquant silencieusement toute la décomposition. C'est le mode d'échec le plus important dans cet article et ne s'annonce pas lui-même. Surveillez le ratio à travers les régimes ; un ratio qui ne bouge jamais est une décomposition cassée, pas un marché stable.
• $\lambda$ est un paramètre libre. Introduire un bouton réglable dans une règle de dimensionnement est comme les règles de dimensionnement surajustées sont construites. Il a besoin d'une justification walk-forward ou doit être fixé à 1.

Conclusion

La prédiction conforme donne déjà à ce blog des largeurs d'intervalle avec une garantie de couverture, et Kelly donne déjà une règle de dimensionnement. Ce qu'aucun ne donne est une réponse à pourquoi l'intervalle est large. Diviser la variance prédictive en parties épistémique et aléatoire y répond, et la réponse est actionnable d'une façon que le total ne l'est pas : le bruit de marché est un risque compensé, l'ignorance du modèle ne l'est pas, et le dénominateur de dimensionnement devrait le dire.

MC Dropout rend la division presque gratuite — une ligne (model.train() à l'inférence) transforme n'importe quel réseau dropout en un bayésien approximatif. Les deep ensembles coûtent $M$x et calibrent mieux. Les deux alimentent le même dénominateur asymétrique $\sigma^2_{\text{alea}} + \lambda \sigma^2_{\text{epi}}$.

Si $\lambda > 1$ paie réellement est une question empirique que ce brouillon ne répond pas encore. Les mesures listées ci-dessus sont le prix de le publier.

Références :

• Blundell, C., Cornebise, J., Kavukcuoglu, K., & Wierstra, D. (2015). Weight Uncertainty in Neural Networks. ICML.
• Gal, Y. & Ghahramani, Z. (2016). Dropout as a Bayesian Approximation: Representing Model Uncertainty in Deep Learning. ICML.
• Lakshminarayanan, B., Pritzel, A., & Blundell, C. (2017). Simple and Scalable Predictive Uncertainty Estimation using Deep Ensembles. NeurIPS.
• Kendall, A. & Gal, Y. (2017). What Uncertainties Do We Need in Bayesian Deep Learning for Computer Vision? NeurIPS.
• Gibbs, I. & Candes, E. (2021). Adaptive Conformal Inference Under Distribution Shift. NeurIPS.
• Kelly, J. L. (1956). A New Interpretation of Information Rate. Bell System Technical Journal.