| """Deterministic, case-preserving evaluation sampling with a strict case cap.""" |
|
|
| import hashlib |
| import json |
| import random |
| from collections import Counter, defaultdict |
|
|
| import numpy as np |
|
|
| from .dataset_schema import VERSION as DATASET_SCHEMA_VERSION |
| from .dataset_training import training_view |
|
|
|
|
| def _signature(decision): |
| return hashlib.sha256( |
| json.dumps(sorted((o["id"], o["description"]) for o in decision["options"])).encode() |
| ).hexdigest() |
|
|
|
|
| def _decisions(dataset): |
| |
| if "input" not in dataset.column_names: |
| for batch in dataset.select_columns(["decisions"]).iter(batch_size=256): |
| yield from batch["decisions"] |
| return |
| for batch in dataset.iter(batch_size=256): |
| for row_index, schema_version in enumerate(batch["schema_version"]): |
| if schema_version != DATASET_SCHEMA_VERSION: |
| raise ValueError(f"Expected {DATASET_SCHEMA_VERSION} rows in structured release") |
| row = {name: values[row_index] for name, values in batch.items()} |
| yield training_view(row)["decisions"] |
|
|
|
|
| def select_balanced_cases(dataset, *, cap, seed, name): |
| """Balance Noul / repeated Choice classes; keep soft targets and whole cases. |
| |
| The cap is never expanded for class coverage. Multi-axis coverage is greedy, |
| so unmet quotas and missing classes are reported rather than guaranteed. |
| """ |
| if not isinstance(cap, int) or isinstance(cap, bool) or cap < 1: |
| raise ValueError("cap must be a positive integer") |
| rng = random.Random(f"{seed}:{name}:balanced-v1") |
| signatures = Counter( |
| _signature(d) for ds in _decisions(dataset) for d in ds if d["type"] == "choice" |
| ) |
| features, bands = [], [] |
| axis_labels = defaultdict(set) |
| for decisions in _decisions(dataset): |
| fs, confidence = set(), {} |
| for d in decisions: |
| if d["type"] == "noul": |
| axis = "noul:" + d["decision_id"] |
| elif d["type"] == "choice" and signatures[_signature(d)] >= 2: |
| axis = "choice:" + d["decision_id"] + ":" + _signature(d) |
| else: |
| continue |
| target = d.get("target") |
| if not target: |
| raise ValueError("Balanced sampling requires labeled decisions") |
| peak = max(target["probabilities"]) |
| winners = [ |
| label |
| for label, p in zip(target["option_ids"], target["probabilities"], strict=True) |
| if abs(p - peak) < 1e-8 |
| ] |
| label = winners[0] if len(winners) == 1 else "__tie__" |
| axis_labels[axis].update(o["id"] for o in d["options"]) |
| axis_labels[axis].add(label) |
| key = (axis, label) |
| fs.add(key) |
| confidence[key] = ( |
| "hard" if peak >= 1 - 1e-6 else "soft_high" if peak >= 0.8 else "soft_low" |
| ) |
| features.append(fs) |
| bands.append(confidence) |
| available = Counter(f for fs in features for f in fs) |
| target_count = min(cap, len(features)) |
| single = bool(features) and len(axis_labels) == 1 and all(len(fs) == 1 for fs in features) |
| quotas = Counter() |
| if single: |
| mode = "single_axis_uniform_classes" |
| buckets = defaultdict(list) |
| for i, fs in enumerate(features): |
| buckets[next(iter(fs))].append(i) |
| keys = sorted(buckets) |
| rng.shuffle(keys) |
| |
| remaining = target_count |
| while remaining: |
| for key in keys: |
| if quotas[key] < len(buckets[key]) and remaining: |
| quotas[key] += 1 |
| remaining -= 1 |
| chosen = [] |
| for key in keys: |
| quota = quotas[key] |
| strata = defaultdict(list) |
| for i in buckets[key]: |
| strata[bands[i][key]].append(i) |
| weights = {b: quota * len(ids) / len(buckets[key]) for b, ids in strata.items()} |
| counts = {b: int(v) for b, v in weights.items()} |
| order = sorted(weights) |
| rng.shuffle(order) |
| order.sort(key=lambda b: weights[b] - counts[b], reverse=True) |
| for b in order[: quota - sum(counts.values())]: |
| counts[b] += 1 |
| for b in sorted(strata): |
| chosen.extend(rng.sample(strata[b], counts[b])) |
| elif available: |
| mode = "multilabel_case_preserving" |
| keys = sorted(available) |
| keyindex = {key: i for i, key in enumerate(keys)} |
| rr, cc = [], [] |
| for i, fs in enumerate(features): |
| for f in sorted(fs): |
| rr.append(i) |
| cc.append(keyindex[f]) |
| row_indices, columns = np.asarray(rr), np.asarray(cc) |
| for axis, labels in axis_labels.items(): |
| eligible = sum(any(f[0] == axis for f in fs) for fs in features) |
| desired = max(1, round(target_count * eligible / len(features) / len(labels))) |
| for label in labels: |
| quotas[(axis, label)] = min(available[(axis, label)], desired) |
| desired = np.array([quotas[k] for k in keys], dtype=float) |
| supply = np.array([available[k] for k in keys], dtype=float) |
| selected = np.zeros(len(keys)) |
| used = np.zeros(len(features), dtype=bool) |
| jitter = np.array([rng.random() * 1e-9 for _ in features]) |
| chosen = [] |
| for _ in range(target_count): |
| weights = 1000 * (selected == 0) + np.maximum(0, desired - selected) / np.maximum( |
| 1, desired |
| ) / np.sqrt(supply) |
| scores = ( |
| np.bincount(row_indices, weights=weights[columns], minlength=len(features)) + jitter |
| ) |
| scores[used] = -np.inf |
| index = int(scores.argmax()) |
| chosen.append(index) |
| used[index] = True |
| for key in features[index]: |
| selected[keyindex[key]] += 1 |
| else: |
| mode = "uniform" |
| chosen = rng.sample(range(len(features)), target_count) |
| observed = Counter(f for i in chosen for f in features[i]) |
| confidence_available = Counter((key, band) for bs in bands for key, band in bs.items()) |
| confidence_selected = Counter((key, band) for i in chosen for key, band in bands[i].items()) |
| labels = [] |
| for axis, values in sorted(axis_labels.items()): |
| for label in sorted(values): |
| key = (axis, label) |
| desired = quotas[key] |
| labels.append( |
| dict( |
| axis=axis, |
| label=label, |
| available=available[key], |
| desired=desired, |
| selected=observed[key], |
| unavailable=available[key] == 0, |
| missing=available[key] > 0 and observed[key] == 0, |
| shortfall=max(0, desired - observed[key]), |
| confidence_bands={ |
| b: dict( |
| available=confidence_available[(key, b)], |
| selected=confidence_selected[(key, b)], |
| ) |
| for b in ["hard", "soft_high", "soft_low"] |
| }, |
| ) |
| ) |
| return sorted(chosen), dict( |
| version="balanced-v1-strict-cap", |
| policy=mode, |
| seed=seed, |
| source_cases=len(features), |
| requested_cap=cap, |
| selected_cases=len(chosen), |
| expanded_for_class_coverage=False, |
| labels=labels, |
| ) |
|
|
