| """Build a clean Hugging Face dataset from the raw NCKL Khmer Dictionary 2022 CSV. |
| |
| Usage: python scripts/build_hf_dataset.py [raw_csv] [out_dir] |
| """ |
| import re |
| import sys |
| from pathlib import Path |
|
|
| import pandas as pd |
|
|
| ROOT = Path(__file__).resolve().parent.parent |
| RAW = Path(sys.argv[1]) if len(sys.argv) > 1 else ROOT / "datasets/nckl_khmer_dictionary_2022/khmer_dictionary_2022.csv" |
| OUT = Path(sys.argv[2]) if len(sys.argv) > 2 else ROOT / "hf/khmer-dictionary" |
|
|
| KHMER_DIGITS = str.maketrans("០១២៣៤៥៦៧៨៩", "0123456789") |
| SUPERSCRIPT = str.maketrans("0123456789", "⁰¹²³⁴⁵⁶⁷⁸⁹") |
|
|
| POS_EN = { |
| "ន.": "noun", |
| "កិ.": "verb", |
| "គុ.": "adjective", |
| "គុ.កិ.": "adverb", |
| "សព្វ.": "pronoun", |
| "ប.": "preposition", |
| "ឈ.": "conjunction", |
| "ឧ.": "interjection", |
| "ធ.": "particle", |
| } |
|
|
|
|
| def homograph_markup(s: str) -> str: |
| """`កេងកង{¥¥}១{££}` -> `កេងកង¹` (superscript homograph number).""" |
| return re.sub( |
| r"\{¥¥\}(.*?)\{££\}", |
| lambda m: m.group(1).translate(KHMER_DIGITS).translate(SUPERSCRIPT), |
| s, |
| ) |
|
|
|
|
| def split_pronunciation(s: str) -> tuple[str, str]: |
| """`[ស្ដន់] (ជើង ត អានជា ដ)` -> (`ស្ដន់`, `ជើង ត អានជា ដ`); |
| `[កន់-តា] ឬ [កន់-តា-រៈ]` -> (`កន់-តា ឬ កន់-តា-រៈ`, ``).""" |
| note = "" |
| |
| s = s.replace("´", "").replace(":", "ៈ").replace("[[", "[") |
| if m := re.fullmatch(r"(.*\])\s*\(([^()]*)\)", s): |
| s, note = m.group(1), m.group(2).strip() |
| alts = re.findall(r"\[([^\]]*)\]", s) |
| if alts and re.fullmatch(r"[\sឬ,]*", re.sub(r"\[[^\]]*\]", "", s)): |
| return " ឬ ".join(a.strip() for a in alts), note |
| return s, note |
|
|
|
|
| def build_g2p(entries: pd.DataFrame) -> pd.DataFrame: |
| """Word -> pronunciation pairs for G2P training, split 90/5/5 by word. |
| |
| Skips entries with no pronunciation (proverbs/idioms), bound forms such as |
| `កម្ពុជ—`, and phrases containing spaces or other non-Khmer characters. |
| Alternative readings (`a ឬ b`) become separate rows. |
| """ |
| g = entries[["word", "pronunciation", "entry_id"]].copy() |
| g["word"] = g["word"].str.rstrip("!?") |
| g["pronunciation"] = g["pronunciation"].str.split(" ឬ ") |
| g = g.explode("pronunciation") |
| khmer_only = r"[ក-]+" |
| g = g[ |
| g["word"].str.fullmatch(khmer_only) |
| & g["pronunciation"].str.fullmatch(r"[ក-\-]+") |
| & ~g["pronunciation"].str.contains(r"^-|-$|--") |
| ] |
| g = (g.groupby(["word", "pronunciation"], sort=False, as_index=False) |
| .agg(entry_ids=("entry_id", list))) |
| g["syllables"] = g["pronunciation"].str.count("-") + 1 |
|
|
| |
| words = pd.Series(g["word"].unique()).sample(frac=1, random_state=42) |
| n = len(words) |
| split = {w: "train" for w in words.iloc[: int(n * 0.9)]} |
| split |= {w: "validation" for w in words.iloc[int(n * 0.9): int(n * 0.95)]} |
| split |= {w: "test" for w in words.iloc[int(n * 0.95):]} |
| g["split"] = g["word"].map(split) |
| return g |
|
|
|
|
| def pos_list(s: str) -> list[str]: |
| return [p for p in re.split(r"[,\s]+", s) if p] |
|
|
|
|
| def main() -> None: |
| d = pd.read_csv(RAW, dtype=str, keep_default_na=False, encoding="utf-8-sig") |
| for c in ("definition", "examples", "notes", "etymology", "pronunciation"): |
| d[c] = d[c].map(homograph_markup) |
|
|
| |
| d.loc[d["level"] == "1", "sense"] = "" |
|
|
| |
| |
| first = d[d["word"] != ""].set_index("id") |
| for c in ("word", "homograph", "sense", "pronunciation", "etymology", "level"): |
| d[c] = d["ref"].map(first[c]) |
| d["pos"] = d["pos"].mask(d["pos"] == "", d["ref"].map(first["pos"])) |
|
|
| pron = d["pronunciation"].map(split_pronunciation) |
| is_sub = d["level"] == "2" |
| senses = pd.DataFrame( |
| { |
| "entry_id": d["ref"].astype(int), |
| "sense_id": d["id"].astype(int), |
| "word": d["sense"].where(is_sub, d["word"]), |
| "headword": d["word"], |
| "homograph": pd.to_numeric(d["homograph"]).astype("Int64"), |
| "is_subentry": is_sub, |
| "pronunciation": pron.str[0], |
| "pronunciation_note": pron.str[1], |
| "etymology": d["etymology"], |
| "sense_no": d.groupby("ref").cumcount() + 1, |
| "sense_label": d["poly"], |
| "part_of_speech": d["pos"], |
| "part_of_speech_en": d["pos"].map( |
| lambda s: ", ".join(POS_EN.get(p, p) for p in pos_list(s)) |
| ), |
| "definition": d["definition"].str.replace(r"\s*:$", "", regex=True), |
| "examples": d["examples"], |
| "notes": d["notes"], |
| } |
| ) |
|
|
| sense_cols = ["sense_no", "sense_label", "part_of_speech", "part_of_speech_en", |
| "definition", "examples", "notes"] |
| entry_cols = ["entry_id", "word", "headword", "homograph", "is_subentry", |
| "pronunciation", "pronunciation_note", "etymology"] |
| entries = ( |
| senses.groupby("entry_id", sort=False) |
| .apply(lambda g: pd.Series({ |
| **g.iloc[0][entry_cols[1:]].to_dict(), |
| "senses": g[sense_cols].to_dict("records"), |
| }), include_groups=False) |
| .reset_index() |
| ) |
| entries["homograph"] = entries["homograph"].astype("Int64") |
| entries["is_subentry"] = entries["is_subentry"].astype(bool) |
|
|
| (OUT / "data").mkdir(parents=True, exist_ok=True) |
| entries.to_parquet(OUT / "data/entries.parquet", index=False) |
| senses.to_parquet(OUT / "data/senses.parquet", index=False) |
| senses.to_csv(OUT / "data/senses.csv", index=False, encoding="utf-8-sig") |
| words = sorted(set(senses["word"]) - {""}) |
| (OUT / "data/words.txt").write_text("\n".join(words) + "\n", encoding="utf-8") |
|
|
| g2p = build_g2p(entries) |
| (OUT / "data/g2p").mkdir(exist_ok=True) |
| for name, part in g2p.groupby("split"): |
| part.drop(columns="split").to_parquet(OUT / f"data/g2p/{name}.parquet", index=False) |
|
|
| print(f"entries={len(entries)} senses={len(senses)} words={len(words)} " |
| f"headwords={senses['headword'].nunique()} subentries={entries['is_subentry'].sum()} " |
| f"no_pron_entries={(entries['pronunciation'] == '').sum()}") |
| print(f"g2p pairs={len(g2p)} words={g2p['word'].nunique()} " |
| + " ".join(f"{k}={v}" for k, v in g2p["split"].value_counts().items())) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
