Upload hf_collect_teacher_metadata.py with huggingface_hub

hf_collect_teacher_metadata.py

@@ -426,10 +426,12 @@ def process_batch(batch, teacher, nsfw_classifier, gaze_estimator, face_embedder
     # First pass: process images and collect humans data (without NSFW)
     humans_data_list = []
     outputs_list = []
+    image_rgbs = []  # cache RGB numpy arrays for later crops
     
     for img_idx, image_pil in enumerate(images):
         img_width, img_height = image_pil.size
         image_rgb = np.array(image_pil.convert('RGB'))
+        image_rgbs.append(image_rgb)
         image_bgr = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR)
         
         outputs = teacher.process_one_image(image_bgr)
@@ -536,8 +538,11 @@ def process_batch(batch, teacher, nsfw_classifier, gaze_estimator, face_embedder
             bbox = human['bbox']
             if bbox is not None:
                 x1, y1, x2, y2 = bbox
-                crop = image_pil.crop((x1, y1, x2, y2))
-                crops.append(crop)
+                ix1, iy1, ix2, iy2 = map(lambda v: max(0, int(round(v))), [x1, y1, x2, y2])
+                ix1, iy1 = min(ix1, image_rgbs[img_idx].shape[1]-1), min(iy1, image_rgbs[img_idx].shape[0]-1)
+                ix2, iy2 = max(ix1+1, min(ix2, image_rgbs[img_idx].shape[1])), max(iy1+1, min(iy2, image_rgbs[img_idx].shape[0]))
+                crop_np = np.ascontiguousarray(image_rgbs[img_idx][iy1:iy2, ix1:ix2])
+                crops.append(crop_np)
                 crop_info.append((img_idx, human_idx))
     
     if crops and nsfw_classifier is not None and nsfw_classifier.enabled:
@@ -643,211 +648,6 @@ def process_batch(batch, teacher, nsfw_classifier, gaze_estimator, face_embedder
         metadatas.append(metadata)
     
     return {'metadata': metadatas}
-    """
-    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():
@@ -924,6 +724,13 @@ def main():
     logger.info(f"✓ Dataset ready in {time.time() - start_ds:.1f}s")
     sys.stdout.flush()
 
+    # Prepare output directory and shared mesh topology
+    out_dir = Path('teacher_labels')
+    out_dir.mkdir(exist_ok=True)
+    faces = teacher.faces
+    logger.info(f"Mesh topology: {faces.shape[0]} faces")
+    sys.stdout.flush()
+
     # 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()")