feat: implement batch processing for face embeddings in EnsembleFaceRecognition

models/face_recognition.py

@@ -1,7 +1,9 @@
 import numpy as np
 from typing import Dict, List, Tuple
+import cv2
 
 from deepface import DeepFace
+from deepface.modules import modeling, preprocessing
 
 class EnsembleFaceRecognition:
     def __init__(self, model_weights: Dict[str, float] = None):
@@ -37,6 +39,54 @@ class EnsembleFaceRecognition:
             'facenet': DeepFace.represent(img_path=image, detector_backend='skip', model_name='Facenet512', normalization='Facenet2018',align=True)[0]['embedding'],
             'arc': DeepFace.represent(img_path=image, detector_backend='skip', model_name='ArcFace',align=True)[0]['embedding']}
     
+    def _preprocess_face_batch(self, faces: np.ndarray, target_size: Tuple[int, int], normalization: str) -> np.ndarray:
+        """Preprocess a batch of face images for model inference"""
+        batch_size = faces.shape[0]
+        processed_faces = []
+        
+        for i in range(batch_size):
+            face = faces[i]
+            # Convert RGB to BGR (DeepFace expects BGR)
+            face = face[:, :, ::-1]
+            
+            # Resize to model input size
+            resized = preprocessing.resize_image(face, target_size)
+            
+            # Normalize
+            normalized = preprocessing.normalize_input(resized, normalization)
+            
+            processed_faces.append(normalized)
+        
+        # Stack into batch and remove the extra dimension added by resize_image
+        batch = np.vstack(processed_faces)
+        return batch
+    
+    def get_face_embeddings_batch(self, faces: np.ndarray) -> Dict[str, np.ndarray]:
+        """Get face embeddings for a batch of images efficiently
+        
+        Args:
+            faces: np.ndarray of shape (batch_size, height, width, channels)
+            
+        Returns:
+            Dict with 'facenet' and 'arc' keys containing batched embeddings
+        """
+        # Load models (cached by DeepFace)
+        facenet_model = modeling.build_model(task="facial_recognition", model_name="Facenet512")
+        arcface_model = modeling.build_model(task="facial_recognition", model_name="ArcFace")
+        
+        # Preprocess faces for each model
+        facenet_batch = self._preprocess_face_batch(faces, facenet_model.input_shape, "Facenet2018")
+        arcface_batch = self._preprocess_face_batch(faces, arcface_model.input_shape, "ArcFace")
+        
+        # Get embeddings using direct model inference (bypassing DeepFace.represent)
+        facenet_embeddings = facenet_model.model(facenet_batch, training=False).numpy()
+        arcface_embeddings = arcface_model.model(arcface_batch, training=False).numpy()
+        
+        return {
+            'facenet': facenet_embeddings,
+            'arc': arcface_embeddings
+        }
+    
     def ensemble_prediction(self,
                             model_predictions: Dict[str, Tuple[List[str], List[float]]],
                             temperature: float = 0.1,

models/image_processor.py

@@ -22,13 +22,15 @@ def get_face_predictions(face, ensemble, data_manager, results):
     Returns:
     List of (name, confidence) tuples
     """
-    # Get embeddings for original and flipped images
-    embeddings_orig = ensemble.get_face_embeddings(face)
-    embeddings_flip = ensemble.get_face_embeddings(np.fliplr(face))
-
-    # Average the embeddings
-    facenet = np.mean([embeddings_orig['facenet'], embeddings_flip['facenet']], axis=0)
-    arc = np.mean([embeddings_orig['arc'], embeddings_flip['arc']], axis=0)
+    # Create batch with original and flipped images
+    face_batch = np.stack([face, face[:, ::-1, :]], axis=0)
+    
+    # Get embeddings for both orientations in one batch call
+    embeddings_batch = ensemble.get_face_embeddings_batch(face_batch)
+    
+    # Average the embeddings across orientations
+    facenet = np.mean(embeddings_batch['facenet'], axis=0)
+    arc = np.mean(embeddings_batch['arc'], axis=0)
 
     # Get predictions from both models
     model_predictions = {