Source code for quantdata.dysanos.grid.gendysanos.run_one_time_comparison

"""Run four conditional one-time SANOS controls on one shared universe."""

from __future__ import annotations

import argparse
import atexit
import json
import multiprocessing as mp
import traceback
from dataclasses import asdict
from pathlib import Path
from typing import Any

from quantdata.dysanos.grid.rndysanos.run_experiment import _atomic_json
from quantdata.dysanos.grid.rndysanos.run_v2_mask_comparison import (
    _attach_universe,
    _cleanup_shared_memory,
    _share_universe,
)

from .run_one_time_control import run as run_control
from .terminal_universe import TerminalPathDiagnostics
from .torch_prep import (
    GenDysanosExperiment,
    prepare_one_time_terminal_experiment,
)


def _worker(
    descriptors: dict[str, dict[str, Any]],
    sampling: TerminalPathDiagnostics,
    args: argparse.Namespace,
) -> None:
    universe, handles = _attach_universe(descriptors)
    try:
        run_control(
            args,
            prepared_universe=universe,
            sampling_diagnostics=sampling,
        )
    except BaseException:
        traceback.print_exc()
        raise
    finally:
        for handle in handles:
            handle.close()


def _job_args(
    args: argparse.Namespace,
    *,
    utility: str,
    state_mode: str,
) -> argparse.Namespace:
    name = f"{utility}-{state_mode}"
    return argparse.Namespace(
        paths=args.paths,
        epochs=args.epochs,
        seed=args.seed,
        generator_block_size=args.generator_block_size,
        universe_mode="one-step",
        trading_state_steps=10,
        num_alpha=None,
        use_matrix_exp=True,
        bandwidth=1.0,
        action_type="network",
        state_mode=state_mode,
        utility=utility,
        lmbda=1.0,
        cost_prop=0.0,
        batch_size=args.batch_size,
        val_batch_size=args.val_batch_size,
        lr=args.lr,
        precision=args.precision,
        compile=True,
        restart=args.restart,
        early_stopping=True,
        minimum_epochs=args.minimum_epochs,
        debug=False,
        checkpoint_root=args.checkpoint_root,
        report=str(Path(args.output_root) / f"{name}.json"),
    )


def _compact(report: dict[str, Any]) -> dict[str, Any]:
    return {
        "device": report["device"],
        "utility": report["utility"],
        "state_mode": report["state_mode"],
        "preparation_seconds": report["preparation_seconds"],
        "compiled_graphs": report["stage"]["compiled_graphs"],
        "memory": report["stage"]["memory"],
        "convergence": report["stage"]["convergence"],
        "training": {
            "loss": report["stage"]["splits"]["training"]["loss"],
            "objective_gradient": report["stage"]["splits"]["training"][
                "objective_gradient"
            ],
            "martingale": report["stage"]["splits"]["training"]["martingale"],
        },
        "validation": {
            "loss": report["stage"]["splits"]["validation"]["loss"],
            "objective_gradient": report["stage"]["splits"]["validation"][
                "objective_gradient"
            ],
            "martingale": report["stage"]["splits"]["validation"]["martingale"],
        },
    }


[docs] def run(args: argparse.Namespace) -> dict[str, Any]: """Prepare once, run four GPU workers, and aggregate their reports.""" output_root = Path(args.output_root) comparison_path = output_root / "one-time-comparison.json" universe, sampling = prepare_one_time_terminal_experiment( GenDysanosExperiment( num_samples=args.paths, seed=args.seed, block_size=args.generator_block_size, ) ) descriptors, handles, shared_bytes = _share_universe(universe) del universe atexit.register(_cleanup_shared_memory, handles) jobs = [ _job_args(args, utility=utility, state_mode=state_mode) for utility, state_mode in ( ("entropy", "raw"), ("powexp", "raw"), ("entropy", "full"), ("powexp", "full"), ) ] initial = { "status": "running", "paths": args.paths, "training_paths": args.paths // 2, "validation_paths": args.paths - args.paths // 2, "epochs": args.epochs, "lr": args.lr, "seed": args.seed, "shared_memory_bytes": shared_bytes, "sampling_diagnostics": asdict(sampling), "reports": [job.report for job in jobs], } _atomic_json(comparison_path, initial) context = mp.get_context("spawn") processes = [ context.Process( target=_worker, args=(descriptors, sampling, job), name=f"{job.utility}-{job.state_mode}", ) for job in jobs ] try: for process in processes: process.start() for process in processes: process.join() exitcodes = {process.name: process.exitcode for process in processes} if any(code != 0 for code in exitcodes.values()): failed = {**initial, "status": "failed", "exitcodes": exitcodes} _atomic_json(comparison_path, failed) raise RuntimeError(f"one or more controls failed: {exitcodes}") reports = [ json.loads(Path(job.report).read_text(encoding="utf-8")) for job in jobs ] result = { **initial, "status": "complete", "exitcodes": exitcodes, "controls": { f"{report['utility']}-{report['state_mode']}": _compact(report) for report in reports }, } _atomic_json(comparison_path, result) return result finally: _cleanup_shared_memory(handles) atexit.unregister(_cleanup_shared_memory)
[docs] def parser() -> argparse.ArgumentParser: result = argparse.ArgumentParser(description=__doc__) result.add_argument("--paths", type=int, default=100_000) result.add_argument("--epochs", type=int, default=20_000) result.add_argument("--seed", type=int, default=500_000) result.add_argument("--generator-block-size", type=int, default=25_000) result.add_argument("--batch-size", type=int, default=4_096) result.add_argument("--val-batch-size", type=int, default=8_192) result.add_argument("--lr", type=float, default=1.0e-4) result.add_argument("--precision", type=int, choices=(32, 64), default=32) result.add_argument("--restart", action="store_true") result.add_argument("--minimum-epochs", type=int, default=2_000) result.add_argument( "--checkpoint-root", default="~/.cache/rndysanos/oce-gendysanos-control" ) result.add_argument( "--output-root", default="quantdata/dysanos/grid/gendysanos/reports/one-time-100000", ) return result
[docs] def main() -> None: args = parser().parse_args() report = run(args) print( json.dumps( { "status": report["status"], "comparison": str(Path(args.output_root) / "one-time-comparison.json"), "exitcodes": report["exitcodes"], "controls": report["controls"], }, indent=2, ), flush=True, )
if __name__ == "__main__": main()