Neural ODEs: Does Continuous Time Beat a Delta-Time Feature?

Sinirsel Sıradan Diferansiyel Denklemler (Chen ve diğerleri, NeurIPS 2018), gizli bir durumun türevini bir sinir ağıyla parametreleştirir ve bir ODE çözücünün çıktıyı hesaplamasına izin verir. Model sürekli-derinlik haline gelir ve pazarlar için daha kullanışlı bir şekilde sürekli-zaman: gizli durum, yalnızca verilerinizin bulunduğu ızgara noktalarında değil, herhangi bir $t$'de değerlendirilebilir.

Bu mülkün, rastgele aralıklarla gelen finansal veriler için bariz bir adımı var. Ancak saha, göründüğünden çok daha zayıf bir iddiayı gizliyor. Sade bir GRU, önceki gözlemden bu yana ekstra bir giriş özelliği sundu - $\log(\Delta t)$ - aynı zamanda ne kadar zaman geçtiğini de "biliyor". Asıl soru, sürekli zamanlı modellerin düzensiz verileri alıp alamayacağı değildir. Gözlemler arasında öğrenilen sürekli dinamiklerin, delta-zaman özelliğinin size halihazırda vermediği herhangi bir şeyi, çıkarım maliyetinin on ila yüz katı kadar çıkarıp çıkarmadığıdır.

Bu makale bu deneyi kuruyor, onu çalıştırmak için gereken tüm araç zincirini veriyor ve makineyi haklı çıkarmak için karşılaştırmanın ne göstermesi gerektiğini rapor ediyor. Tartışmanın çubuk yapısı tarafı - ticaret zamanlamasının kendisinin sinyal taşıdığı - zaman çubuklarının ötesinde; burada önemli olan tek sonuç modellemedir: çözücü gizli durumu keyfi $t$ değerinde değerlendirir, dolayısıyla hiçbir enterpolasyon veya dolguya gerek yoktur.

Test Edilen İddia

Her biri bir öncekinden kesinlikle daha güçlü olan, iç içe geçmiş üç hipotez:

1. H1 — Ham düzensiz BTC ticaret akışındaki bir ODE-RNN uyumu, hiçbir zaman bilgisi olmadan aynı akıştaki GRU uyumunu yener. Bu neredeyse kesindir ve neredeyse değersizdir: ODE-RNN basitçe temel çizgide eksik olan bilgiye sahiptir.
2. H2 — ODE-RNN, GRU'ya bir giriş özelliği olarak $\log(\Delta t)$ verildiğinde aynı GRU'yu geçer. Bu dürüst bir testtir. Bu, Nöral ODE literatürünün genellikle öne sürdüğü bir iddiadır ve finansal verilerde neredeyse hiç kanıtlanmayan bir iddiadır.
3. H3 — H2 avantajı gecikme bütçesinden etkilenmez, yani ODE-RNN uyarlanabilir dopri5 yerine canlı çıkarım için yeterince hızlı sabit adımlı bir çözücüyle konuşlandırıldığında geçerlidir.

Deney Protokolü

Her iki kol için aynı tıklama akışı, aynı hedef, aynı ayarlama bütçesi. 1 m'lik çubuklara yeniden örnekleme yapılmaz; yeniden örnekleme, test edilen yapıyı tam olarak yok eder.

H2'deki negatif sonuç tamamen yayınlanabilir ve tartışmasız daha değerli sonuçtur; dürüst negatif sonuç ve çoklu test altında Sharpe'ın söndürülmesi için aynı standart uygulanır.

İkincil Deney: CNF ve Öğrenci-t

ODE-RNN karşılaştırması çok pahalıysa, daha ucuz ampirik çapa dağıtımsaldır: gerçek BTC günlük getirilerine sürekli bir normalleştirme akışı uydurun ve uydurulmuş yoğunluğunu bir Öğrenci-t uyumuyla ve ampirik kuyrukla karşılaştırın, kuyruk nicelik hatalarını %1 ve %5 seviyelerinde raporlayın. Bu, halihazırda GARCH volatilite tahmini ve asimetrik GARCH ile ölçülen dağılım çalışmasına doğrudan bağlanır.

Bu makalenin geri kalanı, yukarıdakileri çalıştırmak için gereken arka plan ve araç zinciridir.

Arka Plan: ResNet'lerden Sürekli Dinamiklere

Artık ağ $h_{t+1} = h_t + f(h_t, \theta_t)$ değerini hesaplar. Adım boyutunu küçültüp katman sayısını artırdığınızda sürekli bir sınıra yaklaşırsınız:

$\frac{dh(t)}{dt} = f(h(t), t, \theta)$

Ayrı parametrelere sahip $T$ ayrık katmanlar yerine, tek bir ağ $f$ anlık değişim hızını belirtir. $T$ zamanındaki çıktı bir başlangıç ​​değeri problemini çözer:

$h(T) = h(0) + \int_0^T f(h(t), t, \theta) \, dt$

Bir kara kutu çözücü (Euler, Runge-Kutta, Dormand-Prince), yerel hata tahminlerinden adım boyutlarını uyarlanabilir bir şekilde seçerek integrali sayısal olarak hesaplar.

Ek Yöntem

Her çözücü adımında geriye yayılım tüm ara durumları saklar ve adım sayısıyla orantılı olarak hafızaya maliyet getirir. Chen ve diğerleri. bunun yerine $O(1)$ belleğiyle geriye dönük bir ODE'yi çözün. Koşulları karşılayan $a(t) = -\partial L / \partial h(t)$ ek durumunu tanımlayın

$\frac{da(t)}{dt} = -a(t)^T \frac{\partial f(h(t), t, \theta)}{\partial h}$

ve parametre gradyanını geri geçiş boyunca biriktirin:

$\frac{dL}{d\theta} = -\int_T^0 a(t)^T \frac{\partial f(h(t), t, \theta)}{\partial \theta} \, dt$

Geriye doğru geçiş, $h(t)$, $a(t)$ ve $dL/d\theta$'yi eşzamanlı olarak hesaplayan ve çözücüyü $T$'den $0$'ye kadar ters yönde çalıştıran artırılmış bir sistemi çözer.

Takas: $h(t)$'nın geriye doğru yeniden yapılandırılması, katı veya kaotik dinamikler için kötü bir şekilde sayısal hata biriktirir. Kontrol noktası oluşturma orta yoldur; $h(t)$'yi birkaç ara zamanda saklayın, aralarında yeniden hesaplayın. Fiyat süreçleri sürekli yarı-martingales ve orta derecede pürüzsüzdür, bu nedenle ek genellikle dayanır; Mikroyapı olaylarının etrafındaki katılık, uyarlanabilir çözücüleri veya hibritleri zorlayabilir.

ODE-RNN: Gözlemler Arasında Sürekli Gizli Durum

ODE-RNN, ana deneyin etkinleştirdiği mimaridir. Gözlemler arasında gizli durum ODE kapsamında gelişir:

$h(t) = \text{ODESolve}(f_\theta, h(t_i), t_i, t)$

$x_{i+1}$ gözlemi $t_{i+1}$'ye ulaştığında ayrı bir güncelleme tetiklenir:

$h(t_{i+1}^+) = \text{RNNCell}(h(t_{i+1}^-), x_{i+1})$

Üst simgeler gözlemden hemen önceki ve hemen sonraki durumu belirtir. Gözlemler arasında öğrenilen sürekli dinamikler; gözlemlerde, yeni bilgiler.

H2 ablasyonunun araştırdığı mekanizma şudur: uzun bir boşluk, gizli durumun $f_\theta$ altında uzun bir yol kat ettiği anlamına gelir - bir taban çizgisine doğru bozulur veya ıraksar - ve bu evrimin şekli bir skaler olarak sağlanmak yerine öğrenilir. Bu ifade gücünün gerçek ticari verilerde kendini amorti edip etmediği tam olarak ölçülemeyen şeydir.

Doğal, işaretlerin ötesinde uyum sağlar: her varlığın kendi gözlem planına sahip olduğu ve ilişkili varlıkların gizli durumunun yalnızca bir tanesi gözlemlenirken gelişmeye devam ettiği çok varlıklı portföyler; ve düzensiz zamanlarda gelen olaya dayalı sinyaller (haberler, kazançlar, makro açıklamalar).

Sinir SDE'leri: Stokastik Bileşenler Ekleme

Sinirsel ODE'ler deterministiktir ve fiyat yolundaki gürültüyü temsil edemez. Geometrik Brownian hareketi, risk-nötr sapma ve sabit volatilite varsayımlarının gülümsemeye karşı başarısız olduğu yöntemlerden oluşan klasik tedavi, Black-Scholes opsiyon fiyatlandırmasında ele alınmıştır. Nöral SDE'ler parametrik formu öğrenilmiş bir yayılma terimiyle değiştirir:

$dh(t) = f(h(t), t, \theta) \, dt + g(h(t), t, \phi) \, dW(t)$

$f$ sürüklenmedir, $g$ yayılmadır, $W(t)$ bir Wiener sürecidir, hem $f$ hem de $g$ sinir ağlarıdır.

Mimari: Drift Ağı ve Difüzyon Ağı

• Sürüklenme ağı $f_\theta$: beklenen yörünge — trend, ortalama geri dönüş, momentum. Tahmin hatasını en aza indirecek şekilde eğitildi.
• Yayılış ağı $g_\phi$: durumun bir fonksiyonu olarak öğrenilen gürültü büyüklüğü. Değişken rejimlerde yüksek, sakin rejimlerde düşük.

Bölünme, klasik niceliksel finansın yansımasıdır: sürüklenme risk-nötr (veya P-ölçüsü) dinamikleridir, yayılma ise oynaklık yüzeyidir.

Sinirsel SDE'lerin Eğitimi

Stokastik integral $\int g\,dW$ klasik olarak türevlenebilir değildir. Üç yaklaşım:

1. Yol yönünde gradyanlar: yeniden parametrelendirme hilesi — Brownian yollarını örnekleyin, çözücünün gürültüyü sabit girdi olarak ele almasıyla farklılaştırın.
2. Puan eşleştirme: $\nabla_h \log p(h)$ tahminini yapın ve gürültü giderme hedefleri aracılığıyla eğitim verin — kripto tahmini için yayılma modellerinde bağımsız bir üretken model olarak kullanılan makinenin aynısı, burada SDE için bir eğitim seçeneğine indirgenmiştir.
3. Sonlu boyutlu dağılım eşleşmesi: tam yol ölçümleri yerine gözlem zamanlarındaki marjinalleri eşleştirin.

Pathwise pratik varsayılandır. torchsde Euler-Maruyama, Milstein ve stokastik Runge-Kutta'yı autodiff desteğiyle uygular.

Volatilite Yüzeyini Öğrenmek

Klasik modeller (Heston, SABR), difüzyon katsayısına parametrik formlar uygular. Bir Nöral SDE, $g_\phi(S, t)$ öğesini isteğe bağlı bir işlev olarak öğrenir:

$dS(t) = \mu_\theta(S(t), t) \, dt + \sigma_\phi(S(t), t) \, S(t) \, dW(t)$

Bu, difüzyon süreçleri için evrensel bir yaklaşımdır - herhangi bir Ito süreci, yeterli kapasite verildiğinde keyfi doğruluğa ulaşır.

Eksik ve Eşzamansız Veriler için Gizli ODE'ler

Gizli ODE (Rubanova, Chen, Duvenaud, 2019), Sinirsel ODE'yi bir VAE ile eşleştirir: finansal seriler, düşük boyutlu bir gizli alanda öğrenilen, pürüzsüz bir temel sürecin gürültülü gözlemleridir.

1. Tanıma ağı: $q(z_0 | x_{1:N})$ üretmek için gözlemler boyunca geriye doğru çalışan bir ODE-RNN.
2. Gizli dinamikler: $z(t) = z(t_0) + \int_{t_0}^{t} f_\theta(z(s), s)\, ds$.
3. Kod Çözücü: $\hat{x}(t) = \text{Decoder}(z(t))$, istenilen zamanda değerlendirilebilir.

Kayıp standart ELBO'dur:

$\mathcal{L} = \mathbb{E}_{q(z_0)} \left[ \sum_{i=1}^{N} \log p(x_i | z(t_i)) \right] - \text{KL}(q(z_0 | x_{1:N}) \| p(z_0))$

Portföy durumu tahmini: Varlıklar arasındaki seyrek eşzamansız gözlemlerden, ortak dinamikleri yakalayan sürekli bir gizli durum çıkarımı yapın; esas olarak Kalman filtresinin doğrusal olmayan, öğrenilmiş bir versiyonudur.

Eksik veri yüklemesi: duraklamalar ve hafta sonu boşlukları düzgün bir şekilde enterpolasyonlu gizli bir yörüngeye sahip olur; kod çözücü, VAE posteriorundan gelen belirsizliğe sahip boşluk boyunca makul yollar üretir.

Çoklu frekans füzyonu: günlük kapanışlar, gün içi VWAP ve tıklama verileri, paylaşılan bir zaman çizelgesi olmadan tek bir modelde.

İade Dağılımları için Akışların Sürekli Normalleştirilmesi

CNF'ler, basit bir temel dağıtımı karmaşık bir hedefe dönüştürmek için Sinirsel ODE'yi kullanır. Dönüşüm $\frac{dz(t)}{dt} = f(z(t), t, \theta)$'dir ve günlük yoğunluğu, değişkenlerin anlık değişimini takip eder:

$\frac{\partial \log p(z(t))}{\partial t} = -\text{tr}\left(\frac{\partial f}{\partial z(t)}\right)$

$z(T)$ ve $\log p(z(T))$ elde etmek için durumu ve günlük yoğunluğunu $z(0) \sim p_0$'den ileriye doğru entegre edin. Jacobian izi, ölçeklenebilirlik için Hutchinson'un stokastik tahmincisi ile tahmin edilir.

Kripto getirileri leptokurtiktir ve negatif olarak çarpıktır - GARCH volatilite tahmini ve asimetrik GARCH ve kaldıraç etkisi'deki gerçek verilerle ölçülmüştür - ve bir CNF, bunu varsaymak yerine bu şekli öğrenir. Akışın durum değişkenlerine göre koşullandırılması, şeklin rejimle değişmesine izin verir. Yoğunluk yaklaşık olmaktan ziyade kesin olduğundan, Monte Carlo ve önyükleme arka testlerinde hesaplanan kuyruk ölçümlerini ve HRP/CVaR portföy hattında CVaR yapısını besleyebilir; ortak kuyruk yapısı ortak risk için bağ modellerinde ayrı ayrı ele alınır.

Koşullu Yoğunluk Tahmini

Yararlı çerçeveleme, aynı soruna yönelik yayınlanmış üç yaklaşım arasındaki doğrudan karşıtlıktır. TFT size bir nicelik çıktı katmanından sabit bir nicelik kümesi verir. Uyumlu tahmin size kapsam garantisiyle kalibre edilmiş aralıklar sunar. Koşullu bir CNF size kesin, türevlenebilir bir yoğunluk verir:

$\frac{dz(t)}{dt} = f(z(t), t, \text{features}_t, \theta)$

Farklılaştırılabilirlik ayırt edici özelliktir: yoğunluk, ne sabit niceliklerin ne de uygun aralıkların desteklemediği, aşağı yöndeki bir hedefin içinde yer alabilir ve geriye doğru yayılabilir. Tam yoğunluğun, aynı hedefteki TFT niceliklerine göre maliyetine değip değmeyeceği burada test edilmemiştir.

Farklı Alternatiflerle Karşılaştırma

Bu tablonun LSTM'ye karşı dikkat yarısı, karşılaştırmalarla birlikte TFT makalesinde ayrıntılı olarak tartışılmıştır - "TFT vs LSTM vs Vanilya Transformatörü" ve "LSTM Hala Kazandığında" bölümlerine bakın. Burada yeni olan sütunlar sağdaki iki sütun, H2/H3 sorularına karar veren satırlar ise son ikisidir.

torchdiffeq ile Python Uygulaması

torchdiffeq, ODE çözücülerine ek geri yayılım sağlar.

Fiyat Dinamikleri için Temel Sinirsel ODE

import torch
import torch.nn as nn
from torchdiffeq import odeint_adjoint as odeint

class PriceDynamics(nn.Module):
    """Neural network defining dh/dt = f(h, t)."""

    def __init__(self, hidden_dim: int = 64):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(hidden_dim, 128),
            nn.Tanh(),
            nn.Linear(128, 128),
            nn.Tanh(),
            nn.Linear(128, hidden_dim),
        )

    def forward(self, t, h):
        return self.net(h)


class NeuralODEPredictor(nn.Module):
    """
    Encode observed features -> latent state,
    evolve via Neural ODE,
    decode to price prediction.
    """

    def __init__(self, input_dim: int, hidden_dim: int = 64):
        super().__init__()
        self.encoder = nn.Linear(input_dim, hidden_dim)
        self.dynamics = PriceDynamics(hidden_dim)
        self.decoder = nn.Linear(hidden_dim, 1)

    def forward(self, x0, eval_times):
        """
        x0:         (batch, input_dim) features at t=0
        eval_times: (T,) times at which to evaluate the ODE
        Returns:    (T, batch, 1) predictions
        """
        h0 = self.encoder(x0)                          # (batch, hidden_dim)
        h_traj = odeint(self.dynamics, h0, eval_times,
                        method='dopri5', rtol=1e-5, atol=1e-7)
        return self.decoder(h_traj)

Düzensiz Onay Verileri için ODE-RNN

Bu deneysel kol. Geçmesi gereken taban çizgisi, x ile birleştirilmiş log(t_next - t_prev) ile aynı akışta nn.GRUCell olmalıdır.

class ODERNNCell(nn.Module):
    """Single step: ODE-evolve, then RNN-update."""

    def __init__(self, input_dim: int, hidden_dim: int = 64):
        super().__init__()
        self.dynamics = PriceDynamics(hidden_dim)
        self.gru_cell = nn.GRUCell(input_dim, hidden_dim)

    def forward(self, h, x, t_prev, t_next):
        times = torch.tensor([t_prev, t_next], dtype=torch.float32)
        h_evolved = odeint(self.dynamics, h, times,
                           method='dopri5')[-1]  # state at t_next
        h_updated = self.gru_cell(x, h_evolved)
        return h_updated


class ODERNN(nn.Module):
    """Process irregularly-sampled sequence."""

    def __init__(self, input_dim: int, hidden_dim: int = 64):
        super().__init__()
        self.cell = ODERNNCell(input_dim, hidden_dim)
        self.decoder = nn.Linear(hidden_dim, 1)
        self.hidden_dim = hidden_dim

    def forward(self, observations, times):
        """
        observations: list of (batch, input_dim) tensors
        times:        list of floats, observation timestamps
        """
        batch_size = observations[0].shape[0]
        h = torch.zeros(batch_size, self.hidden_dim)

        outputs = []
        for i in range(len(observations)):
            t_prev = 0.0 if i == 0 else times[i - 1]
            h = self.cell(h, observations[i], t_prev, times[i])
            outputs.append(self.decoder(h))

        return torch.stack(outputs)  # (seq_len, batch, 1)

Eğitim Döngüsü

def train_neural_ode(model, train_loader, epochs=100, lr=1e-3):
    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
        optimizer, T_max=epochs
    )

    for epoch in range(epochs):
        epoch_loss = 0.0
        for batch in train_loader:
            features, times, targets = batch
            optimizer.zero_grad()

            predictions = model(features, times)
            loss = torch.nn.functional.mse_loss(predictions, targets)

            loss.backward()
            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
            optimizer.step()

            epoch_loss += loss.item()

        scheduler.step()

        if (epoch + 1) % 10 == 0:
            avg_loss = epoch_loss / len(train_loader)
            print(f"Epoch {epoch+1}/{epochs}, Loss: {avg_loss:.6f}")

İade Dağılımları için Sürekli Normalleştirme Akışı

from torchdiffeq import odeint

class CNFDynamics(nn.Module):
    """Dynamics for continuous normalizing flow."""

    def __init__(self, dim: int = 1, hidden_dim: int = 64):
        super().__init__()
        self.net = nn.Sequential(
            nn.Linear(dim + 1, hidden_dim),  # +1 for time
            nn.Tanh(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.Tanh(),
            nn.Linear(hidden_dim, dim),
        )
        self.dim = dim

    def forward(self, t, state):
        z = state[..., :self.dim]
        t_expand = t.expand(z.shape[0], 1)
        zt = torch.cat([z, t_expand], dim=-1)
        dz = self.net(zt)

        e = torch.randn_like(z)
        e_dz = torch.autograd.grad(
            dz, z, e, create_graph=True
        )[0]
        trace_jac = (e_dz * e).sum(dim=-1, keepdim=True)

        return torch.cat([dz, -trace_jac], dim=-1)


class ReturnDistributionCNF(nn.Module):
    """Model return distributions with continuous normalizing flows."""

    def __init__(self, dim: int = 1):
        super().__init__()
        self.dynamics = CNFDynamics(dim)
        self.dim = dim

    def log_prob(self, x):
        """Compute log probability of observed returns."""
        log_p0 = torch.zeros(x.shape[0], 1)
        state0 = torch.cat([x, log_p0], dim=-1)
        state0.requires_grad_(True)

        times = torch.tensor([1.0, 0.0])  # backward
        state_T = odeint(self.dynamics, state0, times,
                         method='dopri5')[-1]

        z_T = state_T[..., :self.dim]
        delta_log_p = state_T[..., self.dim:]

        log_p_base = -0.5 * (z_T ** 2 + torch.log(
            torch.tensor(2 * torch.pi)
        )).sum(dim=-1, keepdim=True)

        return log_p_base + delta_log_p

    def sample(self, n_samples: int):
        """Generate samples from learned distribution."""
        z0 = torch.randn(n_samples, self.dim)
        log_p0 = torch.zeros(n_samples, 1)
        state0 = torch.cat([z0, log_p0], dim=-1)

        times = torch.tensor([0.0, 1.0])  # forward
        state_T = odeint(self.dynamics, state0, times,
                         method='dopri5')[-1]

        return state_T[..., :self.dim]

Pratik Notlar

Yukarıdaki deneyi yaparken canınızı sıkacak şeyler bunlar.

Çözücü Seçimi ve Hızı

dopri5 doğruluk garantileri verir ancak işlem maliyeti değişkendir; bu nedenle H3, H2'den ayrı bir hipotezdir: yalnızca uyarlanabilir bir çözücü altında var olan bir kenar, canlı gecikme bütçesinden sağ çıkamayabilir. Sabit adımlı çözücüler (Euler, RK4), doğruluk pahasına öngörülebilir gecikme sağlar. Pratik uzlaşma: dopri5 ile eğitim alın, uyarlanabilir çözümleyicinin temsili veriler üzerindeki çıktısıyla eşleşecek şekilde kalibre edilmiş sabit adımlı bir çözücüyle konuşlandırın ve boşluğun küçük olduğunu varsaymak yerine ölçün.

odeint(f, h0, t, method='dopri5', rtol=1e-6, atol=1e-8)

odeint(f, h0, t, method='euler', options={'step_size': 0.1})

Süreksiz atlamalara yakın sert problemler için, method='implicit_adams' veya method='scipy_solver'.

Sayısal Kararlılık

$f_\theta$ büyük değerler çıkarırsa durum farklılaşır. Azaltmalar:

• Lipschitz sabitini kontrol etmek için $f_\theta$ katmanlarında Spektral normalleştirme.
• Eğitim sırasında gradyan kırpma (yukarıdaki eğitim döngüsünde gösterilmiştir).
• Zaman normalleştirme: zaman damgalarını $[0, 1]$ olarak ölçeklendirin.
• Dinamik normda düzenleme: kayba $\lambda \|f_\theta(h, t)\|^2$ ekleyin.

Entegrasyon Aralığı

Aylara yayılan veriler için $t = 0$ dakikadan $t = 10{,}000$ dakikaya kadar entegrasyon yapmayın:

t_normalized = (timestamps - timestamps[0]) / (timestamps[-1] - timestamps[0])

Bu, çözücüyü sayısal olarak dost bir rejimde tutar ve öğrenilen dinamikleri ölçekle değişmez hale getirir. Karşılaştırma için de önemlidir: normalleştirilmemiş bir ODE-RNN, tamamen sayısal nedenlerden dolayı GRU temel çizgisini kaybedebilir; bu, bir bulgudan ziyade bir ölçüm eseri olacaktır.

Çoklu Zaman Ölçeklerini Kullanma

Piyasalar aynı anda mikrosaniye, saniye, dakika ve günlük ölçeklerde dinamiklere sahiptir ve tek bir Nöral ODE bunların hepsini tutmakta zorlanabilir. Seçenekler: birden fazla ODE bloğunu farklı zaman ölçeklerinde istifleyin; hem hızlı hem de yavaş kapasite için gizli boyutu genişletin; veya frekans bandı ve sigorta çıkışları başına ayrı Nöral ODE'ler çalıştırın. (Bu bir model kapasitesi sorusudur ve uyarlamalı çözünürlük incelemesi bölümündeki geriye dönük test doğruluğu sorusundan farklıdır.)

Açık Araştırma Yönergeleri

Neural Jump SDE'leri: ani yer değiştirmeler (ani çökmeler, kazanç sürprizleri) için öğrenilmiş bir atlama bileşeni ekleyin:

$dh = f \, dt + g \, dW + \int_{\mathbb{R}} \gamma(h, z) \, \tilde{N}(dt, dz)$

burada $\tilde{N}$ telafi edilmiş bir Poisson rastgele ölçüsüdür ve $\gamma$ öğrenilmiş bir atlama çekirdeğidir.

Sinir Kontrollü Diferansiyel Denklemler (Sinir CDE'leri): Wiener sürecini genel bir sürüş sinyaliyle değiştirerek gözlemlenen veri akışlarının dinamikleri yönlendirmesine izin verin. İşlem akışının ve teklif akışının gizli piyasa durumunu yönlendirdiği sipariş akışı için doğaldır.

Farklılaştırılabilir Piyasa Simülasyonu: Farklılaştırılabilir bir simülatör içinde üretken model olarak bir Sinir SDE'si kullanın ve ek aracılığıyla geriye yayılarak stratejileri uçtan uca eğitin. Strateji ve pazar modeli birlikte gelişir.

Fizik Bilgisine Sahip Nöral ODE'ler: PINN'ler kayba bir diferansiyel denklem kalıntısı yerleştirir — tekniğin kendisi Navier-Stokes makalesinde tanıtılmıştır. Mali uygulama, öğrenilen dinamikler üzerinde ceza şartları veya katı kısıtlamalar olarak arbitraj yapmama, alım satım paritesi ve martingale koşullarını empoze etmektir.

Çözüm

Sürekli zaman çerçevesi yapısal olarak doğrudur: Piyasalar ayrı, düzensiz zamanlarda gözlemlenen sürekli süreçlerdir ve modellerin buna uyması gerekir. Araç zinciri olgunlaşmıştır — torchdiffeq, torchsde, geri kalanı için düz PyTorch — ve bilinen maliyetler, uzun entegrasyon aralıkları boyunca çözücü hızı ve sayısal kararlılıktır.

Bunlardan herhangi birinin bir üretim yığınına ait olup olmadığına karar veren kısım henüz belirlenmedi. Yapısal doğruluk, tahmin avantajının kanıtı değildir ve sürekli dinamikler için $\log(\Delta t)$ özelliğine göre iddia edilen spesifik avantaj, burada gerçek ticaret verileri üzerinde ölçülmemiştir. Yukarıdaki H2 tablosu dolduruluncaya kadar, ekranın altındaki her şeye, bir sonuç olarak değil, çalışan bir uygulama eklenmiş, iyi tanımlanmış bir hipotez olarak davranın.

Referanslar

• Chen, R.T.Q., Rubanova, Y., Bettencourt, J., Duvenaud, D. (2018). Nöral Adi Diferansiyel Denklemler. NeurIPS 2018. arXiv:1806.07366
• Rubanova, Y., Chen, R.T.Q., Duvenaud, D. (2019). Düzensiz Örneklenmiş Zaman Serileri için Gizli ODE'ler. NeurIPS 2019. arXiv:1907.03907
• Jia, J., Benson, A.R. (2019). Nöral Sıçrama Stokastik Diferansiyel Denklemler. NeurIPS 2019.
• Kidger, P., Morrill, J., Foster, J., Lyons, T. (2020). Düzensiz Zaman Serileri için Sinir Kontrollü Diferansiyel Denklemler. NeurIPS 2020.
• Hasan, A., Pereira, J.M., Farsiu, S., Carin, L. (2021). Finansal Veri Tahminine Yönelik Uygulamalarla Sinir Ağı Stokastik Diferansiyel Denklem Modelleri. arXiv:2111.13164
• torchdiffeq: github.com/rtqichen/torchdiffeq
• UvA Derin Öğrenme Eğitimleri — Nöral ODE'ler: uvadlc-notebooks.readthedocs.io