record screen, age, chopped formula, final?

analyzers/aesthetic_analyzer.py

@@ -53,12 +53,12 @@ from typing import Any
 
 
 # How much weight the learned beauty regressor gets when both signals
-# are available. 0.8 means the SCUT-FBP5500 ResNet-50 dominates the
-# chopped score — rule factors contribute the remaining 20% as
-# refinement, not as primary driver. The trained model has actual
-# learned signal from 60-rater-averaged ground truth, so trusting it
-# more than hand-tuned penalties is the right default.
-LEARNED_WEIGHT = 0.8
+# are available. 0.85 means the SCUT-FBP5500 ResNet-50 strongly
+# dominates the chopped score — rule factors contribute 15% as a
+# refinement layer rather than a primary driver. The trained model
+# learned from 60-rater-averaged human ground truth, which is a much
+# better signal than any hand-tuned heuristic.
+LEARNED_WEIGHT = 0.85
 
 # Baseline score. Penalties push up, bonuses pull down.
 BASELINE = 50.0
@@ -153,10 +153,12 @@ class AestheticAnalyzer:
         # ── Penalties (push score up = more chopped) ─────────────────
 
         # Facial asymmetry: 0 = perfectly symmetric, 1 = very asymmetric.
-        # MediaPipe `facial_asymmetry_score` is already in this range.
+        # MediaPipe's score is noisier than we'd like — attractive faces
+        # still come back with measurable asymmetry from natural
+        # micro-expressions and camera angle. De-emphasised from ×30.
         asym = d.get("facial_asymmetry_score")
         if isinstance(asym, (int, float)):
-            penalty = float(asym) * 30.0   # was 18; bigger asymmetric → more spread
+            penalty = float(asym) * 18.0
             score += penalty
             breakdown["asymmetry_penalty"] = round(penalty, 2)
 
@@ -170,13 +172,15 @@ class AestheticAnalyzer:
             score += penalty
             breakdown["wrinkle_penalty"] = penalty
 
-        # Skin uniformity = LAB L* std-dev over the eroded interior
-        # face mask. Higher std means uneven tone (shadows, blemishes).
+        # Skin uniformity = LAB L* std-dev over the eroded interior face
+        # mask. Higher std means uneven tone (shadows, blemishes).
+        # De-emphasised: the metric over-penalises attractive faces in
+        # warm/directional lighting, which is most photos.
         uniformity = d.get("skin_uniformity")
         if isinstance(uniformity, (int, float)) and uniformity > 0:
-            # Empirically uniformity sits ~8-15 in clean skin and
-            # 20-30 in uneven skin; scale up to +14 (was 8).
-            penalty = min(14.0, max(0.0, (float(uniformity) - 10.0) * 1.0))
+            # Empirically uniformity sits ~8-15 in clean skin and 20-30
+            # in uneven skin. Cap reduced from 14 to 9.
+            penalty = min(9.0, max(0.0, (float(uniformity) - 10.0) * 0.7))
             score += penalty
             breakdown["skin_unevenness_penalty"] = round(penalty, 2)
 
@@ -184,9 +188,11 @@ class AestheticAnalyzer:
         # detector was too noisy (shadows / pores counted as spots).
 
         # Smile asymmetry: 0 = perfectly symmetric smile, larger = lopsided.
+        # De-emphasised — even attractive faces have natural smile
+        # asymmetry, and the MediaPipe blendshape signal exaggerates it.
         smile_asym = d.get("smile_asymmetry")
         if isinstance(smile_asym, (int, float)):
-            penalty = min(10.0, float(smile_asym) * 50.0)  # was max 6, factor 30
+            penalty = min(6.0, float(smile_asym) * 30.0)
             score += penalty
             breakdown["smile_asymmetry_penalty"] = round(penalty, 2)
 
@@ -205,17 +211,43 @@ class AestheticAnalyzer:
 
         # ── Bonuses (pull score down = less chopped) ─────────────────
 
-        # Defined jawline. Two signals (string bucket + numeric angle);
-        # take the stronger of the two contributions.
-        jaw_bonus = 0.0
+        # Defined jawline. EMPHASISED — strong jawline is one of the
+        # most consistent visual cues for "conventionally attractive."
+        # Two signals combine here:
+        #
+        #   (a) The MediaPipe `jawline_type` bucket gives a coarse
+        #       qualitative read.
+        #   (b) The numeric `jawline_angle` (degrees subtended at the
+        #       chin by the two gonion landmarks) gives a continuous
+        #       signal where lower = sharper. We map it linearly into
+        #       a bonus that maxes out at very sharp angles and fades
+        #       to zero by ~145°.
+        #
+        # We take whichever signal is more generous so the cue isn't
+        # double-counted on a single face. Numeric bonus scales as:
+        #
+        #   angle ≤  95°  →  -22  (very sharp)
+        #   angle  95-145 →  linearly -22 → 0
+        #   angle ≥ 145°  →  0   (very soft)
+        jaw_bucket_bonus = 0.0
         jaw_type = d.get("jawline_type")
         jaw_type_bonus_map = {"sharp": -16.0, "strong": -10.0, "soft": 0.0}
         if jaw_type in jaw_type_bonus_map:
-            jaw_bonus = jaw_type_bonus_map[jaw_type]
+            jaw_bucket_bonus = jaw_type_bonus_map[jaw_type]
+
+        jaw_angle_bonus = 0.0
         jaw_angle = d.get("jawline_angle")
-        if isinstance(jaw_angle, (int, float)) and jaw_angle < 115:
-            # Sharp angles add more on top of the categorical signal.
-            jaw_bonus = min(jaw_bonus, -16.0)
+        if isinstance(jaw_angle, (int, float)):
+            if jaw_angle <= 95:
+                jaw_angle_bonus = -22.0
+            elif jaw_angle < 145:
+                # Linear ramp from -22 at 95° to 0 at 145°.
+                jaw_angle_bonus = -22.0 * (145 - jaw_angle) / 50.0
+            # else stays 0
+
+        # Use whichever bonus is more pronounced (smaller / more
+        # negative number = bigger bonus).
+        jaw_bonus = min(jaw_bucket_bonus, jaw_angle_bonus)
         if jaw_bonus:
             score += jaw_bonus
             breakdown["jaw_definition_bonus"] = round(jaw_bonus, 2)

analyzers/age_analyzer.py

@@ -0,0 +1,135 @@
+"""
+AgeAnalyzer — FairFace age classifier with softmax-weighted estimate.
+
+Model
+-----
+- HF repo  : dima806/fairface_age_image_detection
+- Arch     : Vision Transformer (ViT-B/16)
+- Trained  : FairFace dataset (race-balanced)
+- Reported : ~59% top-1 accuracy across 9 age buckets
+- License  : Apache 2.0
+
+Why this and not InsightFace's bundled genderage head
+-----------------------------------------------------
+InsightFace's age regression head systematically over-predicts for
+certain face types — strong jaw, brow ridge, beard shadow, or just
+poor lighting can make it call a 20-year-old "52". Piecewise
+calibration helps with mild overshoot but can't recover when the
+raw prediction is already 50+ years off.
+
+FairFace uses softmax classification across 9 age buckets. Even when
+wrong it's wrong by ~5-10 years, not 30+. We take the softmax-weighted
+expected value across all buckets to get a smooth continuous number
+that moves with confidence — rather than always snapping to a fixed
+bucket midpoint.
+
+Inputs
+------
+img_rgb : np.ndarray (H, W, 3) uint8. Typically a face crop produced
+          by `_crop_to_face` in app.py.
+
+Outputs (dict)
+--------------
+age_estimate     : softmax-weighted expected age (float, years)
+age_range        : argmax bucket as a string (e.g. "20-29")
+age_confidence   : argmax softmax score
+age_distribution : full {bucket: prob} dict over all 9 buckets
+"""
+
+from typing import Any
+
+from PIL import Image
+from transformers import pipeline
+
+
+MODEL_ID = "dima806/fairface_age_image_detection"
+
+AGE_LABELS = [
+    "0-2", "3-9", "10-19", "20-29", "30-39",
+    "40-49", "50-59", "60-69", "70+",
+]
+
+# Midpoint per bucket; used to compute the softmax-weighted expected
+# age. The 70+ bucket midpoint is a guess — there's no upper bound in
+# the FairFace label space.
+AGE_MIDPOINTS = {
+    "0-2": 1.0,
+    "3-9": 6.0,
+    "10-19": 14.5,
+    "20-29": 24.5,
+    "30-39": 34.5,
+    "40-49": 44.5,
+    "50-59": 54.5,
+    "60-69": 64.5,
+    "70+": 75.0,
+}
+
+
+class AgeAnalyzer:
+    def __init__(self):
+        self.classifier = None
+        try:
+            self.classifier = pipeline("image-classification", model=MODEL_ID)
+        except Exception as exc:
+            print(f"[AgeAnalyzer] Failed to load {MODEL_ID}: {exc}")
+
+    def analyze(self, img_rgb) -> dict[str, Any]:
+        if self.classifier is None:
+            return self._empty_result()
+
+        try:
+            pil = Image.fromarray(img_rgb)
+            # Pull all 9 buckets so we can compute the weighted estimate.
+            preds = self.classifier(pil, top_k=len(AGE_LABELS))
+        except Exception as exc:
+            print(f"[AgeAnalyzer] Prediction failed: {exc}")
+            return self._empty_result()
+
+        if not preds:
+            return self._empty_result()
+
+        # Normalise label casing and build the {bucket: prob} dict.
+        distribution = {label: 0.0 for label in AGE_LABELS}
+        for pred in preds:
+            label = self._normalize_label(pred["label"])
+            if label in distribution:
+                distribution[label] = round(float(pred["score"]), 3)
+
+        # Softmax-weighted expected age. Sum over (midpoint × prob).
+        # Lets the number slide between buckets when the model is
+        # uncertain — e.g. 80% confident 20-29, 20% 30-39 → ~26.5
+        # instead of snapping to either bucket's midpoint.
+        total_weight = sum(distribution.values()) or 1.0
+        weighted_age = sum(
+            AGE_MIDPOINTS[label] * prob
+            for label, prob in distribution.items()
+        ) / total_weight
+
+        # Argmax bucket = the model's top guess; report that as
+        # `age_range` for legacy UI compatibility.
+        top = max(distribution.items(), key=lambda kv: kv[1])
+        top_label, top_score = top
+
+        return {
+            "age_estimate": round(float(weighted_age), 1),
+            "age_range": top_label,
+            "age_confidence": round(float(top_score), 3),
+            "age_distribution": distribution,
+        }
+
+    @staticmethod
+    def _normalize_label(label: str) -> str:
+        """Map model output to canonical AGE_LABELS entry."""
+        normalized = label.strip().lower()
+        if normalized == "more than 70":
+            return "70+"
+        return label if label in AGE_LABELS else label.strip()
+
+    @staticmethod
+    def _empty_result() -> dict[str, Any]:
+        return {
+            "age_estimate": 0.0,
+            "age_range": "unknown",
+            "age_confidence": 0.0,
+            "age_distribution": {label: 0.0 for label in AGE_LABELS},
+        }

analyzers/insightface_analyzer.py

@@ -1,30 +1,20 @@
 """
-InsightFaceAnalyzer — face detection + ArcFace recognition + age.
+InsightFaceAnalyzer — face detection + ArcFace recognition embedding.
 
 Model
 -----
 - Package    : `insightface` (https://github.com/deepinsight/insightface)
 - Bundle     : buffalo_l (ResNet50@WebFace600K backbone, ONNX)
-- Used here  : SCRFD-10GF detector, ArcFace 512-d recognition, 106 2D
-               landmarks, and the bundled `genderage.onnx` age head
-               (calibrated piecewise — see below). Gender from
-               buffalo_l is intentionally NOT exposed; FairFace ViT
-               handles gender so we can get a real softmax confidence.
+- Used here  : SCRFD-10GF detector + ArcFace 512-d recognition + 106
+               2D landmarks. The bundle ALSO ships a genderage head,
+               but we ignore it: it routinely calls 20-year-olds "52"
+               and no calibration trick reliably undoes that drift.
+               Age comes from FairFace ViT (AgeAnalyzer), gender from
+               FairFace ViT (GenderAnalyzer).
 - Size       : ~280 MB (ONNX, mixed FP16/FP32)
 - License    : weights research-only; code Apache 2.0
 - Source     : https://github.com/deepinsight/insightface/tree/master/python-package
 
-Age calibration
----------------
-InsightFace's `genderage` head was trained on a dataset that skews
-adult-heavy, so it systematically overshoots young faces by 6-10 years
-while being roughly accurate for older adults. A flat offset (which is
-what we tried first) helps the old end and hurts the young end. We
-apply a piecewise subtractive correction instead — heavy for predicted
-ages under 30, lighter for 30-50, and none for 50+. Tune via
-`AGE_OFFSET_YOUNG`, `AGE_OFFSET_MID` env vars if your population
-skews differently from ours.
-
 Inputs
 ------
 img_rgb : np.ndarray (H, W, 3) uint8
@@ -34,20 +24,14 @@ Outputs (dict)
 face_bbox            : [x1, y1, x2, y2] in pixel coordinates
 face_confidence      : SCRFD detection score
 face_embedding       : list[float] of length 512 (ArcFace, L2-normalised)
-age_estimate         : calibrated age in years (float)
-age_range            : string bucket for legacy UI compatibility
-age_confidence       : 1.0 — InsightFace's head is regression-only
 _insight_landmarks_2d : 106 2D points (internal, stripped from JSON)
 
 Accuracy
 --------
 - Recognition (ArcFace via buffalo_l): 99.83% LFW, 96.21% IJB-B FAR=1e-4.
 - Detection (SCRFD-10GF): >99% recall on WIDER FACE easy / medium.
-- Age (informal): ~5 yr MAE after piecewise calibration. No published
-  benchmark from InsightFace for buffalo_l's age head specifically.
 """
 
-import os
 from typing import Any
 
 import numpy as np
@@ -63,38 +47,6 @@ except ImportError:
 
 MODEL_NAME = "buffalo_l"
 
-# Piecewise age calibration. The genderage head over-predicts young
-# adults heavily and older adults barely. Override at runtime if the
-# default offsets don't match your user population.
-AGE_OFFSET_YOUNG = float(os.environ.get("AGE_OFFSET_YOUNG", "6"))   # raw < 30
-AGE_OFFSET_MID = float(os.environ.get("AGE_OFFSET_MID", "3"))      # 30 ≤ raw < 50
-AGE_OFFSET_OLD = float(os.environ.get("AGE_OFFSET_OLD", "0"))      # raw ≥ 50
-
-# Same legacy bucket schema as before so UI rows showing `age_range`
-# render whatever the source.
-AGE_BUCKETS = [
-    (0, 3, "0-2"), (3, 10, "3-9"), (10, 20, "10-19"),
-    (20, 30, "20-29"), (30, 40, "30-39"), (40, 50, "40-49"),
-    (50, 60, "50-59"), (60, 70, "60-69"), (70, 200, "70+"),
-]
-
-
-def _calibrate_age(raw: float) -> float:
-    """Piecewise calibration on InsightFace's raw age regression.
-
-    Worked examples (with defaults 6 / 3 / 0):
-        raw 28  →  22   (a 20-yr-old often comes back as 28 raw)
-        raw 35  →  32
-        raw 55  →  55   (no correction, model is already fine here)
-    """
-    if raw < 30:
-        offset = AGE_OFFSET_YOUNG
-    elif raw < 50:
-        offset = AGE_OFFSET_MID
-    else:
-        offset = AGE_OFFSET_OLD
-    return max(1.0, raw - offset)
-
 
 class InsightFaceAnalyzer:
     def __init__(self):
@@ -102,7 +54,7 @@ class InsightFaceAnalyzer:
         if not HAS_INSIGHTFACE:
             print(
                 "[InsightFaceAnalyzer] insightface package not installed; "
-                "detection, age, and recognition will be unavailable."
+                "face detection and recognition will be unavailable."
             )
             return
 
@@ -148,18 +100,10 @@ class InsightFaceAnalyzer:
             else None
         )
 
-        # Age — read raw genderage output, then piecewise calibrate.
-        raw_age = float(getattr(face, "age", 0.0))
-        age = _calibrate_age(raw_age)
-
         return {
             "face_bbox": bbox,
             "face_confidence": round(float(face.det_score), 3),
             "face_embedding": embedding,
-            "age_estimate": round(age, 1),
-            "age_raw": round(raw_age, 1),   # for debugging the calibration
-            "age_range": self._bucket_age(age),
-            "age_confidence": 1.0,
             # 106 2D landmarks (forehead, jaw, brows, eyes, nose, lips).
             # Underscore-prefixed → stripped from JSON, available to
             # downstream analyzers that want tighter face geometry.
@@ -170,22 +114,11 @@ class InsightFaceAnalyzer:
             ),
         }
 
-    @staticmethod
-    def _bucket_age(age: float) -> str:
-        for lo, hi, label in AGE_BUCKETS:
-            if lo <= age < hi:
-                return label
-        return "unknown"
-
     @staticmethod
     def _empty_result() -> dict[str, Any]:
         return {
             "face_bbox": None,
             "face_confidence": 0.0,
             "face_embedding": None,
-            "age_estimate": 0.0,
-            "age_raw": 0.0,
-            "age_range": "unknown",
-            "age_confidence": 0.0,
             "_insight_landmarks_2d": None,
         }

app.py

@@ -11,19 +11,23 @@ Pipeline (in execution order)
 -----------------------------
 1.  InsightFaceAnalyzer        InsightFace buffalo_l (ONNX). SCRFD
                                detection + ArcFace 512-d embedding +
-                               106 landmarks + piecewise-calibrated age.
-                               Gender delegated to FairFace (step 3a)
-                               so we get a real softmax confidence.
+                               106 landmarks. Age & gender delegated
+                               to FairFace ViTs (steps 3a / 3b).
 
 2.  LandmarkAnalyzer           MediaPipe Face Landmarker. 478 3D
                                landmarks + 52 ARKit blendshapes →
                                geometric features, smiling, mouth_open.
 
-3a. GenderAnalyzer             FairFace ViT (~93.4% acc). Replaces the
+3a. AgeAnalyzer                FairFace ViT, softmax-weighted across 9
+                               age buckets. Replaces the InsightFace
+                               age regression which routinely missed
+                               by 30+ years on certain face types.
+
+3b. GenderAnalyzer             FairFace ViT (~93.4% acc). Replaces the
                                InsightFace gender head so we get a real
                                softmax confidence instead of argmax 1.0.
 
-3b. EthnicityAnalyzer          cledoux42/Ethnicity_Test_v003 ViT.
+3c. EthnicityAnalyzer          cledoux42/Ethnicity_Test_v003 ViT.
                                5-class ethnicity widened to a 7-bucket
                                schema for legacy compatibility.
 
@@ -94,6 +98,7 @@ from analyzers.color_analyzer import ColorAnalyzer
 from analyzers.obstruction_analyzer import ObstructionAnalyzer
 from analyzers.hair_type_analyzer import HairTypeAnalyzer
 from analyzers.insightface_analyzer import InsightFaceAnalyzer
+from analyzers.age_analyzer import AgeAnalyzer
 from analyzers.gender_analyzer import GenderAnalyzer
 from analyzers.beauty_analyzer import BeautyAnalyzer
 from analyzers.aesthetic_analyzer import AestheticAnalyzer
@@ -115,6 +120,7 @@ app.add_middleware(
 # model-load cost; subsequent requests are warm.
 insightface_analyzer: Optional[InsightFaceAnalyzer] = None
 landmark_analyzer: Optional[LandmarkAnalyzer] = None
+age_analyzer: Optional[AgeAnalyzer] = None
 gender_analyzer: Optional[GenderAnalyzer] = None
 ethnicity_analyzer: Optional[EthnicityAnalyzer] = None
 parsing_analyzer: Optional[ParsingAnalyzer] = None
@@ -156,7 +162,7 @@ def get_analyzers():
     requests are warm.
     """
     global insightface_analyzer, landmark_analyzer
-    global gender_analyzer, ethnicity_analyzer
+    global age_analyzer, gender_analyzer, ethnicity_analyzer
     global parsing_analyzer, emotion_analyzer, color_analyzer
     global obstruction_analyzer, hair_type_analyzer
     global beauty_analyzer, aesthetic_analyzer
@@ -169,6 +175,10 @@ def get_analyzers():
         logger.info("Loading MediaPipe Face Landmarker...")
         landmark_analyzer = LandmarkAnalyzer()
 
+    if age_analyzer is None:
+        logger.info("Loading FairFace age analyzer...")
+        age_analyzer = AgeAnalyzer()
+
     if gender_analyzer is None:
         logger.info("Loading FairFace gender analyzer...")
         gender_analyzer = GenderAnalyzer()
@@ -206,6 +216,7 @@ def get_analyzers():
     return (
         insightface_analyzer,
         landmark_analyzer,
+        age_analyzer,
         gender_analyzer,
         ethnicity_analyzer,
         parsing_analyzer,
@@ -259,6 +270,7 @@ def _run_pipeline(img_array: np.ndarray) -> dict:
     (
         insight,
         landmarks,
+        ages,
         genders,
         ethnicities,
         parsing,
@@ -272,9 +284,10 @@ def _run_pipeline(img_array: np.ndarray) -> dict:
 
     results: dict = {}
 
-    # Step 1: InsightFace — detection, ArcFace recognition embedding,
-    # 106 landmarks, and piecewise-calibrated age. Gender is delegated
-    # to FairFace (step 3a) for a real softmax confidence.
+    # Step 1: InsightFace — detection + ArcFace 512-d recognition
+    # embedding + 106 landmarks. Age and gender both delegated to
+    # FairFace ViTs in step 3 because the bundled genderage head was
+    # too inaccurate (called 20-yr-olds "52" in real photos).
     logger.info("Running InsightFace analysis...")
     insight_results = insight.analyze(img_array)
     results.update(insight_results)
@@ -291,12 +304,19 @@ def _run_pipeline(img_array: np.ndarray) -> dict:
     landmark_results = landmarks.analyze(img_array)
     results.update(landmark_results)
 
-    # Step 3a: FairFace gender. Provides a real softmax confidence
+    # Step 3a: FairFace age. Softmax-weighted estimate across 9
+    # buckets — slides between bucket midpoints when the model is
+    # uncertain instead of snapping. Much more reliable than
+    # InsightFace's regression head on younger faces.
+    logger.info("Running FairFace age analysis...")
+    results.update(ages.analyze(face_crop))
+
+    # Step 3b: FairFace gender. Provides a real softmax confidence
     # score so the UI can show graded uncertainty.
     logger.info("Running FairFace gender analysis...")
     results.update(genders.analyze(face_crop))
 
-    # Step 3b: ethnicity classifier — likes a tighter face crop.
+    # Step 3c: ethnicity classifier — likes a tighter face crop.
     logger.info("Running ethnicity analysis...")
     results.update(ethnicities.analyze(face_crop))