Add word segmentation dataset pipeline and technical report v1.1

- Add src/fetch_ws_sentences.py: fetches 100K sentences (20K × 5 domains)
from HuggingFace datasets with domain-specific quality filters
- Add src/build_ws_dataset.py: converts sentences to BIO format (VLSP 2013
compatible) with stratified 80/10/10 train/dev/test splits
- Add src/ws_statistics.py: computes dataset statistics and converts BIO
files to CoNLL-U format
- Update CLAUDE.md with WS dataset pipeline documentation
- Add TECHNICAL_REPORT_1.1.md: documents udd-ws-v1.1 dataset and proposes
active learning framework for gold-standard Vietnamese UD annotation
with solo annotator setting and task-specific AL strategies for WS,
POS tagging, and dependency parsing

CLAUDE.md

@@ -37,6 +37,8 @@ UDD-1 (Universal Dependency Dataset for Vietnamese) is a Vietnamese Universal De
 | `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`) |
+| `src/fetch_ws_sentences.py` | Fetch 100K sentences (20K × 5 domains) for word segmentation dataset → `ws_sentences_*.txt` |
+| `src/build_ws_dataset.py` | Convert sentences to BIO format via `word_tokenize` + `regex_tokenize` → `ws_{train,dev,test}.txt` |
 
 ## Pipeline Commands
 
@@ -86,6 +88,23 @@ export HF_TOKEN=<token>
 python src/upload_to_hf.py
 ```
 
+### Word Segmentation Dataset Pipeline
+
+Separate pipeline producing a 100K-sentence BIO-tagged dataset (VLSP 2013 compatible) for CRF word segmentation training in tree-1.
+
+```bash
+# Step 1: Fetch 20K sentences per domain (100K total)
+uv run src/fetch_ws_sentences.py
+# → ws_sentences_vlc.txt, ws_sentences_uvn.txt, ws_sentences_uvw.txt,
+#   ws_sentences_uvb_f.txt, ws_sentences_uvb_n.txt
+
+# Step 2: Convert to BIO format with stratified 80/10/10 split
+uv run src/build_ws_dataset.py
+# → udd-ws-v1.1-train.txt (~80K), udd-ws-v1.1-dev.txt (~10K), udd-ws-v1.1-test.txt (~10K)
+```
+
+Output BIO format (`syllable\tB-W` / `syllable\tI-W`, blank line between sentences) is compatible with tree-1's `load_data_vlsp2013()` which maps `B-W→B`, `I-W→I`.
+
 ## Architecture Notes
 
 ### Conversion Pipeline (`convert_to_ud.py`)

TECHNICAL_REPORT_1.1.md

@@ -0,0 +1,519 @@
+# UDD-1 v1.1: Toward a Gold-Standard Vietnamese Universal Dependencies Treebank via Active Learning
+
+**Underthesea NLP**
+
+## Abstract
+
+UDD-1 v1.0 established a 10,000-sentence silver-standard Vietnamese UD treebank from the legal domain. Version 1.1 takes two steps toward gold-standard annotation. First, we scale the data foundation: a multi-domain word segmentation dataset of 100,000 sentences in BIO format (VLSP-compatible) across 5 domains (legal, news, Wikipedia, fiction, non-fiction), enabling training of robust word segmentation models that form the prerequisite for accurate dependency parsing. Second, we lay out a concrete active learning framework for constructing a gold-standard Vietnamese UD treebank under a **solo annotator** setting, with task-specific AL strategies for word segmentation (CRF marginal uncertainty), POS tagging (tag confusion targeting), and dependency parsing (head entropy with partial arc annotation). The pipeline is estimated at ~100 annotator-days to produce 2,000 gold WS, 1,000 gold POS, and 800--1,000 gold DP sentences.
+
+Beyond gold annotation, a central goal of this work is the co-development of **standardized Vietnamese annotation guidelines** for the three core NLP tasks: word segmentation, POS tagging, and dependency parsing. Vietnamese currently lacks a unified, publicly available annotation standard that covers all three tasks consistently. Existing guidelines are fragmented --- the VLSP 2013 shared task defined word segmentation conventions, the NIIVTB project (Nguyen et al., 2018) established 9 rules for word boundary decisions, and UD_Vietnamese-VTB provides limited language-specific UD guidelines --- but no single resource integrates them into a coherent annotation framework. Through the active learning loop, where the most ambiguous and informative examples are systematically surfaced, we develop comprehensive Vietnamese annotation guidelines that address language-specific phenomena (copula *là*, passive markers *được/bị*, serial verb constructions, classifier phrases, topic-comment structure) with explicit decision procedures, worked examples, and cross-task consistency. These guidelines are intended as a reusable community resource for future Vietnamese treebank and dataset construction.
+
+This report documents the word segmentation dataset (udd-ws-v1.1), the active learning roadmap, and the guideline development methodology.
+
+## 1. Introduction
+
+### 1.1 Motivation
+
+The TECHNICAL_REPORT_REVIEW of UDD-1 v1.0 identified a clear path forward:
+
+> *"Could you run the Underthesea parser on 50-100 sentences from the legal corpus that have been manually annotated by a Vietnamese linguist, to report in-domain LAS/UAS? This single addition would move the paper from borderline to solid accept."*
+
+More broadly, the review highlighted three priorities: (1) gold-standard evaluation of annotation quality, (2) reduction of the 8.6% UPOS-forcing artifact rate, and (3) multi-domain coverage beyond the legal domain. Version 1.1 addresses all three through a two-pronged strategy:
+
+- **Word segmentation dataset (udd-ws-v1.1)**: A 100K-sentence, 5-domain BIO-tagged dataset that provides the training data for robust word segmentation --- the first step in the Vietnamese NLP pipeline (WS → POS → DP).
+- **Active learning framework**: A systematic plan to construct gold-standard UD annotations efficiently, using the silver-standard data as a starting point and selectively correcting the most informative errors.
+
+### 1.2 Overview of Contributions
+
+| Contribution | Status | Description |
+|---|---|---|
+| udd-ws-v1.1 dataset | Planned | 100K sentences, 5 domains, BIO format, stratified splits |
+| Active learning literature survey | Planned | 35 papers covering AL for parsing, treebank construction, guidelines |
+| Vietnamese WS annotation guidelines | Planned | NIIVTB 9-rule framework adapted for UDD-1 |
+| AL framework design | This report | Concrete plan for gold-standard UD annotation |
+| Gold-standard annotation | Planned | Target: 2-5K sentences via active learning |
+
+## 2. Word Segmentation Dataset: udd-ws-v1.1
+
+### 2.1 Rationale
+
+Word segmentation is the foundation of Vietnamese NLP. The dependency parser in UDD-1 v1.0 uses an implicit tokenizer that produces segmentation errors propagating to all downstream annotations (Section 5.6 of TECHNICAL_REPORT.md). Building a dedicated word segmentation dataset enables:
+
+1. Training domain-robust CRF word segmentation models (tree-1 pipeline)
+2. Evaluating segmentation quality across domains independently of the parser
+3. Providing a clean input pipeline for future gold-standard UD annotation
+
+### 2.2 Data Collection
+
+Sentences are drawn from 4 HuggingFace datasets, the same sources as UDD-1 v1.0 but scaled to 20,000 sentences per domain:
+
+| Domain | Source Dataset | Sentences | Sent ID Prefix |
+|--------|---------------|-----------|----------------|
+| Legal | `undertheseanlp/UTS_VLC` | 20,000 | `vlc-` |
+| News | `undertheseanlp/UVN-1` | 20,000 | `uvn-` |
+| Wikipedia | `undertheseanlp/UVW-2026` | 20,000 | `uvw-` |
+| Fiction | `undertheseanlp/UVB-v0.1` | 20,000 | `uvb-f-` |
+| Non-fiction | `undertheseanlp/UVB-v0.1` | 20,000 | `uvb-n-` |
+| **Total** | | **100,000** | |
+
+**Table 1**: Domain breakdown of udd-ws-v1.1.
+
+Each domain applies the same quality filters as UDD-1 v1.0 (see `guidelines/00. Sentence Selection.md`), with books applying stricter criteria (30-250 chars, 5-40 words, must start uppercase and end with punctuation).
+
+### 2.3 BIO Annotation
+
+Sentences are converted to syllable-level BIO format using:
+
+1. `underthesea.word_tokenize(sentence, format="text")` → compound tokens with underscores (e.g., `"Việt_Nam là một quốc_gia"`)
+2. `underthesea.pipeline.word_tokenize.regex_tokenize.tokenize()` → syllable splitting
+3. First syllable of each token → `B-W`, continuation syllables → `I-W`
+
+Output format (VLSP 2013 compatible, tab-separated with comment headers):
+
+```
+# sent_id = vlc-1
+# text = Một doanh nghiệp lớn hoạt động hiệu quả .
+Một	B-W
+doanh	B-W
+nghiệp	I-W
+lớn	B-W
+hoạt	B-W
+động	I-W
+hiệu	B-W
+quả	I-W
+.	B-W
+```
+
+This format is directly loadable by tree-1's `load_data_vlsp2013()` function, which maps `B-W → B`, `I-W → I`.
+
+### 2.4 Dataset Statistics
+
+| | Train | Dev | Test | Total |
+|---|---:|---:|---:|---:|
+| Sentences | 80,000 | 10,000 | 10,000 | 100,000 |
+| Words | 1,592,531 | 201,565 | 197,832 | 1,991,928 |
+| Syllables | 2,087,103 | 263,953 | 259,338 | 2,610,394 |
+| Avg word/sent | 19.91 | 20.16 | 19.78 | 19.92 |
+| Avg syl/sent | 26.09 | 26.40 | 25.93 | 26.10 |
+| Avg syl/word | 1.31 | 1.31 | 1.31 | 1.31 |
+
+**Table 2**: udd-ws-v1.1 split statistics.
+
+Splits are stratified by domain (each domain contributes exactly 20% to every split) with random seed 42 for reproducibility.
+
+### 2.5 Word Length Distribution
+
+| Syllables per word | Count | Percentage |
+|:---:|---:|---:|
+| 1 | 1,403,963 | 70.48% |
+| 2 | 564,634 | 28.35% |
+| 3 | 17,820 | 0.89% |
+| 4 | 4,384 | 0.22% |
+| 5+ | 1,127 | 0.06% |
+
+**Table 3**: Word length distribution across the full dataset.
+
+The distribution is consistent with Vietnamese linguistics: ~70% single-syllable words, ~28% two-syllable compounds, and ~2% longer compounds. The 1.31 average syllables per word aligns with the 1.38 figure reported for legal text in SEGMENTATION_EVAL.md (the difference reflecting the inclusion of less formal fiction/non-fiction domains).
+
+### 2.6 Silver-Standard Caveat
+
+The BIO annotations are generated automatically by `underthesea.word_tokenize()` and inherit its segmentation biases. SEGMENTATION_EVAL.md documents known issues including 462 over-segmented dictionary words (7,373 occurrences) and 382 potentially under-segmented tokens. The dataset is a silver-standard resource suitable for CRF training but not for evaluation of segmentation quality. A gold-standard evaluation subset is planned as part of the active learning framework (Section 3).
+
+## 3. Active Learning Framework for Gold-Standard UD Annotation
+
+### 3.1 Goal
+
+Construct a **gold-standard** Vietnamese UD treebank of 2,000--5,000 sentences with verified word segmentation, POS tags, and dependency relations, sufficient to:
+
+1. Report in-domain LAS/UAS on legal and multi-domain text
+2. Serve as evaluation data for parser development
+3. Serve as seed training data for active-learning-boosted parsers
+4. Establish Vietnamese-specific UD annotation guidelines through the annotation process
+
+### 3.2 Solo Annotator Setting
+
+This project operates under a **solo annotator** constraint: a single Vietnamese linguist performs all annotation. This is a realistic setting for under-resourced languages where trained annotators are scarce. The solo setting has specific implications:
+
+- **No inter-annotator agreement (IAA)**: Quality is ensured through consistency checks, model-based error detection, and guideline self-auditing rather than dual annotation.
+- **Consistency advantage**: A single annotator produces internally consistent annotations, avoiding the reconciliation overhead of multi-annotator setups.
+- **Anchoring risk**: The annotator corrects silver-standard pre-annotations, creating anchoring bias toward the parser's output. Mitigation: guidelines explicitly instruct the annotator to evaluate each decision independently; periodic blind re-annotation of 5% of sentences to measure self-consistency.
+- **Throughput**: One annotator correcting pre-annotated data can process 50--100 sentences/day for word segmentation, 30--50 for POS, and 15--30 for dependency parsing (estimates from Brants & Skut 1998, adjusted for Vietnamese complexity).
+
+**Quality assurance without IAA**:
+
+| Method | Purpose | Frequency |
+|--------|---------|-----------|
+| Self-consistency check | Re-annotate 5% of completed sentences blind | Every 200 sentences |
+| Model-based error detection | Flag arcs where retrained model disagrees with gold | After each AL cycle |
+| Dictionary validation | Cross-check WS against Viet74K dictionary | Continuous |
+| UD validator | Automated structural constraint checking | After each batch |
+| Guideline self-audit | Review decisions against written guidelines | Weekly |
+
+**Table 4**: Quality assurance methods for solo annotator setting.
+
+### 3.3 Why Active Learning
+
+Manual annotation of dependency treebanks is expensive. Brants & Skut (1998) showed that correcting pre-annotated data is 3--5x faster than annotation from scratch. Active learning further reduces cost by selecting the most informative examples for annotation.
+
+The literature (surveyed in `active_learning/references/research_active_learning_ud/`) demonstrates:
+
+| Method | Cost Reduction | Reference |
+|--------|---------------|-----------|
+| Uncertainty sampling | ~50% fewer sentences | Hwa (2004) |
+| Head entropy + partial annotation | 40--60% less arc annotation | Li et al. (2016) |
+| DPP batch diversity + uncertainty | ~20--30% fewer sentences | Shi et al. (2021) |
+| Partial annotation + self-training | Best cost reduction across 4 tasks | Zhang et al. (2023) |
+
+**Table 5**: Active learning cost reduction benchmarks from the literature.
+
+UDD-1's situation is particularly favorable for AL: we already have 100K silver-standard sentences that can serve as the initial model's training data and as candidates for selective correction.
+
+### 3.4 Three-Task Active Learning Pipeline
+
+The Vietnamese NLP pipeline is sequential: **Word Segmentation → POS Tagging → Dependency Parsing**. Each task depends on the output of the previous one, so errors cascade. We apply active learning independently to each task with task-specific strategies, proceeding in pipeline order.
+
+```
+  ┌─────────────────────────────────────────────────────────────────┐
+  │                  Task 1: Word Segmentation                      │
+  │                                                                 │
+  │  Silver data ──► Train CRF ──► Score uncertainty ──► Annotate  │
+  │  (100K BIO)      (tree-1)      (token marginals)     (correct  │
+  │                                                       BIO tags) │
+  │                       ◄──── Retrain ◄──── Gold WS data         │
+  └───────────────────────────────┬─────────────────────────────────┘
+                                  │ Gold-segmented sentences
+  ┌───────────────────────────────▼─────────────────────────────────┐
+  │                  Task 2: POS Tagging                             │
+  │                                                                 │
+  │  Silver POS ──► Train CRF ──► Score uncertainty ──► Annotate   │
+  │  (auto-tagged)   (tree-1)     (tag marginals)      (correct    │
+  │                                                      UPOS tags) │
+  │                       ◄──── Retrain ◄──── Gold POS data        │
+  └───────────────────────────────┬─────────────────────────────────┘
+                                  │ Gold-segmented + Gold-POS sentences
+  ┌───────────────────────────────▼─────────────────────────────────┐
+  │                  Task 3: Dependency Parsing                      │
+  │                                                                 │
+  │  Silver DP ──► Train parser ──► Score uncertainty ──► Annotate  │
+  │  (auto-parsed)  (biaffine)     (head entropy)       (correct   │
+  │                                                      arcs +     │
+  │                                                      deprels)   │
+  │                       ◄──── Retrain ◄──── Gold DP data         │
+  └─────────────────────────────────────────────────────────────────┘
+```
+
+### 3.5 Task 1: Active Learning for Word Segmentation
+
+**Objective**: Build a gold-standard word segmentation evaluation set and improve the CRF segmenter through targeted correction of silver BIO data.
+
+**Starting point**: 100K silver BIO sentences (udd-ws-v1.1), CRF model trained on this data (tree-1, 98.90% syllable F1 on silver test set).
+
+#### 3.5.1 Query Strategy: Token-Level Marginal Uncertainty
+
+CRF models produce marginal probabilities for each token's label. For word segmentation, the uncertainty of a token at position $i$ is:
+
+$$u_i = 1 - \max(P(\text{B-W}|x, i),\ P(\text{I-W}|x, i))$$
+
+**Sentence-level score**: average uncertainty across all tokens in the sentence, weighted by the number of multi-syllable word boundaries (positions where a B-W/I-W decision is non-trivial).
+
+**Selection protocol**:
+1. Train CRF on udd-ws-v1.1-train (80K silver sentences)
+2. Predict on udd-ws-v1.1-dev + udd-ws-v1.1-test (20K sentences) with marginal probabilities
+3. Rank sentences by aggregated token uncertainty
+4. Select top-N sentences stratified by domain (equal representation)
+5. Additionally select sentences containing known error patterns from SEGMENTATION_EVAL.md:
+   - Sentences with tokens matching the 462 over-segmented dictionary words
+   - Sentences with tokens matching the 382 under-segmented candidates
+   - Sentences with 4+ syllable tokens (potential under-segmentation)
+
+#### 3.5.2 Annotation Procedure
+
+The annotator corrects BIO tags in a text editor (or annotation tool), focusing on word boundaries:
+
+1. **Review pre-annotated BIO output** with uncertain tokens highlighted
+2. **Correct boundaries** using the NIIVTB 9-rule framework (see `ANNOTATION_GUIDELINE_WORD_SEGMENTATION.md`):
+   - Rule 1 (Insertability test): Can another word be inserted between syllables?
+   - Rule 2 (Semantic opacity): Is the meaning compositional?
+   - Rules 3--9: Additional criteria for specific constructions
+3. **Flag ambiguous cases** for guideline development
+
+**Batch size**: 500 sentences per AL cycle (solo annotator, ~1--2 days of work).
+
+#### 3.5.3 AL Cycle for Word Segmentation
+
+| Cycle | Sentences | Cumulative Gold | Focus |
+|-------|-----------|----------------|-------|
+| 0 (Baseline) | 0 | 0 | Train CRF on 80K silver |
+| 1 | 500 | 500 | Highest uncertainty + known error patterns |
+| 2 | 500 | 1,000 | Retrained CRF's new uncertain tokens |
+| 3 | 500 | 1,500 | Domain-specific compounds, remaining errors |
+| 4 | 500 | 2,000 | Diminishing returns check; stop if F1 plateaus |
+
+**Stopping criterion**: Stop when the CRF retrained on silver+gold data achieves <0.1% F1 improvement on a held-out gold test set (200 sentences set aside from Cycle 1).
+
+**Expected outcome**: 2,000 gold WS sentences, CRF word F1 improvement from ~98.0% to >99%.
+
+### 3.6 Task 2: Active Learning for POS Tagging
+
+**Objective**: Build gold POS annotations on the gold-segmented sentences from Task 1, and improve the CRF POS tagger.
+
+**Starting point**: Gold-segmented sentences from Task 1. Silver POS tags from `underthesea.pos_tag()`, mapped to UPOS via `UPOS_MAP`. CRF POS tagger (tree-1, 95.89% accuracy on silver UDD-1).
+
+**Dependency on Task 1**: POS tagging operates on correctly segmented words. Only sentences with verified word segmentation from Task 1 enter the POS annotation pool.
+
+#### 3.6.1 Query Strategy: Tag Marginal Uncertainty + Confusion-Targeted Selection
+
+CRF POS taggers produce marginal probabilities over the 15 UPOS tags for each token. Two complementary selection criteria:
+
+**Criterion A — Token uncertainty**:
+$$u_i = 1 - \max_t P(t|x, i), \quad t \in \{\text{ADJ, ADP, ADV, ..., X}\}$$
+
+Sentence score = average of top-K most uncertain tokens (not all tokens, to avoid penalizing long easy sentences).
+
+**Criterion B — Confusion-targeted selection**: Prioritize sentences containing tokens from known confusion pairs identified in v1.0:
+- **AUX vs. VERB**: *được*, *bị*, *phải*, *có thể* (20 auxiliary words with dual function)
+- **NOUN vs. VERB**: Vietnamese words frequently function as both (e.g., *quy định* "regulation"/"to regulate")
+- **ADJ vs. VERB**: Stative verbs vs. adjectives (e.g., *đẹp* "beautiful/to be beautiful")
+- **DET vs. PRON**: *này*, *đó*, *nào* (deictic function)
+- **ADP vs. SCONJ**: *khi*, *vì*, *do* (preposition vs. subordinator)
+
+**Selection formula**: Score = $\alpha \cdot \text{uncertainty} + (1-\alpha) \cdot \text{confusion\_density}$, where confusion density is the proportion of tokens matching known confusion pairs. $\alpha = 0.6$ to favor uncertainty while ensuring coverage of systematic errors.
+
+#### 3.6.2 Annotation Procedure
+
+The annotator corrects UPOS tags on gold-segmented sentences:
+
+1. **Review silver UPOS tags** with uncertain and confusion-pair tokens highlighted
+2. **Correct tags** by examining each highlighted token in sentential context:
+   - For AUX/VERB: Apply the AUX word list + syntactic function test (does it modify another verb?)
+   - For NOUN/VERB: Apply the *có thể* test (can *có thể* "can" be inserted before it? → VERB)
+   - For ADJ/VERB: Apply the *rất* test (can *rất* "very" modify it? → ADJ)
+3. **Record XPOS** if the XPOS-UPOS mismatch is justified (functional reclassification) vs. an error
+4. **Do not consider dependency relations**: POS is annotated independently of deprel to break the UPOS-forcing cycle from v1.0
+
+#### 3.6.3 AL Cycle for POS Tagging
+
+| Cycle | Sentences | Cumulative Gold | Focus |
+|-------|-----------|----------------|-------|
+| 0 (Baseline) | 0 | 0 | Evaluate CRF POS on gold-segmented sentences |
+| 1 | 300 | 300 | Highest uncertainty + AUX/VERB confusion |
+| 2 | 300 | 600 | Retrained model's new errors + NOUN/VERB confusion |
+| 3 | 200 | 800 | Remaining confusion pairs, domain-specific terms |
+| 4 | 200 | 1,000 | Diminishing returns check |
+
+**Stopping criterion**: Stop when POS accuracy on held-out gold test set (100 sentences) improves <0.2% per cycle.
+
+**Expected outcome**: 1,000 gold POS sentences, UPOS accuracy improvement from ~95.9% to >97%, elimination of the UPOS-forcing artifact.
+
+### 3.7 Task 3: Active Learning for Dependency Parsing
+
+**Objective**: Build gold dependency annotations on sentences with verified WS and POS, producing the first in-domain LAS/UAS measurements for Vietnamese legal and multi-domain text.
+
+**Starting point**: Sentences with gold WS + gold POS from Tasks 1--2. Silver dependency arcs from `underthesea.dependency_parse()`. Biaffine parser (~76% LAS on VLSP 2020 news benchmark).
+
+**Dependency on Tasks 1--2**: Only sentences with verified WS and POS enter the DP annotation pool. This ensures that measured LAS/UAS reflects parsing quality, not cascading tokenization or POS errors.
+
+#### 3.7.1 Query Strategy: Head Entropy + Partial Arc Annotation
+
+Dependency parsing has the highest annotation cost per sentence (each token requires a head and a deprel). Following Li et al. (2016), we use **partial annotation** to minimize effort: within each selected sentence, the annotator only corrects arcs that the parser is uncertain about.
+
+**Head entropy** for token $i$ with possible heads $h \in \{0, 1, ..., n\}$:
+
+$$H_i = -\sum_{h} P(h|x, i) \log P(h|x, i)$$
+
+This requires a probabilistic parser that outputs head distributions. We use a biaffine parser (Dozat and Manning, 2017) trained on UDD-1 silver data + VLSP 2020, which naturally produces attention scores convertible to probabilities via softmax.
+
+**Sentence selection**: DPP (Determinantal Point Process) batch selection (Shi et al., 2021) combining:
+- **Informativeness**: Sum of head entropy across tokens → selects uncertain sentences
+- **Diversity**: PhoBERT sentence embeddings as the DPP kernel → selects structurally diverse sentences
+- **Domain balance**: Equal quota per domain (legal, news, Wikipedia, fiction, non-fiction)
+
+**Arc selection within sentences**: For each selected sentence, mark arcs where $H_i > \tau$ (threshold determined from validation set, typically keeping the top 30--40% most uncertain arcs). The annotator focuses on these arcs while accepting the parser's output for confident arcs.
+
+#### 3.7.2 Annotation Procedure
+
+The annotator corrects dependency arcs using a tree visualization tool (e.g., Arborator-Grew or ConlluEditor):
+
+1. **View the full parse tree** with uncertain arcs highlighted (red = high entropy, green = confident)
+2. **For each uncertain arc**, decide:
+   - **Head**: Which word does this token depend on? (click to reassign)
+   - **Deprel**: What is the relation? (select from dropdown of 37 UD base types)
+3. **Verify confident arcs only if they look wrong** — the annotator can skip green arcs but is encouraged to scan for obvious errors
+4. **Apply Vietnamese-specific decisions** using the evolving guideline document:
+   - Copula *là*: `cop` when linking subject to predicate nominal, `mark` in cleft constructions
+   - Passive *được/bị*: `aux:pass` when modifying another verb, `root`/`xcomp` when main verb
+   - Serial verbs: second verb as `xcomp` or `conj` depending on shared arguments
+   - Classifiers: `clf` (UD v2 subtype) for numeral-classifier-noun constructions
+   - Topic fronting: `dislocated` when the fronted NP is resumed by a pronoun, `nsubj` otherwise
+
+#### 3.7.3 AL Cycle for Dependency Parsing
+
+| Cycle | Sentences | Arcs Annotated (est.) | Cumulative Gold | Focus |
+|-------|-----------|----------------------|----------------|-------|
+| 0 (Baseline) | 0 | 0 | 0 | Evaluate parser on VLSP 2020 test |
+| 1 (Pilot) | 50 | ~500 (all arcs) | 50 | Full annotation; establish LAS/UAS baseline on legal text; bootstrap guidelines |
+| 2 | 200 | ~800 (partial) | 250 | High-entropy arcs only; focus on nsubj/obj/obl attachment errors |
+| 3 | 200 | ~800 (partial) | 450 | Coordination, subordination, relative clause errors |
+| 4 | 200 | ~800 (partial) | 650 | Multi-domain expansion (news, wiki, books) |
+| 5 | 150 | ~600 (partial) | 800 | Domain-specific constructions, long sentences |
+| 6+ | 100/cycle | ~400/cycle | 1,000+ | Continue until LAS improvement plateaus |
+
+**Cycle 1 is special**: The first 50 sentences are fully annotated (all arcs, not just uncertain ones) to establish a reliable gold test set and measure the initial parser's in-domain LAS/UAS. This addresses the primary reviewer request.
+
+**Stopping criterion**: Stop when retrained parser's LAS on the gold test set (50 sentences from Cycle 1) improves <0.5% per cycle, or when the annotator reports that most uncertain arcs are genuinely ambiguous (guideline-level issues rather than parser errors).
+
+**Expected outcome**: 800--1,000 gold DP sentences with ~3,000--4,000 verified arcs. First reported in-domain LAS/UAS for Vietnamese legal text and multi-domain text.
+
+### 3.8 Cross-Task Annotation Flow
+
+The three tasks are executed sequentially with overlap. As Task 1 produces gold-segmented sentences, they flow into Task 2; as Task 2 produces gold-POS sentences, they flow into Task 3.
+
+```
+Week:   1    2    3    4    5    6    7    8    9   10   11   12
+       ├────┼────┼────┼────┼────┼────┼────┼────┼────┼────┼────┤
+Task 1: ████████████████████
+         WS Cycle 1-4 (2K sentences)
+Task 2:           ██████████████████
+                   POS Cycle 1-4 (1K sentences)
+Task 3:                     ████████████████████████████
+                             DP Cycle 1-6+ (800-1K sentences)
+Guidelines: ◆───────◆───────◆───────◆───────◆───────◆
+            v0.1    v0.2    v0.3    v0.4    v0.5    v1.0
+```
+
+**Overlap**: Task 2 can begin once Task 1 has produced its first 500 gold sentences (Cycle 1). Task 3 can begin once Task 2 has produced its first 300 gold sentences. This overlap reduces total calendar time from ~18 weeks (sequential) to ~12 weeks.
+
+### 3.9 Guideline Development (Solo Annotator)
+
+Without a second annotator for IAA, guidelines evolve through a **self-audit** process:
+
+| Cycle | Guideline Action | Quality Check |
+|-------|-----------------|---------------|
+| WS Cycle 1 | Draft WS guidelines from NIIVTB 9 rules | Dictionary validation of all corrections |
+| WS Cycle 2 | Revise WS guidelines based on encountered edge cases | Re-annotate 25 sentences from Cycle 1 blind; measure self-consistency |
+| POS Cycle 1 | Draft POS guidelines (confusion pairs, AUX list) | Model-based error detection on corrected data |
+| POS Cycle 2 | Revise POS guidelines | Re-annotate 15 sentences from Cycle 1 |
+| DP Cycle 1 | Draft DP guidelines (pilot, 50 full sentences) | UD validator on all sentences |
+| DP Cycle 3 | Major guideline revision after 450 sentences | Re-annotate 25 sentences from Cycles 1--2 |
+| Final | Consolidate all guidelines into single document | Full self-consistency audit on 100 random sentences |
+
+**Self-consistency target**: >95% agreement between original and re-annotation on the same sentences. Disagreements indicate guideline ambiguities that need resolution.
+
+Vietnamese-specific challenges requiring guideline development:
+1. **Copula `là`**: Multiple syntactic functions (copula, focus marker, relative clause marker)
+2. **Passive markers `được/bị`**: AUX vs. main VERB distinction is context-dependent
+3. **Serial verb constructions**: Common in Vietnamese; requires explicit deprel convention
+4. **Classifier constructions**: Numeral-classifier-noun patterns need specific annotation rules
+5. **Topic-comment structure**: Vietnamese allows topic fronting; affects nsubj vs. dislocated
+6. **Legal domain vocabulary**: Terms like *điều*, *khoản*, *mục* have specific syntactic roles
+
+### 3.10 Quality Targets
+
+| Metric | v1.0 (Silver) | v1.1 Target (Gold Subset) |
+|--------|--------------|---------------------------|
+| Word segmentation F1 | Unknown (same as underthesea) | >98% (gold test) |
+| UPOS accuracy | ~91.4% (8.6% forced) | >97% (gold test) |
+| LAS | ~76% (news benchmark) | Measured on legal + multi-domain |
+| UAS | Unknown | Measured on legal + multi-domain |
+| Self-consistency | N/A | >95% on re-annotation |
+| Gold WS sentences | 0 | 2,000 |
+| Gold POS sentences | 0 | 1,000 |
+| Gold DP sentences | 0 | 800--1,000 |
+
+**Table 6**: Quality targets for v1.1 gold annotation.
+
+### 3.11 Cost Estimation (Solo Annotator)
+
+| Task | Sentences | Est. Speed | Est. Days | Calendar Weeks |
+|------|-----------|-----------|-----------|----------------|
+| WS (4 cycles × 500) | 2,000 | 80 sent/day | 25 days | 5 weeks |
+| POS (4 cycles × 250) | 1,000 | 40 sent/day | 25 days | 5 weeks |
+| DP Pilot (full) | 50 | 15 sent/day | 3 days | 1 week |
+| DP Partial (5 cycles × 150--200) | 750--1,000 | 25 sent/day | 30--40 days | 6--8 weeks |
+| Guideline development | — | — | 10 days | distributed |
+| Self-consistency audits | ~200 re-annotated | — | 5 days | distributed |
+| **Total** | | | **~100 days** | **~12 weeks (with overlap)** |
+
+**Table 7**: Cost estimation for solo annotator.
+
+The partial annotation strategy for dependency parsing (annotating only ~40% of arcs per sentence) reduces DP annotation effort by approximately 60% compared to full annotation, consistent with Li et al. (2016). Total effort of ~100 annotator-days is feasible for a single linguist working full-time over 3 months, or part-time over 6 months.
+
+## 4. Data Format and Access
+
+### 4.1 Word Segmentation Dataset (udd-ws-v1.1)
+
+**Files** (local, UDD-1 repository):
+- `udd-ws-v1.1-train.txt` — 80,000 sentences (19 MB)
+- `udd-ws-v1.1-dev.txt` — 10,000 sentences (2.5 MB)
+- `udd-ws-v1.1-test.txt` — 10,000 sentences (2.4 MB)
+- `udd-ws-v1.1-{train,dev,test}.conllu` — CoNLL-U format (words as tokens)
+
+**Format**: BIO text with comment headers (VLSP 2013 compatible):
+```
+# sent_id = uvn-1234
+# text = Original sentence text here
+syllable1	B-W
+syllable2	I-W
+syllable3	B-W
+```
+
+### 4.2 Pipeline Scripts
+
+| Script | Purpose | Command |
+|--------|---------|---------|
+| `src/fetch_ws_sentences.py` | Fetch 100K sentences from HuggingFace | `uv run src/fetch_ws_sentences.py` |
+| `src/build_ws_dataset.py` | Convert to BIO + stratified split | `uv run src/build_ws_dataset.py` |
+| `src/ws_statistics.py` | Convert to CoNLL-U + compute statistics | `uv run src/ws_statistics.py` |
+
+### 4.3 Intermediate Files
+
+- `ws_sentences_{vlc,uvn,uvw,uvb_f,uvb_n}.txt` — Raw sentences per domain (format: `idx\tsentence`)
+
+## 5. Relation to UDD-1 v1.0
+
+UDD-1 v1.1 does not replace v1.0. The relationship is:
+
+| | v1.0 | v1.1 |
+|---|---|---|
+| **UD Treebank** | 10K sentences, legal domain, silver-standard CoNLL-U | Unchanged (v1.0 treebank remains) |
+| **WS Dataset** | N/A | 100K sentences, 5 domains, BIO format |
+| **Gold Annotation** | None | Planned: 2-5K sentences via active learning |
+| **Annotation Guidelines** | Implicit (parser behavior) | Explicit (co-developed through AL) |
+| **Domains** | Legal only | Legal, News, Wikipedia, Fiction, Non-fiction |
+
+The word segmentation dataset feeds into tree-1's CRF training pipeline. The gold annotations planned through active learning will eventually enable a v2.0 release with verified quality.
+
+## 6. Conclusion
+
+UDD-1 v1.1 establishes the data and methodological foundation for building a gold-standard Vietnamese UD treebank:
+
+1. **udd-ws-v1.1**: A 100,000-sentence, 5-domain word segmentation dataset in BIO format, providing the training data for robust tokenization models that underpin all downstream annotations.
+
+2. **Three-task active learning pipeline**: Task-specific AL strategies for each layer of the Vietnamese NLP pipeline:
+   - **Word segmentation**: CRF token marginal uncertainty + dictionary-based error targeting → 2,000 gold sentences
+   - **POS tagging**: Tag marginal uncertainty + confusion-pair targeting (AUX/VERB, NOUN/VERB) → 1,000 gold sentences
+   - **Dependency parsing**: Head entropy + DPP batch diversity + partial arc annotation → 800--1,000 gold sentences
+
+3. **Solo annotator methodology**: Quality assurance through self-consistency checks (>95% target), model-based error detection, dictionary validation, and UD structural validation --- demonstrating that gold treebank construction is feasible without multiple annotators.
+
+4. **Vietnamese UD guidelines**: Co-developed through the annotation process, addressing Vietnamese-specific challenges (copula, passive markers, serial verbs, classifiers, topic-comment structure).
+
+The immediate next step is Task 1, Cycle 1: selecting 500 sentences with highest CRF uncertainty from udd-ws-v1.1 for gold word segmentation annotation. In parallel, the DP pilot (50 fully annotated sentences) will produce the first in-domain LAS/UAS measurements for Vietnamese legal text. Total estimated effort: ~100 annotator-days over 12 weeks.
+
+## References
+
+- Baldridge, J. and Osborne, M. (2004). Active Learning and the Total Cost of Annotation. In *Proceedings of EMNLP 2004*.
+
+- Brants, T. and Skut, W. (1998). Automation of Treebank Annotation. In *Proceedings of CoNLL 1998*.
+
+- de Marneffe, M.-C., Manning, C.D., Nivre, J., and Zeman, D. (2021). Universal Dependencies. *Computational Linguistics*, 47(2):255--308.
+
+- Hwa, R. (2004). Sample Selection for Statistical Parsing. *Computational Linguistics*, 30(3):253--276.
+
+- Li, Z., Zhang, M., Zhang, Y., Liu, Z., Chen, W., Wu, H., and Wang, H. (2016). Active Learning for Dependency Parsing with Partial Annotation. In *Proceedings of ACL 2016*, pp. 344--354.
+
+- Nguyen, Q., Vu, T., Nguyen, D., Nguyen, M., and Phan, T. (2018). Ensuring Annotation Consistency and Accuracy for Vietnamese Treebank. *Language Resources and Evaluation*, Springer.
+
+- Shi, T., Benton, A., Malioutov, I., and Irsoy, O. (2021). Diversity-Aware Batch Active Learning for Dependency Parsing. In *Proceedings of NAACL 2021*.
+
+- Zhang, Z., Strubell, E., and Hovy, E. (2023). Data-efficient Active Learning for Structured Prediction with Partial Annotation and Self-Training. In *Findings of EMNLP 2023*.

src/build_ws_dataset.py

@@ -0,0 +1,278 @@
+# /// script
+# requires-python = ">=3.9"
+# dependencies = [
+#     "underthesea>=6.8.0",
+# ]
+# ///
+"""
+Build word segmentation dataset in BIO format (VLSP 2013 compatible).
+
+Reads 5 intermediate sentence files (ws_sentences_*.txt), applies
+underthesea.word_tokenize to get compound tokens, then splits into
+syllables with B-W/I-W tags. Creates stratified 80/10/10 train/dev/test
+splits with equal domain proportions.
+
+Output files:
+  - udd-ws-v1.1-train.txt  (~80K sentences)
+  - udd-ws-v1.1-dev.txt    (~10K sentences)
+  - udd-ws-v1.1-test.txt   (~10K sentences)
+
+BIO format (tab-separated, blank line between sentences):
+  # sent_id = vlc-1
+  # text = Một doanh nghiệp lớn.
+  syllable1\tB-W
+  syllable2\tI-W
+  syllable3\tB-W
+  <blank line>
+"""
+
+import random
+from os.path import dirname, isfile, join
+
+from underthesea import word_tokenize
+from underthesea.pipeline.word_tokenize.regex_tokenize import tokenize as regex_tokenize
+
+
+# Split ratios
+TRAIN_RATIO = 0.80
+DEV_RATIO = 0.10
+TEST_RATIO = 0.10
+
+# Domain source files, sent_id prefixes
+DOMAIN_CONFIG = {
+    "legal":       ("ws_sentences_vlc.txt",   "vlc-"),
+    "news":        ("ws_sentences_uvn.txt",   "uvn-"),
+    "wikipedia":   ("ws_sentences_uvw.txt",   "uvw-"),
+    "fiction":     ("ws_sentences_uvb_f.txt",  "uvb-f-"),
+    "non-fiction": ("ws_sentences_uvb_n.txt",  "uvb-n-"),
+}
+
+
+def load_sentences(filepath, prefix):
+    """Load sentences from idx\\tsentence file, returning (sent_id, text) 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", 1)
+            if len(parts) == 2:
+                idx = parts[0]
+                sent_id = f"{prefix}{idx}"
+                sentences.append((sent_id, parts[1]))
+    return sentences
+
+
+def sentence_to_bio(sent_id, text):
+    """Convert a sentence to BIO-tagged syllable sequence.
+
+    Uses underthesea.word_tokenize to get compound tokens (with underscores),
+    then splits each token into syllables and assigns B-W/I-W tags.
+
+    Returns (sent_id, text, bio_pairs) or None on failure.
+    """
+    tokenized = word_tokenize(text, format="text")
+    if not tokenized or not tokenized.strip():
+        return None
+
+    tokens = tokenized.strip().split()
+    if not tokens:
+        return None
+
+    bio_pairs = []
+    for token in tokens:
+        token_text = token.replace("_", " ")
+        syllables = regex_tokenize(token_text)
+        for i, syl in enumerate(syllables):
+            tag = "B-W" if i == 0 else "I-W"
+            bio_pairs.append((syl, tag))
+
+    if not bio_pairs:
+        return None
+
+    return (sent_id, text, bio_pairs)
+
+
+def stratified_split(domain_data, seed=42):
+    """Create stratified train/dev/test split preserving domain proportions.
+
+    Args:
+        domain_data: dict of domain_name -> list of BIO sequences
+
+    Returns:
+        train, dev, test lists of BIO sequences
+    """
+    random.seed(seed)
+
+    train = []
+    dev = []
+    test = []
+
+    for domain_name, sequences in domain_data.items():
+        shuffled = list(sequences)
+        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})")
+
+    # Shuffle each split so domains are interleaved
+    random.shuffle(train)
+    random.shuffle(dev)
+    random.shuffle(test)
+
+    return train, dev, test
+
+
+def write_bio_file(sequences, filepath):
+    """Write BIO sequences to file in VLSP format with comment headers."""
+    with open(filepath, "w", encoding="utf-8") as f:
+        for sent_id, text, bio_pairs in sequences:
+            f.write(f"# sent_id = {sent_id}\n")
+            f.write(f"# text = {text}\n")
+            for syl, tag in bio_pairs:
+                f.write(f"{syl}\t{tag}\n")
+            f.write("\n")
+    print(f"  Saved {len(sequences)} sentences to {filepath}")
+
+
+def validate_bio_file(filepath):
+    """Validate BIO format constraints."""
+    errors = 0
+    sentence_count = 0
+    in_sentence = False
+
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line_num, line in enumerate(f, 1):
+            line = line.rstrip("\n")
+            if not line:
+                if in_sentence:
+                    sentence_count += 1
+                    in_sentence = False
+                continue
+
+            # Skip comment lines
+            if line.startswith("#"):
+                continue
+
+            parts = line.split("\t")
+            if len(parts) != 2:
+                print(f"    ERROR line {line_num}: expected 2 tab-separated fields, got {len(parts)}")
+                errors += 1
+                continue
+
+            syl, tag = parts
+            if tag not in ("B-W", "I-W"):
+                print(f"    ERROR line {line_num}: invalid tag '{tag}'")
+                errors += 1
+
+            # I-W cannot start a sentence
+            if not in_sentence and tag == "I-W":
+                print(f"    ERROR line {line_num}: sentence starts with I-W")
+                errors += 1
+
+            in_sentence = True
+
+        # Handle last sentence without trailing newline
+        if in_sentence:
+            sentence_count += 1
+
+    if errors == 0:
+        print(f"    PASS: {sentence_count} sentences, no errors")
+    else:
+        print(f"    FAIL: {sentence_count} sentences, {errors} errors")
+
+    return errors, sentence_count
+
+
+def main():
+    base_dir = dirname(dirname(__file__))
+
+    # Load sentences from all domains
+    print("Loading sentences from domain files...")
+    domain_data = {}
+    total_loaded = 0
+
+    for domain, (filename, prefix) in DOMAIN_CONFIG.items():
+        filepath = join(base_dir, filename)
+        if not isfile(filepath):
+            print(f"  WARNING: {filename} not found, skipping {domain}")
+            continue
+        sentences = load_sentences(filepath, prefix)
+        print(f"  {domain}: loaded {len(sentences)} sentences from {filename}")
+        total_loaded += len(sentences)
+        domain_data[domain] = sentences
+
+    print(f"  Total loaded: {total_loaded}")
+
+    # Convert sentences to BIO format
+    print("\nConverting sentences to BIO format...")
+    domain_bio = {}
+    total_converted = 0
+    total_failed = 0
+
+    for domain, sentences in domain_data.items():
+        bio_sequences = []
+        failed = 0
+        for i, (sent_id, text) in enumerate(sentences):
+            result = sentence_to_bio(sent_id, text)
+            if result:
+                bio_sequences.append(result)
+            else:
+                failed += 1
+            if (i + 1) % 5000 == 0:
+                print(f"  {domain}: {i+1}/{len(sentences)} processed ({len(bio_sequences)} ok, {failed} failed)")
+        domain_bio[domain] = bio_sequences
+        total_converted += len(bio_sequences)
+        total_failed += failed
+        print(f"  {domain}: {len(bio_sequences)} converted, {failed} failed")
+
+    print(f"  Total converted: {total_converted}, failed: {total_failed}")
+
+    # Create stratified split
+    print("\nCreating stratified 80/10/10 split...")
+    train, dev, test = stratified_split(domain_bio)
+
+    total = len(train) + len(dev) + len(test)
+    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: {total}")
+
+    # Write output files
+    print("\nWriting BIO files...")
+    train_path = join(base_dir, "udd-ws-v1.1-train.txt")
+    dev_path = join(base_dir, "udd-ws-v1.1-dev.txt")
+    test_path = join(base_dir, "udd-ws-v1.1-test.txt")
+
+    write_bio_file(train, train_path)
+    write_bio_file(dev, dev_path)
+    write_bio_file(test, test_path)
+
+    # Validate output
+    print("\nValidating output files...")
+    for name, path in [("Train", train_path), ("Dev", dev_path), ("Test", test_path)]:
+        print(f"  {name} ({path}):")
+        validate_bio_file(path)
+
+    # Print sample
+    print("\nSample output (first sentence from train):")
+    if train:
+        sent_id, text, bio_pairs = train[0]
+        print(f"  # sent_id = {sent_id}")
+        print(f"  # text = {text}")
+        for syl, tag in bio_pairs:
+            print(f"  {syl}\t{tag}")
+
+
+if __name__ == "__main__":
+    main()

src/fetch_ws_sentences.py

@@ -0,0 +1,355 @@
+# /// script
+# requires-python = ">=3.9"
+# dependencies = [
+#     "datasets>=2.0.0",
+#     "underthesea>=6.8.0",
+# ]
+# ///
+"""
+Fetch sentences for word segmentation dataset (100K total).
+
+Fetches 20,000 sentences per domain from 4 HuggingFace datasets:
+  - Legal:       undertheseanlp/UTS_VLC     → ws_sentences_vlc.txt
+  - News:        undertheseanlp/UVN-1       → ws_sentences_uvn.txt
+  - Wikipedia:   undertheseanlp/UVW-2026    → ws_sentences_uvw.txt
+  - Fiction:     undertheseanlp/UVB-v0.1    → ws_sentences_uvb_f.txt
+  - Non-fiction: undertheseanlp/UVB-v0.1    → ws_sentences_uvb_n.txt
+
+Output format: idx\tsentence (one sentence per line)
+"""
+
+import re
+from os.path import dirname, join
+
+from datasets import load_dataset
+from underthesea import sent_tokenize, text_normalize
+
+
+TARGET_PER_DOMAIN = 20000
+
+
+# ============================================================================
+# Shared text cleaning
+# ============================================================================
+
+def clean_text(text):
+    """Remove markdown formatting and clean text."""
+    text = text_normalize(text)
+    text = re.sub(r'^#+\s+', '', text, flags=re.MULTILINE)
+    text = re.sub(r'\*+', '', text)
+    text = re.sub(r'^-+$', '', text, flags=re.MULTILINE)
+    text = re.sub(r'\[([^\]]+)\]\([^)]+\)', r'\1', text)
+    text = re.sub(r'\n{2,}', '\n', text)
+    lines = [line.strip() for line in text.split('\n')]
+    text = '\n'.join(lines)
+    return text
+
+
+def base_valid(sent):
+    """Shared base validation: length, Vietnamese diacritics, uppercase ratio."""
+    sent = sent.strip()
+    if not sent:
+        return False, sent
+    if len(sent) < 20 or len(sent) > 300:
+        return False, sent
+    if not re.search(r'[àáảãạăắằẳẵặâấầẩẫậèéẻẽẹêếềểễệìíỉĩịòóỏõọôốồổỗộơớờởỡợùúủũụưứừửữựỳýỷỹỵđ]', sent, re.IGNORECASE):
+        return False, sent
+    if sum(1 for c in sent if c.isupper()) > len(sent) * 0.5:
+        return False, sent
+    return True, sent
+
+
+# ============================================================================
+# Domain-specific validators
+# ============================================================================
+
+def is_valid_legal(sent):
+    """Validate sentence from legal domain (UTS_VLC)."""
+    ok, sent = base_valid(sent)
+    if not ok:
+        return False, sent
+    # Remove trailing list markers
+    sent = re.sub(r'\n\d+\.$', '', sent)
+    sent = re.sub(r'\n[a-z]\)$', '', sent)
+    sent = sent.strip()
+    if not sent:
+        return False, sent
+    # Skip legal structure headers
+    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
+    if re.match(r'^(Điều \d+|Khoản \d+|Mục \d+)', sent):
+        return False, sent
+    if sent.startswith(('English:', 'Số hiệu:', 'Ngày hiệu lực:', '---', '|')):
+        return False, sent
+    if re.search(r'\n\d+$', sent):
+        return False, sent
+    return True, sent
+
+
+def is_valid_news(sent):
+    """Validate sentence from news domain (UVN-1)."""
+    ok, sent = base_valid(sent)
+    if not ok:
+        return False, sent
+    # Skip bylines
+    if re.match(r'^(Theo |PV |Nguồn:|Ảnh:|Video:|Bài:|Tin ảnh:)', sent):
+        return False, sent
+    # Skip photo captions
+    if re.search(r'\(Ảnh:.*\)$', sent):
+        return False, sent
+    if re.search(r'\(Nguồn:.*\)$', sent):
+        return False, sent
+    # Skip date/time 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 URLs
+    if re.search(r'(http|www\.|\.com|\.vn)', sent, re.IGNORECASE):
+        return False, sent
+    # Skip tags/categories
+    if re.match(r'^(Tags?:|Chuyên mục:|Từ khóa:)', sent, re.IGNORECASE):
+        return False, sent
+    # Skip data tables (>30% digits)
+    if sum(1 for c in sent if c.isdigit()) > len(sent) * 0.3:
+        return False, sent
+    return True, sent
+
+
+def is_valid_wiki(sent):
+    """Validate sentence from Wikipedia domain (UVW-2026)."""
+    ok, sent = base_valid(sent)
+    if not ok:
+        return False, sent
+    # Skip 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/list pages
+    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
+    if sent.count('|') > 2:
+        return False, sent
+    if re.search(r'\w+=\w+', sent) and sent.count('=') > 1:
+        return False, sent
+    # Skip reference fragments
+    if re.search(r'\[\d+\]', sent):
+        return False, sent
+    if re.search(r'\[cần', sent):
+        return False, sent
+    # Skip URLs
+    if re.search(r'(http|www\.|\.com|\.org)', sent, re.IGNORECASE):
+        return False, sent
+    # Skip data tables
+    if sum(1 for c in sent if c.isdigit()) > len(sent) * 0.3:
+        return False, sent
+    # Skip list items
+    if re.match(r'^[\*\-•]\s', sent):
+        return False, sent
+    return True, sent
+
+
+def is_valid_book(sent):
+    """Validate sentence from book domain (UVB-v0.1) — stricter quality."""
+    sent = sent.strip()
+    if not sent:
+        return False, sent
+    # Stricter length
+    if len(sent) < 30 or len(sent) > 250:
+        return False, sent
+    # Word count
+    words = sent.split()
+    if len(words) < 5 or len(words) > 40:
+        return False, sent
+    # Must start with uppercase
+    if not sent[0].isupper():
+        return False, sent
+    # Must end with proper punctuation
+    if sent.rstrip()[-1] not in '.!?…"»':
+        return False, sent
+    # Stricter uppercase threshold
+    if sum(1 for c in sent if c.isupper()) > len(sent) * 0.3:
+        return False, sent
+    # Must contain Vietnamese diacritics
+    if not re.search(r'[àáảãạăắằẳẵặâấầẩẫậèéẻẽẹêếềểễệìíỉĩịòóỏõọôốồổỗộơớờởỡợùúủũụưứừửữựỳýỷỹỵđ]', sent, re.IGNORECASE):
+        return False, sent
+    # Skip too many numbers
+    if sum(1 for c in sent if c.isdigit()) > len(sent) * 0.15:
+        return False, sent
+    # Skip structure markers
+    if re.match(r'^(Chương|Phần|Mục|Điều|\d+\.|\([a-z]\))', sent):
+        return False, sent
+    # Skip URLs/emails
+    if re.search(r'(http|www\.|@|\.com|\.vn)', sent, re.IGNORECASE):
+        return False, sent
+    # Skip 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 (ellipsis in middle)
+    if '...' in sent[:-5]:
+        return False, sent
+    # Skip dialogue-heavy
+    quote_count = sent.count('"') + sent.count('\u201c') + sent.count('\u201d')
+    if quote_count > 4:
+        return False, sent
+    return True, sent
+
+
+# ============================================================================
+# Book genre classification (from fetch_uvb_data.py)
+# ============================================================================
+
+FICTION_GENRES = {
+    "Fiction", "Novels", "Romance", "Fantasy", "Science Fiction",
+    "Mystery", "Thriller", "Horror", "Historical Fiction", "Literary Fiction",
+    "Adventure", "Crime", "Suspense", "Drama", "Short Stories"
+}
+
+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 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:
+        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
+
+
+# ============================================================================
+# Sentence extraction helpers
+# ============================================================================
+
+def extract_sentences(docs, validator, target, label=""):
+    """Extract validated sentences from documents until target count reached."""
+    sentences = []
+    for idx, doc in enumerate(docs):
+        content = doc["content"]
+        content = clean_text(content)
+        for sent in sent_tokenize(content):
+            sent = sent.strip()
+            ok, cleaned = validator(sent)
+            if ok:
+                sentences.append(cleaned)
+        if len(sentences) >= target:
+            print(f"  {label}: processed {idx + 1} documents, collected {len(sentences)} sentences")
+            break
+    return sentences[:target]
+
+
+def extract_book_sentences(books, target, label=""):
+    """Extract validated sentences from books until target count reached."""
+    sentences = []
+    for i, book in enumerate(books):
+        if len(sentences) >= target:
+            break
+        content = clean_text(book["content"])
+        for sent in sent_tokenize(content):
+            ok, cleaned = is_valid_book(sent)
+            if ok:
+                sentences.append(cleaned)
+                if len(sentences) >= target:
+                    break
+        if (i + 1) % 50 == 0 or len(sentences) >= target:
+            print(f"  {label}: [{i+1}/{len(books)}] books processed, {len(sentences)} sentences")
+    return sentences[:target]
+
+
+def save_sentences(sentences, filepath):
+    """Save sentences to file in idx\\tsentence format."""
+    with open(filepath, "w", encoding="utf-8") as f:
+        for i, sent in enumerate(sentences, 1):
+            f.write(f"{i}\t{sent}\n")
+    print(f"  Saved {len(sentences)} sentences to {filepath}")
+
+
+# ============================================================================
+# Main
+# ============================================================================
+
+def main():
+    base_dir = dirname(dirname(__file__))
+
+    # --- Legal (UTS_VLC) ---
+    print(f"\n[1/5] Fetching legal sentences (target: {TARGET_PER_DOMAIN})...")
+    ds_vlc = load_dataset("undertheseanlp/UTS_VLC", split="2026")
+    vlc_sentences = extract_sentences(ds_vlc, is_valid_legal, TARGET_PER_DOMAIN, "Legal")
+    save_sentences(vlc_sentences, join(base_dir, "ws_sentences_vlc.txt"))
+
+    # --- News (UVN-1) ---
+    print(f"\n[2/5] Fetching news sentences (target: {TARGET_PER_DOMAIN})...")
+    ds_uvn = load_dataset("undertheseanlp/UVN-1", split="train")
+    uvn_sentences = extract_sentences(ds_uvn, is_valid_news, TARGET_PER_DOMAIN, "News")
+    save_sentences(uvn_sentences, join(base_dir, "ws_sentences_uvn.txt"))
+
+    # --- Wikipedia (UVW-2026) ---
+    print(f"\n[3/5] Fetching Wikipedia sentences (target: {TARGET_PER_DOMAIN})...")
+    ds_uvw = load_dataset("undertheseanlp/UVW-2026", split="train")
+    high_quality = [doc for doc in ds_uvw if (doc.get("quality_score") or 0) >= 5]
+    print(f"  High-quality articles: {len(high_quality)}")
+    uvw_sentences = extract_sentences(high_quality, is_valid_wiki, TARGET_PER_DOMAIN, "Wikipedia")
+    save_sentences(uvw_sentences, join(base_dir, "ws_sentences_uvw.txt"))
+
+    # --- Books (UVB-v0.1) ---
+    print(f"\n[4/5] Fetching fiction sentences (target: {TARGET_PER_DOMAIN})...")
+    print(f"[5/5] Fetching non-fiction sentences (target: {TARGET_PER_DOMAIN})...")
+    ds_uvb = load_dataset("undertheseanlp/UVB-v0.1", split="train")
+
+    fiction_books = []
+    non_fiction_books = []
+    for book in ds_uvb:
+        genres = book.get("genres", [])
+        rating = book.get("goodreads_rating", 0) or 0
+        num_ratings = book.get("goodreads_num_ratings", 0) or 0
+        quality_score = rating * min(num_ratings / 100, 10)
+        book_type = classify_book(genres)
+        book_info = {
+            "title": book["title"],
+            "content": book["content"],
+            "quality_score": quality_score,
+        }
+        if book_type == "fiction":
+            fiction_books.append(book_info)
+        elif book_type == "non-fiction":
+            non_fiction_books.append(book_info)
+
+    fiction_books.sort(key=lambda x: x["quality_score"], reverse=True)
+    non_fiction_books.sort(key=lambda x: x["quality_score"], reverse=True)
+    print(f"  Fiction books: {len(fiction_books)}, Non-fiction books: {len(non_fiction_books)}")
+
+    fiction_sentences = extract_book_sentences(fiction_books, TARGET_PER_DOMAIN, "Fiction")
+    save_sentences(fiction_sentences, join(base_dir, "ws_sentences_uvb_f.txt"))
+
+    nonfiction_sentences = extract_book_sentences(non_fiction_books, TARGET_PER_DOMAIN, "Non-fiction")
+    save_sentences(nonfiction_sentences, join(base_dir, "ws_sentences_uvb_n.txt"))
+
+    # --- Summary ---
+    print("\n" + "=" * 60)
+    print("Summary:")
+    print(f"  Legal:       {len(vlc_sentences):,}")
+    print(f"  News:        {len(uvn_sentences):,}")
+    print(f"  Wikipedia:   {len(uvw_sentences):,}")
+    print(f"  Fiction:     {len(fiction_sentences):,}")
+    print(f"  Non-fiction: {len(nonfiction_sentences):,}")
+    total = len(vlc_sentences) + len(uvn_sentences) + len(uvw_sentences) + len(fiction_sentences) + len(nonfiction_sentences)
+    print(f"  Total:       {total:,}")
+
+
+if __name__ == "__main__":
+    main()

src/ws_statistics.py

@@ -0,0 +1,250 @@
+# /// script
+# requires-python = ">=3.9"
+# dependencies = []
+# ///
+"""
+Convert WS BIO dataset to CoNLL-U format and compute statistics.
+
+Reads udd-ws-v1.1-{train,dev,test}.txt (BIO format) and:
+  1. Converts to CoNLL-U: udd-ws-v1.1-{train,dev,test}.conllu
+  2. Prints statistics matching the style of statistics.py
+
+CoNLL-U format: each word is a token, multi-syllable words have
+syllables joined by space in FORM field (Vietnamese UD convention).
+"""
+
+from collections import Counter
+from os.path import dirname, isfile, join
+
+
+def parse_bio_file(filepath):
+    """Parse BIO file into sentences with metadata and word-level tokens.
+
+    Returns list of dicts with keys: sent_id, text, words, domain.
+    Each word is a string (syllables joined by space for multi-syllable words).
+    """
+    sentences = []
+    current = {"sent_id": "", "text": "", "syllables": [], "tags": []}
+
+    with open(filepath, "r", encoding="utf-8") as f:
+        for line in f:
+            line = line.rstrip("\n")
+            if line.startswith("# sent_id = "):
+                current["sent_id"] = line.split("= ", 1)[1]
+                continue
+            if line.startswith("# text = "):
+                current["text"] = line.split("= ", 1)[1]
+                continue
+            if line.startswith("#"):
+                continue
+            if not line:
+                if current["syllables"]:
+                    words = bio_to_words(current["syllables"], current["tags"])
+                    domain = sent_id_to_domain(current["sent_id"])
+                    sentences.append({
+                        "sent_id": current["sent_id"],
+                        "text": current["text"],
+                        "words": words,
+                        "domain": domain,
+                    })
+                    current = {"sent_id": "", "text": "", "syllables": [], "tags": []}
+                continue
+            parts = line.split("\t")
+            if len(parts) == 2:
+                current["syllables"].append(parts[0])
+                current["tags"].append(parts[1])
+
+    if current["syllables"]:
+        words = bio_to_words(current["syllables"], current["tags"])
+        domain = sent_id_to_domain(current["sent_id"])
+        sentences.append({
+            "sent_id": current["sent_id"],
+            "text": current["text"],
+            "words": words,
+            "domain": domain,
+        })
+
+    return sentences
+
+
+def bio_to_words(syllables, tags):
+    """Convert syllable-level BIO tags to word list."""
+    words = []
+    current = []
+    for syl, tag in zip(syllables, tags):
+        if tag == "B-W":
+            if current:
+                words.append(" ".join(current))
+            current = [syl]
+        else:
+            current.append(syl)
+    if current:
+        words.append(" ".join(current))
+    return words
+
+
+def sent_id_to_domain(sent_id):
+    if sent_id.startswith("vlc-"):
+        return "legal"
+    elif sent_id.startswith("uvn-"):
+        return "news"
+    elif sent_id.startswith("uvw-"):
+        return "wikipedia"
+    elif sent_id.startswith("uvb-f-"):
+        return "fiction"
+    elif sent_id.startswith("uvb-n-"):
+        return "non-fiction"
+    return "unknown"
+
+
+def write_conllu(sentences, filepath):
+    """Write sentences to CoNLL-U format."""
+    with open(filepath, "w", encoding="utf-8") as f:
+        for sent in sentences:
+            f.write(f"# sent_id = {sent['sent_id']}\n")
+            f.write(f"# text = {sent['text']}\n")
+            for i, word in enumerate(sent["words"], 1):
+                # ID  FORM  LEMMA  UPOS  XPOS  FEATS  HEAD  DEPREL  DEPS  MISC
+                f.write(f"{i}\t{word}\t_\t_\t_\t_\t_\t_\t_\t_\n")
+            f.write("\n")
+
+
+def compute_statistics(sentences):
+    """Compute statistics from parsed sentences."""
+    stats = {}
+
+    stats["num_sentences"] = len(sentences)
+    stats["num_words"] = sum(len(s["words"]) for s in sentences)
+    stats["num_syllables"] = sum(
+        sum(len(w.split()) for w in s["words"]) for s in sentences
+    )
+
+    # Sentence length (in words)
+    sent_lengths = [len(s["words"]) for s in sentences]
+    stats["avg_sent_length"] = sum(sent_lengths) / len(sent_lengths) if sent_lengths else 0
+    stats["min_sent_length"] = min(sent_lengths) if sent_lengths else 0
+    stats["max_sent_length"] = max(sent_lengths) if sent_lengths else 0
+
+    # Sentence length in syllables
+    sent_syl_lengths = [sum(len(w.split()) for w in s["words"]) for s in sentences]
+    stats["avg_sent_syl_length"] = sum(sent_syl_lengths) / len(sent_syl_lengths) if sent_syl_lengths else 0
+
+    # Word length distribution (by syllable count)
+    word_syl_counts = Counter()
+    for s in sentences:
+        for w in s["words"]:
+            n_syls = len(w.split())
+            word_syl_counts[n_syls] += 1
+    stats["word_syl_counts"] = word_syl_counts
+
+    # Domain distribution
+    domain_counts = Counter(s["domain"] for s in sentences)
+    stats["domain_counts"] = domain_counts
+
+    return stats
+
+
+def print_statistics(name, stats):
+    """Print statistics in the same format as statistics.py."""
+    print("=" * 60)
+    print(f"  {name}")
+    print("=" * 60)
+
+    print("\n## Basic Statistics")
+    print(f"  Sentences:         {stats['num_sentences']:>10,}")
+    print(f"  Words:             {stats['num_words']:>10,}")
+    print(f"  Syllables:         {stats['num_syllables']:>10,}")
+    print(f"  Avg word/sent:     {stats['avg_sent_length']:>10.2f}")
+    print(f"  Avg syl/sent:      {stats['avg_sent_syl_length']:>10.2f}")
+    print(f"  Avg syl/word:      {stats['num_syllables']/stats['num_words']:>10.2f}")
+    print(f"  Min word/sent:     {stats['min_sent_length']:>10}")
+    print(f"  Max word/sent:     {stats['max_sent_length']:>10}")
+
+    print("\n## Word Length Distribution (by syllable count)")
+    print(f"  {'Syllables':<12} {'Count':>10} {'Percent':>8}")
+    print("  " + "-" * 32)
+    total_words = stats["num_words"]
+    for n_syls in sorted(stats["word_syl_counts"]):
+        count = stats["word_syl_counts"][n_syls]
+        pct = count / total_words * 100
+        print(f"  {n_syls:<12} {count:>10,} {pct:>7.2f}%")
+
+    print("\n## Domain Distribution")
+    print(f"  {'Domain':<15} {'Count':>10} {'Percent':>8}")
+    print("  " + "-" * 35)
+    total_sents = stats["num_sentences"]
+    for domain in ["legal", "news", "wikipedia", "fiction", "non-fiction"]:
+        count = stats["domain_counts"].get(domain, 0)
+        pct = count / total_sents * 100
+        print(f"  {domain:<15} {count:>10,} {pct:>7.2f}%")
+
+    print()
+
+
+def main():
+    base_dir = dirname(dirname(__file__))
+
+    splits = {
+        "train": "udd-ws-v1.1-train.txt",
+        "dev":   "udd-ws-v1.1-dev.txt",
+        "test":  "udd-ws-v1.1-test.txt",
+    }
+
+    all_stats = {}
+
+    for split_name, filename in splits.items():
+        bio_path = join(base_dir, filename)
+        if not isfile(bio_path):
+            print(f"WARNING: {bio_path} not found, skipping")
+            continue
+
+        # Parse BIO
+        print(f"Reading {filename}...")
+        sentences = parse_bio_file(bio_path)
+
+        # Write CoNLL-U
+        conllu_path = bio_path.replace(".txt", ".conllu")
+        write_conllu(sentences, conllu_path)
+        print(f"  → {conllu_path}")
+
+        # Compute statistics
+        stats = compute_statistics(sentences)
+        all_stats[split_name] = stats
+
+    # Print per-split statistics
+    for split_name, stats in all_stats.items():
+        print_statistics(f"udd-ws-v1.1 — {split_name}", stats)
+
+    # Print combined statistics
+    if all_stats:
+        combined = {
+            "num_sentences": sum(s["num_sentences"] for s in all_stats.values()),
+            "num_words": sum(s["num_words"] for s in all_stats.values()),
+            "num_syllables": sum(s["num_syllables"] for s in all_stats.values()),
+            "min_sent_length": min(s["min_sent_length"] for s in all_stats.values()),
+            "max_sent_length": max(s["max_sent_length"] for s in all_stats.values()),
+            "word_syl_counts": Counter(),
+            "domain_counts": Counter(),
+        }
+        for s in all_stats.values():
+            combined["word_syl_counts"] += s["word_syl_counts"]
+            combined["domain_counts"] += s["domain_counts"]
+        combined["avg_sent_length"] = combined["num_words"] / combined["num_sentences"]
+        combined["avg_sent_syl_length"] = combined["num_syllables"] / combined["num_sentences"]
+
+        print_statistics("udd-ws-v1.1 — TOTAL", combined)
+
+        # Summary table
+        print("=" * 60)
+        print("  Summary")
+        print("=" * 60)
+        print(f"\n  {'Split':<8} {'Sentences':>10} {'Words':>10} {'Syllables':>12}")
+        print("  " + "-" * 42)
+        for split_name, stats in all_stats.items():
+            print(f"  {split_name:<8} {stats['num_sentences']:>10,} {stats['num_words']:>10,} {stats['num_syllables']:>12,}")
+        print(f"  {'TOTAL':<8} {combined['num_sentences']:>10,} {combined['num_words']:>10,} {combined['num_syllables']:>12,}")
+        print()
+
+
+if __name__ == "__main__":
+    main()