Download generation/generate.py from EasyOctopus/german-ticket-privacy-data: direct link, hf CLI and curl.
- Browser
- Download file 18.8 kB
-
https://huggingface.co/datasets/EasyOctopus/german-ticket-privacy-data/resolve/main/generation/generate.py
- Command line
-
hf download hf://datasets/EasyOctopus/german-ticket-privacy-data/generation/generate.py
-
curl -L -o generate.py https://huggingface.co/datasets/EasyOctopus/german-ticket-privacy-data/resolve/main/generation/generate.py
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() | |