Neyron ODElar: Uzluksiz vaqt Delta-Vaqt xususiyatidan ustun turadimi?

Neyron oddiy differensial tenglamalar (Chen va boshq., NeurIPS 2018) neyron tarmog'i bilan yashirin holatning * lotinini * parametrlashtiradi va ODE hal qiluvchiga chiqishni hisoblash imkonini beradi. Model uzluksiz chuqurlikka aylanadi va bozorlar uchun foydaliroq, uzluksiz-vaqt: yashirin holat istalgan vaqtda baholanishi mumkin. $t$, nafaqat tarmoq nuqtalarida sizning ma'lumotlaringiz o'tirib qoladi.

Bu mulk tasodifiy vaqt oralig'ida keladigan moliyaviy ma'lumotlar uchun aniq maydonga ega. Ammo maydon ko'rinadiganidan ancha zaifroq da'voni yashiradi. Oddiy GRU qo'shimcha kiritish xususiyatini taqdim etdi - $\log(\Delta t)$ oldingi kuzatuvdan beri - qancha vaqt o'tganini ham "biladi". Haqiqiy savol doimiy vaqt modellari tartibsiz ma'lumotlarni qabul qila oladimi yoki yo'qmi emas. Kuzatishlar orasidagi o'rganilgan uzluksiz dinamika delta-vaqt xususiyati sizga hali bermaydigan narsani chiqarib tashlaydimi yoki yo'qmi, xulosa chiqarish narxidan o'ndan yuz baravargacha.

Ushbu maqola ushbu tajribani o'rnatadi, uni ishga tushirish uchun to'liq asboblar zanjirini beradi va mashinani oqlash uchun taqqoslash nimani ko'rsatishi kerakligi haqida xabar beradi. Dalilning bar-konstruktsiya tomoni - savdo vaqtining o'zi signal beradi - 17 bar turlari bo'yicha o'lchangan dalillar bilan tasdiqlangan. vaqt chegaralaridan tashqari; Bu erda muhim bo'lgan yagona natija modellashtirishdir: hal qiluvchi yashirin holatni o'zboshimchalik bilan baholaydi. $t$, shuning uchun interpolatsiya yoki to'ldirish kerak emas.

Sinov ostidagi da'vo

Har biri avvalgisidan qat'iy kuchliroq bo'lgan uchta gipoteza:

1. H1 — Xom tartibsiz BTC savdo oqimidagi ODE-RNN moslamasi bir xil oqimdagi GRU moslamasidan hech qanday vaqt maʼlumoti yoʻq. Bu deyarli aniq va deyarli foydasiz: ODE-RNN oddiygina asosiy ma'lumotlarga ega emas.
2. H2 - ODE-RNN GRU berilgandan keyin bir xil GRUni uradi $\log(\Delta t)$ kiritish xususiyati sifatida. Bu halol sinov. Bu Neural ODE adabiyoti odatda o'qiladi va moliyaviy ma'lumotlarda deyarli hech qachon ko'rsatilmagan da'vodir.
3. H3 - H2 afzalligi kechikish byudjetidan omon qoladi, ya'ni ODE-RNN adaptiv emas, balki jonli xulosa chiqarish uchun etarlicha tez qat'iy bosqichli hal qiluvchi bilan o'rnatilganda ham saqlanib qoladi. dopri5.

Tajriba protokoli

Xuddi shu belgi oqimi, bir xil maqsad, ikkala qo'l uchun bir xil sozlash byudjeti. 1 m shtrixlarga qayta namuna olishning hojati yo'q - qayta namuna olish sinov ostidagi aniq tuzilmani yo'q qiladi.

H2 bo'yicha salbiy natija to'liq e'lon qilinishi mumkin va, ehtimol, eng qimmatli natija - xuddi shu standartda qo'llaniladigan halol salbiy natija va Sharpeni bir nechta sinovdan o'tkazdi.

Ikkilamchi tajriba: CNF vs Student-t

Agar ODE-RNN taqqoslash juda qimmat bo'lsa, arzonroq empirik langar taqsimot hisoblanadi: haqiqiy BTC kunlik daromadlariga doimiy normallashtiruvchi oqimni moslashtiring va uning o'rnatilgan zichligini Student-t mosligi va empirik quyruq bilan solishtiring, 1% va 5% darajalarida quyruq-kvantil xatolar haqida xabar bering. Bu to'g'ridan-to'g'ri allaqachon o'lchangan tarqatish ishlariga bog'lanadi GARCH o'zgaruvchanligini prognozlash va assimetrik GARCH.

Ushbu maqolaning qolgan qismi yuqoridagi ishlarni bajarish uchun zarur bo'lgan fon va asboblar zanjiridir.

Ma'lumot: ResNets dan uzluksiz dinamikaga

Qoldiq tarmoq hisoblaydi $h_{t+1} = h_t + f(h_t, \theta_t)$. Qadam hajmini kichraytiring va qatlamlar sonini oshiring va siz doimiy chegaraga yaqinlashasiz:

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

O'rniga $T$ alohida parametrlarga ega diskret qatlamlar, bitta tarmoq $f$ oniy o'zgarish tezligini belgilaydi. O'z vaqtida chiqish $T$ boshlang'ich qiymat muammosini hal qiladi:

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

Qora quti hal qiluvchi (Euler, Runge-Kutta, Dormand-Prince) integralni raqamli ravishda hisoblab chiqadi, mahalliy xatoliklarni baholashdan moslashtirilgan tarzda qadam o'lchamlarini tanlaydi.

Qo'shimcha usul

Har bir hal qiluvchi qadam orqali orqaga tarqalish barcha oraliq holatlarni saqlaydi, xotira narxi qadamlar soniga mutanosib. Chen va boshqalar. Buning o'rniga orqaga ODE ni hal qiling $O(1)$ xotira. Qo'shni davlatni aniqlang $a(t) = -\partial L / \partial h(t)$, qanoatlantiradi

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

va orqaga o'tish bo'ylab parametr gradientini to'plang:

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

Orqaga o'tish kengaytirilgan tizimli hisoblashni hal qiladi $h(t)$, $a(t)$ va $dL/d\theta$ bir vaqtning o'zida hal qiluvchini teskari yo'nalishda ishga tushirish $T$ uchun $0$.

Shartnoma: qayta qurish $h(t)$ orqaga qarab sonli xato to'planadi, bu qattiq yoki xaotik dinamika uchun yomon. Tekshirish nuqtasi o'rta zamin - do'kon $h(t)$ bir necha oraliq vaqtda, ular o'rtasida qayta hisoblash. Narx jarayonlari doimiy semimartingales va o'rtacha silliq, shuning uchun qo'shimcha odatda ushlab turadi; mikrotuzilma hodisalari atrofidagi qattiqlik adaptiv hal qiluvchi yoki duragaylarni majburlashi mumkin.

ODE-RNN: Kuzatishlar orasidagi doimiy yashirin holat

ODE-RNN asosiy tajriba yoqadigan arxitektura hisoblanadi. Kuzatishlar orasida ODE ostida yashirin holat rivojlanadi:

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

Kuzatish paytida $x_{i+1}$ yetib keladi $t_{i+1}$, diskret yangilanish ishga tushadi:

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

Ustki belgilar kuzatishdan oldingi va faqat keyingi holatni bildiradi. Kuzatishlar orasida uzluksiz dinamikani o'rgandi; kuzatishlarda, yangi ma'lumotlar.

H2 ablasyon problarining mexanizmi quyidagicha: uzoq bo'shliq yashirin holat uzoq yo'l ostida rivojlanganligini anglatadi. $f_\theta$ - asosiy chiziqqa qarab parchalanish yoki ajralish - va bu evolyutsiyaning shakli skalar sifatida taqdim etilgandan ko'ra o'rganiladi. Ushbu ekspressivlik haqiqiy savdo ma'lumotlarida o'zini to'laydimi yoki yo'qmi - bu o'lchovsiz narsa.

Shomildan tashqari tabiiy moslashuvlar: ko'p aktivli portfellar, bunda har bir aktivning o'z kuzatuv jadvali mavjud va korrelyatsiya qilingan aktivlarning yashirin holati o'zgarishda davom etadi, faqat bittasi kuzatiladi; va tartibsiz vaqtda keladigan hodisalarga asoslangan signallar (yangiliklar, daromadlar, makro relizlar).

Neyron SDE'lar: Stokastik komponentlarni qo'shish

Neyron ODElar deterministikdir va narx yo'lidagi shovqinni ifodalay olmaydi. Klassik davolash - geometrik Braun harakati, xavf-neytral siljish va doimiy o'zgaruvchanlik taxminlarining tabassumga qarshi muvaffaqiyatsiz bo'lish yo'llari - maqolada keltirilgan. Black-Scholes variantlari narxlari. Neyron SDE parametrik shaklni o'rganilgan diffuziya atamasi bilan almashtiradi:

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

$f$ bu drift, $g$ diffuziya, $W(t)$ Wiener jarayoni, ikkalasi ham $f$ va $g$ neyron tarmoqlari.

Arxitektura: Drift Net va Diffusion Net

• Drift tarmog'i $f_\theta$: kutilayotgan traektoriya — tendentsiya, oʻrtacha reversiya, impuls. Prognoz xatosini minimallashtirishga o'rgatilgan.
• Diffuziya tarmog'i $g_\phi$: shovqin kattaligi, davlat funktsiyasi sifatida o'rganilgan. O'zgaruvchan rejimlarda yuqori, tinch rejimlarda past.

Ajralish klassik kvant moliyasini aks ettiradi: drift - bu xavf-neytral (yoki P-o'lchov) dinamikasi, diffuziya - o'zgaruvchanlik yuzasi.

Neyron SDElarni o'rgatish

Stokastik integral $\int g\,dW$ klassik jihatdan farqlanmaydi. Uchta yondashuv:

1. Pathwise gradients: reparametrizatsiya hiylasi — namunaviy Broun yo'llari, shovqinni qattiq kirish sifatida ko'rib chiquvchi hal qiluvchi orqali farqlash.
2. Baholarning mos kelishi: taxmin $\nabla_h \log p(h)$ va denoising maqsadlari orqali o'rgatish - bir xil mashinalar mustaqil generativ model sifatida ishlatiladi kripto prognozi uchun diffuziya modellari, bu erda SDE uchun trening variantiga tushirildi.
3. Chek oʻlchovli taqsimotni moslashtirish: toʻliq yoʻl oʻlchovlari oʻrniga kuzatuv vaqtidagi chegaralarni moslashtirish.

Pathwise amaliy standart hisoblanadi. torchsde Euler-Maruyama, Milstein va stoxastik Runge-Kutta-ni autodiff qo'llab-quvvatlashi bilan amalga oshiradi.

O'zgaruvchanlik yuzasini o'rganish

Klassik modellar (Heston, SABR) diffuziya koeffitsientiga parametrik shakllarni qo'yadi. Neyral SDE o'rganadi $g_\phi(S, t)$ ixtiyoriy funksiya sifatida:

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

Bu diffuziya jarayonlari uchun universal yaqinlashuvchidir - har qanday Ito jarayoni etarli quvvatni hisobga olgan holda o'zboshimchalik bilan aniqlik.

Yo'qolgan va asinxron ma'lumotlar uchun yashirin ODE

Yashirin ODE (Rubanova, Chen, Duvenaud, 2019) Neyron ODEni VAE bilan birlashtiradi: moliyaviy seriyalar past o'lchamli yashirin fazoda o'rganilgan silliq asosiy jarayonning shovqinli kuzatuvlari.

1. Tanib olish tarmog'i: ishlab chiqarish uchun kuzatishlar orqali orqaga qarab ishlaydigan ODE-RNN $q(z_0 | x_{1:N})$.
2. Yashirin dinamika: $z(t) = z(t_0) + \int_{t_0}^{t} f_\theta(z(s), s)\, ds$.
3. Dekoder: $\hat{x}(t) = \text{Decoder}(z(t))$, istalgan vaqtda baholanadi.

Yo'qotish standart ELBO hisoblanadi:

$\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 holatini baholash: aktivlar bo‘yicha siyrak asinxron kuzatuvlar natijasida qo‘shma dinamikani qamrab oluvchi uzluksiz yashirin holat – Kalman filtrining chiziqli bo‘lmagan, o‘rganilgan versiyasini aniqlang.

Yo‘qolgan ma’lumotlarni hisoblash: to‘xtashlar va dam olish kunlaridagi bo‘shliqlar silliq interpolyatsiya qilingan yashirin traektoriyaga ega bo‘ladi; dekoder VAE posterioridan noaniqlik bilan bo'shliq orqali ishonchli yo'llarni ishlab chiqaradi.

Ko'p chastotali termoyadroviy: har kuni yopilish, kunlik VWAP va umumiy vaqt tarmog'isiz bitta modeldagi belgi ma'lumotlari.

Qaytish taqsimoti uchun doimiy normalizatsiya oqimlari

CNF oddiy tayanch taqsimotni murakkab maqsadga aylantirish uchun Neyron ODE dan foydalanadi. Transformatsiya - bu $\frac{dz(t)}{dt} = f(z(t), t, \theta)$, va log-zichlik o'zgaruvchilarning bir zumda o'zgarishiga mos keladi:

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

Holat va log-zichlikni oldinga integratsiyalash $z(0) \sim p_0$ olish uchun; olmoq $z(T)$ va $\log p(z(T))$. Yakobiy izi Xatchinsonning masshtablilik uchun stoxastik baholovchisi bilan baholanadi.

Kripto daromadlari leptokurtik va manfiy qiyshiq bo'lib, real ma'lumotlar bo'yicha o'lchanadi. GARCH o'zgaruvchanligini prognozlash va assimetrik GARCH va kaldıraç effekti - va CNF bu shaklni qabul qilish o'rniga o'rganadi. Oqimni holat o'zgaruvchilari bo'yicha shartlash, rejim bilan shaklni o'zgartirishga imkon beradi. Zichlik taxminiy emas, aniq bo'lganligi sababli, u hisoblangan quyruq ko'rsatkichlarini berishi mumkin. Monte-Karlo va bootstrap backtests va CVaR qurilishi HRP/CVaR portfeli quvuri; bo'g'in quyruq tuzilishi alohida ishlanadi qo'shma xavf uchun kopula modellari.

Shartli zichlikni baholash

Foydali ramka - bu bir xil muammoga uchta nashr etilgan yondashuv o'rtasidagi to'g'ridan-to'g'ri kontrast. TFT sizga kvantli chiqish qatlamidan belgilangan kvantlar to'plamini beradi. Konformal bashorat qamrov kafolati bilan kalibrlangan intervallarni beradi. Shartli CNF sizga aniq, farqlanadigan zichlikni beradi:

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

Differentsiallik ajralib turadigan xususiyatdir: zichlik quyi oqim ob'ektivining ichida joylashishi va orqaga tarqalishi mumkin, bunda na qat'iy kvantlar, na konformal intervallar qo'llab-quvvatlamaydi. Xuddi shu maqsadda TFT kvantlariga nisbatan aniq zichlik o'z narxiga arziydimi yoki yo'qmi, bu erda tekshirilmagan.

Diskret alternativlar bilan taqqoslash

Ushbu jadvalning LSTM va e'tiborning yarmi batafsil ko'rib chiqiladi, benchmarklar, TFT maqolasi — uning "TFT vs LSTM vs Vanilla Transformer" va "When LSTM Still Wins" bo'limlariga qarang. Bu erda yangi ustunlar o'ngdagi ikkitasi va H2/H3 savollarini hal qiladigan qatorlar oxirgi ikkitadir.

Python torchdiffeq bilan amalga oshirish

torchdiffeq ODE hal qiluvchilarni qo'shimcha orqaga tarqalish bilan ta'minlaydi.

Narxlar dinamikasi uchun asosiy neyron 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)

Noqonuniy Shomil ma'lumotlari uchun ODE-RNN

Bu eksperimental qo'l. U engishi kerak bo'lgan asosiy chiziq nn.GRUCell bilan bir xil oqimda log(t_next - t_prev) bilan bog'langan 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)

Trening tsikli

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

Qaytish taqsimoti uchun doimiy normalizatsiya oqimi

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]

Amaliy eslatmalar

Yuqoridagi tajribani o'tkazishda sizni tishlaydigan narsalar shu.

Yechish tanlovi va tezligi

dopri5 aniqlik kafolatlarini beradi, lekin o'zgaruvchan hisoblash narxini beradi, shuning uchun H3 H2 dan alohida gipotezadir: faqat adaptiv hal qiluvchi ostida mavjud bo'lgan chekka jonli kechikish byudjetidan omon qolmasligi mumkin. Ruxsat etilgan bosqichli hal qiluvchilar (Euler, RK4) aniqlik evaziga bashorat qilinadigan kechikishni beradi. Amaliy kelishuv: bilan mashq qiling dopri5, vakillik ma'lumotlaridagi adaptiv hal qiluvchining chiqishiga mos kelish uchun sozlangan qat'iy bosqichli hal qiluvchi bilan joylashtiring va kichik deb o'ylamasdan, bo'shliqni o'lchang.

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

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

Uzluksiz sakrashlar yaqinidagi qattiq muammolar uchun, method='implicit_adams' yoki method='scipy_solver'.

Raqamli barqarorlik

Agar $f_\theta$ davlat farq qiladigan katta qiymatlarni chiqaradi. Yumshatish choralari:

• Qatlamlarda Spektral normalizatsiya $f_\theta$ Lipschitz konstantasini boshqarish uchun.
• Mashq paytida gradientni kesish (yuqoridagi trening tsiklida ko'rsatilgan).
• Vaqtni normallashtirish: vaqt belgilarini shkalasigacha o‘lchash $[0, 1]$.
• Dinamik me'yor bo'yicha tartibga solish: qo'shing $\lambda \|f_\theta(h, t)\|^2$ yo'qotishga.

Integratsiya oralig'i

Oylik ma'lumotlar uchun dan integratsiya qilmang $t = 0$ uchun $t = 10{,}000$ daqiqalar:

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

Bu hal qiluvchini raqamli do'stona rejimda ushlab turadi va o'rganilgan dinamikani miqyosda o'zgarmas qiladi. Taqqoslash uchun bu ham muhim: normallashtirilmagan ODE-RNN faqat sonli sabablarga ko'ra GRU bazasiga yo'qotishi mumkin, bu topilma emas, balki o'lchov artefakti bo'ladi.

Bir nechta vaqt o'lchovlarini boshqarish

Bozorlar bir vaqtning o'zida mikrosoniya, soniya, daqiqa va kunlik o'lchovlarda dinamikaga ega va bitta Neyral ODE ularning barchasini ushlab turish uchun kurash olib borishi mumkin. Variantlar: turli vaqt shkalalarida bir nechta ODE bloklarini to'plash; tez va sekin quvvat uchun yashirin o'lchamni kengaytirish; yoki har bir chastota diapazoni va sug'urta chiqishlari uchun alohida Neyron ODE larini ishlating. (Bu model sig'imiga oid savol bo'lib, u erda test-sodiqlik savolidan farq qiladi adaptiv rezolyutsiyani pastga tushirish.)

Tadqiqot yo'nalishlarini oching

Neural Jump SDEs: to'satdan dislokatsiyalar uchun o'rganilgan sakrash komponentini qo'shing (flesh-halokatlar, daromad kutilmagan hodisalari):

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

qayerda $\tilde{N}$ kompensatsiyalangan Puasson tasodifiy o'lchovidir va $\gamma$ o'rganilgan sakrash yadrosi.

Neyron boshqariladigan differentsial tenglamalar (Neyron CDEs): Viner jarayonini umumiy haydash signali bilan almashtiring, bu esa kuzatilgan ma'lumotlar oqimining dinamikani boshqarishiga imkon beradi. Savdolar va kotirovkalar oqimi yashirin bozor holatini boshqaradigan buyurtma oqimi uchun tabiiydir.

Differentsial bozor simulyatsiyasi: differensiallanuvchi simulyator ichida generativ model sifatida Neyron SDE dan foydalaning va u orqali u orqali orqaga tarqalish orqali strategiyalarni oxirigacha o'rgating. Strategiya va bozor modeli birgalikda rivojlanadi.

Fizikadan ma'lumotga ega neyron ODE'lari: PINN-lar yo'qotishda differentsial tenglama qoldig'ini joylashtiradi - texnikaning o'zi joriy etilgan. Navier-Stokes maqolasi. Moliyaviy dastur o'rganilgan dinamikaga jarima shartlari yoki qattiq cheklovlar sifatida arbitrajsiz, qo'ng'iroq pariteti va martingale shartlarini qo'yishdir.

Xulosa

Uzluksiz vaqt oralig'i tizimli ravishda to'g'ri: bozorlar diskret, tartibsiz vaqtlarda kuzatiladigan uzluksiz jarayonlardir va modellar buni hurmat qilishi kerak. Asboblar zanjiri etuk - torchdiffeq, torchsde, qolganlari uchun oddiy PyTorch - va ma'lum xarajatlar hal qiluvchi tezligi va uzoq integratsiya intervallaridagi raqamli barqarorlikdir.

O'rnatilmagan narsa - bularning birortasi ishlab chiqarish to'plamiga tegishli yoki yo'qligini hal qiladigan qism. Strukturaviy to'g'rilik bashoratli ustunlikning dalili emas va doimiy dinamikaga nisbatan o'ziga xos afzallik da'vo qilingan. $\log(\Delta t)$ xususiyat bu erda haqiqiy savdo ma'lumotlarida o'lchanmagan. Yuqoridagi H2 jadvali to'ldirilgunga qadar, burma ostidagi hamma narsani natija sifatida emas, balki ish ilovasi biriktirilgan yaxshi aniqlangan gipoteza sifatida ko'rib chiqing.

Ma'lumotnomalar

• Chen, R.T.Q., Rubanova, Y., Bettencourt, J., Duvenaud, D. (2018). Neyron oddiy differensial tenglamalar. NeurIPS 2018. arXiv: 1806.07366
• Rubanova, Y., Chen, R.T.Q., Duvenaud, D. (2019). Tartibsiz namunali vaqt seriyasi uchun yashirin ODE. NeurIPS 2019. arXiv: 1907.03907
• Jia, J., Benson, A.R. (2019). Neyron sakrashli stoxastik differensial tenglamalar. NeurIPS 2019.
• Kidger, P., Morrill, J., Foster, J., Lyons, T. (2020). Irregular vaqt seriyasi uchun neyron bilan boshqariladigan differensial tenglamalar. NeurIPS 2020.
• Hasan, A., Pereyra, J.M., Farsiu, S., Karin, L. (2021). Moliyaviy ma'lumotlarni prognozlash uchun ilovalar bilan neyron tarmog'i stoxastik differensial tenglama modellari. arXiv: 2111.13164
• torchdiffeq: github.com/rtqichen/torchdiffeq
• UvA chuqur o'rganish bo'yicha qo'llanmalar - Neyron ODElar: uvadlc-notebooks.readthedocs.io