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

Neurale gewone differentiaalvergelijkingen (Chen et al., NeurIPS 2018) parametriseren de afgeleide van een verborgen toestand met een neuraal netwerk en laten een ODE-oplosser de uitvoer berekenen. Het model wordt continu-diepte en, wat nuttiger is voor markten, continu-tijd: de verborgen toestand kan op elk gewenst moment worden geëvalueerd, niet alleen op de rasterpunten waarop uw gegevens zich bevinden.

Die eigenschap heeft een duidelijke toon voor financiële gegevens, die met willekeurige tussenpozen binnenkomen. Maar het veld verbergt een veel zwakkere bewering dan het lijkt te maken. Een gewone GRU heeft een extra invoerfunctie gegeven – $\log(\Delta t)$ sinds de vorige observatie – ‘weet’ ook hoeveel tijd is verstreken. De echte vraag is niet of continue-tijdmodellen onregelmatige gegevens kunnen verwerken. Het gaat erom of de aangeleerde continue dynamiek tussen waarnemingen alles oplevert wat een delta-tijdkenmerk je nog niet biedt, tegen tien tot honderd keer de gevolgtrekkingskosten.

Dit artikel zet dat experiment op, geeft de volledige gereedschapsketen om het uit te voeren, en rapporteert wat de vergelijking zou moeten laten zien om de machinerie te rechtvaardigen. De staafconstructiekant van het argument – ​​dat de timing van de handel zelf een signaal draagt ​​– wordt vastgesteld met gemeten bewijsmateriaal over 17 staaftypes in [buiten de tijdsbalken] (/en/blog/post/beyond-time-bars-candle-construction); hier is de enige consequentie die ertoe doet een modellering: de oplosser evalueert de verborgen status op willekeurige $t$, dus er is geen interpolatie of opvulling nodig.

De claim die wordt getest

Drie geneste hypothesen, elk strikt sterker dan de vorige:

1. H1 — Een ODE-RNN-fit op een ruwe, onregelmatige BTC-handelsstroom verslaat een GRU-fit op dezelfde stream zonder enige tijdinformatie. Dit is vrijwel zeker en vrijwel waardeloos: de ODE-RNN beschikt eenvoudigweg over informatie die de basislijn ontbeert.
2. H2 — De ODE-RNN verslaat dezelfde GRU zodra de GRU $\log(\Delta t)$ als invoerfunctie krijgt. Dit is de eerlijke test. Het is de bewering die doorgaans wordt gelezen in de Neural ODE-literatuur, en die wordt bijna nooit aangetoond op basis van financiële gegevens.
3. H3 — Het H2-voordeel overleeft het latentiebudget, d.w.z. het blijft van kracht wanneer de ODE-RNN wordt ingezet met een oplosser met vaste stappen die snel genoeg is voor live gevolgtrekking in plaats van adaptieve dopri5.

Experimentprotocol

Dezelfde tick-stream, hetzelfde doel, hetzelfde afstemmingsbudget voor beide armen. Geen herbemonstering naar staven van 1 meter – herbemonstering vernietigt de exacte structuur die wordt getest.

Een negatief resultaat in de tweede helft van de tweede helft is volledig publiceerbaar en misschien wel de meest waardevolle uitkomst – dezelfde standaard toegepast in het eerlijke negatieve resultaat en deflatie van Sharpe onder meerdere tests.

Secundair experiment: CNF versus Student-t

Als de ODE-RNN-vergelijking te duur is, is het goedkopere empirische anker distributief: pas een continue normaliserende stroom toe op echte dagelijkse BTC-rendementen en vergelijk de gepaste dichtheid met een Student-t-fit en met de empirische staart, waarbij staartkwantielfouten worden gerapporteerd op de niveaus van 1% en 5%. Dat sluit rechtstreeks aan bij het verdelingswerk dat al is gemeten in GARCH-volatiliteitsvoorspellingen en asymmetrische GARCH.

De rest van dit artikel is de achtergrond en de toolchain die nodig is om het bovenstaande uit te voeren.

Achtergrond: van ResNets tot Continuous Dynamics

Een restnetwerk berekent $h_{t+1} = h_t + f(h_t, \theta_t)$. Verklein de stapgrootte en verhoog het aantal lagen en je nadert een continue limiet:

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

In plaats van $T$ discrete lagen met afzonderlijke parameters, specificeert een enkel netwerk $f$ de momentane veranderingssnelheid. De uitvoer op tijdstip $T$ lost een beginwaardeprobleem op:

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

Een black-box-oplosser (Euler, Runge-Kutta, Dormand-Prince) berekent de integraal numeriek en kiest adaptief stapgroottes uit lokale foutschattingen.

De adjunct-methode

Door elke oplosserstap terug te propageren worden alle tussenliggende toestanden opgeslagen, wat het geheugen evenredig aan het aantal stappen kost. Chen et al. los in plaats daarvan een achterwaartse ODE op met $O(1)$ geheugen. Definieer de adjunct-status $a(t) = -\partial L / \partial h(t)$, die voldoet

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

en accumuleer de parametergradiënt langs de achterwaartse pas:

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

De achterwaartse pass lost een uitgebreid systeem op dat $h(t)$, $a(t)$ en $dL/d\theta$ tegelijkertijd berekent, waarbij de oplosser in omgekeerde volgorde wordt uitgevoerd van $T$ naar $0$.

De wisselwerking: het achterwaarts reconstrueren van $h(t)$ leidt tot numerieke fouten, wat slecht is voor een stijve of chaotische dynamiek. Controlepunten zijn de middenweg: sla $h(t)$ op een paar tussenliggende tijdstippen op en bereken ze opnieuw. Prijsprocessen zijn continue semi-martingales en redelijk soepel, dus de adjoint houdt over het algemeen stand; stijfheid rond microstructuurgebeurtenissen kan adaptieve oplossers of hybriden dwingen.

ODE-RNN: Continue verborgen toestand tussen waarnemingen

De ODE-RNN is de architectuur waarop het hoofdexperiment draait. Tussen observaties evolueert de verborgen toestand onder de ODE:

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

Wanneer observatie $x_{i+1}$ aankomt op $t_{i+1}$, wordt er een discrete update geactiveerd:

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

De superscripts geven de toestand net voor en net na de waarneming aan. Tussen observaties door geleerde continue dynamiek; bij observaties, nieuwe informatie.

Het mechanisme dat de H2-ablatie onderzoekt is dit: een lange kloof betekent dat de verborgen toestand onder $f_\theta$ een lange weg heeft geëvolueerd – vervallend naar een basislijn, of divergerend – en de vorm van die evolutie wordt aangeleerd in plaats van als een scalair gegeven. Of die expressiviteit zichzelf terugbetaalt op basis van echte handelsgegevens, is precies wat niet wordt gemeten.

Natuurlijke aanpassingen die verder gaan dan maatstaven: portefeuilles met meerdere activa waarbij elk activum zijn eigen observatieschema heeft en de latente staat van gecorreleerde activa blijft evolueren terwijl er slechts één wordt geobserveerd; en gebeurtenisgestuurde signalen (nieuws, winstcijfers, macropublicaties) die op onregelmatige tijdstippen arriveren.

Neurale SDE's: stochastische componenten toevoegen

Neurale ODE's zijn deterministisch en kunnen niet de ruis in een prijspad vertegenwoordigen. De klassieke behandeling – geometrische Brownse beweging, risiconeutrale drift en de manieren waarop aannames over constante volatiliteit mislukken tegen de glimlach – wordt behandeld in [Black-Scholes optieprijzen] (/en/blog/post/black-scholes-options-pricing). Neurale SDE's vervangen de parametrische vorm door een aangeleerde diffusieterm:

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

$f$ is de drift, $g$ de diffusie, $W(t)$ een Wiener-proces, zowel $f$ als $g$ neurale netwerken.

Architectuur: driftnet en diffusienet

• Drift netto $f_\theta$: verwacht traject - trend, gemiddelde omkering, momentum. Getraind om voorspellingsfouten te minimaliseren.
• Diffusienet $g_\phi$: omvang van het geluid, geleerd als functie van de toestand. Hoog in vluchtige regimes, laag in rustige regimes.

De splitsing weerspiegelt de klassieke kwantitatieve financiering: drift is de risico-neutrale (of P-maatstaf) dynamiek, diffusie is het volatiliteitsoppervlak.

Neurale SDE's trainen

De stochastische integraal $\int g\,dW$ is klassiek niet differentieerbaar. Drie benaderingen:

1. Pathgewijze gradiënten: herparameterisatietruc: bemonster Brownse paden, differentieer door de oplosser die ruis als vaste invoer behandelt.
2. Scorematching: schat $\nabla_h \log p(h)$ en train via denoising-doelstellingen – dezelfde machine die wordt gebruikt als een zelfstandig generatief model in [diffusiemodellen voor crypto-voorspelling] (/en/blog/post/diffusion-models-cryptocurrency-prediction), hier gedegradeerd tot een trainingsoptie voor de SDE.
3. Eind-dimensionale verdelingsmatching: match marginalen op observatiemomenten in plaats van volledige padmetingen.

Pathwise is de praktische standaard. torchsde implementeert Euler-Maruyama, Milstein en stochastische Runge-Kutta met autodiff-ondersteuning.

Het vluchtigheidsoppervlak leren kennen

Klassieke modellen (Heston, SABR) leggen parametrische vormen op aan de diffusiecoëfficiënt. Een neurale SDE leert $g_\phi(S, t)$ als een willekeurige functie:

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

Dit is een universele benadering voor diffusieprocessen: elk Ito-proces heeft een willekeurige nauwkeurigheid, gegeven voldoende capaciteit. HOUDEN_42

Latente ODE's voor ontbrekende en asynchrone gegevens

De Latente ODE (Rubanova, Chen, Duvenaud, 2019) combineert een neurale ODE met een VAE: financiële reeksen zijn luidruchtige observaties van een soepel onderliggend proces, geleerd in een laagdimensionale latente ruimte.

1. Erkenningsnetwerk: een ODE-RNN die achteruit door waarnemingen loopt om $q(z_0 | x_{1:N})$ te produceren.
2. Latente dynamiek: $z(t) = z(t_0) + \int_{t_0}^{t} f_\theta(z(s), s)\, ds$.
3. Decoder: $\hat{x}(t) = \text{Decoder}(z(t))$, evalueerbaar op elk gewenst moment.

Het verlies is de standaard ELBO:

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

Schatting van de portefeuillestatus: leid uit schaarse asynchrone observaties van activa een continue latente toestand af die de gewrichtsdynamiek vastlegt - in wezen een niet-lineaire, aangeleerde versie van het Kalman-filter.

Ontbrekende data-imputatie: stops en weekendhiaten krijgen een soepel geïnterpoleerd latent traject; de decoder produceert plausibele paden door de opening met onzekerheid vanaf de VAE posterior.

Multi-frequentiefusie: dagelijkse sluitingen, intraday VWAP en tick-gegevens in één model zonder gedeeld tijdraster.

Continu normaliseren van stromen voor retourverdelingen

CNF's gebruiken een neurale ODE om een ​​eenvoudige basisdistributie om te zetten in een complex doelwit. De transformatie is $\frac{dz(t)}{dt} = f(z(t), t, \theta)$ en de logdichtheid volgt de onmiddellijke verandering van variabelen:

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

Integreer de status en logdichtheid vanaf $z(0) \sim p_0$ om $z(T)$ en $\log p(z(T))$ te verkrijgen. Het Jacobiaanse spoor wordt geschat met de stochastische schatter van Hutchinson voor schaalbaarheid.

Crypto-rendementen zijn leptokurtisch en negatief scheefgetrokken – gemeten op basis van echte gegevens in [GARCH-volatiliteitsvoorspellingen] (/en/blog/post/garch-volatility-forecasting-crypto) en [asymmetrische GARCH en het hefboomeffect] (/en/blog/post/asymmetric-garch-crypto-leverage) – en een CNF leert die vorm in plaats van deze aan te nemen. Door de stroom te conditioneren op basis van toestandsvariabelen kan de vorm veranderen met het regime. Omdat de dichtheid eerder exact dan bij benadering is, kan deze de staartstatistieken voeden die zijn berekend in [Monte Carlo en bootstrap backtests] (/en/blog/post/monte-carlo-bootstrap-backtest) en de CVaR-constructie in [de HRP/CVaR-portfoliopijplijn] (/en/blog/post/portfolio-pipeline-hrp-cvar); De gewrichtsstaartstructuur wordt afzonderlijk behandeld in copulamodellen voor gewrichtsrisico.

Schatting van de voorwaardelijke dichtheid

De bruikbare kadering vormt een direct contrast tussen drie gepubliceerde benaderingen van hetzelfde probleem. TFT geeft je een vaste set kwantielen uit een kwantieluitvoerlaag. Conformele voorspelling geeft u gekalibreerde intervallen met een dekkingsgarantie. Een voorwaardelijke CNF geeft u een exacte, differentieerbare dichtheid:

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

Differentieerbaarheid is de onderscheidende eigenschap: de dichtheid kan zich binnen een stroomafwaarts objectief bevinden en erdoor worden teruggepropageerd, wat noch vaste kwantielen, noch conforme intervallen ondersteunen. Of de exacte dichtheid de kosten waard is ten opzichte van TFT-kwantielen op hetzelfde doelwit, is hier niet getest. HOUDEN_43

Vergelijking met discrete alternatieven

De LSTM-versus-aandacht-helft van deze tabel wordt gedetailleerd beargumenteerd, met benchmarks, in het [TFT-artikel] (/en/blog/post/temporal-fusion-transformer-trading) – zie de secties "TFT vs LSTM vs Vanilla Transformer" en "When LSTM Still Wins". De kolommen die hier nieuw zijn, zijn de twee aan de rechterkant, en de rijen die de H2/H3-vragen bepalen, zijn de laatste twee.

Python-implementatie met torchdiffeq

torchdiffeq biedt ODE-oplossers met aanvullende backpropagatie.

Fundamentele neurale ODE voor prijsdynamiek

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 voor onregelmatige tekengegevens

Dit is de experimentele arm. De basislijn die het moet verslaan is nn.GRUCell op dezelfde stream met log(t_next - t_prev) samengevoegd tot 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)

Trainingslus

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

Continu normaliserende stroom voor retourverdelingen

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]

Praktische opmerkingen

Dit zijn de dingen die je zullen bijten tijdens het uitvoeren van het bovenstaande experiment.

Keuze en snelheid van de oplosser

dopri5 biedt nauwkeurigheidsgaranties maar variabele rekenkosten. Daarom is H3 een aparte hypothese van H2: een voorsprong die alleen bestaat onder een adaptieve oplosser, overleeft mogelijk een live latentiebudget niet. Oplossers met vaste stappen (Euler, RK4) zorgen voor een voorspelbare latentie ten koste van de nauwkeurigheid. Praktisch compromis: trainen met dopri5, implementeren met een oplosser met vaste stappen die is gekalibreerd om de uitvoer van de adaptieve oplosser op representatieve gegevens te evenaren - en de kloof te meten in plaats van aan te nemen dat deze klein is.

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

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

Voor stijve problemen bij discontinue sprongen, method='implicit_adams' of method='scipy_solver'.

Numerieke stabiliteit

Als $f_\theta$ grote waarden uitvoert, wijkt de toestand af. Maatregelen:

• Spectrale normalisatie op lagen van $f_\theta$ om de Lipschitz-constante te regelen.
• Gradient clipping tijdens de training (weergegeven in de trainingslus hierboven).
• Tijdnormalisatie: schaal tijdstempels naar $[0, 1]$.
• Regularisatie op dynamieknorm: voeg $\lambda \|f_\theta(h, t)\|^2$ toe aan het verlies.

Integratie-interval

Integreer gegevens van maanden niet van $t = 0$ tot $t = 10{,}000$ minuten:

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

Dit houdt de oplosser in een numeriek vriendelijk regime en maakt de geleerde dynamiek schaalinvariant. Het is ook van belang voor de vergelijking: een niet-genormaliseerde ODE-RNN kan om puur numerieke redenen verliezen ten opzichte van de GRU-basislijn, wat eerder een meetartefact dan een bevinding zou zijn.

Meerdere tijdschalen hanteren

Markten hebben een dynamiek op microseconde-, seconde-, minuut- en dagschaal tegelijk, en een enkele neurale ODE kan moeite hebben om ze allemaal vast te houden. Opties: stapel meerdere ODE-blokken op verschillende tijdschalen; breid de verborgen dimensie uit voor zowel snelle als langzame capaciteit; of voer afzonderlijke neurale ODE's uit per frequentieband en zekeringsuitgangen. (Dit is een vraag over de modelcapaciteit, verschillend van de backtest-getrouwheidsvraag in adaptieve resolutie drill-down.)

Open onderzoeksrichtingen

Neural Jump SDE's: voeg een aangeleerde jump-component toe voor plotselinge dislocaties (flitscrashes, winstverrassingen):

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

waarbij $\tilde{N}$ een gecompenseerde Poisson-willekeurige maat is en $\gamma$ een aangeleerde sprongkernel.

Neural Controlled Differential Equations (Neural CDEs): vervang het Wiener-proces door een algemeen stuursignaal, waardoor waargenomen datastromen de dynamiek kunnen aansturen. Natuurlijk voor de orderstroom, waarbij de stroom van transacties en offertes de latente markttoestand aandrijft.

Differentieerbare marktsimulatie: gebruik een neurale SDE als het generatieve model in een differentieerbare simulator en train strategieën end-to-end door er doorheen te propageren via de adjoint. Strategie en marktmodel evolueren samen.

Natuurkundig geïnformeerde neurale ODE's: PINN's integreren een differentiaalvergelijkingsresidu in het verlies - de techniek zelf wordt geïntroduceerd in [het Navier-Stokes-artikel] (/en/blog/post/navier-stokes-problem). De financiële toepassing is het opleggen van no-arbitrage, put-call-pariteit en martingaalvoorwaarden als straftermen of harde beperkingen aan de aangeleerde dynamiek.

Conclusie

Het continue tijdkader is structureel correct: markten zijn continue processen die op discrete, onregelmatige tijdstippen worden waargenomen, en modellen moeten dat respecteren. De toolchain is volwassen – torchdiffeq, torchsde, gewone PyTorch voor de rest – en de bekende kosten zijn de snelheid van de oplosser en numerieke stabiliteit over lange integratie-intervallen.

Wat niet vaststaat, is het deel dat beslist of iets hiervan in een productiestapel thuishoort. Structurele correctheid is geen bewijs van voorspellend voordeel, en het specifieke voordeel dat wordt geclaimd voor continue dynamiek ten opzichte van een $\log(\Delta t)$-kenmerk is hier niet gemeten op basis van echte handelsgegevens. Totdat de H2-tabel hierboven is ingevuld, behandel je alles onder de vouw als een goed gespecificeerde hypothese waaraan een werkende implementatie is gekoppeld, en niet als resultaat.

Referenties

• Chen, RTQ, Rubanova, Y., Bettencourt, J., Duvenaud, D. (2018). Neurale gewone differentiaalvergelijkingen. NeurIPS 2018. arXiv:1806.07366
• Rubanova, Y., Chen, RTQ, Duvenaud, D. (2019). Latent ODE's voor onregelmatig bemonsterde tijdreeksen. NeurIPS 2019. arXiv:1907.03907
• Jia, J., Benson, AR (2019). Neural Jump stochastische differentiaalvergelijkingen. NeurIPS 2019.
• Kidger, P., Morrill, J., Foster, J., Lyon, T. (2020). Neuraal gecontroleerde differentiaalvergelijkingen voor onregelmatige tijdreeksen. NeurIPS 2020.
• Hasan, A., Pereira, JM, Farsiu, S., Carin, L. (2021). Neural Network Stochastische differentiaalvergelijkingsmodellen met toepassingen op het voorspellen van financiële gegevens. arXiv:2111.13164
• fakkeldiffeq: github.com/rtqichen/torchdiffeq
• UvA Deep Learning Tutorials - Neurale ODE's: uvadlc-notebooks.readthedocs.io