"""Run four complete-path OCE comparisons on one shared million-path universe."""
from __future__ import annotations
import argparse
import atexit
import gc
import json
import multiprocessing as mp
import time
import traceback
from pathlib import Path
from typing import Any
from .run_experiment import _atomic_json, run_experiment
from .run_v2_mask_comparison import (
_attach_universe,
_cleanup_shared_memory,
_share_universe,
)
from .torch_prep import RNDysanosExperiment, prep_experiment
def _worker(descriptors: dict[str, dict[str, Any]], args: argparse.Namespace) -> None:
universe, handles = _attach_universe(descriptors)
try:
run_experiment(args, prepared_universes=[universe])
except BaseException:
traceback.print_exc()
raise
finally:
for handle in handles:
handle.close()
def _job_args(
args: argparse.Namespace,
*,
name: str,
regime: str,
utility: str,
lmbda: float,
masked: bool,
) -> argparse.Namespace:
return argparse.Namespace(
paths=args.paths,
epochs=args.epochs,
moment_epochs=args.moment_epochs,
stages=1,
validation_fraction=0.5,
universe_seed_offset=args.universe_seed_offset,
independent_split_universes=False,
same_universe=True,
regimes=regime,
batch_size=args.batch_size,
val_batch_size=args.val_batch_size,
lr=args.lr,
final_lr=args.final_lr,
moment_lr=args.moment_lr,
moment_final_lr=args.moment_final_lr,
action_initialization_epochs=0,
action_initialization_lr=1.0e-3,
utility=utility,
lmbda=lmbda,
weight_decay=0.0,
minimum_epochs=args.minimum_epochs,
minimum_moment_epochs=args.minimum_moment_epochs,
early_stopping=True,
convergence_points=args.convergence_points,
convergence_relative_tolerance=args.convergence_relative_tolerance,
cost_band_tolerance=args.cost_band_tolerance,
minimum_unsigned_improvement=0.0,
continue_after_failed_gate=False,
value_seconds=args.value_seconds,
value_update=args.value_update,
checkpoint_seconds=args.checkpoint_seconds,
checkpoint_update=args.checkpoint_update,
checkpoint_root=args.checkpoint_root,
arb_mask_report=args.arb_mask_report if masked else None,
report=str(Path(args.output_root) / f"{name}.json"),
restart=args.restart,
no_compile=args.no_compile,
)
def _final_summary(output: dict[str, Any], regime: str) -> dict[str, Any]:
regime_output = output["regimes"][regime]
stage = regime_output["stages"][-1]
return {
"device": output["device"],
"utility": output["utility"],
"lmbda": output["lmbda"],
"strategy_mask": output["strategy_mask"],
"compiled_graphs": stage["compiled_graphs"],
"elapsed_seconds": stage["elapsed_seconds"],
"memory": stage["memory"],
"convergence": stage["convergence"],
"continuation_gate": stage["continuation_gate"],
"training": {
"loss": stage["splits"]["training"]["loss"],
"objective_gradient": stage["splits"]["training"]["objective_gradient"],
"density_selection": stage["splits"]["training"]["density_selection"],
"martingale": stage["splits"]["training"]["martingale"],
},
"validation": {
"loss": stage["splits"]["validation"]["loss"],
"objective_gradient": stage["splits"]["validation"]["objective_gradient"],
"density_selection": stage["splits"]["validation"]["density_selection"],
"martingale": stage["splits"]["validation"]["martingale"],
},
}
[docs]
def run(args: argparse.Namespace) -> dict[str, Any]:
"""Prepare once, run four GPU workers, and write a compact comparison."""
output_root = Path(args.output_root)
comparison_path = output_root / "path-oce-comparison.json"
jobs = [
(
"powexp-unconditional-unmasked",
"unconditional",
_job_args(
args,
name="powexp-unconditional-unmasked",
regime="unconditional",
utility="powexp",
lmbda=1.0,
masked=False,
),
),
(
"powexp-unconditional-masked",
"unconditional",
_job_args(
args,
name="powexp-unconditional-masked",
regime="unconditional",
utility="powexp",
lmbda=1.0,
masked=True,
),
),
(
"powexp-conditional-unmasked",
"conditional",
_job_args(
args,
name="powexp-conditional-unmasked",
regime="conditional",
utility="powexp",
lmbda=1.0,
masked=False,
),
),
(
"cvar90-unconditional-unmasked",
"unconditional",
_job_args(
args,
name="cvar90-unconditional-unmasked",
regime="unconditional",
utility="cvar",
lmbda=1.0 / 9.0,
masked=False,
),
),
]
report: dict[str, Any] = {
"status": "preparing_shared_universe",
"paths": args.paths,
"training_paths": args.paths // 2,
"validation_paths": args.paths // 2,
"epochs": args.epochs,
"moment_epochs": args.moment_epochs,
"universe_seed_offset": args.universe_seed_offset,
"jobs": {name: job.report for name, _, job in jobs},
}
_atomic_json(comparison_path, report)
started = time.monotonic()
experiment = RNDysanosExperiment(
num_samples=args.paths,
pcnt_validation=0.5,
cnt_universe=1,
universe_seed_offset=args.universe_seed_offset,
)
universe = prep_experiment(experiment, plot_sampler=False)[0]
descriptors, handles, shared_bytes = _share_universe(universe)
del universe
gc.collect()
atexit.register(_cleanup_shared_memory, handles)
report.update(
status="running_four_jobs",
preparation_seconds=time.monotonic() - started,
shared_memory_bytes=shared_bytes,
shared_memory_segments=len(handles),
)
_atomic_json(comparison_path, report)
context = mp.get_context("spawn")
processes = [
(
name,
context.Process(target=_worker, args=(descriptors, job), name=name),
)
for name, _, job in jobs
]
worker_started = time.monotonic()
try:
for _, process in processes:
process.start()
for _, process in processes:
process.join()
exitcodes = {name: process.exitcode for name, process in processes}
if any(code != 0 for code in exitcodes.values()):
report.update(status="failed", exitcodes=exitcodes)
_atomic_json(comparison_path, report)
raise RuntimeError(f"one or more path-OCE workers failed: {exitcodes}")
outputs = {
name: json.loads(Path(job.report).read_text(encoding="utf-8"))
for name, _, job in jobs
}
report.update(
status="complete",
worker_elapsed_seconds=time.monotonic() - worker_started,
exitcodes=exitcodes,
summaries={
name: _final_summary(outputs[name], regime)
for name, regime, _ in jobs
},
)
_atomic_json(comparison_path, report)
return report
finally:
atexit.unregister(_cleanup_shared_memory)
_cleanup_shared_memory(handles)
def _parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--paths", type=int, default=1_000_000)
parser.add_argument("--epochs", type=int, default=200_000)
parser.add_argument("--moment-epochs", type=int, default=200_000)
parser.add_argument("--minimum-epochs", type=int, default=100_000)
parser.add_argument("--minimum-moment-epochs", type=int, default=100_000)
parser.add_argument("--universe-seed-offset", type=int, default=100_000)
parser.add_argument("--batch-size", type=int, default=4_096)
parser.add_argument("--val-batch-size", type=int, default=4_096)
parser.add_argument("--lr", type=float, default=1.0e-3)
parser.add_argument("--final-lr", type=float, default=1.0e-3)
parser.add_argument("--moment-lr", type=float, default=1.0e-3)
parser.add_argument("--moment-final-lr", type=float, default=1.0e-6)
parser.add_argument("--value-update", type=int, default=10_000)
parser.add_argument("--value-seconds", type=float, default=3_600.0)
parser.add_argument("--checkpoint-update", type=int, default=10_000)
parser.add_argument("--checkpoint-seconds", type=float, default=3_600.0)
parser.add_argument("--convergence-points", type=int, default=5)
parser.add_argument("--convergence-relative-tolerance", type=float, default=5.0e-3)
parser.add_argument("--cost-band-tolerance", type=float, default=0.0)
parser.add_argument("--checkpoint-root", default="~/.cache/rndysanos/oce-path")
parser.add_argument(
"--arb-mask-report",
default=(
"quantdata/dysanos/grid/rndysanos/reports/"
"v2-1000000-fixed-simulator-cost-mask-comparison/"
"cost-local-arbitrage-mask.json"
),
)
parser.add_argument(
"--output-root",
default=(
"quantdata/dysanos/grid/rndysanos/reports/"
"path-oce-1000000-comparison"
),
)
parser.add_argument("--restart", action="store_true")
parser.add_argument("--no-compile", action="store_true")
return parser
[docs]
def main() -> None:
report = run(_parser().parse_args())
print(f"completed path-OCE comparison with status={report['status']}", flush=True)
if __name__ == "__main__":
main()
__all__ = ["main", "run"]