| |
| """High-dispersion fail-closed gate for the final v5.2 layout verifier. |
| |
| RC5F establishes whether each semantic role has sufficient anchor support. |
| RC5G additionally rejects contradictory matched-pair offsets: whenever a role |
| has at least two matches, its normalized offset dispersion must be present and |
| no greater than 0.02. This prevents a coordinate median from cancelling |
| opposite geometric errors and spuriously increasing the total reward. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import copy |
| import math |
| from pathlib import Path |
| from typing import Any, Mapping |
|
|
| try: |
| from . import eval_geometric052_rc5f as RC5F |
| except ImportError: |
| import eval_geometric052_rc5f as RC5F |
|
|
|
|
| METRIC_VERSION = "v5.2-rc5g" |
| SCHEMA_VERSION = "edp-geometric-evaluator-v5.2-rc5g" |
| ENGINEERING_THRESHOLDS = dict(RC5F.ENGINEERING_THRESHOLDS) |
| PHYSICAL_SUPPORTED_SEMANTICS = RC5F.PHYSICAL_SUPPORTED_SEMANTICS |
| MAX_MATCHED_OFFSET_DISPERSION_FRACTION = 0.02 |
|
|
|
|
| def _dispersion_unreliable_roles( |
| role_offsets: Mapping[str, Any], |
| ) -> list[str]: |
| unreliable: list[str] = [] |
| for role, detail in role_offsets.items(): |
| if not isinstance(detail, Mapping): |
| unreliable.append(str(role)) |
| continue |
| try: |
| support = int(detail.get("support_count", 0) or 0) |
| except (TypeError, ValueError): |
| support = 0 |
| if support < 2: |
| continue |
| dispersion = detail.get("offset_dispersion_fraction") |
| valid = bool( |
| isinstance(dispersion, (int, float)) |
| and not isinstance(dispersion, bool) |
| and math.isfinite(float(dispersion)) |
| and float(dispersion) <= MAX_MATCHED_OFFSET_DISPERSION_FRACTION |
| ) |
| if not valid: |
| unreliable.append(str(role)) |
| return unreliable |
|
|
|
|
| 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]: |
| result = RC5F.score_dxf_pair( |
| pred, gt, sidecar=sidecar, category=category, **kwargs |
| ) |
| result["schema_version"] = SCHEMA_VERSION |
| result["metric_version"] = METRIC_VERSION |
| result.setdefault("metric_definition", {})[ |
| "layout_offset_dispersion_policy" |
| ] = { |
| "applies_when_support_count_ge": 2, |
| "maximum_offset_dispersion_fraction": ( |
| MAX_MATCHED_OFFSET_DISPERSION_FRACTION |
| ), |
| "missing_dispersion_is_unreliable": True, |
| "failure_policy": "active_layout_score_zero", |
| } |
|
|
| layout = result.get("components", {}).get("layout", {}) |
| details = layout.get("details", {}) if isinstance(layout, Mapping) else {} |
| role_offsets = ( |
| details.get("role_offsets", {}) if isinstance(details, Mapping) else {} |
| ) |
| existing = { |
| str(role) |
| for role in details.get("unreliable_roles", []) |
| } if isinstance(details, Mapping) else set() |
| if isinstance(role_offsets, Mapping): |
| existing.update( |
| str(role) |
| for role, detail in role_offsets.items() |
| if isinstance(detail, Mapping) and detail.get("reliable") is False |
| ) |
| high_dispersion = _dispersion_unreliable_roles(role_offsets) |
| else: |
| high_dispersion = [] |
| unreliable = sorted(existing | set(high_dispersion)) |
|
|
| if unreliable: |
| preserved = copy.deepcopy(dict(details)) |
| preserved.setdefault("prior_layout_score", layout.get("score")) |
| preserved.setdefault("prior_layout_reason", layout.get("reason")) |
| preserved.update( |
| { |
| "role_offsets": copy.deepcopy(role_offsets), |
| "unreliable_roles": unreliable, |
| "high_offset_dispersion_roles": sorted(high_dispersion), |
| "maximum_offset_dispersion_fraction": ( |
| MAX_MATCHED_OFFSET_DISPERSION_FRACTION |
| ), |
| "missing_dispersion_is_unreliable": True, |
| "core_component_fail_closed": True, |
| } |
| ) |
| base = RC5F.RC5.RC3.BASE |
| replacement = base._component( |
| 0.0, True, "insufficient_layout_evidence", **preserved |
| ) |
| result["components"]["layout"] = replacement |
| prompt_components = result["online_reward_prompt_masked"]["components"] |
| prompt_components["layout"] = copy.deepcopy(replacement) |
| atomic = result.get("diagnostics", {}).get("atomic_geometry", {}) |
| result["verified_reward_full_gt"] = ( |
| RC5F.RC5.RC3._scoped_hierarchical_reward( |
| result["components"], |
| atomic, |
| scope="offline_full_gt_executed_dxf", |
| ) |
| ) |
| prompt_reward = RC5F.RC5.RC3._scoped_hierarchical_reward( |
| prompt_components, |
| atomic, |
| scope="prompt_masked_actual_geometry", |
| ) |
| result["online_reward_prompt_masked"] = { |
| **prompt_reward, |
| "components": prompt_components, |
| } |
| result["benchmark"] = RC5F.RC5.RC3._benchmark(result["components"]) |
| result["engineering_success"] = result["benchmark"][ |
| "engineering_success" |
| ] |
|
|
| release = result.get("diagnostics", {}).get("release_status") |
| if isinstance(release, dict): |
| release["candidate"] = METRIC_VERSION |
| return result |
|
|
|
|
| __all__ = [ |
| "ENGINEERING_THRESHOLDS", |
| "MAX_MATCHED_OFFSET_DISPERSION_FRACTION", |
| "METRIC_VERSION", |
| "PHYSICAL_SUPPORTED_SEMANTICS", |
| "SCHEMA_VERSION", |
| "score_dxf_pair", |
| ] |
|
|
