arc-tagger / arctag /driver.py
ksingla025's picture
Arc Tagger v0.4.0
83a951c
Raw History Blame Contribute Delete
10.1 kB
"""Session driver: words in -> engine.ArcSession (arctag/_core/engine.py) -> structured JSON.
This module has no package imports: it takes the engine module (`EN`) and a loaded model (`EN.Loaded`) as arguments.
Message flow:
words -> {"type": "words", "from": k, "words": [...]} (append, or revise words[k:] for interim ASR hypotheses)
final -> {"type": "finalize", "upto": n}
end of utterance -> {"type": "endpoint", "at": n}
spans -> ArcSession.spans(tier) after every update; spans with end > a0 are replaced, older ones are kept
fine domain (sports league / court type) from lexicon cues every 25 words (engine.fine_hint)
"""
import re
UI_DOMAINS = ("auto", "talk", "meeting", "court", "assistant", "sports", "news")
END_RE = re.compile(r"[.?!]+[\"')\]]*$")
# redaction placeholders (public_contact is tag-only, so it is not masked)
REDACT = {
"safety.pii.phone_number": "PHONE", "safety.pii.email": "EMAIL", "safety.pii.street_address": "ADDRESS",
"safety.pii.card_account_number": "CARD", "safety.pii.gov_id": "GOV_ID", "safety.pii.date_of_birth": "DOB",
"safety.pii.private_name": "NAME", "safety.pii.url_handle": "HANDLE",
"safety.profanity.mild": "PROFANITY", "safety.profanity.strong": "PROFANITY",
"safety.toxicity.insult_harassment": "TOXIC", "safety.toxicity.hate_identity": "TOXIC",
"safety.toxicity.threat_violence": "TOXIC", "safety.toxicity.sexual_explicit": "TOXIC", "safety.toxicity.self_harm": "TOXIC",
}
def thr_label(th):
"""which threshold tables are active: display / events tables, model defaults"""
parts = []
if th.pref_step is not None:
parts.append("display")
if th.ev_step is not None:
parts.append("events")
if th.own:
parts.append("default")
return " + ".join(parts) or "default 0.5"
def as_words(x, final=True):
"""str | [str] | [dict] -> word dicts {"w", "final", optional "t0", "t1", "conf", "spk"}"""
if isinstance(x, str):
x = x.split()
out = []
for w in x:
if isinstance(w, str):
if w.strip():
out.append({"w": w.strip(), "final": final})
else:
d = {k: w[k] for k in ("w", "t0", "t1", "conf", "spk", "final") if k in w and w[k] is not None}
d.setdefault("final", final)
if str(d.get("w", "")).strip():
d["w"] = str(d["w"]).strip()
out.append(d)
return out
def split_utterances(words):
"""utterance boundaries after words ending in . ? ! (and at the end)"""
utts, cur = [], []
for w in words:
cur.append(w)
if END_RE.search(w["w"]):
utts.append(cur); cur = []
if cur:
utts.append(cur)
return utts
class Stream:
"""one streaming session. push_words() / endpoint() return incremental updates; finalize() returns the full result."""
def __init__(self, EN, loaded, domain="auto", tier="T0", meta=None):
if domain not in UI_DOMAINS:
raise ValueError(f"domain must be one of {UI_DOMAINS}")
if tier not in ("T0", "T1", "T2"):
raise ValueError("tier must be T0, T1 or T2")
self.EN = EN; self.tier = tier; self.meta = dict(meta or {})
self.s = EN.ArcSession(loaded, ui_domain=domain, asr="unknown")
self._spans = {} # (tag, a, b) -> span (display tier)
self._n_ev = 0; self._fine_n = -1
self.events = []; self.utterances = {} # w0 -> utterance dict (built at its endpoint)
# ------------------------------------------------------------------ input
def push_words(self, words, final=True, revise_from=None, endpoint=False):
"""append words (or, with revise_from=k, replace words[k:] by them: interim ASR revisions). Returns the update."""
ws = as_words(words, final=final)
k = len(self.s.words) if revise_from is None else int(revise_from)
evs = [{"type": "words", "from": k, "words": ws}]
if final:
evs.append({"type": "finalize", "upto": k + len(ws)})
if endpoint:
evs.append({"type": "endpoint", "at": k + len(ws)})
return self._apply(evs)
def endpoint(self):
"""end of the current utterance (ASR speech_final / end-of-turn / VAD): utterance-level read-outs are emitted here"""
n = len(self.s.words)
return self._apply([{"type": "finalize", "upto": n}, {"type": "endpoint", "at": n}])
def finalize(self):
"""close the open utterance (if any) and return the full structured result"""
if self.s.e.n and (not self.s.utt_bounds or self.s.utt_bounds[-1] < self.s.e.n):
self.endpoint()
return self.result()
# ------------------------------------------------------------------ engine
def _apply(self, evs):
s = self.s; EN = self.EN
lo, utt_done = s.apply(evs)
if EN.FINE_REDOMAIN and s.ui_domain in EN.FINE_IX and len(s.words) // 25 != self._fine_n:
self._fine_n = len(s.words) // 25
fh = EN.fine_hint(s.ui_domain, s.words)
if fh and fh != s.fine:
s.set_domain(s.ui_domain, fine=fh)
a0, sp = s.spans(self.tier)
for key in [key for key, x in self._spans.items() if x["b"] > a0]:
del self._spans[key]
for x in sp:
self._spans[(x["tag"], x["a"], x["b"])] = x
ev_new = [self._event(e) for e in s.events[self._n_ev:]]
self._n_ev = len(s.events)
ev_new = [e for e in ev_new if e]
self.events.extend(ev_new)
utts = [self._utt(u) for u in utt_done]
for u in utts:
self.utterances[u["start"]] = u
return {"n_words": len(s.words), "changed_from": lo, "spans": [self._span(x) for x in sp], "events": ev_new,
"utterances": utts, "running": self._running()}
def _event(self, e):
th = self.s.L.thr
if th.ev_hidden(e["tag"]) or e["tier"] != th.ev_tier(e["tag"]):
return None
return {"tag": e["tag"], "at": e["i"], "word": e["word"], "p": e["p"], "thr": e["thr"], "tier": e["tier"], "read": e["q"]}
def _span(self, x):
out = {"tag": x["tag"], "family": x["fam"], "start": x["a"], "end": x["b"], "text": x["text"], "p": x["p"], "thr": x["thr"]}
for k in ("alt", "ver", "kb", "src"):
if k in x:
out[k] = x[k]
return out
@staticmethod
def _on(rows):
return [r["tag"] for r in rows if r["on"]]
AFFECT_GROUPS = ("affect.emotion.", "affect.arousal.", "affect.valence.", "affect.intensity.")
def _emotion(self, j):
"""affect.* utt read-outs (text-only, experimental): the top tag of each affect group in the ontology
(emotion, arousal, valence, intensity)"""
s = self.s
if j is None or j not in s.e.pooled:
return []
import torch
with torch.inference_mode():
U = s.L.GI.probs("utt", s.e.pooled_logits(j)["utt"][None])[0].numpy()
return [r for g in self.AFFECT_GROUPS for r in s._top("utt", U, g, 1)]
def _utt(self, u):
ro = u["readouts"]
r = {"start": u["w0"], "end": u["w1"], "text": u["text"],
"intent": self._on(ro.get("intent", [])), "act": self._on(ro.get("act", [])), "safety": self._on(ro.get("safety", [])),
"role": self._on(ro.get("role", [])), "item": self._on(ro.get("item", [])),
"state": {g: self._on(v) for g, v in (ro.get("state") or {}).items() if self._on(v)},
"emotion": self._emotion(ro.get("j")),
"scores": {k: ro.get(k) for k in ("intent", "act", "safety", "role", "item", "state")}}
if ro.get("role_note"):
r["role_note"] = ro["role_note"]
return r
def _running(self):
ro = self.s.readouts(tier=self.tier if self.tier != "T2" else "T1")
if not ro:
return {}
return {"intent": self._on(ro.get("intent", [])), "act": self._on(ro.get("act", [])), "safety": self._on(ro.get("safety", [])),
"state": {g: self._on(v) for g, v in (ro.get("state") or {}).items() if self._on(v)}}
# ------------------------------------------------------------------ output
def spans(self):
return [self._span(x) for x in sorted(self._spans.values(), key=lambda x: (x["a"], -x["b"], x["tag"]))]
def redacted_text(self, spans=None):
ws = [w["w"] for w in self.s.words]
lab = [None] * len(ws)
for x in spans if spans is not None else self.spans():
L = REDACT.get(x["tag"])
if L:
for i in range(x["start"], min(x["end"], len(ws))):
lab[i] = lab[i] or (L, x["start"])
out = []; i = 0
while i < len(ws):
if lab[i] is None:
out.append(ws[i]); i += 1; continue
j = i
while j < len(ws) and lab[j] == lab[i]:
j += 1
out.append(f"[{lab[i][0]}]"); i = j
return " ".join(out)
def result(self):
sp = self.spans()
utts = [self.utterances[k] for k in sorted(self.utterances)]
return {"meta": dict(self.meta, domain=self.s.ui_domain, fine_domain=self.s.fine, tier=self.tier,
thresholds=thr_label(self.s.L.thr)),
"words": [w["w"] for w in self.s.words],
"spans": sp,
"entities": [x for x in sp if x["family"] in ("entity", "number")],
"pii": [x for x in sp if x["family"] == "pii"],
"profanity_toxicity": [x for x in sp if x["family"] == "profanity"],
"redacted_text": self.redacted_text(sp),
"utterances": utts,
"events": list(self.events)}
def tag(EN, loaded, x, domain="auto", tier="T0", meta=None):
"""offline tagging: text / words -> utterances (split after . ? !) -> one streaming pass -> result"""
st = Stream(EN, loaded, domain=domain, tier=tier, meta=meta)
for u in split_utterances(as_words(x)):
st.push_words(u, final=True, endpoint=True)
return st.finalize()