| """The paper's fixed-population ten-column aggregation for offline DXF scores.""" |
| import math |
|
|
| COMPONENTS = {'SV': 'structure', 'VC': 'view', 'GF': 'geometry', |
| 'DF': 'physical', 'AQ': 'annotation', 'LC': 'layout'} |
| THRESHOLDS = {'structure': 1., 'view': 1., 'geometry': .9, |
| 'physical': .9, 'annotation': .9, 'layout': .85} |
|
|
|
|
| def parse_atoms(result, gt): |
| """Frozen CAMR atomic checks from unify_annotation_columns_20260924_v1.py.""" |
| if result is None: |
| return None, "missing_result" |
| ann = result.get("components", {}).get("annotation", {}) |
| d = ann.get("details", {}) |
| items = d.get("items") |
| if d.get("scope") != "full_gt" or not isinstance(items, list): |
| return None, "no_full_gt_items:" + str(ann.get("reason")) |
| want = sorted((x["id"], x["gt_dimension_index"]) for x in gt["specs"]) |
| got = sorted((x.get("id"), x.get("gt_dimension_index")) for x in items) |
| if want != got or d.get("n_selected_target") != len(want): |
| return None, "target_inventory_mismatch:" + str(ann.get("reason")) |
| if "n_matched_predicted_native" not in d: |
| return None, "missing_native_matching_counters" |
| n = len(want) |
| tp = int(d["n_matched_predicted_native"]) |
| assert n > 0 and 0 <= tp <= n |
| assert tp == sum(float(x["presence"]) for x in items) |
| assert n == int(d["n_total_gt_dimension_targets"]) |
| assert len({x["pred_dimension_index"] for x in items if x["pred_dimension_index"] is not None}) == tp |
| return {"native_target_count": n, "native_matched_count": tp, "all_targets_matched": tp == n, |
| "matching_policy": d.get("matching_policy")}, "observed" |
|
|
|
|
| def make_record(sid, contract, result=None, status='scored', error=None): |
| eligible = bool(contract['full_gt']['annotation_eligible']) |
| row = {'id': sid, 'status': status, 'annotation_eligible': eligible, |
| 'components': {k: 0.0 for k in COMPONENTS}, |
| 'view_pass': False, 'layout_pass': False, 'camr_complete': False, |
| 'annotation_unknown': False, 'error': error} |
| if status != 'scored': |
| if result is not None: |
| raise ValueError('A failed output must not contribute a scored result') |
| return row |
| if result is None: |
| raise ValueError('A scored record requires a result') |
| assert result['metric_version'] == 'v5.2-rc5k-final' |
| benchmark = result['benchmark'] |
| assert benchmark['thresholds'] == THRESHOLDS |
| for column, key in COMPONENTS.items(): |
| component = result['components'][key] |
| value = component['score'] |
| row['components'][column] = float(value) if value is not None else 0.0 |
| assert math.isfinite(row['components'][column]) and 0 <= row['components'][column] <= 1 |
| if key in {'view', 'layout'}: |
| inferred = bool(value >= THRESHOLDS[key]) if component['eligible'] and value is not None else None |
| assert benchmark[key + '_pass'] is inferred |
| row[key + '_pass'] = inferred |
| if eligible: |
| atoms, reason = parse_atoms(result, contract) |
| row['annotation_unknown'] = atoms is None |
| row['annotation_evidence_status'] = reason |
| row['annotation_atoms'] = atoms |
| row['camr_complete'] = atoms is not None and atoms['all_targets_matched'] |
| return row |
|
|
|
|
| def aggregate(rows): |
| if not rows: |
| raise ValueError('Cannot aggregate an empty population') |
| if len({r['id'] for r in rows}) != len(rows): |
| raise ValueError('Duplicate sample IDs') |
| n = len(rows) |
| eligible = [r for r in rows if r['annotation_eligible']] |
| scored = sum(r['status'] == 'scored' for r in rows) |
| camr_count = sum(r['camr_complete'] is True for r in eligible) |
| metrics = {'SDR': 100 * scored / n} |
| metrics.update({k: 100 * math.fsum(r['components'][k] for r in rows) / n for k in COMPONENTS}) |
| metrics.update(CAMR=(100 * camr_count / len(eligible) if eligible else None), |
| CVR=100 * sum(r['view_pass'] is True for r in rows) / n, |
| LAR=100 * sum(r['layout_pass'] is True for r in rows) / n) |
| return {'sample_count': n, 'scorable_count': scored, |
| 'camr_denominator': len(eligible), 'camr_confirmed_count': camr_count, |
| 'annotation_unknown_count': sum(r['annotation_unknown'] for r in eligible), |
| 'metrics': metrics, 'scale': '0--100; rate columns are percentages', |
| 'failed_outputs': 'retained in fixed denominators with zero component scores', |
| 'optional_inapplicable_components': 'fixed-column zero filling'} |
|
|
