municipalbench-full / code /metrics /annotation_agreement.py
Yuquanlee's picture
MunicipalBench dataset files
7825400 verified
Raw History Blame Contribute Delete
16.4 kB
"""Symmetric first-pass agreement; no annotation is treated as ground truth.
Per-image sufficient statistics make the cluster bootstrap exact without
re-solving identical box assignments on every resample.
"""
from __future__ import annotations
import hashlib
import json
import math
from collections import Counter
from itertools import combinations
import numpy as np
from scipy.optimize import linear_sum_assignment
from metrics.localisation import _compute_iou
from metrics.semantic import SemanticPolicy
METHOD_VERSION = "d2-v2-ordinal"
RATING_WIDTH = 43 # Existing summaries, five category counts, 5×5 coincidences.
THRESHOLDS = tuple(i / 10 for i in range(1, 10))
SEED = 20260911
def valid_box(box):
return (isinstance(box, list) and len(box) == 4
and all(type(x) in (int, float) and math.isfinite(x) for x in box)
and box[0] >= 0 and box[1] >= 0 and box[2] > 0 and box[3] > 0
and box[0] + box[2] <= 1 and box[1] + box[3] <= 1)
def canonical_items(items):
return sorted(items, key=lambda v: (v["use_case_id"], tuple(v.get("bbox") or [])))
def match_items(left, right, policy=None, threshold=None):
"""Exact first, then accepted semantic edges. Cardinality precedes IoU.
Canonical side orientation also fixes tie decisions when raters are swapped.
Returned indices refer to the supplied arrays, including duplicate instances.
"""
key = lambda items: tuple((v["use_case_id"], tuple(v.get("bbox") or [])) for v in items)
li = sorted(range(len(left)), key=lambda i: key([left[i]]))
ri = sorted(range(len(right)), key=lambda i: key([right[i]]))
a, b = [left[i] for i in li], [right[i] for i in ri]
swapped = key(a) > key(b)
if swapped:
a, b = b, a
matches = []
for semantic in (False, True) if policy else (False,):
used_a = {i for i, _, _, _ in matches}
used_b = {j for _, j, _, _ in matches}
aa = [i for i in range(len(a)) if i not in used_a]
bb = [j for j in range(len(b)) if j not in used_b]
if not aa or not bb:
continue
weights = np.zeros((len(aa), len(bb)))
overlaps = {}
for x, i in enumerate(aa):
for y, j in enumerate(bb):
ca, cb = a[i]["use_case_id"], b[j]["use_case_id"]
accepted = (ca != cb and policy.allows(ca, cb)) if semantic else ca == cb
overlap = _compute_iou(a[i]["bbox"], b[j]["bbox"]) if threshold is not None else 1.0
if accepted and (threshold is None or overlap >= threshold):
# One additional match outweighs every possible IoU gain.
weights[x, y] = min(len(aa), len(bb)) + 1 + overlap
overlaps[x, y] = overlap
xs, ys = linear_sum_assignment(weights, maximize=True)
matches.extend((aa[x], bb[y], overlaps[x, y], semantic)
for x, y in zip(xs, ys) if weights[x, y] > 0)
return sorted((li[j], ri[i], overlap, semantic) if swapped else
(li[i], ri[j], overlap, semantic) for i, j, overlap, semantic in matches)
def alpha_from_totals(n, total, squares, observed):
"""Interval alpha from pairable ratings and ordered coincidence cost."""
n, total, squares, observed = np.broadcast_arrays(n, total, squares, observed)
expected_numerator = 2 * (n * squares - total * total)
out = np.full(n.shape, np.nan, dtype=float)
np.divide(observed * (n - 1), expected_numerator, out=out,
where=(n > 1) & (expected_numerator > 0))
return 1 - out
def rating_statistics(labels, field):
values = [a[field] for a in labels if not a.get("reported")
and type(a.get(field)) is int and 1 <= a[field] <= 5]
out = np.zeros(RATING_WIDTH)
if len(values) < 2:
return out
n, total, squares = len(values), sum(values), sum(x*x for x in values)
spread = max(values) - min(values)
out[:8] = [1, spread == 0, spread <= 1, n, total, squares,
2 * (n * squares - total * total) / (n - 1), 0]
out[8 + spread] = 1
counts = np.bincount(values, minlength=6)[1:6].astype(float)
out[13:18] = counts
out[18:] = ((np.outer(counts, counts) - np.diag(counts)) / (n - 1)).ravel()
return out
def ordinal_alpha_from_totals(totals):
"""Standard ordinal alpha using this sample's cumulative category midranks.
Category frequencies and distances are rebuilt for every bootstrap sample,
not frozen to the original population. Coincidences count every ordered
within-image pair with 1/(m-1) normalisation.
"""
counts = totals[:, 13:18]
n = counts.sum(axis=1)
midranks = counts.cumsum(axis=1) - counts / 2
distance = (midranks[:, :, None] - midranks[:, None, :]) ** 2
coincidences = totals[:, 18:].reshape(-1, 5, 5)
observed = (coincidences * distance).sum(axis=(1, 2))
expected = (counts[:, :, None] * counts[:, None, :] * distance).sum(axis=(1, 2))
cost = np.full(n.shape, np.nan)
np.divide(observed * (n - 1), expected, out=cost,
where=(n > 1) & (expected > 0) & (totals[:, 0] >= 2))
return 1 - cost
def ratio(a, b):
a, b = np.broadcast_arrays(a, b)
return np.divide(a, b, out=np.full(a.shape, np.nan), where=b > 0)
def bootstrap_estimates(rows, evaluator, names, *, seed=SEED, replicates=2000):
"""Image bootstrap, compressed by identical sufficient-statistic vectors.
Multinomial resampling of pattern counts is exactly resampling images with
replacement, including zero-contribution images, not a pair bootstrap.
"""
rows = np.asarray(rows, dtype=float)
totals = rows.sum(axis=0)
values = np.asarray(evaluator(totals[None, :]))[0]
samples = np.empty((0, len(names)))
if len(rows) >= 2 and replicates:
patterns, counts = np.unique(rows, axis=0, return_counts=True)
rng = np.random.default_rng(seed)
chunks = []
for start in range(0, replicates, 100):
weights = rng.multinomial(len(rows), counts / len(rows), size=min(100, replicates-start))
chunks.append(evaluator(weights @ patterns))
samples = np.concatenate(chunks)
result = {}
for i, name in enumerate(names):
value = float(values[i]) if np.isfinite(values[i]) else None
finite = samples[:, i][np.isfinite(samples[:, i])] if len(samples) else []
ci = [float(x) for x in np.percentile(finite, [2.5, 97.5])] if (
value is not None and len(finite) >= .95 * replicates and len(finite) > 0) else None
result[name] = {"value": value, "ci": ci, "bootstrap_valid": len(finite),
"reason": None if value is not None else "No eligible denominator or no variation"}
return result
def rating_summary(rows, *, seed=SEED, replicates=2000):
rows = np.asarray(rows, dtype=float).reshape(-1, RATING_WIDTH)
rows = rows[rows[:, 0] > 0]
def evaluate(t):
alpha = alpha_from_totals(t[:, 3], t[:, 4], t[:, 5], t[:, 6])
alpha[t[:, 0] < 2] = np.nan
return np.column_stack((ratio(t[:, 1], t[:, 0]), ratio(t[:, 2], t[:, 0]),
ordinal_alpha_from_totals(t), alpha))
result = bootstrap_estimates(rows, evaluate,
["exact", "within_one", "alpha", "interval_alpha"], seed=seed, replicates=replicates)
result["alpha"]["level"] = "ordinal"
result["interval_alpha"]["level"] = "interval"
totals = rows.sum(axis=0)
return {**result, "eligible": len(rows), "ratings": int(totals[3]),
"exact_count": int(totals[1]), "within_one_count": int(totals[2]),
"ranges": totals[8:13].astype(int).tolist(), "limited_support": len(rows) < 10}
# Columns are additive across images; weighted counts and raw counts are separate.
FIELDS = ("label_n exact label_pairs clean_pairs "
"positive_images both_positive unilateral both_absent alpha_n alpha_sum alpha_o "
"label_endpoints semantic_label_endpoints "
"box_n box_positive box_pairs empty_box_pairs box_endpoints raw_box_endpoints "
"iou_sum raw_matches semantic_box_endpoints "
+ " ".join(f"match_{i}" for i in range(1, 10)) + " "
+ " ".join(f"iou_bin_{i}" for i in range(10))).split()
F = {name: i for i, name in enumerate(FIELDS)}
def prepare_image(row, gold, category, domains, policy):
"""Keep public statistical inputs separate from anonymised private evidence."""
taxonomy = {c for ids in domains.values() for c in ids}
labels = []
audit = Counter()
for a in row["first_pass"]:
items = canonical_items(a.get("violations", []))
known = all(v.get("use_case_id") in taxonomy for v in items)
state_ok = (type(a.get("no_violation_detected")) is bool
and a["no_violation_detected"] != bool(items))
usable = not a.get("reported") and known and state_ok
geometry = all(valid_box(v.get("bbox")) for v in items)
audit["reported"] += bool(a.get("reported"))
audit["unknown_class"] += not known
audit["invalid_state"] += not a.get("reported") and not state_ok
audit["invalid_geometry"] += not geometry
labels.append({"label": f"Label {chr(65+len(labels))}",
"plausibility": a.get("plausibility"), "naturalness": a.get("naturalness"),
"reported": bool(a.get("reported")), "label_eligible": usable,
"box_eligible": usable and geometry,
"no_violation_detected": a.get("no_violation_detected"),
"violations": [{"use_case_id": v["use_case_id"],
"name": v.get("use_case_name", v["use_case_id"]),
"bbox": v.get("bbox") if valid_box(v.get("bbox")) else None} for v in items]})
sets = {i: {v["use_case_id"] for v in a["violations"]} for i, a in enumerate(labels) if a["label_eligible"]}
label_pairs = list(combinations(sets, 2))
box_pairs = list(combinations([i for i, a in enumerate(labels) if a["box_eligible"]], 2))
pair_data = []
for i, j in sorted(set(label_pairs) | set(box_pairs)):
a, b = labels[i]["violations"], labels[j]["violations"]
record = {"a": i, "b": j}
if (i, j) in label_pairs:
la, lb = [{"use_case_id": c} for c in sorted(sets[i])], [{"use_case_id": c} for c in sorted(sets[j])]
matched = match_items(la, lb, policy)
record["label_matches"] = [{"a_class": la[x]["use_case_id"], "b_class": lb[y]["use_case_id"],
"semantic": s, "cosine": policy.similarity(la[x]["use_case_id"], lb[y]["use_case_id"])} for x, y, _, s in matched]
if (i, j) in box_pairs:
record["threshold_matches"] = {
str(t): match_items(a, b, threshold=t) for t in THRESHOLDS}
record["box_matches"] = [dict(a=x, b=y, iou=overlap, semantic=s,
a_class=a[x]["use_case_id"], b_class=b[y]["use_case_id"],
cosine=policy.similarity(a[x]["use_case_id"], b[y]["use_case_id"]))
for x, y, overlap, s in match_items(a, b, policy, .5)]
pair_data.append(record)
gold_ids = {v["use_case_id"] for v in gold.get("violations", [])} if gold else set()
return {"image_id": row["image_id"], "category": category, "gold": gold,
"gold_ids": gold_ids, "labels": labels, "sets": sets, "pairs": pair_data,
"audit": dict(audit), "quality": {k: rating_statistics(row["first_pass"], k) for k in ("plausibility", "naturalness")}}
def image_statistics(image, ids, *, per_class=False):
out = np.zeros(len(FIELDS))
def add(key, value): out[F[key]] += value
sets = {i: s & ids for i, s in image["sets"].items()}
lp = [p for p in image["pairs"] if "label_matches" in p]
bp = [p for p in image["pairs"] if "box_matches" in p]
if lp:
add("label_n", 1); add("exact", len({tuple(sorted(s)) for s in sets.values()}) == 1)
add("positive_images", any(sets.values()))
positive = sum(bool(s) for s in sets.values())
if per_class:
n = len(sets)
add("alpha_n", n); add("alpha_sum", positive)
add("alpha_o", 2 * positive * (n-positive) / (n-1))
for p in lp:
a, b = sets[p["a"]], sets[p["b"]]
union, shared = a | b, a & b
w = 1 / len(lp)
endpoints = sum(m["a_class"] in ids for m in p["label_matches"]) + sum(m["b_class"] in ids for m in p["label_matches"])
add("label_pairs", 1); add("clean_pairs", not union)
add("both_positive", w*len(shared)); add("unilateral", w*len(a ^ b))
add("both_absent", w*(len(ids)-len(union)))
add("label_endpoints", w*(len(a)+len(b)))
add("semantic_label_endpoints", w*endpoints)
if bp:
add("box_n", 1)
positive = False
for p in bp:
a = image["labels"][p["a"]]["violations"]
b = image["labels"][p["b"]]["violations"]
endpoints = sum(v["use_case_id"] in ids for v in a+b)
positive |= endpoints > 0
w = 1 / len(bp)
add("box_pairs", 1); add("empty_box_pairs", endpoints == 0)
add("box_endpoints", w*endpoints); add("raw_box_endpoints", endpoints)
for index, t in enumerate(THRESHOLDS, 1):
matches = [m for m in p["threshold_matches"][str(t)] if a[m[0]]["use_case_id"] in ids]
add(f"match_{index}", w*len(matches))
if t == .5:
add("raw_matches", len(matches)); add("iou_sum", w*sum(m[2] for m in matches))
for m in matches:
add(f"iou_bin_{min(9, int(m[2]*10))}", w)
add("semantic_box_endpoints", w*sum((m["a_class"] in ids)+(m["b_class"] in ids) for m in p["box_matches"]))
add("box_positive", positive)
return out
def agreement_summary(rows, *, per_class=False, seed=SEED, replicates=2000):
rows = np.asarray(rows, dtype=float).reshape(-1, len(FIELDS))
names = ["exact", "positive_agreement", "alpha", "semantic_positive_agreement",
"instance_f1", "semantic_instance_f1", "matched_iou"] + [f"iou_{i}" for i in range(1, 10)]
def evaluate(t):
c = lambda key: t[:, F[key]]
alpha = alpha_from_totals(c("alpha_n"), c("alpha_sum"), c("alpha_sum"), c("alpha_o"))
alpha[c("label_n") < 2] = np.nan
if not per_class: alpha[:] = np.nan
return np.column_stack([
ratio(c("exact"), c("label_n")),
ratio(2*c("both_positive"), 2*c("both_positive")+c("unilateral")), alpha,
ratio(c("semantic_label_endpoints"), c("label_endpoints")),
ratio(2*c("match_5"), c("box_endpoints")),
ratio(c("semantic_box_endpoints"), c("box_endpoints")), ratio(c("iou_sum"), c("match_5")),
*[ratio(2*c(f"match_{i}"), c("box_endpoints")) for i in range(1, 10)]])
result = bootstrap_estimates(rows, evaluate, names, seed=seed, replicates=replicates)
if not per_class:
result["alpha"]["reason"] = "Nominal alpha is defined per class, not for a pooled set/domain"
totals = dict(zip(FIELDS, rows.sum(axis=0).tolist()))
result["support"] = totals
result["limited_support"] = totals["label_n"] < 10 or totals["positive_images"] < 10
result["instance_limited_support"] = totals["box_n"] < 10 or totals["box_positive"] < 10
return result
def stable_seed(key):
return (SEED + int(hashlib.sha256(key.encode()).hexdigest()[:8], 16)) % (2**32)
def public_evidence(image):
"""Private image evidence with image-local aliases, never source identities."""
return {"image_id": image["image_id"], "category": image["category"],
"gold": image["gold"], "gold_ids": sorted(image["gold_ids"]),
"labels": image["labels"], "audit": image["audit"],
"rating_ranges": {k: int(np.argmax(v[8:])) if v[0] else None for k, v in image["quality"].items()},
"pairs": [{k: v for k, v in p.items() if k != "threshold_matches"} | {
"exact_box_matches": [dict(a=a, b=b, iou=iou) for a,b,iou,_ in p.get("threshold_matches", {}).get("0.5", [])]
} for p in image["pairs"]]}