| |
| """Prompt-observable v5.1 wrapper around the frozen geometric-v5 evaluator. |
| |
| The expensive and representation-sensitive geometry implementation remains in |
| ``eval_geometric05``. This module changes only the supervision contract: |
| |
| * online physical/annotation scores consume explicit v5.1 sidecar masks; |
| * unmasked GT dimensions are unknown, never model errors; |
| * full-GT reconstruction is retained as a diagnostic; |
| * the strict ``engineering_success`` alias refers only to the certified scope. |
| |
| There is deliberately no fallback to the legacy ``fmfs.eligible`` field. A |
| missing or malformed v5.1 manifest masks physical and annotation supervision. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import copy |
| import math |
| from pathlib import Path |
| from typing import Any, Mapping, Sequence |
|
|
| import numpy as np |
|
|
| try: |
| from . import eval_geometric05 as EV5 |
| except ImportError: |
| import eval_geometric05 as EV5 |
|
|
|
|
| METRIC_VERSION = "v5.1" |
| FMFS_VERSION = "fmfs-v5.1" |
| ENGINEERING_THRESHOLDS = dict(EV5.ENGINEERING_THRESHOLDS) |
| _SCOPE_NAMES = ("prompt", "full_gt", "certified") |
|
|
|
|
| def _unknown_component(reason: str, *, scope: str, **details: Any) -> dict[str, Any]: |
| return EV5._component(None, False, reason, scope=scope, **details) |
|
|
|
|
| def _zero_component(reason: str, *, scope: str, **details: Any) -> dict[str, Any]: |
| return EV5._component(0.0, True, reason, scope=scope, **details) |
|
|
|
|
| def _bool_mask(value: Any, length: int) -> list[bool] | None: |
| if not isinstance(value, Sequence) or isinstance(value, (str, bytes)): |
| return None |
| if len(value) != length or any(type(item) is not bool for item in value): |
| return None |
| return list(value) |
|
|
|
|
| def _dimension_specs(sidecar: Mapping[str, Any] | None) -> tuple[list[dict[str, Any]], list[str]]: |
| errors: list[str] = [] |
| dimensions = sidecar.get("dimensions") if isinstance(sidecar, Mapping) else None |
| raw_items = dimensions.get("items") if isinstance(dimensions, Mapping) else None |
| if not isinstance(raw_items, Sequence) or isinstance(raw_items, (str, bytes)): |
| return [], ["missing_dimensions_items"] |
| specs: list[dict[str, Any]] = [] |
| for position, raw in enumerate(raw_items): |
| if not isinstance(raw, Mapping): |
| errors.append(f"invalid_dimension_item:{position}") |
| continue |
| try: |
| gt_index = int(raw.get("index", raw.get("gt_dimension_index"))) |
| value = float(raw.get("display_value", raw.get("value"))) |
| except (TypeError, ValueError): |
| errors.append(f"invalid_dimension_value_or_index:{position}") |
| continue |
| family = str(raw.get("family") or "").lower() |
| if family not in EV5.DIMENSION_FAMILIES or not math.isfinite(value): |
| errors.append(f"invalid_dimension_family_or_value:{position}") |
| continue |
| specs.append( |
| { |
| "position": position, |
| "id": str(raw.get("id") or f"d{position:03d}"), |
| "gt_dimension_index": gt_index, |
| "family": family, |
| "value": abs(value), |
| "reliable": bool(raw.get("reliable", True)), |
| } |
| ) |
| if len(specs) != len(raw_items): |
| errors.append("dimension_inventory_not_total") |
| return specs, errors |
|
|
|
|
| def _scope_contracts(sidecar: Mapping[str, Any] | None) -> dict[str, Any]: |
| """Fail-closed parser for the v5.1 item-mask contract.""" |
|
|
| specs, errors = _dimension_specs(sidecar) |
| length = len(specs) |
| fmfs = sidecar.get("fmfs") if isinstance(sidecar, Mapping) else None |
| valid_version = isinstance(fmfs, Mapping) and fmfs.get("version") == FMFS_VERSION |
| if not valid_version: |
| errors.append("missing_or_legacy_fmfs_contract") |
| prompt = fmfs.get("prompt") if valid_version else None |
| certified = fmfs.get("certified") if valid_version else None |
|
|
| def parsed_mask(container: Any, key: str) -> list[bool] | None: |
| return _bool_mask(container.get(key), length) if isinstance(container, Mapping) else None |
|
|
| prompt_physical = parsed_mask(prompt, "physical_item_mask") |
| prompt_annotation = parsed_mask(prompt, "annotation_item_mask") |
| certified_physical = parsed_mask(certified, "physical_item_mask") |
| certified_annotation = parsed_mask(certified, "annotation_item_mask") |
| full_mask = [True] * length |
| dimensions = sidecar.get("dimensions") if isinstance(sidecar, Mapping) else None |
| full_eligible = bool( |
| valid_version |
| and specs |
| and not errors |
| and all(item["reliable"] for item in specs) |
| and ( |
| not isinstance(dimensions, Mapping) |
| or int(dimensions.get("reliable_count", length)) == length |
| ) |
| ) |
| prompt_physical_eligible = bool( |
| isinstance(prompt, Mapping) |
| and prompt.get("physical_eligible") |
| and prompt_physical is not None |
| and any(prompt_physical) |
| and not errors |
| ) |
| prompt_annotation_eligible = bool( |
| isinstance(prompt, Mapping) |
| and prompt.get("annotation_eligible") |
| and prompt_annotation is not None |
| and any(prompt_annotation) |
| and not errors |
| ) |
| certified_eligible = bool( |
| isinstance(certified, Mapping) |
| and certified.get("eligible") |
| and certified.get("status") == "certified" |
| and certified_physical is not None |
| and certified_annotation is not None |
| and any(certified_physical) |
| and any(certified_annotation) |
| and not errors |
| ) |
| return { |
| "valid": valid_version and not errors, |
| "errors": errors, |
| "n_dimension_items": length, |
| "specs": specs, |
| "prompt": { |
| "physical_eligible": prompt_physical_eligible, |
| "annotation_eligible": prompt_annotation_eligible, |
| "physical_mask": prompt_physical or [False] * length, |
| "annotation_mask": prompt_annotation or [False] * length, |
| "reason_codes": list(prompt.get("reason_codes", [])) if isinstance(prompt, Mapping) else [], |
| }, |
| "full_gt": { |
| "physical_eligible": full_eligible, |
| "annotation_eligible": full_eligible, |
| "physical_mask": full_mask if full_eligible else [False] * length, |
| "annotation_mask": full_mask if full_eligible else [False] * length, |
| "reason_codes": [] if full_eligible else ["full_gt_dimension_inventory_ineligible"], |
| }, |
| "certified": { |
| "physical_eligible": certified_eligible, |
| "annotation_eligible": certified_eligible, |
| "physical_mask": certified_physical or [False] * length, |
| "annotation_mask": certified_annotation or [False] * length, |
| "status": certified.get("status", "unknown") if isinstance(certified, Mapping) else "unknown", |
| "reason_codes": list(certified.get("reason_codes", [])) if isinstance(certified, Mapping) else [], |
| }, |
| } |
|
|
|
|
| def _pair_context(pred: str | Path, gt: str | Path) -> dict[str, Any]: |
| pred_path, gt_path = Path(pred), Path(gt) |
| pred_meta, gt_meta = EV5._read_structure(pred_path), EV5._read_structure(gt_path) |
| raw_gt = EV5._extract_entities(gt_path) if gt_meta.get("readable") else None |
| target_valid = bool( |
| raw_gt is not None |
| and EV5._n_geometry(raw_gt) > 0 |
| and EV5._safe_bbox(raw_gt) is not None |
| ) |
| raw_pred = EV5._extract_entities(pred_path) if pred_meta.get("readable") else None |
| prediction_valid = bool( |
| raw_pred is not None |
| and EV5._n_geometry(raw_pred) > 0 |
| and EV5._safe_bbox(raw_pred) is not None |
| ) |
| context: dict[str, Any] = { |
| "target_valid": target_valid, |
| "prediction_valid": prediction_valid, |
| "pred_meta": pred_meta, |
| "gt_meta": gt_meta, |
| "raw_pred": raw_pred, |
| "raw_gt": raw_gt, |
| } |
| if not target_valid or not prediction_valid: |
| return context |
| canonical_pred = EV5.EV4.canonicalize_entities(raw_pred) |
| canonical_gt = EV5.EV4.canonicalize_entities(raw_gt) |
| source_center, target_center, global_scale = EV5.EV3.shared_alignment( |
| canonical_pred, canonical_gt |
| ) |
| context.update( |
| { |
| "canonical_pred": canonical_pred, |
| "canonical_gt": canonical_gt, |
| "source_center": source_center, |
| "target_center": target_center, |
| "global_scale": global_scale, |
| } |
| ) |
| return context |
|
|
|
|
| def _selected_specs(contract: Mapping[str, Any], mask: Sequence[bool]) -> list[dict[str, Any]]: |
| return [dict(spec) for spec, selected in zip(contract.get("specs", []), mask) if selected] |
|
|
|
|
| def _masked_component( |
| context: Mapping[str, Any], |
| contract: Mapping[str, Any], |
| mask: Sequence[bool], |
| *, |
| eligible: bool, |
| scope: str, |
| component_name: str, |
| ) -> dict[str, Any]: |
| selected = _selected_specs(contract, mask) |
| item_ids = [item["id"] for item in selected] |
| if not context.get("target_valid"): |
| return _unknown_component( |
| "target_dxf_unreadable_or_degenerate", scope=scope, item_ids=item_ids |
| ) |
| if not eligible or not selected: |
| return _unknown_component( |
| "sidecar_item_mask_ineligible", |
| scope=scope, |
| item_ids=item_ids, |
| contract_errors=list(contract.get("errors", [])), |
| ) |
| if not context.get("prediction_valid"): |
| return _zero_component( |
| "prediction_dxf_unreadable_or_degenerate", scope=scope, item_ids=item_ids |
| ) |
|
|
| raw_gt = context["raw_gt"] |
| gt_dims = list(raw_gt.get("dims", [])) |
| selected_dims: list[Any] = [] |
| local_specs: list[dict[str, Any]] = [] |
| for local_index, spec in enumerate(selected): |
| gt_index = int(spec["gt_dimension_index"]) |
| if not 0 <= gt_index < len(gt_dims): |
| return _unknown_component( |
| "sidecar_gt_dimension_index_out_of_range", |
| scope=scope, |
| item_ids=item_ids, |
| bad_gt_dimension_index=gt_index, |
| ) |
| selected_dims.append(gt_dims[gt_index]) |
| local = dict(spec) |
| local["gt_dimension_index"] = local_index |
| local_specs.append(local) |
|
|
| target_subset = dict(raw_gt) |
| target_subset["dims"] = selected_dims |
| _annotation, annotation_diagnostics = EV5._annotation_component( |
| context["raw_pred"], |
| target_subset, |
| np.asarray(context["source_center"]), |
| np.asarray(context["target_center"]), |
| float(context["global_scale"]), |
| context["pred_meta"], |
| ) |
| raw_fmfs = EV5._fmfs_diagnostics( |
| { |
| "fmfs": { |
| "eligible": True, |
| "fully_derivable": scope == "certified", |
| "items": local_specs, |
| } |
| }, |
| context["canonical_pred"], |
| annotation_diagnostics, |
| ) |
| rows = list(raw_fmfs.get("items", [])) |
| item_scores: list[dict[str, Any]] = [] |
| qualities: list[float] = [] |
| for position, spec in enumerate(selected): |
| row = rows[position] if position < len(rows) and isinstance(rows[position], Mapping) else {} |
| value_quality = float(row.get("value_quality", 0.0) or 0.0) |
| type_quality = float(row.get("type_quality", 0.0) or 0.0) |
| binding_quality = float(row.get("binding_quality", 0.0) or 0.0) |
| internal_binding = float(row.get("internal_binding_quality", 0.0) or 0.0) |
| scale_quality = float(row.get("scale_quality", 0.0) or 0.0) |
| physical_quality = value_quality * binding_quality * internal_binding * scale_quality |
| annotation_quality = type_quality * value_quality * binding_quality * internal_binding * scale_quality |
| quality = physical_quality if component_name == "physical" else annotation_quality |
| quality = max(0.0, min(1.0, quality)) |
| qualities.append(quality) |
| item_scores.append( |
| { |
| "id": spec["id"], |
| "gt_dimension_index": spec["gt_dimension_index"], |
| "score": EV5._round(quality), |
| "physical_quality": EV5._round(physical_quality), |
| "annotation_quality": EV5._round(annotation_quality), |
| "raw": dict(row), |
| } |
| ) |
| score = float(np.mean(qualities)) if qualities else 0.0 |
| return EV5._component( |
| score, |
| True, |
| "ok" if score >= ENGINEERING_THRESHOLDS[component_name] else f"masked_{component_name}_mismatch", |
| scope=scope, |
| item_ids=item_ids, |
| n_items=len(item_ids), |
| items=item_scores, |
| raw_fmfs=raw_fmfs, |
| unmasked_prediction_dimensions_ignored=True, |
| ) |
|
|
|
|
| def _scope_components( |
| context: Mapping[str, Any], contract: Mapping[str, Any], scope: str |
| ) -> dict[str, dict[str, Any]]: |
| scope_contract = contract[scope] |
| return { |
| "physical": _masked_component( |
| context, |
| contract, |
| scope_contract["physical_mask"], |
| eligible=bool(scope_contract["physical_eligible"]), |
| scope=scope, |
| component_name="physical", |
| ), |
| "annotation": _masked_component( |
| context, |
| contract, |
| scope_contract["annotation_mask"], |
| eligible=bool(scope_contract["annotation_eligible"]), |
| scope=scope, |
| component_name="annotation", |
| ), |
| } |
|
|
|
|
| def _pass(component: Mapping[str, Any], name: str) -> bool | None: |
| if not component.get("eligible") or not isinstance(component.get("score"), (int, float)): |
| return None |
| return bool(float(component["score"]) >= ENGINEERING_THRESHOLDS[name]) |
|
|
|
|
| def _tri_and(states: Sequence[bool | None]) -> bool | None: |
| if any(value is False for value in states): |
| return False |
| if states and all(value is True for value in states): |
| return True |
| return None |
|
|
|
|
| def _benchmark_scope( |
| base_benchmark: Mapping[str, Any], |
| scope_components: Mapping[str, Mapping[str, Any]], |
| *, |
| target_eligible: bool, |
| ) -> dict[str, Any]: |
| physical_pass = _pass(scope_components["physical"], "physical") if target_eligible else None |
| annotation_pass = _pass(scope_components["annotation"], "annotation") if target_eligible else None |
| states = { |
| "three_views": base_benchmark.get("three_views"), |
| "geometry_pass": base_benchmark.get("geometry_pass"), |
| "physical_pass": physical_pass, |
| "annotation_pass": annotation_pass, |
| "layout_pass": base_benchmark.get("layout_pass"), |
| "structure_pass": base_benchmark.get("structure_pass"), |
| } |
| success = _tri_and(list(states.values())) if target_eligible else None |
| return { |
| **states, |
| "target_eligible": bool(target_eligible), |
| "fully_evaluable": bool(target_eligible and all(value is not None for value in states.values())), |
| "engineering_success": success, |
| } |
|
|
|
|
| def score_dxf_pair( |
| pred: str | Path, |
| gt: str | Path, |
| sidecar: Mapping[str, Any] | None = None, |
| category: str | None = None, |
| **_kwargs: Any, |
| ) -> dict[str, Any]: |
| """Score a pair with prompt-masked online P/A and certified strict success.""" |
|
|
| base = EV5.score_dxf_pair(pred, gt, sidecar=sidecar, category=category) |
| result = copy.deepcopy(base) |
| contract = _scope_contracts(sidecar) |
| context = _pair_context(pred, gt) |
|
|
| |
| |
| |
| |
| annotation_details = ( |
| base.get("components", {}).get("annotation", {}).get("details", {}) |
| ) |
| if not isinstance(annotation_details, Mapping): |
| annotation_details = {} |
| try: |
| predicted_dimension_count = max( |
| 0, |
| int(annotation_details.get("n_pred_native", 0) or 0) |
| + int(annotation_details.get("n_pred_text_only", 0) or 0), |
| ) |
| matched_dimension_count = max( |
| 0, int(annotation_details.get("matched_by_binding", 0) or 0) |
| ) |
| except (TypeError, ValueError): |
| predicted_dimension_count = 0 |
| matched_dimension_count = 0 |
| unmatched_dimension_count = max( |
| 0, predicted_dimension_count - matched_dimension_count |
| ) |
| anti_hack = result.get("anti_hack") |
| if not isinstance(anti_hack, dict): |
| anti_hack = {} |
| result["anti_hack"] = anti_hack |
| true_duplicate_count = float( |
| anti_hack.get("duplicate_dimension_count", 0.0) or 0.0 |
| ) |
| true_duplicate_ratio = float( |
| anti_hack.get("duplicate_dimension_ratio", 0.0) or 0.0 |
| ) |
| unmatched_ratio = unmatched_dimension_count / max(predicted_dimension_count, 1) |
| anti_hack["true_duplicate_dimension_count"] = true_duplicate_count |
| anti_hack["true_duplicate_dimension_ratio"] = true_duplicate_ratio |
| anti_hack["unmatched_dimension_count"] = unmatched_dimension_count |
| anti_hack["unmatched_dimension_ratio"] = unmatched_ratio |
| anti_hack["dimension_spam_count"] = max(true_duplicate_count, unmatched_dimension_count) |
| anti_hack["dimension_spam_ratio"] = max(true_duplicate_ratio, unmatched_ratio) |
| anti_hack["duplicate_dimension_count"] = anti_hack["dimension_spam_count"] |
| anti_hack["duplicate_dimension_ratio"] = anti_hack["dimension_spam_ratio"] |
| if unmatched_dimension_count: |
| flags = anti_hack.setdefault("flags", []) |
| if "unmatched_dimension_entities" not in flags: |
| flags.append("unmatched_dimension_entities") |
|
|
| scopes = { |
| name: _scope_components(context, contract, name) for name in _SCOPE_NAMES |
| } |
|
|
| prompt = scopes["prompt"] |
| result["metric_version"] = METRIC_VERSION |
| result["components"]["physical"] = prompt["physical"] |
| result["components"]["annotation"] = prompt["annotation"] |
| result["online_reward"] = { |
| "scope": "prompt", |
| "components": { |
| name: result["components"][name] |
| for name in ("view", "geometry", "physical", "annotation", "layout", "structure") |
| }, |
| } |
|
|
| base_benchmark = dict(base.get("benchmark", {})) |
| view_count_ok = bool( |
| isinstance(sidecar, Mapping) |
| and isinstance(sidecar.get("views"), Mapping) |
| and sidecar["views"].get("candidate_count") == EV5.VIEW_TARGET_COUNT |
| ) |
| target_valid = bool(context.get("target_valid")) |
| scope_benchmarks: dict[str, Any] = {} |
| for name in _SCOPE_NAMES: |
| scope_contract = contract[name] |
| target_eligible = bool( |
| target_valid |
| and view_count_ok |
| and scope_contract["physical_eligible"] |
| and scope_contract["annotation_eligible"] |
| ) |
| scope_benchmarks[name] = _benchmark_scope( |
| base_benchmark, scopes[name], target_eligible=target_eligible |
| ) |
|
|
| certified = scope_benchmarks["certified"] |
| benchmark = dict(base_benchmark) |
| benchmark.update( |
| { |
| "physical_pass": certified["physical_pass"], |
| "annotation_pass": certified["annotation_pass"], |
| "engineering_eligible": certified["target_eligible"], |
| "engineering_success": certified["engineering_success"], |
| "cad_pass": certified["engineering_success"], |
| "strict_scope": "certified", |
| "scopes": scope_benchmarks, |
| "thresholds": dict(ENGINEERING_THRESHOLDS), |
| } |
| ) |
| result["benchmark"] = benchmark |
| result["engineering_eligible"] = certified["target_eligible"] |
| result["engineering_success"] = certified["engineering_success"] |
| result["diagnostics"]["v5_base_physical"] = base["components"]["physical"] |
| result["diagnostics"]["v5_base_annotation"] = base["components"]["annotation"] |
| result["diagnostics"]["fmfs_v51"] = { |
| "contract": { |
| key: value |
| for key, value in contract.items() |
| if key != "specs" |
| }, |
| "scopes": scopes, |
| "strict_scope": "certified", |
| "legacy_fmfs_fallback": False, |
| } |
| return result |
|
|
|
|
| __all__ = [ |
| "ENGINEERING_THRESHOLDS", |
| "FMFS_VERSION", |
| "METRIC_VERSION", |
| "score_dxf_pair", |
| ] |
|
|
