| |
| """Assemble the Vox Tier-2 pilot dataset with an audited stratum mixture. |
| |
| Replaces the first-N sampler that produced the degenerate v1 pilot. Every defect |
| that made v1 solvable by `len(text) >= 15` is closed here: |
| |
| 1. LENGTH MATCHING - CLEAN negatives are drawn per word-count bucket to match the |
| DISFLUENCY length histogram. v1 had CLEAN median 8 words vs DISFLUENCY 22, |
| which handed the label to a one-line rule (91.9% accuracy, no model). |
| 2. RANDOM, DOMAIN-BALANCED SAMPLING - v1 took the first N lines of clean_50k, |
| which is 100% MultiWOZ. CLEAN is now drawn across two domains. |
| 3. HARD NEGATIVES - a quota of CLEAN examples must contain filler words in KEEP |
| positions ("works well", "so the cache stays warm"). Without these the model |
| never practises the delete-vs-keep decision that actually matters. |
| 4. GOLD STRATUM QUOTAS - DISFLUENCY is drawn by gold annotation provenance |
| (self-correction / disfluency region / edit region) so no single class |
| dominates, per the taxonomy contract. |
| 5. TIER-1 PARITY - Tier-1-duplicate spans are rejected upstream in the harvester; |
| this script re-checks via dedup.deterministic_reject. |
| |
| Usage: |
| venv/bin/python sandbox/scripts/assemble_pilot.py \ |
| --dis corpus/harvest_dis.jsonl --clean corpus/harvest_clean.jsonl \ |
| --extra-clean corpus/clean_50k.jsonl \ |
| --out corpus/pilot_v2.jsonl --train-out corpus/pilot_v2_train.jsonl \ |
| --val-out corpus/pilot_v2_val.jsonl --total-dis 2000 --total-clean 2000 |
| """ |
|
|
| import argparse |
| import json |
| import random |
| import re |
| import sys |
| from collections import Counter, defaultdict |
|
|
| sys.path.insert(0, "/opt/vox/sandbox/scripts") |
| from dedup import NearDup, norm_tokens |
| from schema import DatasetExample, Span |
|
|
| FILLER_WORD = re.compile( |
| r"\b(well|like|so|just|actually|anyway|really|pretty|okay|right|sort of|kind of)\b", re.I) |
| |
| |
| |
| OPENER = re.compile(r"^\W*(well|yeah|oh|so|okay|ok|right|alright|now)\b", re.I) |
| CUE_PHRASE = re.compile(r"\b(you know|i mean|you see|i guess|sort of|kind of)\b", re.I) |
|
|
| |
| |
| |
| QUOTAS = {"correction": 0.40, "region:D": 0.35, "region:E": 0.10} |
| HARD_NEGATIVE_QUOTA = 0.40 |
|
|
|
|
| |
| |
| |
| |
| |
| |
| def load(path, limit=None): |
| out = [] |
| with open(path, encoding="utf-8") as f: |
| for line in f: |
| line = line.strip() |
| if not line: |
| continue |
| try: |
| d = json.loads(line) |
| out.append(DatasetExample(**{k: v for k, v in d.items() |
| if k in DatasetExample.model_fields})) |
| except Exception: |
| continue |
| if limit and len(out) >= limit: |
| break |
| return out |
|
|
|
|
| def stratum_of(ex: DatasetExample) -> str: |
| """Dominant gold stratum of an example.""" |
| origins = {s.origin for s in ex.spans if s.origin} |
| if "correction" in origins: |
| return "correction" |
| if origins == {"region:E"}: |
| return "region:E" |
| return "region:D" |
|
|
|
|
| def bucket_of(ex: DatasetExample) -> int: |
| return len(ex.raw_text.split()) // 5 * 5 |
|
|
|
|
| |
| |
| |
| def draw_disfluency(items, total, rng, dup): |
| """Quota-driven draw across gold strata, then top up from the remainder.""" |
| pools = defaultdict(list) |
| for ex in items: |
| pools[stratum_of(ex)].append(ex) |
| for v in pools.values(): |
| rng.shuffle(v) |
|
|
| chosen, taken = [], set() |
| for name, frac in QUOTAS.items(): |
| want = int(total * frac) |
| picked = 0 |
| for ex in pools.get(name, []): |
| if picked >= want: |
| break |
| fp = norm_tokens(ex.raw_text) |
| if dup.seen(fp): |
| continue |
| dup.add(fp) |
| chosen.append(ex) |
| taken.add(id(ex)) |
| picked += 1 |
| print(f" stratum {name:12s} quota {frac:.0%} -> {picked} (pool {len(pools.get(name, []))})") |
|
|
| leftover = [ex for pool in pools.values() for ex in pool if id(ex) not in taken] |
| rng.shuffle(leftover) |
| for ex in leftover: |
| if len(chosen) >= total: |
| break |
| fp = norm_tokens(ex.raw_text) |
| if dup.seen(fp): |
| continue |
| dup.add(fp) |
| chosen.append(ex) |
| print(f" stratum {'top-up':12s} quota n/a -> {len(chosen)} (total {len(chosen)}/{total})") |
| return chosen[:total] |
|
|
|
|
| def match_rates(dis): |
| """Surface-feature rates of the DISFLUENCY half; CLEAN must mirror them.""" |
| n = max(len(dis), 1) |
| return { |
| "opener": sum(1 for ex in dis if OPENER.match(ex.raw_text)) / n, |
| "cue": sum(1 for ex in dis if CUE_PHRASE.search(ex.raw_text)) / n, |
| "filler": sum(1 for ex in dis if FILLER_WORD.search(ex.raw_text)) / n, |
| } |
|
|
|
|
| def draw_clean(indomain, extra, dis_lut, total, rng, dup, rates): |
| """Length-matched, domain-balanced CLEAN draw with a hard-negative quota. |
| |
| `dis_lut` maps word-count bucket -> how many DISFLUENCY examples fall in it. |
| Each domain may contribute at most `domain_cap`, so one pool cannot swamp the |
| other (v1 was 100% MultiWOZ because the sampler took the first N lines). |
| """ |
| target = Counter(dis_lut) |
| domain_cap = total // 2 + total % 2 |
|
|
| |
| |
| need_opener = int(round(total * rates["opener"])) |
| need_cue = int(round(total * rates["cue"])) |
| need_filler = max(int(total * HARD_NEGATIVE_QUOTA), int(round(total * rates["filler"]))) |
|
|
| picked = [] |
| stats = Counter() |
| per_source = Counter() |
| seen_keys = set() |
|
|
| def take(ex, source): |
| key = ex.raw_text.strip().lower() |
| if key in seen_keys: |
| return False |
| fp = norm_tokens(ex.raw_text) |
| if dup.seen(fp): |
| return False |
| dup.add(fp) |
| seen_keys.add(key) |
| picked.append(ex) |
| per_source[source] += 1 |
| t = ex.raw_text |
| if OPENER.match(t): |
| stats["opener"] += 1 |
| if CUE_PHRASE.search(t): |
| stats["cue"] += 1 |
| if FILLER_WORD.search(t): |
| stats["filler"] += 1 |
| return True |
|
|
| |
| |
| pool = defaultdict(list) |
| for source, items in (("in_domain", indomain), ("technical_business", extra)): |
| for ex in items: |
| pool[bucket_of(ex)].append((ex, source)) |
| for v in pool.values(): |
| rng.shuffle(v) |
|
|
| def sweep(predicate, cap, label): |
| """Fill from the length-matched pools until `cap` items pass `predicate`.""" |
| |
| |
| for bucket in sorted(target, reverse=True): |
| if len(picked) >= cap: |
| return |
| survivors = [] |
| for ex, source in pool[bucket]: |
| if per_source[source] >= domain_cap: |
| continue |
| if not predicate(ex.raw_text): |
| survivors.append((ex, source)) |
| continue |
| if take(ex, source): |
| target[bucket] -= 1 |
| if target[bucket] <= 0: |
| break |
| else: |
| survivors.append((ex, source)) |
| pool[bucket] = survivors |
|
|
| |
| |
| sweep(lambda t: bool(OPENER.match(t)), need_opener, "opener") |
| sweep(lambda t: bool(CUE_PHRASE.search(t)), need_cue, "cue") |
| sweep(lambda t: bool(FILLER_WORD.search(t)), need_filler, "filler") |
| sweep(lambda t: True, total, "any") |
|
|
| print(f" opener-initial CLEAN : {stats['opener']}/{len(picked)}" |
| f" (target {need_opener}, DISFLUENCY rate {round(100 * rates['opener'], 1)}%)") |
| print(f" cue-phrase CLEAN : {stats['cue']}/{len(picked)}" |
| f" (target {need_cue}, DISFLUENCY rate {round(100 * rates['cue'], 1)}%)") |
| print(f" any-filler CLEAN : {stats['filler']}/{len(picked)} (target {need_filler})") |
| print(f" domain balance: {dict(per_source)} (cap {domain_cap} each)") |
| return picked[:total] |
|
|
|
|
| |
| |
| |
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--dis", default="/opt/vox/sandbox/corpus/harvest_dis.jsonl") |
| ap.add_argument("--clean", default="/opt/vox/sandbox/corpus/harvest_clean.jsonl") |
| ap.add_argument("--extra-clean", default="/opt/vox/sandbox/corpus/clean_50k.jsonl") |
| ap.add_argument("--out", default="/opt/vox/sandbox/corpus/pilot_v2.jsonl") |
| ap.add_argument("--train-out", default="/opt/vox/sandbox/corpus/pilot_v2_train.jsonl") |
| ap.add_argument("--val-out", default="/opt/vox/sandbox/corpus/pilot_v2_val.jsonl") |
| ap.add_argument("--total-dis", type=int, default=2000) |
| ap.add_argument("--total-clean", type=int, default=2000) |
| ap.add_argument("--near-dup", type=float, default=0.85) |
| ap.add_argument("--seed", type=int, default=42) |
| args = ap.parse_args() |
|
|
| rng = random.Random(args.seed) |
| dup = NearDup(args.near_dup) |
|
|
| print("Loading DISFLUENCY (gold-annotated, single-sentence)...") |
| dis_items = load(args.dis) |
| print(f" {len(dis_items)} available") |
|
|
| print("Drawing DISFLUENCY by gold stratum quota...") |
| dis = draw_disfluency(dis_items, args.total_dis, rng, dup) |
|
|
| print("Loading CLEAN pools...") |
| indomain = load(args.clean) |
| extra = load(args.extra_clean) |
| rng.shuffle(indomain) |
| rng.shuffle(extra) |
| print(f" in-domain {len(indomain)}, technical/business {len(extra)}") |
|
|
| dis_lut = Counter(bucket_of(ex) for ex in dis) |
| rates = match_rates(dis) |
| print("Drawing length-matched CLEAN with DISFLUENCY-matched hard negatives...") |
| print(f" DISFLUENCY rates: opener {round(100 * rates['opener'], 1)}%, " |
| f"cue {round(100 * rates['cue'], 1)}%, filler {round(100 * rates['filler'], 1)}%") |
| clean = draw_clean(indomain, extra, dis_lut, args.total_clean, rng, dup, rates) |
|
|
| rows = dis + clean |
| rng.shuffle(rows) |
| for i, ex in enumerate(rows, 1): |
| ex.id = f"vxb_v2_{i:05d}" |
|
|
| |
| |
| train = [ex for i, ex in enumerate(rows) if i % 5 != 0] |
| val = [ex for i, ex in enumerate(rows) if i % 5 == 0] |
|
|
| cats = Counter(ex.category for ex in rows) |
| strata = Counter(stratum_of(ex) for ex in dis) |
| print(f"\nTOTAL {len(rows)} categories {dict(cats)}") |
| print(f"DISFLUENCY strata: {dict(strata)}") |
| for path, data in ((args.out, rows), (args.train_out, train), (args.val_out, val)): |
| with open(path, "w", encoding="utf-8") as f: |
| for ex in data: |
| f.write(json.dumps(ex.model_dump(), ensure_ascii=False) + "\n") |
| print(f" wrote {len(data):5d} -> {path}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
