File size: 8,481 Bytes
ad01ed3 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 | //! Whitespace / Word parity: the atom masks vs the OLD pretokenizers' actual engines.
//!
//! Part A (definitive, no data): for every codepoint, does atom `WORD` == onig `\w` and atom `WS`
//! == onig `\s`? onig is exactly what HF `SysRegex` uses, so this is the ground truth for the
//! `Whitespace` (`\w+|[^\w\s]+`) pretokenizer. Also cross-checked against the `regex` crate
//! (Unicode \p{word}/\p{White_Space}) and `std::char::is_whitespace` (WhitespaceSplit's engine).
//! Part B (span gate): run the two atom FSMs over real multilingual text (benches/data + tests/data/xnli
//! if present) and diff spans against the reference engines.
//!
//! run: cargo test --release --test wsplit_parity -- --nocapture
use fast_split::classify::{classify, in_mask, mask, Atoms};
use fast_split::fsm::{self, Behavior};
use onig::Regex as Onig;
// ── atom membership for a single char ──────────────────────────────────────────────────────────
fn atom_tag(ch: char) -> u8 {
let mut buf = [0u8; 4];
let b = ch.encode_utf8(&mut buf).as_bytes();
let mut tags = [0u8; 4];
classify::<Atoms>(b, &mut tags[..b.len()]);
tags[0]
}
fn atom_word(ch: char) -> bool { in_mask(atom_tag(ch), mask::WORD) }
fn atom_ws(ch: char) -> bool { in_mask(atom_tag(ch), mask::WS) }
fn cp_name(cp: u32) -> &'static str {
match cp {
0x09 => "TAB", 0x0A => "LF", 0x0B => "VT", 0x0C => "FF", 0x0D => "CR", 0x20 => "SPACE",
0x85 => "NEL", 0xA0 => "NBSP", 0x1680 => "OGHAM SP", 0x2007 => "FIGURE SP",
0x2009 => "THIN SP", 0x2028 => "LINE SEP", 0x2029 => "PARA SEP", 0x202F => "NARROW NBSP",
0x205F => "MMSP", 0x3000 => "IDEOGRAPHIC SP", 0x180E => "MONGOLIAN VOWEL SEP",
0x200B => "ZWSP", 0x200C => "ZWNJ", 0x200D => "ZWJ", 0x5F => "LOW LINE",
0xBD => "1/2", 0xBC => "1/4", 0xB2 => "SUPER 2", 0x2168 => "ROMAN IX", _ => "",
}
}
#[test]
fn a_codepoint_diff_word_and_ws() {
let w_onig = Onig::new(r"\A\w\z").unwrap();
let s_onig = Onig::new(r"\A\s\z").unwrap();
let w_re = regex::Regex::new(r"\A\w\z").unwrap();
let s_re = regex::Regex::new(r"\A\s\z").unwrap();
// divergence buckets: (label, list of cps)
let mut w_atom_vs_onig: Vec<u32> = vec![]; // atom \w != onig \w (THE gate for `Whitespace`)
let mut w_atom_vs_re: Vec<u32> = vec![]; // atom \w != Unicode \p{word}
let mut w_onig_vs_re: Vec<u32> = vec![]; // onig \w != Unicode \p{word} (is onig standard?)
let mut s_atom_vs_onig: Vec<u32> = vec![];
let mut s_atom_vs_re: Vec<u32> = vec![];
let mut s_atom_vs_std: Vec<u32> = vec![]; // atom \s != std::char::is_whitespace (WhitespaceSplit gate)
let mut s_onig_vs_std: Vec<u32> = vec![];
for cp in 0u32..=0x10FFFF {
if (0xD800..=0xDFFF).contains(&cp) { continue; }
let ch = char::from_u32(cp).unwrap();
let mut buf = [0u8; 4];
let s = ch.encode_utf8(&mut buf);
let aw = atom_word(ch);
let ow = w_onig.find(s).is_some();
let rw = w_re.is_match(s);
if aw != ow { w_atom_vs_onig.push(cp); }
if aw != rw { w_atom_vs_re.push(cp); }
if ow != rw { w_onig_vs_re.push(cp); }
let as_ = atom_ws(ch);
let os = s_onig.find(s).is_some();
let rs = s_re.is_match(s);
let ss = ch.is_whitespace();
if as_ != os { s_atom_vs_onig.push(cp); }
if as_ != rs { s_atom_vs_re.push(cp); }
if as_ != ss { s_atom_vs_std.push(cp); }
if os != ss { s_onig_vs_std.push(cp); }
}
let show = |name: &str, v: &[u32]| {
println!(" {name}: {} divergent cp(s)", v.len());
for &cp in v.iter().take(40) {
let ch = char::from_u32(cp).unwrap();
let nm = cp_name(cp);
let a = if atom_word(ch) { "W" } else { "." };
let s = if atom_ws(ch) { "S" } else { "." };
println!(" U+{cp:04X} [{a}{s}] {nm:<22} {ch:?}");
}
if v.len() > 40 { println!(" … +{} more", v.len() - 40); }
};
println!("\n=== PART A — all-codepoint property diff ===");
println!("\n-- WORD (\\w) --");
show("atom \\w vs onig \\w [Whitespace GATE]", &w_atom_vs_onig);
show("atom \\w vs Unicode \\p{{word}}", &w_atom_vs_re);
show("onig \\w vs Unicode \\p{{word}}", &w_onig_vs_re);
println!("\n-- WS (\\s) --");
show("atom \\s vs onig \\s [Whitespace GATE]", &s_atom_vs_onig);
show("atom \\s vs Unicode \\p{{White_Space}}", &s_atom_vs_re);
show("atom \\s vs std::is_whitespace [WhitespaceSplit GATE]", &s_atom_vs_std);
show("onig \\s vs std::is_whitespace", &s_onig_vs_std);
// The two gates that actually decide pretokenizer parity:
println!("\n=== GATES ===");
println!(" Whitespace (\\w): atom==onig? {}", w_atom_vs_onig.is_empty());
println!(" Whitespace (\\s): atom==onig? {}", s_atom_vs_onig.is_empty());
println!(" WhitespaceSplit : atom \\s == std::is_whitespace? {}", s_atom_vs_std.is_empty());
}
// ── Part B: span parity over real corpora ───────────────────────────────────────────────────────
fn fsm_whitespace(text: &[u8]) -> Vec<(usize, usize)> {
let mut tags = vec![0u8; text.len()];
classify::<Atoms>(text, &mut tags);
let mut out = Vec::new();
fsm::fsm_class_runs::<{ mask::WS }, 0, { mask::WORD }>(text, &tags, &mut out);
out.iter().map(|&(a, b)| (a as usize, b as usize)).collect()
}
fn fsm_wssplit(text: &[u8]) -> Vec<(usize, usize)> {
let mut tags = vec![0u8; text.len()];
classify::<Atoms>(text, &mut tags);
let mut out = Vec::new();
fsm::fsm_split::<{ mask::WS }, { Behavior::Removed as u8 }>(text, &tags, &mut out);
out.iter().map(|&(a, b)| (a as usize, b as usize)).collect()
}
fn ref_whitespace(text: &str, re: &Onig) -> Vec<(usize, usize)> {
re.find_iter(text).collect()
}
fn ref_wssplit(text: &str) -> Vec<(usize, usize)> {
let mut out = Vec::new();
let mut start: Option<usize> = None;
for (i, ch) in text.char_indices() {
if ch.is_whitespace() {
if let Some(st) = start.take() { out.push((st, i)); }
} else if start.is_none() {
start = Some(i);
}
}
if let Some(st) = start { out.push((st, text.len())); }
out
}
fn diff_report(tag: &str, file: &str, text: &str, got: &[(usize, usize)], want: &[(usize, usize)]) -> usize {
if got == want { return 0; }
println!(" MISMATCH [{tag}] {file}: got {} spans, want {} spans", got.len(), want.len());
let mut shown = 0;
for i in 0..got.len().max(want.len()) {
let g = got.get(i).copied();
let w = want.get(i).copied();
if g != w {
let ctx = w.or(g).map(|(a, b)| {
let a = a.saturating_sub(8);
let b = (b + 8).min(text.len());
&text[a..b]
}).unwrap_or("");
println!(" #{i}: got {g:?} want {w:?} near {ctx:?}");
shown += 1;
if shown >= 6 { println!(" …"); break; }
}
}
1
}
#[test]
fn b_span_parity_corpora() {
let re_ws = Onig::new(r"\w+|[^\w\s]+").unwrap();
let dirs = ["benches/data", "tests/data/xnli"];
let mut files: Vec<std::path::PathBuf> = vec![];
for d in dirs {
if let Ok(rd) = std::fs::read_dir(d) {
for e in rd.flatten() {
let p = e.path();
if p.extension().map_or(false, |x| x == "txt") { files.push(p); }
}
}
}
files.sort();
assert!(!files.is_empty(), "no corpus files found in benches/data or tests/data/xnli");
println!("\n=== PART B — span parity over {} files ===", files.len());
let mut fails = 0;
for p in &files {
let text = std::fs::read_to_string(p).unwrap();
let name = p.file_name().unwrap().to_string_lossy().to_string();
let b = text.as_bytes();
fails += diff_report("Whitespace", &name, &text, &fsm_whitespace(b), &ref_whitespace(&text, &re_ws));
fails += diff_report("WhitespaceSplit", &name, &text, &fsm_wssplit(b), &ref_wssplit(&text));
}
println!(" files clean: {}/{}", (files.len() * 2 - fails), files.len() * 2);
assert_eq!(fails, 0, "{fails} corpus/pretokenizer pairs diverged (see above)");
}
|