"""Run a small compiled-GPU mechanics test for conditional tail quantiles."""
from __future__ import annotations
import argparse
import json
import math
import os
from pathlib import Path
from typing import Any
import torch
from quantdata.torch import BaseEnvironment, DeviceLock
from quantdata.torch.ffw import FeedForwardConfig
from .conditional_tail import (
ConditionalTailConfig,
ConditionalTailQuantileModel,
signed_returns,
)
from .direct_arbitrage import state_normalization
def _memory(device: torch.device) -> dict[str, float]:
output: dict[str, float] = {}
with Path("/proc/self/status").open(encoding="utf-8") as stream:
for line in stream:
name, _, value = line.partition(":")
if name in {"VmRSS", "VmHWM"}:
output[{"VmRSS": "rss_gib", "VmHWM": "peak_rss_gib"}[name]] = (
float(value.split()[0]) / 1024.0**2
)
if device.type == "cuda":
output.update(
cuda_peak_allocated_gib=torch.cuda.max_memory_allocated(device) / 1024.0**3,
cuda_peak_reserved_gib=torch.cuda.max_memory_reserved(device) / 1024.0**3,
)
return output
def _dynamo_counters() -> dict[str, int]:
try:
from torch._dynamo.utils import counters
return {
"frames_total": int(counters["frames"]["total"]),
"frames_ok": int(counters["frames"]["ok"]),
"unique_graphs": int(counters["stats"]["unique_graphs"]),
"graph_breaks": int(sum(counters["graph_break"].values())),
}
except (ImportError, KeyError, TypeError):
return {}
def _synthetic_data(
env: BaseEnvironment,
*,
paths: int,
steps: int,
state_features: int,
instruments: int,
seed: int,
) -> dict[str, torch.Tensor]:
generator = torch.Generator(device=env.device)
generator.manual_seed(seed)
z = torch.randn(
paths,
steps,
state_features,
dtype=env.fdtype,
device=env.device,
generator=generator,
)
loadings = torch.linspace(
-1.0, 1.0, instruments, dtype=env.fdtype, device=env.device
)
location = 0.002 * z[..., :1] * loadings
scale = 0.01 + 0.002 * torch.sigmoid(z[..., 1:2])
noise = torch.randn(
paths,
steps,
instruments,
dtype=env.fdtype,
device=env.device,
generator=generator,
)
return {"z": z, "returns": location + scale * noise}
@torch.no_grad()
def _valuate(
model: ConditionalTailQuantileModel,
data: dict[str, torch.Tensor],
) -> dict[str, Any]:
loss, by_output = model.loss(data["z"], data["returns"])
quantiles = model(data["z"])
targets = signed_returns(data["returns"]).unsqueeze(-2)
coverage = (targets <= quantiles).to(torch.float64).mean(dim=(0, 1, 4))
cvar = model.cvar_scores(data["z"], data["returns"]).mean(dim=(0, 1, 4))
return {
"loss": float(loss.item()),
"pinball_by_direction_level_instrument_mean": by_output.mean(dim=-1).cpu().tolist(),
"coverage_by_direction_level": coverage.cpu().tolist(),
"cvar_score_by_direction_level": cvar.cpu().tolist(),
"monotone": bool(torch.all(quantiles[..., 1:, :] >= quantiles[..., :-1, :]).item()),
"sub_one_path_tied_to_one_path": bool(
torch.equal(quantiles[..., 0, :], quantiles[..., 1, :])
),
}
[docs]
def run(args: argparse.Namespace) -> dict[str, Any]:
with DeviceLock() as device_lock:
env = BaseEnvironment(device=device_lock.device, debug=False)
if env.device.type == "cuda":
torch.cuda.set_device(env.device)
torch.cuda.empty_cache()
torch.cuda.reset_peak_memory_stats()
data = _synthetic_data(
env,
paths=args.paths,
steps=args.steps,
state_features=args.state_features,
instruments=args.instruments,
seed=args.seed,
)
training_paths = args.paths // 2
training = {name: value[:training_paths] for name, value in data.items()}
validation = {name: value[training_paths:] for name, value in data.items()}
state_mean, state_scale = state_normalization(training, batch_size=args.batch_size)
config = ConditionalTailConfig(
label="smoke-conditional-tail",
state_features=args.state_features,
instruments=args.instruments,
training_paths=training_paths,
network_config=FeedForwardConfig(
num_depth=2,
num_width=100,
activation="LeakyReLU",
use_bias=True,
),
)
model = ConditionalTailQuantileModel(
env,
config=config,
state_mean=state_mean,
state_scale=state_scale,
)
optimizer = torch.optim.AdamW(model.parameters(), lr=args.lr, weight_decay=1.0e-4)
gamma = 1.0 if args.epochs == 1 else (args.final_lr / args.lr) ** (1.0 / (args.epochs - 1))
scheduler = torch.optim.lr_scheduler.ExponentialLR(optimizer, gamma=gamma)
generator = torch.Generator(device=env.device)
generator.manual_seed(args.seed + 1)
initial_training = _valuate(model, training)
initial_validation = _valuate(model, validation)
before_compile = _dynamo_counters()
loss_function = (
torch.compile(model.training_loss, dynamic=True)
if args.compile
else model.training_loss
)
batch_losses: list[float] = []
maximum_gradient_norm = 0.0
for epoch in range(args.epochs):
indices = torch.randint(
training_paths,
(min(args.batch_size, training_paths),),
generator=generator,
device=env.device,
)
optimizer.zero_grad(set_to_none=True)
loss, _ = loss_function(training["z"][indices], training["returns"][indices])
loss_value = float(loss.detach().cpu().item())
if not math.isfinite(loss_value):
raise RuntimeError(f"non-finite CPU objective at epoch {epoch + 1}")
loss.backward()
gradient_sqr = torch.zeros((), dtype=torch.float64, device=env.device)
for parameter in model.parameters():
if parameter.grad is None:
continue
if not torch.isfinite(parameter.grad).all().item():
raise RuntimeError(f"non-finite gradient at epoch {epoch + 1}")
gradient_sqr += parameter.grad.to(torch.float64).square().sum()
maximum_gradient_norm = max(maximum_gradient_norm, float(gradient_sqr.sqrt().item()))
optimizer.step()
if epoch + 1 < args.epochs:
scheduler.step()
batch_losses.append(loss_value)
if env.device.type == "cuda":
torch.cuda.synchronize(env.device)
after_compile = _dynamo_counters()
report = {
"device": str(env.device),
"paths": args.paths,
"training_paths": training_paths,
"validation_paths": args.paths - training_paths,
"steps": args.steps,
"state_features": args.state_features,
"instruments": args.instruments,
"epochs": args.epochs,
"compile_requested": args.compile,
"compiled_graphs": {
name: value - before_compile.get(name, 0)
for name, value in after_compile.items()
},
"tail_levels": config.level_metadata(),
"initial_training": initial_training,
"initial_validation": initial_validation,
"final_training": _valuate(model, training),
"final_validation": _valuate(model, validation),
"first_batch_loss": batch_losses[0],
"final_batch_loss": batch_losses[-1],
"maximum_gradient_norm": maximum_gradient_norm,
"memory": _memory(env.device),
}
path = Path(args.report)
path.parent.mkdir(parents=True, exist_ok=True)
temporary = path.with_name(f".{path.name}.{os.getpid()}.tmp")
try:
temporary.write_text(json.dumps(report, indent=2), encoding="utf-8")
os.replace(temporary, path)
finally:
temporary.unlink(missing_ok=True)
return report
def _parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--paths", type=int, default=1_000)
parser.add_argument("--epochs", type=int, default=100)
parser.add_argument("--steps", type=int, default=9)
parser.add_argument("--state-features", type=int, default=21)
parser.add_argument("--instruments", type=int, default=141)
parser.add_argument("--batch-size", type=int, default=256)
parser.add_argument("--lr", type=float, default=1.0e-3)
parser.add_argument("--final-lr", type=float, default=1.0e-5)
parser.add_argument("--seed", type=int, default=83_771)
parser.add_argument("--compile", action=argparse.BooleanOptionalAction, default=True)
parser.add_argument("--report", required=True)
return parser
[docs]
def main() -> None:
args = _parser().parse_args()
for name in ("paths", "epochs", "steps", "state_features", "instruments", "batch_size"):
if getattr(args, name) <= 0:
raise ValueError(f"--{name.replace('_', '-')} must be positive")
if args.paths < 2:
raise ValueError("--paths must be at least two")
report = run(args)
print(json.dumps(report, indent=2), flush=True)
if __name__ == "__main__":
main()
__all__ = ["main", "run"]