#!/usr/bin/env python3 """ matcher_v5.py — merged entity matcher. Replaces voicepii_benchmark's `hit` and matcher_final's `is_hit`, fixing real bugs found in BOTH. WHY A MERGE ----------- On the PHI set the two matchers disagreed on 93 clips (308 vs 353 for vfast). Auditing the disagreements showed each was wrong in a different direction: matcher_v4/voicepii_benchmark MISSED (too strict) - compound numbers: 'seventy-seven' -> 707 instead of 77 - 'eight o two o three' -> no 'o'->0 mapping, so 80203 never matched - abbreviations inside longer golds matcher_final PASSED things it should not (too loose) - `gold_digits in re.sub(r'\\D','',normalize_alnum(transcript))` searches the ENTIRE transcript's concatenated digit stream, so digits scattered across unrelated clauses can satisfy a gold ID. - That is why PN-01 still fires: gold 555-201-4478 vs 'five five five two o L one four four seven eight'. The stray 'l' is a real transcription error, but the digit-stream test skips right over it. PN-01 was one of the three clips manually excluded as a false positive in July; it is still firing. THE FIX: CONTIGUOUS-TOKEN MATCHING ---------------------------------- The transcript is compiled into an ordered token stream where each token is either a letter-chunk, a digit-chunk (from a spoken number run), or a word. A gold value matches only if its canonical form equals the concatenation of ADJACENT tokens. Nothing may be skipped. 'l nine nine zero two three four one' -> ['l']['9902341'] -> L9902341 HIT 'five five five two o l one four four seven eight' -> ['55520']['l']['14478'] -> 5552014478 requires skipping 'l' MISS This bounds the search structurally instead of by a heuristic window, so it fixes the false positive without hand-tuning a threshold. AMBIGUOUS NUMBER RUNS --------------------- 'twenty three nine four eight five' can be read as 23-9-4-8-5 (239485) or 20-3-9-4-8-5 (2039485). Text alone cannot resolve it; only the audio can. Both readings are generated and either may match. This is deliberately permissive on a genuinely ambiguous case, and it is flagged per-clip by which_path() so you can audit how often it fires. python3 matcher_v5.py --selftest python3 matcher_v5.py --in entity_hits.csv --by-category python3 matcher_v5.py --compare voicepii_benchmark,matcher_final --in ... """ import argparse import csv import re import sys import unicodedata # ============================================================ # # NORMALIZATION # # ============================================================ # def canon(s): # Fold diacritics to ASCII first. Stripping them outright turns # 'Chisinau' into 'chinu', which can never match a correct transcript. s = unicodedata.normalize("NFKD", str(s)) s = "".join(c for c in s if not unicodedata.combining(c)) s = s.replace("\u0142", "l").replace("\u0141", "L") s = s.replace("\u00f8", "o").replace("\u00e6", "ae").replace("\u00df", "ss") return re.sub(r"[^a-z0-9]", "", s.lower()) UNITS = { "zero": 0, "one": 1, "two": 2, "three": 3, "four": 4, "five": 5, "six": 6, "seven": 7, "eight": 8, "nine": 9, } TEENS = { "ten": 10, "eleven": 11, "twelve": 12, "thirteen": 13, "fourteen": 14, "fifteen": 15, "sixteen": 16, "seventeen": 17, "eighteen": 18, "nineteen": 19, } TENS = { "twenty": 20, "thirty": 30, "forty": 40, "fourty": 40, "fifty": 50, "sixty": 60, "seventy": 70, "eighty": 80, "ninety": 90, } ZEROISH = {"o", "oh", "nought"} SCALES = {"hundred", "thousand", "million"} GLUE = {"and", "point", "dash", "hyphen"} ORDINAL_TO_CARD = { "first": "one", "second": "two", "third": "three", "fourth": "four", "fifth": "five", "sixth": "six", "seventh": "seven", "eighth": "eight", "ninth": "nine", "tenth": "ten", "eleventh": "eleven", "twelfth": "twelve", "thirteenth": "thirteen", "fourteenth": "fourteen", "fifteenth": "fifteen", "sixteenth": "sixteen", "seventeenth": "seventeen", "eighteenth": "eighteen", "nineteenth": "nineteen", "twentieth": "twenty", "thirtieth": "thirty", "fortieth": "forty", "fiftieth": "fifty", "sixtieth": "sixty", "seventieth": "seventy", "eightieth": "eighty", "ninetieth": "ninety", } SYMWORDS = { "dot": ".", "period": ".", "at": "@", "underscore": "_", "slash": "/", "colon": ":", "plus": "+", } # Spoken separators that vanish under canon() in the gold value. SEPWORDS = {"dash", "hyphen", "space"} MONTHS = { "january": 1, "february": 2, "march": 3, "april": 4, "may": 5, "june": 6, "july": 7, "august": 8, "september": 9, "october": 10, "november": 11, "december": 12, } def is_numword(w): return w in UNITS or w in TEENS or w in TENS or w in ZEROISH or w in SCALES def tokenize(text): """Split into lowercase words, expanding hyphenated compounds.""" raw = re.findall(r"[a-z0-9]+(?:['’][a-z]+)?|[0-9]+", str(text).lower()) out = [] for w in re.split(r"[\s\-–—/]+", str(text).lower()): w = re.sub(r"[^a-z0-9'’.@_:]+", "", w) if w: out.append(w) return out or raw # ============================================================ # # SPOKEN NUMBER RUNS # # ============================================================ # def _run_readings(run): """Return candidate digit-strings for one run of number words. Two readings are produced where they differ: merged : tens + following unit combine ('twenty' 'three' -> 23) unmerged : every token stands alone ('twenty' 'three' -> 20,3) Scale words and glue are dropped; 'o'/'oh' become 0. """ toks = [t for t in run if t not in SCALES and t not in GLUE] if not toks: return set() def emit(merge): parts = [] i = 0 while i < len(toks): w = toks[i] if w in ZEROISH: parts.append("0") i += 1 elif w in TENS: if ( merge and i + 1 < len(toks) and toks[i + 1] in UNITS and toks[i + 1] != "zero" ): parts.append(str(TENS[w] + UNITS[toks[i + 1]])) i += 2 else: parts.append(str(TENS[w])) i += 1 elif w in TEENS: parts.append(str(TEENS[w])) i += 1 elif w in UNITS: parts.append(str(UNITS[w])) i += 1 elif w.isdigit(): parts.append(w) i += 1 else: i += 1 return "".join(parts) return {r for r in (emit(True), emit(False)) if r} def compile_tokens(text): """Compile a transcript into an ordered list of token-alternative sets. Each element is a set of strings that token could contribute. Words map to themselves (canonicalized); number runs map to their digit readings; symbol words map to their symbol. Adjacent elements may be concatenated when testing a gold value -- nothing may be skipped. """ words = tokenize(text) # normalize ordinals so '15th'/'fifteenth' behave like 'fifteen' words = [ORDINAL_TO_CARD.get(w, w) for w in words] words = [re.sub(r"^(\d+)(st|nd|rd|th)$", r"\1", w) for w in words] toks = [] i = 0 n = len(words) while i < n: w = words[i] if is_numword(w) or w.isdigit(): j = i run = [] real = 0 while j < n and ( is_numword(words[j]) or words[j].isdigit() or words[j] in GLUE ): if words[j] not in GLUE: run.append(words[j]) if words[j] not in ZEROISH: real += 1 else: run.append(words[j]) j += 1 while run and run[-1] in GLUE: run.pop() j -= 1 # a lone 'o'/'oh' with no numeric neighbour is the letter O if real == 0: toks.append({canon(w)}) i += 1 continue readings = _run_readings(run) if readings: toks.append(readings) i = j elif w in SEPWORDS: # a spoken separator canon()s away in the gold, so allow skipping toks.append({"", canon(w)}) i += 1 elif w in SYMWORDS: toks.append({SYMWORDS[w], canon(w)}) i += 1 else: c = canon(w) if c: toks.append({c}) i += 1 return toks def contiguous_match(gold_canon, toks, max_span=24): """True if gold equals the concatenation of some ADJACENT token window.""" if not gold_canon: return False n = len(toks) for start in range(n): frontier = {""} for k in range(start, min(n, start + max_span)): nxt = set() for pre in frontier: for alt in toks[k]: cand = pre + canon(alt) if cand == gold_canon: return True if gold_canon.startswith(cand): nxt.add(cand) if not nxt: break frontier = nxt return False # ============================================================ # # ABBREVIATION / ALIASES # # ============================================================ # ALIAS = [ ("street", "st"), ("avenue", "ave"), ("road", "rd"), ("boulevard", "blvd"), ("drive", "dr"), ("lane", "ln"), ("court", "ct"), ("apartment", "apt"), ("suite", "ste"), ("doctor", "dr"), ("mister", "mr"), ("missus", "mrs"), ("saint", "st"), ("mount", "mt"), ("fort", "ft"), ("junior", "jr"), ("senior", "sr"), ("post office box", "po box"), ("and", "&"), ("medical record number", "mrn"), ("social security number", "ssn"), ("date of birth", "dob"), ("percent", "%"), ("dollars", "$"), ] def alias_variants(gold): """Expand a gold value into equivalent surface forms.""" out = {canon(gold)} g = str(gold).lower() for long, short in ALIAS: if long in g: out.add(canon(g.replace(long, short))) if short in g: out.add(canon(g.replace(short, long))) return {v for v in out if v} # ============================================================ # # MASTER TEST # # ============================================================ # def hit(gold, transcript): g = str(gold).strip() t = str(transcript).strip() if not g or not t: return False gc = canon(g) tc = canon(t) if gc and gc in tc: # plain surface match return True for v in alias_variants(g): # abbreviation equivalence if v and v in tc: return True toks = compile_tokens(t) if contiguous_match(gc, toks): # spoken-form match return True for v in alias_variants(g): if v != gc and contiguous_match(v, toks): return True if date_hit(g, t): return True return False _DATE_GOLD = re.compile(r"^(\d{1,2})[/\-.](\d{1,2})[/\-.](\d{2,4})$") def spoken_years(words): """4-digit years from spoken forms: 'nineteen eighty five', 'two thousand twelve'.""" ys = set() for i, w in enumerate(words): if w.isdigit() and len(w) == 4: ys.add(int(w)) # 'nineteen/twenty' + tens[+unit] if w in TEENS and 10 <= TEENS[w] <= 20: head = TEENS[w] j, tail = i + 1, None if j < len(words) and words[j] in TENS: tail = TENS[words[j]] if j + 1 < len(words) and words[j + 1] in UNITS: tail += UNITS[words[j + 1]] elif j < len(words) and words[j] in TEENS: tail = TEENS[words[j]] if tail is not None and tail < 100: ys.add(head * 100 + tail) if w in TENS and TENS[w] == 20: j = i + 1 if j < len(words) and words[j] in TENS: t = TENS[words[j]] if j + 1 < len(words) and words[j + 1] in UNITS: t += UNITS[words[j + 1]] ys.add(2000 + t) # 'two thousand [and] twelve' if w in UNITS and i + 1 < len(words) and words[i + 1] == "thousand": base = UNITS[w] * 1000 j = i + 2 if j < len(words) and words[j] == "and": j += 1 rest = 0 if j < len(words) and words[j] in TEENS: rest = TEENS[words[j]] elif j < len(words) and words[j] in TENS: rest = TENS[words[j]] if j + 1 < len(words) and words[j + 1] in UNITS: rest += UNITS[words[j + 1]] elif j < len(words) and words[j] in UNITS: rest = UNITS[words[j]] ys.add(base + rest) return ys def spoken_days(words): """Day-of-month values from ordinals or plain numbers.""" ds = set() for i, w in enumerate(words): if w.isdigit() and 1 <= int(w) <= 31: ds.add(int(w)) if w in UNITS: ds.add(UNITS[w]) if w in TEENS: ds.add(TEENS[w]) if w in TENS: ds.add(TENS[w]) if i + 1 < len(words) and words[i + 1] in UNITS: ds.add(TENS[w] + UNITS[words[i + 1]]) return ds def date_hit(gold, transcript): """Numeric date gold vs spoken month-name form.""" m = _DATE_GOLD.match(str(gold).strip()) if not m: return False mm, dd, yy = int(m.group(1)), int(m.group(2)), int(m.group(3)) if yy < 100: yy += 1900 if yy > 30 else 2000 words = [ORDINAL_TO_CARD.get(w, w) for w in tokenize(transcript)] text = " ".join(words) month_ok = ( any(MONTHS.get(w) == mm for w in words) or re.search(rf"\b0?{mm}\b", text) is not None ) day_ok = dd in spoken_days(words) year_ok = yy in spoken_years(words) or str(yy) in text return bool(month_ok and day_ok and year_ok) def which_path(gold, transcript): g, t = str(gold), str(transcript) gc = canon(g) if gc and gc in canon(t): return "exact" for v in alias_variants(g): if v and v in canon(t): return "alias" toks = compile_tokens(t) if contiguous_match(gc, toks): return "spoken" for v in alias_variants(g): if v != gc and contiguous_match(v, toks): return "spoken+alias" if date_hit(g, t): return "date" return "miss" # ============================================================ # # VALIDATION SET # # ============================================================ # # Positives from both prior suites, plus every disagreement audited by hand. CASES = [ # ---- plain ---- ("Michael Thompson", "i spoke with michael thompson yesterday", True), ("NVIDIA", "the nvidia earnings call is tomorrow", True), ("Julian O'Brien", "this is julian o'brien calling about a bill", True), # ---- compound numbers (matcher_v4 MISSED these) ---- ("77 Harbor View Drive", "i still live at seventy-seven harbor view drive", True), ("356 Maple Terrace", "my new address is three fifty-six maple terrace", True), ("94 Fairview Road", "delivery should go to ninety-four fairview road", True), ("27609", "the zip code is twenty-seven six-oh-nine", True), ("80203", "the zip code should be eight o two o three", True), ("712", "my credit score is showing a seven hundred and twelve", True), ("648", "my credit score is six hundred and forty-eight", True), ("1274", "i'd like to update my pin to twelve seventy-four", True), ("6690", "let me give you the pin it's sixty-six ninety", True), ("482", "my security code is four eighty two", True), ("739", "my security code is seven thirty-nine", True), ("20-30-45", "my sort code is twenty thirty forty-five", True), ("10-88-23", "the sort code on file is ten eighty-eight twenty-three", True), ("11/25", "the expiration date is eleven twenty-five", True), ("06/26", "i'd like to update my expiration date to oh six twenty-six", True), ( "$4,281.53", "the balance is four thousand two hundred and eighty-one fifty three", True, ), ( "987654321", "my tax file number is nine eight seven six five four three two one", True, ), ( "123 456 782", "my tax file number is one hundred and twenty-three four five six seven eight two", True, ), ("527 748 190", "it's five twenty-seven seven four eight one nine oh", True), ("9081726", "the license number is nine o eight one seven two six", True), # ---- alphanumeric IDs ---- ("L9902341", "my national id number is l nine nine zero two three four one", True), ("MRN-88231", "the record is m r n dash eight eight two three one", True), ("M2233445", "update my license to m two two three three four four five", True), ( "192.168.1.1", "the gateway is one nine two dot one six eight dot one dot one", True, ), # ---- email / address / abbreviation ---- ( "michael.thompson82@gmail.com", "send it to michael dot thompson eighty two at gmail dot com", True, ), ("sarah.alvarez@yahoo.com", "my email is sarah dot alvarez yahoo dot com", True), ( "PO Box 118, Austin, TX 78704", "my mailing address is p o box one eighteen austin t x seven eight seven o four", True, ), ("Dr.", "please make sure my title uh doctor is on the paperwork", True), ("Jr.", "could you add junior after my name on the account", True), ("482 Willowbrook Street", "mail it to 482 willowbrook st", True), # ---- dates ---- ("03/14/1985", "her date of birth is march fourteenth nineteen eighty five", True), ("12/25/2012", "it was december twenty-fifth two thousand twelve", True), ("03/14/1985", "her date of birth is march fourteenth nineteen eighty six", False), # ---- FALSE POSITIVES matcher_final accepted; must be MISSES ---- # PN-01: stray 'l' inside the digit span is a real error. ( "555-201-4478", "you can reach me at five five five two o l one four four seven eight", False, ), # digits scattered across unrelated clauses must not satisfy a gold ID ("4471", "i have four cats and four hundred and seventy one dollars", False), ("617-555-0142", "call six one seven five five five zero one four three", False), ("A7X-42B", "policy a seven x dash four two d", False), # ---- hard negatives, both suites ---- ("Osei", "my maiden name is osay that's how i spell it", False), ("Fischer", "doctor fisher signed the chart", False), ("Rowe", "mister roe called back", False), ("Devon Chen", "devin chen arrived early", False), ("Groq", "we tested grok on the same workload", False), ("tubal ligation", "she had a two ball ligation in twenty ten", False), ("O negative", "the patient is o positive", False), ( "sarah.jones@yahoo.com", "send it to michael dot thompson at gmail dot com", False, ), ("482 Willowbrook Lane", "mail it to five eight two willowbrook lane", False), ] def validate(verbose=True): fails = [] for gold, hyp, expect in CASES: got = hit(gold, hyp) if got != expect: fails.append((gold, hyp, expect, got, which_path(gold, hyp))) if verbose: print(f"matcher_v5 self-test: {len(CASES)-len(fails)}/{len(CASES)} pass") for gold, hyp, exp, got, path in fails: print(f" FAIL gold={gold!r} expected={exp} got={got} via={path}") print(f" hyp={hyp!r}") return not fails # ============================================================ # # SCORER # # ============================================================ # def score(path, by_category=False, dump=None): rows = list(csv.DictReader(open(path, newline="", encoding="utf-8"))) if not rows: print("no rows") return systems = [c[:-5] for c in rows[0] if c.endswith("_text")] n = len(rows) tot = {s: 0 for s in systems} cats = {} out = [] for r in rows: g = r.get("pii_value", "") cat = r.get("category", "") or "(none)" b = cats.setdefault(cat, {s: 0 for s in systems}) b["_n"] = b.get("_n", 0) + 1 rec = {"script_id": r.get("script_id", ""), "category": cat, "pii_value": g} for s in systems: h = hit(g, r.get(f"{s}_text", "")) tot[s] += h b[s] += h rec[s] = int(h) rec[f"{s}_path"] = which_path(g, r.get(f"{s}_text", "")) rec[f"{s}_text"] = r.get(f"{s}_text", "") out.append(rec) print(f"\n=== entity transcription accuracy — {n} clips — {path} ===") for s in systems: print(f" {s:<12} {tot[s]:>5}/{n} = {tot[s]/n:6.1%}") if by_category: print(f"\n{'category':<28}{'n':>5}" + "".join(f"{s:>16}" for s in systems)) for c in sorted(cats): b = cats[c] cn = b["_n"] line = f"{c[:27]:<28}{cn:>5}" for s in systems: line += f"{b[s]}/{cn} ({b[s]/cn:.0%})".rjust(16) print(line) if dump: with open(dump, "w", newline="", encoding="utf-8") as f: w = csv.DictWriter(f, fieldnames=list(out[0].keys())) w.writeheader() w.writerows(out) print(f"\nwrote {dump}") def compare(path, mods): """Score the same file under several matcher modules and diff them.""" import importlib sys.path.insert(0, ".") fns = {"v5": hit} for m in mods: mod = importlib.import_module(m) f = getattr(mod, "hit", None) or getattr(mod, "is_hit", None) if f: fns[m] = f rows = list(csv.DictReader(open(path, newline="", encoding="utf-8"))) systems = [c[:-5] for c in rows[0] if c.endswith("_text")] print(f"\n{'matcher':<28}" + "".join(f"{s:>16}" for s in systems)) for name, f in fns.items(): line = f"{name[:27]:<28}" for s in systems: k = sum(bool(f(r["pii_value"], r.get(f"{s}_text", ""))) for r in rows) line += f"{k}/{len(rows)} ({k/len(rows):.1%})".rjust(16) print(line) def main(): ap = argparse.ArgumentParser() ap.add_argument("--in", dest="inp") ap.add_argument("--selftest", action="store_true") ap.add_argument("--by-category", action="store_true") ap.add_argument("--dump", default=None) ap.add_argument( "--compare", default=None, help="comma list of other matcher modules to diff against", ) a = ap.parse_args() if a.selftest: sys.exit(0 if validate() else 1) if not validate(): sys.exit("SELF-TEST FAILED — refusing to score") if not a.inp: sys.exit("--in required") if a.compare: compare(a.inp, [m.strip() for m in a.compare.split(",")]) score(a.inp, a.by_category, a.dump) if __name__ == "__main__": main()