Upload hf_collect_teacher_metadata.py with huggingface_hub

hf_collect_teacher_metadata.py

@@ -35,6 +35,8 @@ import cv2
 from typing import List, Dict, Optional
 import time
 import functools
+import json
+from collections import defaultdict
 
 # SAM 3D Body imports
 import sys
@@ -80,63 +82,58 @@ class GazeEstimator:
             print("Gaze estimation will be disabled")
             self.enabled = False
     
-    def estimate_gaze(self, image_pil, bbox):
+    def estimate_gaze(self, bbox, detections=None, image_bgr=None):
         """
-        Estimate gaze direction from face crop.
+        Estimate gaze direction for a bbox using optional precomputed detections.
         
         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
+            bbox: [x1, y1, x2, y2]
+            detections: cached L2CS pipeline outputs for the full image
+            image_bgr: optional BGR image (used only when detections missing)
         """
         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}
+            if detections is None and image_bgr is not None:
+                detections = self.pipeline.step(image_bgr)
+            if not detections:
+                return None
             
+            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 detections:
+                face_bbox = result.get('bbox')
+                if face_bbox is None:
+                    continue
+                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:
+                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
+    
+    def run_pipeline(self, image_bgr):
+        """Run L2CS pipeline once per image and reuse detections."""
+        if not self.enabled:
+            return None
+        try:
+            return self.pipeline.step(image_bgr)
+        except Exception as e:
+            print(f"Warning: L2CS pipeline failed: {e}")
+            return None
 
 
 class FaceEmbedder:
@@ -177,12 +174,12 @@ class FaceEmbedder:
             print("Face embeddings will be disabled")
             self.enabled = False
     
-    def extract_embedding(self, image_pil, bbox=None, keypoints_2d=None):
+    def extract_embedding(self, image, bbox=None, keypoints_2d=None):
         """
         Extract 512-dimensional ArcFace embedding from face.
         
         Args:
-            image_pil: PIL Image
+            image: PIL Image or BGR numpy array
             bbox: [x1, y1, x2, y2] in pixel coordinates (optional, for cropping)
             keypoints_2d: Face keypoints for alignment (optional)
             
@@ -193,12 +190,15 @@ class FaceEmbedder:
             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)
+            # Convert to numpy BGR (InsightFace expects BGR)
+            if isinstance(image, Image.Image):
+                image_np = np.array(image)
+                if image_np.shape[2] == 3:
+                    image_bgr = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR)
+                else:
+                    image_bgr = image_np
             else:
-                image_bgr = image_np
+                image_bgr = image
             
             # Optionally crop to bbox region for efficiency
             if bbox is not None:
@@ -427,14 +427,21 @@ def process_batch(batch, teacher, nsfw_classifier, gaze_estimator, face_embedder
     humans_data_list = []
     outputs_list = []
     image_rgbs = []  # cache RGB numpy arrays for later crops
+    image_bgrs = []  # cache BGR arrays for gaze/face embedding
+    gaze_detections = []
     
     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)
+        image_bgrs.append(image_bgr)
+        
+        detections = gaze_estimator.run_pipeline(image_bgr) if gaze_estimator is not None else None
+        gaze_detections.append(detections)
         
-        outputs = teacher.process_one_image(image_bgr)
+        with torch.inference_mode():
+            outputs = teacher.process_one_image(image_bgr)
         outputs_list.append(outputs)
         
         if not outputs:
@@ -481,14 +488,14 @@ def process_batch(batch, teacher, nsfw_classifier, gaze_estimator, face_embedder
             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)
+                    gaze_direction = gaze_estimator.estimate_gaze(bbox, detections=gaze_detections[img_idx])
                 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)
+                    face_embedding = face_embedder.extract_embedding(image_bgrs[img_idx], bbox, kpts2d)
                 except Exception as e:
                     face_embedding = None