code/methods/sequence.py

"""Sequence-family methods for the MacroLens unified API.

Three classes — :class:`DLinear`, :class:`ITransformer`, :class:`ModernTCN`
— each implementing the sklearn-style :class:`~methods.base.Method`
contract. Coverage per the plan §9 matrix:

    | Class       | name           | family     | tasks            |
    |-------------|----------------|------------|------------------|
    | DLinear     | "dlinear"      | "sequence" | {"T1", "T4"}     |
    | ITransformer| "itransformer" | "sequence" | {"T1", "T4"}     |
    | ModernTCN   | "moderntcn"    | "sequence" | {"T1", "T4"}     |

T2 / T5 are dropped from the sequence family (plan §9 footnote): they
are point-in-time fundamentals snapshots, not time-series, so a 1-step
"lookback" hack adds no signal. T2/T5 deep-learning representation is
delegated to LLMs.

Per-task input / output:

* **T1** — Time-series forecasting.
  ``X`` is ``np.ndarray`` shape ``(N, lookback, F)`` float32. ``y`` is
  ``np.ndarray`` shape ``(N, horizon)`` float32 (close-price
  trajectory). ``predict(X)`` returns ``(N, horizon)`` float32 — the
  model emits the full horizon-length trajectory directly.
* **T4** — Scenario-return regression.
  ``X`` is a ``pd.DataFrame`` with three columns: ``lookback`` (object
  dtype, each cell is a ``(L, F)`` ndarray), ``event_type`` (str), and
  ``event_description`` (str). ``y`` is ``np.ndarray`` shape ``(N,)``
  float32 — the realised ``actual_return_pct``. ``predict(X)`` returns
  ``(N,)`` float32.

Hard rules (enforced by ``tests/test_layer_isolation.py`` and
``tests/test_method_contract.py``):

* Zero IO. Zero eval imports. Zero ``meta`` consumption. Zero
  subsampling.
* Imports point at ``methods._vendored.{tslib,moderntcn}``.
* Respects ``MACROLENS_DETERMINISTIC`` env var
  (``torch.use_deterministic_algorithms(True)`` if set).
* The ``seed`` arg to ``fit`` seeds Python, numpy, and torch (CUDA too
  when available).
* Persists state via :class:`~methods.base._TorchSaveMixin`
  (``state.pt`` + ``manifest.json``) with model-shape ``aux`` so
  :meth:`load` can rebuild the architecture before reading the
  ``state_dict``.

T4 specifics for v1: sequence models do not consume the ``event_type``
or ``event_description`` text columns (they're vector-only models).
Future work — fold an event-type one-hot into the lookback channel
axis — is tracked in `methods/_vendored/CHANGES.md` future-work notes,
not implemented here.
"""

from __future__ import annotations

import json
import os
import pathlib
import random
from types import SimpleNamespace
from typing import Any, ClassVar

import numpy as np
import pandas as pd
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

from ._config import (
    DLinearConfig,
    ITransformerConfig,
    ModernTCNConfig,
    SequenceConfig,
)
from ._registry import register
from ._vendored.moderntcn.models.ModernTCN import Model as ModernTCNOfficial
from ._vendored.tslib.models.DLinear import Model as DLinearOfficial
from ._vendored.tslib.models.iTransformer import Model as ITransformerOfficial
from .base import Method, _TorchSaveMixin


_SEQUENCE_TASKS = frozenset({"T1", "T4"})


# ── NaN imputation for sequence models ───────────────────────────────────


def _ffill_impute_panel(X: np.ndarray) -> np.ndarray:
    """Forward-fill NaN along the lookback (time) axis, then 0-fill any
    remaining (timesteps before the first valid observation).

    Sequence models (DLinear / iTransformer / ModernTCN) propagate NaN
    through their forward pass — softmax(NaN) = NaN, attention scores
    blow up, etc. We therefore impute BEFORE the forward pass at both
    fit and predict time. Per-ticker forward-fill within the lookback
    window preserves the most recent observed value as the best
    causal estimate; remaining leading-NaN cells go to 0.

    Parameters
    ----------
    X
        ``(N, L, F)`` float32 panel; may contain NaN / +/-inf.

    Returns
    -------
    np.ndarray
        Same shape, NaN- and inf-free.
    """
    if X.size == 0 or not np.isnan(X).any() and not np.isinf(X).any():
        return X
    # Replace +/-inf with NaN first so the ffill logic catches both.
    out = np.where(np.isfinite(X), X, np.nan).astype(np.float32, copy=True)
    n, L, F = out.shape
    # Vectorized per-(sample, feature) forward-fill along axis=1:
    # build an index array of "last valid timestep at or before t".
    # ``valid`` is bool (N, L, F).
    valid = ~np.isnan(out)
    # For each (n, f), index = max valid timestep <= t (else -1).
    idx = np.where(valid, np.arange(L)[None, :, None], -1)
    last_valid = np.maximum.accumulate(idx, axis=1)
    have_any = last_valid >= 0
    # Gather along the L axis: out_ff[n, t, f] = out[n, last_valid[n,t,f], f]
    n_idx = np.arange(n)[:, None, None]
    f_idx = np.arange(F)[None, None, :]
    safe_last = np.where(have_any, last_valid, 0)
    gathered = out[n_idx, safe_last, f_idx]
    out_ff = np.where(have_any, gathered, 0.0).astype(np.float32)
    return out_ff


def _ffill_impute_2d(X: np.ndarray) -> np.ndarray:
    """``_ffill_impute_panel`` for a single ``(L, F)`` cell.

    Used by T4 lookback stacking where every cell must be imputed before
    being concatenated into ``(N, L, F)``. The 3-D path is the hot loop
    so we keep this thin wrapper.
    """
    return _ffill_impute_panel(X[None, :, :])[0]


# ── Determinism / seeding ────────────────────────────────────────────────


def _apply_seed(seed: int) -> None:
    """Seed Python, numpy and torch (CPU + CUDA). Idempotent."""
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed_all(seed)
    # Disable cuDNN: this host's cuDNN library raises CUDNN_STATUS_NOT_INITIALIZED
    # on Conv1d (used inside iTransformer's Transformer_EncDec ConvFFN block and
    # ModernTCN's depthwise/pointwise convs). Falling back to non-cuDNN conv
    # kernels keeps the sequence family runnable on this box.
    if torch.cuda.is_available():
        torch.backends.cudnn.enabled = False
    if os.environ.get("MACROLENS_DETERMINISTIC", "") == "1":
        # ``warn_only=True`` so non-deterministic CUDA kernels still run on
        # CPU smoke tests; the flag value lands in RunRecord.deterministic_mode
        # for downstream auditing.
        torch.use_deterministic_algorithms(True, warn_only=True)
        torch.backends.cudnn.deterministic = True
        torch.backends.cudnn.benchmark = False


# ── Vendored-model wrappers (Method-contract glue, NOT source patches) ───


class _TSLibWrapper(nn.Module):
    """Thin :class:`nn.Module` wrapping the official TSLib ``Model`` classes.

    TSLib expects a ``configs`` namespace and a forward signature of
    ``forward(x_enc, x_mark_enc, x_dec, x_mark_dec)``; it returns
    ``[B, pred_len, D]``. We expose ``forward(x: (B, L, F)) -> (B, pred_len)``
    by selecting the target variate at ``self.target_idx``.
    """

    def __init__(
        self,
        model_cls: Any,
        n_features: int,
        seq_len: int,
        pred_len: int,
        target_idx: int,
        **model_kwargs: Any,
    ) -> None:
        super().__init__()
        self.target_idx = int(target_idx)
        self.pred_len = int(pred_len)
        cfg = SimpleNamespace(
            task_name="long_term_forecast",
            seq_len=seq_len,
            pred_len=pred_len,
            enc_in=n_features,
            d_model=model_kwargs.get("d_model", 128),
            n_heads=model_kwargs.get("n_heads", 4),
            e_layers=model_kwargs.get("e_layers", 3),
            d_ff=model_kwargs.get("d_ff", 256),
            dropout=model_kwargs.get("dropout", 0.1),
            factor=model_kwargs.get("factor", 1),
            embed="timeF",
            freq="h",
            activation=model_kwargs.get("activation", "gelu"),
            moving_avg=model_kwargs.get("moving_avg", 25),
        )
        self.model = model_cls(cfg)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x: (B, L, F) -> out: (B, pred_len, F) -> (B, pred_len)
        out = self.model(x, None, None, None)
        return out[:, :, self.target_idx]


class _ModernTCNWrapper(nn.Module):
    """Thin :class:`nn.Module` wrapping the official ModernTCN ``Model``.

    ModernTCN consumes ``[B, L, D]`` and emits ``[B, pred_len, D]``; we
    take the target variate to produce ``(B, pred_len)``.
    """

    def __init__(
        self,
        n_features: int,
        seq_len: int,
        pred_len: int,
        target_idx: int,
        **model_kwargs: Any,
    ) -> None:
        super().__init__()
        self.target_idx = int(target_idx)
        self.pred_len = int(pred_len)

        d_model = int(model_kwargs.get("d_model", 64))
        # ModernTCN's source unconditionally builds 4 downsample stages
        # (stem + 3); ``dims`` and ``dw_dims`` therefore must contain 4
        # entries even when ``num_blocks`` only uses one stage.
        default_dims = [d_model, d_model, d_model, d_model]
        cfg = SimpleNamespace(
            patch_size=int(model_kwargs.get("patch_size", 16)),
            patch_stride=int(model_kwargs.get("patch_stride", 8)),
            kernel_size=int(model_kwargs.get("kernel_size", 25)),
            stem_ratio=int(model_kwargs.get("stem_ratio", 1)),
            downsample_ratio=int(model_kwargs.get("downsample_ratio", 2)),
            ffn_ratio=int(model_kwargs.get("ffn_ratio", 2)),
            num_blocks=list(model_kwargs.get("num_blocks", [1])),
            large_size=list(model_kwargs.get("large_size", [51])),
            small_size=list(model_kwargs.get("small_size", [5])),
            dims=list(model_kwargs.get("dims", default_dims)),
            dw_dims=list(model_kwargs.get("dw_dims", default_dims)),
            enc_in=n_features,
            small_kernel_merged=False,
            dropout=float(model_kwargs.get("dropout", 0.1)),
            head_dropout=float(model_kwargs.get("head_dropout", 0.1)),
            use_multi_scale=bool(model_kwargs.get("use_multi_scale", False)),
            revin=bool(model_kwargs.get("revin", True)),
            affine=bool(model_kwargs.get("affine", True)),
            subtract_last=False,
            freq="h",
            seq_len=seq_len,
            individual=False,
            pred_len=pred_len,
            decomposition=bool(model_kwargs.get("decomposition", False)),
        )
        self.model = ModernTCNOfficial(cfg)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        # x: (B, L, F) -> out: (B, pred_len, F) -> (B, pred_len)
        out = self.model(x)
        return out[:, :, self.target_idx]


# ── Training loop (private; no IO) ───────────────────────────────────────


def _train_torch(
    model: nn.Module,
    X_train: np.ndarray,
    y_train: np.ndarray,
    *,
    epochs: int,
    batch_size: int,
    lr: float,
    weight_decay: float,
    grad_clip: float,
    patience: int,
    device: str,
) -> nn.Module:
    """Train a torch model with 10%-holdout early stopping.

    AMP is enabled on CUDA, disabled on CPU.
    """
    use_amp = device.startswith("cuda")
    model = model.to(device)
    n = len(X_train)
    if n < 2:
        return model

    n_val = max(1, int(n * 0.1))
    perm = np.random.permutation(n)
    val_idx = perm[:n_val]
    train_idx = perm[n_val:]

    X_t = torch.tensor(X_train[train_idx], dtype=torch.float32)
    y_t = torch.tensor(y_train[train_idx], dtype=torch.float32)
    X_v = torch.tensor(X_train[val_idx], dtype=torch.float32).to(device)
    y_v = torch.tensor(y_train[val_idx], dtype=torch.float32).to(device)

    train_loader = DataLoader(
        TensorDataset(X_t, y_t),
        batch_size=batch_size,
        shuffle=True,
        pin_memory=use_amp,
        num_workers=0,
    )

    optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=weight_decay)
    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)
    criterion = nn.MSELoss()
    scaler = torch.amp.GradScaler(device) if use_amp else None

    best_val = float("inf")
    best_state: dict[str, torch.Tensor] | None = None
    wait = 0

    for _epoch in range(epochs):
        model.train()
        for xb, yb in train_loader:
            xb = xb.to(device, non_blocking=True)
            yb = yb.to(device, non_blocking=True)
            optimizer.zero_grad(set_to_none=True)
            if use_amp:
                with torch.amp.autocast(device):
                    pred = model(xb)
                    loss = criterion(pred, yb)
                scaler.scale(loss).backward()
                scaler.unscale_(optimizer)
                torch.nn.utils.clip_grad_norm_(model.parameters(), grad_clip)
                scaler.step(optimizer)
                scaler.update()
            else:
                pred = model(xb)
                loss = criterion(pred, yb)
                loss.backward()
                torch.nn.utils.clip_grad_norm_(model.parameters(), grad_clip)
                optimizer.step()

        scheduler.step()

        model.eval()
        with torch.no_grad():
            if use_amp:
                with torch.amp.autocast(device):
                    val_loss = criterion(model(X_v), y_v).item()
            else:
                val_loss = criterion(model(X_v), y_v).item()

        if val_loss < best_val:
            best_val = val_loss
            best_state = {k: v.detach().cpu().clone() for k, v in model.state_dict().items()}
            wait = 0
        else:
            wait += 1
            if wait >= patience:
                break

    if best_state is not None:
        model.load_state_dict(best_state)
    return model


# ── Shared base for the three concrete classes ───────────────────────────


class _SequenceMethodBase(_TorchSaveMixin, Method):
    """Shared fit / predict / save / load implementation.

    Concrete subclasses set:

    * ``name``  — registry id (``dlinear`` / ``itransformer`` / ``moderntcn``).
    * ``family`` — ``"sequence"``.
    * ``tasks`` — ``frozenset({"T1", "T4"})``.
    * ``_config_class`` (set by ``@register``) — the concrete Pydantic config.
    * ``_build_model(n_features, seq_len, pred_len, target_idx, model_kwargs)``
      — returns a ready-to-train ``nn.Module``.
    """

    name: ClassVar[str] = ""
    family: ClassVar[str] = "sequence"
    tasks: ClassVar[frozenset[str]] = _SEQUENCE_TASKS
    schema_version: ClassVar[int] = 1

    # ── construction ────────────────────────────────────────────────────

    def __init__(
        self,
        *,
        task: str,
        config: SequenceConfig | None = None,
        device: str | None = None,
        **kwargs: Any,
    ) -> None:
        if task not in self.tasks:
            raise ValueError(
                f"{type(self).__name__} does not support task {task!r}; "
                f"supported = {sorted(self.tasks)}"
            )
        self.task: str = task
        if config is None:
            config = self.default_config()  # type: ignore[assignment]
            if kwargs:
                # Pydantic frozen=True so build a new config with overrides.
                config = config.__class__(**{**config.model_dump(), **kwargs})
        elif kwargs:
            raise ValueError(
                "pass either `config=` or extra kwargs, not both."
            )
        self.config: SequenceConfig = config
        self.device: str = device or ("cuda" if torch.cuda.is_available() else "cpu")

        # State populated by .fit() — set lazily so .save / .load can detect
        # un-fitted instances cleanly.
        self._model: nn.Module | None = None
        self._aux: dict[str, Any] = {}
        self._scaler: dict[str, np.ndarray | float] | None = None

    # ── concrete-subclass hook ───────────────────────────────────────────

    def _build_model(
        self,
        *,
        n_features: int,
        seq_len: int,
        pred_len: int,
        target_idx: int,
    ) -> nn.Module:
        raise NotImplementedError

    # ── public API ──────────────────────────────────────────────────────

    def fit(self, X: Any, y: Any, *, seed: int = 42) -> "_SequenceMethodBase":
        _apply_seed(seed)
        if self.task == "T1":
            self._fit_t1(X, y)
        elif self.task == "T4":
            self._fit_t4(X, y)
        else:  # pragma: no cover -- guarded by ctor.
            raise RuntimeError(f"unhandled task {self.task!r}")
        return self

    def predict(self, X: Any) -> np.ndarray:
        if self._model is None:
            raise RuntimeError(
                f"{type(self).__name__}.predict called before fit(); "
                f"call .fit(X, y) first."
            )
        if self.task == "T1":
            return self._predict_t1(X)
        if self.task == "T4":
            return self._predict_t4(X)
        raise RuntimeError(f"unhandled task {self.task!r}")  # pragma: no cover

    # ── T1 (TSF) ────────────────────────────────────────────────────────

    def _fit_t1(self, X: Any, y: Any) -> None:
        """Train the sequence model on per-window log-returns.

        Same blow-up rationale as ``methods/classical.py:_fit_t1``: T1
        close prices span $0.50 to $5,000 across the small-cap universe,
        so a global y z-score is dominated by high-price tickers and the
        de-normalised output is unbounded. We instead target the
        log-return relative to each window's last close::

            c_i = X_i[-1, target_idx]
            y_log[i, h] = log(y[i, h] / c_i)

        The neural net learns a dimensionless O(1) target. At predict time
        we exponentiate and rescale by the test window's last close.
        """
        X_arr = np.asarray(X, dtype=np.float32)  # (N, L, F)
        y_arr = np.asarray(y, dtype=np.float32)  # (N, horizon)
        if X_arr.ndim != 3:
            raise ValueError(f"T1 X must be (N, L, F); got {X_arr.shape}")
        if y_arr.ndim != 2:
            raise ValueError(f"T1 y must be (N, horizon); got {y_arr.shape}")
        if X_arr.shape[0] != y_arr.shape[0]:
            raise ValueError(
                f"T1 X/y row mismatch: X={X_arr.shape[0]}, y={y_arr.shape[0]}"
            )

        # Per-window forward-fill imputation along the lookback axis —
        # sequence models propagate NaN through softmax and produce
        # all-NaN forecasts otherwise.
        X_arr = _ffill_impute_panel(X_arr)

        n, lookback, n_features = X_arr.shape
        horizon = int(y_arr.shape[1])
        target_idx = int(self.config.target_idx)
        if not 0 <= target_idx < n_features:
            raise ValueError(
                f"target_idx={target_idx} out of range for F={n_features}"
            )

        # Drop windows where log target is undefined / unstable.
        c = X_arr[:, -1, target_idx].astype(np.float64)
        y_f = y_arr.astype(np.float64)
        keep = (
            np.isfinite(c) & (c > 0.0) &
            np.isfinite(y_f).all(axis=1) & (y_f > 0.0).all(axis=1)
        )
        n_total = int(n)
        n_keep = int(keep.sum())
        if n_keep < 1:
            raise RuntimeError(
                f"T1 fit: only {n_keep}/{n_total} training windows have "
                "positive finite close + horizon prices; cannot fit "
                "log-return target."
            )
        X_arr = X_arr[keep]
        c = c[keep]
        y_log = np.log(y_f[keep] / c[:, None]).astype(np.float32)

        # Per-feature z-score on inputs (X normalisation is unchanged;
        # only the target now uses per-window log-return).
        feat_mean = X_arr.reshape(-1, n_features).mean(axis=0).astype(np.float32)
        feat_std = (X_arr.reshape(-1, n_features).std(axis=0) + 1e-8).astype(np.float32)
        X_n = (X_arr - feat_mean) / feat_std

        model = self._build_model(
            n_features=n_features, seq_len=lookback,
            pred_len=horizon, target_idx=target_idx,
        )
        model = _train_torch(
            model, X_n, y_log,
            epochs=self.config.epochs, batch_size=self.config.batch_size,
            lr=self.config.learning_rate, weight_decay=self.config.weight_decay,
            grad_clip=self.config.grad_clip, patience=self.config.patience,
            device=self.device,
        )
        self._model = model
        # ``_scaler`` carries feat_mean/feat_std for X normalisation and
        # the log-return clip range for de-normalisation. y_mean/y_std are
        # kept as 0/1 for backwards-compat with the legacy save/load path.
        self._scaler = {
            "feat_mean": feat_mean, "feat_std": feat_std,
            "y_mean": 0.0, "y_std": 1.0,
            "log_clip": 2.0,
            "target_for": "log_return",
        }
        self._aux = {
            "task": self.task,
            "n_features": int(n_features),
            "seq_len": int(lookback),
            "pred_len": int(horizon),
            "target_idx": int(target_idx),
        }

    def _predict_t1(self, X: Any) -> np.ndarray:
        arr = np.asarray(X, dtype=np.float32)
        if arr.ndim != 3:
            raise ValueError(f"T1 predict expects (N, L, F); got {arr.shape}")
        assert self._scaler is not None and self._model is not None
        target_idx = int(self._aux.get("target_idx", 0))
        # Capture the per-window last close BEFORE imputation so we don't
        # silently substitute a forward-filled value as the rescaler.
        c_test = arr[:, -1, target_idx].astype(np.float64)
        c_safe = np.where(np.isfinite(c_test) & (c_test > 0.0), c_test, np.nan)

        arr_imp = _ffill_impute_panel(arr)
        arr_n = (arr_imp - self._scaler["feat_mean"]) / self._scaler["feat_std"]

        self._model.eval()
        device = self.device
        use_amp = device.startswith("cuda")
        out_chunks: list[np.ndarray] = []
        bs = 1024
        with torch.no_grad():
            for i in range(0, arr_n.shape[0], bs):
                batch = torch.tensor(arr_n[i : i + bs], dtype=torch.float32).to(device)
                if use_amp:
                    with torch.amp.autocast(device):
                        p = self._model(batch).float().cpu().numpy()
                else:
                    p = self._model(batch).cpu().numpy()
                out_chunks.append(p)
        log_pred = np.concatenate(out_chunks, axis=0).astype(np.float64)
        # Backwards-compat: if loading a legacy checkpoint that used the
        # global z-score target, fall back to the de-z-score path.
        if self._scaler.get("target_for") != "log_return":
            preds = (
                log_pred * float(self._scaler.get("y_std", 1.0))
                + float(self._scaler.get("y_mean", 0.0))
            )
            return preds.astype(np.float32)

        clip = float(self._scaler.get("log_clip", 2.0))
        log_pred = np.clip(log_pred, -clip, clip)
        out = c_safe[:, None] * np.exp(log_pred)
        bad = ~np.isfinite(out)
        if bad.any():
            tile = np.broadcast_to(c_test[:, None], out.shape).astype(np.float64)
            out = np.where(bad, tile, out)
        # Final guard: if c_test itself is non-finite the tile fallback above
        # still leaks NaN/inf into ``out``. Coerce to a finite degenerate
        # prediction (0.0) so downstream eval doesn't crash on NaN.
        out = np.nan_to_num(out, nan=0.0, posinf=0.0, neginf=0.0)
        return out.astype(np.float32)

    # ── T4 (Scenario-return) ────────────────────────────────────────────

    @staticmethod
    def _stack_t4_lookback(X: pd.DataFrame) -> np.ndarray:
        """Stack the ``lookback`` object column into a contiguous
        ``(N, L, F)`` ndarray. Validates that every cell shares one shape.
        """
        if not isinstance(X, pd.DataFrame):
            raise TypeError(f"T4 X must be a DataFrame; got {type(X).__name__}")
        if "lookback" not in X.columns:
            raise ValueError("T4 X is missing the required 'lookback' column.")
        cells = X["lookback"].tolist()
        if not cells:
            raise ValueError("T4 X has zero rows.")
        first = np.asarray(cells[0], dtype=np.float32)
        if first.ndim != 2:
            raise ValueError(
                f"T4 lookback cells must be 2D (L, F); got shape {first.shape}"
            )
        out = np.empty((len(cells), first.shape[0], first.shape[1]), dtype=np.float32)
        for i, c in enumerate(cells):
            arr = np.asarray(c, dtype=np.float32)
            if arr.shape != first.shape:
                raise ValueError(
                    f"T4 lookback cell {i} shape {arr.shape} != first cell shape "
                    f"{first.shape}; all rows must share lookback length and "
                    "feature count."
                )
            out[i] = arr
        return out

    def _fit_t4(self, X: Any, y: Any) -> None:
        lb = self._stack_t4_lookback(X)  # (N, L, F)
        # Per-window forward-fill imputation along the lookback axis.
        # T4 lookback object cells are sourced from the same panel as T1
        # and may carry sparse NaN (financial fundamentals) — same
        # softmax-propagation hazard.
        lb = _ffill_impute_panel(lb)
        y_arr = np.asarray(y, dtype=np.float32)
        if y_arr.ndim != 1:
            raise ValueError(f"T4 y must be (N,); got {y_arr.shape}")
        if lb.shape[0] != y_arr.shape[0]:
            raise ValueError(
                f"T4 X/y row mismatch: X={lb.shape[0]}, y={y_arr.shape[0]}"
            )

        n, lookback, n_features = lb.shape
        # T4 regresses a single scalar per sample; pred_len = 1. The wrapper
        # selects target_idx 0 (the lookback features have no canonical target
        # column; we use a single-step direct regression head).
        target_idx = 0

        feat_mean = lb.reshape(-1, n_features).mean(axis=0).astype(np.float32)
        feat_std = (lb.reshape(-1, n_features).std(axis=0) + 1e-8).astype(np.float32)
        X_n = (lb - feat_mean) / feat_std

        y_mean = float(y_arr.mean())
        y_std = float(y_arr.std() + 1e-8)
        y_n = ((y_arr - y_mean) / y_std).reshape(-1, 1)  # (N, 1) — pred_len=1

        model = self._build_model(
            n_features=n_features, seq_len=lookback, pred_len=1,
            target_idx=target_idx,
        )
        model = _train_torch(
            model, X_n, y_n,
            epochs=self.config.epochs, batch_size=self.config.batch_size,
            lr=self.config.learning_rate, weight_decay=self.config.weight_decay,
            grad_clip=self.config.grad_clip, patience=self.config.patience,
            device=self.device,
        )
        self._model = model
        self._scaler = {
            "feat_mean": feat_mean, "feat_std": feat_std,
            "y_mean": y_mean, "y_std": y_std,
        }
        self._aux = {
            "task": self.task,
            "n_features": int(n_features),
            "seq_len": int(lookback),
            "pred_len": 1,
            "target_idx": target_idx,
        }

    def _predict_t4(self, X: Any) -> np.ndarray:
        lb = self._stack_t4_lookback(X)
        # Same per-window forward-fill imputation as fit.
        lb = _ffill_impute_panel(lb)
        assert self._scaler is not None and self._model is not None
        if lb.shape[2] != self._aux.get("n_features"):
            raise ValueError(
                f"T4 predict feature count {lb.shape[2]} != train "
                f"{self._aux.get('n_features')}; loader contract violation."
            )
        X_n = (lb - self._scaler["feat_mean"]) / self._scaler["feat_std"]

        self._model.eval()
        device = self.device
        use_amp = device.startswith("cuda")
        out_chunks: list[np.ndarray] = []
        bs = 1024
        with torch.no_grad():
            for i in range(0, X_n.shape[0], bs):
                batch = torch.tensor(X_n[i : i + bs], dtype=torch.float32).to(device)
                if use_amp:
                    with torch.amp.autocast(device):
                        p = self._model(batch).float().cpu().numpy()
                else:
                    p = self._model(batch).cpu().numpy()
                out_chunks.append(p)
        preds_n = np.concatenate(out_chunks, axis=0)  # (N, 1)
        preds = preds_n.reshape(-1) * self._scaler["y_std"] + self._scaler["y_mean"]
        # Guard: tiny-sample / instability can produce NaN; replace with the
        # train-target mean (the unconditional best constant predictor under
        # MSE). Safer than emitting NaN that crashes ml.score downstream.
        preds = np.where(np.isfinite(preds), preds, float(self._scaler["y_mean"]))
        return preds.astype(np.float32)

    # ── default_config (overridden via @register) ───────────────────────

    @classmethod
    def default_config(cls) -> SequenceConfig:
        # ``@register`` injects ``_config_class`` and a default_config; this
        # placeholder satisfies the abstract-method check during class
        # creation. The decorator overwrites it.
        return SequenceConfig()  # pragma: no cover

    # ── load (override _TorchSaveMixin to rebuild architecture) ─────────

    @classmethod
    def load(cls, path: pathlib.Path) -> "_SequenceMethodBase":
        path = pathlib.Path(path)
        manifest = Method._check_manifest(path, cls.name, cls.schema_version)
        payload = torch.load(path / "state.pt", weights_only=False)

        cfg_cls = cls._config_class  # type: ignore[attr-defined]
        config = cfg_cls(**payload["config"])
        instance = cls(task=payload["task"], config=config)

        aux = payload.get("aux", {}) or {}
        if not aux:
            # State was never fitted; nothing to reconstruct.
            return instance

        instance._aux = dict(aux)
        instance._model = instance._build_model(
            n_features=int(aux["n_features"]),
            seq_len=int(aux["seq_len"]),
            pred_len=int(aux["pred_len"]),
            target_idx=int(aux["target_idx"]),
        )
        instance._model.load_state_dict(payload["state_dict"])
        instance._model.to(instance.device)

        scaler_path = path / "scaler.joblib"
        if scaler_path.exists():
            import joblib
            instance._scaler = joblib.load(scaler_path)
        return instance


# ── Concrete classes ─────────────────────────────────────────────────────


@register(
    name="dlinear", family="sequence",
    tasks=_SEQUENCE_TASKS, config_class=DLinearConfig,
)
class DLinear(_SequenceMethodBase):
    """DLinear — Zeng et al., AAAI 2023 (TSLib official source).

    Predicts a horizon-length close-price trajectory for T1; a single
    scalar return percentage for T4.
    """

    @classmethod
    def default_config(cls) -> DLinearConfig:
        return DLinearConfig()

    def _build_model(
        self,
        *,
        n_features: int,
        seq_len: int,
        pred_len: int,
        target_idx: int,
    ) -> nn.Module:
        cfg: DLinearConfig = self.config  # type: ignore[assignment]
        return _TSLibWrapper(
            DLinearOfficial,
            n_features=n_features,
            seq_len=seq_len,
            pred_len=pred_len,
            target_idx=target_idx,
            moving_avg=cfg.moving_avg,
        )


@register(
    name="itransformer", family="sequence",
    tasks=_SEQUENCE_TASKS, config_class=ITransformerConfig,
)
class ITransformer(_SequenceMethodBase):
    """iTransformer — Liu et al., ICLR 2024 (TSLib official source).

    Predicts a horizon-length close-price trajectory for T1; a single
    scalar return percentage for T4.
    """

    @classmethod
    def default_config(cls) -> ITransformerConfig:
        return ITransformerConfig()

    def _build_model(
        self,
        *,
        n_features: int,
        seq_len: int,
        pred_len: int,
        target_idx: int,
    ) -> nn.Module:
        cfg: ITransformerConfig = self.config  # type: ignore[assignment]
        return _TSLibWrapper(
            ITransformerOfficial,
            n_features=n_features,
            seq_len=seq_len,
            pred_len=pred_len,
            target_idx=target_idx,
            d_model=cfg.d_model,
            n_heads=cfg.n_heads,
            e_layers=cfg.e_layers,
            d_ff=cfg.d_ff,
            dropout=cfg.dropout,
            factor=cfg.factor,
            activation=cfg.activation,
        )


@register(
    name="moderntcn", family="sequence",
    tasks=_SEQUENCE_TASKS, config_class=ModernTCNConfig,
)
class ModernTCN(_SequenceMethodBase):
    """ModernTCN — Luo & Wang, ICLR 2024 (ModernTCN official source).

    Predicts a horizon-length close-price trajectory for T1; a single
    scalar return percentage for T4.
    """

    @classmethod
    def default_config(cls) -> ModernTCNConfig:
        return ModernTCNConfig()

    def _build_model(
        self,
        *,
        n_features: int,
        seq_len: int,
        pred_len: int,
        target_idx: int,
    ) -> nn.Module:
        cfg: ModernTCNConfig = self.config  # type: ignore[assignment]
        return _ModernTCNWrapper(
            n_features=n_features,
            seq_len=seq_len,
            pred_len=pred_len,
            target_idx=target_idx,
            patch_size=cfg.patch_size,
            patch_stride=cfg.patch_stride,
            d_model=cfg.d_model,
            kernel_size=cfg.kernel_size,
            stem_ratio=cfg.stem_ratio,
            downsample_ratio=cfg.downsample_ratio,
            ffn_ratio=cfg.ffn_ratio,
            num_blocks=list(cfg.num_blocks),
            large_size=list(cfg.large_size),
            small_size=list(cfg.small_size),
            dropout=cfg.dropout,
            head_dropout=cfg.head_dropout,
            revin=cfg.revin,
            affine=cfg.affine,
        )


__all__ = ["DLinear", "ITransformer", "ModernTCN"]