Update app.py

app.py

@@ -42,34 +42,12 @@ PERSON_CLASS_SPECS: tuple[tuple[str, str, str, str], ...] = (
     ("man lying down", "person", "male", "person"),
     ("man taking a bath", "person", "male", "person"),
     ("young child", "person", "child", "person"),
-    ("child", "person", "child", "person"),
-    ("kid", "person", "child", "person"),
     ("baby", "person", "child", "person"),
     ("toddler", "person", "child", "person"),
-    ("preschool child", "person", "child", "person"),
-    ("school-age child", "person", "child", "person"),
-    ("young boy", "person", "child", "person"),
-    ("young girl", "person", "child", "person"),
     ("little girl", "person", "child", "person"),
     ("little boy", "person", "child", "person"),
 )
 
-# Non-human prompts are not moderation classes. They are visual counterevidence
-# used to stop a trophy, bottle, appliance, toy or package from becoming a
-# highly confident "female body" merely because it sits inside a broad person
-# box. The rejection rule below requires strong spatial and score agreement, so
-# a real person printed on product packaging is not discarded automatically.
-OBJECT_CLASS_SPECS: tuple[tuple[str, str, str, str], ...] = (
-    ("trophy", "object", "neutral", "trophy"),
-    ("gold trophy", "object", "neutral", "trophy"),
-    ("bottle", "object", "neutral", "bottle"),
-    ("product bottle", "object", "neutral", "bottle"),
-    ("product packaging", "object", "neutral", "packaging"),
-    ("box package", "object", "neutral", "packaging"),
-    ("appliance", "object", "neutral", "appliance"),
-    ("toy", "object", "neutral", "toy"),
-)
-
 PART_CONCEPTS = (
     "face",
     "head",
@@ -90,34 +68,34 @@ PART_CONCEPTS = (
     "foot",
 )
 
-OBJECT_GATED_CONCEPTS = {
-    "body",
-    "chest",
-    "torso",
-    "abdomen",
-    "midriff",
-    "stomach",
-    "waist",
-    "belly",
-    "arm",
-    "leg",
-    "thigh",
-}
-
-# Generic words such as "child" and "kid" raise recall, but the fallback age
-# consensus uses only visually specific age phrases. This prevents one weak
-# generic child response on adult hands or an object from changing the age.
 CHILD_CONSENSUS_LABELS = {
+    "young child",
     "baby",
     "toddler",
-    "preschool child",
-    "school-age child",
-    "young boy",
-    "young girl",
     "little boy",
     "little girl",
 }
 
+ANATOMICAL_ZONES = {
+    "face": "head",
+    "head": "head",
+    "eye": "head",
+    "eyebrow": "head",
+    "chest": "central",
+    "torso": "central",
+    "abdomen": "central",
+    "midriff": "central",
+    "stomach": "central",
+    "waist": "central",
+    "belly": "central",
+    "body": "central",
+    "arm": "limb",
+    "hand": "limb",
+    "leg": "limb",
+    "thigh": "limb",
+    "foot": "limb",
+}
+
 
 def _build_class_specs() -> tuple[tuple[str, str, str, str], ...]:
     specs = list(PERSON_CLASS_SPECS)
@@ -138,15 +116,8 @@ def _build_class_specs() -> tuple[tuple[str, str, str, str], ...]:
             ("man's upper body", "part", "male", "body"),
             ("woman's profile face", "part", "female", "face"),
             ("man's profile face", "part", "male", "face"),
-            ("woman's hand holding an object", "part", "female", "hand"),
-            ("man's hand holding an object", "part", "male", "hand"),
-            ("woman's hands holding an object", "part", "female", "hand"),
-            ("man's hands holding an object", "part", "male", "hand"),
-            ("woman's hand wearing jewelry", "part", "female", "hand"),
-            ("man's hand wearing jewelry", "part", "male", "hand"),
         )
     )
-    specs.extend(OBJECT_CLASS_SPECS)
     return tuple(specs)
 
 
@@ -180,6 +151,9 @@ CHILD_CONSENSUS_MAX_ADULT_SCORE = float(
 CHILD_CONSENSUS_MAX_ADULT_MARGIN = float(
     os.getenv("CHILD_CONSENSUS_MAX_ADULT_MARGIN", "0.08")
 )
+CHILD_CONSENSUS_MIN_ASPECT_RATIO = float(
+    os.getenv("CHILD_CONSENSUS_MIN_ASPECT_RATIO", "1.10")
+)
 STRONG_FEMALE_PERSON_THRESHOLD = float(
     os.getenv("STRONG_FEMALE_PERSON_THRESHOLD", "0.30")
 )
@@ -219,6 +193,21 @@ FUSION_MIN_TOTAL_MARGIN = float(
 )
 FUSION_MIN_TOP_SCORE = float(os.getenv("FUSION_MIN_TOP_SCORE", "0.13"))
 HUMAN_ANCHOR_THRESHOLD = float(os.getenv("HUMAN_ANCHOR_THRESHOLD", "0.12"))
+FEMALE_OWNER_ANCHOR_THRESHOLD = float(
+    os.getenv("FEMALE_OWNER_ANCHOR_THRESHOLD", "0.08")
+)
+FEMALE_OWNER_ANCHOR_MARGIN = float(
+    os.getenv("FEMALE_OWNER_ANCHOR_MARGIN", "0.02")
+)
+CONTRASTIVE_FEMALE_PART_THRESHOLD = float(
+    os.getenv("CONTRASTIVE_FEMALE_PART_THRESHOLD", "0.25")
+)
+CONTRASTIVE_FEMALE_MAX_DEFICIT = float(
+    os.getenv("CONTRASTIVE_FEMALE_MAX_DEFICIT", "0.04")
+)
+CONTRASTIVE_OWNER_MIN_SCORE = float(
+    os.getenv("CONTRASTIVE_OWNER_MIN_SCORE", "0.05")
+)
 ROBUST_MALE_OWNER_THRESHOLD = float(
     os.getenv("ROBUST_MALE_OWNER_THRESHOLD", "0.25")
 )
@@ -231,13 +220,12 @@ STRONG_UNANCHORED_PART_THRESHOLD = float(
 STRONG_UNANCHORED_PART_MARGIN = float(
     os.getenv("STRONG_UNANCHORED_PART_MARGIN", "0.03")
 )
-OBJECT_CONFLICT_THRESHOLD = float(os.getenv("OBJECT_CONFLICT_THRESHOLD", "0.12"))
-OBJECT_CONFLICT_SCORE_RATIO = float(
-    os.getenv("OBJECT_CONFLICT_SCORE_RATIO", "0.65")
+SEMANTIC_COLLAPSE_IOU = float(os.getenv("SEMANTIC_COLLAPSE_IOU", "0.75"))
+SEMANTIC_COLLAPSE_MIN_CONCEPTS = int(
+    os.getenv("SEMANTIC_COLLAPSE_MIN_CONCEPTS", "5")
 )
-OBJECT_CONFLICT_IOU = float(os.getenv("OBJECT_CONFLICT_IOU", "0.55"))
-OBJECT_CONFLICT_AREA_SIMILARITY = float(
-    os.getenv("OBJECT_CONFLICT_AREA_SIMILARITY", "0.55")
+SEMANTIC_COLLAPSE_MAX_OWNER_AREA_RATIO = float(
+    os.getenv("SEMANTIC_COLLAPSE_MAX_OWNER_AREA_RATIO", "0.55")
 )
 MODEL_IOU_THRESHOLD = float(os.getenv("MODEL_IOU_THRESHOLD", "0.50"))
 CLUSTER_IOU_THRESHOLD = float(os.getenv("CLUSTER_IOU_THRESHOLD", "0.45"))
@@ -265,6 +253,7 @@ for threshold_name, threshold_value in {
     "CHILD_CONSENSUS_THRESHOLD": CHILD_CONSENSUS_THRESHOLD,
     "CHILD_CONSENSUS_MAX_ADULT_SCORE": CHILD_CONSENSUS_MAX_ADULT_SCORE,
     "CHILD_CONSENSUS_MAX_ADULT_MARGIN": CHILD_CONSENSUS_MAX_ADULT_MARGIN,
+    "CHILD_CONSENSUS_MIN_ASPECT_RATIO": CHILD_CONSENSUS_MIN_ASPECT_RATIO,
     "STRONG_FEMALE_PERSON_THRESHOLD": STRONG_FEMALE_PERSON_THRESHOLD,
     "STRONG_FEMALE_PART_THRESHOLD": STRONG_FEMALE_PART_THRESHOLD,
     "STRONG_FEMALE_MARGIN": STRONG_FEMALE_MARGIN,
@@ -272,14 +261,17 @@ for threshold_name, threshold_value in {
     "FUSION_MIN_TOTAL_MARGIN": FUSION_MIN_TOTAL_MARGIN,
     "FUSION_MIN_TOP_SCORE": FUSION_MIN_TOP_SCORE,
     "HUMAN_ANCHOR_THRESHOLD": HUMAN_ANCHOR_THRESHOLD,
+    "FEMALE_OWNER_ANCHOR_THRESHOLD": FEMALE_OWNER_ANCHOR_THRESHOLD,
+    "FEMALE_OWNER_ANCHOR_MARGIN": FEMALE_OWNER_ANCHOR_MARGIN,
+    "CONTRASTIVE_FEMALE_PART_THRESHOLD": CONTRASTIVE_FEMALE_PART_THRESHOLD,
+    "CONTRASTIVE_FEMALE_MAX_DEFICIT": CONTRASTIVE_FEMALE_MAX_DEFICIT,
+    "CONTRASTIVE_OWNER_MIN_SCORE": CONTRASTIVE_OWNER_MIN_SCORE,
     "ROBUST_MALE_OWNER_THRESHOLD": ROBUST_MALE_OWNER_THRESHOLD,
     "ROBUST_MALE_OWNER_MARGIN": ROBUST_MALE_OWNER_MARGIN,
     "STRONG_UNANCHORED_PART_THRESHOLD": STRONG_UNANCHORED_PART_THRESHOLD,
     "STRONG_UNANCHORED_PART_MARGIN": STRONG_UNANCHORED_PART_MARGIN,
-    "OBJECT_CONFLICT_THRESHOLD": OBJECT_CONFLICT_THRESHOLD,
-    "OBJECT_CONFLICT_SCORE_RATIO": OBJECT_CONFLICT_SCORE_RATIO,
-    "OBJECT_CONFLICT_IOU": OBJECT_CONFLICT_IOU,
-    "OBJECT_CONFLICT_AREA_SIMILARITY": OBJECT_CONFLICT_AREA_SIMILARITY,
+    "SEMANTIC_COLLAPSE_IOU": SEMANTIC_COLLAPSE_IOU,
+    "SEMANTIC_COLLAPSE_MAX_OWNER_AREA_RATIO": SEMANTIC_COLLAPSE_MAX_OWNER_AREA_RATIO,
     "MODEL_IOU_THRESHOLD": MODEL_IOU_THRESHOLD,
     "CLUSTER_IOU_THRESHOLD": CLUSTER_IOU_THRESHOLD,
     "CLUSTER_CONTAINMENT_THRESHOLD": CLUSTER_CONTAINMENT_THRESHOLD,
@@ -295,6 +287,8 @@ if FUSION_MIN_SIGNALS < 2:
     raise RuntimeError("FUSION_MIN_SIGNALS must be at least 2")
 if CHILD_CONSENSUS_MIN_LABELS < 2:
     raise RuntimeError("CHILD_CONSENSUS_MIN_LABELS must be at least 2")
+if SEMANTIC_COLLAPSE_MIN_CONCEPTS < 3:
+    raise RuntimeError("SEMANTIC_COLLAPSE_MIN_CONCEPTS must be at least 3")
 if MAX_DETECTIONS <= 0:
     raise RuntimeError("MAX_DETECTIONS must be positive")
 
@@ -605,6 +599,10 @@ def _person_clusters(detections: list[dict[str, Any]]) -> list[dict[str, Any]]:
     people = [item for item in detections if item["kind"] == "person"]
     results: list[dict[str, Any]] = []
     for cluster in _spatial_clusters(people):
+        anchor = max(cluster, key=lambda item: item["score"])
+        box_width = max(anchor["box"]["x_max"] - anchor["box"]["x_min"], 1e-6)
+        box_height = max(anchor["box"]["y_max"] - anchor["box"]["y_min"], 0.0)
+        aspect_ratio = box_height / box_width
         scores = {
             gender: max(
                 (item["score"] for item in cluster if item["gender"] == gender),
@@ -633,6 +631,7 @@ def _person_clusters(detections: list[dict[str, Any]]) -> list[dict[str, Any]]:
             and len(child_support_labels) >= CHILD_CONSENSUS_MIN_LABELS
             and adult_top_score <= CHILD_CONSENSUS_MAX_ADULT_SCORE
             and adult_gender_margin <= CHILD_CONSENSUS_MAX_ADULT_MARGIN
+            and aspect_ratio >= CHILD_CONSENSUS_MIN_ASPECT_RATIO
         )
         if age_consensus:
             winner = "child"
@@ -645,7 +644,6 @@ def _person_clusters(detections: list[dict[str, Any]]) -> list[dict[str, Any]]:
         )
         if winner == "female" and score >= STRONG_FEMALE_PERSON_THRESHOLD:
             confirmed = margin >= STRONG_FEMALE_MARGIN
-        anchor = max(cluster, key=lambda item: item["score"])
         results.append(
             {
                 "winner": winner,
@@ -657,6 +655,7 @@ def _person_clusters(detections: list[dict[str, Any]]) -> list[dict[str, Any]]:
                 "confirmed": confirmed,
                 "age_consensus": age_consensus,
                 "child_support_labels": child_support_labels,
+                "box_aspect_ratio": round(aspect_ratio, 4),
                 "box": anchor["box"],
                 "labels": sorted({item["label"] for item in cluster}),
             }
@@ -710,22 +709,6 @@ def _part_clusters(detections: list[dict[str, Any]]) -> list[dict[str, Any]]:
     return sorted(results, key=lambda item: item["score"], reverse=True)
 
 
-def _object_clusters(detections: list[dict[str, Any]]) -> list[dict[str, Any]]:
-    objects = [item for item in detections if item["kind"] == "object"]
-    results: list[dict[str, Any]] = []
-    for cluster in _spatial_clusters(objects):
-        anchor = max(cluster, key=lambda item: item["score"])
-        results.append(
-            {
-                "concept": anchor["concept"],
-                "score": anchor["score"],
-                "box": anchor["box"],
-                "labels": sorted({item["label"] for item in cluster}),
-            }
-        )
-    return sorted(results, key=lambda item: item["score"], reverse=True)
-
-
 def _best_owner(
     part: dict[str, Any], people: list[dict[str, Any]]
 ) -> dict[str, Any] | None:
@@ -749,7 +732,14 @@ def _best_owner(
 
 def _has_human_anchor(owner: dict[str, Any] | None) -> bool:
     """Require an actual person-like response before trusting body-part labels."""
-    return owner is not None and owner["score"] >= HUMAN_ANCHOR_THRESHOLD
+    return owner is not None and (
+        owner["score"] >= HUMAN_ANCHOR_THRESHOLD
+        or (
+            owner["winner"] == "female"
+            and owner["female_score"] >= FEMALE_OWNER_ANCHOR_THRESHOLD
+            and owner["score_margin"] >= FEMALE_OWNER_ANCHOR_MARGIN
+        )
+    )
 
 
 def _robust_nonfemale_owner(owner: dict[str, Any] | None) -> bool:
@@ -778,46 +768,46 @@ def _strong_unanchored_female_part(part: dict[str, Any]) -> bool:
     )
 
 
-def _best_object_conflict(
-    part: dict[str, Any], objects: list[dict[str, Any]]
+def _semantic_collapse_conflict(
+    part: dict[str, Any],
+    parts: list[dict[str, Any]],
+    people: list[dict[str, Any]],
 ) -> dict[str, Any] | None:
-    """Return strong visual evidence that a broad body label is an object.
+    """Reject an anatomically impossible prompt collapse inside a male box.
 
-    This deliberately excludes precise face/hand/foot concepts. It also
-    requires the object and part boxes to have similar area and substantial
-    IoU; a large package containing a smaller printed woman therefore does not
-    erase the woman.
+    OmDet can assign head, torso and limb labels to the exact same small object
+    (for example a trophy). This check reuses existing detections, so it costs
+    no extra model prompts. Requiring a confirmed male owner and a small
+    owner-area ratio preserves isolated body-part crops and printed women.
     """
-    if part["concept"] not in OBJECT_GATED_CONCEPTS:
+    owner = _best_owner(part, people)
+    if owner is None or not owner["confirmed"] or owner["winner"] != "male":
         return None
+
+    owner_area = _box_area(owner["box"])
     part_area = _box_area(part["box"])
-    if part_area <= 0.0:
+    if owner_area <= 0.0 or part_area / owner_area > SEMANTIC_COLLAPSE_MAX_OWNER_AREA_RATIO:
         return None
 
-    candidates: list[dict[str, Any]] = []
-    for item in objects:
-        object_area = _box_area(item["box"])
-        if object_area <= 0.0:
-            continue
-        area_similarity = min(part_area, object_area) / max(part_area, object_area)
-        if (
-            _box_iou(part["box"], item["box"]) >= OBJECT_CONFLICT_IOU
-            and area_similarity >= OBJECT_CONFLICT_AREA_SIMILARITY
-            and item["score"] >= OBJECT_CONFLICT_THRESHOLD
-            and item["score"]
-            >= part["female_score"] * OBJECT_CONFLICT_SCORE_RATIO
-        ):
-            candidate = dict(item)
-            candidate["iou"] = round(_box_iou(part["box"], item["box"]), 4)
-            candidate["area_similarity"] = round(area_similarity, 4)
-            candidates.append(candidate)
-    return max(candidates, key=lambda item: item["score"], default=None)
+    peers = [
+        item
+        for item in parts
+        if _box_iou(part["box"], item["box"]) >= SEMANTIC_COLLAPSE_IOU
+    ]
+    concepts = sorted({item["concept"] for item in peers})
+    zones = sorted({ANATOMICAL_ZONES[item] for item in concepts})
+    if len(concepts) < SEMANTIC_COLLAPSE_MIN_CONCEPTS or len(zones) < 3:
+        return None
+    return {
+        "concepts": concepts,
+        "zones": zones,
+        "owner_area_ratio": round(part_area / owner_area, 4),
+    }
 
 
 def _female_part_evidence(
     parts: list[dict[str, Any]],
     people: list[dict[str, Any]],
-    objects: list[dict[str, Any]],
 ) -> tuple[list[dict[str, Any]], dict[str, Any] | None]:
     confirmed: list[dict[str, Any]] = []
     weak: list[dict[str, Any]] = []
@@ -825,17 +815,14 @@ def _female_part_evidence(
     for part in parts:
         owner = _best_owner(part, people)
         part["owner"] = owner
-        if part["winner"] != "female":
-            continue
-
         anchored = _has_human_anchor(owner)
         part["human_anchor_score"] = round(owner["score"], 4) if owner else 0.0
 
-        object_conflict = _best_object_conflict(part, objects)
-        if object_conflict is not None:
+        collapse_conflict = _semantic_collapse_conflict(part, parts, people)
+        if collapse_conflict is not None:
             part["evidence_eligible"] = False
-            part["evidence_rejection"] = "non_human_object_conflict"
-            part["object_conflict"] = object_conflict
+            part["evidence_rejection"] = "semantic_collapse_inside_male_owner"
+            part["semantic_collapse"] = collapse_conflict
             continue
 
         if _robust_nonfemale_owner(owner):
@@ -843,6 +830,24 @@ def _female_part_evidence(
             part["evidence_rejection"] = f"robust_{owner['winner']}_owner"
             continue
 
+        contrastive_female = (
+            part["winner"] == "male"
+            and part["female_score"] >= CONTRASTIVE_FEMALE_PART_THRESHOLD
+            and part["male_score"] - part["female_score"]
+            <= CONTRASTIVE_FEMALE_MAX_DEFICIT
+            and owner is not None
+            and owner["score"] >= CONTRASTIVE_OWNER_MIN_SCORE
+        )
+        if part["winner"] != "female" and not contrastive_female:
+            continue
+
+        if contrastive_female:
+            part["evidence_eligible"] = True
+            part["evidence_source"] = "strong_contrastive_female_alternative"
+            part["moderation_winner"] = "female"
+            confirmed.append(part)
+            continue
+
         # Product bottles, packaging and appliances often receive many body
         # labels on one rectangular box. Do not accept those labels unless the
         # region also looks like a person. A very strong standalone part remains
@@ -917,7 +922,6 @@ def _female_part_evidence(
 def _decision_from_clusters(
     people: list[dict[str, Any]],
     parts: list[dict[str, Any]],
-    objects: list[dict[str, Any]],
 ) -> tuple[str, str, str, list[dict[str, Any]], dict[str, Any] | None]:
     confirmed_females = [
         item for item in people if item["confirmed"] and item["winner"] == "female"
@@ -928,7 +932,7 @@ def _decision_from_clusters(
     confirmed_children = [
         item for item in people if item["confirmed"] and item["winner"] == "child"
     ]
-    female_parts, fusion = _female_part_evidence(parts, people, objects)
+    female_parts, fusion = _female_part_evidence(parts, people)
 
     if confirmed_females:
         return "BLOCK", "confirmed_female_person", "female", female_parts, fusion
@@ -972,10 +976,7 @@ def _run_omdet(image: Image.Image, include_debug: bool = False) -> dict[str, Any
     raw = _raw_detections(image)
     people = _person_clusters(raw)
     parts = _part_clusters(raw)
-    objects = _object_clusters(raw)
-    decision, reason, gender, female_parts, fusion = _decision_from_clusters(
-        people, parts, objects
-    )
+    decision, reason, gender, female_parts, fusion = _decision_from_clusters(people, parts)
 
     person_female_score = max(
         (item["female_score"] for item in people), default=0.0
@@ -1007,11 +1008,14 @@ def _run_omdet(image: Image.Image, include_debug: bool = False) -> dict[str, Any
             "prompt_count": len(CLASS_NAMES),
             "persons": people,
             "body_parts": parts,
-            "object_regions": objects,
             "female_evidence": female_parts,
             "fusion": fusion,
             "decision_policy": {
                 "human_anchor_threshold": HUMAN_ANCHOR_THRESHOLD,
+                "female_owner_anchor_threshold": FEMALE_OWNER_ANCHOR_THRESHOLD,
+                "female_owner_anchor_margin": FEMALE_OWNER_ANCHOR_MARGIN,
+                "contrastive_female_part_threshold": CONTRASTIVE_FEMALE_PART_THRESHOLD,
+                "contrastive_female_max_deficit": CONTRASTIVE_FEMALE_MAX_DEFICIT,
                 "robust_male_owner_threshold": ROBUST_MALE_OWNER_THRESHOLD,
                 "robust_male_owner_margin": ROBUST_MALE_OWNER_MARGIN,
                 "fusion_min_signals": FUSION_MIN_SIGNALS,
@@ -1019,8 +1023,10 @@ def _run_omdet(image: Image.Image, include_debug: bool = False) -> dict[str, Any
                 "fusion_min_top_score": FUSION_MIN_TOP_SCORE,
                 "child_consensus_threshold": CHILD_CONSENSUS_THRESHOLD,
                 "child_consensus_min_labels": CHILD_CONSENSUS_MIN_LABELS,
-                "object_conflict_threshold": OBJECT_CONFLICT_THRESHOLD,
-                "object_conflict_score_ratio": OBJECT_CONFLICT_SCORE_RATIO,
+                "child_consensus_min_aspect_ratio": CHILD_CONSENSUS_MIN_ASPECT_RATIO,
+                "semantic_collapse_iou": SEMANTIC_COLLAPSE_IOU,
+                "semantic_collapse_min_concepts": SEMANTIC_COLLAPSE_MIN_CONCEPTS,
+                "semantic_collapse_max_owner_area_ratio": SEMANTIC_COLLAPSE_MAX_OWNER_AREA_RATIO,
             },
             "raw_detection_count": len(raw),
         }
@@ -1044,7 +1050,7 @@ async def lifespan(_: FastAPI):
 app = FastAPI(
     title="AI Shield - OmDet-Turbo Swin-Tiny Test",
     description="Human-anchored female-person and female body-part detector",
-    version="0.3.0",
+    version="0.4.0",
     lifespan=lifespan,
 )