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

Neural Ordinary Differential Equations (Chen et al., NeurIPS 2018) memparameterkan terbitan keadaan tersembunyi dengan rangkaian neural dan membiarkan solver ODE mengira output. Model menjadi continuous-depth dan, lebih berguna untuk pasaran, continuous-time: keadaan tersembunyi boleh dinilai pada sebarang $t$, bukan hanya pada titik grid tempat data anda kebetulan berada.

Sifat ini jelas menarik untuk data kewangan yang tiba pada sela rawak. Namun tarikan itu menyembunyikan tuntutan yang jauh lebih lemah daripada yang kelihatan. GRU biasa yang diberi ciri input tambahan — $log(\Delta t)$ sejak pemerhatian sebelumnya — juga "tahu" berapa lama masa telah berlalu. Persoalan sebenar bukan sama ada model continuous-time boleh menerima data tidak sekata. Persoalannya ialah sama ada dinamik berterusan yang dipelajari antara pemerhatian mengekstrak sesuatu yang belum diberikan oleh ciri delta-time, dengan kos inferens sepuluh hingga seratus kali lebih tinggi.

Artikel ini menyediakan eksperimen tersebut, memberikan seluruh toolchain untuk menjalankannya, dan menerangkan perkara yang perlu ditunjukkan oleh perbandingan agar machinery ini wajar digunakan. Sisi hujah pembinaan bar — bahawa masa dagangan sendiri membawa isyarat — telah dibuktikan dengan bukti terukur pada 17 jenis bar dalam melampaui bar masa; akibat pemodelan yang penting di sini hanya satu: solver menilai keadaan tersembunyi pada $t$ sewenang-wenangnya, jadi interpolasi atau padding tidak diperlukan.

Tuntutan yang Diuji

Tiga hipotesis bersarang, setiap satunya lebih kuat daripada yang sebelumnya:

1. H1 — ODE-RNN yang dipasang pada raw irregular BTC trade stream mengatasi GRU yang dipasang pada stream sama tanpa sebarang maklumat masa. Ini hampir pasti dan hampir tidak berguna: ODE-RNN sekadar memiliki maklumat yang tiada pada baseline.
2. H2 — ODE-RNN mengatasi GRU sama selepas GRU diberi $log(\Delta t)$ sebagai input feature. Inilah ujian yang jujur. Inilah tuntutan yang biasanya difahami daripada literatur Neural ODE, dan hampir tidak pernah ditunjukkan pada data kewangan.
3. H3 — Kelebihan H2 bertahan dalam latency budget, iaitu tetap berlaku apabila ODE-RNN digunakan dengan fixed-step solver yang cukup pantas untuk live inference, bukannya dopri5 adaptif.

Protokol Eksperimen

Tick stream yang sama, sasaran yang sama, dan tuning budget yang sama untuk kedua-dua arm. Jangan resample kepada bar 1m — resampling memusnahkan struktur tepat yang sedang diuji.

Keputusan negatif pada H2 sepenuhnya layak diterbitkan dan mungkin merupakan hasil yang lebih bernilai — standard yang sama digunakan dalam keputusan negatif yang jujur dan Sharpe terdeflasi di bawah multiple testing.

Eksperimen Sekunder: CNF berbanding Student-t

Jika perbandingan ODE-RNN terlalu mahal, sauh empirikal yang lebih murah bersifat distributif: pasangkan continuous normalizing flow pada pulangan harian BTC sebenar dan bandingkan density yang dipasang dengan fit Student-t serta ekor empirikal, lalu laporkan ralat tail-quantile pada tahap 1% dan 5%. Ini berkait terus dengan kerja distributif yang telah diukur dalam ramalan volatiliti GARCH dan GARCH tidak simetri.

Selebihnya artikel ini ialah latar belakang dan toolchain yang diperlukan untuk menjalankan perkara di atas.

Latar Belakang: Daripada ResNet kepada Dinamik Berterusan

Rangkaian residual mengira $h_{t+1} = h_t + f(h_t, \theta_t)$. Kecilkan saiz langkah dan tingkatkan bilangan layer, maka anda menghampiri had berterusan:

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

Daripada $T$ layer diskret dengan parameter berasingan, satu network $f$ menentukan kadar perubahan serta-merta. Output pada masa $T$ menyelesaikan masalah nilai awal:

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

Black-box solver (Euler, Runge-Kutta, Dormand-Prince) mengira kamiran secara berangka dan memilih saiz langkah secara adaptif daripada anggaran ralat setempat.

Kaedah Adjoint

Backpropagation melalui setiap langkah solver menyimpan semua state perantaraan, dengan kos memori berkadar dengan bilangan langkah. Sebaliknya Chen et al. menyelesaikan ODE ke belakang dengan memori $O(1)$. Takrifkan state adjoint $a(t) = -\partial L / \partial h(t)$, yang memenuhi

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

dan kumpulkan gradient parameter sepanjang backward pass:

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

Backward pass menyelesaikan sistem augmented yang mengira $h(t)$, $a(t)$ dan $dL/d\theta$ serentak, dengan menjalankan solver secara songsang dari $T$ ke $0$.

Trade-offnya: membina semula $h(t)$ secara songsang mengumpulkan ralat berangka, khususnya untuk dinamik stiff atau chaotic. Checkpointing ialah jalan tengah — simpan $h(t)$ pada beberapa masa perantaraan dan kira semula di antaranya. Price process ialah continuous semimartingale dan agak smooth, jadi adjoint biasanya bertahan; stiffness sekitar peristiwa microstructure mungkin memaksa solver adaptif atau hybrid.

ODE-RNN: Keadaan Tersembunyi Berterusan antara Pemerhatian

ODE-RNN ialah architecture yang menjadi asas eksperimen utama. Antara pemerhatian, keadaan tersembunyi berkembang mengikut ODE:

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

Apabila pemerhatian $x_{i+1}$ tiba pada $t_{i+1}$, discrete update dijalankan:

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

Superskrip menunjukkan state tepat sebelum dan selepas pemerhatian. Antara pemerhatian terdapat continuous dynamics yang dipelajari; pada pemerhatian, maklumat baharu masuk.

Mekanisme yang diuji oleh ablation H2 ialah ini: jurang panjang bermaksud keadaan tersembunyi telah berkembang jauh di bawah $f_\theta$ — mereput menuju baseline atau menyimpang — dan bentuk evolusi itu dipelajari, bukannya diberikan sebagai scalar. Sama ada ekspresiviti tersebut berbaloi dengan kosnya pada data trade sebenar ialah perkara yang belum diukur.

Padanan semula jadi di luar tick: portfolio multi-aset apabila setiap aset mempunyai jadual pemerhatian sendiri dan state laten aset berkorelasi terus berkembang sementara hanya satu aset diperhatikan; serta isyarat dipacu peristiwa (berita, earnings, keluaran makro) yang tiba pada masa tidak sekata.

Neural SDE: Menambah Komponen Stokastik

Neural ODE bersifat deterministik dan tidak dapat mewakili noise pada laluan harga. Perlakuan klasik — geometric Brownian motion, drift risk-neutral, dan cara andaian constant-volatility gagal menghadapi smile — dibincangkan dalam penentuan harga opsyen Black-Scholes. Neural SDE menggantikan bentuk parametrik dengan diffusion term yang dipelajari:

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

$f$ ialah drift, $g$ diffusion, $W(t)$ proses Wiener; kedua-dua $f$ dan $g$ ialah neural network.

Architecture: Drift Net dan Diffusion Net

• Drift net $f_\theta$: trajectory yang dijangka — trend, mean reversion, momentum. Dilatih untuk meminimumkan prediction error.
• Diffusion net $g_\phi$: magnitud noise, dipelajari sebagai fungsi state. Tinggi dalam regime volatil, rendah dalam keadaan tenang.

Pembahagian ini mencerminkan quant finance klasik: drift ialah dinamik risk-neutral (atau P-measure), diffusion ialah volatility surface.

Melatih Neural SDE

Kamiran stokastik $\int g\,dW$ tidak boleh dibezakan secara klasik. Terdapat tiga pendekatan:

1. Pathwise gradients: reparameterization trick — sample laluan Brownian, kemudian bezakan melalui solver dengan noise sebagai input tetap.
2. Score matching: anggar $\nabla_h \log p(h)$ dan latih melalui denoising objective — machinery yang sama digunakan sebagai generative model kendiri dalam model diffusion untuk ramalan kripto, tetapi di sini menjadi pilihan training untuk SDE.
3. Finite-dimensional distribution matching: padankan marginal pada masa pemerhatian, bukannya keseluruhan path measure.

Pathwise ialah pilihan praktikal lalai. torchsde melaksanakan Euler-Maruyama, Milstein dan stochastic Runge-Kutta dengan sokongan autodiff.

Mempelajari Volatility Surface

Model klasik (Heston, SABR) mengenakan bentuk parametrik pada diffusion coefficient. Neural SDE mempelajari $g_\phi(S, t)$ sebagai fungsi arbitrari:

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

Ini ialah universal approximator untuk diffusion process — dengan kapasiti yang mencukupi, sebarang proses Ito boleh dihampiri dengan ketepatan sewenang-wenangnya.

Latent ODE untuk Data Hilang dan Tidak Segerak

Latent ODE (Rubanova, Chen, Duvenaud, 2019) menggabungkan Neural ODE dengan VAE: siri kewangan ialah pemerhatian bising bagi proses asas yang smooth, dipelajari dalam ruang laten berdimensi rendah.

1. Recognition network: ODE-RNN yang bergerak ke belakang melalui pemerhatian untuk menghasilkan $q(z_0 | x_{1:N})$.
2. Latent dynamics: $z(t) = z(t_0) + \int_{t_0}^{t} f_\theta(z(s), s)\, ds$.
3. Decoder: $\hat{x}(t) = \text{Decoder}(z(t))$, boleh dinilai pada bila-bila masa yang diminta.

Loss ialah ELBO standard:

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

Anggaran state portfolio: daripada pemerhatian tidak segerak yang jarang merentasi banyak aset, infer continuous latent state yang menangkap joint dynamics — pada asasnya versi nonlinear dan learned bagi penapis Kalman.

Imputasi data hilang: halt dan jurang hujung minggu memperoleh latent trajectory yang diinterpolasi dengan lancar; decoder menghasilkan laluan yang munasabah melalui jurang dengan ketidakpastian daripada posterior VAE.

Fusi pelbagai frekuensi: daily close, VWAP intraday dan data tick dalam satu model tanpa shared time grid.

Continuous Normalizing Flow untuk Agihan Pulangan

CNF menggunakan Neural ODE untuk mengubah agihan asas yang mudah menjadi sasaran yang kompleks. Transformasinya ialah $\frac{dz(t)}{dt} = f(z(t), t, \theta)$, dan log-density mengikut instantaneous change of variables:

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

Integrasikan state dan log-density ke hadapan daripada $z(0) \sim p_0$ untuk mendapatkan $z(T)$ dan $\log p(z(T))$. Jejak Jacobian dianggar dengan stochastic estimator Hutchinson supaya boleh diskalakan.

Pulangan kripto bersifat leptokurtik dan condong negatif — diukur pada data sebenar dalam ramalan volatiliti GARCH dan GARCH tidak simetri serta kesan leverage — dan CNF mempelajari bentuk tersebut dan bukannya menganggapnya. Mengondisikan flow pada state variable membolehkan bentuk berubah mengikut regime. Oleh sebab density adalah exact, bukan approximate, ia boleh memberi input kepada tail metric yang dikira dalam Monte Carlo dan bootstrap backtest serta pembinaan CVaR dalam pipeline portfolio HRP/CVaR; joint tail structure dikendalikan secara berasingan dalam model copula untuk risiko bersama.

Anggaran Density Bersyarat

Framing yang berguna ialah kontras langsung antara tiga pendekatan yang telah diterbitkan untuk masalah sama. TFT memberikan set quantile tetap daripada quantile output layer. Conformal prediction memberikan interval yang ditentukur dengan coverage guarantee. Conditional CNF memberikan density yang exact dan differentiable:

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

Differentiability ialah sifat yang membezakannya: density boleh berada dalam downstream objective dan di-backpropagate melaluinya, sesuatu yang tidak disokong oleh fixed quantile mahupun conformal interval. Sama ada density exact berbaloi dengan kosnya berbanding TFT quantile pada sasaran yang sama belum diuji di sini.

Perbandingan dengan Alternatif Diskret

Bahagian LSTM-versus-attention dalam jadual ini dibincangkan dengan terperinci, bersama benchmark, dalam artikel TFT — lihat bahagian "TFT vs LSTM vs Vanilla Transformer" dan "When LSTM Still Wins". Lajur baharu di sini ialah dua lajur di sebelah kanan, manakala baris yang menentukan persoalan H2/H3 ialah dua baris terakhir.

Pelaksanaan Python dengan torchdiffeq

torchdiffeq menyediakan ODE solver dengan adjoint backpropagation.

Neural ODE Asas untuk Price Dynamics

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)

ODE-RNN untuk Data Tick Tidak Sekata

Ini ialah arm eksperimen. Baseline yang perlu dikalahkan ialah nn.GRUCell pada stream sama dengan log(t_next - t_prev) digabungkan ke x.

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)

Kitaran Latihan

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

Continuous Normalizing Flow untuk Agihan Pulangan

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]

Nota Praktikal

Inilah perkara yang akan menyusahkan anda ketika menjalankan eksperimen di atas.

Pilihan Solver dan Kelajuan

dopri5 memberikan jaminan ketepatan tetapi kos pengiraan berubah-ubah, sebab itu H3 ialah hipotesis yang berasingan daripada H2: edge yang hanya wujud di bawah solver adaptif mungkin tidak bertahan dalam live latency budget. Fixed-step solver (Euler, RK4) memberikan latency yang boleh diramal dengan mengorbankan ketepatan. Kompromi praktikal: training dengan dopri5, deployment dengan fixed-step solver yang ditentukur untuk memadankan output solver adaptif pada data yang mewakili — dan ukur jurang tersebut dan bukannya menganggapnya kecil.

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

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

Untuk masalah stiff berhampiran lompatan tidak selanjar, gunakan method='implicit_adams' atau method='scipy_solver'.

Kestabilan Berangka

Jika $f_\theta$ menghasilkan nilai besar, state akan menyimpang. Mitigasinya:

• Spectral normalization pada layer $f_\theta$ untuk mengawal pemalar Lipschitz.
• Gradient clipping semasa training (ditunjukkan dalam training loop di atas).
• Time normalization: skala timestamp kepada $[0, 1]$.
• Regularisasi pada dynamics norm: tambah $\lambda \|f_\theta(h, t)\|^2$ kepada loss.

Sela Integrasi

Untuk data yang merangkumi berbulan-bulan, jangan integrasikan dari $t = 0$ hingga $t = 10{,}000$ minit:

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

Ini mengekalkan solver dalam regime yang mesra secara berangka dan menjadikan dynamics yang dipelajari scale-invariant. Ia juga penting untuk perbandingan: ODE-RNN yang tidak dinormalisasi boleh kalah kepada baseline GRU atas sebab berangka semata-mata, yang akan menjadi measurement artifact dan bukannya finding.

Mengendalikan Pelbagai Skala Masa

Pasaran mempunyai dinamik pada skala mikrosaat, saat, minit dan harian serentak, dan satu Neural ODE mungkin sukar menampung semuanya. Pilihan yang ada: susun beberapa ODE block pada skala masa berbeza; besarkan hidden dimension untuk kapasiti pantas dan perlahan; atau jalankan Neural ODE berasingan bagi setiap frequency band lalu gabungkan output. (Ini persoalan model capacity, berbeza daripada persoalan backtest fidelity dalam adaptive resolution drill-down.)

Arah Penyelidikan Terbuka

Neural Jump SDE: tambah jump component yang dipelajari untuk dislocation mendadak (flash crash, kejutan earnings):

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

di mana $\tilde{N}$ ialah compensated Poisson random measure dan $\gamma$ ialah jump kernel yang dipelajari.

Neural Controlled Differential Equations (Neural CDE): gantikan proses Wiener dengan general driving signal, supaya observed data stream boleh menggerakkan dynamics. Ini semula jadi untuk order flow, tempat stream trade dan quote menggerakkan latent market state.

Differentiable Market Simulation: gunakan Neural SDE sebagai generative model di dalam differentiable simulator dan latih strategy end-to-end dengan backpropagate melaluinya melalui adjoint. Strategy dan market model berkembang bersama.

Physics-Informed Neural ODE: PINN menanam differential-equation residual ke dalam loss — teknik itu sendiri diperkenalkan dalam artikel Navier-Stokes. Aplikasi kewangannya ialah mengenakan no-arbitrage, put-call parity dan martingale condition sebagai penalty term atau hard constraint pada dynamics yang dipelajari.

Kesimpulan

Framing continuous-time adalah betul dari segi struktur: pasaran ialah proses berterusan yang diperhatikan pada masa diskret dan tidak sekata, dan model sepatutnya menghormatinya. Toolchain telah matang — torchdiffeq, torchsde, plain PyTorch untuk selebihnya — dan kos yang diketahui ialah kelajuan solver serta numerical stability pada sela integrasi yang panjang.

Yang belum ditetapkan ialah bahagian yang menentukan sama ada semua ini patut masuk ke production stack. Structural correctness bukan bukti predictive advantage, dan kelebihan khusus yang didakwa untuk continuous dynamics berbanding ciri $\log(\Delta t)$ belum diukur pada data trade sebenar di sini. Sehingga jadual H2 di atas diisi, anggap semua bahagian di bawah fold sebagai hipotesis yang dispesifikasikan dengan baik dan disertakan implementasi yang berfungsi, bukannya hasil.

Rujukan

• Chen, R.T.Q., Rubanova, Y., Bettencourt, J., Duvenaud, D. (2018). Neural Ordinary Differential Equations. NeurIPS 2018. arXiv:1806.07366
• Rubanova, Y., Chen, R.T.Q., Duvenaud, D. (2019). Latent ODEs for Irregularly-Sampled Time Series. NeurIPS 2019. arXiv:1907.03907
• Jia, J., Benson, A.R. (2019). Neural Jump Stochastic Differential Equations. NeurIPS 2019.
• Kidger, P., Morrill, J., Foster, J., Lyons, T. (2020). Neural Controlled Differential Equations for Irregular Time Series. NeurIPS 2020.
• Hasan, A., Pereira, J.M., Farsiu, S., Carin, L. (2021). Neural Network Stochastic Differential Equation Models with Applications to Financial Data Forecasting. arXiv:2111.13164
• torchdiffeq: github.com/rtqichen/torchdiffeq
• UvA Deep Learning Tutorials — Neural ODEs: uvadlc-notebooks.readthedocs.io