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

"""Run fixed-lambda Case C on selected PCA-IV period-return trading times."""

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 scipy.special import logsumexp
from sklearn.cluster import MiniBatchKMeans

from quantdata.torch import BaseEnvironment

from .arb_tracing import fit_physical_state_whitener, weighted_quantile
from .case_c import (
    CaseCAction,
    CaseCConfig,
    CaseCTrainConfig,
    case_c_numerical_band,
    case_c_objective_and_surrogate,
    case_c_pnl,
    powerexp_one,
)
from .case_c_kernel import KernelCaseCAction, KernelCaseCConfig
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/case-c")
_DEFAULT_CHECKPOINT_ROOT = Path(
    "/media/storage/tmp/quantdata/dysanos/case-c/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 _selected_data(data: DeviceExpiryCase, config: CaseCConfig) -> DeviceExpiryCase:
    """Retain only t0 and t6 while preserving the original path split."""

    times = torch.as_tensor(
        (config.deterministic_time, config.conditional_time),
        dtype=torch.int64,
        device=data.state.device,
    )
    return DeviceExpiryCase(
        state=data.state.index_select(1, times),
        returns=data.returns.index_select(1, times),
        costs=data.costs.index_select(1, times),
        numerical_band=data.numerical_band.index_select(1, times),
        path_weight=data.path_weight,
        component=data.component,
        reference=data.reference,
        validation=data.validation,
        option_price=None,
        delta=None,
        cash_strike=None,
        spot=None,
    )


@torch.no_grad()
def _fit_kernel_basis(
    data: DeviceExpiryCase,
    *,
    state_mean: torch.Tensor,
    state_whitener: torch.Tensor,
    kernels: int,
    seed: int,
) -> tuple[torch.Tensor, torch.Tensor, dict[str, Any]]:
    """Fit fixed physical-weighted centers and local scalar bandwidths."""

    state = data.state[data.reference, 1]
    factor = (state - state_mean[None]) @ state_whitener
    sample = factor.double().cpu().numpy()
    weight = data.path_weight[data.reference].double().cpu().numpy()
    estimator = MiniBatchKMeans(
        n_clusters=kernels,
        init="k-means++",
        n_init=3,
        max_iter=200,
        batch_size=4_096,
        random_state=seed,
        reassignment_ratio=0.0,
    )
    estimator.fit(sample, sample_weight=weight)
    distance = estimator.transform(sample)
    assignment = np.argmin(distance, axis=1)
    radius_square = np.empty(kernels, dtype=np.float64)
    cluster_weight = np.empty(kernels, dtype=np.float64)
    for kernel in range(kernels):
        selected = assignment == kernel
        selected_weight = weight[selected]
        cluster_weight[kernel] = selected_weight.sum()
        if not np.any(selected) or not cluster_weight[kernel] > 0.0:
            raise RuntimeError(f"kernel center {kernel} has no physical training mass")
        radius_square[kernel] = np.average(
            np.square(distance[selected, kernel]), weights=selected_weight
        )
    radius = np.sqrt(radius_square)
    positive = radius[radius > 0.0]
    if positive.size != kernels or not np.all(np.isfinite(radius)):
        raise FloatingPointError("kernel radii are not finite-positive")
    radius_floor = 0.25 * float(np.median(positive))
    radius = np.maximum(radius, radius_floor)
    centers = torch.as_tensor(
        estimator.cluster_centers_, dtype=data.state.dtype, device=data.state.device
    )
    inverse_bandwidth = torch.as_tensor(
        np.reciprocal(radius), dtype=data.state.dtype, device=data.state.device
    )
    normalized_mass = cluster_weight / cluster_weight.sum()
    diagnostics: dict[str, Any] = {
        "definition": (
            "physical-weighted MiniBatchKMeans centers in orthogonal t6 state; "
            "bandwidth is weighted within-center RMS distance"
        ),
        "kernels": kernels,
        "radius_floor": radius_floor,
        "minimum_radius": float(radius.min()),
        "median_radius": float(np.median(radius)),
        "maximum_radius": float(radius.max()),
        "minimum_physical_cluster_mass": float(normalized_mass.min()),
        "maximum_physical_cluster_mass": float(normalized_mass.max()),
    }
    return centers, inverse_bandwidth, diagnostics


def _batch_loss(
    model: CaseCAction,
    data: DeviceExpiryCase,
    indices: torch.Tensor,
    *,
    notional: float | torch.Tensor,
) -> tuple[torch.Tensor, dict[str, torch.Tensor]]:
    action, gross, boundary, raw = model(data.state[indices, 1])
    pnl = case_c_pnl(action, data.returns[indices], data.costs[indices])
    objective, surrogate, marginal_weight = case_c_objective_and_surrogate(
        pnl,
        data.path_weight[indices],
        notional=notional,
    )
    loss = -surrogate.mean()
    values = {
        "objective": objective,
        "surrogate": surrogate,
        "gross": gross,
        "boundary": boundary,
        "raw_output_maximum_absolute": raw.abs().amax(dim=-1),
        "marginal_weight": marginal_weight,
        "pnl": pnl,
    }
    return loss, values


@torch.no_grad()
def _fixed_actions(
    model: CaseCAction, data: DeviceExpiryCase, indices: torch.Tensor
) -> torch.Tensor:
    return model(data.state[indices, 1])[0].detach().clone()


def _checkpoint(
    path: Path,
    *,
    model: CaseCAction,
    optimizer: torch.optim.Optimizer,
    generator: torch.Generator,
    notional_index: int,
    notional: float,
    step: int,
    tracker: list[dict[str, Any]],
    completed: bool,
    converged: bool,
) -> None:
    _atomic_torch_save(
        path,
        {
            "model_code_version": type(model.config).version.unique_id48,
            "user_version": model.config.user_version,
            "notional_index": notional_index,
            "notional": notional,
            "model": model.state_dict(),
            "optimizer": optimizer.state_dict(),
            "step": step,
            "tracker": tracker,
            "completed": completed,
            "converged": converged,
            "batch_generator_state": generator.get_state(),
        },
    )


def _train_notional(
    model: CaseCAction,
    callable_model: CaseCAction,
    data: DeviceExpiryCase,
    *,
    notional_index: int,
    notional: float,
    train_config: CaseCTrainConfig,
    checkpoint_path: Path,
) -> dict[str, Any]:
    """Optimize only on the training paths using the normalized exact gradient."""

    optimizer = torch.optim.AdamW(model.parameters(), lr=train_config.lr, weight_decay=0.0)
    generator = torch.Generator(device=model.device)
    generator.manual_seed(train_config.seed + notional_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")
            == type(model.config).version.unique_id48
            and saved.get("user_version") == model.config.user_version
            and saved.get("notional_index") == notional_index
            and saved.get("notional") == notional
        )
        if compatible:
            model.load_state_dict(saved["model"])
            optimizer.load_state_dict(saved["optimizer"])
            start_step = int(saved["step"])
            tracker = list(saved.get("tracker", []))
            generator.set_state(saved["batch_generator_state"].cpu())
            if bool(saved.get("completed")):
                return {
                    "steps": start_step,
                    "converged": bool(saved.get("converged")),
                    "resumed_complete_checkpoint": True,
                    "elapsed_seconds_this_invocation": 0.0,
                    "tracker": tracker,
                }

    fixed_generator = torch.Generator(device=model.device)
    fixed_generator.manual_seed(train_config.seed + 10_000 + notional_index)
    draw = torch.randperm(
        data.reference.numel(), generator=fixed_generator, device=model.device
    )[: min(train_config.valuation_batch_size, data.reference.numel())]
    fixed = data.reference[draw]
    previous_action = _fixed_actions(model, data, fixed)
    stable_points = 0
    converged = False
    compiled_notional = torch.as_tensor(
        notional, dtype=model.fdtype, device=model.device
    )
    started = time.monotonic()
    for step in range(start_step + 1, train_config.epochs_per_notional + 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, notional=compiled_notional
        )
        loss.backward()
        for parameter in model.parameters():
            if parameter.grad is not None and not torch.isfinite(parameter.grad).all().item():
                raise FloatingPointError("Case C analytic gradient became NaN or infinity")
        optimizer.step()
        model.project_parameters_()

        if step % train_config.value_update == 0 or step == train_config.epochs_per_notional:
            with torch.no_grad():
                fixed_loss, values = _batch_loss(
                    model, data, fixed, notional=notional
                )
                action = _fixed_actions(model, data, fixed)
                action_change = float((action - previous_action).abs().amax().cpu())
                previous_action = action
            stable_points = (
                stable_points + 1
                if action_change <= train_config.action_change_tolerance
                else 0
            )
            converged = bool(
                step >= train_config.minimum_epochs_per_notional
                and stable_points >= train_config.convergence_points
            )
            item = {
                "step": step,
                "loss": float(fixed_loss.cpu()),
                "objective_by_time": values["objective"].cpu().tolist(),
                "gross_mean_by_time": values["gross"].mean(dim=0).cpu().tolist(),
                "gross_maximum_by_time": values["gross"].amax(dim=0).cpu().tolist(),
                "raw_output_maximum_absolute_by_time": (
                    values["raw_output_maximum_absolute"].amax(dim=0).cpu().tolist()
                ),
                "boundary_fraction_by_time": values["boundary"].float().mean(dim=0).cpu().tolist(),
                "maximum_fixed_action_change": action_change,
                "stable_points": stable_points,
                "elapsed_seconds": time.monotonic() - started,
            }
            tracker.append(item)
            print(
                f"[n={notional:g}] step {step:,}: "
                f"objective={item['objective_by_time']}, "
                f"gross={item['gross_mean_by_time']}, "
                f"action change={action_change:.3g}, converged={converged}",
                flush=True,
            )
            if step % train_config.checkpoint_update == 0:
                _checkpoint(
                    checkpoint_path,
                    model=model,
                    optimizer=optimizer,
                    generator=generator,
                    notional_index=notional_index,
                    notional=notional,
                    step=step,
                    tracker=tracker,
                    completed=False,
                    converged=converged,
                )
            if converged:
                break

    final_step = int(tracker[-1]["step"]) if tracker else start_step
    _checkpoint(
        checkpoint_path,
        model=model,
        optimizer=optimizer,
        generator=generator,
        notional_index=notional_index,
        notional=notional,
        step=final_step,
        tracker=tracker,
        completed=True,
        converged=converged,
    )
    return {
        "steps": final_step,
        "converged": converged,
        "resumed_complete_checkpoint": False,
        "elapsed_seconds_this_invocation": time.monotonic() - started,
        "constant_learning_rate": train_config.lr,
        "gradient_clipping": False,
        "optimizer_reset_at_notional_start": True,
        "tracker": tracker,
    }


def _marginal_log_weight(
    pnl: np.ndarray, path_weight: np.ndarray, notional: float
) -> np.ndarray:
    scaled = notional * pnl
    log_marginal = np.empty_like(scaled)
    positive = scaled > 0.0
    log_marginal[positive] = -scaled[positive]
    log_marginal[~positive] = np.log1p(-scaled[~positive])
    result = np.log(path_weight) + log_marginal
    result -= logsumexp(result)
    return result


@torch.no_grad()
def _evaluate_split(
    model: CaseCAction,
    data: DeviceExpiryCase,
    indices: torch.Tensor,
    *,
    notional: float,
    batch_size: int,
) -> dict[str, Any]:
    paths = int(indices.numel())
    pnl = np.empty((paths, 2), dtype=np.float64)
    band = np.empty_like(pnl)
    gross = np.empty((paths, 2), dtype=np.float32)
    raw_output_maximum = np.empty_like(gross)
    boundary = np.empty((paths, 2), dtype=bool)
    overlap = np.empty((paths, 2), dtype=np.float32)
    for start in range(0, paths, batch_size):
        stop = min(paths, start + batch_size)
        batch = indices[start:stop]
        action, batch_gross, batch_boundary, raw = model(data.state[batch, 1])
        pnl[start:stop] = case_c_pnl(
            action, data.returns[batch], data.costs[batch]
        ).cpu().double().numpy()
        band[start:stop] = case_c_numerical_band(
            action,
            data.returns[batch],
            data.costs[batch],
            data.numerical_band[batch],
        ).cpu().double().numpy()
        gross[start:stop] = batch_gross.cpu().numpy()
        raw_output_maximum[start:stop] = raw.abs().amax(dim=-1).cpu().numpy()
        boundary[start:stop] = batch_boundary.cpu().numpy()
        overlap[start:stop] = torch.minimum(
            action[..., 0, :, :], action[..., 1, :, :]
        ).sum(dim=(-1, -2)).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]] = []
    names = ("t0_deterministic", "t6_conditional")
    for time_index, name in enumerate(names):
        value = pnl[:, time_index]
        tolerance = band[:, time_index]
        loss = value < -tolerance
        gain = value > tolerance
        scaled = notional * value
        positive = np.maximum(scaled, 0.0)
        negative = np.minimum(scaled, 0.0)
        utility = np.where(
            scaled > 0.0,
            -np.expm1(-positive),
            negative - 0.5 * np.square(negative),
        )
        objective, objective_error = _weighted_mean_error(
            utility, normalized_weight
        )
        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
        )
        marginal_log_weight = _marginal_log_weight(value, weight, notional)
        marginal_weight = np.exp(marginal_log_weight)
        scale_derivative, scale_derivative_error = _weighted_mean_error(
            value, marginal_weight
        )
        reports.append(
            {
                "name": name,
                "objective": objective,
                "objective_standard_error": objective_error,
                "P_mean_unit_pnl": mean,
                "P_mean_unit_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_unit_pnl_01_quantile": weighted_quantile(value, weight, 0.01),
                "P_unit_pnl_05_quantile": weighted_quantile(value, weight, 0.05),
                "P_unit_pnl_median": weighted_quantile(value, weight, 0.50),
                "proposal_minimum_unit_pnl_plus_band": float(
                    np.min(value + tolerance)
                ),
                "proposal_numerically_nonnegative": bool(np.all(~loss)),
                "direct_P_paths": int(direct.sum()),
                "direct_P_loss_count": int(np.sum(loss & direct)),
                "direct_P_gain_count": int(np.sum(gain & direct)),
                "base_action_gross_P_median": weighted_quantile(
                    gross[:, time_index], weight, 0.50
                ),
                "base_action_gross_P_99_percentile": weighted_quantile(
                    gross[:, time_index], weight, 0.99
                ),
                "base_action_gross_proposal_maximum": float(
                    gross[:, time_index].max()
                ),
                "economic_gross_P_median": notional
                * weighted_quantile(gross[:, time_index], weight, 0.50),
                "raw_output_maximum_absolute_proposal": float(
                    raw_output_maximum[:, time_index].max()
                ),
                "P_boundary_fraction": float(
                    np.dot(normalized_weight, boundary[:, time_index])
                ),
                "P_long_short_overlap": float(
                    np.dot(normalized_weight, overlap[:, time_index])
                ),
                "normalized_notional_derivative": scale_derivative,
                "normalized_notional_derivative_standard_error": (
                    scale_derivative_error
                ),
                "marginal_density_effective_sample_size": float(
                    1.0 / np.square(marginal_weight).sum()
                ),
            }
        )
    return {
        "paths": paths,
        "direct_P_paths": int(direct.sum()),
        "physical_weight_effective_sample_size": float(
            np.square(weight.sum()) / np.square(weight).sum()
        ),
        "times": reports,
    }


def _gradient_diagnostics(
    model: CaseCAction,
    data: DeviceExpiryCase,
    indices: torch.Tensor,
    *,
    notional: float,
    sample_paths: int,
) -> dict[str, Any]:
    sample = indices[: min(sample_paths, indices.numel())]
    model.zero_grad(set_to_none=True)
    loss, values = _batch_loss(model, data, sample, notional=notional)
    loss.backward()
    parameter_norm = float(
        torch.linalg.vector_norm(
            torch.cat(
                [
                    parameter.grad.detach().reshape(-1)
                    for parameter in model.parameters()
                    if parameter.grad is not None
                ]
            )
        ).cpu()
    )
    gradient_zero_fractions = [
        float((parameter.grad == 0.0).float().mean().cpu())
        for parameter in model.parameters()
        if parameter.grad is not None
    ]
    marginal_weight = values["marginal_weight"].detach()
    derivative = (marginal_weight * values["pnl"].detach()).sum(dim=0)
    model.zero_grad(set_to_none=True)
    return {
        "sample_paths": int(sample.numel()),
        "normalized_parameter_gradient_l2": parameter_norm,
        "normalized_notional_derivative_by_time": derivative.cpu().tolist(),
        "marginal_density_effective_sample_size_by_time": (
            1.0 / marginal_weight.square().sum(dim=0)
        ).cpu().tolist(),
        "gradient_exact_zero_fraction": (
            float(np.mean(gradient_zero_fractions))
            if gradient_zero_fractions
            else 1.0
        ),
    }


[docs] def run(args: argparse.Namespace) -> dict[str, Any]: notionals = tuple(float(value) for value in args.notionals) case = RequiredCase( generator="pca-iv", trading_frequency="weekly", return_horizon="incremental", hedge="raw", cost_rate=args.cost_bps * 1.0e-4, path_count=100_000, ) 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) full_data, split_diagnostics = _to_device(loaded, case=case, env=env) del loaded gc.collect() label = f"case-c-pca-iv-weekly-period-raw-{args.cost_bps:g}bps-100000" if args.architecture == "kernel": label = f"{label}-kernel-{args.kernels}" config = KernelCaseCConfig( label=label, source_cache_uid=source_cache_uid, state_features=full_data.state.shape[-1], kernels=args.kernels, notionals=notionals, group=f"gendysanos/case-c-kernel/{args.cost_bps:g}bps", user_version=args.user_version, ) else: config = CaseCConfig( label=label, source_cache_uid=source_cache_uid, state_features=full_data.state.shape[-1], notionals=notionals, group=f"gendysanos/case-c/{args.cost_bps:g}bps", user_version=args.user_version, ) data = _selected_data(full_data, config) del full_data state_mean, state_whitener, whitening = fit_physical_state_whitener( data.state, data.path_weight, data.reference, relative_eigenvalue_floor=args.covariance_relative_floor, ) kernel_basis = None if args.architecture == "kernel": 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, ) model = KernelCaseCAction( env, config=config, state_mean=state_mean[1], state_whitener=state_whitener[1], centers=centers, inverse_bandwidth=inverse_bandwidth, ) else: model = CaseCAction( env, config=config, state_mean=state_mean[1], state_whitener=state_whitener[1], ) train_config = CaseCTrainConfig( batch_size=args.batch_size, valuation_batch_size=args.valuation_batch_size, epochs_per_notional=args.epochs_per_notional, minimum_epochs_per_notional=args.minimum_epochs_per_notional, value_update=args.value_update, checkpoint_update=args.checkpoint_update, convergence_points=args.convergence_points, action_change_tolerance=args.action_change_tolerance, lr=args.lr, compile=not args.no_compile, seed=args.seed, ) callable_model = torch.compile(model, dynamic=False) if train_config.compile else model report_path = Path(args.output_root) / f"{config.label}.json" checkpoint_directory = Path(args.checkpoint_root) / config.group stages: list[dict[str, Any]] = [] started = time.monotonic() for notional_index, notional in enumerate(notionals): checkpoint_path = checkpoint_directory / ( f"{config.filename}-notional-{notional_index + 1}.pt" ) pre_gradient = _gradient_diagnostics( model, data, data.reference, notional=notional, sample_paths=args.gradient_paths, ) training = _train_notional( model, callable_model, data, notional_index=notional_index, notional=notional, train_config=train_config, checkpoint_path=checkpoint_path, ) training_set = _evaluate_split( model, data, data.reference, notional=notional, batch_size=args.valuation_batch_size, ) validation_set = _evaluate_split( model, data, data.validation, notional=notional, batch_size=args.valuation_batch_size, ) post_gradient = { "training": _gradient_diagnostics( model, data, data.reference, notional=notional, sample_paths=args.gradient_paths, ), "validation": _gradient_diagnostics( model, data, data.validation, notional=notional, sample_paths=args.gradient_paths, ), } stage = { "notional": notional, "pre_training_gradient": pre_gradient, "training": training, "training_set": training_set, "validation_set": validation_set, "post_training_gradient": post_gradient, "checkpoint": str(checkpoint_path), } stages.append(stage) _atomic_json( report_path, { "status": "running", "schema_version": "1.0", "configuration": asdict(case), "model_config": asdict(config), "train_config": asdict(train_config), "stages": stages, }, ) print( f"Completed n={notional:g}; " f"training derivative={[x['normalized_notional_derivative'] for x in training_set['times']]}; " f"validation derivative={[x['normalized_notional_derivative'] for x in validation_set['times']]}", flush=True, ) report = { "status": "complete", "schema_version": "1.0", "experiment": "Case C fixed-lambda notional continuation", "definition": { "objective": "sup over unit-gross separate long/short actions of E_P[u_1(n X)]", "pnl": "X=(a_plus-a_minus)'R-(a_plus+a_minus)'c", "gradient": "sum_s D_s grad(X_s), D proportional to (p/q) u_1'(n X_s)", "action_constraint": "a_plus,a_minus nonnegative and sum(a_plus+a_minus)<=1", "validation_policy": "held-out paths never enter fitting, convergence, or stopping", "architecture": args.architecture, }, "configuration": asdict(case), "source_cache": source_cache, "source_cache_uid": source_cache_uid, "split": split_diagnostics, "model_config": asdict(config), "train_config": asdict(train_config), "whitening": whitening, "kernel_basis": kernel_basis, "stages": stages, "runtime_seconds": time.monotonic() - started, "device": str(env.device), "peak_gpu_memory_bytes": ( int(torch.cuda.max_memory_allocated(env.device)) if torch.device(env.device).type == "cuda" else 0 ), } _atomic_json(report_path, report) print(f"Completed Case C report {report_path}", flush=True) return report
def _parser() -> argparse.ArgumentParser: parser = argparse.ArgumentParser(description=__doc__) parser.add_argument("--cost-bps", type=float, choices=(1.0, 10.0), required=True) 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( "--architecture", choices=("feedforward", "kernel"), default="feedforward" ) parser.add_argument("--kernels", type=int, default=64) parser.add_argument( "--notionals", type=float, nargs="+", default=[1.0, 2.0, 4.0, 8.0, 16.0, 32.0, 64.0, 128.0, 256.0], ) parser.add_argument("--epochs-per-notional", type=int, default=20_000) parser.add_argument("--minimum-epochs-per-notional", type=int, default=2_000) 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("--convergence-points", type=int, default=8) parser.add_argument("--action-change-tolerance", type=float, default=2.0e-5) parser.add_argument("--lr", type=float, default=3.0e-4) parser.add_argument("--covariance-relative-floor", type=float, default=1.0e-10) parser.add_argument("--seed", type=int, default=182_071) 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())