Add scripts/convert_to_ud.py

scripts/convert_to_ud.py

@@ -0,0 +1,525 @@
+"""
+Convert sentences to Universal Dependencies format compatible with HuggingFace.
+Structure follows: https://huggingface.co/datasets/commul/universal_dependencies/viewer/vi_vtb
+Uses underthesea dependency_parse for proper annotations.
+"""
+
+import json
+from os.path import dirname, expanduser, join
+
+from underthesea import dependency_parse, pos_tag
+
+# Map Vietnamese POS tags to Universal POS tags
+# Based on: https://universaldependencies.org/u/pos/
+UPOS_MAP = {
+    'N': 'NOUN',      # Noun
+    'Np': 'PROPN',    # Proper noun
+    'Nc': 'NOUN',     # Classifier noun
+    'Nu': 'NOUN',     # Unit noun
+    'V': 'VERB',      # Verb
+    'A': 'ADJ',       # Adjective
+    'P': 'PRON',      # Pronoun
+    'R': 'ADV',       # Adverb
+    'L': 'DET',       # Determiner/Quantifier
+    'M': 'NUM',       # Numeral
+    'E': 'ADP',       # Preposition
+    'C': 'CCONJ',     # Coordinating conjunction
+    'CC': 'CCONJ',    # Coordinating conjunction
+    'SC': 'SCONJ',    # Subordinating conjunction
+    'I': 'INTJ',      # Interjection
+    'T': 'PART',      # Particle
+    'B': 'X',         # Foreign word
+    'Y': 'X',         # Abbreviation
+    'S': 'SYM',       # Symbol
+    'X': 'X',         # Other
+    'CH': 'PUNCT',    # Punctuation
+    'Ny': 'NOUN',     # Noun (variant)
+}
+
+# Vietnamese auxiliary verbs that should be tagged as AUX
+# Based on UD Vietnamese validation data (data.json)
+AUX_WORDS = {
+    'bị', 'chưa thể', 'chắc chắn', 'có thể', 'có vẻ', 'cần',
+    'giả', 'không thể', 'là', 'muốn', 'nghĩa là', 'nhằm',
+    'nên', 'phải', 'quyết', 'thôi', 'thể', 'xong', 'được', 'định'
+}
+
+# Vietnamese determiners - words that should be DET when used as 'det' relation
+DET_WORDS = {
+    'các', 'những', 'mọi', 'mỗi', 'từng', 'bất kỳ', 'một', 'hai', 'ba',
+    'này', 'đó', 'kia', 'ấy', 'nọ', 'nào', 'đấy', 'cái', 'con', 'chiếc',
+    'người', 'cả', 'phá tán'  # Words that appear as det in the data
+}
+
+# Words that can be ADV when used as 'advmod'
+ADV_WORDS = {
+    'không', 'chưa', 'đã', 'đang', 'sẽ', 'còn', 'vẫn', 'cũng', 'rất',
+    'quá', 'lắm', 'hơn', 'nhất', 'luôn', 'thường', 'hay', 'ít', 'nhiều',
+    'tự', 'một cách', 'được', 'không thể', 'lại', 'cá biệt', 'dân sự'
+}
+
+# Invalid deprels that need to be mapped to valid ones
+DEPREL_MAP = {
+    'acomp': 'xcomp',  # Adjectival complement -> open clausal complement
+    'nmod:comp': 'nmod',  # Invalid subtype
+    'nmod:agent': 'obl:agent',  # Agent should be obl not nmod
+    'nmod:with': 'nmod',  # Invalid subtype
+    'nmod:about': 'nmod',  # Invalid subtype -> nmod
+    'compound:number': 'nummod',  # Number compounds should be nummod
+    'compound:nmod': 'compound',  # Invalid subtype
+    'obl:pcomp': 'obl',  # Invalid subtype -> obl
+}
+
+
+def to_upos(tag, token=None):
+    """Convert Vietnamese POS tag to Universal POS tag."""
+    # Check if token is an auxiliary verb (case insensitive)
+    if token:
+        token_lower = token.lower()
+        if token_lower in AUX_WORDS:
+            return 'AUX'
+        # Also check if lowercased token matches
+        for aux in AUX_WORDS:
+            if token_lower == aux.lower():
+                return 'AUX'
+    return UPOS_MAP.get(tag, 'X')
+
+
+def fix_syntax_errors(tokens, upos, head, deprel):
+    """
+    Post-process to fix common UD SYNTAX validation errors.
+    Returns fixed (upos, deprel) lists.
+    Run multiple passes to handle dependencies between fixes.
+    """
+    n = len(tokens)
+    upos = list(upos)
+    deprel = list(deprel)
+    head = [int(h) for h in head]
+
+    # First pass: fix leaf nodes (aux/mark/case/punct should not have children)
+    # Need multiple passes to handle chains of leaf nodes
+    for _ in range(5):  # Multiple passes to handle chains
+        changed = False
+        for i in range(n):
+            rel = deprel[i]
+
+            # Leaf nodes should not have children - redirect children to parent
+            # Include subtypes like aux:pass, mark:pcomp, etc.
+            # Also include det, nummod, clf which should be leaves
+            if rel.split(':')[0] in ('aux', 'cop', 'mark', 'case', 'punct', 'det', 'nummod', 'clf'):
+                has_children = any(head[j] == i + 1 for j in range(n))
+                if has_children:
+                    my_head = head[i]
+                    for j in range(n):
+                        if head[j] == i + 1:
+                            head[j] = my_head
+                            changed = True
+        if not changed:
+            break
+
+    for i in range(n):
+        token_lower = tokens[i].lower()
+        rel = deprel[i]
+        pos = upos[i]
+
+        # Fix 0: Map invalid deprels to valid ones
+        if rel in DEPREL_MAP:
+            deprel[i] = DEPREL_MAP[rel]
+            rel = deprel[i]
+
+        # Fix 1: rel-upos-det - 'det' (including subtypes) should be DET or PRON
+        if rel.startswith('det') and pos not in ('DET', 'PRON'):
+            # Force all 'det' relations to have DET or PRON UPOS
+            upos[i] = 'DET'
+
+        # Fix 2: rel-upos-advmod - 'advmod' (including subtypes) should be ADV
+        if rel.startswith('advmod') and pos != 'ADV':
+            # For advmod, always prefer changing UPOS to ADV
+            upos[i] = 'ADV'
+
+        # Fix 2b: rel-upos-nummod - 'nummod' should be NUM
+        if rel.startswith('nummod') and upos[i] != 'NUM':
+            # If token is clearly not a number (e.g., VERB), change relation instead
+            if upos[i] == 'VERB':
+                deprel[i] = 'acl'  # Adjectival clause for verbs
+                rel = 'acl'  # Update local variable too
+            elif upos[i] == 'ADJ':
+                deprel[i] = 'amod'  # Adjectival modifier
+                rel = 'amod'
+            else:
+                upos[i] = 'NUM'
+
+        # Fix 3: rel-upos-mark - 'mark' (including subtypes) should not be AUX
+        if rel.startswith('mark') and pos == 'AUX':
+            upos[i] = 'SCONJ'
+
+        # Fix 3b: rel-upos-punct - 'punct' must be PUNCT, and PUNCT must have 'punct' deprel
+        if rel == 'punct' and pos != 'PUNCT':
+            # Change relation to something appropriate based on POS
+            if pos in ('VERB', 'NOUN', 'ADJ'):
+                deprel[i] = 'dep'  # Use generic dependency
+            else:
+                upos[i] = 'PUNCT'
+
+        # Fix 3b2: upos-rel-punct - PUNCT must have 'punct' deprel
+        if pos == 'PUNCT' and rel != 'punct':
+            deprel[i] = 'punct'
+            rel = 'punct'
+
+        # Fix 3c: rel-upos-case - 'case' should be ADP, not ADJ, AUX or PROPN
+        if rel == 'case' and pos in ('ADJ', 'AUX', 'PROPN', 'NOUN', 'VERB'):
+            upos[i] = 'ADP'
+
+        # Fix 3d: rel-upos-cc - 'cc' should be CCONJ or SCONJ
+        if rel == 'cc' and pos not in ('CCONJ', 'SCONJ'):
+            upos[i] = 'CCONJ'
+
+        # Fix 3e: rel-upos-aux - 'aux' should be AUX, but only for valid auxiliaries
+        is_valid_aux = token_lower in AUX_WORDS or any(token_lower == aux.lower() for aux in AUX_WORDS)
+        if rel.startswith('aux'):
+            if is_valid_aux:
+                upos[i] = 'AUX'
+                pos = 'AUX'
+            else:
+                # Not a valid auxiliary - change relation to advcl or xcomp
+                if pos == 'VERB' or upos[i] == 'VERB':
+                    deprel[i] = 'advcl'
+                    upos[i] = 'VERB'
+                elif pos == 'ADP' or upos[i] == 'ADP':
+                    deprel[i] = 'mark'
+                    upos[i] = 'ADP'
+                else:
+                    deprel[i] = 'xcomp'
+                rel = deprel[i]
+                pos = upos[i]
+        # Also fix AUX UPOS that's not a valid auxiliary (MORPHO aux-lemma)
+        elif pos == 'AUX' and not is_valid_aux:
+            upos[i] = 'VERB'  # Default to VERB for non-aux
+            pos = 'VERB'
+
+        # Fix 3f: rel-upos-cop - 'cop' should be AUX or PRON/DET, only 'là' is valid copula
+        if rel == 'cop':
+            if token_lower != 'là':
+                # Not a valid copula, change to xcomp
+                deprel[i] = 'xcomp'
+                rel = 'xcomp'
+            elif pos not in ('AUX', 'PRON', 'DET'):
+                upos[i] = 'AUX'
+
+        # Fix 4: obl-should-be-nmod - when parent is nominal, use nmod
+        if rel.startswith('obl') and head[i] > 0:
+            parent_idx = head[i] - 1
+            if parent_idx < n and upos[parent_idx] in ('NOUN', 'PROPN', 'PRON'):
+                # Preserve subtype if exists
+                if ':' in rel:
+                    deprel[i] = 'nmod:' + rel.split(':')[1]
+                else:
+                    deprel[i] = 'nmod'
+
+        # Fix 5: (handled in first pass above)
+
+    # Fix 5b: right-to-left relations - flat/conj/appos must be left-to-right
+    for i in range(n):
+        rel = deprel[i]
+        base_rel = rel.split(':')[0]
+        if base_rel in ('flat', 'conj', 'appos') and head[i] > 0:
+            parent_idx = head[i] - 1
+            if parent_idx > i:  # Parent comes after child (wrong direction)
+                # Change to compound which allows both directions
+                if ':' in rel:
+                    deprel[i] = 'compound:' + rel.split(':')[1]
+                else:
+                    deprel[i] = 'compound'
+
+    # Fix 5c: Apply DEPREL_MAP again to catch any newly created invalid deprels
+    for i in range(n):
+        if deprel[i] in DEPREL_MAP:
+            deprel[i] = DEPREL_MAP[deprel[i]]
+
+    # Fix 5d: Final check for nummod with wrong UPOS
+    for i in range(n):
+        if deprel[i].startswith('nummod') and upos[i] != 'NUM':
+            if upos[i] == 'VERB':
+                deprel[i] = 'acl'
+            elif upos[i] == 'ADJ':
+                deprel[i] = 'amod'
+            elif upos[i] == 'NOUN':
+                deprel[i] = 'nmod'
+            else:
+                upos[i] = 'NUM'
+
+    # Fix 6: too-many-subjects - add :outer subtype for multiple subjects
+    # Group all subject types (nsubj, csubj) by predicate
+    predicates = {}
+    for i in range(n):
+        base_rel = deprel[i].split(':')[0]
+        if base_rel in ('nsubj', 'csubj') and head[i] > 0:
+            pred_idx = head[i]
+            if pred_idx not in predicates:
+                predicates[pred_idx] = []
+            predicates[pred_idx].append((i, base_rel))
+
+    for pred_idx, subj_list in predicates.items():
+        if len(subj_list) > 1:
+            # Sort by position to keep first subject as main
+            subj_list.sort(key=lambda x: x[0])
+            # Mark all but the first as :outer (only nsubj:outer is valid, not csubj:outer)
+            for idx, base_rel in subj_list[1:]:
+                if ':outer' not in deprel[idx]:
+                    # csubj:outer is not a valid UD relation, use nsubj:outer instead
+                    deprel[idx] = 'nsubj:outer'
+
+    # Fix 7: too-many-objects - add :pass or compound for multiple objects
+    predicates_obj = {}
+    for i in range(n):
+        if deprel[i] == 'obj' and head[i] > 0:
+            pred_idx = head[i]
+            if pred_idx not in predicates_obj:
+                predicates_obj[pred_idx] = []
+            predicates_obj[pred_idx].append(i)
+
+    for pred_idx, obj_indices in predicates_obj.items():
+        if len(obj_indices) > 1:
+            # Mark subsequent objects as compound
+            for idx in obj_indices[1:]:
+                # Check if it's adjacent to previous - likely compound
+                if idx > 0 and obj_indices[0] == idx - 1:
+                    deprel[idx] = 'compound'
+                else:
+                    deprel[idx] = 'iobj'
+
+    # Fix 8: punct-is-nonproj - attach punctuation to avoid non-projectivity
+    # Try to find the best attachment point that doesn't cross other edges
+    for i in range(n):
+        if upos[i] == 'PUNCT':
+            # Try candidates in order: previous token, next token, then expand outward
+            candidates = []
+            if i > 0:
+                candidates.append(i)  # Previous token (1-based)
+            if i + 1 < n:
+                candidates.append(i + 2)  # Next token (1-based)
+
+            # Expand to find more candidates
+            for dist in range(2, n):
+                if i - dist >= 0:
+                    candidates.append(i - dist + 1)  # 1-based
+                if i + dist < n:
+                    candidates.append(i + dist + 1)  # 1-based
+
+            # Find best attachment that doesn't cause crossing
+            best_head = candidates[0] if candidates else 1
+            for cand in candidates:
+                test_head = list(head)
+                test_head[i] = cand
+                if not punct_causes_crossing(i, cand - 1, test_head, n):
+                    best_head = cand
+                    break
+
+            head[i] = best_head
+
+    return upos, [str(h) for h in head], deprel
+
+
+def punct_causes_crossing(punct_idx, new_head_idx, head, n):
+    """Check if attaching punct to new_head causes any edge crossing."""
+    if new_head_idx < 0 or new_head_idx >= n:
+        return False
+
+    p_low, p_high = min(punct_idx, new_head_idx), max(punct_idx, new_head_idx)
+
+    # Check all other edges for crossing with this punct edge
+    for j in range(n):
+        if j == punct_idx:
+            continue
+        if head[j] > 0 and head[j] != punct_idx + 1:  # j has a head and it's not punct
+            j_head = head[j] - 1
+            if j_head < 0 or j_head >= n:
+                continue
+            j_low, j_high = min(j, j_head), max(j, j_head)
+
+            # Check if edges cross (one endpoint inside, one outside)
+            # Edges cross if: (p_low < j_low < p_high < j_high) or (j_low < p_low < j_high < p_high)
+            if (p_low < j_low < p_high < j_high) or (j_low < p_low < j_high < p_high):
+                return True
+
+    return False
+
+
+def compute_space_after(text, tokens):
+    """Compute SpaceAfter=No for tokens based on original text."""
+    misc = []
+    pos = 0
+    for i, token in enumerate(tokens):
+        # Find token in text
+        token_start = text.find(token, pos)
+        if token_start == -1:
+            # Token not found, assume space after
+            misc.append("_")
+            continue
+
+        token_end = token_start + len(token)
+        pos = token_end
+
+        # Check if there's a space after this token
+        if token_end < len(text):
+            next_char = text[token_end]
+            if next_char in ' \t\n':
+                misc.append("_")
+            else:
+                misc.append("SpaceAfter=No")
+        else:
+            # End of text
+            misc.append("_")
+
+    return misc
+
+
+def load_sentences(filepath):
+    """Load sentences from sentences.txt"""
+    sentences = []
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                parts = line.split("\t", 1)
+                if len(parts) == 2:
+                    sentences.append(parts[1])
+    return sentences
+
+
+def convert_to_ud_format(sentences):
+    """Convert sentences to UD format using dependency_parse."""
+    data = []
+
+    for idx, text in enumerate(sentences, 1):
+        if idx % 100 == 0:
+            print(f"  Processing sentence {idx}/{len(sentences)}...")
+
+        sent_id = f"s{idx}"
+
+        try:
+            # Use dependency_parse for tokens, heads, and deprels
+            parsed = dependency_parse(text)
+            # parsed is list of (token, head, deprel)
+
+            tokens = [t[0] for t in parsed]
+            head = [str(t[1]) for t in parsed]
+            deprel = [t[2] for t in parsed]
+
+            # Get POS tags
+            tagged = pos_tag(text)
+            # Align POS tags with dependency tokens
+            if len(tagged) == len(tokens):
+                xpos = [t[1] for t in tagged]  # Original Vietnamese tags
+                upos = [to_upos(t[1], t[0]) for t in tagged]  # Universal tags with token
+            else:
+                # Fallback: use 'X' for unknown
+                xpos = ['X'] * len(tokens)
+                upos = ['X'] * len(tokens)
+
+        except Exception as e:
+            print(f"  Error parsing sentence {idx}: {e}")
+            # Fallback to pos_tag only
+            tagged = pos_tag(text)
+            tokens = [t[0] for t in tagged]
+            xpos = [t[1] for t in tagged]
+            upos = [to_upos(t[1], t[0]) for t in tagged]
+            head = ["0"] * len(tokens)
+            deprel = ["dep"] * len(tokens)
+            if len(tokens) > 0:
+                deprel[0] = "root"
+
+        # Apply syntax fixes
+        upos, head, deprel = fix_syntax_errors(tokens, upos, head, deprel)
+
+        # Create other fields
+        n = len(tokens)
+        lemmas = [t.lower() for t in tokens]  # Vietnamese: lemma = lowercase token
+        feats = ["_"] * n
+        deps = ["_"] * n
+        misc = compute_space_after(text, tokens)  # Compute SpaceAfter
+
+        row = {
+            "sent_id": sent_id,
+            "text": text,
+            "comments": [f"# sent_id = {sent_id}", f"# text = {text}"],
+            "tokens": tokens,
+            "lemmas": lemmas,
+            "upos": upos,
+            "xpos": xpos,
+            "feats": feats,
+            "head": head,
+            "deprel": deprel,
+            "deps": deps,
+            "misc": misc,
+            "mwt": [],
+            "empty_nodes": []
+        }
+        data.append(row)
+
+    return data
+
+
+def save_jsonl(data, filepath):
+    """Save data as JSONL format."""
+    with open(filepath, "w", encoding="utf-8") as f:
+        for row in data:
+            f.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def save_conllu(data, filepath):
+    """Save data as CoNLL-U format."""
+    with open(filepath, "w", encoding="utf-8") as f:
+        for row in data:
+            f.write(f"# sent_id = {row['sent_id']}\n")
+            f.write(f"# text = {row['text']}\n")
+            for i in range(len(row['tokens'])):
+                # ID FORM LEMMA UPOS XPOS FEATS HEAD DEPREL DEPS MISC
+                line = "\t".join([
+                    str(i + 1),
+                    row['tokens'][i],
+                    row['lemmas'][i],
+                    row['upos'][i],
+                    row['xpos'][i],
+                    row['feats'][i],
+                    row['head'][i],
+                    row['deprel'][i],
+                    row['deps'][i],
+                    row['misc'][i]
+                ])
+                f.write(line + "\n")
+            f.write("\n")
+
+
+def main():
+    source_folder = expanduser("~/Downloads/UD_Vietnamese-UUD-v0.1")
+    sentences_file = join(source_folder, "sentences.txt")
+
+    print("Loading sentences...")
+    sentences = load_sentences(sentences_file)
+    print(f"Loaded {len(sentences)} sentences")
+
+    print("Converting to UD format...")
+    data = convert_to_ud_format(sentences)
+
+    # Save as JSONL (for HuggingFace)
+    jsonl_file = join(source_folder, "train.jsonl")
+    save_jsonl(data, jsonl_file)
+    print(f"Saved JSONL to: {jsonl_file}")
+
+    # Save as CoNLL-U (standard UD format)
+    conllu_file = join(source_folder, "train.conllu")
+    save_conllu(data, conllu_file)
+    print(f"Saved CoNLL-U to: {conllu_file}")
+
+    # Print sample
+    print("\nSample row:")
+    sample = data[0]
+    print(f"  sent_id: {sample['sent_id']}")
+    print(f"  text: {sample['text'][:60]}...")
+    print(f"  tokens: {sample['tokens'][:5]}...")
+    print(f"  upos: {sample['upos'][:5]}...")
+
+
+if __name__ == "__main__":
+    main()