Koopman Operators and DMD: Do Market Modes Survive Out-of-Sample?

Dinamik rejim parchalanishi sizga spektrni taqdim etadi: har biri o'sish tezligi va chastotasiga ega bo'lgan bir nechta murakkab o'ziga xos qiymatlar, ularning har biri sizning aktivingiz kesimida fazoviy rejimga biriktirilgan. Bu strukturaga o'xshaydi. Barcha savol shundaki, u * tuzilmami yoki u bir shovqin oynasini eslab qoladigan chiziqli operatormi?

Bu savolning ikkita tekshirilishi mumkin bo'lgan yarmi bor va ushbu maqola ular atrofida qurilgan:

1. Rejim barqarorligi. DMD-ni oynaga o‘rnating $t$ va derazada $t+1$ . Dominant rejimlar bir xil pastki bo'shliqni qamrab oladimi yoki ular har bir ta'mirlashni o'zgartiradimi? Agar ular o'zgartirilsa, DMD namunadagi parchalanishdir va boshqa hech narsa emas - va ochiqchasiga aytilishicha, boshqa o'quv qo'llanmasidan ko'ra foydaliroq.
2. Spektral radius yetakchi indikator sifatida. Eng katta xususiy qiymat moduli $\rho = \max_j |\lambda_j|$ o'rnatilgan dinamikaning qanchalik portlovchi ekanligini umumlashtiruvchi yagona skalerdir. U sezilgan o'zgaruvchanlikka olib keladimi, uni kechiktiradimi yoki shunchaki qayta ifodalaydimi? Ikkala javob ham e'lon qilinishi mumkin; faqat birinchisi savdoga qo'yiladi.

Bu erda bozorlar statsionar bo'lmagan chiziqli tizimlar ekanligi taxmin qilinadi, bahslashmaydi - blog allaqachon algotradingdagi jalb qiluvchilar da fazo-kosmik geometriya bilan bahslashgan va HMMlar bilan rejimni aniqlash. Keyinchalik torroq savol - statsionar bo'lmaganlik * o'rnatilgan Koopman operatoriga* nima qiladi va uni qanday o'lchash kerak.

1. Asosiy g'oya: chiziqli bo'lmagan dinamikani chiziqlilashtirish

Holat fazosida diskret vaqtli dinamik tizimni ko'rib chiqaylik $\mathcal{M} \subseteq \mathbb{R}^n$ :

$x_{k+1} = F(x_k)$

qayerda $F: \mathcal{M} \to \mathcal{M}$ ehtimol chiziqli bo'lmagan xaritadir. Bozorlar uchun, $x_k$ vaqt bosqichida aktivlar daromadlari, o'zgaruvchanliklari yoki buyurtma kitobi nomutanosibliklari vektoridir $k$ .

Koopman operatori $\mathcal{K}$ davlatga nisbatan harakat qilmaydi $x$ to'g'ridan-to'g'ri, lekin * skalar qiymatli kuzatiladigan funktsiyalarda * $g: \mathcal{M} \to \mathbb{C}$ :

$[\mathcal{K} g](x) = g(F(x))$

Asosiy xususiyat: ** $\mathcal{K}$ chiziqli** bo‘lsa ham $F$ emas. Narx - o'lchovlilik - $\mathcal{K}$ cheksiz o'lchamli funksiya fazosiga ta'sir qiladi. Yaxshi chekli o'lchovli yaqinlashish sizga chiziqli algebraning harakatchanligi bilan chiziqli bo'lmagan dinamikaning ekspressivligini sotib oladi: bashorat matritsaning eksponentatsiyasiga aylanadi va har bir rejim tarmoq og'irliklarida ko'milgandan ko'ra tekshirilishi mumkin.

2. Koopman operatorining spektral dekompozitsiyasi

Agar $\mathcal{K}$ xos qiymatlarga ega $\lambda_j$ va xos funktsiyalar $\varphi_j$ , keyin $\mathcal{K} \varphi_j = \lambda_j \varphi_j$ , va har qanday kuzatilishi mumkin $g$ Ushbu xos funktsiyalar oralig'ida quyidagicha parchalanadi:

$g(x_k) = \sum_{j=1}^{\infty} \varphi_j(x_0) \, \lambda_j^{k} \, v_j$

qayerda $v_j$ Koopman rejimlari - har bir xos funktsiyaning to'liq kuzatiladigan vektorga qanday hissa qo'shishini tavsiflovchi vektor qiymatli koeffitsientlar.

Har bir xos qiymat $\lambda_j = |\lambda_j| e^{i\omega_j}$ o'sish yoki parchalanish tezligini kodlaydi ( $|\lambda_j|$ ) va tebranish chastotasi ( $\omega_j$ ):

Bu jadval va'dadir. 4-bo'limda va'da ma'lumotlarga nisbatan tekshiriladi.

3. Dinamik rejimning parchalanishi (DMD)

DMD - bu taxminiy hisoblash algoritmi $\mathcal{K}$ ma'lumotlardan. Matritsalarga joylashtirilgan suratlar:

$X = \begin{bmatrix} x_0 & x_1 & \cdots & x_{m-1} \end{bmatrix}, \quad X' = \begin{bmatrix} x_1 & x_2 & \cdots & x_m \end{bmatrix}$

DMD eng mos chiziqli operatorni qidiradi $A$ bilan $X' \approx AX$ :

1. SVD ni hisoblang: $X = U \Sigma V^*$
2. Loyiha: $\tilde{A} = U^* X' V \Sigma^{-1}$
3. Eigendecompose: $\tilde{A} W = W \Lambda$
4. To'liq maydon rejimlarini tiklash: $\Phi = X' V \Sigma^{-1} W$

ning ustunlari $\Phi$ DMD rejimlari; diagonali $\Lambda$ DMD xos qiymatlariga ega.

import numpy as np
from numpy.linalg import svd, eig, lstsq

def dmd(X: np.ndarray, rank: int | None = None) -> tuple:
    """
    Dynamic Mode Decomposition.

    Parameters
    ----------
    X : np.ndarray, shape (n_features, n_snapshots)
        Data matrix where each column is a state snapshot.
    rank : int or None
        Truncation rank for the SVD. None = no truncation.

    Returns
    -------
    eigenvalues : np.ndarray, shape (r,)
        DMD eigenvalues (approximating Koopman eigenvalues).
    modes : np.ndarray, shape (n_features, r)
        DMD modes (columns), L2-normalised.
    amplitudes : np.ndarray, shape (r,)
        Mode amplitudes fitted to the FINAL snapshot, so that a one-step
        forecast is simply modes @ (eigenvalues * amplitudes).
    """
    X0 = X[:, :-1]
    X1 = X[:, 1:]

    U, S, Vh = svd(X0, full_matrices=False)

    if rank is not None:
        U = U[:, :rank]
        S = S[:rank]
        Vh = Vh[:rank, :]

    S_inv = np.diag(1.0 / S)

    A_tilde = U.conj().T @ X1 @ Vh.conj().T @ S_inv
    eigenvalues, W = eig(A_tilde)

    modes = X1 @ Vh.conj().T @ S_inv @ W

    norms = np.linalg.norm(modes, axis=0)
    norms[norms == 0] = 1.0
    modes = modes / norms

    amplitudes = lstsq(modes, X[:, -1].astype(complex), rcond=None)[0]

    return eigenvalues, modes, amplitudes

Bu erda ikkita qasddan tanlov. Rejimlar L2-normallashtirilgan, chunki 4.2-bo'lim oynalar bo'ylab rejim pastki bo'shliqlarini solishtiradi va normallashtirilmagan amplitudalar taqqoslashni botqoq qiladi. Amplitudalar birinchisiga emas, oxirgi suratga o‘rnatiladi, bu esa prognoz hech qachon xos qiymatni katta quvvatga ko‘tarmasligini anglatadi – raqamli portlash manbai, sodda DMD signallari suzuvchi nuqta to‘lib toshganida dinamikaga o‘xshaydi.

4. O'lchov

Bu maqolaning darslik bo'lmagan qismidir. Yuqoridagilarning barchasi mos keladigan protseduradir; Quyida moslikning biror narsani anglatishini aniqlash uchun protokol mavjud.

Maʼlumotlar. Loyihaning oʻz almashuv maʼlumotlaridan foydalaning — BTC, ETH va likvidli altslarning koʻndalang boʻlimidan, kapital ETFlarni kunlik yuklab olish emas, balki izchil daqiqa yoki katakchalar tarmogʻida. Blog kripto-birinchi bo'lib, mikrotuzilma argumenti uzatilmaydi. Qurilish $X$ satrlarda aktivlar va ustunlarda vaqt, jurnal deklaratsiyasida, har bir oynada har bir aktiv uchun qadrsizlangan.

4.1 Xususiy qiymat spektri

Hisobot, vakili oyna uchun: qancha $r$ o'ziga xos qiymatlar birlik doirasining tolerantligi doirasida tushadi, qaysi tebranish davri har biriga soatlarda mos keladi (davr). $= 2\pi / |\omega_j|$ barlar, konvertatsiya qilingan) va qaytarilish dispersiyasining qaysi qismi yuqori $r$ rejimlarni qayta qurish.

def spectrum_report(eigenvalues: np.ndarray, bar_minutes: float,
                    tol: float = 0.05) -> list[dict]:
    """
    Turn a DMD spectrum into human-readable rows: modulus, period in hours,
    and whether the eigenvalue sits on the unit circle within `tol`.
    """
    rows = []
    for lam in eigenvalues:
        modulus = float(np.abs(lam))
        omega = float(np.angle(lam))
        period_hours = (2 * np.pi / abs(omega)) * bar_minutes / 60 if omega else np.inf
        rows.append({
            "modulus": modulus,
            "period_hours": period_hours,
            "on_unit_circle": abs(modulus - 1.0) < tol,
            "regime": "unstable" if modulus > 1 + tol
                      else "persistent" if abs(modulus - 1.0) <= tol
                      else "decaying",
        })
    return sorted(rows, key=lambda r: -r["modulus"])


def reconstruction_r2(X: np.ndarray, modes: np.ndarray,
                      eigenvalues: np.ndarray, amplitudes: np.ndarray) -> float:
    """Fraction of in-window return variance captured by the truncated modes."""
    n_steps = X.shape[1]
    powers = eigenvalues[:, None] ** np.arange(-(n_steps - 1), 1)
    X_hat = (modes @ (amplitudes[:, None] * powers)).real
    resid = np.var(X - X_hat)
    return 1.0 - resid / np.var(X)

Halol spektrli hisobot allaqachon maqolaga arziydi. Agar birlik doirasiga hech narsa o'tirmasa, savdo qilish uchun doimiy tsikllar yo'q va qimmatli qog'ozlar adabiyotidagi "yillik mavsumiylik" hikoyasi 24/7 kriptovalyutaga o'tmaydi.

4.2 Qo'shni derazalar bo'ylab rejim barqarorligi

Hal qiluvchi sinov. DMDni oynaga joylashtiring $t$ , keyin oynada $t+1$ , va dominant rejimdagi pastki fazoning qanchasi omon qolishini o'lchang. To'g'ri statistika rejim vektorlarining sodda korrelyatsiyasi emas - rejim tartibi va murakkab faza ixtiyoriydir - lekin ikkita pastki bo'shliq orasidagi asosiy burchaklar.

def subspace_stability(modes_a: np.ndarray, modes_b: np.ndarray,
                       k: int = 3) -> float:
    """
    Overlap between the leading-k DMD mode subspaces of two adjacent windows.

    Returns the mean cosine of the principal angles: 1.0 = identical subspace,
    0.0 = orthogonal. Immune to mode reordering and complex phase, both of
    which are arbitrary in a DMD fit.
    """
    Qa, _ = np.linalg.qr(modes_a[:, :k])
    Qb, _ = np.linalg.qr(modes_b[:, :k])
    sing = np.linalg.svd(Qa.conj().T @ Qb, compute_uv=False)
    return float(np.mean(np.clip(sing, 0.0, 1.0)))


def stability_curve(returns: np.ndarray, window: int, step: int,
                    rank: int, k: int = 3) -> np.ndarray:
    """Subspace overlap between every pair of adjacent windows."""
    fits = []
    for t_end in range(window, returns.shape[1], step):
        evals, modes, _ = dmd(returns[:, t_end - window:t_end], rank=rank)
        order = np.argsort(-np.abs(evals))
        fits.append(modes[:, order])
    return np.array([subspace_stability(fits[i], fits[i + 1], k=k)
                     for i in range(len(fits) - 1)])

Ushbu takrorlanishning taqsimlanishi haqida xabar bering va uni nolga qarshi hisobot bering: bir xil daromadlarning fazaviy tasodifiy surrogatlar bo'yicha hisoblangan bir xil statistika. Yuqori, lekin surrogat nulldan yuqori boʻlmagan oʻzaro kelishish rejimlar dinamikani emas, balki kovariatsiya tuzilishini kuzatishini bildiradi.

4.3 Aniq o'zgaruvchanlikka qarshi aylanma spektr radiusi

Sinov uchun da'vo: $\rho_t = \max_j |\lambda_j|$ , Rolling windows bo'yicha qayta hisoblangan, harakat * oldin * u bilan emas, balki amalga o'zgaruvchanlik. Skayar mexanik jihatdan yangi — blog ilgari real vaqt rejimida geometrik skayarlarni kuzatgan, xususan algoritmik savdo uchun murakkab manifoldlardagi Kobayashi egriliklari — lekin Koopman xos qiymat moduli boshqa nosozlik rejimiga ega boʻlgan boshqa miqdor boʻlib, u meros boʻlib qolgan oʻlchamdan koʻra oʻzining kechikish sinoviga loyiqdir.

def rolling_spectral_radius(returns: np.ndarray, window: int = 1440,
                            step: int = 60, rank: int = 5) -> dict:
    """
    Rolling DMD spectrum for regime monitoring.

    returns : np.ndarray, shape (n_assets, n_timesteps)
    window  : rolling window length in bars
    step    : bars between refits
    """
    idx, radii, dom_freq = [], [], []

    for t_end in range(window, returns.shape[1], step):
        X_win = returns[:, t_end - window:t_end]
        try:
            evals, _, _ = dmd(X_win, rank=rank)
        except np.linalg.LinAlgError:
            continue

        idx.append(t_end)
        radii.append(float(np.max(np.abs(evals))))

        on_circle = np.abs(np.abs(evals) - 1.0) < 0.1
        if on_circle.any():
            sel = evals[on_circle]
            dom_freq.append(float(np.abs(np.angle(sel[np.argmax(np.abs(sel))])) / (2 * np.pi)))
        else:
            dom_freq.append(0.0)

    return {"index": np.array(idx),
            "spectral_radius": np.array(radii),
            "dominant_frequency": np.array(dom_freq)}


def lead_lag(signal: np.ndarray, target: np.ndarray, max_lag: int = 24) -> dict:
    """
    Cross-correlation of `signal` against `target` over +/- max_lag steps.
    A peak at negative lag means the signal LEADS the target.
    """
    s = (signal - signal.mean()) / (signal.std() + 1e-12)
    y = (target - target.mean()) / (target.std() + 1e-12)
    lags = np.arange(-max_lag, max_lag + 1)
    corrs = []
    for L in lags:
        if L < 0:
            corrs.append(float(np.corrcoef(s[:L], y[-L:])[0, 1]))
        elif L > 0:
            corrs.append(float(np.corrcoef(s[L:], y[:-L])[0, 1]))
        else:
            corrs.append(float(np.corrcoef(s, y)[0, 1]))
    corrs = np.array(corrs)
    return {"lags": lags, "corr": corrs, "peak_lag": int(lags[np.argmax(np.abs(corrs))])}

Hizalamoq spectral_radius bir xil gridda hisoblangan va o'qilgan o'zgaruvchanlikni amalga oshirish uchun peak_lag . 0 kechikishdagi cho'qqi degan ma'noni anglatadi $\rho_t$ qo'shimcha qadamlar bilan o'zgaruvchanlikni qayta ko'rsatishdir. Namuna boʻyicha va qatorlar boʻyicha barqaror boʻlgan salbiy kechikish choʻqqisi ushbu maqolaning savdoga qoʻyilgan daʼvoga ega yagona versiyasidir.

Ijobiy natijadan keyin nima kelishi haqida eslatma

Agar $\rho_t$ yetakchilik qilsa, keyingi aniq qadam kesma konstruksiyadir: aktivlarni DMD tomonidan bashorat qilingan keyingi bosqich daromadi bo‘yicha tartiblang, bashorat qilingan g‘oliblarni uzoqroq davom eting va bashorat qilingan yutqazuvchilarni qisqartiring. Bu qurilish bu erda yangilik emas — bu statistik arbitraj va kriptoda juftlik savdosida allaqachon qamrab olingan faktor-qoldiq savdosi va vektorlar va matritsalar bilan murakkab arbitrajning 4-bo‘limi; Koopmanga xos bo'lgan yagona jihat shundan iboratki, shaxsiy portfellar statik PCA yuklamalarini emas, balki vaqt bo'yicha o'zgaruvchan xos qiymatlarni o'z ichiga oladi.

Strategiya bo'limi ataylab ushbu maqolada yo'q, chunki u bu erda to'lovlar va sirpanishlar bilan tekshirilmagan. Bu sodir bo'lganda, u blogning o'z satrini tozalashi kerak: Deflated Sharpe Ratio va bir nechta testdagi ahamiyatlilik testi, halol salbiy ning doimiy qarama-qarshi misoliga qarshi. DMD spektrining chizmasi natija emas.

Bir bosqichli prognozning o'zi uchun, to'g'ri amalga oshirish deraza uzunligining kuchiga xos qiymatni targ'ib qilishdan ko'ra, oxirgi suratdan bashorat qiladi:

def dmd_one_step(returns: np.ndarray, rank: int = 4) -> np.ndarray:
    """
    One-step-ahead prediction from the final snapshot of the window.

    Never raise eigenvalues to the window length: any |lambda| != 1 then
    overflows or underflows and the "signal" becomes numerical garbage.
    """
    evals, modes, amplitudes = dmd(returns, rank=rank)
    return (modes @ (evals * amplitudes)).real

5. Kengaytirilgan DMD (EDMD): Nochiziqli kuzatilishi mumkin

Standart DMD xom holat vektorida ishlaydi. EDMD birinchi navbatda chiziqli bo'lmagan asosiy funktsiyalar lug'ati orqali ma'lumotlarni ko'taradi.

Lug'at berilgan $\mathbf{D} = \{d_1, \ldots, d_p\}$ skalyar funksiyalar $d_i: \mathbb{R}^n \to \mathbb{R}$ , ko'tarilgan holatni aniqlang:

$z_k = \begin{bmatrix} d_1(x_k) \\ d_2(x_k) \\ \vdots \\ d_p(x_k) \end{bmatrix} \in \mathbb{R}^p$

EDMD izlaydi $K \in \mathbb{R}^{p \times p}$ bilan $z_{k+1} \approx K z_k$ . Quyidagi kod tomonidan ishlatiladigan konventsiyada - ustunlar sifatida ifodalanadi, $K$ chap tomonda harakat qilish:

$K = A G^{-1}, \quad G = \sum_{k=0}^{m-1} z_k z_k^{T}, \quad A = \sum_{k=0}^{m-1} z_{k+1} z_k^{T}$

Lug'at domen haqidagi bilimlarni kiritadigan joy va vaqtni kechiktirish qatori kechikish koordinatalari haqida umuman g'amxo'rlik qilish uchun Koopmanga xos sababdir: ular murvatlangan alohida texnika emas, ular ko'tarish xaritasining yana bir blokidir. O'rnatishning o'zi - kechiktirishni tanlash $\tau$ , o'rnatish o'lchami $d$ , va uning ortidagi rekonstruksiya teoremasi — algoritmik savdo uchun murakkab manifoldlar da allaqachon kiritilgan va kodlangan; u yerdan kechikish vektorlarini oling va ularni to'g'ridan-to'g'ri kiriting build_financial_dictionary qo'shimcha qatorlar sifatida.

import numpy as np
from itertools import combinations_with_replacement

def build_financial_dictionary(X: np.ndarray, max_poly_degree: int = 2,
                               include_volatility: bool = True,
                               delay_steps: int = 0) -> np.ndarray:
    """
    Build a dictionary of nonlinear observables for EDMD.

    X : np.ndarray, shape (n_features, n_snapshots)
    Returns Z of shape (n_dict, n_snapshots - delay_steps).
    """
    n_features, n_snapshots = X.shape
    offset = max(delay_steps, 0)
    X_eff = X[:, offset:]
    n_eff = X_eff.shape[1]

    lifted = [X_eff]  # degree-1 terms (identity)

    if max_poly_degree >= 2:
        for deg in range(2, max_poly_degree + 1):
            for combo in combinations_with_replacement(range(n_features), deg):
                term = np.ones(n_eff)
                for idx in combo:
                    term *= X_eff[idx]
                lifted.append(term.reshape(1, -1))

    if include_volatility:
        lifted.append(np.abs(X_eff))   # absolute returns
        lifted.append(X_eff ** 2)      # squared returns

    for d in range(1, delay_steps + 1):
        lifted.append(X[:, offset - d : n_snapshots - d])

    return np.vstack(lifted)


def edmd(X: np.ndarray, dictionary_fn=None, reg: float = 1e-8,
         **dict_kwargs) -> tuple:
    """
    Extended Dynamic Mode Decomposition.

    Solves Z1 ~= K @ Z0 in the least-squares sense. Uses a least-squares
    solve rather than an explicit Gram inverse: `inv` on a near-singular
    dictionary Gram matrix is how EDMD spectra get silently corrupted.
    """
    if dictionary_fn is None:
        dictionary_fn = lambda x: build_financial_dictionary(x, **dict_kwargs)

    Z = dictionary_fn(X)
    Z0, Z1 = Z[:, :-1], Z[:, 1:]

    p = Z0.shape[0]
    G = Z0 @ Z0.T + reg * np.eye(p)   # regularised Gram matrix
    A = Z1 @ Z0.T

    K = np.linalg.solve(G, A.T).T

    eigenvalues, eigenvectors = np.linalg.eig(K)
    return K, eigenvalues, eigenvectors

6. Deep Koopman tarmoqlari

EDMD lug'ati qo'lda yaratilgan bo'lib, bu Koopman-invariant pastki fazosi noma'lum bo'lganda haqiqiy cheklovdir. Deep Koopman tarmoqlari ko'tarish va operatorni birgalikda o'rganadilar.

Arxitektura avtokodlovchi hisoblanadi — kodlovchi, latent kod, dekoder, rekonstruksiyani yo'qotish, hammasi algotradingda anomaliyalarni aniqlash - bo'limning butun nuqtasi bo'lgan bitta qo'shimcha bilan: bitta o'rganilgan matritsa orqali yashirin dinamikani majburlaydigan chiziqlilikning yo'qolishi $K$ .

x_k  -->  [Encoder φ]  -->  z_k  -->  [Linear K]  -->  z_{k+1}  -->  [Decoder ψ]  -->  x̂_{k+1}
                              |                            |
                              +--- Linearity loss: ‖z_{k+1} - K z_k‖ ---+

$\mathcal{L} = \underbrace{\lVert x_{k+1} - \psi(K \varphi(x_k)) \rVert^2}_{\text{prediction}} + \alpha \underbrace{\lVert \varphi(x_{k+1}) - K \varphi(x_k) \rVert^2}_{\text{linearity}} + \beta \underbrace{\lVert x_k - \psi(\varphi(x_k)) \rVert^2}_{\text{reconstruction}}$

holda $\alpha$ Sizda oddiy avtokoder mavjud bo'lib, uning yashirin fazosidan keyin matritsa ko'payadi. Uning yordamida tarmoq evolyutsiyasi chiziqli bo'lmagan har qanday yashirin ko'rinish uchun jazolanadi - bu o'rganilgan odamni qiladi. $K$ 4-bo'limning DMD spektri bilan taqqoslanadigan Koopman yaqinlashuvi va uning xos qiymatlari.

import torch
import torch.nn as nn

class DeepKoopman(nn.Module):
    """Deep Koopman autoencoder: learned lifting + linear latent dynamics."""

    def __init__(self, input_dim: int, latent_dim: int, hidden_dim: int = 128):
        super().__init__()

        self.encoder = nn.Sequential(
            nn.Linear(input_dim, hidden_dim), nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim), nn.ReLU(),
            nn.Linear(hidden_dim, latent_dim),
        )
        self.decoder = nn.Sequential(
            nn.Linear(latent_dim, hidden_dim), nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim), nn.ReLU(),
            nn.Linear(hidden_dim, input_dim),
        )
        self.K = nn.Linear(latent_dim, latent_dim, bias=False)

    def encode(self, x: torch.Tensor) -> torch.Tensor:
        return self.encoder(x)

    def decode(self, z: torch.Tensor) -> torch.Tensor:
        return self.decoder(z)

    def forward(self, x_k: torch.Tensor) -> dict:
        z_k = self.encode(x_k)
        z_k1_pred = self.K(z_k)
        return {
            "z_k": z_k,
            "z_k1_pred": z_k1_pred,
            "x_k1_pred": self.decode(z_k1_pred),
            "x_k_recon": self.decode(z_k),
        }

    def multi_step_predict(self, x_0: torch.Tensor, n_steps: int) -> torch.Tensor:
        """Roll out by repeated application of the linear operator."""
        z = self.encode(x_0)
        preds = []
        for _ in range(n_steps):
            z = self.K(z)
            preds.append(self.decode(z))
        return torch.stack(preds, dim=1)

    def latent_spectrum(self) -> np.ndarray:
        """Eigenvalues of the learned K — directly comparable to DMD's."""
        return np.linalg.eigvals(self.K.weight.detach().cpu().numpy())


def koopman_loss(model: DeepKoopman, x_k: torch.Tensor, x_k1: torch.Tensor,
                 alpha: float = 1.0, beta: float = 0.5) -> torch.Tensor:
    out = model(x_k)
    z_k1_true = model.encode(x_k1)

    prediction = nn.functional.mse_loss(out["x_k1_pred"], x_k1)
    linearity = nn.functional.mse_loss(out["z_k1_pred"], z_k1_true)
    reconstruction = nn.functional.mse_loss(out["x_k_recon"], x_k)

    return prediction + alpha * linearity + beta * reconstruction

latent_spectrum Bu ketma-ketlik modeliga erishishdan ko'ra ko'proq o'qitishga arziydi: o'rganilgan operator hali ham matritsa bo'lib qoladi, shuning uchun 4.2-barqarorlik testi va 4.3-bo'limda kechikish testi chuqur modelga o'zgarishsiz qo'llaniladi.

7. Amaliy mulohazalar va tuzoqlar

Ranka tanlash. Kesish darajasi $r$ noaniq farqli dialdir - juda past dinamikani o'tkazib yuboradi, juda baland shovqinga mos keladi. Singular-qiymatli tirsakka ko'z olmang; blog allaqachon "shovqinni o'rnatishdan oldin qancha komponentlar" to'g'ri javob beradi, Marchenko-Pastur tasodifiy matritsa nazariyasidan vektorlar va matritsalar bilan murakkab arbitraj. Deraza shakli uchun yagona qiymatlari Marchenko-Pastur chetidan oshib ketadigan komponentlarni saqlang va natijani ko'rsating. $r$ siz nashr etayotgan har bir spektrning yonida.

Oyna uzunligi. Koopman nazariyasi qat'iy belgilangan $F$ ; bozorlar bitta narsani ta'minlamaydi. Qayta tiklash majburiydir va 4.2-bo'limning barqarorlik egri chizig'i tanlangan oynaning taxmin qilish uchun etarlicha uzunligini va bitta rejim ichida qolish uchun etarlicha qisqa ekanligini aniqlash uchun aniq diagnostika hisoblanadi.

Shovqin sezgirligi. Moliyaviy maʼlumotlar past signal/shovqin nisbatiga ega va standart DMD shovqinga bogʻliq. $X$ . Rejimlar beqaror degan xulosaga kelishdan oldin sinab ko'rishga arziydigan vositalar:

• Total DMD (TDMD) — ikkalasini ham davolaydi $X$ va $X'$ jami eng kichik kvadratlar orqali shovqinli.
• Optimallashtirilgan DMD — qoldiq Frobenius normasiga nisbatan xos qiymat rejimining parchalanishini bevosita optimallashtiradi.
• Yadro EDMD — lug'at yaratmasdan yuqori o'lchamli xususiyat maydonida aniq ishlaydi.

Agar rejim barqarorligi TDMD ostida sezilarli darajada oshsa, beqarorlik o'lchov shovqini edi. Agar shunday bo'lmasa, bu bozor edi.

8. DMD qaerda o'tiradi

O'zgaruvchanlikka xos prognozlash uchun taqqoslash nuqtasi GARCH oilasi - qarang Kripto uchun GARCH o'zgaruvchanligini prognozlash. To'liq chiziqli bo'lmagan ketma-ketlik modellari va ularning talqin qilinishi va xato to'planishi bilan bog'liq kelishuvlar uchun qarang Savdoda vaqtinchalik termoyadroviy transformator.

DMD ning joylashuvi tor, ammo haqiqiydir: avtoregressiv chiqish emas, balki bitta matritsa quvvati tomonidan yaratilgan ko'p bosqichli prognozlar, har bir rejim tekshirilishi mumkin. Bu joy alfani o'z ichiga oladimi, bu jadvalning emas, balki 4-bo'limning savolidir.

Xulosa

Koopman nazariyasi bozor dinamikasiga qarashning chinakam nafis usulidir va nafislik aynan nima uchun mavjud bo'lgan eng qattiq sinovga muhtoj. Takliflar:

1. DMD-ni moslang, so'ngra darhol mosligini sinab ko'ring. Faza bo'yicha tasodifiy null bilan o'lchanadigan qo'shni oynalar orasidagi pastki bo'shliqning o'xshashligi sizga tushdan keyin tuzilmani topganingizni yoki oynani yodlaganingizni bildiradi.
2. Darajlanuvchi spektr radiusi kuzatilishi kerak bo'lgan bir skalyardir va uning qiymati butunlay oldingi kechikish natijasiga bog'liq. Kechikish 0 da bu o'zgaruvchanlik proksi; salbiy kechikishda bu rejim ogohlantirishidir.
3. Oxirgi suratda langar amplitudalarini belgilang va hech qachon xususiy qiymatlarni oyna uzunligiga oshirmang. Yovvoyi tabiatdagi DMD "signallari" ning katta qismi suzuvchi nuqtali artefaktlardir.
4. Tirsak bilan emas, balki Marchenko-Pastur bo'yicha darajani tanlang va darajani har bir spektr bilan e'lon qiling.
5. Spektr syujeti natija emas. Buning ustiga qurilgan har qanday strategiya hisobdan oldin toʻlovlar, sirpanishlar va deflatsiyalangan Sharpe sinovidan omon qolishi kerak.

Ulardan tashqari ilovalar uchun PyDMD kutubxonasi DMD variantlarini har tomonlama qamrab oladi va Mallen va boshqalarning mos yozuvlar kodi chuqur Koopman tomonini qamrab oladi.

Bozorlar tartibsiz, statsionar bo'lmagan va qisman kuzatilgan bo'lib qoladi. Koopman nazariyasi ushbu tartibsizlikdan tuzilmani ajratib olish uchun printsipial ob'ektivni taklif qiladi - agar siz strukturaning keyingi haftada mavjudligini tekshirsangiz.

Ma'lumotnomalar va qo'shimcha o'qish:

• B. O. Kupman, "Gamilton tizimlari va Hilbert fazosida transformatsiyalar", * Milliy Fanlar Akademiyasi materiallari*, 1931 yil.
• J. H. Tu va boshqalar, "Dinamik rejimlar dekompozitsiyasi: nazariya va qo‘llanmalar", Journal of Computational Dynamics, 2014 yil.
• M. O. Uilyams, I. G. Kevrekidis, C. V. Rouli, "Koopman operatorining ma'lumotlarga asoslangan yaqinlashuvi: dinamik rejimning parchalanishini kengaytirish", * Nonlinear fanlar jurnali*, 2015 yil.
• B. Lusch, J. N. Kutz, S. L. Brunton, "Chiziqli bo'lmagan dinamikaning universal chiziqli o'rnatilishi uchun chuqur o'rganish", * Tabiat aloqalari *, 2018 yil.
• J. Mann va J. N. Kutz, "Moliyaviy savdo strategiyalari uchun dinamik rejim dekompozitsiyasi", * Miqdoriy moliya*, 2016 yil.
• A. Mallen va boshqalar, "Vaqtinchalik taqsimot siljishi bilan vaqt seriyasi uchun Koopman neyron forekasteri", ICML, 2023 yil.
• E. Gonsales va M. Generelo, "Koopman operatorlari, EDMD, Takens teoremasi va Machine Learning orqali xaotik iqtisodiy modellarni tahlil qilish", Moliya va iqtisodda ma'lumotlar fani, 2022 yil.