| |
| """Open-contour-safe retention candidate layered on v5.2-rc5h. |
| |
| The historical closure-retention formula is ``min(1, predicted / target)``. |
| It is correct whenever the target has at least one joined endpoint, but maps |
| the legitimate ``open target / equally open prediction`` case (0 / 0) to |
| zero. That makes a GT drawing score below one against itself (notably |
| ``0073_00731389``). |
| |
| RC5I treats the target joined-endpoint fraction as a lower-bound requirement: |
| |
| * a prediction at least as closed as the target receives one; |
| * a less-closed prediction receives ``predicted / target``; |
| * a completely open target imposes no closure requirement, so every numeric |
| prediction -- including an equally open one -- receives one. |
| |
| The wrapper preserves RC5H and only replaces changed contour-retention rows, |
| the geometry component derived from those rows, and dependent aggregates. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import copy |
| import math |
| from pathlib import Path |
| from typing import Any, Mapping |
|
|
| try: |
| from . import eval_geometric052_rc5h as RC5H |
| except ImportError: |
| import eval_geometric052_rc5h as RC5H |
|
|
|
|
| METRIC_VERSION = "v5.2-rc5i" |
| SCHEMA_VERSION = "edp-geometric-evaluator-v5.2-rc5i" |
| ENGINEERING_THRESHOLDS = dict(RC5H.ENGINEERING_THRESHOLDS) |
| PHYSICAL_SUPPORTED_SEMANTICS = RC5H.PHYSICAL_SUPPORTED_SEMANTICS |
| MAX_MATCHED_OFFSET_DISPERSION_FRACTION = ( |
| RC5H.MAX_MATCHED_OFFSET_DISPERSION_FRACTION |
| ) |
|
|
| RC3 = RC5H.RC3 |
| BASE = RC5H.BASE |
| OPEN_TARGET_EPSILON = 1.0e-12 |
|
|
|
|
| def _finite_fraction(value: Any) -> float | None: |
| if isinstance(value, bool) or not isinstance(value, (int, float)): |
| return None |
| number = float(value) |
| return number if math.isfinite(number) else None |
|
|
|
|
| def closure_retention( |
| predicted: Mapping[str, Any], target: Mapping[str, Any] |
| ) -> dict[str, Any]: |
| """Score retained closure as a one-sided target requirement. |
| |
| Endpoint-join fractions are produced in [0, 1]. Clipping here keeps the |
| helper fail-safe for direct unit use without changing valid diagnostics. |
| """ |
|
|
| target_fraction = _finite_fraction(target.get("joined_endpoint_fraction")) |
| predicted_fraction = _finite_fraction( |
| predicted.get("joined_endpoint_fraction") |
| ) |
| if target_fraction is None: |
| return { |
| "eligible": False, |
| "score": None, |
| "reason": "target_closure_ineligible", |
| } |
| if predicted_fraction is None: |
| return { |
| "eligible": True, |
| "score": 0.0, |
| "reason": "prediction_has_no_contour", |
| } |
|
|
| target_value = min(1.0, max(0.0, target_fraction)) |
| predicted_value = min(1.0, max(0.0, predicted_fraction)) |
| if target_value <= OPEN_TARGET_EPSILON: |
| score = 1.0 |
| else: |
| score = min(1.0, predicted_value / target_value) |
| return { |
| "eligible": True, |
| "score": float(score), |
| "reason": "ok", |
| "predicted_joined_fraction": float(predicted_fraction), |
| "target_joined_fraction": float(target_fraction), |
| } |
|
|
|
|
| def _replace_retention_rows(rows: Mapping[str, Any]) -> list[str]: |
| """Replace only rows whose numeric retention score actually changes.""" |
|
|
| corrected_roles: list[str] = [] |
| for role, row in rows.items(): |
| if not isinstance(row, dict): |
| continue |
| contour = row.get("contour") |
| if not isinstance(contour, dict): |
| continue |
| predicted = contour.get("predicted") |
| target = contour.get("target") |
| previous = contour.get("retention") |
| if not isinstance(predicted, Mapping) or not isinstance(target, Mapping): |
| continue |
| replacement = closure_retention(predicted, target) |
| previous_score = ( |
| previous.get("score") if isinstance(previous, Mapping) else None |
| ) |
| if replacement.get("score") == previous_score: |
| continue |
| contour["retention"] = replacement |
| corrected_roles.append(str(role)) |
| return corrected_roles |
|
|
|
|
| def _mark_release(result: dict[str, Any]) -> None: |
| release = result.get("diagnostics", {}).get("release_status") |
| if isinstance(release, dict): |
| release["candidate"] = METRIC_VERSION |
|
|
|
|
| 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 RC5H, then repair only open-target closure retention.""" |
|
|
| result = RC5H.score_dxf_pair( |
| pred, |
| gt, |
| sidecar=sidecar, |
| category=category, |
| **kwargs, |
| ) |
| result["schema_version"] = SCHEMA_VERSION |
| result["metric_version"] = METRIC_VERSION |
| result.setdefault("metric_definition", {})[ |
| "contour_closure_retention_policy" |
| ] = { |
| "definition": "one_sided_target_joined_endpoint_fraction_requirement", |
| "score": "1_if_target_open_else_min_1_predicted_over_target", |
| "open_target_epsilon": OPEN_TARGET_EPSILON, |
| "more_closed_than_target_is_not_penalized": True, |
| "changed_component_definitions": ["geometry"], |
| } |
|
|
| |
| |
| context = RC3._consume_appended_omitted_marker( |
| RC3.MATCH.build_pair_context(pred, gt, sidecar=sidecar) |
| ) |
| if not context.get("eligible") or not context.get("prediction_valid"): |
| result.setdefault("diagnostics", {})[ |
| "rc5i_open_contour_retention" |
| ] = { |
| "applied": False, |
| "reason": "pair_context_ineligible_or_prediction_invalid", |
| "corrected_roles": [], |
| } |
| _mark_release(result) |
| return result |
|
|
| rows, curve = BASE._semantic_rows(context) |
| corrected_roles = _replace_retention_rows(rows) |
| result.setdefault("diagnostics", {})[ |
| "rc5i_open_contour_retention" |
| ] = { |
| "applied": bool(corrected_roles), |
| "reason": "corrected" if corrected_roles else "no_score_change", |
| "corrected_roles": corrected_roles, |
| "open_target_epsilon": OPEN_TARGET_EPSILON, |
| } |
| if not corrected_roles: |
| _mark_release(result) |
| return result |
|
|
| geometry, atomic = BASE._geometry_component(context, rows, curve) |
| components = result.get("components") |
| prompt = result.get("online_reward_prompt_masked") |
| prompt_components = prompt.get("components") if isinstance(prompt, dict) else None |
| if not isinstance(components, dict) or not isinstance(prompt_components, dict): |
| _mark_release(result) |
| return result |
|
|
| components["geometry"] = geometry |
| prompt_components["geometry"] = copy.deepcopy(geometry) |
| diagnostics = result["diagnostics"] |
| diagnostics["semantic_views"] = rows |
| diagnostics["curve_geometry"] = curve |
| diagnostics["atomic_geometry"] = { |
| key: copy.deepcopy(value) for key, value in atomic.items() if key != "curve" |
| } |
| diagnostics["curve_summary"] = copy.deepcopy(atomic.get("curve")) |
| RC5H._rescore_downstream(result) |
| _mark_release(result) |
| return result |
|
|
|
|
| __all__ = [ |
| "ENGINEERING_THRESHOLDS", |
| "MAX_MATCHED_OFFSET_DISPERSION_FRACTION", |
| "METRIC_VERSION", |
| "OPEN_TARGET_EPSILON", |
| "PHYSICAL_SUPPORTED_SEMANTICS", |
| "SCHEMA_VERSION", |
| "closure_retention", |
| "score_dxf_pair", |
| ] |
|
|
