attributes and skin features

analyzers/attribute_analyzer.py

@@ -1,15 +1,23 @@
 """
-Pretrained CLIP-based face attribute classification.
-
-The old implementation tried to download unavailable CelebA weights and then
-fell back to random predictions. This version uses a public zero-shot CLIP
-model so the output is deterministic and grounded in pretrained weights.
+CLIP zero-shot attribute classification.
+
+Previous version put all ~70 candidate labels into a single zero-shot pipeline
+call, which applied one softmax across every label at once. That meant each
+binary pair ("wearing earrings" vs "not wearing earrings") received ~1/70 of
+the probability mass and the comparison between positive and negative was
+essentially noise — hence the hallucinated accessories.
+
+This version encodes the image once with CLIPModel.get_image_features, then
+runs a fresh 2-way softmax per binary pair. Group labels (hair color,
+hair texture) get their own N-way softmax. All scores are now independent
+of how many other labels we happen to be asking about.
 """
 
 from typing import Any
 
+import torch
 from PIL import Image
-from transformers import pipeline
+from transformers import CLIPModel, CLIPProcessor
 
 
 CLIP_MODEL_ID = "openai/clip-vit-base-patch32"
@@ -51,114 +59,117 @@ PAIRS = {
 HAIR_COLOR_LABELS = ["black hair", "blond hair", "brown hair", "gray hair"]
 HAIR_TEXTURE_LABELS = ["straight hair", "wavy hair", "curly hair"]
 
+# Some pairs default to False unless CLIP is confidently past this threshold.
+# Stops borderline cases from being flipped to True on a 51/49 split.
+ACCESSORY_THRESHOLD = 0.65
+ACCESSORY_KEYS = {
+    "wearing_earrings", "wearing_necklace", "wearing_necktie", "wearing_hat",
+    "heavy_makeup", "wearing_lipstick",
+}
+
+
+def _prompt(text: str) -> str:
+    return f"a photo of {text}"
+
 
 class AttributeAnalyzer:
     def __init__(self):
-        self.classifier = self._load_classifier()
-
-    @staticmethod
-    def _load_classifier():
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = None
+        self.processor = None
         try:
-            return pipeline("zero-shot-image-classification", model=CLIP_MODEL_ID)
+            self.model = CLIPModel.from_pretrained(CLIP_MODEL_ID).to(self.device).eval()
+            self.processor = CLIPProcessor.from_pretrained(CLIP_MODEL_ID)
         except Exception as exc:
-            print(f"[AttributeAnalyzer] Failed to load CLIP classifier: {exc}")
-            return None
+            print(f"[AttributeAnalyzer] Failed to load CLIP: {exc}")
 
+    @torch.no_grad()
     def analyze(self, img_rgb) -> dict[str, Any]:
-        pil = Image.fromarray(img_rgb)
-
-        candidate_labels = []
-        for positive, negative in PAIRS.values():
-            candidate_labels.extend([positive, negative])
-        candidate_labels.extend(HAIR_COLOR_LABELS)
-        candidate_labels.extend(HAIR_TEXTURE_LABELS)
-
-        if self.classifier is None:
+        if self.model is None or self.processor is None:
             return self._empty_result()
 
-        try:
-            predictions = self.classifier(
-                pil,
-                candidate_labels=candidate_labels,
-                hypothesis_template="a photo of {}",
-            )
-        except Exception as exc:
-            print(f"[AttributeAnalyzer] Prediction failed: {exc}")
-            return self._empty_result()
-        score_map = {item["label"]: float(item["score"]) for item in predictions}
-
-        result: dict[str, Any] = {"_celeba_raw": {k: round(v, 3) for k, v in score_map.items()}}
-
-        def pair_score(key: str) -> tuple[bool, float]:
-            positive, negative = PAIRS[key]
-            positive_score = score_map.get(positive, 0.0)
-            negative_score = score_map.get(negative, 0.0)
-            return positive_score >= negative_score, round(positive_score, 3)
-
-        hair_color = max(HAIR_COLOR_LABELS, key=lambda label: score_map.get(label, 0.0))
-        hair_texture = max(HAIR_TEXTURE_LABELS, key=lambda label: score_map.get(label, 0.0))
+        pil = Image.fromarray(img_rgb)
 
-        result["hair_color_celeba"] = hair_color.split()[0]
-        result["hair_color_scores"] = {
-            label.split()[0]: round(score_map.get(label, 0.0), 3)
-            for label in HAIR_COLOR_LABELS
+        # Encode image once.
+        image_inputs = self.processor(images=pil, return_tensors="pt").to(self.device)
+        image_features = self.model.get_image_features(**image_inputs)
+        image_features = image_features / image_features.norm(dim=-1, keepdim=True)
+
+        # Per-pair scoring: each pair gets its own independent 2-way softmax.
+        pair_scores: dict[str, float] = {}
+        for key, (positive, negative) in PAIRS.items():
+            prompts = [_prompt(positive), _prompt(negative)]
+            pair_scores[key] = self._softmax_positive(image_features, prompts)
+
+        # Group scoring (N-way softmax within each group).
+        color_scores = self._group_softmax(
+            image_features, [_prompt(x) for x in HAIR_COLOR_LABELS]
+        )
+        texture_scores = self._group_softmax(
+            image_features, [_prompt(x) for x in HAIR_TEXTURE_LABELS]
+        )
+
+        hair_color_name = HAIR_COLOR_LABELS[int(torch.argmax(torch.tensor(color_scores)))].split()[0]
+        hair_texture_name = HAIR_TEXTURE_LABELS[int(torch.argmax(torch.tensor(texture_scores)))].split()[0]
+
+        def flag(key: str) -> bool:
+            score = pair_scores.get(key, 0.0)
+            threshold = ACCESSORY_THRESHOLD if key in ACCESSORY_KEYS else 0.5
+            return score >= threshold
+
+        result: dict[str, Any] = {
+            "_celeba_raw": {k: round(v, 3) for k, v in pair_scores.items()},
+            "hair_color_celeba": hair_color_name,
+            "hair_color_scores": {
+                label.split()[0]: round(float(score), 3)
+                for label, score in zip(HAIR_COLOR_LABELS, color_scores)
+            },
+            "hair_texture_celeba": hair_texture_name,
         }
-        result["hair_texture_celeba"] = hair_texture.split()[0]
 
-        result["has_bangs"] = pair_score("has_bangs")[0]
-        result["is_bald"] = pair_score("is_bald")[0]
-        result["receding_hairline"] = pair_score("receding_hairline")[0]
+        for key in PAIRS:
+            result[key] = flag(key)
 
-        has_beard, beard_score = pair_score("has_beard")
-        result["has_beard"] = has_beard
+        beard_score = pair_scores.get("has_beard", 0.0)
         result["facial_hair"] = {
-            "5_o_clock_shadow": score_map.get("has a beard", 0.0) > 0.45,
-            "goatee": pair_score("goatee")[0],
-            "mustache": pair_score("mustache")[0],
-            "sideburns": pair_score("sideburns")[0],
-            "full_beard": has_beard and beard_score > 0.55,
+            "5_o_clock_shadow": 0.45 < beard_score < 0.7,
+            "goatee": flag("goatee"),
+            "mustache": flag("mustache"),
+            "sideburns": flag("sideburns"),
+            "full_beard": beard_score > 0.7,
         }
 
-        result["wearing_glasses"] = pair_score("wearing_glasses")[0]
-        result["wearing_earrings"] = pair_score("wearing_earrings")[0]
-        result["wearing_hat"] = pair_score("wearing_hat")[0]
-        result["wearing_necklace"] = pair_score("wearing_necklace")[0]
-        result["wearing_necktie"] = pair_score("wearing_necktie")[0]
-
-        result["heavy_makeup"] = pair_score("heavy_makeup")[0]
-        result["wearing_lipstick"] = pair_score("wearing_lipstick")[0]
-
-        result["big_nose"] = pair_score("big_nose")[0]
-        result["pointy_nose"] = pair_score("pointy_nose")[0]
-        result["big_lips"] = pair_score("big_lips")[0]
-        result["high_cheekbones"] = pair_score("high_cheekbones")[0]
-        result["oval_face_celeba"] = pair_score("oval_face_celeba")[0]
-        result["double_chin"] = pair_score("double_chin")[0]
-        result["chubby"] = pair_score("chubby")[0]
-        result["rosy_cheeks"] = pair_score("rosy_cheeks")[0]
-        result["bags_under_eyes"] = pair_score("bags_under_eyes")[0]
-        result["narrow_eyes"] = pair_score("narrow_eyes")[0]
-        result["arched_eyebrows"] = pair_score("arched_eyebrows")[0]
-        result["bushy_eyebrows"] = pair_score("bushy_eyebrows")[0]
-        result["pale_skin"] = pair_score("pale_skin")[0]
-        result["attractive"] = pair_score("attractive")[0]
-        result["young"] = pair_score("young")[0]
-        result["smiling_celeba"] = pair_score("smiling_celeba")[0]
-        result["mouth_open"] = pair_score("mouth_open")[0]
-
         return result
 
+    @torch.no_grad()
+    def _softmax_positive(self, image_features: torch.Tensor, prompts: list[str]) -> float:
+        text_inputs = self.processor(
+            text=prompts, return_tensors="pt", padding=True
+        ).to(self.device)
+        text_features = self.model.get_text_features(**text_inputs)
+        text_features = text_features / text_features.norm(dim=-1, keepdim=True)
+        logits = (image_features @ text_features.T) * self.model.logit_scale.exp()
+        probs = torch.softmax(logits, dim=-1)[0]
+        return float(probs[0])
+
+    @torch.no_grad()
+    def _group_softmax(self, image_features: torch.Tensor, prompts: list[str]) -> list[float]:
+        text_inputs = self.processor(
+            text=prompts, return_tensors="pt", padding=True
+        ).to(self.device)
+        text_features = self.model.get_text_features(**text_inputs)
+        text_features = text_features / text_features.norm(dim=-1, keepdim=True)
+        logits = (image_features @ text_features.T) * self.model.logit_scale.exp()
+        probs = torch.softmax(logits, dim=-1)[0]
+        return [float(p) for p in probs]
+
     @staticmethod
     def _empty_result() -> dict[str, Any]:
-        return {
+        base: dict[str, Any] = {
             "_celeba_raw": {},
             "hair_color_celeba": "unknown",
             "hair_color_scores": {"black": 0.0, "blond": 0.0, "brown": 0.0, "gray": 0.0},
             "hair_texture_celeba": "unknown",
-            "has_bangs": False,
-            "is_bald": False,
-            "receding_hairline": False,
-            "has_beard": False,
             "facial_hair": {
                 "5_o_clock_shadow": False,
                 "goatee": False,
@@ -166,28 +177,7 @@ class AttributeAnalyzer:
                 "sideburns": False,
                 "full_beard": False,
             },
-            "wearing_glasses": False,
-            "wearing_earrings": False,
-            "wearing_hat": False,
-            "wearing_necklace": False,
-            "wearing_necktie": False,
-            "heavy_makeup": False,
-            "wearing_lipstick": False,
-            "big_nose": False,
-            "pointy_nose": False,
-            "big_lips": False,
-            "high_cheekbones": False,
-            "oval_face_celeba": False,
-            "double_chin": False,
-            "chubby": False,
-            "rosy_cheeks": False,
-            "bags_under_eyes": False,
-            "narrow_eyes": False,
-            "arched_eyebrows": False,
-            "bushy_eyebrows": False,
-            "pale_skin": False,
-            "attractive": False,
-            "young": False,
-            "smiling_celeba": False,
-            "mouth_open": False,
         }
+        for key in PAIRS:
+            base[key] = False
+        return base

analyzers/demographic_analyzer.py

@@ -1,13 +1,13 @@
 """
 Public pretrained demographic classifiers.
 
-This replaces the broken private FairFace weight download with public HF models:
-- Age: dima806/fairface_age_image_detection
-- Gender: dima806/fairface_gender_image_detection
-- Race: NikhilJaddu/fairface-race-vit
+Models used (all public, with published accuracy):
+- Age:       dima806/fairface_age_image_detection   (~59% top-1 on FairFace age buckets)
+- Gender:    dima806/fairface_gender_image_detection (~93.4% on FairFace)
+- Ethnicity: cledoux42/Ethnicity_Test_v003          (ViT, 79.6% accuracy, macro-F1 0.797)
 
-The output remains compatible with the rest of the app, but predictions come
-from real pretrained weights instead of random fallback values.
+The ethnicity model replaces the former NikhilJaddu/fairface-race-vit checkpoint,
+which had no published performance metrics on the HF model card.
 """
 
 from typing import Any
@@ -18,10 +18,13 @@ from transformers import pipeline
 
 AGE_MODEL_ID = "dima806/fairface_age_image_detection"
 GENDER_MODEL_ID = "dima806/fairface_gender_image_detection"
-RACE_MODEL_ID = "NikhilJaddu/fairface-race-vit"
+RACE_MODEL_ID = "cledoux42/Ethnicity_Test_v003"
 
 AGE_LABELS = ["0-2", "3-9", "10-19", "20-29", "30-39", "40-49", "50-59", "60-69", "70+"]
 GENDER_LABELS = ["Male", "Female"]
+# cledoux42/Ethnicity_Test_v003 outputs 5 classes: african, asian, caucasian, hispanic, indian.
+# We keep the legacy 7-bucket schema internally so the rest of the app still works;
+# unseen buckets simply stay at 0.0 in the distribution.
 RACE_LABELS = ["White", "Black", "Latino_Hispanic", "East Asian", "Southeast Asian", "Indian", "Middle Eastern"]
 
 
@@ -97,6 +100,7 @@ class DemographicAnalyzer:
     def _normalize_race_label(label: str) -> str:
         normalized = label.strip().lower().replace("-", "_")
         race_aliases = {
+            # Original FairFace 7-class labels
             "white": "White",
             "black": "Black",
             "latino_hispanic": "Latino_Hispanic",
@@ -105,6 +109,11 @@ class DemographicAnalyzer:
             "southeast asian": "Southeast Asian",
             "indian": "Indian",
             "middle eastern": "Middle Eastern",
+            # cledoux42/Ethnicity_Test_v003 5-class labels → map into our schema
+            "african": "Black",
+            "asian": "East Asian",
+            "caucasian": "White",
+            "hispanic": "Latino_Hispanic",
         }
         return race_aliases.get(normalized, label)
 

analyzers/parsing_analyzer.py

@@ -1,171 +1,93 @@
 """
-BiSeNet — 19-class face parsing / segmentation.
-
-Segments the face into regions: skin, left/right eyebrow, left/right eye,
-nose, upper/lower lip, hair, hat, earring, necklace, neck, cloth, etc.
-
-From the segmentation masks we derive:
-- Hair presence and approximate length
-- Wearing glasses, hat, earrings (from mask presence)
-- Skin smoothness (wrinkle detection via edge density on skin mask)
-- Freckle/mole estimation (dark spots on skin mask)
-- Makeup presence indicators
-
-The masks (_skin_mask, _hair_mask) are also shared with color_analyzer
-for accurate pixel sampling.
+SegFormer-B5 human parsing — replaces the old jonathandinu/face-parsing loader.
+
+Model: matei-dorian/segformer-b5-finetuned-human-parsing
+  - Architecture: SegFormer-B5 (nvidia/mit-b5 backbone)
+  - Published metrics on its eval set:
+      • Mean IoU:       0.6258
+      • Mean accuracy:  0.7547
+      • Overall acc.:   0.8256
+      • Face:  acc 0.9094 / IoU 0.8294
+      • Hair:  acc 0.8974 / IoU 0.8171
+  - Outputs 18 classes (background, hat, hair, sunglasses, upper-clothes, skirt,
+    pants, dress, belt, left-shoe, right-shoe, face, left-leg, right-leg,
+    left-arm, right-arm, bag, scarf).
+
+We keep the same downstream contract as before: skin/hair/lip masks plus
+hair-length, accessory flags, wrinkle estimation, freckle/mole detection.
+The lip mask is approximated from the face region (no lip-specific class)
+and is mainly used as a fallback — MediaPipe lip landmarks are still the
+primary source for lip geometry/color in color_analyzer.
 """
 
-import os
 from typing import Any
 
 import cv2
 import numpy as np
 import torch
-import torch.nn as nn
-from huggingface_hub import hf_hub_download
 from PIL import Image
-from torchvision import transforms
+from transformers import (
+    SegformerForSemanticSegmentation,
+    SegformerImageProcessor,
+)
+
+MODEL_ID = "matei-dorian/segformer-b5-finetuned-human-parsing"
 
-# BiSeNet class labels (19 classes)
+# Official label map from the model card.
 PARSING_LABELS = {
     0: "background",
-    1: "skin",
-    2: "left_eyebrow",
-    3: "right_eyebrow",
-    4: "left_eye",
-    5: "right_eye",
-    6: "eyeglasses",
-    7: "left_ear",
-    8: "right_ear",
-    9: "earring",
-    10: "nose",
-    11: "mouth_interior",
-    12: "upper_lip",
-    13: "lower_lip",
-    14: "neck",
-    15: "necklace",
-    16: "cloth",
-    17: "hair",
-    18: "hat",
+    1: "hat",
+    2: "hair",
+    3: "sunglasses",
+    4: "upper_clothes",
+    5: "skirt",
+    6: "pants",
+    7: "dress",
+    8: "belt",
+    9: "left_shoe",
+    10: "right_shoe",
+    11: "face",
+    12: "left_leg",
+    13: "right_leg",
+    14: "left_arm",
+    15: "right_arm",
+    16: "bag",
+    17: "scarf",
 }
 
-BISENET_REPO = "jonathandinu/face-parsing"
-BISENET_FILE = "model.safetensors"
-
-TRANSFORM = transforms.Compose([
-    transforms.Resize((512, 512)),
-    transforms.ToTensor(),
-    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
-])
-
-
-# ── Lightweight BiSeNet Architecture ──────────────────────────────────
-# If the HuggingFace weights aren't available, we define a minimal
-# architecture. The actual weights determine accuracy.
-
-class ConvBNReLU(nn.Module):
-    def __init__(self, in_c, out_c, ks=3, stride=1, padding=1):
-        super().__init__()
-        self.conv = nn.Conv2d(in_c, out_c, ks, stride, padding, bias=False)
-        self.bn = nn.BatchNorm2d(out_c)
-        self.relu = nn.ReLU(inplace=True)
-
-    def forward(self, x):
-        return self.relu(self.bn(self.conv(x)))
-
-
-class BiSeNetMini(nn.Module):
-    """Minimal BiSeNet-like architecture for face parsing."""
-
-    def __init__(self, n_classes=19):
-        super().__init__()
-        # Simplified encoder
-        self.layer1 = nn.Sequential(
-            ConvBNReLU(3, 64, 7, 2, 3),
-            ConvBNReLU(64, 64),
-        )
-        self.layer2 = nn.Sequential(
-            ConvBNReLU(64, 128, 3, 2, 1),
-            ConvBNReLU(128, 128),
-        )
-        self.layer3 = nn.Sequential(
-            ConvBNReLU(128, 256, 3, 2, 1),
-            ConvBNReLU(256, 256),
-        )
-        self.layer4 = nn.Sequential(
-            ConvBNReLU(256, 512, 3, 2, 1),
-            ConvBNReLU(512, 512),
-        )
-        # Decoder
-        self.up4 = nn.ConvTranspose2d(512, 256, 2, stride=2)
-        self.dec4 = ConvBNReLU(512, 256)
-        self.up3 = nn.ConvTranspose2d(256, 128, 2, stride=2)
-        self.dec3 = ConvBNReLU(256, 128)
-        self.up2 = nn.ConvTranspose2d(128, 64, 2, stride=2)
-        self.dec2 = ConvBNReLU(128, 64)
-        self.up1 = nn.ConvTranspose2d(64, 64, 2, stride=2)
-        self.conv_out = nn.Conv2d(64, n_classes, 1)
-
-    def forward(self, x):
-        e1 = self.layer1(x)
-        e2 = self.layer2(e1)
-        e3 = self.layer3(e2)
-        e4 = self.layer4(e3)
-        d4 = self.dec4(torch.cat([self.up4(e4), e3], 1))
-        d3 = self.dec3(torch.cat([self.up3(d4), e2], 1))
-        d2 = self.dec2(torch.cat([self.up2(d3), e1], 1))
-        d1 = self.up1(d2)
-        return self.conv_out(d1)
-
 
 class ParsingAnalyzer:
     def __init__(self):
         self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-        self.model = self._load_model()
-
-    def _load_model(self) -> nn.Module:
-        model = BiSeNetMini(n_classes=19)
+        self.processor = None
+        self.model = None
         try:
-            weight_path = hf_hub_download(
-                repo_id=BISENET_REPO,
-                filename=BISENET_FILE,
-            )
-            # Try loading safetensors first, fall back to torch
-            try:
-                from safetensors.torch import load_file
-                state_dict = load_file(weight_path)
-            except ImportError:
-                state_dict = torch.load(weight_path, map_location=self.device, weights_only=True)
-
-            model.load_state_dict(state_dict, strict=False)
-        except Exception as e:
-            print(f"[ParsingAnalyzer] Could not load BiSeNet weights: {e}")
-            print("[ParsingAnalyzer] Falling back to random weights")
-
-        model.to(self.device).eval()
-        return model
+            self.processor = SegformerImageProcessor.from_pretrained(MODEL_ID)
+            self.model = SegformerForSemanticSegmentation.from_pretrained(MODEL_ID)
+            self.model.to(self.device).eval()
+        except Exception as exc:
+            print(f"[ParsingAnalyzer] Failed to load {MODEL_ID}: {exc}")
 
     def analyze(self, img_rgb: np.ndarray) -> dict[str, Any]:
         h, w = img_rgb.shape[:2]
+
+        if self.model is None or self.processor is None:
+            return self._empty_result(h, w)
+
         pil = Image.fromarray(img_rgb)
-        tensor = TRANSFORM(pil).unsqueeze(0).to(self.device)
+        inputs = self.processor(images=pil, return_tensors="pt").to(self.device)
 
         with torch.no_grad():
-            out = self.model(tensor)
-            if isinstance(out, tuple):
-                out = out[0]
+            logits = self.model(**inputs).logits  # (1, C, H/4, W/4)
 
-        # Resize parsing map to original image size
-        parsing = out.squeeze(0).cpu().numpy()
-        parsing = np.argmax(parsing, axis=0)  # (512, 512)
-        parsing = cv2.resize(
-            parsing.astype(np.uint8), (w, h), interpolation=cv2.INTER_NEAREST
+        upsampled = torch.nn.functional.interpolate(
+            logits, size=(h, w), mode="bilinear", align_corners=False
         )
+        parsing = upsampled.argmax(dim=1)[0].cpu().numpy().astype(np.uint8)
 
-        # Build individual masks
-        masks: dict[str, np.ndarray] = {}
-        for label_id, label_name in PARSING_LABELS.items():
-            masks[label_name] = (parsing == label_id)
+        masks: dict[str, np.ndarray] = {
+            name: (parsing == label_id) for label_id, name in PARSING_LABELS.items()
+        }
 
         total_pixels = h * w
         region_coverage = {
@@ -174,22 +96,20 @@ class ParsingAnalyzer:
             if name != "background"
         }
 
-        result: dict[str, Any] = {
-            "region_coverage": region_coverage,
-        }
+        result: dict[str, Any] = {"region_coverage": region_coverage}
 
-        # Pass masks for color analyzer
-        skin_mask = masks.get("skin", np.zeros((h, w), dtype=bool))
+        skin_mask = masks.get("face", np.zeros((h, w), dtype=bool))
         hair_mask = masks.get("hair", np.zeros((h, w), dtype=bool))
+        # No dedicated lip class; color_analyzer falls back to landmarks for lips.
+        lip_mask = np.zeros((h, w), dtype=bool)
+
         result["_skin_mask"] = skin_mask
         result["_hair_mask"] = hair_mask
-        lip_mask = masks.get("upper_lip", np.zeros((h, w), dtype=bool)) | \
-                   masks.get("lower_lip", np.zeros((h, w), dtype=bool))
         result["_lip_mask"] = lip_mask
 
         # ── Hair length estimation ───────────────────────────────────
-        hair_pixels = hair_mask.sum()
-        face_pixels = skin_mask.sum() + hair_pixels
+        hair_pixels = int(hair_mask.sum())
+        face_pixels = int(skin_mask.sum()) + hair_pixels
         hair_ratio = hair_pixels / face_pixels if face_pixels else 0
 
         if hair_ratio < 0.05:
@@ -204,18 +124,13 @@ class ParsingAnalyzer:
         result["hair_present"] = hair_ratio > 0.03
 
         # ── Accessories from segmentation ────────────────────────────
-        result["glasses_detected"] = region_coverage.get("eyeglasses", 0) > 0.005
+        result["glasses_detected"] = region_coverage.get("sunglasses", 0) > 0.005
         result["hat_detected"] = region_coverage.get("hat", 0) > 0.01
-        result["earring_detected"] = region_coverage.get("earring", 0) > 0.002
-        result["necklace_detected"] = region_coverage.get("necklace", 0) > 0.002
+        result["earring_detected"] = False  # no earring class in this model
+        result["necklace_detected"] = False  # no necklace class in this model
 
-        # ── Skin analysis on skin mask ───────────────────────────────
+        # ── Skin analysis on face mask ───────────────────────────────
         if skin_mask.sum() > 100:
-            skin_region = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
-            skin_region = skin_region.astype(float)
-            skin_region[~skin_mask] = np.nan
-
-            # Wrinkle estimation via Laplacian edge density
             skin_gray = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2GRAY)
             laplacian = cv2.Laplacian(skin_gray, cv2.CV_64F)
             skin_edges = np.abs(laplacian)
@@ -233,7 +148,6 @@ class ParsingAnalyzer:
 
             result["skin_texture_score"] = round(float(edge_density), 2)
 
-            # Freckle/mole estimation (dark spots)
             skin_lab = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2LAB)
             l_channel = skin_lab[:, :, 0].astype(float)
             l_channel[~skin_mask] = np.nan
@@ -247,9 +161,8 @@ class ParsingAnalyzer:
                 else "none"
             )
 
-            # Skin uniformity
             skin_l_values = l_channel[skin_mask]
-            result["skin_uniformity"] = round(float(np.std(skin_l_values)), 2)
+            result["skin_uniformity"] = round(float(np.nanstd(skin_l_values)), 2)
         else:
             result["wrinkle_level"] = "unknown"
             result["skin_texture_score"] = 0
@@ -257,3 +170,23 @@ class ParsingAnalyzer:
             result["skin_uniformity"] = 0
 
         return result
+
+    @staticmethod
+    def _empty_result(h: int, w: int) -> dict[str, Any]:
+        empty = np.zeros((h, w), dtype=bool)
+        return {
+            "region_coverage": {},
+            "_skin_mask": empty,
+            "_hair_mask": empty,
+            "_lip_mask": empty,
+            "hair_length": "unknown",
+            "hair_present": False,
+            "glasses_detected": False,
+            "hat_detected": False,
+            "earring_detected": False,
+            "necklace_detected": False,
+            "wrinkle_level": "unknown",
+            "skin_texture_score": 0,
+            "freckles_or_moles": "unknown",
+            "skin_uniformity": 0,
+        }

app.py

@@ -164,7 +164,7 @@ async def analyze_face(file: UploadFile = File(...)):
 
         # Step 4: BiSeNet → pixel segmentation → hair length, wrinkles, spots
         logger.info("Running face parsing...")
-        parse_results = parsing.analyze(img_bgr)
+        parse_results = parsing.analyze(img_array)
         results.update(parse_results)
 
         # Step 5: HSEmotion → emotion classification
@@ -234,7 +234,7 @@ async def analyze_face_base64(body: dict):
         attr_results = attributes.analyze(img_array)
         results.update(attr_results)
 
-        parse_results = parsing.analyze(img_bgr)
+        parse_results = parsing.analyze(img_array)
         results.update(parse_results)
 
         emo_results = emotions.analyze(img_array)