#!/usr/bin/env python """Deterministic sentence selection for the LLM NER annotation kit. Reads the PerDT test split in two-column IOB2 (`corpus/perdt-ner-iob/test.txt`, the `--merge-subtokens` tokenization) and writes two id-sorted JSONL files: annotation/data/pool-500.jsonl 400 entity-rich + 100 entity-free sentences annotation/data/select-100.jsonl 80 rich + 20 empty, a subset of the pool Only PER/LOC/ORG/DAT are kept as silver spans; MON/TIM/PCT are dropped (too thin to annotate: 205/135/121 train spans). A sentence is "empty" only if it has no silver span of any label at all, so the 8 MON/TIM/PCT-only sentences land in neither bucket. Selection is seeded with random.Random(0) and re-runs byte-identically. """ import argparse import json import random from pathlib import Path KEEP = ("PER", "LOC", "ORG", "DAT") MIN_TOKENS, MAX_TOKENS = 6, 45 # select-100 per-label sentence minimums, applied greedily in this order MINIMUMS = (("DAT", 20), ("ORG", 25), ("PER", 25), ("LOC", 25)) def iob_sents(path): """[(tokens, tags)] — blank line separates sentences, same reader as transfer_perdt_ner.""" sents, cur = [], [] for line in path.open(encoding="utf8"): line = line.rstrip("\n") if not line.strip(): if cur: sents.append(cur) cur = [] continue p = line.split("\t") if len(p) < 2: p = line.split() if len(p) < 2: continue cur.append((p[0], p[-1])) if cur: sents.append(cur) return [([t for t, _ in s], [g for _, g in s]) for s in sents] def spans_from_iob(tags): """[(start, end, label)] over token indices; end is exclusive.""" spans, i = [], 0 while i < len(tags): tag = tags[i] if tag.startswith("B-"): label, j = tag[2:], i + 1 while j < len(tags) and tags[j] == f"I-{label}": j += 1 spans.append((i, j, label)) i = j else: i += 1 return spans def record(split, idx, tokens, spans): return { "id": f"{split}:{idx}", "tokens": tokens, "text": " ".join(tokens), "silver": [ {"start": s, "end": e, "label": lab, "text": " ".join(tokens[s:e])} for s, e, lab in spans if lab in KEEP ], } def labels_of(rec): return {e["label"] for e in rec["silver"]} def dump(path, recs): path.parent.mkdir(parents=True, exist_ok=True) with path.open("w", encoding="utf8") as fh: for r in sorted(recs, key=lambda r: int(r["id"].split(":")[1])): fh.write(json.dumps(r, ensure_ascii=False) + "\n") def report(name, recs, n_rich, n_empty): print(f"{name}: {len(recs)} sentences ({n_rich} rich, {n_empty} empty)") for lab in KEEP: sents = sum(1 for r in recs if lab in labels_of(r)) spans = sum(1 for r in recs for e in r["silver"] if e["label"] == lab) print(f" {lab}: {sents} sentences, {spans} spans") def main(): ap = argparse.ArgumentParser(description=__doc__) ap.add_argument("--corpus", default="corpus/perdt-ner-iob/test.txt") ap.add_argument("--split", default="test") ap.add_argument("--out-dir", default="annotation/data") ap.add_argument("--seed", type=int, default=0) ap.add_argument("--mode", choices=("kit", "split"), default="kit", help="kit: test-all + pool-500 + select-100; " "split: the whole split as shards, for bulk relabelling") ap.add_argument("--shard-size", type=int, default=2000, help="sentences per shard in split mode; 0 writes one file") args = ap.parse_args() sents = iob_sents(Path(args.corpus)) rich, empty, every = [], [], [] for idx, (tokens, tags) in enumerate(sents): spans = spans_from_iob(tags) rec = record(args.split, idx, tokens, spans) every.append(rec) if not spans: empty.append(rec) elif rec["silver"] and MIN_TOKENS <= len(tokens) <= MAX_TOKENS: rich.append(rec) print(f"corpus: {len(sents)} sentences, {len(rich)} rich (after length filter), " f"{len(empty)} empty") if args.mode == "split": out = Path(args.out_dir) if args.shard_size: shards = [every[i:i + args.shard_size] for i in range(0, len(every), args.shard_size)] for n, shard in enumerate(shards): dump(out / f"shard-{n:03d}.jsonl", shard) where = f"{len(shards)} shards of <= {args.shard_size} sentences in {out}" else: dump(out / f"{args.split}-all.jsonl", every) where = f"one file, {out}/{args.split}-all.jsonl" n_any = sum(1 for r in every if r["silver"]) report(args.split, every, n_any, len(every) - n_any) print(where) return rng = random.Random(args.seed) # --- pool: 400 rich, seeded with every DAT and every ORG sentence, then a shuffled fill chosen = {r["id"] for r in rich if "DAT" in labels_of(r)} chosen |= {r["id"] for r in rich if "ORG" in labels_of(r)} pool_rich = [r for r in rich if r["id"] in chosen] if len(pool_rich) > 400: raise SystemExit(f"DAT+ORG seed is {len(pool_rich)} sentences, over the 400 budget") remainder = [r for r in rich if r["id"] not in chosen] rng.shuffle(remainder) pool_rich += remainder[: 400 - len(pool_rich)] pool_empty = list(empty) rng.shuffle(pool_empty) pool_empty = pool_empty[:100] pool = pool_rich + pool_empty # --- select-100: 80 rich meeting per-label minimums, 20 empty order = list(pool_rich) rng.shuffle(order) picked, picked_ids = [], set() def take(rec): picked.append(rec) picked_ids.add(rec["id"]) for label, minimum in MINIMUMS: have = sum(1 for r in picked if label in labels_of(r)) for r in order: if have >= minimum: break if r["id"] in picked_ids or label not in labels_of(r): continue take(r) have += 1 if have < minimum: raise SystemExit(f"cannot reach {label} >= {minimum}: only {have} available") for r in order: if len(picked) >= 80: break if r["id"] not in picked_ids: take(r) sel_empty = list(pool_empty) rng.shuffle(sel_empty) sel_empty = sel_empty[:20] select = picked + sel_empty out = Path(args.out_dir) dump(out / "test-all.jsonl", every) dump(out / "pool-500.jsonl", pool) dump(out / "select-100.jsonl", select) n_any = sum(1 for r in every if r["silver"]) report("test-all", every, n_any, len(every) - n_any) report("pool-500", pool, len(pool_rich), len(pool_empty)) report("select-100", select, len(picked), len(sel_empty)) if __name__ == "__main__": main()