Upload 3 files

build_sequence.py

@@ -0,0 +1,330 @@
+"""
+build_sequences.py
+==================
+从族谱（genealogy.pkl）和多尺度 3DGS 量化索引构建 split 序列。
+
+序列结构（固定长度 MAX_SEQ_LEN = 38）：
+  [parent(1)] [uncle×≤4] [child×≤32] [EOS(1)] [PAD×...]
+
+每个 token 字段：
+  dx, dy, dz    float32  坐标偏移（parent=0,0,0；其他=相对parent）
+  scale_idx     int32    scale codebook 索引
+  rot_idx       int32    rotation codebook 索引
+  dc_idx        int32    DC codebook 索引
+  sh_idx        int32    SH codebook 索引
+  opacity       float32  不透明度原值（不量化）
+  role          uint8    身份标识：
+                           0 = parent（父节点，坐标原点）
+                           1 = uncle （叔伯节点，相对坐标）
+                           2 = child （子节点，相对坐标）
+                           3 = EOS   （序列结束符）
+                           4 = PAD   （补齐，不参与计算）
+
+层级方向（粗→细）：
+  quant_paths 按 L3, L2, L1, L0 顺序传入
+  L3 最粗（点最少）作为 parent，逐级向细展开
+"""
+
+import os
+import argparse
+import pickle
+import numpy as np
+
+# ─────────────────────────────────────────────
+# 常量
+# ─────────────────────────────────────────────
+
+ROLE_PARENT  = np.uint8(0)
+ROLE_UNCLE   = np.uint8(1)
+ROLE_CHILD   = np.uint8(2)
+ROLE_EOS     = np.uint8(3)
+ROLE_PAD     = np.uint8(4)
+
+MAX_CHILDREN = 32
+MAX_UNCLES   = 4
+# 固定序列长度：parent(1) + uncle(4) + child(32) + EOS(1)
+MAX_SEQ_LEN  = 1 + MAX_UNCLES + MAX_CHILDREN + 1   # = 38
+
+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_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(),
+    }
+
+
+# ─────────────────────────────────────────────
+# 2. 加载族谱
+# ─────────────────────────────────────────────
+
+def load_genealogy(genealogy_path: str) -> dict:
+    with open(genealogy_path, 'rb') as f:
+        return pickle.load(f)
+
+
+# ─────────────────────────────────────────────
+# 3. Token 构造工具
+# ─────────────────────────────────────────────
+
+def make_token(gauss_idx: int, quant: dict,
+               parent_pos: np.ndarray, role: np.uint8) -> np.ndarray:
+    """构造单个特征 token，坐标为相对 parent_pos 的偏移。"""
+    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]
+    token['role']      = role
+    return token[0]
+
+
+def make_eos_token() -> np.ndarray:
+    """结束符：特征全 0，role=3。"""
+    token = np.zeros(1, dtype=TOKEN_DTYPE)
+    token['role'] = ROLE_EOS
+    return token[0]
+
+
+def make_pad_token() -> np.ndarray:
+    """补齐符：特征全 0，role=4，不参与任何 loss/attention。"""
+    token = np.zeros(1, dtype=TOKEN_DTYPE)
+    token['role'] = ROLE_PAD
+    return token[0]
+
+
+# ─────────────────────────────────────────────
+# 4. 构建单层所有 split 序列
+# ──────────────────────────��──────────────────
+
+def build_level_sequences(
+    parent_quant: dict,
+    child_quant:  dict,
+    children_ids: np.ndarray,    # (N_coarse, MAX_CHILDREN)，-1 为空位
+    max_uncles:   int = MAX_UNCLES,
+    min_children: int = 1,
+    fixed_len:    int = MAX_SEQ_LEN,
+) -> list:
+    """
+    遍历每个粗节点，构造一条固定长度的 split 序列。
+
+    序列 token 顺序：
+      [parent(1)] [uncle×≤max_uncles] [child×N_valid] [EOS(1)] [PAD×...]
+
+    role 编码：
+      0 = parent   坐标固定为 (0,0,0)，特征来自自身
+      1 = uncle    坐标相对 parent，特征来自自身
+      2 = child    坐标相对 parent，特征来自细尺度
+      3 = EOS      结束符，标志真实子节点已全部输出
+      4 = PAD      补齐，attention mask 中被屏蔽
+
+    返回：list of np.ndarray，每个元素 shape (fixed_len,) TOKEN_DTYPE
+    """
+    N_parents = children_ids.shape[0]
+    sequences = []
+
+    for p_idx in range(N_parents):
+        child_row      = children_ids[p_idx]
+        valid_children = child_row[child_row >= 0]
+
+        if len(valid_children) < min_children:
+            continue
+
+        parent_pos = parent_quant['positions'][p_idx]
+        tokens     = []
+
+        # ── parent（坐标置零）─────────────────────────
+        t = make_token(p_idx, parent_quant, parent_pos, ROLE_PARENT)
+        t['dx'] = t['dy'] = t['dz'] = 0.0
+        tokens.append(t)
+
+        # ── uncle（前后各 half 个空间邻居）────────────
+        half         = max_uncles // 2
+        added_uncles = 0
+        for offset in list(range(-half, 0)) + list(range(1, half + 1)):
+            u_idx = p_idx + offset
+            if 0 <= u_idx < N_parents and added_uncles < max_uncles:
+                tokens.append(
+                    make_token(u_idx, parent_quant, parent_pos, ROLE_UNCLE)
+                )
+                added_uncles += 1
+
+        # ── child（所有有效子节点）──────────────────────
+        for c_idx in valid_children:
+            tokens.append(
+                make_token(int(c_idx), child_quant, parent_pos, ROLE_CHILD)
+            )
+
+        # ── EOS ────────────────────────────────────────
+        tokens.append(make_eos_token())
+
+        # ── PAD 补齐到 fixed_len ────────────────────────
+        while len(tokens) < fixed_len:
+            tokens.append(make_pad_token())
+
+        # 超长截断（极端情况：uncle+child 超出 fixed_len-2）
+        if len(tokens) > fixed_len:
+            tokens = tokens[:fixed_len - 1]
+            tokens.append(make_eos_token())
+
+        sequences.append(np.array(tokens, dtype=TOKEN_DTYPE))
+
+    return sequences
+
+
+# ─────────────────────────────────────────────
+# 5. 多层序列构建主函数
+# ─────────────────────────────────────────────
+
+def build_all_sequences(
+    quant_paths:    list,    # 按粗→细顺序：[L3.npz, L2.npz, L1.npz, L0.npz]
+    genealogy_path: str,
+    save_dir:       str,
+    max_uncles:     int = MAX_UNCLES,
+    min_children:   int = 1,
+) -> None:
+    """
+    quant_paths 按粗→细顺序传入，例如：
+        [L3_quantized.npz, L2_quantized.npz, L1_quantized.npz, L0_quantized.npz]
+
+    genealogy.pkl 格式：
+        genealogy[3]['children_ids'] shape (N_L3, MAX_CHILDREN)
+            L3粗节点 → L2细节点索引
+        genealogy[2]['children_ids'] shape (N_L2, MAX_CHILDREN)
+            L2粗节点 → L1细节点索引
+        genealogy[1]['children_ids'] shape (N_L1, MAX_CHILDREN)
+            L1粗节点 → L0细节点索引
+
+    输出（按粗→细命名）：
+        save_dir/sequences_L3_to_L2.pkl
+        save_dir/sequences_L2_to_L1.pkl
+        save_dir/sequences_L1_to_L0.pkl
+    """
+    os.makedirs(save_dir, exist_ok=True)
+
+    print(f"[build] 加载族谱：{genealogy_path}")
+    genealogy = load_genealogy(genealogy_path)
+
+    print(f"[build] 加载量化数据（共 {len(quant_paths)} 个尺度，粗→细顺序）...")
+    quants = []
+    for path in quant_paths:
+        print(f"         {os.path.basename(path)}")
+        quants.append(load_quantized(path))
+
+    # quants[0]=最粗(L3), quants[1]=L2, ..., quants[-1]=最细(L0)
+    n_levels = len(quants)
+    # genealogy key: quants[0]→quants[1] 对应 key=n_levels-1（即3）
+    #               quants[1]→quants[2] 对应 key=n_levels-2（即2）
+    #               ...
+
+    for i in range(n_levels - 1):
+        coarse_level = n_levels - 1 - i      # 3, 2, 1
+        fine_level   = coarse_level - 1      # 2, 1, 0
+        gen_key      = coarse_level          # genealogy key 与粗尺度编号一致
+
+        coarse_name = f"L{coarse_level}"
+        fine_name   = f"L{fine_level}"
+
+        if gen_key not in genealogy:
+            print(f"[build] 警告：族谱中无 key={gen_key}，跳过 {coarse_name}→{fine_name}")
+            continue
+
+        parent_quant = quants[i]
+        child_quant  = quants[i + 1]
+        children_ids = genealogy[gen_key]['children_ids']   # (N_coarse, 32)
+
+        print(f"\n[build] 构建 {coarse_name}→{fine_name} 序列")
+        print(f"         父节点数={children_ids.shape[0]}, "
+              f"children_ids.shape={children_ids.shape}")
+
+        sequences = build_level_sequences(
+            parent_quant, child_quant, children_ids,
+            max_uncles=max_uncles,
+            min_children=min_children,
+            fixed_len=MAX_SEQ_LEN,
+        )
+
+        if len(sequences) == 0:
+            print("         [警告] 没有有效序列，请检查族谱与量化数据")
+            continue
+
+        # 统计子节点数分布
+        child_counts = np.array([
+            int((s['role'] == ROLE_CHILD).sum()) for s in sequences
+        ])
+        print(f"         生成序列数：{len(sequences)}")
+        print(f"         子节点数：min={child_counts.min()}, "
+              f"max={child_counts.max()}, mean={child_counts.mean():.2f}")
+
+        # role 分布统计
+        all_roles = np.concatenate([s['role'] for s in sequences])
+        for r, name in [(0,'parent'),(1,'uncle'),(2,'child'),(3,'EOS'),(4,'PAD')]:
+            cnt = (all_roles == r).sum()
+            print(f"           role={r}({name:6s})：{cnt:,} tokens")
+
+        out_path = os.path.join(save_dir,
+                                f"sequences_{coarse_name}_to_{fine_name}.pkl")
+        with open(out_path, 'wb') as f:
+            pickle.dump(sequences, f, protocol=4)
+
+        size_mb = os.path.getsize(out_path) / 1024 / 1024
+        print(f"         保存 → {out_path}  ({size_mb:.2f} MB)")
+
+    print(f"\n[build] 全部序列构建完成！")
+    print(f"        固定序列长度 MAX_SEQ_LEN={MAX_SEQ_LEN} "
+          f"(parent=1, uncle≤{MAX_UNCLES}, child≤{MAX_CHILDREN}, EOS=1)")
+
+
+# ─────────────────────────────────────────────
+# 6. CLI
+# ─────────────────────────────────────────────
+
+def parse_args():
+    parser = argparse.ArgumentParser(description="构建 3DGS split 序列")
+    parser.add_argument('--quant_paths', nargs='+', required=True,
+                        help='量化 .npz 路径，按粗→细顺序：L3 L2 L1 L0')
+    parser.add_argument('--genealogy',    required=True,
+                        help='族谱 genealogy.pkl 路径')
+    parser.add_argument('--save_dir',     default='./sequences',
+                        help='序列输出目录（默认 ./sequences）')
+    parser.add_argument('--max_uncles',   type=int, default=MAX_UNCLES)
+    parser.add_argument('--min_children', type=int, default=1)
+    return parser.parse_args()
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    build_all_sequences(
+        quant_paths=args.quant_paths,
+        genealogy_path=args.genealogy,
+        save_dir=args.save_dir,
+        max_uncles=args.max_uncles,
+        min_children=args.min_children,
+    )

infer_upsample.py

@@ -0,0 +1,456 @@
+"""
+infer_upsample.py
+=================
+使用训练好的 Transformer，从粗尺度（Ln）自回归生成细尺度（L(n-1)）。
+
+流程：
+  1. 读取粗尺度量化数据（.npz）
+  2. 为每个粗节点构造前缀序列（parent + uncles）
+  3. 自回归生成子节点（遇到 role=EOS 或超过 MAX_CHILDREN 则停止）
+  4. 将子节点量化索引解码为真实属性（查 codebook）
+  5. 写出新的 .ply 文件
+
+role 编码（与训练一致）：
+  0 = parent   1 = uncle   2 = child   3 = EOS   4 = PAD
+"""
+
+import os
+import argparse
+import pickle
+import numpy as np
+
+import torch
+import torch.nn.functional as F
+from plyfile import PlyData, PlyElement
+
+# ─────────────────────────────────────────────
+# 常量（与 build_sequences / train_transformer 一致）
+# ─────────────────────────────────────────────
+
+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
+
+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')}")
+    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_prefix_batch(
+    p_idx:      int,
+    quant:      dict,
+    max_uncles: int    = MAX_UNCLES,
+    device:     str    = 'cpu',
+) -> tuple:
+    """
+    构造粗节点 p_idx 的前缀 batch（parent + uncles），
+    返回 (batch_dict, parent_pos)。
+    batch_dict 中每个张量 shape (1, prefix_len)。
+    """
+    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)
+
+    # ── uncle ──────────────────────────────────
+    half         = max_uncles // 2
+    added_uncles = 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_uncles < max_uncles:
+            tokens.append(_make_np_token(u_idx, quant, parent_pos, ROLE_UNCLE))
+            added_uncles += 1
+
+    seq = np.array(tokens, dtype=TOKEN_DTYPE)
+    return _seq_to_batch(seq, device), parent_pos
+
+
+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]
+    token['role']      = role
+    return token[0]
+
+
+def _seq_to_batch(seq: np.ndarray, device: str) -> dict:
+    """将 numpy 序列转为模型输入 dict，batch_size=1。"""
+    L   = len(seq)
+    xyz = np.stack([seq['dx'], seq['dy'], seq['dz']], axis=1)  # (L, 3)
+    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),
+        # Dataset 里的两个 loss_mask 推断时不需要，但 forward 不用它们，可省略
+    }
+
+
+def _append_token(batch: dict, token_np: np.ndarray, device: str) -> dict:
+    """将新预测的 token 拼接到 batch 末尾，用于下一步自回归。"""
+    new_xyz = torch.tensor(
+        [[[token_np['dx'], token_np['dy'], token_np['dz']]]],
+        dtype=torch.float32, device=device
+    )
+    def cat(key, val, dtype):
+        new = torch.tensor([[val]], dtype=dtype, device=device)
+        return torch.cat([batch[key], new], 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),
+    }
+
+
+# ─────────────────────────────────────────────
+# 5. 自回归生成子节点
+# ─────────────────────────────────────────────
+
+def generate_children(
+    model:          object,
+    prefix_batch:   dict,
+    parent_pos:     np.ndarray,
+    max_children:   int   = MAX_CHILDREN,
+    temperature:    float = 0.8,
+    top_k:          int   = 50,
+    device:         str   = 'cpu',
+) -> list:
+    """
+    给定前缀 batch（parent + uncles），自回归采样子节点。
+
+    每步先预测 role：
+      role=2(child)  → 继续预测特征，加入序列
+      role=3(EOS)    → 提前终止
+      其他           → 异常，强制终止
+
+    返回 list of dict，每个 dict 包含子节点所有字段 + world_pos。
+    """
+    current_batch = prefix_batch
+    children      = []
+
+    def _sample_cls(logits: torch.Tensor, n_classes: int) -> int:
+        logits = logits / temperature
+        if top_k > 0:
+            k = min(top_k, n_classes)
+            topk_vals, _ = torch.topk(logits, k)
+            threshold     = topk_vals[-1]
+            logits        = logits.masked_fill(logits < threshold, float('-inf'))
+        probs = F.softmax(logits, dim=-1)
+        return int(torch.multinomial(probs, 1).item())
+
+    for _ in range(max_children):
+        with torch.no_grad():
+            pred = model(current_batch)
+
+        # ── 先预测 role ────────────────────────
+        role_logits = pred['role'][0, -1, :]    # (4,)
+        pred_role   = _sample_cls(role_logits, N_ROLE)
+
+        if pred_role == ROLE_EOS:
+            break   # 模型预测到结束符，停止
+
+        if pred_role != ROLE_CHILD:
+            # 预测出了 parent/uncle，模型异常，强制终止
+            break
+
+        # ── role=child，预测其他特征 ────────────
+        pred_scale = _sample_cls(pred['scale'][0, -1, :], N_SCALE)
+        pred_rot   = _sample_cls(pred['rot'][0, -1, :],   N_ROT)
+        pred_dc    = _sample_cls(pred['dc'][0, -1, :],    N_DC)
+        pred_sh    = _sample_cls(pred['sh'][0, -1, :],    N_SH)
+
+        pred_xyz = pred['xyz'][0, -1, :].cpu().numpy()          # (3,) 相对偏移
+        pred_opa = float(pred['opacity'][0, -1, 0].cpu())
+
+        # 记录子节点信息
+        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':   float(np.clip(pred_opa, -10, 10)),
+            'role':      ROLE_CHILD,
+            'world_pos': parent_pos + pred_xyz,    # 世界坐标
+        }
+        children.append(child)
+
+        # 将新 token 加入序列（供下一步生成）
+        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']   = child['opacity']
+        np_token['role']      = ROLE_CHILD
+        current_batch = _append_token(current_batch, np_token[0], device)
+
+    return children
+
+
+# ─────────────────────────────────────────────
+# 6. 写出 .ply
+# ─────────────────────────────────────────────
+
+def children_to_ply(
+    all_children: list,
+    codebooks:    dict,
+    save_path:    str,
+    n_sh_rest:    int = 45,
+) -> 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)
+    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)
+
+    # 量化索引 → 真实属性（codebook 查表）
+    scales    = codebooks['scale'][scale_idx]       # (N, 3)
+    rotations = codebooks['rotation'][rot_idx]      # (N, 4)
+    dc        = codebooks['dc'][dc_idx]             # (N, 3)
+    sh_rest   = codebooks['sh'][sh_idx]             # (N, 45)
+
+    # 构造 PLY vertex 结构
+    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')] +
+        [(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]
+    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,
+) -> 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)
+
+    N = quant['positions'].shape[0]
+    if max_gaussians > 0:
+        N = min(N, max_gaussians)
+    print(f"[infer] 处理 {N} 个粗节点，最多生成 {N * max_children} 个子节点")
+
+    all_children     = []
+    total_generated  = 0
+    early_stop_count = 0
+
+    for p_idx in range(N):
+        if p_idx % 5000 == 0:
+            print(f"  进度：{p_idx}/{N}  已生成子节点：{total_generated}")
+
+        prefix_batch, parent_pos = make_prefix_batch(
+            p_idx, quant, max_uncles=max_uncles, device=device
+        )
+        children = generate_children(
+            model, prefix_batch, parent_pos,
+            max_children=max_children,
+            temperature=temperature,
+            top_k=top_k,
+            device=device,
+        )
+
+        if len(children) < max_children:
+            early_stop_count += 1
+
+        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)
+    print(f"\n[infer] 完成！输出 → {save_path}")
+
+
+# ─────────────────────────────────────────────
+# 8. CLI
+# ─────────────────────────────────────────────
+
+def parse_args():
+    p = argparse.ArgumentParser(description="用 Transformer 从粗尺度生成细尺度 3DGS")
+    p.add_argument('--ckpt',          required=True,  help='模型 checkpoint 路径')
+    p.add_argument('--quant_npz',     required=True,  help='粗尺度量化数据 .npz')
+    p.add_argument('--codebook_dir',  required=True,  help='codebook 目录')
+    p.add_argument('--save_path',     required=True,  help='输出 .ply 路径')
+    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,
+                   help='调试用：只处理前 N 个粗节点')
+    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,
+    )

train_transformer.py

@@ -0,0 +1,526 @@
+"""
+train_transformer.py
+====================
+训练层级 3DGS split 生成 Transformer。
+
+模型：GPT 风格 decoder-only Transformer，自回归预测序列中每个下一个 token。
+
+输入序列（固定长度 MAX_SEQ_LEN=38）：
+  [parent(1)] [uncle×≤4] [child×≤32] [EOS(1)] [PAD×...]
+
+role 编码：
+  0 = parent   1 = uncle   2 = child   3 = EOS   4 = PAD
+
+输出（多头）：
+  role     分类 (0~3，4类，PAD不预测)   cross-entropy
+  xyz      回归                          MSE（只在 child 位置）
+  opacity  回归                          MSE（只在 child 位置）
+  scale    分类 N_SCALE=16384            CE（只在 child 位置）
+  rot      分类 N_ROT=16384              CE（只在 child 位置）
+  dc       分类 N_DC=4096               CE（只在 child 位置）
+  sh       分类 N_SH=4096               CE（只在 child 位置）
+"""
+
+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
+from torch.utils.data import Dataset, DataLoader
+
+# ─────────────────────────────────────────────
+# 常量（与 build_sequences.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      # 模型只预测 0~3，PAD 不输出
+
+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. Dataset
+# ─────────────────────────────────────────────
+
+class SplitSequenceDataset(Dataset):
+    """
+    加载 build_sequences.py 生成的 .pkl 序列文件。
+    序列已是固定长度 MAX_SEQ_LEN，无需再 pad。
+    """
+
+    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)
+            print(f"  加载 {os.path.basename(path)}：{len(seqs)} 条")
+        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]          # (MAX_SEQ_LEN,) TOKEN_DTYPE
+        role = seq['role'].astype(np.int64) # (L,)
+
+        # attention mask：PAD 位置为 False
+        attn_mask = (role != ROLE_PAD)      # (L,) bool
+
+        # loss_mask_feat：只在 child 位置计算特征 loss（xyz/opa/scale/rot/dc/sh）
+        loss_mask_feat = (role == ROLE_CHILD)   # (L,) bool
+
+        # loss_mask_role：在所有非 PAD 位置计算 role 分类 loss（包含 EOS）
+        loss_mask_role = (role != ROLE_PAD)     # (L,) bool
+
+        xyz = np.stack([seq['dx'], seq['dy'], seq['dz']], axis=1)  # (L, 3)
+
+        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(seq['opacity'].astype(np.float32)),
+            '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):
+    """
+    将每个 token 的多字段（离散索引 + 连续值 + role）映射到 d_model 维。
+    """
+
+    def __init__(self, d_model: int):
+        super().__init__()
+        d = d_model // 8    # 每个子字段的 embedding 维度
+
+        # 离散索引 embedding（索引 +1 偏移，0 留给 padding_idx）
+        self.emb_scale = nn.Embedding(N_SCALE + 1, d, padding_idx=0)
+        self.emb_rot   = nn.Embedding(N_ROT   + 1, d, padding_idx=0)
+        self.emb_dc    = nn.Embedding(N_DC    + 1, d, padding_idx=0)
+        self.emb_sh    = nn.Embedding(N_SH    + 1, d, padding_idx=0)
+
+        # role embedding：0~3 有效，4=PAD（padding_idx 屏蔽梯度）
+        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)
+
+        # 合并：xyz(2d) + scale(d) + rot(d) + dc(d) + sh(d) + opa(d) + role(d) = 8d
+        self.proj = nn.Linear(d * 8, d_model)
+
+    def forward(self, batch: dict) -> torch.Tensor:
+        # 离散索引 +1 避免与 padding_idx=0 冲突
+        e_s    = self.emb_scale(batch['scale'] + 1)   # (B, L, d)
+        e_r    = self.emb_rot(  batch['rot']   + 1)
+        e_d    = self.emb_dc(   batch['dc']    + 1)
+        e_h    = self.emb_sh(   batch['sh']    + 1)
+
+        # role 直接使用（0~4），PAD(4) 由 padding_idx 自动归零
+        e_role = self.emb_role(batch['role'])          # (B, L, d)
+
+        e_xyz  = self.proj_xyz(batch['xyz'].float())           # (B, L, 2d)
+        e_opa  = self.proj_opa(batch['opacity'].unsqueeze(-1).float())  # (B, L, d)
+
+        cat = torch.cat([e_xyz, e_s, e_r, e_d, e_h, e_opa, e_role], dim=-1)  # (B,L,8d)
+        return self.proj(cat)   # (B, L, d_model)
+
+
+# ─────────────────────────────────────────────
+# 3. Transformer Model
+# ─────────────────────────────────────────────
+
+class SplitTransformer(nn.Module):
+    """
+    Decoder-only Transformer，自回归预测下一个 token 的所有字段。
+    使用 Pre-LayerNorm（更稳定），因果 mask + PAD key_padding_mask。
+    """
+
+    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,
+    ):
+        super().__init__()
+        self.d_model     = d_model
+        self.max_seq_len = max_seq_len
+
+        self.token_emb = TokenEmbedding(d_model)
+        self.pos_emb   = nn.Embedding(max_seq_len, d_model)
+
+        layer = nn.TransformerDecoderLayer(
+            d_model=d_model,
+            nhead=n_heads,
+            dim_feedforward=d_ff,
+            dropout=dropout,
+            batch_first=True,
+            norm_first=True,        # Pre-LN，更稳定
+        )
+        self.transformer = nn.TransformerDecoder(layer, num_layers=n_layers)
+
+        # 因果 mask（上三角屏蔽未来位置）
+        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)      # 分类 4 类（不含 PAD）
+        self.head_xyz     = nn.Linear(d_model, 3)           # 回归
+        self.head_opacity = nn.Linear(d_model, 1)           # 回归
+        self.head_scale   = nn.Linear(d_model, N_SCALE)     # 分类
+        self.head_rot     = nn.Linear(d_model, N_ROT)       # 分类
+        self.head_dc      = nn.Linear(d_model, N_DC)        # 分类
+        self.head_sh      = nn.Linear(d_model, N_SH)        # 分类
+
+        self._init_weights()
+
+    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])
+
+    def forward(self, batch: dict) -> dict:
+        B, L = batch['scale'].shape
+
+        # Token embedding + 位置 embedding
+        tok_emb = self.token_emb(batch)                             # (B, L, D)
+        pos     = torch.arange(L, device=tok_emb.device)
+        x       = tok_emb + self.pos_emb(pos).unsqueeze(0)         # (B, L, D)
+
+        # key_padding_mask：True 的位置被忽略（PAD）
+        pad_mask = ~batch['attn_mask']                              # (B, L)
+
+        # 因果 mask（L×L 上三角）
+        causal = self.causal_mask[:L, :L]                          # (L, L)
+
+        # Decoder（tgt=memory=x，退化为纯 self-attn）
+        out = self.transformer(
+            tgt=x,
+            memory=x,
+            tgt_mask=causal,
+            memory_mask=causal,
+            tgt_key_padding_mask=pad_mask,
+            memory_key_padding_mask=pad_mask,
+        )   # (B, L, D)
+
+        return {
+            'role':    self.head_role(out),       # (B, L, 4)
+            'xyz':     self.head_xyz(out),         # (B, L, 3)
+            'opacity': self.head_opacity(out),     # (B, L, 1)
+            'scale':   self.head_scale(out),       # (B, L, N_SCALE)
+            'rot':     self.head_rot(out),         # (B, L, N_ROT)
+            'dc':      self.head_dc(out),          # (B, L, N_DC)
+            'sh':      self.head_sh(out),          # (B, L, N_SH)
+        }
+
+
+# ─────────────────────────────────────────────
+# 4. Loss
+# ─────────────────────────────────────────────
+
+def compute_loss(pred: dict, batch: dict, weights: dict = None) -> tuple:
+    """
+    自回归 loss：位置 t 的输出预测位置 t+1 的 token。
+
+    loss_mask_feat（child 位置）→ 特征 loss（xyz/opa/scale/rot/dc/sh）
+    loss_mask_role（非PAD位置） → role 分类 loss（包含 EOS 的 role=3）
+
+    两类 mask 均在 shift 后（[:, 1:]）取。
+    """
+    if weights is None:
+        weights = {
+            'role': 1.5,
+            'xyz': 1.0, 'opacity': 0.5,
+            'scale': 2.0, 'rot': 2.0, 'dc': 1.0, 'sh': 1.0,
+        }
+
+    # shift：用位置 t 的输出预测位置 t+1
+    feat_mask = batch['loss_mask_feat'][:, 1:]   # (B, L-1) child 位置
+    role_mask = batch['loss_mask_role'][:, 1:]   # (B, L-1) 非PAD位置
+
+    def _reg_loss(pred_key, tgt_key, mask, squeeze=False):
+        p = pred[pred_key][:, :-1]               # (B, L-1, ...)
+        t = batch[tgt_key][:, 1:]
+        if squeeze:
+            p = p.squeeze(-1)
+        mse = F.mse_loss(p, t.float(), reduction='none')
+        if mse.dim() == 3:
+            mse = mse.mean(-1)
+        denom = mask.sum().clamp(min=1)
+        return (mse * mask).sum() / denom
+
+    def _cls_loss(pred_key, tgt_key, mask):
+        p = pred[pred_key][:, :-1]               # (B, L-1, C)
+        t = batch[tgt_key][:, 1:]                # (B, L-1)
+        if not mask.any():
+            return p.sum() * 0.0
+        return F.cross_entropy(p[mask], t[mask])
+
+    # role loss：在所有非 PAD 位置（包含 EOS）
+    loss_role  = _cls_loss('role',    'role',    role_mask)
+
+    # 特征 loss：只在 child 位置
+    loss_xyz   = _reg_loss('xyz',     'xyz',     feat_mask)
+    loss_opa   = _reg_loss('opacity', 'opacity', feat_mask, squeeze=True)
+    loss_scale = _cls_loss('scale',   'scale',   feat_mask)
+    loss_rot   = _cls_loss('rot',     'rot',     feat_mask)
+    loss_dc    = _cls_loss('dc',      'dc',      feat_mask)
+    loss_sh    = _cls_loss('sh',      'sh',      feat_mask)
+
+    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
+    )
+
+    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. 训练主循环
+# ─────────────────────────────────────────────
+
+def train(
+    seq_pkl_paths: list,
+    save_dir:      str,
+    # 模型超参
+    d_model:      int   = 512,
+    n_heads:      int   = 8,
+    n_layers:     int   = 6,
+    d_ff:         int   = 2048,
+    dropout:      float = 0.1,
+    # 训练超参
+    batch_size:   int   = 64,
+    lr:           float = 3e-4,
+    epochs:       int   = 50,
+    warmup_steps: int   = 1000,
+    grad_clip:    float = 1.0,
+    val_ratio:    float = 0.05,
+    save_every:   int   = 5,
+    device:       str   = 'auto',
+):
+    os.makedirs(save_dir, exist_ok=True)
+
+    if device == 'auto':
+        device = 'cuda' if torch.cuda.is_available() else 'cpu'
+    print(f"[train] device={device}")
+
+    # ── 数据集 ────────────────���──────────────
+    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)
+    )
+
+    train_loader = DataLoader(
+        train_set, batch_size=batch_size, shuffle=True,
+        collate_fn=collate_fn, num_workers=4, pin_memory=True,
+    )
+    val_loader = DataLoader(
+        val_set, batch_size=batch_size, shuffle=False,
+        collate_fn=collate_fn, num_workers=2,
+    )
+
+    # ── 模型 ─────────────────────────────────
+    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,
+    ).to(device)
+    n_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(f"[train] 参数量：{n_params / 1e6:.2f}M")
+
+    # ── 优化器 + 调度器 ───────────────────────
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-2)
+    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):
+        model.train()
+        epoch_losses = []
+
+        for batch in train_loader:
+            batch = {k: v.to(device) if isinstance(v, torch.Tensor) else v
+                     for k, v in batch.items()}
+
+            pred = model(batch)
+            loss, loss_dict = compute_loss(pred, batch)
+
+            optimizer.zero_grad()
+            loss.backward()
+            nn.utils.clip_grad_norm_(model.parameters(), grad_clip)
+            optimizer.step()
+            scheduler.step()
+            epoch_losses.append(loss_dict['total'])
+            global_step += 1
+
+        train_loss = np.mean(epoch_losses)
+
+        # ── 验证 ─────────────────────────────
+        model.eval()
+        val_losses = []
+        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)
+                val_losses.append(ld['total'])
+        val_loss = np.mean(val_losses)
+
+        print(f"[epoch {epoch:03d}/{epochs}] "
+              f"train={train_loss:.4f}  val={val_loss:.4f}  "
+              f"lr={scheduler.get_last_lr()[0]:.2e}")
+
+        # ── checkpoint ────────────────────────
+        if epoch % save_every == 0:
+            ckpt_path = os.path.join(save_dir, f"ckpt_epoch{epoch:03d}.pt")
+            torch.save({
+                'epoch':           epoch,
+                'model_state':     model.state_dict(),
+                'optimizer_state': optimizer.state_dict(),
+                'val_loss':        val_loss,
+                '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,
+                ),
+            }, 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': model.state_dict(),
+                '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,
+                ),
+            }, best_path)
+
+    print(f"\n[train] 训练完成！最优 val_loss={best_val_loss:.4f}")
+    print(f"        最优模型 → {best_path}")
+    return model
+
+
+# ─────────────────────────────────────────────
+# 6. CLI
+# ─────────────────────────────────────────────
+
+def parse_args():
+    p = argparse.ArgumentParser(description="训练 3DGS split 生成 Transformer")
+    p.add_argument('--seq_paths',   nargs='+', required=True,
+                   help='序列 .pkl 路径（可多个合并训练）')
+    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('--batch_size',  type=int,   default=64)
+    p.add_argument('--lr',          type=float, default=3e-4)
+    p.add_argument('--epochs',      type=int,   default=50)
+    p.add_argument('--warmup',      type=int,   default=1000)
+    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('--device',      default='auto')
+    return p.parse_args()
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    train(
+        seq_pkl_paths=args.seq_paths,
+        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,
+        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,
+        device=args.device,
+    )