""" train_transformer.py ==================== 训练层级 3DGS split 生成 Transformer。 支持单卡和多卡（DDP）自动切换。 单卡启动： python train_transformer.py --seq_paths sequences/*.pkl --codebook_dir ./codebooks 四卡启动： torchrun --nproc_per_node=4 train_transformer.py --seq_paths sequences/*.pkl --codebook_dir ./codebooks 修复的三个 NaN 地雷： 1. NaN * 0 = NaN：_reg_loss 改用 torch.where 屏蔽 PAD，彻底切断 NaN 污染 2. 缺少 Final LayerNorm：TransformerEncoder 加 norm 参数，约束残差流方差 3. Softmax -inf → NaN：forward 里对 transformer 输出做 nan_to_num 保底清理 role 编码： 0 = parent 1 = uncle 2 = child 3 = EOS 4 = PAD """ import os import math import argparse import pickle import numpy as np import torch import torch.nn as nn import torch.nn.functional as F import torch.distributed as dist from torch.nn.parallel import DistributedDataParallel as DDP from torch.utils.data import Dataset, DataLoader, DistributedSampler # ───────────────────────────────────────────── # 常量 # ───────────────────────────────────────────── ROLE_PARENT = 0 ROLE_UNCLE = 1 ROLE_CHILD = 2 ROLE_EOS = 3 ROLE_PAD = 4 MAX_CHILDREN = 32 MAX_UNCLES = 4 MAX_SEQ_LEN = 1 + MAX_UNCLES + MAX_CHILDREN + 1 # = 38 N_SCALE = 16384 N_ROT = 16384 N_DC = 4096 N_SH = 4096 N_ROLE = 4 CB_DIM = { 'scale': 3, 'rot': 4, 'dc': 3, 'sh': 45, } D_CB = 64 TOKEN_DTYPE = np.dtype([ ('dx', np.float32), ('dy', np.float32), ('dz', np.float32), ('scale_idx', np.int32), ('rot_idx', np.int32), ('dc_idx', np.int32), ('sh_idx', np.int32), ('opacity', np.float32), ('role', np.uint8), ]) LOSS_WEIGHTS = { 'role': 0.5, 'xyz': 1.0, 'opacity': 2.0, 'scale': 1.0, 'rot': 1.0, 'dc': 1.0, 'sh': 1.0, } OPACITY_LOGIT_CLIP = 20.0 OPACITY_NORM_CLIP = OPACITY_LOGIT_CLIP / 10.0 def normalize_quaternions_np(rotations: np.ndarray) -> np.ndarray: rotations = rotations.astype(np.float32, copy=True) norms = np.linalg.norm(rotations, axis=1, keepdims=True) valid = np.isfinite(norms) & (norms > 1e-8) rotations = np.where(valid, rotations / np.maximum(norms, 1e-8), rotations) bad = ~valid.squeeze(1) if bad.any(): rotations[bad] = np.array([1.0, 0.0, 0.0, 0.0], dtype=np.float32) return rotations # ───────────────────────────────────────────── # 分布式工具 # ───────────────────────────────────────────── def is_dist() -> bool: return dist.is_available() and dist.is_initialized() def get_rank() -> int: return dist.get_rank() if is_dist() else 0 def get_world_size() -> int: return dist.get_world_size() if is_dist() else 1 def is_main() -> bool: return get_rank() == 0 def setup_dist() -> bool: if 'RANK' not in os.environ: return False dist.init_process_group(backend='nccl') torch.cuda.set_device(int(os.environ['LOCAL_RANK'])) return True def cleanup_dist(): if is_dist(): dist.destroy_process_group() def reduce_mean(tensor: torch.Tensor) -> float: if not is_dist(): return tensor.item() rt = tensor.clone() dist.all_reduce(rt, op=dist.ReduceOp.SUM) return (rt / get_world_size()).item() # ───────────────────────────────────────────── # 1. Dataset # ───────────────────────────────────────────── class SplitSequenceDataset(Dataset): def __init__(self, seq_pkl_paths: list): self.sequences = [] for path in seq_pkl_paths: with open(path, 'rb') as f: seqs = pickle.load(f) self.sequences.extend(seqs) if is_main(): print(f" 加载 {os.path.basename(path)}：{len(seqs)} 条") if is_main(): print(f"[Dataset] 共 {len(self.sequences)} 条序列，" f"固定长度 {MAX_SEQ_LEN}") def __len__(self): return len(self.sequences) def __getitem__(self, idx): seq = self.sequences[idx] role = seq['role'].astype(np.int64) attn_mask = (role != ROLE_PAD) loss_mask_feat = (role == ROLE_CHILD) loss_mask_role = (role != ROLE_PAD) xyz = np.stack([seq['dx'], seq['dy'], seq['dz']], axis=1) # opacity 归一化到 [-1, 1] 附近 opacity = np.nan_to_num( seq['opacity'].astype(np.float32), nan=0.0, posinf=OPACITY_LOGIT_CLIP, neginf=-OPACITY_LOGIT_CLIP, ) opacity = np.clip(opacity, -OPACITY_LOGIT_CLIP, OPACITY_LOGIT_CLIP) opacity_norm = opacity / 10.0 return { 'xyz': torch.from_numpy(xyz).float(), 'scale': torch.from_numpy(seq['scale_idx'].astype(np.int64)), 'rot': torch.from_numpy(seq['rot_idx'].astype(np.int64)), 'dc': torch.from_numpy(seq['dc_idx'].astype(np.int64)), 'sh': torch.from_numpy(seq['sh_idx'].astype(np.int64)), 'opacity': torch.from_numpy(opacity_norm), 'role': torch.from_numpy(role), 'attn_mask': torch.from_numpy(attn_mask), 'loss_mask_feat': torch.from_numpy(loss_mask_feat), 'loss_mask_role': torch.from_numpy(loss_mask_role), } def collate_fn(batch): keys = ['xyz', 'scale', 'rot', 'dc', 'sh', 'opacity', 'role', 'attn_mask', 'loss_mask_feat', 'loss_mask_role'] return {k: torch.stack([b[k] for b in batch], dim=0) for k in keys} # ───────────────────────────────────────────── # 2. Token Embedding # ───────────────────────────────────────────── class TokenEmbedding(nn.Module): def __init__(self, d_model: int): super().__init__() d = d_model // 8 # 输入侧：codebook 向量查表 + 小 Linear，不用大 Embedding table self.inp_proj_scale = nn.Linear(CB_DIM['scale'], d) self.inp_proj_rot = nn.Linear(CB_DIM['rot'], d) self.inp_proj_dc = nn.Linear(CB_DIM['dc'], d) self.inp_proj_sh = nn.Linear(CB_DIM['sh'], d) # role 只有 5 个值，小 Embedding 完全没问题 self.emb_role = nn.Embedding(5, d, padding_idx=ROLE_PAD) self.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) p = torch.nan_to_num(p, nan=0.0, posinf=1e4, neginf=-1e4) t = torch.nan_to_num(t.float(), nan=0.0, posinf=1e4, neginf=-1e4) if p.dim() == 3: valid = mask & torch.isfinite(p).all(dim=-1) & torch.isfinite(t).all(dim=-1) else: valid = mask & torch.isfinite(p) & torch.isfinite(t) if not valid.any(): return torch.tensor(0.0, device=p.device) mse = F.mse_loss(p / scale, t / scale, reduction='none') if mse.dim() == 3: mse = mse.mean(-1) # torch.where：mask=True 的位置保留 mse，mask=False 填 0.0 # 彻底切断 PAD 位置 NaN 的污染（NaN * 0 = NaN，但 where 选 0.0 安全） masked_mse = torch.where(valid, mse, torch.zeros_like(mse)) return masked_mse.sum() / valid.sum().clamp(min=1) def _opacity_loss(mask): p = pred['opacity'][:, :-1].squeeze(-1) t = batch['opacity'][:, 1:].float() p = torch.nan_to_num( p, nan=0.0, posinf=OPACITY_NORM_CLIP, neginf=-OPACITY_NORM_CLIP, ) t = torch.nan_to_num( t, nan=0.0, posinf=OPACITY_NORM_CLIP, neginf=-OPACITY_NORM_CLIP, ).clamp(-OPACITY_NORM_CLIP, OPACITY_NORM_CLIP) valid = mask & torch.isfinite(p) & torch.isfinite(t) if not valid.any(): return torch.tensor(0.0, device=p.device) loss = F.smooth_l1_loss(p, t, reduction='none', beta=0.25) loss = torch.where(valid, loss, torch.zeros_like(loss)) return loss.sum() / valid.sum().clamp(min=1) def _cls_loss_role(mask): p = pred['role'][:, :-1] t = batch['role'][:, 1:] if not mask.any(): return torch.tensor(0.0, device=p.device) # p[mask] 直接丢弃 PAD 位置，天然安全 p_m = p[mask] t_m = t[mask] valid = (t_m >= 0) & (t_m < N_ROLE) if not valid.all(): p_m, t_m = p_m[valid], t_m[valid] if p_m.numel() == 0: return torch.tensor(0.0, device=p.device) return F.cross_entropy(p_m, t_m, label_smoothing=0.1) def _emb_loss(pred_emb_key, tgt_idx_key, mask, cb_name): p = pred[pred_emb_key][:, :-1] t_idx = batch[tgt_idx_key][:, 1:] if not mask.any(): return torch.tensor(0.0, device=p.device) p_m = p[mask] t_idx_m = t_idx[mask] cb = getattr(raw_model, f'cb_{cb_name}') cb_proj = getattr(raw_model, f'cb_proj_{cb_name}') valid = (t_idx_m >= 0) & (t_idx_m < cb.shape[0]) if not valid.all(): p_m, t_idx_m = p_m[valid], t_idx_m[valid] if p_m.numel() == 0: return torch.tensor(0.0, device=p.device) with torch.no_grad(): t_emb = cb_proj(cb[t_idx_m]) # 两边 normalize 后算 MSE，梯度有界 p_norm = F.normalize(p_m, dim=-1, eps=1e-8) t_norm = F.normalize(t_emb, dim=-1, eps=1e-8) return F.mse_loss(p_norm, t_norm) loss_role = _cls_loss_role(role_mask) loss_xyz = _reg_loss('xyz', 'xyz', feat_mask, scale=5.0) loss_opa = _opacity_loss(feat_mask) loss_scale = _emb_loss('scale_emb', 'scale', feat_mask, 'scale') loss_rot = _emb_loss('rot_emb', 'rot', feat_mask, 'rot') loss_dc = _emb_loss('dc_emb', 'dc', feat_mask, 'dc') loss_sh = _emb_loss('sh_emb', 'sh', feat_mask, 'sh') total = ( weights['role'] * loss_role + weights['xyz'] * loss_xyz + weights['opacity'] * loss_opa + weights['scale'] * loss_scale + weights['rot'] * loss_rot + weights['dc'] * loss_dc + weights['sh'] * loss_sh ) if not torch.isfinite(total): bad = {k: v.item() for k, v in { 'role': loss_role, 'xyz': loss_xyz, 'opa': loss_opa, 'scale': loss_scale, 'rot': loss_rot, 'dc': loss_dc, 'sh': loss_sh, }.items() if not torch.isfinite(v)} if is_main(): print(f"[NaN警告] 非有限 loss 来自：{bad}") total = torch.tensor(0.0, requires_grad=True, device=loss_role.device) return total, { 'role': loss_role.item(), 'xyz': loss_xyz.item(), 'opacity': loss_opa.item(), 'scale': loss_scale.item(), 'rot': loss_rot.item(), 'dc': loss_dc.item(), 'sh': loss_sh.item(), 'total': total.item(), } # ───────────────────────────────────────────── # 5. 诊断（第一个 batch） # ───────────────────────────────────────────── def diagnose_first_batch(model, batch, loss_weights=None): if not is_main(): return print("\n========== 第一个 batch 诊断 ==========") for key, val in batch.items(): if not isinstance(val, torch.Tensor): continue if val.dtype == torch.float32: finite = torch.isfinite(val) val_finite = val[finite] if val_finite.numel() == 0: min_val, max_val = float('nan'), float('nan') else: min_val, max_val = val_finite.min().item(), val_finite.max().item() print(f" batch[{key:16s}]: shape={str(val.shape):25s} " f"nan={torch.isnan(val).sum().item()} " f"inf={torch.isinf(val).sum().item()} " f"min={min_val:10.4f} max={max_val:10.4f}") else: print(f" batch[{key:16s}]: shape={str(val.shape):25s} " f"dtype={val.dtype} " f"min={val.min().item()} max={val.max().item()}") raw_model = model.module if hasattr(model, 'module') else model with torch.no_grad(): pred_check = raw_model(batch) print() for key, val in pred_check.items(): print(f" pred[{key:12s}]: " f"nan={torch.isnan(val).sum().item()} " f"min={val.min().item():9.4f} " f"max={val.max().item():9.4f} " f"std={val.std().item():.4f}") _, loss_dict_check = compute_loss(pred_check, batch, model, weights=loss_weights) print() for key, val in loss_dict_check.items(): print(f" loss_{key:8s} = {val:.6f}") print("========================================\n") # ───────────────────────────────────────────── # 6. 训练主循环 # ───────────────────────────────────────────── def train( seq_pkl_paths: list, codebook_dir: str, save_dir: str, d_model: int = 512, n_heads: int = 8, n_layers: int = 6, d_ff: int = 2048, d_cb: int = D_CB, dropout: float = 0.1, batch_size: int = 64, lr: float = 1e-4, epochs: int = 50, warmup_steps: int = 2000, grad_clip: float = 1.0, val_ratio: float = 0.05, save_every: int = 5, 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, )