#!/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()