| """Build the official PerSHOP release from the original spreadsheets. |
| |
| Usage: |
| python scripts/make_splits.py --dialogues PerSHOP.xlsx --products Products_DataBASE.xlsx --out . |
| |
| Outputs (relative to --out): |
| data/dialogues/{train,validation,test}.jsonl one row per utterance |
| data/products/products.jsonl product database (750 items) |
| data/products/slots.jsonl slot names and descriptions |
| splits/{train,validation,test}_dialogue_ids.txt |
| splits/split_stats.json |
| |
| Splitting protocol |
| ------------------ |
| * The unit of splitting is the dialogue: all utterances of a dialogue go to the |
| same split, so no dialogue context leaks between train and evaluation data. |
| * Ratio 80/10/10, stratified by each dialogue's primary domain (its most |
| frequent non-"Chats" domain), so every product domain appears in all splits |
| wherever it has enough dialogues. |
| * Fixed seed (42). Re-running this script on the same input reproduces the |
| same split exactly. |
| |
| Corrections |
| ----------- |
| The documented corrections in scripts/corrections.json are applied to the |
| original annotations: 13 markup-syntax fixes, removal of 2 empty utterances, |
| and renaming the slot "super-product" to "super_product". Each fix is checked |
| against the original text, so the script fails if the input has changed. |
| `raw_text` is kept verbatim. `text` and `entities` are derived from the |
| corrected `annotated_text` by parsing the inline markup "[span](slot)". |
| """ |
|
|
| import argparse |
| import json |
| import random |
| import re |
| from collections import Counter |
| from pathlib import Path |
|
|
| import pandas as pd |
|
|
| SEED = 42 |
| RATIOS = {"train": 0.8, "validation": 0.1, "test": 0.1} |
|
|
| DOMAIN_EN = { |
| "Chats": "chit-chat", |
| "لبنیات": "dairy", |
| "نوشیدنی": "beverages", |
| "خوار و بار": "groceries", |
| "خانه و سبک زندگی": "home and lifestyle", |
| "پروتئین": "protein", |
| "کودک": "baby and child", |
| "کنسروجات": "canned food", |
| "آرایشی و بهداشتی": "cosmetics and personal care", |
| "خشکبار، دسر و شیرینی": "nuts, desserts and sweets", |
| "میوه و سبزیجات": "fruits and vegetables", |
| "مد و پوشاک": "fashion and clothing", |
| "دستمال و شوینده": "tissues and detergents", |
| "دیجیتال": "digital", |
| "خودرو، موتور، دوچرخه": "car, motorcycle and bicycle", |
| } |
|
|
| MARKUP = re.compile(r"\[([^\[\]]+?)\]\(([^()]+?)\)") |
|
|
|
|
| def clean(value): |
| """Convert pandas missing values to None and strip strings.""" |
| if pd.isna(value): |
| return None |
| return str(value).strip() if isinstance(value, str) else value |
|
|
|
|
| def parse_markup(annotated): |
| """Return plain text and entity spans (character offsets on the plain text).""" |
| if annotated is None: |
| return None, [] |
| text_parts, entities, cursor, out_len = [], [], 0, 0 |
| for match in MARKUP.finditer(annotated): |
| before = annotated[cursor:match.start()] |
| text_parts.append(before) |
| out_len += len(before) |
| span, slot = match.group(1), match.group(2).strip() |
| entities.append({"value": span, "slot": slot, "start": out_len, "end": out_len + len(span)}) |
| text_parts.append(span) |
| out_len += len(span) |
| cursor = match.end() |
| text_parts.append(annotated[cursor:]) |
| return "".join(text_parts), entities |
|
|
|
|
| def apply_corrections(df, corrections_path): |
| """Apply the documented corrections, checking each against the original text.""" |
| corrections = json.loads(corrections_path.read_text(encoding="utf-8")) |
| df = df.copy() |
| for fix in corrections["markup_fixes"]: |
| mask = df.id == fix["utterance_id"] |
| original = df.loc[mask, "user_text"].iloc[0] |
| if original.count(fix["before"]) != 1: |
| raise ValueError(f"Correction does not match utterance {fix['utterance_id']}") |
| df.loc[mask, "user_text"] = original.replace(fix["before"], fix["after"]) |
| removed = [r["utterance_id"] for r in corrections["removed_utterances"]] |
| if not df.loc[df.id.isin(removed), "user_text"].isna().all(): |
| raise ValueError("An utterance listed for removal is not empty") |
| df = df[~df.id.isin(removed)] |
| for old, new in corrections["renamed_slots"].items(): |
| df["user_text"] = df.user_text.str.replace(f"]({old})", f"]({new})", regex=False) |
| return df |
|
|
|
|
| def split_dialogues(primary_domain): |
| """Stratified dialogue-level split with a fixed seed.""" |
| rng = random.Random(SEED) |
| assignment = {} |
| for domain in sorted(primary_domain.unique()): |
| ids = sorted(primary_domain[primary_domain == domain].index.tolist()) |
| rng.shuffle(ids) |
| n = len(ids) |
| n_val = round(n * RATIOS["validation"]) |
| n_test = round(n * RATIOS["test"]) |
| for i, dialogue_id in enumerate(ids): |
| if i < n_test: |
| assignment[dialogue_id] = "test" |
| elif i < n_test + n_val: |
| assignment[dialogue_id] = "validation" |
| else: |
| assignment[dialogue_id] = "train" |
| return assignment |
|
|
|
|
| def build_rows(df): |
| rows = [] |
| df = df.sort_values(["dialogue_number", "id"]) |
| for dialogue_id, group in df.groupby("dialogue_number", sort=True): |
| for turn_index, record in enumerate(group.itertuples(index=False)): |
| annotated = clean(record.user_text) |
| text, entities = parse_markup(annotated) |
| domain = clean(record.domain) |
| rows.append({ |
| "utterance_id": int(record.id), |
| "dialogue_id": int(dialogue_id), |
| "turn_index": turn_index, |
| "speaker": clean(record.Speecher).lower(), |
| "domain": domain, |
| "domain_en": DOMAIN_EN.get(domain, domain), |
| "intent": clean(record.intent), |
| "super_product": clean(record.SuperProduct), |
| "text": text, |
| "annotated_text": annotated, |
| "raw_text": clean(record.RawText), |
| "entities": entities, |
| }) |
| return rows |
|
|
|
|
| def write_jsonl(path, records): |
| path.parent.mkdir(parents=True, exist_ok=True) |
| with path.open("w", encoding="utf-8") as f: |
| for record in records: |
| f.write(json.dumps(record, ensure_ascii=False) + "\n") |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser() |
| parser.add_argument("--dialogues", required=True) |
| parser.add_argument("--products", required=True) |
| parser.add_argument("--out", default=".") |
| args = parser.parse_args() |
| out = Path(args.out) |
|
|
| df = pd.read_excel(args.dialogues, sheet_name="Chats").rename(columns={"Intents & Actions": "intent"}) |
| df = apply_corrections(df, Path(__file__).with_name("corrections.json")) |
|
|
| product_turns = df[df.domain != "Chats"] |
| primary = product_turns.groupby("dialogue_number").domain.agg(lambda s: s.value_counts().index[0]) |
| primary = primary.reindex(sorted(df.dialogue_number.unique())).fillna("Chats") |
| assignment = split_dialogues(primary) |
|
|
| rows = build_rows(df) |
| stats = {"seed": SEED, "ratios": RATIOS, "splits": {}} |
| for split in RATIOS: |
| split_rows = [r for r in rows if assignment[r["dialogue_id"]] == split] |
| write_jsonl(out / "data" / "dialogues" / f"{split}.jsonl", split_rows) |
| dialogue_ids = sorted({r["dialogue_id"] for r in split_rows}) |
| ids_path = out / "splits" / f"{split}_dialogue_ids.txt" |
| ids_path.parent.mkdir(parents=True, exist_ok=True) |
| ids_path.write_text("\n".join(map(str, dialogue_ids)) + "\n", encoding="utf-8") |
| stats["splits"][split] = { |
| "dialogues": len(dialogue_ids), |
| "utterances": len(split_rows), |
| "primary_domain_dialogues": dict(Counter(DOMAIN_EN[primary[i]] for i in dialogue_ids).most_common()), |
| } |
|
|
| products = pd.read_excel(args.products, sheet_name="woz_product") |
| product_records = [ |
| {col.replace("-", "_"): clean(val) for col, val in rec.items() if clean(val) is not None} |
| for rec in products.to_dict(orient="records") |
| ] |
| for rec in product_records: |
| rec["domain_en"] = DOMAIN_EN.get(rec.get("domain"), rec.get("domain")) |
| write_jsonl(out / "data" / "products" / "products.jsonl", product_records) |
|
|
| slots = pd.read_excel(args.products, sheet_name="Slots") |
| write_jsonl(out / "data" / "products" / "slots.jsonl", |
| [{"slot": clean(s), "description": clean(d)} for s, d in zip(slots.iloc[:, 0], slots.iloc[:, 1])]) |
|
|
| stats["products"] = len(product_records) |
| (out / "splits" / "split_stats.json").write_text(json.dumps(stats, ensure_ascii=False, indent=2), encoding="utf-8") |
| print(json.dumps(stats, ensure_ascii=False, indent=2)) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
