| """Shared, dependency-free reporting helpers for GRIP dataset validators.""" |
| from __future__ import annotations |
|
|
| import math |
| from collections import Counter, defaultdict |
|
|
|
|
| def quantiles(values): |
| data = sorted(float(value) for value in values) |
| if not data: |
| return {"count": 0} |
|
|
| def percentile(fraction): |
| position = fraction * (len(data) - 1) |
| lower = int(math.floor(position)) |
| upper = int(math.ceil(position)) |
| if lower == upper: |
| return data[lower] |
| return data[lower] + (data[upper] - data[lower]) * (position - lower) |
|
|
| return { |
| "count": len(data), "min": data[0], "p25": percentile(.25), |
| "p50": percentile(.50), "p75": percentile(.75), |
| "p95": percentile(.95), "max": data[-1], |
| } |
|
|
|
|
| def cramers_v_raw(xs, ys): |
| pairs = [(str(x), str(y)) for x, y in zip(xs, ys)] |
| if not pairs: |
| return 0.0 |
| rows = sorted({x for x, _ in pairs}) |
| cols = sorted({y for _, y in pairs}) |
| if len(rows) < 2 or len(cols) < 2: |
| return 0.0 |
| table = Counter(pairs) |
| row_counts = Counter(x for x, _ in pairs) |
| col_counts = Counter(y for _, y in pairs) |
| total = len(pairs) |
| chi2 = 0.0 |
| for row in rows: |
| for col in cols: |
| expected = row_counts[row] * col_counts[col] / total |
| chi2 += (table[row, col] - expected) ** 2 / expected |
| return math.sqrt((chi2 / total) / min(len(rows) - 1, len(cols) - 1)) |
|
|
|
|
| def cramers_v(xs, ys): |
| """Bias-corrected Cramer's V (Bergsma/Wicher correction). |
| |
| The correction is essential for sparse, high-cardinality features such as |
| canvas-size pairs: uncorrected V approaches one when most contingency-table |
| cells are empty even when the variables were sampled independently. |
| """ |
| pairs = [(str(x), str(y)) for x, y in zip(xs, ys)] |
| if not pairs: |
| return 0.0 |
| rows = sorted({x for x, _ in pairs}) |
| cols = sorted({y for _, y in pairs}) |
| if len(rows) < 2 or len(cols) < 2: |
| return 0.0 |
| table = Counter(pairs) |
| row_counts = Counter(x for x, _ in pairs) |
| col_counts = Counter(y for _, y in pairs) |
| total = len(pairs) |
| chi2 = 0.0 |
| for row in rows: |
| for col in cols: |
| expected = row_counts[row] * col_counts[col] / total |
| chi2 += (table[row, col] - expected) ** 2 / expected |
| phi2 = chi2 / total |
| row_count, col_count = len(rows), len(cols) |
| corrected_phi2 = max(0.0, phi2 - ((col_count - 1) * (row_count - 1)) / (total - 1)) |
| corrected_rows = row_count - ((row_count - 1) ** 2) / (total - 1) |
| corrected_cols = col_count - ((col_count - 1) ** 2) / (total - 1) |
| denominator = min(corrected_rows - 1, corrected_cols - 1) |
| return math.sqrt(corrected_phi2 / denominator) if denominator > 0 else 0.0 |
|
|
|
|
| def decile_labels(values): |
| numeric = [float(value) for value in values] |
| ordered = sorted(numeric) |
| if len(set(ordered)) < 2: |
| return ["0"] * len(numeric) |
| cuts = [ordered[min(len(ordered) - 1, int(len(ordered) * step / 10))] |
| for step in range(1, 10)] |
| return [str(sum(value > cut for cut in cuts)) for value in numeric] |
|
|
|
|
| def feature_association(values, answers): |
| if values and all(isinstance(value, (int, float)) and not isinstance(value, bool) |
| for value in values): |
| return cramers_v(decile_labels(values), answers), "numeric_deciles" |
| normalized = [repr(value) if isinstance(value, (dict, list)) else str(value) |
| for value in values] |
| return cramers_v(normalized, answers), "categorical" |
|
|
|
|
| def distributions(records, continuous, categorical): |
| return { |
| "continuous": {name: quantiles([row[name] for row in records]) |
| for name in continuous}, |
| "categorical": {name: dict(sorted(Counter(str(row[name]) for row in records).items())) |
| for name in categorical}, |
| } |
|
|
|
|
| def answer_distributions(records): |
| result = {} |
| for level in range(1, 6): |
| counts = Counter(str(row["questions"][level - 1]["ground_truth"]) for row in records) |
| total = sum(counts.values()) |
| result[str(level)] = { |
| "counts": dict(counts), |
| "constant_answer_baseline": max(counts.values(), default=0) / total if total else 0.0, |
| } |
| return result |
|
|
|
|
| def leak_audit(records, feature_names, whitelist): |
| result = {} |
| for feature in feature_names: |
| values = [row[feature] for row in records] |
| levels = {} |
| for level in range(1, 6): |
| answers = [row["questions"][level - 1]["ground_truth"] for row in records] |
| value, kind = feature_association(values, answers) |
| levels[str(level)] = {"cramers_v": value, "kind": kind} |
| result[feature] = { |
| "levels": levels, |
| "classification": "definitional" if feature in whitelist else "scene_feature", |
| "whitelist_justification": whitelist.get(feature), |
| } |
| return result |
|
|
|
|
| def split_summary(records, value_field, split_field): |
| groups = defaultdict(list) |
| for row in records: |
| groups[str(row[split_field])].append(row[value_field]) |
| return {key: quantiles(values) for key, values in sorted(groups.items())} |
|
|
