Improve WS sentence quality filters, diversity sampling, and update technical report

- Add 14-rule quality filter pipeline: lang_detect with Vietnamese fallback,
balanced brackets, markup/glued text rejection, safe_sent_tokenize() fix
- Replace sequential extraction with round-robin sampling (MAX_PER_DOC=500,
MAX_PER_BOOK=500) for source diversity across all domains
- Add sentence_score() continuous quality function and near-duplicate detection
- Update technical report v1.1 with quality pipeline, diversity metrics, and
sentence scoring documentation
- Update sentence selection guidelines with all filter specifications

TECHNICAL_REPORT_v1.1.md

@@ -27,8 +27,10 @@ More broadly, the review highlighted three priorities: (1) gold-standard evaluat
 
 | 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 |
+| udd-ws-v1.1 dataset | Complete | 100K sentences, 5 domains, BIO format, stratified splits |
+| Sentence quality pipeline | Complete | 14-rule quality filter + continuous quality scoring |
+| Diversity-aware sampling | Complete | Round-robin extraction with per-source caps |
+| Active learning literature survey | Complete | 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 |
@@ -58,7 +60,78 @@ Sentences are drawn from 4 HuggingFace datasets, the same sources as UDD-1 v1.0
 
 **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.2.1 Preprocessing
+
+All source texts undergo Unicode normalization (`underthesea.text_normalize()`), markdown removal, and whitespace normalization before sentence segmentation. Sentence splitting uses `safe_sent_tokenize()`, a wrapper around `underthesea.sent_tokenize()` that fixes incorrect splits inside Vietnamese thousands-separator numbers (e.g., "2.000" was split into "2." + "000..."). This affected ~1,700 sentences across the corpus.
+
+#### 2.2.2 Quality Filters
+
+Every sentence must pass a comprehensive quality filter pipeline (14 rules) before inclusion. The full specification is in `guidelines/00. Sentence Selection/Guideline.md`.
+
+**Common filters** (`base_valid()`, all domains):
+
+| Category | Rule | Condition |
+|----------|------|-----------|
+| Structure | Length bounds | 20--300 characters |
+| Structure | Minimum words | >= 4 words |
+| Structure | Proper start | First character uppercase or digit |
+| Structure | Proper end | Terminal punctuation (`.!?…"»"'):`) |
+| Language | Vietnamese content | At least one Vietnamese diacritical character |
+| Language | Not mostly uppercase | Uppercase characters <= 50% |
+| Language | Language detection | `underthesea.lang_detect()` == `"vi"` with fallback: accept if 3+ Vietnamese diacritical characters (prevents false rejection of sentences with foreign proper nouns) |
+| Markup | No HTML/template | Reject `{`, `}`, `<`, `>`, `\|` |
+| Markup | No template key=value | Reject `\w+=\w+` (but allow spaced `=` like `GDP = 3.500 USD`) |
+| Markup | No file extensions | Reject `.jpg`, `.png`, `.gif`, `.svg`, `.webp` |
+| Brackets | Balanced | `(` count == `)` count; `[` count == `]` count |
+| Glued text | Multi-tone detection | Reject tokens with 2+ toned vowels (Vietnamese syllables carry at most one tone mark; multiple tones indicate OCR-like merge errors) |
+| Glued text | Digit-letter glue | Reject tokens with a toned vowel AND `\d[letter]` pattern |
+
+**Domain-specific filters** add further rules: legal header/article removal, news byline/caption filtering, Wikipedia stub/infobox/reference rejection, and books apply stricter thresholds (30--250 chars, 5--40 words, <= 30% uppercase, <= 15% digits, punctuation density, no mid-sentence ellipsis, limited dialogue).
+
+#### 2.2.3 Deduplication
+
+Two levels of deduplication are applied during extraction (not as post-processing):
+
+- **Exact deduplication**: Raw sentence strings are tracked in a `seen` set. Identical sentences from different documents are rejected.
+- **Near-duplicate detection**: All digit sequences are normalized to `#` (`normalize_for_dedup()`), then exact-matched. This catches formulaic sentences differing only in numbers (e.g., legal clauses referencing different article numbers, news reporting different statistics).
+
+#### 2.2.4 Diversity-Aware Sampling
+
+Initial sequential extraction produced low source diversity: fiction was dominated by 5 books (primarily Murakami's *1Q84*), and legal text came from only 106 documents. We replaced sequential extraction with **round-robin sampling** with per-source caps:
+
+1. **Phase 1 (Candidate collection)**: Scan all documents/books, collecting up to `MAX_PER_DOC=500` (or `MAX_PER_BOOK=500`) valid sentences per source. For non-book domains, scanning stops at 3x the target candidate count.
+2. **Phase 2 (Round-robin selection)**: Cycle through all sources, taking one sentence per source per round, with exact and near-duplicate deduplication. This ensures no single source dominates.
+
+Books are ranked by quality score (`goodreads_rating * min(num_ratings / 100, 10)`) and processed in descending order, so higher-quality books are scanned first.
+
+**Source diversity achieved**:
+
+| Domain | Sequential (before) | Round-robin (after) |
+|--------|:---:|:---:|
+| Legal | 106 documents | 275 documents |
+| News | 1,030 documents | 3,091 documents |
+| Wikipedia | 180 articles | 785 articles |
+| Fiction | 5 books | 72 books |
+| Non-fiction | 20 books | 68 books |
+
+**Table 1b**: Source diversity improvement from round-robin sampling.
+
+#### 2.2.5 Sentence Quality Score
+
+Beyond binary pass/fail filters, each sentence is assigned a continuous quality score via `sentence_score()` returning a value in (0, 1). The score combines 6 sub-scores:
+
+| Sub-score | Weight | Description |
+|-----------|--------|-------------|
+| Length | 0.20 | Gaussian around ideal range [60, 200] chars |
+| Word count | 0.15 | Gaussian around ideal range [8, 35] words |
+| Structure | 0.20 | Proper start (+0.5) + proper end (+0.5) |
+| Cleanliness | 0.30 | Penalties for markup, unbalanced brackets, glued text, file extensions, excessive uppercase |
+| Completeness | 0.15 | Penalties for unbalanced quotes, excessive digit ratio |
+| Vietnamese density | multiplier | Ratio of Vietnamese diacritical characters to total letters (20%+ maps to 1.0). Applied as a **multiplier** so non-Vietnamese text scores near 0. |
+
+Formula: `final_score = clamp(base_score * vietnamese_density, 0.01, 0.99)`
+
+This score is used for quality reporting and will be used for active learning sentence selection (prioritizing sentences in the 0.7--0.95 range where annotation effort has the highest marginal value).
 
 ### 2.3 BIO Annotation
 
@@ -115,7 +188,11 @@ Splits are stratified by domain (each domain contributes exactly 20% to every sp
 
 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
+### 2.6 Input Quality Summary
+
+The 14-rule quality filter pipeline ensures that all 100,000 input sentences are well-formed Vietnamese text. Post-filtering validation confirms 0 duplicates, 0 near-duplicates, 0 unbalanced brackets, 0 markup remnants, 0 lowercase starts, 0 missing end punctuation, and 0 glued text across the entire dataset.
+
+### 2.7 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).
 
@@ -461,8 +538,10 @@ syllable3	B-W
 
 | Script | Purpose | Command |
 |--------|---------|---------|
-| `src/fetch_ws_sentences.py` | Fetch 100K sentences from HuggingFace | `uv run src/fetch_ws_sentences.py` |
+| `src/fetch_ws_sentences.py` | Fetch 100K sentences with quality filters and round-robin sampling | `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/fix_ws_errors.py` | Fix known WS errors (cross-boundary merges, always-split compounds) | `uv run src/fix_ws_errors.py` |
+| `src/check_ws_errors.py` | Rule-based WS error checker (7 rules) | `uv run src/check_ws_errors.py` |
 | `src/ws_statistics.py` | Convert to CoNLL-U + compute statistics | `uv run src/ws_statistics.py` |
 
 ### 4.3 Intermediate Files
@@ -487,16 +566,18 @@ The word segmentation dataset feeds into tree-1's CRF training pipeline. The gol
 
 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.
+1. **udd-ws-v1.1**: A 100,000-sentence, 5-domain word segmentation dataset in BIO format, built with a rigorous 14-rule quality filter pipeline, diversity-aware round-robin sampling (72 fiction books, 68 non-fiction books, 275 legal documents, 3,091 news documents, 785 Wikipedia articles), and two-level deduplication (exact + digit-normalized near-duplicate detection). The dataset provides training data for robust tokenization models that underpin all downstream annotations.
+
+2. **Sentence quality infrastructure**: A continuous quality scoring function (`sentence_score()`) and comprehensive validation pipeline that ensures all input sentences are well-formed Vietnamese text, free of markup, OCR artifacts, and duplicates. The `safe_sent_tokenize()` wrapper fixes Vietnamese-specific sentence splitting errors in the upstream NLP toolkit.
 
-2. **Three-task active learning pipeline**: Task-specific AL strategies for each layer of the Vietnamese NLP pipeline:
+3. **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. **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).
+5. **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.
 

guidelines/00. Sentence Selection/Guideline.md

@@ -1,6 +1,8 @@
 # Sentence Selection Criteria
 
-This document describes the criteria used to select sentences for inclusion in the UDD-1 treebank. Sentences are drawn from 5 domains (Legal, News, Wikipedia, Fiction, Non-fiction), each contributing 8,000 sentences to a total of 40,000.
+This document describes the criteria used to select sentences for inclusion in the UDD-1 dataset. Sentences are drawn from 5 domains (Legal, News, Wikipedia, Fiction, Non-fiction), each contributing 20,000 sentences to a total of 100,000.
+
+Implementation: `src/fetch_ws_sentences.py`
 
 ## 1. Preprocessing
 
@@ -9,20 +11,59 @@ All source texts undergo the same preprocessing before sentence selection:
 1. **Unicode normalization** via `underthesea.text_normalize()`
 2. **Markdown removal**: headers (`#`), bold/italic (`**`, `*`), links (`[text](url)`), horizontal rules (`---`)
 3. **Whitespace normalization**: collapse multiple newlines, strip leading/trailing whitespace per line
-4. **Sentence segmentation** via `underthesea.sent_tokenize()`
+4. **Sentence segmentation** via `safe_sent_tokenize()` — a wrapper around `underthesea.sent_tokenize()` that fixes incorrect splits inside Vietnamese thousands-separator numbers (e.g., "2.000" was split into "2." + "000...")
 
 ## 2. Common Criteria (All Domains)
 
-Every sentence must pass the following checks:
+Every sentence must pass all of the following checks (`base_valid()`):
+
+### 2.1 Structure
 
 | Criteria | Condition |
 |----------|-----------|
 | Non-empty | Sentence must not be blank after stripping |
 | Minimum length | >= 20 characters |
 | Maximum length | <= 300 characters |
-| Contains Vietnamese | Must contain at least one Vietnamese diacritical character (e.g., à, á, ả, ã, ạ, ă, â, đ, ê, ô, ơ, ư) |
-| Not mostly uppercase | Uppercase characters must be <= 50% of total characters |
-| No URLs | Must not contain `http`, `www.`, `.com`, `.vn` |
+| Minimum word count | >= 4 words (ensures enough syntactic structure for annotation) |
+| Starts with uppercase or digit | First character must be `[A-Z]` or `[0-9]` |
+| Ends with punctuation | Last character must be one of `.!?…"»"'):` |
+
+### 2.2 Language
+
+| Criteria | Condition |
+|----------|-----------|
+| Contains Vietnamese diacritics | At least one Vietnamese-specific character (à, á, ả, ã, ạ, ă, â, đ, ê, ô, ơ, ư, and their variants) |
+| Not mostly uppercase | Uppercase characters must be <= 50% of total |
+| Language detection with fallback | `underthesea.lang_detect(sent)` must return `"vi"`. **Fallback**: if lang_detect rejects but the sentence contains 3+ Vietnamese diacritical characters, the sentence is accepted (prevents false rejection of Vietnamese sentences with foreign proper nouns) |
+
+### 2.3 Markup and Noise
+
+| Criteria | Condition |
+|----------|-----------|
+| No HTML/template characters | Must not contain `{`, `}`, `<`, `>`, or `\|` |
+| No template key=value | Reject `\w+=\w+` patterns (e.g., `label1=value`), but allow spaced `=` (e.g., `GDP = 3.500 USD`) |
+| No file extensions | Must not contain `.jpg`, `.jpeg`, `.png`, `.gif`, `.svg`, `.webp` |
+| Balanced brackets | `(` count must equal `)` count; `[` count must equal `]` count |
+
+### 2.4 Glued Text Detection
+
+Vietnamese syllables each carry at most one tone mark. The following rules detect OCR-like merge errors:
+
+| Criteria | Condition | Example |
+|----------|-----------|---------|
+| Multiple tones in one token | Any whitespace-delimited token with 2+ toned vowels is rejected | "lõmlà" (õ + à) → should be "lõm là" |
+| Digit glued to Vietnamese text | Token has a toned vowel AND matches `\d[letter]` | "59Sẹo" → should be "59 Sẹo" |
+
+Toned vowels: á à ả ã ạ, ắ ằ ẳ ẵ ặ, ấ ầ ẩ ẫ ậ, é è ẻ ẽ ẹ, ế ề ể ễ ệ, í ì ỉ ĩ ị, ó ò ỏ õ ọ, ố ồ ổ ỗ ộ, ớ ờ ở ỡ ợ, ú ù ủ ũ ụ, ứ ừ ử ữ ự, ý ỳ ỷ ỹ ỵ (and uppercase equivalents).
+
+### 2.5 Deduplication
+
+Two levels of deduplication are applied during extraction (not as post-processing):
+
+| Level | Method | Catches |
+|-------|--------|---------|
+| **Exact** | `seen` set of raw sentence strings | Identical sentences from different documents |
+| **Near-duplicate** | Normalize all digit sequences to `#`, then exact match on the normalized form | Formulaic sentences differing only in numbers (e.g., legal clauses referencing different article numbers, news reporting different statistics) |
 
 ## 3. Domain-Specific Criteria
 
@@ -32,7 +73,7 @@ Additional filters for legal text noise:
 
 - **Header removal**: skip lines matching `QUỐC HỘI`, `CỘNG HÒA`, `Độc lập`, `Phần thứ`, `Chương [IVX]+`, `MỤC \d+`
 - **Article/clause titles**: skip `Điều \d+`, `Khoản \d+`, `Mục \d+`
-- **Metadata lines**: skip lines starting with `English:`, `Số hiệu:`, `Ngày hiệu lực:`, `---`, `|`
+- **Metadata lines**: skip lines starting with `English:`, `Số hiệu:`, `Ngày hiệu lực:`, `---`
 - **Trailing list markers**: remove trailing `1.` or `a)` patterns before validation
 - **Incomplete lines**: skip lines ending with a bare number
 
@@ -55,19 +96,18 @@ Two-stage filtering:
 **Stage 2 - Sentence-level**:
 - **Stub markers**: skip sentences containing `bài sơ khai`, `sơ khai về`, `cần được mở rộng`, `Thể loại:`
 - **Section headers**: skip `Thể loại`, `Danh sách`, `Xem thêm`, `Tham khảo`, `Liên kết ngoài`, `Chú thích`
-- **Infobox remnants**: skip sentences with more than 2 pipe characters (`|`) or multiple `key=value` patterns
+- **Infobox remnants**: skip sentences with 2+ pipe characters (`|`)
 - **Reference fragments**: skip sentences containing `[1]`, `[2]`, `[cần dẫn nguồn]`
 - **Bullet lists**: skip lines starting with `*`, `-`, or `•`
 - **Excessive numbers**: digit characters must be <= 30% of total characters
 
 ### 3.4 Fiction & Non-fiction (source: `undertheseanlp/UVB-v0.1`)
 
-The most restrictive criteria, designed to select well-formed literary sentences:
+The most restrictive criteria, designed to select well-formed literary sentences. `is_valid_book()` calls `base_valid()` first, then applies additional checks:
 
 **Book-level filtering**:
 - Books are classified as fiction or non-fiction based on genre tags (e.g., `Novels`, `Romance`, `Fantasy` for fiction; `History`, `Biography`, `Psychology` for non-fiction)
 - Books are ranked by quality score: `goodreads_rating * min(num_ratings / 100, 10)`, higher-rated books are prioritized
-- Maximum 500 sentences per book to ensure source diversity
 
 **Sentence-level filtering** (stricter than other domains):
 
@@ -75,68 +115,70 @@ The most restrictive criteria, designed to select well-formed literary sentences
 |----------|-----------|
 | Minimum length | >= 30 characters (vs. 20 for others) |
 | Maximum length | <= 250 characters (vs. 300 for others) |
-| Minimum word count | >= 5 words |
+| Minimum word count | >= 5 words (vs. 4 for others) |
 | Maximum word count | <= 40 words |
-| Starts with uppercase | First character must be uppercase |
-| Ends with punctuation | Last character must be one of `.!?…"»` |
 | Uppercase ratio | <= 30% (vs. 50% for others) |
 | Digit ratio | <= 15% (vs. 30% for news/wiki) |
 | Punctuation density | Punctuation count must be <= 1.5x word count |
 | No mid-sentence ellipsis | `...` must not appear before the last 5 characters |
-| Limited dialogue | At most 4 quotation marks (`"`, `"`, `"`) per sentence |
+| Limited dialogue | At most 4 quotation marks per sentence |
 | No chapter headers | Skip `Chương`, `Phần`, `Mục`, `Điều`, numbered items |
 | No URLs/emails | Skip sentences containing `http`, `www.`, `@`, `.com`, `.vn` |
 
-## 4. Sampling Strategy
+## 4. Sentence Quality Score
 
-- Each domain contributes exactly **8,000 sentences** (books domain: 8,000 fiction + 8,000 non-fiction)
-- Sentences are collected sequentially from documents until the target count is reached
-- For Wikipedia: only high-quality articles are used (quality_score >= 5)
-- For Books: books are processed in descending order of quality score
+Beyond the binary pass/fail filters, each sentence is assigned a continuous quality score via `sentence_score(sent)` returning a value in **(0, 1)**. This score can be used for ranking, quality reporting, and active learning selection.
 
-## 5. Train/Dev/Test Split
+### 4.1 Sub-scores
 
-After collecting all 40,000 sentences, the dataset is split using stratified sampling:
+The score combines 6 dimensions:
 
-| Split | Ratio | Sentences | ~Tokens |
-|-------|-------|-----------|---------|
-| Train | 91.4% | ~36,560 | ~548K |
-| Dev | 4.3% | ~1,720 | ~26K |
-| Test | 4.3% | ~1,720 | ~26K |
+| Sub-score | Weight | Description |
+|-----------|--------|-------------|
+| **Length** | 0.20 | Gaussian around ideal range [60, 200] chars. Sentences shorter or longer are penalized smoothly. |
+| **Word count** | 0.15 | Gaussian around ideal range [8, 35] words. |
+| **Structure** | 0.20 | Binary checks: starts with uppercase/digit (+0.5), ends with punctuation (+0.5). |
+| **Cleanliness** | 0.30 | Starts at 1.0, deducted for: markup chars (-0.3), template `=` (-0.2), unbalanced brackets (-0.2), glued text (-0.3), file extensions (-0.2), excessive uppercase (-0.2). Minimum 0.0. |
+| **Completeness** | 0.15 | Starts at 1.0, deducted for: unbalanced quotes (-0.2), excessive digit ratio >30% (-0.3) or >20% (-0.1). Minimum 0.0. |
+| **Vietnamese density** | multiplier | Ratio of Vietnamese diacritical characters to total letters, scaled so that 20%+ diacritics maps to 1.0. Applied as a **multiplier** on the weighted sum of other sub-scores — non-Vietnamese text scores near 0 regardless of other qualities. |
 
-### Rationale for Split Ratio
+### 4.2 Formula
 
-The 91.4/4.3/4.3 ratio follows established practices in Universal Dependencies:
+```
+base_score = 0.20 * length + 0.15 * word_count + 0.20 * structure + 0.30 * cleanliness + 0.15 * completeness
+final_score = clamp(base_score * vietnamese_density, 0.01, 0.99)
+```
 
-1. **UD official guidelines** (universaldependencies.org) specify that for treebanks with >110K words, dev and test sets should each contain "between 10K words and 10% of the data" (de Marneffe et al., 2021). UDD-1's dev and test sets each contain ~26K tokens, comfortably exceeding the 10K-word minimum while staying under 10%.
+### 4.3 Score Interpretation
 
-2. **CoNLL shared task standard.** The CoNLL 2017 and 2018 shared tasks on UD parsing established 10K words as the minimum threshold for a meaningful test set (Zeman et al., 2017; 2018). UDD-1's test set is more than double this minimum.
+| Range | Quality | Examples |
+|-------|---------|---------|
+| 0.95 - 0.99 | Excellent | Well-formed Vietnamese sentence, ideal length, no noise |
+| 0.80 - 0.95 | Good | Minor issues: slightly short/long, or light noise |
+| 0.50 - 0.80 | Marginal | Significant issues: markup remnants, unbalanced punctuation |
+| 0.10 - 0.50 | Poor | Multiple issues: heavy markup + structural problems |
+| 0.01 - 0.10 | Reject | Non-Vietnamese or nearly empty |
 
-3. **Comparable to major UD treebanks in absolute dev/test size.** Large UD treebanks allocate progressively smaller percentages to dev/test while maintaining sufficient absolute sizes:
+## 5. Sampling Strategy
 
-   | Treebank | Total | Dev | Test | Dev% | Test% |
-   |----------|-------|-----|------|------|-------|
-   | Czech-PDT | 213,897 | 22,666 | 20,187 | 10.6% | 9.4% |
-   | Korean-Kaist | 27,363 | 2,066 | 2,287 | 7.6% | 8.4% |
-   | English-EWT | 16,622 | 2,001 | 2,077 | 12.0% | 12.5% |
-   | Hindi-HDTB | 16,649 | 1,659 | 1,684 | 10.0% | 10.1% |
-   | French-GSD | 16,342 | 1,476 | 416 | 9.0% | 2.5% |
-   | Japanese-GSD | 8,100 | 507 | 543 | 6.3% | 6.7% |
-   | Vietnamese-VTB | 3,323 | 1,123 | 800 | 33.8% | 24.1% |
+- Each domain contributes exactly **20,000 unique sentences** (total: 100,000)
+- Sentences are collected sequentially from documents until the target count is reached
+- Both exact and near-duplicate deduplication are applied during extraction
+- For Wikipedia: only high-quality articles are used (quality_score >= 5)
+- For Books: books are processed in descending order of quality score
 
-   UDD-1's ~1,720-sentence dev/test sets are in the same range as English-EWT (~2,000) and Hindi-HDTB (~1,670).
+## 6. Train/Dev/Test Split
 
-4. **Maximizing training data.** Since UDD-1 is a silver-standard treebank intended for parser training, maximizing the training portion is beneficial. The dev/test sets at ~1,720 sentences each are large enough for reliable evaluation, while the remaining 91.4% provides maximum training signal (Nivre et al., 2020).
+After collecting all 100,000 sentences, the dataset is split using stratified sampling:
+
+| Split | Ratio | ~Sentences |
+|-------|-------|------------|
+| Train | 80% | ~80,000 |
+| Dev | 10% | ~10,000 |
+| Test | 10% | ~10,000 |
 
 ### Split Method
 
 - **Stratified by domain**: each domain is shuffled independently and split according to the ratios above, ensuring proportional representation across all splits
 - **Reproducible**: random seed = 42
 - Sentence IDs encode the domain: `vlc-` (legal), `uvn-` (news), `uvw-` (wikipedia), `uvb-f-` (fiction), `uvb-n-` (non-fiction)
-
-## References
-
-- de Marneffe, M.-C., Manning, C.D., Nivre, J., & Zeman, D. (2021). Universal Dependencies. *Computational Linguistics*, 47(2), 255-308. https://aclanthology.org/2021.cl-2.11/
-- Nivre, J., et al. (2020). Universal Dependencies v2: An Evergrowing Multilingual Treebank Collection. In *Proceedings of LREC 2020*, pp. 4034-4043. https://aclanthology.org/2020.lrec-1.497/
-- Zeman, D., et al. (2017). CoNLL 2017 Shared Task: Multilingual Parsing from Raw Text to Universal Dependencies. In *Proceedings of the CoNLL 2017 Shared Task*, pp. 1-19. https://aclanthology.org/K17-3001/
-- Zeman, D., et al. (2018). CoNLL 2018 Shared Task: Multilingual Parsing from Raw Text to Universal Dependencies. In *Proceedings of the CoNLL 2018 Shared Task*, pp. 1-21. https://aclanthology.org/K18-2001/

src/fetch_ws_sentences.py

@@ -22,11 +22,21 @@ import re
 from os.path import dirname, join
 
 from datasets import load_dataset
-from underthesea import sent_tokenize, text_normalize
+from underthesea import lang_detect, sent_tokenize, text_normalize
 
 
 TARGET_PER_DOMAIN = 20000
 
+# Vietnamese toned vowels — each syllable has at most one tone mark.
+# A whitespace-delimited token with 2+ toned vowels is glued text.
+TONED_VOWELS = set(
+    'áàảãạắằẳẵặấầẩẫậéèẻẽẹếềểễệíìỉĩịóòỏõọốồổỗộớờởỡợúùủũụứừửữựýỳỷỹỵ'
+    'ÁÀẢÃẠẮẰẲẴẶẤẦẨẪẬÉÈẺẼẸẾỀỂỄỆÍÌỈĨỊÓÒỎÕỌỐỒỔỖỘỚỜỞỠỢÚÙỦŨỤỨỪỬỮỰÝỲỶỸỴ'
+)
+
+# All Vietnamese diacritical characters (toned vowels + base vowels ă, â, ê, ô, ơ, ư, đ)
+VIET_DIACRITICS = TONED_VOWELS | set('ăâêôơưđĂÂÊÔƠƯĐ')
+
 
 # ============================================================================
 # Shared text cleaning
@@ -45,17 +55,180 @@ def clean_text(text):
     return text
 
 
+def safe_sent_tokenize(text):
+    """Sentence tokenize with fix for numbers split across sentence boundaries.
+
+    underthesea's sent_tokenize splits "2.000" into ["...hơn 2.", "000 học sinh..."].
+    This merges consecutive sentences where the split occurred inside a number.
+    """
+    raw_sents = sent_tokenize(text)
+    if not raw_sents:
+        return raw_sents
+    merged = [raw_sents[0]]
+    for sent in raw_sents[1:]:
+        prev = merged[-1]
+        # Previous ends with digit(s) + period, current starts with digit(s)
+        if re.search(r'\d\s*\.\s*$', prev) and re.match(r'\d', sent):
+            merged[-1] = prev + sent
+        else:
+            merged.append(sent)
+    return merged
+
+
+def sentence_score(sent):
+    """Score a sentence's quality on a (0, 1) scale.
+
+    Combines 6 sub-scores:
+      1. Length score     — Gaussian around ideal range [60, 200] chars
+      2. Word count score — Gaussian around ideal range [8, 35] words
+      3. Vietnamese density — ratio of Vietnamese diacritical chars to total letters
+      4. Structure score  — proper start (uppercase/digit) + proper end (punctuation)
+      5. Cleanliness score — absence of markup, unbalanced brackets, glued text
+      6. Completeness score — balanced quotes, no trailing fragments
+
+    Returns a float in (0, 1). Higher is better.
+    """
+    import math
+
+    sent = sent.strip()
+    if not sent:
+        return 0.0
+
+    # --- 1. Length score (0-1): Gaussian penalty outside [60, 200] ---
+    char_len = len(sent)
+    if 60 <= char_len <= 200:
+        len_score = 1.0
+    elif char_len < 60:
+        len_score = math.exp(-0.5 * ((char_len - 60) / 30) ** 2)
+    else:
+        len_score = math.exp(-0.5 * ((char_len - 200) / 60) ** 2)
+
+    # --- 2. Word count score (0-1): Gaussian penalty outside [8, 35] ---
+    words = sent.split()
+    wc = len(words)
+    if 8 <= wc <= 35:
+        wc_score = 1.0
+    elif wc < 8:
+        wc_score = math.exp(-0.5 * ((wc - 8) / 3) ** 2)
+    else:
+        wc_score = math.exp(-0.5 * ((wc - 35) / 10) ** 2)
+
+    # --- 3. Vietnamese density (0-1): diacritical chars / total letters ---
+    total_letters = sum(1 for c in sent if c.isalpha())
+    viet_chars = sum(1 for c in sent if c in VIET_DIACRITICS)
+    viet_score = min(viet_chars / max(total_letters, 1) * 5, 1.0)  # 20%+ diacritics → 1.0
+
+    # --- 4. Structure score (0-1): start + end quality ---
+    start_ok = 0.5 if (sent[0].isupper() or sent[0].isdigit()) else 0.0
+    end_ok = 0.5 if sent[-1] in '.!?…"»"\'):' else 0.0
+    struct_score = start_ok + end_ok
+
+    # --- 5. Cleanliness score (0-1): penalty for noise signals ---
+    clean_score = 1.0
+    # Markup characters
+    if re.search(r'[{}<>|]', sent):
+        clean_score -= 0.3
+    if re.search(r'\w+=\w+', sent):
+        clean_score -= 0.2
+    # Unbalanced brackets
+    for o, c in [('(', ')'), ('[', ']')]:
+        if sent.count(o) != sent.count(c):
+            clean_score -= 0.2
+            break
+    # Glued text
+    for token in words:
+        tone_count = sum(1 for ch in token if ch in TONED_VOWELS)
+        if tone_count >= 2:
+            clean_score -= 0.3
+            break
+        if tone_count >= 1 and re.search(r'\d[a-zA-ZĐđÀ-ỹ]', token):
+            clean_score -= 0.3
+            break
+    # File extensions
+    if re.search(r'\.(jpg|jpeg|png|gif|svg|webp)\b', sent, re.IGNORECASE):
+        clean_score -= 0.2
+    # Excessive uppercase
+    if sum(1 for c in sent if c.isupper()) > len(sent) * 0.5:
+        clean_score -= 0.2
+    clean_score = max(clean_score, 0.0)
+
+    # --- 6. Completeness score (0-1): balanced quotes, no fragments ---
+    comp_score = 1.0
+    # Unbalanced quotes
+    double_quotes = sent.count('"') + sent.count('\u201c') + sent.count('\u201d')
+    if double_quotes % 2 != 0:
+        comp_score -= 0.2
+    # Excessive digit ratio
+    digit_ratio = sum(1 for c in sent if c.isdigit()) / max(len(sent), 1)
+    if digit_ratio > 0.3:
+        comp_score -= 0.3
+    elif digit_ratio > 0.2:
+        comp_score -= 0.1
+    comp_score = max(comp_score, 0.0)
+
+    # --- Weighted combination ---
+    # Vietnamese density is a multiplier (gate): non-Vietnamese → near 0
+    base_score = (
+        0.20 * len_score
+        + 0.15 * wc_score
+        + 0.20 * struct_score
+        + 0.30 * clean_score
+        + 0.15 * comp_score
+    )
+    score = base_score * viet_score
+    return round(max(0.01, min(score, 0.99)), 4)
+
+
 def base_valid(sent):
-    """Shared base validation: length, Vietnamese diacritics, uppercase ratio."""
+    """Shared base validation: length, word count, structure, language, punctuation, markup."""
     sent = sent.strip()
     if not sent:
         return False, sent
     if len(sent) < 20 or len(sent) > 300:
         return False, sent
+    # Minimum word count — ensures enough syntactic structure
+    if len(sent.split()) < 4:
+        return False, sent
+    # Must start with uppercase letter or digit
+    if not sent[0].isupper() and not sent[0].isdigit():
+        return False, sent
+    # Must end with proper punctuation (including : and ) for legal/academic)
+    if sent[-1] not in '.!?…"»"\'):':
+        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
+    # Markup characters — reject template/HTML remnants
+    if re.search(r'[{}<>]', sent):
+        return False, sent
+    if '|' in sent:
+        return False, sent
+    # Template-like = (no spaces): reject "key=value" but allow "x = y"
+    if re.search(r'\w+=\w+', sent):
+        return False, sent
+    # Unbalanced brackets — opening and closing counts must match
+    for open_ch, close_ch in [('(', ')'), ('[', ']')]:
+        if sent.count(open_ch) != sent.count(close_ch):
+            return False, sent
+    # File extension remnants (wiki image markup)
+    if re.search(r'\.(jpg|jpeg|png|gif|svg|webp)\b', sent, re.IGNORECASE):
+        return False, sent
+    # Glued text — two syllables merged without space
+    for token in sent.split():
+        tone_count = sum(1 for c in token if c in TONED_VOWELS)
+        # Vietnamese syllable has at most 1 tone mark; 2+ means glued (e.g., "lõmlà")
+        if tone_count >= 2:
+            return False, sent
+        # Digit glued to Vietnamese text (e.g., "59Sẹo")
+        if tone_count >= 1 and re.search(r'\d[a-zA-ZĐđÀ-ỹ]', token):
+            return False, sent
+    # Language detection with Vietnamese diacritics fallback
+    if lang_detect(sent) != "vi":
+        # Fallback: accept if sentence has 3+ Vietnamese diacritical characters
+        viet_char_count = sum(1 for c in sent if c in VIET_DIACRITICS)
+        if viet_char_count < 3:
+            return False, sent
     return True, sent
 
 
@@ -128,9 +301,7 @@ def is_valid_wiki(sent):
     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:
+    if sent.count('|') >= 2:
         return False, sent
     # Skip reference fragments
     if re.search(r'\[\d+\]', sent):
@@ -150,9 +321,9 @@ def is_valid_wiki(sent):
 
 
 def is_valid_book(sent):
-    """Validate sentence from book domain (UVB-v0.1) — stricter quality."""
-    sent = sent.strip()
-    if not sent:
+    """Validate sentence from book domain (UVB-v0.1) — stricter quality on top of base_valid."""
+    ok, sent = base_valid(sent)
+    if not ok:
         return False, sent
     # Stricter length
     if len(sent) < 30 or len(sent) > 250:
@@ -161,18 +332,9 @@ def is_valid_book(sent):
     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
@@ -183,7 +345,7 @@ def is_valid_book(sent):
     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 '.,;:!?-–—()[]{}""\'\'«»')
+    punct_count = sum(1 for c in sent if c in '.,;:!?-\u2013\u2014()[]""\'\'\xab\xbb')
     if punct_count > len(words) * 1.5:
         return False, sent
     # Skip incomplete sentences (ellipsis in middle)
@@ -236,38 +398,149 @@ def classify_book(genres):
 # Sentence extraction helpers
 # ============================================================================
 
+def normalize_for_dedup(sent):
+    """Normalize sentence for near-duplicate detection.
+
+    Replaces all digit sequences with '#' so that sentences differing only
+    in numbers (e.g., article numbers, amounts) are treated as duplicates.
+    Also lowercases for case-insensitive matching.
+    """
+    return re.sub(r'\d+', '#', sent.lower())
+
+
+MAX_PER_DOC = 500  # Cap sentences per document to ensure source diversity
+
+
 def extract_sentences(docs, validator, target, label=""):
-    """Extract validated sentences from documents until target count reached."""
-    sentences = []
+    """Extract validated, deduplicated sentences from documents via round-robin.
+
+    Phase 1: Scan all documents, collect up to MAX_PER_DOC valid sentences each.
+    Phase 2: Round-robin across documents to ensure even source representation.
+    """
+    # Phase 1: collect candidate sentences per document
+    doc_pools = []  # list of [sentences]
     for idx, doc in enumerate(docs):
         content = doc["content"]
         content = clean_text(content)
-        for sent in sent_tokenize(content):
+        sents = []
+        for sent in safe_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")
+                sents.append(cleaned)
+            if len(sents) >= MAX_PER_DOC:
+                break
+        if sents:
+            doc_pools.append(sents)
+        if (idx + 1) % 200 == 0:
+            print(f"  {label}: [{idx+1}] docs scanned, {len(doc_pools)} with valid sentences")
+        # Stop scanning if we have enough candidates (3x target for safety)
+        total_candidates = sum(len(s) for s in doc_pools)
+        if total_candidates >= target * 3:
+            print(f"  {label}: [{idx+1}] docs scanned, {len(doc_pools)} with candidates, {total_candidates:,} total")
+            break
+
+    if not doc_pools:
+        return []
+
+    total_candidates = sum(len(s) for s in doc_pools)
+    print(f"  {label}: {len(doc_pools)} docs with candidates, {total_candidates:,} total candidate sentences")
+
+    # Phase 2: round-robin selection with dedup
+    sentences = []
+    seen = set()
+    seen_normalized = set()
+    round_idx = 0
+
+    while len(sentences) < target and doc_pools:
+        made_progress = False
+        for i in range(len(doc_pools)):
+            sents = doc_pools[i]
+            if round_idx >= len(sents):
+                continue
+            cleaned = sents[round_idx]
+            if cleaned in seen:
+                continue
+            norm = normalize_for_dedup(cleaned)
+            if norm in seen_normalized:
+                continue
+            seen.add(cleaned)
+            seen_normalized.add(norm)
+            sentences.append(cleaned)
+            made_progress = True
+            if len(sentences) >= target:
+                break
+        if not made_progress:
             break
+        # Remove exhausted documents
+        doc_pools = [s for s in doc_pools if round_idx + 1 < len(s)]
+        round_idx += 1
+
+    print(f"  {label}: {len(sentences):,} sentences from {round_idx} rounds")
     return sentences[:target]
 
 
+MAX_PER_BOOK = 500  # Cap sentences per book to ensure source diversity
+
+
 def extract_book_sentences(books, target, label=""):
-    """Extract validated sentences from books until target count reached."""
-    sentences = []
+    """Extract validated, deduplicated sentences from books via round-robin.
+
+    Phase 1: Extract up to MAX_PER_BOOK valid sentences from each book.
+    Phase 2: Round-robin across all books to ensure even representation.
+    """
+    # Phase 1: collect candidate sentences per book
+    book_pools = []  # list of (title, [sentences])
     for i, book in enumerate(books):
-        if len(sentences) >= target:
-            break
         content = clean_text(book["content"])
-        for sent in sent_tokenize(content):
+        sents = []
+        for sent in safe_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")
+                sents.append(cleaned)
+            if len(sents) >= MAX_PER_BOOK:
+                break
+        if sents:
+            book_pools.append((book["title"], sents))
+        if (i + 1) % 50 == 0:
+            print(f"  {label}: [{i+1}/{len(books)}] books scanned, {len(book_pools)} with valid sentences")
+
+    total_candidates = sum(len(s) for _, s in book_pools)
+    print(f"  {label}: {len(book_pools)} books with candidates, {total_candidates:,} total candidate sentences")
+
+    # Phase 2: round-robin selection with dedup
+    sentences = []
+    seen = set()
+    seen_normalized = set()
+    round_idx = 0
+    books_contributed = set()
+
+    while len(sentences) < target and book_pools:
+        made_progress = False
+        for i in range(len(book_pools)):
+            title, sents = book_pools[i]
+            if round_idx >= len(sents):
+                continue
+            cleaned = sents[round_idx]
+            if cleaned in seen:
+                continue
+            norm = normalize_for_dedup(cleaned)
+            if norm in seen_normalized:
+                continue
+            seen.add(cleaned)
+            seen_normalized.add(norm)
+            sentences.append(cleaned)
+            books_contributed.add(title)
+            made_progress = True
+            if len(sentences) >= target:
+                break
+        if not made_progress:
+            break
+        # Remove exhausted books
+        book_pools = [(t, s) for t, s in book_pools if round_idx + 1 < len(s)]
+        round_idx += 1
+
+    print(f"  {label}: {len(sentences):,} sentences from {len(books_contributed)} books ({round_idx} rounds)")
     return sentences[:target]