Datasets:

mythezone
/

LOBench-A-share-processed

#!/usr/bin/env python3
"""Architecture coverage for LOB reconstruction and masked-value imputation.
The experiment retains the nine architecture names used in the first
submission.  Each benchmark-side adapter emits a 128-dimensional vector and
uses the same two-layer sequential Transformer decoder.  This isolates encoder
architecture coverage from the controlled representation-reuse experiment.
"""

from __future__ import annotations

import argparse
import copy
import csv
import json
import math
import statistics
import sys
import time
from pathlib import Path

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


ROOT = Path(__file__).resolve().parents[3]
ADMA_SRC = ROOT / "experiments/adma2026_representation/src"
TBD_SCRIPTS = ROOT / "experiments/tbd_revision/scripts"
for source in (ADMA_SRC, TBD_SCRIPTS, ROOT):
    if str(source) not in sys.path:
        sys.path.insert(0, str(source))

from models import (  # noqa: E402
    AutoEncoder,
    PositionalEncoding,
    SimLOBStyleEncoder,
    TransformerEncoder,
)
from train_downstream import load_npz, set_seed  # noqa: E402
from train_representation_baselines import lob_validity_metrics  # noqa: E402
from run_representation_task_suite import load_normalization as load_data_normalization  # noqa: E402

MODEL_ORDER = (
    "cnn2",
    "lstm",
    "transformer",
    "itransformer",
    "timesnet",
    "timemixer",
    "deeplob",
    "translob",
    "simlob",
)
MODEL_NAMES = {
    "cnn2": "CNN2-derived",
    "lstm": "LSTM-derived",
    "transformer": "Transformer-derived",
    "itransformer": "iTransformer-derived",
    "timesnet": "TimesNet-derived",
    "timemixer": "TimeMixer-derived",
    "deeplob": "DeepLOB-derived",
    "translob": "TransLOB-derived",
    "simlob": "SimLOB-derived",
}
MODEL_FAMILIES = {
    "cnn2": "Foundational",
    "lstm": "Foundational",
    "transformer": "Foundational",
    "itransformer": "Generic time series",
    "timesnet": "Generic time series",
    "timemixer": "Generic time series",
    "deeplob": "LOB specific",
    "translob": "LOB specific",
    "simlob": "LOB specific",
}


class CNN2Adapter(nn.Module):
    """CNN2-derived two-dimensional convolutional encoder."""

    def __init__(self, latent_dim: int = 128):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(1, 16, kernel_size=(7, 3), padding=(3, 1)),
            nn.BatchNorm2d(16),
            nn.PReLU(),
            nn.MaxPool2d((2, 1)),
            nn.Conv2d(16, 32, kernel_size=(5, 3), padding=(2, 1)),
            nn.BatchNorm2d(32),
            nn.PReLU(),
            nn.MaxPool2d((2, 2)),
            nn.Conv2d(32, 32, kernel_size=(3, 3), padding=1),
            nn.BatchNorm2d(32),
            nn.PReLU(),
            nn.AvgPool2d(kernel_size=(5, 4), stride=(5, 4)),
        )
        self.output = nn.Linear(32 * 5 * 5, latent_dim)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.output(self.features(x.unsqueeze(1)).flatten(1))


class LSTMAdapter(nn.Module):
    """Three-layer LSTM encoder used in the foundational architecture group."""

    def __init__(self, latent_dim: int = 128, hidden_dim: int = 128):
        super().__init__()
        self.input = nn.Linear(40, hidden_dim)
        self.recurrent = nn.LSTM(
            hidden_dim,
            hidden_dim,
            num_layers=3,
            batch_first=True,
            dropout=0.1,
        )
        self.output = nn.Linear(hidden_dim, latent_dim)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        _, (hidden, _) = self.recurrent(self.input(x))
        return self.output(hidden[-1])


class InvertedTransformerAdapter(nn.Module):
    """iTransformer-derived encoder that treats LOB variables as tokens."""

    def __init__(self, latent_dim: int = 128, hidden_dim: int = 96):
        super().__init__()
        self.embedding = nn.Linear(100, hidden_dim)
        layer = nn.TransformerEncoderLayer(
            d_model=hidden_dim,
            nhead=4,
            dim_feedforward=4 * hidden_dim,
            dropout=0.1,
            activation="gelu",
            batch_first=True,
        )
        self.encoder = nn.TransformerEncoder(layer, num_layers=2)
        self.output = nn.Linear(hidden_dim, latent_dim)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        variable_tokens = self.embedding(x.transpose(1, 2))
        return self.output(self.encoder(variable_tokens).mean(dim=1))


class TemporalMultiScaleBlock(nn.Module):
    def __init__(self, hidden_dim: int):
        super().__init__()
        self.paths = nn.ModuleList(
            [
                nn.Conv1d(
                    hidden_dim,
                    hidden_dim,
                    kernel_size=kernel,
                    padding=kernel // 2,
                    groups=hidden_dim,
                )
                for kernel in (3, 5, 9)
            ]
        )
        self.mix = nn.Conv1d(3 * hidden_dim, hidden_dim, kernel_size=1)
        self.norm = nn.LayerNorm(hidden_dim)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        temporal = x.transpose(1, 2)
        mixed = self.mix(torch.cat([path(temporal) for path in self.paths], dim=1))
        return self.norm(x + torch.nn.functional.gelu(mixed.transpose(1, 2)))


class TimesNetAdapter(nn.Module):
    """TimesNet-derived encoder with parallel temporal scales."""

    def __init__(self, latent_dim: int = 128, hidden_dim: int = 96):
        super().__init__()
        self.input = nn.Linear(40, hidden_dim)
        self.blocks = nn.Sequential(
            TemporalMultiScaleBlock(hidden_dim),
            TemporalMultiScaleBlock(hidden_dim),
        )
        self.output = nn.Linear(hidden_dim, latent_dim)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        return self.output(self.blocks(self.input(x)).mean(dim=1))


class TimeMixerAdapter(nn.Module):
    """TimeMixer-derived encoder that mixes three temporal resolutions."""

    def __init__(self, latent_dim: int = 128, hidden_dim: int = 96):
        super().__init__()
        self.input = nn.Linear(40, hidden_dim)
        self.scale_mixer = nn.ModuleList(
            [
                nn.Sequential(
                    nn.LayerNorm(hidden_dim),
                    nn.Linear(hidden_dim, 2 * hidden_dim),
                    nn.GELU(),
                    nn.Linear(2 * hidden_dim, hidden_dim),
                )
                for _ in range(3)
            ]
        )
        self.output = nn.Linear(3 * hidden_dim, latent_dim)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        scales = [x]
        temporal = x.transpose(1, 2)
        for factor in (2, 4):
            scales.append(
                torch.nn.functional.avg_pool1d(
                    temporal,
                    kernel_size=factor,
                    stride=factor,
                ).transpose(1, 2)
            )
        summaries = []
        for scale, mixer in zip(scales, self.scale_mixer, strict=True):
            hidden = self.input(scale)
            summaries.append((hidden + mixer(hidden)).mean(dim=1))
        return self.output(torch.cat(summaries, dim=1))


class DeepLOBAdapter(nn.Module):
    """DeepLOB-derived convolution, inception, and recurrent encoder."""

    def __init__(self, latent_dim: int = 128):
        super().__init__()
        self.feature_convolution = nn.Sequential(
            nn.Conv2d(1, 32, kernel_size=(1, 2), stride=(1, 2)),
            nn.LeakyReLU(0.01),
            nn.BatchNorm2d(32),
            nn.Conv2d(32, 32, kernel_size=(3, 1), padding=(1, 0)),
            nn.LeakyReLU(0.01),
            nn.BatchNorm2d(32),
            nn.Conv2d(32, 32, kernel_size=(1, 2), stride=(1, 2)),
            nn.LeakyReLU(0.01),
            nn.BatchNorm2d(32),
            nn.Conv2d(32, 32, kernel_size=(1, 10)),
            nn.LeakyReLU(0.01),
            nn.BatchNorm2d(32),
        )
        self.inception_1 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=1),
            nn.LeakyReLU(0.01),
            nn.Conv2d(64, 64, kernel_size=(3, 1), padding=(1, 0)),
        )
        self.inception_2 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=1),
            nn.LeakyReLU(0.01),
            nn.Conv2d(64, 64, kernel_size=(5, 1), padding=(2, 0)),
        )
        self.inception_3 = nn.Sequential(
            nn.MaxPool2d((3, 1), stride=(1, 1), padding=(1, 0)),
            nn.Conv2d(32, 64, kernel_size=1),
        )
        self.recurrent = nn.LSTM(192, 128, batch_first=True)
        self.output = nn.Linear(128, latent_dim)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        hidden = self.feature_convolution(x.unsqueeze(1))
        hidden = torch.cat(
            [self.inception_1(hidden), self.inception_2(hidden), self.inception_3(hidden)],
            dim=1,
        )
        hidden = hidden.squeeze(-1).transpose(1, 2)
        hidden, _ = self.recurrent(hidden)
        return self.output(hidden[:, -1, :])


class TransLOBAdapter(nn.Module):
    """TransLOB-derived dilated temporal convolution and attention encoder."""

    def __init__(self, latent_dim: int = 128, hidden_dim: int = 96):
        super().__init__()
        self.convolution = nn.Sequential(
            nn.Conv1d(40, hidden_dim, kernel_size=3, padding=1),
            nn.GELU(),
            nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, dilation=2, padding=2),
            nn.GELU(),
            nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, dilation=4, padding=4),
            nn.GELU(),
            nn.Conv1d(hidden_dim, hidden_dim, kernel_size=3, dilation=8, padding=8),
            nn.GELU(),
        )
        self.position = PositionalEncoding(hidden_dim)
        layer = nn.TransformerEncoderLayer(
            d_model=hidden_dim,
            nhead=4,
            dim_feedforward=4 * hidden_dim,
            dropout=0.1,
            activation="gelu",
            batch_first=True,
        )
        self.temporal = nn.TransformerEncoder(layer, num_layers=2)
        self.output = nn.Linear(hidden_dim, latent_dim)

    def forward(self, x: torch.Tensor) -> torch.Tensor:
        hidden = self.convolution(x.transpose(1, 2)).transpose(1, 2)
        hidden = self.temporal(self.position(hidden))
        return self.output(hidden.mean(dim=1))


def build_encoder(name: str, latent_dim: int = 128, hidden_dim: int = 96) -> nn.Module:
    if name == "cnn2":
        return CNN2Adapter(latent_dim=latent_dim)
    if name == "lstm":
        return LSTMAdapter(latent_dim=latent_dim)
    if name == "transformer":
        return TransformerEncoder(
            latent_dim=latent_dim,
            d_model=hidden_dim,
            nhead=4,
            layers=2,
        )
    if name == "itransformer":
        return InvertedTransformerAdapter(latent_dim=latent_dim, hidden_dim=hidden_dim)
    if name == "timesnet":
        return TimesNetAdapter(latent_dim=latent_dim, hidden_dim=hidden_dim)
    if name == "timemixer":
        return TimeMixerAdapter(latent_dim=latent_dim, hidden_dim=hidden_dim)
    if name == "deeplob":
        return DeepLOBAdapter(latent_dim=latent_dim)
    if name == "translob":
        return TransLOBAdapter(latent_dim=latent_dim, hidden_dim=hidden_dim)
    if name == "simlob":
        return SimLOBStyleEncoder(
            latent_dim=latent_dim,
            d_model=hidden_dim,
            nhead=4,
        )
    raise KeyError(f"unknown model {name!r}")


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


def load_normalization(config: dict, stock: str) -> dict[str, float]:
    return load_data_normalization(ROOT / config["processed_dir"], stock)


def make_loader(
    x: torch.Tensor,
    index: torch.Tensor,
    batch_size: int,
    shuffle: bool,
    seed: int,
    num_workers: int,
) -> DataLoader:
    generator = torch.Generator()
    generator.manual_seed(seed)
    return DataLoader(
        TensorDataset(x[index]),
        batch_size=batch_size,
        shuffle=shuffle,
        num_workers=num_workers,
        pin_memory=torch.cuda.is_available(),
        generator=generator,
    )


def entry_mask(x: torch.Tensor, ratio: float, seed: int) -> torch.Tensor:
    if not 0 < ratio < 1:
        raise ValueError("mask ratio must lie between zero and one")
    generator = torch.Generator(device=x.device)
    generator.manual_seed(int(seed))
    return torch.rand(x.shape, generator=generator, device=x.device) < ratio


def model_input_and_target(
    x: torch.Tensor,
    task: str,
    mask_ratio: float,
    mask_seed: int,
) -> tuple[torch.Tensor, torch.Tensor]:
    if task == "reconstruction":
        return x, torch.ones_like(x, dtype=torch.bool)
    if task == "imputation":
        mask = entry_mask(x, mask_ratio, mask_seed)
        return x.masked_fill(mask, 0.0), mask
    raise KeyError(task)


def inverse_grouped(x: torch.Tensor, normalization: dict[str, float]) -> torch.Tensor:
    raw = x.clone()
    raw[..., :20] = (
        raw[..., :20] * normalization["price_std"] + normalization["price_mean"]
    )
    raw[..., 20:] = (
        raw[..., 20:] * normalization["volume_std"] + normalization["volume_mean"]
    )
    return raw


def evaluate(
    model: nn.Module,
    loader: DataLoader,
    task: str,
    mask_ratio: float,
    mask_seed: int,
    device: torch.device,
    normalization: dict[str, float],
) -> dict[str, float]:
    model.eval()
    squared_error = 0.0
    absolute_error = 0.0
    evaluated_entries = 0
    endpoint_squared_error = 0.0
    endpoint_entries = 0
    raw_price_absolute_error = 0.0
    raw_volume_absolute_error = 0.0
    raw_price_entries = 0
    raw_volume_entries = 0
    validity_totals: dict[str, float] = {}
    observations = 0
    with torch.no_grad():
        for batch_number, (target,) in enumerate(loader):
            target = target.to(device, non_blocking=True)
            input_x, mask = model_input_and_target(
                target,
                task,
                mask_ratio,
                mask_seed + batch_number,
            )
            prediction = model(input_x)
            completed = prediction if task == "reconstruction" else torch.where(mask, prediction, target)
            difference = prediction - target
            region = difference[mask]
            squared_error += float((region * region).sum().item())
            absolute_error += float(region.abs().sum().item())
            evaluated_entries += int(region.numel())

            endpoint_difference = completed[:, -1, :] - target[:, -1, :]
            endpoint_squared_error += float((endpoint_difference * endpoint_difference).sum().item())
            endpoint_entries += int(endpoint_difference.numel())

            raw_prediction = inverse_grouped(prediction, normalization)
            raw_target = inverse_grouped(target, normalization)
            raw_difference = (raw_prediction - raw_target).abs()
            price_mask = mask[..., :20]
            volume_mask = mask[..., 20:]
            raw_price_absolute_error += float(raw_difference[..., :20][price_mask].sum().item())
            raw_volume_absolute_error += float(raw_difference[..., 20:][volume_mask].sum().item())
            raw_price_entries += int(price_mask.sum().item())
            raw_volume_entries += int(volume_mask.sum().item())

            validity = lob_validity_metrics(
                completed[:, -1:, :],
                target[:, -1:, :],
                normalization=normalization,
                raw_price_tick_size=0.01,
            )
            observations += len(target)
            for key, value in validity.items():
                validity_totals[key] = validity_totals.get(key, 0.0) + float(value) * len(target)

    return {
        "normalized_mse": squared_error / max(evaluated_entries, 1),
        "normalized_mae": absolute_error / max(evaluated_entries, 1),
        "endpoint_completed_mse": endpoint_squared_error / max(endpoint_entries, 1),
        "raw_price_mae": raw_price_absolute_error / max(raw_price_entries, 1),
        "raw_volume_mae": raw_volume_absolute_error / max(raw_volume_entries, 1),
        "evaluated_entries": float(evaluated_entries),
        **{key: value / max(observations, 1) for key, value in validity_totals.items()},
    }


def run_case(
    config: dict,
    model_name: str,
    task: str,
    stock: str,
    seed: int,
    results_dir: Path,
    force: bool,
) -> None:
    output_path = results_dir / f"{stock}_{model_name}_{task}_seed{seed}.json"
    if output_path.exists() and not force:
        print(f"SKIP {stock} {model_name} {task} seed={seed}", flush=True)
        return
    set_seed(seed)
    training = config["training"]
    device = torch.device(training.get("device", "cuda") if torch.cuda.is_available() else "cpu")
    x, _, splits = load_npz(data_path(config, stock))
    normalization = load_normalization(config, stock)
    batch_size = int(training.get("batch_size", 128))
    num_workers = int(training.get("num_workers", 0))
    train_loader = make_loader(x, splits["train"], batch_size, True, seed, num_workers)
    validation_loader = make_loader(x, splits["val"], batch_size, False, seed, num_workers)
    test_loader = make_loader(x, splits["test"], batch_size, False, seed, num_workers)

    latent_dim = int(training.get("latent_dim", 128))
    hidden_dim = int(training.get("hidden_dim", 96))
    encoder = build_encoder(model_name, latent_dim=latent_dim, hidden_dim=hidden_dim)
    model = AutoEncoder(
        encoder,
        latent_dim=latent_dim,
        decoder_name="transformer_seq",
        decoder_layers=int(training.get("decoder_layers", 2)),
        decoder_heads=int(training.get("decoder_heads", 8)),
        decoder_d_model=int(training.get("decoder_d_model", 128)),
    ).to(device)
    encoder_parameters = sum(parameter.numel() for parameter in encoder.parameters())
    total_parameters = sum(parameter.numel() for parameter in model.parameters())
    optimizer = torch.optim.AdamW(
        model.parameters(),
        lr=float(training.get("learning_rate", 3e-4)),
        weight_decay=float(training.get("weight_decay", 1e-5)),
    )
    epochs = int(training.get("epochs", 20))
    patience = int(training.get("patience", 6))
    mask_ratio = float(config.get("imputation_mask_ratio", 0.2))
    best_validation = math.inf
    best_epoch = 0
    best_state = copy.deepcopy(model.state_dict())
    stale = 0
    history: list[dict[str, float | int]] = []
    started = time.perf_counter()
    for epoch in range(1, epochs + 1):
        model.train()
        loss_sum = 0.0
        entry_count = 0
        epoch_started = time.perf_counter()
        for batch_number, (target,) in enumerate(train_loader):
            target = target.to(device, non_blocking=True)
            input_x, mask = model_input_and_target(
                target,
                task,
                mask_ratio,
                seed * 1_000_000 + epoch * 10_000 + batch_number,
            )
            optimizer.zero_grad(set_to_none=True)
            prediction = model(input_x)
            difference = prediction[mask] - target[mask]
            loss = torch.mean(difference * difference)
            loss.backward()
            optimizer.step()
            loss_sum += float((difference.detach() * difference.detach()).sum().item())
            entry_count += int(difference.numel())
        validation = evaluate(
            model,
            validation_loader,
            task,
            mask_ratio,
            seed * 10_000 + 2_000,
            device,
            normalization,
        )
        validation_loss = validation["normalized_mse"]
        history.append(
            {
                "epoch": epoch,
                "train_mse": loss_sum / max(entry_count, 1),
                "validation_mse": validation_loss,
                "epoch_seconds": time.perf_counter() - epoch_started,
            }
        )
        print(
            f"EPOCH {stock} {model_name} {task} seed={seed} {epoch}/{epochs} "
            f"train={history[-1]['train_mse']:.6f} val={validation_loss:.6f}",
            flush=True,
        )
        if validation_loss < best_validation - 1e-6:
            best_validation = validation_loss
            best_epoch = epoch
            best_state = copy.deepcopy(model.state_dict())
            stale = 0
        else:
            stale += 1
        if patience and stale >= patience:
            break
    model.load_state_dict(best_state)
    test = evaluate(
        model,
        test_loader,
        task,
        mask_ratio,
        seed * 10_000 + 4_000,
        device,
        normalization,
    )
    payload = {
        "stock": stock,
        "model": model_name,
        "model_name": MODEL_NAMES[model_name],
        "family": MODEL_FAMILIES[model_name],
        "task": task,
        "seed": seed,
        "encoder_parameters": encoder_parameters,
        "total_parameters": total_parameters,
        "representation_dimension": latent_dim,
        "hidden_dimension": hidden_dim,
        "decoder": "common two-layer sequential Transformer",
        "imputation_mask": {
            "unit": "individual LOB entries",
            "ratio": mask_ratio,
            "replacement": "zero in normalized coordinates",
        },
        "best_epoch": best_epoch,
        "stopped_epoch": len(history),
        "best_validation_mse": best_validation,
        "seconds": time.perf_counter() - started,
        "test": test,
        "history": history,
    }
    output_path.parent.mkdir(parents=True, exist_ok=True)
    output_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
    print(
        f"DONE {stock} {model_name} {task} seed={seed} "
        f"mse={test['normalized_mse']:.6f}",
        flush=True,
    )


def bootstrap_stock_interval(values: list[float], seed: int) -> tuple[float, float]:
    rng = np.random.default_rng(seed)
    array = np.asarray(values, dtype=float)
    draws = rng.choice(array, size=(20_000, len(array)), replace=True).mean(axis=1)
    return float(np.quantile(draws, 0.025)), float(np.quantile(draws, 0.975))


def summarize(config: dict, results_dir: Path, output_dir: Path) -> None:
    rows = [json.loads(path.read_text(encoding="utf-8")) for path in sorted(results_dir.glob("*.json"))]
    expected = {
        (stock, model, task, seed)
        for stock in config["stocks"]
        for model in config["models"]
        for task in config["tasks"]
        for seed in config["seeds"]
    }
    observed = {(row["stock"], row["model"], row["task"], int(row["seed"])) for row in rows}
    missing = sorted(expected - observed)
    if missing:
        raise ValueError(f"missing {len(missing)} architecture-task cases; first={missing[:3]}")

    case_rows: list[dict[str, object]] = []
    for row in rows:
        case_rows.append(
            {
                "stock": row["stock"],
                "model": row["model"],
                "model_name": row["model_name"],
                "family": row["family"],
                "task": row["task"],
                "seed": row["seed"],
                "best_epoch": row["best_epoch"],
                "stopped_epoch": row["stopped_epoch"],
                "seconds": row["seconds"],
                "encoder_parameters": row["encoder_parameters"],
                "total_parameters": row["total_parameters"],
                **row["test"],
            }
        )

    metric_names = (
        "normalized_mse",
        "normalized_mae",
        "raw_price_mae",
        "raw_volume_mae",
        "tick_spread_valid_rate",
        "joint_five_constraint_snapshot_valid_rate",
        "mean_price_constraint_violation_ticks",
    )
    summary_rows: list[dict[str, object]] = []
    for model in config["models"]:
        for task in config["tasks"]:
            group = [row for row in case_rows if row["model"] == model and row["task"] == task]
            stock_means: dict[str, dict[str, float]] = {}
            for stock in config["stocks"]:
                stock_group = [row for row in group if row["stock"] == stock]
                stock_means[stock] = {
                    metric: statistics.fmean(float(row[metric]) for row in stock_group)
                    for metric in metric_names
                }
            mse_values = [stock_means[stock]["normalized_mse"] for stock in config["stocks"]]
            interval = bootstrap_stock_interval(mse_values, 20260802 + MODEL_ORDER.index(model))
            item: dict[str, object] = {
                "model": model,
                "model_name": MODEL_NAMES[model],
                "family": MODEL_FAMILIES[model],
                "task": task,
                "n_stocks": len(config["stocks"]),
                "seeds_per_stock": len(config["seeds"]),
                "encoder_parameters": int(group[0]["encoder_parameters"]),
                "total_parameters": int(group[0]["total_parameters"]),
                "normalized_mse_ci95_low": interval[0],
                "normalized_mse_ci95_high": interval[1],
                "best_epoch_mean": statistics.fmean(float(row["best_epoch"]) for row in group),
                "seconds_mean": statistics.fmean(float(row["seconds"]) for row in group),
            }
            for metric in metric_names:
                values = [stock_means[stock][metric] for stock in config["stocks"]]
                item[f"{metric}_mean"] = statistics.fmean(values)
                item[f"{metric}_stock_sd"] = statistics.stdev(values)
            summary_rows.append(item)

    output_dir.mkdir(parents=True, exist_ok=True)
    case_path = output_dir / "architecture_task_coverage_cases.csv"
    with case_path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(case_rows[0]))
        writer.writeheader()
        writer.writerows(case_rows)
    summary_path = output_dir / "architecture_task_coverage_summary.csv"
    with summary_path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(summary_rows[0]))
        writer.writeheader()
        writer.writerows(summary_rows)

    summary_lookup = {(row["model"], row["task"]): row for row in summary_rows}
    markdown = [
        "# Nine-architecture reconstruction and imputation coverage",
        "",
        (
            "All benchmark-side adapters emit a 128-dimensional representation and use "
            "the same two-layer sequential Transformer decoder. Results average three "
            "seeds within each stock and then average the five stocks. Imputation masks "
            "20% of individual entries; errors are evaluated on the hidden entries."
        ),
        "",
        "| Family | Adapter | Encoder params | Reconstruction MSE | Imputation MSE | Imputation price MAE | Imputation joint validity |",
        "|---|---|---:|---:|---:|---:|---:|",
    ]
    for model in config["models"]:
        reconstruction = summary_lookup[(model, "reconstruction")]
        imputation = summary_lookup[(model, "imputation")]
        markdown.append(
            f"| {MODEL_FAMILIES[model]} | {MODEL_NAMES[model]} | "
            f"{int(reconstruction['encoder_parameters']):,} | "
            f"{float(reconstruction['normalized_mse_mean']):.4f} | "
            f"{float(imputation['normalized_mse_mean']):.4f} | "
            f"{float(imputation['raw_price_mae_mean']):.4f} | "
            f"{100 * float(imputation['joint_five_constraint_snapshot_valid_rate_mean']):.1f}% |"
        )
    markdown_path = output_dir / "architecture_task_coverage.md"
    markdown_path.write_text("\n".join(markdown) + "\n", encoding="utf-8")
    print(f"wrote {case_path}")
    print(f"wrote {summary_path}")
    print(f"wrote {markdown_path}")


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--config",
        type=Path,
        default=ROOT / "experiments/tbd_revision/configs/final_revision_architecture_task_coverage.json",
    )
    parser.add_argument("--models", nargs="+")
    parser.add_argument("--tasks", nargs="+")
    parser.add_argument("--stocks", nargs="+")
    parser.add_argument("--seeds", nargs="+", type=int)
    parser.add_argument("--results-dir", type=Path)
    parser.add_argument("--output-dir", type=Path)
    parser.add_argument("--force", action="store_true")
    parser.add_argument("--summarize-only", action="store_true")
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    config = json.loads(args.config.read_text(encoding="utf-8"))
    results_dir = args.results_dir or ROOT / config["results_dir"]
    output_dir = args.output_dir or ROOT / config["summary_dir"]
    if args.summarize_only:
        summarize(config, results_dir, output_dir)
        return
    models = args.models or config["models"]
    tasks = args.tasks or config["tasks"]
    stocks = args.stocks or config["stocks"]
    seeds = args.seeds or config["seeds"]
    for model_name in models:
        if model_name not in MODEL_ORDER:
            raise KeyError(model_name)
        for task in tasks:
            for stock in stocks:
                for seed in seeds:
                    run_case(config, model_name, task, stock, seed, results_dir, args.force)


if __name__ == "__main__":
    main()