| |
| |
| |
|
|
| import sys |
| import os |
| import torch |
| import argparse |
| from tqdm import tqdm |
| import json |
| from torch.utils.data import DataLoader, WeightedRandomSampler |
| import torch.optim.lr_scheduler as lr_scheduler |
| import torch.nn.functional as F |
| import math |
|
|
| sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))) |
| chamfer_lib_path = os.path.join(os.path.dirname(__file__), '..', '..', 'ChamferDistancePytorch') |
| sys.path.insert(0, chamfer_lib_path) |
|
|
| from dragmesh.data.balanced_dataset_utils import VAE_LMDBDataset, get_motion_type_weights |
| from dragmesh.utils.logger import create_logger |
| from dragmesh.utils.kpp_normalization import KPP_ORIGIN_NORMALIZATION |
|
|
| from dragmesh.models.predictor import KeypointPredictor |
| from dragmesh.models.predictor_loss import compute_predictor_loss, geodesic_loss_report |
|
|
| try: |
| from dragmesh.models.model_v2 import count_parameters |
| except ImportError: |
| print("Warning: 'count_parameters' not found in 'dragmesh.models.model_v2'.") |
| def count_parameters(model): |
| return sum(p.numel() for p in model.parameters() if p.requires_grad) |
|
|
| def str2bool(v): |
| """ |
| NOTE: `argparse` with `type=bool` is error-prone (e.g., the string 'False' becomes True). |
| This helper supports common CLI boolean strings: True/False/1/0/yes/no. |
| """ |
| if isinstance(v, bool): |
| return v |
| if v is None: |
| return False |
| s = str(v).strip().lower() |
| if s in ("1", "true", "t", "yes", "y", "on"): |
| return True |
| if s in ("0", "false", "f", "no", "n", "off"): |
| return False |
| raise argparse.ArgumentTypeError(f"Invalid boolean value: {v}") |
|
|
| def _coerce_pointcloud(x: torch.Tensor) -> torch.Tensor: |
| """ |
| Handle common point-cloud layouts from different LMDB formats: |
| - [N,3] / [B,N,3] |
| - [3,N] / [B,3,N] |
| - [N,>=3] keep the first 3 channels |
| """ |
| if x is None: |
| return x |
| if x.dim() == 2: |
| |
| if x.shape[0] == 3 and x.shape[1] != 3: |
| x = x.transpose(0, 1) |
| if x.shape[-1] > 3: |
| x = x[:, :3] |
| return x |
| if x.dim() == 3: |
| |
| if x.shape[1] == 3 and x.shape[2] != 3: |
| x = x.transpose(1, 2) |
| if x.shape[-1] > 3: |
| x = x[:, :, :3] |
| return x |
| return x |
|
|
| def _get_with_aliases(batch: dict, keys: list[str]): |
| for k in keys: |
| if k in batch: |
| return batch[k] |
| return None |
|
|
| def _ensure_batch_fields(batch: dict, device: torch.device): |
| """ |
| Make training robust to dataset / LMDB field-name variations: |
| - initial_mesh: required; shape is coerced to [B, N, 3] |
| - drag_point/drag_vector/part_mask: default to zeros/ones if missing |
| - joint_type/axis/origin: support common aliases with dtype/shape fallbacks |
| """ |
| mesh = _get_with_aliases(batch, ["initial_mesh", "mesh", "points", "pc"]) |
| if mesh is None: |
| raise KeyError("Missing required field: initial_mesh (or mesh/points/pc)") |
| mesh = _coerce_pointcloud(mesh).to(device) |
|
|
| |
| if mesh.dim() != 3: |
| raise ValueError(f"initial_mesh should be [B,N,3], got shape={tuple(mesh.shape)}") |
| B, N, _ = mesh.shape |
|
|
| part_mask = _get_with_aliases(batch, ["part_mask", "mask", "seg", "part_seg"]) |
| if part_mask is None: |
| part_mask = torch.ones((B, N), device=device, dtype=torch.float32) |
| else: |
| if part_mask.dim() == 1: |
| part_mask = part_mask.unsqueeze(0).expand(B, -1) |
| part_mask = part_mask.to(device).float() |
|
|
| drag_point = _get_with_aliases(batch, ["drag_point", "drag_pt", "start_point"]) |
| if drag_point is None: |
| drag_point = torch.zeros((B, 3), device=device, dtype=mesh.dtype) |
| else: |
| drag_point = drag_point.to(device).float() |
| if drag_point.dim() == 1: |
| drag_point = drag_point.unsqueeze(0) |
|
|
| drag_vector = _get_with_aliases(batch, ["drag_vector", "drag_vec", "direction", "drag_dir"]) |
| if drag_vector is None: |
| drag_vector = torch.zeros((B, 3), device=device, dtype=mesh.dtype) |
| else: |
| drag_vector = drag_vector.to(device).float() |
| if drag_vector.dim() == 1: |
| drag_vector = drag_vector.unsqueeze(0) |
|
|
| gt_joint_type = _get_with_aliases(batch, ["joint_type", "gt_joint_type", "type"]) |
| if gt_joint_type is None: |
| |
| gt_joint_type = torch.zeros((B,), device=device, dtype=torch.long) |
| else: |
| gt_joint_type = gt_joint_type.to(device) |
| if gt_joint_type.dim() == 0: |
| gt_joint_type = gt_joint_type.view(1) |
| if gt_joint_type.dim() == 2 and gt_joint_type.shape[-1] == 1: |
| gt_joint_type = gt_joint_type[:, 0] |
| |
| gt_joint_type = gt_joint_type.long() |
|
|
| gt_joint_axis = _get_with_aliases(batch, ["joint_axis", "gt_joint_axis", "axis"]) |
| if gt_joint_axis is None: |
| gt_joint_axis = torch.tensor([0.0, 0.0, 1.0], device=device).view(1, 3).expand(B, 3) |
| else: |
| gt_joint_axis = gt_joint_axis.to(device).float() |
| if gt_joint_axis.dim() == 1: |
| gt_joint_axis = gt_joint_axis.unsqueeze(0) |
| gt_joint_axis = F.normalize(gt_joint_axis, dim=-1) |
|
|
| gt_joint_origin = _get_with_aliases(batch, ["joint_origin", "gt_joint_origin", "origin"]) |
| if gt_joint_origin is None: |
| gt_joint_origin = torch.zeros((B, 3), device=device, dtype=torch.float32) |
| else: |
| gt_joint_origin = gt_joint_origin.to(device).float() |
| if gt_joint_origin.dim() == 1: |
| gt_joint_origin = gt_joint_origin.unsqueeze(0) |
|
|
| return mesh, part_mask, drag_point, drag_vector, gt_joint_type, gt_joint_axis, gt_joint_origin |
|
|
|
|
| def custom_collate_fn(batch): |
|
|
| batch = [b for b in batch if b is not None] |
| if not batch: |
| return None |
|
|
| return torch.utils.data.dataloader.default_collate(batch) |
|
|
|
|
| def warn_if_old_origin_lmdb(dataset, name: str): |
| """Detect LMDBs built with the old joint-origin-centered KPP labels.""" |
| checked = 0 |
| zero_origin = 0 |
| missing_version = 0 |
| for idx in range(min(len(dataset), 32)): |
| sample = dataset[idx] |
| if sample is None: |
| continue |
| checked += 1 |
| if "origin_normalization_version" not in sample: |
| missing_version += 1 |
| origin = sample.get("joint_origin") |
| if origin is not None and torch.max(torch.abs(origin.float())).item() < 1e-6: |
| zero_origin += 1 |
| if checked and (missing_version == checked or zero_origin == checked): |
| print( |
| f"[WARN] {name} LMDB looks like it was built with old KPP origin labels " |
| "(joint-origin-centered, target always near zero). Rebuild LMDB with " |
| "scripts/data/build_lmdb.py before retraining KPP origin prediction." |
| ) |
|
|
|
|
| def train_epoch(model, dataloader, optimizer, device, |
| type_weight, axis_weight, |
| origin_weight, origin_l1_beta, |
| epoch): |
| model.train() |
|
|
| losses = {'total': 0, 'type': 0, 'axis': 0, 'origin': 0} |
| num_batches = 0 |
|
|
| pbar = tqdm(dataloader, desc=f"Training Epoch {epoch+1}") |
| for batch in pbar: |
| if batch is None: |
| continue |
| try: |
| mesh, part_mask, drag_point, drag_vector, gt_joint_type, gt_joint_axis, gt_joint_origin = _ensure_batch_fields(batch, device=device) |
| except Exception as e: |
| |
| pbar.set_postfix({'skip': type(e).__name__}) |
| continue |
|
|
| pred_type_logits, pred_axis, pred_origin = model( |
| mesh, part_mask, drag_point, drag_vector |
| ) |
|
|
| loss_dict = compute_predictor_loss( |
| pred_type_logits, pred_axis, pred_origin, |
| gt_type=gt_joint_type, gt_axis=gt_joint_axis, gt_origin=gt_joint_origin, |
| type_weight=type_weight, |
| axis_weight=axis_weight, |
| origin_weight=origin_weight, |
| origin_l1_beta=origin_l1_beta |
| ) |
|
|
| optimizer.zero_grad() |
| loss_dict['total_loss'].backward() |
| torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0) |
| optimizer.step() |
|
|
| losses['total'] += loss_dict['total_loss'].item() |
| losses['type'] += loss_dict['type_loss'].item() |
| losses['axis'] += loss_dict['axis_loss'].item() |
| |
| losses['origin'] += loss_dict['origin_loss'].item() |
| num_batches += 1 |
|
|
| pbar.set_postfix({ |
| 'loss': f'{loss_dict["total_loss"].item():.4f}', |
| 'axis': f'{loss_dict["axis_loss"].item():.6f}', |
| 'origin(S-L1)': f'{loss_dict["origin_loss"].item():.4f}' |
| }) |
|
|
| if num_batches == 0: |
| return {k: 0 for k in losses.keys()} |
|
|
| return {k: v / num_batches for k, v in losses.items()} |
|
|
|
|
| def validate(model, dataloader, device, |
| type_weight, axis_weight, |
| origin_weight, origin_l1_beta, predict_type): |
| model.eval() |
|
|
| losses = {'total': 0, 'type': 0, 'axis': 0, 'origin': 0} |
| num_batches = 0 |
|
|
| total_samples = 0 |
| correct_type = 0 |
|
|
| axis_errors_sum = 0.0 |
| origin_errors_sum = 0.0 |
|
|
| with torch.no_grad(): |
| for batch in tqdm(dataloader, desc="Validation"): |
| if batch is None: |
| continue |
| try: |
| mesh, part_mask, drag_point, drag_vector, gt_joint_type, gt_joint_axis, gt_joint_origin = _ensure_batch_fields(batch, device=device) |
| except Exception: |
| continue |
|
|
| pred_type_logits, pred_axis, pred_origin = model( |
| mesh, part_mask, drag_point, drag_vector |
| ) |
|
|
| |
| loss_dict = compute_predictor_loss( |
| pred_type_logits, pred_axis, pred_origin, |
| gt_type=gt_joint_type, gt_axis=gt_joint_axis, gt_origin=gt_joint_origin, |
| type_weight=type_weight, |
| axis_weight=axis_weight, |
| origin_weight=origin_weight, |
| origin_l1_beta=origin_l1_beta |
| ) |
|
|
| losses['total'] += loss_dict['total_loss'].item() |
| losses['type'] += loss_dict['type_loss'].item() |
| losses['axis'] += loss_dict['axis_loss'].item() |
| losses['origin'] += loss_dict['origin_loss'].item() |
|
|
| num_batches += 1 |
| batch_size = gt_joint_type.size(0) |
| total_samples += batch_size |
|
|
| |
| if predict_type and pred_type_logits is not None: |
| pred_type = pred_type_logits.argmax(dim=1) |
| correct_type += (pred_type == gt_joint_type).sum().item() |
| |
|
|
| |
| angle_rad_per_sample = geodesic_loss_report(pred_axis, gt_joint_axis) |
| angle_mrad_per_sample = angle_rad_per_sample * 1000.0 |
| axis_errors_sum += angle_mrad_per_sample.sum().item() |
|
|
| |
| origin_l1_per_sample = F.l1_loss(pred_origin, gt_joint_origin, reduction='none').mean(dim=1) |
| origin_mm_per_sample = (origin_l1_per_sample * 1000) |
| origin_errors_sum += origin_mm_per_sample.sum().item() |
|
|
| if num_batches == 0: |
| return {k: 0 for k in losses.keys()} |
|
|
| avg_losses = {k: v / num_batches for k, v in losses.items()} |
|
|
| type_acc = (correct_type / total_samples) * 100 if total_samples > 0 and predict_type else -1 |
| avg_axis_error = axis_errors_sum / total_samples if total_samples > 0 else 0 |
| avg_origin_error = origin_errors_sum / total_samples if total_samples > 0 else 0 |
|
|
| avg_losses['type_acc'] = type_acc |
| avg_losses['axis_error_mrad'] = avg_axis_error |
| avg_losses['origin_error_mm'] = avg_origin_error |
|
|
| return avg_losses |
|
|
|
|
| def main(args): |
| print("\n" + "="*70) |
| print("Training KPP (Keypoint Predictor) Model - V-Opt-5 (Loss Tuning)") |
| print(" V-Opt-3 (Decoupled Heads)") |
| print(" Smooth L1 Loss") |
| print(" Beta={:.4f} (10mm)".format(args.origin_l1_beta)) |
| print("="*70) |
|
|
| device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') |
| print(f"Using device: {device}") |
|
|
| os.makedirs(args.output_dir, exist_ok=True) |
|
|
| logger = create_logger( |
| output_dir=args.output_dir, |
| use_tensorboard=args.use_tensorboard, |
| use_wandb=args.use_wandb, |
| wandb_project=args.wandb_project if args.use_wandb else None, |
| wandb_config=vars(args) if args.use_wandb else None |
| ) |
|
|
| with open(os.path.join(args.output_dir, 'config_predictor_kpp.json'), 'w') as f: |
| json.dump(vars(args), f, indent=2) |
|
|
| print(f"\nLoading datasets...") |
| train_dataset = VAE_LMDBDataset(lmdb_path=args.lmdb_train_path, augment=False) |
| val_dataset = VAE_LMDBDataset(lmdb_path=args.lmdb_val_path, augment=False) |
| if args.origin_normalization != KPP_ORIGIN_NORMALIZATION: |
| raise ValueError( |
| f"Unsupported origin_normalization={args.origin_normalization!r}; " |
| f"expected {KPP_ORIGIN_NORMALIZATION!r}" |
| ) |
| warn_if_old_origin_lmdb(train_dataset, "train") |
| warn_if_old_origin_lmdb(val_dataset, "val") |
|
|
| print(f" Training: {len(train_dataset)} samples") |
| print(f" Validation: {len(val_dataset)} samples") |
|
|
| train_loader = DataLoader( |
| train_dataset, batch_size=args.batch_size, shuffle=True, |
| num_workers=args.num_workers, collate_fn=custom_collate_fn, |
| drop_last=False, pin_memory=args.pin_memory |
| ) |
| val_loader = DataLoader( |
| val_dataset, batch_size=args.batch_size, shuffle=False, |
| num_workers=args.num_workers, pin_memory=args.pin_memory, collate_fn=custom_collate_fn |
| ) |
|
|
| print("\nCreating model...") |
| model = KeypointPredictor( |
| use_mask=args.use_mask, |
| use_drag=args.use_drag, |
| encoder_type=args.encoder_type, |
| head_type=args.head_type, |
| predict_type=args.predict_type |
| ).to(device) |
|
|
| total_params = count_parameters(model) |
| print(f"Parameters: {total_params:,} (~{total_params/1e6:.2f}M)") |
|
|
| optimizer = torch.optim.AdamW( |
| model.parameters(), |
| lr=args.learning_rate, |
| weight_decay=args.weight_decay |
| ) |
|
|
| scheduler = lr_scheduler.ReduceLROnPlateau( |
| optimizer, mode='min', factor=0.5, patience=args.lr_patience, min_lr=1e-7, verbose=True |
| ) |
|
|
| start_epoch = 0 |
| best_val_metric = float('inf') |
|
|
| |
| if args.resume and os.path.isfile(args.resume): |
| print(f"\nLoading checkpoint: {args.resume}") |
| checkpoint = torch.load(args.resume, map_location=device) |
| try: |
| model.load_state_dict(checkpoint['model_state_dict'], strict=True) |
| print(" Model loaded (strict=True)") |
| except Exception as e: |
| print(f" Model load error: {e}, attempting strict=False") |
| model.load_state_dict(checkpoint['model_state_dict'], strict=False) |
|
|
| if 'optimizer_state_dict' in checkpoint: |
| optimizer.load_state_dict(checkpoint['optimizer_state_dict']) |
| if 'scheduler_state_dict' in checkpoint: |
| scheduler.load_state_dict(checkpoint['scheduler_state_dict']) |
| start_epoch = checkpoint.get('epoch', 0) |
| best_val_metric = checkpoint.get('val_origin_error_mm', float('inf')) |
| print(f" Resumed from epoch {start_epoch}, Best Origin Error: {best_val_metric:.3f} mm") |
| else: |
| print(" Starting training from scratch.") |
|
|
| print("\n" + "="*70) |
| print("Loss Weights (V-Opt-5):") |
| print(f" Type (CE):{args.type_weight:.2f}") |
| print(f" Origin (SL1): {args.origin_weight:.2f} (beta={args.origin_l1_beta:.4f})") |
| print(f" Axis (Geo): {args.axis_weight:.2f}") |
| print("="*70) |
|
|
| print(f"\nStarting training (epochs {start_epoch+1}-{args.num_epochs})...\n") |
|
|
| for epoch in range(start_epoch, args.num_epochs): |
| print(f"\n{'='*70}") |
| print(f"Epoch {epoch+1}/{args.num_epochs} | LR: {optimizer.param_groups[0]['lr']:.2e}") |
| print(f"{'='*70}") |
|
|
| train_losses = train_epoch( |
| model, train_loader, optimizer, device, |
| type_weight=args.type_weight, |
| axis_weight=args.axis_weight, |
| origin_weight=args.origin_weight, |
| origin_l1_beta=args.origin_l1_beta, |
| epoch=epoch |
| ) |
|
|
| val_losses = validate( |
| model, val_loader, device, |
| type_weight=args.type_weight, |
| axis_weight=args.axis_weight, |
| origin_weight=args.origin_weight, |
| origin_l1_beta=args.origin_l1_beta, |
| predict_type=args.predict_type |
| ) |
|
|
| scheduler.step(val_losses['origin_error_mm']) |
|
|
| print(f"\nEpoch {epoch + 1} Summary:") |
| print(f" Train - Total: {train_losses['total']:.4f} | Origin(SL1): {train_losses['origin']:.4f}") |
| print(f" Val - Total: {val_losses['total']:.4f} | Origin(SL1): {val_losses['origin']:.4f}") |
| print(f" Val Metrics - Type Acc: {val_losses['type_acc']:.2f}% | Axis Error: {val_losses['axis_error_mrad']:.3f} mrad | Origin Error: {val_losses['origin_error_mm']:.3f} mm") |
|
|
| logger.log_metrics({ |
| 'total_loss': train_losses['total'], 'type_loss': train_losses['type'], |
| 'axis_loss': train_losses['axis'], 'origin_loss_smoothl1': train_losses['origin'], |
| 'lr': optimizer.param_groups[0]['lr'] |
| }, step=epoch + 1, prefix='train/') |
|
|
| logger.log_metrics({ |
| 'total_loss': val_losses['total'], 'type_loss': val_losses['type'], |
| 'axis_loss': val_losses['axis'], 'origin_loss_smoothl1': val_losses['origin'], |
| 'type_acc': val_losses['type_acc'], |
| 'axis_error_mrad': val_losses['axis_error_mrad'], |
| 'origin_error_mm': val_losses['origin_error_mm'] |
| }, step=epoch + 1, prefix='val/') |
|
|
| current_val_metric = val_losses['origin_error_mm'] |
|
|
| if current_val_metric < best_val_metric: |
| best_val_metric = current_val_metric |
| torch.save({ |
| 'epoch': epoch + 1, 'model_state_dict': model.state_dict(), |
| 'optimizer_state_dict': optimizer.state_dict(), 'scheduler_state_dict': scheduler.state_dict(), |
| 'val_origin_error_mm': best_val_metric, 'config': vars(args) |
| }, os.path.join(args.output_dir, 'best_model_kpp.pth')) |
| print(f" Saved best model (Origin Error: {best_val_metric:.3f} mm)") |
|
|
| if (epoch + 1) % args.save_every == 0: |
| torch.save({ |
| 'epoch': epoch + 1, 'model_state_dict': model.state_dict(), |
| 'optimizer_state_dict': optimizer.state_dict(), 'scheduler_state_dict': scheduler.state_dict(), |
| 'val_origin_error_mm': current_val_metric, 'config': vars(args) |
| }, os.path.join(args.output_dir, f'checkpoint_kpp_epoch_{epoch+1}.pth')) |
| print(f" Saved checkpoint") |
|
|
| logger.close() |
|
|
| print("\n" + "="*70) |
| print(" KPP training complete!") |
| print(f"Best val origin error: {best_val_metric:.3f} mm") |
| print(f"Saved to: {args.output_dir}") |
| print("="*70) |
|
|
|
|
| if __name__ == "__main__": |
| parser = argparse.ArgumentParser(description="Train KPP (Keypoint Predictor)") |
|
|
|
|
| parser.add_argument('--lmdb_train_path', default='data/dragmesh_train.lmdb') |
| parser.add_argument('--lmdb_val_path', default='data/dragmesh_val.lmdb') |
| parser.add_argument('--data_split_json_path', type=str, default='configs/category_split_v2.json') |
|
|
|
|
| parser.add_argument('--batch_size', type=int, default=32) |
| parser.add_argument('--num_epochs', type=int, default=200) |
| parser.add_argument('--learning_rate', type=float, default=3e-5) |
| parser.add_argument('--weight_decay', type=float, default=1e-4) |
| parser.add_argument('--lr_patience', type=int, default=15) |
|
|
|
|
| parser.add_argument('--type_weight', type=float, default=10.0) |
| parser.add_argument('--axis_weight', type=float, default=300.0) |
| parser.add_argument('--origin_weight', type=float, default=500.0) |
|
|
|
|
| parser.add_argument('--origin_l1_beta', type=float, default=0.005) |
|
|
|
|
| parser.add_argument('--use_mask', type=str2bool, default=True) |
| parser.add_argument('--use_drag', type=str2bool, default=True) |
|
|
| |
| parser.add_argument('--encoder_type', type=str, default='attention', choices=['pointnet', 'attention']) |
| parser.add_argument('--head_type', type=str, default='decoupled', choices=['coupled', 'decoupled']) |
| parser.add_argument('--predict_type', type=str2bool, default=True) |
| parser.add_argument('--origin_normalization', type=str, default=KPP_ORIGIN_NORMALIZATION) |
|
|
| parser.add_argument('--use_tensorboard', type=str2bool, default=True) |
| parser.add_argument('--use_wandb', type=str2bool, default=False) |
| parser.add_argument('--wandb_project', type=str, default='kpp_ablation') |
| parser.add_argument('--num_workers', type=int, default=4) |
| parser.add_argument('--pin_memory', type=str2bool, default=False) |
| parser.add_argument('--output_dir', type=str, default='outputs/kpp') |
| parser.add_argument('--save_every', type=int, default=50) |
| parser.add_argument('--resume', type=str, default='') |
|
|
| args = parser.parse_args() |
| main(args) |
