Upload scripts/preprocess_humanml3d.py with huggingface_hub

scripts/preprocess_humanml3d.py

@@ -0,0 +1,227 @@
+"""
+Preprocess HumanML3D data into TopoSlots unified format.
+
+Input: HumanML3D raw data (new_joints/*.npy, texts/*.txt)
+Output: Processed data in data/processed/humanml3d/
+  - skeleton.npz: SMPL-22 skeleton graph
+  - motions/{motion_id}.npz: per-motion features
+  - splits/{train,val,test}.txt: data splits
+  - stats.npz: dataset statistics (mean, std)
+"""
+
+import sys
+import argparse
+from pathlib import Path
+import numpy as np
+from tqdm import tqdm
+
+# Add project root to path
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.data.skeleton_graph import SkeletonGraph
+from src.data.humanml3d_converter import (
+    get_smpl22_skeleton,
+    load_humanml3d_motion,
+    compute_motion_features,
+    extract_rotations_from_263d,
+    load_humanml3d_split,
+    SMPL_22_JOINT_NAMES,
+)
+
+
+def preprocess_humanml3d(
+    raw_dir: str,
+    output_dir: str,
+    target_fps: float = 20.0,
+    max_frames: int = 196,  # ~10s at 20fps
+    min_frames: int = 24,   # ~1.2s at 20fps
+):
+    raw_dir = Path(raw_dir)
+    output_dir = Path(output_dir)
+
+    # Create output directories
+    (output_dir / 'motions').mkdir(parents=True, exist_ok=True)
+    (output_dir / 'splits').mkdir(parents=True, exist_ok=True)
+
+    # 1. Save skeleton graph
+    print("Building SMPL-22 skeleton graph...")
+
+    # Compute average rest pose from first 100 motions
+    train_ids = load_humanml3d_split(raw_dir, 'train')
+    rest_poses = []
+    for mid in train_ids[:100]:
+        try:
+            motion = load_humanml3d_motion(mid, raw_dir)
+            rest_poses.append(motion['joint_positions'][0])  # first frame
+        except Exception:
+            continue
+
+    avg_rest_pose = np.mean(rest_poses, axis=0) if rest_poses else None
+    skeleton = get_smpl22_skeleton(avg_rest_pose)
+
+    # Save skeleton
+    np.savez(
+        output_dir / 'skeleton.npz',
+        **skeleton.to_dict(),
+    )
+    print(f"  Skeleton: {skeleton.num_joints} joints")
+
+    # 2. Process all motions
+    all_splits = {}
+    for split in ['train', 'val', 'test']:
+        try:
+            ids = load_humanml3d_split(raw_dir, split)
+            all_splits[split] = ids
+        except FileNotFoundError:
+            print(f"  Warning: {split}.txt not found, skipping")
+            all_splits[split] = []
+
+    all_ids = set()
+    for ids in all_splits.values():
+        all_ids.update(ids)
+
+    print(f"\nProcessing {len(all_ids)} motions...")
+
+    # Collect statistics
+    all_local_pos = []
+    all_velocities = []
+    all_root_vel = []
+    processed_count = 0
+    skipped_count = 0
+
+    for motion_id in tqdm(sorted(all_ids)):
+        try:
+            # Load raw motion
+            motion = load_humanml3d_motion(motion_id, raw_dir)
+            joint_positions = motion['joint_positions']
+            T = joint_positions.shape[0]
+
+            # Filter by length
+            if T < min_frames:
+                skipped_count += 1
+                continue
+            if T > max_frames:
+                joint_positions = joint_positions[:max_frames]
+
+            # Compute position-based features (Scheme C: slot token input)
+            features = compute_motion_features(
+                joint_positions, skeleton, fps=target_fps
+            )
+
+            # Extract rotation-based features from 263D (Scheme C: decoder GT)
+            joint_vecs = motion['joint_vecs']
+            rot_features = None
+            if joint_vecs is not None and joint_vecs.shape[0] == joint_positions.shape[0]:
+                rot_features = extract_rotations_from_263d(joint_vecs)
+
+            # Build save dict
+            # --- Scheme C layout ---
+            # Slot token input: local_positions [T,J,3] + velocities [T,J,3] = 6D per joint
+            # Decoder GT: local_rotations_6d [T,J-1,6] (for FK supervision)
+            # Root track: root_position [T,3] + root_velocity [T,3]
+            # Auxiliary: foot_contact [T,4], bone_lengths [T,J], accelerations [T,J,3]
+            save_dict = {
+                # Slot token features (cross-skeleton compatible)
+                'local_positions': features['local_positions'].astype(np.float32),   # [T, 22, 3]
+                'velocities': features['velocities'].astype(np.float32),             # [T, 22, 3]
+                # Root trajectory (separate track)
+                'root_position': features['root_position'].astype(np.float32),       # [T, 3]
+                'root_velocity': features['root_velocity'].astype(np.float32),       # [T, 3]
+                # Decoder GT (skeleton-specific, for FK supervision)
+                'joint_positions': joint_positions.astype(np.float32),               # [T, 22, 3]
+                'accelerations': features['accelerations'].astype(np.float32),       # [T, 22, 3]
+                'bone_lengths': features['bone_lengths'].astype(np.float32),         # [T, 22]
+                # Auxiliary
+                'foot_contact': features['foot_contact'].astype(np.float32),         # [T, 4]
+                # Metadata
+                'num_frames': joint_positions.shape[0],
+                'fps': target_fps,
+                'skeleton_id': 'smpl_22',
+            }
+
+            # Add rotation data if available (from 263D vector)
+            if rot_features is not None:
+                save_dict['local_rotations_6d'] = rot_features['local_rotations_6d'].astype(np.float32)  # [T, 21, 6]
+                save_dict['foot_contact'] = rot_features['foot_contact_4ch'].astype(np.float32)          # [T, 4] (override with GT)
+
+            # Save texts
+            texts = motion['texts']
+            save_dict['texts'] = '|||'.join(texts) if texts else ''
+
+            np.savez_compressed(
+                output_dir / 'motions' / f'{motion_id}.npz',
+                **save_dict,
+            )
+
+            # Collect stats (subsample for memory)
+            if processed_count % 5 == 0:
+                all_local_pos.append(features['local_positions'])
+                all_velocities.append(features['velocities'])
+                all_root_vel.append(features['root_velocity'])
+
+            processed_count += 1
+
+        except Exception as e:
+            print(f"  Error processing {motion_id}: {e}")
+            skipped_count += 1
+
+    print(f"\nProcessed: {processed_count}, Skipped: {skipped_count}")
+
+    # 3. Compute and save statistics
+    print("Computing dataset statistics...")
+    all_local_pos = np.concatenate(all_local_pos, axis=0)  # [N, J, 3]
+    all_velocities = np.concatenate(all_velocities, axis=0)
+    all_root_vel = np.concatenate(all_root_vel, axis=0)
+
+    stats = {
+        'local_pos_mean': all_local_pos.mean(axis=0),
+        'local_pos_std': all_local_pos.std(axis=0) + 1e-8,
+        'velocity_mean': all_velocities.mean(axis=0),
+        'velocity_std': all_velocities.std(axis=0) + 1e-8,
+        'root_vel_mean': all_root_vel.mean(axis=0),
+        'root_vel_std': all_root_vel.std(axis=0) + 1e-8,
+    }
+
+    np.savez(output_dir / 'stats.npz', **stats)
+
+    # 4. Save splits
+    for split, ids in all_splits.items():
+        # Filter to only processed motions
+        valid_ids = [
+            mid for mid in ids
+            if (output_dir / 'motions' / f'{mid}.npz').exists()
+        ]
+        with open(output_dir / 'splits' / f'{split}.txt', 'w') as f:
+            for mid in valid_ids:
+                f.write(f'{mid}\n')
+        print(f"  {split}: {len(valid_ids)} motions")
+
+    print(f"\nDone! Output saved to {output_dir}")
+
+
+if __name__ == '__main__':
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        '--raw_dir',
+        type=str,
+        default='data/raw/HumanML3D',
+        help='Path to raw HumanML3D data',
+    )
+    parser.add_argument(
+        '--output_dir',
+        type=str,
+        default='data/processed/humanml3d',
+        help='Output directory',
+    )
+    parser.add_argument('--target_fps', type=float, default=20.0)
+    parser.add_argument('--max_frames', type=int, default=196)
+    parser.add_argument('--min_frames', type=int, default=24)
+
+    args = parser.parse_args()
+    preprocess_humanml3d(
+        args.raw_dir, args.output_dir,
+        target_fps=args.target_fps,
+        max_frames=args.max_frames,
+        min_frames=args.min_frames,
+    )