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

"""Execute historical-state mean-variance portfolios across risk aversions."""

from __future__ import annotations

import argparse
import json
import math
import os
import time
from pathlib import Path
from typing import Any

import numpy as np
from cdxcore.verbose import Context

from quantdata.biz_calendar import DAYS_PER_YEAR

from .historical_state_period_audit import (
    conditional_period_returns,
    decode_historical_fit,
    execute_frozen_action,
    observed_surface_calls,
    solve_mean_variance_portfolio,
    summarize_fit_errors,
)
from .torch_prep import GenDysanosExperiment, _load_generator_components

_DEFAULT_OUTPUT = Path(
    "quantdata/dysanos/grid/gendysanos/reports/historical-state-period-audit/"
    "dysanos-historical-states-1d-raw-0bps-mean-variance-"
    "gamma-1-10-100.json"
)


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, allow_nan=False), encoding="utf-8"
        )
        os.replace(temporary, path)
    finally:
        temporary.unlink(missing_ok=True)


def _sample_summary(
    action: np.ndarray,
    scenario_return: np.ndarray,
    *,
    risk_aversion: float,
) -> dict[str, float | int]:
    pnl = np.asarray(scenario_return, dtype=np.float64) @ np.asarray(
        action, dtype=np.float64
    )
    mean = float(np.mean(pnl))
    variance = float(np.var(pnl, ddof=0))
    return {
        "paths": int(pnl.size),
        "mean_pnl": mean,
        "median_pnl": float(np.median(pnl)),
        "pnl_standard_deviation": math.sqrt(variance),
        "mean_pnl_standard_error": math.sqrt(variance / pnl.size),
        "loss_count": int(np.count_nonzero(pnl < 0.0)),
        "loss_frequency": float(np.mean(pnl < 0.0)),
        "mean_variance_objective": mean - 0.5 * risk_aversion * variance,
    }


def _distribution(values: np.ndarray) -> dict[str, float]:
    values = np.asarray(values, dtype=np.float64)
    return {
        "mean": float(np.mean(values)),
        "standard_error": float(
            np.std(values, ddof=0) / math.sqrt(values.size)
        ),
        "minimum": float(np.min(values)),
        "p01": float(np.quantile(values, 0.01)),
        "p10": float(np.quantile(values, 0.10)),
        "median": float(np.quantile(values, 0.50)),
        "p90": float(np.quantile(values, 0.90)),
        "p99": float(np.quantile(values, 0.99)),
        "maximum": float(np.max(values)),
    }


def _aggregate(
    rows: list[dict[str, Any]], risk_aversions: tuple[float, ...]
) -> dict[str, Any]:
    result: dict[str, Any] = {}
    for risk_aversion in risk_aversions:
        key = f"{risk_aversion:g}"
        realized = np.asarray(
            [row["risk_aversions"][key]["realized"]["net_pnl"] for row in rows]
        )
        validation = np.asarray(
            [
                row["risk_aversions"][key]["model_validation"]["mean_pnl"]
                for row in rows
            ]
        )
        l1_norm = np.asarray(
            [row["risk_aversions"][key]["portfolio"]["l1_norm"] for row in rows]
        )
        converged = np.asarray(
            [
                row["risk_aversions"][key]["portfolio"]["optimizer"][
                    "converged"
                ]
                for row in rows
            ],
            dtype=bool,
        )
        result[key] = {
            "risk_aversion": risk_aversion,
            "realized_trade_pnl": _distribution(realized),
            "realized_loss_count": int(np.count_nonzero(realized < 0.0)),
            "realized_loss_frequency": float(np.mean(realized < 0.0)),
            "model_validation_mean_pnl": _distribution(validation),
            "model_validation_positive_mean_count": int(
                np.count_nonzero(validation > 0.0)
            ),
            "model_validation_to_realized_correlation": (
                float(np.corrcoef(validation, realized)[0, 1])
                if np.std(validation) > 0.0 and np.std(realized) > 0.0
                else None
            ),
            "portfolio_l1_norm": _distribution(l1_norm),
            "optimizer_converged_count": int(np.count_nonzero(converged)),
        }
    return result


def _parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument(
        "--risk-aversions", type=float, nargs="+", default=(1.0, 10.0, 100.0)
    )
    parser.add_argument("--training-paths", type=int, default=1_024)
    parser.add_argument("--validation-paths", type=int, default=4_096)
    parser.add_argument("--seed", type=int, default=731_991)
    parser.add_argument("--decoder-block-size", type=int, default=8_192)
    parser.add_argument("--start-index", type=int, default=0)
    parser.add_argument("--max-dates", type=int)
    parser.add_argument("--progress-every", type=int, default=25)
    parser.add_argument("--checkpoint-every", type=int, default=50)
    parser.add_argument("--device", default="cpu")
    parser.add_argument("--output", type=Path, default=_DEFAULT_OUTPUT)
    return parser


[docs] def main() -> None: args = _parser().parse_args() import torch risk_aversions = tuple(float(value) for value in args.risk_aversions) if not risk_aversions or not all( math.isfinite(value) and value > 0.0 for value in risk_aversions ): raise ValueError("risk aversions must be finite and positive") started = time.perf_counter() experiment = GenDysanosExperiment( num_samples=2, num_alpha=None, use_matrix_exp=True, bandwidth=1.0, trading_frequency="daily", return_horizon="incremental", delta_hedged=False, cost_rate=0.0, num_trading_times=2, seed=args.seed, importance_sampling=None, ) _, market, model, sampler = _load_generator_components( experiment, verbose=Context.quiet ) device = torch.device(args.device) if device.type == "cuda" and not torch.cuda.is_available(): raise RuntimeError(f"requested CUDA device {args.device!r} is unavailable") model.env.device = device model.to(device) model.decoder.xnms = model.decoder.xnms.to(device) model.eval() for parameter in model.parameters(): parameter.requires_grad_(False) print("decoding DYSANOS fits for all historical states", flush=True) fitted_calls = decode_historical_fit(model, sampler, market) fit_rows, fit_aggregate = summarize_fit_errors( fitted_calls=fitted_calls, market_calls=np.asarray(market["mids"]), relative_strikes=np.asarray(market["xstrikes"])[:, :, 1:-1], expiries=np.asarray(market["expiries"]), market_vols=np.asarray(market["mid_vols"]), weights=np.asarray(market["weights"]), ) del fitted_calls maximum_index = len(market["dates"]) - 1 start = max(0, args.start_index) stop = maximum_index if args.max_dates is not None: stop = min(stop, start + args.max_dates) if start >= stop: raise ValueError(f"empty historical interval [{start}, {stop})") rows: list[dict[str, Any]] = [] def report(status: str) -> dict[str, Any]: return { "status": status, "objective": ( "maximize a^T mean(R|h) - gamma/2 * " "a^T covariance(R|h) a subject to ||a||_1 <= 1" ), "risk_aversions": list(risk_aversions), "market_case": { "return_horizon": "one trading day", "delta_hedged": False, "transaction_cost_rate": 0.0, "spot_reset_to_one": True, "num_alpha": None, "use_matrix_exp": True, "surface_first": True, }, "sampling": { "training_paths_per_state": args.training_paths, "model_validation_paths_per_state": args.validation_paths, "historical_states": stop - start, "next_observed_market_is_used_only_for_realized_execution": True, }, "historical_interval": { "first_date": str(np.asarray(market["dates"])[start]), "last_entry_date": str(np.asarray(market["dates"])[stop - 1]), "last_exit_date": str(np.asarray(market["dates"])[stop]), }, "surface_fit_error_all_1412_states": fit_aggregate, "states": rows, "aggregate": _aggregate(rows, risk_aversions) if rows else None, "elapsed_seconds": time.perf_counter() - started, } for ordinal, index in enumerate(range(start, stop), start=1): expiries = np.asarray(market["expiries"][index], dtype=np.float64) training_return, relative_strikes, initial_model_calls = ( conditional_period_returns( model, sampler, surface_state=sampler.xstate[index, 1:], expiries=expiries, paths=args.training_paths, seed=args.seed + 2_000_003 * index, decoder_block_size=args.decoder_block_size, ) ) validation_return, validation_strikes, validation_initial_calls = ( conditional_period_returns( model, sampler, surface_state=sampler.xstate[index, 1:], expiries=expiries, paths=args.validation_paths, seed=args.seed + 2_000_003 * index + 1, decoder_block_size=args.decoder_block_size, ) ) if not np.allclose(validation_strikes, relative_strikes) or not np.allclose( validation_initial_calls, initial_model_calls ): raise RuntimeError("conditional train/validation contract grids differ") entry_calls = observed_surface_calls( grid_expiries=np.asarray(market["expiries"][index]), extended_strikes=np.asarray(market["xstrikes"][index]), inner_calls=np.asarray(market["mids"][index]), query_expiries=expiries, query_strikes=relative_strikes, ) spot_ratio = float( market["spot_ref"][index + 1] / market["spot_ref"][index] ) exit_calls = observed_surface_calls( grid_expiries=np.asarray(market["expiries"][index + 1]), extended_strikes=np.asarray(market["xstrikes"][index + 1]), inner_calls=np.asarray(market["mids"][index + 1]), query_expiries=np.maximum(expiries - 1.0 / DAYS_PER_YEAR, 0.0), query_strikes=relative_strikes / spot_ratio, ) row: dict[str, Any] = { "state_index": index, "date": str(np.asarray(market["dates"])[index]), "next_market_date": str(np.asarray(market["dates"])[index + 1]), "surface_fit_error": fit_rows[index], "risk_aversions": {}, } for risk_aversion in risk_aversions: key = f"{risk_aversion:g}" action, optimizer = solve_mean_variance_portfolio( training_return, risk_aversion=risk_aversion, ) row["risk_aversions"][key] = { "portfolio": { "l1_norm": float(np.abs(action).sum()), "nonzero_positions": int( np.count_nonzero(np.abs(action) > 1.0e-10) ), "optimizer": optimizer, "action": action.tolist(), }, "model_training": _sample_summary( action, training_return, risk_aversion=risk_aversion, ), "model_validation": _sample_summary( action, validation_return, risk_aversion=risk_aversion, ), "realized": execute_frozen_action( action, spot_ratio=spot_ratio, entry_calls=entry_calls, exit_calls=exit_calls, cost_rate=0.0, ), } rows.append(row) if ordinal == 1 or ordinal % args.progress_every == 0 or index + 1 == stop: values = ", ".join( f"g={key}: {row['risk_aversions'][key]['realized']['net_pnl']:.6g}" for key in row["risk_aversions"] ) print( f"{ordinal:,}/{stop - start:,} {row['date']}: {values}", flush=True, ) if ordinal % args.checkpoint_every == 0: _atomic_json(args.output, report("running")) result = report("complete") _atomic_json(args.output, result) for key, aggregate in result["aggregate"].items(): pnl = aggregate["realized_trade_pnl"] print( f"gamma={key}: mean={pnl['mean']:.8g}, median={pnl['median']:.8g}", flush=True, ) print(f"output={args.output}", flush=True)
if __name__ == "__main__": main()