Datasets:

mythezone
/

LOBench-A-share-processed

#!/usr/bin/env python3
"""Profile the three frozen controlled implementations used in the final revision."""

from __future__ import annotations

import argparse
import csv
import json
import platform
import statistics
import sys
import time
from pathlib import Path

import torch


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

from models import Classifier  # noqa: E402
from train_representation_baselines import build_method  # noqa: E402


METHODS = {
    "Ti-MAE-style": "timae",
    "LOBGrid--Ti-MAE-style": "lobgrid_timae",
    "SimLOB-style": "simlob2026",
}

CORE_STOCKS = (
    "asset_001",
    "asset_002",
    "asset_017",
    "asset_005",
    "asset_033",
)
CORE_SEEDS = (2026, 2027, 2028)


def parameter_count(module: torch.nn.Module) -> int:
    return sum(parameter.numel() for parameter in module.parameters())


def synchronized_forward_seconds(
    model: torch.nn.Module,
    sample: torch.Tensor,
    *,
    warmup: int,
    repeats: int,
) -> list[float]:
    device = sample.device
    model.eval()
    with torch.inference_mode():
        for _ in range(warmup):
            model(sample)
        if device.type == "cuda":
            torch.cuda.synchronize(device)
        observations: list[float] = []
        for _ in range(repeats):
            started = time.perf_counter()
            model(sample)
            if device.type == "cuda":
                torch.cuda.synchronize(device)
            observations.append(time.perf_counter() - started)
    return observations


def peak_forward_gib(model: torch.nn.Module, sample: torch.Tensor) -> float | None:
    if sample.device.type != "cuda":
        return None
    torch.cuda.empty_cache()
    torch.cuda.reset_peak_memory_stats(sample.device)
    with torch.inference_mode():
        model(sample)
        torch.cuda.synchronize(sample.device)
    return torch.cuda.max_memory_allocated(sample.device) / (1024**3)


def result_costs(
    results_dir: Path,
    method: str,
    *,
    stocks: set[str],
    seeds: set[int],
) -> dict[str, float | int]:
    pretrain_paths = []
    for path in sorted(results_dir.glob(f"*_{method}_seed*_encoder.pretrain.json")):
        payload = json.loads(path.read_text(encoding="utf-8"))
        if payload.get("method") != method:
            continue
        if any(f"_seed{seed}_encoder.pretrain.json" in path.name for seed in seeds):
            pretrain_paths.append(path)
    if not pretrain_paths:
        raise FileNotFoundError(f"No pooled pretraining metadata for {method}.")
    pretrain_seconds = [
        float(json.loads(path.read_text(encoding="utf-8"))["seconds"])
        for path in pretrain_paths
    ]

    # Do not filter by a filename fragment such as ``*_timae_*``: that
    # fragment also matches ``lobgrid_timae``.  The serialized method key is
    # authoritative, and every stock/seed pair must occur exactly once.
    adapt_cases: dict[tuple[str, int], tuple[Path, dict[str, object]]] = {}
    for path in sorted(results_dir.glob("*_fine_tune_seed*_budget050.json")):
        payload = json.loads(path.read_text(encoding="utf-8"))
        if (
            payload.get("method") != method
            or payload.get("setting") != "fine_tune"
            or str(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-9
        ):
            continue
        key = (str(payload["stock"]), int(payload["seed"]))
        if key in adapt_cases:
            raise ValueError(
                f"Duplicate 50%-budget adaptation case for {method}/{key}: "
                f"{adapt_cases[key][0]} and {path}"
            )
        adapt_cases[key] = (path, payload)
    expected_adapt_cases = {
        (stock, seed) for stock in stocks for seed in seeds
    }
    if set(adapt_cases) != expected_adapt_cases:
        missing = sorted(expected_adapt_cases - set(adapt_cases))
        extra = sorted(set(adapt_cases) - expected_adapt_cases)
        raise ValueError(
            f"Incomplete 50%-budget adaptations for {method}: "
            f"missing={missing}, extra={extra}"
        )
    adapt_seconds = [
        float(adapt_cases[key][1]["downstream_seconds"])
        for key in sorted(adapt_cases)
    ]
    return {
        "pretrain_runs": len(pretrain_seconds),
        "pretrain_minutes_mean": statistics.fmean(pretrain_seconds) / 60.0,
        "pretrain_minutes_sd": statistics.stdev(pretrain_seconds)
        / 60.0
        if len(pretrain_seconds) > 1
        else 0.0,
        "adapt_runs": len(adapt_seconds),
        "adapt_seconds_mean": statistics.fmean(adapt_seconds),
        "adapt_seconds_sd": statistics.stdev(adapt_seconds)
        if len(adapt_seconds) > 1
        else 0.0,
    }


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 parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--results-dir",
        type=Path,
        default=ROOT
        / "experiments/tbd_revision/outputs/results_final_revision_ashare5_pooled_3seed",
    )
    parser.add_argument(
        "--out-dir",
        type=Path,
        default=ROOT
        / "experiments/tbd_revision/outputs/summary_final_revision_complexity",
    )
    parser.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
    parser.add_argument("--warmup", type=int, default=30)
    parser.add_argument("--repeats", type=int, default=100)
    parser.add_argument("--throughput-batch-size", type=int, default=128)
    parser.add_argument(
        "--training-hardware",
        default="single NVIDIA RTX 5880 Ada",
    )
    parser.add_argument("--stocks", nargs="+", default=list(CORE_STOCKS))
    parser.add_argument("--seeds", nargs="+", type=int, default=list(CORE_SEEDS))
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    device = torch.device(args.device)
    if device.type == "cuda":
        hardware = (
            f"{torch.cuda.get_device_name(device)}; PyTorch {torch.__version__}; "
            f"CUDA {torch.version.cuda}"
        )
    else:
        hardware = f"CPU; PyTorch {torch.__version__}"

    rows: list[dict[str, object]] = []
    for display_name, method in METHODS.items():
        encoder = build_method(method, latent_dim=128, d_model=96)
        model = Classifier(encoder, latent_dim=128, num_classes=3).to(device)
        sample_b1 = torch.randn(1, 100, 40, device=device)
        sample_bn = torch.randn(args.throughput_batch_size, 100, 40, device=device)
        latency = synchronized_forward_seconds(
            model,
            sample_b1,
            warmup=args.warmup,
            repeats=args.repeats,
        )
        throughput_times = synchronized_forward_seconds(
            model,
            sample_bn,
            warmup=args.warmup,
            repeats=args.repeats,
        )
        costs = result_costs(
            args.results_dir,
            method,
            stocks=set(args.stocks),
            seeds=set(args.seeds),
        )
        rows.append(
            {
                "implementation": display_name,
                "method_key": method,
                "trainable_parameters": parameter_count(model),
                "peak_forward_gib_b128": peak_forward_gib(model, sample_bn),
                "batch1_latency_ms_mean": statistics.fmean(latency) * 1000.0,
                "batch1_latency_ms_sd": statistics.stdev(latency) * 1000.0
                if len(latency) > 1
                else 0.0,
                "throughput_batch_size": args.throughput_batch_size,
                "samples_per_second": args.throughput_batch_size
                / statistics.fmean(throughput_times),
                **costs,
            }
        )

    args.out_dir.mkdir(parents=True, exist_ok=True)
    write_csv(args.out_dir / "complexity_profile.csv", rows)
    (args.out_dir / "complexity_profile.json").write_text(
        json.dumps(
            {
                "hardware": hardware,
                "software": {
                    "python": sys.version,
                    "platform": platform.platform(),
                    "pytorch": torch.__version__,
                    "cuda_runtime": torch.version.cuda,
                    "cudnn": (
                        torch.backends.cudnn.version()
                        if torch.backends.cudnn.is_available()
                        else None
                    ),
                },
                "input_shape": "[batch, 100, 40]",
                "dtype": "float32",
                "float32_matmul_precision": torch.get_float32_matmul_precision(),
                "latency_scope": "classifier forward pass under torch.inference_mode",
                "measurement_protocol": {
                    "cuda_synchronized": device.type == "cuda",
                    "warmup_iterations": args.warmup,
                    "measured_repetitions": args.repeats,
                    "latency_batch_size": 1,
                    "throughput_batch_size": args.throughput_batch_size,
                    "peak_memory_batch_size": args.throughput_batch_size,
                    "peak_memory_metric": (
                        "process-local torch.cuda.max_memory_allocated"
                        if device.type == "cuda"
                        else None
                    ),
                },
                "cost_scope": {
                    "training_hardware": args.training_hardware,
                    "stocks": args.stocks,
                    "seeds": args.seeds,
                    "label_budget": 0.5,
                    "pooled_pretraining_aggregation": (
                        "mean and sample SD over three seed-specific pooled runs"
                    ),
                    "adaptation_aggregation": (
                        "mean and sample SD over five stocks x three seeds"
                    ),
                    "included_in_training_wall_time": (
                        "in-memory batch iteration, host-to-device transfer, "
                        "optimization, validation, checkpointing, and final evaluation"
                    ),
                    "excluded": (
                        "raw-data preparation, external market-data/network I/O, "
                        "exchange connectivity, and order execution"
                    ),
                },
                "rows": rows,
            },
            indent=2,
        ),
        encoding="utf-8",
    )
    lines = [
        "# Final-revision model-side cost profile",
        "",
        f"Forward-profile hardware: {hardware}",
        f"Training-time hardware: {args.training_hardware}",
        "",
        "All model-side measurements use FP32. Latency and throughput are synchronized "
        f"classifier-forward measurements after {args.warmup} warm-up iterations and "
        f"{args.repeats} measured repetitions. Peak memory is process-local allocated "
        f"memory for a batch of {args.throughput_batch_size}. "
        "Pooled pretraining is counted once per method and seed; adaptation is "
        "averaged over the five-stock x three-seed 50%-label cases. "
        "Pretraining time is summarized over three seed-specific pooled runs. "
        "Training wall time includes in-memory batch iteration, host-to-device "
        "transfer, optimization, validation, checkpointing, and final evaluation. "
        "Raw-data preparation and external market-data/network or execution-system "
        "I/O are excluded.",
        "",
        "| implementation | params | peak GiB | B1 ms | samples/s | pretrain min | adapt s |",
        "|---|---:|---:|---:|---:|---:|---:|",
    ]
    for row in rows:
        peak = row["peak_forward_gib_b128"]
        lines.append(
            f"| {row['implementation']} | {int(row['trainable_parameters']):,} | "
            f"{float(peak):.3f} | {float(row['batch1_latency_ms_mean']):.3f} | "
            f"{float(row['samples_per_second']):.1f} | "
            f"{float(row['pretrain_minutes_mean']):.2f} | "
            f"{float(row['adapt_seconds_mean']):.1f} |"
        )
    (args.out_dir / "complexity_profile.md").write_text(
        "\n".join(lines) + "\n",
        encoding="utf-8",
    )
    print(f"wrote final cost profile to {args.out_dir}")


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3
	"""Profile the three frozen controlled implementations used in the final revision."""

	from __future__ import annotations

	import argparse
	import csv
	import json
	import platform
	import statistics
	import sys
	import time
	from pathlib import Path

	import torch


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

	from models import Classifier # noqa: E402
	from train_representation_baselines import build_method # noqa: E402


	METHODS = {
	"Ti-MAE-style": "timae",
	"LOBGrid--Ti-MAE-style": "lobgrid_timae",
	"SimLOB-style": "simlob2026",
	}

	CORE_STOCKS = (
	"asset_001",
	"asset_002",
	"asset_017",
	"asset_005",
	"asset_033",
	)
	CORE_SEEDS = (2026, 2027, 2028)


	def parameter_count(module: torch.nn.Module) -> int:
	return sum(parameter.numel() for parameter in module.parameters())


	def synchronized_forward_seconds(
	model: torch.nn.Module,
	sample: torch.Tensor,
	*,
	warmup: int,
	repeats: int,
	) -> list[float]:
	device = sample.device
	model.eval()
	with torch.inference_mode():
	for _ in range(warmup):
	model(sample)
	if device.type == "cuda":
	torch.cuda.synchronize(device)
	observations: list[float] = []
	for _ in range(repeats):
	started = time.perf_counter()
	model(sample)
	if device.type == "cuda":
	torch.cuda.synchronize(device)
	observations.append(time.perf_counter() - started)
	return observations


	def peak_forward_gib(model: torch.nn.Module, sample: torch.Tensor) -> float \| None:
	if sample.device.type != "cuda":
	return None
	torch.cuda.empty_cache()
	torch.cuda.reset_peak_memory_stats(sample.device)
	with torch.inference_mode():
	model(sample)
	torch.cuda.synchronize(sample.device)
	return torch.cuda.max_memory_allocated(sample.device) / (1024**3)


	def result_costs(
	results_dir: Path,
	method: str,
	*,
	stocks: set[str],
	seeds: set[int],
	) -> dict[str, float \| int]:
	pretrain_paths = []
	for path in sorted(results_dir.glob(f"_{method}_seed_encoder.pretrain.json")):
	payload = json.loads(path.read_text(encoding="utf-8"))
	if payload.get("method") != method:
	continue
	if any(f"_seed{seed}_encoder.pretrain.json" in path.name for seed in seeds):
	pretrain_paths.append(path)
	if not pretrain_paths:
	raise FileNotFoundError(f"No pooled pretraining metadata for {method}.")
	pretrain_seconds = [
	float(json.loads(path.read_text(encoding="utf-8"))["seconds"])
	for path in pretrain_paths
	]

	# Do not filter by a filename fragment such as ``_timae_``: that
	# fragment also matches ``lobgrid_timae``. The serialized method key is
	# authoritative, and every stock/seed pair must occur exactly once.
	adapt_cases: dict[tuple[str, int], tuple[Path, dict[str, object]]] = {}
	for path in sorted(results_dir.glob("_fine_tune_seed_budget050.json")):
	payload = json.loads(path.read_text(encoding="utf-8"))
	if (
	payload.get("method") != method
	or payload.get("setting") != "fine_tune"
	or str(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-9
	):
	continue
	key = (str(payload["stock"]), int(payload["seed"]))
	if key in adapt_cases:
	raise ValueError(
	f"Duplicate 50%-budget adaptation case for {method}/{key}: "
	f"{adapt_cases[key][0]} and {path}"
	)
	adapt_cases[key] = (path, payload)
	expected_adapt_cases = {
	(stock, seed) for stock in stocks for seed in seeds
	}
	if set(adapt_cases) != expected_adapt_cases:
	missing = sorted(expected_adapt_cases - set(adapt_cases))
	extra = sorted(set(adapt_cases) - expected_adapt_cases)
	raise ValueError(
	f"Incomplete 50%-budget adaptations for {method}: "
	f"missing={missing}, extra={extra}"
	)
	adapt_seconds = [
	float(adapt_cases[key][1]["downstream_seconds"])
	for key in sorted(adapt_cases)
	]
	return {
	"pretrain_runs": len(pretrain_seconds),
	"pretrain_minutes_mean": statistics.fmean(pretrain_seconds) / 60.0,
	"pretrain_minutes_sd": statistics.stdev(pretrain_seconds)
	/ 60.0
	if len(pretrain_seconds) > 1
	else 0.0,
	"adapt_runs": len(adapt_seconds),
	"adapt_seconds_mean": statistics.fmean(adapt_seconds),
	"adapt_seconds_sd": statistics.stdev(adapt_seconds)
	if len(adapt_seconds) > 1
	else 0.0,
	}


	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 parse_args() -> argparse.Namespace:
	parser = argparse.ArgumentParser(description=__doc__)
	parser.add_argument(
	"--results-dir",
	type=Path,
	default=ROOT
	/ "experiments/tbd_revision/outputs/results_final_revision_ashare5_pooled_3seed",
	)
	parser.add_argument(
	"--out-dir",
	type=Path,
	default=ROOT
	/ "experiments/tbd_revision/outputs/summary_final_revision_complexity",
	)
	parser.add_argument("--device", default="cuda" if torch.cuda.is_available() else "cpu")
	parser.add_argument("--warmup", type=int, default=30)
	parser.add_argument("--repeats", type=int, default=100)
	parser.add_argument("--throughput-batch-size", type=int, default=128)
	parser.add_argument(
	"--training-hardware",
	default="single NVIDIA RTX 5880 Ada",
	)
	parser.add_argument("--stocks", nargs="+", default=list(CORE_STOCKS))
	parser.add_argument("--seeds", nargs="+", type=int, default=list(CORE_SEEDS))
	return parser.parse_args()


	def main() -> None:
	args = parse_args()
	device = torch.device(args.device)
	if device.type == "cuda":
	hardware = (
	f"{torch.cuda.get_device_name(device)}; PyTorch {torch.__version__}; "
	f"CUDA {torch.version.cuda}"
	)
	else:
	hardware = f"CPU; PyTorch {torch.__version__}"

	rows: list[dict[str, object]] = []
	for display_name, method in METHODS.items():
	encoder = build_method(method, latent_dim=128, d_model=96)
	model = Classifier(encoder, latent_dim=128, num_classes=3).to(device)
	sample_b1 = torch.randn(1, 100, 40, device=device)
	sample_bn = torch.randn(args.throughput_batch_size, 100, 40, device=device)
	latency = synchronized_forward_seconds(
	model,
	sample_b1,
	warmup=args.warmup,
	repeats=args.repeats,
	)
	throughput_times = synchronized_forward_seconds(
	model,
	sample_bn,
	warmup=args.warmup,
	repeats=args.repeats,
	)
	costs = result_costs(
	args.results_dir,
	method,
	stocks=set(args.stocks),
	seeds=set(args.seeds),
	)
	rows.append(
	{
	"implementation": display_name,
	"method_key": method,
	"trainable_parameters": parameter_count(model),
	"peak_forward_gib_b128": peak_forward_gib(model, sample_bn),
	"batch1_latency_ms_mean": statistics.fmean(latency) * 1000.0,
	"batch1_latency_ms_sd": statistics.stdev(latency) * 1000.0
	if len(latency) > 1
	else 0.0,
	"throughput_batch_size": args.throughput_batch_size,
	"samples_per_second": args.throughput_batch_size
	/ statistics.fmean(throughput_times),
	**costs,
	}
	)

	args.out_dir.mkdir(parents=True, exist_ok=True)
	write_csv(args.out_dir / "complexity_profile.csv", rows)
	(args.out_dir / "complexity_profile.json").write_text(
	json.dumps(
	{
	"hardware": hardware,
	"software": {
	"python": sys.version,
	"platform": platform.platform(),
	"pytorch": torch.__version__,
	"cuda_runtime": torch.version.cuda,
	"cudnn": (
	torch.backends.cudnn.version()
	if torch.backends.cudnn.is_available()
	else None
	),
	},
	"input_shape": "[batch, 100, 40]",
	"dtype": "float32",
	"float32_matmul_precision": torch.get_float32_matmul_precision(),
	"latency_scope": "classifier forward pass under torch.inference_mode",
	"measurement_protocol": {
	"cuda_synchronized": device.type == "cuda",
	"warmup_iterations": args.warmup,
	"measured_repetitions": args.repeats,
	"latency_batch_size": 1,
	"throughput_batch_size": args.throughput_batch_size,
	"peak_memory_batch_size": args.throughput_batch_size,
	"peak_memory_metric": (
	"process-local torch.cuda.max_memory_allocated"
	if device.type == "cuda"
	else None
	),
	},
	"cost_scope": {
	"training_hardware": args.training_hardware,
	"stocks": args.stocks,
	"seeds": args.seeds,
	"label_budget": 0.5,
	"pooled_pretraining_aggregation": (
	"mean and sample SD over three seed-specific pooled runs"
	),
	"adaptation_aggregation": (
	"mean and sample SD over five stocks x three seeds"
	),
	"included_in_training_wall_time": (
	"in-memory batch iteration, host-to-device transfer, "
	"optimization, validation, checkpointing, and final evaluation"
	),
	"excluded": (
	"raw-data preparation, external market-data/network I/O, "
	"exchange connectivity, and order execution"
	),
	},
	"rows": rows,
	},
	indent=2,
	),
	encoding="utf-8",
	)
	lines = [
	"# Final-revision model-side cost profile",
	"",
	f"Forward-profile hardware: {hardware}",
	f"Training-time hardware: {args.training_hardware}",
	"",
	"All model-side measurements use FP32. Latency and throughput are synchronized "
	f"classifier-forward measurements after {args.warmup} warm-up iterations and "
	f"{args.repeats} measured repetitions. Peak memory is process-local allocated "
	f"memory for a batch of {args.throughput_batch_size}. "
	"Pooled pretraining is counted once per method and seed; adaptation is "
	"averaged over the five-stock x three-seed 50%-label cases. "
	"Pretraining time is summarized over three seed-specific pooled runs. "
	"Training wall time includes in-memory batch iteration, host-to-device "
	"transfer, optimization, validation, checkpointing, and final evaluation. "
	"Raw-data preparation and external market-data/network or execution-system "
	"I/O are excluded.",
	"",
	"\| implementation \| params \| peak GiB \| B1 ms \| samples/s \| pretrain min \| adapt s \|",
	"\|---\|---:\|---:\|---:\|---:\|---:\|---:\|",
	]
	for row in rows:
	peak = row["peak_forward_gib_b128"]
	lines.append(
	f"\| {row['implementation']} \| {int(row['trainable_parameters']):,} \| "
	f"{float(peak):.3f} \| {float(row['batch1_latency_ms_mean']):.3f} \| "
	f"{float(row['samples_per_second']):.1f} \| "
	f"{float(row['pretrain_minutes_mean']):.2f} \| "
	f"{float(row['adapt_seconds_mean']):.1f} \|"
	)
	(args.out_dir / "complexity_profile.md").write_text(
	"\n".join(lines) + "\n",
	encoding="utf-8",
	)
	print(f"wrote final cost profile to {args.out_dir}")


	if __name__ == "__main__":
	main()