infer_upsample.py

"""
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,
    )