एपिस्टेमिक बनाम एलेटोरिक: रिटर्न मॉडल नहीं जानता उसे मापना

इस ब्लॉग में हर पोजिशन-साइज़िंग नियम अनिश्चितता को एक एकल स्केलर में संक्षिप्त कर देता है। केली विचरण से विभाजित करता है। कंफ़ॉर्मल प्रेडिक्शन अंतराल चौड़ाई से विभाजित करता है। वोलैटिलिटी टार्गेटिंग GARCH पूर्वानुमान से विभाजित करता है। तीनों सही हैं, और तीनों एक अंतर को फेंक देते हैं जो ट्रेडिंग के लिए मायने रखता है: एक शोरीय बाज़ार और एक अज्ञान मॉडल के बीच का अंतर।

ये एक ही जोखिम नहीं हैं। बाज़ार शोर मूल्यवान है — इसे वहन करने के लिए आप प्रतिपूर्ति पाते हैं। मॉडल अज्ञान मूल्यवान नहीं है, प्रतिपूर्तित नहीं है, और यह ठीक वह स्थिति है जिसमें आपकी एज अनुमान कम से कम विश्वसनीय होती है। एक साइज़िंग नियम जो दोनों को समान रूप से दंडित करता है, मेज पर कुछ छोड़ देता है।

यह पोस्ट इस विभाजन को मापने योग्य बनाने के बारे में है। ठोस रूप में:

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

इसे केली हर में कुल विचरण के बजाय रखें। लेख का शेष भाग दो घटकों (MC ड्रॉपआउट, डीप एनसेंबल्स) का अनुमान लगाने और वास्तविक डेटा पर विभाजन कैसा दिखता है, इसके बारे में है।

थीसिस: दो अनिश्चितताएं, दो प्रतिक्रियाएं

"ट्रेडिंग कार्रवाई" पंक्ति में असममिति पूरा तर्क है। उच्च एलेटोरिक विचरण एक ज्ञात अज्ञात है: आप इसके लिए आकार तय कर सकते हैं, इसे हेज कर सकते हैं, और इसे रखने के लिए जोखिम प्रीमियम की अपेक्षा कर सकते हैं। उच्च एपिस्टेमिक विचरण एक अज्ञात अज्ञात है: मॉडल बहिर्जात कर रहा है, इसका माध्य अनुमान $\mu$ इसके विचरण अनुमान के संदिग्ध है, और अपने स्वयं के पैरामीटर्स के बारे में गलत होने से कोई प्रीमियम जुड़ा नहीं है।

एक मॉडल जो दोनों को घोल देता है, या तो अपरिचित शासनों में अधिक ट्रेड करेगा (एपिस्टेमिक अनिश्चितता की उपेक्षा करके) या परिचित लेकिन शोरीय शासनों में कम ट्रेड करेगा (एलेटोरिक अनिश्चितता को अत्यधिक दंडित करके)। मानक केली, $\sigma^2_{\text{total}}$ पर लागू होने पर, यह दोनों करता है जो घटक प्रभावी होता है।

विघटन

एपिस्टेमिक अनिश्चितता मॉडल पैरामीटर्स $\theta$ के बारे में अनिश्चितता से आती है। एक एकल $\theta^*$ (अधिकतम संभावना के रूप में) के बजाय, हम एक वितरण $p(\theta \mid \mathcal{D})$ बनाए रखते हैं और एकीकृत करते हैं:

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

$\theta$ पर एकीकरण से प्रेरित फैलाव एपिस्टेमिक है। यह सिकुड़ता है जैसे-जैसे $\mathcal{D}$ इनपुट क्षेत्र को कवर करने के लिए बढ़ता है।

एलेटोरिक अनिश्चितता डेटा-जनित प्रक्रिया की सशर्त शोर है। एक तंत्रिका नेटवर्क में, इसे एक दूसरे आउटपुट हेड द्वारा मॉडलिंग किया जाता है जो इनपुट-निर्भर विचरण उत्सर्जित करता है:

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

यह हेटेरोस्केडास्टिक हेड वही वस्तु का अनुमान लगाता है जो GARCclassically अनुमान लगाता है — स्थिति-निर्भर सशर्त विचरण जो रात में ऊंचा और चरम घंटों में कम होता है। यदि आप क्रिप्टो पर इस वस्तु की empíricals चाहते हैं, तो क्रिप्टो वोलैटिलिटी के लिए GARCH(1,1) इसे उचित रूप से कवर करता है, जिसमें यह कि लाइव सशर्त पूर्वानुमान (अशर्त नमूना विचरण नहीं) केली हर में होता है। NN हेड उसी मात्रा का बस एक अलग estimator है, माध्य के साथ संयुक्त रूप से फिट।

जो GARCH आपको नहीं दे सकता वह दूसरा टर्म है। इस पोस्ट का शेष भाग उसी के लिए है।

यह पहले से प्रकाशित के सापेक्ष कहां खड़ा है

दो पिछले पोस्ट आसन्न भूमि को कवर करते हैं और पहले पढ़ने योग्य हैं, क्योंकि यह जानबूझकर उन्हें दोहराता नहीं है:

• जोखिम-जागरूक पोजिशन साइज़िंग के लिए कंफ़ॉर्मल प्रेडिक्शन आपको एक सीमित-नमूना कवरेज गारंटी के साथ अंतराल देता है, कोई वितरण धारणा नहीं, प्लस इनवर्स-विड्थ साइज़िंग और एज-रेशियो नो-ट्रेड फ़िल्टर। यदि आप केवल सही ढंग से आकार दिया गया अंतराल चाहते हैं तो यह बेहतरीन टूल है।
• टेम्पोरल फ्यूजन ट्रांसफ़ॉर्मर सीधे क्वांटाइल उत्सर्जित करते हैं और पहले से चेतावनी देते हैं कि पिनबॉल-लॉस क्वांटाइल स्वचालित रूप से आउट-ऑफ-सैंपल कैलिब्रेटेड नहीं हैं।

ट्रेड-ऑफ साफ़ है। कंफ़ॉर्मल आपको गारंटी देता है लेकिन एक नंबर — अंतराल चौड़ाई विघटनीय नहीं है, इसलिए यह नहीं बता सकता क्यों यह चौड़ा हुआ। बेयसियन विधियां आपको विघटन देती हैं लेकिन कोई गारंटी नहीं — MC ड्रॉपआउट अंतराल केवल उतने ही अच्छे हैं जितना अनुमानित posterior। यह लेख विघटन खरीदने के बारे में है; आपको शायद कवरेज के लिए इसके ऊपर कंफ़ॉर्मल रखना चाहिए।

विधि 1: वेरिएशनल इन्फरेंस (Bayes by Backprop)

एक बेयसियन तंत्रिका नेटवर्क वेट पर एक प्रायर $p(\theta)$ रखता है और posterior $p(\theta \mid \mathcal{D}) \propto p(\mathcal{D} \mid \theta) p(\theta)$ की तलाश करता है। नॉर्मलाइज़र को हर वेट कॉन्फ़िगरेशन पर एकीकरण की आवश्यकता होती है, जो किसी भी चीज़ के लिए अव्यावहारिक है जिसमें एक आधार से अधिक पैरामीटर हों।

वेरिएशनल इन्फरेंस अव्यावहारिक posterior को एक ट्रैक्टेबल परिवार $q_\phi(\theta)$ से बदल देता है — आमतौर पर एक फ़ैक्टराइज़्ड गाऊसियन $q_\phi(\theta) = \prod_j \mathcal{N}(\theta_j; \mu_j, \sigma_j^2)$ — और कम करता है

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

चूंकि इसमें अज्ञात posterior शामिल है, हम इसके बजाय एविडेंस लोअर बाउंड को अधिकतम करते हैं:

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

पहला टर्म $q_\phi$ को डेटा की व्याख्या करने के लिए धक्का देता है; दूसरा इसे प्रायर के पास रखता है। Bayes by Backprop (Blundell et al., 2015) इसे reparameterization ट्रिक से अंतर करने योग्य बनाता है: $\epsilon \sim \mathcal{N}(0, I)$, सेट करें $\theta = \mu + \sigma \odot \epsilon$।

व्यवहार में, VI पैरामीटर गणना दोगुनी करता है, ग्रेडिएंट विचरण बढ़ाता है (हर फॉरवर्ड पास अलग वेट उपयोग करता है), और मीन-फ़ील्ड धारणा वेट सहसंबंधों की अनदेखी करती है, जिससे एपिस्टेमिक अनिश्चितता को कम आंकने की प्रवृत्ति होती है। एक ट्रेडिंग स्टैक के लिए जहां आपके पास पहले से एक प्रशिक्षित deterministic मॉडल है, नीचे दो सस्ती विधियां आमतौर पर बेहतर प्रवेश बिंदु हैं।

विधि 2: MC ड्रॉपआउट

Gal और Ghahramani (2016) ने दिखाया कि ड्रॉपआउट के साथ प्रशिक्षित और ड्रॉपआउट अभी भी टेस्ट समय पर सक्रिय के साथ मूल्यांकित नेटवर्क एक डीप गाऊसियन प्रक्रिया में एक अनुमानित वेरिएशनल इन्फरेंस प्रक्रिया है। ड्रॉपआउट पहले से ही सबनेटवर्क्स पर एक वितरण प्रेरित करता है; इन्फरेंस के दौरान इसे चालू रखना और $T$ फॉरवर्ड पास चलाना उस निहित posterior से नमूने लेता है।

यह इस ब्लॉग में कहीं और नहीं है। यहां प्रकाशित कोड ड्रॉपआउट का उपयोग केवल ट्रेनिंग-टाइम रेगुलराइज़र के रूप में करता है (स्प्रेड मॉडलिंग, TFT पर dropout=0.1–0.3)। इन्फरेंस के दौरान इसे चालू रखना एक एकल-पंक्ति परिवर्तन है जिसका एक पूरी तरह से अलग अर्थ है।

प्रेडिक्टिव सांख्यिकी

$T$ stochastic फॉरवर्ड पास दिए गए $\{\hat{y}_t\}_{t=1}^{T}$ और प्रति-पास विचरण $\hat{\sigma}_t^2(x)$:

प्रेडिक्टिव मीन:

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

एपिस्टेमिक (पास के बीच असहमति):

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

एलेटोरिक (प्रेडिक्टेड शोर का माध्य):

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

विघटन बिल्कुल कुल विचरण का नियम है: सशर्त माध्य का विचरण, प्लस सशर्त विचरण का माध्य। कुल प्रेडिक्टिव विचरण उनका योग है।

PyTorch कार्यान्वयन

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

class MCDropoutNet(nn.Module):
    """
    अनिश्चितता अनुमान के लिए MC ड्रॉपआउट के साथ रिटर्न-प्रेडिक्शन नेटवर्क।
    दोनों प्रेडिक्टेड मीन और लॉग-वेरियंस (एलेटोरिक) आउटपुट देता है।
    """
    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)        # प्रेडिक्टेड रिटर्न
        self.head_logvar = nn.Linear(hidden_dim, 1)    # log(एलेटोरिक वेरियंस)

    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):
    """नेगेटिव लॉग-लिकलीहुड एक गाऊसियन के लिए जिसमें सीखी गई, इनपुट-निर्भर वेरियंस है।"""
    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 ड्रॉपआउट इन्फरेंस: ड्रॉपआउट ऑन रखें, T फॉरवर्ड पास एकत्र करें，
    प्रेडिक्टिव वेरियंस को एपिस्टेमिक और एलेटोरिक भागों में विघटित करें।
    """
    model.train()  # eval() नहीं — यह ड्रॉपआउट को सक्रिय रखता है
    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)              # पास के ऊपर वेरियंस
    aleatoric_var = log_vars.exp().mean(dim=0)  # पास के ऊपर E

    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),
    }

प्रशिक्षण heteroscedastic लॉस का उपयोग करता है, जो वेरियंस हेड को कुछ अर्थ देता है। सेल्फ-रेगुलेटिंग स्ट्रक्चर नोट करें: 0.5 * precision * (target - mu)**2 टर्म छोटे वेरियंस चाहता है, 0.5 * log_var टर्म इसे दंडित करता है, और संतुलन बिंदु सशर्त शोर स्तर है।

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

वह गोटचा जो विधि को शांत से मारता है: mc_predict के अंदर model.eval() को कॉल करना। ड्रॉपआउट को निष्क्रिय करता है, हर पास समान मान लौटाता है, epistemic_var बिल्कुल शून्य में ढह जाता है, और आपका साइज़िंग नियम शांत से एलेटोरिक वेरियंस पर सादा केली में वापस आ जाता है। यह त्रुटि के बिना विफल होता है। अपने इन्फरेंस पथ पर epistemic_var > 0 सुनिश्चित करें।

फॉरवर्ड पास की संख्या चुनना

• $T = 30$: स्थिर माध्य के लिए एक उचित निचली सीमा
• $T = 100$: माध्य और विचरण के लिए उपयोगी डिफ़ॉल्ट
• $T = 500{+}$: कम होते प्रतिफल जब तक आपको टेल क्वांटाइल की आवश्यकता न हो

विधि 3: डीप एनसेंबल्स

Lakshminarayanan et al. (2017) अलग-अलग यादृच्छिक प्रारंभ से $M$ स्वतंत्र नेटवर्क प्रशिक्षित करते हैं और एकत्र करते हैं। औपचारिक रूप से बेयसियन न होते हुए भी, डीप एनसेंबल्स अनिश्चितता कैलिब्रेशन बेंचमार्क पर अधिक सिद्धांत विधियों को लगातार हरा देते हैं।

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

सदस्यों के बीच असहमति एपिस्टेमिक अनुमान है। एनसेंबल्स इस ब्लॉग में कहीं और एग्रीगेशन डिवाइस के रूप में दिखाई देते हैं — एनोमली डिटेक्शन, HMM रेजिम डिटेक्शन, कंफ़ॉर्मल का EnbPI ब्लॉक बूटस्ट्रैप — लेकिन कभी इंटर-मेंबर स्प्रेड के माध्यम से अनिश्चितता estimator के रूप में नहीं। यह यहां उपयोग है।

एनसेंबल कार्यान्वयन

विविधता स्वतंत्र प्रशिक्षण से आती है, $M$ वस्तुओं के निर्माण से नहीं। अप्रशिक्षित या समान रूप से प्रशिक्षित सदस्यों का एनसेंबल या तो शोर या शून्य एपिस्टेमिक विचरण लौटाता है:

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

    def fit(self, train_loader, epochs: int = 200, lr: float = 1e-3):
        """प्रत्येक सदस्य स्वतंत्र रूप से प्रशिक्षित होता है। विविधता यहां से आती है
        -- अलग init, अलग शफल ऑर्डर। इसे छोड़ना
        epistemic_var == 0 देता है (समान सदस्य) या शुद्ध शोर (अप्रशिक्षित)।"""
        for seed, model in enumerate(self.models):
            torch.manual_seed(1000 + seed)   # अलग शफल/ड्रॉपआउट स्ट्रीम
            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()                     # यहां सही: कोई ड्रॉपआउट सैंपलिंग
            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)   # सदस्यों के पार फैलाव
        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(),
        }

नोट करें कि model.eval() DeepEnsemble.predict में सही है और mc_predict में गलत है। स्टोकैस्टिसिटी स्रोत भिन्न है: एनसेंबल्स इसे स्वतंत्र प्रशिक्षण से प्राप्त करते हैं, MC ड्रॉपआउट लाइव ड्रॉपआउट मास्क से।

ट्रेड-ऑफ: MC ड्रॉपआउट vs डीप एनसेंबल्स

एक प्रगमैटिक हाइब्रिड: एक छोटा एनसेंबल ($M = 3{-}5$) प्रशिक्षित करें जहां प्रत्येक सदस्य MC ड्रॉपआउट भी उपयोग करता है, दोनों इंटर-मॉडल असहमति और इंट्रा-मॉडल स्टोकैस्टिसिटी को कैप्चर करता है।

लाभ: असममित साइज़िंग

यहां वास्तविक योगदान है। गाऊसियन केली है $f^* = \mu / \sigma^2$; व्युत्पन्न, विकास परवलय, ड्राडउन प्रायिकता तालिका और आंशिक केली के बजाय पूर्ण केली चलाने के चार कारण सभी रणनीतियों के लिए केली मानदंड में हैं, और यहां दोहराए नहीं जाते। दिए गए के रूप में $f^* = \mu / \sigma^2$ एक तिमाही-केली अंश पर लें।

परिवर्तन हर है। कुल प्रेडिक्टिव वेरियंस के बजाय:

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

$\lambda > 1$ के लिए तर्क: एलेटोरिक वेरियंस बाज़ार का शोर है, यह मूल्यवान है, और इसे वहन करना है कि एक रणनीति कमाती है। एपिस्टेमिक वेरियंस आपकी अज्ञानता है — इसमें कोई प्रीमियम नहीं है, और बदतर, यह आपके $\mu$ अनुमान के साथ सहसंबंधित है गलत होने के साथ। जब $\sigma_{\text{epi}}$ बड़ा है, केली का अंश हर के समय अविश्वसनीय है, इसलिए साइज़िंग त्रुटि यौगिक होती है। बाज़ार शोर के सापेक्ष इसे सुपर-लीनियर रूप से दंडित करना इसका प्रत्यक्ष अभिव्यक्ति है।

def uncertainty_adjusted_position_size(
    pred_mean: float,
    epistemic_std: float,
    aleatoric_std: float,
    max_position: float = 1.0,
    lam: float = 2.0,                   # एपिस्टेमिक दंड; वैलिडेशन पर ट्यून करें
    max_epi_ratio: float = 0.5,         # इस epi/alea अनुपात से ऊपर परहेज करें
    base_kelly_fraction: float = 0.25,
) -> float:
    """केली साइज़िंग जहां एपिस्टेमिक वेरियंस एलेटोरिक से अधिक कड़ार से दंडित होता है।"""
    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))

गेट एक नोट के योग्य है। एक विश्वास सीमा के नीचे पोजिशन को शून्य करना यहां नया नहीं है — कंफ़ॉर्मल लेख सामान्य नो-ट्रेड फ़िल्टर को $e_t = |\hat{\mu}| / w_t$ के रूप में निर्दिष्ट और कोड करता है min_edge सीमा के साथ, जिसमें सीमा कैसे चुनें और शून्य को पार करने वाले अंतराल की ज्यामितीय रीडिंग शामिल है। उस मशीनरी के लिए कंफ़ॉर्मल प्रेडिक्शन देखें। जो नया है वह हर है: $\sigma_{\text{epi}} / \sigma_{\text{alea}}$ पर गेटिंग विशेष रूप से तब फायर करता है जब मॉडल अपने पैरामीटर्स के बारे में बाज़ार की तुलना में अधिक भ्रमित है — एक अवस्था जो कुल-अनिश्चितता गेटिंग नहीं पा सकती, क्योंकि एक शांत लेकिन अपरिचित शासन कम कुल विचरण और एक भयानक एपिस्टेमिक अनुपात हो सकता है।

कैलिब्रेशन: इसे सौंपें

एक अनिश्चितता अनुमान केवल तब उपयोगी है जब कैलिब्रेटेड: एक नाममात्र 95% अंतराल को सत्य को ~95% समय शामिल करना चाहिए। यहां अपना गाऊसियन-क्वांटाइल विश्वसनीयता चेक न लॉल करें — एक पैरामीट्रिक अंतराल भारी-पूँच रिटर्न अवशिष्ट पर वही विफलता मोड है जो कंफ़ॉर्मल प्रेडिक्शन से बचने के लिए मौजूद है, और यह एक कामकाज evaluate() भेजता है जो लक्ष्य बनाम empírical कवरेज के साथ पीछे एक सीमित-नमूना गारंटी रिपोर्ट करता है। TFT पोस्ट क्वांटाइल हेड्स के लिए भी वही बिंदु बनाता है।

पोस्ट-हॉक रीस्केलिंग ($\tilde{\sigma} = \alpha \sigma + \beta$ वैलिडेशन सेट पर फिट) सस्ता फिक्स है, और यह एडेप्टिव कंफ़ॉर्मल इन्फरेंस का कमजोर चचेरा भाई है, जो एक स्थिर रीस्केल के बजाय एक लॉन्ग-रन कवरेज बाउंड के साथ एक ऑनलाइन miscoverage स्तर $\alpha_t$ बनाए रखता है। ACI मजबूत विकल्प है; रैखिक रीस्केलिंग को प्राथमिकता देने का एकमात्र कारण यह है कि यह एपिस्टेमिक/एलेटोरिक अनुपात को बनाए रखता है, जो ACI की एकल चौड़ाई नहीं करता।

प्रकाशन से पहले क्या मापा जाना चाहिए

ऊपर की विधियां स्थापित हैं। यह दावा कि ट्रेडिंग में विभाजन कुछ खरीदता है स्थापित नहीं है, और यह ब्लॉग केवल तर्क पर साइज़िंग नियम प्रकाशित नहीं करता। बार:

1. डेटासेट और लक्ष्य। इंस्ट्रूमेंट, बार आकार, स्पष्ट दिनांक श्रेणी, फीचर सेट, और प्रेडिक्शन लक्ष्य नाम दें।

2. विभाजन स्वयं। कुल प्रेडिक्टिव वेरियंस का कितना अंश एपिस्टेमिक बनाम एलेटोरिक है, और यह अनुपात एक नामित शांत खिड़की और एक नामित अस्थिर के बीच कैसे चलता है। यह मनी चार्ट है और अभी तक मौजूद नहीं है। वह परिकल्पना जो falsifying के योग्य है: अनुपात वास्तविक वोलैटिलिटी से पहले बढ़ता है, क्योंकि अपरिचितता अशांति से पहले आती है।

3. कवरेज vs कंफ़ॉर्मल। मापा out-of-sample कवरेज MC ड्रॉपआउट अंतराल का नाममात्र के बनाम उसी डेटा पर प्रकाशित लेख से split-कंफ़ॉर्मल अंतराल के। वह head-to-head स्वयं एक नया परिणाम है और दो पोस्ट के बीच प्राकृतिक पुल।

4. क्या $\lambda$ कुछ खरीदता है? वैलिडेशन पर एपिस्टेमिक दंड को स्वीप करें और $\lambda = 1$ बेसलाइन के खिलाफ PnL और अधिकतम ड्राडउन रिपोर्ट करें। यदि यह कुछ नहीं खरीदता, तो कहें — ईमानदार नेगेटिव उस परिणाम के लिए टेम्पलेट है और एक प्रकाशन योग्य परिणाम है।

5. इन्फरेंस लागत। मापा गया, लक्ष्य हार्डवेयर पर, प्रत्येक $T$ पर।

कोई भी मूल्यांकन यहां वॉक-फॉरवर्ड ऑप्टिमाइज़ेशन अनुशासन के तहत चलता है — $\lambda$ एक hyperparameter है, और पूरे नमूने पर ट्यून किया गया $\lambda$ एक परिणाम नहीं है।

उत्पादन के लिए व्यावहारिक युक्तियां

1. प्रायर को वार्म-अप करें। वेरिएशनल इन्फरेंस के साथ, एक प्री-ट्रेंड डिटरमिनिस्टिक नेटवर्क से वेरिएशनल मीन को इनिशियलाइज़ करें बजाय यादृच्छिक रूप से। आमतौर पर अभिसारण समय को आधा कर देता है।

2. वेरियंस कोलैप्स के लिए देखें। सीखी गई वेरियंस $\sigma_j$ लगभग शून्य तक ड्रिफ्ट कर सकती हैं, BNN को शांत से एक डिटरमिनिस्टिक नेटवर्क में वापस ले जाती हैं। प्रशिक्षण के दौरान माध्य $\sigma_j$ की निगरानी करें; यदि आवश्यक हो तो KL annealing जोड़ें।

3. एक निश्चित वैलिडेशन सेट पर नहीं, बल्कि रोलिंग आधार पर रीकैलिब्रेट करें। बाज़ार गैर-स्टेशनरी हैं और एक बार फिट कैलिब्रेशन क्षय होता है। या तो वॉक-फॉरवर्ड अनुशासन के तहत रोलिंग विंडो पर रीट्रेन करें, या ACI को मॉडल staleness को ऑनलाइन अवशोषित करने दें — कंफ़ॉर्मल पोस्ट सीधे रीट्रेन-फ़्रीक्वेंसी ट्रेड-ऑफ को कवर करता है।

4. एनसेंबल विविधता मायने रखती है। अलग बीज, अलग शफल, वैकल्पिक रूप से प्रति सदस्य अलग hyperparameters। इनिशियलाइज़ेशन विविधता एनसेंबल गुणवत्ता का प्राथमिक ड्राइवर है, जो यहीं कि ऊपर fit() लूप वैकल्पिक नहीं है।

5. विघटन लॉग करें, केवल कुल नहीं। दोनों घटकों को रियलाइज़्ड परिणामों के साथ संग्रहीत करें। इसके बिना आप रिव्यू में एकमात्र महत्वपूर्ण प्रश्न का उत्तर नहीं दे सकते: जब sizer ने एक्सपोज़र काटा, तो क्या इसलिए कि बाज़ार शोरीय था या मॉडल खो गया था — और क्या यह सही था?

6. अनिश्चितता फीचर के रूप में। रोलिंग एपिस्टेमिक सांख्यिकी स्वयं ड्राडउन के लिए भविष्यवाणीपूर्ण हो सकती है। बेहद संभव, अमापा, और एक अलग पोस्ट के योग्य।

सीमाएं और ईमानदार चेतावनी

• अनुमानित posteriors अभी भी अनुमानित हैं। MC ड्रॉपआउट और VI वास्तविक posterior की सीमित दृष्टि देते हैं। कुछ भी न होने से बेहतर, ग्राउंड ट्रूथ नहीं, और न तो कोई कवरेज गारंटी दोनों से जुड़ी है।
• कैलिब्रेशन ठीक तब बिगड़ता है जब आपको इसकी आवश्यकता होती है। एक वास्तव में नए शासन में मॉडल अभी भी miscalibrated हो सकता है — यह केवल एक deterministic से कम miscalibrated होने की प्रवृत्ति रखता है। एक out-of-distribution इनपुट से अनिश्चितता अनुमान स्वयं out-of-distribution आउटपुट हैं।
• एलेटोरिक वेरियंस एपिस्टेमिक सिग्नल को अवशोषित कर सकता है। यदि हेटेरोस्केडास्टिक हेड पर्याप्त लचीला है, तो यह मॉडल अनिश्चितता को डेटा शोर के रूप में समझाने के लिए सीखता है, $\sigma_{\text{epi}}$ को शून्य की ओर ढहने और पूरे विघटन को शांत से हरा देता है। यह इस पोस्ट का सबसे महत्वपूर्ण विफलता मोड है और यह खुद की घोषणा नहीं करता। शासन के ऊपर अनुपात की निगरानी करें; एक अनुपात जो कभी नहीं चलता एक टूटा हुआ विघटन है, स्थिर बाज़ार नहीं।
• $\lambda$ एक मुफ्त पैरामीटर है। एक साइज़िंग नियम में एक tunable नॉब पेश करना overfit साइज़िंग नियम कैसे बनाए जाते हैं। इसे एक वॉक-फॉरवर्ड justification की आवश्यकता है या इसे 1 पर फिक्स करना होगा।

निष्कर्ष

कंफ़ॉर्मल प्रेडिक्शन पहले से ही इस ब्लॉग को एक कवरेज गारंटी के साथ अंतराल चौड़ाई देता है, और केली पहले से ही इसे एक साइज़िंग नियम देता है। जो नहीं देता वह उत्तर है क्यों अंतराल चौड़ा है। प्रेडिक्टिव वेरियंस को एपिस्टेमिक और एलेटोरिक भागों में विभाजित करने से वह उत्तर मिलता है, और उत्तर कुल की तुलना में अधिक कार्यवाही योग्य है: बाज़ार शोर मुआवजा दिया गया जोखिम है, मॉडल अज्ञान नहीं है, और साइज़िंग हर को यह कहना चाहिए।

MC ड्रॉपआउट विभाजन को लगभग मुफ्त बनाता है — इन्फरेंस पर एक लाइन (model.train()) किसी भी ड्रॉपआउट नेट को एक अनुमानित बेयसियन में बदल देता है। डीप एनसेंबल्स $M$x का खर्च करते हैं और बेहतर कैलिब्रेट करते हैं। दोनों एक ही असममित हर $\sigma^2_{\text{alea}} + \lambda \sigma^2_{\text{epi}}$ को खिलाते हैं।

क्या $\lambda > 1$ वास्तव में भुगतान करता है एक empírical प्रश्न है जो यह ड्राफ्ट अभी तक उत्तर नहीं देता। ऊपर सूचीबद्ध माप इसे प्रकाशित करने की कीमत हैं।

संदर्भ:

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