Add ACD cognate extraction script

scripts/extract_acd_cognates.py

@@ -0,0 +1,288 @@
+#!/usr/bin/env python3
+"""Extract cognate pairs from the ACD (Austronesian Comparative Dictionary) CLDF dataset.
+
+Source: https://github.com/lexibank/acd (CC BY 4.0)
+Citation: Blust, Trussel & Smith (2023), DOI: 10.5281/zenodo.7737547
+Data files: data/training/raw/acd_cldf/{forms,languages,cognatesets}.csv
+  — Downloaded by scripts/ingest_acd.py via urllib from GitHub raw content
+
+The ACD provides expert cognacy assignments for 146K+ Austronesian forms.
+This script reads the Cognacy column from forms.csv and generates
+cross-language pairwise cognate pairs within each cognacy group.
+
+IPA handling:
+  - ACD provides NO IPA/Segments data. Forms are in Blust notation
+    (proto-forms) or orthographic form (modern languages).
+  - Proto-forms: converted via Blust (2009) notation → IPA mapping.
+  - Modern forms: lowercased orthography used as pseudo-IPA.
+  - Score = -1 sentinel for ALL pairs (no reliable IPA for SCA computation).
+
+Iron Rule: All data read from external CSV files. No hardcoded word lists.
+
+Output: staging/cognate_pairs/acd_cognate_pairs.tsv (14-column schema)
+"""
+
+from __future__ import annotations
+
+import csv
+import io
+import re
+import sys
+from collections import defaultdict
+from itertools import combinations
+from pathlib import Path
+
+sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding="utf-8")
+sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding="utf-8")
+
+ROOT = Path(__file__).resolve().parent.parent
+ACD_DIR = ROOT / "data" / "training" / "raw" / "acd_cldf"
+STAGING_DIR = ROOT / "staging" / "cognate_pairs"
+STAGING_DIR.mkdir(parents=True, exist_ok=True)
+
+HEADER = (
+    "Lang_A\tWord_A\tIPA_A\tLang_B\tWord_B\tIPA_B\tConcept_ID\t"
+    "Relationship\tScore\tSource\tRelation_Detail\tDonor_Language\t"
+    "Confidence\tSource_Record_ID\n"
+)
+
+# Blust notation → IPA mapping
+# Reference: Blust (2009) "The Austronesian Languages", Chapter 2
+BLUST_TO_IPA = {
+    "C": "ts", "N": "ŋ", "R": "ʀ", "S": "s", "Z": "z",
+    "H": "h", "L": "ɬ", "T": "t", "D": "d",
+    "ng": "ŋ", "ny": "ɲ", "nj": "ɲ",
+    "q": "ʔ", "e": "ə",
+    "₁": "", "₂": "", "₃": "", "₄": "", "₅": "",
+    "₆": "", "₇": "", "₈": "", "₉": "", "₀": "",
+}
+
+
+def blust_to_ipa(form: str) -> str:
+    """Convert Blust notation to approximate IPA.
+
+    Reference: Blust (2009) The Austronesian Languages, Chapter 2.
+    """
+    form = form.lstrip("*")
+    form = re.sub(r"\([^)]+\)", "", form)
+    keys = sorted(BLUST_TO_IPA.keys(), key=len, reverse=True)
+    result = []
+    i = 0
+    while i < len(form):
+        matched = False
+        for key in keys:
+            if form[i:i + len(key)] == key:
+                result.append(BLUST_TO_IPA[key])
+                i += len(key)
+                matched = True
+                break
+        if not matched:
+            if form[i] not in "- ":
+                result.append(form[i])
+            i += 1
+    return "".join(result)
+
+
+def clean_form(value: str) -> str:
+    """Clean a form value for use as Word column."""
+    if not value:
+        return "-"
+    result = re.sub(r"\([^)]*\)", "", value)
+    result = re.sub(r"\[[^\]]*\]", "", result)
+    result = re.sub(r"^\*+", "", result)
+    result = result.strip().strip("-").strip()
+    return result if result else "-"
+
+
+def form_to_ipa(value: str, is_proto: bool) -> str:
+    """Convert form value to IPA representation.
+
+    Proto-forms: Blust notation → IPA via cited mapping.
+    Modern forms: lowercased cleaned form (pseudo-IPA).
+    """
+    cleaned = clean_form(value)
+    if cleaned == "-":
+        return "-"
+    if is_proto:
+        return blust_to_ipa(value)
+    return cleaned.lower()
+
+
+def main():
+    print("=" * 60)
+    print("ACD Cognate Extraction")
+    print("=" * 60)
+    print(f"  Source: {ACD_DIR}")
+
+    # Step 1: Load languages (for ISO codes and proto status)
+    lang_map: dict[str, dict] = {}
+    lang_path = ACD_DIR / "languages.csv"
+    with open(lang_path, "r", encoding="utf-8") as f:
+        for row in csv.DictReader(f):
+            lid = row["ID"]
+            iso = row.get("ISO639P3code", "").strip()
+            name = row.get("Name", "")
+            is_proto = row.get("Is_Proto", "false").lower() == "true"
+            lang_map[lid] = {
+                "iso": iso if iso else "-",
+                "name": name,
+                "is_proto": is_proto,
+            }
+    print(f"  Languages loaded: {len(lang_map)}")
+    proto_count = sum(1 for v in lang_map.values() if v["is_proto"])
+    modern_iso = sum(1 for v in lang_map.values()
+                     if not v["is_proto"] and v["iso"] != "-")
+    print(f"    Proto-languages: {proto_count}")
+    print(f"    Modern with ISO: {modern_iso}")
+
+    # Step 2: Load forms grouped by cognacy
+    cognacy_groups: dict[str, list[dict]] = defaultdict(list)
+    forms_path = ACD_DIR / "forms.csv"
+    total_forms = 0
+    skipped_no_cognacy = 0
+    skipped_no_lang = 0
+    loan_flagged_forms = 0
+
+    with open(forms_path, "r", encoding="utf-8") as f:
+        for row in csv.DictReader(f):
+            total_forms += 1
+            cognacy = row.get("Cognacy", "").strip()
+            if not cognacy:
+                skipped_no_cognacy += 1
+                continue
+
+            lang_id = row.get("Language_ID", "").strip()
+            if lang_id not in lang_map:
+                skipped_no_lang += 1
+                continue
+
+            lang_info = lang_map[lang_id]
+            iso = lang_info["iso"]
+            is_proto = lang_info["is_proto"]
+
+            # Skip proto-languages (no ISO code, not real attestations)
+            if is_proto:
+                continue
+
+            # Skip languages without ISO codes (unidentifiable)
+            if iso == "-":
+                continue
+
+            value = row.get("Value", "").strip()
+            if not value:
+                continue
+
+            loan = row.get("Loan", "").strip()
+            doubt = row.get("Doubt", "").strip()
+            is_loan = loan.lower() == "true" if loan else False
+            is_doubtful = doubt.lower() == "true" if doubt else False
+
+            if is_loan:
+                loan_flagged_forms += 1
+
+            # Concept from Description or Parameter_ID
+            description = row.get("Description", "").strip()
+            param_id = row.get("Parameter_ID", "").strip()
+            concept = description if description else param_id
+            # Normalize concept: lowercase, replace spaces with underscore
+            if concept:
+                concept = concept.lower().replace(" ", "_")
+            else:
+                concept = "-"
+
+            word = clean_form(value)
+            ipa = form_to_ipa(value, is_proto=False)
+
+            cognacy_groups[cognacy].append({
+                "iso": iso,
+                "word": word,
+                "ipa": ipa,
+                "concept": concept,
+                "is_loan": is_loan,
+                "is_doubtful": is_doubtful,
+                "form_id": row.get("ID", ""),
+            })
+
+    print(f"\n  Total forms: {total_forms:,}")
+    print(f"  Skipped (no cognacy): {skipped_no_cognacy:,}")
+    print(f"  Skipped (unknown language): {skipped_no_lang:,}")
+    print(f"  Loan-flagged forms: {loan_flagged_forms:,}")
+    print(f"  Cognacy groups with modern forms: {len(cognacy_groups):,}")
+
+    # Step 3: Deduplicate members within each cognacy group by (iso, word)
+    dedup_removed = 0
+    for cog, members in cognacy_groups.items():
+        seen: set[str] = set()
+        unique: list[dict] = []
+        for m in members:
+            key = f"{m['iso']}|{m['word']}"
+            if key not in seen:
+                seen.add(key)
+                unique.append(m)
+            else:
+                dedup_removed += 1
+        cognacy_groups[cog] = unique
+    print(f"  Dedup removed: {dedup_removed:,}")
+
+    # Step 4: Generate cross-language pairs within each cognacy group
+    output_path = STAGING_DIR / "acd_cognate_pairs.tsv"
+    total_pairs = 0
+    loan_flagged_pairs = 0
+    doubtful_pairs = 0
+
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(HEADER)
+
+        for cognacy_id, members in sorted(cognacy_groups.items()):
+            if len(members) < 2:
+                continue
+
+            for a, b in combinations(members, 2):
+                # Skip same-language pairs
+                if a["iso"] == b["iso"]:
+                    continue
+
+                # Determine relation detail and confidence
+                if a["is_loan"] or b["is_loan"]:
+                    relation_detail = "loan_flagged"
+                    loan_flagged_pairs += 1
+                else:
+                    relation_detail = "inherited"
+
+                if a["is_doubtful"] or b["is_doubtful"]:
+                    confidence = "doubtful"
+                    doubtful_pairs += 1
+                else:
+                    confidence = "certain"
+
+                # Use the concept from form A (both should share concept
+                # within cognacy group, but take A's)
+                concept = a["concept"] if a["concept"] != "-" else b["concept"]
+
+                # Score = -1: ACD has no IPA, all forms are pseudo-IPA
+                score = -1
+
+                # Source_Record_ID: cognacy group from ACD forms.csv
+                source_record_id = f"acd_{cognacy_id}"
+
+                row = (
+                    f"{a['iso']}\t{a['word']}\t{a['ipa']}\t"
+                    f"{b['iso']}\t{b['word']}\t{b['ipa']}\t"
+                    f"{concept}\texpert_cognate\t{score}\tacd\t"
+                    f"{relation_detail}\t-\t{confidence}\t{source_record_id}\n"
+                )
+                f.write(row)
+                total_pairs += 1
+
+                if total_pairs % 500000 == 0:
+                    print(f"    ... {total_pairs:,} pairs written")
+
+    print(f"\n  Total pairs: {total_pairs:,}")
+    print(f"  Loan-flagged pairs: {loan_flagged_pairs:,}")
+    print(f"  Doubtful pairs: {doubtful_pairs:,}")
+    print(f"  Output: {output_path}")
+    print("=" * 60)
+
+
+if __name__ == "__main__":
+    main()