| |
| """v5.2-rc5 evaluator with hybrid, causally isolated view-layout offsets. |
| |
| RC5 retains every RC3 component except layout. A semantic role offset is the |
| coordinate median of raw offsets from its already one-to-one matched |
| primitives (LINE midpoint, CIRCLE/ARC centre). One match is sufficient. Only |
| with zero matched pairs is RC3's parameter-stable view anchor used as an |
| explicit fallback. Layout fails closed to zero when evidence is unavailable. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import copy |
| import math |
| from itertools import combinations |
| from pathlib import Path |
| from typing import Any, Mapping, Sequence |
|
|
| import numpy as np |
|
|
| try: |
| from . import eval_geometric052_rc3 as RC3 |
| except ImportError: |
| import eval_geometric052_rc3 as RC3 |
|
|
|
|
| METRIC_VERSION = "v5.2-rc5" |
| SCHEMA_VERSION = "edp-geometric-evaluator-v5.2-rc5" |
| ENGINEERING_THRESHOLDS = dict(RC3.ENGINEERING_THRESHOLDS) |
| PHYSICAL_SUPPORTED_SEMANTICS = RC3.PHYSICAL_SUPPORTED_SEMANTICS |
| OFFSET_DEFINITION = "GT_anchor-global_scale*Pred_anchor" |
|
|
|
|
| def _visibility(layer: Any) -> str: |
| token = str(layer).casefold() |
| return "hidden" if "hidden" in token or "dash" in token else "visible" |
|
|
|
|
| def _family_entities(entities: Mapping[str, Any], family: str) -> list[Any]: |
| if family in {"visible_line", "hidden_line"}: |
| expected = "visible" if family == "visible_line" else "hidden" |
| return [ |
| item |
| for item in entities.get("lines", []) |
| if isinstance(item, Sequence) |
| and not isinstance(item, (str, bytes)) |
| and item |
| and _visibility(item[-1]) == expected |
| ] |
| return list(entities.get("circles" if family == "circle" else "arcs", [])) |
|
|
|
|
| def _anchor(item: Sequence[Any], family: str) -> np.ndarray | None: |
| try: |
| if family in {"visible_line", "hidden_line"}: |
| if len(item) < 4: |
| return None |
| return np.asarray( |
| ( |
| 0.5 * (float(item[0]) + float(item[2])), |
| 0.5 * (float(item[1]) + float(item[3])), |
| ), |
| dtype=float, |
| ) |
| if len(item) < 2: |
| return None |
| return np.asarray((float(item[0]), float(item[1])), dtype=float) |
| except (TypeError, ValueError): |
| return None |
|
|
|
|
| def _role_offset( |
| context: Mapping[str, Any], |
| rows: Mapping[str, Any], |
| role: str, |
| *, |
| scale: float, |
| sheet_diagonal: float, |
| ) -> tuple[np.ndarray | None, dict[str, Any]]: |
| pred_index = rows[role].get("predicted_view_index") |
| if not isinstance(pred_index, int) or not 0 <= pred_index < len(context["pred_views"]): |
| return None, { |
| "offset": None, |
| "support_count": 0, |
| "fallback_used": False, |
| "offset_source": "unavailable", |
| "offset_dispersion_fraction": None, |
| } |
| pred_view = context["pred_views"][pred_index] |
| gt_view = context["gt_by_role"][role] |
| pred_entities = pred_view.get("entities", {}) |
| gt_entities = gt_view.get("entities", {}) |
| offsets: list[np.ndarray] = [] |
| matched_by_family: dict[str, int] = {} |
| predicted_count = 0 |
| target_count = 0 |
| for family in ("visible_line", "hidden_line", "circle", "arc"): |
| predicted = _family_entities(pred_entities, family) |
| target = _family_entities(gt_entities, family) |
| predicted_count += len(predicted) |
| target_count += len(target) |
| accepted = 0 |
| for pair in rows[role]["primitive"][family].get("pairs", []): |
| try: |
| pred_item = predicted[int(pair["predicted_index"])] |
| gt_item = target[int(pair["target_index"])] |
| except (KeyError, TypeError, ValueError, IndexError): |
| continue |
| pred_anchor = _anchor(pred_item, family) |
| gt_anchor = _anchor(gt_item, family) |
| if pred_anchor is None or gt_anchor is None: |
| continue |
| offsets.append(gt_anchor - scale * pred_anchor) |
| accepted += 1 |
| matched_by_family[family] = accepted |
|
|
| support = len(offsets) |
| fallback_used = False |
| source = "matched_primitive_pair_median" |
| if support: |
| offset = np.median(np.asarray(offsets, dtype=float), axis=0) |
| dispersion = float( |
| np.median([np.linalg.norm(item - offset) for item in offsets]) |
| / sheet_diagonal |
| ) |
| else: |
| pred_anchor = pred_view.get("layout_anchor") |
| gt_anchor = gt_view.get("layout_anchor") |
| if pred_anchor is None or gt_anchor is None: |
| offset = None |
| else: |
| offset = np.asarray(gt_anchor, dtype=float) - scale * np.asarray( |
| pred_anchor, dtype=float |
| ) |
| fallback_used = True |
| dispersion = None |
| source = "fallback_parameter_stable_view_anchor" |
|
|
| precision = support / predicted_count if predicted_count else 0.0 |
| recall = support / target_count if target_count else 0.0 |
| return offset, { |
| "offset": [RC3.BASE._round(float(value)) for value in offset] |
| if offset is not None |
| else None, |
| "support_count": support, |
| "matched_by_family": matched_by_family, |
| "fallback_used": fallback_used, |
| "offset_source": source if offset is not None else "unavailable", |
| "predicted_anchor_count": predicted_count, |
| "target_anchor_count": target_count, |
| "anchor_precision": RC3.BASE._round(precision), |
| "anchor_recall": RC3.BASE._round(recall), |
| "offset_dispersion_fraction": RC3.BASE._round(dispersion), |
| } |
|
|
|
|
| def _layout_component( |
| context: Mapping[str, Any], rows: Mapping[str, Any] |
| ) -> dict[str, Any]: |
| roles = [str(role) for role, row in rows.items() if row["present"]] |
| alignment = context["alignment"] |
| scale = float(alignment.get("global_scale", 1.0)) |
| sheet_diagonal = max(float(alignment.get("sheet_diagonal", 1.0)), 1.0) |
| if len(roles) < 2: |
| return RC3.BASE._component( |
| 0.0, |
| True, |
| "insufficient_layout_evidence", |
| matched_roles=roles, |
| global_scale=RC3.BASE._round(scale), |
| core_component_fail_closed=True, |
| ) |
|
|
| offsets: dict[str, np.ndarray] = {} |
| diagnostics: dict[str, Any] = {} |
| for role in roles: |
| offset, detail = _role_offset( |
| context, rows, role, scale=scale, sheet_diagonal=sheet_diagonal |
| ) |
| diagnostics[role] = detail |
| if offset is not None: |
| offsets[role] = offset |
| missing = [role for role in roles if role not in offsets] |
| if missing: |
| return RC3.BASE._component( |
| 0.0, |
| True, |
| "insufficient_layout_evidence", |
| matched_roles=roles, |
| missing_offset_roles=missing, |
| role_offsets=diagnostics, |
| global_scale=RC3.BASE._round(scale), |
| scale_source="alignment.global_scale", |
| core_component_fail_closed=True, |
| ) |
|
|
| errors: list[float] = [] |
| pair_rows: list[dict[str, Any]] = [] |
| for first, second in combinations(roles, 2): |
| error = float(np.linalg.norm(offsets[second] - offsets[first]) / sheet_diagonal) |
| errors.append(error) |
| pair_rows.append( |
| {"roles": [first, second], "offset_error_fraction": RC3.BASE._round(error)} |
| ) |
| mean_error = float(np.mean(errors)) |
| score = math.exp(-mean_error / 0.10) |
| dispersions = [ |
| float(detail["offset_dispersion_fraction"]) |
| for detail in diagnostics.values() |
| if detail.get("offset_dispersion_fraction") is not None |
| ] |
| return RC3.BASE._component( |
| score, |
| True, |
| "ok" if mean_error <= 0.02 else "relative_view_layout_mismatch", |
| matched_roles=roles, |
| mean_pair_offset_error_fraction=RC3.BASE._round(mean_error), |
| pairs=pair_rows, |
| role_offsets=diagnostics, |
| matched_support_total=sum( |
| int(detail["support_count"]) for detail in diagnostics.values() |
| ), |
| fallback_role_count=sum( |
| bool(detail["fallback_used"]) for detail in diagnostics.values() |
| ), |
| offset_dispersion_macro=RC3.BASE._round(float(np.mean(dispersions))) |
| if dispersions |
| else None, |
| offset_definition=OFFSET_DEFINITION, |
| global_scale=RC3.BASE._round(scale), |
| scale_source="alignment.global_scale", |
| uniform_sheet_scale_invariant=True, |
| global_translation_invariant=True, |
| core_component_fail_closed=True, |
| ) |
|
|
|
|
| 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]: |
| """Run RC3 once, then replace layout and all dependent aggregates.""" |
|
|
| result = RC3.score_dxf_pair( |
| pred, gt, sidecar=sidecar, category=category, **kwargs |
| ) |
| result["schema_version"] = SCHEMA_VERSION |
| result["metric_version"] = METRIC_VERSION |
| result.setdefault("metric_definition", {}).update( |
| { |
| "layout_offset_formula": OFFSET_DEFINITION, |
| "layout_anchor_sources": [ |
| "line_midpoint", |
| "circle_center", |
| "arc_center", |
| ], |
| "layout_hybrid_policy": ( |
| "matched_pair_if_support_ge_1_else_parameter_stable_view_anchor" |
| ), |
| "layout_failure_policy": "core_component_score_zero", |
| } |
| ) |
|
|
| context = RC3._consume_appended_omitted_marker( |
| RC3.MATCH.build_pair_context(pred, gt, sidecar=sidecar) |
| ) |
| if context.get("eligible") and context.get("prediction_valid"): |
| rows, _curve = RC3.BASE._semantic_rows(context) |
| layout = _layout_component(context, rows) |
| components = result["components"] |
| components["layout"] = layout |
| prompt_components = result["online_reward_prompt_masked"]["components"] |
| prompt_components["layout"] = copy.deepcopy(layout) |
| atomic = result.get("diagnostics", {}).get("atomic_geometry", {}) |
| result["verified_reward_full_gt"] = RC3._scoped_hierarchical_reward( |
| components, atomic, scope="offline_full_gt_executed_dxf" |
| ) |
| prompt_reward = RC3._scoped_hierarchical_reward( |
| prompt_components, atomic, scope="prompt_masked_actual_geometry" |
| ) |
| result["online_reward_prompt_masked"] = { |
| **prompt_reward, |
| "components": prompt_components, |
| } |
| result["benchmark"] = RC3._benchmark(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", |
| "METRIC_VERSION", |
| "OFFSET_DEFINITION", |
| "PHYSICAL_SUPPORTED_SEMANTICS", |
| "SCHEMA_VERSION", |
| "score_dxf_pair", |
| ] |
|
|
