train_hyperbolic.py

"""
torchrun --standalone --nproc_per_node=16 train_hyperbolic.py --config-name=lewm_hyperbolic trainer.accelerator=npu trainer.devices=16 trainer.precision=bf16 wandb.enabled=False num_workers=4 loader.batch_size=32 subdir=ogbench/hyperbolic_exp_test
"""

import hashlib
import faulthandler
import math
import os
from functools import partial
from pathlib import Path, PurePosixPath
from types import MethodType

import h5py
import hydra
import lightning as pl
import numpy as np
import stable_pretraining as spt
import stable_worldmodel as swm
import torch
import torch.nn.functional as F
from einops import rearrange
from lightning.pytorch.callbacks import Callback
from lightning.pytorch.loggers import WandbLogger
from lightning.pytorch.strategies import SingleDeviceStrategy
from omegaconf import OmegaConf, open_dict
from torch import nn

try:
    from torch.distributed.elastic.multiprocessing.errors import record
except Exception:
    def record(fn):
        return fn

try:
    import fcntl
except ImportError:
    fcntl = None

from module import ARPredictor, Embedder, MLP, SIGReg
from npu_accelerator import NPUAccelerator
from npu_ddp_strategy import NPUDDPStrategy
try:
    from train_pahm import (
        SafeSequenceDataset,
        dataset_has_preprocessed_pixels,
        is_rank_zero_process,
        maybe_resolve_sharded_dataset,
        print_dataset_diagnostics,
        resolve_npu_devices,
        validate_hdf5_episode_metadata,
    )
except ImportError:
    from train import (
        SafeSequenceDataset,
        dataset_has_preprocessed_pixels,
        is_rank_zero_process,
        maybe_resolve_sharded_dataset,
        print_dataset_diagnostics,
        resolve_npu_devices,
        validate_hdf5_episode_metadata,
    )
from utils import (
    LossHistoryCallback,
    ModelObjectCallBack,
    get_column_normalizer,
    get_img_preprocessor,
    maybe_enable_npu,
    resolve_runtime_device,
)


def detach_clone(v):
    return v.detach().clone() if torch.is_tensor(v) else v


def _non_finite_tensor_names(values: dict[str, torch.Tensor]) -> list[str]:
    bad_names = []
    for name, value in values.items():
        if torch.is_tensor(value) and not bool(torch.isfinite(value).all()):
            bad_names.append(name)
    return bad_names


class NonFiniteGradientCallback(Callback):
    """Stop immediately when a non-finite gradient would corrupt a checkpoint."""

    def on_after_backward(self, trainer, pl_module):
        parameters = [
            parameter
            for parameter in pl_module.model.parameters()
            if parameter.grad is not None
        ]
        if not parameters:
            return

        try:
            torch.nn.utils.clip_grad_norm_(
                parameters,
                max_norm=float("inf"),
                error_if_nonfinite=True,
            )
        except RuntimeError as exc:
            bad_names = [
                f"model.{name}"
                for name, parameter in pl_module.model.named_parameters()
                if parameter.grad is not None and not bool(torch.isfinite(parameter.grad).all())
            ]
            bad_preview = ", ".join(bad_names[:8]) or "<global gradient norm>"
            raise FloatingPointError(
                "Detected non-finite gradients before optimizer.step "
                f"at global_step={trainer.global_step}. "
                f"First affected parameters: {bad_preview}."
            ) from exc


def _dataset_name_to_h5_path(dataset_name: str) -> Path:
    normalized = str(dataset_name).replace("\\", "/")
    cache_dir = Path(swm.data.utils.get_cache_dir())
    return cache_dir / f"{normalized}.h5"


def _build_preprocessed_dataset_candidates(dataset_name: str, img_size: int) -> list[str]:
    normalized = str(dataset_name).replace("\\", "/")
    pure_name = PurePosixPath(normalized)
    parent = "" if str(pure_name.parent) == "." else pure_name.parent.as_posix()
    stem = pure_name.name
    prep_suffix = f"_prep{img_size}"

    candidates = []
    seen = set()

    def add(candidate: str) -> None:
        if candidate and candidate not in seen:
            seen.add(candidate)
            candidates.append(candidate)

    if parent:
        add(f"{parent}{prep_suffix}/{stem}{prep_suffix}")
        add(f"{parent}{prep_suffix}/{stem}")

    add(f"{normalized}{prep_suffix}")
    return candidates


def maybe_resolve_full_dataset(cfg) -> None:
    base_name = str(cfg.data.dataset.name).replace("\\", "/")
    resolved_name = None
    resolved_reason = None

    for preprocessed_name in _build_preprocessed_dataset_candidates(base_name, cfg.img_size):
        if _dataset_name_to_h5_path(preprocessed_name).exists():
            resolved_name = preprocessed_name
            resolved_reason = "preprocessed"
            break

    if resolved_name is None and _dataset_name_to_h5_path(base_name).exists():
        resolved_name = base_name
        resolved_reason = "raw"

    if resolved_name is not None and resolved_name != base_name:
        with open_dict(cfg):
            cfg.data.dataset.name = resolved_name

    rank = int(os.environ.get("RANK", "0"))
    world_size = int(os.environ.get("WORLD_SIZE", "1"))
    effective_name = str(cfg.data.dataset.name).replace("\\", "/")
    print(
        f"[dataset-diag] using full dataset '{effective_name}' "
        f"(reason={resolved_reason or 'unverified'}, world_size={world_size}, rank={rank})",
        flush=True,
    )


def _unique_preserve_order(values) -> list:
    result = []
    seen = set()
    for value in values or []:
        if value not in seen:
            seen.add(value)
            result.append(value)
    return result


def resolve_dataset_cache_keys(cfg) -> list[str]:
    dataset_kwargs = OmegaConf.to_container(cfg.data.dataset, resolve=True)
    if bool(cfg.data_loading.get("cache_all_keys_in_memory", False)):
        return _unique_preserve_order(dataset_kwargs.get("keys_to_load") or [])
    return _unique_preserve_order(dataset_kwargs.get("keys_to_cache") or [])


def build_hdf5_dataset_kwargs(cfg, cache_keys: list[str], use_shared_cache: bool) -> dict:
    dataset_kwargs = OmegaConf.to_container(cfg.data.dataset, resolve=True)
    dataset_kwargs["keys_to_cache"] = [] if use_shared_cache else cache_keys
    return dataset_kwargs


def resolve_shared_cache_dir(cfg) -> Path:
    configured = str(cfg.data_loading.get("shared_cache_dir", "")).strip()
    if configured:
        return Path(configured)

    default_dir = Path("/dev/shm/lewm_shared_hdf5")
    if default_dir.exists():
        return default_dir
    return Path(swm.data.utils.get_cache_dir(), "shared_hdf5")


def _dataset_cache_fingerprint(h5_path: str | Path) -> str:
    resolved = Path(h5_path).resolve()
    stat = resolved.stat()
    payload = f"{resolved}|{stat.st_size}|{stat.st_mtime_ns}"
    return hashlib.sha1(payload.encode("utf-8")).hexdigest()[:16]


def _sanitize_cache_key(key: str) -> str:
    return str(key).replace("/", "__")


def _cache_file_path(cache_dir: Path, key: str) -> Path:
    return cache_dir / f"{_sanitize_cache_key(key)}.npy"


def _rows_per_chunk(dataset_obj: h5py.Dataset, chunk_bytes: int) -> int:
    if len(dataset_obj.shape) == 0:
        return 1
    if dataset_obj.shape[0] == 0:
        return 1

    trailing = int(np.prod(dataset_obj.shape[1:], dtype=np.int64)) if len(dataset_obj.shape) > 1 else 1
    bytes_per_row = max(1, trailing * dataset_obj.dtype.itemsize)
    return max(1, min(int(dataset_obj.shape[0]), max(1, int(chunk_bytes) // bytes_per_row)))


def _is_valid_shared_cache_file(cache_path: Path, source_dataset: h5py.Dataset) -> bool:
    if not cache_path.exists():
        return False
    try:
        cached = np.load(cache_path, mmap_mode="r")
    except Exception:
        return False

    try:
        return cached.shape == source_dataset.shape and cached.dtype == source_dataset.dtype
    finally:
        del cached


def _write_hdf5_dataset_to_npy(
    source_dataset: h5py.Dataset,
    cache_path: Path,
    chunk_bytes: int,
) -> None:
    tmp_path = cache_path.with_suffix(f"{cache_path.suffix}.tmp.{os.getpid()}")
    if tmp_path.exists():
        tmp_path.unlink()

    mmap = np.lib.format.open_memmap(
        tmp_path,
        mode="w+",
        dtype=source_dataset.dtype,
        shape=source_dataset.shape,
    )
    progress_bar = None
    try:
        if len(source_dataset.shape) == 0:
            mmap[()] = source_dataset[()]
        else:
            rows_per_chunk = _rows_per_chunk(source_dataset, chunk_bytes)
            total_rows = int(source_dataset.shape[0])
            rank = get_rank() if 'get_rank' in globals() else int(os.environ.get('RANK', os.environ.get('RANK_ID', '0')))
            try:
                from tqdm.auto import tqdm
                progress_bar = tqdm(
                    total=total_rows,
                    desc=f"cache:{cache_path.stem}:rank{rank}",
                    unit="rows",
                    leave=True,
                )
            except Exception:
                progress_bar = None

            for start in range(0, total_rows, rows_per_chunk):
                end = min(total_rows, start + rows_per_chunk)
                mmap[start:end] = source_dataset[start:end]
                if progress_bar is not None:
                    progress_bar.update(end - start)
        mmap.flush()
    finally:
        if progress_bar is not None:
            progress_bar.close()
        del mmap

    os.replace(tmp_path, cache_path)


def _lock_handle(lock_path: Path):
    lock_path.parent.mkdir(parents=True, exist_ok=True)
    handle = lock_path.open("a+b")
    if fcntl is not None:
        fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
    return handle


def _unlock_handle(handle) -> None:
    try:
        if fcntl is not None:
            fcntl.flock(handle.fileno(), fcntl.LOCK_UN)
    finally:
        handle.close()


def ensure_shared_cache_files(
    h5_path: str | Path,
    cache_keys: list[str],
    shared_cache_root: Path,
    chunk_bytes: int,
) -> tuple[Path, dict[str, Path]]:
    h5_path = Path(h5_path)
    fingerprint = _dataset_cache_fingerprint(h5_path)
    dataset_cache_dir = shared_cache_root / fingerprint
    file_paths = {key: _cache_file_path(dataset_cache_dir, key) for key in cache_keys}
    lock_path = shared_cache_root / f"{fingerprint}.lock"

    rank = get_rank() if 'get_rank' in globals() else int(os.environ.get('RANK', os.environ.get('RANK_ID', '0')))
    print(
        f"[dataset-diag] rank={rank} waiting for shared cache lock '{lock_path.name}'",
        flush=True,
    )
    lock = _lock_handle(lock_path)
    try:
        print(
            f"[dataset-diag] rank={rank} acquired shared cache lock '{lock_path.name}'",
            flush=True,
        )
        dataset_cache_dir.mkdir(parents=True, exist_ok=True)
        with h5py.File(h5_path, "r") as h5_file:
            for key in cache_keys:
                if key not in h5_file:
                    raise KeyError(f"Requested shared cache key '{key}' not found in '{h5_path}'.")

                cache_path = file_paths[key]
                if _is_valid_shared_cache_file(cache_path, h5_file[key]):
                    continue

                print(
                    f"[dataset-diag] building shared cache key='{key}' path='{cache_path}'",
                    flush=True,
                )
                _write_hdf5_dataset_to_npy(h5_file[key], cache_path, chunk_bytes)
    finally:
        _unlock_handle(lock)

    return dataset_cache_dir, file_paths


def _shared_cache_load_slice(self, ep_idx: int, start: int, end: int) -> dict:
    self._open()
    g_start, g_end = (
        self.offsets[ep_idx] + start,
        self.offsets[ep_idx] + end,
    )
    steps = {}
    for col in self._keys:
        if col in self._cache:
            data = np.array(self._cache[col][g_start:g_end], copy=True)
        else:
            data = self.h5_file[col][g_start:g_end]
        if col != "action":
            data = data[:: self.frameskip]

        if data.dtype == np.object_ or data.dtype.kind in ("S", "U"):
            val = data[0] if len(data) > 0 else b""
            steps[col] = val.decode() if isinstance(val, bytes) else val
        else:
            steps[col] = torch.from_numpy(data)
            if data.ndim == 4 and data.shape[-1] in (1, 3):
                steps[col] = steps[col].permute(0, 3, 1, 2)

    return self.transform(steps) if self.transform else steps


def attach_shared_cache_to_dataset(dataset, cache_keys: list[str], cfg) -> None:
    if not cache_keys:
        return

    shared_cache_root = resolve_shared_cache_dir(cfg)
    chunk_bytes = int(cfg.data_loading.get("shared_cache_chunk_bytes", 512 * 1024 * 1024))
    dataset_cache_dir, file_paths = ensure_shared_cache_files(
        h5_path=getattr(dataset, "h5_path"),
        cache_keys=cache_keys,
        shared_cache_root=shared_cache_root,
        chunk_bytes=chunk_bytes,
    )

    shared_arrays = {key: np.load(path, mmap_mode="r") for key, path in file_paths.items()}
    dataset._cache.update(shared_arrays)
    dataset._shared_cache_dir = dataset_cache_dir
    dataset._shared_cache_paths = file_paths
    dataset._load_slice = MethodType(_shared_cache_load_slice, dataset)
    print(
        f"[dataset-diag] attached shared cache dir='{dataset_cache_dir}' keys={cache_keys}",
        flush=True,
    )


class LorentzManifold(nn.Module):
    def __init__(
        self,
        *,
        curvature_init: float = 1.0,
        learn_curvature: bool = False,
        max_tangent_norm: float = 5.0,
        eps: float = 1e-5,
        fp32_distance: bool = True,
    ):
        super().__init__()
        curvature_init = max(float(curvature_init), float(eps))
        raw_curvature = torch.log(torch.expm1(torch.tensor(curvature_init)))
        if learn_curvature:
            self.raw_curvature = nn.Parameter(raw_curvature)
        else:
            self.register_buffer("raw_curvature", raw_curvature)
        self.max_tangent_norm = float(max_tangent_norm)
        self.eps = float(eps)
        self.fp32_distance = bool(fp32_distance)

    @property
    def curvature(self) -> torch.Tensor:
        return F.softplus(self.raw_curvature) + self.eps

    def _work_dtype(self, x: torch.Tensor) -> torch.dtype:
        if self.fp32_distance and x.dtype in (torch.float16, torch.bfloat16):
            return torch.float32
        return x.dtype

    def _curvature_like(self, x: torch.Tensor) -> torch.Tensor:
        return self.curvature.to(device=x.device, dtype=self._work_dtype(x))

    def _radius_like(self, x: torch.Tensor) -> torch.Tensor:
        return self._curvature_like(x).rsqrt()

    def clamp_tangent(self, u: torch.Tensor) -> torch.Tensor:
        if self.max_tangent_norm <= 0:
            return u
        norm = torch.linalg.vector_norm(u, dim=-1, keepdim=True)
        scale = self.max_tangent_norm / norm.clamp_min(self.eps)
        return torch.where(norm > self.max_tangent_norm, u * scale, u)

    def project(self, x: torch.Tensor) -> torch.Tensor:
        x = x.to(dtype=self._work_dtype(x))
        spatial = x[..., 1:]
        radius = self._radius_like(x)
        time = torch.sqrt(
            radius.square() + spatial.square().sum(dim=-1, keepdim=True)
        ).clamp_min(self.eps)
        return torch.cat([time, spatial], dim=-1)

    def expmap0(self, u: torch.Tensor) -> torch.Tensor:
        u = self.clamp_tangent(u).to(dtype=self._work_dtype(u))
        c = self._curvature_like(u)
        sqrt_c = torch.sqrt(c)
        radius = c.rsqrt()

        norm = torch.linalg.vector_norm(u, dim=-1, keepdim=True)
        scaled_norm = sqrt_c * norm
        safe_norm = norm.clamp_min(self.eps)

        factor = torch.ones_like(norm)
        valid = norm > self.eps
        factor = torch.where(
            valid,
            torch.sinh(scaled_norm) / (sqrt_c * safe_norm),
            factor,
        )

        time = torch.cosh(scaled_norm) * radius
        spatial = factor * u
        return self.project(torch.cat([time, spatial], dim=-1))

    def minkowski_dot(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
        x = x.to(dtype=self._work_dtype(x))
        y = y.to(dtype=self._work_dtype(y))
        return (x[..., 1:] * y[..., 1:]).sum(dim=-1) - x[..., 0] * y[..., 0]

    def pairwise_minkowski_dot(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
        x = x.to(dtype=self._work_dtype(x))
        y = y.to(dtype=self._work_dtype(y))
        spatial = x[..., 1:] @ y[..., 1:].transpose(-1, -2)
        temporal = x[..., :1] @ y[..., :1].transpose(-1, -2)
        return spatial - temporal

    def dist(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
        x = self.project(x)
        y = self.project(y)
        c = self._curvature_like(x)
        arg = (-c * self.minkowski_dot(x, y)).clamp_min(1.0 + self.eps)
        return torch.acosh(arg) / torch.sqrt(c)

    def pairwise_dist(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
        x = self.project(x)
        y = self.project(y)
        c = self._curvature_like(x)
        arg = (-c * self.pairwise_minkowski_dot(x, y)).clamp_min(1.0 + self.eps)
        return torch.acosh(arg) / torch.sqrt(c)

    def to_poincare(self, x: torch.Tensor) -> torch.Tensor:
        x = self.project(x)
        radius = self._radius_like(x)
        return x[..., 1:] / (x[..., :1] + radius).clamp_min(self.eps)


class LorentzContrastiveLoss(nn.Module):
    def __init__(self, temperature: float = 0.2, label_smoothing: float = 0.0):
        super().__init__()
        self.temperature = float(temperature)
        self.label_smoothing = float(label_smoothing)

    def forward(
        self,
        pred_points: torch.Tensor,
        target_points: torch.Tensor,
        manifold: LorentzManifold,
    ) -> dict[str, torch.Tensor]:
        pred_flat = pred_points.reshape(-1, pred_points.size(-1))
        target_flat = target_points.reshape(-1, target_points.size(-1))

        dist_matrix = manifold.pairwise_dist(pred_flat, target_flat)
        logits = -dist_matrix / max(self.temperature, 1e-6)
        labels = torch.arange(logits.size(0), device=logits.device)

        loss = 0.5 * (
            F.cross_entropy(logits, labels, label_smoothing=self.label_smoothing)
            + F.cross_entropy(logits.t(), labels, label_smoothing=self.label_smoothing)
        )

        pos_dist = dist_matrix.diag().mean()
        if dist_matrix.size(0) > 1:
            neg_mask = ~torch.eye(dist_matrix.size(0), dtype=torch.bool, device=dist_matrix.device)
            neg_dist = dist_matrix[neg_mask].mean()
        else:
            neg_dist = torch.zeros_like(pos_dist)

        return {
            "contrastive_loss": loss,
            "contrastive_pos_dist": pos_dist,
            "contrastive_neg_dist": neg_dist,
        }


class AdaptiveEntailmentConeLoss(nn.Module):
    """Cone-style surrogate defined in Poincare coordinates."""

    def __init__(
        self,
        *,
        min_aperture: float = 0.10,
        max_aperture: float = 1.10,
        radius_margin: float = 0.02,
        angle_weight: float = 1.0,
        radius_weight: float = 1.0,
        eps: float = 1e-6,
    ):
        super().__init__()
        self.min_aperture = float(min_aperture)
        self.max_aperture = float(max_aperture)
        self.radius_margin = float(radius_margin)
        self.angle_weight = float(angle_weight)
        self.radius_weight = float(radius_weight)
        self.eps = float(eps)

    def penalty(
        self,
        parent_points: torch.Tensor,
        child_points: torch.Tensor,
        manifold: LorentzManifold,
    ) -> dict[str, torch.Tensor]:
        parent_ball = manifold.to_poincare(parent_points).float()
        child_ball = manifold.to_poincare(child_points).float()

        parent_radius = torch.linalg.vector_norm(parent_ball, dim=-1)
        child_radius = torch.linalg.vector_norm(child_ball, dim=-1)

        valid = (parent_radius > self.eps) & (child_radius > self.eps)
        parent_dir = parent_ball / parent_radius.unsqueeze(-1).clamp_min(self.eps)
        child_dir = child_ball / child_radius.unsqueeze(-1).clamp_min(self.eps)

        cosine = (parent_dir * child_dir).sum(dim=-1).clamp(-0.9995, 0.9995)
        angle = torch.zeros_like(parent_radius)
        angle = torch.where(valid, torch.acos(cosine), angle)

        openness = (1.0 - parent_radius).clamp(0.0, 1.0)
        aperture = self.min_aperture + (self.max_aperture - self.min_aperture) * openness

        angle_violation = F.relu(angle - aperture)
        angle_violation = torch.where(valid, angle_violation, torch.zeros_like(angle_violation))
        radius_violation = F.relu(parent_radius + self.radius_margin - child_radius)
        loss = self.angle_weight * angle_violation + self.radius_weight * radius_violation

        return {
            "loss": loss,
            "angle_violation": angle_violation,
            "radius_violation": radius_violation,
            "aperture": aperture,
            "parent_radius": parent_radius,
            "child_radius": child_radius,
        }

    def forward(
        self,
        parent_points: torch.Tensor,
        child_points: torch.Tensor,
        manifold: LorentzManifold,
    ) -> dict[str, torch.Tensor]:
        stats = self.penalty(parent_points, child_points, manifold)
        return {
            "cone_loss": stats["loss"].mean(),
            "cone_angle_loss": stats["angle_violation"].mean(),
            "cone_radius_loss": stats["radius_violation"].mean(),
            "cone_aperture": stats["aperture"].mean(),
            "parent_radius": stats["parent_radius"].mean(),
            "child_radius": stats["child_radius"].mean(),
        }


class HyperbolicJEPA(nn.Module):
    def __init__(
        self,
        *,
        encoder: nn.Module,
        predictor: nn.Module,
        action_encoder: nn.Module,
        projector: nn.Module,
        pred_proj: nn.Module,
        hyper_projector: nn.Module,
        manifold: LorentzManifold,
        cone_loss: AdaptiveEntailmentConeLoss,
        contrastive_loss: LorentzContrastiveLoss,
        tangent_stabilization: dict | None = None,
    ):
        super().__init__()
        self.encoder = encoder
        self.predictor = predictor
        self.action_encoder = action_encoder
        self.projector = projector
        self.pred_proj = pred_proj
        self.hyper_projector = hyper_projector
        self.manifold = manifold
        self.cone_loss = cone_loss
        self.contrastive_loss = contrastive_loss
        self.tangent_stabilization = tangent_stabilization or {}
        self.planning_config = {}
        self.trm_metric = None

    def set_planning_config(self, config: dict | None = None):
        self.planning_config = config or {}

    def set_trajectory_reachability_metric(self, metric: nn.Module | None):
        self.trm_metric = metric
        if self.trm_metric is not None:
            self.trm_metric.eval()
            self.trm_metric.requires_grad_(False)

    def _stabilize_tangent(
        self,
        tangent: torch.Tensor,
    ) -> tuple[torch.Tensor, dict[str, torch.Tensor]]:
        cfg = self.tangent_stabilization
        enabled = bool(cfg.get("enabled", False))
        tangent_fp32 = tangent.float()
        raw_norm = tangent_fp32.norm(dim=-1)
        if not enabled:
            max_norm = float(self.manifold.max_tangent_norm)
            if max_norm > 0:
                saturated = raw_norm >= max_norm
            else:
                saturated = torch.zeros_like(raw_norm, dtype=torch.bool)
            return tangent_fp32, {
                "raw_tangent_norm": raw_norm,
                "scaled_tangent_norm": raw_norm,
                "bounded_tangent_norm": raw_norm,
                "tangent_saturation_fraction": saturated.float(),
            }

        scaled = tangent_fp32
        if bool(cfg.get("scale_by_sqrt_dim", True)):
            scaled = scaled / math.sqrt(float(tangent.size(-1)))

        scaled_norm = scaled.norm(dim=-1, keepdim=True)
        max_norm = float(cfg.get("max_norm", self.manifold.max_tangent_norm))
        if max_norm <= 0:
            bounded = scaled
        else:
            bounded_norm = max_norm * torch.tanh(scaled_norm / max_norm)
            bounded = scaled * bounded_norm / scaled_norm.clamp_min(self.manifold.eps)

        bounded_norm = bounded.norm(dim=-1)
        saturation_threshold = float(cfg.get("saturation_threshold", 0.95))
        if max_norm > 0:
            saturated = bounded_norm >= saturation_threshold * max_norm
        else:
            saturated = torch.zeros_like(bounded_norm, dtype=torch.bool)
        return bounded, {
            "raw_tangent_norm": raw_norm,
            "scaled_tangent_norm": scaled_norm.squeeze(-1),
            "bounded_tangent_norm": bounded_norm,
            "tangent_saturation_fraction": saturated.float(),
        }

    def to_hyperbolic(
        self,
        emb: torch.Tensor,
        *,
        return_stats: bool = False,
    ) -> tuple[torch.Tensor, torch.Tensor] | tuple[torch.Tensor, torch.Tensor, dict[str, torch.Tensor]]:
        shape_prefix = emb.shape[:-1]
        flat = emb.reshape(-1, emb.size(-1))
        raw_tangent = self.hyper_projector(flat)
        tangent, stats = self._stabilize_tangent(raw_tangent)
        tangent = tangent.reshape(*shape_prefix, tangent.size(-1))
        points = self.manifold.expmap0(tangent)
        if return_stats:
            stats = {
                key: value.reshape(*shape_prefix)
                for key, value in stats.items()
            }
            return tangent, points, stats
        return tangent, points

    def encode(self, info: dict) -> dict:
        pixels = info["pixels"].float()
        bsz = pixels.size(0)

        pixels = rearrange(pixels, "b t ... -> (b t) ...")
        output = self.encoder(pixels, interpolate_pos_encoding=True)
        pixels_emb = output.last_hidden_state[:, 0]
        emb = self.projector(pixels_emb)
        emb = rearrange(emb, "(b t) d -> b t d", b=bsz)

        hyp_tangent, hyp_emb, tangent_stats = self.to_hyperbolic(emb, return_stats=True)

        info["emb"] = emb
        info["hyp_tangent"] = hyp_tangent
        info["hyp_emb"] = hyp_emb
        info.update(tangent_stats)

        if "action" in info:
            info["act_emb"] = self.action_encoder(info["action"])

        return info

    def predict(self, emb: torch.Tensor, act_emb: torch.Tensor) -> torch.Tensor:
        preds = self.predictor(emb, act_emb)
        preds = self.pred_proj(rearrange(preds, "b t d -> (b t) d"))
        return rearrange(preds, "(b t) d -> b t d", b=emb.size(0))

    def rollout_from_encoded(
        self,
        emb: torch.Tensor,
        act_emb: torch.Tensor,
        *,
        history_size: int,
        rollout_steps: int,
    ) -> tuple[torch.Tensor, torch.Tensor]:
        max_rollout_steps = emb.size(1) - history_size
        rollout_steps = min(int(rollout_steps), int(max_rollout_steps))
        if rollout_steps <= 0:
            raise ValueError(
                f"Expected rollout_steps > 0 with history_size={history_size}, got "
                f"rollout_steps={rollout_steps}, sequence_len={emb.size(1)}."
            )

        pred_context = emb[:, :history_size].clone()
        act_context = act_emb[:, :history_size].clone()
        preds = []

        for step_idx in range(rollout_steps):
            pred_step = self.predict(
                pred_context[:, -history_size:],
                act_context[:, -history_size:],
            )[:, -1:]
            preds.append(pred_step)
            pred_context = torch.cat([pred_context, pred_step], dim=1)

            if step_idx + 1 < rollout_steps:
                next_act = act_emb[:, history_size + step_idx : history_size + step_idx + 1]
                act_context = torch.cat([act_context, next_act], dim=1)

        pred_rollout = torch.cat(preds, dim=1)
        _, pred_rollout_hyp = self.to_hyperbolic(pred_rollout)
        return pred_rollout, pred_rollout_hyp

    def rollout(self, info: dict, action_sequence: torch.Tensor, history_size: int = 3) -> dict:
        assert "pixels" in info, "pixels not in info_dict"

        hist = info["pixels"].size(2)
        batch_size, num_samples, horizon = action_sequence.shape[:3]
        act_0, act_future = torch.split(action_sequence, [hist, horizon - hist], dim=2)
        info["action"] = act_0
        n_steps = horizon - hist

        init = {k: v[:, 0] for k, v in info.items() if torch.is_tensor(v)}
        init = self.encode(init)
        emb = info["emb"] = init["emb"].unsqueeze(1).expand(batch_size, num_samples, -1, -1)
        init = {k: detach_clone(v) for k, v in init.items()}

        emb = rearrange(emb, "b s ... -> (b s) ...").clone()
        act = rearrange(act_0, "b s ... -> (b s) ...")
        act_future = rearrange(act_future, "b s ... -> (b s) ...")

        for step_idx in range(n_steps):
            act_emb = self.action_encoder(act)
            emb_trunc = emb[:, -history_size:]
            act_trunc = act_emb[:, -history_size:]
            pred_emb = self.predict(emb_trunc, act_trunc)[:, -1:]
            emb = torch.cat([emb, pred_emb], dim=1)

            next_act = act_future[:, step_idx : step_idx + 1]
            act = torch.cat([act, next_act], dim=1)

        act_emb = self.action_encoder(act)
        emb_trunc = emb[:, -history_size:]
        act_trunc = act_emb[:, -history_size:]
        pred_emb = self.predict(emb_trunc, act_trunc)[:, -1:]
        emb = torch.cat([emb, pred_emb], dim=1)

        pred_rollout = rearrange(emb, "(b s) ... -> b s ...", b=batch_size, s=num_samples)
        _, pred_hyp = self.to_hyperbolic(pred_rollout)
        info["predicted_emb"] = pred_rollout
        info["predicted_hyp_emb"] = pred_hyp
        return info

    def _planning_hyperbolic_config(self) -> dict[str, float | bool]:
        defaults = {
            "enabled": True,
            "terminal_weight": 1.0,
            "best_weight": 0.35,
            "mean_weight": 0.15,
            "progress_weight": 0.10,
            "progress_margin": 0.0,
            "cone_weight": 0.08,
        }
        if not isinstance(self.planning_config, dict):
            return defaults

        hyper_cfg = self.planning_config.get("hyperbolic", {})
        source = hyper_cfg if isinstance(hyper_cfg, dict) and hyper_cfg else self.planning_config
        if not isinstance(source, dict):
            return defaults

        merged = defaults.copy()
        for key in defaults:
            if key in source:
                merged[key] = source[key]
        return merged

    def _planning_trm_config(self) -> dict[str, float | bool | str | None]:
        defaults = {
            "enabled": False,
            "checkpoint": None,
            "weight": 0.5,
            "mode": "hybrid",
            "normalize_candidates": True,
        }
        if not isinstance(self.planning_config, dict):
            return defaults

        source = self.planning_config.get("trm", {})
        if not isinstance(source, dict):
            return defaults

        merged = defaults.copy()
        for key in defaults:
            if key in source:
                merged[key] = source[key]
        return merged

    @staticmethod
    def _standardize_candidate_cost(cost: torch.Tensor) -> torch.Tensor:
        mean = cost.mean(dim=-1, keepdim=True)
        std = cost.std(dim=-1, keepdim=True, unbiased=False).clamp_min(1e-6)
        return (cost - mean) / std

    def _trajectory_reachability_cost(self, info_dict: dict) -> torch.Tensor:
        if self.trm_metric is None:
            raise RuntimeError(
                "planning.trm.enabled=True requires a loaded trajectory reachability metric."
            )

        input_space = str(getattr(self.trm_metric, "input_space", "tangent"))
        if input_space == "euclidean":
            predicted = info_dict["predicted_emb"][..., -1, :]
            goal = info_dict["goal_emb"][..., -1, :]
        elif input_space == "tangent":
            predicted, _ = self.to_hyperbolic(info_dict["predicted_emb"][..., -1:, :])
            predicted = predicted[..., -1, :]
            goal = info_dict["goal_hyp_tangent"][..., -1, :]
        elif input_space == "lorentz":
            predicted = info_dict["predicted_hyp_emb"][..., -1, :]
            goal = info_dict["goal_hyp_emb"][..., -1, :]
        else:
            raise ValueError(f"Unsupported TRM input space: {input_space!r}")

        while goal.ndim < predicted.ndim:
            goal = goal.unsqueeze(1)
        goal = goal.expand_as(predicted)
        return self.trm_metric(predicted, goal)

    def _blend_trajectory_reachability_cost(
        self,
        base_cost: torch.Tensor,
        info_dict: dict,
    ) -> torch.Tensor:
        trm_cfg = self._planning_trm_config()
        if not bool(trm_cfg.get("enabled", False)):
            return base_cost

        trm_cost = self._trajectory_reachability_cost(info_dict)
        trm_weight = float(trm_cfg.get("weight", 0.5))
        mode = str(trm_cfg.get("mode", "hybrid")).lower()
        normalize = bool(trm_cfg.get("normalize_candidates", True))
        if mode == "replace":
            cost = trm_cost
        elif mode == "add":
            cost = base_cost + trm_weight * trm_cost
        elif mode == "hybrid":
            base_cost = self._standardize_candidate_cost(base_cost) if normalize else base_cost
            metric_cost = (
                self._standardize_candidate_cost(trm_cost)
                if normalize
                else trm_cost
            )
            cost = base_cost + trm_weight * metric_cost
        else:
            raise ValueError(
                f"Unsupported planning.trm.mode={mode!r}; expected hybrid, replace, or add."
            )
        info_dict["planning_trm_cost"] = trm_cost.mean().detach()
        return cost

    def criterion(self, info_dict: dict) -> torch.Tensor:
        pred_hyp = info_dict["predicted_hyp_emb"]
        goal_hyp = info_dict["goal_hyp_emb"][..., -1:, :]
        while goal_hyp.ndim < pred_hyp.ndim:
            goal_hyp = goal_hyp.unsqueeze(1)
        goal_hyp = goal_hyp.expand_as(pred_hyp)

        step_cost = self.manifold.dist(pred_hyp, goal_hyp).pow(2)
        terminal_cost = step_cost[..., -1]

        planning_cfg = self._planning_hyperbolic_config()
        if not bool(planning_cfg.get("enabled", True)):
            return self._blend_trajectory_reachability_cost(terminal_cost, info_dict)

        history_size = 1
        if "pixels" in info_dict and torch.is_tensor(info_dict["pixels"]):
            history_size = int(info_dict["pixels"].size(2))

        rollout_cost = step_cost[..., history_size:]
        if rollout_cost.size(-1) == 0:
            rollout_cost = step_cost[..., -1:]

        best_cost = rollout_cost.min(dim=-1).values
        mean_cost = rollout_cost.mean(dim=-1)

        if rollout_cost.size(-1) > 1:
            progress_delta = rollout_cost[..., 1:] - rollout_cost[..., :-1]
            progress_cost = F.relu(
                progress_delta + float(planning_cfg.get("progress_margin", 0.0))
            ).mean(dim=-1)
        else:
            progress_cost = torch.zeros_like(terminal_cost)

        cone_penalty = self.cone_loss.penalty(pred_hyp, goal_hyp, self.manifold)["loss"]
        rollout_cone = cone_penalty[..., history_size:]
        if rollout_cone.size(-1) == 0:
            rollout_cone = cone_penalty[..., -1:]
        cone_cost = rollout_cone.mean(dim=-1)

        cost = (
            float(planning_cfg.get("terminal_weight", 1.0)) * terminal_cost
            + float(planning_cfg.get("best_weight", 0.35)) * best_cost
            + float(planning_cfg.get("mean_weight", 0.15)) * mean_cost
            + float(planning_cfg.get("progress_weight", 0.10)) * progress_cost
            + float(planning_cfg.get("cone_weight", 0.08)) * cone_cost
        )

        cost = self._blend_trajectory_reachability_cost(cost, info_dict)

        info_dict.update(
            {
                "planning_terminal_cost": terminal_cost.mean().detach(),
                "planning_best_cost": best_cost.mean().detach(),
                "planning_mean_cost": mean_cost.mean().detach(),
                "planning_progress_cost": progress_cost.mean().detach(),
                "planning_cone_cost": cone_cost.mean().detach(),
            }
        )
        return cost

    def get_cost(self, info_dict: dict, action_candidates: torch.Tensor) -> torch.Tensor:
        assert "goal" in info_dict, "goal not in info_dict"

        device = next(self.parameters()).device
        for key in list(info_dict.keys()):
            if torch.is_tensor(info_dict[key]):
                info_dict[key] = info_dict[key].to(device)

        goal = {k: v[:, 0] for k, v in info_dict.items() if torch.is_tensor(v)}
        goal["pixels"] = goal["goal"]

        for key in list(goal.keys()):
            if key.startswith("goal_"):
                goal[key[len("goal_") :]] = goal.pop(key)

        goal.pop("action", None)
        goal = self.encode(goal)

        info_dict["goal_emb"] = goal["emb"]
        info_dict["goal_hyp_tangent"] = goal["hyp_tangent"]
        info_dict["goal_hyp_emb"] = goal["hyp_emb"]
        info_dict = self.rollout(info_dict, action_candidates)
        return self.criterion(info_dict)


def ensure_hyperbolic_defaults(cfg):
    with open_dict(cfg):
        if str(cfg.get("output_model_name", "")) == "lewm":
            cfg.output_model_name = "lewm_hyperbolic"

        if "data_loading" not in cfg or cfg.data_loading is None:
            cfg.data_loading = OmegaConf.create({})
        if "use_sharded_dataset" not in cfg.data_loading:
            cfg.data_loading.use_sharded_dataset = True
        if "cache_all_keys_in_memory" not in cfg.data_loading:
            cfg.data_loading.cache_all_keys_in_memory = False
        if "share_cache_across_ranks" not in cfg.data_loading:
            cfg.data_loading.share_cache_across_ranks = False
        if "shared_cache_dir" not in cfg.data_loading:
            cfg.data_loading.shared_cache_dir = ""
        if "shared_cache_chunk_bytes" not in cfg.data_loading:
            cfg.data_loading.shared_cache_chunk_bytes = 512 * 1024 * 1024

        if "hyperbolic" not in cfg or cfg.hyperbolic is None:
            cfg.hyperbolic = OmegaConf.create({})

        hyp = cfg.hyperbolic
        if "learn_curvature" not in hyp:
            hyp.learn_curvature = False
        if "curvature_init" not in hyp:
            hyp.curvature_init = 1.0
        if "max_tangent_norm" not in hyp:
            hyp.max_tangent_norm = 5.0
        if "eps" not in hyp:
            hyp.eps = 1e-5
        if "fp32_distance" not in hyp:
            hyp.fp32_distance = True
        if "cone_offset" not in hyp:
            hyp.cone_offset = int(cfg.wm.num_preds)

        if "loss_weights" not in hyp or hyp.loss_weights is None:
            hyp.loss_weights = OmegaConf.create({})
        if "pred" not in hyp.loss_weights:
            hyp.loss_weights.pred = 1.0
        if "contrastive" not in hyp.loss_weights:
            hyp.loss_weights.contrastive = 0.05
        if "cone" not in hyp.loss_weights:
            hyp.loss_weights.cone = 0.05
        if "tangent" not in hyp.loss_weights:
            hyp.loss_weights.tangent = 0.0
        if "rollout" not in hyp.loss_weights:
            hyp.loss_weights.rollout = 0.25
        if "rollout_hyp" not in hyp.loss_weights:
            hyp.loss_weights.rollout_hyp = 0.0
        if "radius" not in hyp.loss_weights:
            hyp.loss_weights.radius = 0.0

        if "rollout" not in hyp or hyp.rollout is None:
            hyp.rollout = OmegaConf.create({})
        if "enabled" not in hyp.rollout:
            hyp.rollout.enabled = True
        if "steps" not in hyp.rollout:
            hyp.rollout.steps = int(cfg.wm.history_size)
        if "warmup_steps" not in hyp.rollout:
            hyp.rollout.warmup_steps = 0

        if "stabilization" not in hyp or hyp.stabilization is None:
            hyp.stabilization = OmegaConf.create({})
        if "enabled" not in hyp.stabilization:
            hyp.stabilization.enabled = False
        if "scale_by_sqrt_dim" not in hyp.stabilization:
            hyp.stabilization.scale_by_sqrt_dim = True
        if "max_norm" not in hyp.stabilization:
            hyp.stabilization.max_norm = float(hyp.max_tangent_norm)
        if "target_norm" not in hyp.stabilization:
            hyp.stabilization.target_norm = 2.0
        if "saturation_threshold" not in hyp.stabilization:
            hyp.stabilization.saturation_threshold = 0.95

        if "finite_guard" not in hyp or hyp.finite_guard is None:
            hyp.finite_guard = OmegaConf.create({})
        if "enabled" not in hyp.finite_guard:
            hyp.finite_guard.enabled = False
        if "check_gradients" not in hyp.finite_guard:
            hyp.finite_guard.check_gradients = False

        if "contrastive" not in hyp or hyp.contrastive is None:
            hyp.contrastive = OmegaConf.create({})
        if "temperature" not in hyp.contrastive:
            hyp.contrastive.temperature = 0.2
        if "label_smoothing" not in hyp.contrastive:
            hyp.contrastive.label_smoothing = 0.0

        if "cone" not in hyp or hyp.cone is None:
            hyp.cone = OmegaConf.create({})
        if "min_aperture" not in hyp.cone:
            hyp.cone.min_aperture = 0.10
        if "max_aperture" not in hyp.cone:
            hyp.cone.max_aperture = 1.10
        if "radius_margin" not in hyp.cone:
            hyp.cone.radius_margin = 0.02
        if "angle_weight" not in hyp.cone:
            hyp.cone.angle_weight = 1.0
        if "radius_weight" not in hyp.cone:
            hyp.cone.radius_weight = 1.0

        required_future_steps = int(cfg.wm.num_preds)
        if bool(hyp.rollout.enabled):
            required_future_steps = max(required_future_steps, int(hyp.rollout.steps))

        required_num_steps = int(cfg.wm.history_size) + required_future_steps
        if int(cfg.data.dataset.num_steps) < required_num_steps:
            cfg.data.dataset.num_steps = required_num_steps


def build_hyperbolic_world_model(cfg, action_dim: int) -> HyperbolicJEPA:
    hidden_dim = None
    encoder = spt.backbone.utils.vit_hf(
        cfg.encoder_scale,
        patch_size=cfg.patch_size,
        image_size=cfg.img_size,
        pretrained=False,
        use_mask_token=False,
    )
    hidden_dim = encoder.config.hidden_size
    embed_dim = int(cfg.wm.get("embed_dim", hidden_dim))
    effective_act_dim = int(cfg.data.dataset.frameskip) * int(action_dim)

    with open_dict(cfg):
        if "manifold_dim" not in cfg.hyperbolic:
            cfg.hyperbolic.manifold_dim = embed_dim + 1
        if "head_hidden_dim" not in cfg.hyperbolic:
            cfg.hyperbolic.head_hidden_dim = 2 * embed_dim
        if int(cfg.hyperbolic.manifold_dim) < 2:
            raise ValueError("hyperbolic.manifold_dim must be at least 2.")
        cfg.wm.action_dim = int(action_dim)

    predictor = ARPredictor(
        num_frames=cfg.wm.history_size,
        input_dim=embed_dim,
        hidden_dim=hidden_dim,
        output_dim=hidden_dim,
        **cfg.predictor,
    )
    action_encoder = Embedder(input_dim=effective_act_dim, emb_dim=embed_dim)
    projector = MLP(
        input_dim=hidden_dim,
        output_dim=embed_dim,
        hidden_dim=2048,
        norm_fn=torch.nn.BatchNorm1d,
    )
    predictor_proj = MLP(
        input_dim=hidden_dim,
        output_dim=embed_dim,
        hidden_dim=2048,
        norm_fn=torch.nn.BatchNorm1d,
    )

    manifold = LorentzManifold(
        curvature_init=float(cfg.hyperbolic.curvature_init),
        learn_curvature=bool(cfg.hyperbolic.learn_curvature),
        max_tangent_norm=float(cfg.hyperbolic.max_tangent_norm),
        eps=float(cfg.hyperbolic.eps),
        fp32_distance=bool(cfg.hyperbolic.fp32_distance),
    )
    hyper_projector = MLP(
        input_dim=embed_dim,
        output_dim=int(cfg.hyperbolic.manifold_dim) - 1,
        hidden_dim=int(cfg.hyperbolic.head_hidden_dim),
        norm_fn=torch.nn.LayerNorm,
    )
    cone_loss = AdaptiveEntailmentConeLoss(
        **OmegaConf.to_container(cfg.hyperbolic.cone, resolve=True),
    )
    contrastive_loss = LorentzContrastiveLoss(
        **OmegaConf.to_container(cfg.hyperbolic.contrastive, resolve=True),
    )

    return HyperbolicJEPA(
        encoder=encoder,
        predictor=predictor,
        action_encoder=action_encoder,
        projector=projector,
        pred_proj=predictor_proj,
        hyper_projector=hyper_projector,
        manifold=manifold,
        cone_loss=cone_loss,
        contrastive_loss=contrastive_loss,
        tangent_stabilization=OmegaConf.to_container(
            cfg.hyperbolic.stabilization,
            resolve=True,
        ),
    )


def resolve_accelerator(cfg) -> str:
    requested = str(cfg.trainer.get("accelerator", "auto")).lower()

    if requested == "auto":
        resolved = resolve_runtime_device("auto")
        with open_dict(cfg):
            cfg.trainer.accelerator = resolved
        print(f"[runtime] auto-selected accelerator={resolved}", flush=True)
        return resolved

    if requested == "gpu" and not torch.cuda.is_available():
        resolved = resolve_runtime_device("auto")
        with open_dict(cfg):
            cfg.trainer.accelerator = resolved
        print(
            f"[runtime] accelerator=gpu requested but no CUDA backend is available; "
            f"falling back to accelerator={resolved}",
            flush=True,
        )
        return resolved

    return requested


def hyperbolic_forward(self, batch, stage, cfg):
    ctx_len = int(cfg.wm.history_size)
    n_preds = int(cfg.wm.num_preds)
    sigreg_weight = float(cfg.loss.sigreg.weight)
    loss_weights = cfg.hyperbolic.loss_weights
    rollout_cfg = cfg.hyperbolic.rollout

    batch["action"] = torch.nan_to_num(
        batch["action"],
        nan=0.0,
        posinf=0.0,
        neginf=0.0,
    )
    output = self.model.encode(batch)

    emb = output["emb"]
    hyp_emb = output["hyp_emb"]
    act_emb = output["act_emb"]

    ctx_emb = emb[:, :ctx_len]
    ctx_act = act_emb[:, :ctx_len]
    tgt_emb = emb[:, n_preds:]
    tgt_hyp = hyp_emb[:, n_preds:]

    pred_emb = self.model.predict(ctx_emb, ctx_act)
    aligned_steps = min(pred_emb.size(1), tgt_emb.size(1))
    if aligned_steps <= 0:
        raise ValueError(
            f"Expected at least one aligned prediction step, got pred={pred_emb.size(1)} target={tgt_emb.size(1)}."
        )
    pred_emb = pred_emb[:, :aligned_steps]
    tgt_emb = tgt_emb[:, :aligned_steps]
    tgt_hyp = tgt_hyp[:, :aligned_steps]
    _, pred_hyp = self.model.to_hyperbolic(pred_emb)

    cone_offset = int(cfg.hyperbolic.cone_offset)
    cone_offset = max(1, min(cone_offset, hyp_emb.size(1) - 1))
    parent_hyp = hyp_emb[:, :-cone_offset]
    child_hyp = hyp_emb[:, cone_offset:]

    cone_out = self.model.cone_loss(parent_hyp, child_hyp, self.model.manifold)
    contrastive_out = self.model.contrastive_loss(pred_hyp, tgt_hyp, self.model.manifold)

    output["pred_loss"] = self.model.manifold.dist(pred_hyp, tgt_hyp).pow(2).mean()
    output["tangent_loss"] = (pred_emb - tgt_emb).pow(2).mean()
    target_tangent_norm = float(cfg.hyperbolic.stabilization.target_norm)
    output["tangent_radius_loss"] = F.relu(
        output["scaled_tangent_norm"] - target_tangent_norm
    ).pow(2).mean()
    rollout_steps = 0
    if bool(rollout_cfg.enabled):
        rollout_steps = min(int(rollout_cfg.steps), emb.size(1) - ctx_len)
    if rollout_steps > 0:
        rollout_pred_emb, rollout_pred_hyp = self.model.rollout_from_encoded(
            emb,
            act_emb,
            history_size=ctx_len,
            rollout_steps=rollout_steps,
        )
        rollout_tgt_emb = emb[:, ctx_len : ctx_len + rollout_steps]
        rollout_tgt_hyp = hyp_emb[:, ctx_len : ctx_len + rollout_steps]
        output["rollout_loss"] = (rollout_pred_emb - rollout_tgt_emb).pow(2).mean()
        output["rollout_hyp_loss"] = (
            self.model.manifold.dist(rollout_pred_hyp, rollout_tgt_hyp).pow(2).mean()
        )
    else:
        output["rollout_loss"] = torch.zeros_like(output["tangent_loss"])
        output["rollout_hyp_loss"] = torch.zeros_like(output["pred_loss"])
    output["sigreg_loss"] = self.sigreg(emb.transpose(0, 1))
    output.update(cone_out)
    output.update(contrastive_out)

    rollout_warmup_steps = int(rollout_cfg.warmup_steps)
    rollout_weight_scale = 1.0
    if rollout_warmup_steps > 0:
        rollout_weight_scale = min(
            1.0,
            float(int(getattr(self, "global_step", 0)) + 1) / float(rollout_warmup_steps),
        )
    output["rollout_weight_scale"] = output["pred_loss"].new_tensor(rollout_weight_scale)

    output["loss"] = (
        float(loss_weights.pred) * output["pred_loss"]
        + sigreg_weight * output["sigreg_loss"]
        + float(loss_weights.contrastive) * output["contrastive_loss"]
        + float(loss_weights.cone) * output["cone_loss"]
        + float(loss_weights.tangent) * output["tangent_loss"]
        + rollout_weight_scale * float(loss_weights.rollout) * output["rollout_loss"]
        + rollout_weight_scale * float(loss_weights.rollout_hyp) * output["rollout_hyp_loss"]
        + float(loss_weights.radius) * output["tangent_radius_loss"]
    )

    if bool(cfg.hyperbolic.finite_guard.enabled):
        guarded_values = {
            key: value
            for key, value in output.items()
            if key.endswith("loss")
            or key
            in {
                "raw_tangent_norm",
                "scaled_tangent_norm",
                "bounded_tangent_norm",
                "tangent_saturation_fraction",
            }
        }
        bad_names = _non_finite_tensor_names(guarded_values)
        if bad_names:
            raise FloatingPointError(
                "Detected non-finite forward tensors before optimizer.step "
                f"at stage={stage} global_step={int(getattr(self, 'global_step', 0))}. "
                f"Affected tensors: {', '.join(bad_names)}."
            )

    losses_dict = {f"{stage}/{k}": v.detach() for k, v in output.items() if "loss" in k}
    self.log_dict(losses_dict, on_step=True, on_epoch=True, sync_dist=True)

    metric_keys = {
        "contrastive_pos_dist",
        "contrastive_neg_dist",
        "cone_aperture",
        "parent_radius",
        "child_radius",
        "raw_tangent_norm_mean",
        "scaled_tangent_norm_mean",
        "bounded_tangent_norm_mean",
        "tangent_saturation_fraction_mean",
        "rollout_weight_scale",
    }
    output["raw_tangent_norm_mean"] = output["raw_tangent_norm"].mean()
    output["scaled_tangent_norm_mean"] = output["scaled_tangent_norm"].mean()
    output["bounded_tangent_norm_mean"] = output["bounded_tangent_norm"].mean()
    output["tangent_saturation_fraction_mean"] = output["tangent_saturation_fraction"].mean()
    metrics = {f"{stage}/{k}": v.detach() for k, v in output.items() if k in metric_keys}
    metrics[f"{stage}/curvature"] = self.model.manifold.curvature.detach()
    self.log_dict(metrics, on_step=True, on_epoch=True, sync_dist=True)
    return output


def run_hyperbolic_training(cfg):
    ensure_hyperbolic_defaults(cfg)
    print(
        "[train] rollout loss config: "
        f"enabled={bool(cfg.hyperbolic.rollout.enabled)} "
        f"steps={int(cfg.hyperbolic.rollout.steps)} "
        f"warmup_steps={int(cfg.hyperbolic.rollout.warmup_steps)} "
        f"euclidean_weight={float(cfg.hyperbolic.loss_weights.rollout)} "
        f"hyperbolic_weight={float(cfg.hyperbolic.loss_weights.rollout_hyp)} "
        f"dataset.num_steps={int(cfg.data.dataset.num_steps)}",
        flush=True,
    )
    print(
        "[train] tangent stabilization: "
        f"enabled={bool(cfg.hyperbolic.stabilization.enabled)} "
        f"scale_by_sqrt_dim={bool(cfg.hyperbolic.stabilization.scale_by_sqrt_dim)} "
        f"max_norm={float(cfg.hyperbolic.stabilization.max_norm)} "
        f"target_norm={float(cfg.hyperbolic.stabilization.target_norm)} "
        f"radius_weight={float(cfg.hyperbolic.loss_weights.radius)}",
        flush=True,
    )
    accelerator_name = resolve_accelerator(cfg)
    maybe_enable_npu(accelerator_name)
    if str(accelerator_name).lower() == "npu":
        with open_dict(cfg):
            if cfg.trainer.get("devices", "auto") == "auto":
                cfg.trainer.devices = torch.npu.device_count()
            if cfg.loader.get("pin_memory", False):
                cfg.loader.pin_memory = False
    if bool(cfg.data_loading.get("use_sharded_dataset", True)):
        maybe_resolve_sharded_dataset(cfg)
    else:
        maybe_resolve_full_dataset(cfg)

    cache_keys = resolve_dataset_cache_keys(cfg)
    use_shared_cache = bool(cfg.data_loading.get("share_cache_across_ranks", False)) and len(cache_keys) > 0
    dataset_kwargs = build_hdf5_dataset_kwargs(cfg, cache_keys=cache_keys, use_shared_cache=use_shared_cache)
    print(
        "[dataset-diag] loader_mode="
        f"{'sharded' if bool(cfg.data_loading.get('use_sharded_dataset', True)) else 'full-dataset'} "
        f"cache_all_keys_in_memory={bool(cfg.data_loading.get('cache_all_keys_in_memory', False))} "
        f"share_cache_across_ranks={use_shared_cache} "
        f"keys_to_cache={cache_keys}",
        flush=True,
    )
    dataset = swm.data.HDF5Dataset(**dataset_kwargs, transform=None)
    if use_shared_cache:
        attach_shared_cache_to_dataset(dataset, cache_keys=cache_keys, cfg=cfg)
    validate_hdf5_episode_metadata(dataset)
    skip_resize = dataset_has_preprocessed_pixels(dataset, cfg.img_size)
    print_dataset_diagnostics(dataset, skip_resize)

    transforms = [
        get_img_preprocessor(
            source="pixels",
            target="pixels",
            img_size=cfg.img_size,
            resize=not skip_resize,
        )
    ]

    with open_dict(cfg):
        for col in cfg.data.dataset.keys_to_load:
            if col.startswith("pixels"):
                continue
            transforms.append(get_column_normalizer(dataset, col, col))
            setattr(cfg.wm, f"{col}_dim", dataset.get_dim(col))

    dataset.transform = spt.data.transforms.Compose(*transforms)

    generator = torch.Generator().manual_seed(cfg.seed)
    train_set, val_set = spt.data.random_split(
        dataset, lengths=[cfg.train_split, 1 - cfg.train_split], generator=generator
    )

    sequence_keys = tuple(cfg.data.dataset.keys_to_load)
    dataset_label = str(getattr(dataset, "h5_path", cfg.data.dataset.name))
    train_set = SafeSequenceDataset(
        train_set,
        cfg.data.dataset.num_steps,
        sequence_keys,
        dataset_label=f"train:{dataset_label}",
    )
    val_set = SafeSequenceDataset(
        val_set,
        cfg.data.dataset.num_steps,
        sequence_keys,
        dataset_label=f"val:{dataset_label}",
    )

    loader_kwargs = OmegaConf.to_container(cfg.loader, resolve=True)
    if int(loader_kwargs.get("num_workers", 0)) == 0:
        loader_kwargs.pop("prefetch_factor", None)
        loader_kwargs["persistent_workers"] = False

    train_loader = torch.utils.data.DataLoader(
        train_set,
        **loader_kwargs,
        shuffle=True,
        drop_last=True,
        generator=generator,
    )
    val_loader = torch.utils.data.DataLoader(
        val_set,
        **loader_kwargs,
        shuffle=False,
        drop_last=False,
    )

    world_model = build_hyperbolic_world_model(cfg, action_dim=int(cfg.wm.action_dim))

    optimizers = {
        "model_opt": {
            "modules": "model",
            "optimizer": dict(cfg.optimizer),
            "scheduler": {"type": "LinearWarmupCosineAnnealingLR"},
            "interval": "epoch",
        },
    }

    data_module = spt.data.DataModule(train=train_loader, val=val_loader)
    module = spt.Module(
        model=world_model,
        sigreg=SIGReg(**cfg.loss.sigreg.kwargs),
        forward=partial(hyperbolic_forward, cfg=cfg),
        optim=optimizers,
    )

    run_id = cfg.get("subdir") or ""
    run_dir = Path(swm.data.utils.get_cache_dir(), run_id)

    logger = None
    if cfg.wandb.enabled and is_rank_zero_process():
        logger = WandbLogger(**cfg.wandb.config)
        logger.log_hyperparams(OmegaConf.to_container(cfg))

    run_dir.mkdir(parents=True, exist_ok=True)
    if is_rank_zero_process():
        with open(run_dir / "config.yaml", "w") as handle:
            OmegaConf.save(cfg, handle)

    callbacks = []
    if bool(cfg.get("dump_object", True)):
        callbacks.append(
            ModelObjectCallBack(
                dirpath=run_dir,
                filename=cfg.output_model_name,
                epoch_interval=1,
            )
        )
    callbacks.append(
        LossHistoryCallback(
        dirpath=run_dir,
        filename=f"{cfg.output_model_name}_losses.txt",
        )
    )
    if bool(cfg.hyperbolic.finite_guard.check_gradients):
        callbacks.append(NonFiniteGradientCallback())

    trainer_kwargs = OmegaConf.to_container(cfg.trainer, resolve=True)
    num_sanity_val_steps = int(trainer_kwargs.pop("num_sanity_val_steps", 1))
    enable_checkpointing = bool(trainer_kwargs.pop("enable_checkpointing", True))
    if str(accelerator_name).lower() == "npu":
        npu_accelerator = NPUAccelerator()
        parsed_devices, parallel_devices = resolve_npu_devices(trainer_kwargs.get("devices", 1))
        is_single_device = len(parsed_devices) == 1
        trainer_kwargs.pop("accelerator", None)
        trainer_kwargs.pop("devices", None)
        if is_single_device:
            trainer_kwargs["strategy"] = SingleDeviceStrategy(
                device=parallel_devices[0],
                accelerator=npu_accelerator,
            )
        else:
            trainer_kwargs["strategy"] = NPUDDPStrategy(
                accelerator=npu_accelerator,
                parallel_devices=parallel_devices,
                process_group_backend="hccl",
                start_method="popen",
            )

    trainer = pl.Trainer(
        **trainer_kwargs,
        callbacks=callbacks,
        num_sanity_val_steps=num_sanity_val_steps,
        logger=logger,
        enable_checkpointing=enable_checkpointing,
    )

    manager = spt.Manager(
        trainer=trainer,
        module=module,
        data=data_module,
        ckpt_path=run_dir / f"{cfg.output_model_name}_weights.ckpt",
    )
    manager()


@hydra.main(version_base=None, config_path="./config/train", config_name="lewm_hyperbolic")
def run(cfg):
    run_hyperbolic_training(cfg)


@record
def _main():
    faulthandler.enable(all_threads=True)
    run()


if __name__ == "__main__":
    _main()