Epistemisch vs Aleatorisch: Meten Wat een Returnmodel Niet Weet

Elke positiegrootel op deze blog reduceert onzekerheid tot één scalair. Kelly deelt door variantie. Conformal voorspelling deelt door intervalbreedte. Volatiliteitsdoelstelling deelt door een GARCH-voorspelling. Alle drie zijn correct, en alle drie werpen een onderscheid weg dat belangrijk is voor trading: het verschil tussen een markt die rumoerig is en een model die onwetend is.

Dat is niet hetzelfde risico. Marktgeruis is geprijsd — het is waar je voor gecompenseerd wordt om het te dragen. Modelonwetendheid is niet geprijsd, niet gecompenseerd, en precies de toestand waarin je edge-schat het minst betrouwbaar is. Een sizingregel die ze gelijk straft laat iets liggen.

Deze post gaat over het meetbaar maken van die split. Concreet:

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

Zet dat in de Kelly-noemer in plaats van de totale variantie. De rest van het artikel gaat over het schatten van de twee componenten (MC Dropout, deep ensembles), en hoe de split er in de praktijk uitziet.

Deze: Twee Onzekerheden Vragen Twee Reacties

De asymmetrie in de rij "trading-actie" is het hele argument. Hoge aleatorische variantie is een bekende onbekende: je kunt erop dimensioneren, het afdekken, en verwachten een risicopremie te krijgen voor het dragen ervan. Hoge epistemische variantie is een onbekende onbekende: het model extrapoleert, zijn gemiddelde schatting $\mu$ is net zo verdacht als zijn variantieschatting, en er is geen premie verbonden aan het fout zijn over je eigen parameters.

Een model dat de twee door elkaar haalt zal of overtraden in onbekende regimes (epistemische onzekerheid negeren) of ondertraden in bekende-maar-rumoerige regimes (aleatorische onzekerheid overstraffen). Standaard Kelly, toegepast op $\sigma^2_{\text{total}}$, doet beide afhankelijk van welke component domineert.

De Decompositie

Epistemische onzekerheid komt van onzekerheid over modelparameters $\theta$. In plaats van één $\theta^*$(zoals bij maximum likelihood), houden we een verdeling $p(\theta \mid \mathcal{D})$ in stand en integreren:

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

De spreiding veroorzaakt door integratie over $\theta$ is epistemisch. Ze krimpt als $\mathcal{D}$ groeit om het invoergebied te bedekken.

Aleatorische onzekerheid is de voorwaardelijke ruis van het datagenereringsproces. In een neuraal netwerk wordt het gemodelleerd door een tweede uitvoerkop die invoerafhankelijke variantie uitstoot:

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

Die heteroscedastische kop schat hetzelfde object dat GARCH klassiek schat — toestandsafhankelijke voorwaardelijke variantie die 's nachts hoog is en op piekuren laag. Als je de empiriek van dat object op crypto wilt, GARCH(1,1) for crypto volatility behandelt het goed, inclusief waarom de live voorwaardelijke voorspelling (niet de onvoorwaardelijke steekproefvariantie) in de Kelly-noemer thuishoort. De NN-kop is gewoon een andere schatter van hetzelfde object, gezamenlijk met het gemiddelde gefit.

Wat GARCH je niet kan geven is de andere term. Daar is de rest van deze post voor.

Positie Relatief aan Wat Alreeds Gepubliceerd

Twee eerdere posts behandelen aangrenzend terrein en zijn de moeite van het vooraf lezen waard, want deze post herhaalt ze bewust niet:

• Conformal voorspelling voor risicobewuste positiemeting geeft je intervallen met een steekproefgarantie, geen verdelingsaanname, plus inverse-breedte sizing en een edge-ratio no-trade filter. Het is het sterkere hulpmiddel als je alleen een correct gefateneerd interval wilt.
• Temporal Fusion Transformers stoten direct kwantielen uit en waarschuwen al dat pinball-loss kwantielen niet automatisch gekalibreerd zijn out of sample.

De ruil is schoon. Conformal geeft een garantie maar één getal — de intervalbreedte is niet ontledbaar, dus het kan je niet vertellen waarom het verbreedde. Bayes-methodes geven een decompositie maar geen garantie — MC Dropout's intervallen zijn alleen zo goed als de benaderende posterior. Dit artikel gaat over het kopen van de decompositie; je moet conformal er waarschijnlijk bovenop houden voor de dekking.

Methode 1: Variatie-inferentie (Bayes door Backprop)

Een Bayesiaans neuraal netwerk plaatst een prior $p(\theta)$ op gewichten en zoekt de posterior $p(\theta \mid \mathcal{D}) \propto p(\mathcal{D} \mid \theta) p(\theta)$. De normalisator vereist integratie over elke gewichtsconfiguratie, wat ondoenlijk is voor alles met meer dan een handvol parameters.

Variatie-inferentie vervangt de onhanteerbare posterior door een hanteerbare familie $q_\phi(\theta)$ — typisch een gefactoriseerde Gauss $q_\phi(\theta) = \prod_j \mathcal{N}(\theta_j; \mu_j, \sigma_j^2)$ — en minimaliseert

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

Omdat dit de onbekende posterior betreft, maximaliseren we in plaats daarvan de Evidence Lower Bound:

$\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)$

De eerste term duwt $q_\phi$ naar het verklaren van de data; de tweede houdt het dicht bij de prior. Bayes by Backprop(Blundell et al., 2015) maakt dit differentieerbaar met de reparameterisatie-truc: sample $\epsilon \sim \mathcal{N}(0, I)$, zet $\theta = \mu + \sigma \odot \epsilon$.

In de praktijk verdubbelt VI het aantal parameters, verhoogt het de gradiëntvariantie (elke forward pass gebruikt verschillende gewichten), en negeert het mean-field aannemede gewichtscorrelaties, wat geneigd is om epistemische onzekerheid te onderschatten. Voor een tradingstack waar je al een getraind deterministisch model hebt, zijn de twee goedkopere methoden hieronder meestal het betere instappunt.

Methode 2: MC Dropout

Gal en Ghahramani (2016) toonden aan dat een netwerk getraind met dropout en geëvalueerd met dropout nog steeds aan tijdens testtijd een benaderingsvariatie-inferentieprocedure is in een diep Gauss-proces. Dropout induceert al een verdeling over subnetwerken; het aanlaten tijdens inferentie en $T$ forward passes uitvoeren neemt steekproeven van die impliciete posterior.

Dit nergens anders op deze blog. Gepubliceerde code hier gebruikt dropout alleen als trainingsregelaar(spread modelling, TFT bij dropout=0.1–0.3). Het aanlaten tijdens inferentie is een éélnijner verandering met een geheel andere betekenis.

Voorspellende Statistiek

Gegeven $T$ stochastische forward passes die $\{\hat{y}_t\}_{t=1}^{T}$ opleveren en per-pass varianties $\hat{\sigma}_t^2(x)$:

Voorspellend gemiddelde:

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

Epistemisch (verschil tussen passes):

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

Aleatorisch (gemiddelde van voorspelde ruis):

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

De decompositie is precies de wet van totale variantie: variantie van de voorwaardelijke gemiddelden, plus gemiddelde van de voorwaardelijke varianties. Totale voorspellende variantie is hun som.

PyTorch Implementatie

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

class MCDropoutNet(nn.Module):
    """
    Return-voorspellend netwerk met MC Dropout voor onzekerheidschatting.
    Geeft zowel voorspeld gemiddelde als log-variantie (aleatorisch) uit.
    """
    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)        # voorspelde return
        self.head_logvar = nn.Linear(hidden_dim, 1)    # log(aleatorische variantie)

    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):
    """Negatieve log-likelihood voor een Gauss met geleerde, invoerafhankelijke variantie."""
    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):
    """
    MC Dropout inferentie: houd dropout AAN, verzamel T forward passes,
    ontled voorspellende variantie in epistemisch en aleatorisch.
    """
    model.train()  # NOT eval() -- dit is wat dropout actief houdt
    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 over passes
    aleatoric_var = log_vars.exp().mean(dim=0)  # E over 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),
    }

Training gebruikt de heteroscedastische loss, wat maakt dat de variantie-kop betekenis heeft. Let op de zelfregulerende structuur: de 0.5 * precision * (target - mu)**2 term wil kleine variantie, de 0.5 * log_var term straft het, en het evenwichtspunt is het voorwaardelijke ruisniveau.

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()

De gotcha die de methode stil doodt: model.eval() aanroepen binnen mc_predict. Het schakelt dropout uit, elke pass keert dezelfde waarde terug, epistemic_var stort in tot precies nul, en je sizingregel keert stil terug naar gewone Kelly op aleatorische variantie. Het faalt zonder foutmelding. Assert dat epistemic_var > 0 in je inferentiepad.

Methode 3: Deep Ensembles

Lakshminarayanan et al. (2017) trainen $M$ onafhankelijke netwerken van verschillende random initialisaties en aggregeren. Hoewel niet formeel Bayesiaans, verslaan deep ensembles consequent principelere methoden op onzekerheidskalibratiebenchmarks.

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

Het meningsverschil tussen leden is de epistemische schatting. Ensembles komen elders op deze blog voor als aggregatieapparaten — anomalie detectie, HMM regime detectie, conformals EnbPI block bootstrap — maar nog nooit als onzekerheids-schatteur via inter-leden spreiding. Dat is het gebruik hier.

Ensemble Implementatie

Diversiteit komt van onafhankelijke training, niet van het bouwen van $M$ objecten. Een ensemble van ongetrainde of identiek getrainde leden geeft ruis of nul epistemische variantie:

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)          # verschillende init per lid
            self.models.append(
                MCDropoutNet(input_dim, hidden_dim, dropout_p=0.0)
            )

    def fit(self, train_loader, epochs: int = 200, lr: float = 1e-3):
        """Elk lid wordt onafhankelijk getraind. Hier komt de diversiteit vandaan --
        verschillende init, verschillende shuffle-volgorde. Dit overslaan
        levert epistemic_var == 0 (identieke leden) of pure ruis (ongetraind) op."""
        for seed, model in enumerate(self.models):
            torch.manual_seed(1000 + seed)   # verschillende shuffle/dropout stream
            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 hier: geen dropout sampling
            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)   # spreiding OVER leden
        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(),
        }

Let erop dat model.eval() correct is in DeepEnsemble.predict en fout in mc_predict. De stochastische bron verschilt: ensembles halen het uit onafhankelijke training, MC Dropout uit live dropout masks.

Trade-offs: MC Dropout vs Deep Ensembles

Een pragmatische hybride: train een klein ensemble ($M = 3{-}5$) waarbij elk lid ook MC Dropout gebruikt, zowel inter-model meningsverschillen als intra-model stochastiek vangend.

De Beloning: Asymmetrisch Sizing

Hier is de daadwerkelijke bijdrage. Gaussisch Kelly is $f^* = \mu / \sigma^2$; de afleiding, de groeiparabool, de drawdown-kansentabel en de vier redenen om fractioneel in plaats van vol Kelly te draaien staan allemaal in The Kelly Criterion for Strategies, en worden hier niet herhaald. Neem $f^* = \mu / \sigma^2$ bij een kwart-Kelly fractie als gegeven.

De modificatie is de noemer. In plaats van totale voorspellende variantie:

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

Het argument voor $\lambda > 1$: aleatorische variantie is de ruis van de markt, het is geprijsd, en het dragen ervan is hoe een strategie verdient. Epistemische variantie is jouw onwetendheid — het draagt geen premie, en erger, het is gecorreleerd met je $\mu$ schatting die fout is. Wanneer $\sigma_{\text{epi}}$ groot is, is de teller van Kelly tegelijkertijd met de noemer onbetrouwbaar, dus de fout in sizing componeert. Het superlineair straffen ervan ten opzichte van marktruis is de directe uiting daarvan.

def uncertainty_adjusted_position_size(
    pred_mean: float,
    epistemic_std: float,
    aleatoric_std: float,
    max_position: float = 1.0,
    lam: float = 2.0,                   # epistemische penalty; tune op validatie
    max_epi_ratio: float = 0.5,         # afzien boven deze epi/alea ratio
    base_kelly_fraction: float = 0.25,
) -> float:
    """Kelly sizing waarbij epistemische variantie zwaarder wordt gestraft dan aleatorische."""
    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))

De poort verdient een noot. Posities onder een drempel van vertrouwen op nul zetten is hier niet nieuw — de conformal post specificeert en codeert de algemene no-trade filter als $e_t = |\hat{\mu}| / w_t$ met een min_edge drempel, inclusief hoe de drempel te kiezen en de geometrische lezing van een interval dat nul doorsnijdt. Zie conformal prediction voor die machine. Wat nieuw is de noemer: poorten op $\sigma_{\text{epi}} / \sigma_{\text{alea}}$ gaat specifiek af wanneer het model meer in de war is over zijn eigen parameters dan de markt rumoerig is — een toestand die totale onzekerheids-poorting niet kan detecteren, want een rustig-maar-onbekend regime kan lage totale variantie en een verschrikkelijke epistemische ratio hebben.

Kalibratie: Geef Dit Uit

Een onzekerheidschat is alleen nuttig als gekalibreerd: een nominaal 95% interval moet de waarheid ~95% van de tijd bevatten. Rol je eigen Gaussian-kwantiel betrouwbaarheidscheck niet hier — een parametrisch interval op vettige return residuen is precies de faalmodus conformal prediction bestaat om te vermijden, en het levert een werkende evaluate() af die doel vs empirische dekking rapporteert met een steekproefgarantie erachter. De TFT post maakt hetzelfde punt voor kwantielkoppen.

Post-hoc rescaling ($\tilde{\sigma} = \alpha \sigma + \beta$ gefit op een validatieset) is de goedkope fix, en het is de zwakkere neef van Adaptive Conformal Inference, die een online miscoverage-niveau $\alpha_t$ in stand houdt met een langetermijn dekkingsgrens in plaats van een statische herschaling. ACI is de sterkere optie; de enige reden om te kiezen voor lineaire rescaling is dat het de epistemisch/aleatorische ratio behoudt, wat de enkele breedte van ACI niet doet.

Wat Moet Worden Gemeten Voordat Dit Publiceert

De bovenstaande methoden zijn gevestigd. De claim dat de split iets oplevert in trading is niet, en deze blog publiceert geen sizingregels op argument alleen. De lat:

**1. Dataset en doel. ** Noem het instrument, bar grootte, expliciete datumbereik, feature set, en voorspellingsdoel.

**2. De split zelf. ** Welk fraction van totale voorspellende variantie is epistemisch vs aleatorisch, en hoe die ratio beweegt tussen een genoemd kalm venster en een genoemd volatiel venster. Dit is de geldgrafiek en die bestaat nog niet. De hypothese die het waard is om te falsifiëren: de ratio piekt vóór gerealiseerde volatiliteit, omdat onbekendheid turbulentie voorafgaat.

**3. Dekking vs conformal. ** Gemeten out-of-sample dekking van MC Dropout intervallen tegen nominaal, vergeleken met split-conformal intervallen uit de gepubliceerde post op dezelfde data. Die head-to-head is op zich een nieuw resultaat en de natuurlijke brug tussen de twee posts.

**4. Doet $\lambda$ iets kopen? ** Sweep de epistemische penalty op validatie en rapporteer PnL en maximale drawdown tegen de $\lambda = 1$ baseline. Als het niets oplevert, zeg dat — The Honest Negative is het sjabloon voor die uitkomst en het is een publiceerbaar resultaat.

**5. Inferentiekosten. ** Gemeten, op de doelhardware, bij elk $T$.

Elke evaluatie hier loopt onder walk-forward optimization discipline — $\lambda$ is een hyperparameter, en een $\lambda$ getuned op de volledige steekproef is geen resultaat.

Praktische Tips voor Productie

**1. Warm de prior op. ** Bij variatie-inferentie, initialiseer de variatiegemiddelde van een voorgetraind deterministisch netwerk in plaats van willekeurig. Halveert meestal de convergentietijd.

**2. Let op variantie-ineenstorting. ** Geleerde varianties $\sigma_j$ kunnen naar bijna nul afdrijven, stil terugkerend de BNN naar een deterministisch netwerk. Monitor gemiddelde $\sigma_j$ tijdens training; voeg KL annealing toe indien nodig.

**3. Herkalibreer op een rolling basis, niet een vaste validatieset. ** Markten zijn niet-stationair en een eenmalig gefitte kalibratie degradeert. Retrain op een rolling venster onder walk-forward discipline, of laat ACI modelstaleheid online absorberen — de conformal post behandelt de retrain-frequentie trade-off direct.

**4. Ensemble diversiteit doet ertoe. ** Verschillende zaden, verschillende shuffles, optioneel verschillende hyperparameters per lid. Initialisatie-diversiteit is de primaire driver van ensemblekwaliteit, vandaar dat de fit() lus hierboven niet optioneel is.

**5. Log de decompositie, niet alleen het totaal. ** Sla beide componenten op naast gerealiseerde outcomes. Zonder dit kun je niet de enige vraag beantwoorden die in review belangrijk is: toen de sizer exposure verlaagde, was dat omdat de markt rumoerig was of omdat het model de weg kwijt was — en had hij gelijk?

**6. Onzekerheid als feature. ** Rolling epistemische statistiek kunnen zelf voorspellend zijn voor drawdowns. Geloofwaardig, ongemeten, en een aparte post waard.

Beperkingen en Eerlijke Voorbehouden

• **Benaderende posteriors zijn nog steeds benaderd. ** MC Dropout en VI geven een beperkt zicht op de echte posterior. Beter dan niets, geen grondwaar, en geen dekkingsgarantie is aan een van beide verbonden.
• **Kalibratie degradeert precies wanneer je het nodig hebt. ** In een echt nieuw regime kan het model nog steeds mis-calibrated zijn — het neigt alleen minder mis-calibrated te zijn dan een deterministische. Onzekerheidschattingen van out-of-distribution input zijn zelf out-of-distribution outputs.
• **Aleatorische variantie kan epistemisch signaal absorberen. ** Als de heteroscedastische kop flexibel genoeg is, leert het om modelonzekerheid weg te leggen als dataruis, waardoor $\sigma_{\text{epi}}$ naar nul instort en de hele decompositie stil verslaat. Dit is de belangrijkste faalmodus in deze post en het kondigt zichzelf niet aan. Monitor de ratio over regimes; een ratio die nooit beweegt is een gebroken decompositie, geen stabiele markt.
• **$\lambda$ is een vrij parameter. ** Het introduceren van een instelbare knop in een sizingregel is hoe overfitte sizingregels worden gebouwd. Het heeft walk-forward rechtvaardiging nodig of het moet vast worden gezet op 1.

Conclusie

Conformal voorspelling geeft deze blog al intervalbreedtes met een dekkingsgarantie, en Kelly geeft het al een sizingregel. Geen van beide geeft een antwoord op waarom het interval breed is. Het splitsen van voorspellende variantie in epistemisch en aleatorisch beantwoordt dat, en het antwoord is actieerbaar op een manier die het totaal niet is: marktruis is gecompenseerd risico, modelonwetendheid niet, en de sizingnoemer moet dat zeggen.

MC Dropout maakt de split bijna gratis — één regel(model.train() bij inferentie) verandert elk dropout-netwerk in een benaderend Bayesian netwerk. Deep ensembles kosten $M$x en kalibreren beter. Beide voeden dezelfde asymmetrische noemer $\sigma^2_{\text{alea}} + \lambda \sigma^2_{\text{epi}}$.

Of $\lambda > 1$ daadwerkelijk betaalt is een empirische vraag die dit concept nog niet beantwoordt. De bovenstaande metingen zijn de prijs voor publicatie.

Referenties:

• 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.