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

"""Search independently simulated Dysanos paths for direct conditional arbitrage.

Example
-------
::

    python -m quantdata.dysanos.grid.rndysanos.run_direct_arbitrage \
        --paths 200000 --epochs 200000 --cost-mode combined --seed 70771 \
        --report quantdata/dysanos/grid/rndysanos/reports/direct-arbitrage.json
"""

from __future__ import annotations

import argparse
import gc
import json
import math
import os
import time
from dataclasses import asdict
from pathlib import Path
from typing import Any

import numpy as np
import torch
from cdxcore.err import verify_inp

from quantdata.torch import BaseEnvironment, DeviceLock

from .direct_arbitrage import (
    DirectArbitrageConfig,
    DirectArbitrageTrainConfig,
    effective_cost,
    train_direct_policy,
    unconditional_cost,
)
from .local_arbitrage import unpack_direction_mask
from .run_experiment import (
    _counter_difference,
    _dynamo_counters,
    memory_snapshot,
    pair_training_validation_universes,
)
from .torch_drift_change import (
    DysanosConfig,
    DysanosModel,
    prepare_universe,
    split_training_validation,
)
from .torch_prep import RNDysanosExperiment, prep_experiment


def _atomic_json(path: Path, value: dict[str, Any]) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
    try:
        temporary.write_text(json.dumps(value, indent=2), encoding="utf-8")
        os.replace(temporary, path)
    finally:
        temporary.unlink(missing_ok=True)


def _conditional_cost_model(
    *,
    report_path: Path,
    env: BaseEnvironment,
    geometry: Any,
    allow_different_sample_count: bool = False,
) -> tuple[DysanosModel, str]:
    report = json.loads(report_path.read_text(encoding="utf-8"))
    regime = report.get("regimes", {}).get("conditional")
    if regime is None or not regime.get("stages"):
        raise ValueError(f"{report_path} contains no conditional model stage")
    checkpoint_path = Path(regime["stages"][0]["checkpoint"]).expanduser()
    state = torch.load(checkpoint_path, map_location=env.device, weights_only=False)
    stored_config = state.get("config")
    if not isinstance(stored_config, dict):
        raise RuntimeError(f"checkpoint {checkpoint_path} has no model configuration")
    config = DysanosConfig(
        label=stored_config["label"],
        group=stored_config["group"],
        user_version=stored_config["user_version"],
        utility=stored_config["utility"],
        lmbda=stored_config["lmbda"],
        delta_hedged=stored_config["delta_hedged"],
        cash_returns=stored_config["cash_returns"],
        learn_cost=stored_config["learn_cost"],
        cost_cond=stored_config["cost_cond"],
        cost_uncond=stored_config["cost_uncond"],
        cost_prop=stored_config["cost_prop"],
        seed=stored_config["seed"],
        action_scale=stored_config["action_scale"],
        drift_scale=stored_config["drift_scale"],
        sqr_scale=stored_config["sqr_scale"],
        cash_floor=stored_config["cash_floor"],
        density_floor=stored_config["density_floor"],
        denominator_floor=stored_config["denominator_floor"],
    )
    verify_inp(
        config.delta_hedged and not config.cash_returns,
        "conditional cost checkpoint has incompatible return semantics",
    )
    verify_inp(
        float(config.cost_cond) == 1.0,
        lambda: f"conditional cost multiplier must be one, got {config.cost_cond}",
    )
    expected_geometry = asdict(geometry)
    stored_geometry = state.get("geometry")
    if allow_different_sample_count and isinstance(stored_geometry, dict):
        stored_geometry = {
            name: value
            for name, value in stored_geometry.items()
            if name != "samples"
        }
        expected_geometry = {
            name: value
            for name, value in expected_geometry.items()
            if name != "samples"
        }
    if stored_geometry != expected_geometry:
        raise RuntimeError(
            f"checkpoint geometry {stored_geometry} != {expected_geometry}"
        )
    if state.get("phase") != "main" or int(state.get("moment_epoch", 0)) <= 0:
        raise RuntimeError("conditional moment checkpoint is unfinished")
    model = DysanosModel(env, geometry=geometry, config=config)
    incompatible = model.load_state_dict(state["model_state"], strict=False)
    unexpected = set(incompatible.unexpected_keys)
    if not unexpected.issubset({"offset.value"}) or incompatible.missing_keys:
        raise RuntimeError(
            "conditional cost checkpoint has incompatible model tensors: "
            f"missing={incompatible.missing_keys}, unexpected={incompatible.unexpected_keys}"
        )
    model.freeze_moments()
    model.requires_grad_(False)
    model.eval()
    return model, str(checkpoint_path)


def _label_top_instruments(
    valuation: dict[str, Any], *, strikes: int
) -> None:
    for item in valuation["top_instruments_by_mean_gross_exposure"]:
        instrument = item["instrument"]
        if instrument == 0:
            item.update(kind="spot", expiry_index=None, strike_index=None)
        else:
            option = instrument - 1
            item.update(
                kind="delta_hedged_option",
                expiry_index=option // strikes,
                strike_index=option % strikes,
            )


def _excluded_direction_mask(
    *,
    mask_path: Path,
    paths: int,
    steps: int,
    option_instruments: int,
    total_instruments: int,
    device: torch.device,
) -> torch.Tensor:
    packed_array = np.load(mask_path, mmap_mode="r", allow_pickle=False)
    expected = (paths * steps, 2, math.ceil(option_instruments / 8))
    if packed_array.shape != expected or packed_array.dtype != np.uint8:
        raise ValueError(
            f"packed mask {mask_path} must have shape/dtype {expected}/uint8, "
            f"got {packed_array.shape}/{packed_array.dtype}"
        )
    packed = torch.tensor(packed_array, dtype=torch.uint8, device=device)
    options = unpack_direction_mask(
        packed, instruments=option_instruments
    ).reshape(paths, steps, 2, option_instruments)
    del packed
    excluded = torch.zeros(
        paths,
        steps,
        2 * total_instruments,
        dtype=torch.bool,
        device=device,
    )
    excluded[..., 1:total_instruments] = options[..., 0, :]
    excluded[..., total_instruments + 1 :] = options[..., 1, :]
    return excluded


[docs] def run( args: argparse.Namespace, *, prepared_universe: dict[str, np.ndarray] | None = None, ) -> dict[str, Any]: if args.paths <= 0 or args.paths % 2: raise ValueError("--paths must be a positive even number") preparation_started = time.monotonic() if prepared_universe is None: experiment = RNDysanosExperiment( num_samples=args.paths // 2, pcnt_validation=0.5, cnt_universe=2, universe_seed_offset=args.universe_seed_offset, ) source = prep_experiment(experiment, plot_sampler=False) paired = pair_training_validation_universes(source, consume=True) del source universe = paired.pop() del paired else: universe = prepared_universe gc.collect() preparation_seconds = time.monotonic() - preparation_started with DeviceLock() as device_lock: env = BaseEnvironment(device=device_lock.device, debug=False) data_config = DysanosConfig( label="direct-arbitrage-data", delta_hedged=True, cash_returns=False, cost_cond=0.0, cost_uncond=1.0, ) all_data, geometry = prepare_universe( universe, config=data_config, env=env ) if geometry.samples != args.paths: raise RuntimeError( f"prepared universe has {geometry.samples} paths, expected {args.paths}" ) del universe training, validation = split_training_validation(all_data, 0.5) del all_data assert validation is not None training_paths = training["z"].shape[0] validation_paths = validation["z"].shape[0] if training_paths != args.paths // 2 or validation_paths != args.paths // 2: raise RuntimeError( f"expected equal {args.paths // 2}-path splits, found " f"{training_paths} and {validation_paths}" ) n_cost = training_paths * geometry.steps bar_c = unconditional_cost( training, cost_uncond=1.0, batch_size=args.valuation_batch_size, ) conditional_model = None conditional_checkpoint = None if args.cost_mode == "combined": conditional_model, conditional_checkpoint = _conditional_cost_model( report_path=Path(args.conditional_report), env=env, geometry=geometry, allow_different_sample_count=prepared_universe is not None, ) training_cost = effective_cost( training, bar_c=bar_c, cost_prop=args.cost_prop, conditional_variance_model=conditional_model, n_cost=n_cost, batch_size=args.valuation_batch_size, ) validation_cost = effective_cost( validation, bar_c=bar_c, cost_prop=args.cost_prop, conditional_variance_model=conditional_model, n_cost=n_cost, batch_size=args.valuation_batch_size, ) del conditional_model if args.state_mode == "raw": training["z"] = training["z"][ ..., : geometry.state_variables ].clone() validation["z"] = validation["z"][ ..., : geometry.state_variables ].clone() training_policy = { "z": training["z"], "dH": training["dH"], "cost": training_cost, } validation_policy = { "z": validation["z"], "dH": validation["dH"], "cost": validation_cost, } mask_report: dict[str, Any] | None = None if args.arbitrage_mask_report is not None: mask_report_path = Path(args.arbitrage_mask_report) mask_report = json.loads(mask_report_path.read_text(encoding="utf-8")) if mask_report.get("status") != "complete": raise RuntimeError(f"arbitrage mask report {mask_report_path} is incomplete") if ( mask_report.get("paths") != args.paths or mask_report.get("universe_seed_offset") != args.universe_seed_offset ): raise RuntimeError( f"arbitrage mask report {mask_report_path} uses a different universe" ) mask_files = mask_report.get("mask_files", {}) training_policy["excluded_directions"] = _excluded_direction_mask( mask_path=Path(mask_files["training"]), paths=training_paths, steps=geometry.steps, option_instruments=geometry.expiries * geometry.strikes, total_instruments=geometry.instruments, device=env.device, ) validation_policy["excluded_directions"] = _excluded_direction_mask( mask_path=Path(mask_files["validation"]), paths=validation_paths, steps=geometry.steps, option_instruments=geometry.expiries * geometry.strikes, total_instruments=geometry.instruments, device=env.device, ) del training, validation gc.collect() config = DirectArbitrageConfig( label=( f"{args.objective}-{args.state_mode}-" f"{'masked' if mask_report is not None else 'unmasked'}" f"-seed-{args.seed}" ), group=( f"validation/{args.paths}-paths/{args.objective}-{args.state_mode}/" f"{'masked' if mask_report is not None else 'unmasked'}" ), user_version="1.0", state_features=training_policy["z"].shape[-1], instruments=geometry.instruments, epsilon=args.epsilon, delta=args.delta, numerical_tolerance=args.numerical_tolerance, smooth_temperature=args.smooth_temperature, tail_fraction=args.tail_fraction, downside_weight=args.downside_weight, tail_weight=args.tail_weight, overlap_weight=args.overlap_weight, mean_reward_weight=args.mean_reward_weight, discovery_fraction=args.discovery_fraction, constraint_ramp_fraction=args.constraint_ramp_fraction, initial_trade_fraction=args.initial_trade_fraction, mask_arbitrage_candidates=mask_report is not None, objective=args.objective, cap_weight=args.cap_weight, seed=args.seed, ) train_config = DirectArbitrageTrainConfig( batch_size=args.batch_size, valuation_batch_size=args.valuation_batch_size, lr=args.lr, final_lr=args.final_lr, weight_decay=args.weight_decay, compile=not args.no_compile, value_update=args.value_update, checkpoint_update=args.checkpoint_update, checkpoint_root=args.checkpoint_root, ) memory_before = memory_snapshot(env.device) compilation_before = _dynamo_counters() started = time.monotonic() result = train_direct_policy( training_policy, validation_policy, config=config, train_config=train_config, epochs=args.epochs, env=env, restart=args.restart, ) if env.device.type == "cuda": torch.cuda.synchronize(env.device) elapsed_seconds = time.monotonic() - started compilation = _counter_difference(_dynamo_counters(), compilation_before) _label_top_instruments(result.training, strikes=geometry.strikes) assert result.validation is not None _label_top_instruments(result.validation, strikes=geometry.strikes) report = { "method": ( "state-only unbounded signed output with radial L1 clipping" if args.objective == "radial-l1-v2" else "state-only long/short softmax direction with sigmoid exposure gate" ), "objective_name": ( "V2.0" if args.objective == "radial-l1-v2" else "legacy simplex soft-hit" ), "objective_formula": ( "-E[X] + lambda_minus E[(-X)_+] + " "lambda_tail CVaR_tail((-X)_+) + " "lambda_cap E[((||v||_1-1)_+)^2]" if args.objective == "radial-l1-v2" else None ), "state_mode": args.state_mode, "state_features": training_policy["z"].shape[-1], "arbitrage_mask_report": args.arbitrage_mask_report, "arbitrage_mask_definition": ( None if mask_report is None else mask_report.get("arb_function") ), "return_semantics": "delta-hedged, non-cash-normalized dH", "gross_constraint": ( "a=v/max(1,||v||_1), hence ||a||_1<=1 at every state" if args.objective == "radial-l1-v2" else "sum(long + short) <= 1 at every state" ), "cost_mode": args.cost_mode, "cost_definition": ( "max(conditional standard error, unconditional standard error, " "one-basis-point proportional cost)" if args.cost_mode == "combined" else "max(unconditional standard error, one-basis-point proportional cost)" ), "conditional_checkpoint": conditional_checkpoint, "paths": args.paths, "training_paths": training_paths, "validation_paths": validation_paths, "n_cost": n_cost, "epochs": args.epochs, "universe_seed_offset": args.universe_seed_offset, "preparation_seconds": preparation_seconds, "elapsed_seconds": elapsed_seconds, "device": str(env.device), "geometry": asdict(geometry), "config": asdict(config), "train_config": asdict(train_config), "checkpoint": str(result.checkpoint_path), "restarted": result.restarted, "compiled_graphs": compilation, "memory_before": memory_before, "memory_after": memory_snapshot(env.device), "bar_c": bar_c.cpu().numpy().tolist(), "training": result.training, "validation": result.validation, "tracker": result.tracker, "conclusion": { "training_qualifies": result.training["qualifies_empirically"], "validation_qualifies": result.validation["qualifies_empirically"], "population_almost_sure_claim": False, "reason": ( "Monte Carlo validation can reject candidates and bound loss " "probability, but cannot prove a population almost-sure statement." ), }, } _atomic_json(Path(args.report), report) return report
def _parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--paths", type=int, default=200_000) parser.add_argument("--epochs", type=int, default=200_000) parser.add_argument( "--cost-mode", choices=["unconditional", "combined"], required=True ) parser.add_argument("--state-mode", choices=["full", "raw"], default="full") parser.add_argument("--arbitrage-mask-report") parser.add_argument("--seed", type=int, required=True) parser.add_argument("--universe-seed-offset", type=int, default=0) parser.add_argument("--epsilon", type=float, default=0.01) parser.add_argument("--delta", type=float, default=0.01) parser.add_argument("--numerical-tolerance", type=float, default=1.0e-4) parser.add_argument("--smooth-temperature", type=float, default=0.0025) parser.add_argument("--tail-fraction", type=float, default=0.01) parser.add_argument("--downside-weight", type=float, default=10.0) parser.add_argument("--tail-weight", type=float, default=100.0) parser.add_argument("--overlap-weight", type=float, default=1.0) parser.add_argument("--mean-reward-weight", type=float, default=0.1) parser.add_argument("--discovery-fraction", type=float, default=0.05) parser.add_argument("--constraint-ramp-fraction", type=float, default=0.45) parser.add_argument("--initial-trade-fraction", type=float, default=0.01) parser.add_argument( "--objective", choices=["radial-l1-v2", "simplex-soft-hit"], default="radial-l1-v2", ) parser.add_argument("--cap-weight", type=float, default=1.0) parser.add_argument("--cost-prop", type=float, default=0.0001) parser.add_argument("--batch-size", type=int, default=1_024) parser.add_argument("--valuation-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-4) parser.add_argument("--weight-decay", type=float, default=1.0e-4) parser.add_argument("--value-update", type=int, default=10_000) parser.add_argument("--checkpoint-update", type=int, default=10_000) parser.add_argument( "--checkpoint-root", default="~/.cache/rndysanos/direct-arbitrage" ) parser.add_argument( "--conditional-report", default=( "quantdata/dysanos/grid/rndysanos/reports/" "full-200000-e1000000-up-to10-per-cap-conditional-same.json" ), ) parser.add_argument("--report", required=True) parser.add_argument("--restart", action="store_true") parser.add_argument("--no-compile", action="store_true") return parser
[docs] def main() -> None: args = _parser().parse_args() report = run(args) print(json.dumps(report, indent=2), flush=True)
if __name__ == "__main__": main() __all__ = ["main", "run"]