solveedit_benchmark_2728 / code /src /pvr_eval /agent /instance_matching.py
wenjieshu's picture
Add files using upload-large-folder tool
b8ea052 verified
Raw History Blame Contribute Delete
66.8 kB
"""Objective input/output instance matching for PVR tool evidence. The matcher is deliberately model-agnostic. Executors may provide CLIP crop embeddings, while unit tests and CPU-only runs can omit them. Detector label, colour and shape evidence remain separately visible in every assignment so a reviewer can tell why two instances were paired. """ from __future__ import annotations from dataclasses import dataclass, field import re from typing import Any, Iterable, Mapping, Sequence import numpy as np from pvr_eval.agent.detector_fusion import semantic_class MATCH_SCHEMA_VERSION = "pvr.instance_matches.v1" @dataclass(frozen=True) class MatchConfig: minimum_confidence: float = 0.55 ambiguity_margin: float = 0.04 semantic_weight: float = 0.30 clip_weight: float = 0.40 foreground_clip_weight: float = 0.20 colour_weight: float = 0.20 shape_weight: float = 0.10 mask_shape_weight: float = 0.0 spatial_weight: float = 0.0 verified_roster_profile: str = "" verified_roster_assignment_mode: str = "identity_exact" verified_roster_expected_counts: Mapping[str, int] = field(default_factory=dict) verified_roster_minimum_area_ratio: float = 0.10 verified_roster_maximum_area_ratio: float = 6.0 identity_agnostic_target_coverage_profile: str = "" target_coverage_minimum_probability: float = 0.50 target_coverage_minimum_margin: float = 0.15 target_coverage_minimum_animal_probability: float = 0.75 target_coverage_minimum_animal_margin: float = 0.50 target_coverage_maximum_protected_overlap: float = 0.10 target_coverage_neighborhood_fraction_of_diagonal: float = 0.08 VERIFIED_GROUP_ROSTER_PROFILE = "verified_group_roster_assignment_v1" QUESTION_SUPPORT_COVERAGE_MODE = "question_support_allowed_edit_coverage_v1" PROTECTED_SUBJECT_ROSTER_PROFILE = "protected_subject_roster_clearance_v1" IDENTITY_AGNOSTIC_TARGET_COVERAGE_PROFILE = "identity_agnostic_target_animal_coverage_v1" def _tokens(value: Any) -> set[str]: stop = {"a", "an", "the", "and", "or", "of", "on", "in", "at", "to", "with", "object", "item"} return { token for token in re.findall(r"[a-z0-9]+", str(value or "").lower().replace("grey", "gray")) if token not in stop } def _normalise_group(value: Any) -> str: tokens = sorted(_tokens(str(value or "").replace("_", " "))) normalised = " ".join(tokens) if normalised.endswith("s") and not normalised.endswith("ss"): normalised = normalised[:-1] return normalised def _verified_group(item: Mapping[str, Any], *, source: bool) -> str: values = ( (item.get("group_id"), item.get("matching_class"), item.get("semantic_class"), item.get("label")) if source else (item.get("verified_roster_group"), item.get("predicted_class"), item.get("semantic_class")) ) for value in values: group = _normalise_group(value) if group and group != "unknown": return group return "" def _geometry_area(item: Mapping[str, Any]) -> float | None: mask = item.get("binary_mask") if isinstance(mask, np.ndarray) and mask.size: area = float(np.count_nonzero(mask)) if area > 0: return area box = _bbox(item) if box is None: return None area = max(0.0, box[2] - box[0]) * max(0.0, box[3] - box[1]) return area if area > 0 else None def semantic_similarity(left: Mapping[str, Any], right: Mapping[str, Any]) -> float: """Conservative class compatibility in ``[0, 0.75]``. Identical query strings are detector requests, not independent proof that either crop belongs to that category. The component is deliberately capped below one and matching is gated by the coarse semantic class. """ left_class = str(left.get("semantic_class") or semantic_class(left)) right_class = str(right.get("semantic_class") or semantic_class(right)) if left_class != right_class: return 0.0 left_tokens = _tokens(f"{left.get('label', '')} {left.get('query_text', '')}") right_tokens = _tokens(f"{right.get('label', '')} {right.get('query_text', '')}") if not left_tokens or not right_tokens: return 0.0 overlap = len(left_tokens & right_tokens) union = len(left_tokens | right_tokens) if left_tokens <= right_tokens or right_tokens <= left_tokens: return 0.75 return min(0.75, overlap / union) if overlap else 0.0 def cosine_similarity(left: np.ndarray | None, right: np.ndarray | None) -> float | None: if left is None or right is None or left.size == 0 or right.size == 0 or left.shape != right.shape: return None denominator = float(np.linalg.norm(left) * np.linalg.norm(right)) if denominator <= 1e-12: return None # CLIP cosine may be negative. Map it to a bounded confidence component. return float(np.clip((float(np.dot(left, right)) / denominator + 1.0) / 2.0, 0.0, 1.0)) def histogram_similarity(left: np.ndarray | None, right: np.ndarray | None) -> float | None: if left is None or right is None or left.size == 0 or right.size == 0 or left.shape != right.shape: return None left = np.asarray(left, dtype=np.float64) right = np.asarray(right, dtype=np.float64) left_sum, right_sum = float(left.sum()), float(right.sum()) if left_sum <= 0 or right_sum <= 0: return None left, right = left / left_sum, right / right_sum return float(np.clip(np.minimum(left, right).sum(), 0.0, 1.0)) def _bbox(item: Mapping[str, Any]) -> list[float] | None: value = item.get("bbox") or item.get("bbox_xyxy") if isinstance(value, str): try: value = [float(part) for part in value.split(",")] except ValueError: return None if not isinstance(value, (list, tuple)) or len(value) != 4: return None try: return [float(part) for part in value] except (TypeError, ValueError): return None def shape_similarity(left: Mapping[str, Any], right: Mapping[str, Any]) -> float | None: a, b = _bbox(left), _bbox(right) if a is None or b is None: return None aw, ah = max(1.0, a[2] - a[0]), max(1.0, a[3] - a[1]) bw, bh = max(1.0, b[2] - b[0]), max(1.0, b[3] - b[1]) aspect = min(aw / ah, bw / bh) / max(aw / ah, bw / bh) area = min(aw * ah, bw * bh) / max(aw * ah, bw * bh) return float(np.clip(0.65 * aspect + 0.35 * np.sqrt(area), 0.0, 1.0)) def mask_shape_similarity(left: Mapping[str, Any], right: Mapping[str, Any]) -> float | None: """Compare translation-invariant coarse mask shape statistics. Source and output instances may legitimately move, so raw image-coordinate mask IoU is not an identity feature. Area ratio and bbox fill ratio retain useful silhouette evidence without rewarding the old location. """ left_mask, right_mask = left.get("binary_mask"), right.get("binary_mask") left_box, right_box = _bbox(left), _bbox(right) if ( not isinstance(left_mask, np.ndarray) or not isinstance(right_mask, np.ndarray) or left_mask.size == 0 or right_mask.size == 0 or left_box is None or right_box is None ): return None left_area, right_area = float(np.count_nonzero(left_mask)), float(np.count_nonzero(right_mask)) if left_area <= 0 or right_area <= 0: return None left_box_area = max(1.0, (left_box[2] - left_box[0]) * (left_box[3] - left_box[1])) right_box_area = max(1.0, (right_box[2] - right_box[0]) * (right_box[3] - right_box[1])) area_score = min(left_area, right_area) / max(left_area, right_area) left_fill, right_fill = left_area / left_box_area, right_area / right_box_area fill_score = min(left_fill, right_fill) / max(left_fill, right_fill) return float(np.clip(0.60 * np.sqrt(area_score) + 0.40 * fill_score, 0.0, 1.0)) def spatial_similarity(left: Mapping[str, Any], right: Mapping[str, Any]) -> float | None: """Same-location similarity for checks that declare spatial invariance.""" a, b = _bbox(left), _bbox(right) if a is None or b is None: return None ix0, iy0 = max(a[0], b[0]), max(a[1], b[1]) ix1, iy1 = min(a[2], b[2]), min(a[3], b[3]) intersection = max(0.0, ix1 - ix0) * max(0.0, iy1 - iy0) area_a = max(0.0, a[2] - a[0]) * max(0.0, a[3] - a[1]) area_b = max(0.0, b[2] - b[0]) * max(0.0, b[3] - b[1]) union = area_a + area_b - intersection iou = 0.0 if union <= 0 else intersection / union center_a = ((a[0] + a[2]) / 2.0, (a[1] + a[3]) / 2.0) center_b = ((b[0] + b[2]) / 2.0, (b[1] + b[3]) / 2.0) distance = float(np.hypot(center_a[0] - center_b[0], center_a[1] - center_b[1])) diagonal_a = float(np.hypot(a[2] - a[0], a[3] - a[1])) diagonal_b = float(np.hypot(b[2] - b[0], b[3] - b[1])) scale = max(1.0, (diagonal_a + diagonal_b) / 2.0) center_score = max(0.0, 1.0 - distance / (2.0 * scale)) return float(np.clip(0.70 * iou + 0.30 * center_score, 0.0, 1.0)) def source_output_mask_iou(left: Mapping[str, Any], right: Mapping[str, Any]) -> float | None: left_mask, right_mask = left.get("binary_mask"), right.get("binary_mask") if not isinstance(left_mask, np.ndarray) or not isinstance(right_mask, np.ndarray): return None if left_mask.shape != right_mask.shape or left_mask.size == 0: return None intersection = int(np.logical_and(left_mask, right_mask).sum()) union = int(np.logical_or(left_mask, right_mask).sum()) return None if union <= 0 else intersection / union def source_zone_output_overlap_ratio(left: Mapping[str, Any], right: Mapping[str, Any]) -> float | None: """Fraction of the output mask that remains in the input source mask.""" left_mask, right_mask = left.get("binary_mask"), right.get("binary_mask") if not isinstance(left_mask, np.ndarray) or not isinstance(right_mask, np.ndarray): return None if left_mask.shape != right_mask.shape or left_mask.size == 0: return None output_area = int(np.count_nonzero(right_mask)) if output_area <= 0: return None intersection = int(np.logical_and(left_mask, right_mask).sum()) return intersection / output_area def pair_similarity( left: Mapping[str, Any], right: Mapping[str, Any], *, config: MatchConfig, ) -> dict[str, Any]: components: dict[str, float | None] = { "semantic": semantic_similarity(left, right), "clip": cosine_similarity(left.get("clip_embedding"), right.get("clip_embedding")), "foreground_clip": cosine_similarity( left.get("foreground_clip_embedding"), right.get("foreground_clip_embedding") ), "colour": histogram_similarity(left.get("colour_histogram"), right.get("colour_histogram")), "shape": shape_similarity(left, right), "mask_shape": mask_shape_similarity(left, right), "spatial": spatial_similarity(left, right) if config.spatial_weight > 0 else None, } left_class = str(left.get("semantic_class") or semantic_class(left)) right_class = str(right.get("semantic_class") or semantic_class(right)) category_compatible = bool(left_class and right_class and left_class == right_class) weights = { "semantic": config.semantic_weight, "clip": config.clip_weight, "foreground_clip": config.foreground_clip_weight, "colour": config.colour_weight, "shape": config.shape_weight, "mask_shape": config.mask_shape_weight, "spatial": config.spatial_weight, } available = [(name, value) for name, value in components.items() if value is not None] denominator = sum(weights[name] for name, _ in available) score = 0.0 if denominator <= 0 else sum(weights[name] * float(value) for name, value in available) / denominator # A zero semantic overlap is a strong incompatibility signal. Appearance # alone must not pair unrelated detector categories. if not category_compatible: score = 0.0 return { "score": float(np.clip(score, 0.0, 1.0)), "category_compatible": category_compatible, "semantic_class": left_class if category_compatible else f"{left_class}!={right_class}", "components": {key: (None if value is None else round(float(value), 6)) for key, value in components.items()}, "source_output_mask_iou": ( None if (mask_iou := source_output_mask_iou(left, right)) is None else round(float(mask_iou), 6) ), "source_zone_output_overlap_ratio": ( None if (source_overlap := source_zone_output_overlap_ratio(left, right)) is None else round(float(source_overlap), 6) ), "effective_weights": {name: weights[name] for name, _ in available}, } def _linear_assignment(scores: np.ndarray) -> list[tuple[int, int]]: if scores.size == 0: return [] try: from scipy.optimize import linear_sum_assignment rows, columns = linear_sum_assignment(-scores) return list(zip(rows.tolist(), columns.tolist())) except Exception: # Deterministic fallback for minimal environments. The production # server has SciPy, but tests should not depend on it. remaining_rows = set(range(scores.shape[0])) remaining_columns = set(range(scores.shape[1])) result: list[tuple[int, int]] = [] while remaining_rows and remaining_columns: row, column = max( ((r, c) for r in remaining_rows for c in remaining_columns), key=lambda pair: (scores[pair], -pair[0], -pair[1]), ) result.append((row, column)) remaining_rows.remove(row) remaining_columns.remove(column) return result def _public_instance(item: Mapping[str, Any], index: int) -> dict[str, Any]: public = { "instance_id": str(item.get("instance_id") or f"instance_{index:03d}"), "label": str(item.get("label") or ""), "query_text": str(item.get("query_text") or ""), "query_aliases": [str(value) for value in item.get("query_aliases", []) if str(value or "").strip()], "bbox_xyxy": _bbox(item), "detector_score": float(item.get("score") or 0.0), "detector_backend": str(item.get("detector_backend") or item.get("backend") or ""), "supporting_backends": str(item.get("supporting_backends") or ""), "semantic_class": str(item.get("semantic_class") or semantic_class(item)), "arbitration": str(item.get("arbitration") or ""), "mask_backend": str(item.get("mask_backend") or ""), } for key in ( "group_id", "matching_class", "verified_roster_group", "predicted_class", "evidence_role", "proposal_source", ): if str(item.get(key) or "").strip(): public[key] = str(item[key]) encoded_mask = item.get("encoded_mask") if isinstance(encoded_mask, Mapping) and encoded_mask: public["encoded_mask"] = dict(encoded_mask) polygon = item.get("polygon") if isinstance(polygon, (list, tuple)) and polygon: public["polygon"] = list(polygon) target_coverage = item.get("target_coverage_evidence") if isinstance(target_coverage, Mapping) and target_coverage: public["target_coverage_evidence"] = dict(target_coverage) return public def _same_physical_subject(left: Mapping[str, Any], right: Mapping[str, Any]) -> bool: """Conservatively identify two masks as proposals for one physical subject.""" left_mask, right_mask = left.get("binary_mask"), right.get("binary_mask") if ( isinstance(left_mask, np.ndarray) and isinstance(right_mask, np.ndarray) and left_mask.shape == right_mask.shape and left_mask.size ): intersection = int(np.logical_and(left_mask, right_mask).sum()) smaller = min(int(left_mask.sum()), int(right_mask.sum())) return bool(smaller > 0 and intersection / smaller >= 0.70) left_box, right_box = _bbox(left), _bbox(right) if left_box is None or right_box is None: return False ix0, iy0 = max(left_box[0], right_box[0]), max(left_box[1], right_box[1]) ix1, iy1 = min(left_box[2], right_box[2]), min(left_box[3], right_box[3]) intersection = max(0.0, ix1 - ix0) * max(0.0, iy1 - iy0) left_area = max(0.0, left_box[2] - left_box[0]) * max(0.0, left_box[3] - left_box[1]) right_area = max(0.0, right_box[2] - right_box[0]) * max(0.0, right_box[3] - right_box[1]) union = left_area + right_area - intersection return bool(union > 0 and intersection / union >= 0.50) def _physical_subject_components(items: Sequence[Mapping[str, Any]]) -> list[list[int]]: adjacency = {index: set() for index in range(len(items))} for left in range(len(items)): for right in range(left + 1, len(items)): if _same_physical_subject(items[left], items[right]): adjacency[left].add(right) adjacency[right].add(left) components: list[list[int]] = [] remaining = set(adjacency) while remaining: stack = [remaining.pop()] component: list[int] = [] while stack: index = stack.pop() component.append(index) for neighbor in adjacency[index]: if neighbor in remaining: remaining.remove(neighbor) stack.append(neighbor) components.append(sorted(component)) return sorted(components, key=lambda value: (value[0] if value else -1)) def _bbox_edge_gap(left: Mapping[str, Any], right: Mapping[str, Any]) -> float | None: left_box, right_box = _bbox(left), _bbox(right) if left_box is None or right_box is None: return None dx = max(left_box[0] - right_box[2], right_box[0] - left_box[2], 0.0) dy = max(left_box[1] - right_box[3], right_box[1] - left_box[3], 0.0) return float(np.hypot(dx, dy)) def _mask_overlap_fraction( item: Mapping[str, Any], others: Sequence[Mapping[str, Any]], ) -> float | None: mask = item.get("binary_mask") if not isinstance(mask, np.ndarray) or mask.size == 0 or not mask.any(): return None area = int(mask.sum()) overlaps: list[float] = [] for other in others: other_mask = other.get("binary_mask") if ( isinstance(other_mask, np.ndarray) and other_mask.shape == mask.shape and other_mask.size and other_mask.any() ): overlaps.append(int(np.logical_and(mask, other_mask).sum()) / max(1, area)) return max(overlaps, default=0.0) def _dominant_target_neighbourhood( outputs: Sequence[Mapping[str, Any]], columns: Sequence[int], *, fraction_of_diagonal: float, ) -> dict[str, Any]: """Return a unique dominant seed component for coverage-only proposals. The seeds are already species-certified target masks. Their dominant spatial component only scopes additional identity-agnostic proposals; it never creates an animal identity or replaces the original target masks. """ distinct_columns: list[int] = [] for component in _physical_subject_components([outputs[index] for index in columns]): candidates = [columns[index] for index in component] distinct_columns.append(max(candidates, key=lambda index: float(outputs[index].get("score") or 0.0))) masks = [outputs[index].get("binary_mask") for index in distinct_columns] shapes = { tuple(int(value) for value in mask.shape[:2]) for mask in masks if isinstance(mask, np.ndarray) and mask.ndim >= 2 and mask.size } if len(shapes) != 1 or not distinct_columns: return { "status": "insufficient", "reason": "unique_image_shape_and_seed_targets_required", "seed_columns": distinct_columns, } height, width = next(iter(shapes)) diagonal = float(np.hypot(width, height)) threshold = max(1.0, float(fraction_of_diagonal) * diagonal) adjacency = {index: set() for index in range(len(distinct_columns))} for left in range(len(distinct_columns)): for right in range(left + 1, len(distinct_columns)): gap = _bbox_edge_gap(outputs[distinct_columns[left]], outputs[distinct_columns[right]]) if gap is not None and gap <= threshold: adjacency[left].add(right) adjacency[right].add(left) components: list[list[int]] = [] remaining = set(adjacency) while remaining: stack = [remaining.pop()] component: list[int] = [] while stack: index = stack.pop() component.append(index) for neighbor in adjacency[index]: if neighbor in remaining: remaining.remove(neighbor) stack.append(neighbor) components.append(sorted(component)) components.sort(key=lambda value: (-len(value), value[0])) if not components or (len(components) > 1 and len(components[0]) == len(components[1])): return { "status": "insufficient", "reason": "dominant_seed_component_ambiguous", "seed_columns": distinct_columns, "component_sizes": [len(value) for value in components], "neighbourhood_edge_gap_pixels": threshold, } dominant = [distinct_columns[index] for index in components[0]] return { "status": "ok", "reason": "", "seed_columns": distinct_columns, "dominant_seed_columns": dominant, "component_sizes": [len(value) for value in components], "neighbourhood_edge_gap_pixels": threshold, "image_shape": [height, width], } def certify_protected_subject_roster( instances: Sequence[Mapping[str, Any]], expected_queries: Sequence[str], ) -> dict[str, Any]: """Certify one real, unique output mask for every protected subject. Detector and segmenter adapters may emit several overlapping proposals for one body. Those proposals are one physical-subject component, not several subjects. Two disjoint candidates for the same query remain ambiguous and fail closed. A selected mask also cannot be reused for two query slots. """ queries = [str(value).strip() for value in expected_queries if str(value).strip()] candidates = [ item for item in instances if isinstance(item.get("binary_mask"), np.ndarray) and item["binary_mask"].size and bool(item["binary_mask"].any()) ] assignments: list[dict[str, Any]] = [] missing: list[str] = [] ambiguous: list[dict[str, Any]] = [] selected_instances: list[Mapping[str, Any]] = [] for query in queries: query_group = _normalise_group(query) query_candidates = [ item for item in candidates if _normalise_group( item.get("predicted_class") or item.get("verified_roster_group") or item.get("semantic_class") or item.get("label") ) == query_group ] components = _physical_subject_components(query_candidates) if not query_candidates: missing.append(query) continue if len(components) != 1: ambiguous.append({ "query": query, "candidate_count": len(query_candidates), "physical_subject_component_count": len(components), "candidates": [ _public_instance(item, index) for index, item in enumerate(query_candidates) ], }) continue component_items = [query_candidates[index] for index in components[0]] selected = max( component_items, key=lambda item: ( _geometry_area(item) or 0.0, float(item.get("score") or item.get("detector_score") or 0.0), ), ) selected_instances.append(selected) assignments.append({ "query": query, "candidate_count": len(query_candidates), "physical_subject_component_count": 1, "selected": _public_instance(selected, len(assignments)), "selection_policy": "largest_real_mask_within_one_physical_subject_component", }) cross_query_duplicates: list[dict[str, str]] = [] for left in range(len(selected_instances)): for right in range(left + 1, len(selected_instances)): if _same_physical_subject(selected_instances[left], selected_instances[right]): cross_query_duplicates.append({ "left_query": assignments[left]["query"], "right_query": assignments[right]["query"], }) complete = bool(queries) and not missing and not ambiguous and not cross_query_duplicates certificate = { "profile": PROTECTED_SUBJECT_ROSTER_PROFILE, "status": "ok" if complete else "insufficient", "complete": complete, "ambiguity_free": not ambiguous and not cross_query_duplicates, "identity_assignment_asserted": True, "expected_queries": queries, "assignment_count": len(assignments), "assignments": assignments, "missing_queries": missing, "ambiguous_queries": ambiguous, "cross_query_duplicate_subjects": cross_query_duplicates, "mask_requirement": "nonempty_real_instance_mask", } return { "status": certificate["status"], "reason": "" if complete else "protected_subject_roster_incomplete_or_ambiguous", "selected_instances": selected_instances if complete else [], "certificate": certificate, } def certify_protected_subject_transition( source_instances: Sequence[Mapping[str, Any]], output_instances: Sequence[Mapping[str, Any]], expected_queries: Sequence[str], *, minimum_confidence: float = 0.45, ) -> dict[str, Any]: """Verify contract-prompted protected masks across input and output. The reviewed annotations provide identity and a stable prompt window, but never geometry: both sides must still materialize nonempty real masks. Appearance, colour, shape, and mask-shape agreement then verify that the output prompt did not silently segment background or another subject. """ queries = [str(value).strip() for value in expected_queries if str(value).strip()] source_by_group: dict[str, list[Mapping[str, Any]]] = {} output_by_group: dict[str, list[Mapping[str, Any]]] = {} for item in source_instances: source_by_group.setdefault(_verified_group(item, source=True), []).append(item) for item in output_instances: output_by_group.setdefault(_verified_group(item, source=True), []).append(item) assignments: list[dict[str, Any]] = [] selected: list[dict[str, Any]] = [] missing: list[dict[str, Any]] = [] config = MatchConfig( minimum_confidence=minimum_confidence, ambiguity_margin=0.0, semantic_weight=0.25, clip_weight=0.35, foreground_clip_weight=0.0, colour_weight=0.15, shape_weight=0.10, mask_shape_weight=0.15, spatial_weight=0.0, ) for query in queries: group = _normalise_group(query) source_candidates = source_by_group.get(group, []) output_candidates = output_by_group.get(group, []) if len(source_candidates) != 1 or len(output_candidates) != 1: missing.append({ "query": query, "source_candidate_count": len(source_candidates), "output_candidate_count": len(output_candidates), "reason": "exactly_one_prompted_real_mask_required_per_side", }) continue source, output = source_candidates[0], output_candidates[0] evidence = pair_similarity(source, output, config=config) confidence = float(evidence["score"]) if confidence < minimum_confidence: missing.append({ "query": query, "source_candidate_count": 1, "output_candidate_count": 1, "confidence": round(confidence, 6), "reason": "protected_source_output_identity_below_minimum_confidence", }) continue output_copy = dict(output) output_copy["label"] = query output_copy["query_text"] = query output_copy["semantic_class"] = query output_copy["predicted_class"] = query output_copy["verified_roster_group"] = query selected.append(output_copy) assignments.append({ "query": query, "confidence": round(confidence, 6), "source": _public_instance(source, len(assignments)), "output": _public_instance(output_copy, len(assignments)), "components": evidence["components"], "source_output_mask_iou": evidence["source_output_mask_iou"], "selection_policy": "reviewed_prompt_real_mask_cross_image_identity_v1", }) cross_query_duplicates: list[dict[str, str]] = [] for left in range(len(selected)): for right in range(left + 1, len(selected)): if _same_physical_subject(selected[left], selected[right]): cross_query_duplicates.append({ "left_query": assignments[left]["query"], "right_query": assignments[right]["query"], }) complete = bool(queries) and not missing and not cross_query_duplicates certificate = { "profile": PROTECTED_SUBJECT_ROSTER_PROFILE, "status": "ok" if complete else "insufficient", "complete": complete, "ambiguity_free": not cross_query_duplicates, "identity_assignment_asserted": True, "expected_queries": queries, "assignment_count": len(assignments), "assignments": assignments, "missing_or_rejected_queries": missing, "missing_queries": [item["query"] for item in missing], "ambiguous_queries": [], "cross_query_duplicate_subjects": cross_query_duplicates, "mask_requirement": "nonempty_real_mask_on_input_and_output", "minimum_identity_confidence": minimum_confidence, "annotation_scope": "identity_and_prompt_window_not_geometry", } return { "status": certificate["status"], "reason": "" if complete else "protected_subject_transition_incomplete", "selected_instances": selected if complete else [], "certificate": certificate, } def _match_verified_group_roster( inputs: list[Mapping[str, Any]], outputs: list[Mapping[str, Any]], *, config: MatchConfig, protected_instances: Sequence[Mapping[str, Any]] = (), ) -> dict[str, Any]: """Certify a reviewed source roster as output groups, not fake slot identities. Some questions need the union of all instances in a verified group (for example all birds as allowed-edit masks), while the identity of two same-colour members inside that group is immaterial. This profile still requires mutually exclusive output group labels, plausible real mask areas, exact group cardinality, and a one-to-one assignment. Ambiguity at the *group boundary* fails closed; swaps inside an already-certified group do not. """ inferred: dict[str, list[int]] = {} for row, item in enumerate(inputs): group = _verified_group(item, source=True) inferred.setdefault(group, []).append(row) inferred_counts = {group: len(rows) for group, rows in inferred.items() if group} configured_counts = { _normalise_group(group): int(count) for group, count in config.verified_roster_expected_counts.items() if _normalise_group(group) and int(count) > 0 } expected_counts = configured_counts or inferred_counts certificate_reasons: list[str] = [] if "" in inferred: certificate_reasons.append("source_group_missing") if configured_counts and configured_counts != inferred_counts: certificate_reasons.append("configured_source_group_counts_mismatch") source_area_medians: dict[str, float] = {} pooled_source_areas: list[float] = [] for group, rows in inferred.items(): areas = [area for row in rows if (area := _geometry_area(inputs[row])) is not None] if areas: source_area_medians[group] = float(np.median(np.asarray(areas, dtype=np.float64))) pooled_source_areas.extend(areas) pooled_source_area_median = ( float(np.median(np.asarray(pooled_source_areas, dtype=np.float64))) if pooled_source_areas else None ) output_groups = [_verified_group(item, source=False) for item in outputs] plausible_by_group: dict[str, list[int]] = {group: [] for group in expected_counts} rejected_candidates: list[dict[str, Any]] = [] identity_agnostic_candidates: list[int] = [] identity_agnostic_audit: list[dict[str, Any]] = [] output_area_ratios: dict[int, float | None] = {} for column, (item, group) in enumerate(zip(outputs, output_groups)): public = _public_instance(item, column) target_coverage = item.get("target_coverage_evidence") identity_agnostic = bool( group not in expected_counts and config.identity_agnostic_target_coverage_profile == IDENTITY_AGNOSTIC_TARGET_COVERAGE_PROFILE and isinstance(target_coverage, Mapping) and target_coverage.get("profile") == IDENTITY_AGNOSTIC_TARGET_COVERAGE_PROFILE and target_coverage.get("binary_status") == "candidate" ) if identity_agnostic: output_area = _geometry_area(item) real_mask = item.get("binary_mask") has_real_mask = bool( isinstance(real_mask, np.ndarray) and real_mask.size and real_mask.any() and str(item.get("mask_backend") or "") and "fallback" not in str(item.get("mask_backend") or "").lower() and str(item.get("mask_backend") or "").lower() != "bbox" ) ratio = ( None if pooled_source_area_median is None or output_area is None else output_area / max(pooled_source_area_median, 1e-12) ) output_area_ratios[column] = ratio target_probability = float(target_coverage.get("target_probability") or 0.0) target_margin = float(target_coverage.get("target_margin") or 0.0) animal_probability = float(target_coverage.get("animal_probability") or 0.0) animal_margin = float(target_coverage.get("animal_margin") or 0.0) protected_overlap = _mask_overlap_fraction(item, protected_instances) reasons: list[str] = [] if not has_real_mask: reasons.append("real_non_bbox_mask_required") if ratio is None or not ( config.verified_roster_minimum_area_ratio <= ratio <= config.verified_roster_maximum_area_ratio ): reasons.append("pooled_source_area_plausibility_out_of_range") target_gate = bool( target_probability >= config.target_coverage_minimum_probability and target_margin >= config.target_coverage_minimum_margin ) animal_gate = bool( animal_probability >= config.target_coverage_minimum_animal_probability and animal_margin >= config.target_coverage_minimum_animal_margin ) if not (target_gate or animal_gate): reasons.append("target_or_animal_binary_evidence_below_minimum") if protected_overlap is None: reasons.append("protected_overlap_mask_evidence_missing") elif protected_overlap > config.target_coverage_maximum_protected_overlap: reasons.append("protected_subject_overlap_exceeds_maximum") audit = { "output_index": column, "output": public, "binary_status": "candidate", "target_probability": round(target_probability, 6), "target_margin": round(target_margin, 6), "animal_probability": round(animal_probability, 6), "animal_margin": round(animal_margin, 6), "binary_acceptance_basis": ( "target_vs_distractor" if target_gate else "animal_vs_background" if animal_gate else "none" ), "area_ratio_to_pooled_source_median": ( None if ratio is None else round(float(ratio), 6) ), "protected_subject_overlap_fraction": ( None if protected_overlap is None else round(float(protected_overlap), 6) ), "pre_neighbourhood_reasons": reasons, } identity_agnostic_audit.append(audit) if not reasons: identity_agnostic_candidates.append(column) else: rejected_candidates.append({ "output": public, "group_id": "target_animal_identity_agnostic", "rejection_reason": reasons[0], "rejection_reasons": reasons, }) continue if group not in expected_counts: rejected_candidates.append({ "output": public, "group_id": group, "rejection_reason": "group_label_not_in_verified_roster", }) continue source_median = source_area_medians.get(group) output_area = _geometry_area(item) ratio = ( None if source_median is None or output_area is None or source_median <= 0 else output_area / source_median ) output_area_ratios[column] = ratio if ratio is None: rejected_candidates.append({ "output": public, "group_id": group, "rejection_reason": "real_mask_or_bbox_area_missing", }) continue if not ( config.verified_roster_minimum_area_ratio <= ratio <= config.verified_roster_maximum_area_ratio ): rejected_candidates.append({ "output": public, "group_id": group, "area_ratio_to_source_group_median": round(float(ratio), 6), "rejection_reason": "group_size_plausibility_out_of_range", }) continue plausible_by_group[group].append(column) if config.verified_roster_assignment_mode == QUESTION_SUPPORT_COVERAGE_MODE: source_roster_complete = not certificate_reasons and inferred_counts == expected_counts base_provisional_output = sorted({ column for columns in plausible_by_group.values() for column in columns }) neighbourhood = _dominant_target_neighbourhood( outputs, base_provisional_output, fraction_of_diagonal=config.target_coverage_neighborhood_fraction_of_diagonal, ) promoted_identity_agnostic: list[int] = [] dominant_columns = list(neighbourhood.get("dominant_seed_columns", [])) neighbourhood_threshold = float( neighbourhood.get("neighbourhood_edge_gap_pixels") or 0.0 ) audit_by_column = { int(item["output_index"]): item for item in identity_agnostic_audit } for column in identity_agnostic_candidates: gaps = [ gap for seed in dominant_columns if (gap := _bbox_edge_gap(outputs[column], outputs[seed])) is not None ] minimum_gap = min(gaps) if gaps else None audit = audit_by_column[column] audit["minimum_gap_to_dominant_seed_pixels"] = ( None if minimum_gap is None else round(float(minimum_gap), 6) ) audit["neighbourhood_edge_gap_pixels"] = neighbourhood_threshold if neighbourhood.get("status") != "ok": audit["neighbourhood_status"] = "rejected" audit["neighbourhood_reason"] = str(neighbourhood.get("reason") or "") rejected_candidates.append({ "output": audit["output"], "group_id": "target_animal_identity_agnostic", "rejection_reason": "dominant_target_neighbourhood_incomplete", }) elif minimum_gap is None or minimum_gap > neighbourhood_threshold: audit["neighbourhood_status"] = "rejected" audit["neighbourhood_reason"] = "outside_dominant_target_neighbourhood" rejected_candidates.append({ "output": audit["output"], "group_id": "target_animal_identity_agnostic", "rejection_reason": "outside_dominant_target_neighbourhood", "minimum_gap_to_dominant_seed_pixels": audit[ "minimum_gap_to_dominant_seed_pixels" ], }) else: audit["neighbourhood_status"] = "accepted" audit["neighbourhood_reason"] = "" promoted_identity_agnostic.append(column) provisional_output = sorted({ *base_provisional_output, *promoted_identity_agnostic, }) identity_agnostic_set = set(promoted_identity_agnostic) accepted_output: list[int] = [] duplicate_output_candidates: list[dict[str, Any]] = [] output_boundary_ambiguous = False physical_components = _physical_subject_components( [outputs[column] for column in provisional_output] ) for component in physical_components: columns = [provisional_output[index] for index in component] groups = { output_groups[column] for column in columns if column not in identity_agnostic_set } if len(groups) > 1: output_boundary_ambiguous = True certificate_reasons.append("output_group_boundary_overlap_ambiguous") duplicate_output_candidates.append({ "group_ids": sorted(groups), "candidate_instance_ids": [ _public_instance(outputs[column], column)["instance_id"] for column in columns ], "resolution": "rejected_cross_group_ambiguity", }) continue selected = max( columns, key=lambda column: ( column not in identity_agnostic_set, _geometry_area(outputs[column]) or 0.0, float(outputs[column].get("score") or 0.0), ), ) accepted_output.append(selected) if len(columns) > 1: duplicate_output_candidates.append({ "group_ids": sorted(groups) or ["target_animal_identity_agnostic"], "candidate_instance_ids": [ _public_instance(outputs[column], column)["instance_id"] for column in columns ], "selected_instance_id": _public_instance(outputs[selected], selected)["instance_id"], "resolution": ( "collapsed_identity_agnostic_duplicate_into_species_certified_mask" if selected not in identity_agnostic_set and any(column in identity_agnostic_set for column in columns) else "collapsed_same_target_physical_duplicate" ), }) accepted_output.sort() complete = source_roster_complete and not output_boundary_ambiguous status = "ok" if complete else "insufficient" reason = ( "" if complete else "verified_output_roster_ambiguous" if output_boundary_ambiguous else "verified_source_roster_incomplete" ) image_shapes = { tuple(int(value) for value in item["binary_mask"].shape[:2]) for item in (*inputs, *outputs) if isinstance(item.get("binary_mask"), np.ndarray) and item["binary_mask"].ndim >= 2 } input_public = [_public_instance(item, index) for index, item in enumerate(inputs)] output_public = [_public_instance(item, index) for index, item in enumerate(outputs)] accepted_public = [output_public[index] for index in accepted_output] return { "schema_version": MATCH_SCHEMA_VERSION, "status": status, "reason": reason, "matches": [], "ambiguous_pairs": [], "unmatched_input": [] if source_roster_complete else input_public, "unmatched_output": [ item for index, item in enumerate(output_public) if index not in accepted_output ], "input_count": len(inputs), "output_count": len(outputs), "matched_count": 0, "input_instances": input_public, "output_instances": output_public, "allowed_edit_input_instances": input_public, "allowed_edit_output_instances": accepted_public, "image_shape": list(next(iter(image_shapes))) if len(image_shapes) == 1 else [], "candidate_score_matrix": [ { "output_instance_id": output_public[index]["instance_id"], "output_group_id": ( "target_animal_identity_agnostic" if index in identity_agnostic_set else output_groups[index] ), "area_ratio_to_source_group_median": ( None if output_area_ratios.get(index) is None else round(float(output_area_ratios[index]), 6) ), "accepted_for_allowed_edit_coverage": index in accepted_output, } for index in range(len(outputs)) ], "roster_assignment_certificate": { "profile": VERIFIED_GROUP_ROSTER_PROFILE, "assignment_mode": QUESTION_SUPPORT_COVERAGE_MODE, "status": status, "complete": complete, "source_roster_complete": source_roster_complete, "ambiguity_free": not output_boundary_ambiguous, "identity_assignment_asserted": False, "coverage_scope": ( "source_masks_plus_species_or_certified_identity_agnostic_target_masks" ), "expected_counts": expected_counts, "source_counts": inferred_counts, "matched_instance_ids": sorted( item["instance_id"] for item in input_public if item["instance_id"] ), "allowed_output_instance_ids": [ item["instance_id"] for item in accepted_public ], "allowed_output_count": len(accepted_public), "minimum_area_ratio": config.verified_roster_minimum_area_ratio, "maximum_area_ratio": config.verified_roster_maximum_area_ratio, "identity_agnostic_target_coverage": { "profile": config.identity_agnostic_target_coverage_profile, "status": str(neighbourhood.get("status") or "not_requested"), "identity_assignment_asserted": False, "binary_classifier_scope": "target_animal_vs_protected_and_background", "pooled_source_area_median": pooled_source_area_median, "protected_subject_count": len(protected_instances), "minimum_target_probability": config.target_coverage_minimum_probability, "minimum_target_margin": config.target_coverage_minimum_margin, "minimum_animal_probability": ( config.target_coverage_minimum_animal_probability ), "minimum_animal_margin": config.target_coverage_minimum_animal_margin, "maximum_protected_overlap": ( config.target_coverage_maximum_protected_overlap ), "neighbourhood": neighbourhood, "candidate_count": len(identity_agnostic_audit), "promoted_candidate_count": len(promoted_identity_agnostic), "accepted_after_physical_dedup_count": sum( index in identity_agnostic_set for index in accepted_output ), "candidates": identity_agnostic_audit, }, "rejected_candidates": rejected_candidates, "duplicate_output_candidates": duplicate_output_candidates, "reasons": certificate_reasons, }, "thresholds": { "minimum_confidence": config.minimum_confidence, "ambiguity_margin": config.ambiguity_margin, }, } pair_evidence: list[list[dict[str, Any]]] = [] scores = np.zeros((len(inputs), len(outputs)), dtype=np.float64) candidate_matrix: list[dict[str, Any]] = [] for row, left in enumerate(inputs): evidence_row: list[dict[str, Any]] = [] source_group = _verified_group(left, source=True) for column, right in enumerate(outputs): evidence = pair_similarity(left, right, config=config) output_group = output_groups[column] group_compatible = bool(source_group and source_group == output_group) plausible = column in plausible_by_group.get(source_group, []) score = float(evidence["score"]) if group_compatible and plausible else 0.0 scores[row, column] = score evidence_row.append(evidence) candidate_matrix.append({ "input_instance_id": _public_instance(left, row)["instance_id"], "output_instance_id": _public_instance(right, column)["instance_id"], "source_group_id": source_group, "output_group_id": output_group, "group_compatible": group_compatible, "size_plausible": plausible, "area_ratio_to_source_group_median": ( None if output_area_ratios.get(column) is None else round(float(output_area_ratios[column]), 6) ), "score": round(score, 6), "components": evidence["components"], "rejection_reason": ( "" if group_compatible and plausible else "group_size_implausible" if group_compatible else "group_label_mismatch" ), }) pair_evidence.append(evidence_row) matches: list[dict[str, Any]] = [] ambiguous: list[dict[str, Any]] = [] accepted_input: set[int] = set() accepted_output: set[int] = set() group_certificates: list[dict[str, Any]] = [] for group, expected_count in expected_counts.items(): rows = inferred.get(group, []) columns = plausible_by_group.get(group, []) group_reasons: list[str] = [] if len(rows) != expected_count: group_reasons.append("source_group_cardinality_mismatch") if len(columns) < expected_count: group_reasons.append("output_group_candidates_missing") assignments: list[tuple[int, int]] = [] if rows and columns: local_scores = scores[np.ix_(rows, columns)] assignments = [ (rows[local_row], columns[local_column]) for local_row, local_column in _linear_assignment(local_scores) ] selected_columns = {column for _, column in assignments} unselected_columns = [column for column in columns if column not in selected_columns] selected_scores = [float(scores[row, column]) for row, column in assignments] best_unselected = max( [0.0, *[float(scores[row, column]) for row in rows for column in unselected_columns]] ) boundary_margin = ( min(selected_scores) - best_unselected if len(assignments) == expected_count and selected_scores else float("-inf") ) if selected_scores and min(selected_scores) < config.minimum_confidence: group_reasons.append("group_assignment_below_minimum_confidence") if len(columns) > expected_count and boundary_margin < config.ambiguity_margin: group_reasons.append("group_boundary_assignment_ambiguous") group_ok = not group_reasons and len(assignments) == expected_count for row, column in assignments: score = float(scores[row, column]) row_alternatives = [ float(scores[row, other]) for other in columns if other != column ] column_alternatives = [ float(scores[other, column]) for other in rows if other != row ] individual_margin = score - max([0.0, *row_alternatives, *column_alternatives]) selection_margin = score - best_unselected record = { "input": _public_instance(inputs[row], row), "output": _public_instance(outputs[column], column), "confidence": round(score, 6), "margin": round(selection_margin, 6), "individual_identity_margin": round(individual_margin, 6), "assignment_scope": "verified_group_set_not_individual_identity", "group_id": group, "area_ratio_to_source_group_median": round(float(output_area_ratios[column]), 6), **pair_evidence[row][column], } record["confidence"] = round(score, 6) if group_ok: matches.append(record) accepted_input.add(row) accepted_output.add(column) elif "group_boundary_assignment_ambiguous" in group_reasons: record["rejection_reason"] = "ambiguous_group_boundary" ambiguous.append(record) group_certificates.append({ "group_id": group, "expected_count": expected_count, "source_count": len(rows), "plausible_output_count": len(columns), "rejected_output_count": sum( item.get("group_id") == group for item in rejected_candidates ), "selected_output_instance_ids": [ _public_instance(outputs[column], column)["instance_id"] for _, column in assignments ], "minimum_selected_confidence": ( None if not selected_scores else round(min(selected_scores), 6) ), "group_boundary_margin": ( None if not np.isfinite(boundary_margin) else round(float(boundary_margin), 6) ), "complete": group_ok, "ambiguity_free": "group_boundary_assignment_ambiguous" not in group_reasons, "reasons": group_reasons, }) complete = not certificate_reasons and len(accepted_input) == len(inputs) ambiguity_free = not ambiguous and all(row["ambiguity_free"] for row in group_certificates) if ambiguous: reason = "ambiguous_assignments" elif not complete: reason = "verified_roster_incomplete" else: reason = "" status = "ok" if complete and ambiguity_free else "insufficient" image_shapes = { tuple(int(value) for value in item["binary_mask"].shape[:2]) for item in (*inputs, *outputs) if isinstance(item.get("binary_mask"), np.ndarray) and item["binary_mask"].ndim >= 2 } return { "schema_version": MATCH_SCHEMA_VERSION, "status": status, "reason": reason, "matches": matches, "ambiguous_pairs": ambiguous, "unmatched_input": [ _public_instance(item, index) for index, item in enumerate(inputs) if index not in accepted_input ], "unmatched_output": [ _public_instance(item, index) for index, item in enumerate(outputs) if index not in accepted_output ], "input_count": len(inputs), "output_count": len(outputs), "matched_count": len(matches), "input_instances": [_public_instance(item, index) for index, item in enumerate(inputs)], "output_instances": [_public_instance(item, index) for index, item in enumerate(outputs)], "image_shape": list(next(iter(image_shapes))) if len(image_shapes) == 1 else [], "candidate_score_matrix": candidate_matrix, "roster_assignment_certificate": { "profile": VERIFIED_GROUP_ROSTER_PROFILE, "status": status, "complete": complete, "ambiguity_free": ambiguity_free, "expected_counts": expected_counts, "source_counts": inferred_counts, "minimum_area_ratio": config.verified_roster_minimum_area_ratio, "maximum_area_ratio": config.verified_roster_maximum_area_ratio, "groups": group_certificates, "rejected_candidates": rejected_candidates, "reasons": certificate_reasons, }, "thresholds": { "minimum_confidence": config.minimum_confidence, "ambiguity_margin": config.ambiguity_margin, }, } def match_instances( input_instances: Sequence[Mapping[str, Any]], output_instances: Sequence[Mapping[str, Any]], *, config: MatchConfig | None = None, protected_instances: Sequence[Mapping[str, Any]] = (), ) -> dict[str, Any]: """Return one-to-one assignments and fail-closed ambiguity metadata.""" cfg = config or MatchConfig() inputs, outputs = list(input_instances), list(output_instances) if not inputs: return { "schema_version": MATCH_SCHEMA_VERSION, "status": "insufficient", "reason": "no_input_instances", "matches": [], "unmatched_input": [], "unmatched_output": [_public_instance(item, index) for index, item in enumerate(outputs)], } if cfg.verified_roster_profile == VERIFIED_GROUP_ROSTER_PROFILE: return _match_verified_group_roster( inputs, outputs, config=cfg, protected_instances=protected_instances, ) if not outputs: return { "schema_version": MATCH_SCHEMA_VERSION, "status": "ok", "reason": "no_output_instances", "matches": [], "unmatched_input": [_public_instance(item, index) for index, item in enumerate(inputs)], "unmatched_output": [], "ambiguous_pairs": [], "thresholds": {"minimum_confidence": cfg.minimum_confidence, "ambiguity_margin": cfg.ambiguity_margin}, } pair_evidence: list[list[dict[str, Any]]] = [] scores = np.zeros((len(inputs), len(outputs)), dtype=np.float64) for row, left in enumerate(inputs): evidence_row = [] for column, right in enumerate(outputs): evidence = pair_similarity(left, right, config=cfg) evidence_row.append(evidence) scores[row, column] = evidence["score"] pair_evidence.append(evidence_row) matches, ambiguous = [], [] accepted_input: set[int] = set() accepted_output: set[int] = set() for row, column in _linear_assignment(scores): score = float(scores[row, column]) row_alternatives = [float(scores[row, j]) for j in range(scores.shape[1]) if j != column] column_alternatives = [float(scores[i, column]) for i in range(scores.shape[0]) if i != row] alternative = max([0.0, *row_alternatives, *column_alternatives]) margin = score - alternative record = { "input": _public_instance(inputs[row], row), "output": _public_instance(outputs[column], column), "confidence": round(score, 6), "margin": round(margin, 6), **pair_evidence[row][column], } record["confidence"] = round(score, 6) if score < cfg.minimum_confidence: record["rejection_reason"] = ( "semantic_class_mismatch" if not record.get("category_compatible", True) else "below_minimum_confidence" ) continue if margin < cfg.ambiguity_margin: record["rejection_reason"] = "ambiguous_best_match" ambiguous.append(record) continue accepted_input.add(row) accepted_output.add(column) matches.append(record) status = "insufficient" if ambiguous else "ok" image_shapes = { tuple(int(value) for value in item["binary_mask"].shape[:2]) for item in (*inputs, *outputs) if isinstance(item.get("binary_mask"), np.ndarray) and item["binary_mask"].ndim >= 2 } pairwise_mask_iou = [ { "input_instance_id": _public_instance(inputs[row], row)["instance_id"], "output_instance_id": _public_instance(outputs[column], column)["instance_id"], "source_output_mask_iou": evidence.get("source_output_mask_iou"), "source_zone_output_overlap_ratio": evidence.get("source_zone_output_overlap_ratio"), } for row, evidence_row in enumerate(pair_evidence) for column, evidence in enumerate(evidence_row) if evidence.get("source_output_mask_iou") is not None ] return { "schema_version": MATCH_SCHEMA_VERSION, "status": status, "reason": "ambiguous_assignments" if ambiguous else "", "matches": matches, "ambiguous_pairs": ambiguous, "unmatched_input": [_public_instance(item, index) for index, item in enumerate(inputs) if index not in accepted_input], "unmatched_output": [_public_instance(item, index) for index, item in enumerate(outputs) if index not in accepted_output], "input_count": len(inputs), "output_count": len(outputs), "matched_count": len(matches), "input_instances": [_public_instance(item, index) for index, item in enumerate(inputs)], "output_instances": [_public_instance(item, index) for index, item in enumerate(outputs)], "image_shape": list(next(iter(image_shapes))) if len(image_shapes) == 1 else [], "pairwise_source_output_mask_iou": pairwise_mask_iou, "thresholds": {"minimum_confidence": cfg.minimum_confidence, "ambiguity_margin": cfg.ambiguity_margin}, } def deduplicate_instances( items: Iterable[Mapping[str, Any]], *, iou_threshold: float = 0.75, preserve_nested_query_roles: bool = False, ) -> list[dict[str, Any]]: """Class-aware NMS for repeated fused detector/mask rows. Group-pose programs deliberately request an aggregate and its physical components. Their boxes are nested by design, so callers may disable the smaller-box containment shortcut while retaining ordinary high-IoU NMS. """ def iou(left: list[float], right: list[float]) -> float: x0, y0 = max(left[0], right[0]), max(left[1], right[1]) x1, y1 = min(left[2], right[2]), min(left[3], right[3]) intersection = max(0.0, x1 - x0) * max(0.0, y1 - y0) union = max(0.0, left[2] - left[0]) * max(0.0, left[3] - left[1]) + max(0.0, right[2] - right[0]) * max(0.0, right[3] - right[1]) - intersection return 0.0 if union <= 0 else intersection / union def smaller_overlap(left: list[float], right: list[float]) -> float: x0, y0 = max(left[0], right[0]), max(left[1], right[1]) x1, y1 = min(left[2], right[2]), min(left[3], right[3]) intersection = max(0.0, x1 - x0) * max(0.0, y1 - y0) left_area = max(0.0, left[2] - left[0]) * max(0.0, left[3] - left[1]) right_area = max(0.0, right[2] - right[0]) * max(0.0, right[3] - right[1]) denominator = min(left_area, right_area) return 0.0 if denominator <= 0 else intersection / denominator ordered = sorted((dict(item) for item in items if _bbox(item) is not None), key=lambda item: float(item.get("score") or 0.0), reverse=True) kept: list[dict[str, Any]] = [] for item in ordered: duplicate = next(( existing for existing in kept if ( semantic_class(item) not in {"", "unknown"} and semantic_class(item) == semantic_class(existing) or semantic_similarity(item, existing) >= 0.5 ) and ( iou(_bbox(item) or [], _bbox(existing) or []) >= iou_threshold or ( not preserve_nested_query_roles and smaller_overlap(_bbox(item) or [], _bbox(existing) or []) >= 0.82 ) ) ), None) if duplicate is not None: aliases = [ *duplicate.get("query_aliases", []), duplicate.get("query_text", ""), *item.get("query_aliases", []), item.get("query_text", ""), ] duplicate["query_aliases"] = list(dict.fromkeys(str(value) for value in aliases if str(value or "").strip())) continue item["query_aliases"] = list(dict.fromkeys([ *[str(value) for value in item.get("query_aliases", []) if str(value or "").strip()], str(item.get("query_text") or ""), ])) item.setdefault("instance_id", f"instance_{len(kept):03d}") kept.append(item) return kept
"""Objective input/output instance matching for PVR tool evidence.
The matcher is deliberately model-agnostic. Executors may provide CLIP crop
embeddings, while unit tests and CPU-only runs can omit them. Detector label,
colour and shape evidence remain separately visible in every assignment so a
reviewer can tell why two instances were paired.
"""
from __future__ import annotations
from dataclasses import dataclass, field
import re
from typing import Any, Iterable, Mapping, Sequence
import numpy as np
from pvr_eval.agent.detector_fusion import semantic_class
MATCH_SCHEMA_VERSION = "pvr.instance_matches.v1"
@dataclass(frozen=True)
class MatchConfig:
minimum_confidence: float = 0.55
ambiguity_margin: float = 0.04
semantic_weight: float = 0.30
clip_weight: float = 0.40
foreground_clip_weight: float = 0.20
colour_weight: float = 0.20
shape_weight: float = 0.10
mask_shape_weight: float = 0.0
spatial_weight: float = 0.0
verified_roster_profile: str = ""
verified_roster_assignment_mode: str = "identity_exact"
verified_roster_expected_counts: Mapping[str, int] = field(default_factory=dict)
verified_roster_minimum_area_ratio: float = 0.10
verified_roster_maximum_area_ratio: float = 6.0
identity_agnostic_target_coverage_profile: str = ""
target_coverage_minimum_probability: float = 0.50
target_coverage_minimum_margin: float = 0.15
target_coverage_minimum_animal_probability: float = 0.75
target_coverage_minimum_animal_margin: float = 0.50
target_coverage_maximum_protected_overlap: float = 0.10
target_coverage_neighborhood_fraction_of_diagonal: float = 0.08
VERIFIED_GROUP_ROSTER_PROFILE = "verified_group_roster_assignment_v1"
QUESTION_SUPPORT_COVERAGE_MODE = "question_support_allowed_edit_coverage_v1"
PROTECTED_SUBJECT_ROSTER_PROFILE = "protected_subject_roster_clearance_v1"
IDENTITY_AGNOSTIC_TARGET_COVERAGE_PROFILE = "identity_agnostic_target_animal_coverage_v1"
def _tokens(value: Any) -> set[str]:
stop = {"a", "an", "the", "and", "or", "of", "on", "in", "at", "to", "with", "object", "item"}
return {
token
for token in re.findall(r"[a-z0-9]+", str(value or "").lower().replace("grey", "gray"))
if token not in stop
}
def _normalise_group(value: Any) -> str:
tokens = sorted(_tokens(str(value or "").replace("_", " ")))
normalised = " ".join(tokens)
if normalised.endswith("s") and not normalised.endswith("ss"):
normalised = normalised[:-1]
return normalised
def _verified_group(item: Mapping[str, Any], *, source: bool) -> str:
values = (
(item.get("group_id"), item.get("matching_class"), item.get("semantic_class"), item.get("label"))
if source
else (item.get("verified_roster_group"), item.get("predicted_class"), item.get("semantic_class"))
)
for value in values:
group = _normalise_group(value)
if group and group != "unknown":
return group
return ""
def _geometry_area(item: Mapping[str, Any]) -> float | None:
mask = item.get("binary_mask")
if isinstance(mask, np.ndarray) and mask.size:
area = float(np.count_nonzero(mask))
if area > 0:
return area
box = _bbox(item)
if box is None:
return None
area = max(0.0, box[2] - box[0]) * max(0.0, box[3] - box[1])
return area if area > 0 else None
def semantic_similarity(left: Mapping[str, Any], right: Mapping[str, Any]) -> float:
"""Conservative class compatibility in ``[0, 0.75]``.
Identical query strings are detector requests, not independent proof that