Datasets:

mythezone
/

LOBench-A-share-processed

#!/usr/bin/env python3
"""Summarize the five-stock, three-seed hyperparameter sensitivity grid."""

from __future__ import annotations

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


METHODS = ("timae", "lobgrid_timae", "simlob2026")
STOCKS = ("asset_001", "asset_002", "asset_017", "asset_005", "asset_033")
SEEDS = (2026, 2027, 2028)
AXES = {
    "latent_dim": ((64, "latent64"), (128, "baseline"), (256, "latent256")),
    "hidden_width": ((64, "width64"), (96, "baseline"), (128, "width128")),
    "attention_heads": ((2, "heads2"), (4, "baseline"), (8, "heads8")),
    "mask_ratio": ((0.2, "mask20"), (0.4, "baseline"), (0.6, "mask60")),
    "learning_rate": ((0.0001, "lr100"), (0.0003, "baseline"), (0.001, "lr1000")),
    "batch_size": ((64, "batch64"), (128, "baseline"), (256, "batch256")),
    "weight_decay": ((0.0, "wd0"), (0.00001, "baseline"), (0.0001, "wd1e4")),
}


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--results-root", 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 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 load_variant(directory: Path) -> dict[tuple[str, str, int, str], dict]:
    cases: dict[tuple[str, str, int, str], dict] = {}
    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("method") not in METHODS
            or payload.get("stock") not in STOCKS
            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["method"]),
            str(payload["stock"]),
            int(payload["seed"]),
            str(payload["setting"]),
        )
        if key in cases:
            raise ValueError(f"Duplicate sensitivity case in {directory}: {key}")
        cases[key] = payload
    expected = {
        (method, stock, seed, setting)
        for method in METHODS
        for stock in STOCKS
        for seed in SEEDS
        for setting in ("from_scratch", "fine_tune")
    }
    if set(cases) != expected:
        missing = sorted(expected - set(cases))
        extra = sorted(set(cases) - expected)
        raise ValueError(
            f"{directory} is incomplete: missing={missing[:5]}, extra={extra[:5]}"
        )
    return cases


def main() -> None:
    args = parse_args()
    variants = {
        variant
        for values in AXES.values()
        for _, variant in values
    }
    cases = {
        variant: load_variant(args.results_root / variant)
        for variant in sorted(variants)
    }

    stock_rows: list[dict[str, object]] = []
    summary_rows: list[dict[str, object]] = []
    for axis_index, (axis, values) in enumerate(AXES.items()):
        for value_index, (value, variant) in enumerate(values):
            for method_index, method in enumerate(METHODS):
                stock_deltas = []
                stock_scratch = []
                stock_pooled = []
                for stock in STOCKS:
                    scratch = [
                        float(cases[variant][(method, stock, seed, "from_scratch")]["test"]["macro_f1"])
                        for seed in SEEDS
                    ]
                    pooled = [
                        float(cases[variant][(method, stock, seed, "fine_tune")]["test"]["macro_f1"])
                        for seed in SEEDS
                    ]
                    scratch_mean = statistics.fmean(scratch)
                    pooled_mean = statistics.fmean(pooled)
                    delta_mean = statistics.fmean(
                        candidate - baseline
                        for candidate, baseline in zip(pooled, scratch)
                    )
                    stock_scratch.append(scratch_mean)
                    stock_pooled.append(pooled_mean)
                    stock_deltas.append(delta_mean)
                    stock_rows.append(
                        {
                            "axis": axis,
                            "value": value,
                            "variant": variant,
                            "method": method,
                            "stock": stock,
                            "n_seeds": len(SEEDS),
                            "scratch_macro_f1_mean": scratch_mean,
                            "pooled_macro_f1_mean": pooled_mean,
                            "paired_delta_mean": delta_mean,
                            "paired_delta_seed_sd": statistics.stdev(
                                candidate - baseline
                                for candidate, baseline in zip(pooled, scratch)
                            ),
                        }
                    )
                ci_low, ci_high = bootstrap_ci(
                    stock_deltas,
                    20260801 + 100 * axis_index + 10 * value_index + method_index,
                )
                summary_rows.append(
                    {
                        "axis": axis,
                        "value": value,
                        "variant": variant,
                        "method": method,
                        "n_stocks": len(STOCKS),
                        "seeds_per_stock": len(SEEDS),
                        "scratch_macro_f1_mean": statistics.fmean(stock_scratch),
                        "pooled_macro_f1_mean": statistics.fmean(stock_pooled),
                        "paired_delta_mean": statistics.fmean(stock_deltas),
                        "paired_delta_median": statistics.median(stock_deltas),
                        "ci95_low": ci_low,
                        "ci95_high": ci_high,
                        "wins": sum(value_ > 0 for value_ in stock_deltas),
                    }
                )

    range_rows: list[dict[str, object]] = []
    for axis in AXES:
        for method in METHODS:
            cells = [
                row
                for row in summary_rows
                if row["axis"] == axis and row["method"] == method
            ]
            if len(cells) != 3:
                raise ValueError(f"Expected three values for {axis}/{method}")
            best = max(cells, key=lambda row: float(row["paired_delta_mean"]))
            worst = min(cells, key=lambda row: float(row["paired_delta_mean"]))
            retained = next(row for row in cells if row["variant"] == "baseline")
            range_rows.append(
                {
                    "axis": axis,
                    "method": method,
                    "retained_value": retained["value"],
                    "retained_delta": retained["paired_delta_mean"],
                    "minimum_delta": worst["paired_delta_mean"],
                    "minimum_value": worst["value"],
                    "maximum_delta": best["paired_delta_mean"],
                    "maximum_value": best["value"],
                    "delta_span": float(best["paired_delta_mean"])
                    - float(worst["paired_delta_mean"]),
                    "positive_values": sum(
                        float(row["paired_delta_mean"]) > 0 for row in cells
                    ),
                }
            )

    overall_rows: list[dict[str, object]] = []
    for method in METHODS:
        unique_by_variant: dict[str, dict[str, object]] = {}
        for row in summary_rows:
            if row["method"] != method:
                continue
            variant = str(row["variant"])
            previous = unique_by_variant.get(variant)
            if previous is not None and abs(
                float(previous["paired_delta_mean"])
                - float(row["paired_delta_mean"])
            ) > 1e-12:
                raise ValueError(f"Inconsistent repeated baseline for {method}")
            unique_by_variant[variant] = row
        if len(unique_by_variant) != 15:
            raise ValueError(
                f"Expected 15 unique configurations for {method}; "
                f"found {len(unique_by_variant)}"
            )
        cells = list(unique_by_variant.values())
        best = max(cells, key=lambda row: float(row["paired_delta_mean"]))
        worst = min(cells, key=lambda row: float(row["paired_delta_mean"]))
        deltas = [float(row["paired_delta_mean"]) for row in cells]
        retained = unique_by_variant["baseline"]
        overall_rows.append(
            {
                "method": method,
                "n_unique_configurations": len(cells),
                "retained_delta": retained["paired_delta_mean"],
                "minimum_delta": worst["paired_delta_mean"],
                "minimum_variant": worst["variant"],
                "maximum_delta": best["paired_delta_mean"],
                "maximum_variant": best["variant"],
                "median_delta": statistics.median(deltas),
                "positive_configurations": sum(value > 0 for value in deltas),
                "within_practical_range": sum(abs(value) <= 0.01 for value in deltas),
            }
        )

    args.output_dir.mkdir(parents=True, exist_ok=True)
    write_csv(args.output_dir / "hyperparameter_stock_summary.csv", stock_rows)
    write_csv(args.output_dir / "hyperparameter_sensitivity.csv", summary_rows)
    write_csv(args.output_dir / "hyperparameter_axis_ranges.csv", range_rows)
    write_csv(args.output_dir / "hyperparameter_overall_ranges.csv", overall_rows)
    payload = {
        "design": {
            "stocks": list(STOCKS),
            "methods": list(METHODS),
            "seeds": list(SEEDS),
            "label_budget": 0.5,
            "axes": {
                axis: [value for value, _ in values]
                for axis, values in AXES.items()
            },
            "aggregation": "seeds paired and averaged within stock; five stock means form the reporting units",
            "retained_configuration": {
                "latent_dim": 128,
                "hidden_width": 96,
                "attention_heads": 4,
                "mask_ratio": 0.4,
                "learning_rate": 0.0003,
                "batch_size": 128,
                "weight_decay": 0.00001,
            },
        },
        "rows": summary_rows,
        "axis_ranges": range_rows,
        "overall_ranges": overall_rows,
    }
    (args.output_dir / "hyperparameter_sensitivity.json").write_text(
        json.dumps(payload, indent=2) + "\n",
        encoding="utf-8",
    )

    lines = [
        "# Hyperparameter sensitivity",
        "",
        "Each row changes one setting from the retained configuration. Seeds are paired within stock before the five-stock summary.",
        "",
        "| axis | value | method | scratch F1 | pooled F1 | paired delta [95% stock interval] | wins/5 |",
        "|---|---:|---|---:|---:|---:|---:|",
    ]
    for row in summary_rows:
        lines.append(
            f"| {row['axis']} | {row['value']} | {row['method']} | "
            f"{row['scratch_macro_f1_mean']:.4f} | "
            f"{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 |"
        )
    lines.extend(
        [
            "",
            "## Across-value ranges",
            "",
            "| axis | method | retained delta | minimum | maximum | span | positive values |",
            "|---|---|---:|---:|---:|---:|---:|",
        ]
    )
    for row in range_rows:
        lines.append(
            f"| {row['axis']} | {row['method']} | "
            f"{row['retained_delta']:+.4f} | "
            f"{row['minimum_delta']:+.4f} ({row['minimum_value']}) | "
            f"{row['maximum_delta']:+.4f} ({row['maximum_value']}) | "
            f"{row['delta_span']:.4f} | {row['positive_values']}/3 |"
        )
    lines.extend(
        [
            "",
            "## Across the 15 unique configurations",
            "",
            "| method | retained | minimum | maximum | median | positive | within ±0.01 |",
            "|---|---:|---:|---:|---:|---:|---:|",
        ]
    )
    for row in overall_rows:
        lines.append(
            f"| {row['method']} | {row['retained_delta']:+.4f} | "
            f"{row['minimum_delta']:+.4f} ({row['minimum_variant']}) | "
            f"{row['maximum_delta']:+.4f} ({row['maximum_variant']}) | "
            f"{row['median_delta']:+.4f} | "
            f"{row['positive_configurations']}/15 | "
            f"{row['within_practical_range']}/15 |"
        )
    (args.output_dir / "hyperparameter_sensitivity.md").write_text(
        "\n".join(lines) + "\n",
        encoding="utf-8",
    )
    print(
        f"wrote {len(summary_rows)} hyperparameter summaries from "
        f"{len(stock_rows)} stock-level cells"
    )


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""Summarize the five-stock, three-seed hyperparameter sensitivity grid."""

	from __future__ import annotations

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


	METHODS = ("timae", "lobgrid_timae", "simlob2026")
	STOCKS = ("asset_001", "asset_002", "asset_017", "asset_005", "asset_033")
	SEEDS = (2026, 2027, 2028)
	AXES = {
	"latent_dim": ((64, "latent64"), (128, "baseline"), (256, "latent256")),
	"hidden_width": ((64, "width64"), (96, "baseline"), (128, "width128")),
	"attention_heads": ((2, "heads2"), (4, "baseline"), (8, "heads8")),
	"mask_ratio": ((0.2, "mask20"), (0.4, "baseline"), (0.6, "mask60")),
	"learning_rate": ((0.0001, "lr100"), (0.0003, "baseline"), (0.001, "lr1000")),
	"batch_size": ((64, "batch64"), (128, "baseline"), (256, "batch256")),
	"weight_decay": ((0.0, "wd0"), (0.00001, "baseline"), (0.0001, "wd1e4")),
	}


	def parse_args() -> argparse.Namespace:
	parser = argparse.ArgumentParser(description=__doc__)
	parser.add_argument("--results-root", 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 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 load_variant(directory: Path) -> dict[tuple[str, str, int, str], dict]:
	cases: dict[tuple[str, str, int, str], dict] = {}
	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("method") not in METHODS
	or payload.get("stock") not in STOCKS
	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["method"]),
	str(payload["stock"]),
	int(payload["seed"]),
	str(payload["setting"]),
	)
	if key in cases:
	raise ValueError(f"Duplicate sensitivity case in {directory}: {key}")
	cases[key] = payload
	expected = {
	(method, stock, seed, setting)
	for method in METHODS
	for stock in STOCKS
	for seed in SEEDS
	for setting in ("from_scratch", "fine_tune")
	}
	if set(cases) != expected:
	missing = sorted(expected - set(cases))
	extra = sorted(set(cases) - expected)
	raise ValueError(
	f"{directory} is incomplete: missing={missing[:5]}, extra={extra[:5]}"
	)
	return cases


	def main() -> None:
	args = parse_args()
	variants = {
	variant
	for values in AXES.values()
	for _, variant in values
	}
	cases = {
	variant: load_variant(args.results_root / variant)
	for variant in sorted(variants)
	}

	stock_rows: list[dict[str, object]] = []
	summary_rows: list[dict[str, object]] = []
	for axis_index, (axis, values) in enumerate(AXES.items()):
	for value_index, (value, variant) in enumerate(values):
	for method_index, method in enumerate(METHODS):
	stock_deltas = []
	stock_scratch = []
	stock_pooled = []
	for stock in STOCKS:
	scratch = [
	float(cases[variant][(method, stock, seed, "from_scratch")]["test"]["macro_f1"])
	for seed in SEEDS
	]
	pooled = [
	float(cases[variant][(method, stock, seed, "fine_tune")]["test"]["macro_f1"])
	for seed in SEEDS
	]
	scratch_mean = statistics.fmean(scratch)
	pooled_mean = statistics.fmean(pooled)
	delta_mean = statistics.fmean(
	candidate - baseline
	for candidate, baseline in zip(pooled, scratch)
	)
	stock_scratch.append(scratch_mean)
	stock_pooled.append(pooled_mean)
	stock_deltas.append(delta_mean)
	stock_rows.append(
	{
	"axis": axis,
	"value": value,
	"variant": variant,
	"method": method,
	"stock": stock,
	"n_seeds": len(SEEDS),
	"scratch_macro_f1_mean": scratch_mean,
	"pooled_macro_f1_mean": pooled_mean,
	"paired_delta_mean": delta_mean,
	"paired_delta_seed_sd": statistics.stdev(
	candidate - baseline
	for candidate, baseline in zip(pooled, scratch)
	),
	}
	)
	ci_low, ci_high = bootstrap_ci(
	stock_deltas,
	20260801 + 100 * axis_index + 10 * value_index + method_index,
	)
	summary_rows.append(
	{
	"axis": axis,
	"value": value,
	"variant": variant,
	"method": method,
	"n_stocks": len(STOCKS),
	"seeds_per_stock": len(SEEDS),
	"scratch_macro_f1_mean": statistics.fmean(stock_scratch),
	"pooled_macro_f1_mean": statistics.fmean(stock_pooled),
	"paired_delta_mean": statistics.fmean(stock_deltas),
	"paired_delta_median": statistics.median(stock_deltas),
	"ci95_low": ci_low,
	"ci95_high": ci_high,
	"wins": sum(value_ > 0 for value_ in stock_deltas),
	}
	)

	range_rows: list[dict[str, object]] = []
	for axis in AXES:
	for method in METHODS:
	cells = [
	row
	for row in summary_rows
	if row["axis"] == axis and row["method"] == method
	]
	if len(cells) != 3:
	raise ValueError(f"Expected three values for {axis}/{method}")
	best = max(cells, key=lambda row: float(row["paired_delta_mean"]))
	worst = min(cells, key=lambda row: float(row["paired_delta_mean"]))
	retained = next(row for row in cells if row["variant"] == "baseline")
	range_rows.append(
	{
	"axis": axis,
	"method": method,
	"retained_value": retained["value"],
	"retained_delta": retained["paired_delta_mean"],
	"minimum_delta": worst["paired_delta_mean"],
	"minimum_value": worst["value"],
	"maximum_delta": best["paired_delta_mean"],
	"maximum_value": best["value"],
	"delta_span": float(best["paired_delta_mean"])
	- float(worst["paired_delta_mean"]),
	"positive_values": sum(
	float(row["paired_delta_mean"]) > 0 for row in cells
	),
	}
	)

	overall_rows: list[dict[str, object]] = []
	for method in METHODS:
	unique_by_variant: dict[str, dict[str, object]] = {}
	for row in summary_rows:
	if row["method"] != method:
	continue
	variant = str(row["variant"])
	previous = unique_by_variant.get(variant)
	if previous is not None and abs(
	float(previous["paired_delta_mean"])
	- float(row["paired_delta_mean"])
	) > 1e-12:
	raise ValueError(f"Inconsistent repeated baseline for {method}")
	unique_by_variant[variant] = row
	if len(unique_by_variant) != 15:
	raise ValueError(
	f"Expected 15 unique configurations for {method}; "
	f"found {len(unique_by_variant)}"
	)
	cells = list(unique_by_variant.values())
	best = max(cells, key=lambda row: float(row["paired_delta_mean"]))
	worst = min(cells, key=lambda row: float(row["paired_delta_mean"]))
	deltas = [float(row["paired_delta_mean"]) for row in cells]
	retained = unique_by_variant["baseline"]
	overall_rows.append(
	{
	"method": method,
	"n_unique_configurations": len(cells),
	"retained_delta": retained["paired_delta_mean"],
	"minimum_delta": worst["paired_delta_mean"],
	"minimum_variant": worst["variant"],
	"maximum_delta": best["paired_delta_mean"],
	"maximum_variant": best["variant"],
	"median_delta": statistics.median(deltas),
	"positive_configurations": sum(value > 0 for value in deltas),
	"within_practical_range": sum(abs(value) <= 0.01 for value in deltas),
	}
	)

	args.output_dir.mkdir(parents=True, exist_ok=True)
	write_csv(args.output_dir / "hyperparameter_stock_summary.csv", stock_rows)
	write_csv(args.output_dir / "hyperparameter_sensitivity.csv", summary_rows)
	write_csv(args.output_dir / "hyperparameter_axis_ranges.csv", range_rows)
	write_csv(args.output_dir / "hyperparameter_overall_ranges.csv", overall_rows)
	payload = {
	"design": {
	"stocks": list(STOCKS),
	"methods": list(METHODS),
	"seeds": list(SEEDS),
	"label_budget": 0.5,
	"axes": {
	axis: [value for value, _ in values]
	for axis, values in AXES.items()
	},
	"aggregation": "seeds paired and averaged within stock; five stock means form the reporting units",
	"retained_configuration": {
	"latent_dim": 128,
	"hidden_width": 96,
	"attention_heads": 4,
	"mask_ratio": 0.4,
	"learning_rate": 0.0003,
	"batch_size": 128,
	"weight_decay": 0.00001,
	},
	},
	"rows": summary_rows,
	"axis_ranges": range_rows,
	"overall_ranges": overall_rows,
	}
	(args.output_dir / "hyperparameter_sensitivity.json").write_text(
	json.dumps(payload, indent=2) + "\n",
	encoding="utf-8",
	)

	lines = [
	"# Hyperparameter sensitivity",
	"",
	"Each row changes one setting from the retained configuration. Seeds are paired within stock before the five-stock summary.",
	"",
	"\| axis \| value \| method \| scratch F1 \| pooled F1 \| paired delta [95% stock interval] \| wins/5 \|",
	"\|---\|---:\|---\|---:\|---:\|---:\|---:\|",
	]
	for row in summary_rows:
	lines.append(
	f"\| {row['axis']} \| {row['value']} \| {row['method']} \| "
	f"{row['scratch_macro_f1_mean']:.4f} \| "
	f"{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 \|"
	)
	lines.extend(
	[
	"",
	"## Across-value ranges",
	"",
	"\| axis \| method \| retained delta \| minimum \| maximum \| span \| positive values \|",
	"\|---\|---\|---:\|---:\|---:\|---:\|---:\|",
	]
	)
	for row in range_rows:
	lines.append(
	f"\| {row['axis']} \| {row['method']} \| "
	f"{row['retained_delta']:+.4f} \| "
	f"{row['minimum_delta']:+.4f} ({row['minimum_value']}) \| "
	f"{row['maximum_delta']:+.4f} ({row['maximum_value']}) \| "
	f"{row['delta_span']:.4f} \| {row['positive_values']}/3 \|"
	)
	lines.extend(
	[
	"",
	"## Across the 15 unique configurations",
	"",
	"\| method \| retained \| minimum \| maximum \| median \| positive \| within ±0.01 \|",
	"\|---\|---:\|---:\|---:\|---:\|---:\|---:\|",
	]
	)
	for row in overall_rows:
	lines.append(
	f"\| {row['method']} \| {row['retained_delta']:+.4f} \| "
	f"{row['minimum_delta']:+.4f} ({row['minimum_variant']}) \| "
	f"{row['maximum_delta']:+.4f} ({row['maximum_variant']}) \| "
	f"{row['median_delta']:+.4f} \| "
	f"{row['positive_configurations']}/15 \| "
	f"{row['within_practical_range']}/15 \|"
	)
	(args.output_dir / "hyperparameter_sensitivity.md").write_text(
	"\n".join(lines) + "\n",
	encoding="utf-8",
	)
	print(
	f"wrote {len(summary_rows)} hyperparameter summaries from "
	f"{len(stock_rows)} stock-level cells"
	)


	if __name__ == "__main__":
	main()