| |
| """v5.2-rc2 acceptance candidate. |
| |
| This add-only module keeps rc1 available for comparison while fixing four |
| issues found by the real-GT counterfactual audit: outlier-sensitive view |
| clustering, non-JSON diagnostics, missing primitive recall in the physical |
| score, and an alignment-dependent structure gate. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import copy |
| from pathlib import Path |
| from typing import Any, Mapping |
|
|
| try: |
| from . import eval_geometric052 as BASE |
| from . import view_entity_matching_v52_rc2 as MATCH |
| except ImportError: |
| import eval_geometric052 as BASE |
| import view_entity_matching_v52_rc2 as MATCH |
|
|
|
|
| METRIC_VERSION = "v5.2-rc2" |
| SCHEMA_VERSION = "edp-geometric-evaluator-v5.2-rc2" |
| ENGINEERING_THRESHOLDS = BASE.ENGINEERING_THRESHOLDS |
| PHYSICAL_SUPPORTED_SEMANTICS = BASE.PHYSICAL_SUPPORTED_SEMANTICS | { |
| "bounding_box_width", |
| "bounding_box_height", |
| "cut_profile_diameter", |
| } |
|
|
|
|
| def _physical_component( |
| context: Mapping[str, Any], |
| rows: Mapping[str, Any], |
| sidecar: Mapping[str, Any] | None, |
| ) -> dict[str, Any]: |
| """Include circle/arc matching recall in physical feature quality.""" |
|
|
| component = copy.deepcopy(BASE._physical_component(context, rows, sidecar)) |
| if not component.get("eligible"): |
| return component |
| details = component.get("details", {}) |
| qualities: list[float] = [] |
| for item in details.get("extent_items", []): |
| value = item.get("score") |
| if item.get("eligible") and isinstance(value, (int, float)): |
| qualities.append(float(value)) |
| for item in details.get("primitive_items", []): |
| role, family = item.get("role"), item.get("family") |
| raw = item.get("score") |
| family_row = rows.get(role, {}).get("primitive", {}).get(family, {}) |
| match_f1 = family_row.get("f1") |
| if not isinstance(raw, (int, float)) or not isinstance(match_f1, (int, float)): |
| continue |
| effective = float(raw) * float(match_f1) |
| item["raw_parameter_score"] = BASE._round(float(raw)) |
| item["match_f1"] = BASE._round(float(match_f1)) |
| item["score"] = BASE._round(effective) |
| qualities.append(effective) |
| if not qualities: |
| return BASE._component( |
| None, |
| False, |
| "no_supported_actual_geometry_measurements", |
| **details, |
| ) |
| macro = sum(qualities) / len(qualities) |
| worst = min(qualities) |
| score = 0.55 * macro + 0.45 * worst |
| component["score"] = BASE._round(score) |
| component["reason"] = ( |
| "ok" |
| if score >= ENGINEERING_THRESHOLDS["physical"] |
| else "actual_geometry_measurement_mismatch" |
| ) |
| details["macro"] = BASE._round(macro) |
| details["worst"] = BASE._round(worst) |
| details["primitive_recall_is_scored"] = True |
| details["reads_prediction_dimension_text"] = False |
| return component |
|
|
|
|
| def _structure_component( |
| context: Mapping[str, Any], frozen: Mapping[str, Any] |
| ) -> dict[str, Any]: |
| """Use only true duplicate dimensions for the anti-spam validity gate.""" |
|
|
| anti_hack = frozen.get("anti_hack", {}) if isinstance(frozen, Mapping) else {} |
| try: |
| duplicate_ratio = float(anti_hack.get("true_duplicate_dimension_ratio", 0.0) or 0.0) |
| except (TypeError, ValueError): |
| duplicate_ratio = 0.0 |
| readable = bool(context.get("pred_meta", {}).get("readable")) |
| nondegenerate = bool(context.get("prediction_valid")) |
| valid = bool(readable and nondegenerate and duplicate_ratio < 0.50) |
| return BASE._component( |
| 1.0 if valid else 0.0, |
| True, |
| "ok" if valid else "invalid_or_true_dimension_spam_gate_failed", |
| gate_only=True, |
| readable=readable, |
| nondegenerate=nondegenerate, |
| true_duplicate_dimension_ratio=BASE._round(duplicate_ratio), |
| alignment_dependent_unmatched_dimensions_ignored=True, |
| positive_continuous_reward=False, |
| ) |
|
|
|
|
| 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 DXF pair with the rc2 matching and causal component fixes.""" |
|
|
| frozen = BASE.EV51.score_dxf_pair(pred, gt, sidecar=sidecar, category=category) |
| context = MATCH.build_pair_context(pred, gt, sidecar=sidecar) |
| result: dict[str, Any] = { |
| "schema_version": SCHEMA_VERSION, |
| "metric_version": METRIC_VERSION, |
| "category": category, |
| "anti_hack": copy.deepcopy(frozen.get("anti_hack", {})), |
| "diagnostics": { |
| "v51_frozen": { |
| "metric_version": frozen.get("metric_version"), |
| "components": copy.deepcopy(frozen.get("components", {})), |
| "benchmark": copy.deepcopy(frozen.get("benchmark", {})), |
| "anti_hack": copy.deepcopy(frozen.get("anti_hack", {})), |
| }, |
| "matching": { |
| key: copy.deepcopy(value) |
| for key, value in context.items() |
| if key |
| not in { |
| "raw_pred", |
| "raw_gt", |
| "canonical_pred", |
| "canonical_gt", |
| "pred_views", |
| "pred_views_all", |
| "gt_by_role", |
| } |
| }, |
| }, |
| } |
| if not context.get("eligible"): |
| components = { |
| name: BASE._component(None, False, str(context.get("reason"))) |
| for name in ("view", "geometry", "physical", "annotation", "layout", "structure") |
| } |
| result["components"] = components |
| result["hierarchical_reward"] = {"score": None, "reason": "target_ineligible"} |
| result["online_reward"] = {"scope": "prompt_observable_v52", "components": components} |
| result["benchmark"] = BASE._benchmark(components) |
| result["engineering_success"] = None |
| return result |
| if not context.get("prediction_valid"): |
| components = BASE._zero_components("prediction_dxf_unreadable_or_degenerate") |
| reward = BASE._hierarchical_reward(components, {"topology_score": 0.0}) |
| result["components"] = components |
| result["hierarchical_reward"] = reward |
| result["online_reward"] = { |
| "scope": "prompt_observable_v52", |
| "components": components, |
| "hierarchical_reward": reward, |
| } |
| result["benchmark"] = BASE._benchmark(components) |
| result["engineering_success"] = result["benchmark"]["engineering_success"] |
| return result |
|
|
| rows, curve = BASE._semantic_rows(context) |
| view = BASE._view_component(context, rows) |
| layout = BASE._layout_component(context, rows) |
| geometry, atomic = BASE._geometry_component(context, rows, curve) |
| physical = _physical_component(context, rows, sidecar) |
| annotation, annotation_diagnostic = BASE._annotation_component(context, sidecar) |
| structure = _structure_component(context, frozen) |
| components = { |
| "view": view, |
| "geometry": geometry, |
| "physical": physical, |
| "annotation": annotation, |
| "layout": layout, |
| "structure": structure, |
| } |
| reward = BASE._hierarchical_reward(components, atomic) |
| benchmark = BASE._benchmark(components) |
| result.update( |
| { |
| "components": components, |
| "online_reward": { |
| "scope": "prompt_observable_v52", |
| "components": components, |
| "hierarchical_reward": reward, |
| }, |
| "hierarchical_reward": reward, |
| "benchmark": benchmark, |
| "engineering_success": benchmark["engineering_success"], |
| } |
| ) |
| result["diagnostics"].update( |
| { |
| "semantic_views": rows, |
| "curve_geometry": curve, |
| "atomic_geometry": { |
| key: copy.deepcopy(value) for key, value in atomic.items() if key != "curve" |
| }, |
| "curve_summary": atomic.get("curve"), |
| "annotation_fields": annotation_diagnostic, |
| "release_status": { |
| "grpo_connected": False, |
| "reason": "counterfactual_and_real_generation_acceptance_required", |
| "candidate": METRIC_VERSION, |
| }, |
| } |
| ) |
| return result |
|
|
|
|
| __all__ = [ |
| "ENGINEERING_THRESHOLDS", |
| "METRIC_VERSION", |
| "PHYSICAL_SUPPORTED_SEMANTICS", |
| "SCHEMA_VERSION", |
| "score_dxf_pair", |
| ] |
|
|
