Upload hf_job_gaze.py with huggingface_hub

hf_job_gaze.py

@@ -1,8 +1,8 @@
 #!/usr/bin/env python3
 """
-Gaze Estimation Job - Estimate gaze direction using L2CS-Net
+Face Embedding Job - Extract ArcFace embeddings from detected faces
 Requires: SAM 3D Body outputs for face bboxes
-Outputs: Pitch/yaw gaze angles per detected face
+Outputs: 512-dim face embeddings with detection confidence
 """
 import argparse
 import os
@@ -30,34 +30,35 @@ import cv2
 import json
 
 
-def init_gaze_estimator(device='cuda'):
-    """Initialize L2CS-Net gaze estimator"""
-    logger.info("Installing L2CS-Net...")
+def init_face_embedder(device='cuda'):
+    """Initialize InsightFace ArcFace model"""
+    logger.info("Installing InsightFace...")
     try:
         subprocess.run(
-            ['pip', 'install', '-q', 'git+https://github.com/edavalosanaya/L2CS-Net.git@main'],
+            ['pip', 'install', '-q', 'insightface', 'onnxruntime-gpu' if device.type == 'cuda' else 'onnxruntime'],
             check=True,
             capture_output=True
         )
-        logger.info("✓ L2CS-Net installed")
+        logger.info("✓ InsightFace installed")
     except Exception as e:
-        logger.warning(f"L2CS-Net installation failed: {e}")
+        logger.warning(f"InsightFace installation failed: {e}")
     
-    logger.info("Loading L2CS-Net...")
-    from l2cs import Pipeline
+    logger.info("Loading InsightFace ArcFace...")
+    import insightface
+    from insightface.app import FaceAnalysis
     
-    pipeline = Pipeline(
-        weights='L2CSNet_gaze360.pkl',
-        arch='ResNet50',
-        device=device
+    app = FaceAnalysis(
+        name='buffalo_l',
+        providers=['CUDAExecutionProvider'] if device.type == 'cuda' else ['CPUExecutionProvider']
     )
-    logger.info("✓ L2CS-Net loaded")
+    app.prepare(ctx_id=0 if device.type == 'cuda' else -1, det_size=(640, 640))
+    logger.info("✓ ArcFace loaded")
     
-    return pipeline
+    return app
 
 
-def make_square_bbox_with_padding(bbox, img_width, img_height, padding=0.15):
-    """Convert bbox to square with padding for gaze estimation"""
+def make_square_bbox_with_padding(bbox, img_width, img_height, padding=0.2):
+    """Convert bbox to square with padding for face detection"""
     x1, y1, x2, y2 = bbox
     w = x2 - x1
     h = y2 - y1
@@ -115,58 +116,45 @@ def has_valid_face(keypoints_2d, keypoints_3d, img_width, img_height):
     return True
 
 
-def estimate_gaze_batch(pipeline, image_bgr, bboxes, img_width, img_height):
-    """Run L2CS once on full image and match results to face bboxes"""
+def extract_embedding(app, image_bgr, bbox, img_width, img_height):
+    """Extract face embedding from bbox region with proper cropping and padding"""
     try:
-        # 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)
+        # 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
         
-        detections = pipeline.step(image_bgr)
-        if not detections:
-            return [None] * len(bboxes)
+        # Crop to square region
+        crop = image_bgr[y1:y2, x1:x2]
         
-        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)
+        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
         
-        return results
+        # Use the most confident face
+        face = max(faces, key=lambda x: x.det_score)
+        embedding = face.embedding
+        embedding_norm = embedding / np.linalg.norm(embedding)
+        
+        return {
+            'embedding': embedding_norm.astype(np.float32).tolist(),
+            'det_score': float(face.det_score),
+            'embedding_dim': len(embedding)
+        }
     except Exception as e:
-        logger.error(f"Gaze estimation failed: {e}")
-        return [None] * len(bboxes)
+        logger.error(f"Embedding extraction failed: {e}")
+        return None
 
 
 def process_batch(batch, sam3d_dataset):
@@ -187,7 +175,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,
-                'gaze_data': None
+                'embeddings': None
             })
             continue
         
@@ -197,38 +185,42 @@ def process_batch(batch, sam3d_dataset):
         image_rgb = np.array(image_pil.convert('RGB'))
         image_bgr = cv2.cvtColor(image_rgb, cv2.COLOR_RGB2BGR)
         
-        # Collect bboxes for valid faces only
-        bboxes = []
-        for human in humans_data:
+        # Extract embeddings for each human with valid face
+        embeddings = []
+        for human_idx, human in enumerate(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 has_valid_face(kpts2d, kpts3d, img_width, img_height) and bbox is not None:
-                bboxes.append(bbox)
-            else:
-                bboxes.append(None)
-        
-        # Estimate gaze for all valid faces in one pass
-        gaze_results = estimate_gaze_batch(gaze_pipeline, image_bgr, bboxes, img_width, img_height)
+            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)
         
         results_list.append({
             'image_id': image_id,
-            'gaze_data': json.dumps(gaze_results) if any(g is not None for g in gaze_results) else None
+            'embeddings': json.dumps(embeddings) if any(e is not None for e in embeddings) else None
         })
     
     return {
         'image_id': [r['image_id'] for r in results_list],
-        'gaze_directions': [r['gaze_data'] for r in results_list]
+        'face_embeddings': [r['embeddings'] for r in results_list]
     }
 
 
 def main():
-    global gaze_pipeline
+    global face_app
     
     logger.info("="*60)
-    logger.info("Gaze Estimation (L2CS-Net)")
+    logger.info("Face Embedding Extraction (ArcFace)")
     logger.info("="*60)
     
     ap = argparse.ArgumentParser()
@@ -246,8 +238,8 @@ def main():
     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
     logger.info(f"Using device: {device}")
     
-    # Load gaze estimator
-    gaze_pipeline = init_gaze_estimator(device)
+    # Load face embedder
+    face_app = init_face_embedder(device)
     
     # Load SAM3D results
     logger.info(f"Loading SAM3D results from {args.sam3d_dataset}...")
@@ -288,12 +280,12 @@ def main():
     # Create output dataset
     features = Features({
         'image_id': Value('string'),
-        'gaze_directions': Value('string')
+        'face_embeddings': Value('string')
     })
     
     output_ds = HFDataset.from_dict({
         'image_id': [r['image_id'] for r in results],
-        'gaze_directions': [r['gaze_directions'] for r in results]
+        'face_embeddings': [r['face_embeddings'] for r in results]
     }, features=features)
     
     # Upload