Source code for quantdata.dysanos.grid.rndysanos.run_weighted_deterministic_oce

"""Solve the deterministic complete-path powerexp benchmark under exact IS.

The action is one unrestricted constant matrix ``a[t, instrument]``.  The
tail-complete Gaussian proposal is weighted back to the fitted physical
measure in the objective, validation statistics, and martingale diagnostics.
"""

from __future__ import annotations

import argparse
import json
import time
from dataclasses import asdict
from pathlib import Path

import torch

from quantdata.dysanos.grid.gendysanos.torch_prep import (
    GenDysanosExperiment,
    prepare_terminal_path_experiment,
)
from quantdata.dysanos.grid.torch_simulator import GaussianSpotImportanceConfig
from quantdata.torch import BaseEnvironment, DeviceLock

from .run_experiment import (
    _atomic_json,
    _baseline_split,
    _counter_difference,
    _dynamo_counters,
    _stage_report,
)
from .torch_drift_change import DysanosConfig, TrainConfig, train


[docs] def run(args: argparse.Namespace) -> dict[str, object]: """Generate one universe and solve the full-training L-BFGS problem.""" if args.paths <= 0 or args.paths % 2: raise ValueError("'paths' must be positive and even") output = Path(args.output) started = time.monotonic() universe, diagnostics = prepare_terminal_path_experiment( GenDysanosExperiment( num_samples=args.paths, mode="path", option_return_horizon=args.option_return_horizon, num_steps=args.trading_state_steps, num_alpha=None, use_matrix_exp=True, bandwidth=1.0, seed=args.seed, block_size=args.generator_block_size, importance_sampling=( GaussianSpotImportanceConfig( spot_std_multiplier=args.importance_spot_std_multiplier, base_probability=args.importance_base_probability, target_action_count=args.importance_target_action_count, ) if args.importance_sampling else None ), ) ) generation_seconds = time.monotonic() - started with DeviceLock() as device_lock: env = BaseEnvironment( precision=args.precision, device=device_lock.device, debug=False, ) hedge_label = "dh" if args.delta_hedged else "unhedged" scale_label = "cash" if args.cash_returns else "raw" horizon_label = args.option_return_horizon.replace("-", "") sampling_label = "is" if args.importance_sampling else "directp" config = DysanosConfig( label=( f"weighted-deterministic-powexp-p{args.precision}-" f"{hedge_label}-{scale_label}-{horizon_label}-{sampling_label}-" f"{args.paths}-{args.seed}" ), group=( f"gendysanos/{sampling_label}-path/{args.paths}/seed-{args.seed}/" f"powexp-deterministic-p{args.precision}-{hedge_label}-" f"{scale_label}-{horizon_label}" ), user_version="3.1", utility="powexp", lmbda=1.0, oce_variant="simplified", action_type="deterministic", deterministic_precondition=args.precondition, deterministic_preprocess=args.preprocess, state_mode="raw", delta_hedged=args.delta_hedged, cash_returns=args.cash_returns, learn_cost=False, cost_cond=0.0, cost_uncond=0.0, cost_prop=args.cost_prop, ) train_config = TrainConfig( trn_batch_size=args.batch_size, val_batch_size=args.val_batch_size, validation_fraction=0.5, optimizer="SciPy", lr=args.lr, final_lr=args.lr, weight_decay=0.0, compile=not args.no_compile, value_seconds=args.value_seconds, value_update=args.value_update, checkpoint_seconds=args.checkpoint_seconds, checkpoint_update=args.checkpoint_update, heavy_output_update=args.epochs, early_stopping=True, minimum_epochs=args.minimum_epochs, convergence_points=args.convergence_points, convergence_relative_tolerance=( args.convergence_relative_tolerance ), require_cost_band=False, scipy_gradient_tolerance=args.scipy_gradient_tolerance, scipy_function_tolerance=args.scipy_function_tolerance, scipy_max_line_search_steps=args.scipy_max_line_search_steps, checkpoint_root=args.checkpoint_root, ) before_compile = _dynamo_counters() training_started = time.monotonic() result = train( universe, config=config, train_config=train_config, epochs=args.epochs, moment_epochs=1, restart=args.restart, env=env, ) torch.cuda.synchronize(env.device) stage = _stage_report( result=result, elapsed_seconds=time.monotonic() - training_started, device=env.device, compilation=_counter_difference( _dynamo_counters(), before_compile ), ) report: dict[str, object] = { "status": "complete", "experiment": "likelihood-weighted deterministic path powerexp", "objective": ( "sup_a E_P[u(sum (a+b)*dH)] after separable b preprocessing" if args.preprocess else "sup_{a[t,omega]} E_P[u(sum a*dH)]" ), "paths": args.paths, "training_paths": args.paths // 2, "validation_paths": args.paths // 2, "return_semantics": ( ( f"{args.option_return_horizon} delta-hedged P&L" if args.delta_hedged else f"{args.option_return_horizon} unhedged option P&L" ) + ( " divided by initial gross notional" if args.cash_returns else " in raw normalized-dollar units" ) ), "cost_prop": args.cost_prop, "importance_semantics": ( "all objectives, normalizers, means, and MC errors include p/q" if args.importance_sampling else "direct sampling under P; all path weights equal one" ), "generation_seconds": generation_seconds, "sampling_diagnostics": asdict(diagnostics), "model_config": asdict(config), "train_config": asdict(train_config), "device": str(env.device), "baseline": { "training": _baseline_split(result.training), "validation": _baseline_split(result.validation), }, "stage": stage, } _atomic_json(output, report) return report
def _parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--paths", type=int, default=100_000) parser.add_argument("--epochs", type=int, default=250) parser.add_argument("--minimum-epochs", type=int, default=20) parser.add_argument("--seed", type=int, default=700_000) parser.add_argument("--trading-state-steps", type=int, default=10) parser.add_argument( "--option-return-horizon", choices=["expiry", "one-day"], default="one-day", ) parser.add_argument("--generator-block-size", type=int, default=10_000) parser.add_argument("--batch-size", type=int, default=8_192) parser.add_argument("--val-batch-size", type=int, default=8_192) parser.add_argument("--lr", type=float, default=1.0) parser.add_argument("--precision", type=int, choices=[32, 64], default=64) parser.add_argument( "--delta-hedged", action=argparse.BooleanOptionalAction, default=True, ) parser.add_argument( "--cash-returns", action=argparse.BooleanOptionalAction, default=True, ) parser.add_argument( "--precondition", action=argparse.BooleanOptionalAction, default=False, ) parser.add_argument( "--preprocess", action=argparse.BooleanOptionalAction, default=False, ) parser.add_argument("--cost-prop", type=float, default=0.0) parser.add_argument("--value-update", type=int, default=5) parser.add_argument("--value-seconds", type=float, default=1_800.0) parser.add_argument("--checkpoint-update", type=int, default=5) parser.add_argument("--checkpoint-seconds", type=float, default=1_800.0) parser.add_argument("--convergence-points", type=int, default=7) parser.add_argument( "--convergence-relative-tolerance", type=float, default=1.0e-4 ) parser.add_argument("--scipy-gradient-tolerance", type=float, default=1.0e-10) parser.add_argument("--scipy-function-tolerance", type=float, default=0.0) parser.add_argument("--scipy-max-line-search-steps", type=int, default=50) parser.add_argument("--importance-spot-std-multiplier", type=float, default=8.0) parser.add_argument("--importance-base-probability", type=float, default=0.1) parser.add_argument("--importance-target-action-count", type=int, default=3) parser.add_argument( "--importance-sampling", action=argparse.BooleanOptionalAction, default=True, ) parser.add_argument("--restart", action="store_true") parser.add_argument("--no-compile", action="store_true") parser.add_argument( "--checkpoint-root", default="/home/hans/.cache/rndysanos/weighted-deterministic-oce", ) parser.add_argument( "--output", default=( "quantdata/dysanos/grid/rndysanos/reports/" "weighted-deterministic-oce-100000.json" ), ) return parser
[docs] def main() -> None: args = _parser().parse_args() report = run(args) stage = report["stage"] assert isinstance(stage, dict) print( json.dumps( { "status": report["status"], "output": args.output, "convergence": stage["convergence"], "training": stage["splits"]["training"]["objective_gradient"], "validation": stage["splits"]["validation"]["objective_gradient"], }, indent=2, ), flush=True, )
if __name__ == "__main__": main() __all__ = ["main", "run"]