feat: replaced our model with built-in pyfeat classifier.

botender/perception/detection_worker.py

@@ -6,12 +6,13 @@
 
 import numpy as np
 import torch
-from pandas import DataFrame
 
 import botender.logging_utils as logging_utils
 from botender.perception.detectors import EmotionDetector, FacialExpressionDetector
 from botender.webcam_processor import Rectangle
 
+from feat import Detector  # type: ignore
+
 warnings.filterwarnings("ignore")
 logger = logging.getLogger(__name__)
 
@@ -25,8 +26,8 @@
 class DetectionResult:
     faces: list[Rectangle]
     """A list of rectangles representing the faces detected in the frame."""
-    features: DataFrame
-    """A dataframe containing all the features extracted from the frame."""
+    features: list
+    """A list containing all the features extracted from the frame."""
     emotion: str
     """A string that defines the detected emotion."""
 
@@ -45,6 +46,8 @@ class DetectionWorker(Process):
     _last_emotions: list[str] = []
     _detect_emotion_counter: int = 0
 
+    _detector: Detector
+
     def __init__(
         self,
         logging_queue: Queue,
@@ -62,17 +65,18 @@ def __init__(
         self._result_connection = result_connection
         self._stop_event = stop_event
         self._detect_emotion_event = detect_emotion_event
-        self._current_result = DetectionResult(
-            faces=[], features=DataFrame(), emotion="neutral"
-        )
+        self._current_result = DetectionResult(faces=[], features=[], emotion="neutral")
 
     def run(self):
         """Uses the detectors to detect faces and emotions in the newest frames."""
 
         logging_utils.configure_publisher(self._logging_queue)
         logger.debug("Successfully spawned detection worker. Initializing detector...")
-        self.facial_expression_detector = FacialExpressionDetector(device=_get_device())
-        self.emotion_detector = EmotionDetector()
+        self._detector = Detector(device=_get_device())
+        self.facial_expression_detector = FacialExpressionDetector(
+            detector=self._detector
+        )
+        self.emotion_detector = EmotionDetector(detector=self._detector)
         logger.debug("Successfully initialized detector. Starting work loop...")
         self._result_connection.send(True)  # Signal that we are ready
 
@@ -115,10 +119,14 @@ def detect_emotion(self) -> bool:
             return clear_flag
 
         # extract features
-        features = self.facial_expression_detector.extract_features(self.work_frame)
+        features, faces = self.facial_expression_detector.extract_features(
+            self.work_frame
+        )
         self._current_result.features = features
         # predict emotion
-        emotion = self.emotion_detector.detect_emotion(features=features)
+        emotion = self.emotion_detector.detect_emotion(
+            frame=self.work_frame, faces=faces, features=features
+        )
         self._last_emotions.append(emotion)
 
         self._detect_emotion_counter += 1

botender/perception/detectors/emotion_detector.py

@@ -1,43 +1,43 @@
 import logging
-import pickle
 
-from pandas import DataFrame
-from pkg_resources import resource_filename
-from sklearn.svm import SVC  # type: ignore[import-untyped]
+from feat import Detector  # type: ignore
+from feat.utils import FEAT_EMOTION_COLUMNS  # type: ignore
+import numpy as np
 
 logger = logging.getLogger(__name__)
 
-SVM_MODEL_PATH = resource_filename(__name__, "models/svm_model.pkl")
-SCALER_MODEL_PATH = resource_filename(__name__, "models/scaler.pkl")
-LABEL_ENCODER_MODEL_PATH = resource_filename(__name__, "models/label_encoder.pkl")
+PYFEAT_EMOTIONS_TO_EMOTIONS = {
+    "neutral": "neutral",
+    "anger": "angry",
+    "happy": "happy",
+    "sadness": "sad",
+}
 
 
 class EmotionDetector:
     """The EmotionDetector is responsible for predict the emotion of the user."""
 
-    _model: SVC  # or whatever model we use
+    _detector: Detector  # use built-in pyfeat classifier
 
-    def __init__(self):
-        # load model
-        logger.info("Loading emotion detection model...")
-        # Load the model from the file
-        with open(SVM_MODEL_PATH, "rb") as file:
-            self.loaded_model = pickle.load(file)
+    def __init__(self, detector: Detector):
+        self._detector = detector
 
-        with open(SCALER_MODEL_PATH, "rb") as file:
-            self.loaded_scaler = pickle.load(file)
-
-        with open(LABEL_ENCODER_MODEL_PATH, "rb") as file:
-            self.loaded_label_encoder = pickle.load(file)
-
-    def detect_emotion(self, features: DataFrame) -> str:
+    def detect_emotion(
+        self,
+        frame: np.ndarray,
+        faces: list[tuple[float, float, float, float, float]],
+        features: list,
+    ) -> str:
         """Predicts the emotion in the given features and returns it as a string."""
 
-        if len(features) == 0:
+        if len(faces) == 0 or len(features) == 0:
             return "neutral"
 
-        scaled_aus = self.loaded_scaler.transform(features[0])
-        predictions = self.loaded_model.predict(scaled_aus)
-        predicted_emotions = self.loaded_label_encoder.inverse_transform(predictions)
+        detected_emotions = self._detector.detect_emotions(frame, [faces], features)[0]
+
+        detected_emotion = FEAT_EMOTION_COLUMNS[np.argmax(detected_emotions[0])]
+        if detected_emotion not in PYFEAT_EMOTIONS_TO_EMOTIONS.keys():
+            detected_emotion = "neutral"
+        predicted_emotion = PYFEAT_EMOTIONS_TO_EMOTIONS[detected_emotion]
 
-        return predicted_emotions[0]
+        return predicted_emotion

botender/perception/detectors/facial_expression_detector.py

@@ -1,6 +1,6 @@
 import numpy as np
 from feat import Detector  # type: ignore
-from pandas import DataFrame
+from typing import Tuple
 
 from botender.webcam_processor import Rectangle
 
@@ -11,10 +11,10 @@ class FacialExpressionDetector:
 
     _detector: Detector
     _faces: list[tuple[float, float, float, float, float]]
-    _features: DataFrame
+    _features: list
 
-    def __init__(self, device: str = "cpu"):
-        self._detector = Detector(device=device)
+    def __init__(self, detector: Detector):
+        self._detector = detector
 
     def detect_faces(self, frame) -> list[Rectangle]:
         """Detects faces in a frame and returns a list of rectangles representing the
@@ -23,14 +23,14 @@ def detect_faces(self, frame) -> list[Rectangle]:
         self._faces = self._detector.detect_faces(frame)[0]
         return [((x1, y1), (x2, y2)) for x1, y1, x2, y2, _ in self._faces]
 
-    def extract_features(self, frame: np.ndarray) -> DataFrame:
+    def extract_features(self, frame: np.ndarray) -> Tuple[list, list]:
         """Extracts features from the faces detected in the last frame and returns them
-        as a DataFrame."""
+        as a list. Returns additionally a list of the faces that were used to extract."""
+
         faces = self._faces
         if len(faces) == 0:
-            return DataFrame()
+            return ([], faces)
 
         landmarks = self._detector.detect_landmarks(frame, [faces])
-        aus = self._detector.detect_aus(frame, landmarks)
 
-        return aus
+        return (landmarks, faces)