Upload hf_job_face_embedding.py with huggingface_hub

hf_job_face_embedding.py

@@ -57,22 +57,92 @@ def init_face_embedder(device='cuda'):
     return app
 
 
-def extract_embedding(app, image_bgr, bbox):
-    """Extract face embedding from bbox region"""
+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
+    
+    # Make square
+    size = max(w, h)
+    cx = (x1 + x2) / 2
+    cy = (y1 + y2) / 2
+    
+    # Add padding
+    size = size * (1 + padding)
+    
+    # Get square bbox
+    x1_sq = max(0, int(cx - size / 2))
+    y1_sq = max(0, int(cy - size / 2))
+    x2_sq = min(img_width, int(cx + size / 2))
+    y2_sq = min(img_height, int(cy + size / 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"""
+    if keypoints_2d is None or keypoints_3d is None:
+        return False
+    
+    kpts2d_arr = np.array(keypoints_2d)
+    kpts3d_arr = np.array(keypoints_3d)
+    
+    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]
+    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)
+    
+    if not keypoints_valid_3d:
+        return False
+    
+    # Check 2D 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):
+            return False
+    
+    return True
+
+
+def extract_embedding(app, image_bgr, bbox, img_width, img_height):
+    """Extract face embedding from bbox region with proper cropping and padding"""
     try:
-        x1, y1, x2, y2 = map(int, bbox)
-        pad = 20
-        h, w = image_bgr.shape[:2]
-        x1 = max(0, x1 - pad)
-        y1 = max(0, y1 - pad)
-        x2 = min(w, x2 + pad)
-        y2 = min(h, y2 + pad)
+        # 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
+        
+        # Crop to square region
         crop = image_bgr[y1:y2, x1:x2]
         
+        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)
@@ -96,6 +166,7 @@ def process_batch(batch, sam3d_dataset):
     
     for idx, image_pil in enumerate(images):
         image_id = Path(image_paths[idx]).stem if image_paths[idx] else f'img_{idx:06d}'
+        img_width, img_height = image_pil.size
         
         # Find corresponding SAM3D data
         sam3d_row = sam3d_dataset.filter(lambda x: x['image_id'] == image_id).take(1)
@@ -121,31 +192,17 @@ def process_batch(batch, sam3d_dataset):
             kpts2d = human.get('keypoints_2d')
             kpts3d = human.get('keypoints_3d')
             
-            # Check if face is valid
-            if bbox is None or kpts2d is None or kpts3d is None:
-                embeddings.append(None)
-                continue
-            
-            kpts2d_arr = np.array(kpts2d)
-            kpts3d_arr = np.array(kpts3d)
-            
-            if len(kpts2d_arr) < 3 or len(kpts3d_arr) < 3:
+            # Check if this human has a valid, visible face
+            if not has_valid_face(kpts2d, kpts3d, img_width, img_height):
                 embeddings.append(None)
                 continue
             
-            # Check face keypoints valid
-            nose_3d = kpts3d_arr[0]
-            left_eye_3d = kpts3d_arr[1]
-            right_eye_3d = kpts3d_arr[2]
-            
-            if (np.linalg.norm(nose_3d) < 1e-6 or 
-                np.linalg.norm(left_eye_3d) < 1e-6 or 
-                np.linalg.norm(right_eye_3d) < 1e-6):
+            if bbox is None:
                 embeddings.append(None)
                 continue
             
-            # Extract embedding
-            embedding = extract_embedding(face_app, image_bgr, bbox)
+            # Extract embedding from face region
+            embedding = extract_embedding(face_app, image_bgr, bbox, img_width, img_height)
             embeddings.append(embedding)
         
         results_list.append({