| |
| """Causally scoped v5.2-rc3 evaluator (offline acceptance candidate). |
| |
| RC3 deliberately exposes two different verifier scopes: |
| |
| ``components`` / ``verified_reward_full_gt`` |
| Offline, executed-DXF versus full-GT verification. Full-GT physical |
| geometry is retained here because an RLVR verifier is allowed to access |
| the reference answer. |
| |
| ``online_reward_prompt_masked`` |
| The FMFS-masked view of physical/annotation supervision. Prompt physical |
| features are scored only when the sidecar supplies a certified mapping to |
| actual geometry. Missing or ambiguous mappings are ineligible; there is |
| no fallback to predicted DIMENSION text or to the full-GT physical score. |
| |
| One positive uniform sheet scale remains an explicit legal invariance. The |
| metric verifies geometry and physical proportions after fitting that scale; |
| it does not require a particular DXF plotting scale. |
| |
| This module is add-only and is not connected to GRPO. It uses the RC3 matcher |
| so every predicted cluster, including clusters outside the bounded role |
| assignment search, contributes to extra-geometry precision. |
| """ |
|
|
| 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 |
| from scipy.optimize import linear_sum_assignment |
|
|
| try: |
| from . import eval_geometric052 as BASE |
| from . import eval_geometric052_rc2 as RC2 |
| from . import view_entity_matching_v52_rc3 as MATCH |
| except ImportError: |
| import eval_geometric052 as BASE |
| import eval_geometric052_rc2 as RC2 |
| import view_entity_matching_v52_rc3 as MATCH |
|
|
|
|
| METRIC_VERSION = "v5.2-rc3" |
| SCHEMA_VERSION = "edp-geometric-evaluator-v5.2-rc3" |
| ENGINEERING_THRESHOLDS = dict(BASE.ENGINEERING_THRESHOLDS) |
|
|
| PHYSICAL_SUPPORTED_SEMANTICS = BASE.PHYSICAL_SUPPORTED_SEMANTICS | { |
| "bounding_box_width", |
| "bounding_box_height", |
| "cut_profile_diameter", |
| } |
|
|
| MAX_DIMENSION_BINDING_FRACTION = 0.08 |
| MAX_DIMENSION_VALUE_LOG_ERROR = math.log(1.5) |
| MAX_GEOMETRY_BINDING_REL_ERROR = 0.03 |
| SEVERE_ANNOTATION_SPAM_MULTIPLIER = 3 |
| SEVERE_ANNOTATION_SPAM_ALLOWANCE = 6 |
|
|
|
|
| def _consume_appended_omitted_marker(context: dict[str, Any]) -> dict[str, Any]: |
| """Make clear that RC3 appended, and therefore did not omit, the clusters.""" |
|
|
| alignment = context.get("alignment") |
| if not isinstance(alignment, dict): |
| return context |
| original = list(alignment.get("omitted_original_indices", [])) |
| alignment["role_assignment_omitted_original_indices"] = original |
| alignment["omitted_original_indices"] = [] |
| alignment["omitted_clusters_are_appended_as_extras"] = True |
| return context |
|
|
|
|
| def _layout_component( |
| context: Mapping[str, Any], rows: Mapping[str, Any] |
| ) -> dict[str, Any]: |
| """Measure layout with radius/arc-parameter-invariant view anchors.""" |
|
|
| roles = [role for role, row in rows.items() if row["present"]] |
| if len(roles) < 2: |
| return BASE._component( |
| None, False, "fewer_than_two_semantic_roles", matched_roles=roles |
| ) |
| alignment = context["alignment"] |
| scale = float(alignment.get("global_scale", 1.0)) |
| role_to_pred = alignment["role_to_pred"] |
| pred_views = context["pred_views"] |
| gt_by_role = context["gt_by_role"] |
| sheet_diagonal = max(float(alignment.get("sheet_diagonal", 1.0)), 1.0) |
| errors: list[float] = [] |
| pair_rows: list[dict[str, Any]] = [] |
| for first, second in combinations(roles, 2): |
| pred_first = pred_views[role_to_pred[first]].get("layout_anchor") |
| pred_second = pred_views[role_to_pred[second]].get("layout_anchor") |
| gt_first = gt_by_role[first].get("layout_anchor") |
| gt_second = gt_by_role[second].get("layout_anchor") |
| if any(value is None for value in (pred_first, pred_second, gt_first, gt_second)): |
| return BASE._component( |
| None, |
| False, |
| "layout_anchor_unavailable", |
| matched_roles=roles, |
| anchor_definition=MATCH.LAYOUT_ANCHOR_DEFINITION, |
| ) |
| pred_vector = scale * ( |
| np.asarray(pred_second, dtype=float) - np.asarray(pred_first, dtype=float) |
| ) |
| gt_vector = np.asarray(gt_second, dtype=float) - np.asarray(gt_first, dtype=float) |
| error = float(np.linalg.norm(pred_vector - gt_vector) / sheet_diagonal) |
| errors.append(error) |
| pair_rows.append( |
| {"roles": [first, second], "vector_error_fraction": BASE._round(error)} |
| ) |
| mean_error = float(np.mean(errors)) |
| score = math.exp(-mean_error / 0.10) |
| return BASE._component( |
| score, |
| True, |
| "ok" if mean_error <= 0.02 else "relative_view_layout_mismatch", |
| matched_roles=roles, |
| mean_pair_vector_error_fraction=BASE._round(mean_error), |
| pairs=pair_rows, |
| anchor_definition=MATCH.LAYOUT_ANCHOR_DEFINITION, |
| uniform_sheet_scale_invariant=True, |
| ) |
|
|
|
|
| def _scope_contract( |
| sidecar: Mapping[str, Any] | None, scope: str |
| ) -> tuple[dict[str, Any], dict[str, Any]]: |
| contract = BASE.EV51._scope_contracts(sidecar) |
| selected = contract.get(scope, {}) |
| return contract, selected if isinstance(selected, Mapping) else {} |
|
|
|
|
| def _dimension_targets( |
| context: Mapping[str, Any], |
| sidecar: Mapping[str, Any] | None, |
| contract: Mapping[str, Any], |
| ) -> list[dict[str, Any]]: |
| gt_dims = list((context.get("raw_gt") or {}).get("dims", [])) |
| targets: list[dict[str, Any]] = [] |
| for spec_index, raw_spec in enumerate(contract.get("specs", [])): |
| spec = dict(raw_spec) |
| try: |
| gt_index = int(spec["gt_dimension_index"]) |
| except (KeyError, TypeError, ValueError): |
| continue |
| if not 0 <= gt_index < len(gt_dims): |
| continue |
| targets.append( |
| { |
| "spec_index": spec_index, |
| "spec": spec, |
| "gt_index": gt_index, |
| "dimension": gt_dims[gt_index], |
| "role": BASE._dimension_role(sidecar, gt_index), |
| } |
| ) |
| return targets |
|
|
|
|
| def _dimension_pair_detail( |
| context: Mapping[str, Any], |
| pred_dim: Mapping[str, Any], |
| target: Mapping[str, Any], |
| ) -> dict[str, Any]: |
| role = target.get("role") |
| transform = MATCH.role_local_transform(context, str(role)) if role else None |
| if transform is None: |
| scale = float(context["alignment"].get("global_scale", 1.0)) |
| translation = np.asarray( |
| context["alignment"].get("translation", (0.0, 0.0)), dtype=float |
| ) |
| else: |
| scale, translation = transform |
| sheet_diagonal = max(float(context["alignment"].get("sheet_diagonal", 1.0)), 1.0) |
| pred_binding = np.asarray(pred_dim.get("binding_point", (0.0, 0.0)), dtype=float) |
| gt_binding = np.asarray( |
| target["dimension"].get("binding_point", (0.0, 0.0)), dtype=float |
| ) |
| distance = float( |
| np.linalg.norm(pred_binding * scale + translation - gt_binding) / sheet_diagonal |
| ) |
| pred_family = BASE._semantic_family(pred_dim.get("family")) |
| target_family = BASE._semantic_family(target["spec"].get("family")) |
| target_value = abs(float(target["spec"]["value"])) |
| predicted_value, value_source = BASE._dimension_display_value( |
| pred_dim, |
| target_value=target_value, |
| target_dimension=target["dimension"], |
| global_scale=float(scale), |
| ) |
| if predicted_value is None or target_value <= 1e-12: |
| value_log_error = math.inf |
| value_relative_error = None |
| else: |
| value_log_error = abs( |
| math.log(max(float(predicted_value), 1e-12) / target_value) |
| ) |
| value_relative_error = abs(float(predicted_value) / target_value - 1.0) |
| family_ok = pred_family == target_family |
| accepted = bool( |
| family_ok |
| and distance <= MAX_DIMENSION_BINDING_FRACTION |
| and value_log_error <= MAX_DIMENSION_VALUE_LOG_ERROR |
| ) |
| cost = ( |
| distance |
| + (2.0 if not family_ok else 0.0) |
| + 0.20 * min(value_log_error, 2.0) |
| ) |
| return { |
| "cost": cost, |
| "accepted": accepted, |
| "binding_distance_fraction": distance, |
| "predicted_family": pred_family, |
| "target_family": target_family, |
| "family_ok": family_ok, |
| "target_value": target_value, |
| "predicted_value": predicted_value, |
| "value_source": value_source, |
| "value_log_error": value_log_error, |
| "value_relative_error": value_relative_error, |
| "scale": float(scale), |
| "role": role, |
| } |
|
|
|
|
| def _annotation_component( |
| context: Mapping[str, Any], |
| sidecar: Mapping[str, Any] | None, |
| *, |
| scope: str, |
| ) -> dict[str, Any]: |
| """Score masked target quality plus precision against the total GT inventory.""" |
|
|
| contract, selected_contract = _scope_contract(sidecar, scope) |
| mask = selected_contract.get("annotation_mask", []) |
| if not selected_contract.get("annotation_eligible"): |
| return BASE._component( |
| None, |
| False, |
| f"{scope}_annotation_mask_ineligible", |
| scope=scope, |
| contract_errors=contract.get("errors", []), |
| reason_codes=selected_contract.get("reason_codes", []), |
| ) |
| targets = _dimension_targets(context, sidecar, contract) |
| selected_spec_indices = { |
| index for index, selected in enumerate(mask) if selected |
| } |
| selected_targets = [ |
| target for target in targets if target["spec_index"] in selected_spec_indices |
| ] |
| if not selected_targets: |
| return BASE._component( |
| None, False, "no_valid_masked_target_dimensions", scope=scope |
| ) |
|
|
| pred_dims = list((context.get("raw_pred") or {}).get("dims", [])) |
| details: dict[tuple[int, int], dict[str, Any]] = {} |
| pairs_by_target: dict[int, int] = {} |
| if pred_dims and targets: |
| costs = np.zeros((len(pred_dims), len(targets)), dtype=float) |
| for pred_index, pred_dim in enumerate(pred_dims): |
| for target_index, target in enumerate(targets): |
| detail = _dimension_pair_detail(context, pred_dim, target) |
| details[(pred_index, target_index)] = detail |
| costs[pred_index, target_index] = float(detail["cost"]) |
| pred_rows, target_columns = linear_sum_assignment(costs) |
| for pred_index, target_index in zip(pred_rows, target_columns): |
| detail = details[(int(pred_index), int(target_index))] |
| if detail["accepted"]: |
| pairs_by_target[int(target_index)] = int(pred_index) |
|
|
| target_position = {target["spec_index"]: index for index, target in enumerate(targets)} |
| item_rows: list[dict[str, Any]] = [] |
| item_scores: list[float] = [] |
| presence_values: list[float] = [] |
| type_values: list[float] = [] |
| value_values: list[float] = [] |
| binding_values: list[float] = [] |
| for target in selected_targets: |
| position = target_position[target["spec_index"]] |
| pred_index = pairs_by_target.get(position) |
| spec = target["spec"] |
| if pred_index is None: |
| item_scores.append(0.0) |
| presence_values.append(0.0) |
| type_values.append(0.0) |
| value_values.append(0.0) |
| binding_values.append(0.0) |
| item_rows.append( |
| { |
| "id": spec["id"], |
| "gt_dimension_index": target["gt_index"], |
| "pred_dimension_index": None, |
| "role": target.get("role"), |
| "presence": 0.0, |
| "type": 0.0, |
| "display_value": 0.0, |
| "binding": 0.0, |
| "score": 0.0, |
| "reason": "missing_or_semantically_incompatible_dimension", |
| } |
| ) |
| continue |
| detail = details[(pred_index, position)] |
| value_quality = math.exp(-float(detail["value_log_error"]) / 0.10) |
| binding_quality = math.exp( |
| -float(detail["binding_distance_fraction"]) / 0.03 |
| ) |
| item_score = 0.35 + 0.20 + 0.30 * value_quality + 0.15 * binding_quality |
| item_scores.append(item_score) |
| presence_values.append(1.0) |
| type_values.append(1.0) |
| value_values.append(value_quality) |
| binding_values.append(binding_quality) |
| item_rows.append( |
| { |
| "id": spec["id"], |
| "gt_dimension_index": target["gt_index"], |
| "pred_dimension_index": pred_index, |
| "role": target.get("role"), |
| "presence": 1.0, |
| "type": 1.0, |
| "display_value": BASE._round(value_quality), |
| "binding": BASE._round(binding_quality), |
| "target_display_value": BASE._round(detail["target_value"]), |
| "predicted_display_value": BASE._round(detail["predicted_value"]), |
| "display_value_source": detail["value_source"], |
| "display_value_relative_error": BASE._round( |
| detail["value_relative_error"] |
| ), |
| "binding_distance_fraction": BASE._round( |
| detail["binding_distance_fraction"] |
| ), |
| "score": BASE._round(item_score), |
| "reason": "ok" if item_score >= 0.90 else "annotation_field_mismatch", |
| } |
| ) |
|
|
| target_macro = float(np.mean(item_scores)) |
| target_worst = min(item_scores) |
| target_quality = 0.50 * target_macro + 0.50 * target_worst |
| matched_predicted = set(pairs_by_target.values()) |
| pred_meta = context.get("pred_meta", {}) |
| gt_meta = context.get("gt_meta", {}) |
| pred_text = int(pred_meta.get("dimension_like_text", 0) or 0) |
| gt_text = int(gt_meta.get("dimension_like_text", 0) or 0) |
| predicted_inventory = len(pred_dims) + pred_text |
| matched_inventory = len(matched_predicted) + min(pred_text, gt_text) |
| predicted_precision = ( |
| matched_inventory / predicted_inventory if predicted_inventory else 0.0 |
| ) |
| score = BASE._harmonic(target_quality, predicted_precision) |
| return BASE._component( |
| score, |
| True, |
| "ok" if score >= ENGINEERING_THRESHOLDS["annotation"] else "annotation_recall_precision_or_field_mismatch", |
| scope=scope, |
| n_selected_target=len(selected_targets), |
| n_total_gt_dimension_targets=len(targets), |
| n_predicted_native=len(pred_dims), |
| n_predicted_dimension_like_text=pred_text, |
| n_matched_predicted_native=len(matched_predicted), |
| n_unmatched_predicted_native=len(pred_dims) - len(matched_predicted), |
| predicted_precision=BASE._round(predicted_precision), |
| presence_recall=BASE._round(float(np.mean(presence_values))), |
| type_macro=BASE._round(float(np.mean(type_values))), |
| display_value_macro=BASE._round(float(np.mean(value_values))), |
| binding_macro=BASE._round(float(np.mean(binding_values))), |
| target_quality=BASE._round(target_quality), |
| item_macro=BASE._round(target_macro), |
| item_worst=BASE._round(target_worst), |
| items=item_rows, |
| matching_policy="one_to_one_all_gt_inventory_family_binding_value_gated", |
| unselected_gt_dimensions_are_precision_neutral=True, |
| reads_actual_geometry=False, |
| ) |
|
|
|
|
| def _sidecar_dimension_item( |
| sidecar: Mapping[str, Any] | None, gt_index: int |
| ) -> Mapping[str, Any] | None: |
| dimensions = sidecar.get("dimensions") if isinstance(sidecar, Mapping) else None |
| items = dimensions.get("items") if isinstance(dimensions, Mapping) else None |
| if isinstance(items, Sequence) and 0 <= gt_index < len(items): |
| item = items[gt_index] |
| return item if isinstance(item, Mapping) else None |
| return None |
|
|
|
|
| def _fmfs_prompt_items( |
| sidecar: Mapping[str, Any] | None, |
| ) -> dict[int, Mapping[str, Any]]: |
| fmfs = sidecar.get("fmfs") if isinstance(sidecar, Mapping) else None |
| prompt = fmfs.get("prompt") if isinstance(fmfs, Mapping) else None |
| items = prompt.get("items") if isinstance(prompt, Mapping) else None |
| result: dict[int, Mapping[str, Any]] = {} |
| if not isinstance(items, Sequence) or isinstance(items, (str, bytes)): |
| return result |
| for item in items: |
| if not isinstance(item, Mapping): |
| continue |
| try: |
| gt_index = int(item["gt_dimension_index"]) |
| except (KeyError, TypeError, ValueError): |
| continue |
| result[gt_index] = item |
| return result |
|
|
|
|
| def _linear_axis(item: Mapping[str, Any], target_dim: Mapping[str, Any]) -> int | None: |
| binding = item.get("v51_binding") |
| orientation = binding.get("orientation") if isinstance(binding, Mapping) else None |
| if orientation == "horizontal": |
| return 0 |
| if orientation == "vertical": |
| return 1 |
| refs = target_dim.get("ref_points", {}) |
| if isinstance(refs, Mapping) and "defpoint2" in refs and "defpoint3" in refs: |
| first = np.asarray(refs["defpoint2"], dtype=float) |
| second = np.asarray(refs["defpoint3"], dtype=float) |
| delta = np.abs(second - first) |
| if float(np.max(delta)) > 1e-12: |
| return int(delta[1] > delta[0]) |
| return None |
|
|
|
|
| def _map_prompt_physical_item( |
| context: Mapping[str, Any], |
| rows: Mapping[str, Any], |
| sidecar: Mapping[str, Any] | None, |
| target: Mapping[str, Any], |
| fmfs_item: Mapping[str, Any], |
| ) -> tuple[dict[str, Any] | None, str | None]: |
| semantic = str(fmfs_item.get("semantic_type") or "") |
| if semantic not in PHYSICAL_SUPPORTED_SEMANTICS: |
| return None, f"unsupported_semantic:{semantic or 'missing'}" |
| if not fmfs_item.get("physical_eligible"): |
| return None, "fmfs_item_not_physical_eligible" |
| binding = fmfs_item.get("binding") |
| geometry_binding = binding.get("geometry") if isinstance(binding, Mapping) else None |
| if not isinstance(geometry_binding, Mapping) or geometry_binding.get("state") != "certified": |
| return None, "geometry_binding_not_certified" |
| role = target.get("role") |
| if role not in context.get("gt_by_role", {}): |
| return None, "semantic_view_role_unavailable" |
| target_view = context["gt_by_role"][role] |
| row = rows[role] |
| spec_family = BASE._semantic_family(target["spec"].get("family")) |
| target_dim = target["dimension"] |
| measurement = target_dim.get("measurement") |
| if not isinstance(measurement, (int, float)) or float(measurement) <= 1e-12: |
| return None, "target_geometry_measurement_unavailable" |
|
|
| if spec_family == "linear": |
| sidecar_item = _sidecar_dimension_item(sidecar, target["gt_index"]) |
| axis = _linear_axis(sidecar_item or {}, target_dim) |
| if axis is None: |
| return None, "linear_axis_unavailable" |
| gt_size = np.asarray(target_view["size"], dtype=float) |
| gt_value = float(gt_size[axis]) |
| relative = abs(float(measurement) / max(gt_value, 1e-12) - 1.0) |
| if relative > MAX_GEOMETRY_BINDING_REL_ERROR: |
| return None, "linear_dimension_not_equal_to_view_extent" |
| pred_index = context["alignment"].get("role_to_pred", {}).get(role) |
| if not isinstance(pred_index, int) or not 0 <= pred_index < len(context.get("pred_views", [])): |
| score = 0.0 |
| pred_value = None |
| log_error = None |
| else: |
| scale = float(context["alignment"].get("global_scale", 1.0)) |
| pred_value = float(context["pred_views"][pred_index]["size"][axis]) * scale |
| log_error = abs(math.log(max(pred_value, 1e-12) / gt_value)) |
| score = math.exp(-log_error / 0.10) |
| return { |
| "id": target["spec"]["id"], |
| "gt_dimension_index": target["gt_index"], |
| "semantic": semantic, |
| "role": role, |
| "measurement": "bbox_width" if axis == 0 else "bbox_height", |
| "target_actual_geometry": BASE._round(gt_value), |
| "predicted_actual_geometry_aligned": BASE._round(pred_value), |
| "log_error": BASE._round(log_error), |
| "score": BASE._round(score), |
| }, None |
|
|
| if spec_family not in {"diameter", "radius"}: |
| return None, f"unsupported_dimension_family:{spec_family}" |
| multiplier = 2.0 if spec_family == "diameter" else 1.0 |
| candidates: list[tuple[str, int, float]] = [] |
| for family in ("circle", "arc"): |
| plural = "circles" if family == "circle" else "arcs" |
| for index, primitive in enumerate(target_view["entities"].get(plural, [])): |
| geometry_value = multiplier * abs(float(primitive[2])) |
| relative = abs(float(measurement) / max(geometry_value, 1e-12) - 1.0) |
| if relative <= MAX_GEOMETRY_BINDING_REL_ERROR: |
| candidates.append((family, index, geometry_value)) |
| if len(candidates) != 1: |
| return None, "circular_geometry_binding_not_unique" |
| family, target_index, geometry_value = candidates[0] |
| primitive_row = row["primitive"][family] |
| matched_pair = next( |
| ( |
| pair |
| for pair in primitive_row.get("pairs", []) |
| if int(pair.get("target_index", -1)) == target_index |
| ), |
| None, |
| ) |
| if matched_pair is None: |
| score = 0.0 |
| log_error = None |
| else: |
| log_error = float(matched_pair.get("radius_log_error", 0.0)) |
| score = math.exp(-log_error / 0.10) |
| return { |
| "id": target["spec"]["id"], |
| "gt_dimension_index": target["gt_index"], |
| "semantic": semantic, |
| "role": role, |
| "measurement": f"{family}_{spec_family}", |
| "target_actual_geometry": BASE._round(geometry_value), |
| "matched": matched_pair is not None, |
| "radius_log_error": BASE._round(log_error), |
| "score": BASE._round(score), |
| }, None |
|
|
|
|
| def _prompt_physical_component( |
| context: Mapping[str, Any], |
| rows: Mapping[str, Any], |
| sidecar: Mapping[str, Any] | None, |
| ) -> dict[str, Any]: |
| contract, prompt = _scope_contract(sidecar, "prompt") |
| if not prompt.get("physical_eligible"): |
| return BASE._component( |
| None, |
| False, |
| "prompt_physical_mask_ineligible", |
| scope="prompt_masked_actual_geometry", |
| contract_errors=contract.get("errors", []), |
| reason_codes=prompt.get("reason_codes", []), |
| reads_prediction_dimension_text=False, |
| ) |
| mask = prompt.get("physical_mask", []) |
| selected_indices = {index for index, selected in enumerate(mask) if selected} |
| targets = [ |
| target |
| for target in _dimension_targets(context, sidecar, contract) |
| if target["spec_index"] in selected_indices |
| ] |
| fmfs_items = _fmfs_prompt_items(sidecar) |
| mapped: list[dict[str, Any]] = [] |
| errors: list[dict[str, Any]] = [] |
| for target in targets: |
| item = fmfs_items.get(target["gt_index"]) |
| if item is None: |
| errors.append( |
| {"gt_dimension_index": target["gt_index"], "reason": "missing_fmfs_prompt_item"} |
| ) |
| continue |
| row, error = _map_prompt_physical_item(context, rows, sidecar, target, item) |
| if error: |
| errors.append( |
| {"gt_dimension_index": target["gt_index"], "reason": error} |
| ) |
| elif row is not None: |
| mapped.append(row) |
| if not targets or errors or len(mapped) != len(targets): |
| return BASE._component( |
| None, |
| False, |
| "prompt_physical_actual_geometry_mapping_incomplete", |
| scope="prompt_masked_actual_geometry", |
| n_selected=len(targets), |
| n_mapped=len(mapped), |
| mapping_errors=errors, |
| mapped_items=mapped, |
| reads_prediction_dimension_text=False, |
| fallback_to_full_gt_physical=False, |
| ) |
| qualities = [float(item["score"]) for item in mapped] |
| macro = float(np.mean(qualities)) |
| worst = min(qualities) |
| score = 0.55 * macro + 0.45 * worst |
| return BASE._component( |
| score, |
| True, |
| "ok" if score >= ENGINEERING_THRESHOLDS["physical"] else "prompt_mapped_actual_geometry_mismatch", |
| scope="prompt_masked_actual_geometry", |
| macro=BASE._round(macro), |
| worst=BASE._round(worst), |
| items=mapped, |
| reads_prediction_dimension_text=False, |
| fallback_to_full_gt_physical=False, |
| uniform_sheet_scale_invariant=True, |
| ) |
|
|
|
|
| def _full_gt_physical_component( |
| context: Mapping[str, Any], |
| rows: Mapping[str, Any], |
| sidecar: Mapping[str, Any] | None, |
| ) -> dict[str, Any]: |
| component = RC2._physical_component(context, rows, sidecar) |
| details = component.setdefault("details", {}) |
| details["scope"] = "offline_full_gt_actual_geometry" |
| details["prompt_mask_applied"] = False |
| details["reads_prediction_dimension_text"] = False |
| details["uniform_sheet_scale_invariant"] = True |
| details["fail_closed_for_unsupported_semantics"] = False |
| return component |
|
|
|
|
| def _structure_component( |
| context: Mapping[str, Any], frozen: Mapping[str, Any] |
| ) -> dict[str, Any]: |
| """Independent validity gate; ordinary geometry/layout errors do not enter.""" |
|
|
| pred_meta = context.get("pred_meta", {}) |
| gt_meta = context.get("gt_meta", {}) |
| pred_counts = pred_meta.get("entity_type_counts", {}) |
| gt_counts = gt_meta.get("entity_type_counts", {}) |
| pred_native = int(pred_meta.get("native_dimensions", 0) or 0) |
| gt_native = int(gt_meta.get("native_dimensions", 0) or 0) |
| pred_text_total = sum(int(pred_counts.get(name, 0) or 0) for name in ("TEXT", "MTEXT")) |
| gt_text_total = sum(int(gt_counts.get(name, 0) or 0) for name in ("TEXT", "MTEXT")) |
| pred_annotation_total = pred_native + pred_text_total |
| gt_annotation_total = gt_native + gt_text_total |
| annotation_limit = max( |
| SEVERE_ANNOTATION_SPAM_ALLOWANCE, |
| gt_annotation_total + SEVERE_ANNOTATION_SPAM_ALLOWANCE, |
| SEVERE_ANNOTATION_SPAM_MULTIPLIER * gt_annotation_total, |
| ) |
| severe_annotation_spam = pred_annotation_total > annotation_limit |
| unsupported = int(pred_meta.get("unsupported_geometry_like", 0) or 0) |
| 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 |
| alignment = context.get("alignment", {}) |
| accounting_ok = bool(alignment.get("all_extra_clusters_accounted_for", False)) |
| readable = bool(pred_meta.get("readable")) |
| nondegenerate = bool(context.get("prediction_valid")) |
| valid = bool( |
| readable |
| and nondegenerate |
| and accounting_ok |
| and unsupported == 0 |
| and duplicate_ratio < 0.50 |
| and not severe_annotation_spam |
| ) |
| flags = [ |
| name |
| for name, active in ( |
| ("unreadable_or_degenerate", not (readable and nondegenerate)), |
| ("extra_cluster_accounting_incomplete", not accounting_ok), |
| ("unsupported_geometry_like", unsupported > 0), |
| ("true_duplicate_dimension_spam", duplicate_ratio >= 0.50), |
| ("severe_dimension_or_text_spam", severe_annotation_spam), |
| ) |
| if active |
| ] |
| return BASE._component( |
| 1.0 if valid else 0.0, |
| True, |
| "ok" if valid else "independent_validity_or_anti_hack_gate_failed", |
| gate_only=True, |
| flags=flags, |
| readable=readable, |
| nondegenerate=nondegenerate, |
| all_extra_clusters_accounted_for=accounting_ok, |
| unsupported_geometry_like=unsupported, |
| true_duplicate_dimension_ratio=BASE._round(duplicate_ratio), |
| predicted_native_dimensions=pred_native, |
| predicted_text_mtext=pred_text_total, |
| predicted_dimension_like_text=int(pred_meta.get("dimension_like_text", 0) or 0), |
| target_annotation_inventory=gt_annotation_total, |
| predicted_annotation_inventory=pred_annotation_total, |
| severe_annotation_spam_limit=annotation_limit, |
| positive_continuous_reward=False, |
| reads_geometry_or_layout_quality=False, |
| ) |
|
|
|
|
| def _scoped_hierarchical_reward( |
| components: Mapping[str, Mapping[str, Any]], |
| atomic: Mapping[str, Any], |
| *, |
| scope: str, |
| ) -> dict[str, Any]: |
| """Renormalise absent optional stages instead of silently substituting them.""" |
|
|
| def eligible_score(name: str) -> float | None: |
| row = components[name] |
| value = row.get("score") |
| if row.get("eligible") and isinstance(value, (int, float)): |
| return float(value) |
| return None |
|
|
| structure = eligible_score("structure") |
| view = eligible_score("view") |
| geometry = eligible_score("geometry") |
| if structure is None or view is None or geometry is None: |
| return { |
| "score": None, |
| "eligible": False, |
| "scope": scope, |
| "reason": "required_reward_stage_ineligible", |
| } |
| topology = float(atomic.get("topology_score", 0.0)) |
| layout = eligible_score("layout") |
| physical = eligible_score("physical") |
| annotation = eligible_score("annotation") |
| view_topology_gate = BASE._harmonic(view, topology) |
| geometry_gate = BASE._harmonic(view_topology_gate, geometry) |
| stages: dict[str, float] = { |
| "view_topology": view_topology_gate |
| * (0.70 + 0.30 * layout if layout is not None else 1.0), |
| "geometry": view_topology_gate * geometry, |
| } |
| weights = {"view_topology": 0.35, "geometry": 0.30} |
| upstream = geometry_gate |
| if physical is not None: |
| stages["physical"] = geometry_gate * physical |
| weights["physical"] = 0.20 |
| upstream = BASE._harmonic(geometry_gate, physical) |
| if annotation is not None: |
| stages["annotation"] = upstream * annotation |
| weights["annotation"] = 0.15 |
| active_weight = sum(weights.values()) |
| reward = structure * sum(weights[name] * stages[name] for name in weights) / active_weight |
| excluded = [ |
| name |
| for name in ("layout", "physical", "annotation") |
| if eligible_score(name) is None |
| ] |
| return { |
| "score": BASE._round(reward), |
| "eligible": True, |
| "scope": scope, |
| "reason": "ok", |
| "structure_gate": BASE._round(structure), |
| "view_topology_gate": BASE._round(view_topology_gate), |
| "geometry_gate": BASE._round(geometry_gate), |
| "stages": {name: BASE._round(value) for name, value in stages.items()}, |
| "active_weights": {name: BASE._round(value / active_weight) for name, value in weights.items()}, |
| "excluded_ineligible_components": excluded, |
| "ineligible_components_are_not_substituted": True, |
| } |
|
|
|
|
| def _benchmark(components: Mapping[str, Mapping[str, Any]]) -> dict[str, Any]: |
| states: dict[str, bool | None] = {} |
| for name, threshold in ENGINEERING_THRESHOLDS.items(): |
| row = components[name] |
| value = row.get("score") |
| states[f"{name}_pass"] = ( |
| bool(float(value) >= threshold) |
| if row.get("eligible") and isinstance(value, (int, float)) |
| else None |
| ) |
| evaluable = all(value is not None for value in states.values()) |
| success = all(bool(value) for value in states.values()) if evaluable else None |
| return { |
| **states, |
| "fully_evaluable": evaluable, |
| "engineering_success": success, |
| "cad_pass": success, |
| "thresholds": dict(ENGINEERING_THRESHOLDS), |
| "scope": "offline_full_gt_executed_dxf", |
| "uniform_sheet_scale_invariant": True, |
| } |
|
|
|
|
| def _matching_diagnostics(context: Mapping[str, Any]) -> dict[str, Any]: |
| excluded = { |
| "raw_pred", |
| "raw_gt", |
| "canonical_pred", |
| "canonical_gt", |
| "pred_views", |
| "pred_views_all", |
| "gt_by_role", |
| } |
| return { |
| key: copy.deepcopy(value) |
| for key, value in context.items() |
| if key not in excluded |
| } |
|
|
|
|
| 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 one executed prediction under explicit full-GT and prompt scopes.""" |
|
|
| frozen = BASE.EV51.score_dxf_pair(pred, gt, sidecar=sidecar, category=category) |
| context = _consume_appended_omitted_marker( |
| MATCH.build_pair_context(pred, gt, sidecar=sidecar) |
| ) |
| result: dict[str, Any] = { |
| "schema_version": SCHEMA_VERSION, |
| "metric_version": METRIC_VERSION, |
| "category": category, |
| "metric_definition": { |
| "uniform_sheet_scale_invariant": True, |
| "absolute_dxf_plotting_scale_required": False, |
| "grpo_connected": False, |
| }, |
| "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": _matching_diagnostics(context), |
| }, |
| } |
| names = ("view", "geometry", "physical", "annotation", "layout", "structure") |
| if not context.get("eligible"): |
| components = { |
| name: BASE._component(None, False, str(context.get("reason"))) |
| for name in names |
| } |
| result["components"] = components |
| result["verified_reward_full_gt"] = { |
| "score": None, |
| "eligible": False, |
| "scope": "offline_full_gt_executed_dxf", |
| "reason": "target_ineligible", |
| } |
| result["online_reward_prompt_masked"] = { |
| "score": None, |
| "eligible": False, |
| "scope": "prompt_masked_actual_geometry", |
| "reason": "target_ineligible", |
| "components": components, |
| } |
| result["benchmark"] = _benchmark(components) |
| result["engineering_success"] = None |
| return result |
| if not context.get("prediction_valid"): |
| components = BASE._zero_components("prediction_dxf_unreadable_or_degenerate") |
| full_reward = _scoped_hierarchical_reward( |
| components, {"topology_score": 0.0}, scope="offline_full_gt_executed_dxf" |
| ) |
| prompt_reward = _scoped_hierarchical_reward( |
| components, {"topology_score": 0.0}, scope="prompt_masked_actual_geometry" |
| ) |
| result["components"] = components |
| result["verified_reward_full_gt"] = full_reward |
| result["online_reward_prompt_masked"] = { |
| **prompt_reward, |
| "components": components, |
| } |
| result["benchmark"] = _benchmark(components) |
| result["engineering_success"] = result["benchmark"]["engineering_success"] |
| return result |
|
|
| rows, curve = BASE._semantic_rows(context) |
| view = BASE._view_component(context, rows) |
| layout = _layout_component(context, rows) |
| geometry, atomic = BASE._geometry_component(context, rows, curve) |
| full_physical = _full_gt_physical_component(context, rows, sidecar) |
| full_annotation = _annotation_component(context, sidecar, scope="full_gt") |
| prompt_physical = _prompt_physical_component(context, rows, sidecar) |
| prompt_annotation = _annotation_component(context, sidecar, scope="prompt") |
| structure = _structure_component(context, frozen) |
| components = { |
| "view": view, |
| "geometry": geometry, |
| "physical": full_physical, |
| "annotation": full_annotation, |
| "layout": layout, |
| "structure": structure, |
| } |
| prompt_components = { |
| "view": copy.deepcopy(view), |
| "geometry": copy.deepcopy(geometry), |
| "physical": prompt_physical, |
| "annotation": prompt_annotation, |
| "layout": copy.deepcopy(layout), |
| "structure": copy.deepcopy(structure), |
| } |
| full_reward = _scoped_hierarchical_reward( |
| components, atomic, scope="offline_full_gt_executed_dxf" |
| ) |
| prompt_reward = _scoped_hierarchical_reward( |
| prompt_components, atomic, scope="prompt_masked_actual_geometry" |
| ) |
| benchmark = _benchmark(components) |
| result.update( |
| { |
| "components": components, |
| "verified_reward_full_gt": full_reward, |
| "online_reward_prompt_masked": { |
| **prompt_reward, |
| "components": prompt_components, |
| }, |
| "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"), |
| "release_status": { |
| "grpo_connected": False, |
| "candidate": METRIC_VERSION, |
| "reason": "counterfactual_and_real_generation_acceptance_required", |
| }, |
| } |
| ) |
| return result |
|
|
|
|
| __all__ = [ |
| "ENGINEERING_THRESHOLDS", |
| "METRIC_VERSION", |
| "PHYSICAL_SUPPORTED_SEMANTICS", |
| "SCHEMA_VERSION", |
| "score_dxf_pair", |
| ] |
|
|
