"""Construct capped empirical densities for the conditional time-six market."""
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 torch import Tensor
from quantdata.torch import BaseEnvironment
from .arb_tracing import fit_physical_state_whitener
from .required_runs import RequiredCase
from .run_case_c import _fit_kernel_basis
from .run_expiry_arbitrage_experiments import _DEFAULT_CACHE_ROOT, _load_case, _to_device
from .run_parallel_direction_comparison import (
_select_times_and_fold,
_to_itm_dollar_portfolio,
)
_DEFAULT_OUTPUT_ROOT = Path(
"quantdata/dysanos/grid/gendysanos/reports/implied-cvar"
)
_DEFAULT_DENSITY_ROOT = Path(
"/media/storage/tmp/quantdata/dysanos/implied-cvar/densities"
)
[docs]
@torch.no_grad()
def project_weighted_capped_density_(
density: Tensor,
probability: Tensor,
density_cap: float,
*,
iterations: int = 48,
) -> None:
"""Project in weighted L2 onto ``E_p[D]=1`` and ``0<=D<=cap``."""
assert density.ndim == probability.ndim == 1 and density.shape == probability.shape
assert density_cap >= 1.0 and torch.all(probability > 0.0)
lower = torch.min(density - density_cap)
upper = torch.max(density)
for _ in range(iterations):
midpoint = 0.5 * (lower + upper)
mean = torch.dot(probability, torch.clamp(density - midpoint, 0.0, density_cap))
lower = torch.where(mean > 1.0, midpoint, lower)
upper = torch.where(mean > 1.0, upper, midpoint)
density.copy_(torch.clamp(density - 0.5 * (lower + upper), 0.0, density_cap))
# Remove the final float32 normalization error without violating the cap.
error = 1.0 - torch.dot(probability, density)
if torch.abs(error) > 16.0 * torch.finfo(density.dtype).eps:
if error > 0.0:
room = density < density_cap
else:
room = density > 0.0
correction_mass = probability[room].sum()
density[room] += error / correction_mass
density.clamp_(0.0, density_cap)
[docs]
def conditional_moments(
density: Tensor,
probability: Tensor,
kernel_weight: Tensor,
returns: Tensor,
) -> Tensor:
"""Return ``E_p[D phi_k R_j]`` for every kernel and instrument."""
assert density.shape == probability.shape == returns.shape[:1]
assert kernel_weight.shape[0] == returns.shape[0]
weighted_return = probability[:, None] * density[:, None] * returns
return kernel_weight.mT @ weighted_return
[docs]
def fit_entropy_density(
probability: Tensor,
kernel_weight: Tensor,
returns: Tensor,
*,
max_iter: int,
) -> tuple[Tensor, dict[str, Any]]:
"""Find an uncapped exponential-family density with zero kernel moments."""
theta = torch.nn.Parameter(
torch.zeros(
(kernel_weight.shape[1], returns.shape[1]),
dtype=returns.dtype,
device=returns.device,
)
)
optimizer = torch.optim.LBFGS(
(theta,),
lr=1.0,
max_iter=max_iter,
tolerance_grad=1.0e-12,
tolerance_change=1.0e-15,
history_size=20,
line_search_fn="strong_wolfe",
)
log_probability = torch.log(probability)
evaluations = 0
def closure() -> Tensor:
nonlocal evaluations
optimizer.zero_grad(set_to_none=True)
score = (returns @ theta.mT * kernel_weight).sum(dim=-1)
log_normalizer = torch.logsumexp(log_probability + score, dim=0)
log_normalizer.backward()
evaluations += 1
return log_normalizer
started = time.monotonic()
optimizer.step(closure)
with torch.no_grad():
score = (returns @ theta.mT * kernel_weight).sum(dim=-1)
log_normalizer = torch.logsumexp(log_probability + score, dim=0)
density = torch.exp(score - log_normalizer)
moment = conditional_moments(
density, probability, kernel_weight, returns
)
support = moment.abs().amax(dim=-1).sum()
if not torch.isfinite(density).all().item():
raise FloatingPointError("entropy initializer produced a non-finite density")
return density, {
"definition": "D is proportional to exp(sum_k phi_k(x) theta_k^T R)",
"evaluations": evaluations,
"elapsed_seconds": time.monotonic() - started,
"weighted_mean_density": float(torch.dot(probability, density).item()),
"minimum_density": float(density.min().item()),
"maximum_density": float(density.max().item()),
"conditional_OCE_maximum_upper_bound": float(support.item()),
}
@torch.no_grad()
def _kernel_weights(
state: Tensor,
*,
state_mean: Tensor,
state_whitener: Tensor,
centers: Tensor,
inverse_bandwidth: Tensor,
batch_size: int,
) -> Tensor:
result = torch.empty(
(state.shape[0], centers.shape[0]), dtype=state.dtype, device=state.device
)
for start in range(0, state.shape[0], batch_size):
stop = min(state.shape[0], start + batch_size)
factor = (state[start:stop] - state_mean[None]) @ state_whitener
distance_square = (
factor[:, None, :] - centers[None, :, :]
).square().sum(dim=-1)
result[start:stop] = torch.softmax(
-0.5 * distance_square * inverse_bandwidth.square()[None], dim=-1
)
return result
def _fit_one_cap(
initial_density: Tensor,
*,
density_cap: float,
probability: Tensor,
kernel_weight: Tensor,
returns: Tensor,
moment_scale: Tensor,
steps: int,
batch_size: int,
learning_rate: float,
value_update: int,
tolerance: float,
) -> tuple[Tensor, dict[str, Any]]:
density = torch.nn.Parameter(initial_density.detach().clone())
project_weighted_capped_density_(density, probability, density_cap)
verify_inp(
batch_size == density.shape[0],
lambda: (
"the monotone weighted projected-gradient solve requires the full "
f"sample ({density.shape[0]}), got batch size {batch_size}"
),
)
tracker: list[dict[str, Any]] = []
consecutive = 0
started = time.monotonic()
step_size = learning_rate
for step in range(1, steps + 1):
density.grad = None
moment = conditional_moments(
density, probability, kernel_weight, returns
)
loss = 0.5 * torch.square(moment / moment_scale).sum()
loss.backward()
if density.grad is None or not torch.isfinite(density.grad).all().item():
raise FloatingPointError("conditional density gradient is non-finite")
# The projection uses the physical weighted L2 metric. Its matching
# gradient is the Euclidean autograd gradient divided by p.
direction = density.grad / probability
previous = density.detach().clone()
previous_loss = float(loss.item())
accepted = False
for _ in range(20):
with torch.no_grad():
density.copy_(previous - step_size * direction)
project_weighted_capped_density_(
density, probability, density_cap
)
candidate_moment = conditional_moments(
density, probability, kernel_weight, returns
)
candidate_loss = float(
(0.5 * torch.square(candidate_moment / moment_scale).sum()).item()
)
if candidate_loss <= previous_loss:
accepted = True
step_size *= 1.05
break
step_size *= 0.5
if not accepted:
with torch.no_grad():
density.copy_(previous)
step_size = max(step_size, torch.finfo(density.dtype).eps)
if step % value_update == 0 or step == steps:
with torch.no_grad():
raw_moment = conditional_moments(
density, probability, kernel_weight, returns
)
support = raw_moment.abs().amax(dim=-1).sum()
standardized_rms = torch.sqrt(
torch.square(raw_moment / moment_scale).mean()
)
mean_density = torch.dot(probability, density)
item = {
"step": step,
"conditional_OCE_maximum_upper_bound": float(support.item()),
"standardized_moment_RMS": float(standardized_rms.item()),
"weighted_mean_density": float(mean_density.item()),
"minimum_density": float(density.min().item()),
"maximum_density": float(density.max().item()),
"projected_gradient_step_size": step_size,
"elapsed_seconds": time.monotonic() - started,
}
tracker.append(item)
print(
f"cap={density_cap:g} step={step:,} "
f"upper={item['conditional_OCE_maximum_upper_bound']:.6g} "
f"std_rms={item['standardized_moment_RMS']:.6g}",
flush=True,
)
consecutive = consecutive + 1 if support <= tolerance else 0
if consecutive >= 3:
break
return density.detach(), {
"density_cap": density_cap,
"lambda": density_cap - 1.0,
"steps": step,
"converged": consecutive >= 3,
"tolerance": tolerance,
"tracker": tracker,
"final": tracker[-1],
}
[docs]
def run(args: argparse.Namespace) -> dict[str, Any]:
lambdas = tuple(float(value) for value in args.lambdas)
verify_inp(
bool(lambdas)
and all(math.isfinite(value) and value > 0.0 for value in lambdas)
and all(left < right for left, right in zip(lambdas, lambdas[1:])),
lambda: f"lambdas must be finite, positive, and increasing: {lambdas}",
)
torch.set_float32_matmul_precision("high")
case = RequiredCase(
generator=args.generator,
trading_frequency="weekly",
return_horizon="expiry",
hedge="raw",
cost_rate=0.0,
path_count=100_000,
)
loaded = _load_case(case, cache_root=Path(args.cache_root), need_primitives=True)
source_cache = str(loaded.source_cache)
source_cache_uid = loaded.source_cache_uid
env = BaseEnvironment(precision=32, device=args.device, debug=False)
full_data, source_split = _to_device(loaded, case=case, env=env)
del loaded
gc.collect()
data, _ = _select_times_and_fold(
full_data,
deterministic_time=0,
conditional_time=6,
fold=0,
seed=100_097,
)
del full_data
data, normalization = _to_itm_dollar_portfolio(
data, cost_rate=0.0, vector_barrier=False
)
all_indices = torch.arange(data.state.shape[0], device=env.device)
data.reference = all_indices
data.validation = all_indices
state_mean, state_whitener, whitening = fit_physical_state_whitener(
data.state,
data.path_weight,
all_indices,
relative_eigenvalue_floor=1.0e-10,
)
centers, inverse_bandwidth, kernel_basis = _fit_kernel_basis(
data,
state_mean=state_mean[1],
state_whitener=state_whitener[1],
kernels=args.kernels,
seed=args.seed,
)
kernel_weight = _kernel_weights(
data.state[:, 1],
state_mean=state_mean[1],
state_whitener=state_whitener[1],
centers=centers,
inverse_bandwidth=inverse_bandwidth,
batch_size=args.valuation_batch_size,
)
native_return = data.returns[:, 1]
returns = native_return.reshape(native_return.shape[0], -1)
probability = data.path_weight / data.path_weight.sum()
# The smallest proposal weights can underflow only when normalized in
# float32. Giving them the smallest normal mass is immaterial in total but
# preserves the strictly positive reference measure required by D=q/p.
probability = probability.clamp_min(torch.finfo(probability.dtype).tiny)
probability /= probability.sum()
if args.dual_precision == 64:
probability = probability.double()
kernel_weight = kernel_weight.double()
returns = returns.double()
moment_scale = torch.sqrt(
kernel_weight.square().mT
@ (probability[:, None] * returns.square())
).clamp_min(1.0e-8)
entropy_density, entropy = fit_entropy_density(
probability,
kernel_weight,
returns,
max_iter=args.entropy_steps,
)
print(f"Entropy density: {entropy}", flush=True)
density = torch.ones_like(probability)
fits: list[dict[str, Any]] = []
saved_density: Path | None = None
for head, lmbda in enumerate(lambdas):
entropy_start = entropy_density.clone()
project_weighted_capped_density_(
entropy_start, probability, 1.0 + lmbda
)
with torch.no_grad():
warm_loss = torch.square(
conditional_moments(
density, probability, kernel_weight, returns
)
/ moment_scale
).sum()
entropy_loss = torch.square(
conditional_moments(
entropy_start, probability, kernel_weight, returns
)
/ moment_scale
).sum()
if entropy_loss < warm_loss:
density = entropy_start
density, fit = _fit_one_cap(
density,
density_cap=1.0 + lmbda,
probability=probability,
kernel_weight=kernel_weight,
returns=returns,
moment_scale=moment_scale,
steps=args.steps,
batch_size=args.batch_size,
learning_rate=args.lr,
value_update=args.value_update,
tolerance=args.tolerance,
)
fits.append(fit)
if fit["converged"] and saved_density is None:
saved_density = (
Path(args.density_root)
/ f"{args.generator}-weekly-expiry-itm-dollar-t6-density.npz"
)
saved_density.parent.mkdir(parents=True, exist_ok=True)
np.savez_compressed(
saved_density,
density=density.cpu().double().numpy(),
probability=probability.cpu().double().numpy(),
)
minimum = next((fit["lambda"] for fit in fits if fit["converged"]), None)
report = {
"status": "complete",
"experiment": "conditional empirical CVaR density-cap upper bounds",
"definition": (
"For fixed normalized Gaussian state kernels phi_k, D is projected "
"onto E_p[D]=1 and 0<=D<=1+lambda. The upper bound on the maximum "
"conditional CVaR OCE is sum_k max_j |E_p[D phi_k R_j]|."
),
"configuration": asdict(case),
"lambdas": list(lambdas),
"source_cache": source_cache,
"source_cache_uid": source_cache_uid,
"source_split_unused_for_fitting": source_split,
"portfolio_normalization": normalization,
"whitening": whitening,
"kernel_basis": kernel_basis,
"entropy_density_initializer": entropy,
"independent_return_coordinates": int(returns.shape[1]),
"fits": fits,
"smallest_tested_lambda_certified_zero": minimum,
"density_path": None if saved_density is None else str(saved_density),
}
report_path = Path(args.output_root) / (
f"implied-cvar-{args.generator}-weekly-expiry-itm-dollar-t6-dual.json"
)
_atomic = report_path.with_name(f".{report_path.name}.{os.getpid()}.tmp")
report_path.parent.mkdir(parents=True, exist_ok=True)
_atomic.write_text(json.dumps(report, indent=2, allow_nan=False), encoding="utf-8")
os.replace(_atomic, report_path)
print(f"Completed conditional dual report {report_path}", flush=True)
return report
def _parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--generator", choices=("pca-iv", "dysanos"), required=True)
parser.add_argument("--device", choices=("cuda:0", "cuda:1", "cuda:2"), required=True)
parser.add_argument("--lambdas", nargs="+", type=float, default=(5, 6, 7, 8, 9, 10))
parser.add_argument("--kernels", type=int, default=64)
parser.add_argument("--steps", type=int, default=10_000)
parser.add_argument("--batch-size", type=int, default=100_000)
parser.add_argument("--valuation-batch-size", type=int, default=8_192)
parser.add_argument("--value-update", type=int, default=500)
parser.add_argument("--entropy-steps", type=int, default=300)
parser.add_argument("--lr", type=float, default=1.0e-2)
parser.add_argument("--tolerance", type=float, default=1.0e-6)
parser.add_argument("--dual-precision", type=int, choices=(32, 64), default=64)
parser.add_argument("--seed", type=int, default=283_091)
parser.add_argument("--cache-root", default=str(_DEFAULT_CACHE_ROOT))
parser.add_argument("--output-root", default=str(_DEFAULT_OUTPUT_ROOT))
parser.add_argument("--density-root", default=str(_DEFAULT_DENSITY_ROOT))
return parser
if __name__ == "__main__":
run(_parser().parse_args())