#!/usr/bin/env python3 """Summarize prediction retraining across four movement thresholds.""" from __future__ import annotations import argparse import csv import json import random import statistics from pathlib import Path METHODS = ("timae", "lobgrid_timae", "simlob2026") STOCKS = ("asset_001", "asset_002", "asset_017", "asset_005", "asset_033") SEEDS = (2026, 2027, 2028) THRESHOLDS = ( (0.0001, "threshold0001"), (0.0003, "baseline"), (0.0005, "threshold0005"), (0.0010, "threshold0010"), ) def parse_args() -> argparse.Namespace: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--baseline-dir", type=Path, required=True) parser.add_argument("--alternate-root", type=Path, required=True) parser.add_argument("--processed-dir", type=Path, required=True) parser.add_argument("--output-dir", type=Path, required=True) return parser.parse_args() def percentile(values: list[float], probability: float) -> float: ordered = sorted(values) position = probability * (len(ordered) - 1) lower = int(position) upper = min(lower + 1, len(ordered) - 1) weight = position - lower return ordered[lower] * (1.0 - weight) + ordered[upper] * weight def bootstrap_ci(values: list[float], seed: int) -> tuple[float, float]: rng = random.Random(seed) draws = sorted( statistics.fmean(values[rng.randrange(len(values))] for _ in values) for _ in range(20_000) ) return percentile(draws, 0.025), percentile(draws, 0.975) def load_cases(directory: Path) -> dict[tuple[str, str, int, str], dict]: cases = {} for path in sorted(directory.glob("*.json")): if path.name.endswith(".pretrain.json") or path.name == "resolved_config.json": continue payload = json.loads(path.read_text(encoding="utf-8")) if ( payload.get("stock") not in STOCKS or payload.get("method") not in METHODS or int(payload.get("seed", -1)) not in SEEDS or abs(float(payload.get("label_budget", -1.0)) - 0.5) > 1e-12 or payload.get("setting") not in {"from_scratch", "fine_tune"} ): continue key = ( str(payload["stock"]), str(payload["method"]), int(payload["seed"]), str(payload["setting"]), ) if key in cases: raise ValueError(f"Duplicate threshold case in {directory}: {key}") cases[key] = payload expected = { (stock, method, seed, setting) for stock in STOCKS for method in METHODS for seed in SEEDS for setting in ("from_scratch", "fine_tune") } if set(cases) != expected: raise ValueError( f"{directory} is incomplete; missing examples: " f"{sorted(expected - set(cases))[:5]}" ) return cases def label_shares(processed_dir: Path, threshold: float) -> dict[str, float]: import numpy as np counts = [0, 0, 0] for stock in STOCKS: with np.load(processed_dir / f"{stock}_pilot.npz") as data: returns = data["future_returns"][data["test_idx"]] labels = np.where( returns > threshold, 2, np.where(returns < -threshold, 0, 1), ) for class_id in range(3): counts[class_id] += int((labels == class_id).sum()) total = sum(counts) return { "test_down_share": counts[0] / total, "test_neutral_share": counts[1] / total, "test_up_share": counts[2] / total, } def write_csv(path: Path, rows: list[dict[str, object]]) -> None: with path.open("w", newline="", encoding="utf-8") as handle: writer = csv.DictWriter(handle, fieldnames=list(rows[0])) writer.writeheader() writer.writerows(rows) def main() -> None: args = parse_args() directories = { variant: args.baseline_dir if variant == "baseline" else args.alternate_root / variant for _, variant in THRESHOLDS } cases = {variant: load_cases(directory) for variant, directory in directories.items()} rows = [] stock_rows = [] for threshold_index, (threshold, variant) in enumerate(THRESHOLDS): shares = label_shares(args.processed_dir, threshold) for method_index, method in enumerate(METHODS): stock_scratch = [] stock_tuned = [] stock_deltas = [] for stock in STOCKS: scratch = [ float(cases[variant][(stock, method, seed, "from_scratch")]["test"]["macro_f1"]) for seed in SEEDS ] tuned = [ float(cases[variant][(stock, method, seed, "fine_tune")]["test"]["macro_f1"]) for seed in SEEDS ] delta = [candidate - baseline for candidate, baseline in zip(tuned, scratch)] stock_scratch.append(statistics.fmean(scratch)) stock_tuned.append(statistics.fmean(tuned)) stock_deltas.append(statistics.fmean(delta)) stock_rows.append( { "threshold": threshold, "variant": variant, "method": method, "stock": stock, "scratch_macro_f1_mean": statistics.fmean(scratch), "pooled_macro_f1_mean": statistics.fmean(tuned), "paired_delta_mean": statistics.fmean(delta), "paired_delta_seed_sd": statistics.stdev(delta), } ) low, high = bootstrap_ci( stock_deltas, 20260802 + 10 * threshold_index + method_index, ) rows.append( { "threshold": threshold, "variant": variant, "method": method, "n_stocks": len(STOCKS), "seeds_per_stock": len(SEEDS), **shares, "scratch_macro_f1_mean": statistics.fmean(stock_scratch), "pooled_macro_f1_mean": statistics.fmean(stock_tuned), "paired_delta_mean": statistics.fmean(stock_deltas), "ci95_low": low, "ci95_high": high, "wins": sum(value > 0 for value in stock_deltas), } ) args.output_dir.mkdir(parents=True, exist_ok=True) write_csv(args.output_dir / "label_threshold_retraining.csv", rows) write_csv(args.output_dir / "label_threshold_retraining_stock.csv", stock_rows) payload = { "design": { "thresholds": [threshold for threshold, _ in THRESHOLDS], "retained_threshold": 0.0003, "stocks": list(STOCKS), "methods": list(METHODS), "seeds": list(SEEDS), "label_budget": 0.5, "pretraining_checkpoint": "fixed retained pooled checkpoint", "role": "exploratory label-definition robustness", }, "rows": rows, } (args.output_dir / "label_threshold_retraining.json").write_text( json.dumps(payload, indent=2) + "\n", encoding="utf-8", ) lines = [ "# Label-threshold retraining", "", "The pooled checkpoint is fixed. Every downstream condition is retrained after regenerating labels from continuous future returns.", "", "| threshold | model | test D/N/U | scratch F1 | pooled F1 | paired delta [95% stock interval] | wins/5 |", "|---:|---|---:|---:|---:|---:|---:|", ] for row in rows: lines.append( f"| {row['threshold']:.4f} | {row['method']} | " f"{row['test_down_share']:.3f}/{row['test_neutral_share']:.3f}/{row['test_up_share']:.3f} | " f"{row['scratch_macro_f1_mean']:.4f} | {row['pooled_macro_f1_mean']:.4f} | " f"{row['paired_delta_mean']:+.4f} " f"[{row['ci95_low']:+.4f}, {row['ci95_high']:+.4f}] | " f"{row['wins']}/5 |" ) (args.output_dir / "label_threshold_retraining.md").write_text( "\n".join(lines) + "\n", encoding="utf-8", ) print(f"wrote {len(rows)} threshold summaries") if __name__ == "__main__": main()