Upload infer_upsample.py

infer_upsample.py

@@ -0,0 +1,442 @@
+"""
+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
+
+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),
+    }
+
+
+# ─────────────────────────────────────────────
+# 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',
+) -> 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  # 反归一化
+
+        # 预测 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':   float(np.clip(pred_opa, -20, 20)),
+            '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
+
+
+# ─────────────────────────────────────────────
+# 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)
+
+    scales    = codebooks['scale'][scale_idx]
+    rotations = 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')] +
+        [(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} 个粗节点")
+
+    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)
+    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)
+    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,
+    )