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

Neural Ordinary Differential Equations (Chen et al., NeurIPS 2018) memparameterkan turunan suatu hidden state dengan jaringan saraf dan membiarkan solver ODE menghitung output. Model menjadi continuous-depth dan, yang lebih berguna untuk pasar, continuous-time: hidden state dapat dievaluasi pada sembarang $t$, bukan hanya pada titik grid tempat data Anda kebetulan berada.

Sifat ini memiliki daya tarik yang jelas untuk data finansial yang tiba pada interval acak. Namun daya tarik itu menyembunyikan klaim yang jauh lebih lemah daripada yang terlihat. GRU biasa yang diberi fitur input tambahan — $\log(\Delta t)$ sejak observasi sebelumnya — juga "tahu" berapa lama waktu telah berlalu. Pertanyaan sebenarnya bukan apakah model continuous-time dapat menerima data tidak teratur. Pertanyaannya adalah apakah dinamika kontinu yang dipelajari di antara observasi mengekstrak sesuatu yang belum diberikan fitur delta-time, dengan biaya inferensi sepuluh hingga seratus kali lebih besar.

Artikel ini menyiapkan eksperimen tersebut, memberikan seluruh toolchain untuk menjalankannya, dan menjelaskan apa yang harus ditunjukkan perbandingan agar machinery ini layak digunakan. Sisi argumen konstruksi bar — bahwa waktu perdagangan sendiri membawa sinyal — telah ditetapkan dengan bukti terukur pada 17 jenis bar dalam beyond time bars; konsekuensi pemodelan yang penting di sini hanya satu: solver mengevaluasi hidden state pada $t$ sembarang, sehingga tidak diperlukan interpolasi atau padding.

Klaim yang Diuji

Tiga hipotesis bertingkat, masing-masing lebih kuat daripada yang sebelumnya:

1. H1 — ODE-RNN yang di-fit pada raw irregular BTC trade stream mengalahkan GRU yang di-fit pada stream yang sama tanpa time information sama sekali. Ini hampir pasti dan hampir tidak berguna: ODE-RNN sekadar memiliki informasi yang tidak dimiliki baseline.
2. H2 — ODE-RNN mengalahkan GRU yang sama setelah GRU diberi $\log(\Delta t)$ sebagai input feature. Inilah pengujian yang jujur. Inilah klaim yang biasanya dipahami dari literatur Neural ODE, dan hampir tidak pernah didemonstrasikan pada data finansial.
3. H3 — Keunggulan H2 bertahan dalam latency budget, yaitu tetap berlaku ketika ODE-RNN digunakan dengan fixed-step solver yang cukup cepat untuk live inference, bukan adaptive dopri5.

Protokol Eksperimen

Stream tick yang sama, target yang sama, dan tuning budget yang sama untuk kedua arm. Jangan resample menjadi bar 1m — resampling menghancurkan struktur persis yang sedang diuji.

Hasil negatif pada H2 sepenuhnya layak dipublikasikan dan mungkin merupakan hasil yang lebih bernilai — standar yang sama diterapkan dalam hasil negatif yang jujur dan deflated Sharpe di bawah multiple testing.

Eksperimen Sekunder: CNF vs Student-t

Jika perbandingan ODE-RNN terlalu mahal, anchor empiris yang lebih murah bersifat distribusional: fit continuous normalizing flow pada return harian BTC nyata dan bandingkan density hasil fit dengan fit Student-t serta empirical tail, lalu laporkan error tail-quantile pada level 1% dan 5%. Ini terhubung langsung dengan pekerjaan distribusional yang telah diukur dalam GARCH volatility forecasting dan asymmetric GARCH.

Bagian artikel selanjutnya adalah background dan toolchain yang diperlukan untuk menjalankan eksperimen di atas.

Latar Belakang: Dari ResNet ke Dinamika Kontinu

Residual network menghitung $h_{t+1} = h_t + f(h_t, \theta_t)$. Kecilkan step size dan perbesar jumlah layer, maka Anda mendekati limit kontinu:

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

Alih-alih $T$ layer diskret dengan parameter terpisah, satu network $f$ menentukan laju perubahan sesaat. Output pada waktu $T$ menyelesaikan initial value problem:

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

Black-box solver (Euler, Runge-Kutta, Dormand-Prince) menghitung integral secara numerik dan memilih step size secara adaptif dari local error estimate.

Metode Adjoint

Backpropagation melalui setiap solver step menyimpan seluruh intermediate state, dengan biaya memori sebanding dengan jumlah step. Chen et al. sebagai gantinya menyelesaikan ODE mundur dengan memory $O(1)$. Definisikan adjoint state $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 akumulasikan gradient parameter selama 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 augmented system yang menghitung $h(t)$, $a(t)$, dan $dL/d\theta$ secara bersamaan, dengan menjalankan solver mundur dari $T$ ke $0$.

Trade-off-nya: merekonstruksi $h(t)$ secara mundur mengakumulasi numerical error, terutama untuk dinamika stiff atau chaotic. Checkpointing adalah jalan tengah — simpan $h(t)$ pada beberapa waktu antara dan hitung ulang di antaranya. Price process adalah continuous semimartingale dan cukup smooth, sehingga adjoint umumnya bertahan; stiffness di sekitar microstructure event dapat memaksa adaptive solver atau hybrid.

ODE-RNN: Hidden State Kontinu di Antara Observasi

ODE-RNN adalah architecture yang menjadi dasar eksperimen utama. Di antara observasi, hidden state berevolusi menurut ODE:

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

Ketika observasi $x_{i+1}$ tiba pada $t_{i+1}$, discrete update dijalankan:

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

Superscript menunjukkan state tepat sebelum dan sesudah observasi. Di antara observasi terdapat continuous dynamics yang dipelajari; pada observasi masuk informasi baru.

Mekanisme yang diuji oleh ablation H2 adalah ini: gap panjang berarti hidden state telah berevolusi jauh di bawah $f_\theta$ — meluruh menuju baseline atau divergen — dan bentuk evolusi itu dipelajari, bukan diberikan sebagai scalar. Apakah ekspresivitas tersebut sepadan dengan biayanya pada trade data nyata adalah hal yang belum diukur.

Fit alami di luar tick: portfolio multi-aset ketika setiap aset memiliki jadwal observasi sendiri dan latent state aset berkorelasi terus berevolusi sementara hanya satu aset yang diamati; serta sinyal event-driven (berita, earnings, rilis makro) yang tiba pada waktu tidak teratur.

Neural SDE: Menambahkan Komponen Stokastik

Neural ODE bersifat deterministik dan tidak dapat merepresentasikan noise pada price path. Perlakuan klasik — geometric Brownian motion, risk-neutral drift, dan cara asumsi constant-volatility gagal menghadapi smile — dibahas dalam Black-Scholes options pricing. Neural SDE mengganti bentuk parametrik dengan diffusion term yang dipelajari:

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

$f$ adalah drift, $g$ diffusion, $W(t)$ Wiener process; $f$ dan $g$ keduanya neural network.

Arsitektur: Drift Net dan Diffusion Net

• Drift net $f_\theta$: trajectory yang diharapkan — trend, mean reversion, momentum. Dilatih untuk meminimalkan prediction error.
• Diffusion net $g_\phi$: magnitudo noise, dipelajari sebagai fungsi dari state. Tinggi pada regime volatil, rendah pada regime tenang.

Pembagian ini mencerminkan quant finance klasik: drift adalah dinamika risk-neutral (atau P-measure), diffusion adalah volatility surface.

Melatih Neural SDE

Stochastic integral $\int g\,dW$ tidak terdiferensiasi secara klasik. Ada tiga pendekatan:

1. Pathwise gradients: reparameterization trick — sample Brownian path, lalu diferensiasikan melalui solver dengan noise sebagai input tetap.
2. Score matching: estimasikan $\nabla_h \log p(h)$ dan latih melalui denoising objective — machinery yang sama digunakan sebagai generative model mandiri dalam diffusion models untuk prediksi kripto, di sini diturunkan menjadi pilihan training untuk SDE.
3. Finite-dimensional distribution matching: cocokkan marginal pada waktu observasi, bukan seluruh path measure.

Pathwise adalah default praktis. torchsde mengimplementasikan Euler-Maruyama, Milstein, dan stochastic Runge-Kutta dengan autodiff support.

Mempelajari Volatility Surface

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

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

Ini adalah universal approximator untuk diffusion process — dengan kapasitas yang cukup, proses Ito apa pun dapat didekati dengan akurasi arbitrer.

Latent ODE untuk Data Hilang dan Asinkron

Latent ODE (Rubanova, Chen, Duvenaud, 2019) memasangkan Neural ODE dengan VAE: financial series adalah observasi bising dari proses dasar yang smooth, dipelajari dalam latent space berdimensi rendah.

1. Recognition network: ODE-RNN yang berjalan mundur melalui observasi 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))$, dapat dievaluasi pada waktu apa pun yang diminta.

Loss-nya adalah ELBO standar:

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

Portfolio state estimation: dari observasi asinkron yang sparse pada banyak aset, infer continuous latent state yang menangkap joint dynamics — pada dasarnya versi nonlinear dan learned dari Kalman filter.

Imputasi data hilang: halt dan gap akhir pekan memperoleh latent trajectory yang diinterpolasi mulus; decoder menghasilkan path masuk akal melalui gap dengan uncertainty dari posterior VAE.

Fusion multi-frekuensi: daily close, intraday VWAP, dan tick data dalam satu model tanpa shared time grid.

Continuous Normalizing Flow untuk Distribusi Return

CNF menggunakan Neural ODE untuk mengubah base distribution sederhana menjadi target kompleks. Transformasinya adalah $\frac{dz(t)}{dt} = f(z(t), t, \theta)$, dan log-density mengikuti 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 depan dari $z(0) \sim p_0$ untuk memperoleh $z(T)$ dan $\log p(z(T))$. Jacobian trace diestimasi dengan stochastic estimator Hutchinson agar dapat diskalakan.

Return kripto bersifat leptokurtic dan skew negatif — diukur pada data nyata dalam GARCH volatility forecasting dan asymmetric GARCH serta leverage effect — dan CNF mempelajari bentuk tersebut alih-alih mengasumsikannya. Mengondisikan flow pada state variable memungkinkan bentuk berubah menurut regime. Karena density bersifat exact, bukan approximate, ia dapat memberi input pada tail metric yang dihitung dalam Monte Carlo dan bootstrap backtest serta construction CVaR dalam pipeline portfolio HRP/CVaR; joint tail structure ditangani secara terpisah dalam copula models untuk joint risk.

Estimasi Density Kondisional

Framing yang berguna adalah kontras langsung antara tiga pendekatan yang telah dipublikasikan untuk masalah yang sama. TFT memberi sekumpulan quantile tetap dari quantile output layer. Conformal prediction memberi interval terkalibrasi dengan coverage guarantee. Conditional CNF memberi density yang exact dan differentiable:

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

Differentiability adalah sifat pembeda: density dapat berada di dalam downstream objective dan di-backpropagate melaluinya, sesuatu yang tidak didukung oleh fixed quantile maupun conformal interval. Apakah density exact sepadan dengan biayanya dibanding TFT quantile pada target yang sama belum diuji di sini.

Perbandingan dengan Alternatif Diskret

Bagian LSTM-versus-attention pada tabel ini dibahas detail dengan benchmark dalam artikel TFT — lihat bagian "TFT vs LSTM vs Vanilla Transformer" dan "When LSTM Still Wins". Kolom baru di sini adalah dua kolom di kanan, sementara baris penentu pertanyaan H2/H3 adalah dua baris terakhir.

Implementasi Python dengan torchdiffeq

torchdiffeq menyediakan ODE solver dengan adjoint backpropagation.

Neural ODE Dasar 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 Teratur

Ini adalah experimental arm. Baseline yang harus dikalahkan adalah nn.GRUCell pada stream yang 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)

Siklus Pelatihan

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 Distribusi Return

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]

Catatan Praktis

Inilah hal-hal yang akan menyulitkan Anda saat menjalankan eksperimen di atas.

Pilihan Solver dan Kecepatan

dopri5 memberikan jaminan akurasi tetapi biaya komputasinya bervariasi, itulah sebabnya H3 adalah hipotesis terpisah dari H2: edge yang hanya ada di bawah adaptive solver mungkin tidak bertahan dalam live latency budget. Fixed-step solver (Euler, RK4) memberikan latency yang dapat diprediksi dengan mengorbankan akurasi. Kompromi praktis: training dengan dopri5, deployment dengan fixed-step solver yang dikalibrasi agar output-nya cocok dengan adaptive solver pada data representatif — dan ukur gap tersebut alih-alih 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 di dekat lompatan diskret, gunakan method='implicit_adams' atau method='scipy_solver'.

Stabilitas Numerik

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

• Spectral normalization pada layer $f_\theta$ untuk mengendalikan Lipschitz constant.
• Gradient clipping selama training (ditunjukkan dalam training loop di atas).
• Time normalization: scale timestamp ke $[0, 1]$.
• Regularisasi pada dynamics norm: tambahkan $\lambda \|f_\theta(h, t)\|^2$ ke loss.

Interval Integrasi

Untuk data yang mencakup berbulan-bulan, jangan mengintegrasikan dari $t = 0$ hingga $t = 10{,}000$ menit:

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

Ini menjaga solver dalam regime yang ramah secara numerik dan membuat dynamics yang dipelajari scale-invariant. Ini juga penting untuk perbandingan: ODE-RNN yang tidak dinormalisasi dapat kalah dari GRU baseline semata-mata karena alasan numerik, yang akan menjadi measurement artifact, bukan finding.

Menangani Banyak Skala Waktu

Pasar memiliki dinamika pada skala mikrodetik, detik, menit, dan harian sekaligus, dan satu Neural ODE mungkin kesulitan menampung semuanya. Pilihan yang tersedia: susun beberapa ODE block pada skala waktu berbeda; perbesar hidden dimension untuk kapasitas cepat maupun lambat; atau jalankan Neural ODE terpisah per frequency band lalu gabungkan output. (Ini adalah pertanyaan tentang model capacity, berbeda dari pertanyaan backtest fidelity dalam adaptive resolution drill-down.)

Arah Riset Terbuka

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

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

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

Neural Controlled Differential Equations (Neural CDE): ganti Wiener process dengan general driving signal, sehingga observed data stream dapat menggerakkan dynamics. Ini alami 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 via adjoint. Strategy dan market model berevolusi bersama.

Physics-Informed Neural ODE: PINN menanamkan differential-equation residual ke dalam loss — tekniknya diperkenalkan dalam artikel Navier-Stokes. Aplikasi finansialnya adalah menerapkan no-arbitrage, put-call parity, dan martingale condition sebagai penalty term atau hard constraint pada dynamics yang dipelajari.

Kesimpulan

Framing continuous-time benar secara struktural: pasar adalah proses kontinu yang diamati pada waktu diskret dan tidak teratur, dan model seharusnya menghormati hal itu. Toolchain telah matang — torchdiffeq, torchsde, plain PyTorch untuk sisanya — dan biaya yang diketahui adalah kecepatan solver serta numerical stability pada interval integrasi panjang.

Yang belum ditetapkan adalah bagian yang menentukan apakah semua ini layak masuk production stack. Structural correctness bukan bukti predictive advantage, dan specific advantage yang diklaim continuous dynamics dibanding fitur $\log(\Delta t)$ belum diukur pada trade data nyata di sini. Sampai tabel H2 di atas diisi, anggap semua bagian di bawah sebagai hipotesis yang telah dispesifikasikan dengan baik dan dilengkapi implementasi yang berfungsi, bukan sebagai hasil.

Referensi

• 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