Blame for code/experiments/tbd_revision/scripts/train_representation_baselines.py

#!/usr/bin/env python3
"""Controlled representation-learning baselines for the LOBench revision."""

from __future__ import annotations

import argparse
import copy
import hashlib
import json
import math
import os
import random
import socket
import sys
import time
from datetime import datetime, timezone
from functools import partial
from pathlib import Path

import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset

ROOT = Path(__file__).resolve().parents[3]
SRC = ROOT / "experiments/adma2026_representation/src"
if str(SRC) not in sys.path:
    sys.path.insert(0, str(SRC))

from models import (  # noqa: E402
    Classifier,
    LOBConvGridEncoder,
    LOBShapeGatedFlowLevelSimLOBEncoder,
    LOBShapeFlowLevelSimLOBEncoder,
    LOBShapeFlowSimLOBEncoder,
    LOBShapeHybridLevelSimLOBEncoder,
    LOBShapeLevelSimLOBEncoder,
    LOBShapeStructuredLevelSimLOBEncoder,
    LOBGridEncoder,
    LOBShapeGridFusionEncoder,
    LOBShapeSimLOBEncoder,
    LOBShapeWideSimLOBEncoder,
    LOBStructEncoder,
    PositionalEncoding,
    SimLOBStyleEncoder,
    TLOB2025Encoder,
)
from train_downstream import (  # noqa: E402
    classification_metrics,
    count_parameters,
    evaluate,
    load_npz,
    sample_label_budget,
    set_seed,
    train_epoch,
)


def utc_now() -> str:
    return datetime.now(timezone.utc).isoformat()


def sha256_file(path: Path, chunk_size: int = 8 * 1024 * 1024) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as handle:
        while chunk := handle.read(chunk_size):
            digest.update(chunk)
    return digest.hexdigest()


def sha256_tensor(tensor: torch.Tensor) -> str:
    import numpy as np  # noqa: PLC0415

    value = np.ascontiguousarray(
        tensor.detach().cpu().numpy(),
        dtype=np.int64,
    )
    return hashlib.sha256(value.tobytes()).hexdigest()


def sha256_state_dict(state_dict: dict[str, torch.Tensor]) -> str:
    digest = hashlib.sha256()
    for name in sorted(state_dict):
        value = state_dict[name].detach().cpu().contiguous()
        digest.update(name.encode("utf-8"))
        digest.update(b"\0")
        digest.update(str(tuple(value.shape)).encode("ascii"))
        digest.update(b"\0")
        digest.update(str(value.dtype).encode("ascii"))
        digest.update(b"\0")
        digest.update(value.numpy().tobytes())
    return digest.hexdigest()


def atomic_write_json(path: Path, value: dict) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
    temporary.write_text(json.dumps(value, indent=2), encoding="utf-8")
    os.replace(temporary, path)


def atomic_torch_save(state_dict: dict[str, torch.Tensor], path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    temporary = path.with_name(f".{path.name}.tmp-{os.getpid()}")
    torch.save(state_dict, temporary)
    os.replace(temporary, path)


def result_setting_name(config: dict, setting: str) -> str:
    return str(config.get("result_setting_names", {}).get(setting, setting))


def result_path_for(
    config: dict,
    stock: str,
    method: str,
    setting: str,
    seed: int,
    label_budget: float,
) -> Path:
    tag = int(round(label_budget * 100))
    condition = result_setting_name(config, setting)
    return Path(config["results_dir"]) / (
        f"{stock}_{method}_{condition}_seed{seed}_budget{tag:03d}.json"
    )


class AdapterClassifier(nn.Module):
    def __init__(self, encoder: nn.Module, latent_dim: int = 128, num_classes: int = 3, bottleneck: int = 32):
        super().__init__()
        self.encoder = encoder
        self.adapter = nn.Sequential(
            nn.LayerNorm(latent_dim),
            nn.Linear(latent_dim, bottleneck),
            nn.GELU(),
            nn.Linear(bottleneck, latent_dim),
        )
        self.head = nn.Sequential(nn.LayerNorm(latent_dim), nn.Linear(latent_dim, num_classes))

    def forward(self, x):
        z = self.encoder(x)
        z = z + self.adapter(z)
        return self.head(z)


class TransformerBackbone(nn.Module):
    def __init__(self, latent_dim: int = 128, d_model: int = 96, layers: int = 2, nhead: int = 4):
        super().__init__()
        self.in_proj = nn.Linear(40, d_model)
        self.pos = PositionalEncoding(d_model)
        layer = nn.TransformerEncoderLayer(
            d_model=d_model,
            nhead=nhead,
            dim_feedforward=4 * d_model,
            batch_first=True,
            dropout=0.1,
            activation="gelu",
        )
        self.encoder = nn.TransformerEncoder(layer, num_layers=layers)
        self.out = nn.Linear(d_model, latent_dim)

    def sequence(self, x):
        return self.encoder(self.pos(self.in_proj(x)))

    def forward(self, x):
        return self.out(self.sequence(x).mean(dim=1))


class DilatedConvBackbone(nn.Module):
    def __init__(self, latent_dim: int = 128, d_model: int = 96):
        super().__init__()
        self.in_proj = nn.Conv1d(40, d_model, kernel_size=1)
        self.blocks = nn.ModuleList(
            [
                nn.Sequential(
                    nn.Conv1d(d_model, d_model, kernel_size=3, padding=d, dilation=d),
                    nn.GELU(),
                    nn.Conv1d(d_model, d_model, kernel_size=1),
                )
                for d in (1, 2, 4, 8)
            ]
        )
        self.norm = nn.LayerNorm(d_model)
        self.out = nn.Linear(d_model, latent_dim)

    def sequence(self, x):
        h = self.in_proj(x.transpose(1, 2))
        for block in self.blocks:
            h = h + block(h)
        return self.norm(h.transpose(1, 2))

    def forward(self, x):
        return self.out(self.sequence(x).mean(dim=1))


def legalize_lob_prices(raw, gap_scale: float = 0.02):
    bid_raw = raw[:, :, :10].flip(-1)
    ask_raw = raw[:, :, 10:20]
    best_bid = bid_raw[:, :, :1]
    spread = torch.nn.functional.softplus(ask_raw[:, :, :1] - bid_raw[:, :, :1]) * gap_scale + 1e-5
    bid_gaps = torch.nn.functional.softplus(bid_raw[:, :, 1:]) * gap_scale + 1e-5
    ask_gaps = torch.nn.functional.softplus(ask_raw[:, :, 1:]) * gap_scale + 1e-5
    bid_near = torch.cat([best_bid, best_bid - torch.cumsum(bid_gaps, dim=-1)], dim=-1)
    best_ask = best_bid + spread
    ask_near = torch.cat([best_ask, best_ask + torch.cumsum(ask_gaps, dim=-1)], dim=-1)
    out = raw.clone()
    out[:, :, :10] = bid_near.flip(-1)
    out[:, :, 10:20] = ask_near
    return out


class ReconstructionPretrainer(nn.Module):
    def __init__(self, encoder: nn.Module, d_model: int = 96, legalize_prices: bool = False):
        super().__init__()
        self.encoder = encoder
        self.decode = nn.Sequential(nn.Linear(d_model, d_model), nn.GELU(), nn.Linear(d_model, 40))
        self.legalize_prices = legalize_prices

    def forward(self, x):
        pred = self.decode(self.encoder.sequence(x))
        if self.legalize_prices:
            pred = legalize_lob_prices(pred)
        return pred


class TrendReconstructionPretrainer(ReconstructionPretrainer):
    def __init__(self, encoder: nn.Module, d_model: int = 96, legalize_prices: bool = False, latent_dim: int = 128):
        super().__init__(encoder, d_model=d_model, legalize_prices=legalize_prices)
        self.trend_head = nn.Sequential(nn.LayerNorm(latent_dim), nn.Linear(latent_dim, 3))
        self.auxtrend_weight = 0.25
        self.auxtrend_class_weights = None

    def trend_logits(self, x):
        return self.trend_head(self.encoder(x))


class TFCPretrainer(nn.Module):
    def __init__(self, latent_dim: int, d_model: int):
        super().__init__()
        self.encoder = TransformerBackbone(latent_dim=latent_dim, d_model=d_model)
        self.freq_encoder = TransformerBackbone(latent_dim=latent_dim, d_model=d_model)

    def frequency_view(self, x):
        freq = torch.fft.rfft(x, dim=1).abs()
        if freq.size(1) < x.size(1):
            freq = torch.nn.functional.pad(freq, (0, 0, 0, x.size(1) - freq.size(1)))
        return freq[:, : x.size(1)]

    def forward(self, x):
        return self.encoder(x), self.freq_encoder(self.frequency_view(x))


def make_loader(x, y, idx, batch_size, shuffle, num_workers=0, pin_memory=False):
    return DataLoader(
        TensorDataset(x[idx], y[idx]),
        batch_size=batch_size,
        shuffle=shuffle,
        num_workers=num_workers,
        pin_memory=pin_memory,
    )


def load_npz_with_train_index(
    path: Path,
    index_key: str = "train_idx",
    relabel_threshold: float | None = None,
):
    x, y, splits = load_npz(path)
    if index_key != "train_idx" or relabel_threshold is not None:
        import numpy as np  # noqa: PLC0415

        data = np.load(path)
        if index_key != "train_idx":
            if index_key not in data.files:
                raise KeyError(f"{path} does not contain requested index {index_key}")
            splits["train"] = torch.tensor(data[index_key], dtype=torch.long)
        if relabel_threshold is not None:
            if relabel_threshold <= 0:
                raise ValueError("The relabel threshold must be positive")
            if "future_returns" not in data.files:
                raise KeyError(f"{path} does not contain future_returns")
            future_returns = data["future_returns"]
            labels = np.where(
                future_returns > relabel_threshold,
                2,
                np.where(future_returns < -relabel_threshold, 0, 1),
            )
            y = torch.tensor(labels, dtype=torch.long)
    return x, y, splits


def load_test_group_ids(path: Path, test_idx) -> list[str] | None:
    """Return exchange-date labels aligned with the test-loader order."""

    import numpy as np  # noqa: PLC0415

    data = np.load(path)
    if "end_times" not in data.files:
        if "relative_day_id" in data.files:
            return [str(value) for value in data["relative_day_id"][test_idx.cpu().numpy()]]
        return None
    values = data["end_times"][test_idx.cpu().numpy()]
    return [str(value).split("T", 1)[0].split(" ", 1)[0] for value in values]


def data_path_for_stock(config, stock: str) -> Path:
    template = str(config.get("data_file_template", "{stock}_pilot.npz"))
    return Path(config["processed_dir"]) / template.format(stock=stock)


def make_pooled_loader(config, stocks, split, batch_size, shuffle, num_workers=0, pin_memory=False):
    xs = []
    ys = []
    keep_labels = bool(config.get("pooled_keep_labels", False))
    pretrain_index_key = str(config.get("pretrain_index_key", "train_idx"))
    for stock in stocks:
        x, y, splits = load_npz_with_train_index(
            data_path_for_stock(config, stock),
            pretrain_index_key,
        )
        idx = splits[split]
        xs.append(x[idx])
        ys.append(y[idx] if keep_labels else torch.zeros(len(idx), dtype=torch.long))
    return DataLoader(
        TensorDataset(torch.cat(xs, dim=0), torch.cat(ys, dim=0)),
        batch_size=batch_size,
        shuffle=shuffle,
        num_workers=num_workers,
        pin_memory=pin_memory,
    )


def _log_epochs_enabled(cfg):
    return bool(cfg.get("log_epochs", False))


def _log_epoch(cfg, message):
    if _log_epochs_enabled(cfg):
        print(message, flush=True)


def augment(x, mask_prob: float = 0.12, noise_std: float = 0.02):
    out = x + noise_std * torch.randn_like(x)
    mask = torch.rand_like(out) < mask_prob
    return out.masked_fill(mask, 0.0)


def mask_points(x, mask_prob: float):
    mask = torch.rand(x.size(0), x.size(1), 1, device=x.device) < mask_prob
    return x.masked_fill(mask, 0.0), mask.expand_as(x)


def mask_patches(x, patch_len: int = 10, mask_ratio: float = 0.35):
    bsz, steps, _ = x.shape
    n_patches = max(1, steps // patch_len)
    patch_mask = torch.rand(bsz, n_patches, device=x.device) < mask_ratio
    mask = torch.zeros(bsz, steps, 1, device=x.device, dtype=torch.bool)
    for i in range(n_patches):
        mask[:, i * patch_len : min((i + 1) * patch_len, steps)] = patch_mask[:, i].view(bsz, 1, 1)
    return x.masked_fill(mask, 0.0), mask.expand_as(x)


def nt_xent(z1, z2, temperature: float = 0.2):
    z1 = torch.nn.functional.normalize(z1, dim=1)
    z2 = torch.nn.functional.normalize(z2, dim=1)
    logits = z1 @ z2.t() / temperature
    labels = torch.arange(z1.size(0), device=z1.device)
    return 0.5 * (
        torch.nn.functional.cross_entropy(logits, labels)
        + torch.nn.functional.cross_entropy(logits.t(), labels)
    )


def frequency_loss(pred, target):
    pred_freq = torch.fft.rfft(pred, dim=1).abs()
    target_freq = torch.fft.rfft(target, dim=1).abs()
    return torch.mean((pred_freq - target_freq) ** 2)


def lob_sides(x):
    bid_p = x[:, :, :10].flip(-1)
    ask_p = x[:, :, 10:20]
    bid_v = x[:, :, 20:30].flip(-1)
    ask_v = x[:, :, 30:40]
    return bid_p, ask_p, bid_v, ask_v


def lob_validity_penalty(
    pred,
    volume_zero_threshold=None,
    price_zero_threshold=None,
    price_gap_margin=0.0,
):
    """Soft LOB constraints in normalized coordinates.

    Price ordering and spread are invariant under the benchmark's shared
    positive affine price transform. Raw volume zero is not invariant under
    z-scoring, so callers must provide its normalized value
    ``(0 - volume_mean) / volume_std``. If it is unavailable, the volume term is
    deliberately omitted instead of using the minimum target value as a
    surrogate.
    """
    bid_p, ask_p, bid_v, ask_v = lob_sides(pred)
    gap = torch.as_tensor(
        price_gap_margin,
        dtype=pred.dtype,
        device=pred.device,
    ).reshape(1, 1, 1)
    bid_order = torch.relu(gap - (bid_p[:, :, :-1] - bid_p[:, :, 1:])).mean()
    ask_order = torch.relu(gap - (ask_p[:, :, 1:] - ask_p[:, :, :-1])).mean()
    spread = torch.relu(gap - (ask_p[:, :, :1] - bid_p[:, :, :1])).mean()
    volume = pred[:, :, 20:40]
    if price_zero_threshold is not None:
        price_floor = torch.as_tensor(
            price_zero_threshold,
            dtype=pred.dtype,
            device=pred.device,
        ).reshape(1, 1, 1)
        price_penalty = torch.relu(price_floor - pred[:, :, :20]).mean()
    else:
        price_penalty = pred.new_zeros(())
    if volume_zero_threshold is not None:
        volume_floor = torch.as_tensor(
            volume_zero_threshold,
            dtype=volume.dtype,
            device=volume.device,
        ).reshape(1, 1, 1)
        volume_penalty = torch.relu(volume_floor - volume).mean()
    else:
        volume_penalty = volume.new_zeros(())
    return bid_order + ask_order + spread + price_penalty + volume_penalty


def lob_aware_reconstruction_loss(
    pred,
    target,
    mask=None,
    structure_weight: float = 2.0,
    volume_zero_threshold=None,
    price_zero_threshold=None,
    price_gap_margin=0.0,
):
    if mask is not None and mask.any():
        mse = torch.mean((pred[mask] - target[mask]) ** 2)
    else:
        mse = torch.mean((pred - target) ** 2)
    return mse + structure_weight * lob_validity_penalty(
        pred,
        volume_zero_threshold=volume_zero_threshold,
        price_zero_threshold=price_zero_threshold,
        price_gap_margin=price_gap_margin,
    )


def inverse_grouped_normalization(x, normalization):
    raw = x.clone()
    raw[:, :, :20] = (
        raw[:, :, :20] * float(normalization["price_std"])
        + float(normalization["price_mean"])
    )
    raw[:, :, 20:40] = (
        raw[:, :, 20:40] * float(normalization["volume_std"])
        + float(normalization["volume_mean"])
    )
    return raw


def lob_validity_metrics(
    pred,
    target=None,
    normalization=None,
    raw_price_tick_size=None,
):
    """Return strict/weak validity and, when possible, raw-unit errors.

    Raw volume validity and price/volume MAE are emitted only when the exact
    training-partition normalization statistics are supplied.
    """
    with torch.no_grad():
        evaluated_pred = (
            inverse_grouped_normalization(pred, normalization)
            if normalization is not None
            else pred
        )
        evaluated_target = (
            inverse_grouped_normalization(target, normalization)
            if target is not None and normalization is not None
            else target
        )
        bid_p, ask_p, _, _ = lob_sides(evaluated_pred)
        spread_gap = ask_p[:, :, 0] - bid_p[:, :, 0]
        bid_gaps = bid_p[:, :, :-1] - bid_p[:, :, 1:]
        ask_gaps = ask_p[:, :, 1:] - ask_p[:, :, :-1]
        spread_bad = spread_gap <= 0
        bid_strict_bad = (bid_p[:, :, 1:] >= bid_p[:, :, :-1]).any(dim=-1)
        ask_strict_bad = (ask_p[:, :, 1:] <= ask_p[:, :, :-1]).any(dim=-1)
        bid_weak_bad = (bid_p[:, :, 1:] > bid_p[:, :, :-1]).any(dim=-1)
        ask_weak_bad = (ask_p[:, :, 1:] < ask_p[:, :, :-1]).any(dim=-1)
        metrics = {
            "spread_cross_rate": float(spread_bad.float().mean().item()),
            "spread_valid_rate": float((~spread_bad).float().mean().item()),
            "bid_order_strict_bad_rate": float(bid_strict_bad.float().mean().item()),
            "bid_order_strict_valid_rate": float((~bid_strict_bad).float().mean().item()),
            "ask_order_strict_bad_rate": float(ask_strict_bad.float().mean().item()),
            "ask_order_strict_valid_rate": float((~ask_strict_bad).float().mean().item()),
            "bid_order_weak_bad_rate": float(bid_weak_bad.float().mean().item()),
            "bid_order_weak_valid_rate": float((~bid_weak_bad).float().mean().item()),
            "ask_order_weak_bad_rate": float(ask_weak_bad.float().mean().item()),
            "ask_order_weak_valid_rate": float((~ask_weak_bad).float().mean().item()),
        }
        if normalization is not None:
            price_bad = (evaluated_pred[:, :, :20] <= 0).any(dim=-1)
            volume = evaluated_pred[:, :, 20:40]
            volume_bad = (volume < 0).any(dim=-1)
            any_bad = (
                spread_bad
                | bid_strict_bad
                | ask_strict_bad
                | price_bad
                | volume_bad
            )
            metrics.update(
                {
                    "price_nonpositive_rate": float(price_bad.float().mean().item()),
                    "price_positive_valid_rate": float((~price_bad).float().mean().item()),
                    "volume_negative_rate": float(volume_bad.float().mean().item()),
                    "volume_nonnegative_valid_rate": float((~volume_bad).float().mean().item()),
                    "any_lob_illegal_rate": float(any_bad.float().mean().item()),
                    "all_lob_constraints_valid_rate": float((~any_bad).float().mean().item()),
                }
            )
            if raw_price_tick_size is not None:
                tick = float(raw_price_tick_size)
                if tick <= 0:
                    raise ValueError("raw_price_tick_size must be positive")
                tolerance = max(1e-8, tick * 1e-4)
                tick_bid_bad = (bid_gaps < tick - tolerance).any(dim=-1)
                tick_ask_bad = (ask_gaps < tick - tolerance).any(dim=-1)
                tick_spread_bad = spread_gap < tick - tolerance
                tick_price_bad = (evaluated_pred[:, :, :20] < tick - tolerance).any(dim=-1)
                joint_bad = (
                    tick_bid_bad
                    | tick_ask_bad
                    | tick_spread_bad
                    | tick_price_bad
                    | volume_bad
                )
                bid_violation = torch.relu(tick - bid_gaps) / tick
                ask_violation = torch.relu(tick - ask_gaps) / tick
                spread_violation = torch.relu(tick - spread_gap) / tick
                price_violation = torch.relu(tick - evaluated_pred[:, :, :20]) / tick
                all_price_violations = torch.cat(
                    [
                        bid_violation.reshape(-1),
                        ask_violation.reshape(-1),
                        spread_violation.reshape(-1),
                        price_violation.reshape(-1),
                    ]
                )
                metrics.update(
                    {
                        "raw_price_tick_size": tick,
                        "tick_bid_order_valid_rate": float((~tick_bid_bad).float().mean().item()),
                        "tick_ask_order_valid_rate": float((~tick_ask_bad).float().mean().item()),
                        "tick_spread_valid_rate": float((~tick_spread_bad).float().mean().item()),
                        "tick_price_positive_valid_rate": float((~tick_price_bad).float().mean().item()),
                        "joint_five_constraint_snapshot_valid_rate": float((~joint_bad).float().mean().item()),
                        "bid_order_violation_ticks": float(bid_violation.mean().item()),
                        "ask_order_violation_ticks": float(ask_violation.mean().item()),
                        "spread_violation_ticks": float(spread_violation.mean().item()),
                        "price_floor_violation_ticks": float(price_violation.mean().item()),
                        "mean_price_constraint_violation_ticks": float(all_price_violations.mean().item()),
                    }
                )
            if evaluated_target is not None:
                metrics["raw_price_mae"] = float(
                    torch.mean(torch.abs(evaluated_pred[:, :, :20] - evaluated_target[:, :, :20])).item()
                )
                metrics["raw_volume_mae"] = float(
                    torch.mean(torch.abs(evaluated_pred[:, :, 20:40] - evaluated_target[:, :, 20:40])).item()
                )
        return metrics


def build_method(
    method: str,
    latent_dim: int,
    d_model: int,
    nhead: int = 4,
):
    if method == "ts2vec":
        return DilatedConvBackbone(latent_dim=latent_dim, d_model=d_model)
    if method in {"simmtm", "timae", "timae_lobloss", "timae_softlobloss", "timesurl", "tfc"}:
        return TransformerBackbone(
            latent_dim=latent_dim,
            d_model=d_model,
            nhead=nhead,
        )
    if method in {"lobconv_timae", "lobconv_timae_lobloss", "lobconv_timae_softlobloss"}:
        return LOBConvGridEncoder(latent_dim=latent_dim, d_model=d_model)
    if method in {"lobgrid_timae", "lobgrid_timae_lobloss", "lobgrid_timae_softlobloss"}:
        return LOBGridEncoder(
            latent_dim=latent_dim,
            d_model=d_model,
            nhead=nhead,
        )
    if method in {"lobstruct_timae", "lobstruct_timae_lobloss"}:
        return LOBStructEncoder(latent_dim=latent_dim, d_model=d_model)
    if method in {"tlob2025", "tlob2025_lobloss", "tlob2025_softlobloss"}:
        return TLOB2025Encoder(latent_dim=latent_dim, d_model=d_model)
    if method in {"simlob2026", "simlob2026_lobloss", "simlob2026_softlobloss"}:
        return SimLOBStyleEncoder(
            latent_dim=latent_dim,
            d_model=d_model,
            nhead=nhead,
        )
    if method in {
        "lobshape_simlob",
        "lobshape_simlob_lobloss",
        "lobshape_simlob_lobloss_auxtrend",
        "lobshape_simlob_twostage_lobloss",
    }:
        return LOBShapeSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
    if method in {"lobshape_level_simlob", "lobshape_level_simlob_lobloss"}:
        return LOBShapeLevelSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
    if method in {"lobshape_structured_level_simlob", "lobshape_structured_level_simlob_lobloss"}:
        return LOBShapeStructuredLevelSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
    if method in {"lobshape_hybrid_level_simlob", "lobshape_hybrid_level_simlob_lobloss"}:
        return LOBShapeHybridLevelSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
    if method in {"lobshape_flow_simlob", "lobshape_flow_simlob_lobloss", "lobshape_flow_simlob_lobloss_auxtrend"}:
        return LOBShapeFlowSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
    if method in {"lobshape_flow_level_simlob", "lobshape_flow_level_simlob_lobloss"}:
        return LOBShapeFlowLevelSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
    if method in {"lobshape_gated_flow_level_simlob", "lobshape_gated_flow_level_simlob_lobloss"}:
        return LOBShapeGatedFlowLevelSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
    if method in {"lobshape_wide_simlob", "lobshape_wide_simlob_lobloss"}:
        return LOBShapeWideSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
    if method in {"lobshape_gridfusion", "lobshape_gridfusion_lobloss"}:
        return LOBShapeGridFusionEncoder(latent_dim=latent_dim, d_model=d_model)
    raise KeyError(f"unknown representation baseline method: {method}")


def _run_pretrain_stage(
    model,
    save_model,
    train_step,
    val_step,
    train_loader,
    val_loader,
    cfg,
    device,
    ckpt_path,
    stage_name,
    epochs,
    patience,
    learning_rate,
):
    opt = torch.optim.AdamW(model.parameters(), lr=learning_rate, weight_decay=cfg["weight_decay"])
    best = float("inf")
    best_epoch = 0
    history = []
    epochs_without_improvement = 0
    started = time.perf_counter()
    for epoch in range(1, int(epochs) + 1):
        epoch_started = time.perf_counter()
        model.train()
        train_loss = 0.0
        train_n = 0
        for x, y in train_loader:
            x = x.to(device)
            y = y.to(device)
            opt.zero_grad(set_to_none=True)
            loss = train_step(model, x, y)
            loss.backward()
            opt.step()
            train_loss += float(loss.item()) * len(x)
            train_n += len(x)
        model.eval()
        val_loss = 0.0
        val_n = 0
        with torch.no_grad():
            for x, y in val_loader:
                x = x.to(device)
                y = y.to(device)
                loss = val_step(model, x, y)
                val_loss += float(loss.item()) * len(x)
                val_n += len(x)
        train_loss /= max(train_n, 1)
        val_loss /= max(val_n, 1)
        history.append(
            {
                "stage": stage_name,
                "epoch": epoch,
                "train_loss": train_loss,
                "val_loss": val_loss,
                "epoch_seconds": time.perf_counter() - epoch_started,
            }
        )
        next_best = min(best, val_loss)
        _log_epoch(
            cfg,
            f"EPOCH pretrain:{stage_name} {epoch}/{int(epochs)} "
            f"train_loss={train_loss:.6f} val_loss={val_loss:.6f} "
            f"best={next_best:.6f} epoch_seconds={history[-1]['epoch_seconds']:.2f}",
        )
        if val_loss < best:
            best = val_loss
            best_epoch = epoch
            atomic_torch_save(save_model.state_dict(), ckpt_path)
            epochs_without_improvement = 0
        else:
            epochs_without_improvement += 1
        if patience and epochs_without_improvement >= patience:
            break
    return {
        "stage": stage_name,
        "best_val_loss": best,
        "best_epoch": best_epoch,
        "seconds": time.perf_counter() - started,
        "history": history,
    }


def pretrain_method(
    method,
    latent_dim,
    d_model,
    train_loader,
    val_loader,
    cfg,
    device,
    ckpt_path,
    *,
    nhead=4,
    mask_ratio=0.4,
    force=False,
):
    meta_path = ckpt_path.with_suffix(".pretrain.json")
    if not force and ckpt_path.exists() and meta_path.exists():
        return json.loads(meta_path.read_text(encoding="utf-8")) | {"cached": True}

    if method == "lobshape_simlob_twostage_lobloss":
        encoder = LOBShapeSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=False).to(device)
        stage1_epochs = int(cfg.get("twostage_mse_epochs", max(1, int(cfg["pretrain_epochs"]) // 2)))
        stage2_epochs = int(cfg.get("twostage_lob_epochs", max(1, int(cfg["pretrain_epochs"]) - stage1_epochs)))
        stage1_patience = int(cfg.get("twostage_mse_patience", cfg.get("pretrain_patience", 0)))
        stage2_patience = int(cfg.get("twostage_lob_patience", cfg.get("pretrain_patience", 0)))
        stage1_path = ckpt_path.with_suffix(".mse_stage.pt")
        stage1 = _run_pretrain_stage(
            model,
            model.encoder,
            timae_step,
            timae_step,
            train_loader,
            val_loader,
            cfg,
            device,
            stage1_path,
            "mse",
            stage1_epochs,
            stage1_patience,
            float(cfg["learning_rate"]),
        )
        model.encoder.load_state_dict(torch.load(stage1_path, map_location=device))
        model.legalize_prices = True
        stage2 = _run_pretrain_stage(
            model,
            model.encoder,
            lob_aware_timae_step,
            lob_aware_timae_step,
            train_loader,
            val_loader,
            cfg,
            device,
            ckpt_path,
            "lob_aware",
            stage2_epochs,
            stage2_patience,
            float(cfg.get("twostage_lob_learning_rate", float(cfg["learning_rate"]) * 0.5)),
        )
        history = stage1["history"] + stage2["history"]
        meta = {
            "method": method,
            "best_val_loss": stage2["best_val_loss"],
            "best_epoch": stage1_epochs + stage2["best_epoch"],
            "seconds": stage1["seconds"] + stage2["seconds"],
            "stages": [
                {key: value for key, value in stage1.items() if key != "history"},
                {key: value for key, value in stage2.items() if key != "history"},
            ],
            "history": history,
            "cached": False,
            "implementation": "local_lite_twostage",
        }
        atomic_write_json(meta_path, meta)
        return meta

    if method == "ts2vec":
        model = DilatedConvBackbone(latent_dim=latent_dim, d_model=d_model).to(device)
        train_step = ts2vec_step
        val_step = ts2vec_step
        save_model = model
    elif method == "tfc":
        model = TFCPretrainer(latent_dim=latent_dim, d_model=d_model).to(device)
        train_step = tfc_step
        val_step = tfc_step
        save_model = model.encoder
    elif method == "simmtm":
        encoder = TransformerBackbone(
            latent_dim=latent_dim,
            d_model=d_model,
            nhead=nhead,
        )
        model = ReconstructionPretrainer(encoder, d_model=d_model).to(device)
        train_step = simmtm_step
        val_step = simmtm_step
        save_model = model.encoder
    elif method in {"timae", "timae_lobloss", "timae_softlobloss"}:
        encoder = TransformerBackbone(
            latent_dim=latent_dim,
            d_model=d_model,
            nhead=nhead,
        )
        use_lob_loss = method.endswith("_lobloss") or method.endswith("_softlobloss")
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        step = lob_aware_timae_step if use_lob_loss else timae_step
        train_step = partial(step, mask_ratio=mask_ratio)
        val_step = partial(step, mask_ratio=mask_ratio)
        save_model = model.encoder
    elif method in {"lobconv_timae", "lobconv_timae_lobloss", "lobconv_timae_softlobloss"}:
        encoder = LOBConvGridEncoder(latent_dim=latent_dim, d_model=d_model)
        use_lob_loss = method.endswith("_lobloss") or method.endswith("_softlobloss")
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        train_step = lob_aware_timae_step if use_lob_loss else timae_step
        val_step = lob_aware_timae_step if use_lob_loss else timae_step
        save_model = model.encoder
    elif method in {"lobgrid_timae", "lobgrid_timae_lobloss", "lobgrid_timae_softlobloss"}:
        encoder = LOBGridEncoder(
            latent_dim=latent_dim,
            d_model=d_model,
            nhead=nhead,
        )
        use_lob_loss = method.endswith("_lobloss") or method.endswith("_softlobloss")
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        step = lob_aware_timae_step if use_lob_loss else timae_step
        train_step = partial(step, mask_ratio=mask_ratio)
        val_step = partial(step, mask_ratio=mask_ratio)
        save_model = model.encoder
    elif method in {"lobstruct_timae", "lobstruct_timae_lobloss"}:
        encoder = LOBStructEncoder(latent_dim=latent_dim, d_model=d_model)
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        train_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        val_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        save_model = model.encoder
    elif method in {"tlob2025", "tlob2025_lobloss", "tlob2025_softlobloss"}:
        encoder = TLOB2025Encoder(latent_dim=latent_dim, d_model=d_model)
        use_lob_loss = method.endswith("_lobloss") or method.endswith("_softlobloss")
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        train_step = lob_aware_timae_step if use_lob_loss else timae_step
        val_step = lob_aware_timae_step if use_lob_loss else timae_step
        save_model = model.encoder
    elif method in {"simlob2026", "simlob2026_lobloss", "simlob2026_softlobloss"}:
        encoder = SimLOBStyleEncoder(
            latent_dim=latent_dim,
            d_model=d_model,
            nhead=nhead,
        )
        use_lob_loss = method.endswith("_lobloss") or method.endswith("_softlobloss")
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        step = lob_aware_timae_step if use_lob_loss else timae_step
        train_step = partial(step, mask_ratio=mask_ratio)
        val_step = partial(step, mask_ratio=mask_ratio)
        save_model = model.encoder
    elif method in {"lobshape_simlob", "lobshape_simlob_lobloss"}:
        encoder = LOBShapeSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        train_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        val_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        save_model = model.encoder
    elif method in {"lobshape_level_simlob", "lobshape_level_simlob_lobloss"}:
        encoder = LOBShapeLevelSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        train_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        val_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        save_model = model.encoder
    elif method in {"lobshape_structured_level_simlob", "lobshape_structured_level_simlob_lobloss"}:
        encoder = LOBShapeStructuredLevelSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        train_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        val_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        save_model = model.encoder
    elif method in {"lobshape_hybrid_level_simlob", "lobshape_hybrid_level_simlob_lobloss"}:
        encoder = LOBShapeHybridLevelSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        train_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        val_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        save_model = model.encoder
    elif method == "lobshape_simlob_lobloss_auxtrend":
        encoder = LOBShapeSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
        model = TrendReconstructionPretrainer(
            encoder,
            d_model=d_model,
            legalize_prices=True,
            latent_dim=latent_dim,
        ).to(device)
        model.auxtrend_weight = float(cfg.get("auxtrend_weight", 0.25))
        if cfg.get("auxtrend_class_weights") is not None:
            model.auxtrend_class_weights = torch.tensor(
                cfg["auxtrend_class_weights"],
                dtype=torch.float32,
                device=device,
            )
        train_step = auxtrend_lob_aware_timae_step
        val_step = auxtrend_lob_aware_timae_step
        save_model = model.encoder
    elif method in {"lobshape_flow_simlob", "lobshape_flow_simlob_lobloss"}:
        encoder = LOBShapeFlowSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        train_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        val_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        save_model = model.encoder
    elif method in {"lobshape_flow_level_simlob", "lobshape_flow_level_simlob_lobloss"}:
        encoder = LOBShapeFlowLevelSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        train_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        val_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        save_model = model.encoder
    elif method in {"lobshape_gated_flow_level_simlob", "lobshape_gated_flow_level_simlob_lobloss"}:
        encoder = LOBShapeGatedFlowLevelSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        train_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        val_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        save_model = model.encoder
    elif method == "lobshape_flow_simlob_lobloss_auxtrend":
        encoder = LOBShapeFlowSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
        model = TrendReconstructionPretrainer(
            encoder,
            d_model=d_model,
            legalize_prices=True,
            latent_dim=latent_dim,
        ).to(device)
        model.auxtrend_weight = float(cfg.get("auxtrend_weight", 0.25))
        if cfg.get("auxtrend_class_weights") is not None:
            model.auxtrend_class_weights = torch.tensor(
                cfg["auxtrend_class_weights"],
                dtype=torch.float32,
                device=device,
            )
        train_step = auxtrend_lob_aware_timae_step
        val_step = auxtrend_lob_aware_timae_step
        save_model = model.encoder
    elif method in {"lobshape_wide_simlob", "lobshape_wide_simlob_lobloss"}:
        encoder = LOBShapeWideSimLOBEncoder(latent_dim=latent_dim, d_model=d_model)
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        train_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        val_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        save_model = model.encoder
    elif method in {"lobshape_gridfusion", "lobshape_gridfusion_lobloss"}:
        encoder = LOBShapeGridFusionEncoder(latent_dim=latent_dim, d_model=d_model)
        model = ReconstructionPretrainer(encoder, d_model=d_model, legalize_prices=method.endswith("_lobloss")).to(device)
        train_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        val_step = lob_aware_timae_step if method.endswith("_lobloss") else timae_step
        save_model = model.encoder
    elif method == "timesurl":
        encoder = TransformerBackbone(latent_dim=latent_dim, d_model=d_model)
        model = ReconstructionPretrainer(encoder, d_model=d_model).to(device)
        train_step = timesurl_step
        val_step = timesurl_step
        save_model = model.encoder
    else:
        raise KeyError(method)

    opt = torch.optim.AdamW(model.parameters(), lr=cfg["learning_rate"], weight_decay=cfg["weight_decay"])
    best = float("inf")
    best_epoch = 0
    history = []
    epochs_without_improvement = 0
    patience = int(cfg.get("pretrain_patience", 0))
    started = time.perf_counter()
    for epoch in range(1, int(cfg["pretrain_epochs"]) + 1):
        epoch_started = time.perf_counter()
        model.train()
        train_loss = 0.0
        train_n = 0
        for x, y in train_loader:
            x = x.to(device)
            y = y.to(device)
            opt.zero_grad(set_to_none=True)
            loss = train_step(model, x, y)
            loss.backward()
            opt.step()
            train_loss += float(loss.item()) * len(x)
            train_n += len(x)
        model.eval()
        val_loss = 0.0
        val_n = 0
        with torch.no_grad():
            for x, y in val_loader:
                x = x.to(device)
                y = y.to(device)
                loss = val_step(model, x, y)
                val_loss += float(loss.item()) * len(x)
                val_n += len(x)
        train_loss /= max(train_n, 1)
        val_loss /= max(val_n, 1)
        history.append(
            {
                "epoch": epoch,
                "train_loss": train_loss,
                "val_loss": val_loss,
                "epoch_seconds": time.perf_counter() - epoch_started,
            }
        )
        next_best = min(best, val_loss)
        _log_epoch(
            cfg,
            f"EPOCH pretrain:{method} {epoch}/{int(cfg['pretrain_epochs'])} "
            f"train_loss={train_loss:.6f} val_loss={val_loss:.6f} "
            f"best={next_best:.6f} epoch_seconds={history[-1]['epoch_seconds']:.2f}",
        )
        if val_loss < best:
            best = val_loss
            best_epoch = epoch
            atomic_torch_save(save_model.state_dict(), ckpt_path)
            epochs_without_improvement = 0
        else:
            epochs_without_improvement += 1
        if patience and epochs_without_improvement >= patience:
            break

    meta = {
        "method": method,
        "best_val_loss": best,
        "best_epoch": best_epoch,
        "seconds": time.perf_counter() - started,
        "history": history,
        "stopped_epoch": len(history),
        "batches_per_epoch": len(train_loader),
        "optimizer_steps": len(history) * len(train_loader),
        "cached": False,
        "epoch_cap": int(cfg["pretrain_epochs"]),
        "patience": int(cfg.get("pretrain_patience", 0)),
        "max_epoch_hit": len(history) >= int(cfg["pretrain_epochs"]),
        "implementation": "controlled_benchmark_v1",
        "hyperparameters": {
            "latent_dim": int(latent_dim),
            "d_model": int(d_model),
            "nhead": int(nhead),
            "mask_ratio": float(mask_ratio),
            "learning_rate": float(cfg["learning_rate"]),
            "batch_size": int(cfg["batch_size"]),
            "epoch_cap": int(cfg["pretrain_epochs"]),
            "patience": int(cfg.get("pretrain_patience", 0)),
        },
    }
    atomic_write_json(meta_path, meta)
    return meta


def ts2vec_step(model, x, y=None):
    z1 = model(augment(x))
    z2 = model(augment(x))
    return nt_xent(z1, z2)


def tfc_step(model, x, y=None):
    time_z, freq_z = model(augment(x))
    return nt_xent(time_z, freq_z)


def simmtm_step(model, x, y=None):
    masked, mask = mask_points(x, mask_prob=0.25)
    pred = model(masked)
    recon = torch.mean((pred[mask] - x[mask]) ** 2) if mask.any() else torch.mean((pred - x) ** 2)
    align = nt_xent(model.encoder(x), model.encoder(masked))
    return recon + 0.2 * align


def timae_step(model, x, y=None, mask_ratio=0.4):
    masked, mask = mask_patches(x, patch_len=10, mask_ratio=mask_ratio)
    pred = model(masked)
    return torch.mean((pred[mask] - x[mask]) ** 2) if mask.any() else torch.mean((pred - x) ** 2)


def lob_aware_timae_step(model, x, y=None, mask_ratio=0.4):
    masked, mask = mask_patches(x, patch_len=10, mask_ratio=mask_ratio)
    pred = model(masked)
    return lob_aware_reconstruction_loss(pred, x, mask=mask, structure_weight=2.0)


def auxtrend_lob_aware_timae_step(model, x, y=None):
    masked, mask = mask_patches(x, patch_len=10, mask_ratio=0.4)
    pred = model(masked)
    recon = lob_aware_reconstruction_loss(pred, x, mask=mask, structure_weight=2.0)
    if y is None:
        return recon
    logits = model.trend_logits(x)
    trend = torch.nn.functional.cross_entropy(logits, y, weight=model.auxtrend_class_weights)
    return recon + float(model.auxtrend_weight) * trend


def timesurl_step(model, x, y=None):
    point_masked, point_mask = mask_points(x, mask_prob=0.2)
    pred = model(point_masked)
    recon = torch.mean((pred[point_mask] - x[point_mask]) ** 2) if point_mask.any() else torch.mean((pred - x) ** 2)
    contrast = nt_xent(model.encoder(augment(x)), model.encoder(augment(x, mask_prob=0.18, noise_std=0.015)))
    return recon + 0.2 * contrast + 0.05 * frequency_loss(pred, x)


def collect_logits(model, loader, device):
    model.eval()
    logits_all = []
    y_all = []
    with torch.no_grad():
        for x, y in loader:
            logits_all.append(model(x.to(device)).cpu())
            y_all.append(y)
    return torch.cat(logits_all), torch.cat(y_all)


def confusion_summary(logits, y_true):
    pred = logits.argmax(dim=1)
    matrix = torch.zeros(3, 3, dtype=torch.long)
    for true_cls in range(3):
        for pred_cls in range(3):
            matrix[true_cls, pred_cls] = ((y_true == true_cls) & (pred == pred_cls)).sum()
    pred_counts = torch.bincount(pred, minlength=3)
    true_counts = torch.bincount(y_true, minlength=3)
    return {
        "matrix_rows_true_cols_pred": matrix.tolist(),
        "pred_counts": pred_counts.tolist(),
        "true_counts": true_counts.tolist(),
    }


def classification_metrics_by_group(logits, y_true, group_ids):
    if group_ids is None:
        return None
    if len(group_ids) != len(y_true):
        raise ValueError(
            f"group label count {len(group_ids)} does not match predictions {len(y_true)}"
        )
    rows = {}
    for group in sorted(set(group_ids)):
        keep = torch.tensor(
            [value == group for value in group_ids],
            dtype=torch.bool,
        )
        rows[group] = {
            "n": int(keep.sum().item()),
            "metrics": classification_metrics(logits[keep], y_true[keep]),
            "confusion": confusion_summary(logits[keep], y_true[keep]),
        }
    return rows


def evaluate_with_logit_bias(model, loader, device, bias):
    logits, y_true = collect_logits(model, loader, device)
    bias_tensor = torch.tensor(bias, dtype=logits.dtype).view(1, -1)
    return classification_metrics(logits + bias_tensor, y_true)


def tune_logit_bias(model, val_loader, device):
    logits, y_true = collect_logits(model, val_loader, device)
    best_bias = torch.zeros(3)
    best_metrics = classification_metrics(logits, y_true)
    best_score = best_metrics["macro_f1"]
    grid = torch.linspace(-1.5, 1.5, steps=13)
    for b0 in grid:
        for b1 in grid:
            for b2 in grid:
                bias = torch.tensor([b0, b1, b2], dtype=logits.dtype)
                bias = bias - bias.mean()
                metrics = classification_metrics(logits + bias.view(1, -1), y_true)
                if metrics["macro_f1"] > best_score:
                    best_score = metrics["macro_f1"]
                    best_metrics = metrics
                    best_bias = bias
    return {"bias": [float(v) for v in best_bias.tolist()], "val": best_metrics}


def train_downstream_model(
    encoder,
    x,
    y,
    splits,
    train_idx,
    train_cfg,
    setting,
    device,
    return_artifacts=False,
    test_group_ids=None,
):
    if setting == "multiinit_fine_tune":
        trials = []
        best_result = None
        best_score = -1.0
        start_seed = int(train_cfg.get("multiinit_seed_start", 31000))
        for init_id in range(int(train_cfg.get("multiinit_count", 5))):
            set_seed(start_seed + init_id)
            trial = train_downstream_model(
                copy.deepcopy(encoder),
                x,
                y,
                splits,
                train_idx,
                train_cfg,
                "fine_tune",
                device,
                return_artifacts=False,
                test_group_ids=test_group_ids,
            )
            trials.append(
                {
                    "init_id": init_id,
                    "seed": start_seed + init_id,
                    "best_val_macro_f1": trial["best_val_macro_f1"],
                    "best_epoch": trial["best_epoch"],
                    "test": trial["test"],
                    "test_confusion": trial["test_confusion"],
                    "downstream_seconds": trial["downstream_seconds"],
                }
            )
            if trial["best_val_macro_f1"] > best_score:
                best_score = trial["best_val_macro_f1"]
                best_result = trial
        best_result = copy.deepcopy(best_result)
        best_result["multiinit"] = {
            "selected_by": "validation_macro_f1",
            "count": len(trials),
            "trials": trials,
        }
        best_result["downstream_seconds"] = sum(trial["downstream_seconds"] for trial in trials)
        return best_result

    ensemble_pairs = {
        "probe_finetune_ensemble": ("frozen_probe", "fine_tune"),
        "probe_adapter_ensemble": ("frozen_probe", "adapter_tune"),
        "adapter_finetune_ensemble": ("adapter_tune", "fine_tune"),
    }
    if setting in ensemble_pairs:
        left_name, right_name = ensemble_pairs[setting]
        left = train_downstream_model(
            copy.deepcopy(encoder),
            x,
            y,
            splits,
            train_idx,
            train_cfg,
            left_name,
            device,
            return_artifacts=True,
            test_group_ids=test_group_ids,
        )
        right = train_downstream_model(
            copy.deepcopy(encoder),
            x,
            y,
            splits,
            train_idx,
            train_cfg,
            right_name,
            device,
            return_artifacts=True,
            test_group_ids=test_group_ids,
        )
        best_alpha = 0.0
        best_val = None
        best_score = -1.0
        for alpha in torch.linspace(0.0, 1.0, steps=int(train_cfg.get("ensemble_alpha_steps", 21))):
            alpha_value = float(alpha.item())
            val_logits = (1.0 - alpha_value) * left["_val_logits"] + alpha_value * right["_val_logits"]
            metrics = classification_metrics(val_logits, left["_val_true"])
            if metrics["macro_f1"] > best_score:
                best_score = metrics["macro_f1"]
                best_alpha = alpha_value
                best_val = metrics
        test_logits = (1.0 - best_alpha) * left["_test_logits"] + best_alpha * right["_test_logits"]
        test_metrics = classification_metrics(test_logits, left["_test_true"])
        result = {
            "parameters": {
                "total": left["parameters"]["total"] + right["parameters"]["total"],
                "trainable": left["parameters"]["trainable"] + right["parameters"]["trainable"],
            },
            "best_val_macro_f1": best_score,
            "best_epoch": {
                left_name: left["best_epoch"],
                right_name: right["best_epoch"],
            },
            "downstream_seconds": left["downstream_seconds"] + right["downstream_seconds"],
            "val": best_val,
            "test": test_metrics,
            "val_confusion": confusion_summary(
                (1.0 - best_alpha) * left["_val_logits"] + best_alpha * right["_val_logits"],
                left["_val_true"],
            ),
            "test_confusion": confusion_summary(test_logits, left["_test_true"]),
            "test_by_group": classification_metrics_by_group(
                test_logits,
                left["_test_true"],
                test_group_ids,
            ),
            "calibration": None,
            "history": {
                left_name: left["history"],
                right_name: right["history"],
            },
            "ensemble": {
                f"alpha_{right_name}": best_alpha,
                f"alpha_{left_name}": 1.0 - best_alpha,
                f"{left_name}_test": left["test"],
                f"{right_name}_test": right["test"],
                f"{left_name}_best_val_macro_f1": left["best_val_macro_f1"],
                f"{right_name}_best_val_macro_f1": right["best_val_macro_f1"],
            },
        }
        return result

    if setting in {"frozen_probe", "adapter_tune", "calibrated_probe", "adapter_calibrated"}:
        for param in encoder.parameters():
            param.requires_grad = False
    if setting == "fusion_tune":
        for param in encoder.parameters():
            param.requires_grad = False
        for module_name in ("fuse", "time_score", "out"):
            module = getattr(encoder, module_name, None)
            if module is not None:
                for param in module.parameters():
                    param.requires_grad = True
    if setting in {"adapter_tune", "adapter_calibrated"}:
        model = AdapterClassifier(
            encoder,
            latent_dim=int(train_cfg["latent_dim"]),
            bottleneck=int(train_cfg.get("adapter_bottleneck", 32)),
        ).to(device)
    else:
        model = Classifier(encoder, latent_dim=int(train_cfg["latent_dim"])).to(device)
    parameters = count_parameters(model)
    if setting == "slow_fine_tune" and hasattr(model, "encoder") and hasattr(model, "head"):
        encoder_lr = float(train_cfg["learning_rate"]) * float(train_cfg.get("encoder_lr_mult", 0.25))
        opt = torch.optim.AdamW(
            [
                {"params": [p for p in model.encoder.parameters() if p.requires_grad], "lr": encoder_lr},
                {"params": [p for p in model.head.parameters() if p.requires_grad], "lr": train_cfg["learning_rate"]},
            ],
            weight_decay=train_cfg["weight_decay"],
        )
    else:
        opt = torch.optim.AdamW(
            [p for p in model.parameters() if p.requires_grad],
            lr=train_cfg["learning_rate"],
            weight_decay=train_cfg["weight_decay"],
        )
    class_weights = train_cfg.get("class_weights")
    if class_weights == "balanced":
        counts = torch.bincount(y[train_idx], minlength=3).to(dtype=torch.float32)
        weights = counts.sum() / (3.0 * counts.clamp_min(1.0))
        criterion = nn.CrossEntropyLoss(weight=weights.to(device))
    elif class_weights is not None:
        criterion = nn.CrossEntropyLoss(weight=torch.tensor(class_weights, dtype=torch.float32, device=device))
    else:
        criterion = nn.CrossEntropyLoss()
    batch_size = int(train_cfg["batch_size"])
    num_workers = int(train_cfg.get("num_workers", 0))
    pin_memory = device.type == "cuda"
    train_loader = make_loader(x, y, train_idx, batch_size, True, num_workers, pin_memory)
    val_loader = make_loader(x, y, splits["val"], batch_size, False, num_workers, pin_memory)
    test_loader = make_loader(x, y, splits["test"], batch_size, False, num_workers, pin_memory)
    best_val_macro_f1 = -1.0
    best_epoch = 0
    best_state = copy.deepcopy(model.state_dict())
    history = []
    patience = int(train_cfg.get("downstream_patience", 0))
    epochs_without_improvement = 0
    started = time.perf_counter()
    for epoch in range(1, int(train_cfg["downstream_epochs"]) + 1):
        epoch_started = time.perf_counter()
        loss = train_epoch(model, train_loader, opt, device, criterion)
        metrics = evaluate(model, val_loader, device)
        if metrics["macro_f1"] > best_val_macro_f1:
            best_val_macro_f1 = metrics["macro_f1"]
            best_epoch = epoch
            best_state = copy.deepcopy(model.state_dict())
            epochs_without_improvement = 0
        else:
            epochs_without_improvement += 1
        history.append(
            {
                "epoch": epoch,
                "loss": loss,
                "epoch_seconds": time.perf_counter() - epoch_started,
                **{f"val_{k}": v for k, v in metrics.items()},
            }
        )
        _log_epoch(
            train_cfg,
            f"EPOCH downstream:{setting} {epoch}/{int(train_cfg['downstream_epochs'])} "
            f"loss={loss:.6f} val_macro_f1={metrics['macro_f1']:.6f} "
            f"best={best_val_macro_f1:.6f} epoch_seconds={history[-1]['epoch_seconds']:.2f}",
        )
        if patience and epochs_without_improvement >= patience:
            break
    model.load_state_dict(best_state)
    calibration = None
    val_logits, val_true = collect_logits(model, val_loader, device)
    test_logits, test_true = collect_logits(model, test_loader, device)
    val_metrics = classification_metrics(val_logits, val_true)
    test_metrics = classification_metrics(test_logits, test_true)
    val_confusion = confusion_summary(val_logits, val_true)
    test_confusion = confusion_summary(test_logits, test_true)
    if setting in {"calibrated_probe", "adapter_calibrated", "fine_tune_calibrated"}:
        calibration = tune_logit_bias(model, val_loader, device)
        bias_tensor = torch.tensor(calibration["bias"], dtype=val_logits.dtype).view(1, -1)
        val_metrics = classification_metrics(val_logits + bias_tensor, val_true)
        test_metrics = classification_metrics(test_logits + bias_tensor, test_true)
        val_confusion = confusion_summary(val_logits + bias_tensor, val_true)
        test_confusion = confusion_summary(test_logits + bias_tensor, test_true)
    result = {
        "parameters": parameters,
        "best_val_macro_f1": best_val_macro_f1,
        "best_epoch": best_epoch,
        "downstream_seconds": time.perf_counter() - started,
        "val": val_metrics,
        "test": test_metrics,
        "val_confusion": val_confusion,
        "test_confusion": test_confusion,
        "test_by_group": classification_metrics_by_group(
            test_logits,
            test_true,
            test_group_ids,
        ),
        "calibration": calibration,
        "history": history,
        "stopped_epoch": len(history),
        "epoch_cap": int(train_cfg["downstream_epochs"]),
        "patience": patience,
        "max_epoch_hit": len(history) >= int(train_cfg["downstream_epochs"]),
        "optimizer_steps": len(history) * len(train_loader),
        "batches_per_epoch": len(train_loader),
    }
    if return_artifacts:
        result["_val_logits"] = val_logits
        result["_val_true"] = val_true
        result["_test_logits"] = test_logits
        result["_test_true"] = test_true
    return result


def completed_result(path: Path) -> bool:
    if not path.exists():
        return False
    try:
        value = json.loads(path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        return False
    return value.get("status") == "complete" and isinstance(value.get("test"), dict)


def checkpoint_pair_valid(ckpt: Path, meta_path: Path) -> bool:
    if not ckpt.exists() or not meta_path.exists():
        return False
    try:
        meta = json.loads(meta_path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        return False
    expected = meta.get("checkpoint_sha256")
    return bool(expected) and expected == sha256_file(ckpt)


def index_provenance(path: Path, index_key: str) -> dict:
    import numpy as np  # noqa: PLC0415

    with np.load(path) as data:
        if index_key not in data.files:
            raise KeyError(f"{path} does not contain requested index {index_key}")
        indices = np.asarray(data[index_key], dtype=np.int64)
    contiguous = np.ascontiguousarray(indices, dtype=np.int64)
    return {
        "samples": int(len(indices)),
        "index_sha256": hashlib.sha256(contiguous.tobytes()).hexdigest(),
    }


def dataset_provenance(config: dict, stock: str, data_path: Path) -> dict:
    manifest_path = Path(
        config.get(
            "dataset_manifest",
            Path(config["processed_dir"]).parent / "manifest.json",
        )
    )
    value = {
        "dataset_path": str(data_path.resolve()),
        "manifest_path": str(manifest_path.resolve()),
    }
    if not manifest_path.exists():
        value["manifest_available"] = False
        return value
    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
    duration = str(config.get("duration", Path(config["processed_dir"]).name))
    condition = manifest.get("stocks", {}).get(stock, {}).get("conditions", {}).get(duration, {})
    value.update(
        {
            "manifest_available": True,
            "manifest_schema": manifest.get("manifest_schema"),
            "manifest_sha256": sha256_file(manifest_path),
            "dataset_sha256": condition.get("npz_sha256"),
            "train_dates": condition.get("train_dates"),
            "validation_dates": condition.get("validation_dates"),
            "test_dates": condition.get("test_dates"),
            "normalization": condition.get("normalization"),
            "holdout_fingerprints": condition.get("holdout_fingerprints"),
        }
    )
    return value


def run_one(
    config,
    stock,
    method,
    seed,
    label_budget,
    settings,
    force=False,
    force_pretrain=False,
):
    train_cfg = config["training"]
    out_dir = Path(config["results_dir"])
    out_dir.mkdir(parents=True, exist_ok=True)
    result_paths = [
        result_path_for(config, stock, method, setting, seed, label_budget)
        for setting in settings
    ]
    if not force and all(completed_result(path) for path in result_paths):
        print(f"SKIP {stock} {method}: downstream results already exist", flush=True)
        return

    set_seed(seed)
    device = torch.device(train_cfg["device"] if torch.cuda.is_available() else "cpu")
    data_path = data_path_for_stock(config, stock)
    downstream_index_key = str(config.get("downstream_index_key", "train_idx"))
    pretrain_index_key = str(config.get("pretrain_index_key", "train_idx"))
    data_cfg = config.get("data", {})
    relabel_threshold = (
        float(data_cfg["label_threshold"])
        if data_cfg.get("relabel_from_future_returns", False)
        else None
    )
    x, y, splits = load_npz_with_train_index(
        data_path,
        downstream_index_key,
        relabel_threshold=relabel_threshold,
    )
    test_group_ids = load_test_group_ids(data_path, splits["test"])
    _log_epoch(
        train_cfg,
        f"START {stock} {method} seed={seed} budget={label_budget} "
        f"device={device} train={len(splits['train'])} val={len(splits['val'])} test={len(splits['test'])}",
    )
    batch_size = int(train_cfg["batch_size"])
    num_workers = int(train_cfg.get("num_workers", 0))
    pin_memory = device.type == "cuda"
    pretrain_scope = config.get("pretrain_scope", "local")
    pretrain_stocks = config.get("pretrain_stocks", config.get("stocks", [stock]))
    pretrain_id = config.get("pretrain_id", f"pooled{len(pretrain_stocks)}")
    latent_dim = int(train_cfg["latent_dim"])
    d_model = int(train_cfg.get("d_model", 96))
    nhead = int(train_cfg.get("nhead", 4))
    mask_ratio = float(train_cfg.get("mask_ratio", 0.4))
    if d_model % nhead:
        raise ValueError(
            f"d_model={d_model} must be divisible by nhead={nhead}"
        )
    if not 0.0 < mask_ratio < 1.0:
        raise ValueError(f"mask_ratio must lie in (0, 1), got {mask_ratio}")
    pretrain_dir = Path(config.get("pretrain_dir", out_dir))
    pretrain_dir.mkdir(parents=True, exist_ok=True)
    if pretrain_scope == "pooled":
        ckpt = pretrain_dir / f"{pretrain_id}_{method}_seed{seed}_encoder.pt"
        pretrain_run_id = f"{config.get('duration', 'duration')}:{pretrain_id}:{method}:seed{seed}"
    else:
        ckpt = pretrain_dir / f"{stock}_{method}_seed{seed}_encoder.pt"
        pretrain_run_id = (
            f"{config.get('duration', 'duration')}:target-local:{stock}:{method}:seed{seed}"
        )
    meta_path = ckpt.with_suffix(".pretrain.json")
    needs_pretraining = any(setting != "from_scratch" for setting in settings)
    if not needs_pretraining:
        pretrain = {
            "method": method,
            "skipped": True,
            "seconds": 0.0,
            "history": [],
            "best_epoch": None,
            "stopped_epoch": 0,
            "batches_per_epoch": 0,
            "optimizer_steps": 0,
            "cached": False,
            "epoch_cap": int(train_cfg.get("pretrain_epochs", 0)),
            "patience": int(train_cfg.get("pretrain_patience", 0)),
            "max_epoch_hit": False,
        }
    elif not force_pretrain and checkpoint_pair_valid(ckpt, meta_path):
        pretrain = json.loads(meta_path.read_text(encoding="utf-8")) | {"cached": True}
        _log_epoch(train_cfg, f"PRETRAIN cache hit {ckpt}")
    else:
        producer_started = utc_now()
        if pretrain_scope == "pooled":
            train_loader = make_pooled_loader(config, pretrain_stocks, "train", batch_size, True, num_workers, pin_memory)
            val_loader = make_pooled_loader(config, pretrain_stocks, "val", batch_size, False, num_workers, pin_memory)
        else:
            _, _, pretrain_splits = load_npz_with_train_index(data_path, pretrain_index_key)
            train_loader = make_loader(x, y, pretrain_splits["train"], batch_size, True, num_workers, pin_memory)
            val_loader = make_loader(x, y, splits["val"], batch_size, False, num_workers, pin_memory)
        pretrain = pretrain_method(
            method,
            latent_dim,
            d_model,
            train_loader,
            val_loader,
            train_cfg,
            device,
            ckpt,
            nhead=nhead,
            mask_ratio=mask_ratio,
            # The outer checksum-aware cache check already decided that this
            # pair must be produced (or reproduced).
            force=True,
        )
        producer_finished = utc_now()
        partition_stocks = pretrain_stocks if pretrain_scope == "pooled" else [stock]
        partition_provenance = {
            value: index_provenance(
                data_path_for_stock(config, value),
                pretrain_index_key,
            )
            for value in partition_stocks
        }
        pretrain.update(
            {
                "cached": False,
                "run_id": pretrain_run_id,
                "scope": pretrain_scope,
                "duration": config.get("duration"),
                "checkpoint_path": str(ckpt.resolve()),
                "checkpoint_sha256": sha256_file(ckpt),
                "meta_path": str(meta_path.resolve()),
                "train_partitions": partition_provenance,
                "natural_partition_concatenation": pretrain_scope == "pooled",
                "producer_started_at_utc": producer_started,
                "producer_finished_at_utc": producer_finished,
                "cache_producer": {
                    "hostname": socket.gethostname(),
                    "pid": os.getpid(),
                    "stock_invocation": stock,
                    "task_id": os.environ.get("LOBENCH_TASK_ID"),
                    "attempt": int(os.environ.get("LOBENCH_RUN_ATTEMPT", "1")),
                },
                "epoch_cap": int(train_cfg["pretrain_epochs"]),
                "patience": int(train_cfg.get("pretrain_patience", 0)),
            }
        )
        pretrain["max_epoch_hit"] = int(pretrain.get("stopped_epoch", 0)) >= int(
            train_cfg["pretrain_epochs"]
        )
        atomic_write_json(meta_path, pretrain)
    if needs_pretraining and not checkpoint_pair_valid(ckpt, meta_path):
        raise RuntimeError(f"Incomplete or checksum-mismatched pretrain cache: {ckpt}")
    downstream_train_idx = sample_label_budget(y, splits["train"], label_budget, seed)
    train_class_counts = torch.bincount(y[downstream_train_idx], minlength=3)
    downstream_index_sha256 = sha256_tensor(downstream_train_idx)
    data_lineage = dataset_provenance(config, stock, data_path)

    for setting, result_path in zip(settings, result_paths):
        if completed_result(result_path) and not force:
            print(f"SKIP {stock} {method} {setting}: {result_path}", flush=True)
            continue
        # Reset before every downstream arm so that the random encoder/head
        # initialization is paired across from-scratch and pretrained controls.
        set_seed(seed)
        encoder = build_method(method, latent_dim, d_model, nhead=nhead)
        uses_pretraining = setting != "from_scratch"
        if uses_pretraining:
            encoder.load_state_dict(torch.load(ckpt, map_location="cpu"))
        initial_encoder_state_sha256 = sha256_state_dict(encoder.state_dict())
        downstream_setting = "fine_tune" if setting == "from_scratch" else setting
        downstream = train_downstream_model(
            encoder,
            x,
            y,
            splits,
            downstream_train_idx,
            train_cfg,
            downstream_setting,
            device,
            test_group_ids=test_group_ids,
        )
        condition_name = result_setting_name(config, setting)
        training_condition = (
            "direct"
            if setting == "from_scratch"
            else ("pooled" if pretrain_scope == "pooled" else "target_local")
        )
        task_id = os.environ.get("LOBENCH_TASK_ID") or (
            f"{config.get('duration')}__{training_condition}__{stock}__"
            f"{method}__seed{seed}"
        )
        result = {
            "schema": "training_duration_core_result_v1",
            "status": "complete",
            "experiment_id": config.get("experiment_id"),
            "config_path": config.get("_config_path"),
            "config_sha256": config.get("_config_sha256"),
            "duration": config.get("duration"),
            "stock": stock,
            "method": method,
            "setting": setting,
            "condition": condition_name,
            "training_condition": training_condition,
            "downstream_setting": downstream_setting,
            "initialization": "pretrained" if uses_pretraining else "random",
            "pretrain_used": uses_pretraining,
            "seed": seed,
            "label_budget": label_budget,
            "label_horizon": config.get("data", {}).get("label_horizon"),
            "label_threshold": config.get("data", {}).get("label_threshold"),
            "hyperparameters": {
                "latent_dim": latent_dim,
                "d_model": d_model,
                "nhead": nhead,
                "mask_ratio": mask_ratio,
                "learning_rate": float(train_cfg["learning_rate"]),
                "batch_size": int(train_cfg["batch_size"]),
                "weight_decay": float(train_cfg["weight_decay"]),
                "pretrain_epoch_cap": int(train_cfg.get("pretrain_epochs", 0)),
                "pretrain_patience": int(train_cfg.get("pretrain_patience", 0)),
                "downstream_epoch_cap": int(train_cfg["downstream_epochs"]),
                "downstream_patience": int(train_cfg.get("downstream_patience", 0)),
            },
            "train_samples": int(len(downstream_train_idx)),
            "full_train_samples": int(len(splits["train"])),
            "downstream_train_index_sha256": downstream_index_sha256,
            "downstream_train_index_count": int(len(downstream_train_idx)),
            "downstream_train_index_class_counts": {
                "down": int(train_class_counts[0]),
                "stationary": int(train_class_counts[1]),
                "up": int(train_class_counts[2]),
            },
            "downstream_train_class_counts": {
                "down": int(train_class_counts[0]),
                "stationary": int(train_class_counts[1]),
                "up": int(train_class_counts[2]),
            },
            "classification_head": {
                "architecture": "LayerNorm(latent_dim)+Linear(latent_dim,3)",
                "latent_dim": latent_dim,
                "classes": ["down", "stationary", "up"],
                "paired_initialization_seed": seed,
            },
            "pretrain": pretrain,
            "pretrain_scope": pretrain_scope if uses_pretraining else "none",
            "configured_pretrain_scope": pretrain_scope,
            "pretrain_id": (
                pretrain_id if pretrain_scope == "pooled" else stock
            ) if uses_pretraining else None,
            "pretrain_run_id": pretrain_run_id if uses_pretraining else None,
            "pretrain_index_key": pretrain_index_key,
            "downstream_index_key": downstream_index_key,
            "pretrain_cached": bool(pretrain.get("cached")),
            "pretrain_cache_dir": str(pretrain_dir),
            "encoder_checkpoint_path": str(ckpt.resolve()) if uses_pretraining else None,
            "encoder_checkpoint_sha256": sha256_file(ckpt) if uses_pretraining else None,
            "initial_encoder_state_sha256": initial_encoder_state_sha256,
            "random_initialization_sha256": (
                initial_encoder_state_sha256 if not uses_pretraining else None
            ),
            "data_lineage": data_lineage,
            "reproducibility": {
                "paired_seed_reset": True,
                "deterministic_algorithms": bool(
                    torch.are_deterministic_algorithms_enabled()
                ),
                "cudnn_deterministic": bool(torch.backends.cudnn.deterministic),
                "cudnn_benchmark": bool(torch.backends.cudnn.benchmark),
                "task_id": task_id,
                "attempt": int(os.environ.get("LOBENCH_RUN_ATTEMPT", "1")),
            },
            "data_protocol": {
                "sessions": config.get("data", {}).get("sessions"),
                "session_end_inclusive": config.get("data", {}).get(
                    "session_end_inclusive"
                ),
                "sampling": config.get("data", {}).get("sampling"),
                "label_budget_sampling": "per-class-stratified-within-natural-train",
            },
            **downstream,
        }
        result["total_seconds"] = result["downstream_seconds"] + (
            float(pretrain.get("seconds", 0.0)) if uses_pretraining else 0.0
        )
        result["completed_at_utc"] = utc_now()
        atomic_write_json(result_path, result)
        print(
            f"DONE {stock} {method} {setting}: "
            f"macro_f1={result['test']['macro_f1']:.4f} acc={result['test']['accuracy']:.4f}",
            flush=True,
        )


def summarize(config, name: str):
    out_dir = Path(config["results_dir"])
    rows = []
    for path in sorted(out_dir.glob("*.json")):
        if path.name.endswith(".pretrain.json"):
            continue
        data = json.loads(path.read_text(encoding="utf-8"))
        if "test" not in data:
            continue
        rows.append(
            {
                "stock": data["stock"],
                "method": data["method"],
                "setting": data["setting"],
                "seed": data["seed"],
                "label_budget": data["label_budget"],
                "macro_f1": data["test"]["macro_f1"],
                "balanced_accuracy": data["test"]["balanced_accuracy"],
                "accuracy": data["test"]["accuracy"],
                "best_epoch": data["best_epoch"],
                "pretrain_best_epoch": data["pretrain"].get("best_epoch"),
                "total_seconds": data["total_seconds"],
            }
        )
    summary_dir = out_dir.parent / "summary"
    summary_dir.mkdir(parents=True, exist_ok=True)
    csv_path = summary_dir / f"{name}_per_stock.csv"
    md_path = summary_dir / f"{name}_summary.md"
    if rows:
        import csv

        with csv_path.open("w", newline="", encoding="utf-8") as fh:
            writer = csv.DictWriter(fh, fieldnames=list(rows[0].keys()))
            writer.writeheader()
            writer.writerows(rows)
    grouped = {}
    for row in rows:
        grouped.setdefault((row["method"], row["setting"]), []).append(row["macro_f1"])
    lines = [f"# {name} Summary", "", "| method | setting | n | mean_macro_f1 |", "|---|---|---:|---:|"]
    for (method, setting), values in sorted(grouped.items()):
        lines.append(f"| {method} | {setting} | {len(values)} | {sum(values) / len(values):.4f} |")
    md_path.write_text("\n".join(lines) + "\n", encoding="utf-8")
    print(f"wrote {csv_path}", flush=True)
    print(f"wrote {md_path}", flush=True)


def parse_args():
    parser = argparse.ArgumentParser()
    parser.add_argument("--config", required=True)
    parser.add_argument("--stocks", nargs="+")
    parser.add_argument("--methods", nargs="+")
    parser.add_argument("--settings", nargs="+")
    parser.add_argument("--seeds", nargs="+", type=int)
    parser.add_argument("--label-budgets", nargs="+", type=float)
    parser.add_argument("--force", action="store_true")
    parser.add_argument("--force-pretrain", action="store_true")
    parser.add_argument("--pretrain-epochs", type=int, default=None)
    parser.add_argument("--downstream-epochs", type=int, default=None)
    parser.add_argument("--summarize-only", action="store_true")
    parser.add_argument("--no-summarize", action="store_true")
    parser.add_argument("--name", default=None)
    return parser.parse_args()


def main():
    args = parse_args()
    config_path = Path(args.config)
    config = json.loads(config_path.read_text(encoding="utf-8"))
    config["_config_path"] = str(config_path.resolve())
    config["_config_sha256"] = sha256_file(config_path)
    if args.pretrain_epochs is not None:
        config["training"]["pretrain_epochs"] = int(args.pretrain_epochs)
    if args.downstream_epochs is not None:
        config["training"]["downstream_epochs"] = int(args.downstream_epochs)
    name = args.name or Path(args.config).stem
    if args.summarize_only:
        summarize(config, name)
        return
    stocks = args.stocks or config["stocks"]
    methods = args.methods or config["methods"]
    settings = args.settings or config["settings"]
    seeds = args.seeds or config["seeds"]
    label_budgets = args.label_budgets or config["label_budgets"]
    total = len(stocks) * len(methods) * len(seeds) * len(label_budgets)
    i = 0
    for stock in stocks:
        for method in methods:
            for seed in seeds:
                for label_budget in label_budgets:
                    i += 1
                    print(f"RUN {i}/{total} {stock} {method} seed={seed} budget={label_budget}", flush=True)
                    run_one(
                        config,
                        stock,
                        method,
                        seed,
                        label_budget,
                        settings,
                        force=args.force,
                        force_pretrain=args.force_pretrain,
                    )
    if not args.no_summarize:
        summarize(config, name)


if __name__ == "__main__":
    main()