Expand UDD-1 to 40K sentences across 5 domains

Add fetch scripts for news (UVN-1) and Wikipedia (UVW-2026) domains.
Increase sentence targets to 8K per domain for legal and books.
Add build_dataset.py to combine all domains with sent_id prefixes
and create stratified train/dev/test splits. Update convert_to_ud.py
to support domain-specific sent_ids and upload_to_hf.py for multi-split
upload with domain field.

CLAUDE.md

@@ -0,0 +1,117 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+UDD-1 (Universal Dependency Dataset for Vietnamese) is a Vietnamese Universal Dependencies treebank with 40,000 sentences from 5 domains. The repo contains both the dataset files (CoNLL-U format) and the tooling pipeline for creating/validating them.
+
+### Domain Breakdown
+
+| Category | Source Dataset | Sentences | Sent ID Prefix |
+|----------|---------------|-----------|----------------|
+| Wikipedia | `undertheseanlp/UVW-2026` | 8,000 | `uvw-` |
+| News | `undertheseanlp/UVN-1` | 8,000 | `uvn-` |
+| Legal | `undertheseanlp/UTS_VLC` | 8,000 | `vlc-` |
+| Fiction | `undertheseanlp/UVB-v0.1` | 8,000 | `uvb-f-` |
+| Non-fiction | `undertheseanlp/UVB-v0.1` | 8,000 | `uvb-n-` |
+
+## Repository Structure
+
+- Root `.conllu` files: The published dataset splits (`vi_udd-ud-{train,dev,test}.conllu`)
+- `data/`: Parquet files for HuggingFace dataset hosting
+- `src/`: Pipeline scripts for data fetching, conversion, validation, and upload
+- `src/udtools/`: Vendored copy of the [Universal Dependencies tools](https://github.com/UniversalDependencies/tools) package (validator + scorer)
+
+## Key Pipeline Scripts
+
+| Script | Purpose |
+|--------|---------|
+| `src/fetch_data.py` | Fetch 8,000 sentences from `undertheseanlp/UTS_VLC` (legal domain) → `sentences_vlc.txt` |
+| `src/fetch_uvn_data.py` | Fetch 8,000 sentences from `undertheseanlp/UVN-1` (news domain) → `sentences_uvn.txt` |
+| `src/fetch_uvw_data.py` | Fetch 8,000 sentences from `undertheseanlp/UVW-2026` (Wikipedia, quality_score >= 5) → `sentences_uvw.txt` |
+| `src/fetch_uvb_data.py` | Fetch 8,000 fiction + 8,000 non-fiction from `undertheseanlp/UVB-v0.1` → `sentences_uvb.txt` |
+| `src/build_dataset.py` | Combine all sentence files, assign sent_id prefixes, create stratified train/dev/test splits → `sentences_{train,dev,test}.txt` |
+| `src/convert_to_ud.py` | Convert raw sentences to UD format using `underthesea` NLP toolkit (dependency parsing + POS tagging). Outputs JSONL and CoNLL-U |
+| `src/statistics.py` | Compute dataset statistics from CoNLL-U files |
+| `src/upload_to_hf.py` | Upload dataset splits to HuggingFace Hub with domain field (requires `HF_TOKEN` env var) |
+| `src/run_conversion.sh` | Wrapper that runs conversion with GPU monitoring and timestamped results |
+| `src/run_on_runpod.py` | Manage RunPod GPU instances for conversion (requires `RUNPOD_API_KEY`) |
+
+## Pipeline Commands
+
+### 1. Fetch sentences from all sources
+```bash
+python src/fetch_data.py        # Legal → sentences_vlc.txt
+python src/fetch_uvn_data.py    # News → sentences_uvn.txt
+python src/fetch_uvw_data.py    # Wikipedia → sentences_uvw.txt
+python src/fetch_uvb_data.py    # Books → sentences_uvb.txt
+```
+
+### 2. Build combined dataset with splits
+```bash
+python src/build_dataset.py     # → sentences_{train,dev,test}.txt
+```
+
+### 3. Run UD conversion (GPU-optimized)
+```bash
+python src/convert_to_ud.py -i sentences_train.txt -o output/ -p train -b 64
+python src/convert_to_ud.py -i sentences_dev.txt -o output/ -p dev -b 64
+python src/convert_to_ud.py -i sentences_test.txt -o output/ -p test -b 64
+# Or use the shell wrapper:
+./src/run_conversion.sh <input_file> [batch_size]
+```
+
+### 4. Validate CoNLL-U files
+```bash
+cd src/udtools
+pip install -e .
+python validate.py --lang vi vi_udd-ud-train.conllu
+```
+
+### 5. Run udtools tests
+```bash
+cd src/udtools
+python -m pytest tests/
+```
+
+### 6. Compute dataset statistics
+```bash
+python src/statistics.py
+```
+
+### 7. Upload to HuggingFace
+```bash
+export HF_TOKEN=<token>
+python src/upload_to_hf.py
+```
+
+## Architecture Notes
+
+### Conversion Pipeline (`convert_to_ud.py`)
+The core conversion flow: raw Vietnamese text -> `underthesea.dependency_parse()` + `underthesea.pos_tag()` -> Vietnamese POS mapped to Universal POS via `UPOS_MAP` -> syntax error post-processing via `fix_syntax_errors()` -> CoNLL-U output.
+
+`fix_syntax_errors()` is a critical multi-pass function that corrects UD validation issues:
+- Redirects children of leaf-only relations (aux, case, punct, det, etc.)
+- Maps invalid deprels via `DEPREL_MAP`
+- Enforces UPOS/deprel consistency (e.g., `det` must be DET/PRON, `advmod` must be ADV)
+- Handles Vietnamese-specific auxiliary verbs (`AUX_WORDS`) and copula (`la`)
+- Fixes directional constraints (flat/conj/appos must be left-to-right)
+- Resolves multiple subjects/objects per predicate
+- Fixes non-projective punctuation attachment
+
+### udtools (Vendored UD Validator)
+The `src/udtools/` directory is a vendored copy of the official UD tools. The validator class hierarchy is: `Validator` -> `Level6` -> `Level5` -> ... -> `Level1`. Each level adds progressively stricter UD compliance checks. The `Validator` class in `validator.py` is the main entry point.
+
+### Data Format
+- **CoNLL-U**: Standard 10-column UD format (ID, FORM, LEMMA, UPOS, XPOS, FEATS, HEAD, DEPREL, DEPS, MISC)
+- **JSONL**: HuggingFace-compatible format with fields: `sent_id`, `text`, `tokens`, `lemmas`, `upos`, `xpos`, `feats`, `head`, `deprel`, `deps`, `misc`, `domain`
+- Sentence ID prefixes: `vlc-` = legal, `uvn-` = news, `uvw-` = wikipedia, `uvb-f-` = fiction, `uvb-n-` = non-fiction
+- Split ratios: Train (91.4%) / Dev (4.3%) / Test (4.3%), stratified by domain
+
+## Dependencies
+
+- `underthesea`: Vietnamese NLP toolkit (tokenization, POS tagging, dependency parsing)
+- `torch`: Required by underthesea models (GPU-accelerated)
+- `datasets`, `huggingface_hub`: For HuggingFace dataset operations
+- `udtools` dependencies: `udapi>=0.5.0`, `regex>=2020.09.27` (see `src/udtools/pyproject.toml`)

src/build_dataset.py

@@ -0,0 +1,209 @@
+"""
+Build the combined UDD-1 multi-domain dataset (40,000 sentences).
+
+Reads sentence files from all domains, assigns domain-specific sent_id prefixes,
+and creates stratified train/dev/test splits.
+
+Domain mapping:
+  - sentences_vlc.txt  -> prefix: vlc-    (Legal)
+  - sentences_uvn.txt  -> prefix: uvn-    (News)
+  - sentences_uvw.txt  -> prefix: uvw-    (Wikipedia)
+  - sentences_uvb.txt  -> prefix: uvb-f-  (Fiction), uvb-n- (Non-fiction)
+
+Output:
+  - sentences_train.txt  (91.4%)
+  - sentences_dev.txt    (4.3%)
+  - sentences_test.txt   (4.3%)
+
+Each line format: sent_id\tsentence
+"""
+
+import random
+from os.path import dirname, isfile, join
+
+
+# Split ratios
+TRAIN_RATIO = 0.914
+DEV_RATIO = 0.043
+TEST_RATIO = 0.043
+
+
+def load_sentences_with_prefix(filepath, prefix):
+    """Load sentences from a file and assign sent_id prefix.
+
+    Returns list of (sent_id, sentence) tuples.
+    """
+    sentences = []
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            parts = line.split("\t")
+            # Format: idx\tsentence
+            if len(parts) == 2:
+                idx = parts[0]
+                sentence = parts[1]
+                sent_id = f"{prefix}{idx}"
+                sentences.append((sent_id, sentence))
+            # Format: idx\tsource\tsentence (sentences_uvb.txt)
+            elif len(parts) >= 3:
+                idx = parts[0]
+                source = parts[1]
+                sentence = parts[2]
+                sent_id = f"{prefix}{idx}"
+                sentences.append((sent_id, sentence, source))
+    return sentences
+
+
+def load_uvb_sentences(filepath):
+    """Load UVB sentences and split by fiction/non-fiction with proper prefixes."""
+    fiction = []
+    non_fiction = []
+    fiction_idx = 0
+    non_fiction_idx = 0
+
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            parts = line.split("\t")
+            if len(parts) >= 3:
+                source = parts[1]
+                sentence = parts[2]
+                if source == "fiction":
+                    fiction_idx += 1
+                    fiction.append((f"uvb-f-{fiction_idx}", sentence))
+                else:
+                    non_fiction_idx += 1
+                    non_fiction.append((f"uvb-n-{non_fiction_idx}", sentence))
+
+    return fiction, non_fiction
+
+
+def stratified_split(domain_sentences, seed=42):
+    """Create stratified train/dev/test split preserving domain proportions.
+
+    Args:
+        domain_sentences: dict of domain_name -> list of (sent_id, sentence)
+        seed: random seed for reproducibility
+
+    Returns:
+        train, dev, test lists of (sent_id, sentence)
+    """
+    random.seed(seed)
+
+    train = []
+    dev = []
+    test = []
+
+    for domain_name, sentences in domain_sentences.items():
+        # Shuffle within each domain
+        shuffled = list(sentences)
+        random.shuffle(shuffled)
+
+        n = len(shuffled)
+        n_dev = max(1, round(n * DEV_RATIO))
+        n_test = max(1, round(n * TEST_RATIO))
+        n_train = n - n_dev - n_test
+
+        train.extend(shuffled[:n_train])
+        dev.extend(shuffled[n_train:n_train + n_dev])
+        test.extend(shuffled[n_train + n_dev:])
+
+        print(f"  {domain_name}: {n_train} train / {n_dev} dev / {n_test} test (total: {n})")
+
+    return train, dev, test
+
+
+def save_split(sentences, filepath):
+    """Save a list of (sent_id, sentence) to file."""
+    with open(filepath, "w", encoding="utf-8") as f:
+        for sent_id, sentence in sentences:
+            f.write(f"{sent_id}\t{sentence}\n")
+
+
+def main():
+    base_dir = dirname(dirname(__file__))
+
+    # Define source files and their prefixes
+    sources = {
+        "vlc": ("sentences_vlc.txt", "vlc-"),
+        "uvn": ("sentences_uvn.txt", "uvn-"),
+        "uvw": ("sentences_uvw.txt", "uvw-"),
+    }
+
+    # Load sentences from each domain
+    domain_sentences = {}
+
+    for domain, (filename, prefix) in sources.items():
+        filepath = join(base_dir, filename)
+        if not isfile(filepath):
+            print(f"Warning: {filepath} not found, skipping {domain}")
+            continue
+        sents = load_sentences_with_prefix(filepath, prefix)
+        # Extract just (sent_id, sentence) tuples
+        domain_sentences[domain] = [(s[0], s[1]) for s in sents]
+        print(f"Loaded {len(domain_sentences[domain])} sentences from {filename}")
+
+    # Load UVB (books) with fiction/non-fiction split
+    uvb_filepath = join(base_dir, "sentences_uvb.txt")
+    if isfile(uvb_filepath):
+        fiction, non_fiction = load_uvb_sentences(uvb_filepath)
+        domain_sentences["uvb-fiction"] = fiction
+        domain_sentences["uvb-nonfiction"] = non_fiction
+        print(f"Loaded {len(fiction)} fiction + {len(non_fiction)} non-fiction sentences from sentences_uvb.txt")
+    else:
+        print(f"Warning: {uvb_filepath} not found, skipping books domain")
+
+    # Report totals
+    total = sum(len(v) for v in domain_sentences.values())
+    print(f"\nTotal sentences across all domains: {total}")
+
+    # Create stratified split
+    print("\nCreating stratified train/dev/test split...")
+    train, dev, test = stratified_split(domain_sentences)
+
+    print(f"\nSplit sizes:")
+    print(f"  Train: {len(train)} ({100*len(train)/total:.1f}%)")
+    print(f"  Dev:   {len(dev)} ({100*len(dev)/total:.1f}%)")
+    print(f"  Test:  {len(test)} ({100*len(test)/total:.1f}%)")
+    print(f"  Total: {len(train) + len(dev) + len(test)}")
+
+    # Save splits
+    save_split(train, join(base_dir, "sentences_train.txt"))
+    save_split(dev, join(base_dir, "sentences_dev.txt"))
+    save_split(test, join(base_dir, "sentences_test.txt"))
+
+    print(f"\nSaved to:")
+    print(f"  {join(base_dir, 'sentences_train.txt')}")
+    print(f"  {join(base_dir, 'sentences_dev.txt')}")
+    print(f"  {join(base_dir, 'sentences_test.txt')}")
+
+    # Print domain distribution per split
+    print("\nDomain distribution per split:")
+    for split_name, split_data in [("Train", train), ("Dev", dev), ("Test", test)]:
+        domain_counts = {}
+        for sent_id, _ in split_data:
+            # Determine domain from sent_id prefix
+            if sent_id.startswith("vlc-"):
+                domain = "legal"
+            elif sent_id.startswith("uvn-"):
+                domain = "news"
+            elif sent_id.startswith("uvw-"):
+                domain = "wikipedia"
+            elif sent_id.startswith("uvb-f-"):
+                domain = "fiction"
+            elif sent_id.startswith("uvb-n-"):
+                domain = "non-fiction"
+            else:
+                domain = "unknown"
+            domain_counts[domain] = domain_counts.get(domain, 0) + 1
+
+        counts_str = ", ".join(f"{d}: {c}" for d, c in sorted(domain_counts.items()))
+        print(f"  {split_name}: {counts_str}")
+
+
+if __name__ == "__main__":
+    main()

src/convert_to_ud.py

@@ -0,0 +1,692 @@
+"""
+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.
+
+Optimized for GPU batch processing.
+"""
+
+import json
+import os
+from os.path import dirname, expanduser, join
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import multiprocessing
+
+# Fix GPU tensor compatibility issue with pack_padded_sequence
+# The lengths tensor must be on CPU even when using CUDA
+import torch
+_original_pack = torch.nn.utils.rnn.pack_padded_sequence
+
+def _patched_pack(input, lengths, batch_first=False, enforce_sorted=True):
+    if lengths.is_cuda:
+        lengths = lengths.cpu()
+    return _original_pack(input, lengths, batch_first=batch_first, enforce_sorted=enforce_sorted)
+
+torch.nn.utils.rnn.pack_padded_sequence = _patched_pack
+
+from underthesea import dependency_parse, pos_tag
+
+# Global model cache for batch processing
+_models_loaded = False
+
+# 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 input files.
+
+    Supported formats:
+      - sent_id\\tsentence  (build_dataset.py output: sentences_train.txt, etc.)
+      - idx\\tsentence       (fetch_data.py output: sentences_vlc.txt, etc.)
+      - idx\\tsource\\tsentence (fetch_uvb_data.py output: sentences_uvb.txt)
+
+    Returns list of (sent_id, sentence) tuples. For formats without a sent_id,
+    generates one as s{idx}.
+    """
+    sentences = []
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.strip()
+            if line:
+                parts = line.split("\t")
+                if len(parts) == 2:
+                    first, second = parts
+                    # If first part looks like a sent_id prefix (non-numeric), use it
+                    if not first.isdigit():
+                        sentences.append((first, second))
+                    else:
+                        sentences.append((f"s{first}", second))
+                elif len(parts) >= 3:
+                    sentences.append((f"s{parts[0]}", parts[2]))
+    return sentences
+
+
+def process_single_sentence(args):
+    """Process a single sentence (used for parallel processing)."""
+    idx, text, sent_id = args
+
+    try:
+        # Use dependency_parse for tokens, heads, and deprels
+        parsed = dependency_parse(text)
+        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)
+        if len(tagged) == len(tokens):
+            xpos = [t[1] for t in tagged]
+            upos = [to_upos(t[1], t[0]) for t in tagged]
+        else:
+            xpos = ['X'] * len(tokens)
+            upos = ['X'] * len(tokens)
+
+    except Exception as 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]
+    feats = ["_"] * n
+    deps = ["_"] * n
+    misc = compute_space_after(text, tokens)
+
+    return idx, {
+        "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": []
+    }
+
+
+def convert_to_ud_format(sentences, batch_size=32, num_workers=4):
+    """Convert sentences to UD format using dependency_parse with batch processing.
+
+    Args:
+        sentences: list of (sent_id, text) tuples or list of text strings
+        batch_size: batch size for GPU processing
+        num_workers: number of workers (unused in batch mode)
+    """
+    global _models_loaded
+
+    # Pre-warm models with a dummy sentence to load them into GPU memory
+    if not _models_loaded:
+        print("  Loading models into GPU memory...")
+        _ = dependency_parse("Xin chào")
+        _ = pos_tag("Xin chào")
+        _models_loaded = True
+        print("  Models loaded.")
+
+    data = [None] * len(sentences)
+    total = len(sentences)
+
+    # Process in batches for better GPU utilization
+    print(f"  Processing {total} sentences with batch_size={batch_size}...")
+
+    for batch_start in range(0, total, batch_size):
+        batch_end = min(batch_start + batch_size, total)
+        batch = []
+        for i in range(batch_start, batch_end):
+            s = sentences[i]
+            if isinstance(s, tuple):
+                sent_id, text = s
+                batch.append((i + 1, text, sent_id))
+            else:
+                batch.append((i + 1, s, f"s{i + 1}"))
+
+        # Process batch - GPU models benefit from sequential calls within batch
+        # as they can better utilize GPU memory
+        for args in batch:
+            idx, row = process_single_sentence(args)
+            data[idx - 1] = row
+
+        # Progress update
+        processed = batch_end
+        if processed % 100 == 0 or processed == total:
+            print(f"  Processed {processed}/{total} sentences ({100*processed/total:.1f}%)")
+
+    return data
+
+
+def convert_to_ud_format_parallel(sentences, num_workers=None):
+    """Convert sentences using multiple workers (CPU parallelism).
+
+    Note: This is useful when GPU is bottleneck or for CPU-only processing.
+    For GPU processing, use convert_to_ud_format with batch processing.
+
+    Args:
+        sentences: list of (sent_id, text) tuples or list of text strings
+        num_workers: number of parallel workers
+    """
+    global _models_loaded
+
+    if num_workers is None:
+        num_workers = min(4, multiprocessing.cpu_count())
+
+    # Pre-warm models
+    if not _models_loaded:
+        print("  Loading models...")
+        _ = dependency_parse("Xin chào")
+        _ = pos_tag("Xin chào")
+        _models_loaded = True
+        print("  Models loaded.")
+
+    data = [None] * len(sentences)
+    total = len(sentences)
+    processed = 0
+
+    print(f"  Processing {total} sentences with {num_workers} workers...")
+
+    # Build args list with sent_id
+    args_list = []
+    for i in range(total):
+        s = sentences[i]
+        if isinstance(s, tuple):
+            sent_id, text = s
+            args_list.append((i + 1, text, sent_id))
+        else:
+            args_list.append((i + 1, s, f"s{i + 1}"))
+
+    # Use ThreadPoolExecutor for I/O bound tasks with GPU
+    with ThreadPoolExecutor(max_workers=num_workers) as executor:
+        futures = {
+            executor.submit(process_single_sentence, args): i
+            for i, args in enumerate(args_list)
+        }
+
+        for future in as_completed(futures):
+            idx, row = future.result()
+            data[idx - 1] = row
+            processed += 1
+
+            if processed % 100 == 0 or processed == total:
+                print(f"  Processed {processed}/{total} sentences ({100*processed/total:.1f}%)")
+
+    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():
+    import argparse
+    import time
+    parser = argparse.ArgumentParser(description="Convert sentences to UD format")
+    parser.add_argument("--input", "-i", type=str, help="Input sentences file")
+    parser.add_argument("--output-dir", "-o", type=str, help="Output directory")
+    parser.add_argument("--prefix", "-p", type=str, default="train", help="Output file prefix")
+    parser.add_argument("--batch-size", "-b", type=int, default=64,
+                        help="Batch size for GPU processing (default: 64, increase for more GPU usage)")
+    parser.add_argument("--parallel", action="store_true",
+                        help="Use parallel processing with multiple workers")
+    parser.add_argument("--workers", "-w", type=int, default=4,
+                        help="Number of workers for parallel processing (default: 4)")
+    args = parser.parse_args()
+
+    # Default paths
+    if args.input:
+        sentences_file = args.input
+    else:
+        source_folder = expanduser("~/Downloads/UD_Vietnamese-UUD-v0.1")
+        sentences_file = join(source_folder, "sentences.txt")
+
+    if args.output_dir:
+        output_dir = args.output_dir
+    else:
+        output_dir = dirname(sentences_file)
+
+    print("Loading sentences...")
+    sentences = load_sentences(sentences_file)
+    print(f"Loaded {len(sentences)} sentences")
+
+    # Check GPU availability
+    if torch.cuda.is_available():
+        print(f"GPU: {torch.cuda.get_device_name(0)}")
+        print(f"GPU Memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.1f} GB")
+    else:
+        print("GPU: Not available (using CPU)")
+
+    print(f"\nConverting to UD format (batch_size={args.batch_size})...")
+    start_time = time.time()
+
+    if args.parallel:
+        data = convert_to_ud_format_parallel(sentences, num_workers=args.workers)
+    else:
+        data = convert_to_ud_format(sentences, batch_size=args.batch_size)
+
+    elapsed = time.time() - start_time
+    speed = len(sentences) / elapsed
+    print(f"\nCompleted in {elapsed:.1f}s ({speed:.1f} sentences/sec)")
+
+    # Save as JSONL (for HuggingFace)
+    jsonl_file = join(output_dir, f"{args.prefix}.jsonl")
+    save_jsonl(data, jsonl_file)
+    print(f"Saved JSONL to: {jsonl_file}")
+
+    # Save as CoNLL-U (standard UD format)
+    conllu_file = join(output_dir, f"{args.prefix}.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()

src/fetch_data.py

@@ -0,0 +1,115 @@
+"""
+Fetch data from HuggingFace dataset undertheseanlp/UTS_VLC
+- Get documents from law dataset
+- Segment sentences using underthesea
+- Get first 8000 sentences
+"""
+
+import re
+from os.path import dirname, join
+
+from datasets import load_dataset
+
+from underthesea import sent_tokenize, text_normalize
+
+
+def clean_text(text):
+    """Remove markdown formatting and clean text."""
+    # Normalize Unicode using underthesea
+    text = text_normalize(text)
+    # Remove markdown headers
+    text = re.sub(r'^#+\s+', '', text, flags=re.MULTILINE)
+    # Remove bold/italic markers
+    text = re.sub(r'\*+', '', text)
+    # Remove horizontal rules
+    text = re.sub(r'^-+$', '', text, flags=re.MULTILINE)
+    # Remove links
+    text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
+    # Remove multiple newlines
+    text = re.sub(r'\n{2,}', '\n', text)
+    # Remove leading/trailing whitespace per line
+    lines = [line.strip() for line in text.split('\n')]
+    text = '\n'.join(lines)
+    return text
+
+
+def is_valid_sentence(sent):
+    """Check if sentence is valid for UD annotation."""
+    sent = sent.strip()
+    # Remove trailing list markers like "1." or "a)"
+    sent = re.sub(r'\n\d+\.$', '', sent)
+    sent = re.sub(r'\n[a-z]\)$', '', sent)
+    sent = sent.strip()
+
+    if not sent:
+        return False, sent
+    # Too short
+    if len(sent) < 20:
+        return False, sent
+    # Too long
+    if len(sent) > 300:
+        return False, sent
+    # Skip headers (all caps, or starts with "Điều", "Chương", etc.)
+    if re.match(r'^(QUỐC HỘI|CỘNG HÒA|Độc lập|Phần thứ|Chương [IVX]+|MỤC \d+)', sent):
+        return False, sent
+    # Skip article titles
+    if re.match(r'^(Điều \d+|Khoản \d+|Mục \d+)', sent):
+        return False, sent
+    # Skip if mostly uppercase
+    if sum(1 for c in sent if c.isupper()) > len(sent) * 0.5:
+        return False, sent
+    # Skip if starts with special markers
+    if sent.startswith(('English:', 'Số hiệu:', 'Ngày hiệu lực:', '---', '|')):
+        return False, sent
+    # Must contain Vietnamese characters
+    if not re.search(r'[àáảãạăắằẳẵặâấầẩẫậèéẻẽẹêếềểễệìíỉĩịòóỏõọôốồổỗộơớờởỡợùúủũụưứừửữựỳýỷỹỵđ]', sent, re.IGNORECASE):
+        return False, sent
+    # Skip if ends with just a number (incomplete sentence)
+    if re.search(r'\n\d+$', sent):
+        return False, sent
+    return True, sent
+
+
+def fetch_and_process():
+    # Load dataset from HuggingFace
+    print("Loading dataset from HuggingFace...")
+    ds = load_dataset("undertheseanlp/UTS_VLC", split="2026")
+
+    # Segment sentences from all documents until we have 8000
+    print("Segmenting sentences...")
+    all_sentences = []
+    for idx, doc in enumerate(ds):
+        content = doc["content"]
+        content = clean_text(content)
+        sentences = sent_tokenize(content)
+        for sent in sentences:
+            sent = sent.strip()
+            is_valid, cleaned_sent = is_valid_sentence(sent)
+            if is_valid:
+                all_sentences.append(cleaned_sent)
+        if len(all_sentences) >= 8000:
+            print(f"Processed {idx + 1} documents")
+            break
+
+    # Get first 8000 sentences
+    sentences_out = all_sentences[:8000]
+    print(f"Total sentences collected: {len(sentences_out)}")
+
+    # Save to output file
+    output_dir = dirname(dirname(__file__))
+    output_file = join(output_dir, "sentences_vlc.txt")
+
+    with open(output_file, "w", encoding="utf-8") as f:
+        for i, sent in enumerate(sentences_out, 1):
+            f.write(f"{i}\t{sent}\n")
+
+    print(f"Saved to: {output_file}")
+
+    # Print sample
+    print("\nSample sentences:")
+    for i, sent in enumerate(sentences_out[:5], 1):
+        print(f"  {i}. {sent[:80]}...")
+
+
+if __name__ == "__main__":
+    fetch_and_process()

src/fetch_uvb_data.py

@@ -0,0 +1,250 @@
+"""
+Fetch data from HuggingFace dataset undertheseanlp/UVB-v0.1
+- Get 8,000 high-quality sentences from fiction books
+- Get 8,000 high-quality sentences from non-fiction books
+"""
+
+import re
+from os.path import dirname, join
+
+from datasets import load_dataset
+from underthesea import sent_tokenize, text_normalize
+
+
+# Fiction-related genres
+FICTION_GENRES = {
+    "Fiction", "Novels", "Romance", "Fantasy", "Science Fiction",
+    "Mystery", "Thriller", "Horror", "Historical Fiction", "Literary Fiction",
+    "Adventure", "Crime", "Suspense", "Drama", "Short Stories"
+}
+
+# Non-fiction related genres
+NON_FICTION_GENRES = {
+    "Non Fiction", "Nonfiction", "History", "Biography", "Autobiography",
+    "Self Help", "Psychology", "Philosophy", "Science", "Politics",
+    "Economics", "Business", "Education", "Travel", "Memoir",
+    "Essays", "Reference", "Health", "Religion", "Spirituality"
+}
+
+
+def clean_text(text):
+    """Remove formatting and clean text."""
+    # Normalize Unicode using underthesea
+    text = text_normalize(text)
+    # Remove markdown headers
+    text = re.sub(r'^#+\s+', '', text, flags=re.MULTILINE)
+    # Remove bold/italic markers
+    text = re.sub(r'\*+', '', text)
+    # Remove horizontal rules
+    text = re.sub(r'^-+$', '', text, flags=re.MULTILINE)
+    # Remove links
+    text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
+    # Remove multiple newlines
+    text = re.sub(r'\n{2,}', '\n', text)
+    # Remove leading/trailing whitespace per line
+    lines = [line.strip() for line in text.split('\n')]
+    text = '\n'.join(lines)
+    return text
+
+
+def is_high_quality_sentence(sent):
+    """Check if sentence is high quality for UD annotation."""
+    sent = sent.strip()
+
+    if not sent:
+        return False, sent
+
+    # Length constraints
+    if len(sent) < 30:  # Minimum length for meaningful sentence
+        return False, sent
+    if len(sent) > 250:  # Maximum length
+        return False, sent
+
+    # Word count constraints
+    words = sent.split()
+    if len(words) < 5:  # At least 5 words
+        return False, sent
+    if len(words) > 40:  # Max 40 words
+        return False, sent
+
+    # Must start with uppercase letter (proper sentence)
+    if not sent[0].isupper():
+        return False, sent
+
+    # Must end with proper punctuation
+    if not sent.rstrip()[-1] in '.!?…"»':
+        return False, sent
+
+    # Skip if mostly uppercase (headers, titles)
+    if sum(1 for c in sent if c.isupper()) > len(sent) * 0.3:
+        return False, sent
+
+    # Must contain Vietnamese characters
+    if not re.search(r'[àáảãạăắằẳẵặâấầẩẫậèéẻẽẹêếềểễệìíỉĩịòóỏõọôốồổỗộơớờởỡợùúủũụưứừửữựỳýỷỹỵđ]', sent, re.IGNORECASE):
+        return False, sent
+
+    # Skip sentences with too many numbers (tables, lists)
+    num_digits = sum(1 for c in sent if c.isdigit())
+    if num_digits > len(sent) * 0.15:
+        return False, sent
+
+    # Skip sentences with special patterns
+    if re.match(r'^(Chương|Phần|Mục|Điều|\d+\.|\([a-z]\))', sent):
+        return False, sent
+
+    # Skip sentences with URLs or emails
+    if re.search(r'(http|www\.|@|\.com|\.vn)', sent, re.IGNORECASE):
+        return False, sent
+
+    # Skip sentences with excessive punctuation
+    punct_count = sum(1 for c in sent if c in '.,;:!?-–—()[]{}""\'\'«»')
+    if punct_count > len(words) * 1.5:
+        return False, sent
+
+    # Skip incomplete sentences (ending with ellipsis in middle)
+    if '...' in sent[:-5]:
+        return False, sent
+
+    # Skip dialogue-heavy sentences (too many quotes)
+    quote_count = sent.count('"') + sent.count('"') + sent.count('"')
+    if quote_count > 4:
+        return False, sent
+
+    return True, sent
+
+
+def classify_book(genres):
+    """Classify book as fiction or non-fiction based on genres."""
+    if not genres:
+        return None
+
+    genres_set = set(genres)
+
+    is_fiction = bool(genres_set & FICTION_GENRES)
+    is_non_fiction = bool(genres_set & NON_FICTION_GENRES)
+
+    if is_fiction and not is_non_fiction:
+        return "fiction"
+    elif is_non_fiction and not is_fiction:
+        return "non-fiction"
+    elif is_fiction and is_non_fiction:
+        # Prefer the dominant one
+        fiction_count = len(genres_set & FICTION_GENRES)
+        non_fiction_count = len(genres_set & NON_FICTION_GENRES)
+        return "fiction" if fiction_count > non_fiction_count else "non-fiction"
+
+    return None
+
+
+def extract_sentences_from_book(content, max_sentences=500):
+    """Extract high-quality sentences from book content."""
+    content = clean_text(content)
+    sentences = sent_tokenize(content)
+
+    valid_sentences = []
+    for sent in sentences:
+        is_valid, cleaned_sent = is_high_quality_sentence(sent)
+        if is_valid:
+            valid_sentences.append(cleaned_sent)
+            if len(valid_sentences) >= max_sentences:
+                break
+
+    return valid_sentences
+
+
+def fetch_and_process():
+    print("Loading UVB-v0.1 dataset from HuggingFace...")
+    ds = load_dataset("undertheseanlp/UVB-v0.1", split="train")
+
+    print(f"Total books in dataset: {len(ds)}")
+
+    # Classify books
+    fiction_books = []
+    non_fiction_books = []
+
+    for book in ds:
+        genres = book.get("genres", [])
+        rating = book.get("goodreads_rating", 0) or 0
+        num_ratings = book.get("goodreads_num_ratings", 0) or 0
+
+        # Quality filter: prefer books with good ratings
+        quality_score = rating * min(num_ratings / 100, 10)  # Weight by rating count
+
+        book_type = classify_book(genres)
+        book_info = {
+            "title": book["title"],
+            "content": book["content"],
+            "rating": rating,
+            "num_ratings": num_ratings,
+            "quality_score": quality_score,
+            "genres": genres
+        }
+
+        if book_type == "fiction":
+            fiction_books.append(book_info)
+        elif book_type == "non-fiction":
+            non_fiction_books.append(book_info)
+
+    print(f"Fiction books: {len(fiction_books)}")
+    print(f"Non-fiction books: {len(non_fiction_books)}")
+
+    # Sort by quality score (higher is better)
+    fiction_books.sort(key=lambda x: x["quality_score"], reverse=True)
+    non_fiction_books.sort(key=lambda x: x["quality_score"], reverse=True)
+
+    # Extract sentences from fiction books
+    print("\nExtracting sentences from fiction books...")
+    fiction_sentences = []
+    for i, book in enumerate(fiction_books):
+        if len(fiction_sentences) >= 8000:
+            break
+        sentences = extract_sentences_from_book(book["content"])
+        for sent in sentences:
+            if len(fiction_sentences) >= 8000:
+                break
+            fiction_sentences.append(sent)
+        print(f"  [{i+1}/{len(fiction_books)}] {book['title'][:50]} - {len(sentences)} sentences (total: {len(fiction_sentences)})")
+
+    # Extract sentences from non-fiction books
+    print("\nExtracting sentences from non-fiction books...")
+    non_fiction_sentences = []
+    for i, book in enumerate(non_fiction_books):
+        if len(non_fiction_sentences) >= 8000:
+            break
+        sentences = extract_sentences_from_book(book["content"])
+        for sent in sentences:
+            if len(non_fiction_sentences) >= 8000:
+                break
+            non_fiction_sentences.append(sent)
+        print(f"  [{i+1}/{len(non_fiction_books)}] {book['title'][:50]} - {len(sentences)} sentences (total: {len(non_fiction_sentences)})")
+
+    print(f"\nFiction sentences collected: {len(fiction_sentences)}")
+    print(f"Non-fiction sentences collected: {len(non_fiction_sentences)}")
+
+    # Combine all sentences
+    all_sentences = fiction_sentences[:8000] + non_fiction_sentences[:8000]
+    print(f"Total sentences: {len(all_sentences)}")
+
+    # Save to output file
+    output_dir = dirname(dirname(__file__))
+    output_file = join(output_dir, "sentences_uvb.txt")
+
+    with open(output_file, "w", encoding="utf-8") as f:
+        for i, sent in enumerate(all_sentences, 1):
+            source = "fiction" if i <= len(fiction_sentences[:8000]) else "non-fiction"
+            f.write(f"{i}\t{source}\t{sent}\n")
+
+    print(f"\nSaved to: {output_file}")
+
+    # Print samples
+    print("\nSample fiction sentences:")
+    for i, sent in enumerate(fiction_sentences[:3], 1):
+        print(f"  {i}. {sent[:100]}...")
+
+    print("\nSample non-fiction sentences:")
+    for i, sent in enumerate(non_fiction_sentences[:3], 1):
+        print(f"  {i}. {sent[:100]}...")
+
+
+if __name__ == "__main__":
+    fetch_and_process()

src/fetch_uvn_data.py

@@ -0,0 +1,127 @@
+"""
+Fetch data from HuggingFace dataset undertheseanlp/UVN-1
+- Get documents from news dataset
+- Segment sentences using underthesea
+- Get first 8000 sentences
+"""
+
+import re
+from os.path import dirname, join
+
+from datasets import load_dataset
+
+from underthesea import sent_tokenize, text_normalize
+
+
+def clean_text(text):
+    """Remove formatting and clean text."""
+    # Normalize Unicode using underthesea
+    text = text_normalize(text)
+    # Remove markdown headers
+    text = re.sub(r'^#+\s+', '', text, flags=re.MULTILINE)
+    # Remove bold/italic markers
+    text = re.sub(r'\*+', '', text)
+    # Remove horizontal rules
+    text = re.sub(r'^-+$', '', text, flags=re.MULTILINE)
+    # Remove links
+    text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
+    # Remove multiple newlines
+    text = re.sub(r'\n{2,}', '\n', text)
+    # Remove leading/trailing whitespace per line
+    lines = [line.strip() for line in text.split('\n')]
+    text = '\n'.join(lines)
+    return text
+
+
+def is_valid_sentence(sent):
+    """Check if sentence is valid for UD annotation."""
+    sent = sent.strip()
+
+    if not sent:
+        return False, sent
+    # Too short
+    if len(sent) < 20:
+        return False, sent
+    # Too long
+    if len(sent) > 300:
+        return False, sent
+    # Must contain Vietnamese characters
+    if not re.search(r'[àáảãạăắằẳẵặâấầẩẫậèéẻẽẹêếềểễệìíỉĩịòóỏõọôốồổỗộơớờởỡợùúủũụưứừửữựỳýỷỹỵđ]', sent, re.IGNORECASE):
+        return False, sent
+    # Skip if mostly uppercase (headers, titles)
+    if sum(1 for c in sent if c.isupper()) > len(sent) * 0.5:
+        return False, sent
+    # Skip bylines (e.g., "Theo VnExpress", "PV/Báo ...")
+    if re.match(r'^(Theo |PV |Nguồn:|Ảnh:|Video:|Bài:|Tin ảnh:)', sent):
+        return False, sent
+    # Skip photo captions (short sentences ending with source attribution)
+    if re.search(r'\(Ảnh:.*\)$', sent):
+        return False, sent
+    if re.search(r'\(Nguồn:.*\)$', sent):
+        return False, sent
+    # Skip date/time patterns at start
+    if re.match(r'^\d{1,2}/\d{1,2}/\d{4}', sent):
+        return False, sent
+    if re.match(r'^\d{1,2}:\d{2}', sent):
+        return False, sent
+    # Skip sentences with URLs
+    if re.search(r'(http|www\.|\.com|\.vn)', sent, re.IGNORECASE):
+        return False, sent
+    # Skip sentences that are just tags or categories
+    if re.match(r'^(Tags?:|Chuyên mục:|Từ khóa:)', sent, re.IGNORECASE):
+        return False, sent
+    # Skip sentences with excessive numbers (data tables)
+    num_digits = sum(1 for c in sent if c.isdigit())
+    if num_digits > len(sent) * 0.3:
+        return False, sent
+    return True, sent
+
+
+TARGET_COUNT = 8000
+
+
+def fetch_and_process():
+    # Load dataset from HuggingFace
+    print("Loading UVN-1 dataset from HuggingFace...")
+    ds = load_dataset("undertheseanlp/UVN-1", split="train")
+
+    print(f"Total articles in dataset: {len(ds)}")
+
+    # Segment sentences from all documents until we have enough
+    print("Segmenting sentences...")
+    all_sentences = []
+    for idx, doc in enumerate(ds):
+        content = doc["content"]
+        content = clean_text(content)
+        sentences = sent_tokenize(content)
+        for sent in sentences:
+            sent = sent.strip()
+            is_valid, cleaned_sent = is_valid_sentence(sent)
+            if is_valid:
+                all_sentences.append(cleaned_sent)
+        if len(all_sentences) >= TARGET_COUNT:
+            print(f"Processed {idx + 1} documents")
+            break
+
+    # Get first TARGET_COUNT sentences
+    sentences_out = all_sentences[:TARGET_COUNT]
+    print(f"Total sentences collected: {len(sentences_out)}")
+
+    # Save to output file
+    output_dir = dirname(dirname(__file__))
+    output_file = join(output_dir, "sentences_uvn.txt")
+
+    with open(output_file, "w", encoding="utf-8") as f:
+        for i, sent in enumerate(sentences_out, 1):
+            f.write(f"{i}\t{sent}\n")
+
+    print(f"Saved to: {output_file}")
+
+    # Print sample
+    print("\nSample sentences:")
+    for i, sent in enumerate(sentences_out[:5], 1):
+        print(f"  {i}. {sent[:80]}...")
+
+
+if __name__ == "__main__":
+    fetch_and_process()

src/fetch_uvw_data.py

@@ -0,0 +1,135 @@
+"""
+Fetch data from HuggingFace dataset undertheseanlp/UVW-2026
+- Get articles with quality_score >= 5
+- Segment sentences using underthesea
+- Get first 8000 sentences
+"""
+
+import re
+from os.path import dirname, join
+
+from datasets import load_dataset
+
+from underthesea import sent_tokenize, text_normalize
+
+
+def clean_text(text):
+    """Remove formatting and clean text."""
+    # Normalize Unicode using underthesea
+    text = text_normalize(text)
+    # Remove markdown headers
+    text = re.sub(r'^#+\s+', '', text, flags=re.MULTILINE)
+    # Remove bold/italic markers
+    text = re.sub(r'\*+', '', text)
+    # Remove horizontal rules
+    text = re.sub(r'^-+$', '', text, flags=re.MULTILINE)
+    # Remove links
+    text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
+    # Remove multiple newlines
+    text = re.sub(r'\n{2,}', '\n', text)
+    # Remove leading/trailing whitespace per line
+    lines = [line.strip() for line in text.split('\n')]
+    text = '\n'.join(lines)
+    return text
+
+
+def is_valid_sentence(sent):
+    """Check if sentence is valid for UD annotation."""
+    sent = sent.strip()
+
+    if not sent:
+        return False, sent
+    # Too short
+    if len(sent) < 20:
+        return False, sent
+    # Too long
+    if len(sent) > 300:
+        return False, sent
+    # Must contain Vietnamese characters
+    if not re.search(r'[àáảãạăắằẳẵặâấầẩẫậèéẻẽẹêếềểễệìíỉĩịòóỏõọôốồổỗộơớờởỡợùúủũụưứừửữựỳýỷỹỵđ]', sent, re.IGNORECASE):
+        return False, sent
+    # Skip if mostly uppercase (headers, titles)
+    if sum(1 for c in sent if c.isupper()) > len(sent) * 0.5:
+        return False, sent
+    # Skip Wikipedia stub markers
+    if re.search(r'(bài sơ khai|sơ khai về|cần được mở rộng|Thể loại:)', sent):
+        return False, sent
+    # Skip category lists
+    if re.match(r'^(Thể loại|Danh sách|Xem thêm|Tham khảo|Liên kết ngoài|Chú thích)', sent):
+        return False, sent
+    # Skip infobox remnants (pipe-separated values, key=value patterns)
+    if sent.count('|') > 2:
+        return False, sent
+    if re.search(r'\w+=\w+', sent) and sent.count('=') > 1:
+        return False, sent
+    # Skip reference fragments ([1], [cần dẫn nguồn])
+    if re.search(r'\[\d+\]', sent):
+        return False, sent
+    if re.search(r'\[cần', sent):
+        return False, sent
+    # Skip sentences with URLs
+    if re.search(r'(http|www\.|\.com|\.org)', sent, re.IGNORECASE):
+        return False, sent
+    # Skip sentences with excessive numbers (data tables)
+    num_digits = sum(1 for c in sent if c.isdigit())
+    if num_digits > len(sent) * 0.3:
+        return False, sent
+    # Skip list items starting with bullets or numbers
+    if re.match(r'^[\*\-•]\s', sent):
+        return False, sent
+    return True, sent
+
+
+TARGET_COUNT = 8000
+
+
+def fetch_and_process():
+    # Load dataset from HuggingFace
+    print("Loading UVW-2026 dataset from HuggingFace...")
+    ds = load_dataset("undertheseanlp/UVW-2026", split="train")
+
+    print(f"Total articles in dataset: {len(ds)}")
+
+    # Filter by quality score
+    print("Filtering articles by quality_score >= 5...")
+    high_quality = [doc for doc in ds if (doc.get("quality_score") or 0) >= 5]
+    print(f"High-quality articles: {len(high_quality)}")
+
+    # Segment sentences from all documents until we have enough
+    print("Segmenting sentences...")
+    all_sentences = []
+    for idx, doc in enumerate(high_quality):
+        content = doc["content"]
+        content = clean_text(content)
+        sentences = sent_tokenize(content)
+        for sent in sentences:
+            sent = sent.strip()
+            is_valid, cleaned_sent = is_valid_sentence(sent)
+            if is_valid:
+                all_sentences.append(cleaned_sent)
+        if len(all_sentences) >= TARGET_COUNT:
+            print(f"Processed {idx + 1} articles")
+            break
+
+    # Get first TARGET_COUNT sentences
+    sentences_out = all_sentences[:TARGET_COUNT]
+    print(f"Total sentences collected: {len(sentences_out)}")
+
+    # Save to output file
+    output_dir = dirname(dirname(__file__))
+    output_file = join(output_dir, "sentences_uvw.txt")
+
+    with open(output_file, "w", encoding="utf-8") as f:
+        for i, sent in enumerate(sentences_out, 1):
+            f.write(f"{i}\t{sent}\n")
+
+    print(f"Saved to: {output_file}")
+
+    # Print sample
+    print("\nSample sentences:")
+    for i, sent in enumerate(sentences_out[:5], 1):
+        print(f"  {i}. {sent[:80]}...")
+
+
+if __name__ == "__main__":
+    fetch_and_process()

src/upload_to_hf.py

@@ -0,0 +1,119 @@
+"""
+Upload UD dataset to HuggingFace Hub.
+Dataset: undertheseanlp/UDD-v0.1
+
+Loads train/dev/test JSONL splits and uploads as DatasetDict with domain field.
+
+Usage:
+    export $(cat .env | xargs) && python upload_to_hf.py
+"""
+
+import json
+import os
+from os.path import expanduser, join
+
+from datasets import Dataset, DatasetDict
+from huggingface_hub import HfApi, login
+
+
+# Sent_id prefix -> domain mapping
+DOMAIN_MAP = {
+    "vlc-": "legal",
+    "uvn-": "news",
+    "uvw-": "wikipedia",
+    "uvb-f-": "fiction",
+    "uvb-n-": "non-fiction",
+}
+
+
+def get_domain(sent_id):
+    """Extract domain from sent_id prefix."""
+    for prefix, domain in DOMAIN_MAP.items():
+        if sent_id.startswith(prefix):
+            return domain
+    return "unknown"
+
+
+def load_jsonl(filepath):
+    """Load JSONL file and add domain field."""
+    data = []
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            row = json.loads(line)
+            row["domain"] = get_domain(row.get("sent_id", ""))
+            data.append(row)
+    return data
+
+
+def main():
+    # Login with token from environment
+    token = os.environ.get("HF_TOKEN")
+    if token:
+        print("Logging in with HF_TOKEN...")
+        login(token=token)
+    else:
+        print("Warning: HF_TOKEN not set. Using cached credentials.")
+
+    source_folder = expanduser("~/Downloads/UD_Vietnamese-UUD-v0.1")
+    readme_file = join(source_folder, "README.md")
+
+    # Load all splits
+    splits = {}
+    for split_name, filename in [("train", "train.jsonl"), ("validation", "dev.jsonl"), ("test", "test.jsonl")]:
+        filepath = join(source_folder, filename)
+        if os.path.isfile(filepath):
+            print(f"Loading {split_name} from {filepath}...")
+            data = load_jsonl(filepath)
+            splits[split_name] = Dataset.from_list(data)
+            print(f"  {split_name}: {len(data)} sentences")
+        else:
+            print(f"Warning: {filepath} not found, skipping {split_name} split")
+
+    if not splits:
+        print("Error: No data files found!")
+        return
+
+    # Create DatasetDict
+    print("\nCreating HuggingFace DatasetDict...")
+    dataset_dict = DatasetDict(splits)
+
+    print(f"Dataset: {dataset_dict}")
+    for split_name, ds in dataset_dict.items():
+        print(f"  {split_name}: {len(ds)} rows, features: {list(ds.features.keys())}")
+
+    # Print domain distribution
+    for split_name, ds in dataset_dict.items():
+        domains = {}
+        for row in ds:
+            d = row["domain"]
+            domains[d] = domains.get(d, 0) + 1
+        domain_str = ", ".join(f"{d}: {c}" for d, c in sorted(domains.items()))
+        print(f"  {split_name} domains: {domain_str}")
+
+    # Push to HuggingFace Hub
+    repo_id = "undertheseanlp/UDD-v0.1"
+    print(f"\nPushing to HuggingFace Hub: {repo_id}")
+
+    dataset_dict.push_to_hub(
+        repo_id,
+        private=False,
+        commit_message="Update: 40K sentences from 5 domains (legal, news, wikipedia, fiction, non-fiction)"
+    )
+
+    # Upload README.md
+    if os.path.isfile(readme_file):
+        print("Uploading README.md...")
+        api = HfApi()
+        api.upload_file(
+            path_or_fileobj=readme_file,
+            path_in_repo="README.md",
+            repo_id=repo_id,
+            repo_type="dataset",
+            commit_message="Update README with dataset card"
+        )
+
+    print(f"\nDone! Dataset available at: https://huggingface.co/datasets/{repo_id}")
+
+
+if __name__ == "__main__":
+    main()