Upload hf_job_gaze.py with huggingface_hub

hf_job_gaze.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 """
-Face Embedding Job - Extract ArcFace embeddings from detected faces
+Gaze Estimation Job - Estimate gaze direction using L2CS-Net
 Requires: SAM 3D Body outputs for face bboxes
-Outputs: 512-dim face embeddings with detection confidence
+Outputs: Pitch/yaw gaze angles per detected face
 """
 import argparse
 import os
@@ -30,35 +30,34 @@ import cv2
 import json
 
 
-def init_face_embedder(device='cuda'):
-    """Initialize InsightFace ArcFace model"""
-    logger.info("Installing InsightFace...")
+def init_gaze_estimator(device='cuda'):
+    """Initialize L2CS-Net gaze estimator"""
+    logger.info("Installing L2CS-Net...")
     try:
         subprocess.run(
-            ['pip', 'install', '-q', 'insightface', 'onnxruntime-gpu' if device.type == 'cuda' else 'onnxruntime'],
+            ['pip', 'install', '-q', 'git+https://github.com/edavalosanaya/L2CS-Net.git@main'],
             check=True,
             capture_output=True
         )
-        logger.info("✓ InsightFace installed")
+        logger.info("✓ L2CS-Net installed")
     except Exception as e:
-        logger.warning(f"InsightFace installation failed: {e}")
+        logger.warning(f"L2CS-Net installation failed: {e}")
     
-    logger.info("Loading InsightFace ArcFace...")
-    import insightface
-    from insightface.app import FaceAnalysis
+    logger.info("Loading L2CS-Net...")
+    from l2cs import Pipeline
     
-    app = FaceAnalysis(
-        name='buffalo_l',
-        providers=['CUDAExecutionProvider'] if device.type == 'cuda' else ['CPUExecutionProvider']
+    pipeline = Pipeline(
+        weights='L2CSNet_gaze360.pkl',
+        arch='ResNet50',
+        device=device
     )
-    app.prepare(ctx_id=0 if device.type == 'cuda' else -1, det_size=(640, 640))
-    logger.info("✓ ArcFace loaded")
+    logger.info("✓ L2CS-Net loaded")
     
-    return app
+    return pipeline
 
 
-def make_square_bbox_with_padding(bbox, img_width, img_height, padding=0.2):
-    """Convert bbox to square with padding for face detection"""
+def make_square_bbox_with_padding(bbox, img_width, img_height, padding=0.15):
+    """Convert bbox to square with padding for gaze estimation"""
     x1, y1, x2, y2 = bbox
     w = x2 - x1
     h = y2 - y1
@@ -80,8 +79,8 @@ def make_square_bbox_with_padding(bbox, img_width, img_height, padding=0.2):
     return [x1_sq, y1_sq, x2_sq, y2_sq]
 
 
-def has_valid_face(keypoints_2d, keypoints_3d, img_width, img_height):
-    """Check if human has a valid, visible face"""
+def has_valid_eyes(keypoints_2d, keypoints_3d, img_width, img_height):
+    """Check if human has valid, visible eyes for gaze estimation"""
     if keypoints_2d is None or keypoints_3d is None:
         return False
     
@@ -91,24 +90,21 @@ def has_valid_face(keypoints_2d, keypoints_3d, img_width, img_height):
     if len(kpts2d_arr) < 3 or len(kpts3d_arr) < 3:
         return False
     
-    # Check face keypoints (nose, left eye, right eye)
-    nose_2d = kpts2d_arr[0]
+    # Check eye keypoints specifically (left eye, right eye)
     left_eye_2d = kpts2d_arr[1]
     right_eye_2d = kpts2d_arr[2]
-    nose_3d = kpts3d_arr[0]
     left_eye_3d = kpts3d_arr[1]
     right_eye_3d = kpts3d_arr[2]
     
-    # Check 3D keypoints are valid (not at origin)
-    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)
+    # Check 3D eye keypoints are valid (not at origin)
+    eyes_valid_3d = (np.linalg.norm(left_eye_3d) > 1e-6 and 
+                     np.linalg.norm(right_eye_3d) > 1e-6)
     
-    if not keypoints_valid_3d:
+    if not eyes_valid_3d:
         return False
     
-    # Check 2D keypoints are within image bounds
-    for kp in [nose_2d, left_eye_2d, right_eye_2d]:
+    # Check 2D eye keypoints are within image bounds
+    for kp in [left_eye_2d, right_eye_2d]:
         if (kp[0] < 0 or kp[0] >= img_width or 
             kp[1] < 0 or kp[1] >= img_height):
             return False
@@ -116,45 +112,58 @@ def has_valid_face(keypoints_2d, keypoints_3d, img_width, img_height):
     return True
 
 
-def extract_embedding(app, image_bgr, bbox, img_width, img_height):
-    """Extract face embedding from bbox region with proper cropping and padding"""
+def estimate_gaze_batch(pipeline, image_bgr, bboxes, img_width, img_height):
+    """Run L2CS once on full image and match results to face bboxes"""
     try:
-        # Make square bbox with padding for better face detection
-        square_bbox = make_square_bbox_with_padding(bbox, img_width, img_height, padding=0.2)
-        x1, y1, x2, y2 = square_bbox
+        # Convert bboxes to square with padding
+        square_bboxes = []
+        for bbox in bboxes:
+            if bbox is not None:
+                square_bbox = make_square_bbox_with_padding(bbox, img_width, img_height, padding=0.15)
+                square_bboxes.append(square_bbox)
+            else:
+                square_bboxes.append(None)
         
-        # Crop to square region
-        crop = image_bgr[y1:y2, x1:x2]
+        detections = pipeline.step(image_bgr)
+        if not detections:
+            return [None] * len(bboxes)
         
-        if crop.size == 0:
-            return None
-        
-        # Resize to optimal size for InsightFace (640x640 max)
-        crop_h, crop_w = crop.shape[:2]
-        if max(crop_h, crop_w) > 640:
-            scale = 640 / max(crop_h, crop_w)
-            new_h = int(crop_h * scale)
-            new_w = int(crop_w * scale)
-            crop = cv2.resize(crop, (new_w, new_h), interpolation=cv2.INTER_LINEAR)
-        
-        # Detect faces
-        faces = app.get(crop)
-        if len(faces) == 0:
-            return None
-        
-        # Use the most confident face
-        face = max(faces, key=lambda x: x.det_score)
-        embedding = face.embedding
-        embedding_norm = embedding / np.linalg.norm(embedding)
+        results = []
+        for square_bbox in square_bboxes:
+            if square_bbox is None:
+                results.append(None)
+                continue
+            
+            x1, y1, x2, y2 = square_bbox
+            bbox_center = np.array([(x1 + x2) / 2, (y1 + y2) / 2])
+            
+            best_result = None
+            min_dist = float('inf')
+            
+            for det in detections:
+                face_bbox = det.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 = det
+            
+            if best_result is not None:
+                results.append({
+                    'pitch': float(best_result.get('pitch', 0)),
+                    'yaw': float(best_result.get('yaw', 0))
+                })
+            else:
+                results.append(None)
         
-        return {
-            'embedding': embedding_norm.astype(np.float32).tolist(),
-            'det_score': float(face.det_score),
-            'embedding_dim': len(embedding)
-        }
+        return results
     except Exception as e:
-        logger.error(f"Embedding extraction failed: {e}")
-        return None
+        logger.error(f"Gaze estimation failed: {e}")
+        return [None] * len(bboxes)
 
 
 def process_batch(batch, sam3d_dataset):
@@ -175,7 +184,7 @@ def process_batch(batch, sam3d_dataset):
         if not sam3d_row or not sam3d_row[0]['sam3d_data']:
             results_list.append({
                 'image_id': image_id,
-                'embeddings': None
+                'gaze_data': None
             })
             continue
         
@@ -185,42 +194,38 @@ def process_batch(batch, sam3d_dataset):
         image_rgb = np.array(image_pil.convert('RGB'))
         image_bgr = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR)
         
-        # Extract embeddings for each human with valid face
-        embeddings = []
-        for human_idx, human in enumerate(humans_data):
+        # Collect bboxes for valid eyes only
+        bboxes = []
+        for human in humans_data:
             bbox = human.get('bbox')
             kpts2d = human.get('keypoints_2d')
             kpts3d = human.get('keypoints_3d')
             
-            # Check if this human has a valid, visible face
-            if not has_valid_face(kpts2d, kpts3d, img_width, img_height):
-                embeddings.append(None)
-                continue
-            
-            if bbox is None:
-                embeddings.append(None)
-                continue
-            
-            # Extract embedding from face region
-            embedding = extract_embedding(face_app, image_bgr, bbox, img_width, img_height)
-            embeddings.append(embedding)
+            # Check if this human has valid, visible eyes for gaze estimation
+            if has_valid_eyes(kpts2d, kpts3d, img_width, img_height) and bbox is not None:
+                bboxes.append(bbox)
+            else:
+                bboxes.append(None)
+        
+        # Estimate gaze for all valid eyes in one pass
+        gaze_results = estimate_gaze_batch(gaze_pipeline, image_bgr, bboxes, img_width, img_height)
         
         results_list.append({
             'image_id': image_id,
-            'embeddings': json.dumps(embeddings) if any(e is not None for e in embeddings) else None
+            'gaze_data': json.dumps(gaze_results) if any(g is not None for g in gaze_results) else None
         })
     
     return {
         'image_id': [r['image_id'] for r in results_list],
-        'face_embeddings': [r['embeddings'] for r in results_list]
+        'gaze_directions': [r['gaze_data'] for r in results_list]
     }
 
 
 def main():
-    global face_app
+    global gaze_pipeline
     
     logger.info("="*60)
-    logger.info("Face Embedding Extraction (ArcFace)")
+    logger.info("Gaze Estimation (L2CS-Net)")
     logger.info("="*60)
     
     ap = argparse.ArgumentParser()
@@ -238,8 +243,8 @@ def main():
     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
     logger.info(f"Using device: {device}")
     
-    # Load face embedder
-    face_app = init_face_embedder(device)
+    # Load gaze estimator
+    gaze_pipeline = init_gaze_estimator(device)
     
     # Load SAM3D results
     logger.info(f"Loading SAM3D results from {args.sam3d_dataset}...")
@@ -280,12 +285,12 @@ def main():
     # Create output dataset
     features = Features({
         'image_id': Value('string'),
-        'face_embeddings': Value('string')
+        'gaze_directions': Value('string')
     })
     
     output_ds = HFDataset.from_dict({
         'image_id': [r['image_id'] for r in results],
-        'face_embeddings': [r['face_embeddings'] for r in results]
+        'gaze_directions': [r['gaze_directions'] for r in results]
     }, features=features)
     
     # Upload