Upload 2 files

infer_upsample.py

@@ -0,0 +1,766 @@
+"""
+infer_upsample.py
+=================
+使用训练好的 Transformer，从粗尺度（Ln）自回归生成细尺度（L(n-1)）。
+
+flow：
+  1. 读取粗尺度量化数据（.npz）
+  2. 为每个粗节点构造前缀序列（parent + uncles）
+  3. 自回归生成子节点：
+       - role 用 softmax 采样（4类）
+       - xyz / opacity 用回归预测
+       - scale/rot/dc/sh 用 embedding 最近邻搜索还原 codebook 索引
+  4. 将子节点 codebook 索引解码为真实属性（查表）
+  5. 写出新的 .ply 文件
+
+role 编码：
+  0 = parent   1 = uncle   2 = child   3 = EOS   4 = PAD
+"""
+
+import os
+import argparse
+import numpy as np
+
+import torch
+import torch.nn.functional as F
+from plyfile import PlyData, PlyElement
+
+# ─────────────────────────────────────────────
+# 常量（与 train_transformer.py 一致）
+# ─────────────────────────────────────────────
+
+ROLE_PARENT  = 0
+ROLE_UNCLE   = 1
+ROLE_CHILD   = 2
+ROLE_EOS     = 3
+ROLE_PAD     = 4
+
+MAX_CHILDREN = 32
+MAX_UNCLES   = 4
+MAX_SEQ_LEN  = 1 + MAX_UNCLES + MAX_CHILDREN + 1   # = 38
+
+N_SCALE  = 16384
+N_ROT    = 16384
+N_DC     = 4096
+N_SH     = 4096
+N_ROLE   = 4
+
+OPACITY_MIN_LOGIT = -20.0
+OPACITY_MAX_LOGIT = 20.0
+
+TOKEN_DTYPE = np.dtype([
+    ('dx',         np.float32),
+    ('dy',         np.float32),
+    ('dz',         np.float32),
+    ('scale_idx',  np.int32),
+    ('rot_idx',    np.int32),
+    ('dc_idx',     np.int32),
+    ('sh_idx',     np.int32),
+    ('opacity',    np.float32),
+    ('role',       np.uint8),
+])
+
+
+# ─────────────────────────────────────────────
+# 1. 加载模型
+# ─────────────────────────────────────────────
+
+def load_model(ckpt_path: str, device: str = 'cpu'):
+    from train_transformer import SplitTransformer
+
+    ckpt   = torch.load(ckpt_path, map_location=device)
+    config = ckpt.get('config', {})
+    model  = SplitTransformer(**config).to(device)
+    state  = ckpt.get('model_state', ckpt)
+    model.load_state_dict(state)
+    model.eval()
+    print(f"[load] {os.path.basename(ckpt_path)}  "
+          f"d_model={config.get('d_model')}, "
+          f"n_layers={config.get('n_layers')}, "
+          f"d_cb={config.get('d_cb')}")
+    return model
+
+
+# ─────────────────────────────────────────────
+# 2. 加载 codebook（用于最终解码索引→真实属性）
+# ─────────────────────────────────────────────
+
+def load_codebooks(codebook_dir: str) -> dict:
+    cbs = {}
+    for name in ['scale', 'rotation', 'dc', 'sh']:
+        path = os.path.join(codebook_dir, f"{name}_codebook.npz")
+        cbs[name] = np.load(path)['codebook'].astype(np.float32)
+        print(f"[load] {name}_codebook: {cbs[name].shape}")
+    return cbs
+
+
+# ─────────────────────────────────────────────
+# 3. 加载量化数据
+# ─────────────────────────────────────────────
+
+def load_quantized(npz_path: str) -> dict:
+    npz = np.load(npz_path)
+    return {
+        'scale_indices':    npz['scale_indices'],
+        'rotation_indices': npz['rotation_indices'],
+        'dc_indices':       npz['dc_indices'],
+        'sh_indices':       npz['sh_indices'],
+        'positions':        npz['positions'],
+        'opacities':        npz['opacities'].squeeze(),
+    }
+
+
+# ─────────────────────────────────────────────
+# 4. 构造前缀 batch（parent + uncles）
+# ─────────────────────────────────────────────
+
+def _make_np_token(gauss_idx: int, quant: dict,
+                   parent_pos: np.ndarray, role: int) -> np.ndarray:
+    pos   = quant['positions'][gauss_idx]
+    delta = pos - parent_pos
+    token = np.zeros(1, dtype=TOKEN_DTYPE)
+    token['dx']        = delta[0]
+    token['dy']        = delta[1]
+    token['dz']        = delta[2]
+    token['scale_idx'] = quant['scale_indices'][gauss_idx]
+    token['rot_idx']   = quant['rotation_indices'][gauss_idx]
+    token['dc_idx']    = quant['dc_indices'][gauss_idx]
+    token['sh_idx']    = quant['sh_indices'][gauss_idx]
+    token['opacity']   = quant['opacities'][gauss_idx] / 10.0   # 与训��归一化一致
+    token['role']      = role
+    return token[0]
+
+
+def _seq_to_batch(seq: np.ndarray, device: str) -> dict:
+    L   = len(seq)
+    xyz = np.stack([seq['dx'], seq['dy'], seq['dz']], axis=1)
+    return {
+        'xyz':       torch.tensor(xyz, device=device).float().unsqueeze(0),
+        'scale':     torch.tensor(seq['scale_idx'].astype(np.int64), device=device).unsqueeze(0),
+        'rot':       torch.tensor(seq['rot_idx'].astype(np.int64),   device=device).unsqueeze(0),
+        'dc':        torch.tensor(seq['dc_idx'].astype(np.int64),    device=device).unsqueeze(0),
+        'sh':        torch.tensor(seq['sh_idx'].astype(np.int64),    device=device).unsqueeze(0),
+        'opacity':   torch.tensor(seq['opacity'].astype(np.float32), device=device).unsqueeze(0),
+        'role':      torch.tensor(seq['role'].astype(np.int64),      device=device).unsqueeze(0),
+        'attn_mask': torch.ones(1, L, dtype=torch.bool, device=device),
+    }
+
+
+def make_prefix_batch(p_idx: int, quant: dict,
+                      max_uncles: int = MAX_UNCLES,
+                      device: str = 'cpu') -> tuple:
+    N          = quant['positions'].shape[0]
+    parent_pos = quant['positions'][p_idx]
+    tokens     = []
+
+    # parent（坐标置零）
+    t = _make_np_token(p_idx, quant, parent_pos, ROLE_PARENT)
+    t['dx'] = t['dy'] = t['dz'] = 0.0
+    tokens.append(t)
+
+    # uncles
+    half = max_uncles // 2
+    added = 0
+    for offset in list(range(-half, 0)) + list(range(1, half + 1)):
+        u_idx = p_idx + offset
+        if 0 <= u_idx < N and added < max_uncles:
+            tokens.append(_make_np_token(u_idx, quant, parent_pos, ROLE_UNCLE))
+            added += 1
+
+    return _seq_to_batch(np.array(tokens, dtype=TOKEN_DTYPE), device), parent_pos
+
+
+def _append_token(batch: dict, token_np: np.ndarray, device: str) -> dict:
+    new_xyz = torch.tensor(
+        [[[token_np['dx'], token_np['dy'], token_np['dz']]]],
+        dtype=torch.float32, device=device
+    )
+    def cat(key, val, dtype):
+        return torch.cat([batch[key],
+                          torch.tensor([[val]], dtype=dtype, device=device)], dim=1)
+    return {
+        'xyz':       torch.cat([batch['xyz'], new_xyz], dim=1),
+        'scale':     cat('scale',   int(token_np['scale_idx']), torch.int64),
+        'rot':       cat('rot',     int(token_np['rot_idx']),   torch.int64),
+        'dc':        cat('dc',      int(token_np['dc_idx']),    torch.int64),
+        'sh':        cat('sh',      int(token_np['sh_idx']),    torch.int64),
+        'opacity':   cat('opacity', float(token_np['opacity']), torch.float32),
+        'role':      cat('role',    int(token_np['role']),      torch.int64),
+        'attn_mask': torch.cat([batch['attn_mask'],
+                                torch.ones(1, 1, dtype=torch.bool, device=device)], dim=1),
+    }
+
+
+def make_prefix_batch_many(p_indices: np.ndarray,
+                           quant: dict,
+                           max_uncles: int = MAX_UNCLES,
+                           device: str = 'cpu') -> tuple:
+    """Build a padded prefix batch for multiple parent points."""
+    rows = []
+    parent_positions = quant['positions'][p_indices]
+    lengths = []
+
+    for p_idx, parent_pos in zip(p_indices, parent_positions):
+        tokens = []
+
+        t = _make_np_token(int(p_idx), quant, parent_pos, ROLE_PARENT)
+        t['dx'] = t['dy'] = t['dz'] = 0.0
+        tokens.append(t)
+
+        n_points = quant['positions'].shape[0]
+        half = max_uncles // 2
+        added = 0
+        for offset in list(range(-half, 0)) + list(range(1, half + 1)):
+            u_idx = int(p_idx) + offset
+            if 0 <= u_idx < n_points and added < max_uncles:
+                tokens.append(_make_np_token(u_idx, quant, parent_pos, ROLE_UNCLE))
+                added += 1
+
+        row = np.array(tokens, dtype=TOKEN_DTYPE)
+        rows.append(row)
+        lengths.append(len(row))
+
+    batch_size = len(rows)
+    max_len = max(lengths) if lengths else 0
+
+    xyz = np.zeros((batch_size, max_len, 3), dtype=np.float32)
+    scale = np.zeros((batch_size, max_len), dtype=np.int64)
+    rot = np.zeros((batch_size, max_len), dtype=np.int64)
+    dc = np.zeros((batch_size, max_len), dtype=np.int64)
+    sh = np.zeros((batch_size, max_len), dtype=np.int64)
+    opacity = np.zeros((batch_size, max_len), dtype=np.float32)
+    role = np.full((batch_size, max_len), ROLE_PAD, dtype=np.int64)
+    attn_mask = np.zeros((batch_size, max_len), dtype=bool)
+
+    for i, row in enumerate(rows):
+        L = len(row)
+        xyz[i, :L, :] = np.stack([row['dx'], row['dy'], row['dz']], axis=1)
+        scale[i, :L] = row['scale_idx'].astype(np.int64)
+        rot[i, :L] = row['rot_idx'].astype(np.int64)
+        dc[i, :L] = row['dc_idx'].astype(np.int64)
+        sh[i, :L] = row['sh_idx'].astype(np.int64)
+        opacity[i, :L] = row['opacity'].astype(np.float32)
+        role[i, :L] = row['role'].astype(np.int64)
+        attn_mask[i, :L] = True
+
+    batch = {
+        'xyz': torch.from_numpy(xyz).to(device=device, dtype=torch.float32),
+        'scale': torch.from_numpy(scale).to(device=device, dtype=torch.int64),
+        'rot': torch.from_numpy(rot).to(device=device, dtype=torch.int64),
+        'dc': torch.from_numpy(dc).to(device=device, dtype=torch.int64),
+        'sh': torch.from_numpy(sh).to(device=device, dtype=torch.int64),
+        'opacity': torch.from_numpy(opacity).to(device=device, dtype=torch.float32),
+        'role': torch.from_numpy(role).to(device=device, dtype=torch.int64),
+        'attn_mask': torch.from_numpy(attn_mask).to(device=device, dtype=torch.bool),
+    }
+    return batch, parent_positions.astype(np.float32), torch.tensor(lengths, device=device, dtype=torch.long)
+
+
+def _append_tokens_batched(batch: dict,
+                           row_idx: torch.Tensor,
+                           lengths: torch.Tensor,
+                           child_data: dict,
+                           device: str) -> dict:
+    """Append one generated child token for each active row."""
+    if row_idx.numel() == 0:
+        return batch
+
+    next_len = int(lengths[row_idx].max().item()) + 1
+    cur_len = batch['role'].shape[1]
+    if next_len > cur_len:
+        pad_len = next_len - cur_len
+        B = batch['role'].shape[0]
+        batch = {
+            'xyz': torch.cat([batch['xyz'], torch.zeros(B, pad_len, 3, device=device)], dim=1),
+            'scale': torch.cat([batch['scale'], torch.zeros(B, pad_len, dtype=torch.long, device=device)], dim=1),
+            'rot': torch.cat([batch['rot'], torch.zeros(B, pad_len, dtype=torch.long, device=device)], dim=1),
+            'dc': torch.cat([batch['dc'], torch.zeros(B, pad_len, dtype=torch.long, device=device)], dim=1),
+            'sh': torch.cat([batch['sh'], torch.zeros(B, pad_len, dtype=torch.long, device=device)], dim=1),
+            'opacity': torch.cat([batch['opacity'], torch.zeros(B, pad_len, device=device)], dim=1),
+            'role': torch.cat([batch['role'], torch.full((B, pad_len), ROLE_PAD, dtype=torch.long, device=device)], dim=1),
+            'attn_mask': torch.cat([batch['attn_mask'], torch.zeros(B, pad_len, dtype=torch.bool, device=device)], dim=1),
+        }
+
+    pos = lengths[row_idx]
+    batch['xyz'][row_idx, pos, :] = child_data['xyz']
+    batch['scale'][row_idx, pos] = child_data['scale']
+    batch['rot'][row_idx, pos] = child_data['rot']
+    batch['dc'][row_idx, pos] = child_data['dc']
+    batch['sh'][row_idx, pos] = child_data['sh']
+    batch['opacity'][row_idx, pos] = child_data['opacity_norm']
+    batch['role'][row_idx, pos] = ROLE_CHILD
+    batch['attn_mask'][row_idx, pos] = True
+    lengths[row_idx] += 1
+    return batch
+
+
+def _sample_roles_batched(logits: torch.Tensor,
+                          temperature: float,
+                          top_k: int) -> torch.Tensor:
+    logits = logits / max(temperature, 1e-8)
+    if top_k > 0:
+        k = min(top_k, logits.shape[-1])
+        topk_vals, _ = torch.topk(logits, k, dim=-1)
+        threshold = topk_vals[:, -1].unsqueeze(-1)
+        logits = logits.masked_fill(logits < threshold, float('-inf'))
+    probs = F.softmax(logits, dim=-1)
+    return torch.multinomial(probs, 1).squeeze(1)
+
+
+def _nearest_codebook_batched(pred_emb: torch.Tensor,
+                              cb_norm: torch.Tensor) -> torch.Tensor:
+    pred_norm = F.normalize(pred_emb, dim=-1, eps=1e-8)
+    return torch.matmul(pred_norm, cb_norm.t()).argmax(dim=-1)
+
+
+def prepare_codebook_norms(model) -> dict:
+    with torch.no_grad():
+        return {
+            'scale': F.normalize(model.get_cb_emb('scale'), dim=-1, eps=1e-8),
+            'rot': F.normalize(model.get_cb_emb('rot'), dim=-1, eps=1e-8),
+            'dc': F.normalize(model.get_cb_emb('dc'), dim=-1, eps=1e-8),
+            'sh': F.normalize(model.get_cb_emb('sh'), dim=-1, eps=1e-8),
+        }
+
+
+def alpha_to_logit(alpha: float) -> float:
+    alpha = float(np.clip(alpha, 1e-6, 1.0 - 1e-6))
+    return float(np.log(alpha / (1.0 - alpha)))
+
+
+def opacity_clip_from_alpha(min_alpha: float, max_alpha: float) -> tuple:
+    min_logit = OPACITY_MIN_LOGIT if min_alpha <= 0.0 else alpha_to_logit(min_alpha)
+    max_logit = OPACITY_MAX_LOGIT if max_alpha >= 1.0 else alpha_to_logit(max_alpha)
+    if min_logit > max_logit:
+        raise ValueError(
+            f"opacity_min_alpha must be <= opacity_max_alpha, got {min_alpha} > {max_alpha}"
+        )
+    return min_logit, max_logit
+
+
+def normalize_quaternions_np(rotations: np.ndarray) -> np.ndarray:
+    rotations = rotations.astype(np.float32, copy=True)
+    norms = np.linalg.norm(rotations, axis=1, keepdims=True)
+    valid = np.isfinite(norms) & (norms > 1e-8)
+    rotations = np.where(valid, rotations / np.maximum(norms, 1e-8), rotations)
+    bad = ~valid.squeeze(1)
+    if bad.any():
+        rotations[bad] = np.array([1.0, 0.0, 0.0, 0.0], dtype=np.float32)
+    return rotations
+
+
+# ─────────────────────────────────────────────
+# 5. 自回归生成子节点
+# ─────────────────────────────────────────────
+
+def generate_children(
+    model,
+    prefix_batch:  dict,
+    parent_pos:    np.ndarray,
+    max_children:  int   = MAX_CHILDREN,
+    temperature:   float = 0.8,
+    top_k:         int   = 50,
+    device:        str   = 'cpu',
+    opacity_clip_min: float = OPACITY_MIN_LOGIT,
+    opacity_clip_max: float = OPACITY_MAX_LOGIT,
+) -> list:
+    current_batch = prefix_batch
+    children      = []
+
+    # 预计算 codebook embedding（只算一次）
+    with torch.no_grad():
+        cb_embs = {
+            'scale': model.get_cb_emb('scale'),
+            'rot':   model.get_cb_emb('rot'),
+            'dc':    model.get_cb_emb('dc'),
+            'sh':    model.get_cb_emb('sh'),
+        }
+
+    def _sample_role(logits: torch.Tensor) -> int:
+        logits = logits / temperature
+        if top_k > 0:
+            k = min(top_k, N_ROLE)
+            topk_vals, _ = torch.topk(logits, k)
+            logits = logits.masked_fill(logits < topk_vals[-1], float('-inf'))
+        probs = F.softmax(logits, dim=-1)
+        return int(torch.multinomial(probs, 1).item())
+
+    def _nearest(pred_emb: torch.Tensor, name: str) -> int:
+        # L2 normalize 后最近邻（与训练时的 normalize MSE 一致）
+        pred_norm = F.normalize(pred_emb.unsqueeze(0), dim=-1)   # (1, d_cb)
+        cb_norm   = F.normalize(cb_embs[name], dim=-1)           # (K, d_cb)
+        dist2     = ((cb_norm - pred_norm) ** 2).sum(dim=-1)     # (K,)
+        return int(dist2.argmin().item())
+
+    for _ in range(max_children):
+        with torch.no_grad():
+            pred = model(current_batch)
+
+        # 先预测 role
+        pred_role = _sample_role(pred['role'][0, -1, :])
+
+        if pred_role == ROLE_EOS:
+            break
+        if pred_role != ROLE_CHILD:
+            break
+
+        # 预测 xyz / opacity（回归）
+        pred_xyz = pred['xyz'][0, -1, :].cpu().numpy()
+        pred_opa = float(pred['opacity'][0, -1, 0].cpu()) * 10.0  # 反归一化
+        pred_opa = float(np.clip(pred_opa, opacity_clip_min, opacity_clip_max))
+
+        # 预测 scale/rot/dc/sh（最近邻）
+        pred_scale = _nearest(pred['scale_emb'][0, -1, :], 'scale')
+        pred_rot   = _nearest(pred['rot_emb'][0, -1, :],   'rot')
+        pred_dc    = _nearest(pred['dc_emb'][0, -1, :],    'dc')
+        pred_sh    = _nearest(pred['sh_emb'][0, -1, :],    'sh')
+
+        child = {
+            'dx':        float(pred_xyz[0]),
+            'dy':        float(pred_xyz[1]),
+            'dz':        float(pred_xyz[2]),
+            'scale_idx': pred_scale,
+            'rot_idx':   pred_rot,
+            'dc_idx':    pred_dc,
+            'sh_idx':    pred_sh,
+            'opacity':   pred_opa,
+            'role':      ROLE_CHILD,
+            'world_pos': parent_pos + pred_xyz,
+        }
+        children.append(child)
+
+        # 把新 token 加入序列（opacity 保持归一化状态）
+        np_token = np.zeros(1, dtype=TOKEN_DTYPE)
+        np_token['dx']        = child['dx']
+        np_token['dy']        = child['dy']
+        np_token['dz']        = child['dz']
+        np_token['scale_idx'] = pred_scale
+        np_token['rot_idx']   = pred_rot
+        np_token['dc_idx']    = pred_dc
+        np_token['sh_idx']    = pred_sh
+        np_token['opacity']   = pred_opa / 10.0
+        np_token['role']      = ROLE_CHILD
+        current_batch = _append_token(current_batch, np_token[0], device)
+
+    return children
+
+
+def generate_children_batch(
+    model,
+    prefix_batch: dict,
+    parent_positions: np.ndarray,
+    lengths: torch.Tensor,
+    cb_norms: dict,
+    max_children: int = MAX_CHILDREN,
+    temperature: float = 0.8,
+    top_k: int = 50,
+    device: str = 'cpu',
+    opacity_clip_min: float = OPACITY_MIN_LOGIT,
+    opacity_clip_max: float = OPACITY_MAX_LOGIT,
+) -> tuple:
+    batch = prefix_batch
+    B = parent_positions.shape[0]
+    active = torch.ones(B, dtype=torch.bool, device=device)
+    child_counts = np.zeros(B, dtype=np.int32)
+    children_by_row = [[] for _ in range(B)]
+
+    parent_positions_t = torch.from_numpy(parent_positions).to(device=device, dtype=torch.float32)
+
+    with torch.inference_mode():
+        for _ in range(max_children):
+            row_idx = torch.nonzero(active, as_tuple=False).squeeze(1)
+            if row_idx.numel() == 0:
+                break
+
+            active_lengths = lengths[row_idx]
+            cur_len = int(active_lengths.max().item())
+            active_batch = {k: v[row_idx, :cur_len] for k, v in batch.items()}
+
+            pred = model(active_batch)
+            gather_pos = (active_lengths - 1).view(-1, 1, 1)
+
+            role_logits = pred['role'].gather(
+                1, gather_pos.expand(-1, 1, pred['role'].shape[-1])
+            ).squeeze(1)
+            pred_role = _sample_roles_batched(role_logits, temperature, top_k)
+
+            child_mask = pred_role == ROLE_CHILD
+            if not child_mask.any():
+                active[row_idx] = False
+                continue
+
+            stopped_rows = row_idx[~child_mask]
+            if stopped_rows.numel() > 0:
+                active[stopped_rows] = False
+
+            child_rows = row_idx[child_mask]
+            child_local_idx = torch.nonzero(child_mask, as_tuple=False).squeeze(1)
+            child_pos = (active_lengths[child_mask] - 1).view(-1, 1, 1)
+
+            pred_xyz = pred['xyz'][child_local_idx].gather(
+                1, child_pos.expand(-1, 1, pred['xyz'].shape[-1])
+            ).squeeze(1)
+            pred_opa = pred['opacity'][child_local_idx].gather(
+                1, child_pos.expand(-1, 1, pred['opacity'].shape[-1])
+            ).squeeze(1).squeeze(-1) * 10.0
+
+            pred_scale_emb = pred['scale_emb'][child_local_idx].gather(
+                1, child_pos.expand(-1, 1, pred['scale_emb'].shape[-1])
+            ).squeeze(1)
+            pred_rot_emb = pred['rot_emb'][child_local_idx].gather(
+                1, child_pos.expand(-1, 1, pred['rot_emb'].shape[-1])
+            ).squeeze(1)
+            pred_dc_emb = pred['dc_emb'][child_local_idx].gather(
+                1, child_pos.expand(-1, 1, pred['dc_emb'].shape[-1])
+            ).squeeze(1)
+            pred_sh_emb = pred['sh_emb'][child_local_idx].gather(
+                1, child_pos.expand(-1, 1, pred['sh_emb'].shape[-1])
+            ).squeeze(1)
+
+            pred_scale = _nearest_codebook_batched(pred_scale_emb, cb_norms['scale'])
+            pred_rot = _nearest_codebook_batched(pred_rot_emb, cb_norms['rot'])
+            pred_dc = _nearest_codebook_batched(pred_dc_emb, cb_norms['dc'])
+            pred_sh = _nearest_codebook_batched(pred_sh_emb, cb_norms['sh'])
+
+            world_pos = parent_positions_t[child_rows] + pred_xyz
+            pred_opa_clipped = pred_opa.clamp(opacity_clip_min, opacity_clip_max)
+
+            rows_cpu = child_rows.cpu().numpy()
+            xyz_cpu = pred_xyz.cpu().numpy()
+            opa_cpu = pred_opa_clipped.cpu().numpy()
+            world_cpu = world_pos.cpu().numpy()
+            scale_cpu = pred_scale.cpu().numpy()
+            rot_cpu = pred_rot.cpu().numpy()
+            dc_cpu = pred_dc.cpu().numpy()
+            sh_cpu = pred_sh.cpu().numpy()
+
+            for j, row in enumerate(rows_cpu):
+                children_by_row[int(row)].append({
+                    'dx': float(xyz_cpu[j, 0]),
+                    'dy': float(xyz_cpu[j, 1]),
+                    'dz': float(xyz_cpu[j, 2]),
+                    'scale_idx': int(scale_cpu[j]),
+                    'rot_idx': int(rot_cpu[j]),
+                    'dc_idx': int(dc_cpu[j]),
+                    'sh_idx': int(sh_cpu[j]),
+                    'opacity': float(opa_cpu[j]),
+                    'role': ROLE_CHILD,
+                    'world_pos': world_cpu[j],
+                })
+                child_counts[row] += 1
+
+            batch = _append_tokens_batched(
+                batch,
+                child_rows,
+                lengths,
+                {
+                    'xyz': pred_xyz,
+                    'scale': pred_scale,
+                    'rot': pred_rot,
+                    'dc': pred_dc,
+                    'sh': pred_sh,
+                    'opacity_norm': pred_opa_clipped / 10.0,
+                },
+                device,
+            )
+
+    children = [child for row_children in children_by_row for child in row_children]
+    return children, child_counts
+
+
+# ─────────────────────────────────────────────
+# 6. 写出 .ply
+# ─────────────────────────────────────────────
+
+def children_to_ply(
+    all_children: list,
+    codebooks:    dict,
+    save_path:    str,
+    n_sh_rest:    int = 45,
+    opacity_clip_min: float = OPACITY_MIN_LOGIT,
+    opacity_clip_max: float = OPACITY_MAX_LOGIT,
+) -> None:
+    N = len(all_children)
+    if N == 0:
+        print("[write_ply] 警告：没有子节点，跳过")
+        return
+
+    print(f"[write_ply] 共 {N} 个子节点，解码并写出 {save_path} ...")
+
+    positions = np.array([c['world_pos'] for c in all_children], dtype=np.float32)
+    opacities = np.array([c['opacity']   for c in all_children], dtype=np.float32)
+    opacities = np.clip(opacities, opacity_clip_min, opacity_clip_max).astype(np.float32)
+    scale_idx = np.array([c['scale_idx'] for c in all_children], dtype=np.int32)
+    rot_idx   = np.array([c['rot_idx']   for c in all_children], dtype=np.int32)
+    dc_idx    = np.array([c['dc_idx']    for c in all_children], dtype=np.int32)
+    sh_idx    = np.array([c['sh_idx']    for c in all_children], dtype=np.int32)
+
+    scales    = codebooks['scale'][scale_idx]
+    rotations = normalize_quaternions_np(codebooks['rotation'][rot_idx])
+    dc        = codebooks['dc'][dc_idx]
+    sh_rest   = codebooks['sh'][sh_idx]
+
+    fields = (
+        [('x','f4'), ('y','f4'), ('z','f4'),
+         ('opacity','f4'),
+         ('scale_0','f4'), ('scale_1','f4'), ('scale_2','f4'),
+         ('rot_0','f4'), ('rot_1','f4'), ('rot_2','f4'), ('rot_3','f4'),
+         ('f_dc_0','f4'), ('f_dc_1','f4'), ('f_dc_2','f4'),
+         ('filter_3D','f4')] +
+        [(f'f_rest_{i}', 'f4') for i in range(n_sh_rest)]
+    )
+    vd = np.zeros(N, dtype=np.dtype(fields))
+
+    vd['x']       = positions[:, 0]
+    vd['y']       = positions[:, 1]
+    vd['z']       = positions[:, 2]
+    vd['opacity'] = opacities
+    vd['scale_0'] = scales[:, 0]
+    vd['scale_1'] = scales[:, 1]
+    vd['scale_2'] = scales[:, 2]
+    vd['rot_0']   = rotations[:, 0]
+    vd['rot_1']   = rotations[:, 1]
+    vd['rot_2']   = rotations[:, 2]
+    vd['rot_3']   = rotations[:, 3]
+    vd['f_dc_0']  = dc[:, 0]
+    vd['f_dc_1']  = dc[:, 1]
+    vd['f_dc_2']  = dc[:, 2]
+    vd['filter_3D'] = 0.0
+    for i in range(n_sh_rest):
+        vd[f'f_rest_{i}'] = sh_rest[:, i]
+
+    os.makedirs(os.path.dirname(os.path.abspath(save_path)), exist_ok=True)
+    PlyData([PlyElement.describe(vd, 'vertex')]).write(save_path)
+    size_mb = os.path.getsize(save_path) / 1024 / 1024
+    print(f"[write_ply] 完成  {size_mb:.2f} MB")
+
+
+# ─────────────────────────────────────────────
+# 7. 主推断流程
+# ─────────────────────────────────────────────
+
+def infer_upsample(
+    ckpt_path:    str,
+    quant_npz:    str,
+    codebook_dir: str,
+    save_path:    str,
+    max_uncles:   int   = MAX_UNCLES,
+    max_children: int   = MAX_CHILDREN,
+    temperature:  float = 0.8,
+    top_k:        int   = 50,
+    device:       str   = 'auto',
+    max_gaussians: int  = -1,
+    batch_size:   int   = 1024,
+    opacity_min_alpha: float = 0.0,
+    opacity_max_alpha: float = 0.95,
+) -> None:
+    if device == 'auto':
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    print(f"[infer] device={device}")
+
+    model     = load_model(ckpt_path, device)
+    codebooks = load_codebooks(codebook_dir)
+    quant     = load_quantized(quant_npz)
+    cb_norms  = prepare_codebook_norms(model)
+
+    N = quant['positions'].shape[0]
+    if max_gaussians > 0:
+        N = min(N, max_gaussians)
+    batch_size = max(1, int(batch_size))
+    opacity_clip_min, opacity_clip_max = opacity_clip_from_alpha(
+        opacity_min_alpha, opacity_max_alpha
+    )
+    print(f"[infer] batch_size={batch_size}")
+    print(
+        f"[infer] opacity_logit_clip=[{opacity_clip_min:.4f}, {opacity_clip_max:.4f}] "
+        f"(alpha=[{opacity_min_alpha}, {opacity_max_alpha}])"
+    )
+    print(f"[infer] 处理 {N} 个粗节点")
+
+    all_children     = []
+    total_generated  = 0
+    early_stop_count = 0
+
+    for start in range(0, N, batch_size):
+        end = min(start + batch_size, N)
+        print(f"  progress: {start}/{N}  generated: {total_generated}")
+
+        p_indices = np.arange(start, end, dtype=np.int64)
+        prefix_batch, parent_positions, lengths = make_prefix_batch_many(
+            p_indices, quant, max_uncles=max_uncles, device=device
+        )
+        children, child_counts = generate_children_batch(
+            model,
+            prefix_batch,
+            parent_positions,
+            lengths,
+            cb_norms,
+            max_children=max_children,
+            temperature=temperature,
+            top_k=top_k,
+            device=device,
+            opacity_clip_min=opacity_clip_min,
+            opacity_clip_max=opacity_clip_max,
+        )
+
+        early_stop_count += int((child_counts < max_children).sum())
+        all_children.extend(children)
+        total_generated += len(children)
+
+    print(f"\n[infer] 生成完成")
+    print(f"        总子节点数：{total_generated}")
+    print(f"        平均每粗节点子节点数：{total_generated / max(N, 1):.2f}")
+    print(f"        EOS 提前终止：{early_stop_count}/{N} "
+          f"({100 * early_stop_count / max(N, 1):.1f}%)")
+
+    children_to_ply(
+        all_children,
+        codebooks,
+        save_path,
+        opacity_clip_min=opacity_clip_min,
+        opacity_clip_max=opacity_clip_max,
+    )
+    print(f"\n[infer] 完成！输出 → {save_path}")
+
+
+# ─────────────────────────────────────────────
+# 8. CLI
+# ─────────────────────────────────────────────
+
+def parse_args():
+    p = argparse.ArgumentParser(description="用 Transformer 上采样 3DGS")
+    p.add_argument('--ckpt',          required=True)
+    p.add_argument('--quant_npz',     required=True)
+    p.add_argument('--codebook_dir',  required=True)
+    p.add_argument('--save_path',     required=True)
+    p.add_argument('--max_uncles',    type=int,   default=MAX_UNCLES)
+    p.add_argument('--max_children',  type=int,   default=MAX_CHILDREN)
+    p.add_argument('--temperature',   type=float, default=0.8)
+    p.add_argument('--top_k',         type=int,   default=50)
+    p.add_argument('--device',        default='auto')
+    p.add_argument('--max_gaussians', type=int,   default=-1)
+    p.add_argument('--batch_size',    type=int,   default=1024)
+    p.add_argument('--opacity_min_alpha', type=float, default=0.0,
+                   help='Clamp generated opacity to at least this alpha before writing/feeding back.')
+    p.add_argument('--opacity_max_alpha', type=float, default=0.95,
+                   help='Clamp generated opacity to at most this alpha before writing/feeding back; use 1.0 to disable.')
+    return p.parse_args()
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    infer_upsample(
+        ckpt_path=args.ckpt,
+        quant_npz=args.quant_npz,
+        codebook_dir=args.codebook_dir,
+        save_path=args.save_path,
+        max_uncles=args.max_uncles,
+        max_children=args.max_children,
+        temperature=args.temperature,
+        top_k=args.top_k,
+        device=args.device,
+        max_gaussians=args.max_gaussians,
+        batch_size=args.batch_size,
+        opacity_min_alpha=args.opacity_min_alpha,
+        opacity_max_alpha=args.opacity_max_alpha,
+    )

train_transformer.py

@@ -0,0 +1,894 @@
+"""
+train_transformer.py
+====================
+训练层级 3DGS split 生成 Transformer。
+支持单卡和多卡（DDP）自动切换。
+
+单卡启动：
+    python train_transformer.py --seq_paths sequences/*.pkl --codebook_dir ./codebooks
+
+四卡启动：
+    torchrun --nproc_per_node=4 train_transformer.py --seq_paths sequences/*.pkl --codebook_dir ./codebooks
+
+修复的三个 NaN 地雷：
+  1. NaN * 0 = NaN：_reg_loss 改用 torch.where 屏蔽 PAD，彻底切断 NaN 污染
+  2. 缺少 Final LayerNorm：TransformerEncoder 加 norm 参数，约束残差流方差
+  3. Softmax -inf → NaN：forward 里对 transformer 输出做 nan_to_num 保底清理
+
+role 编码：
+  0 = parent   1 = uncle   2 = child   3 = EOS   4 = PAD
+"""
+
+import os
+import math
+import argparse
+import pickle
+import numpy as np
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torch.distributed as dist
+from torch.nn.parallel import DistributedDataParallel as DDP
+from torch.utils.data import Dataset, DataLoader, DistributedSampler
+
+# ─────────────────────────────────────────────
+# 常量
+# ─────────────────────────────────────────────
+
+ROLE_PARENT  = 0
+ROLE_UNCLE   = 1
+ROLE_CHILD   = 2
+ROLE_EOS     = 3
+ROLE_PAD     = 4
+
+MAX_CHILDREN = 32
+MAX_UNCLES   = 4
+MAX_SEQ_LEN  = 1 + MAX_UNCLES + MAX_CHILDREN + 1   # = 38
+
+N_SCALE  = 16384
+N_ROT    = 16384
+N_DC     = 4096
+N_SH     = 4096
+N_ROLE   = 4
+
+CB_DIM = {
+    'scale': 3,
+    'rot':   4,
+    'dc':    3,
+    'sh':    45,
+}
+
+D_CB = 64
+
+TOKEN_DTYPE = np.dtype([
+    ('dx',         np.float32),
+    ('dy',         np.float32),
+    ('dz',         np.float32),
+    ('scale_idx',  np.int32),
+    ('rot_idx',    np.int32),
+    ('dc_idx',     np.int32),
+    ('sh_idx',     np.int32),
+    ('opacity',    np.float32),
+    ('role',       np.uint8),
+])
+
+LOSS_WEIGHTS = {
+    'role':    0.5,
+    'xyz':     1.0,
+    'opacity': 2.0,
+    'scale':   1.0,
+    'rot':     1.0,
+    'dc':      1.0,
+    'sh':      1.0,
+}
+
+OPACITY_LOGIT_CLIP = 20.0
+OPACITY_NORM_CLIP = OPACITY_LOGIT_CLIP / 10.0
+
+
+def normalize_quaternions_np(rotations: np.ndarray) -> np.ndarray:
+    rotations = rotations.astype(np.float32, copy=True)
+    norms = np.linalg.norm(rotations, axis=1, keepdims=True)
+    valid = np.isfinite(norms) & (norms > 1e-8)
+    rotations = np.where(valid, rotations / np.maximum(norms, 1e-8), rotations)
+    bad = ~valid.squeeze(1)
+    if bad.any():
+        rotations[bad] = np.array([1.0, 0.0, 0.0, 0.0], dtype=np.float32)
+    return rotations
+
+
+# ─────────────────────────────────────────────
+# 分布式工具
+# ─────────────────────────────────────────────
+
+def is_dist() -> bool:
+    return dist.is_available() and dist.is_initialized()
+
+def get_rank() -> int:
+    return dist.get_rank() if is_dist() else 0
+
+def get_world_size() -> int:
+    return dist.get_world_size() if is_dist() else 1
+
+def is_main() -> bool:
+    return get_rank() == 0
+
+def setup_dist() -> bool:
+    if 'RANK' not in os.environ:
+        return False
+    dist.init_process_group(backend='nccl')
+    torch.cuda.set_device(int(os.environ['LOCAL_RANK']))
+    return True
+
+def cleanup_dist():
+    if is_dist():
+        dist.destroy_process_group()
+
+def reduce_mean(tensor: torch.Tensor) -> float:
+    if not is_dist():
+        return tensor.item()
+    rt = tensor.clone()
+    dist.all_reduce(rt, op=dist.ReduceOp.SUM)
+    return (rt / get_world_size()).item()
+
+
+# ─────────────────────────────────────────────
+# 1. Dataset
+# ─────────────────────────────────────────────
+
+class SplitSequenceDataset(Dataset):
+
+    def __init__(self, seq_pkl_paths: list):
+        self.sequences = []
+        for path in seq_pkl_paths:
+            with open(path, 'rb') as f:
+                seqs = pickle.load(f)
+            self.sequences.extend(seqs)
+            if is_main():
+                print(f"  加载 {os.path.basename(path)}：{len(seqs)} 条")
+        if is_main():
+            print(f"[Dataset] 共 {len(self.sequences)} 条序列，"
+                  f"固定长度 {MAX_SEQ_LEN}")
+
+    def __len__(self):
+        return len(self.sequences)
+
+    def __getitem__(self, idx):
+        seq  = self.sequences[idx]
+        role = seq['role'].astype(np.int64)
+
+        attn_mask      = (role != ROLE_PAD)
+        loss_mask_feat = (role == ROLE_CHILD)
+        loss_mask_role = (role != ROLE_PAD)
+
+        xyz = np.stack([seq['dx'], seq['dy'], seq['dz']], axis=1)
+
+        # opacity 归一化到 [-1, 1] 附近
+        opacity = np.nan_to_num(
+            seq['opacity'].astype(np.float32),
+            nan=0.0,
+            posinf=OPACITY_LOGIT_CLIP,
+            neginf=-OPACITY_LOGIT_CLIP,
+        )
+        opacity = np.clip(opacity, -OPACITY_LOGIT_CLIP, OPACITY_LOGIT_CLIP)
+        opacity_norm = opacity / 10.0
+
+        return {
+            'xyz':             torch.from_numpy(xyz).float(),
+            'scale':           torch.from_numpy(seq['scale_idx'].astype(np.int64)),
+            'rot':             torch.from_numpy(seq['rot_idx'].astype(np.int64)),
+            'dc':              torch.from_numpy(seq['dc_idx'].astype(np.int64)),
+            'sh':              torch.from_numpy(seq['sh_idx'].astype(np.int64)),
+            'opacity':         torch.from_numpy(opacity_norm),
+            'role':            torch.from_numpy(role),
+            'attn_mask':       torch.from_numpy(attn_mask),
+            'loss_mask_feat':  torch.from_numpy(loss_mask_feat),
+            'loss_mask_role':  torch.from_numpy(loss_mask_role),
+        }
+
+
+def collate_fn(batch):
+    keys = ['xyz', 'scale', 'rot', 'dc', 'sh', 'opacity',
+            'role', 'attn_mask', 'loss_mask_feat', 'loss_mask_role']
+    return {k: torch.stack([b[k] for b in batch], dim=0) for k in keys}
+
+
+# ─────────────────────────────────────────────
+# 2. Token Embedding
+# ─────────────────────────────────────────────
+
+class TokenEmbedding(nn.Module):
+
+    def __init__(self, d_model: int):
+        super().__init__()
+        d = d_model // 8
+
+        # 输入侧：codebook 向量查表 + 小 Linear，不用大 Embedding table
+        self.inp_proj_scale = nn.Linear(CB_DIM['scale'], d)
+        self.inp_proj_rot   = nn.Linear(CB_DIM['rot'],   d)
+        self.inp_proj_dc    = nn.Linear(CB_DIM['dc'],    d)
+        self.inp_proj_sh    = nn.Linear(CB_DIM['sh'],    d)
+
+        # role 只有 5 个值，小 Embedding 完全没问题
+        self.emb_role = nn.Embedding(5, d, padding_idx=ROLE_PAD)
+
+        self.proj_xyz  = nn.Linear(3, d * 2)
+        self.proj_opa  = nn.Linear(1, d)
+
+        self.proj = nn.Linear(d * 8, d_model)
+
+    def forward(self,
+                batch: dict,
+                cb_scale: torch.Tensor,
+                cb_rot:   torch.Tensor,
+                cb_dc:    torch.Tensor,
+                cb_sh:    torch.Tensor) -> torch.Tensor:
+
+        with torch.no_grad():
+            s_vec = cb_scale[batch['scale'].clamp(0, cb_scale.shape[0] - 1)]
+            r_vec = cb_rot[  batch['rot'].clamp(0,   cb_rot.shape[0]   - 1)]
+            d_vec = cb_dc[   batch['dc'].clamp(0,    cb_dc.shape[0]    - 1)]
+            h_vec = cb_sh[   batch['sh'].clamp(0,    cb_sh.shape[0]    - 1)]
+
+        # 【地雷修复】F.normalize 加 eps，防止零向量导致除以零
+        e_s = self.inp_proj_scale(F.normalize(s_vec, dim=-1, eps=1e-8))
+        e_r = self.inp_proj_rot(  F.normalize(r_vec, dim=-1, eps=1e-8))
+        e_d = self.inp_proj_dc(   F.normalize(d_vec, dim=-1, eps=1e-8))
+        e_h = self.inp_proj_sh(   F.normalize(h_vec, dim=-1, eps=1e-8))
+
+        e_role = self.emb_role(batch['role'].clamp(0, 4))
+
+        e_xyz  = self.proj_xyz(batch['xyz'].float())
+        e_opa  = self.proj_opa(batch['opacity'].unsqueeze(-1).float())
+
+        cat = torch.cat([e_xyz, e_s, e_r, e_d, e_h, e_opa, e_role], dim=-1)
+        return self.proj(cat)
+
+
+# ─────────────────────────────────────────────
+# 3. Transformer Model
+# ─────────────────────────────────────────────
+
+class SplitTransformer(nn.Module):
+
+    def __init__(
+        self,
+        d_model:      int   = 512,
+        n_heads:      int   = 8,
+        n_layers:     int   = 6,
+        d_ff:         int   = 2048,
+        max_seq_len:  int   = MAX_SEQ_LEN,
+        dropout:      float = 0.1,
+        codebook_dir: str   = None,
+        d_cb:         int   = D_CB,
+    ):
+        super().__init__()
+        self.d_model     = d_model
+        self.max_seq_len = max_seq_len
+        self.d_cb        = d_cb
+
+        self.token_emb = TokenEmbedding(d_model)
+        self.pos_emb   = nn.Embedding(max_seq_len, d_model)
+
+        layer = nn.TransformerEncoderLayer(
+            d_model=d_model,
+            nhead=n_heads,
+            dim_feedforward=d_ff,
+            dropout=dropout,
+            batch_first=True,
+            norm_first=True,
+        )
+
+        # 【地雷二修复】加 Final LayerNorm，约束 Pre-LN 残差流方差
+        final_norm = nn.LayerNorm(d_model)
+        self.transformer = nn.TransformerEncoder(
+            layer, num_layers=n_layers, norm=final_norm
+        )
+
+        self.register_buffer(
+            'causal_mask',
+            torch.triu(torch.ones(max_seq_len, max_seq_len), diagonal=1).bool()
+        )
+
+        # 输出头
+        self.head_role    = nn.Linear(d_model, N_ROLE)
+        self.head_xyz     = nn.Linear(d_model, 3)
+        self.head_opacity = nn.Linear(d_model, 1)
+        self.head_scale_emb = nn.Linear(d_model, d_cb)
+        self.head_rot_emb   = nn.Linear(d_model, d_cb)
+        self.head_dc_emb    = nn.Linear(d_model, d_cb)
+        self.head_sh_emb    = nn.Linear(d_model, d_cb)
+
+        # 输出侧 codebook 投影（冻结）
+        self.cb_proj_scale = nn.Linear(CB_DIM['scale'], d_cb)
+        self.cb_proj_rot   = nn.Linear(CB_DIM['rot'],   d_cb)
+        self.cb_proj_dc    = nn.Linear(CB_DIM['dc'],    d_cb)
+        self.cb_proj_sh    = nn.Linear(CB_DIM['sh'],    d_cb)
+
+        if codebook_dir is not None:
+            self._load_codebooks(codebook_dir)
+        else:
+            self.register_buffer('cb_scale', torch.zeros(1, CB_DIM['scale']))
+            self.register_buffer('cb_rot',   torch.zeros(1, CB_DIM['rot']))
+            self.register_buffer('cb_dc',    torch.zeros(1, CB_DIM['dc']))
+            self.register_buffer('cb_sh',    torch.zeros(1, CB_DIM['sh']))
+
+        self._init_weights()
+
+        # 冻结 cb_proj
+        for name in ['cb_proj_scale', 'cb_proj_rot', 'cb_proj_dc', 'cb_proj_sh']:
+            for param in getattr(self, name).parameters():
+                param.requires_grad_(False)
+
+    def _load_codebooks(self, codebook_dir: str):
+        name_map = {
+            'scale':    'cb_scale',
+            'rotation': 'cb_rot',
+            'dc':       'cb_dc',
+            'sh':       'cb_sh',
+        }
+        for file_name, buf_name in name_map.items():
+            path = os.path.join(codebook_dir, f"{file_name}_codebook.npz")
+            if not os.path.exists(path):
+                raise FileNotFoundError(f"找不到 codebook：{path}")
+            cb = np.load(path)['codebook'].astype(np.float32)
+            if file_name == 'rotation':
+                cb = normalize_quaternions_np(cb)
+            self.register_buffer(buf_name, torch.from_numpy(cb))
+            if is_main():
+                print(f"  [codebook] {file_name}: {cb.shape}")
+
+    def _init_weights(self):
+        for m in self.modules():
+            if isinstance(m, nn.Linear):
+                nn.init.xavier_uniform_(m.weight)
+                if m.bias is not None:
+                    nn.init.zeros_(m.bias)
+            elif isinstance(m, nn.Embedding):
+                nn.init.normal_(m.weight, std=0.02)
+                if m.padding_idx is not None:
+                    nn.init.zeros_(m.weight[m.padding_idx])
+
+        for head in [self.head_role, self.head_xyz, self.head_opacity,
+                     self.head_scale_emb, self.head_rot_emb,
+                     self.head_dc_emb, self.head_sh_emb]:
+            nn.init.normal_(head.weight, std=0.02)
+            nn.init.zeros_(head.bias)
+
+    def forward(self, batch: dict) -> dict:
+        B, L = batch['scale'].shape
+
+        tok_emb = self.token_emb(
+            batch,
+            cb_scale=self.cb_scale,
+            cb_rot=self.cb_rot,
+            cb_dc=self.cb_dc,
+            cb_sh=self.cb_sh,
+        )
+
+        pos = torch.arange(L, device=tok_emb.device)
+        x   = tok_emb + self.pos_emb(pos).unsqueeze(0)
+
+        pad_mask = ~batch['attn_mask']
+        causal   = self.causal_mask[:L, :L]
+
+        out = self.transformer(
+            src=x,
+            mask=causal,
+            src_key_padding_mask=pad_mask,
+        )
+
+        # 【地雷三修复】清理 PAD 位置 softmax(-inf) 产生的 NaN
+        # 只对废弃的 PAD 位置做保底，不影响有效位置的梯度
+        out = torch.nan_to_num(out, nan=0.0)
+
+        return {
+            'role':      self.head_role(out),
+            'xyz':       self.head_xyz(out),
+            'opacity':   self.head_opacity(out),
+            'scale_emb': self.head_scale_emb(out),
+            'rot_emb':   self.head_rot_emb(out),
+            'dc_emb':    self.head_dc_emb(out),
+            'sh_emb':    self.head_sh_emb(out),
+        }
+
+    def get_cb_emb(self, name: str) -> torch.Tensor:
+        cb   = getattr(self, f'cb_{name}')
+        proj = getattr(self, f'cb_proj_{name}')
+        with torch.no_grad():
+            return proj(cb)
+
+    def nearest_codebook_idx(self, pred_emb: torch.Tensor, name: str) -> int:
+        cb_emb = self.get_cb_emb(name)
+        dist2  = ((cb_emb - pred_emb.unsqueeze(0)) ** 2).sum(dim=-1)
+        return int(dist2.argmin().item())
+
+
+# ─────────────────────────────────────────────
+# 4. Loss
+# ───���─────────────────────────────────────────
+
+def compute_loss(pred: dict, batch: dict,
+                 model: nn.Module,
+                 weights: dict = None) -> tuple:
+    if weights is None:
+        weights = LOSS_WEIGHTS
+
+    feat_mask = batch['loss_mask_feat'][:, 1:]
+    role_mask = batch['loss_mask_role'][:, 1:]
+
+    raw_model = model.module if hasattr(model, 'module') else model
+
+    # 【地雷一修复】用 torch.where 代替乘法屏蔽，彻底切断 NaN * 0 = NaN
+    def _reg_loss(pred_key, tgt_key, mask, squeeze=False, scale=1.0):
+        p = pred[pred_key][:, :-1]
+        t = batch[tgt_key][:, 1:]
+        if squeeze:
+            p = p.squeeze(-1)
+        if not mask.any():
+            return torch.tensor(0.0, device=p.device)
+
+        p = torch.nan_to_num(p, nan=0.0, posinf=1e4, neginf=-1e4)
+        t = torch.nan_to_num(t.float(), nan=0.0, posinf=1e4, neginf=-1e4)
+        if p.dim() == 3:
+            valid = mask & torch.isfinite(p).all(dim=-1) & torch.isfinite(t).all(dim=-1)
+        else:
+            valid = mask & torch.isfinite(p) & torch.isfinite(t)
+        if not valid.any():
+            return torch.tensor(0.0, device=p.device)
+
+        mse = F.mse_loss(p / scale, t / scale, reduction='none')
+        if mse.dim() == 3:
+            mse = mse.mean(-1)
+
+        # torch.where：mask=True 的位置保留 mse，mask=False 填 0.0
+        # 彻底切断 PAD 位置 NaN 的污染（NaN * 0 = NaN，但 where 选 0.0 安全）
+        masked_mse = torch.where(valid, mse, torch.zeros_like(mse))
+        return masked_mse.sum() / valid.sum().clamp(min=1)
+
+    def _opacity_loss(mask):
+        p = pred['opacity'][:, :-1].squeeze(-1)
+        t = batch['opacity'][:, 1:].float()
+        p = torch.nan_to_num(
+            p,
+            nan=0.0,
+            posinf=OPACITY_NORM_CLIP,
+            neginf=-OPACITY_NORM_CLIP,
+        )
+        t = torch.nan_to_num(
+            t,
+            nan=0.0,
+            posinf=OPACITY_NORM_CLIP,
+            neginf=-OPACITY_NORM_CLIP,
+        ).clamp(-OPACITY_NORM_CLIP, OPACITY_NORM_CLIP)
+        valid = mask & torch.isfinite(p) & torch.isfinite(t)
+        if not valid.any():
+            return torch.tensor(0.0, device=p.device)
+        loss = F.smooth_l1_loss(p, t, reduction='none', beta=0.25)
+        loss = torch.where(valid, loss, torch.zeros_like(loss))
+        return loss.sum() / valid.sum().clamp(min=1)
+
+    def _cls_loss_role(mask):
+        p = pred['role'][:, :-1]
+        t = batch['role'][:, 1:]
+        if not mask.any():
+            return torch.tensor(0.0, device=p.device)
+        # p[mask] 直接丢弃 PAD 位置，天然安全
+        p_m = p[mask]
+        t_m = t[mask]
+        valid = (t_m >= 0) & (t_m < N_ROLE)
+        if not valid.all():
+            p_m, t_m = p_m[valid], t_m[valid]
+        if p_m.numel() == 0:
+            return torch.tensor(0.0, device=p.device)
+        return F.cross_entropy(p_m, t_m, label_smoothing=0.1)
+
+    def _emb_loss(pred_emb_key, tgt_idx_key, mask, cb_name):
+        p     = pred[pred_emb_key][:, :-1]
+        t_idx = batch[tgt_idx_key][:, 1:]
+        if not mask.any():
+            return torch.tensor(0.0, device=p.device)
+
+        p_m     = p[mask]
+        t_idx_m = t_idx[mask]
+
+        cb      = getattr(raw_model, f'cb_{cb_name}')
+        cb_proj = getattr(raw_model, f'cb_proj_{cb_name}')
+
+        valid = (t_idx_m >= 0) & (t_idx_m < cb.shape[0])
+        if not valid.all():
+            p_m, t_idx_m = p_m[valid], t_idx_m[valid]
+        if p_m.numel() == 0:
+            return torch.tensor(0.0, device=p.device)
+
+        with torch.no_grad():
+            t_emb = cb_proj(cb[t_idx_m])
+
+        # 两边 normalize 后算 MSE，梯度有界
+        p_norm = F.normalize(p_m,   dim=-1, eps=1e-8)
+        t_norm = F.normalize(t_emb, dim=-1, eps=1e-8)
+        return F.mse_loss(p_norm, t_norm)
+
+    loss_role  = _cls_loss_role(role_mask)
+    loss_xyz   = _reg_loss('xyz',     'xyz',     feat_mask, scale=1.0)
+    loss_opa   = _opacity_loss(feat_mask)
+    loss_scale = _emb_loss('scale_emb', 'scale', feat_mask, 'scale')
+    loss_rot   = _emb_loss('rot_emb',   'rot',   feat_mask, 'rot')
+    loss_dc    = _emb_loss('dc_emb',    'dc',    feat_mask, 'dc')
+    loss_sh    = _emb_loss('sh_emb',    'sh',    feat_mask, 'sh')
+
+    total = (
+        weights['role']    * loss_role  +
+        weights['xyz']     * loss_xyz   +
+        weights['opacity'] * loss_opa   +
+        weights['scale']   * loss_scale +
+        weights['rot']     * loss_rot   +
+        weights['dc']      * loss_dc    +
+        weights['sh']      * loss_sh
+    )
+
+    if not torch.isfinite(total):
+        bad = {k: v.item() for k, v in {
+            'role': loss_role, 'xyz': loss_xyz, 'opa': loss_opa,
+            'scale': loss_scale, 'rot': loss_rot,
+            'dc': loss_dc, 'sh': loss_sh,
+        }.items() if not torch.isfinite(v)}
+        if is_main():
+            print(f"[NaN警告] 非有限 loss 来自：{bad}")
+        total = torch.tensor(0.0, requires_grad=True, device=loss_role.device)
+
+    return total, {
+        'role':    loss_role.item(),
+        'xyz':     loss_xyz.item(),
+        'opacity': loss_opa.item(),
+        'scale':   loss_scale.item(),
+        'rot':     loss_rot.item(),
+        'dc':      loss_dc.item(),
+        'sh':      loss_sh.item(),
+        'total':   total.item(),
+    }
+
+
+# ─────────────────────────────────────────────
+# 5. 诊断（第一个 batch）
+# ─────────────────────────────────────────────
+
+def diagnose_first_batch(model, batch, loss_weights=None):
+    if not is_main():
+        return
+    print("\n========== 第一个 batch 诊断 ==========")
+
+    for key, val in batch.items():
+        if not isinstance(val, torch.Tensor):
+            continue
+        if val.dtype == torch.float32:
+            finite = torch.isfinite(val)
+            val_finite = val[finite]
+            if val_finite.numel() == 0:
+                min_val, max_val = float('nan'), float('nan')
+            else:
+                min_val, max_val = val_finite.min().item(), val_finite.max().item()
+            print(f"  batch[{key:16s}]: shape={str(val.shape):25s} "
+                  f"nan={torch.isnan(val).sum().item()} "
+                  f"inf={torch.isinf(val).sum().item()} "
+                  f"min={min_val:10.4f} max={max_val:10.4f}")
+        else:
+            print(f"  batch[{key:16s}]: shape={str(val.shape):25s} "
+                  f"dtype={val.dtype} "
+                  f"min={val.min().item()} max={val.max().item()}")
+
+    raw_model = model.module if hasattr(model, 'module') else model
+    with torch.no_grad():
+        pred_check = raw_model(batch)
+
+    print()
+    for key, val in pred_check.items():
+        print(f"  pred[{key:12s}]: "
+              f"nan={torch.isnan(val).sum().item()} "
+              f"min={val.min().item():9.4f} "
+              f"max={val.max().item():9.4f} "
+              f"std={val.std().item():.4f}")
+
+    _, loss_dict_check = compute_loss(pred_check, batch, model, weights=loss_weights)
+    print()
+    for key, val in loss_dict_check.items():
+        print(f"  loss_{key:8s} = {val:.6f}")
+
+    print("========================================\n")
+
+
+# ─────────────────────────────────────────────
+# 6. 训练主循环
+# ─────────────────────────────────────────────
+
+def train(
+    seq_pkl_paths: list,
+    codebook_dir:  str,
+    save_dir:      str,
+    d_model:       int   = 512,
+    n_heads:       int   = 8,
+    n_layers:      int   = 6,
+    d_ff:          int   = 2048,
+    d_cb:          int   = D_CB,
+    dropout:       float = 0.1,
+    batch_size:    int   = 64,
+    lr:            float = 1e-4,
+    epochs:        int   = 50,
+    warmup_steps:  int   = 2000,
+    grad_clip:     float = 1.0,
+    val_ratio:     float = 0.05,
+    save_every:    int   = 5,
+    xyz_weight:    float = LOSS_WEIGHTS['xyz'],
+    opacity_weight: float = LOSS_WEIGHTS['opacity'],
+    num_workers:   int   = 4,
+    val_num_workers: int = 2,
+):
+    use_ddp = setup_dist()
+
+    if use_ddp:
+        local_rank = int(os.environ['LOCAL_RANK'])
+        device     = f'cuda:{local_rank}'
+    elif torch.cuda.is_available():
+        device = 'cuda'
+    else:
+        device = 'cpu'
+
+    if is_main():
+        print(f"[train] device={device}  "
+              f"world_size={get_world_size()}  "
+              f"DDP={'开启' if use_ddp else '关闭'}")
+        print(f"[train] xyz_loss_weight={xyz_weight}")
+        print(f"[train] opacity_loss_weight={opacity_weight}")
+        print(f"[train] dataloader_workers train={num_workers} val={val_num_workers}")
+        os.makedirs(save_dir, exist_ok=True)
+
+    loss_weights = dict(LOSS_WEIGHTS)
+    loss_weights['xyz'] = xyz_weight
+    loss_weights['opacity'] = opacity_weight
+
+    # ── 数据集 ───────────────────────────────
+    full_dataset = SplitSequenceDataset(seq_pkl_paths)
+    n_val        = max(1, int(len(full_dataset) * val_ratio))
+    n_train      = len(full_dataset) - n_val
+    train_set, val_set = torch.utils.data.random_split(
+        full_dataset, [n_train, n_val],
+        generator=torch.Generator().manual_seed(42)
+    )
+
+    if use_ddp:
+        train_sampler = DistributedSampler(train_set, shuffle=True)
+        val_sampler   = DistributedSampler(val_set,   shuffle=False)
+        train_loader  = DataLoader(
+            train_set, batch_size=batch_size, sampler=train_sampler,
+            collate_fn=collate_fn, num_workers=num_workers, pin_memory=True,
+            persistent_workers=(num_workers > 0),
+        )
+        val_loader = DataLoader(
+            val_set, batch_size=batch_size, sampler=val_sampler,
+            collate_fn=collate_fn, num_workers=val_num_workers, pin_memory=True,
+            persistent_workers=(val_num_workers > 0),
+        )
+    else:
+        train_loader = DataLoader(
+            train_set, batch_size=batch_size, shuffle=True,
+            collate_fn=collate_fn, num_workers=num_workers, pin_memory=True,
+            persistent_workers=(num_workers > 0),
+        )
+        val_loader = DataLoader(
+            val_set, batch_size=batch_size, shuffle=False,
+            collate_fn=collate_fn, num_workers=val_num_workers,
+            pin_memory=True,
+            persistent_workers=(val_num_workers > 0),
+        )
+
+    # ── 模型 ─────────────────────────────────
+    model = SplitTransformer(
+        d_model=d_model, n_heads=n_heads, n_layers=n_layers,
+        d_ff=d_ff, max_seq_len=MAX_SEQ_LEN, dropout=dropout,
+        codebook_dir=codebook_dir, d_cb=d_cb,
+    ).to(device)
+
+    if use_ddp:
+        model = DDP(
+            model,
+            device_ids=[local_rank],
+            output_device=local_rank,
+            broadcast_buffers=False,
+        )
+
+    if is_main():
+        raw = model.module if use_ddp else model
+        n_params = sum(p.numel() for p in raw.parameters() if p.requires_grad)
+        print(f"[train] 参数量：{n_params / 1e6:.2f}M")
+
+    # ── 优化器（只更新未冻结参数）────────────
+    optimizer = torch.optim.AdamW(
+        filter(lambda p: p.requires_grad, model.parameters()),
+        lr=lr, weight_decay=1e-2, eps=1e-8,
+    )
+
+    total_steps = epochs * len(train_loader)
+
+    def lr_lambda(step):
+        if step < warmup_steps:
+            return step / max(1, warmup_steps)
+        progress = (step - warmup_steps) / max(1, total_steps - warmup_steps)
+        return max(0.1, 0.5 * (1 + math.cos(math.pi * progress)))
+
+    scheduler = torch.optim.lr_scheduler.LambdaLR(optimizer, lr_lambda)
+
+    # ── 训练循环 ─────────────────────────────
+    best_val_loss = float('inf')
+    global_step   = 0
+
+    for epoch in range(1, epochs + 1):
+        if use_ddp:
+            train_sampler.set_epoch(epoch)
+
+        model.train()
+        epoch_loss_sum = 0.0
+        epoch_steps    = 0
+
+        for batch in train_loader:
+            batch = {k: v.to(device) if isinstance(v, torch.Tensor) else v
+                     for k, v in batch.items()}
+
+            if global_step == 0:
+                diagnose_first_batch(model, batch, loss_weights=loss_weights)
+
+            pred = model(batch)
+            loss, loss_dict = compute_loss(pred, batch, model, weights=loss_weights)
+
+            # NaN batch 保底跳过
+            if not torch.isfinite(loss):
+                if is_main():
+                    print(f"  [step {global_step}] 跳过 NaN batch")
+                optimizer.zero_grad()
+                global_step += 1
+                continue
+
+            optimizer.zero_grad()
+            loss.backward()
+
+            # 梯度监控（前 20 步）
+            if is_main() and global_step < 20:
+                total_norm = 0.0
+                for p in model.parameters():
+                    if p.grad is not None:
+                        total_norm += p.grad.data.norm(2).item() ** 2
+                total_norm = total_norm ** 0.5
+                print(f"  [step {global_step:03d}] "
+                      f"loss={loss_dict['total']:.4f}  "
+                      f"grad_norm={total_norm:.4f}")
+
+            nn.utils.clip_grad_norm_(model.parameters(), grad_clip)
+            optimizer.step()
+            scheduler.step()
+
+            epoch_loss_sum += loss_dict['total']
+            epoch_steps    += 1
+            global_step    += 1
+
+        train_loss = reduce_mean(torch.tensor(
+            epoch_loss_sum / max(epoch_steps, 1), device=device
+        ))
+
+        # ── 验证 ─────────────────────────────
+        model.eval()
+        val_loss_sum = 0.0
+        val_steps    = 0
+        with torch.no_grad():
+            for batch in val_loader:
+                batch = {k: v.to(device) if isinstance(v, torch.Tensor) else v
+                         for k, v in batch.items()}
+                pred = model(batch)
+                _, ld = compute_loss(pred, batch, model, weights=loss_weights)
+                val_loss_sum += ld['total']
+                val_steps    += 1
+
+        val_loss = reduce_mean(torch.tensor(
+            val_loss_sum / max(val_steps, 1), device=device
+        ))
+
+        if is_main():
+            print(f"[epoch {epoch:03d}/{epochs}] "
+                  f"train={train_loss:.4f}  val={val_loss:.4f}  "
+                  f"lr={scheduler.get_last_lr()[0]:.2e}")
+
+            raw_model = model.module if use_ddp else model
+
+            if epoch % save_every == 0:
+                ckpt_path = os.path.join(save_dir, f"ckpt_epoch{epoch:03d}.pt")
+                torch.save({
+                    'epoch':           epoch,
+                    'model_state':     raw_model.state_dict(),
+                    'optimizer_state': optimizer.state_dict(),
+                    'val_loss':        val_loss,
+                    'loss_weights':    loss_weights,
+                    'config': dict(
+                        d_model=d_model, n_heads=n_heads, n_layers=n_layers,
+                        d_ff=d_ff, max_seq_len=MAX_SEQ_LEN, dropout=dropout,
+                        d_cb=d_cb, codebook_dir=codebook_dir,
+                    ),
+                }, ckpt_path)
+                print(f"            checkpoint → {ckpt_path}")
+
+            if val_loss < best_val_loss:
+                best_val_loss = val_loss
+                best_path = os.path.join(save_dir, 'best_model.pt')
+                torch.save({
+                    'model_state': raw_model.state_dict(),
+                    'loss_weights': loss_weights,
+                    'config': dict(
+                        d_model=d_model, n_heads=n_heads, n_layers=n_layers,
+                        d_ff=d_ff, max_seq_len=MAX_SEQ_LEN, dropout=dropout,
+                        d_cb=d_cb, codebook_dir=codebook_dir,
+                    ),
+                }, best_path)
+
+    if is_main():
+        print(f"\n[train] 训练完成！最优 val_loss={best_val_loss:.4f}")
+        print(f"        最优模型 → {best_path}")
+
+    cleanup_dist()
+
+
+# ─────────────────────────────────────────────
+# 7. CLI
+# ─────────────────────────────────────────────
+
+def parse_args():
+    p = argparse.ArgumentParser(description="训练 3DGS split 生成 Transformer")
+    p.add_argument('--seq_paths',    nargs='+', required=True)
+    p.add_argument('--codebook_dir', required=True)
+    p.add_argument('--save_dir',     default='./checkpoints')
+    p.add_argument('--d_model',      type=int,   default=512)
+    p.add_argument('--n_heads',      type=int,   default=8)
+    p.add_argument('--n_layers',     type=int,   default=6)
+    p.add_argument('--d_ff',         type=int,   default=2048)
+    p.add_argument('--d_cb',         type=int,   default=D_CB)
+    p.add_argument('--batch_size',   type=int,   default=64,
+                   help='每张卡的 batch size')
+    p.add_argument('--lr',           type=float, default=1e-4)
+    p.add_argument('--epochs',       type=int,   default=50)
+    p.add_argument('--warmup',       type=int,   default=2000)
+    p.add_argument('--val_ratio',    type=float, default=0.05)
+    p.add_argument('--save_every',   type=int,   default=5)
+    p.add_argument('--dropout',      type=float, default=0.1)
+    p.add_argument('--grad_clip',    type=float, default=1.0)
+    p.add_argument('--xyz_weight', type=float, default=LOSS_WEIGHTS['xyz'],
+                   help='XYZ regression loss weight.')
+    p.add_argument('--opacity_weight', type=float, default=LOSS_WEIGHTS['opacity'],
+                   help='Opacity reconstruction loss weight. Increase if inferred points become too opaque.')
+    p.add_argument('--num_workers', type=int, default=4,
+                   help='DataLoader workers for training.')
+    p.add_argument('--val_num_workers', type=int, default=2,
+                   help='DataLoader workers for validation.')
+    return p.parse_args()
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    train(
+        seq_pkl_paths=args.seq_paths,
+        codebook_dir=args.codebook_dir,
+        save_dir=args.save_dir,
+        d_model=args.d_model,
+        n_heads=args.n_heads,
+        n_layers=args.n_layers,
+        d_ff=args.d_ff,
+        d_cb=args.d_cb,
+        dropout=args.dropout,
+        batch_size=args.batch_size,
+        lr=args.lr,
+        epochs=args.epochs,
+        warmup_steps=args.warmup,
+        val_ratio=args.val_ratio,
+        save_every=args.save_every,
+        grad_clip=args.grad_clip,
+        xyz_weight=args.xyz_weight,
+        opacity_weight=args.opacity_weight,
+        num_workers=args.num_workers,
+        val_num_workers=args.val_num_workers,
+    )