EasyOctopus's picture
Release the contextual German support ticket experiment
5a9ac83 verified
Raw History Blame Contribute Delete
18.8 kB
"""Create fictional, annotated support dialogues. Uses only the Python standard library."""
from collections import Counter, defaultdict
from datetime import date, timedelta
from hashlib import sha256
import json
from pathlib import Path
import random
import re
import string
import unicodedata
from language import (
ACK, DEV_QUESTIONS, FIRST, INTRO, LABEL_FIELD, LAST, PAIR_REPLY, PLACE, STREETS,
TRAIN_QUESTIONS, WORDS, bank,
)
ROOT = Path(__file__).resolve().parent
SEED = 210849
CORE = ("PERSON", "CUSTOMER_ID", "ORDER_ID")
LABELS = tuple(LABEL_FIELD)
FORMATS = {
"train": {
"explicit": bank("{field}: {v}.|Ich kann es Ihnen gleich geben. {field}: {v}|Bei mir steht hinter {field} der Eintrag {v}.|Mein Formular sagt „{field}: {v}“.|So steht es in der App:\n{field} = {v}|Hier bitte: {v} ({field}).|Für die Maske noch mal: {field} {v}.|Gern, das Feld {field} enthält {v}."),
"mixed": bank("Für den Eintrag: {v}; außerdem ist {w} vermerkt.|{v} und {w}, in der Reihenfolge wie gefragt.|{v}\n{w}|Das sind {v} sowie {w}.|Erster Punkt: {v}. Zum zweiten: {w}.|Ich hab beides gefunden: {v} / {w}."),
"correct": bank("Im ersten Schreiben stand {v}, richtig ist {w}.|Sorry, ich habe eben {v} abgelesen. Im neuen Beleg steht {w}.|Bitte {v} durch {w} ersetzen.|Nachtrag: erst {v}, jetzt {w}.|Nicht {v}. Die aktuelle Angabe lautet {w}."),
"incidental": bank("{pub} steht im Prospekt. Den Rückruf bitte an {v}.|Das Motiv heißt {pub}. Persönlich erreichen Sie mich unter {v}.|Im Sortiment steht {pub}. Für das Feld {field} bitte {v} eintragen.|Zum Artikel: {pub}. Zum Zuordnen noch mein Eintrag bei {field}: {v}."),
"ack": bank("{ack}|Hallo. {ack}|{ack} Danke für die Geduld.|{ack} Ich muss erst nachsehen.|🙋 {ack}|{ack}\nViele Grüße"),
"ordinary": bank("Im Prospekt ist das Muster {pub} abgebildet.|Wir brauchen {n} Packungen, passt das noch in einen Karton?|Der Kurs kostet {n},50 Euro.|Die Dose ist für {n} Liter ausgelegt.|Es ist das Modell {pub}. Das kann man ohne Anmeldung sehen.|In der Liste steht die Teilenummer {pub}, mehr ist es nicht.|Ab {n} Stück fällt das Porto weg.|Der Film heißt „{pub}“."),
"switch": bank("Mit meiner Kundenakte hat das nichts zu tun. Es geht um den Modellcode {pub}.|Den Beleg teile ich hier nicht. Im frei zugänglichen Teileplan steht {pub}.|Lassen wir das Persönliche. Ich suche den Titel „{pub}“.|Ich wollte eigentlich nach dem Katalogeintrag {pub} fragen."),
"negpub": bank("Ihre persönlichen Daten brauchen wir hier nicht. {q}|Bitte keine Kundennummer schicken. {q}|Das Feld zum Vertrag bleibt leer. {q}|Die Abholperson interessiert uns erst später. {q}"),
"negpriv": bank("Das Prospektmotiv haben wir schon. {q}|Die Teilenummer kenne ich. {q}|Bitte keine allgemeine Modellnummer. {q}|Um welche Serie es geht, steht bereits hier. {q}"),
},
"dev": {
"explicit": bank("Aus meiner Unterlage abgeschrieben, {field}: {v}.|Bitte den Wert {v} unter {field} übertragen.|Ein Foto geht nicht, darum als Text: {field}: {v}|Ich habe nachgesehen. Im Abschnitt {field} finde ich {v}."),
"mixed": bank("Zuerst {v}, danach bitte {w} eintragen.|Von oben nach unten gelesen:\n{v}\n{w}|Einmal {v}. Und dazu noch {w}."),
"correct": bank("Die bisherige Angabe {v} ist überholt, bitte {w} vormerken.|Kleine Berichtigung: {w} gilt seit heute, vorher war es {v}.|Streich {v} bitte. Es muss {w} heißen."),
"incidental": bank("Gedruckt ist {pub}. Falls noch eine Rückmeldung nötig ist, hier mein Eintrag für {field}: {v}.|Zum Angebot {pub} noch eine persönliche Angabe, {field}: {v}.|{pub} ist allgemein erhältlich. Mein Eintrag für {field} lautet {v}."),
"ack": bank("{ack}|{ack} Das hilft mir schon.|Kurzes Update: {ack}|{ack} Bis dahin vielen Dank.|{ack} 📎"),
"ordinary": bank("Wir vergleichen gerade die Größe {n} aus der Tabelle.|Die Schau trägt im Jahresprogramm den Titel {pub}.|Die Anleitung zeigt {pub} als allgemeine Baugruppenreferenz.|Der angegebene Preis beträgt {n},90 Euro pro Set.|Das Brett ist {n} Zentimeter breit, richtig?|Der Stoff heißt öffentlich {pub}."),
"switch": bank("Ich bin wegen des allgemein angebotenen Teils {pub} hier. Über meine Daten reden wir später.|Persönliches lassen wir bitte aus. Das Schild in der Auslage sagt {pub}.|Anderes Anliegen: Gibt es die Ausgabe „{pub}“ noch?"),
"negpub": bank("Die Angaben auf Ihrem Ausweis spielen dabei keine Rolle. {q}|Das Aktenzeichen können Sie für sich behalten. {q}|Die individuelle Transaktion bitte auslassen. {q}"),
"negpriv": bank("Über das öffentlich beworbene Angebot sind wir uns einig. {q}|Die Serienbezeichnung hilft bei Ihrer persönlichen Zuordnung nicht. {q}"),
},
}
MULTI = {
"train": [
("PERSON","ORDER_ID","Wer nimmt die Lieferung an, und zu welchem Auftrag gehört sie?"),
("CUSTOMER_ID","ORDER_ID","Bitte erst Ihre Kundennummer, dann die Referenz zur einzelnen Bestellung."),
("EMAIL","PHONE","Wie mailen wir Ihnen und unter welcher Nummer dürfen wir anrufen?"),
("PERSON","ADDRESS","Für wen und an welche Anschrift soll das Paket gehen?"),
("IBAN","BIC","Zum Überweisen brauche ich IBAN und BIC in dieser Reihenfolge."),
("ACCOUNT_ID","TAX_ID","Welche Vertragskennung und welche persönliche Steuer-ID stehen im Formular?"),
("PERSON","DATE_OF_BIRTH","Wen nimmt die Praxis auf und wann wurde die Person geboren?"),
("INSURANCE_ID","EMAIL","Was steht auf Ihrer Versichertenkarte, und wohin senden wir den Bescheid?"),
],
"dev": [
("PERSON","CUSTOMER_ID","Wer gehört zu dem Konto und woran erkennen wir den persönlichen Stammsatz?"),
("EMAIL","ORDER_ID","Wir benötigen den elektronischen Empfänger und den Nachweis für den einzelnen Einkauf."),
("ADDRESS","PHONE","Nennen Sie mir zunächst den Zustellort und danach, wo der Fahrer anrufen soll."),
("DATE_OF_BIRTH","INSURANCE_ID","Bitte das Datum Ihrer Geburt sowie die persönliche Kassenkennung einsetzen."),
("PERSON","IBAN","Auf wen läuft die Erstattung und auf welches IBAN-Konto soll sie fließen?"),
],
}
def normalized(text):
return "".join(c for c in unicodedata.normalize("NFKC",text).casefold() if c.isalnum())
def render(template, fields):
"""Compose and annotate in one pass, including repeated values and emoji."""
parts, gold, length = [], [], 0
for item in re.split(r"(\{\w+\})",template):
if item.startswith("{") and item.endswith("}"):
value, label = fields[item[1:-1]]
else:
value, label = item, None
if label:
gold.append({"start":length,"end":length+len(value),"label":label})
parts.append(value)
length += len(value)
return "".join(parts), gold
class Build:
def __init__(self, split, reserved):
self.split = split
self.r = random.Random(SEED + int(split=="dev"))
self.q = TRAIN_QUESTIONS if split=="train" else DEV_QUESTIONS
self.f = FORMATS[split]
self.reserved = reserved
self.values = set()
self.rows = []
self.seen = set()
self.pairs = 0
def number(self, modulus):
# Partition the permutation of an even integer domain across splits.
raw = 2*self.r.randrange(modulus//2) + int(self.split=="dev")
return (raw*31 + 19) % modulus
def stem(self):
return self.r.choice(LAST[self.split])
def code(self):
digit = f"{10000+self.number(90000)}"
head = "".join(self.r.choices("BCDFGHJKLMNPRSTVWXYZ",k=self.r.choice((1,2,3))))
return self.r.choice((digit, head+"-"+digit, digit[:2]+"."+digit[2:]+"/"+head,
head+digit, digit+"-"+head, head+"/"+digit+"/X", digit[:2]+" "+digit[2:]))
def value(self, label, ambiguous=False):
r = self.r
for _ in range(200):
first = r.choice(FIRST[self.split])
last = self.stem()
if label=="PERSON":
choices = [last,first+" "+last,first+" "+last+"-"+self.stem(),first[0]+". "+last]
if ambiguous:
choices += [r.choice(WORDS[self.split]),r.choice(WORDS[self.split]),last]
val=r.choice(choices)
if r.random()<0.10:
val=val.lower()
elif label in ("CUSTOMER_ID","ORDER_ID","ACCOUNT_ID"):
val=self.code()
elif label=="ADDRESS":
val=f"{r.choice(STREETS[self.split])} {1+self.number(240)}{r.choice(('', '', 'a', 'b'))}, {10000+self.number(89000)} {r.choice(PLACE[self.split])}"
elif label=="PHONE":
loc, block=r.choice((("030","23125"),("069","90009"),("040","66969"),("0221","4710"),("089","99998")))
tail=f"{self.number(1000):03}"
val=r.choice((f"{loc} {block} {tail}",f"+49 {loc[1:]} {block}{tail}",f"{loc}/{block}-{tail}",f"({loc}) {block}{tail}"))
elif label=="EMAIL":
n=self.number(10000)
val=r.choice((f"post.{last.casefold()}{n}@fach.invalid",f"{first.casefold()}-{n}@brief.invalid",f"kontakt+{n}@schalter.invalid"))
elif label=="DATE_OF_BIRTH":
d=date(1941,1,1)+timedelta(days=self.number(24000))
val=r.choice((d.strftime("%d.%m.%Y"),d.isoformat(),f"{d.day}.{d.month}.{d.year}"))
elif label=="IBAN":
raw="DE00"+"00000000"+f"{self.number(10**10):010}"
val=r.choice((raw," ".join(raw[i:i+4] for i in range(0,len(raw),4))))
elif label=="BIC":
val="XQ"+r.choice("BDFGHKLMPRST")+r.choice("ABGHM")+"DE00"+f"{self.number(1000):03}"
elif label=="INSURANCE_ID":
val=r.choice("BDFGHMNRT")+f"{self.number(10**9):09}"
elif label=="TAX_ID":
# An initial zero makes this eleven-digit value deliberately invalid.
val="0"+f"{self.number(10**10):010}"
elif label=="PAYMENT_CARD":
# With an all-zero issuer prefix this is a fixture, not a payment credential.
raw="000000"+f"{self.number(10**10):010}"
val=r.choice((raw," ".join(raw[i:i+4] for i in range(0,16,4))))
elif label=="IP":
val=r.choice(("192.0.2.","198.51.100.","203.0.113."))+str(self.number(252)+1)
elif label=="ORGANIZATION":
val=r.choice(WORDS[self.split])+r.choice(("bogen","steg","ton","glas","faden"))+" "+r.choice(("Werkstatt eG","Labor GmbH","Services KG","Atelier OHG"))
else:
raise ValueError(label)
if normalized(val) not in self.reserved:
self.values.add(normalized(val))
return val
raise RuntimeError((self.split,label))
def ask(self, category):
q=self.r.choice(self.q[category])
if self.r.random()<0.28:
q=self.r.choice(INTRO[self.split])+" "+q
return q
def add(self, group, context, template, fields, pair=None):
text, gold=render(template,fields)
key=(context,text)
if key in self.seen:
return False
self.seen.add(key)
self.rows.append({"id":f"{self.split}-{len(self.rows):05d}","context":context,"text":text,
"gold":gold,"group":group,"pair":pair})
return True
def pair(self):
category=self.r.choices(CORE, weights=[48,26,26])[0]
public="PUBLIC_NAME" if category=="PERSON" else "PUBLIC_CODE"
form=self.r.choice(PAIR_REPLY[self.split])
val=self.value(category,True)
private_q,public_q=self.ask(category),self.ask(public)
text,_=render(form,{"v":(val,category)})
if (private_q,text) in self.seen or (public_q,text) in self.seen:
return
pair=f"{self.split}-contrast-{self.pairs:04d}"
self.pairs+=1
self.add("paired-private",private_q,form,{"v":(val,category)},pair)
self.add("paired-public",public_q,form,{"v":(val,None)},pair)
def example(self, group):
r=self.r
category=r.choice(LABELS)
field=(LABEL_FIELD[category],None)
context=self.ask(category)
public_type=r.choice(("PUBLIC_NAME","PUBLIC_CODE"))
pub_val=self.value("PERSON",True) if public_type=="PUBLIC_NAME" else self.code()
if normalized(pub_val) in self.reserved:
return
self.values.add(normalized(pub_val))
pub=(pub_val,None)
if group=="explicit":
val=(self.value(category),category)
form=r.choice(self.f["explicit"] if r.random()<0.55 else PAIR_REPLY[self.split])
self.add(group,context,form,{"field":field,"v":val})
elif group=="multiple":
if r.random()<.30:
private_label=r.choice(CORE)
fields=[(self.ask(private_label),(self.value(private_label, True),private_label)),
(self.ask(public_type),pub)]
r.shuffle(fields)
q=" ".join(prompt for prompt,_ in fields)
self.add(group,q,r.choice(self.f["mixed"]),{"v":fields[0][1],"w":fields[1][1]})
else:
a,b,q=r.choice(MULTI[self.split])
self.add(group,q,r.choice(self.f["mixed"]),{"v":(self.value(a),a),"w":(self.value(b),b)})
elif group=="correction":
if r.random()<.25:
a,b=pub_val,self.value("PERSON",True) if public_type=="PUBLIC_NAME" else self.code()
if normalized(b) in self.reserved:
return
self.values.add(normalized(b))
context=self.ask(public_type)
category=None
else:
a,b=self.value(category),self.value(category)
if a!=b:
self.add(group,context,r.choice(self.f["correct"]),{"v":(a,category),"w":(b,category)})
elif group=="acknowledgment":
self.add(group,context,r.choice(self.f["ack"]),{"ack":(r.choice(ACK[self.split]),None)})
elif group=="public-with-private":
form=r.choice(self.f["incidental"])
if "Rückruf" in form: category="PHONE"
if "erreichen Sie" in form: category=r.choice(("EMAIL","PHONE"))
self.add(group,self.ask(public_type),form,{"pub":pub,"v":(self.value(category),category),"field":(LABEL_FIELD[category],None)})
elif group=="topic-change":
self.add(group,context,r.choice(self.f["switch"]),{"pub":pub})
elif group=="negated":
private=r.random()<0.5
label=r.choice(CORE) if private else None
q=r.choice(self.f["negpriv" if private else "negpub"]).format(q=self.ask(label or public_type))
val=self.value(label,True) if label else pub_val
self.add(group,q,r.choice(PAIR_REPLY[self.split]),{"v":(val,label)})
elif group=="ordinary":
self.add(group,self.ask(public_type),r.choice(self.f["ordinary"]),{"pub":pub,"n":(str(2+self.number(900)),None)})
elif group=="reply-only":
if r.random()<0.65:
self.add(group,"",r.choice(self.f["explicit"]),{"field":field,"v":(self.value(category),category)})
else:
self.add(group,"",r.choice(self.f["ordinary"]),{"pub":pub,"n":(str(2+self.number(900)),None)})
else:
raise ValueError(group)
def run(self, n):
while len(self.rows)<n//2:
self.pair()
proportions={"explicit":.26,"multiple":.12,"correction":.09,"acknowledgment":.10,
"public-with-private":.10,"topic-change":.06,"negated":.08,"ordinary":.06,"reply-only":.13}
remaining=n-len(self.rows)
counts={group:int(remaining*prop) for group,prop in proportions.items()}
counts["reply-only"]+=remaining-sum(counts.values())
for group,count in counts.items():
target=len(self.rows)+count
while len(self.rows)<target:
self.example(group)
self.r.shuffle(self.rows)
return self.rows
def write_file(name, payload):
temp=ROOT/(name+".tmp")
temp.write_text(payload,encoding="utf-8")
temp.replace(ROOT/name)
def audit(rows):
groups, labels, paired=Counter(), Counter(), defaultdict(list)
assert len({row["id"] for row in rows})==len(rows)
assert len({(row["context"],row["text"]) for row in rows})==len(rows)
for row in rows:
groups[row["group"]]+=1
prev=0
for e in row["gold"]:
a,b,label=e["start"],e["end"],e["label"]
assert prev<=a<b<=len(row["text"])
assert row["text"][a:b].strip()==row["text"][a:b] and label in LABELS
labels[label]+=1
prev=b
if row["pair"]:
paired[row["pair"]].append(row)
for p in paired.values():
assert len(p)==2 and p[0]["text"]==p[1]["text"] and p[0]["context"]!=p[1]["context"]
assert sorted(len(r["gold"]) for r in p)==[0,1]
assert set(labels)==set(LABELS)
return {"rows":len(rows),"groups":dict(sorted(groups.items())),"labels":dict(sorted(labels.items())),
"paired_replies":len(paired),"clean_rows":sum(not r["gold"] for r in rows),
"unique_question_texts":len({r["context"] for r in rows if r["context"]}),
"reply_only":sum(not r["context"] for r in rows)}
def main():
training=Build("train",set())
train=training.run(4200)
devset=Build("dev",training.values)
dev=devset.run(420)
assert not training.values & devset.values
frames=lambda rows:{row["context"] for row in rows if row["context"]}
assert not frames(train) & frames(dev)
assert not {r["text"] for r in train} & {r["text"] for r in dev}
manifest={"seed":SEED,"offset_unit":"unicode_code_point","end_exclusive":True,"splits":{}}
for name,rows in (("train",train),("dev",dev)):
results=audit(rows)
payload="".join(json.dumps(r,ensure_ascii=False,separators=(",",":"))+"\n" for r in rows)
write_file(name+".jsonl",payload)
results["sha256"]=sha256(payload.encode()).hexdigest()
manifest["splits"][name]=results
manifest["split_checks"]={"overlap_nonempty_questions":0,"overlap_reply_strings":0,
"overlap_normalized_value_bank":0,"mixed_train_dev_pairs":0}
manifest["sources"]={p:sha256((ROOT/p).read_bytes()).hexdigest() for p in ("generate.py","language.py")}
write_file("manifest.json",json.dumps(manifest,ensure_ascii=False,indent=2)+"\n")
print(json.dumps(manifest["splits"],ensure_ascii=False))
if __name__=="__main__":
main()