Datasets:

addyo07
/

vox-tier2-backup

#!/usr/bin/env python3
"""Deterministic stratum profiler for a Tier-2 disfluency dataset.
Answers three questions that a schema/roundtrip QA gate cannot:
  1. Which disfluency archetypes are actually represented, and in what quantity?
  2. How much of the DISFLUENCY half is machine-substituted filler (not human speech)?
  3. Which trivial surface features predict the CLEAN/DISFLUENCY label?
     (A dataset that a one-line rule solves is degenerate and must be rejected.)
Usage:
  venv/bin/python sandbox/scripts/profile_disfluency.py <dataset.jsonl> [--filler-bank PATH]
Exit code 0 always; this is a reporter, not a gate. Gate thresholds live in qa_gate.py.
"""

import argparse
import json
import re
import sys
from collections import Counter

sys.path.insert(0, "/opt/vox/sandbox/scripts")
from dedup import already_gone_by_tier1

# --- Archetype cues -----------------------------------------------------------
# TRUE self-correction: speaker audibly abandons one plan and states another.
# "I mean" is deliberately NOT here — in this corpus it is overwhelmingly a
# parenthetical hedge ("..., I mean, it was classic TREK"), i.e. a filler.
SUPERSESSION_CUE = re.compile(
    r"\b(wait no|no wait|scratch that|sorry|correction|i apologize|my mistake|"
    r"or instead|make that|i said|actually)\b", re.I)

# Filler that survives Tier 1 and is genuinely ambiguous (delete vs keep).
FILLER_PHRASE = re.compile(
    r"^[\s,.]*("
    r"well|so|so then|and so|like|anyway|basically|right|okay|ok|alright|now|oh|yeah|"
    r"you know|you see|i mean|i guess|i think|kind of|sort of|pretty much|"
    r"of course|naturally|honestly|seriously|to be honest|by the way|whatever|"
    r"i mean that|i dont know|dunno|you get it|that said|in fact|indeed|"
    r"at least|well then|well i|anyways|anyhow"
    r")[\s,.]*$", re.I)

WORD = re.compile(r"[A-Za-z0-9']+")


def words(text):
    return [w.lower() for w in WORD.findall(text)]


def classify(raw, span):
    """Assign one deterministic archetype to a single span."""
    text = span["text"]
    before = raw[: span["span"][0]]
    sw = words(text)

    # 0. Duplicates of upstream Tier 1 — must never appear in a Tier-2 dataset.
    if already_gone_by_tier1(raw, text):
        return "tier1_duplicate"

    # 1. Partial phrase echo ("The client, the client is waiting") — survives Tier 1
    #    because only *consecutive identical* tokens are collapsed upstream.
    if sw:
        bw = words(before)
        for k in range(min(len(sw), 6), 0, -1):
            if len(bw) >= k and bw[-k:] == sw[:k]:
                return "repetition"

    # 2. True supersession: a correction cue governs material that gets dropped.
    if SUPERSESSION_CUE.search(text):
        return "supersession"

    # 3. Filler / discourse marker: bare hesitation, no propositional content.
    if FILLER_PHRASE.match(text.strip(" ,.")):
        return "filler"

    # 4. Everything else is an abandoned stem / false start.
    return "false_start"


def main():
    ap = argparse.ArgumentParser()
    ap.add_argument("dataset")
    ap.add_argument("--filler-bank", default="/opt/vox/sandbox/corpus/filler_bank.json")
    ap.add_argument("--sample", type=int, default=0, help="report only the first N CLEAN spans")
    args = ap.parse_args()

    bank = set()
    try:
        with open(args.filler_bank) as f:
            bank = {s.lower().strip().strip(",. ") for s in json.load(f)}
    except Exception:
        pass

    rows = [json.loads(l) for l in open(args.dataset) if l.strip()]
    clean = [r for r in rows if r["category"] == "CLEAN"]
    dis = [r for r in rows if r["category"] == "DISFLUENCY"]
    spans = [(r, s) for r in dis for s in r["spans"]]

    print(f"dataset: {args.dataset}")
    print(f"rows: {len(rows)}  CLEAN: {len(clean)}  DISFLUENCY: {len(dis)}  spans: {len(spans)}")

    # --- 1. Archetype coverage -------------------------------------------------
    arche = Counter(classify(r["raw_text"], s) for r, s in spans)
    print("\n[1] ARCHETYPE COVERAGE (spans)")
    for k, v in arche.most_common():
        print(f"  {k:12s} {v:6d}  {round(100 * v / max(len(spans), 1), 1):5.1f}%")

    # --- 2. Machine-substituted filler vs human speech -------------------------
    if bank:
        n_bank = sum(1 for _, s in spans if s["text"].lower().strip().strip(",. ") in bank)
        bank_by_arche = Counter(
            classify(r["raw_text"], s) for r, s in spans
            if s["text"].lower().strip().strip(",. ") in bank)
        print("\n[2] MACHINE-SUBSTITUTED FILLER (span text == filler_bank entry)")
        print(f"  {n_bank}/{len(spans)} spans ({round(100 * n_bank / max(len(spans), 1), 1)}%)")
        for k, v in bank_by_arche.most_common():
            print(f"    as {k:12s} {v:6d}")

    # --- 3. Span geometry -----------------------------------------------------
    lead = sum(1 for _, s in spans if s["span"][0] == 0)
    internal = sum(1 for _, s in spans if re.search(r"[.?!]\s+[A-Z]", s["text"]))
    multi_sent = sum(1 for r in dis if re.search(r"[.?!]\s+[A-Z]", r["raw_text"]))
    print("\n[3] SHAPE (must match production: ONE closed sentence per example)")
    print(f"  examples spanning >1 sentence : {multi_sent}/{len(dis)}"
          f"  ({round(100 * multi_sent / max(len(dis), 1), 1)}%)")
    print(f"  spans starting at char 0     : {lead}/{len(spans)}"
          f"  ({round(100 * lead / max(len(spans), 1), 1)}%)")
    print(f"  spans containing a sentence break : {internal}/{len(spans)}")

    # --- 4. Trivial-feature baselines -----------------------------------------
    wl_c = sorted(len(r["raw_text"].split()) for r in clean)
    wl_d = sorted(len(r["raw_text"].split()) for r in dis)
    med = lambda v: v[len(v) // 2] if v else 0
    print("\n[4] LENGTH DISTRIBUTION")
    print(f"  CLEAN     words median {med(wl_c):3d}  p90 {wl_c[int(len(wl_c) * .9)] if wl_c else 0:3d}")
    print(f"  DISFLUENCY words median {med(wl_d):3d}  p90 {wl_d[int(len(wl_d) * .9)] if wl_d else 0:3d}")

    def acc(pred):
        return round(100 * sum(1 for r in rows
                               if (r["category"] == "DISFLUENCY") == pred(r["raw_text"]))
                     / max(len(rows), 1), 1)

    best = max(((acc(lambda t, w=w: len(t.split()) >= w), w)
                for w in range(3, 40)), default=(0, 0))
    opener = re.compile(r"^\W*(well|yeah|oh|so|okay|ok|right|alright|now)\b", re.I)
    cue = re.compile(r"\b(you know|i mean|you see|i guess|sort of|kind of)\b", re.I)

    print("\n[5] TRIVIAL BASELINES (no model). A degenerate dataset scores high here.")
    print(f"  always CLEAN                    : {acc(lambda t: False)}%")
    print(f"  best word-count stump (>= {best[1]:2d} words) : {best[0]}%")
    print(f"  sentence-opener OR cue marker   : "
          f"{acc(lambda t: bool(opener.match(t)) or bool(cue.search(t)))}%")
    print(f"  combined                        : "
          f"{acc(lambda t: len(t.split()) >= best[1] or bool(opener.match(t)) or bool(cue.search(t)))}%")

    # --- 6. Hard-negative coverage -------------------------------------------
    if args.sample:
        bank_hits = sum(1 for r in clean[: args.sample]
                        if any(b in r["raw_text"].lower() for b in bank))
        print(f"\n[6] first {args.sample} CLEAN examples containing a filler_bank phrase: {bank_hits}")


if __name__ == "__main__":
    sys.exit(main())

	#!/usr/bin/env python3
	"""Deterministic stratum profiler for a Tier-2 disfluency dataset.

	Answers three questions that a schema/roundtrip QA gate cannot:
	1. Which disfluency archetypes are actually represented, and in what quantity?
	2. How much of the DISFLUENCY half is machine-substituted filler (not human speech)?
	3. Which trivial surface features predict the CLEAN/DISFLUENCY label?
	(A dataset that a one-line rule solves is degenerate and must be rejected.)

	Usage:
	venv/bin/python sandbox/scripts/profile_disfluency.py <dataset.jsonl> [--filler-bank PATH]

	Exit code 0 always; this is a reporter, not a gate. Gate thresholds live in qa_gate.py.
	"""

	import argparse
	import json
	import re
	import sys
	from collections import Counter

	sys.path.insert(0, "/opt/vox/sandbox/scripts")
	from dedup import already_gone_by_tier1

	# --- Archetype cues -----------------------------------------------------------
	# TRUE self-correction: speaker audibly abandons one plan and states another.
	# "I mean" is deliberately NOT here — in this corpus it is overwhelmingly a
	# parenthetical hedge ("..., I mean, it was classic TREK"), i.e. a filler.
	SUPERSESSION_CUE = re.compile(
	r"\b(wait no\|no wait\|scratch that\|sorry\|correction\|i apologize\|my mistake\|"
	r"or instead\|make that\|i said\|actually)\b", re.I)

	# Filler that survives Tier 1 and is genuinely ambiguous (delete vs keep).
	FILLER_PHRASE = re.compile(
	r"^[\s,.]*("
	r"well\|so\|so then\|and so\|like\|anyway\|basically\|right\|okay\|ok\|alright\|now\|oh\|yeah\|"
	r"you know\|you see\|i mean\|i guess\|i think\|kind of\|sort of\|pretty much\|"
	r"of course\|naturally\|honestly\|seriously\|to be honest\|by the way\|whatever\|"
	r"i mean that\|i dont know\|dunno\|you get it\|that said\|in fact\|indeed\|"
	r"at least\|well then\|well i\|anyways\|anyhow"
	r")[\s,.]*$", re.I)

	WORD = re.compile(r"[A-Za-z0-9']+")


	def words(text):
	return [w.lower() for w in WORD.findall(text)]


	def classify(raw, span):
	"""Assign one deterministic archetype to a single span."""
	text = span["text"]
	before = raw[: span["span"][0]]
	sw = words(text)

	# 0. Duplicates of upstream Tier 1 — must never appear in a Tier-2 dataset.
	if already_gone_by_tier1(raw, text):
	return "tier1_duplicate"

	# 1. Partial phrase echo ("The client, the client is waiting") — survives Tier 1
	# because only consecutive identical tokens are collapsed upstream.
	if sw:
	bw = words(before)
	for k in range(min(len(sw), 6), 0, -1):
	if len(bw) >= k and bw[-k:] == sw[:k]:
	return "repetition"

	# 2. True supersession: a correction cue governs material that gets dropped.
	if SUPERSESSION_CUE.search(text):
	return "supersession"

	# 3. Filler / discourse marker: bare hesitation, no propositional content.
	if FILLER_PHRASE.match(text.strip(" ,.")):
	return "filler"

	# 4. Everything else is an abandoned stem / false start.
	return "false_start"


	def main():
	ap = argparse.ArgumentParser()
	ap.add_argument("dataset")
	ap.add_argument("--filler-bank", default="/opt/vox/sandbox/corpus/filler_bank.json")
	ap.add_argument("--sample", type=int, default=0, help="report only the first N CLEAN spans")
	args = ap.parse_args()

	bank = set()
	try:
	with open(args.filler_bank) as f:
	bank = {s.lower().strip().strip(",. ") for s in json.load(f)}
	except Exception:
	pass

	rows = [json.loads(l) for l in open(args.dataset) if l.strip()]
	clean = [r for r in rows if r["category"] == "CLEAN"]
	dis = [r for r in rows if r["category"] == "DISFLUENCY"]
	spans = [(r, s) for r in dis for s in r["spans"]]

	print(f"dataset: {args.dataset}")
	print(f"rows: {len(rows)} CLEAN: {len(clean)} DISFLUENCY: {len(dis)} spans: {len(spans)}")

	# --- 1. Archetype coverage -------------------------------------------------
	arche = Counter(classify(r["raw_text"], s) for r, s in spans)
	print("\n[1] ARCHETYPE COVERAGE (spans)")
	for k, v in arche.most_common():
	print(f" {k:12s} {v:6d} {round(100 * v / max(len(spans), 1), 1):5.1f}%")

	# --- 2. Machine-substituted filler vs human speech -------------------------
	if bank:
	n_bank = sum(1 for _, s in spans if s["text"].lower().strip().strip(",. ") in bank)
	bank_by_arche = Counter(
	classify(r["raw_text"], s) for r, s in spans
	if s["text"].lower().strip().strip(",. ") in bank)
	print("\n[2] MACHINE-SUBSTITUTED FILLER (span text == filler_bank entry)")
	print(f" {n_bank}/{len(spans)} spans ({round(100 * n_bank / max(len(spans), 1), 1)}%)")
	for k, v in bank_by_arche.most_common():
	print(f" as {k:12s} {v:6d}")

	# --- 3. Span geometry -----------------------------------------------------
	lead = sum(1 for _, s in spans if s["span"][0] == 0)
	internal = sum(1 for _, s in spans if re.search(r"[.?!]\s+[A-Z]", s["text"]))
	multi_sent = sum(1 for r in dis if re.search(r"[.?!]\s+[A-Z]", r["raw_text"]))
	print("\n[3] SHAPE (must match production: ONE closed sentence per example)")
	print(f" examples spanning >1 sentence : {multi_sent}/{len(dis)}"
	f" ({round(100 * multi_sent / max(len(dis), 1), 1)}%)")
	print(f" spans starting at char 0 : {lead}/{len(spans)}"
	f" ({round(100 * lead / max(len(spans), 1), 1)}%)")
	print(f" spans containing a sentence break : {internal}/{len(spans)}")

	# --- 4. Trivial-feature baselines -----------------------------------------
	wl_c = sorted(len(r["raw_text"].split()) for r in clean)
	wl_d = sorted(len(r["raw_text"].split()) for r in dis)
	med = lambda v: v[len(v) // 2] if v else 0
	print("\n[4] LENGTH DISTRIBUTION")
	print(f" CLEAN words median {med(wl_c):3d} p90 {wl_c[int(len(wl_c) * .9)] if wl_c else 0:3d}")
	print(f" DISFLUENCY words median {med(wl_d):3d} p90 {wl_d[int(len(wl_d) * .9)] if wl_d else 0:3d}")

	def acc(pred):
	return round(100 * sum(1 for r in rows
	if (r["category"] == "DISFLUENCY") == pred(r["raw_text"]))
	/ max(len(rows), 1), 1)

	best = max(((acc(lambda t, w=w: len(t.split()) >= w), w)
	for w in range(3, 40)), default=(0, 0))
	opener = re.compile(r"^\W*(well\|yeah\|oh\|so\|okay\|ok\|right\|alright\|now)\b", re.I)
	cue = re.compile(r"\b(you know\|i mean\|you see\|i guess\|sort of\|kind of)\b", re.I)

	print("\n[5] TRIVIAL BASELINES (no model). A degenerate dataset scores high here.")
	print(f" always CLEAN : {acc(lambda t: False)}%")
	print(f" best word-count stump (>= {best[1]:2d} words) : {best[0]}%")
	print(f" sentence-opener OR cue marker : "
	f"{acc(lambda t: bool(opener.match(t)) or bool(cue.search(t)))}%")
	print(f" combined : "
	f"{acc(lambda t: len(t.split()) >= best[1] or bool(opener.match(t)) or bool(cue.search(t)))}%")

	# --- 6. Hard-negative coverage -------------------------------------------
	if args.sample:
	bank_hits = sum(1 for r in clean[: args.sample]
	if any(b in r["raw_text"].lower() for b in bank))
	print(f"\n[6] first {args.sample} CLEAN examples containing a filler_bank phrase: {bank_hits}")


	if __name__ == "__main__":
	sys.exit(main())