Upload hf_collect_teacher_metadata.py with huggingface_hub

hf_collect_teacher_metadata.py

@@ -34,10 +34,7 @@ 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
+import functools
 
 # SAM 3D Body imports
 import sys
@@ -412,7 +409,240 @@ def compute_bbox_from_keypoints(keypoints_2d, indices):
     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]:
+def process_batch(batch, teacher, nsfw_classifier, gaze_estimator, face_embedder, faces, out_dir):
+    """
+    Process a batch of samples using dataset.map() with batched NSFW inference
+    
+    Args:
+        batch: dict with 'image' list and optional 'image_path' list
+        ... (other args)
+        
+    Returns:
+        dict with 'metadata' list
+    """
+    images = batch['image']
+    image_paths = batch.get('image_path', [f'img_{i:06d}' for i in range(len(images))])
+    
+    # First pass: process images and collect humans data (without NSFW)
+    humans_data_list = []
+    outputs_list = []
+    
+    for img_idx, image_pil in enumerate(images):
+        img_width, img_height = image_pil.size
+        image_rgb = np.array(image_pil.convert('RGB'))
+        image_bgr = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR)
+        
+        outputs = teacher.process_one_image(image_bgr)
+        outputs_list.append(outputs)
+        
+        if not outputs:
+            humans_data_list.append([])
+            continue
+        
+        humans_data = []
+        for human_idx, pred in enumerate(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')
+            bbox = pred.get('bbox', None)
+            
+            # Check face
+            has_face = False
+            if kpts2d is not None and kpts3d is not None and len(kpts2d) >= 3 and len(kpts3d) >= 3:
+                nose_2d = kpts2d[0]
+                left_eye_2d = kpts2d[1]
+                right_eye_2d = kpts2d[2]
+                nose_3d = kpts3d[0]
+                left_eye_3d = kpts3d[1]
+                right_eye_3d = kpts3d[2]
+                
+                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:
+                    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
+            
+            face_orientation = None
+            if has_face:
+                face_orientation = compute_face_orientation(vertices, kpts3d)
+            
+            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:
+                    gaze_direction = None
+            
+            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:
+                    face_embedding = None
+            
+            # Compute bboxes
+            left_hand_bbox = None
+            right_hand_bbox = None
+            left_foot_bbox = None
+            right_foot_bbox = None
+            
+            if kpts2d is not None:
+                left_hand_indices = list(range(42, 62))
+                left_hand_bbox = compute_bbox_from_keypoints(kpts2d, left_hand_indices)
+                
+                right_hand_indices = list(range(21, 41))
+                right_hand_bbox = compute_bbox_from_keypoints(kpts2d, right_hand_indices)
+                
+                left_foot_indices = [15, 16, 17]
+                left_foot_bbox = compute_bbox_from_keypoints(kpts2d, left_foot_indices)
+                
+                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,
+                'has_mesh': vertices is not None,
+                'nsfw_scores': None  # Will fill later
+            })
+        
+        humans_data_list.append(humans_data)
+    
+    # Batch NSFW classification
+    crops = []
+    crop_info = []  # (img_idx, human_idx)
+    
+    for img_idx, humans_data in enumerate(humans_data_list):
+        image_pil = images[img_idx]
+        for human_idx, human in enumerate(humans_data):
+            bbox = human['bbox']
+            if bbox is not None:
+                x1, y1, x2, y2 = bbox
+                crop = image_pil.crop((x1, y1, x2, y2))
+                crops.append(crop)
+                crop_info.append((img_idx, human_idx))
+    
+    if crops and nsfw_classifier is not None and nsfw_classifier.enabled:
+        try:
+            results = nsfw_classifier.model(crops, conf=0.2, iou=0.3, verbose=False)
+            
+            for crop_idx, result in enumerate(results):
+                img_idx, human_idx = crop_info[crop_idx]
+                bbox = humans_data_list[img_idx][human_idx]['bbox']
+                x1, y1, x2, y2 = bbox
+                
+                detections = []
+                if result.boxes:
+                    for box in result.boxes:
+                        class_id = int(box.cls.item())
+                        confidence = box.conf.item()
+                        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}'
+                        
+                        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:
+                    humans_data_list[img_idx][human_idx]['nsfw_scores'] = detections
+                else:
+                    humans_data_list[img_idx][human_idx]['nsfw_scores'] = [{'class': 'safe', 'confidence': 1.0, 'bbox': [x1, y1, x2, y2]}]
+        except Exception as e:
+            print(f"! Batched NSFW failed: {e}")
+            # Fallback: set safe for all
+            for img_idx, humans_data in enumerate(humans_data_list):
+                for human in humans_data:
+                    if human['bbox'] is not None:
+                        x1, y1, x2, y2 = human['bbox']
+                        human['nsfw_scores'] = [{'class': 'safe', 'confidence': 1.0, 'bbox': [x1, y1, x2, y2]}]
+    
+    # Save NPZ files and create metadata
+    metadatas = []
+    for img_idx, (humans_data, image_path) in enumerate(zip(humans_data_list, image_paths)):
+        image_pil = images[img_idx]
+        image_id = Path(image_path).stem if image_path else f'img_{img_idx:06d}'
+        img_width, img_height = image_pil.size
+        
+        out_path = out_dir / f"{image_id}.npz"
+        if out_path.exists():
+            metadatas.append(None)
+            continue
+        
+        if not humans_data:
+            metadata = {
+                'image_id': image_id,
+                'num_humans': 0,
+                'image_width': img_width,
+                'image_height': img_height,
+                'processing_time_ms': 0,  # Not tracked in batch
+                'status': 'no_detection',
+                'humans': []
+            }
+        else:
+            num_humans = len(humans_data)
+            
+            # Save first human's mesh
+            pred = outputs_list[img_idx][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)
+            
+            np.savez_compressed(
+                out_path,
+                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_id=image_id,
+                num_humans=num_humans,
+                image_width=img_width,
+                image_height=img_height,
+                humans_metadata=json.dumps(humans_data)
+            )
+            
+            metadata = {
+                'image_id': image_id,
+                'num_humans': num_humans,
+                'image_width': img_width,
+                'image_height': img_height,
+                'processing_time_ms': 0,  # Not tracked
+                'status': 'success',
+                'npz_size_bytes': out_path.stat().st_size,
+                'humans': humans_data
+            }
+        
+        metadatas.append(metadata)
+    
+    return {'metadata': metadatas}
     """
     Process PIL image and save .npz with ALL outputs + metadata + NSFW scores per human.
     
@@ -694,48 +924,49 @@ def main():
     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)
+    # Process using dataset.map() for efficient batching
+    batch_size = 4  # Adjust based on GPU memory (higher = more efficient)
+    logger.info(f"Processing with batch_size={batch_size} using dataset.map()")
     sys.stdout.flush()
-
-    processed = 0
-    failed = 0
-    no_detection = 0
+    
+    process_batch_partial = functools.partial(
+        process_batch,
+        teacher=teacher,
+        nsfw_classifier=nsfw_classifier,
+        gaze_estimator=gaze_estimator,
+        face_embedder=face_embedder,
+        faces=faces,
+        out_dir=out_dir
+    )
+    
+    processed_ds = ds.map(
+        process_batch_partial,
+        batched=True,
+        batch_size=batch_size,
+        remove_columns=ds.column_names  # Remove original columns, keep only metadata
+    )
+    
+    # Collect metadata from processed dataset
     metadata_records = []
+    batch_count = 0
     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
+    for batch_result in processed_ds:
+        metadata_records.extend(batch_result['metadata'])
+        batch_count += 1
         
-        if i % 10 == 0:
+        if batch_count % 10 == 0:
             elapsed = time.time() - start_process
+            processed = sum(1 for m in metadata_records if m and m['status'] == 'success')
             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")
+            logger.info(f"[{batch_count} batches] success={processed}, speed={speed:.2f} img/s")
             sys.stdout.flush()
-
+    
     total_time = time.time() - start_process
+    processed = sum(1 for m in metadata_records if m and m['status'] == 'success')
+    no_detection = sum(1 for m in metadata_records if m and m['status'] == 'no_detection')
+    failed = sum(1 for m in metadata_records if m and m['status'] == 'error')
+    
     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)")