init

config.py

@@ -298,6 +298,8 @@ IMG_QUALITY = float(os.environ.get("IMG_QUALITY", 0.5))
 FACE_CONFIDENCE = float(os.environ.get("FACE_CONFIDENCE", 0.7))
 AGE_CONFIDENCE = float(os.environ.get("AGE_CONFIDENCE", 0.99))
 GENDER_CONFIDENCE = float(os.environ.get("GENDER_CONFIDENCE", 1.1))
+# 是否启用 DeepFace 的情绪识别（默认开启；关闭可减少推理耗时）
+DEEPFACE_EMOTION_ENABLED = os.environ.get("DEEPFACE_EMOTION_ENABLED", "true").lower() in ("1", "true", "on")
 UPSCALE_SIZE = int(os.environ.get("UPSCALE_SIZE", 2))
 SAVE_QUALITY = int(os.environ.get("SAVE_QUALITY", 85))
 REALESRGAN_MODEL = os.environ.get("REALESRGAN_MODEL", "realesr-general-x4v3")

face_analyzer.py

@@ -1,7 +1,7 @@
 import os
 import random
 import time
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 
 import cv2
 import numpy as np
@@ -485,7 +485,7 @@ class EnhancedFaceAnalyzer:
             raise e
 
     def _predict_age_emotion_with_deepface(
-        self, face_image: np.ndarray
+        self, face_image: np.ndarray, include_emotion: bool = True
     ) -> Dict[str, Any]:
         """使用DeepFace预测年龄、情绪（并返回可用的性别信息用于回退）"""
         if not DEEPFACE_AVAILABLE:
@@ -496,10 +496,11 @@ class EnhancedFaceAnalyzer:
             raise ValueError("无效的人脸图像")
 
         try:
+            actions = ["age", "gender", "emotion"] if include_emotion else ["age", "gender"]
             # DeepFace分析 - 禁用进度条和详细输出
             result = DeepFace.analyze(
                 img_path=face_image,
-                actions=["age", "emotion", "gender"],
+                actions=actions,
                 enforce_detection=False,
                 detector_backend="skip",
                 silent=True  # 禁用进度条输出
@@ -511,8 +512,12 @@ class EnhancedFaceAnalyzer:
 
             # 提取信息
             age = result.get("age", 25)
-            emotion = result.get("dominant_emotion", "neutral")
-            emotion_scores = result.get("emotion", {})
+            if include_emotion:
+                emotion = result.get("dominant_emotion", "neutral")
+                emotion_scores = result.get("emotion", {}) or {}
+            else:
+                emotion = "neutral"
+                emotion_scores = {"neutral": 100.0}
             # 性别信息（用于在HowCuteAmI置信度低时回退）
             deep_gender = result.get("dominant_gender", "Woman")
             deep_gender_conf = result.get("gender", {}).get(deep_gender, 50.0) / 100.0
@@ -576,6 +581,10 @@ class EnhancedFaceAnalyzer:
         # 使用HowCuteAmI预测颜值和性别
         beauty_gender_result = self._predict_beauty_gender_with_howcuteami(face)
 
+        # Hybrid 模式下可配置是否启用 DeepFace 情绪识别（默认启用）。
+        deepface_emotion_enabled = bool(getattr(config, "DEEPFACE_EMOTION_ENABLED", True))
+        age_emotion_result: Optional[Dict[str, Any]] = None
+
         # 首先获取HowCuteAmI的年龄/性别预测置信度
         howcuteami_age_confidence = beauty_gender_result.get("age_confidence", 0)
         gender_confidence = beauty_gender_result.get("gender_confidence", 0)
@@ -586,9 +595,9 @@ class EnhancedFaceAnalyzer:
         # 如果HowCuteAmI的年龄置信度低于阈值，则使用DeepFace的年龄
         agec = config.AGE_CONFIDENCE
         if howcuteami_age_confidence < agec:
-            # 使用DeepFace获取年龄/情绪（以及可选的性别回退信息）
+            # 需要 DeepFace 年龄时，仍调用 DeepFace（但可按开关选择是否同时跑 emotion）
             age_emotion_result = self._predict_age_emotion_with_deepface(
-                face_image
+                face_image, include_emotion=deepface_emotion_enabled
             )
             deep_age = age_emotion_result["age"]
             logger.info(
@@ -602,8 +611,8 @@ class EnhancedFaceAnalyzer:
                 "beauty_raw_score": beauty_gender_result["beauty_raw_score"],
                 "age": deep_age,
                 "age_confidence": age_emotion_result["age_confidence"],
-                "emotion": age_emotion_result["emotion"],
-                "emotion_analysis": age_emotion_result["emotion_analysis"],
+                "emotion": age_emotion_result.get("emotion") or "neutral",
+                "emotion_analysis": age_emotion_result.get("emotion_analysis") or {"neutral": 100.0},
                 "model_used": "hybrid_deepface_age",
                 "age_model_used": "DeepFace",
                 "gender_model_used": "HowCuteAmI",
@@ -613,6 +622,16 @@ class EnhancedFaceAnalyzer:
             logger.info(
                 f"HowCuteAmI age confidence ({howcuteami_age_confidence}) is high enough, value={age}; using HowCuteAmI for age prediction"
             )
+            # 情绪识别完全可选：关闭时直接返回默认值，避免多一次 DeepFace 推理。
+            if deepface_emotion_enabled:
+                age_emotion_result = self._predict_age_emotion_with_deepface(
+                    face_image, include_emotion=True
+                )
+                emotion = age_emotion_result.get("emotion") or "neutral"
+                emotion_analysis = age_emotion_result.get("emotion_analysis") or {"neutral": 100.0}
+            else:
+                emotion = "neutral"
+                emotion_analysis = {"neutral": 100.0}
             # 合并结果，保留HowCuteAmI的年龄预测
             result = {
                 "gender": beauty_gender_result["gender"],  # 先用HowCuteAmI，后面可能回退
@@ -621,8 +640,8 @@ class EnhancedFaceAnalyzer:
                 "beauty_raw_score": beauty_gender_result["beauty_raw_score"],
                 "age": beauty_gender_result["age"],
                 "age_confidence": beauty_gender_result["age_confidence"],
-                "emotion": None,
-                "emotion_analysis": None,
+                "emotion": emotion,
+                "emotion_analysis": emotion_analysis,
                 "model_used": "hybrid",
                 "age_model_used": "HowCuteAmI",
                 "gender_model_used": "HowCuteAmI",
@@ -632,8 +651,8 @@ class EnhancedFaceAnalyzer:
         try:
             how_gender = beauty_gender_result.get("gender")
             how_conf = float(beauty_gender_result.get("gender_confidence", 0) or 0)
-            deep_gender = age_emotion_result.get("gender")
-            deep_conf = float(age_emotion_result.get("gender_confidence", 0) or 0)
+            deep_gender = age_emotion_result.get("gender") if age_emotion_result else None
+            deep_conf = float(age_emotion_result.get("gender_confidence", 0) or 0) if age_emotion_result else 0.0
 
             final_gender = result.get("gender")
             final_conf = float(result.get("gender_confidence", 0) or 0)
@@ -714,10 +733,12 @@ class EnhancedFaceAnalyzer:
             raise ValueError("无效的人脸图像")
 
         try:
+            deepface_emotion_enabled = bool(getattr(config, "DEEPFACE_EMOTION_ENABLED", True))
+            actions = ["age", "gender", "emotion"] if deepface_emotion_enabled else ["age", "gender"]
             # DeepFace分析 - 禁用进度条和详细输出
             result = DeepFace.analyze(
                 img_path=face_image,
-                actions=["age", "gender", "emotion"],
+                actions=actions,
                 enforce_detection=False,
                 detector_backend="skip",
                 silent=True  # 禁用进度条输出
@@ -740,8 +761,12 @@ class EnhancedFaceAnalyzer:
                 gender = "Male"
 
             # DeepFace没有内置颜值评分，这里使用简单的启发式方法
-            emotion = result.get("dominant_emotion", "neutral")
-            emotion_scores = result.get("emotion", {})
+            if deepface_emotion_enabled:
+                emotion = result.get("dominant_emotion", "neutral")
+                emotion_scores = result.get("emotion", {}) or {}
+            else:
+                emotion = "neutral"
+                emotion_scores = {"neutral": 100.0}
 
             # 基于情绪和年龄的简单颜值估算
             happiness_score = emotion_scores.get("happy", 0) / 100
@@ -835,10 +860,10 @@ class EnhancedFaceAnalyzer:
                     )
                 elif model_type == ModelType.HOWCUTEAMI:
                     prediction_result = self._predict_with_howcuteami(face_resized)
-                    # 非混合模式也进行性别合并：引入DeepFace性别
+                    # 非混合模式也进行性别合并：引入DeepFace性别（不需要 emotion，减少耗时）
                     try:
                         age_emotion_result = self._predict_age_emotion_with_deepface(
-                            face_for_deepface
+                            face_for_deepface, include_emotion=False
                         )
                         how_gender = prediction_result.get("gender")
                         how_conf = float(prediction_result.get("gender_confidence", 0) or 0)
@@ -848,13 +873,17 @@ class EnhancedFaceAnalyzer:
                         final_conf = float(prediction_result.get("gender_confidence", 0) or 0)
                         if (str(how_gender) == "Female") or (str(deep_gender) == "Female"):
                             final_gender = "Female"
-                            final_conf = max(how_conf if how_gender == "Female" else 0,
-                                             deep_conf if deep_gender == "Female" else 0)
+                            final_conf = max(
+                                how_conf if how_gender == "Female" else 0,
+                                deep_conf if deep_gender == "Female" else 0,
+                            )
                             prediction_result["gender_model_used"] = "Combined(H+DF)"
                         elif (str(how_gender) == "Male") and (str(deep_gender) == "Male"):
                             final_gender = "Male"
-                            final_conf = max(how_conf if how_gender == "Male" else 0,
-                                             deep_conf if deep_gender == "Male" else 0)
+                            final_conf = max(
+                                how_conf if how_gender == "Male" else 0,
+                                deep_conf if deep_gender == "Male" else 0,
+                            )
                             prediction_result["gender_model_used"] = "Combined(H+DF)"
                         prediction_result["gender"] = final_gender
                         prediction_result["gender_confidence"] = round(float(final_conf), 4)
@@ -875,13 +904,17 @@ class EnhancedFaceAnalyzer:
                         final_conf = float(prediction_result.get("gender_confidence", 0) or 0)
                         if (str(how_gender) == "Female") or (str(deep_gender) == "Female"):
                             final_gender = "Female"
-                            final_conf = max(how_conf if how_gender == "Female" else 0,
-                                             deep_conf if deep_gender == "Female" else 0)
+                            final_conf = max(
+                                how_conf if how_gender == "Female" else 0,
+                                deep_conf if deep_gender == "Female" else 0,
+                            )
                             prediction_result["gender_model_used"] = "Combined(H+DF)"
                         elif (str(how_gender) == "Male") and (str(deep_gender) == "Male"):
                             final_gender = "Male"
-                            final_conf = max(how_conf if how_gender == "Male" else 0,
-                                             deep_conf if deep_gender == "Male" else 0)
+                            final_conf = max(
+                                how_conf if how_gender == "Male" else 0,
+                                deep_conf if deep_gender == "Male" else 0,
+                            )
                             prediction_result["gender_model_used"] = "Combined(H+DF)"
                         prediction_result["gender"] = final_gender
                         prediction_result["gender_confidence"] = round(float(final_conf), 4)
@@ -892,7 +925,9 @@ class EnhancedFaceAnalyzer:
                     prediction_result = self._predict_with_hybrid_model(
                         face_resized, face_for_deepface
                     )
-                    logger.warning(f"Model {model_type.value} is not available, using hybrid mode")
+                    logger.warning(
+                        f"Model {model_type.value} is not available, using hybrid mode"
+                    )
 
             except Exception as e:
                 logger.error(f"Prediction failed, using default values: {e}")
@@ -1016,8 +1051,8 @@ class EnhancedFaceAnalyzer:
                 "age_model_used": prediction_result.get("age_model_used", prediction_result.get("model_used", model_type.value)),
                 "beauty_score": prediction_result.get("beauty_score", 0),
                 "beauty_raw_score": prediction_result.get("beauty_raw_score", 0),
-                "emotion": prediction_result.get("emotion", "neutral"),
-                "emotion_analysis": prediction_result.get("emotion_analysis", {}),
+                "emotion": prediction_result.get("emotion") or "neutral",
+                "emotion_analysis": prediction_result.get("emotion_analysis") or {"neutral": 100.0},
                 # "facial_features": facial_features,  # 五官分析
                 "bounding_box": {
                     "x1": int(face_box[0]),
@@ -1054,12 +1089,13 @@ class EnhancedFaceAnalyzer:
             if DEEPFACE_AVAILABLE:
                 try:
                     import tempfile
+                    deepface_emotion_enabled = bool(getattr(config, "DEEPFACE_EMOTION_ENABLED", True))
                     with tempfile.NamedTemporaryFile(suffix='.webp', delete=False) as tmp_file:
                         cv2.imwrite(tmp_file.name, test_image, [cv2.IMWRITE_WEBP_QUALITY, 95])
                         # 预热DeepFace - 使用最小的actions集合
                         DeepFace.analyze(
                             img_path=tmp_file.name,
-                            actions=["age", "emotion", "gender"],
+                            actions=["age", "gender", "emotion"] if deepface_emotion_enabled else ["age", "gender"],
                             detector_backend="yolov8",
                             enforce_detection=False,
                             silent=True