| |
| """Causally-audited geometric evaluator v5.2 (offline release candidate). |
| |
| v5.2 keeps the public six-component schema but replaces the parts that the |
| real-GT counterfactual audit found to be coupled: |
| |
| * semantic views are matched before a shared scale is fitted; |
| * geometry retains per-role/per-family one-to-one precision and recall; |
| * circle/arc parameters are measured explicitly, not inferred from Curve-F1; |
| * physical geometry never reads predicted DIMENSION text; |
| * annotation scores presence/type/display value/binding separately; |
| * structure is a binary validity/anti-hack gate, not a positive style reward; |
| * the scalar is hierarchical, so downstream quality cannot compensate for a |
| missing view or missing required feature. |
| |
| The frozen v5.1 result is preserved under ``diagnostics.v51_frozen`` solely as |
| an audit baseline. This module is not connected to GRPO until its |
| counterfactual and real-generation acceptance suites pass. |
| """ |
|
|
| 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 curve_geometry_metric as CURVE |
| from . import eval_geometric05 as EV5 |
| from . import eval_geometric051 as EV51 |
| from . import feature_topology_diagnostic as FEATURE |
| from . import view_entity_matching_v52 as MATCH |
| except ImportError: |
| import curve_geometry_metric as CURVE |
| import eval_geometric05 as EV5 |
| import eval_geometric051 as EV51 |
| import feature_topology_diagnostic as FEATURE |
| import view_entity_matching_v52 as MATCH |
|
|
|
|
| METRIC_VERSION = "v5.2-rc1" |
| SCHEMA_VERSION = "edp-geometric-evaluator-v5.2-rc1" |
|
|
| ENGINEERING_THRESHOLDS = { |
| "structure": 1.0, |
| "view": 1.0, |
| "geometry": 0.90, |
| "physical": 0.90, |
| "annotation": 0.90, |
| "layout": 0.85, |
| } |
|
|
| PHYSICAL_SUPPORTED_SEMANTICS = { |
| "profile_width", |
| "overall_width", |
| "profile_height", |
| "overall_height", |
| "extrusion_depth", |
| "thickness", |
| "profile_diameter", |
| "outer_diameter", |
| "inner_diameter", |
| "hole_diameter", |
| "radius", |
| "arc_radius", |
| } |
|
|
|
|
| def _round(value: float | None, digits: int = 6) -> float | None: |
| if value is None or not math.isfinite(float(value)): |
| return None |
| return round(float(value), digits) |
|
|
|
|
| def _clip(value: float) -> float: |
| return float(min(1.0, max(0.0, value))) |
|
|
|
|
| def _mean(values: Sequence[float]) -> float | None: |
| return float(np.mean(values)) if values else None |
|
|
|
|
| def _minimum(values: Sequence[float]) -> float | None: |
| return float(min(values)) if values else None |
|
|
|
|
| def _harmonic(first: float, second: float) -> float: |
| if first <= 0.0 or second <= 0.0: |
| return 0.0 |
| return float(2.0 * first * second / (first + second)) |
|
|
|
|
| def _component( |
| score: float | None, eligible: bool, reason: str, **details: Any |
| ) -> dict[str, Any]: |
| if not eligible: |
| score = None |
| elif score is None: |
| raise ValueError("eligible component requires numeric score") |
| return { |
| "score": _round(_clip(float(score))) if score is not None else None, |
| "eligible": bool(eligible), |
| "reason": str(reason), |
| "details": details, |
| } |
|
|
|
|
| def _zero_components(reason: str) -> dict[str, dict[str, Any]]: |
| return { |
| name: _component(0.0, True, reason) |
| for name in ("view", "geometry", "physical", "annotation", "structure") |
| } | {"layout": _component(None, False, reason)} |
|
|
|
|
| def _curve_quality(curve: Mapping[str, Any]) -> tuple[float, dict[str, Any]]: |
| aggregate = curve.get("aggregate", {}) if isinstance(curve, Mapping) else {} |
| channel = aggregate.get("all", {}) if isinstance(aggregate, Mapping) else {} |
| cd = channel.get("normalized_chamfer") if isinstance(channel, Mapping) else None |
| f1 = None |
| thresholds = channel.get("thresholds", {}) if isinstance(channel, Mapping) else {} |
| if isinstance(thresholds, Mapping): |
| row = thresholds.get("0.02", {}) |
| if isinstance(row, Mapping) and isinstance(row.get("f1"), (int, float)): |
| f1 = float(row["f1"]) |
| if not isinstance(cd, (int, float)) or not math.isfinite(float(cd)): |
| return 0.0, {"normalized_chamfer": None, "f1_at_2pct": _round(f1), "reason": "curve_ineligible"} |
| cd_value = max(0.0, float(cd)) |
| cd_quality = math.exp(-cd_value / 0.02) |
| quality = 0.75 * cd_quality + 0.25 * (f1 if f1 is not None else cd_quality) |
| return _clip(quality), { |
| "normalized_chamfer": _round(cd_value), |
| "chamfer_quality": _round(cd_quality), |
| "f1_at_2pct": _round(f1), |
| "score": _round(quality), |
| } |
|
|
|
|
| def _semantic_rows(context: Mapping[str, Any]) -> tuple[dict[str, Any], dict[str, Any]]: |
| gt_by_role = context["gt_by_role"] |
| pred_views = context.get("pred_views", []) |
| alignment = context["alignment"] |
| role_to_pred = alignment.get("role_to_pred", {}) |
| global_scale = float(alignment.get("global_scale", 1.0)) |
| rows: dict[str, Any] = {} |
| curve_pred: dict[str, Mapping[str, Any] | None] = {} |
| curve_gt: dict[str, Mapping[str, Any]] = {} |
| for role, target_view in gt_by_role.items(): |
| pred_index = role_to_pred.get(role) |
| predicted_view = ( |
| pred_views[pred_index] |
| if isinstance(pred_index, int) and 0 <= pred_index < len(pred_views) |
| else None |
| ) |
| primitive = MATCH.match_view_primitives( |
| predicted_view, target_view, global_scale=global_scale |
| ) |
| target_entities = target_view["entities"] |
| predicted_entities = ( |
| predicted_view["entities"] |
| if predicted_view is not None |
| else {"lines": [], "circles": [], "arcs": [], "dims": []} |
| ) |
| diagonal = max(float(np.linalg.norm(np.asarray(target_view["size"], dtype=float))), 1.0) |
| pred_closure = FEATURE._endpoint_join_diagnostic(predicted_entities, diagonal=diagonal) |
| gt_closure = FEATURE._endpoint_join_diagnostic(target_entities, diagonal=diagonal) |
| closure = FEATURE._closure_retention(pred_closure, gt_closure) |
| strict = None |
| if predicted_view is not None: |
| strict = EV5.EV3.score_geometry( |
| predicted_entities, |
| target_entities, |
| np.asarray(predicted_view["center"], dtype=float), |
| np.asarray(target_view["center"], dtype=float), |
| global_scale, |
| diagonal, |
| ) |
| rows[role] = { |
| "present": predicted_view is not None, |
| "predicted_view_index": pred_index, |
| "primitive": primitive, |
| "contour": { |
| "predicted": pred_closure, |
| "target": gt_closure, |
| "retention": closure, |
| }, |
| "strict": strict, |
| } |
| curve_pred[role] = predicted_view |
| curve_gt[role] = target_view |
| curve = CURVE.score_matched_views( |
| curve_pred, curve_gt, global_scale=global_scale |
| ) |
| return rows, curve |
|
|
|
|
| def _view_component(context: Mapping[str, Any], rows: Mapping[str, Any]) -> dict[str, Any]: |
| roles = list(context["gt_by_role"]) |
| present = [role for role in roles if rows[role]["present"]] |
| coverage = len(present) / max(len(roles), 1) |
| missing = [role for role in roles if role not in present] |
| return _component( |
| coverage, |
| True, |
| "ok" if not missing else "semantic_roles_missing", |
| expected_roles=roles, |
| present_roles=present, |
| missing_roles=missing, |
| role_coverage=_round(coverage), |
| worst_role_present=not missing, |
| alignment_reason=context["alignment"].get("reason"), |
| alignment_pairs=context["alignment"].get("pairs", []), |
| ) |
|
|
|
|
| def _layout_component(context: Mapping[str, Any], rows: Mapping[str, Any]) -> dict[str, Any]: |
| roles = [role for role, row in rows.items() if row["present"]] |
| if len(roles) < 2: |
| return _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 = [] |
| pair_rows = [] |
| for first, second in combinations(roles, 2): |
| pred_vector = scale * ( |
| np.asarray(pred_views[role_to_pred[second]]["center"], dtype=float) |
| - np.asarray(pred_views[role_to_pred[first]]["center"], dtype=float) |
| ) |
| gt_vector = ( |
| np.asarray(gt_by_role[second]["center"], dtype=float) |
| - np.asarray(gt_by_role[first]["center"], 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": _round(error)} |
| ) |
| mean_error = float(np.mean(errors)) if errors else math.inf |
| score = math.exp(-mean_error / 0.10) |
| return _component( |
| score, |
| True, |
| "ok" if mean_error <= 0.02 else "relative_view_layout_mismatch", |
| matched_roles=roles, |
| mean_pair_vector_error_fraction=_round(mean_error), |
| pairs=pair_rows, |
| missing_roles_do_not_repeat_penalty=True, |
| ) |
|
|
|
|
| def _geometry_component( |
| context: Mapping[str, Any], rows: Mapping[str, Any], curve: Mapping[str, Any] |
| ) -> tuple[dict[str, Any], dict[str, Any]]: |
| feature_scores: list[float] = [] |
| role_scores: dict[str, float] = {} |
| parameter_scores: list[float] = [] |
| role_details: dict[str, Any] = {} |
| for role, row in rows.items(): |
| local: list[float] = [] |
| for family in ("visible_line", "hidden_line", "circle", "arc"): |
| item = row["primitive"][family] |
| if item.get("eligible") and isinstance(item.get("f1"), (int, float)): |
| value = float(item["f1"]) |
| local.append(value) |
| feature_scores.append(value) |
| if family in {"circle", "arc"} and item.get("eligible"): |
| parameter = item.get("parameter_score") |
| if isinstance(parameter, (int, float)): |
| parameter_scores.append(float(parameter)) |
| retention = row["contour"]["retention"] |
| if retention.get("eligible") and isinstance(retention.get("score"), (int, float)): |
| local.append(float(retention["score"])) |
| feature_scores.append(float(retention["score"])) |
| role_score = float(np.mean(local)) if local else (1.0 if row["present"] else 0.0) |
| role_scores[role] = role_score |
| role_details[role] = { |
| "feature_macro": _round(role_score), |
| "feature_worst": _round(min(local)) if local else _round(role_score), |
| } |
| macro = float(np.mean(feature_scores)) if feature_scores else 0.0 |
| worst = min( |
| [min(role_scores.values()) if role_scores else 0.0] |
| + [float(value) for value in feature_scores] |
| ) |
| topology_score = 0.40 * macro + 0.60 * worst |
| extra_indices = context["alignment"].get("extra_predicted_indices", []) |
| pred_views = context.get("pred_views", []) |
| extra_primitives = int( |
| sum( |
| int(pred_views[index].get("n_primitives", 0)) |
| for index in extra_indices |
| if isinstance(index, int) and 0 <= index < len(pred_views) |
| ) |
| ) |
| target_primitives = int( |
| sum(int(view.get("n_primitives", 0)) for view in context["gt_by_role"].values()) |
| ) |
| extra_precision = target_primitives / max(target_primitives + extra_primitives, 1) |
| topology_score *= extra_precision |
| curve_score, curve_details = _curve_quality(curve) |
| parameter_score = _mean(parameter_scores) |
| weighted = [(0.58, topology_score), (0.30, curve_score)] |
| if parameter_score is not None: |
| weighted.append((0.12, parameter_score)) |
| weight_sum = sum(weight for weight, _ in weighted) |
| score = sum(weight * value for weight, value in weighted) / weight_sum |
| component = _component( |
| score, |
| True, |
| "ok" if score >= ENGINEERING_THRESHOLDS["geometry"] else "geometry_or_topology_mismatch", |
| topology_score=_round(topology_score), |
| feature_macro=_round(macro), |
| feature_worst=_round(worst), |
| extra_fragment_precision=_round(extra_precision), |
| extra_primitive_count=extra_primitives, |
| curve_score=_round(curve_score), |
| parameter_score=_round(parameter_score), |
| roles=role_details, |
| ) |
| return component, { |
| "topology_score": topology_score, |
| "feature_macro": macro, |
| "feature_worst": worst, |
| "curve_score": curve_score, |
| "curve": curve_details, |
| "parameter_score": parameter_score, |
| } |
|
|
|
|
| def _prompt_semantics(sidecar: Mapping[str, Any] | None) -> tuple[list[str], list[str]]: |
| parameters = sidecar.get("parameters") if isinstance(sidecar, Mapping) else None |
| candidates = parameters.get("candidates") if isinstance(parameters, Mapping) else None |
| values: list[str] = [] |
| if isinstance(candidates, Sequence) and not isinstance(candidates, (str, bytes)): |
| for item in candidates: |
| semantic = item.get("semantic") if isinstance(item, Mapping) else None |
| if isinstance(semantic, Mapping) and semantic.get("type"): |
| values.append(str(semantic["type"])) |
| supported = sorted({value for value in values if value in PHYSICAL_SUPPORTED_SEMANTICS}) |
| unsupported = sorted({value for value in values if value not in PHYSICAL_SUPPORTED_SEMANTICS}) |
| return supported, unsupported |
|
|
|
|
| def _physical_component( |
| context: Mapping[str, Any], rows: Mapping[str, Any], sidecar: Mapping[str, Any] | None |
| ) -> dict[str, Any]: |
| alignment = context["alignment"] |
| scale = float(alignment.get("global_scale", 1.0)) |
| role_to_pred = alignment.get("role_to_pred", {}) |
| pred_views = context.get("pred_views", []) |
| gt_by_role = context["gt_by_role"] |
| extent_items: list[dict[str, Any]] = [] |
| qualities: list[float] = [] |
| for role, gt_view in gt_by_role.items(): |
| pred_index = role_to_pred.get(role) |
| if not isinstance(pred_index, int) or not 0 <= pred_index < len(pred_views): |
| extent_items.append({"role": role, "eligible": False, "reason": "role_missing"}) |
| continue |
| pred_size = np.asarray(pred_views[pred_index]["size"], dtype=float) * scale |
| gt_size = np.asarray(gt_view["size"], dtype=float) |
| for axis, name in enumerate(("width", "height")): |
| if gt_size[axis] <= 1e-9: |
| continue |
| log_error = abs(math.log(max(float(pred_size[axis]), 1e-12) / float(gt_size[axis]))) |
| quality = math.exp(-log_error / 0.10) |
| qualities.append(quality) |
| extent_items.append( |
| { |
| "role": role, |
| "measurement": f"bbox_{name}", |
| "eligible": True, |
| "predicted_aligned": _round(float(pred_size[axis])), |
| "target": _round(float(gt_size[axis])), |
| "log_error": _round(log_error), |
| "relative_error": _round(abs(float(pred_size[axis]) / float(gt_size[axis]) - 1.0)), |
| "score": _round(quality), |
| } |
| ) |
| primitive_items: list[dict[str, Any]] = [] |
| for role, row in rows.items(): |
| for family in ("circle", "arc"): |
| item = row["primitive"][family] |
| if item.get("eligible"): |
| value = item.get("parameter_score") |
| if isinstance(value, (int, float)): |
| qualities.append(float(value)) |
| primitive_items.append( |
| { |
| "role": role, |
| "family": family, |
| "score": _round(float(value)), |
| "pairs": copy.deepcopy(item.get("pairs", [])), |
| "recall": item.get("recall"), |
| } |
| ) |
| supported, unsupported = _prompt_semantics(sidecar) |
| if not qualities: |
| return _component( |
| None, |
| False, |
| "no_supported_actual_geometry_measurements", |
| extent_items=extent_items, |
| primitive_items=primitive_items, |
| supported_prompt_semantics=supported, |
| unsupported_prompt_semantics=unsupported, |
| reads_prediction_dimension_text=False, |
| ) |
| macro = float(np.mean(qualities)) |
| worst = min(qualities) |
| score = 0.55 * macro + 0.45 * worst |
| return _component( |
| score, |
| True, |
| "ok" if score >= ENGINEERING_THRESHOLDS["physical"] else "actual_geometry_measurement_mismatch", |
| measurement_scope="matched_view_extents_and_matched_circle_arc_parameters", |
| macro=_round(macro), |
| worst=_round(worst), |
| extent_items=extent_items, |
| primitive_items=primitive_items, |
| supported_prompt_semantics=supported, |
| unsupported_prompt_semantics=unsupported, |
| fail_closed_for_unsupported_semantics=True, |
| reads_prediction_dimension_text=False, |
| ) |
|
|
|
|
| def _semantic_family(value: Any) -> str: |
| token = str(value or "").lower() |
| return "linear" if token in {"linear", "aligned"} else token |
|
|
|
|
| def _dimension_display_value( |
| dimension: Mapping[str, Any], |
| *, |
| target_value: float, |
| target_dimension: Mapping[str, Any], |
| global_scale: float, |
| ) -> tuple[float | None, str]: |
| value = dimension.get("display_value") |
| if isinstance(value, (int, float)) and math.isfinite(float(value)): |
| return abs(float(value)), "explicit_display_text" |
| measurement = dimension.get("measurement") |
| target_measurement = target_dimension.get("measurement") |
| if ( |
| isinstance(measurement, (int, float)) |
| and isinstance(target_measurement, (int, float)) |
| and abs(float(target_measurement)) > 1e-12 |
| ): |
| inferred = abs(float(measurement)) * global_scale * target_value / abs(float(target_measurement)) |
| return inferred, "automatic_measurement_placeholder" |
| return None, "display_value_unavailable" |
|
|
|
|
| def _dimension_role( |
| sidecar: Mapping[str, Any] | None, gt_index: int |
| ) -> str | None: |
| dimensions = sidecar.get("dimensions") if isinstance(sidecar, Mapping) else None |
| items = dimensions.get("items") if isinstance(dimensions, Mapping) else None |
| item = items[gt_index] if isinstance(items, Sequence) and 0 <= gt_index < len(items) else None |
| if isinstance(item, Mapping): |
| for key in ("nearest_view_position", "nearest_view_role"): |
| value = str(item.get(key) or "") |
| if value in {"front", "top", "right"}: |
| return value |
| try: |
| view_index = int(item.get("view_candidate_index")) |
| except (TypeError, ValueError): |
| view_index = -1 |
| views = sidecar.get("views") if isinstance(sidecar, Mapping) else None |
| candidates = views.get("candidates") if isinstance(views, Mapping) else None |
| if isinstance(candidates, Sequence) and 0 <= view_index < len(candidates): |
| candidate = candidates[view_index] |
| if isinstance(candidate, Mapping) and candidate.get("name"): |
| return str(candidate["name"]) |
| return None |
|
|
|
|
| def _annotation_component( |
| context: Mapping[str, Any], sidecar: Mapping[str, Any] | None |
| ) -> tuple[dict[str, Any], dict[str, Any]]: |
| contract = EV51._scope_contracts(sidecar) |
| prompt = contract.get("prompt", {}) |
| mask = prompt.get("annotation_mask", []) if isinstance(prompt, Mapping) else [] |
| specs = [ |
| dict(spec) |
| for spec, selected in zip(contract.get("specs", []), mask) |
| if selected |
| ] |
| if not prompt.get("annotation_eligible") or not specs: |
| component = _component( |
| None, |
| False, |
| "prompt_annotation_mask_ineligible", |
| contract_errors=contract.get("errors", []), |
| reads_actual_geometry=False, |
| ) |
| return component, {"items": [], "eligible": False} |
| raw_pred, raw_gt = context.get("raw_pred") or {}, context.get("raw_gt") or {} |
| pred_dims, gt_dims = list(raw_pred.get("dims", [])), list(raw_gt.get("dims", [])) |
| targets: list[dict[str, Any]] = [] |
| for spec in specs: |
| gt_index = int(spec["gt_dimension_index"]) |
| if not 0 <= gt_index < len(gt_dims): |
| continue |
| targets.append( |
| { |
| "spec": spec, |
| "gt_index": gt_index, |
| "dimension": gt_dims[gt_index], |
| "role": _dimension_role(sidecar, gt_index), |
| } |
| ) |
| if not targets: |
| component = _component(None, False, "no_valid_masked_target_dimensions") |
| return component, {"items": [], "eligible": False} |
| sheet_diagonal = max(float(context["alignment"].get("sheet_diagonal", 1.0)), 1.0) |
| costs = np.full((len(pred_dims), len(targets)), 10.0, dtype=float) |
| raw_cost: dict[tuple[int, int], dict[str, Any]] = {} |
| for pred_index, pred_dim in enumerate(pred_dims): |
| pred_binding = np.asarray(pred_dim.get("binding_point", (0.0, 0.0)), dtype=float) |
| for target_index, target in enumerate(targets): |
| role = target["role"] |
| transform = MATCH.role_local_transform(context, 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 |
| aligned_binding = pred_binding * scale + translation |
| gt_binding = np.asarray(target["dimension"].get("binding_point", (0.0, 0.0)), dtype=float) |
| distance = float(np.linalg.norm(aligned_binding - gt_binding) / sheet_diagonal) |
| pred_family = _semantic_family(pred_dim.get("family")) |
| target_family = _semantic_family(target["spec"].get("family")) |
| family_penalty = 0.05 if pred_family != target_family else 0.0 |
| costs[pred_index, target_index] = distance + family_penalty |
| raw_cost[(pred_index, target_index)] = { |
| "binding_distance_fraction": distance, |
| "predicted_family": pred_family, |
| "target_family": target_family, |
| "role": role, |
| "scale": scale, |
| } |
| pairs: dict[int, int] = {} |
| if pred_dims: |
| rows, columns = linear_sum_assignment(costs) |
| for pred_index, target_index in zip(rows, columns): |
| if raw_cost[(int(pred_index), int(target_index))]["binding_distance_fraction"] <= 0.08: |
| pairs[int(target_index)] = int(pred_index) |
| 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_index, target in enumerate(targets): |
| spec = target["spec"] |
| pred_index = pairs.get(target_index) |
| if pred_index is None: |
| presence_values.append(0.0) |
| type_values.append(0.0) |
| value_values.append(0.0) |
| binding_values.append(0.0) |
| item_scores.append(0.0) |
| item_rows.append( |
| { |
| "id": spec["id"], |
| "gt_dimension_index": target["gt_index"], |
| "pred_dimension_index": None, |
| "role": target["role"], |
| "presence": 0.0, |
| "type": 0.0, |
| "display_value": 0.0, |
| "binding": 0.0, |
| "score": 0.0, |
| "reason": "missing_dimension", |
| } |
| ) |
| continue |
| pred_dim = pred_dims[pred_index] |
| detail = raw_cost[(pred_index, target_index)] |
| presence = 1.0 |
| type_quality = float(detail["predicted_family"] == detail["target_family"]) |
| target_value = abs(float(spec["value"])) |
| predicted_value, value_source = _dimension_display_value( |
| pred_dim, |
| target_value=target_value, |
| target_dimension=target["dimension"], |
| global_scale=float(detail["scale"]), |
| ) |
| if predicted_value is None or target_value <= 1e-12: |
| relative_error, value_quality = None, 0.0 |
| else: |
| relative_error = abs(predicted_value / target_value - 1.0) |
| value_quality = math.exp( |
| -abs(math.log(max(predicted_value, 1e-12) / target_value)) / 0.10 |
| ) |
| binding_quality = math.exp(-float(detail["binding_distance_fraction"]) / 0.03) |
| item_score = 0.35 * presence + 0.20 * type_quality + 0.30 * value_quality + 0.15 * binding_quality |
| presence_values.append(presence) |
| type_values.append(type_quality) |
| value_values.append(value_quality) |
| binding_values.append(binding_quality) |
| item_scores.append(item_score) |
| item_rows.append( |
| { |
| "id": spec["id"], |
| "gt_dimension_index": target["gt_index"], |
| "pred_dimension_index": pred_index, |
| "role": target["role"], |
| "presence": 1.0, |
| "type": _round(type_quality), |
| "display_value": _round(value_quality), |
| "binding": _round(binding_quality), |
| "target_display_value": _round(target_value), |
| "predicted_display_value": _round(predicted_value), |
| "display_value_source": value_source, |
| "display_value_relative_error": _round(relative_error), |
| "binding_distance_fraction": _round(float(detail["binding_distance_fraction"])), |
| "score": _round(item_score), |
| "reason": "ok" if item_score >= 0.90 else "annotation_field_mismatch", |
| } |
| ) |
| macro = float(np.mean(item_scores)) |
| worst = min(item_scores) |
| score = 0.50 * macro + 0.50 * worst |
| component = _component( |
| score, |
| True, |
| "ok" if score >= ENGINEERING_THRESHOLDS["annotation"] else "masked_annotation_mismatch", |
| n_target=len(targets), |
| n_predicted_native=len(pred_dims), |
| presence_recall=_round(float(np.mean(presence_values))), |
| type_macro=_round(float(np.mean(type_values))), |
| display_value_macro=_round(float(np.mean(value_values))), |
| binding_macro=_round(float(np.mean(binding_values))), |
| item_macro=_round(macro), |
| item_worst=_round(worst), |
| items=item_rows, |
| reads_actual_geometry=False, |
| unmasked_target_dimensions_ignored=True, |
| ) |
| return component, {"eligible": True, "items": item_rows} |
|
|
|
|
| def _structure_component( |
| context: Mapping[str, Any], frozen: Mapping[str, Any] |
| ) -> dict[str, Any]: |
| anti_hack = frozen.get("anti_hack", {}) if isinstance(frozen, Mapping) else {} |
| spam_ratio = anti_hack.get("dimension_spam_ratio", anti_hack.get("duplicate_dimension_ratio", 0.0)) |
| try: |
| spam_ratio = float(spam_ratio or 0.0) |
| except (TypeError, ValueError): |
| spam_ratio = 0.0 |
| valid = bool( |
| context.get("prediction_valid") |
| and context.get("pred_meta", {}).get("readable") |
| and spam_ratio < 0.50 |
| ) |
| return _component( |
| 1.0 if valid else 0.0, |
| True, |
| "ok" if valid else "invalid_or_anti_hack_gate_failed", |
| gate_only=True, |
| readable=bool(context.get("pred_meta", {}).get("readable")), |
| nondegenerate=bool(context.get("prediction_valid")), |
| dimension_spam_ratio=_round(spam_ratio), |
| positive_continuous_reward=False, |
| ) |
|
|
|
|
| def _hierarchical_reward(components: Mapping[str, Mapping[str, Any]], atomic: Mapping[str, Any]) -> dict[str, Any]: |
| def score(name: str, fallback: float = 1.0) -> float: |
| row = components[name] |
| value = row.get("score") |
| return float(value) if row.get("eligible") and isinstance(value, (int, float)) else fallback |
|
|
| structure_gate = score("structure", 0.0) |
| view = score("view", 0.0) |
| topology = float(atomic.get("topology_score", 0.0)) |
| geometry = score("geometry", 0.0) |
| layout = score("layout", 1.0) |
| physical = score("physical", geometry) |
| annotation = score("annotation", 1.0) |
| view_topology_gate = _harmonic(view, topology) |
| geometry_gate = _harmonic(view_topology_gate, geometry) |
| physical_gate = _harmonic(geometry_gate, physical) |
| stages = { |
| "view_topology": 0.70 * view_topology_gate + 0.30 * view_topology_gate * layout, |
| "geometry": view_topology_gate * geometry, |
| "physical": geometry_gate * physical, |
| "annotation": physical_gate * annotation, |
| } |
| reward = structure_gate * ( |
| 0.35 * stages["view_topology"] |
| + 0.30 * stages["geometry"] |
| + 0.20 * stages["physical"] |
| + 0.15 * stages["annotation"] |
| ) |
| return { |
| "score": _round(reward), |
| "structure_gate": _round(structure_gate), |
| "view_topology_gate": _round(view_topology_gate), |
| "geometry_gate": _round(geometry_gate), |
| "physical_gate": _round(physical_gate), |
| "stages": {name: _round(value) for name, value in stages.items()}, |
| "policy": { |
| "structure": "binary_multiplicative_gate", |
| "view_topology": "harmonic_gate", |
| "downstream": "each_stage_multiplied_by_upstream_gate", |
| "weights": { |
| "view_topology": 0.35, |
| "geometry": 0.30, |
| "physical": 0.20, |
| "annotation": 0.15, |
| }, |
| }, |
| } |
|
|
|
|
| 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), |
| "strict_scope": "prompt_observable_v52", |
| } |
|
|
|
|
| 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 an executed DXF pair with independent v5.2 components.""" |
|
|
| frozen = 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: _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"] = _benchmark(components) |
| result["engineering_success"] = None |
| return result |
| if not context.get("prediction_valid"): |
| components = _zero_components("prediction_dxf_unreadable_or_degenerate") |
| reward = _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"] = _benchmark(components) |
| result["engineering_success"] = result["benchmark"]["engineering_success"] |
| return result |
|
|
| rows, curve = _semantic_rows(context) |
| view = _view_component(context, rows) |
| layout = _layout_component(context, rows) |
| geometry, atomic = _geometry_component(context, rows, curve) |
| physical = _physical_component(context, rows, sidecar) |
| annotation, annotation_diagnostic = _annotation_component(context, sidecar) |
| structure = _structure_component(context, frozen) |
| components = { |
| "view": view, |
| "geometry": geometry, |
| "physical": physical, |
| "annotation": annotation, |
| "layout": layout, |
| "structure": structure, |
| } |
| reward = _hierarchical_reward(components, atomic) |
| benchmark = _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", |
| }, |
| } |
| ) |
| return result |
|
|
|
|
| __all__ = [ |
| "ENGINEERING_THRESHOLDS", |
| "METRIC_VERSION", |
| "PHYSICAL_SUPPORTED_SEMANTICS", |
| "SCHEMA_VERSION", |
| "score_dxf_pair", |
| ] |
|
|
