Datasets:

mythezone
/

LOBench-A-share-processed

#!/usr/bin/env python3
"""Summarize matched pretrained-versus-scratch deltas without pseudo-replication."""

from __future__ import annotations

import argparse
import csv
import itertools
import json
import random
import statistics
from collections import defaultdict
from pathlib import Path


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--results-dir", type=Path, required=True)
    parser.add_argument("--out-dir", type=Path, required=True)
    parser.add_argument("--name", required=True)
    parser.add_argument(
        "--methods",
        nargs="+",
        default=["timae", "lobgrid_timae", "simlob2026"],
    )
    parser.add_argument("--targets", nargs="+")
    parser.add_argument("--exclude-targets", nargs="+", default=[])
    parser.add_argument("--seeds", nargs="+", type=int)
    parser.add_argument("--label-budget", type=float, default=0.5)
    parser.add_argument("--allow-incomplete", action="store_true")
    return parser.parse_args()


def percentile(values: list[float], probability: float) -> float:
    if not values:
        return float("nan")
    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_mean_ci(
    values: list[float],
    *,
    seed: int,
    repetitions: int = 20_000,
) -> tuple[float, float]:
    rng = random.Random(seed)
    n = len(values)
    boot = sorted(
        statistics.fmean(values[rng.randrange(n)] for _ in range(n))
        for _ in range(repetitions)
    )
    return percentile(boot, 0.025), percentile(boot, 0.975)


def sign_flip_p(values: list[float], *, seed: int) -> tuple[float, str]:
    observed = abs(statistics.fmean(values))
    tolerance = 1e-15
    if len(values) <= 20:
        null = (
            abs(statistics.fmean(sign * value for sign, value in zip(signs, values)))
            for signs in itertools.product((-1.0, 1.0), repeat=len(values))
        )
        denominator = 2 ** len(values)
        extreme = sum(value >= observed - tolerance for value in null)
        return extreme / denominator, "exact"

    rng = random.Random(seed)
    repetitions = 100_000
    extreme = 0
    for _ in range(repetitions):
        candidate = abs(
            statistics.fmean(
                value if rng.random() < 0.5 else -value for value in values
            )
        )
        extreme += candidate >= observed - tolerance
    return (extreme + 1) / (repetitions + 1), "monte_carlo_100000"


def write_csv(path: Path, rows: list[dict]) -> None:
    if not rows:
        return
    with path.open("w", newline="", encoding="utf-8") as handle:
        writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
        writer.writeheader()
        writer.writerows(rows)


def read_cases(args: argparse.Namespace) -> list[dict]:
    cases = []
    for path in sorted(args.results_dir.glob("*.json")):
        if path.name.endswith(".pretrain.json"):
            continue
        data = json.loads(path.read_text(encoding="utf-8"))
        if "test" not in data or data.get("setting") not in {
            "from_scratch",
            "fine_tune",
        }:
            continue
        target = data["stock"]
        seed = int(data["seed"])
        if data["method"] not in args.methods:
            continue
        if args.targets and target not in args.targets:
            continue
        if target in args.exclude_targets:
            continue
        if args.seeds and seed not in args.seeds:
            continue
        if abs(float(data["label_budget"]) - args.label_budget) > 1e-9:
            continue
        cases.append(
            {
                "target": target,
                "method": data["method"],
                "seed": seed,
                "setting": data["setting"],
                "macro_f1": float(data["test"]["macro_f1"]),
                "balanced_accuracy": float(data["test"]["balanced_accuracy"]),
                "accuracy": float(data["test"]["accuracy"]),
                "source_file": path.name,
            }
        )
    return cases


def main() -> None:
    args = parse_args()
    cases = read_cases(args)
    lookup = {
        (row["target"], row["method"], row["seed"], row["setting"]): row
        for row in cases
    }
    target_values = (
        sorted(set(args.targets) - set(args.exclude_targets))
        if args.targets
        else sorted({row["target"] for row in cases})
    )
    seed_values = (
        sorted(set(args.seeds))
        if args.seeds
        else sorted({row["seed"] for row in cases})
    )
    expected = {
        (target, method, seed, setting)
        for target in target_values
        for method in args.methods
        for seed in seed_values
        for setting in ("from_scratch", "fine_tune")
    }
    missing = sorted(expected - set(lookup))
    if missing and not args.allow_incomplete:
        raise ValueError(f"Missing {len(missing)} matched cases; first: {missing[:5]}")

    paired_rows = []
    for target in target_values:
        for method in args.methods:
            for seed in seed_values:
                scratch = lookup.get((target, method, seed, "from_scratch"))
                pretrained = lookup.get((target, method, seed, "fine_tune"))
                if not scratch or not pretrained:
                    continue
                paired_rows.append(
                    {
                        "target": target,
                        "method": method,
                        "seed": seed,
                        "scratch_macro_f1": scratch["macro_f1"],
                        "pretrained_macro_f1": pretrained["macro_f1"],
                        "paired_delta_macro_f1": pretrained["macro_f1"]
                        - scratch["macro_f1"],
                        "scratch_balanced_accuracy": scratch["balanced_accuracy"],
                        "pretrained_balanced_accuracy": pretrained[
                            "balanced_accuracy"
                        ],
                        "paired_delta_balanced_accuracy": pretrained[
                            "balanced_accuracy"
                        ]
                        - scratch["balanced_accuracy"],
                    }
                )

    grouped: dict[tuple[str, str], list[dict]] = defaultdict(list)
    for row in paired_rows:
        grouped[(row["method"], row["target"])].append(row)
    target_rows = []
    for (method, target), rows in sorted(grouped.items()):
        target_rows.append(
            {
                "method": method,
                "target": target,
                "n_seeds": len(rows),
                "scratch_macro_f1_mean": statistics.fmean(
                    row["scratch_macro_f1"] for row in rows
                ),
                "pretrained_macro_f1_mean": statistics.fmean(
                    row["pretrained_macro_f1"] for row in rows
                ),
                "paired_delta_macro_f1_mean": statistics.fmean(
                    row["paired_delta_macro_f1"] for row in rows
                ),
                "paired_delta_macro_f1_seed_sd": statistics.stdev(
                    row["paired_delta_macro_f1"] for row in rows
                )
                if len(rows) > 1
                else 0.0,
            }
        )

    summary_rows = []
    for method_index, method in enumerate(args.methods):
        per_target = [row for row in target_rows if row["method"] == method]
        if not per_target:
            continue
        if len(per_target) == 1 and per_target[0]["n_seeds"] > 1:
            uncertainty_unit = "seed"
            inferential_values = [
                row["paired_delta_macro_f1"]
                for row in paired_rows
                if row["method"] == method
            ]
        else:
            uncertainty_unit = "target"
            inferential_values = [
                row["paired_delta_macro_f1_mean"] for row in per_target
            ]
        ci_low, ci_high = bootstrap_mean_ci(
            inferential_values,
            seed=20260731 + method_index,
        )
        randomization_p, p_kind = sign_flip_p(
            inferential_values,
            seed=20260831 + method_index,
        )
        summary_rows.append(
            {
                "name": args.name,
                "method": method,
                "n_targets": len(per_target),
                "seeds_per_target_min": min(row["n_seeds"] for row in per_target),
                "seeds_per_target_max": max(row["n_seeds"] for row in per_target),
                "uncertainty_unit": uncertainty_unit,
                "mean_paired_delta_macro_f1": statistics.fmean(inferential_values),
                "median_paired_delta_macro_f1": statistics.median(
                    inferential_values
                ),
                "q1_paired_delta_macro_f1": percentile(inferential_values, 0.25),
                "q3_paired_delta_macro_f1": percentile(inferential_values, 0.75),
                "bootstrap_ci95_low": ci_low,
                "bootstrap_ci95_high": ci_high,
                "wins": sum(value > 0 for value in inferential_values),
                "ties": sum(value == 0 for value in inferential_values),
                "losses": sum(value < 0 for value in inferential_values),
                "sign_flip_p": randomization_p,
                "sign_flip_kind": p_kind,
            }
        )

    args.out_dir.mkdir(parents=True, exist_ok=True)
    write_csv(args.out_dir / "paired_seed_cases.csv", paired_rows)
    write_csv(args.out_dir / "paired_target_summary.csv", target_rows)
    write_csv(args.out_dir / "paired_aggregate_summary.csv", summary_rows)
    lines = [
        f"# {args.name}",
        "",
        f"Completeness: {len(set(lookup))}/{len(expected)} expected arm files.",
        "",
        "Seeds are paired within target. When multiple targets are available, seeds "
        "are averaged inside target before cross-target summaries; therefore target–seed "
        "runs are not treated as independent markets.",
        "",
        "| method | targets | uncertainty unit | mean delta (95% bootstrap CI) | median | IQR | wins | sign-flip p |",
        "|---|---:|---|---:|---:|---:|---:|---:|",
    ]
    for row in summary_rows:
        denominator = (
            row["n_targets"]
            if row["uncertainty_unit"] == "target"
            else row["seeds_per_target_max"]
        )
        lines.append(
            f"| {row['method']} | {row['n_targets']} | {row['uncertainty_unit']} | "
            f"{row['mean_paired_delta_macro_f1']:+.4f} "
            f"[{row['bootstrap_ci95_low']:+.4f}, {row['bootstrap_ci95_high']:+.4f}] | "
            f"{row['median_paired_delta_macro_f1']:+.4f} | "
            f"[{row['q1_paired_delta_macro_f1']:+.4f}, "
            f"{row['q3_paired_delta_macro_f1']:+.4f}] | "
            f"{row['wins']}/{denominator} | {row['sign_flip_p']:.4f} "
            f"({row['sign_flip_kind']}) |"
        )
    if missing:
        lines.extend(["", "## Missing cases", "", *[f"- `{row}`" for row in missing]])
    (args.out_dir / "summary.md").write_text("\n".join(lines) + "\n", encoding="utf-8")
    print(
        f"wrote {args.name} to {args.out_dir}; "
        f"completeness {len(set(lookup))}/{len(expected)}"
    )


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""Summarize matched pretrained-versus-scratch deltas without pseudo-replication."""

	from __future__ import annotations

	import argparse
	import csv
	import itertools
	import json
	import random
	import statistics
	from collections import defaultdict
	from pathlib import Path


	def parse_args() -> argparse.Namespace:
	parser = argparse.ArgumentParser(description=__doc__)
	parser.add_argument("--results-dir", type=Path, required=True)
	parser.add_argument("--out-dir", type=Path, required=True)
	parser.add_argument("--name", required=True)
	parser.add_argument(
	"--methods",
	nargs="+",
	default=["timae", "lobgrid_timae", "simlob2026"],
	)
	parser.add_argument("--targets", nargs="+")
	parser.add_argument("--exclude-targets", nargs="+", default=[])
	parser.add_argument("--seeds", nargs="+", type=int)
	parser.add_argument("--label-budget", type=float, default=0.5)
	parser.add_argument("--allow-incomplete", action="store_true")
	return parser.parse_args()


	def percentile(values: list[float], probability: float) -> float:
	if not values:
	return float("nan")
	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_mean_ci(
	values: list[float],
	*,
	seed: int,
	repetitions: int = 20_000,
	) -> tuple[float, float]:
	rng = random.Random(seed)
	n = len(values)
	boot = sorted(
	statistics.fmean(values[rng.randrange(n)] for _ in range(n))
	for _ in range(repetitions)
	)
	return percentile(boot, 0.025), percentile(boot, 0.975)


	def sign_flip_p(values: list[float], *, seed: int) -> tuple[float, str]:
	observed = abs(statistics.fmean(values))
	tolerance = 1e-15
	if len(values) <= 20:
	null = (
	abs(statistics.fmean(sign * value for sign, value in zip(signs, values)))
	for signs in itertools.product((-1.0, 1.0), repeat=len(values))
	)
	denominator = 2 ** len(values)
	extreme = sum(value >= observed - tolerance for value in null)
	return extreme / denominator, "exact"

	rng = random.Random(seed)
	repetitions = 100_000
	extreme = 0
	for _ in range(repetitions):
	candidate = abs(
	statistics.fmean(
	value if rng.random() < 0.5 else -value for value in values
	)
	)
	extreme += candidate >= observed - tolerance
	return (extreme + 1) / (repetitions + 1), "monte_carlo_100000"


	def write_csv(path: Path, rows: list[dict]) -> None:
	if not rows:
	return
	with path.open("w", newline="", encoding="utf-8") as handle:
	writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
	writer.writeheader()
	writer.writerows(rows)


	def read_cases(args: argparse.Namespace) -> list[dict]:
	cases = []
	for path in sorted(args.results_dir.glob("*.json")):
	if path.name.endswith(".pretrain.json"):
	continue
	data = json.loads(path.read_text(encoding="utf-8"))
	if "test" not in data or data.get("setting") not in {
	"from_scratch",
	"fine_tune",
	}:
	continue
	target = data["stock"]
	seed = int(data["seed"])
	if data["method"] not in args.methods:
	continue
	if args.targets and target not in args.targets:
	continue
	if target in args.exclude_targets:
	continue
	if args.seeds and seed not in args.seeds:
	continue
	if abs(float(data["label_budget"]) - args.label_budget) > 1e-9:
	continue
	cases.append(
	{
	"target": target,
	"method": data["method"],
	"seed": seed,
	"setting": data["setting"],
	"macro_f1": float(data["test"]["macro_f1"]),
	"balanced_accuracy": float(data["test"]["balanced_accuracy"]),
	"accuracy": float(data["test"]["accuracy"]),
	"source_file": path.name,
	}
	)
	return cases


	def main() -> None:
	args = parse_args()
	cases = read_cases(args)
	lookup = {
	(row["target"], row["method"], row["seed"], row["setting"]): row
	for row in cases
	}
	target_values = (
	sorted(set(args.targets) - set(args.exclude_targets))
	if args.targets
	else sorted({row["target"] for row in cases})
	)
	seed_values = (
	sorted(set(args.seeds))
	if args.seeds
	else sorted({row["seed"] for row in cases})
	)
	expected = {
	(target, method, seed, setting)
	for target in target_values
	for method in args.methods
	for seed in seed_values
	for setting in ("from_scratch", "fine_tune")
	}
	missing = sorted(expected - set(lookup))
	if missing and not args.allow_incomplete:
	raise ValueError(f"Missing {len(missing)} matched cases; first: {missing[:5]}")

	paired_rows = []
	for target in target_values:
	for method in args.methods:
	for seed in seed_values:
	scratch = lookup.get((target, method, seed, "from_scratch"))
	pretrained = lookup.get((target, method, seed, "fine_tune"))
	if not scratch or not pretrained:
	continue
	paired_rows.append(
	{
	"target": target,
	"method": method,
	"seed": seed,
	"scratch_macro_f1": scratch["macro_f1"],
	"pretrained_macro_f1": pretrained["macro_f1"],
	"paired_delta_macro_f1": pretrained["macro_f1"]
	- scratch["macro_f1"],
	"scratch_balanced_accuracy": scratch["balanced_accuracy"],
	"pretrained_balanced_accuracy": pretrained[
	"balanced_accuracy"
	],
	"paired_delta_balanced_accuracy": pretrained[
	"balanced_accuracy"
	]
	- scratch["balanced_accuracy"],
	}
	)

	grouped: dict[tuple[str, str], list[dict]] = defaultdict(list)
	for row in paired_rows:
	grouped[(row["method"], row["target"])].append(row)
	target_rows = []
	for (method, target), rows in sorted(grouped.items()):
	target_rows.append(
	{
	"method": method,
	"target": target,
	"n_seeds": len(rows),
	"scratch_macro_f1_mean": statistics.fmean(
	row["scratch_macro_f1"] for row in rows
	),
	"pretrained_macro_f1_mean": statistics.fmean(
	row["pretrained_macro_f1"] for row in rows
	),
	"paired_delta_macro_f1_mean": statistics.fmean(
	row["paired_delta_macro_f1"] for row in rows
	),
	"paired_delta_macro_f1_seed_sd": statistics.stdev(
	row["paired_delta_macro_f1"] for row in rows
	)
	if len(rows) > 1
	else 0.0,
	}
	)

	summary_rows = []
	for method_index, method in enumerate(args.methods):
	per_target = [row for row in target_rows if row["method"] == method]
	if not per_target:
	continue
	if len(per_target) == 1 and per_target[0]["n_seeds"] > 1:
	uncertainty_unit = "seed"
	inferential_values = [
	row["paired_delta_macro_f1"]
	for row in paired_rows
	if row["method"] == method
	]
	else:
	uncertainty_unit = "target"
	inferential_values = [
	row["paired_delta_macro_f1_mean"] for row in per_target
	]
	ci_low, ci_high = bootstrap_mean_ci(
	inferential_values,
	seed=20260731 + method_index,
	)
	randomization_p, p_kind = sign_flip_p(
	inferential_values,
	seed=20260831 + method_index,
	)
	summary_rows.append(
	{
	"name": args.name,
	"method": method,
	"n_targets": len(per_target),
	"seeds_per_target_min": min(row["n_seeds"] for row in per_target),
	"seeds_per_target_max": max(row["n_seeds"] for row in per_target),
	"uncertainty_unit": uncertainty_unit,
	"mean_paired_delta_macro_f1": statistics.fmean(inferential_values),
	"median_paired_delta_macro_f1": statistics.median(
	inferential_values
	),
	"q1_paired_delta_macro_f1": percentile(inferential_values, 0.25),
	"q3_paired_delta_macro_f1": percentile(inferential_values, 0.75),
	"bootstrap_ci95_low": ci_low,
	"bootstrap_ci95_high": ci_high,
	"wins": sum(value > 0 for value in inferential_values),
	"ties": sum(value == 0 for value in inferential_values),
	"losses": sum(value < 0 for value in inferential_values),
	"sign_flip_p": randomization_p,
	"sign_flip_kind": p_kind,
	}
	)

	args.out_dir.mkdir(parents=True, exist_ok=True)
	write_csv(args.out_dir / "paired_seed_cases.csv", paired_rows)
	write_csv(args.out_dir / "paired_target_summary.csv", target_rows)
	write_csv(args.out_dir / "paired_aggregate_summary.csv", summary_rows)
	lines = [
	f"# {args.name}",
	"",
	f"Completeness: {len(set(lookup))}/{len(expected)} expected arm files.",
	"",
	"Seeds are paired within target. When multiple targets are available, seeds "
	"are averaged inside target before cross-target summaries; therefore target–seed "
	"runs are not treated as independent markets.",
	"",
	"\| method \| targets \| uncertainty unit \| mean delta (95% bootstrap CI) \| median \| IQR \| wins \| sign-flip p \|",
	"\|---\|---:\|---\|---:\|---:\|---:\|---:\|---:\|",
	]
	for row in summary_rows:
	denominator = (
	row["n_targets"]
	if row["uncertainty_unit"] == "target"
	else row["seeds_per_target_max"]
	)
	lines.append(
	f"\| {row['method']} \| {row['n_targets']} \| {row['uncertainty_unit']} \| "
	f"{row['mean_paired_delta_macro_f1']:+.4f} "
	f"[{row['bootstrap_ci95_low']:+.4f}, {row['bootstrap_ci95_high']:+.4f}] \| "
	f"{row['median_paired_delta_macro_f1']:+.4f} \| "
	f"[{row['q1_paired_delta_macro_f1']:+.4f}, "
	f"{row['q3_paired_delta_macro_f1']:+.4f}] \| "
	f"{row['wins']}/{denominator} \| {row['sign_flip_p']:.4f} "
	f"({row['sign_flip_kind']}) \|"
	)
	if missing:
	lines.extend(["", "## Missing cases", "", *[f"- `{row}`" for row in missing]])
	(args.out_dir / "summary.md").write_text("\n".join(lines) + "\n", encoding="utf-8")
	print(
	f"wrote {args.name} to {args.out_dir}; "
	f"completeness {len(set(lookup))}/{len(expected)}"
	)


	if __name__ == "__main__":
	main()