"""Run fixed-L1-radius utility continuation for conditional arbitrage."""
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 filelock import FileLock
from scipy.special import logsumexp
from quantdata.torch import BaseEnvironment
from .arb_tracing import (
fit_physical_state_whitener,
tracing_numerical_band,
tracing_utility_objective,
weighted_quantile,
)
from .norm_continuation import (
NormContinuationAction,
NormContinuationConfig,
NormContinuationTrainConfig,
NormContinuationUtility,
clipped_radius_pnl_derivative,
continuation_loss,
continuation_pnl,
exterior_l1_penalty,
radial_l1_clip,
)
from .required_runs import RequiredCase
from .run_expiry_arbitrage_experiments import (
_DEFAULT_CACHE_ROOT,
DeviceExpiryCase,
_load_case,
_to_device,
)
_DEFAULT_OUTPUT_ROOT = Path(
"quantdata/dysanos/grid/gendysanos/reports/norm-continuation"
)
_DEFAULT_CHECKPOINT_ROOT = Path(
"/media/storage/tmp/quantdata/dysanos/norm-continuation/checkpoints"
)
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 _atomic_torch_save(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:
torch.save(value, temporary)
os.replace(temporary, path)
finally:
temporary.unlink(missing_ok=True)
def _weighted_mean_error(
values: np.ndarray, normalized_weight: np.ndarray
) -> tuple[float, float]:
mean = float(np.dot(normalized_weight, values))
error = float(
np.sqrt(np.sum(np.square(normalized_weight * (values - mean))))
)
return mean, error
def _batch_loss(
model: NormContinuationAction,
data: DeviceExpiryCase,
indices: torch.Tensor,
*,
radius: float | torch.Tensor,
) -> tuple[torch.Tensor, dict[str, torch.Tensor]]:
return continuation_loss(
model,
data.state[indices],
data.returns[indices],
data.costs[indices],
data.path_weight[indices],
radius=radius,
)
def _checkpoint(
path: Path,
*,
model: NormContinuationAction,
optimizer: torch.optim.Optimizer,
generator: torch.Generator,
radius_index: int,
radius: float,
step: int,
tracker: list[dict[str, Any]],
completed: bool,
) -> None:
device = torch.device(model.device)
_atomic_torch_save(
path,
{
"model_code_version": NormContinuationConfig.version.unique_id48,
"user_version": model.config.user_version,
"radius_index": radius_index,
"radius": radius,
"model": model.state_dict(),
"optimizer": optimizer.state_dict(),
"step": step,
"tracker": tracker,
"completed": completed,
"torch_rng_state": torch.get_rng_state(),
"cuda_rng_state": (
torch.cuda.get_rng_state(device) if device.type == "cuda" else None
),
"batch_generator_state": generator.get_state(),
},
)
def _parameter_gradient_norms(
model: NormContinuationAction, *, objective_count: int
) -> list[float]:
result: list[float] = []
for network in model.networks:
gradients = [
parameter.grad.detach().reshape(-1)
for parameter in network.parameters()
if parameter.grad is not None
]
flat = (
torch.cat(gradients)
if gradients
else torch.zeros(1, dtype=model.fdtype, device=model.device)
)
flat = objective_count * flat
if not torch.isfinite(flat).all().item():
raise FloatingPointError("continuation parameter gradient is non-finite")
result.append(float(torch.linalg.vector_norm(flat).cpu()))
return result
def _gradient_diagnostics(
model: NormContinuationAction,
data: DeviceExpiryCase,
indices: torch.Tensor,
*,
radius: float,
sample_paths: int,
) -> dict[str, Any]:
"""Separate economic, projection, penalty, and parameter gradients."""
sample = indices[: min(sample_paths, indices.numel())]
state = data.state[sample]
returns = data.returns[sample]
costs = data.costs[sample]
weight = data.path_weight[sample]
times = model.config.trading_times
model.zero_grad(set_to_none=True)
total_loss, values = continuation_loss(
model, state, returns, costs, weight, radius=radius
)
total_loss.backward()
total_parameter_norm = _parameter_gradient_norms(model, objective_count=times)
model.zero_grad(set_to_none=True)
action, raw_l1, clipped = model(state, radius)
pnl = continuation_pnl(action, returns, costs)
objective = tracing_utility_objective(
pnl,
weight,
utility=model.config.utility,
risk_aversion=model.config.risk_aversion,
)
utility_loss = -objective.mean()
utility_loss.backward()
utility_parameter_norm = _parameter_gradient_norms(model, objective_count=times)
model.zero_grad(set_to_none=True)
_, penalty_raw_l1, _ = model(state, radius)
penalty_loss = (
model.config.exterior_penalty
* exterior_l1_penalty(penalty_raw_l1, radius).mean()
)
penalty_loss.backward()
penalty_parameter_norm = _parameter_gradient_norms(model, objective_count=times)
model.zero_grad(set_to_none=True)
raw = model.raw_action(state).detach().requires_grad_(True)
projected, diagnostic_raw_l1, diagnostic_clipped = radial_l1_clip(raw, radius)
diagnostic_pnl = continuation_pnl(projected, returns, costs)
diagnostic_objective = tracing_utility_objective(
diagnostic_pnl,
weight,
utility=model.config.utility,
risk_aversion=model.config.risk_aversion,
)
raw_utility_gradient = torch.autograd.grad(
-diagnostic_objective.mean(), raw, retain_graph=True
)[0]
raw_penalty_gradient = torch.autograd.grad(
model.config.exterior_penalty
* exterior_l1_penalty(diagnostic_raw_l1, radius).mean(),
raw,
retain_graph=True,
)[0]
action_leaf = projected.detach().requires_grad_(True)
action_pnl = continuation_pnl(action_leaf, returns, costs)
action_objective = tracing_utility_objective(
action_pnl,
weight,
utility=model.config.utility,
risk_aversion=model.config.risk_aversion,
)
action_utility_gradient = torch.autograd.grad(-action_objective.mean(), action_leaf)[0]
radial_scale = torch.ones(
times, dtype=projected.dtype, device=projected.device, requires_grad=True
)
scaled_action = projected.detach() * radial_scale[None, :, None, None]
scaled_pnl = continuation_pnl(scaled_action, returns, costs)
scaled_objective = tracing_utility_objective(
scaled_pnl,
weight,
utility=model.config.utility,
risk_aversion=model.config.risk_aversion,
)
radial_objective_derivative = torch.autograd.grad(
scaled_objective.sum(), radial_scale
)[0]
radius_pnl_derivative = clipped_radius_pnl_derivative(
diagnostic_pnl, diagnostic_clipped, radius
)
radius_scale = torch.ones(
times,
dtype=diagnostic_pnl.dtype,
device=diagnostic_pnl.device,
requires_grad=True,
)
radius_linearization = diagnostic_pnl.detach() + (
radius_scale[None, :] - 1.0
) * radius_pnl_derivative.detach()
radius_objective = tracing_utility_objective(
radius_linearization,
weight,
utility=model.config.utility,
risk_aversion=model.config.risk_aversion,
)
frozen_network_radius_derivative = torch.autograd.grad(
radius_objective.sum(), radius_scale
)[0]
def tensor_norm_by_time(value: torch.Tensor) -> list[float]:
flattened = value.transpose(0, 1).reshape(times, -1)
return torch.linalg.vector_norm(flattened, dim=1).cpu().tolist()
def tensor_max_by_time(value: torch.Tensor) -> list[float]:
flattened = value.transpose(0, 1).reshape(times, -1)
return flattened.abs().amax(dim=1).cpu().tolist()
raw_norm = tensor_norm_by_time(raw_utility_gradient)
action_norm = tensor_norm_by_time(action_utility_gradient)
transmission = [
raw_value / action_value if action_value > 0.0 else 0.0
for raw_value, action_value in zip(raw_norm, action_norm, strict=True)
]
finfo = torch.finfo(pnl.dtype)
positive_exponential_underflow = (
(pnl > 0.0)
& (model.config.risk_aversion * pnl > -math.log(finfo.tiny))
)
return {
"sample_paths": int(sample.numel()),
"radius": radius,
"loss": float(total_loss.detach().cpu()),
"objective_by_time": values["objective"].detach().cpu().tolist(),
"exterior_penalty_by_time": values["penalty"].detach().cpu().tolist(),
"clipped_fraction_by_time": clipped.float().mean(dim=0).detach().cpu().tolist(),
"raw_l1_maximum_by_time": raw_l1.amax(dim=0).detach().cpu().tolist(),
"total_parameter_gradient_l2_by_time": total_parameter_norm,
"utility_parameter_gradient_l2_by_time": utility_parameter_norm,
"penalty_parameter_gradient_l2_by_time": penalty_parameter_norm,
"raw_utility_gradient_l2_by_time": raw_norm,
"raw_utility_gradient_maximum_absolute_by_time": tensor_max_by_time(
raw_utility_gradient
),
"raw_penalty_gradient_l2_by_time": tensor_norm_by_time(
raw_penalty_gradient
),
"action_space_utility_gradient_l2_by_time": action_norm,
"projection_gradient_transmission_ratio_by_time": transmission,
"multiplicative_action_scale_objective_derivative_by_time": (
radial_objective_derivative.detach().cpu().tolist()
),
"frozen_network_radius_objective_derivative_by_time": (
frozen_network_radius_derivative.detach().cpu().tolist()
),
"raw_utility_gradient_exact_zero_fraction": float(
(raw_utility_gradient == 0.0).float().mean().cpu()
),
"action_space_gradient_exact_zero_fraction": float(
(action_utility_gradient == 0.0).float().mean().cpu()
),
"positive_marginal_exponential_underflow_fraction": float(
positive_exponential_underflow.float().mean().cpu()
),
"maximum_risk_adjusted_pnl": float(
(model.config.risk_aversion * pnl).amax().detach().cpu()
),
"minimum_risk_adjusted_pnl": float(
(model.config.risk_aversion * pnl).amin().detach().cpu()
),
"diagnostic_clipped_fraction": float(
diagnostic_clipped.float().mean().detach().cpu()
),
}
def _train_radius(
model: NormContinuationAction,
callable_model: NormContinuationAction,
data: DeviceExpiryCase,
*,
radius_index: int,
radius: float,
train_config: NormContinuationTrainConfig,
checkpoint_path: Path,
) -> dict[str, Any]:
device = torch.device(model.device)
optimizer = torch.optim.AdamW(
model.parameters(),
lr=train_config.lr,
weight_decay=train_config.weight_decay,
)
generator = torch.Generator(device=model.device)
generator.manual_seed(train_config.seed + radius_index)
tracker: list[dict[str, Any]] = []
start_step = 0
if checkpoint_path.exists():
saved = torch.load(checkpoint_path, map_location=model.device, weights_only=False)
compatible = (
saved.get("model_code_version")
== NormContinuationConfig.version.unique_id48
and saved.get("user_version") == model.config.user_version
and saved.get("radius_index") == radius_index
and saved.get("radius") == radius
)
if compatible:
model.load_state_dict(saved["model"])
optimizer.load_state_dict(saved["optimizer"])
start_step = int(saved["step"])
tracker = list(saved.get("tracker", []))
torch.set_rng_state(saved["torch_rng_state"].cpu())
if device.type == "cuda" and saved.get("cuda_rng_state") is not None:
torch.cuda.set_rng_state(saved["cuda_rng_state"].cpu(), device)
generator.set_state(saved["batch_generator_state"].cpu())
print(
f"Warm-started radius n={radius:g} from step {start_step:,}.",
flush=True,
)
if bool(saved.get("completed")):
return {
"steps": start_step,
"converged": bool(saved.get("converged", True)),
"resumed_complete_checkpoint": True,
"elapsed_seconds_this_invocation": 0.0,
"tracker": tracker,
}
else:
print("Continuation checkpoint version changed; cold-starting stage.", flush=True)
fixed_generator = torch.Generator(device=model.device)
fixed_generator.manual_seed(train_config.seed + 10_000 + radius_index)
fixed_draw = torch.randperm(
data.reference.numel(), generator=fixed_generator, device=model.device
)[: min(train_config.valuation_batch_size, data.reference.numel())]
fixed = data.reference[fixed_draw]
compiled_radius = torch.as_tensor(
radius, dtype=model.fdtype, device=model.device
)
started = time.monotonic()
converged = False
if device.type == "cuda":
torch.cuda.reset_peak_memory_stats(device)
for step in range(start_step + 1, train_config.epochs_per_radius + 1):
draw = torch.randint(
data.reference.numel(),
(train_config.batch_size,),
generator=generator,
device=model.device,
)
indices = data.reference[draw]
optimizer.zero_grad(set_to_none=True)
loss, _ = _batch_loss(
callable_model, data, indices, radius=compiled_radius
)
loss.backward()
for parameter in model.parameters():
if parameter.grad is not None and not torch.isfinite(parameter.grad).all().item():
raise FloatingPointError("continuation gradient became NaN or infinity")
optimizer.step()
if step % train_config.value_update == 0 or step == train_config.epochs_per_radius:
with torch.no_grad():
fixed_loss, values = _batch_loss(model, data, fixed, radius=radius)
item = {
"step": step,
"elapsed_seconds": time.monotonic() - started,
"loss": float(fixed_loss.cpu()),
"objective_by_time": values["objective"].cpu().tolist(),
"exterior_penalty_by_time": values["penalty"].cpu().tolist(),
"action_l1_mean_by_time": values["action_l1_mean"].cpu().tolist(),
"action_l1_maximum_by_time": values["action_l1_maximum"].cpu().tolist(),
"raw_l1_mean_by_time": values["raw_l1_mean"].cpu().tolist(),
"raw_l1_maximum_by_time": values["raw_l1_maximum"].cpu().tolist(),
"clipped_fraction_by_time": values["clipped_fraction"].cpu().tolist(),
}
tracker.append(item)
recent = tracker[-train_config.convergence_points :]
if (
step >= train_config.minimum_epochs_per_radius
and len(recent) == train_config.convergence_points
):
recent_loss = np.asarray(
[point["loss"] for point in recent], dtype=np.float64
)
scale = max(1.0e-8, float(np.max(np.abs(recent_loss))))
converged = bool(
np.ptp(recent_loss)
<= train_config.convergence_relative_tolerance * scale
)
print(
f"[n={radius:g}] step {step:,}: loss={item['loss']:.8g}, "
f"action L1 max={max(item['action_l1_maximum_by_time']):.5g}, "
f"raw L1 max={max(item['raw_l1_maximum_by_time']):.5g}, "
f"clipped={max(item['clipped_fraction_by_time']):.1%}, "
f"converged={converged}",
flush=True,
)
if step % train_config.checkpoint_update == 0:
_checkpoint(
checkpoint_path,
model=model,
optimizer=optimizer,
generator=generator,
radius_index=radius_index,
radius=radius,
step=step,
tracker=tracker,
completed=False,
)
if converged:
break
final_step = tracker[-1]["step"] if tracker else start_step
_checkpoint(
checkpoint_path,
model=model,
optimizer=optimizer,
generator=generator,
radius_index=radius_index,
radius=radius,
step=final_step,
tracker=tracker,
completed=True,
)
# Persist convergence explicitly without changing the checkpoint schema
# required for warm-starting older partial stages.
saved = torch.load(checkpoint_path, map_location="cpu", weights_only=False)
saved["converged"] = converged
_atomic_torch_save(checkpoint_path, saved)
return {
"steps": final_step,
"converged": converged,
"resumed_complete_checkpoint": False,
"elapsed_seconds_this_invocation": time.monotonic() - started,
"peak_gpu_memory_bytes": (
int(torch.cuda.max_memory_allocated(device)) if device.type == "cuda" else 0
),
"constant_learning_rate": train_config.lr,
"gradient_clipping": False,
"optimizer_reset_at_radius_start": True,
"tracker": tracker,
}
@torch.no_grad()
def _evaluate_split(
model: NormContinuationAction,
data: DeviceExpiryCase,
indices: torch.Tensor,
*,
radius: float,
batch_size: int,
) -> dict[str, Any]:
paths = int(indices.numel())
times = model.config.trading_times
pnl = np.empty((paths, times), dtype=np.float64)
band = np.empty_like(pnl)
action_l1 = np.empty((paths, times), dtype=np.float32)
raw_l1 = np.empty_like(action_l1)
clipped = np.empty((paths, times), dtype=bool)
for start in range(0, paths, batch_size):
stop = min(paths, start + batch_size)
batch = indices[start:stop]
action, batch_raw_l1, batch_clipped = model(data.state[batch], radius)
batch_pnl = continuation_pnl(action, data.returns[batch], data.costs[batch])
pnl[start:stop] = batch_pnl.cpu().double().numpy()
band[start:stop] = tracing_numerical_band(
action,
data.returns[batch],
data.costs[batch],
data.numerical_band[batch],
).cpu().double().numpy()
action_l1[start:stop] = action.abs().sum(dim=(-1, -2)).cpu().numpy()
raw_l1[start:stop] = batch_raw_l1.cpu().numpy()
clipped[start:stop] = batch_clipped.cpu().numpy()
weight = data.path_weight[indices].cpu().double().numpy()
component = data.component[indices].cpu().numpy()
normalized_weight = weight / weight.sum()
direct = component == 0
reports: list[dict[str, Any]] = []
for time_index in range(times):
value = pnl[:, time_index]
tolerance = band[:, time_index]
loss = value < -tolerance
gain = value > tolerance
mean, mean_error = _weighted_mean_error(value, normalized_weight)
loss_probability, loss_error = _weighted_mean_error(
loss.astype(np.float64), normalized_weight
)
gain_probability, gain_error = _weighted_mean_error(
gain.astype(np.float64), normalized_weight
)
if model.config.utility == "entropy":
log_weight = np.log(normalized_weight)
log_tilt = log_weight - model.config.risk_aversion * value
objective = -logsumexp(log_tilt) / model.config.risk_aversion
log_tilt -= logsumexp(log_tilt)
marginal_weight = np.exp(log_tilt)
marginal = marginal_weight / normalized_weight
else:
positive = np.maximum(value, 0.0)
negative = np.minimum(value, 0.0)
utility_value = np.where(
value > 0.0,
-np.expm1(-model.config.risk_aversion * positive)
/ model.config.risk_aversion,
negative
- 0.5 * model.config.risk_aversion * np.square(negative),
)
marginal = np.where(
value > 0.0,
np.exp(-model.config.risk_aversion * positive),
1.0 - model.config.risk_aversion * negative,
)
objective = float(np.dot(normalized_weight, utility_value))
marginal_weight = normalized_weight * marginal
marginal_weight /= marginal_weight.sum()
radial_derivative, radial_error = _weighted_mean_error(
value, marginal_weight
)
radius_derivative, radius_derivative_error = _weighted_mean_error(
clipped[:, time_index] * value / radius,
marginal_weight,
)
direct_radius_derivative, direct_radius_derivative_error = (
_weighted_mean_error(
marginal * clipped[:, time_index] * value / radius,
normalized_weight,
)
)
reports.append(
{
"trading_time_index": time_index,
"objective": float(objective),
"P_mean_pnl": mean,
"P_mean_pnl_standard_error": mean_error,
"P_loss_probability": loss_probability,
"P_loss_probability_standard_error": loss_error,
"P_gain_probability": gain_probability,
"P_gain_probability_standard_error": gain_error,
"P_pnl_01_quantile": weighted_quantile(value, weight, 0.01),
"P_pnl_05_quantile": weighted_quantile(value, weight, 0.05),
"P_pnl_median": weighted_quantile(value, weight, 0.50),
"proposal_minimum_pnl_plus_band": float(np.min(value + tolerance)),
"direct_P_paths": int(direct.sum()),
"direct_P_loss_count": int(np.sum(loss & direct)),
"direct_P_gain_count": int(np.sum(gain & direct)),
"action_l1_P_median": weighted_quantile(
action_l1[:, time_index], weight, 0.50
),
"action_l1_P_99_percentile": weighted_quantile(
action_l1[:, time_index], weight, 0.99
),
"action_l1_proposal_maximum": float(
action_l1[:, time_index].max()
),
"raw_l1_P_99_percentile": weighted_quantile(
raw_l1[:, time_index], weight, 0.99
),
"raw_l1_proposal_maximum": float(raw_l1[:, time_index].max()),
"P_clipped_fraction": float(
np.dot(normalized_weight, clipped[:, time_index])
),
"proposal_clipped_fraction": float(clipped[:, time_index].mean()),
"normalized_radial_objective_derivative": radial_derivative,
"normalized_radial_objective_derivative_standard_error": radial_error,
"normalized_frozen_network_radius_objective_derivative": (
radius_derivative
),
"normalized_frozen_network_radius_objective_derivative_standard_error": (
radius_derivative_error
),
"frozen_network_radius_objective_derivative": (
direct_radius_derivative
),
"frozen_network_radius_objective_derivative_standard_error": (
direct_radius_derivative_error
),
"marginal_density_effective_sample_size": float(
1.0 / np.square(marginal_weight).sum()
),
"positive_marginal_exponential_underflow_fraction": float(
np.mean(
(value > 0.0)
& (
model.config.risk_aversion * value
> -math.log(np.finfo(np.float32).tiny)
)
)
),
}
)
return {
"paths": paths,
"direct_P_paths": int(direct.sum()),
"physical_weight_mean_before_split_normalization": float(weight.mean()),
"physical_weight_effective_sample_size": float(
np.square(weight.sum()) / np.square(weight).sum()
),
"times": reports,
}
[docs]
def run(args: argparse.Namespace) -> dict[str, Any]:
radii = tuple(float(radius) for radius in args.radii)
case = RequiredCase(
generator=args.generator,
trading_frequency="weekly",
return_horizon="expiry",
hedge="delta",
cost_rate=1.0e-4,
path_count=args.paths,
)
utility: NormContinuationUtility = args.utility
loaded = _load_case(case, cache_root=Path(args.cache_root), need_primitives=False)
source_cache = str(loaded.source_cache)
source_cache_uid = loaded.source_cache_uid
env = BaseEnvironment(precision=args.precision, device=args.device, debug=args.debug)
device = torch.device(env.device)
data, split_diagnostics = _to_device(loaded, case=case, env=env)
del loaded
gc.collect()
if device.type == "cuda":
torch.cuda.synchronize(device)
state_mean, state_whitener, whitening = fit_physical_state_whitener(
data.state,
data.path_weight,
data.reference,
relative_eigenvalue_floor=args.covariance_relative_floor,
)
label = (
f"norm-continuation-{utility}-g{args.risk_aversion:.0e}-"
f"{case.generator}-{case.path_count}"
)
model_config = NormContinuationConfig(
label=label,
source_cache_uid=source_cache_uid,
group=(
f"gendysanos/norm-continuation/{case.generator}/{utility}/"
f"gamma-{args.risk_aversion:.0e}/{case.path_count}"
),
user_version=args.user_version,
state_features=data.state.shape[-1],
risk_aversion=args.risk_aversion,
utility=utility,
radii=radii,
exterior_penalty=args.exterior_penalty,
covariance_relative_floor=args.covariance_relative_floor,
)
train_config = NormContinuationTrainConfig(
batch_size=args.batch_size,
valuation_batch_size=args.valuation_batch_size,
epochs_per_radius=args.epochs_per_radius,
minimum_epochs_per_radius=args.minimum_epochs_per_radius,
value_update=args.value_update,
checkpoint_update=args.checkpoint_update,
lr=args.lr,
compile=not args.no_compile,
convergence_points=args.convergence_points,
convergence_relative_tolerance=args.convergence_relative_tolerance,
seed=args.seed,
)
model = NormContinuationAction(
env,
config=model_config,
state_mean=state_mean,
state_whitener=state_whitener,
)
callable_model = torch.compile(model, dynamic=False) if train_config.compile else model
report_path = Path(args.output_root) / f"{label}.json"
checkpoint_directory = Path(args.checkpoint_root) / model_config.group
stages: list[dict[str, Any]] = []
started = time.monotonic()
for radius_index, radius in enumerate(radii):
checkpoint_path = checkpoint_directory / (
f"{model_config.filename}-radius-{radius_index + 1}.pt"
)
with FileLock(str(checkpoint_path) + ".lock"):
pre_training_gradient = _gradient_diagnostics(
model,
data,
data.reference,
radius=radius,
sample_paths=args.gradient_paths,
)
training = _train_radius(
model,
callable_model,
data,
radius_index=radius_index,
radius=radius,
train_config=train_config,
checkpoint_path=checkpoint_path,
)
training_set = _evaluate_split(
model,
data,
data.reference,
radius=radius,
batch_size=args.valuation_batch_size,
)
validation_set = _evaluate_split(
model,
data,
data.validation,
radius=radius,
batch_size=args.valuation_batch_size,
)
post_training_gradient = {
"training": _gradient_diagnostics(
model,
data,
data.reference,
radius=radius,
sample_paths=args.gradient_paths,
),
"validation": _gradient_diagnostics(
model,
data,
data.validation,
radius=radius,
sample_paths=args.gradient_paths,
),
}
stage = {
"radius_index": radius_index + 1,
"radius": radius,
"pre_training_gradient": pre_training_gradient,
"training": training,
"training_set": training_set,
"validation_set": validation_set,
"post_training_gradient": post_training_gradient,
"checkpoint": str(checkpoint_path),
}
stages.append(stage)
_atomic_json(
report_path,
{
"status": "running",
"schema_version": "1.0",
"experiment": "fixed L1 norm continuation",
"configuration": asdict(case),
"model_config": asdict(model_config),
"train_config": asdict(train_config),
"stages": stages,
},
)
train_gradient = post_training_gradient["training"]
print(
f"Completed n={radius:g}: clipped="
f"{max(item['P_clipped_fraction'] for item in training_set['times']):.1%}, "
f"min raw utility |grad|="
f"{min(train_gradient['raw_utility_gradient_l2_by_time']):.3g}, "
f"marginal underflow="
f"{train_gradient['positive_marginal_exponential_underflow_fraction']:.1%}",
flush=True,
)
final_gradients = [
stage["post_training_gradient"]["training"] for stage in stages
]
report = {
"status": "complete",
"schema_version": "1.0",
"experiment": "fixed L1 norm continuation",
"definition": {
"objective": (
"maximize E_P[u(a_t(x_t)'dH_t-|a_t(x_t)|'c_t)] separately "
"for each trading time, jointly over all expiries"
),
"projection": "a_n(v)=v min(1,n/||v||_1)",
"exterior_penalty": (
"rho E[(||v||_1-n)_+^2]; excluded from the economic objective"
),
"continuation": (
"warm-start the same action network at each increasing radius; "
"reset AdamW moments at each radius"
),
"gradient_diagnostics": (
"separate action-space utility, projected raw-output utility, "
"exterior-penalty, total parameter, and radial-scale derivatives"
),
},
"configuration": asdict(case),
"source_cache": source_cache,
"source_cache_uid": source_cache_uid,
"split": split_diagnostics,
"model_config": asdict(model_config),
"train_config": asdict(train_config),
"whitening": whitening,
"stages": stages,
"summary": {
"minimum_final_raw_utility_gradient_l2_by_radius": [
min(value["raw_utility_gradient_l2_by_time"])
for value in final_gradients
],
"maximum_final_raw_utility_gradient_l2_by_radius": [
max(value["raw_utility_gradient_l2_by_time"])
for value in final_gradients
],
"raw_utility_gradient_exact_zero_fraction_by_radius": [
value["raw_utility_gradient_exact_zero_fraction"]
for value in final_gradients
],
"positive_marginal_exponential_underflow_fraction_by_radius": [
value["positive_marginal_exponential_underflow_fraction"]
for value in final_gradients
],
},
"runtime_seconds": time.monotonic() - started,
"device": str(env.device),
"peak_gpu_memory_bytes": (
int(torch.cuda.max_memory_allocated(device)) if device.type == "cuda" else 0
),
}
_atomic_json(report_path, report)
print(f"Completed {label}; report={report_path}", flush=True)
return report
def _parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--generator", choices=("dysanos", "pca-iv"), required=True)
parser.add_argument("--utility", choices=("powerexp", "entropy"), required=True)
parser.add_argument("--risk-aversion", type=float, default=100.0)
parser.add_argument("--paths", type=int, default=100_000)
parser.add_argument("--device", choices=("cpu", "cuda:0", "cuda:1", "cuda:2"), required=True)
parser.add_argument("--precision", type=int, choices=(32, 64), default=32)
parser.add_argument(
"--radii",
type=float,
nargs="+",
default=[0.25, 0.5, 1.0, 2.0, 4.0, 8.0, 16.0],
)
parser.add_argument("--exterior-penalty", type=float, default=1.0e-3)
parser.add_argument("--epochs-per-radius", type=int, default=10_000)
parser.add_argument("--minimum-epochs-per-radius", type=int, default=1_500)
parser.add_argument("--batch-size", type=int, default=4_096)
parser.add_argument("--valuation-batch-size", type=int, default=16_384)
parser.add_argument("--gradient-paths", type=int, default=16_384)
parser.add_argument("--value-update", type=int, default=250)
parser.add_argument("--checkpoint-update", type=int, default=2_000)
parser.add_argument("--lr", type=float, default=3.0e-4)
parser.add_argument("--convergence-points", type=int, default=10)
parser.add_argument("--convergence-relative-tolerance", type=float, default=1.0e-4)
parser.add_argument("--covariance-relative-floor", type=float, default=1.0e-10)
parser.add_argument("--seed", type=int, default=94_103)
parser.add_argument("--user-version", default="0.1")
parser.add_argument("--cache-root", default=str(_DEFAULT_CACHE_ROOT))
parser.add_argument("--output-root", default=str(_DEFAULT_OUTPUT_ROOT))
parser.add_argument("--checkpoint-root", default=str(_DEFAULT_CHECKPOINT_ROOT))
parser.add_argument("--no-compile", action="store_true")
parser.add_argument("--debug", action="store_true")
return parser
if __name__ == "__main__":
run(_parser().parse_args())