| """ |
| Core Poincaré Ball Operations. |
| |
| All ops run in fp32 via @_fp32 decorator regardless of ambient mixed-precision. |
| """ |
| import torch |
| import torch.nn as nn |
| import torch.nn.functional as F |
| import functools |
|
|
| MIN_NORM = 1e-15 |
| BALL_EPS = 1e-5 |
| TANH_CLAMP = 15.0 |
|
|
|
|
| def _fp32(fn): |
| """Disable autocast, cast inputs to fp32, cast output back.""" |
| @functools.wraps(fn) |
| def wrapper(*args, **kwargs): |
| with torch.amp.autocast(device_type="cuda", enabled=False): |
| orig = None |
| for a in args: |
| if torch.is_tensor(a): |
| orig = a.dtype; break |
| if orig is None: |
| for v in kwargs.values(): |
| if torch.is_tensor(v): |
| orig = v.dtype; break |
| orig = orig or torch.float32 |
| a32 = [a.float() if torch.is_tensor(a) else a for a in args] |
| k32 = {k: v.float() if torch.is_tensor(v) else v for k, v in kwargs.items()} |
| r = fn(*a32, **k32) |
| return r.to(orig) if torch.is_tensor(r) else r |
| return wrapper |
|
|
|
|
| def safe_arctanh(x): |
| return torch.atanh(x.clamp(-1 + 1e-7, 1 - 1e-7)) |
|
|
| def safe_tanh(x): |
| return torch.tanh(x.clamp(-TANH_CLAMP, TANH_CLAMP)) |
|
|
| def clamp_norm(x, c, eps=BALL_EPS): |
| max_norm = (1.0 / torch.sqrt(c)) - eps |
| norm = x.norm(dim=-1, keepdim=True).clamp(min=MIN_NORM) |
| return torch.where(norm > max_norm, x / norm * max_norm, x) |
|
|
|
|
| @_fp32 |
| def exp_map_zero(v, c): |
| """Tangent space → Poincaré ball at origin.""" |
| sqrt_c = torch.sqrt(c) |
| v_norm = v.norm(dim=-1, keepdim=True).clamp(min=MIN_NORM) |
| factor = safe_tanh(sqrt_c * v_norm) / sqrt_c |
| return clamp_norm(factor * (v / v_norm), c) |
|
|
|
|
| @_fp32 |
| def log_map_zero(x, c): |
| """Poincaré ball → tangent space at origin.""" |
| sqrt_c = torch.sqrt(c) |
| x_norm = x.norm(dim=-1, keepdim=True).clamp(min=MIN_NORM) |
| factor = safe_arctanh(sqrt_c * x_norm) / (sqrt_c * x_norm) |
| return factor * x |
|
|
|
|
| @_fp32 |
| def mobius_add(u, v, c): |
| """Möbius addition u ⊕_c v.""" |
| u2 = (u * u).sum(-1, keepdim=True) |
| v2 = (v * v).sum(-1, keepdim=True) |
| uv = (u * v).sum(-1, keepdim=True) |
| num = (1 + 2 * c * uv + c * v2) * u + (1 - c * u2) * v |
| den = (1 + 2 * c * uv + c * c * u2 * v2).clamp(min=MIN_NORM) |
| return num / den |
|
|
|
|
| @_fp32 |
| def hyperbolic_distance(x, y, c): |
| """d_c(x, y) in Poincaré ball.""" |
| sqrt_c = torch.sqrt(c) |
| diff = mobius_add(-x, y, c) |
| return (2.0 / sqrt_c) * safe_arctanh(sqrt_c * diff.norm(dim=-1).clamp(min=MIN_NORM)) |
|
|
|
|
| @_fp32 |
| def poincare_radius(x, c): |
| """d_c(0, x) = (2/√c) · artanh(√c · ‖x‖).""" |
| sqrt_c = torch.sqrt(c) |
| return (2.0 / sqrt_c) * safe_arctanh(sqrt_c * x.norm(dim=-1).clamp(min=MIN_NORM)) |
|
|
|
|
| @_fp32 |
| def einstein_midpoint(points, weights, c): |
| """Weighted Einstein midpoint. points: (..., N, d), weights: (..., N).""" |
| p2 = (points * points).sum(-1, keepdim=True) |
| klein = 2.0 * points / (1.0 + c * p2).clamp(min=MIN_NORM) |
| k2 = (klein * klein).sum(-1, keepdim=True) |
| gamma = 1.0 / torch.sqrt((1.0 - c * k2).clamp(min=MIN_NORM)) |
| w = weights.unsqueeze(-1) |
| wg = w * gamma |
| k_bar = (wg * klein).sum(-2) / wg.sum(-2).clamp(min=MIN_NORM) |
| kb2 = (k_bar * k_bar).sum(-1, keepdim=True) |
| denom = 1.0 + torch.sqrt((1.0 - c * kb2).clamp(min=MIN_NORM)) |
| return clamp_norm(k_bar / denom.clamp(min=MIN_NORM), c) |
|
|
|
|
| class LearnableCurvature(nn.Module): |
| """c = clamp(softplus(hat_c) + c_min, max=c_max).""" |
| def __init__(self, init_value=1.0, c_min=0.01, c_max=None): |
| super().__init__() |
| self.c_min = c_min |
| self.c_max = c_max |
| delta = init_value - c_min |
| assert delta > 0, f"init_value({init_value}) must > c_min({c_min})" |
| if delta > 20.0: |
| init_hat = torch.tensor(delta, dtype=torch.float32) |
| else: |
| init_hat = torch.log(torch.expm1(torch.tensor(delta, dtype=torch.float32))) |
| self.hat_c = nn.Parameter(init_hat) |
|
|
| def forward(self): |
| c = F.softplus(self.hat_c) + self.c_min |
| if self.c_max is not None: |
| c = c.clamp(max=self.c_max) |
| return c |
|
|
