Upload hf_collect_teacher_metadata.py with huggingface_hub

hf_collect_teacher_metadata.py

@@ -0,0 +1,846 @@
+#!/usr/bin/env python3
+"""
+HuggingFace Jobs script: Collect teacher outputs with metadata tracking.
+
+Saves for each image:
+- Full SAM 3D Body outputs (.npz)
+- Metadata: num_humans, image_width, image_height, processing_time
+"""
+import argparse
+import os
+from pathlib import Path
+import warnings
+warnings.filterwarnings('ignore')
+import logging
+import sys
+
+# Configure logging to stdout (so HF Jobs can capture it)
+logging.basicConfig(
+    level=logging.INFO,
+    format='[%(asctime)s] %(levelname)s: %(message)s',
+    datefmt='%Y-%m-%d %H:%M:%S',
+    stream=sys.stdout,
+    force=True
+)
+logger = logging.getLogger(__name__)
+
+# Also flush stdout immediately
+sys.stdout.reconfigure(line_buffering=True) if hasattr(sys.stdout, 'reconfigure') else None
+
+import numpy as np
+import torch
+from datasets import load_dataset, Dataset as HFDataset, Features, Value
+from PIL import Image
+import cv2
+from typing import List, Dict, Optional
+import time
+import json
+from collections import defaultdict
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+import subprocess
+
+# SAM 3D Body imports
+import sys
+sam_repo = Path(__file__).parent.parent / "sam-3d-body"
+if str(sam_repo) not in sys.path:
+    sys.path.insert(0, str(sam_repo))
+from sam_3d_body import load_sam_3d_body, SAM3DBodyEstimator
+
+# Set environment variable
+os.environ['PYOPENGL_PLATFORM'] = 'osmesa'
+
+
+class GazeEstimator:
+    """Gaze estimation using L2CS-Net"""
+    
+    def __init__(self, device='cuda'):
+        self.device = device
+        logger.info("Installing L2CS-Net...")
+        # Install L2CS-Net package
+        try:
+            subprocess.run(
+                ['pip', 'install', '-q', 'git+https://github.com/edavalosanaya/L2CS-Net.git@main'],
+                check=True,
+                capture_output=True
+            )
+            logger.info("✓ L2CS-Net installed")
+        except Exception as e:
+            print(f"Warning: L2CS-Net installation failed: {e}")
+        
+        print("Loading L2CS-Net gaze estimator...")
+        try:
+            from l2cs import Pipeline
+            # Use Gaze360 pretrained weights (better for unconstrained images)
+            self.pipeline = Pipeline(
+                weights='L2CSNet_gaze360.pkl',  # Will download automatically
+                arch='ResNet50',
+                device=device
+            )
+            self.enabled = True
+            print("✓ L2CS-Net gaze estimator loaded")
+        except Exception as e:
+            print(f"Warning: Could not load L2CS-Net: {e}")
+            print("Gaze estimation will be disabled")
+            self.enabled = False
+    
+    def estimate_gaze(self, image_pil, bbox):
+        """
+        Estimate gaze direction from face crop.
+        
+        Args:
+            image_pil: PIL Image
+            bbox: [x1, y1, x2, y2] in pixel coordinates
+            
+        Returns:
+            dict with 'pitch' and 'yaw' in degrees, or None if failed
+        """
+        if not self.enabled:
+            return None
+        
+        try:
+            # Convert PIL to numpy
+            image_np = np.array(image_pil)
+            
+            # L2CS expects BGR format
+            if image_np.shape[2] == 3:
+                image_bgr = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
+            else:
+                image_bgr = image_np
+            
+            # Run gaze estimation
+            results = self.pipeline.step(image_bgr)
+            
+            if results and len(results) > 0:
+                # Find detection closest to our bbox
+                x1, y1, x2, y2 = bbox
+                bbox_center = np.array([(x1 + x2) / 2, (y1 + y2) / 2])
+                
+                best_result = None
+                min_dist = float('inf')
+                
+                for result in results:
+                    # L2CS returns face bbox in result
+                    face_bbox = result.get('bbox', None)
+                    if face_bbox is not None:
+                        fx1, fy1, fx2, fy2 = face_bbox
+                        face_center = np.array([(fx1 + fx2) / 2, (fy1 + fy2) / 2])
+                        dist = np.linalg.norm(bbox_center - face_center)
+                        if dist < min_dist:
+                            min_dist = dist
+                            best_result = result
+                
+                if best_result is not None:
+                    # Extract pitch and yaw (in degrees)
+                    pitch = float(best_result.get('pitch', 0))
+                    yaw = float(best_result.get('yaw', 0))
+                    return {'pitch': pitch, 'yaw': yaw}
+            
+            return None
+            
+        except Exception as e:
+            print(f"Gaze estimation error: {e}")
+            return None
+
+
+class FaceEmbedder:
+    """Face embedding extraction using InsightFace ArcFace (ResNet100-IR)"""
+    
+    def __init__(self, device='cuda'):
+        self.device = device
+        print("Installing InsightFace...")
+        # Install InsightFace package
+        try:
+            subprocess.run(
+                ['pip', 'install', '-q', 'insightface', 'onnxruntime-gpu' if device.type == 'cuda' else 'onnxruntime'],
+                check=True,
+                capture_output=True
+            )
+            print("✓ InsightFace installed")
+        except Exception as e:
+            print(f"Warning: InsightFace installation failed: {e}")
+        
+        print("Loading InsightFace ArcFace (ResNet100-IR)...")
+        try:
+            import insightface
+            from insightface.app import FaceAnalysis
+            
+            # Initialize with ArcFace ResNet100 model
+            # det_size=(640, 640) for better detection
+            self.app = FaceAnalysis(
+                name='buffalo_l',  # Uses ResNet100 backbone
+                providers=['CUDAExecutionProvider'] if device.type == 'cuda' else ['CPUExecutionProvider']
+            )
+            self.app.prepare(ctx_id=0 if device.type == 'cuda' else -1, det_size=(640, 640))
+            self.enabled = True
+            print("✓ InsightFace ArcFace loaded (ResNet100-IR)")
+            print("  Model: buffalo_l (ResNet100 + ArcFace head)")
+            print("  Robust to: occlusion, lighting, blur, pose variations, aging")
+        except Exception as e:
+            print(f"Warning: Could not load InsightFace: {e}")
+            print("Face embeddings will be disabled")
+            self.enabled = False
+    
+    def extract_embedding(self, image_pil, bbox=None, keypoints_2d=None):
+        """
+        Extract 512-dimensional ArcFace embedding from face.
+        
+        Args:
+            image_pil: PIL Image
+            bbox: [x1, y1, x2, y2] in pixel coordinates (optional, for cropping)
+            keypoints_2d: Face keypoints for alignment (optional)
+            
+        Returns:
+            dict with 'embedding' (512-dim vector), 'det_score' (confidence), or None if failed
+        """
+        if not self.enabled:
+            return None
+        
+        try:
+            # Convert PIL to numpy BGR (InsightFace expects BGR)
+            image_np = np.array(image_pil)
+            if image_np.shape[2] == 3:
+                image_bgr = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
+            else:
+                image_bgr = image_np
+            
+            # Optionally crop to bbox region for efficiency
+            if bbox is not None:
+                x1, y1, x2, y2 = map(int, bbox)
+                # Add padding for better detection
+                pad = 20
+                h, w = image_bgr.shape[:2]
+                x1 = max(0, x1 - pad)
+                y1 = max(0, y1 - pad)
+                x2 = min(w, x2 + pad)
+                y2 = min(h, y2 + pad)
+                image_bgr = image_bgr[y1:y2, x1:x2]
+            
+            # Detect and extract faces
+            faces = self.app.get(image_bgr)
+            
+            if len(faces) == 0:
+                return None
+            
+            # Use the largest/most confident face
+            face = max(faces, key=lambda x: x.det_score)
+            
+            # Extract embedding (512-dim ArcFace feature)
+            embedding = face.embedding  # numpy array, shape (512,)
+            det_score = float(face.det_score)
+            
+            # Normalize embedding (L2 norm = 1)
+            embedding_norm = embedding / np.linalg.norm(embedding)
+            
+            return {
+                'embedding': embedding_norm.astype(np.float32).tolist(),
+                'det_score': det_score,
+                'embedding_dim': len(embedding)
+            }
+            
+        except Exception as e:
+            print(f"Face embedding extraction error: {e}")
+            return None
+
+
+class NSFWClassifier:
+    """NSFW classification using EraX-NSFW-V1.0 YOLO model"""
+    
+    def __init__(self, device='cuda'):
+        self.device = device
+        print("Loading EraX-NSFW YOLO model...")
+        try:
+            # Download the model if not already downloaded
+            from huggingface_hub import snapshot_download
+            snapshot_download(repo_id="erax-ai/EraX-NSFW-V1.0", local_dir="./", force_download=False)
+            
+            from ultralytics import YOLO
+            # Use the m model for better accuracy
+            self.model = YOLO('erax_nsfw_yolo11m.pt')
+            self.enabled = True
+            print("✓ EraX-NSFW classifier loaded (YOLO11m)")
+        except Exception as e:
+            print(f"Warning: Could not load EraX-NSFW: {e}")
+            print("NSFW classification will be disabled")
+            self.enabled = False
+    
+    def classify_crop(self, image_pil, bbox):
+        """
+        Classify NSFW content in a crop defined by bbox.
+        
+        Args:
+            image_pil: PIL Image
+            bbox: [x1, y1, x2, y2] in pixel coordinates
+            
+        Returns:
+            dict with class scores, or None if failed
+        """
+        if not self.enabled:
+            return None
+        
+        try:
+            # Convert bbox to ultralytics format [x1, y1, x2, y2]
+            x1, y1, x2, y2 = bbox
+            
+            # Crop the image
+            crop = image_pil.crop((x1, y1, x2, y2))
+            
+            # Convert PIL to numpy for ultralytics
+            crop_np = np.array(crop)
+            
+            # Run inference with confidence and IoU thresholds
+            results = self.model(crop_np, conf=0.2, iou=0.3, verbose=False)
+            
+            detections = []
+            if len(results) > 0 and len(results[0].boxes) > 0:
+                boxes = results[0].boxes
+                for box in boxes:
+                    class_id = int(box.cls.item())
+                    confidence = box.conf.item()
+                    
+                    # Model classes: ['anus', 'make_love', 'nipple', 'penis', 'vagina']
+                    class_names = ['anus', 'make_love', 'nipple', 'penis', 'vagina']
+                    class_name = class_names[class_id] if class_id < len(class_names) else f'class_{class_id}'
+                    
+                    # Get bbox relative to crop and convert to absolute coordinates
+                    dx1, dy1, dx2, dy2 = box.xyxy[0].tolist()
+                    abs_bbox = [x1 + dx1, y1 + dy1, x1 + dx2, y1 + dy2]
+                    
+                    detections.append({
+                        'class': class_name,
+                        'confidence': confidence,
+                        'bbox': abs_bbox
+                    })
+            
+            if detections:
+                return detections
+            else:
+                # No detections - consider safe
+                return [{'class': 'safe', 'confidence': 1.0, 'bbox': [x1, y1, x2, y2]}]
+                
+        except Exception as e:
+            print(f"! NSFW classification failed: {e}")
+            return None
+
+
+def compute_face_orientation(vertices, keypoints_3d):
+    """
+    Compute face orientation vector from 3D mesh vertices and keypoints.
+    Uses nose→head_top vector as face direction.
+    
+    Args:
+        vertices: (N, 3) array of 3D vertices
+        keypoints_3d: (70, 3) array of 3D keypoints (MHR70 format)
+        
+    Returns:
+        (3,) normalized face orientation vector [x, y, z] or None
+    """
+    if vertices is None or keypoints_3d is None:
+        return None
+    
+    try:
+        # MHR70 keypoint indices (from sam-3d-body/sam_3d_body/metadata/mhr70.py)
+        # 0: nose, 1: left-eye, 2: right-eye
+        # Check if face keypoints are valid (not all zeros)
+        nose_3d = keypoints_3d[0]
+        left_eye_3d = keypoints_3d[1]
+        right_eye_3d = keypoints_3d[2]
+        
+        # Verify face keypoints are valid (not at origin)
+        if (np.linalg.norm(nose_3d) < 1e-6 or 
+            np.linalg.norm(left_eye_3d) < 1e-6 or 
+            np.linalg.norm(right_eye_3d) < 1e-6):
+            return None  # Face keypoints not detected
+        
+        # Find topmost vertex as head top (highest Y coordinate in body frame)
+        head_top_idx = np.argmax(vertices[:, 1])  # Y is up in SMPL convention
+        head_top_3d = vertices[head_top_idx]
+        
+        # Face orientation = nose → head_top (points upward/forward from face)
+        face_orientation = head_top_3d - nose_3d
+        
+        # Normalize
+        norm = np.linalg.norm(face_orientation)
+        if norm > 1e-6:
+            face_orientation = face_orientation / norm
+            return face_orientation.astype(np.float32)
+        
+        return None
+        
+    except Exception as e:
+        print(f"Face orientation computation failed: {e}")
+        return None
+
+
+def compute_bbox_from_keypoints(keypoints_2d, indices):
+    """
+    Compute bounding box from a set of 2D keypoints.
+    
+    Args:
+        keypoints_2d: (70, 2) array of 2D keypoints
+        indices: list of keypoint indices to include
+        
+    Returns:
+        [x1, y1, x2, y2] or None if no valid keypoints
+    """
+    if keypoints_2d is None or len(keypoints_2d) < max(indices) + 1:
+        return None
+    
+    valid_points = []
+    for idx in indices:
+        kp = keypoints_2d[idx]
+        if kp[0] >= 0 and kp[1] >= 0:  # Check if keypoint is valid (not -1, -1)
+            valid_points.append(kp)
+    
+    if len(valid_points) < 2:  # Need at least 2 points for a bbox
+        return None
+    
+    points = np.array(valid_points)
+    x1, y1 = points.min(axis=0)
+    x2, y2 = points.max(axis=0)
+    
+    # Add some padding (10% of bbox size)
+    width = x2 - x1
+    height = y2 - y1
+    padding_x = width * 0.1
+    padding_y = height * 0.1
+    
+    x1 = max(0, x1 - padding_x)
+    y1 = max(0, y1 - padding_y)
+    x2 = x2 + padding_x
+    y2 = y2 + padding_y
+    
+    return [float(x1), float(y1), float(x2), float(y2)]
+
+
+def collect_for_image(estimator, nsfw_classifier, gaze_estimator, face_embedder, image_pil, image_id: str, out_dir: Path, faces: np.ndarray) -> Optional[Dict]:
+    """
+    Process PIL image and save .npz with ALL outputs + metadata + NSFW scores per human.
+    
+    Returns metadata dict or None if failed.
+    """
+    out_path = out_dir / f"{image_id}.npz"
+    if out_path.exists():
+        return None
+    
+    # Get image dimensions
+    img_width, img_height = image_pil.size
+    
+    # Convert PIL to numpy array
+    image_rgb = np.array(image_pil.convert('RGB'))
+    image_bgr = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR)
+    
+    start_time = time.time()
+    
+    try:
+        # Use process_one_image
+        outputs = estimator.process_one_image(image_bgr)
+        
+        processing_time = time.time() - start_time
+        
+        if not outputs:
+            # No humans detected
+            return {
+                'image_id': image_id,
+                'num_humans': 0,
+                'image_width': img_width,
+                'image_height': img_height,
+                'processing_time_ms': int(processing_time * 1000),
+                'status': 'no_detection',
+                'humans': []
+            }
+        
+        num_humans = len(outputs)
+        
+        # Process each detected human
+        humans_data = []
+        for human_idx, pred in enumerate(outputs):
+            # Get 3D body outputs
+            vertices = pred.get('pred_vertices')
+            cam_t = pred.get('pred_cam_t')
+            focal_length = pred.get('focal_length')
+            kpts2d = pred.get('pred_keypoints_2d')
+            kpts3d = pred.get('pred_keypoints_3d')
+            
+            # Get bounding box from detection
+            bbox = pred.get('bbox', None)  # [x1, y1, x2, y2]
+            
+            # Check if we have valid face keypoints (nose, eyes) in the image
+            has_face = False
+            if kpts2d is not None and kpts3d is not None and len(kpts2d) >= 3 and len(kpts3d) >= 3:
+                # Get 2D projected keypoints (nose, left eye, right eye)
+                nose_2d = kpts2d[0]  # [x, y]
+                left_eye_2d = kpts2d[1]
+                right_eye_2d = kpts2d[2]
+                
+                # Get 3D keypoints to check they exist
+                nose_3d = kpts3d[0]
+                left_eye_3d = kpts3d[1]
+                right_eye_3d = kpts3d[2]
+                
+                # Check if face keypoints are valid:
+                # 1. 3D keypoints are not at origin
+                # 2. 2D keypoints are inside image bounds
+                keypoints_valid_3d = (np.linalg.norm(nose_3d) > 1e-6 and 
+                                     np.linalg.norm(left_eye_3d) > 1e-6 and 
+                                     np.linalg.norm(right_eye_3d) > 1e-6)
+                
+                keypoints_in_image = True
+                if keypoints_valid_3d:
+                    # Check if face keypoints are within image bounds
+                    for kp in [nose_2d, left_eye_2d, right_eye_2d]:
+                        if (kp[0] < 0 or kp[0] >= img_width or 
+                            kp[1] < 0 or kp[1] >= img_height):
+                            keypoints_in_image = False
+                            break
+                
+                has_face = keypoints_valid_3d and keypoints_in_image
+            
+            # Compute face orientation from mesh (only if face visible in image)
+            face_orientation = None
+            if has_face:
+                face_orientation = compute_face_orientation(vertices, kpts3d)
+            
+            # Estimate gaze direction (only if face visible and bbox available)
+            gaze_direction = None
+            if has_face and bbox is not None and gaze_estimator is not None:
+                try:
+                    gaze_direction = gaze_estimator.estimate_gaze(image_pil, bbox)
+                except Exception as e:
+                    print(f"! Gaze estimation failed for {image_id} human {human_idx}: {e}")
+                    gaze_direction = None
+            
+            # Extract face embedding (only if face visible)
+            face_embedding = None
+            if has_face and bbox is not None and face_embedder is not None:
+                try:
+                    face_embedding = face_embedder.extract_embedding(image_pil, bbox, kpts2d)
+                except Exception as e:
+                    print(f"! Face embedding extraction failed for {image_id} human {human_idx}: {e}")
+                    face_embedding = None
+            
+            # NSFW classification for this human
+            nsfw_scores = None
+            if bbox is not None and nsfw_classifier is not None:
+                try:
+                    nsfw_scores = nsfw_classifier.classify_crop(image_pil, bbox)
+                except Exception as e:
+                    print(f"! NSFW classification failed for {image_id} human {human_idx}: {e}")
+                    nsfw_scores = None
+            
+            # Compute hand and foot bboxes from keypoints
+            left_hand_bbox = None
+            right_hand_bbox = None
+            left_foot_bbox = None
+            right_foot_bbox = None
+            
+            if kpts2d is not None:
+                # Left hand keypoints: indices 42-61 (left_thumb4 to left_pinky_finger_third_joint)
+                left_hand_indices = list(range(42, 62))
+                left_hand_bbox = compute_bbox_from_keypoints(kpts2d, left_hand_indices)
+                
+                # Right hand keypoints: indices 21-40 (right_thumb4 to right_pinky_finger_third_joint)
+                right_hand_indices = list(range(21, 41))
+                right_hand_bbox = compute_bbox_from_keypoints(kpts2d, right_hand_indices)
+                
+                # Left foot keypoints: indices 15-17 (left_big_toe, left_small_toe, left_heel)
+                left_foot_indices = [15, 16, 17]
+                left_foot_bbox = compute_bbox_from_keypoints(kpts2d, left_foot_indices)
+                
+                # Right foot keypoints: indices 18-20 (right_big_toe, right_small_toe, right_heel)
+                right_foot_indices = [18, 19, 20]
+                right_foot_bbox = compute_bbox_from_keypoints(kpts2d, right_foot_indices)
+            
+            humans_data.append({
+                'human_idx': human_idx,
+                'bbox': bbox.tolist() if bbox is not None else None,
+                'left_hand_bbox': left_hand_bbox,
+                'right_hand_bbox': right_hand_bbox,
+                'left_foot_bbox': left_foot_bbox,
+                'right_foot_bbox': right_foot_bbox,
+                'has_face': has_face,
+                'face_orientation': face_orientation.tolist() if face_orientation is not None else None,
+                'gaze_direction': gaze_direction,
+                'face_embedding': face_embedding,
+                'nsfw_scores': nsfw_scores,
+                'has_mesh': vertices is not None
+            })
+        
+        # Save first detected person's mesh (or could save all in future)
+        pred = outputs[0]
+        vertices = pred.get('pred_vertices')
+        cam_t = pred.get('pred_cam_t')
+        focal_length = pred.get('focal_length')
+        kpts2d = pred.get('pred_keypoints_2d')
+        kpts3d = pred.get('pred_keypoints_3d')
+        bbox_0 = pred.get('bbox', None)
+        
+        # Save to npz with all humans metadata
+        np.savez_compressed(
+            out_path,
+            # First human mesh data
+            vertices=vertices.astype(np.float32) if vertices is not None else None,
+            faces=faces.astype(np.int32),
+            cam_t=cam_t.astype(np.float32) if cam_t is not None else None,
+            focal_length=np.array([focal_length], dtype=np.float32) if focal_length is not None else None,
+            keypoints_2d=kpts2d.astype(np.float32) if kpts2d is not None else None,
+            keypoints_3d=kpts3d.astype(np.float32) if kpts3d is not None else None,
+            bbox=np.array(bbox_0, dtype=np.float32) if bbox_0 is not None else None,
+            # Image metadata
+            image_id=image_id,
+            num_humans=num_humans,
+            image_width=img_width,
+            image_height=img_height,
+            # All humans data (as JSON string in npz)
+            humans_metadata=json.dumps(humans_data)
+        )
+        
+        return {
+            'image_id': image_id,
+            'num_humans': num_humans,
+            'image_width': img_width,
+            'image_height': img_height,
+            'processing_time_ms': int(processing_time * 1000),
+            'status': 'success',
+            'npz_size_bytes': out_path.stat().st_size,
+            'humans': humans_data
+        }
+        
+    except Exception as e:
+        processing_time = time.time() - start_time
+        print(f"! Error on {image_id}: {e}")
+        return {
+            'image_id': image_id,
+            'num_humans': 0,
+            'image_width': img_width,
+            'image_height': img_height,
+            'processing_time_ms': int(processing_time * 1000),
+            'status': 'error',
+            'error_message': str(e),
+            'humans': []
+        }
+
+
+def main():
+    logger.info("="*60)
+    logger.info("SAM 3D Body Metadata Collection with Face Features")
+    logger.info("="*60)
+    sys.stdout.flush()
+    
+    ap = argparse.ArgumentParser()
+    ap.add_argument('--input-dataset', type=str, required=True)
+    ap.add_argument('--output-dataset', type=str, required=True)
+    ap.add_argument('--split', type=str, default='train')
+    ap.add_argument('--checkpoint', type=str, default='checkpoints/sam-3d-body-dinov3/model.ckpt')
+    ap.add_argument('--mhr-path', type=str, default='checkpoints/sam-3d-body-dinov3/assets/mhr_model.pt')
+    ap.add_argument('--limit', type=int, default=0)
+    ap.add_argument('--shard-index', type=int, default=0)
+    ap.add_argument('--num-shards', type=int, default=1)
+    args = ap.parse_args()
+
+    logger.info(f"Arguments: {vars(args)}")
+    sys.stdout.flush()
+
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    logger.info(f"Using device: {device}")
+    if torch.cuda.is_available():
+        logger.info(f"  GPU: {torch.cuda.get_device_name(0)}")
+        logger.info(f"  CUDA version: {torch.version.cuda}")
+    sys.stdout.flush()
+
+    # Load gaze estimator
+    logger.info("Loading gaze estimator...")
+    sys.stdout.flush()
+    gaze_estimator = GazeEstimator(device=device)
+    
+    # Load face embedder (InsightFace ArcFace)
+    logger.info("Loading face embedder (InsightFace ArcFace)...")
+    sys.stdout.flush()
+    face_embedder = FaceEmbedder(device=device)
+    
+    # Load NSFW classifier
+    logger.info("Loading NSFW classifier...")
+    sys.stdout.flush()
+    nsfw_classifier = NSFWClassifier(device=device)
+
+    # Load teacher
+    logger.info("Loading SAM 3D Body teacher...")
+    sys.stdout.flush()
+    start_load = time.time()
+    model, model_cfg = load_sam_3d_body(args.checkpoint, device=device, mhr_path=args.mhr_path)
+    model.eval()
+    
+    teacher = SAM3DBodyEstimator(
+        sam_3d_body_model=model,
+        model_cfg=model_cfg,
+        human_detector=None,
+        human_segmentor=None,
+        fov_estimator=None,
+    )
+    logger.info(f"✓ Model loaded in {time.time() - start_load:.1f}s")
+    sys.stdout.flush()
+
+    # Load dataset
+    logger.info(f"Loading dataset {args.input_dataset}...")
+    sys.stdout.flush()
+    start_ds = time.time()
+    ds = load_dataset(args.input_dataset, split=args.split, streaming=True)
+    
+    if args.num_shards > 1:
+        ds = ds.shard(num_shards=args.num_shards, index=args.shard_index)
+        logger.info(f"Using shard {args.shard_index+1}/{args.num_shards} (~{100/args.num_shards:.1f}% of dataset)")
+    
+    if args.limit and args.limit > 0:
+        ds = ds.take(args.limit)
+    logger.info(f"✓ Dataset ready in {time.time() - start_ds:.1f}s")
+    sys.stdout.flush()
+
+    # Process
+    out_dir = Path('teacher_labels')
+    out_dir.mkdir(exist_ok=True)
+
+    # Get mesh faces (same for all images)
+    faces = teacher.faces
+    logger.info(f"Mesh topology: {faces.shape[0]} faces")
+    logger.info("="*60)
+    logger.info("Starting image processing...")
+    logger.info("="*60)
+    sys.stdout.flush()
+
+    processed = 0
+    failed = 0
+    no_detection = 0
+    metadata_records = []
+    start_process = time.time()
+    
+    for i, sample in enumerate(ds, 1):
+        image_pil = sample['image']
+        image_id = sample.get('image_path', f'img_{i:06d}')
+        image_id = Path(image_id).stem if image_id else f'img_{i:06d}'
+        
+        metadata = collect_for_image(teacher, nsfw_classifier, gaze_estimator, face_embedder, image_pil, image_id, out_dir, faces)
+        
+        if metadata:
+            metadata_records.append(metadata)
+            
+            if metadata['status'] == 'success':
+                processed += 1
+            elif metadata['status'] == 'no_detection':
+                no_detection += 1
+            else:
+                failed += 1
+        
+        if i % 10 == 0:
+            elapsed = time.time() - start_process
+            speed = processed / elapsed if elapsed > 0 else 0
+            logger.info(f"[{i}] success={processed}, no_detect={no_detection}, failed={failed}, speed={speed:.2f} img/s")
+            sys.stdout.flush()
+
+    total_time = time.time() - start_process
+    logger.info("="*60)
+    logger.info(f"✓ Processing complete!")
+    logger.info(f"  Processed: {processed} images in {total_time:.1f}s ({processed/total_time:.2f} img/s)")
+    logger.info(f"  No detection: {no_detection}, Failed: {failed}")
+    logger.info("="*60)
+    sys.stdout.flush()
+    
+    # Compute metadata statistics
+    if metadata_records:
+        successful = [m for m in metadata_records if m['status'] == 'success']
+        if successful:
+            total_humans = sum(m['num_humans'] for m in successful)
+            avg_humans = total_humans / len(successful)
+            avg_width = sum(m['image_width'] for m in successful) / len(successful)
+            avg_height = sum(m['image_height'] for m in successful) / len(successful)
+            avg_time = sum(m['processing_time_ms'] for m in successful) / len(successful)
+            
+            # NSFW statistics
+            nsfw_stats = defaultdict(list)
+            for m in successful:
+                for human in m.get('humans', []):
+                    nsfw_list = human.get('nsfw_scores', [])
+                    for detection in nsfw_list:
+                        label = detection['class']
+                        score = detection['confidence']
+                        nsfw_stats[label].append(score)
+            
+            print(f"\nMetadata Statistics:")
+            print(f"  Total humans detected: {total_humans}")
+            print(f"  Avg humans per image: {avg_humans:.2f}")
+            print(f"  Avg image size: {avg_width:.0f}x{avg_height:.0f}")
+            print(f"  Avg processing time: {avg_time:.0f}ms")
+            
+            if nsfw_stats:
+                print(f"\nNSFW Classification Statistics:")
+                for label, scores in nsfw_stats.items():
+                    avg_score = sum(scores) / len(scores)
+                    max_score = max(scores)
+                    print(f"  {label}: avg={avg_score:.3f}, max={max_score:.3f}, n={len(scores)}")
+            
+            # Face orientation and gaze statistics
+            face_orientation_count = sum(1 for m in successful for h in m.get('humans', []) if h.get('face_orientation'))
+            gaze_count = sum(1 for m in successful for h in m.get('humans', []) if h.get('gaze_direction'))
+            face_embedding_count = sum(1 for m in successful for h in m.get('humans', []) if h.get('face_embedding'))
+            print(f"\nFace Orientation & Gaze Statistics:")
+            print(f"  Face orientations computed: {face_orientation_count}/{total_humans}")
+            print(f"  Gaze directions estimated: {gaze_count}/{total_humans}")
+            print(f"  Face embeddings extracted: {face_embedding_count}/{total_humans}")
+            
+            # Face embedding quality statistics
+            if face_embedding_count > 0:
+                det_scores = [h['face_embedding']['det_score'] for m in successful 
+                             for h in m.get('humans', []) if h.get('face_embedding')]
+                avg_det_score = sum(det_scores) / len(det_scores)
+                min_det_score = min(det_scores)
+                print(f"\nFace Embedding Quality (InsightFace ArcFace):")
+                print(f"  Model: ResNet100-IR + ArcFace head (512-dim)")
+                print(f"  Avg detection confidence: {avg_det_score:.3f}")
+                print(f"  Min detection confidence: {min_det_score:.3f}")
+
+    
+    # Save metadata JSON locally
+    metadata_path = Path('metadata.json')
+    with open(metadata_path, 'w') as f:
+        json.dump(metadata_records, f, indent=2)
+    print(f"Saved metadata to {metadata_path}")
+    
+    # Upload labels
+    print(f"\nUploading labels to {args.output_dataset}...")
+    
+    label_files = sorted(out_dir.glob('*.npz'))
+    data = {'image_id': [], 'label_data': []}
+    
+    for npz_path in label_files:
+        data['image_id'].append(npz_path.stem)
+        with open(npz_path, 'rb') as f:
+            data['label_data'].append(f.read())
+    
+    features = Features({
+        'image_id': Value('string'),
+        'label_data': Value('binary'),
+    })
+    
+    label_ds = HFDataset.from_dict(data, features=features)
+    label_ds.push_to_hub(
+        args.output_dataset,
+        split=args.split,
+        token=os.environ.get('HF_TOKEN'),
+        private=True,
+    )
+    logger.info(f"✓ Uploaded {len(label_files)} labels to {args.output_dataset}")
+    sys.stdout.flush()
+    
+    # Upload metadata JSON
+    from huggingface_hub import HfApi
+    api = HfApi(token=os.environ.get('HF_TOKEN'))
+    api.upload_file(
+        path_or_fileobj=str(metadata_path),
+        path_in_repo=f'metadata_shard{args.shard_index}.json',
+        repo_id=args.output_dataset,
+        repo_type='dataset'
+    )
+    logger.info(f"✓ Uploaded metadata to {args.output_dataset}/metadata_shard{args.shard_index}.json")
+    sys.stdout.flush()
+
+
+if __name__ == '__main__':
+    main()