| """
|
| 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()
|
|
|
