Delete train_transformer.py

train_transformer.py

@@ -1,842 +0,0 @@
-"""
-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,
-}
-
-
-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_norm = seq['opacity'].astype(np.float32) / 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.xyz_norm  = nn.LayerNorm(3)
-        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(self.xyz_norm(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)
-
-        mse = F.mse_loss(p / scale, t.float() / 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(mask, mse, torch.zeros_like(mse))
-        return masked_mse.sum() / mask.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=5.0)
-    loss_opa   = _reg_loss('opacity', 'opacity', feat_mask, squeeze=True, scale=1.0)
-    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:
-            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={val.min().item():10.4f} max={val.max().item():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,
-    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] 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['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('--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,
-        opacity_weight=args.opacity_weight,
-        num_workers=args.num_workers,
-        val_num_workers=args.val_num_workers,
-    )