"""Seeded exact dense-bin sampling and the author's pooled sparse-bin grouping.""" from collections import Counter, defaultdict import json from pathlib import Path import shutil import sqlite3 import tempfile import numpy as np import pandas as pd from _common import numeric, output_path, parser, unique, preflight_outputs INPUT_COLUMNS = ["Frame", "EV_Vehicle_ID", "POV_Vehicle_ID", "x_local", "y_local", "v_rel", "cangle"] OUTPUT_COLUMNS = INPUT_COLUMNS + ["round_v", "Sample_Group_ID"] def read_chunks(path, chunksize): last_frame, boundary = None, set() with pd.read_csv(path, usecols=INPUT_COLUMNS, chunksize=chunksize) as reader: for chunk in reader: numeric(chunk, ["Frame", "EV_Vehicle_ID", "POV_Vehicle_ID", "cangle"], integer=True) numeric(chunk, ["x_local", "y_local", "v_rel"]) unique(chunk, ["Frame", "EV_Vehicle_ID", "POV_Vehicle_ID"]) if not len(chunk): continue if not chunk.Frame.is_monotonic_increasing or (last_frame is not None and chunk.Frame.iloc[0] < last_frame): raise ValueError("Candidate CSV must be sorted by Frame") if last_frame is not None: keys = set(map(tuple, chunk.loc[chunk.Frame.eq(last_frame), ["EV_Vehicle_ID", "POV_Vehicle_ID"]].to_numpy())) if boundary & keys: raise ValueError("Duplicate pair/frame across CSV chunks") tail = set(map(tuple, chunk.loc[chunk.Frame.eq(chunk.Frame.iloc[-1]), ["EV_Vehicle_ID", "POV_Vehicle_ID"]].to_numpy())) boundary = boundary | tail if last_frame == chunk.Frame.iloc[-1] else tail last_frame = chunk.Frame.iloc[-1] if not chunk.cangle.isin([0, 1]).all() or chunk.v_rel.le(0).any() or chunk.EV_Vehicle_ID.eq(chunk.POV_Vehicle_ID).any(): raise ValueError("Require binary cangle, positive relative speed, and distinct vehicle IDs") yield chunk def balance(input_path, output, audit_path, target=50000, max_relative_speed=30., seed=42, chunksize=500000, work_dir=None): if target < 1 or int(target) != target or chunksize < 1 or not np.isfinite(max_relative_speed) or max_relative_speed <= 0: raise ValueError("Require positive integer target/chunksize and finite positive maximum speed") preflight_outputs(output, audit_path) if Path(output).resolve() == Path(audit_path).resolve() or Path(audit_path).exists(): raise FileExistsError("Choose distinct new output and audit filenames") source = Path(input_path) initial_stat = (source.stat().st_size, source.stat().st_mtime_ns) counts, input_rows, excluded = Counter(), 0, 0 for chunk in read_chunks(source, chunksize): input_rows += len(chunk) excluded += int(chunk.v_rel.gt(max_relative_speed).sum()) chunk = chunk.loc[chunk.v_rel.le(max_relative_speed)].copy() chunk["round_v"] = np.round(chunk.v_rel, 1) counts.update({(int(c), float(v)): int(n) for (c, v), n in chunk.groupby(["cangle", "round_v"]).size().items()}) if not counts: raise ValueError("No eligible candidate records at or below the maximum relative speed") if not any(n >= target for n in counts.values()) and not any(sum(n for (c, _), n in counts.items() if c == category) >= target for category in (0, 1)): raise ValueError("Insufficient observations to form any complete fitting group; no balanced CSV written") rng = np.random.default_rng(seed) selected = {key: np.sort(rng.choice(count, target, replace=False)) for key, count in sorted(counts.items()) if count >= target} offsets = defaultdict(int) groups, dropped_sparse = [], {} dense_rows = 0 if work_dir is not None: Path(work_dir).mkdir(parents=True, exist_ok=True) with tempfile.TemporaryDirectory(prefix="pair_balance_", dir=work_dir) as temporary_dir: dense_path = Path(temporary_dir) / "dense.csv" con = sqlite3.connect(Path(temporary_dir) / "sparse.sqlite") try: con.execute("CREATE TABLE sparse (ordinal INTEGER PRIMARY KEY, Frame INTEGER, EV_Vehicle_ID INTEGER, POV_Vehicle_ID INTEGER, x_local REAL, y_local REAL, v_rel REAL, cangle INTEGER)") ordinal = 0 for chunk in read_chunks(source, chunksize): chunk = chunk.loc[chunk.v_rel.le(max_relative_speed)].copy() chunk["round_v"] = np.round(chunk.v_rel, 1) for key, group in chunk.groupby(["cangle", "round_v"], sort=True): key = int(key[0]), float(key[1]) if key in selected: start, stop = offsets[key], offsets[key] + len(group) choice = selected[key] local = choice[(choice >= start) & (choice < stop)] - start part = group.iloc[local].copy() part["Sample_Group_ID"] = f"dense_{key[0]}_{int(round(key[1] * 10))}" if len(part): part[OUTPUT_COLUMNS].to_csv(dense_path, mode="a", header=not dense_path.exists(), index=False) dense_rows += len(part) offsets[key] = stop else: records = [(ordinal + i, int(r.Frame), int(r.EV_Vehicle_ID), int(r.POV_Vehicle_ID), float(r.x_local), float(r.y_local), float(r.v_rel), int(r.cangle)) for i, r in enumerate(group[INPUT_COLUMNS].itertuples(index=False))] con.executemany("INSERT INTO sparse VALUES (?,?,?,?,?,?,?,?)", records) ordinal += len(records) con.commit() if (source.stat().st_size, source.stat().st_mtime_ns) != initial_stat: raise ValueError("Input changed between sampling passes") if any(offsets[key] != counts[key] for key in selected) or dense_rows != len(selected) * target: raise RuntimeError("Sampling counts changed; refusing an incomplete dense sample") for (cangle, speed), size in sorted(counts.items()): if (cangle, speed) in selected: groups.append({"Sample_Group_ID": f"dense_{cangle}_{int(round(speed * 10))}", "cangle": cangle, "round_v": speed, "kind": "dense_rounded_bin", "input_count": size, "output_count": target}) con.execute("CREATE INDEX sparse_speed ON sparse(cangle,v_rel,ordinal)") with output_path(output) as temporary: if dense_path.exists(): shutil.copyfile(dense_path, temporary) else: pd.DataFrame(columns=OUTPUT_COLUMNS).to_csv(temporary, index=False) for category in (0, 1): cursor = con.execute("SELECT Frame,EV_Vehicle_ID,POV_Vehicle_ID,x_local,y_local,v_rel,cangle FROM sparse WHERE cangle=? ORDER BY v_rel,ordinal", (category,)) index = 0 while True: records = cursor.fetchmany(target) if len(records) < target: dropped_sparse[str(category)] = len(records) break group = pd.DataFrame.from_records(records, columns=INPUT_COLUMNS) group["round_v"] = float(np.round(group.v_rel.mean(), 1)) group["Sample_Group_ID"] = f"sparse_{category}_{index}" group[OUTPUT_COLUMNS].to_csv(temporary, mode="a", header=False, index=False) groups.append({"Sample_Group_ID": f"sparse_{category}_{index}", "cangle": category, "round_v": float(group.round_v.iloc[0]), "kind": "pooled_sparse_sorted_block", "input_count": target, "output_count": target, "v_min": float(group.v_rel.min()), "v_max": float(group.v_rel.max())}) index += 1 finally: con.close() keys = Counter((g["cangle"], g["round_v"]) for g in groups) audit = {"input_rows": input_rows, "input_bytes": initial_stat[0], "excluded_above_max_relative_speed": excluded, "max_relative_speed_mps": max_relative_speed, "target_samples": target, "seed": seed, "dense_sampling": "Exact uniform sampling without replacement; RNG PCG64; deterministic for this row order and seed", "sparse_grouping": "Pool nondense bins within category; sort by v_rel then original order; full target-sized blocks; drop final remainder", "sparse_remainder_discarded": dropped_sparse, "groups": groups, "output_rows": len(groups) * target, "representative_key_collisions": [{"cangle": c, "round_v": v, "group_count": n} for (c, v), n in keys.items() if n > 1], "historical_sample_identity": "Original script had no seed. This seeded sample cannot be claimed identical to historical samples."} with output_path(audit_path) as temporary: Path(temporary).write_text(json.dumps(audit, indent=2, allow_nan=False), encoding="utf-8") return audit def main(): p = parser(__doc__) p.add_argument("--input", required=True, help="Frame-sorted full candidate-pair CSV") p.add_argument("--output", required=True, help="New balanced sample CSV; use only for fitting") p.add_argument("--audit", required=True, help="New JSON group counts, discarded remainders and key collisions") p.add_argument("--target-samples", type=int, default=50000, help="Original production value: 50000") p.add_argument("--max-relative-speed", type=float, default=30., help="Original fitting cutoff in m/s; not the annotation cutoff") p.add_argument("--seed", type=int, default=42) p.add_argument("--chunksize", type=int, default=500000) p.add_argument("--work-dir", help="Writable scratch directory for sparse rows; needs disk capacity") a = p.parse_args() balance(a.input, a.output, a.audit, a.target_samples, a.max_relative_speed, a.seed, a.chunksize, a.work_dir) if __name__ == "__main__": main()