From db6ec36050ee4e6b7368f6f2d0f3b4f4933b4603 Mon Sep 17 00:00:00 2001 From: Ethan Zou Date: Thu, 19 Nov 2026 07:21:30 +0800 Subject: [PATCH 1/4] =?UTF-8?q?=E6=8E=92=E5=BA=8F=E4=B8=8D=E5=8F=98?= =?UTF-8?q?=E9=87=8F=EF=BC=9A=E5=85=A8=E9=83=A8=E8=AF=84=E6=B5=8B=E7=94=A8?= =?UTF-8?q?=E4=BE=8B=E9=80=90=E9=94=AE=E6=89=93=E4=B8=80=E9=81=8D=E6=9F=A5?= =?UTF-8?q?=E3=80=8C=E6=B0=B8=E8=BF=9C=E4=B8=8D=E8=AE=B8=E5=87=BA=E7=8E=B0?= =?UTF-8?q?=E3=80=8D=E7=9A=84=E7=BB=93=E6=9E=9C=EF=BC=8C=E6=9F=A5=E5=87=BA?= =?UTF-8?q?=E6=9D=A5=E7=9A=84=E4=B8=89=E7=B1=BB=E4=BF=AE=E6=8E=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit cehaohou 那种只剩两个纠错候选的结果,top1 评测里只少一条,看不出来。新加 wowtype-eval --invariants (scripts/invariants.sh,CI 在排序评测后面跑):tools/eval 的 7239 条用例逐键打(2.4 万个前缀), 每个前缀不带上文、带用例的上文、带「我本地」各查一次,可选再带神经语言模型,检查六条硬规则: 打对了的拼音第一个不是纠错的、第一个音节的单字一直在、候选不会只剩几个、加了上文或模型照着打的读法还在、 不重复。规则、和 librime / libime / libpinyin 的对照写在 docs/ENGINE-INVARIANTS.md。 修了的三处: - 第一名是纠错的时(yusezhi 的「越职」、gaj 的「感」),句首词也按照着打的读法的音节边界对齐。 以前只按纠错的音节对齐,yu、ga 的单字和句首词全被筛掉,yusezhi 整个候选框只有 6 个。 - protect_exact_input 之后按位置再拦一次:纠错的不排在第一个照着打的读法前面(音节更少的除外)。 sheihaiyo 以前出「谁还要」:压它用的基准是补全的「谁还有」,补全的被挪走以后它又成了第一。 - 模糊音兜底的词标上 Feature::fuzzy(不进权重),compose_candidates 不拿它筛硬凑的整句。 接着上文打 ninke 以前只剩「宁可」,照着打的「您可」整个没了。 评测(/usr/share/wowtype 的数据,rime-ice 927e1cf1,和基线同一份):各组和基线持平(逐组 +0.0)。 --- .github/workflows/ci.yml | 8 + core/src/bin/common/invariants.rs | 624 ++++++++++++++++++++++++++++++ core/src/bin/eval.rs | 63 ++- core/src/lib.rs | 216 ++++++++++- core/src/rank.rs | 3 + docs/ENGINE-INVARIANTS.md | 199 ++++++++++ docs/ENGINE.md | 13 + scripts/invariants.sh | 90 +++++ tools/eval/README.md | 8 + tools/eval/invariants-allow.tsv | 3 + 10 files changed, 1201 insertions(+), 26 deletions(-) create mode 100644 core/src/bin/common/invariants.rs create mode 100644 docs/ENGINE-INVARIANTS.md create mode 100755 scripts/invariants.sh create mode 100644 tools/eval/invariants-allow.tsv diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d4466af5..5b872089 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -231,6 +231,14 @@ jobs: fi - name: 评测(回归集必须全过,其余各组和基线比) run: scripts/eval.sh "$EVAL_DATA" + - name: 排序不变量(全部用例逐键打,一条都不许违反) + # 「照着打的拼音不被纠错抢第一」「第一个音节的单字一直在」这类规则,见 docs/ENGINE-INVARIANTS.md。 + # 复用上一步编好的 wowtype-eval;不带神经语言模型(data 任务不下载 nnlm.bin),带模型的本地跑: + # scripts/invariants.sh <数据目录> --nnlm + if: ${{ !cancelled() }} + env: + WOWTYPE_EVAL_BIN: target/release/wowtype-eval + run: scripts/invariants.sh "$EVAL_DATA" addon: name: 插件 · ${{ matrix.distro }} · ${{ matrix.arch }} diff --git a/core/src/bin/common/invariants.rs b/core/src/bin/common/invariants.rs new file mode 100644 index 00000000..23af4db8 --- /dev/null +++ b/core/src/bin/common/invariants.rs @@ -0,0 +1,624 @@ +//! `wowtype-eval --invariants`:把评测集里的每个输入逐键打一遍,检查「无论排序怎么调都不许出现」的结果。 +//! +//! 排序评测(top1 命中率)只能说明「大多数时候第一个对」,说明不了「这种离谱的结果从来不会有」: +//! `cehaohou` 只剩「的好后」「得好后」两个候选(72bf8e2 修的)时,top1 统计里只少了一条。 +//! 这里的每条规则都是硬的——一条都不许违反(`tools/eval/invariants-allow.tsv` 里写明了理由的除外)。 +//! 规则的来历和成熟输入法(librime、libime、libpinyin)的做法见 `docs/ENGINE-INVARIANTS.md`。 +//! +//! 每个前缀(`c`、`ce`、`ceh`……)在几种条件下各查一次:没有上文、用例自带的上文、`--inv-context` +//! 给的上文;给了 `--nnlm` 时每种再带上神经语言模型查一次。规则: +//! +//! - **typed-first**:输入能整个切成完整音节(不靠纠错、补全)时,第一个候选不是纠错出来的。 +//! 例外和 `typed_reading_first` 一样:纠错以后音节更少(`shijain` 照字母读是 shi jia in,纠一处是「时间」)。 +//! - **typed-first-partial**:不靠纠错、只靠末音节补全能读通时(`ceh` = ce + h…),第一个候选也不是纠错出来的 +//! (同样的音节数例外)。 +//! - **first-syllable-chars**:照着打的读法(不纠错,末音节可以补全)有两个以上音节时,第一个音节的单字在候选里 +//! (`cehao` 里要有「测」:整句不对时用户要一个字一个字选)。切法不止一种时(`kenengs` = ke neng s / ken eng s) +//! 只要第一个候选用的那种;第一个候选是纠错出来的,每种都要。 +//! - **min-candidates**:第一个音节是完整音节时,候选(不算原始串)至少有 min(9, 这个音节的常用单字数) 个。 +//! - **typed-kept**:没有上文、不带神经语言模型时照着打的那个读法(第一个不纠错、用完整个输入的候选), +//! 加了上文或者带上模型以后还在:它是词库里的一个词时这个词还在候选里;是几个词拼的整句时, +//! 至少还有一个照着打的整句(拼法可以换:晚 | 事儿 → 碗 | 事儿)。 +//! - **no-duplicates**:候选里没有字和用掉的键都一样的两条。 + +use std::collections::{HashMap, HashSet}; +use std::fmt::Write as _; +use std::sync::Arc; + +use wowtype_core::nnlm::Nnlm; +use wowtype_core::syllable::parse; +use wowtype_core::{ + Candidate, EdgeKind, Engine, GraphMode, GraphOptions, Lexicon, Syllable, SyllableGraph, + SyllableQuery, +}; + +/// 一页候选的个数(min-candidates 的上限)。 +const PAGE: usize = 9; + +pub struct Options { + /// 每个前缀都额外带上这些上文各查一次。 + pub contexts: Vec, + /// 每条规则最多打印几条违反(0 = 全打)。 + pub limit: usize, + /// 已知违反的清单(规则、输入、上文、理由)。 + pub allow: Option, + /// 违反写进这个文件(全部,TSV)。 + pub out: Option, +} + +/// 一个输入(一次按键后的整串)在音节图上的形状,和排序无关。 +struct Shape { + /// 只用完整音节(不纠错、不补全)切完的最少音节数。 + exact: Option, + /// 不纠错、末音节可以补全时切完的最少音节数。 + no_typo: Option, + /// 不纠错(末音节可以补全)、音节最少的切法里第一个音节的拼音;最少音节数小于 2 时为空。 + first: Vec, + /// 第一个音节本身是个完整音节、打全了(单音节输入就是整个输入):min-candidates 看它的单字数。 + head: Vec, +} + +fn shape(input: &str, lexicon: &dyn Lexicon, chars: &mut HashMap) -> Option { + let parsed = parse(&input.to_ascii_lowercase()).ok()?; + if parsed.is_empty() { + return None; + } + let graph = SyllableGraph::build( + &parsed, + GraphOptions { + mode: GraphMode::Full, + allow_erhua: true, + typo: false, + completion: true, + }, + ); + let n = graph.len(); + // 词库里一个字都没有的音节(nia、hm……)不算「照着打能读」:zuinia 照着打是 zui ni a,不是 zui nia。 + // 补全边的音节是补出来的,不查 + let mut has_chars = HashMap::new(); + for pos in 0..n { + for e in graph.edges_from(pos) { + if e.completion == 0 && matches!(e.kind, EdgeKind::Full { .. }) { + let text = e.display(); + has_chars + .entry(text.clone()) + .or_insert_with(|| char_count(lexicon, chars, &text) > 0); + } + } + } + let usable = |e: &wowtype_core::Edge| { + e.completion > 0 || has_chars.get(&e.display()).copied().unwrap_or(false) + }; + // 从每个位置走到底最少几个音节 + let min_from = |allow_completion: bool| -> Vec> { + let mut best = vec![None; n + 1]; + best[n] = Some(0); + for pos in (0..n).rev() { + best[pos] = graph + .edges_from(pos) + .iter() + .filter(|e| !e.typo && (allow_completion || e.completion == 0) && usable(e)) + .filter_map(|e| best[e.end].map(|b| b + e.syllable_count())) + .min(); + } + best + }; + let exact = min_from(false); + let no_typo = min_from(true); + let plain_syllable = |e: &&wowtype_core::Edge| { + !e.typo && e.completion == 0 && matches!(e.kind, EdgeKind::Full { erhua: false, .. }) + }; + let mut first = Vec::new(); + if let Some(total) = no_typo[0].filter(|&t| t >= 2) { + for e in graph.edges_from(0).iter().filter(plain_syllable) { + if no_typo[e.end].is_some_and(|rest| rest + 1 == total) { + first.push(e.display()); + } + } + } + let mut head = first.clone(); + if head.is_empty() && exact[0] == Some(1) { + head.extend( + graph + .edges_from(0) + .iter() + .filter(plain_syllable) + .filter(|e| e.end == n) + .map(|e| e.display()), + ); + } + first.sort(); + first.dedup(); + head.sort(); + head.dedup(); + Some(Shape { + exact: exact[0], + no_typo: no_typo[0], + first, + head, + }) +} + +fn is_raw(c: &Candidate) -> bool { + c.words.len() == 1 && c.words[0].pinyin.is_empty() +} + +fn syllables(c: &Candidate) -> usize { + c.pinyin.split_whitespace().count() +} + +fn typo(c: &Candidate) -> bool { + c.features.typo_count > 0.0 +} + +/// 每个词在词库里真有这个读音(模糊音兜底的「朋友」penyou、「最近」zuijing 不算照着打的)。 +fn lexicon_reading(lexicon: &dyn Lexicon, c: &Candidate) -> bool { + !c.words.is_empty() + && c.words.iter().all(|w| { + let query: Option> = w + .pinyin + .split_whitespace() + .map(|s| Syllable::from_text(s).map(|s| s.query(false))) + .collect(); + query.is_some_and(|q| { + !q.is_empty() && lexicon.lookup(&q).iter().any(|e| e.word == w.text) + }) + }) +} + +/// 照着打的那个读法:第一个不纠错、用完整个输入、每个词词库里真有这个读音的中文候选。 +fn typed_reading<'a>( + lexicon: &dyn Lexicon, + cands: &'a [Candidate], + len: usize, +) -> Option<&'a Candidate> { + cands + .iter() + .find(|c| !is_raw(c) && !typo(c) && c.consumed >= len && lexicon_reading(lexicon, c)) +} + +/// 照着打的读法是不是词库里的一个词(不是几个词拼出来的整句)。 +fn is_word(c: &Candidate) -> bool { + c.words.len() == 1 && c.words[0].known +} + +/// 候选前几个的简写:纠错的后面标 `*`,句首词标 `…`。 +fn brief(cands: &[Candidate], len: usize, n: usize) -> String { + let mut out: Vec = cands + .iter() + .take(n) + .map(|c| { + let mut s = c.text.clone(); + if typo(c) { + s.push('*'); + } + if c.consumed < len { + s.push('…'); + } + s + }) + .collect(); + if cands.len() > n { + out.push(format!("……共 {} 个", cands.len())); + } + out.join(" ") +} + +struct Violation { + rule: &'static str, + input: String, + context: String, + nnlm: bool, + detail: String, +} + +impl Violation { + fn key(&self) -> (String, String, String) { + ( + self.rule.to_string(), + self.input.clone(), + self.context.clone(), + ) + } +} + +/// 单字数:这个音节的常用单字有几个(min-candidates 的门槛)。 +fn char_count(lexicon: &dyn Lexicon, cache: &mut HashMap, syllable: &str) -> usize { + if let Some(&n) = cache.get(syllable) { + return n; + } + let n = parse(syllable) + .ok() + .map(|p| { + let g = SyllableGraph::build(&p, GraphOptions::default()); + g.edges_from(0) + .iter() + .filter(|e| { + e.end == g.len() && matches!(e.kind, EdgeKind::Full { erhua: false, .. }) + }) + .map(|e| { + let q: Vec = vec![e.query()]; + lexicon + .lookup_common(&q) + .iter() + .filter(|w| w.word.chars().count() == 1) + .count() + }) + .max() + .unwrap_or(0) + }) + .unwrap_or(0); + cache.insert(syllable.to_string(), n); + n +} + +/// 一种条件下查出来的候选要满足的规则(typed-kept 另算)。 +fn check_one( + input: &str, + shape: &Shape, + cands: &[Candidate], + lexicon: &dyn Lexicon, + chars: &mut HashMap, + mut report: impl FnMut(&'static str, String), +) { + let len = input.len(); + let top = cands.iter().find(|c| !is_raw(c)); + // typed-first / typed-first-partial + if let Some(top) = top.filter(|c| typo(c)) { + let (rule, need) = match (shape.exact, shape.no_typo) { + (Some(n), _) => ("typed-first", Some(n)), + (None, Some(n)) => ("typed-first-partial", Some(n)), + _ => ("", None), + }; + // 照着打的音节词库里一个字都没有(ng、hm):没有可排的,纠错出来的排第一不算 + let typed_has_chars = shape + .head + .iter() + .chain(&shape.first) + .any(|s| char_count(lexicon, chars, s) > 0); + if let Some(need) = need.filter(|_| typed_has_chars) { + // 纠错以后整个输入用更少的音节读完,是在把输入解释得更省(shijain -> 时间),不算 + let fewer = top.consumed >= len && syllables(top) < need; + if !fewer { + report( + rule, + format!( + "第一个是纠错出来的「{}」({}),照着打能读成 {need} 个音节", + top.text, top.pinyin + ), + ); + } + } + } + // first-syllable-chars:照着打的切法不止一种时(kenengs = ke neng s / ken eng s),候选里第一个照着打的读法 + // 用的是其中一种,就只要这一种的单字(hung 的「混个」hun g…,不要求 hu ng 的「虎」);一个照着打的读法都没有时,每种都要 + let top_first = typed_reading(lexicon, cands, len) + .and_then(|c| c.pinyin.split_whitespace().next()) + .filter(|f| shape.first.iter().any(|s| s == f)); + let wanted: Vec<&String> = match top_first { + Some(f) => shape.first.iter().filter(|s| *s == f).collect(), + None => shape.first.iter().collect(), + }; + for s in wanted { + if char_count(lexicon, chars, s) == 0 { + continue; + } + let found = cands + .iter() + .any(|c| c.text.chars().count() == 1 && c.pinyin == *s); + if !found { + report( + "first-syllable-chars", + format!("候选里没有第一个音节 {s} 的单字"), + ); + } + } + // min-candidates + let need = shape + .head + .iter() + .map(|s| char_count(lexicon, chars, s)) + .max() + .unwrap_or(0) + .min(PAGE); + let shown = cands.iter().filter(|c| !is_raw(c)).count(); + if shown < need { + report( + "min-candidates", + format!( + "只有 {shown} 个中文候选,第一个音节({})就有 {need} 个以上常用单字", + shape.head.join("/") + ), + ); + } + // no-duplicates + let mut seen = HashSet::new(); + for c in cands { + if !seen.insert((c.text.as_str(), c.consumed)) { + report( + "no-duplicates", + format!("「{}」(用掉 {} 个键)出现了两次", c.text, c.consumed), + ); + break; + } + } +} + +fn read_allow(path: &str) -> HashMap<(String, String, String), String> { + let text = std::fs::read_to_string(path) + .unwrap_or_else(|e| super::fail(&format!("读不了 {path}: {e}"))); + let mut out = HashMap::new(); + for (i, line) in text.lines().enumerate() { + if line.trim().is_empty() || line.starts_with('#') { + continue; + } + let cols: Vec<&str> = line.split('\t').collect(); + if cols.len() < 4 || cols[3].trim().is_empty() { + super::fail(&format!( + "{path}:{}: 要四列:规则、输入、上文(可以空)、理由", + i + 1 + )); + } + out.insert( + ( + cols[0].to_string(), + cols[1].to_string(), + cols[2].to_string(), + ), + cols[3].to_string(), + ); + } + out +} + +/// 跑全部检查,返回是不是有没列进清单的违反。 +pub fn run( + engine: &Engine, + lexicon: &dyn Lexicon, + nnlm: Option>, + cases: &[(String, String)], + opts: &Options, +) -> bool { + // 逐键:每个用例的每个前缀;上文:没有、用例自带的、--inv-context 的 + let mut prefixes: Vec = Vec::new(); + let mut seen_prefix = HashSet::new(); + let mut with_context: Vec<(String, String)> = Vec::new(); + let mut seen_ctx = HashSet::new(); + for (input, context) in cases { + let letters: Vec = input + .char_indices() + .map(|(i, ch)| i + ch.len_utf8()) + .collect(); + for &end in &letters { + let prefix = &input[..end]; + if prefix.ends_with('\'') { + continue; + } + if seen_prefix.insert(prefix.to_string()) { + prefixes.push(prefix.to_string()); + } + let mut ctxs: Vec<&str> = opts.contexts.iter().map(String::as_str).collect(); + if !context.is_empty() { + ctxs.push(context); + } + for c in ctxs { + if seen_ctx.insert((prefix.to_string(), c.to_string())) { + with_context.push((prefix.to_string(), c.to_string())); + } + } + } + } + eprintln!( + "不变量:{} 个用例,逐键 {} 个前缀,带上文的 {} 组{}", + cases.len(), + prefixes.len(), + with_context.len(), + if nnlm.is_some() { + ",每组再带神经语言模型查一次" + } else { + "" + } + ); + + let mut violations: Vec = Vec::new(); + let mut chars: HashMap = HashMap::new(); + let mut shapes: HashMap> = HashMap::new(); + // 没有上文、不带模型时照着打的读法 + let mut typed: HashMap = HashMap::new(); + let mut queries = 0usize; + + let mut run_condition = + |engine: &Engine, + input: &str, + context: &str, + with_nnlm: bool, + violations: &mut Vec, + typed: &mut HashMap| { + engine.set_context(context); + engine.set_nnlm(if with_nnlm { nnlm.clone() } else { None }); + let cands = engine.input(input); + queries += 1; + let shape = shapes + .entry(input.to_string()) + .or_insert_with(|| shape(input, lexicon, &mut chars)); + let Some(shape) = shape.as_ref() else { + return; + }; + let mut found: Vec<(&'static str, String)> = Vec::new(); + check_one(input, shape, &cands, lexicon, &mut chars, |rule, detail| { + found.push((rule, detail)) + }); + let base = context.is_empty() && !with_nnlm; + // typed-kept:照着打的读法是个词时这个词还在;是几个词拼的整句时(晚 | 事儿),换一种拼法 + // (碗 | 事儿)也算,但至少要有一个照着打的整句 + if base { + if shape.exact.is_some() { + if let Some(t) = typed_reading(lexicon, &cands, input.len()) + .filter(|c| c.features.prefix_completion == 0.0) + { + typed.insert(input.to_string(), (t.text.clone(), is_word(t))); + } + } + } else if let Some((t, word)) = typed.get(input) { + let kept = if *word { + cands.iter().any(|c| &c.text == t) + } else { + typed_reading(lexicon, &cands, input.len()).is_some() + }; + if !kept { + found.push(( + "typed-kept", + if *word { + format!("没有上文、不带模型时照着打的词「{t}」不见了") + } else { + format!( + "没有上文、不带模型时有照着打的整句(「{t}」),这里一个都没有了" + ) + }, + )); + } + } + for (rule, detail) in found { + violations.push(Violation { + rule, + input: input.to_string(), + context: context.to_string(), + nnlm: with_nnlm, + detail: format!("{detail};候选 {}", brief(&cands, input.len(), 9)), + }); + } + }; + + let modes: &[bool] = if nnlm.is_some() { + &[false, true] + } else { + &[false] + }; + for &m in modes { + for p in &prefixes { + run_condition(engine, p, "", m, &mut violations, &mut typed); + } + } + for &m in modes { + for (p, c) in &with_context { + run_condition(engine, p, c, m, &mut violations, &mut typed); + } + } + engine.set_context(""); + engine.set_nnlm(nnlm.clone()); + eprintln!("共查询 {queries} 次"); + + // 同一条规则、同一个输入和上文,带不带模型都违反时只算一条(标「两种都」) + let mut merged: Vec = Vec::new(); + let mut index: HashMap<(String, String, String), usize> = HashMap::new(); + for v in violations { + match index.get(&v.key()) { + Some(&i) => { + if merged[i].nnlm != v.nnlm { + merged[i].detail.push_str("(带不带模型都这样)"); + } + } + None => { + index.insert(v.key(), merged.len()); + merged.push(v); + } + } + } + + let allow = opts.allow.as_deref().map(read_allow).unwrap_or_default(); + let mut used_allow = HashSet::new(); + let mut by_rule: Vec<(&'static str, Vec<&Violation>)> = Vec::new(); + let mut new_count = 0usize; + for v in &merged { + if allow.contains_key(&v.key()) { + used_allow.insert(v.key()); + continue; + } + new_count += 1; + match by_rule.iter_mut().find(|(r, _)| *r == v.rule) { + Some((_, list)) => list.push(v), + None => by_rule.push((v.rule, vec![v])), + } + } + + let rules = [ + "typed-first", + "typed-first-partial", + "first-syllable-chars", + "min-candidates", + "typed-kept", + "no-duplicates", + ]; + println!("== 不变量"); + for rule in rules { + let list = by_rule + .iter() + .find(|(r, _)| *r == rule) + .map(|(_, l)| l.as_slice()) + .unwrap_or(&[]); + let allowed = merged + .iter() + .filter(|v| v.rule == rule && allow.contains_key(&v.key())) + .count(); + println!( + "{rule:<22} 违反 {}{}", + list.len(), + if allowed > 0 { + format!("(另有 {allowed} 条在已知清单里)") + } else { + String::new() + } + ); + let shown = if opts.limit == 0 { + list.len() + } else { + opts.limit.min(list.len()) + }; + for v in &list[..shown] { + println!(" {}", line(v)); + } + if shown < list.len() { + println!(" ……还有 {} 条(--inv-limit 0 全打)", list.len() - shown); + } + } + let stale: Vec<_> = allow.keys().filter(|k| !used_allow.contains(*k)).collect(); + if !stale.is_empty() { + println!( + "已知清单里这些已经不违反了,从 {} 删掉:", + opts.allow.as_deref().unwrap_or("") + ); + for (r, i, c) in &stale { + println!(" {r}\t{i}\t{c}"); + } + } + if let Some(path) = &opts.out { + let mut out = String::from("# 规则\t输入\t上文\t神经语言模型\t说明\n"); + for v in &merged { + let _ = writeln!( + out, + "{}\t{}\t{}\t{}\t{}", + v.rule, + v.input, + v.context, + if v.nnlm { "带" } else { "不带" }, + v.detail + ); + } + if let Err(e) = std::fs::write(path, out) { + super::fail(&format!("写不了 {path}: {e}")); + } + } + new_count > 0 || !stale.is_empty() +} + +fn line(v: &Violation) -> String { + let mut s = v.input.clone(); + if !v.context.is_empty() { + let _ = write!(s, "(上文「{}」)", v.context); + } + if v.nnlm { + s.push_str("(带模型)"); + } + let _ = write!(s, ":{}", v.detail); + s +} diff --git a/core/src/bin/eval.rs b/core/src/bin/eval.rs index 7a57f679..21864d2c 100644 --- a/core/src/bin/eval.rs +++ b/core/src/bin/eval.rs @@ -25,7 +25,13 @@ //! //! 每组(每个用例文件,组名是文件名去掉 .tsv)报 top1 / top3 / top9 和「通过」(按上面的属性判断; //! 没写属性的用例「通过」就是 top1)。这是调排序权重时唯一靠谱的依据——没有数据就是盲调。 +//! +//! `--invariants`:不统计命中率,改成把每个输入逐键打一遍、检查不许出现的结果(纠错的排在照着打的前面、 +//! 第一个音节的单字没了……),见 `common/invariants.rs` 和 `docs/ENGINE-INVARIANTS.md`。 +//! CI 跑的是 `scripts/invariants.sh`。 +#[path = "common/invariants.rs"] +mod invariants; #[path = "common/preset.rs"] mod preset; @@ -263,6 +269,11 @@ fn main() { let mut markdown_path: Option = None; let mut strict: Vec = Vec::new(); let mut list_misses = false; + let mut invariants_mode = false; + let mut inv_contexts: Vec = Vec::new(); + let mut inv_limit = 20usize; + let mut inv_allow: Option = None; + let mut inv_out: Option = None; let mut i = 1; while i < args.len() { @@ -345,6 +356,15 @@ fn main() { "--markdown" => markdown_path = Some(value(&mut i, "--markdown")), "--strict" => strict.push(value(&mut i, "--strict")), "--misses" => list_misses = true, + "--invariants" => invariants_mode = true, + "--inv-context" => inv_contexts.push(value(&mut i, "--inv-context")), + "--inv-limit" => { + inv_limit = value(&mut i, "--inv-limit") + .parse() + .unwrap_or_else(|_| fail("--inv-limit 要一个数")) + } + "--inv-allow" => inv_allow = Some(value(&mut i, "--inv-allow")), + "--inv-out" => inv_out = Some(value(&mut i, "--inv-out")), "-h" | "--help" => { println!("wowtype-eval (--data <目录> | --lexicon ) --eval [--eval ...]"); println!(" 配置:默认和外壳一致(候选上限 1000、词库旁边的 words.lm / english.txt、纠错开、模糊音关)"); @@ -354,6 +374,7 @@ fn main() { println!(" [--nnlm ] [--nnlm-rerank n] [--lm-weight w] [--learn | --learn-from ]"); println!(" 输出:[--k n] [--show-top1] [--misses]"); println!(" 门槛:[--strict 组名]... [--baseline [--tolerance 百分点]] [--write-baseline ] [--markdown ]"); + println!(" 不变量:--invariants [--inv-context 上文]... [--inv-limit n] [--inv-allow ] [--inv-out ]"); return; } other => fail(&format!("未知参数: {other}")), @@ -406,6 +427,7 @@ fn main() { None => lm, }; let lex: Arc = Arc::new(lexicon); + let lex_for_checks = lex.clone(); let ranker = Arc::new(LinearRanker::new(weights)); let mut config = if legacy { EngineConfig { @@ -471,17 +493,48 @@ fn main() { ); let mut engine = Engine::new(lex, lm).with_config(config).with_ranker(ranker); engine.prepare_fuzzy(); - if let Some(path) = &nnlm_path { - if let Err(e) = engine.load_nnlm(path) { - fail(&format!("{e:#}")); - } - } + let nnlm_model = nnlm_path.as_ref().map(|path| { + Arc::new(wowtype_core::nnlm::Nnlm::load(path).unwrap_or_else(|e| fail(&format!("{e:#}")))) + }); + engine.set_nnlm(nnlm_model.clone()); if let Some(path) = &english_path { if let Err(e) = engine.load_english(path) { fail(&format!("{e:#}")); } } + if invariants_mode { + let mut cases: Vec<(String, String)> = Vec::new(); + for eval_path in &eval_paths { + let data = std::fs::read_to_string(eval_path) + .unwrap_or_else(|e| fail(&format!("读取用例 {eval_path} 失败: {e}"))); + // 双拼的用例(sp=)按键和音节对不上,不查 + for case in parse_cases(eval_path, &data) + .into_iter() + .filter(|c| c.scheme.is_none()) + { + let context = if legacy { + case.context.clone() + } else { + preset::context_tail(&case.context).to_string() + }; + cases.push((case.input, context)); + } + } + let opts = invariants::Options { + contexts: inv_contexts, + limit: inv_limit, + allow: inv_allow, + out: inv_out, + }; + let failed = invariants::run(&engine, lex_for_checks.as_ref(), nnlm_model, &cases, &opts); + if failed { + eprintln!("有不变量被违反了"); + std::process::exit(1); + } + return; + } + let mut results: Vec = Vec::new(); for eval_path in &eval_paths { let data = match std::fs::read_to_string(eval_path) { diff --git a/core/src/lib.rs b/core/src/lib.rs index f4ff5679..3fc30cfa 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -1241,6 +1241,7 @@ impl Engine { }; protect_exact_input(&mut result); + typos_after_typed(&mut result); promote_picked(&mut result); pin_single_initial(&normalized, &mut result); self.promote_custom(&mut result); @@ -1912,6 +1913,7 @@ impl Engine { let feature = Feature { coverage_score: 1.0, lm_score_with_previous_txt: lm as f32, + fuzzy: true, ..Feature::default() }; let score = -view.cost(&entry) @@ -2566,6 +2568,45 @@ fn protect_exact_input(candidates: &mut Vec) { *candidates = keep; } +/// 纠错出来的候选不排在第一个照着打的读法(不纠错、每个词词库里都有、不是简拼)前面, +/// 除非它用的音节更少(`jintiam` 的「今天」)。 +/// +/// [`typed_reading_first`] 在束搜索的结果上按分数压过一次,但后面按位置挪候选的步骤会把它绕过去: +/// `sheihaiyo` 里压纠错词「谁还要」用的基准是补全出来的「谁还有」(yo → you),[`protect_exact_input`] +/// 接着把补全的整句挪到「谁嗨哟」后面,「谁还要」就又成了第一个。这里按位置再拦一次, +/// 不管前面谁动过顺序。只挪第一个照着打的读法前面的。 +fn typos_after_typed(candidates: &mut Vec) { + let syllables = |c: &Candidate| c.pinyin.split_whitespace().count(); + let typed = |c: &Candidate| { + !is_raw_candidate(c) + && c.features.typo_count == 0.0 + && c.features.full_jianpin == 0.0 + && !c.words.is_empty() + && c.words.iter().all(|w| w.known) + }; + let Some(anchor) = candidates.iter().position(typed) else { + return; + }; + let need = syllables(&candidates[anchor]); + let yields = |c: &Candidate| c.features.typo_count > 0.0 && syllables(c) >= need; + if !candidates[..anchor].iter().any(yields) { + return; + } + let mut moved = Vec::new(); + let mut keep = Vec::with_capacity(candidates.len()); + for (i, c) in candidates.drain(..).enumerate() { + if i < anchor && yields(&c) { + moved.push(c); + } else { + keep.push(c); + } + } + let at = keep.iter().position(typed).map_or(keep.len(), |i| i + 1); + keep.splice(at..at, moved); + make_scores_monotonic(&mut keep); + *candidates = keep; +} + /// 两个候选的音节一样(整词和拼凑出来的整句:启动器 / 启动 | 其)。 fn same_syllables(a: &Candidate, b: &Candidate) -> bool { a.pinyin.split_whitespace().eq(b.pinyin.split_whitespace()) @@ -2755,35 +2796,61 @@ fn prefix_on_syllable_boundaries( return Vec::new(); }; // 儿化的音节(wanr)按「音节 + r」两段算:第一名是「玩儿」时,wan 的单字(玩、万)照样是句首词 - let syllables: Vec<&str> = top - .pinyin - .split_whitespace() - .flat_map(|s| match s.strip_suffix('r') { - Some(base) if !base.is_empty() && s != "er" => vec![base, "r"], - _ => vec![s], - }) - .collect(); - if syllables.len() < 2 { - prefix.clear(); - return Vec::new(); - } + let syllables_of = |c: &Candidate| -> Vec { + c.pinyin + .split_whitespace() + .flat_map(|s| match s.strip_suffix('r') { + Some(base) if !base.is_empty() && s != "er" => { + vec![base.to_string(), "r".to_string()] + } + _ => vec![s.to_string()], + }) + .collect() + }; let letters: String = normalized .chars() .filter(|c| c.is_ascii_alphabetic()) .collect(); - if top.features.full_jianpin > 0.0 || syllables.concat().len() > letters.len() + 2 { + let syllables = syllables_of(top); + if syllables.len() >= 2 + && (top.features.full_jianpin > 0.0 || syllables.concat().len() > letters.len() + 2) + { // 简拼(zgrm)字母和音节对不上,不按边界筛 return Vec::new(); } + // 第一名是纠错出来的(yusezhi 的「越职」yue zhi、gaj 的「感」gan)时,用户照着打的读法 + // (雨色质 yu se zhi、噶举 ga j…)的音节边界也算:纠错的音节对不上字母,只按它对齐的话 + // 句首词和第一个音节的单字全被筛掉,候选只剩几个纠错出来的整词 + let typed = (top.features.typo_count > 0.0) + .then(|| { + result.iter().find(|c| { + !is_raw_candidate(c) + && c.features.typo_count == 0.0 + && c.features.full_jianpin == 0.0 + && c.words.iter().all(|w| w.known) + }) + }) + .flatten() + .map(syllables_of) + // 最后一个音节可以是补全出来的(saj 的「撒娇」sa jiao),比字母长;对齐只看它前面的音节 + .filter(|s| s.len() >= 2); + if syllables.len() < 2 && typed.is_none() { + prefix.clear(); + return Vec::new(); + } // 从头对齐:补全和纠错只改动对不上的那一段,前面对得上的音节边界照样可信 let mut boundaries = Vec::new(); - let mut at = 0; - for syllable in &syllables[..syllables.len() - 1] { - if !letters[at..].starts_with(syllable) { - break; + for syllables in std::iter::once(&syllables).chain(typed.as_ref()) { + let mut at = 0; + for syllable in syllables.iter().take(syllables.len().saturating_sub(1)) { + if !letters[at..].starts_with(syllable.as_str()) { + break; + } + at += syllable.len(); + if !boundaries.contains(&at) { + boundaries.push(at); + } } - at += syllable.len(); - boundaries.push(at); } let exact = top.features.typo_count == 0.0; let mut other_splits = Vec::new(); @@ -3016,11 +3083,16 @@ fn compose_candidates(result: &mut Vec, prefix: Vec, max: let mut kept: Vec = Vec::new(); let mut sentences = 0usize; // 第一名是打全了的、词库里的整词(你好;纠错出来的也算:zhognguo -> 中国)时,比它差 - // JUNK_SENTENCE_MARGIN 以上的整句(泥 | 好、点 | 脑、钟 | 国)是硬凑的,不占位置;用户选过的照留 + // JUNK_SENTENCE_MARGIN 以上的整句(泥 | 好、点 | 脑、钟 | 国)是硬凑的,不占位置;用户选过的照留。 + // 模糊音兜底加进来的词(模糊音关着时,ninke 接着上文出「宁可」)不算:照着打的读音(您 | 可) + // 只能排在它后面,不能被它当成硬凑的整个筛掉 let top_word = whole .first() .filter(|c| { - c.words.len() == 1 && c.words[0].known && c.features.prefix_completion == 0.0 + c.words.len() == 1 + && c.words[0].known + && c.features.prefix_completion == 0.0 + && !c.features.fuzzy }) .map(|c| c.score); for c in whole { @@ -5326,6 +5398,108 @@ mod tests { } } + fn ranked(text: &str, pinyin: &str, typos: f32, consumed: usize) -> Candidate { + Candidate { + text: text.into(), + pinyin: pinyin.into(), + score: 0.0, + features: Feature { + typo_count: typos, + typo: if typos > 0.0 { 1.0 } else { 0.0 }, + coverage_score: 1.0, + ..Feature::default() + }, + words: vec![CandidateWord { + text: text.into(), + pinyin: pinyin.into(), + freq: 1000.0, + known: true, + }], + consumed, + } + } + + #[test] + fn typos_never_end_up_ahead_of_the_typed_reading() { + // sheihaiyo:前面的步骤把补全的整句挪走以后,纠错的「谁还要」又到了第一个 + let mut list = vec![ + ranked("谁还要", "shei hai yao", 1.0, 9), + ranked("谁嗨哟", "shei hai yo", 0.0, 9), + ranked("谁还有", "shei hai you", 0.0, 9), + ]; + typos_after_typed(&mut list); + let texts: Vec<&str> = list.iter().map(|c| c.text.as_str()).collect(); + assert_eq!(texts, ["谁嗨哟", "谁还要", "谁还有"]); + assert!( + list.windows(2).all(|w| w[0].score > w[1].score), + "分数跟着顺序递减" + ); + + // 纠错以后音节更少(jintiam -> 今天):不挪 + let mut list = vec![ + ranked("今天", "jin tian", 1.0, 7), + ranked("金蹄啊", "jin ti a", 0.0, 7), + ]; + typos_after_typed(&mut list); + assert_eq!(list[0].text, "今天"); + } + + #[test] + fn prefix_words_follow_the_typed_syllables_when_the_top_is_a_correction() { + // yusezhi:第一名「越职」是删掉 s 纠出来的(yue zhi),按它对齐的话 yu、yu se 一个边界都对不上, + // 句首词(语塞、雨)全被筛掉,以前一共只剩 6 个候选 + let result = vec![ + ranked("越职", "yue zhi", 1.0, 7), + ranked("雨色质", "yu se zhi", 0.0, 7), + ]; + let mut prefix = vec![ + ranked("语塞", "yu se", 0.0, 4), + ranked("雨", "yu", 0.0, 2), + ranked("越", "yue", 1.0, 3), + ]; + prefix_on_syllable_boundaries(&result, "yusezhi", &mut prefix); + let texts: Vec<&str> = prefix.iter().map(|c| c.text.as_str()).collect(); + assert!( + texts.contains(&"语塞") && texts.contains(&"雨"), + "{texts:?}" + ); + + // gaj:第一名「感」是单音节的纠错词,以前一个句首词都不留(ga 的单字没了) + let result = vec![ranked("感", "gan", 1.0, 3), ranked("噶举", "ga ju", 0.0, 3)]; + let mut prefix = vec![ranked("嘎", "ga", 0.0, 2)]; + prefix_on_syllable_boundaries(&result, "gaj", &mut prefix); + assert_eq!(prefix.len(), 1); + } + + #[test] + fn fuzzy_fallback_word_does_not_drop_the_typed_sentence() { + // ninke 接着上文打:模糊音兜底加的「宁可」(ning ke)排第一时,照着打的「您 | 可」不能被当成硬凑的整句筛掉 + let mut fuzzy = ranked("宁可", "nin ke", 0.0, 5); + fuzzy.features.fuzzy = true; + fuzzy.score = -10.0; + let mut typed = ranked("您可", "nin ke", 0.0, 5); + typed.words = ["您", "可"] + .iter() + .zip(["nin", "ke"]) + .map(|(t, p)| CandidateWord { + text: t.to_string(), + pinyin: p.into(), + freq: 1000.0, + known: true, + }) + .collect(); + typed.score = -20.0; + let mut result = vec![fuzzy.clone(), typed.clone()]; + compose_candidates(&mut result, Vec::new(), 10); + assert!(result.iter().any(|c| c.text == "您可"), "照着打的整句被筛掉了"); + + // 照着打的整词排第一时,差得多的硬凑整句照旧筛掉(你好 vs 泥 | 好) + fuzzy.features.fuzzy = false; + let mut result = vec![fuzzy, typed]; + compose_candidates(&mut result, Vec::new(), 10); + assert!(!result.iter().any(|c| c.text == "您可")); + } + #[test] fn nnlm_picks_cap_scored_chars() { let long = "一二三四五六七八九十".repeat(4); // 40 个字 diff --git a/core/src/rank.rs b/core/src/rank.rs index 1c34a958..5ee477a6 100644 --- a/core/src/rank.rs +++ b/core/src/rank.rs @@ -62,6 +62,9 @@ pub struct Feature { pub other_completion: f32, pub typo: f32, pub force_emit: f32, + /// 不是排序特征(不进 [`Feature::to_vector`],权重里没有它):这个候选是模糊音关着时 + /// 模糊音兜底加进来的(`penyou` -> 朋友),不是照着打的读音。排序规则用它区分「照着打的整词」。 + pub fuzzy: bool, } impl Feature { diff --git a/docs/ENGINE-INVARIANTS.md b/docs/ENGINE-INVARIANTS.md new file mode 100644 index 00000000..27288635 --- /dev/null +++ b/docs/ENGINE-INVARIANTS.md @@ -0,0 +1,199 @@ +# 排序不变量:和成熟输入法对照,以及「永远不许出现」的规则 + +这份文档回答一个问题:**为什么 `cehaohou` 会只剩「的好后」「得好后」两个候选,成熟的输入法为什么不会这样?** +然后列出 WowType 现在用来拦这类结果的不变量检查(`scripts/invariants.sh`,CI 里每次都跑), +这次查出来、修好了的违反,和还没修、建议怎么改的地方。 + +引擎本身的设计见 [ENGINE.md](ENGINE.md);排序评测(top1 命中率)见 [tools/eval/README.md](../tools/eval/README.md)。 + +## 1. 起因 + +72bf8e2 修了 `cehaohou`(测好后):接着「我本地」打时只出「的好后」「得好后」。三处原因叠在一起: + +1. 束搜索剪枝按「末词」合并状态,不看纠错处数:纠错的「的 | 好」把照着打的「测 | 好」并掉了,照着打的读法走不到底; +2. 排序让纠错出来的候选排到照着打的读法前面:纠错是一个固定罚分(`typo_cost` = 8),「的」「得」的词频和神经语言模型分数高得多,罚分拦不住; +3. 神经语言模型的分数以纠错出来的路径为基准归一,照着打的整句全被扣十几分。 + +根子上的问题是:**精确匹配、纠错、补全、简拼、语言模型重排,全都折算成一个分数再排**,各类之间没有硬的先后; +评测集只量「第一个对不对」(top1),量不出「这种结果永远不许有」。一条离谱的结果在 top1 统计里只是少一条, +混在几千条里谁也看不出来。 + +## 2. 成熟输入法怎么做 + +读的是 librime(RIME)、libime(fcitx5 拼音)、libpinyin(ibus-libpinyin)的源码(2026-11 的 HEAD,只读不编)。 +**只借思路,不抄代码**:它们的许可证(BSD-3 / LGPL)和本仓库(MIT OR Apache-2.0)不同。 +标「推断」的是从代码推出来、没有直接看到的结论,其余都在源码里核实过。 + +### librime + +- **表示**:音节图的每条边带一个拼写类型(正常、模糊音、简拼、补全、歧义),另有一个「是不是纠错」的标记和一个 + 「可信度」(对数概率)。模糊音、简拼各罚 log 0.5,补全 log 0.05,纠错 log 0.01(`algo/calculus.cc`、`algo/syllabifier.cc`)。 +- **精确的边一直在**:建图时先记下每个位置上精确匹配的音节,只有**不是**精确匹配的才标成纠错、加罚分; + 精确的那条边可信度为 0,和纠错边并存(`test/corrector_test.cc` 就测这个)。纠错边不参与决定「这个位置能不能走到底」, + 也就决定不了切分。 +- **硬的分层,不只靠分数**: + - 不同翻译器的候选先按「从哪开始」、再按「到哪结束(长的在前)」、最后才按质量排(`Candidate::compare`): + 句首词永远排在盖住整段输入的候选后面; + - 同一个结束位置里,精确匹配排在联想(没打完的词)前面,再比剩下没打的码长,最后才比分数(`compare_head_entries`); + - 正常拼写能走到底时,简拼类的边直接删掉。 +- **纠错有名额**:一次最多出 4 个纠错候选(`max_corrections_`)。 +- **整句只在需要时才造**:已经有一个精确、不靠纠错的词盖住整段输入时,不再拼整句(`has_reliable_phrase`)。 +- **候选顺序**:整句 → 从长到短的词 → 第一个音节的单字。单字一直在。 +- **整句解码**:每个位置按末词各留一条最好的(`poet.cc`)。 + +### libime(fcitx5 拼音) + +- **表示**:模糊音、纠错、补全是标记位(`PinyinFuzzyFlag`)。解析输入时**带纠错解一遍、不带纠错再解一遍,结果合并进同一张图**: + 不纠错的切分永远在图里。罚分是软的(每处模糊 log10 0.5;纠错算 10 处,约 1000 倍)。 +- **剪枝**:每个音节跨度最多留 40 个词,但**从输入开头起的跨度不剪**;束宽 20,每个词节点留一个最好的前驱。 + (推断:词节点本身不会丢,但句子中间某个精确的前驱排到 20 名以外时,那条精确的历史会丢。) +- **候选怎么拼**:先是最好的整句;然后从输入开头起的**不纠错的词全部无条件加入**;纠错的词只在精确词的分数窗口里、 + 或者是单音节时才加;多个词拼的句首候选只要路径上有一处纠错就不要。去重时,同字同跨度的两条留没纠错的那条。 + 候选数上限(15)**不管单音节的字**:第一个音节的单字永远在。 +- **测试**:只测了候选不重复、某个词在不在,没有「纠错不能排在精确前面」这种顺序断言。 + +### libpinyin + +- **表示**:纠错是解析表里的「非标准拼法」条目(`zhagn` → zhang),**只在这串字母本身不是合法拼法时才会用到**, + 不会和合法拼法竞争;解析是单一最优的动态规划,纠错距离只在最后打破平局。 +- **没有显式的模糊、补全罚分**,靠读音频率的占比。 +- **候选排序是严格分层的**:先按词长、再按拼音长、最后才按频率;第一个音节的单字永远在(排最后)。 + +### 共同的规矩 + +| # | 规矩 | 谁这样做 | +|---|---|---| +| P1 | 照着打的读法永远在:纠错、模糊只是**加**进来的候选,从不**替换** | 三家都是 | +| P2 | 纠错的代价远大于模糊、简拼(约 100–1000 倍 vs 2 倍) | librime、libime | +| P3 | 从输入开头起的精确词无条件进候选;纠错的要过分数门槛;带纠错的多词句首候选不要 | libime | +| P4 | 同字同跨度时留没纠错的那条 | libime、librime(去重留排在前面的) | +| P5 | 纠错候选有名额 | librime(4 个) | +| P6 | 已经有精确的整词盖住整段输入时不拼整句 | librime | +| P7 | 先按覆盖(用掉多少输入)分层,再比分数 | librime、libpinyin(硬分层);libime(每个没盖住的音节重罚) | +| P8 | 第一个音节的单字永远在,候选数上限不管它们 | 三家都是 | +| P9 | 输入开头起的跨度不剪;剪枝按末词各留一条,不把不同的末词并掉 | libime、librime、libpinyin | +| P10 | 纠错不决定切分 | librime、libpinyin | + +三家都**没有**「纠错不许排在精确前面」这种测试:它们靠的是结构(分层、名额、无条件加入),不是靠调分数再测。 + +## 3. WowType 现在怎么做 + +一次按键的流程(`core/src/lib.rs`): + +1. **音节图**(`graph.rs`):全拼边;纠错边(相邻键替换、音节内对调、多按、中间漏按、跨音节对调,每条边纠一处); + 末音节补全边(缺几个字母)。全拼走不通时另建简拼 / 全拼混简拼的图(`abbrev_graph`)。 +2. **束搜索**(`beam.rs`):每条边的代价 = 词典代价 + 语言模型 + `typo_cost`(8.0)× 纠错处数 + `completion_cost`(1.5)× 补的字母数 + + `abbrev_cost` / `tail_abbrev_cost`。`prune` 每个位置留 `beam_size`(20)个状态,按「末词 + 纠错处数」去重, + 纠错最少的状态另外至少留 4 个(`TYPED_RESERVE`,72bf8e2 加的)。 +3. **`query_once`**:把路径变成候选,`nnlm_scores`(神经语言模型,以纠错最少的照着打的读法为基准)、`typed_reading_first` + (纠错多的不排到纠错少的照着打的读法前面,按分数压)、`exact_syllable_first`(单音节输入:本音节的字 → 补全 → 纠错)。 +4. **`pinyin_candidates`** 里按位置再挪:`protect_exact_input`(打全了的实在的词排第一)、`promote_picked`、 + `pin_single_initial`、原始串 / 英文、`prefix_on_syllable_boundaries` + `compose_candidates`(句首词和整句穿插, + 排第一的没纠错时纠错的放到句首词后面)、`append_more_candidates`(翻页长尾:同音词 → 句首词 → 单字 → 换切法的词……)。 + +## 4. 对照:哪里是「一个分数」,成熟引擎用的是「分层」 + +| 方面 | 成熟引擎 | WowType | 风险 | +|---|---|---|---| +| 纠错 vs 照着打 | 精确边一直在、纠错边不决定切分(P1、P10);纠错候选有名额(P5) | 纠错边和精确边进同一个束搜索,靠 `typo_cost` 拉开;之后由 `typed_reading_first`(按分数)、`compose_candidates`(按位置)、本次加的 `typos_after_typed`(按位置)几处分别补救 | 任何一个后面按位置挪候选的步骤都可能绕过前面的补救(`sheihaiyo` 就是这样,见第 6 节)。规则散在好几处,每处的「照着打」定义还不完全一样 | +| 纠错的代价 | 约 log 0.01 ~ log 0.001,而且是额外一层 | `typo_cost` = 8(≈ log 0.0003),但词频、语言模型、神经语言模型的分数范围能到十几二十,一个罚分盖不住 | 高频字(的、得、是)附近的键最容易出事 | +| 句首词(前缀)对齐 | 从输入开头起的精确词无条件加入(P3) | 按**第一名**的音节边界筛(`prefix_on_syllable_boundaries`),第一名是纠错的时就按纠错的音节筛 | 第一名是纠错时,照着打的第一个音节的单字整个没了(`yusezhi`、`gaj`,本次修了) | +| 单字 | 永远在,不受上限(P8) | 翻页长尾补,但长尾也是按第一名的切法补;候选上限 1000 一般够 | 同上 | +| 补全 vs 精确 | librime 精确在前、再比剩下的码长(硬分层) | 补全每字母罚 1.5,单音节输入另有 `exact_syllable_first` 按位置分层,多音节输入只靠分数和 `protect_exact_input` | `typed_reading_first` 把补全出来的读法也当「照着打」的基准,后面的步骤又把补全的挪走了(`sheihaiyo`) | +| 模糊音兜底 | 模糊音是和精确读音并列的一层,罚分固定(log 0.5),精确的永远在(P1) | 模糊音关着时 `fuzzy_fallback` 在第一名偏弱时补一两个模糊音的词,和其它候选按分数混排;`compose_candidates` 以前把它当成「打全了的整词」,比它差 3 以上的照着打的整句全当硬凑的筛掉 | 接着上文打 `ninke` 只剩「宁可」,照着打的「您可」整个没了(本次修了) | +| 简拼 | 正常拼写走得通就删简拼边 | 全拼有精确路径且有认识的词时不建简拼图(`run_query`),结构上已经分层 | 和成熟引擎一致 | +| 整句 vs 整词 | 有精确整词盖住整段输入就不拼整句(P6) | 照样拼,再由 `protect_exact_input`、`compose_candidates` 的 `JUNK_SENTENCE_MARGIN` 按分差筛 | 分差是调出来的阈值 | +| 语言模型 / 神经语言模型 | 不改变上面的分层,只在层内排序 | 加进同一个分数;72bf8e2 以后基准是照着打的读法,纠错路径不加分 | 层内排序没问题;跨层时还是一个分数 | +| 剪枝 | 输入开头的跨度不剪;按末词各留一条(P9) | 按「末词 + 纠错处数」各留一条,纠错最少的保底 4 个 | 和成熟引擎同一思路(72bf8e2 以后) | +| 测试 | 结构保证,测试少 | 本次加了逐键的不变量检查 | — | + +**结论**:WowType 的问题不是某个权重调错了,而是「照着打的读法优先」「第一个音节的单字一直在」这类规矩没有一个统一的、 +最后执行的分层,而是散在几个按分数或按位置挪候选的函数里,后一个能把前一个的结果冲掉。成熟引擎用结构保证 +(精确的永远加入、纠错有名额、按覆盖分层),WowType 现在用不变量检查兜底,再逐步把规矩收拢(第 7 节)。 + +## 5. 不变量检查 + +`wowtype-eval --invariants`(`core/src/bin/common/invariants.rs`)把 `tools/eval/*.tsv` 里的每个输入**逐键**打一遍 +(`c`、`ce`、`ceh`……),每个前缀在几种条件下各查一次:没有上文;用例自带的上文;脚本里固定加的上文(「我本地」); +给了 `--nnlm` 时每种再带上神经语言模型查一次。双拼用例(`sp=`)不查。 + +| 规则 | 内容 | 对应的规矩 | +|---|---|---| +| `typed-first` | 输入能整个切成完整音节(不靠纠错、补全)时,第一个候选不是纠错出来的。例外:纠错以后音节更少(`shijain` 照字母读是 shi jia in,纠一处是「时间」);照着打的音节词库里一个字都没有(`ng`) | P1 | +| `typed-first-partial` | 不靠纠错、只靠末音节补全能读通时(`ceh` = ce + h…),同上 | P1 | +| `first-syllable-chars` | 照着打的读法(不纠错,末音节可以补全)有两个以上音节时,第一个音节的单字在候选里。切法不止一种时(`kenengs` = ke neng s / ken eng s)只要第一个候选用的那种;第一个候选是纠错的,每种都要 | P3、P8 | +| `min-candidates` | 第一个音节是打全了的音节时,中文候选至少 min(9, 这个音节的常用单字数) 个 | P8 | +| `typed-kept` | 没有上文、不带模型时照着打的读法,加了上文或带上模型以后还在:是一个词时这个词还在;是几个词拼的整句时,至少还有一个照着打的整句 | P1 | +| `no-duplicates` | 没有字和用掉的键都一样的两条候选 | P4 | + +怎么跑: + +```bash +scripts/invariants.sh /usr/share/wowtype # 和 CI 一样(不带模型) +scripts/invariants.sh /usr/share/wowtype --nnlm /usr/share/wowtype/nnlm.bin # 带神经语言模型(慢一倍多) +scripts/invariants.sh /usr/share/wowtype --inv-limit 0 # 每条规则的违反全打出来 +``` + +数据目录、模型所在目录不可写时脚本先复制到临时目录(载入时会在旁边写缓存)。逐键约 2.4 万个前缀,加上带上文的约 5 万次查询(带模型再翻一倍), +不带模型约两分钟,带模型约六分钟。CI 的「排序评测(真实词库)」任务在排序评测后面跑它(复用编好的 `wowtype-eval`)。 + +**一条都不许违反。** 确实是对的、只是规则太死的,写进 `tools/eval/invariants-allow.tsv`(规则、输入、上文、理由四列), +不写理由不认;清单里的条目不再违反了,检查也会失败,提醒删掉。现在清单是空的。 + +写规则时踩过的坑(都是规则本身太死,已经改了规则,不是引擎的问题): + +- 一种输入有几种照着打的切法(`kenengs` = ke neng s / ken eng s,`hung` = hu ng / hun g…):只要候选里第一个照着打的读法用的那一种的单字; +- 词库里一个字都没有的音节(`nia`、`ng`、`hm`)不算「照着打能读」:`zuinia` 照着打是 zui ni a,三个音节,纠一处的「最佳」两个音节,按「音节更少」的例外排第一不算错; +- 模糊音兜底的词(`zuijing` 的「最近」、`penyou` 的「朋友」)不算照着打的读法:规则查词库,词库里这个词真有这个读音才算。 + +## 6. 这次查出来的 + +数据:`/usr/share/wowtype`(rime-ice 927e1cf1,和 `tools/eval/baseline.tsv` 同一份)。 + +### 修之前(pre-release 的 72bf8e2,规则同上) + +NNLM_BEFORE_PLACEHOLDER + +### 修了的两处 + +1. **第一名是纠错时,句首词和单字按纠错的音节对齐,全被筛掉**(`prefix_on_syllable_boundaries`)。 + `yusezhi`:第一名「越职」是删掉 s 纠出来的(yue zhi),yu、yu se 一个边界都对不上,句首词(语塞、雨……)全没了, + 整个候选框只有 6 个;`gaj`:第一名「感」(gan)只有一个音节,按老规矩一个句首词都不留,ga 的单字(嘎)没了。 + 现在第一名是纠错的时,照着打的读法(第一个不纠错、每个词都认识、不是简拼的候选)的音节边界也算(对应 P3、P8)。 + `yusezhi` 现在 790 个候选,第一页有「语塞」「雨」「与」。 +2. **纠错词被按位置挪回第一**(新加 `typos_after_typed`)。`sheihaiyo`:`typed_reading_first` 压纠错词「谁还要」时 + 用的基准是补全出来的「谁还有」(yo → you),接着 `protect_exact_input` 把补全的整句挪到「谁嗨哟」后面, + 「谁还要」又成了第一个。现在 `protect_exact_input` 之后按位置再拦一次:纠错的候选不排在第一个照着打的读法前面, + 除非音节更少(对应 P1)。 + +3. **模糊音兜底的词把照着打的整句当成硬凑的筛掉**(`compose_candidates`)。模糊音关着时,第一名偏弱就由 + `fuzzy_fallback` 补一两个模糊音的词(`penyou` → 朋友)。接着上文打 `ninke` 时补进来的「宁可」(ning ke)排第一, + `compose_candidates` 把它当成「打全了的整词」,比它差 3 以上的整句都当硬凑的去掉,照着打的「您可」整个没了 + (`zhouru` 的「周如」、`nachi` 的「那吃」、`zhidingyi` 的「指定一」带模型时也一样)。现在模糊音兜底的候选带一个标记 + (`Feature::fuzzy`,不是排序特征,不进权重),不当这个筛选的基准(对应 P1):照着打的整句排在它后面,不再被筛掉。 + +三处都有单元测试(`typos_never_end_up_ahead_of_the_typed_reading`、 +`prefix_words_follow_the_typed_syllables_when_the_top_is_a_correction`、 +`fuzzy_fallback_word_does_not_drop_the_typed_sentence`)。排序评测各组和基线持平(逐组 +0.0)。 + +### 修之后 + +NNLM_AFTER_PLACEHOLDER + +## 7. 还没做的:把规矩收拢成分层 + +不变量检查只能事后兜底。照成熟引擎的做法,建议按这个顺序把散着的补救收拢(每一步都要 `scripts/eval.sh` 持平、 +`scripts/invariants.sh` 零违反): + +1. **一个统一的「照着打」定义**。现在 `typed_reading_typos`(路径级)、`typos_after_typed`(候选级)、 + `prefix_on_syllable_boundaries` 里的照着打的读法、`exact_syllable_first` 的 `exact` 各写各的。 + 束搜索出来时就在 `Candidate` 上记一个「层」(精确 / 补全 / 简拼 / 纠错),后面所有步骤只看这个字段。 +2. **最后一步统一按层排**(像 librime 的 `Candidate::compare`):层与层之间按层,层内才按分数和现有的按位置规则。 + 这样 `protect_exact_input`、`compose_candidates`、`exact_syllable_first` 里各自的「纠错放后面」就可以删掉, + 也不会再出现后一步冲掉前一步的情况。纠错层的例外(音节更少的整词:`shijain` → 时间、`tianqu` 的「天气」放第二) + 作为显式的规则写在这一步,而不是靠分数碰巧。 +3. **纠错候选有名额**(P5):照着打的读法存在时,前两页最多几个纠错候选。 +4. **句首词不再按第一名的切法筛**,改成 libime 的做法(P3):从输入开头起、落在照着打的任一种切法的音节边界上的精确词无条件加入, + 纠错的句首词只在分数窗口里加。本次的修复是这一步的最小版本。 +5. **有精确整词盖住整段输入时不拼整句**(P6),代替 `JUNK_SENTENCE_MARGIN` 这个按分差筛的阈值。 +6. **评测集加逐键的整句用例**:现在 `daily.tsv` 只测整句打完那一刻。不变量检查已经逐键跑,但只检查规则,不检查 top1。 diff --git a/docs/ENGINE.md b/docs/ENGINE.md index 41e8ec34..81fd2606 100644 --- a/docs/ENGINE.md +++ b/docs/ENGINE.md @@ -273,8 +273,21 @@ d 在 c 上面,「的」「得」的词频、神经语言模型给的分比固 - 神经语言模型的分数以纠错最少的读法里最顺的那条为基准,比它还顺的纠错路径不加分(`nnlm_scores`)。 以前拿「的好」当基准,「测好」这些没纠错的整句全被扣十几分,输给没让模型打分的生僻词。 +- 后面按位置挪候选的步骤(`protect_exact_input` 把补全的整句挪到精确的整句后面……)不能把纠错的又挪回第一: + `protect_exact_input` 之后按位置再拦一次(`typos_after_typed`)。`sheihaiyo` 曾经出「谁还要」(yo 当成漏按的 yao), + 因为前面压它用的基准是补全出来的「谁还有」,补全的被挪走以后它又成了第一。 +- 第一名是纠错出来的时,句首词也按照着打的读法的音节边界对齐(`prefix_on_syllable_boundaries`): + `yusezhi` 的第一名「越职」(yue zhi)一个边界都对不上字母,以前句首词和 yu 的单字全被筛掉,整个候选框只有 6 个。 + +- 模糊音关着时兜底补进来的词(`fuzzy_fallback`:`penyou` → 朋友)带标记 `Feature::fuzzy`(不是排序特征)。 + 它排第一时不当「打全了的整词」,`compose_candidates` 不拿它去筛硬凑的整句:接着上文打 `ninke` 时补进来的「宁可」 + 曾经把照着打的「您可」整个筛掉。 + 没有零纠错的读法能把输入读完时,纠错结果照常排到前面。 +这些规则有没有被哪个改动冲掉,由排序不变量检查(`scripts/invariants.sh`,CI 里每次都跑)逐键查, +规则、和 librime / libime / libpinyin 的对照见 [ENGINE-INVARIANTS.md](ENGINE-INVARIANTS.md)。 + 长句改成**逐位置束搜索**:每个位置只留分数最高的若干条路径,一整句不用枚举全部切分; 同时会给出「句首词」候选(`nihaozhongguo` 里的「你好」),选了它就只上屏这一段、剩下的拼音继续打。 句首词只在音节边界上切(单音节 `dan` 不会出「大」),4 个音节以上的输入里第二位放整句开头 diff --git a/scripts/invariants.sh b/scripts/invariants.sh new file mode 100755 index 00000000..697f6412 --- /dev/null +++ b/scripts/invariants.sh @@ -0,0 +1,90 @@ +#!/usr/bin/env bash +# 排序不变量:把 tools/eval/ 下全部用例逐键打一遍,检查「不管排序怎么调都不许出现」的结果 +# (照着打的拼音被纠错的抢了第一、第一个音节的单字没了、候选只剩几个……)。一条都不许违反, +# tools/eval/invariants-allow.tsv 里写明了理由的除外。规则见 core/src/bin/common/invariants.rs、 +# docs/ENGINE-INVARIANTS.md。CI 的「排序不变量」任务跑的就是它。 +# +# scripts/invariants.sh <数据目录> [--nnlm ] [wowtype-eval 的其它参数,比如 --inv-limit 0] +# +# 每个前缀没有上文查一次、带用例自带的上文和下面 CONTEXTS 里的上文各查一次;给了 --nnlm 时每种再带上 +# 神经语言模型查一次(慢一倍多)。 +# +# 有 $GITHUB_STEP_SUMMARY 时把结果追加进去。WOWTYPE_EVAL_BIN 指定现成的 wowtype-eval,不给就现编一个。 +# 数据目录不可写时(比如 /usr/share/wowtype)先复制到临时目录:载入词库、模型会在旁边写缓存。 +set -euo pipefail +cd "$(dirname "$0")/.." + +DATA=${1:?用法:scripts/invariants.sh <数据目录> [--nnlm ] [wowtype-eval 的参数]} +shift +EVAL_DIR=tools/eval +ALLOW=$EVAL_DIR/invariants-allow.tsv +SETS=(regress common mid rare jianpin trunc trunc_exact homophone2 homophone3 daily context) +# 每个前缀都带着查一次的上文:72bf8e2 修的 cehaohou 就是接着「我本地」打时整个没了「测好」 +CONTEXTS=(我本地) + +for f in lexicon.tsv words.lm english.txt; do + if [[ ! -s "$DATA/$f" ]]; then + echo "数据目录 ${DATA} 里没有 ${f}(要 scripts/make-data.sh 的输出)" >&2 + exit 1 + fi +done + +tmp=$(mktemp -d) +trap 'rm -rf "$tmp"' EXIT +if [[ ! -w "$DATA" ]]; then + mkdir "$tmp/data" + for f in lexicon.tsv words.lm english.txt VERSION SOURCE.txt; do + [[ -f "$DATA/$f" ]] && cp "$DATA/$f" "$tmp/data/" + done + DATA=$tmp/data +fi + +extra=() +while (($#)); do + if [[ "$1" == "--nnlm" ]]; then + model=${2:?--nnlm 要一个文件} + # 模型旁边也会写缓存,不可写时一样复制 + if [[ ! -w "$(dirname "$model")" ]]; then + cp "$model" "$tmp/nnlm.bin" + model=$tmp/nnlm.bin + fi + extra+=(--nnlm "$model") + shift 2 + else + extra+=("$1") + shift + fi +done + +BIN=${WOWTYPE_EVAL_BIN:-} +if [[ -z "$BIN" ]]; then + cargo build --release --locked -p wowtype-core --no-default-features --bin wowtype-eval >&2 + BIN=${CARGO_TARGET_DIR:-target}/release/wowtype-eval +fi + +args=(--data "$DATA" --invariants --inv-out "$tmp/violations.tsv") +for name in "${SETS[@]}"; do + args+=(--eval "$EVAL_DIR/$name.tsv") +done +for c in "${CONTEXTS[@]}"; do + args+=(--inv-context "$c") +done +[[ -f "$ALLOW" ]] && args+=(--inv-allow "$ALLOW") + +status=0 +"$BIN" "${args[@]}" ${extra[@]+"${extra[@]}"} | tee "$tmp/report.txt" || status=$? + +if [[ -n "${GITHUB_STEP_SUMMARY:-}" ]]; then + { + echo "## 排序不变量" + echo + echo '```' + sed -n '/^== 不变量/,$p' "$tmp/report.txt" + echo '```' + if ((status)); then + echo + echo "**有不变量被违反了。** 本地复现:\`scripts/invariants.sh <数据目录> --inv-limit 0\`" + fi + } >> "$GITHUB_STEP_SUMMARY" +fi +exit "$status" diff --git a/tools/eval/README.md b/tools/eval/README.md index 66310a1f..55ec5e5e 100644 --- a/tools/eval/README.md +++ b/tools/eval/README.md @@ -128,6 +128,14 @@ scripts/eval.sh /usr/share/wowtype 换了数据(rime-ice 提交、`data/` 下的热词和词频表、`words.lm`)也要重写基线,提交说明里写清是数据变了。 评测集本身改了(重新生成、加了用例)同样要重写基线,前后数字不能直接比。 +## 排序不变量 + +排序评测只量「第一个对不对」,量不出「这种结果永远不许有」(`cehaohou` 只剩两个纠错候选时 top1 统计里只少一条)。 +`scripts/invariants.sh <数据目录> [--nnlm nnlm.bin]` 把这里全部用例逐键打一遍,检查硬规则: +打对了的拼音第一个不是纠错出来的、第一个音节的单字一直在、候选不会只剩几个、加了上文或神经语言模型照着打的读法还在…… +一条都不许违反(`invariants-allow.tsv` 里写明了理由的除外)。CI 在排序评测后面跑它。规则和来历见 +[docs/ENGINE-INVARIANTS.md](../../docs/ENGINE-INVARIANTS.md)。 + ## 来源和许可证 - `common`、`mid`、`rare`、`jianpin`、`trunc`、`trunc_exact`、`homophone2`、`homophone3` 是从雾凇拼音 rime-ice diff --git a/tools/eval/invariants-allow.tsv b/tools/eval/invariants-allow.tsv new file mode 100644 index 00000000..6b427702 --- /dev/null +++ b/tools/eval/invariants-allow.tsv @@ -0,0 +1,3 @@ +# 排序不变量的已知违反:scripts/invariants.sh 不把这里的算失败。 +# 只放「结果其实是对的、规则太死」的条目,每条写清理由;修好了(不再违反)检查会提示删掉。规则见 docs/ENGINE-INVARIANTS.md。 +# 规则输入上文(没有就留空)理由 From c5b3c8cadb8358b0bd4eebea0a4c86d470d22a4d Mon Sep 17 00:00:00 2001 From: Ethan Zou Date: Thu, 19 Nov 2026 07:55:14 +0800 Subject: [PATCH 2/4] =?UTF-8?q?=E7=BA=A0=E9=94=99=E3=80=81=E6=A8=A1?= =?UTF-8?q?=E7=B3=8A=E9=9F=B3=E5=85=9C=E5=BA=95=E3=80=81=E7=AE=80=E6=8B=BC?= =?UTF-8?q?=E3=80=81=E8=A1=A5=E5=85=A8=E5=8F=AA=E8=83=BD=E3=80=8C=E5=8A=A0?= =?UTF-8?q?=E3=80=8D=E5=80=99=E9=80=89=EF=BC=9A=E4=B8=8D=E5=8F=98=E9=87=8F?= =?UTF-8?q?=E5=AF=B9=E6=AF=94=E7=9D=80=E6=9F=A5=EF=BC=8C=E6=9F=A5=E5=87=BA?= =?UTF-8?q?=E6=9D=A5=E7=9A=84=E5=85=AD=E7=B1=BB=E4=BF=AE=E6=8E=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 用户的规矩:按键纠错应该是添加可疑的候选词,而不是替代原候选词。不变量检查加上: - typo / fuzzy / jianpin-only-adds、-outranks-typed:把这种机制关掉再查一次,关掉时第一页的词和排第一的 照着打的读法开着时都还在、不排到它加进来的候选后面(fuzzy-outranks-typed 只报告,等用户定,见文档); - completion-outranks-word:打全了的常用整词不排在补全出来的候选后面。 修了的: - 同字同跨度留照着打的那条(collect_spans):cunzai 里没有「蹲」(cun),纠错读出来的 dun 便宜被留下又被筛掉; - 句首词、长尾的名额纠错词另算(collect_spans、first_words); - 第一名是纠错的时,拼音和打的字母一字不差的句首词都留(jitnian 以前只剩「今天」「金田」);第一名是模糊音兜底的词时 也按照着打的读法对齐(kaoyang 的「烤烟…」); - 纠错词只在没有照着打的读法时才当筛硬凑整句的基准(meiyuo 的「没雨哦」);整句名额被纠错的占满时照着打的第一句照留 (接着上文打 weihuj 的「委户籍」); - protect_exact_input 不拿模糊音兜底的词当锚点(jiesu:补全的「结算」压在「借宿」前面);新加 completions_after_exact_words(fangxiangji:补全的「方向键」压在「芳香剂」前面);长尾补进来的打全了的常用词 插在补全前面(qingkuan 的「请款」)。 wowtype-show 加 --no-typo、--no-fuzzy-fallback、--why(标出拼音和是谁加的)。 评测(/usr/share/wowtype 的数据,和基线同一份):trunc_exact 96.7% → 98.4%,mid 93.8% → 94.1%,其余持平;基线已更新。 | 组 | 用例 | top1 | 基线 top1 | 差 | |---|---:|---:|---:|---:| | regress | 69 | 91.3% | 91.3% | +0.0 | | common | 1000 | 96.7% | 96.7% | +0.0 | | mid | 1000 | 94.1% | 93.8% | +0.3 | | rare | 1000 | 88.8% | 88.8% | +0.0 | | jianpin | 1000 | 63.0% | 63.0% | +0.0 | | trunc | 1000 | 92.2% | 92.2% | +0.0 | | trunc_exact | 1000 | 98.4% | 96.7% | +1.7 | | homophone2 | 300 | 100.0% | 100.0% | +0.0 | | homophone3 | 200 | 99.5% | 99.5% | +0.0 | | daily | 138 | 92.0% | 92.0% | +0.0 | | context | 533 | 88.4% | 88.4% | +0.0 | --- core/src/beam.rs | 57 ++++++- core/src/bin/common/invariants.rs | 237 +++++++++++++++++++++++++++++- core/src/bin/eval.rs | 8 +- core/src/bin/show.rs | 38 ++++- core/src/lib.rs | 176 ++++++++++++++++++++-- docs/ENGINE-INVARIANTS.md | 122 ++++++++++++--- tools/eval/baseline.tsv | 6 +- 7 files changed, 591 insertions(+), 53 deletions(-) diff --git a/core/src/beam.rs b/core/src/beam.rs index d98dbb5a..b5c0e3a8 100644 --- a/core/src/beam.rs +++ b/core/src/beam.rs @@ -201,6 +201,7 @@ pub fn beam_search( per_span, config, false, + false, ); for state in states { @@ -335,6 +336,7 @@ pub fn first_words( per_span, config, RARE, + true, ) .into_iter() .filter(|s| s.word.known && s.word.end < n) @@ -353,13 +355,25 @@ pub fn first_words( }); // 每个长度最多取几个,避免两字词把单字全部挤掉;单字多留几个, // 整句和词都不对时用户靠它一个字一个字地选 - let mut per_end: HashMap = HashMap::new(); + // 纠错出来的另算名额,不占照着打的词的位置(纠错只能「加」候选) + let mut per_end: HashMap<(usize, bool), usize> = HashMap::new(); words.retain(|(w, _)| { - let count = per_end.entry(w.end).or_insert(0); + let count = per_end.entry((w.end, w.typos > 0)).or_insert(0); *count += 1; let single = w.pinyin.split_whitespace().count() <= 1; *count <= if single { 6 } else { 3 } }); + // 超过 limit 时先去掉排在后面的纠错词,照着打的词留着 + let typed = words.iter().filter(|(w, _)| w.typos == 0).count(); + let mut typo_room = limit.saturating_sub(typed); + words.retain(|(w, _)| { + if w.typos == 0 { + return true; + } + let keep = typo_room > 0; + typo_room = typo_room.saturating_sub(1); + keep + }); words.truncate(limit); words } @@ -387,6 +401,7 @@ pub fn all_first_words( per_span, config, RARE, + true, ) .into_iter() .filter(|s| s.word.known) @@ -409,6 +424,9 @@ pub fn all_first_words( /// 从 pos 出发的所有候选词:词典命中(按结束位置分组,各取代价最低的若干个) /// 加上每条精确边的未登录兜底。 +/// `typo_quota`:纠错出来的词另算名额(句首词、翻页长尾用)。纠错只能「加」候选:和照着打的词抢同一份 +/// 名额的话,纠错出来的常用词(词频高、只扣一个固定罚分)会把照着打的冷门字挤掉(`cunzai` 的「蹲」cun)。 +#[allow(clippy::too_many_arguments)] fn collect_spans( graph: &SyllableGraph, lexicon: &dyn Lexicon, @@ -417,6 +435,7 @@ fn collect_spans( per_span: usize, config: &BeamConfig, rare: bool, + typo_quota: bool, ) -> Vec { let mut found: Vec = Vec::new(); let mut keys: Vec = Vec::new(); @@ -459,15 +478,39 @@ fn collect_spans( // 按代价排序;只在最多 `per_span` 个保留项里做线性比较,避免 // 为每个候选克隆 String 并重新计算哈希。 let mut unique = Vec::with_capacity(per_span.min(group.len())); + // (照着打的, 纠错的) 各留了几个;不另算名额时两种合在第一个里数 + let mut kept = (0usize, 0usize); for span in group { - if unique + let corrected = typo_quota && span.word.typos > 0; + let count = if corrected { kept.1 } else { kept.0 }; + if count >= per_span { + if kept.0 >= per_span && (!typo_quota || kept.1 >= per_span) { + break; + } + continue; + } + match unique .iter() - .all(|kept: &Span| kept.word.text != span.word.text) + .position(|k: &Span| k.word.text == span.word.text) { - unique.push(span); - if unique.len() >= per_span { - break; + None => { + unique.push(span); + if corrected { + kept.1 += 1; + } else { + kept.0 += 1; + } + } + // 同一个字既能照着打读出来、也能纠错读出来(蹲:dun 常用,cun 冷门):留照着打的那个。 + // 按代价留的话纠错的 dun 便宜,照着打的 cun 被去重去掉,后面再筛掉纠错的,cunzai 里就没有「蹲」了 + Some(at) if unique[at].word.typos > 0 && span.word.typos == 0 => { + if typo_quota { + kept.1 -= 1; + kept.0 += 1; + } + unique[at] = span; } + Some(_) => {} } } out.extend(unique); diff --git a/core/src/bin/common/invariants.rs b/core/src/bin/common/invariants.rs index 23af4db8..841c668b 100644 --- a/core/src/bin/common/invariants.rs +++ b/core/src/bin/common/invariants.rs @@ -20,6 +20,11 @@ //! 加了上文或者带上模型以后还在:它是词库里的一个词时这个词还在候选里;是几个词拼的整句时, //! 至少还有一个照着打的整句(拼法可以换:晚 | 事儿 → 碗 | 事儿)。 //! - **no-duplicates**:候选里没有字和用掉的键都一样的两条。 +//! - **completion-outranks-word**:打全了、整个输入正好是一个常用词(词频 1000 以上、读音一点不差)时,补全出来的 +//! 候选不排在它前面。 +//! - **typo / fuzzy / jianpin-only-adds**、**-outranks-typed**:按错键纠错、模糊音兜底、简拼只能**加**候选,不能替换: +//! 把它关掉再查一次,关掉时第一页的候选开着时都还在,关掉时排第一的不排在它加进来的候选后面 +//! (纠错以后音节更少的例外,同 typed-first)。见 [`only_adds`]。 use std::collections::{HashMap, HashSet}; use std::fmt::Write as _; @@ -32,8 +37,14 @@ use wowtype_core::{ SyllableQuery, }; +/// 只报告、不算失败的规则:模糊音兜底的词排到照着打的读法前面(`penyou` -> 朋友、`shengme` -> 什么) +/// 是回归集定死的现有行为,要不要也改成「只加」等用户定,见 docs/ENGINE-INVARIANTS.md。 +const REPORT_ONLY: [&str; 1] = ["fuzzy-outranks-typed"]; + /// 一页候选的个数(min-candidates 的上限)。 const PAGE: usize = 9; +/// completion-outranks-word 只管这么常用以上的词(和引擎的 `EXACT_PROTECT_MIN_FREQ` 一样)。 +const EXACT_WORD_FREQ: f64 = 1000.0; pub struct Options { /// 每个前缀都额外带上这些上文各查一次。 @@ -177,6 +188,25 @@ fn typed_reading<'a>( .find(|c| !is_raw(c) && !typo(c) && c.consumed >= len && lexicon_reading(lexicon, c)) } +/// 候选的拼音正好是打的字母(不是补全、纠错出来的)。翻页长尾里补全出来的词没有补全的标记, +/// 只能这样认:shenghu 的「圣皇」是 sheng huang。 +fn same_letters(c: &Candidate, input: &str) -> bool { + let typed = input.bytes().filter(u8::is_ascii_alphabetic).map(|b| b.to_ascii_lowercase()); + c.pinyin + .bytes() + .filter(u8::is_ascii_alphabetic) + .eq(typed) +} + +/// 「照着打的」:不是纠错、模糊音兜底、简拼加进来的,每个词词库里真有这个读音。 +fn plain_typed(lexicon: &dyn Lexicon, c: &Candidate) -> bool { + !is_raw(c) + && !typo(c) + && !c.features.fuzzy + && c.features.full_jianpin == 0.0 + && lexicon_reading(lexicon, c) +} + /// 照着打的读法是不是词库里的一个词(不是几个词拼出来的整句)。 fn is_word(c: &Candidate) -> bool { c.words.len() == 1 && c.words[0].known @@ -313,6 +343,38 @@ fn check_one( ); } } + // completion-outranks-word:输入打全了、整个输入正好是一个够常用的词(读音一点不差)时, + // 补全出来的候选不排在它前面(zhongdi 出「种地」不出「重点」,见 protect_exact_input) + if shape.exact.is_some() { + let word_at = cands.iter().position(|c| { + c.consumed >= len + && is_word(c) + && c.words[0].freq >= EXACT_WORD_FREQ + && !typo(c) + && c.features.prefix_completion == 0.0 + && c.features.full_jianpin == 0.0 + && !c.features.fuzzy + && same_letters(c, input) + && lexicon_reading(lexicon, c) + }); + if let Some(at) = word_at { + let ahead: Vec<&str> = cands[..at] + .iter() + .filter(|c| c.features.prefix_completion > 0.0) + .map(|c| c.text.as_str()) + .collect(); + if !ahead.is_empty() { + report( + "completion-outranks-word", + format!( + "打全了的词「{}」排在补全出来的「{}」后面", + cands[at].text, + ahead.join("」「") + ), + ); + } + } + } // min-candidates let need = shape .head @@ -344,6 +406,137 @@ fn check_one( } } +/// 只该往候选里「加」东西的机制:开着和关掉时的候选对比([`only_adds`])。 +struct Mechanism { + /// 规则名的前缀(`typo-only-adds`、`typo-outranks-typed`)。 + name: &'static str, + /// 说明里的叫法。 + label: &'static str, + /// 这个候选是这个机制加进来的。 + added: fn(&Candidate) -> bool, + /// 开关。 + set: fn(&mut Engine, bool), +} + +impl Mechanism { + fn added(&self, c: &Candidate) -> bool { + (self.added)(c) + } + + fn set(&self, engine: &mut Engine, on: bool) { + (self.set)(engine, on) + } +} + +const MECHANISMS: [Mechanism; 3] = [ + Mechanism { + name: "typo", + label: "按错键纠错", + added: |c| c.features.typo_count > 0.0, + set: |e, on| e.set_typo_correction(on), + }, + Mechanism { + name: "fuzzy", + label: "模糊音兜底", + added: |c| c.features.fuzzy, + set: |e, on| e.set_fuzzy_fallback(on), + }, + Mechanism { + name: "jianpin", + label: "简拼", + added: |c| c.features.full_jianpin > 0.0, + set: |e, on| e.set_jianpin_fallback(on), + }, +]; + +/// 用户的原话:按键纠错应该是「添加可疑的候选词,而不是替代原候选词」。纠错、模糊音兜底、简拼都一样: +/// +/// - `<机制>-only-adds`:关掉它时第一页有的词(词库里的整词、句首词、单字)和排第一的照着打的读法,开着时还在候选里; +/// - `<机制>-outranks-typed`:关掉它时排第一的,开着时不排在它加进来的候选后面。例外和 typed-first 一样: +/// 纠错以后整个输入的音节更少(`jintiam` -> 今天)。 +fn only_adds( + mechanism: &Mechanism, + lexicon: &dyn Lexicon, + input: &str, + on: &[Candidate], + off: &[Candidate], + mut report: impl FnMut(&'static str, String), +) { + let len = input.len(); + let rule = |suffix: &str| -> &'static str { + match (mechanism.name, suffix) { + ("typo", "adds") => "typo-only-adds", + ("typo", _) => "typo-outranks-typed", + ("fuzzy", "adds") => "fuzzy-only-adds", + ("fuzzy", _) => "fuzzy-outranks-typed", + (_, "adds") => "jianpin-only-adds", + _ => "jianpin-outranks-typed", + } + }; + // 词库里的词(整词、句首词、单字)一个都不能少;几个词拼的整句有上限、会换拼法,只要还有一个照着打的整句 + let mut missing: Vec<&str> = off + .iter() + .filter(|c| !is_raw(c)) + .take(PAGE) + .filter(|c| is_word(c) && plain_typed(lexicon, c)) + .filter(|c| !on.iter().any(|o| o.text == c.text)) + .map(|c| c.text.as_str()) + .collect(); + // 关掉时排第一的照着打的读法(关掉一种机制时另外几种照样会加候选,那些不算):整句也要还在 + let top = off + .iter() + .find(|c| c.consumed >= len && plain_typed(lexicon, c)); + // 是几个词拼的整句时(我 | 知己)拼法可以换,至少还要有一个照着打的读法 + let typed_on = on.iter().any(|c| c.consumed >= len && plain_typed(lexicon, c)); + if let Some(t) = top.filter(|t| !is_word(t) && !typed_on) { + missing.push(t.text.as_str()); + } + if !missing.is_empty() { + report( + rule("adds"), + format!( + "关掉{}时第一页有的「{}」,开着时没了;关掉时 {}", + mechanism.label, + missing.join("」「"), + brief(off, len, 9) + ), + ); + } + let Some(top) = top else { + return; + }; + // 开着时它前面的、加进来的候选:比到它和开着时第一个照着打的读法里靠前的那个 + let Some(at) = on + .iter() + .position(|c| c.text == top.text || (c.consumed >= len && plain_typed(lexicon, c))) + else { + return; + }; + let ahead: Vec<&Candidate> = on[..at] + .iter() + .filter(|c| mechanism.added(c)) + .filter(|c| { + // 纠错以后整个输入用更少的音节读完(jintiam -> 今天):和 typed-first 的例外一样 + !(mechanism.name == "typo" && c.consumed >= len && syllables(c) < syllables(top)) + }) + .collect(); + if !ahead.is_empty() { + report( + rule("outranks"), + format!( + "关掉{}时排第一的「{}」,开着时排到了它加进来的「{}」后面", + mechanism.label, + top.text, + ahead + .iter() + .map(|c| c.text.as_str()) + .collect::>() + .join("」「") + ), + ); + } +} + fn read_allow(path: &str) -> HashMap<(String, String, String), String> { let text = std::fs::read_to_string(path) .unwrap_or_else(|e| super::fail(&format!("读不了 {path}: {e}"))); @@ -373,7 +566,7 @@ fn read_allow(path: &str) -> HashMap<(String, String, String), String> { /// 跑全部检查,返回是不是有没列进清单的违反。 pub fn run( - engine: &Engine, + engine: &mut Engine, lexicon: &dyn Lexicon, nnlm: Option>, cases: &[(String, String)], @@ -428,7 +621,7 @@ pub fn run( let mut queries = 0usize; let mut run_condition = - |engine: &Engine, + |engine: &mut Engine, input: &str, context: &str, with_nnlm: bool, @@ -448,6 +641,24 @@ pub fn run( check_one(input, shape, &cands, lexicon, &mut chars, |rule, detail| { found.push((rule, detail)) }); + // 纠错、模糊音兜底、简拼只能「加」候选:关掉它再查一次,对比 + for mechanism in &MECHANISMS { + if !cands.iter().take(2 * PAGE).any(|c| mechanism.added(c)) { + continue; + } + // 简拼只在全拼走不通时才用(zg、wm 本来就没有照着打的全拼读法),只查打全了的输入: + // 那时它一个候选都不该加 + if mechanism.name == "jianpin" && shape.exact.is_none() { + continue; + } + mechanism.set(engine, false); + let off = engine.input(input); + mechanism.set(engine, true); + queries += 1; + only_adds(mechanism, lexicon, input, &cands, &off, |rule, detail| { + found.push((rule, detail)) + }); + } let base = context.is_empty() && !with_nnlm; // typed-kept:照着打的读法是个词时这个词还在;是几个词拼的整句时(晚 | 事儿),换一种拼法 // (碗 | 事儿)也算,但至少要有一个照着打的整句 @@ -496,12 +707,12 @@ pub fn run( }; for &m in modes { for p in &prefixes { - run_condition(engine, p, "", m, &mut violations, &mut typed); + run_condition(&mut *engine, p, "", m, &mut violations, &mut typed); } } for &m in modes { for (p, c) in &with_context { - run_condition(engine, p, c, m, &mut violations, &mut typed); + run_condition(&mut *engine, p, c, m, &mut violations, &mut typed); } } engine.set_context(""); @@ -534,7 +745,9 @@ pub fn run( used_allow.insert(v.key()); continue; } - new_count += 1; + if !REPORT_ONLY.contains(&v.rule) { + new_count += 1; + } match by_rule.iter_mut().find(|(r, _)| *r == v.rule) { Some((_, list)) => list.push(v), None => by_rule.push((v.rule, vec![v])), @@ -548,6 +761,13 @@ pub fn run( "min-candidates", "typed-kept", "no-duplicates", + "completion-outranks-word", + "typo-only-adds", + "typo-outranks-typed", + "fuzzy-only-adds", + "fuzzy-outranks-typed", + "jianpin-only-adds", + "jianpin-outranks-typed", ]; println!("== 不变量"); for rule in rules { @@ -561,12 +781,17 @@ pub fn run( .filter(|v| v.rule == rule && allow.contains_key(&v.key())) .count(); println!( - "{rule:<22} 违反 {}{}", + "{rule:<24} 违反 {}{}{}", list.len(), if allowed > 0 { format!("(另有 {allowed} 条在已知清单里)") } else { String::new() + }, + if REPORT_ONLY.contains(&rule) { + "(只报告,不算失败,见 docs/ENGINE-INVARIANTS.md)" + } else { + "" } ); let shown = if opts.limit == 0 { diff --git a/core/src/bin/eval.rs b/core/src/bin/eval.rs index 21864d2c..fc47c57e 100644 --- a/core/src/bin/eval.rs +++ b/core/src/bin/eval.rs @@ -527,7 +527,13 @@ fn main() { allow: inv_allow, out: inv_out, }; - let failed = invariants::run(&engine, lex_for_checks.as_ref(), nnlm_model, &cases, &opts); + let failed = invariants::run( + &mut engine, + lex_for_checks.as_ref(), + nnlm_model, + &cases, + &opts, + ); if failed { eprintln!("有不变量被违反了"); std::process::exit(1); diff --git a/core/src/bin/show.rs b/core/src/bin/show.rs index 010904fc..85f96a29 100644 --- a/core/src/bin/show.rs +++ b/core/src/bin/show.rs @@ -4,7 +4,8 @@ //! ``` //! wowtype-show (--data <目录> | --lexicon lexicon.tsv) [--lm words.lm | --no-lm] [--english english.txt | --no-english] //! [--nnlm nnlm.bin] -//! [--max 1000] [--show 18] [--context 文本] [--shuangpin 方案] [--scores] [--legacy] 拼音... +//! [--max 1000] [--show 18] [--context 文本] [--shuangpin 方案] [--scores] [--legacy] +//! [--no-typo] [--no-fuzzy-fallback] [--why] 拼音... //! ``` //! //! 只打印前 `--show` 个(默认 18,外壳的前两页)。`--legacy` 是以前的配置:候选上限 18、 @@ -42,6 +43,9 @@ fn main() { let mut no_english = false; let mut scheme = None; let mut inputs = Vec::new(); + let mut no_typo = false; + let mut no_fuzzy_fallback = false; + let mut why = false; let mut i = 1; while i < args.len() { let take = |i: &mut usize| -> String { @@ -72,10 +76,14 @@ fn main() { ); } "--scores" => scores = true, + "--no-typo" => no_typo = true, + "--no-fuzzy-fallback" => no_fuzzy_fallback = true, + "--why" => why = true, "--legacy" => legacy = true, "-h" | "--help" => { println!("wowtype-show (--data <目录> | --lexicon ) [--lm | --no-lm] [--english | --no-english]"); println!(" [--max n] [--show n] [--context 文本] [--shuangpin 方案] [--scores] [--legacy] 拼音..."); + println!(" [--no-typo] [--no-fuzzy-fallback] [--why] 关掉纠错 / 模糊音兜底;--why 标出拼音和是谁加的"); return; } other => inputs.push(other.to_string()), @@ -117,6 +125,12 @@ fn main() { config.shuangpin = true; config.shuangpin_scheme = s; } + if no_typo { + config.typo_correction = false; + } + if no_fuzzy_fallback { + config.fuzzy_fallback = false; + } let lm: Arc = if !lm_path.is_empty() { wowtype_core::lm::load_lm(&lm_path) .unwrap_or_else(|e| fail(&format!("语言模型载入失败: {e:#}"))) @@ -156,10 +170,28 @@ fn main() { } else { "词" }; + // --why:拼音,和是哪种机制加进来的(* 纠错、~ 模糊音兜底、^ 简拼、+ 补全) + let detail = if why { + let f = &c.features; + let mut marks = String::new(); + for (on, mark) in [ + (f.typo_count > 0.0, '*'), + (f.fuzzy, '~'), + (f.full_jianpin > 0.0, '^'), + (f.prefix_completion > 0.0, '+'), + ] { + if on { + marks.push(mark); + } + } + format!("[{}{marks}]", c.pinyin) + } else { + String::new() + }; if scores { - format!("{}.{}{}({:.1})", i + 1, c.text, kind, c.score) + format!("{}.{}{}{detail}({:.1})", i + 1, c.text, kind, c.score) } else { - format!("{}.{}{}", i + 1, c.text, kind) + format!("{}.{}{}{detail}", i + 1, c.text, kind) } }) .collect(); diff --git a/core/src/lib.rs b/core/src/lib.rs index 3fc30cfa..2566951d 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -754,6 +754,11 @@ impl Engine { self.config.typo_correction = on; } + /// 全拼走不通时是否试简拼(见 [`EngineConfig::jianpin_fallback`]),默认开。 + pub fn set_jianpin_fallback(&mut self, on: bool) { + self.config.jianpin_fallback = on; + } + /// 是否也出 CJK 扩展 B 区及以后的单字(默认不出,常见字体显示不了;通用规范汉字表里的照常)。 pub fn set_rare_ext_chars(&mut self, on: bool) { self.config.beam.rare_ext_chars = on; @@ -1241,6 +1246,7 @@ impl Engine { }; protect_exact_input(&mut result); + completions_after_exact_words(&mut result); typos_after_typed(&mut result); promote_picked(&mut result); pin_single_initial(&normalized, &mut result); @@ -1522,7 +1528,23 @@ impl Engine { && c.features.history_use_count == 0.0 && same_syllables(c, &candidate) }); - result.insert(stitched.unwrap_or(at), candidate); + // 打全了、够常用的整词不排在补全出来的候选后面(和 protect_exact_input 对束搜索结果做的一样): + // 束搜索的名额被补全的词占满时(qingkuan:情况、请况、轻狂……),「请款」只能从这里补进来, + // 以前插在全部补全候选后面 + let before_completion = (candidate.words[0].freq >= EXACT_PROTECT_MIN_FREQ) + .then(|| { + result[..at].iter().position(|c| { + c.consumed >= raw.len() + && c.features.prefix_completion > 0.0 + && c.features.history_use_count == 0.0 + }) + }) + .flatten(); + let place = match (stitched, before_completion) { + (Some(a), Some(b)) => a.min(b), + (a, b) => a.or(b).unwrap_or(at), + }; + result.insert(place, candidate); at += 1; } for (i, c) in raws { @@ -2465,10 +2487,13 @@ fn weak_syllables(path: &BeamPath) -> usize { /// 补全照常可以排第一。 fn protect_exact_input(candidates: &mut Vec) { let multi = |w: &CandidateWord| w.pinyin.split_whitespace().count() >= 2; + // 模糊音兜底的词不是照着打的(jiesu 的「结束」是 jie shu):当了锚点的话下面一个都不挪, + // 补全出来的「结算」就一直压在打全了的「借宿」前面 let is_exact = |c: &Candidate| { c.features.coverage_score >= 1.0 && c.features.typo_count == 0.0 && c.features.prefix_completion == 0.0 + && !c.features.fuzzy && !c.words.is_empty() && c.words.iter().all(|w| w.known) }; @@ -2568,8 +2593,10 @@ fn protect_exact_input(candidates: &mut Vec) { *candidates = keep; } -/// 纠错出来的候选不排在第一个照着打的读法(不纠错、每个词词库里都有、不是简拼)前面, -/// 除非它用的音节更少(`jintiam` 的「今天」)。 +/// 纠错出来的候选不排在第一个照着打的读法(不纠错、每个词词库里都有、不是简拼、不是模糊音兜底)前面, +/// 除非它用的音节更少(`jintiam` 的「今天」)。用户的原话:纠错应该是「添加可疑的候选词,而不是替代原候选词」。 +/// +/// 模糊音兜底的词不在这里管:`penyou` 出「朋友」、`shengme` 出「什么」排第一是回归集定死的。 /// /// [`typed_reading_first`] 在束搜索的结果上按分数压过一次,但后面按位置挪候选的步骤会把它绕过去: /// `sheihaiyo` 里压纠错词「谁还要」用的基准是补全出来的「谁还有」(yo → you),[`protect_exact_input`] @@ -2581,6 +2608,7 @@ fn typos_after_typed(candidates: &mut Vec) { !is_raw_candidate(c) && c.features.typo_count == 0.0 && c.features.full_jianpin == 0.0 + && !c.features.fuzzy && !c.words.is_empty() && c.words.iter().all(|w| w.known) }; @@ -2607,6 +2635,44 @@ fn typos_after_typed(candidates: &mut Vec) { *candidates = keep; } +/// 打全了、整个输入正好是一个够常用的词([`EXACT_PROTECT_MIN_FREQ`])时,补全出来的候选都排在这些词后面。 +/// +/// [`protect_exact_input`] 只认第一个这样的词:它已经排第一时什么都不挪。`fangxiangji` 第一个是「放像机」, +/// 补全的「方向键」(jian)就一直压在同样打全了的「芳香剂」前面。补全只能「加」候选,不能抢打全了的词的位置。 +/// 用户选过的补全不挪。 +fn completions_after_exact_words(candidates: &mut Vec) { + let exact_word = |c: &Candidate| { + c.words.len() == 1 + && c.words[0].known + && c.words[0].freq >= EXACT_PROTECT_MIN_FREQ + && c.features.coverage_score >= 1.0 + && c.features.typo_count == 0.0 + && c.features.prefix_completion == 0.0 + && c.features.full_jianpin == 0.0 + && !c.features.fuzzy + }; + let Some(last) = candidates.iter().rposition(exact_word) else { + return; + }; + let yields = |c: &Candidate| c.features.prefix_completion > 0.0 && c.features.history_use_count == 0.0; + if !candidates[..last].iter().any(yields) { + return; + } + let mut moved = Vec::new(); + let mut keep = Vec::with_capacity(candidates.len()); + for (i, c) in candidates.drain(..).enumerate() { + if i < last && yields(&c) { + moved.push(c); + } else { + keep.push(c); + } + } + let at = keep.iter().rposition(exact_word).map_or(keep.len(), |i| i + 1); + keep.splice(at..at, moved); + make_scores_monotonic(&mut keep); + *candidates = keep; +} + /// 两个候选的音节一样(整词和拼凑出来的整句:启动器 / 启动 | 其)。 fn same_syllables(a: &Candidate, b: &Candidate) -> bool { a.pinyin.split_whitespace().eq(b.pinyin.split_whitespace()) @@ -2821,12 +2887,15 @@ fn prefix_on_syllable_boundaries( // 第一名是纠错出来的(yusezhi 的「越职」yue zhi、gaj 的「感」gan)时,用户照着打的读法 // (雨色质 yu se zhi、噶举 ga j…)的音节边界也算:纠错的音节对不上字母,只按它对齐的话 // 句首词和第一个音节的单字全被筛掉,候选只剩几个纠错出来的整词 - let typed = (top.features.typo_count > 0.0) + // 第一名是模糊音兜底的词(kaoyang 的「考研」按 kao yang 显示,实际是 kao yan)时也一样: + // 按它对齐会把照着打的「烤烟…」(kao yan | g)筛掉 + let typed = (top.features.typo_count > 0.0 || top.features.fuzzy) .then(|| { result.iter().find(|c| { !is_raw_candidate(c) && c.features.typo_count == 0.0 && c.features.full_jianpin == 0.0 + && !c.features.fuzzy && c.words.iter().all(|w| w.known) }) }) @@ -2834,7 +2903,8 @@ fn prefix_on_syllable_boundaries( .map(syllables_of) // 最后一个音节可以是补全出来的(saj 的「撒娇」sa jiao),比字母长;对齐只看它前面的音节 .filter(|s| s.len() >= 2); - if syllables.len() < 2 && typed.is_none() { + let corrected_top = top.features.typo_count > 0.0 || top.features.fuzzy; + if syllables.len() < 2 && typed.is_none() && !corrected_top { prefix.clear(); return Vec::new(); } @@ -2863,11 +2933,14 @@ fn prefix_on_syllable_boundaries( if boundaries.contains(&used) { return true; } - if exact - && used < letters.len() - && p.pinyin.split_whitespace().collect::() == letters[..used] - && splits_into_syllables(&letters[used..]) - { + let typed_letters = p.pinyin.split_whitespace().collect::() == letters[..used]; + // 第一名是纠错出来的:照着打的字母读出来的句首词一个都不筛(纠错只能「加」候选)。 + // jitnian 的第一名「今天」(jin tian)和字母一个边界都对不上,没有这条时整个候选框只剩「今天」「金田」, + // ji 的单字全没了;gajg 的「尬」「嘎」、om 的「哦」也是 + if !exact && p.features.typo_count == 0.0 && typed_letters { + return true; + } + if exact && used < letters.len() && typed_letters && splits_into_syllables(&letters[used..]) { other_splits.push(p.clone()); } false @@ -3086,6 +3159,9 @@ fn compose_candidates(result: &mut Vec, prefix: Vec, max: // JUNK_SENTENCE_MARGIN 以上的整句(泥 | 好、点 | 脑、钟 | 国)是硬凑的,不占位置;用户选过的照留。 // 模糊音兜底加进来的词(模糊音关着时,ninke 接着上文出「宁可」)不算:照着打的读音(您 | 可) // 只能排在它后面,不能被它当成硬凑的整个筛掉 + // 纠错出来的词只在没有照着打的读法时才当基准(zhognguo 本来就读不通):meiyuo 的「没有」(yuo 当成 you) + // 当基准的话,照着打的「没雨哦」这些整句全被当成硬凑的去掉,纠错就成了「替换」 + let typed_exists = whole.iter().any(|c| c.features.typo_count == 0.0 && !c.features.fuzzy); let top_word = whole .first() .filter(|c| { @@ -3093,8 +3169,11 @@ fn compose_candidates(result: &mut Vec, prefix: Vec, max: && c.words[0].known && c.features.prefix_completion == 0.0 && !c.features.fuzzy + && (c.features.typo_count == 0.0 || !typed_exists) }) .map(|c| c.score); + // 照着打的候选(不纠错、不是模糊音兜底的) + let typed = |c: &Candidate| c.features.typo_count == 0.0 && !c.features.fuzzy; for c in whole { if is_sentence(&c) { let junk = top_word.is_some_and(|top| top - c.score > JUNK_SENTENCE_MARGIN); @@ -3102,8 +3181,11 @@ fn compose_candidates(result: &mut Vec, prefix: Vec, max: continue; } let first = kept.is_empty(); + // 整句的名额被纠错出来的整句占满、前面一个照着打的都没有时,照着打的这一句照样留:接着上文打 weihuj, + // 前面全是「委会」「维护」这些纠错的,照着打的「委户籍」「维护及」以前一个都不剩(纠错只能「加」候选) + let over_cap = sentences >= cap && !(typed(&c) && !kept.iter().any(typed)); if !first - && (sentences >= cap || kept.iter().any(|k| differs_only_at_tail(&k.text, &c.text))) + && (over_cap || kept.iter().any(|k| differs_only_at_tail(&k.text, &c.text))) { continue; } @@ -5471,6 +5553,78 @@ mod tests { assert_eq!(prefix.len(), 1); } + #[test] + fn typed_reading_of_a_char_survives_a_cheaper_correction() { + // 蹲:dun 常用、cun 冷门。纠错把 c 读成 d 得到的「蹲」便宜得多,以前同一个跨度里按代价去重, + // 照着打的 cun 被去掉,纠错的又因为第一名没纠错被筛掉,cunzai 里一个「蹲」都没有 + let e = engine(concat!( + "cun zai\t存在\t500000\n", + "cun\t存\t90000\n", + "cun\t村\t80000\n", + "dun\t蹲\t66158\n", + "cun\t蹲\t1\n", + "zai\t在\t900000\n", + )); + let found = e.input("cunzai"); + assert_eq!(found[0].text, "存在"); + assert!( + found.iter().any(|c| c.text == "蹲" && c.pinyin == "cun"), + "{:?}", + found.iter().map(|c| (&c.text, &c.pinyin)).collect::>() + ); + } + + #[test] + fn completions_go_after_every_exact_word() { + // fangxiangji:「放像机」已经第一,补全的「方向键」(jian)也不能压在打全了的「芳香剂」前面 + let mut completion = ranked("方向键", "fang xiang jian", 0.0, 11); + completion.features.prefix_completion = 1.0; + let mut list = vec![ + ranked("放像机", "fang xiang ji", 0.0, 11), + completion, + ranked("芳香剂", "fang xiang ji", 0.0, 11), + ]; + completions_after_exact_words(&mut list); + let texts: Vec<&str> = list.iter().map(|c| c.text.as_str()).collect(); + assert_eq!(texts, ["放像机", "芳香剂", "方向键"]); + } + + #[test] + fn typed_prefixes_stay_when_the_top_is_a_correction() { + // jitnian:第一名「今天」(jin tian)纠了一处,和字母一个音节边界都对不上; + // 照着打的 ji 的字以前全被筛掉,候选只剩「今天」「金田」 + let result = vec![ranked("今天", "jin tian", 1.0, 7)]; + let mut prefix = vec![ + ranked("几", "ji", 0.0, 2), + ranked("进", "jin", 1.0, 3), + ]; + prefix_on_syllable_boundaries(&result, "jitnian", &mut prefix); + let texts: Vec<&str> = prefix.iter().map(|c| c.text.as_str()).collect(); + assert_eq!(texts, ["几"]); + } + + #[test] + fn a_corrected_word_does_not_drop_typed_sentences_as_junk() { + // meiyuo:第一名「没有」是 yuo 当成 you 纠出来的;拿它当「打全了的整词」去筛硬凑的整句, + // 照着打的「没雨哦」就整个没了 + let mut corrected = ranked("没有", "mei you", 1.0, 6); + corrected.score = -8.0; + let mut typed = ranked("没雨哦", "mei yu o", 0.0, 6); + typed.words = [("没", "mei"), ("雨", "yu"), ("哦", "o")] + .iter() + .map(|(t, p)| CandidateWord { + text: t.to_string(), + pinyin: p.to_string(), + freq: 1000.0, + known: true, + }) + .collect(); + typed.score = -20.0; + let mut result = vec![corrected, typed]; + compose_candidates(&mut result, Vec::new(), 10); + assert!(result.iter().any(|c| c.text == "没雨哦")); + } + #[test] fn fuzzy_fallback_word_does_not_drop_the_typed_sentence() { // ninke 接着上文打:模糊音兜底加的「宁可」(ning ke)排第一时,照着打的「您 | 可」不能被当成硬凑的整句筛掉 diff --git a/docs/ENGINE-INVARIANTS.md b/docs/ENGINE-INVARIANTS.md index 27288635..0871fb92 100644 --- a/docs/ENGINE-INVARIANTS.md +++ b/docs/ENGINE-INVARIANTS.md @@ -6,6 +6,10 @@ 引擎本身的设计见 [ENGINE.md](ENGINE.md);排序评测(top1 命中率)见 [tools/eval/README.md](../tools/eval/README.md)。 +用户定的规矩,原话:「按键纠错逻辑我觉得应该是添加可疑的候选词,而不是替代原候选词吧」。这份文档把它当成头一条不变量: +**纠错只能往候选里加东西,不能删掉、也不能盖过照着打的字母读出来的东西**(照着打的读法,和照着打的音节的字、词)。 +补全、简拼、模糊音、双拼、神经语言模型重排也拿同一条规矩查了一遍(第 6 节)。 + ## 1. 起因 72bf8e2 修了 `cehaohou`(测好后):接着「我本地」打时只出「的好后」「得好后」。三处原因叠在一起: @@ -99,7 +103,9 @@ | 纠错的代价 | 约 log 0.01 ~ log 0.001,而且是额外一层 | `typo_cost` = 8(≈ log 0.0003),但词频、语言模型、神经语言模型的分数范围能到十几二十,一个罚分盖不住 | 高频字(的、得、是)附近的键最容易出事 | | 句首词(前缀)对齐 | 从输入开头起的精确词无条件加入(P3) | 按**第一名**的音节边界筛(`prefix_on_syllable_boundaries`),第一名是纠错的时就按纠错的音节筛 | 第一名是纠错时,照着打的第一个音节的单字整个没了(`yusezhi`、`gaj`,本次修了) | | 单字 | 永远在,不受上限(P8) | 翻页长尾补,但长尾也是按第一名的切法补;候选上限 1000 一般够 | 同上 | -| 补全 vs 精确 | librime 精确在前、再比剩下的码长(硬分层) | 补全每字母罚 1.5,单音节输入另有 `exact_syllable_first` 按位置分层,多音节输入只靠分数和 `protect_exact_input` | `typed_reading_first` 把补全出来的读法也当「照着打」的基准,后面的步骤又把补全的挪走了(`sheihaiyo`) | +| 补全 vs 精确 | librime 精确在前、再比剩下的码长(硬分层) | 补全每字母罚 1.5,单音节输入另有 `exact_syllable_first` 按位置分层,多音节输入只靠分数和 `protect_exact_input`(只认第一个打全了的词) | `typed_reading_first` 把补全出来的读法也当「照着打」的基准,后面的步骤又把补全的挪走了(`sheihaiyo`);`qingkuan` 的「请款」、`fangxiangji` 的「芳香剂」排在补全的「情况」「方向键」后面(本次修了) | +| 同字同跨度 | 留没纠错的那条(P4) | 束搜索、句首词、长尾按代价去重:纠错读出来的同一个字更便宜就留纠错的 | `cunzai` 里没有「蹲」(cun):纠错的 dun 便宜,照着打的被去重掉,纠错的又被筛掉(本次修了) | +| 名额 | 输入开头的精确词不受名额限制(P3、P9) | 句首词、长尾每个跨度的名额纠错词和照着打的词一起抢;整句名额同样 | 纠错出来的常用词把照着打的冷门字、整句挤掉(`weihuj` 接着上文打一个照着打的整句都不剩,本次修了) | | 模糊音兜底 | 模糊音是和精确读音并列的一层,罚分固定(log 0.5),精确的永远在(P1) | 模糊音关着时 `fuzzy_fallback` 在第一名偏弱时补一两个模糊音的词,和其它候选按分数混排;`compose_candidates` 以前把它当成「打全了的整词」,比它差 3 以上的照着打的整句全当硬凑的筛掉 | 接着上文打 `ninke` 只剩「宁可」,照着打的「您可」整个没了(本次修了) | | 简拼 | 正常拼写走得通就删简拼边 | 全拼有精确路径且有认识的词时不建简拼图(`run_query`),结构上已经分层 | 和成熟引擎一致 | | 整句 vs 整词 | 有精确整词盖住整段输入就不拼整句(P6) | 照样拼,再由 `protect_exact_input`、`compose_candidates` 的 `JUNK_SENTENCE_MARGIN` 按分差筛 | 分差是调出来的阈值 | @@ -125,6 +131,15 @@ | `min-candidates` | 第一个音节是打全了的音节时,中文候选至少 min(9, 这个音节的常用单字数) 个 | P8 | | `typed-kept` | 没有上文、不带模型时照着打的读法,加了上文或带上模型以后还在:是一个词时这个词还在;是几个词拼的整句时,至少还有一个照着打的整句 | P1 | | `no-duplicates` | 没有字和用掉的键都一样的两条候选 | P4 | +| `completion-outranks-word` | 打全了、整个输入正好是一个常用词(词频 1000 以上、拼音和打的字母一字不差)时,补全出来的候选不排在它前面 | P7 | +| `typo-only-adds` | **用户的规矩**:把按错键纠错关掉再查一次,关掉时第一页的词(整词、句首词、单字)开着时都还在,关掉时排第一的照着打的读法开着时也还在(是几个词拼的整句时,至少还有一个照着打的读法) | P1、P3 | +| `typo-outranks-typed` | 关掉纠错时排第一的照着打的读法,开着时不排在纠错加进来的候选后面(音节更少的例外,同 `typed-first`) | P1 | +| `fuzzy-only-adds` | 同 `typo-only-adds`,关的是模糊音兜底 | P1 | +| `fuzzy-outranks-typed` | 同 `typo-outranks-typed`,关的是模糊音兜底。**只报告、不算失败**,见第 6 节「等决定」 | P1 | +| `jianpin-only-adds`、`jianpin-outranks-typed` | 同上,关的是简拼;只查打全了的输入(`zg`、`wm` 本来就没有照着打的全拼读法,简拼就是照着打的) | P1 | + +纠错、模糊音兜底、简拼三条是对比着查的:开着时前两页里有它加进来的候选,就把它关掉(`set_typo_correction`、 +`set_fuzzy_fallback`、`set_jianpin_fallback`)再查一次。 怎么跑: @@ -135,7 +150,7 @@ scripts/invariants.sh /usr/share/wowtype --inv-limit 0 # ``` 数据目录、模型所在目录不可写时脚本先复制到临时目录(载入时会在旁边写缓存)。逐键约 2.4 万个前缀,加上带上文的约 5 万次查询(带模型再翻一倍), -不带模型约两分钟,带模型约六分钟。CI 的「排序评测(真实词库)」任务在排序评测后面跑它(复用编好的 `wowtype-eval`)。 +不带模型约两分半,带模型约十分钟。CI 的「排序评测(真实词库)」任务在排序评测后面跑它(复用编好的 `wowtype-eval`)。 **一条都不许违反。** 确实是对的、只是规则太死的,写进 `tools/eval/invariants-allow.tsv`(规则、输入、上文、理由四列), 不写理由不认;清单里的条目不再违反了,检查也会失败,提醒删掉。现在清单是空的。 @@ -144,7 +159,9 @@ scripts/invariants.sh /usr/share/wowtype --inv-limit 0 # - 一种输入有几种照着打的切法(`kenengs` = ke neng s / ken eng s,`hung` = hu ng / hun g…):只要候选里第一个照着打的读法用的那一种的单字; - 词库里一个字都没有的音节(`nia`、`ng`、`hm`)不算「照着打能读」:`zuinia` 照着打是 zui ni a,三个音节,纠一处的「最佳」两个音节,按「音节更少」的例外排第一不算错; -- 模糊音兜底的词(`zuijing` 的「最近」、`penyou` 的「朋友」)不算照着打的读法:规则查词库,词库里这个词真有这个读音才算。 +- 模糊音兜底的词(`zuijing` 的「最近」、`penyou` 的「朋友」)不算照着打的读法:规则查词库,词库里这个词真有这个读音才算; +- 翻页长尾里补全出来的词没有补全的标记(`shenghu` 的「圣皇」是 sheng huang):「打全了的词」要拼音和打的字母一字不差; +- 「只能加」不管几个词硬凑的整句(`zenm` 的「谮吗」):整句有名额、会换拼法,只要还有一个照着打的读法就行。 ## 6. 这次查出来的 @@ -152,34 +169,95 @@ scripts/invariants.sh /usr/share/wowtype --inv-limit 0 # ### 修之前(pre-release 的 72bf8e2,规则同上) -NNLM_BEFORE_PLACEHOLDER - -### 修了的两处 - -1. **第一名是纠错时,句首词和单字按纠错的音节对齐,全被筛掉**(`prefix_on_syllable_boundaries`)。 +检查跑在两种配置上:不带模型(和 CI 一样),以及带 `nnlm.bin`(每种上文带、不带模型各查一次)。 + +| 规则 | 不带模型 | 带模型 | +|---|---:|---:| +| `typed-first` | 1 | 5 | +| `typed-first-partial` | 0 | 0 | +| `first-syllable-chars` | 22 | 44 | +| `min-candidates` | 1 | 4 | +| `typed-kept` | 5 | 13 | +| `no-duplicates` | 0 | 0 | +| 合计 | 29 | 66 | + +典型的几条(`*` 是纠错出来的,`…` 是句首词): + +- `suanlibugouxunli`(算力不够训练,带模型):候选只有三个,第一个是纠错的「山里不够训练*」,suan 的单字一个都没有。 + 和 `cehaohou` 同一类,72bf8e2 没拦住:拦的是束搜索里的分数,后面按位置挪候选的步骤又把纠错的挪了回来,句首词也按纠错的音节对齐。 +- `jidegeimamadadianhu`(记得给妈妈打电话,接着「我本地」、带模型):只剩三个,第一个「借给妈妈打电话*」,ji 的单字没了。 +- `ditieshan`(接着「我本地」、带模型):第一个是「地铁站*」(sh 当成 zh),照着打的「地铁山」排在后面;`hegere` 第一个是「合格的*」。 +- `yusezhi`:一共 6 个候选,全是纠错和硬凑的整句,yu 的单字、「语塞」都没有。 +- `sheihaiyo`:第一个是纠错的「谁还要*」(yo 当成漏按的 yao),照着打的「谁嗨哟」第二。 +- `saj`、`ern`、`rem`、`huw`、`kab`、`shuk`……(接着「我本地」):第一个是纠错出来的单字(赛*、人*……), + 第一个音节(sa、er、re、hu……)的单字一个都没有。 +- `ninke`、`zhouru`、`pencha`……(接着「我本地」):模糊音兜底的「宁可」「走入」排第一,照着打的「您可」「周如」整个没了。 + +「只能加」的六条规则(`completion-outranks-word` 和 typo / fuzzy / jianpin 的两条)是在前三处修完以后才加的, +旧引擎上没法直接跑(要用到本次加的 `Feature::fuzzy`、`set_jianpin_fallback`)。规则改准以后第一次跑(不带模型,带「我本地」): +`completion-outranks-word` 58、`typo-only-adds` 122、`typo-outranks-typed` 1、`fuzzy-only-adds` 5,修到下面第 9 处时全部清零。 + +### 修了的九处 + +1. **第一名是纠错或模糊音兜底的词时,句首词和单字按它的音节对齐,全被筛掉**(`prefix_on_syllable_boundaries`)。 `yusezhi`:第一名「越职」是删掉 s 纠出来的(yue zhi),yu、yu se 一个边界都对不上,句首词(语塞、雨……)全没了, - 整个候选框只有 6 个;`gaj`:第一名「感」(gan)只有一个音节,按老规矩一个句首词都不留,ga 的单字(嘎)没了。 - 现在第一名是纠错的时,照着打的读法(第一个不纠错、每个词都认识、不是简拼的候选)的音节边界也算(对应 P3、P8)。 - `yusezhi` 现在 790 个候选,第一页有「语塞」「雨」「与」。 + 整个候选框只有 6 个;`gaj`、`saj`、`ern`:第一名「感」「赛」「人」只有一个音节,按老规矩一个句首词都不留; + `kaoyang`:第一名是模糊音兜底的「考研」(按 kao yang 显示),照着打的「烤烟…」被筛掉。 + 现在照着打的读法(第一个不纠错、不是模糊音兜底、每个词都认识、不是简拼的候选)的音节边界也算;第一名是纠错的时, + 拼音和打的字母一字不差的句首词一个都不筛(`jitnian` 以前整个候选框只剩「今天」「金田」,现在 ji 的字都在)。对应 P3、P8。 2. **纠错词被按位置挪回第一**(新加 `typos_after_typed`)。`sheihaiyo`:`typed_reading_first` 压纠错词「谁还要」时 用的基准是补全出来的「谁还有」(yo → you),接着 `protect_exact_input` 把补全的整句挪到「谁嗨哟」后面, 「谁还要」又成了第一个。现在 `protect_exact_input` 之后按位置再拦一次:纠错的候选不排在第一个照着打的读法前面, 除非音节更少(对应 P1)。 - -3. **模糊音兜底的词把照着打的整句当成硬凑的筛掉**(`compose_candidates`)。模糊音关着时,第一名偏弱就由 - `fuzzy_fallback` 补一两个模糊音的词(`penyou` → 朋友)。接着上文打 `ninke` 时补进来的「宁可」(ning ke)排第一, - `compose_candidates` 把它当成「打全了的整词」,比它差 3 以上的整句都当硬凑的去掉,照着打的「您可」整个没了 - (`zhouru` 的「周如」、`nachi` 的「那吃」、`zhidingyi` 的「指定一」带模型时也一样)。现在模糊音兜底的候选带一个标记 - (`Feature::fuzzy`,不是排序特征,不进权重),不当这个筛选的基准(对应 P1):照着打的整句排在它后面,不再被筛掉。 - -三处都有单元测试(`typos_never_end_up_ahead_of_the_typed_reading`、 -`prefix_words_follow_the_typed_syllables_when_the_top_is_a_correction`、 -`fuzzy_fallback_word_does_not_drop_the_typed_sentence`)。排序评测各组和基线持平(逐组 +0.0)。 +3. **模糊音兜底的词把照着打的整句当成硬凑的筛掉**(`compose_candidates`)。接着上文打 `ninke` 时补进来的「宁可」排第一, + 比它差 3 以上的整句都当硬凑的去掉,照着打的「您可」整个没了(`zhouru`、`nachi`、`zhidingyi` 带模型时也一样)。 + 现在模糊音兜底的候选带标记 `Feature::fuzzy`(不是排序特征,不进权重),不当这个筛选的基准(对应 P1)。 +4. **纠错词当硬凑整句的基准**(`compose_candidates`)。`meiyuo`:第一名「没有」是 yuo 当成 you 纠出来的,拿它去筛, + 照着打的「没雨哦」整个没了。现在纠错出来的词只在没有任何照着打的读法时才当基准(`zhognguo` 这种本来就读不通的照旧)。 +5. **整句名额被纠错的整句占满**(`compose_candidates`)。接着上文打 `weihuj`、`weidew`:前面全是纠错的「委会」「委的」, + 照着打的「委户籍」「味的我」一个都不剩。现在前面一个照着打的都没有时,照着打的这一句不受整句名额限制(对应 P3)。 +6. **同字同跨度留了纠错的那条**(`beam.rs` 的 `collect_spans`)。「蹲」dun 常用、cun 冷门:同一个跨度里按代价去重, + 纠错读出来的 dun 便宜,照着打的 cun 被去掉,后面纠错的又被筛掉,`cunzai`、`cunku` 里没有「蹲」。现在同字时留照着打的(对应 P4, + 和 libime 一样)。 +7. **句首词、长尾的名额纠错词和照着打的一起抢**(`collect_spans`、`first_words`)。现在纠错词另算名额,超过上限时先去掉纠错词(对应 P3)。 + 束搜索本身不动(72bf8e2 的 `prune` 已经给纠错最少的状态保底)。 +8. **补全压过打全了的词**。两处:`protect_exact_input` 把模糊音兜底的「结束」(jiesu)当成打全了的锚点,一个都不挪, + 补全的「结算」压在「借宿」前面(锚点现在不认模糊音);它只认第一个打全了的词,`fangxiangji` 第一个是「放像机」时补全的 + 「方向键」照样压在「芳香剂」前面(新加 `completions_after_exact_words`,补全的排到所有打全了的常用词后面);束搜索名额被补全占满时, + 打全了的「请款」(qingkuan)从长尾补进来,以前插在全部补全候选后面(`append_more_candidates`,现在插在补全前面)。对应 P7。 +9. 排序评测因此**涨了**:`trunc_exact` 96.7% → 98.4%,`mid` 93.8% → 94.1%,其余各组持平,`tools/eval/baseline.tsv` 已更新。 + +每一处都有单元测试(`typos_never_end_up_ahead_of_the_typed_reading`、 +`prefix_words_follow_the_typed_syllables_when_the_top_is_a_correction`、`typed_prefixes_stay_when_the_top_is_a_correction`、 +`fuzzy_fallback_word_does_not_drop_the_typed_sentence`、`a_corrected_word_does_not_drop_typed_sentences_as_junk`、 +`typed_reading_of_a_char_survives_a_cheaper_correction`、`completions_go_after_every_exact_word`)。 ### 修之后 NNLM_AFTER_PLACEHOLDER +### 等决定:模糊音兜底要不要也「只加不抢第一」 + +模糊音关着时,第一名偏弱就由 `fuzzy_fallback` 补一两个模糊音的词,分数高出一截就排第一:`zhouba` 第一是「走吧」, +照着打的「周报」第二;`lindai` 第一是「领带」,照着打的「林带」第二。按用户的规矩,这也是「替代」。但回归集 +(`tools/eval/regress.tsv` 第 82、83 条)明确要求 `shengme` → 什么、`penyou` → 朋友 排第一,改成只加这两条就失败。 +所以现在:模糊音兜底**只加不删**是硬规则(`fuzzy-only-adds`,已经清零),**排到照着打的前面**只报告(`fuzzy-outranks-typed`, +不带模型约 57 条)。要改的话:`typos_after_typed` 的 `yields` 加上 `c.features.fuzzy`(试过,其余各组不变),同时改回归集那两条。 + +### 其它几种机制 + +- **双拼**:按错键纠错和模糊音兜底在双拼下本来就关着(`run_query`、`prefix_candidates`、`append_more_candidates` 里的 + `typo = typo_correction && !shuangpin`、`fuzzy_fallback && !shuangpin`),补全只给悬空的声母,简拼只在全拼走不通时用, + 结构上不会替换照着打的读法。不变量检查不跑双拼用例(`sp=`),这一点是读代码得出的,没有逐键验证。 +- **神经语言模型重排**:只在束搜索的路径里重排,72bf8e2 以后以照着打的读法为基准;带 `nnlm.bin` 的检查里 + `typed-kept`(加了模型照着打的读法还在)和其余规则见上表。 +- **会话层**(`core/src/session.rs`):读了候选怎么拼(`compute_candidates`)、翻页、选句首词(`choose_now`)、学习(`learn`、 + `learn_composed`)、上文(`set_context`、`check_context`)。会话只往引擎的候选里**加**东西(emoji 推荐插在第 3 个、按键 emoji、 + 日期时间),不删不重排引擎的候选;唯一挪位置的是日期时间的触发词(打 `shijian` 时把「时间」挪到第一),挪的就是照着打的那个词。 + 选了纠错出来的词,记的是纠错后的拼音(`record_selection_with_pinyin(词, 纠错后的拼音)`),不会把「ce → 的」学进去; + `promote_picked` 只提前没纠错、没补全、不是简拼的选过的词,所以选过一次纠错词也不会让它下次排到照着打的前面。 + 这一层没查出要改的地方;逐键的会话级检查(翻页、选了句首词以后剩下的部分)没有做,`scripts/addon-test.sh` 的按键用例照常全过。 + ## 7. 还没做的:把规矩收拢成分层 不变量检查只能事后兜底。照成熟引擎的做法,建议按这个顺序把散着的补救收拢(每一步都要 `scripts/eval.sh` 持平、 @@ -194,6 +272,6 @@ NNLM_AFTER_PLACEHOLDER 作为显式的规则写在这一步,而不是靠分数碰巧。 3. **纠错候选有名额**(P5):照着打的读法存在时,前两页最多几个纠错候选。 4. **句首词不再按第一名的切法筛**,改成 libime 的做法(P3):从输入开头起、落在照着打的任一种切法的音节边界上的精确词无条件加入, - 纠错的句首词只在分数窗口里加。本次的修复是这一步的最小版本。 + 纠错的句首词只在分数窗口里加。本次的修复(第 1、7 处)是这一步的最小版本。 5. **有精确整词盖住整段输入时不拼整句**(P6),代替 `JUNK_SENTENCE_MARGIN` 这个按分差筛的阈值。 6. **评测集加逐键的整句用例**:现在 `daily.tsv` 只测整句打完那一刻。不变量检查已经逐键跑,但只检查规则,不检查 top1。 diff --git a/tools/eval/baseline.tsv b/tools/eval/baseline.tsv index 32b4b014..5fe82e31 100644 --- a/tools/eval/baseline.tsv +++ b/tools/eval/baseline.tsv @@ -4,12 +4,12 @@ # 组 用例 top1 top3 top9 通过 regress 69 63 65 69 69 common 1000 967 998 1000 967 -mid 1000 938 990 999 938 +mid 1000 941 997 1000 941 rare 1000 888 986 1000 888 jianpin 1000 630 810 914 630 trunc 1000 922 984 994 922 -trunc_exact 1000 967 982 994 967 +trunc_exact 1000 984 1000 1000 984 homophone2 300 300 300 300 300 homophone3 200 199 200 200 200 daily 138 127 130 132 127 -context 533 471 524 532 471 +context 533 471 525 532 471 From 03964c7530d89008318331f2744f5b37e67dbe07 Mon Sep 17 00:00:00 2001 From: Ethan Zou Date: Thu, 19 Nov 2026 08:05:01 +0800 Subject: [PATCH 3/4] =?UTF-8?q?=E7=BA=A0=E9=94=99=E5=87=BA=E6=9D=A5?= =?UTF-8?q?=E7=9A=84=E5=BC=80=E5=A4=B4=E8=AF=8D=E4=B8=8D=E6=94=BE=E7=AC=AC?= =?UTF-8?q?=E4=BA=8C=E4=BD=8D=EF=BC=9B=E6=96=87=E6=A1=A3=E5=86=99=E4=B8=8A?= =?UTF-8?q?=E6=9C=80=E5=90=8E=E7=9A=84=E6=A3=80=E6=9F=A5=E7=BB=93=E6=9E=9C?= =?UTF-8?q?=E5=92=8C=E8=BF=98=E6=B2=A1=E4=BF=AE=E7=9A=84?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 接着上文打 jidegeimamadadianhu(带模型):第一个是纠错的「借给妈妈打电话」(音节更少,可以第一), compose_candidates 又把它的开头「借给…」(也是纠错的)放到第二位,压在照着打的「记得给麻麻打电话」前面。 开头词是纠错的时不放第二位。排序评测不变。 docs/ENGINE-INVARIANTS.md:修之后的数字(不带模型全部清零;带模型还有 4 条 typo-only-adds,是第一名的切法 换了以后换切法的句首词跟着没了,不是纠错替换,写了建议的修法)、模糊音兜底要不要也只加(等用户定)、 双拼 / 神经语言模型 / 会话层查下来的结论。 --- core/src/lib.rs | 34 ++++++++++++++++++++++++++++++++- docs/ENGINE-INVARIANTS.md | 40 ++++++++++++++++++++++++++++++++++----- 2 files changed, 68 insertions(+), 6 deletions(-) diff --git a/core/src/lib.rs b/core/src/lib.rs index 2566951d..5ab8f964 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -3226,7 +3226,11 @@ fn compose_candidates(result: &mut Vec, prefix: Vec, max: kept.insert(1, word); } } - let long_sentence = syllables >= 4 && kept.first().map(is_sentence).unwrap_or(false); + // 第一名是纠错出来的整句时(接着上文打 jidegeimamadadianhu,第一个是「借给妈妈打电话」),它的开头「借给」也是纠错的, + // 不放到第二位去压照着打的「记得给妈妈打电话」 + let head_corrected = prefix.first().is_some_and(|p| p.features.typo_count > 0.0); + let long_sentence = + syllables >= 4 && !head_corrected && kept.first().map(is_sentence).unwrap_or(false); let mut merged: Vec = Vec::with_capacity(kept.len() + prefix.len() + corrected.len()); let mut prefix = prefix.into_iter(); @@ -5625,6 +5629,34 @@ mod tests { assert!(result.iter().any(|c| c.text == "没雨哦")); } + #[test] + fn a_corrected_head_word_does_not_take_the_second_slot() { + // 第一名是纠错出来的长整句时,它的开头词也是纠错的,不放到第二位压照着打的整句 + let sentence = |text: &str, words: &[(&str, &str)], typos: f32, score: f64| { + let mut c = ranked(text, "", typos, 8); + c.words = words + .iter() + .map(|(t, p)| CandidateWord { + text: t.to_string(), + pinyin: p.to_string(), + freq: 1000.0, + known: true, + }) + .collect(); + c.pinyin = words.iter().map(|w| w.1).collect::>().join(" "); + c.score = score; + c + }; + let corrected = sentence("借给妈妈", &[("借给", "jie gei"), ("妈妈", "ma ma")], 1.0, -10.0); + let typed = sentence("记得给妈妈", &[("记得", "ji de"), ("给", "gei"), ("妈妈", "ma ma")], 0.0, -12.0); + let mut head = ranked("借给", "jie gei", 1.0, 4); + head.score = -11.0; + let mut result = vec![corrected, typed]; + compose_candidates(&mut result, vec![head], 10); + let texts: Vec<&str> = result.iter().map(|c| c.text.as_str()).collect(); + assert_eq!(texts[1], "记得给妈妈", "{texts:?}"); + } + #[test] fn fuzzy_fallback_word_does_not_drop_the_typed_sentence() { // ninke 接着上文打:模糊音兜底加的「宁可」(ning ke)排第一时,照着打的「您 | 可」不能被当成硬凑的整句筛掉 diff --git a/docs/ENGINE-INVARIANTS.md b/docs/ENGINE-INVARIANTS.md index 0871fb92..3b9163d8 100644 --- a/docs/ENGINE-INVARIANTS.md +++ b/docs/ENGINE-INVARIANTS.md @@ -195,9 +195,9 @@ scripts/invariants.sh /usr/share/wowtype --inv-limit 0 # 「只能加」的六条规则(`completion-outranks-word` 和 typo / fuzzy / jianpin 的两条)是在前三处修完以后才加的, 旧引擎上没法直接跑(要用到本次加的 `Feature::fuzzy`、`set_jianpin_fallback`)。规则改准以后第一次跑(不带模型,带「我本地」): -`completion-outranks-word` 58、`typo-only-adds` 122、`typo-outranks-typed` 1、`fuzzy-only-adds` 5,修到下面第 9 处时全部清零。 +`completion-outranks-word` 58、`typo-only-adds` 122、`typo-outranks-typed` 1、`fuzzy-only-adds` 5,修完下面几处以后不带模型时全部清零。 -### 修了的九处 +### 修了的几处 1. **第一名是纠错或模糊音兜底的词时,句首词和单字按它的音节对齐,全被筛掉**(`prefix_on_syllable_boundaries`)。 `yusezhi`:第一名「越职」是删掉 s 纠出来的(yue zhi),yu、yu se 一个边界都对不上,句首词(语塞、雨……)全没了, @@ -225,16 +225,46 @@ scripts/invariants.sh /usr/share/wowtype --inv-limit 0 # 补全的「结算」压在「借宿」前面(锚点现在不认模糊音);它只认第一个打全了的词,`fangxiangji` 第一个是「放像机」时补全的 「方向键」照样压在「芳香剂」前面(新加 `completions_after_exact_words`,补全的排到所有打全了的常用词后面);束搜索名额被补全占满时, 打全了的「请款」(qingkuan)从长尾补进来,以前插在全部补全候选后面(`append_more_candidates`,现在插在补全前面)。对应 P7。 -9. 排序评测因此**涨了**:`trunc_exact` 96.7% → 98.4%,`mid` 93.8% → 94.1%,其余各组持平,`tools/eval/baseline.tsv` 已更新。 +9. **纠错出来的开头词放到第二位**(`compose_candidates`)。四个音节以上时第二位放第一名的开头词;第一名是纠错的整句时 + (接着「我本地」打 `jidegeimamadadianhu`,带模型时第一个是「借给妈妈打电话」),开头的「借给…」也是纠错的,压在照着打的 + 「记得给麻麻打电话」前面。现在开头词是纠错的时不放第二位。 +10. 排序评测因此**涨了**:`trunc_exact` 96.7% → 98.4%,`mid` 93.8% → 94.1%,其余各组持平,`tools/eval/baseline.tsv` 已更新。 每一处都有单元测试(`typos_never_end_up_ahead_of_the_typed_reading`、 `prefix_words_follow_the_typed_syllables_when_the_top_is_a_correction`、`typed_prefixes_stay_when_the_top_is_a_correction`、 `fuzzy_fallback_word_does_not_drop_the_typed_sentence`、`a_corrected_word_does_not_drop_typed_sentences_as_junk`、 -`typed_reading_of_a_char_survives_a_cheaper_correction`、`completions_go_after_every_exact_word`)。 +`typed_reading_of_a_char_survives_a_cheaper_correction`、`completions_go_after_every_exact_word`、 +`a_corrected_head_word_does_not_take_the_second_slot`)。 ### 修之后 -NNLM_AFTER_PLACEHOLDER +同样的数据和条件(每个前缀不带上文、带用例的上文、带「我本地」各查一次): + +| 规则 | 不带模型(CI) | 带 `nnlm.bin` | +|---|---:|---:| +| `typed-first` / `typed-first-partial` | 0 / 0 | 0 / 0 | +| `first-syllable-chars` | 0 | 0 | +| `min-candidates` | 0 | 0 | +| `typed-kept` | 0 | 0 | +| `no-duplicates` | 0 | 0 | +| `completion-outranks-word` | 0 | 0 | +| `typo-only-adds` / `typo-outranks-typed` | 0 / 0 | 4 / 0 | +| `fuzzy-only-adds` | 0 | 0 | +| `jianpin-only-adds` / `jianpin-outranks-typed` | 0 / 0 | 0 / 0 | +| `fuzzy-outranks-typed`(只报告) | 57 | 144 | + +带模型那一列是在最后一处修改(`compose_candidates` 不把纠错出来的开头词放到第二位)之前跑的,那时还有一条 +`typo-outranks-typed`:接着「我本地」打 `jidegeimamadadianhu`,第一个是纠错的「借给妈妈打电话」(音节更少,按例外可以第一), +它的开头「借给…」也是纠错的,被放到第二位,压在照着打的「记得给麻麻打电话」前面。修了以后用 `wowtype-show` 核对过 +(照着打的整句排第二),排序评测不变;带模型的整套检查没有在最后这次修改之后重跑。 + +### 还没修的 + +带模型、接着上文打时的 4 条 `typo-only-adds`(`lingjias`、`biwans`、`duochuang`、`wanshir`):关掉纠错时第一页有的 +句首词(`lingjias` 的「另计」「灵机」「零级」)开着时没了。查下来不是纠错替换了照着打的东西,而是开关纠错时排第一的 +**照着打的读法**换了一个(「另加上」ling jia shang 和「零假设」ling jia she),`prefix_on_syllable_boundaries` 按第一名的切法筛句首词, +「灵机」是 ling ji | a s 这种换切法才对得上的词,跟着第一名的切法时有时无。不带模型时不出现,所以 CI 不拦。 +建议的修法就是第 7 节第 4 条:句首词不按第一名的切法筛,从输入开头起、落在任一种照着打的切法的音节边界上的词都留。 ### 等决定:模糊音兜底要不要也「只加不抢第一」 From d16e689780212e62cb82b876692298ba27281891 Mon Sep 17 00:00:00 2001 From: Ethan Zou Date: Thu, 19 Nov 2026 19:00:29 +0800 Subject: [PATCH 4/4] =?UTF-8?q?=E6=A8=A1=E7=B3=8A=E9=9F=B3=E5=85=9C?= =?UTF-8?q?=E5=BA=95=EF=BC=9A=E7=85=A7=E7=9D=80=E6=89=93=E6=9C=AC=E8=BA=AB?= =?UTF-8?q?=E6=98=AF=E8=AF=8D=E5=BA=93=E9=87=8C=E7=9A=84=E5=B8=B8=E7=94=A8?= =?UTF-8?q?=E8=AF=8D=E6=97=B6=E8=AE=A9=E4=BD=8D=EF=BC=88penyou=20=E5=87=BA?= =?UTF-8?q?=E3=80=8C=E5=96=B7=E6=B2=B9=E3=80=8D=E3=80=8C=E6=9C=8B=E5=8F=8B?= =?UTF-8?q?=E3=80=8D=EF=BC=89=EF=BC=8C=E5=8F=AA=E8=83=BD=E7=A1=AC=E5=87=91?= =?UTF-8?q?=E6=97=B6=E6=89=8D=E6=8E=92=E7=AC=AC=E4=B8=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 用户定的规矩。照着打的读法是词库里词频够的整词时它排第一,模糊音兜底的词紧跟其后 (penyou、zuijing、lindai、tiexiang);照着打只能几个字硬凑或靠补全时照旧模糊音的词第一 (shengme 什么、zhouba 走吧)。用户选过的模糊音词不挪。 检查:新硬规则 fuzzy-outranks-word,去掉只报告的 fuzzy-outranks-typed。不带模型全部规则 0 违反; 带模型只剩文档里记着的 4 条 typo-only-adds。 评测:regress 改了 penyou(喷油第一、朋友前两名)、加了 zuijing,72 条全过;mid 941 → 942,其余各组不变。 --- core/src/bin/common/invariants.rs | 42 +++++++++------ core/src/lib.rs | 89 +++++++++++++++++++++++++++---- docs/ENGINE-INVARIANTS.md | 27 +++++----- docs/ENGINE.md | 3 +- tools/eval/baseline.tsv | 4 +- tools/eval/regress.tsv | 6 ++- 6 files changed, 128 insertions(+), 43 deletions(-) diff --git a/core/src/bin/common/invariants.rs b/core/src/bin/common/invariants.rs index 841c668b..840a28e4 100644 --- a/core/src/bin/common/invariants.rs +++ b/core/src/bin/common/invariants.rs @@ -37,13 +37,9 @@ use wowtype_core::{ SyllableQuery, }; -/// 只报告、不算失败的规则:模糊音兜底的词排到照着打的读法前面(`penyou` -> 朋友、`shengme` -> 什么) -/// 是回归集定死的现有行为,要不要也改成「只加」等用户定,见 docs/ENGINE-INVARIANTS.md。 -const REPORT_ONLY: [&str; 1] = ["fuzzy-outranks-typed"]; - /// 一页候选的个数(min-candidates 的上限)。 const PAGE: usize = 9; -/// completion-outranks-word 只管这么常用以上的词(和引擎的 `EXACT_PROTECT_MIN_FREQ` 一样)。 +/// completion-outranks-word、fuzzy-outranks-word 只管这么常用以上的词(和引擎的 `EXACT_PROTECT_MIN_FREQ` 一样)。 const EXACT_WORD_FREQ: f64 = 1000.0; pub struct Options { @@ -373,6 +369,23 @@ fn check_one( ), ); } + // fuzzy-outranks-word:同样的词也不排在模糊音兜底的词后面(penyou 出「喷油」「朋友」)。照着打 + // 只能几个字硬凑时(shengme)模糊音的词可以排第一,那是用户定的,不查 + let ahead: Vec<&str> = cands[..at] + .iter() + .filter(|c| c.features.fuzzy) + .map(|c| c.text.as_str()) + .collect(); + if !ahead.is_empty() { + report( + "fuzzy-outranks-word", + format!( + "照着打的词「{}」排在模糊音兜底的「{}」后面", + cands[at].text, + ahead.join("」「") + ), + ); + } } } // min-candidates @@ -468,7 +481,8 @@ fn only_adds( ("typo", "adds") => "typo-only-adds", ("typo", _) => "typo-outranks-typed", ("fuzzy", "adds") => "fuzzy-only-adds", - ("fuzzy", _) => "fuzzy-outranks-typed", + // 模糊音的「排到前面」不在这里查:照着打是现成的词时归 fuzzy-outranks-word,硬凑时允许 + ("fuzzy", _) => "fuzzy-outranks-word", (_, "adds") => "jianpin-only-adds", _ => "jianpin-outranks-typed", } @@ -505,6 +519,9 @@ fn only_adds( let Some(top) = top else { return; }; + if mechanism.name == "fuzzy" { + return; + } // 开着时它前面的、加进来的候选:比到它和开着时第一个照着打的读法里靠前的那个 let Some(at) = on .iter() @@ -745,9 +762,7 @@ pub fn run( used_allow.insert(v.key()); continue; } - if !REPORT_ONLY.contains(&v.rule) { - new_count += 1; - } + new_count += 1; match by_rule.iter_mut().find(|(r, _)| *r == v.rule) { Some((_, list)) => list.push(v), None => by_rule.push((v.rule, vec![v])), @@ -765,7 +780,7 @@ pub fn run( "typo-only-adds", "typo-outranks-typed", "fuzzy-only-adds", - "fuzzy-outranks-typed", + "fuzzy-outranks-word", "jianpin-only-adds", "jianpin-outranks-typed", ]; @@ -781,17 +796,12 @@ pub fn run( .filter(|v| v.rule == rule && allow.contains_key(&v.key())) .count(); println!( - "{rule:<24} 违反 {}{}{}", + "{rule:<24} 违反 {}{}", list.len(), if allowed > 0 { format!("(另有 {allowed} 条在已知清单里)") } else { String::new() - }, - if REPORT_ONLY.contains(&rule) { - "(只报告,不算失败,见 docs/ENGINE-INVARIANTS.md)" - } else { - "" } ); let shown = if opts.limit == 0 { diff --git a/core/src/lib.rs b/core/src/lib.rs index 5ab8f964..ea6cfc7c 100644 --- a/core/src/lib.rs +++ b/core/src/lib.rs @@ -1248,6 +1248,7 @@ impl Engine { protect_exact_input(&mut result); completions_after_exact_words(&mut result); typos_after_typed(&mut result); + fuzzy_after_exact_word(&mut result); promote_picked(&mut result); pin_single_initial(&normalized, &mut result); self.promote_custom(&mut result); @@ -2635,22 +2636,53 @@ fn typos_after_typed(candidates: &mut Vec) { *candidates = keep; } +/// 照着打、打全了、整个输入正好是词库里一个够常用的词([`EXACT_PROTECT_MIN_FREQ`])。 +fn is_exact_frequent_word(c: &Candidate) -> bool { + c.words.len() == 1 + && c.words[0].known + && c.words[0].freq >= EXACT_PROTECT_MIN_FREQ + && c.features.coverage_score >= 1.0 + && c.features.typo_count == 0.0 + && c.features.prefix_completion == 0.0 + && c.features.full_jianpin == 0.0 + && !c.features.fuzzy +} + +/// 照着打的读法本身就是词库里一个够常用的词时,模糊音兜底的词排在第一个这样的词后面 +/// (`penyou`:喷油、朋友;`zuijing`:最精、最近)。 +/// +/// 照着打只能几个字硬凑(`shengme` 没有 sheng me 这个词)时不动,模糊音的词照旧排第一(什么): +/// 那时它多半才是用户要的。用户选过的模糊音词也不动。 +fn fuzzy_after_exact_word(candidates: &mut Vec) { + let Some(first) = candidates.iter().position(is_exact_frequent_word) else { + return; + }; + let yields = |c: &Candidate| c.features.fuzzy && c.features.history_use_count == 0.0; + if !candidates[..first].iter().any(yields) { + return; + } + let mut moved = Vec::new(); + let mut keep = Vec::with_capacity(candidates.len()); + for (i, c) in candidates.drain(..).enumerate() { + if i < first && yields(&c) { + moved.push(c); + } else { + keep.push(c); + } + } + let at = keep.iter().position(is_exact_frequent_word).map_or(keep.len(), |i| i + 1); + keep.splice(at..at, moved); + make_scores_monotonic(&mut keep); + *candidates = keep; +} + /// 打全了、整个输入正好是一个够常用的词([`EXACT_PROTECT_MIN_FREQ`])时,补全出来的候选都排在这些词后面。 /// /// [`protect_exact_input`] 只认第一个这样的词:它已经排第一时什么都不挪。`fangxiangji` 第一个是「放像机」, /// 补全的「方向键」(jian)就一直压在同样打全了的「芳香剂」前面。补全只能「加」候选,不能抢打全了的词的位置。 /// 用户选过的补全不挪。 fn completions_after_exact_words(candidates: &mut Vec) { - let exact_word = |c: &Candidate| { - c.words.len() == 1 - && c.words[0].known - && c.words[0].freq >= EXACT_PROTECT_MIN_FREQ - && c.features.coverage_score >= 1.0 - && c.features.typo_count == 0.0 - && c.features.prefix_completion == 0.0 - && c.features.full_jianpin == 0.0 - && !c.features.fuzzy - }; + let exact_word = is_exact_frequent_word; let Some(last) = candidates.iter().rposition(exact_word) else { return; }; @@ -5657,6 +5689,43 @@ mod tests { assert_eq!(texts[1], "记得给妈妈", "{texts:?}"); } + #[test] + fn fuzzy_word_goes_after_a_typed_whole_word() { + // penyou:照着打的「喷油」是词库里的词,模糊音兜底的「朋友」排它后面 + let mut fuzzy = ranked("朋友", "pen you", 0.0, 6); + fuzzy.features.fuzzy = true; + fuzzy.score = -5.0; + let mut typed = ranked("喷油", "pen you", 0.0, 6); + typed.score = -9.0; + let mut list = vec![fuzzy.clone(), typed.clone()]; + fuzzy_after_exact_word(&mut list); + let texts: Vec<&str> = list.iter().map(|c| c.text.as_str()).collect(); + assert_eq!(texts, ["喷油", "朋友"]); + assert!(list[0].score >= list[1].score); + + // shengme:照着打只能两个字硬凑,模糊音的「什么」照旧排第一 + typed.words = ["生", "么"] + .iter() + .zip(["sheng", "me"]) + .map(|(t, p)| CandidateWord { + text: t.to_string(), + pinyin: p.into(), + freq: 1000.0, + known: true, + }) + .collect(); + let mut list = vec![fuzzy.clone(), typed.clone()]; + fuzzy_after_exact_word(&mut list); + assert_eq!(list[0].text, "朋友"); + + // 用户选过的模糊音词不挪 + typed = ranked("喷油", "pen you", 0.0, 6); + fuzzy.features.history_use_count = 1.0; + let mut list = vec![fuzzy, typed]; + fuzzy_after_exact_word(&mut list); + assert_eq!(list[0].text, "朋友"); + } + #[test] fn fuzzy_fallback_word_does_not_drop_the_typed_sentence() { // ninke 接着上文打:模糊音兜底加的「宁可」(ning ke)排第一时,照着打的「您 | 可」不能被当成硬凑的整句筛掉 diff --git a/docs/ENGINE-INVARIANTS.md b/docs/ENGINE-INVARIANTS.md index 3b9163d8..651d74e4 100644 --- a/docs/ENGINE-INVARIANTS.md +++ b/docs/ENGINE-INVARIANTS.md @@ -135,7 +135,7 @@ | `typo-only-adds` | **用户的规矩**:把按错键纠错关掉再查一次,关掉时第一页的词(整词、句首词、单字)开着时都还在,关掉时排第一的照着打的读法开着时也还在(是几个词拼的整句时,至少还有一个照着打的读法) | P1、P3 | | `typo-outranks-typed` | 关掉纠错时排第一的照着打的读法,开着时不排在纠错加进来的候选后面(音节更少的例外,同 `typed-first`) | P1 | | `fuzzy-only-adds` | 同 `typo-only-adds`,关的是模糊音兜底 | P1 | -| `fuzzy-outranks-typed` | 同 `typo-outranks-typed`,关的是模糊音兜底。**只报告、不算失败**,见第 6 节「等决定」 | P1 | +| `fuzzy-outranks-word` | 照着打的读法本身是词库里一个够常用的词(词频 ≥ 1000)时,模糊音兜底的词不排在它前面(`penyou` 出「喷油」「朋友」)。照着打只能几个字硬凑时(`shengme`)模糊音的词可以排第一,见第 6 节「模糊音兜底」 | P6 | | `jianpin-only-adds`、`jianpin-outranks-typed` | 同上,关的是简拼;只查打全了的输入(`zg`、`wm` 本来就没有照着打的全拼读法,简拼就是照着打的) | P1 | 纠错、模糊音兜底、简拼三条是对比着查的:开着时前两页里有它加进来的候选,就把它关掉(`set_typo_correction`、 @@ -249,14 +249,10 @@ scripts/invariants.sh /usr/share/wowtype --inv-limit 0 # | `no-duplicates` | 0 | 0 | | `completion-outranks-word` | 0 | 0 | | `typo-only-adds` / `typo-outranks-typed` | 0 / 0 | 4 / 0 | -| `fuzzy-only-adds` | 0 | 0 | +| `fuzzy-only-adds` / `fuzzy-outranks-word` | 0 / 0 | 0 / 0 | | `jianpin-only-adds` / `jianpin-outranks-typed` | 0 / 0 | 0 / 0 | -| `fuzzy-outranks-typed`(只报告) | 57 | 144 | -带模型那一列是在最后一处修改(`compose_candidates` 不把纠错出来的开头词放到第二位)之前跑的,那时还有一条 -`typo-outranks-typed`:接着「我本地」打 `jidegeimamadadianhu`,第一个是纠错的「借给妈妈打电话」(音节更少,按例外可以第一), -它的开头「借给…」也是纠错的,被放到第二位,压在照着打的「记得给麻麻打电话」前面。修了以后用 `wowtype-show` 核对过 -(照着打的整句排第二),排序评测不变;带模型的整套检查没有在最后这次修改之后重跑。 +两列都是在全部修改(包括下面「模糊音兜底」那一处)之后重跑的。 ### 还没修的 @@ -266,13 +262,18 @@ scripts/invariants.sh /usr/share/wowtype --inv-limit 0 # 「灵机」是 ling ji | a s 这种换切法才对得上的词,跟着第一名的切法时有时无。不带模型时不出现,所以 CI 不拦。 建议的修法就是第 7 节第 4 条:句首词不按第一名的切法筛,从输入开头起、落在任一种照着打的切法的音节边界上的词都留。 -### 等决定:模糊音兜底要不要也「只加不抢第一」 +### 模糊音兜底:照着打是现成的词时让位(用户定的) -模糊音关着时,第一名偏弱就由 `fuzzy_fallback` 补一两个模糊音的词,分数高出一截就排第一:`zhouba` 第一是「走吧」, -照着打的「周报」第二;`lindai` 第一是「领带」,照着打的「林带」第二。按用户的规矩,这也是「替代」。但回归集 -(`tools/eval/regress.tsv` 第 82、83 条)明确要求 `shengme` → 什么、`penyou` → 朋友 排第一,改成只加这两条就失败。 -所以现在:模糊音兜底**只加不删**是硬规则(`fuzzy-only-adds`,已经清零),**排到照着打的前面**只报告(`fuzzy-outranks-typed`, -不带模型约 57 条)。要改的话:`typos_after_typed` 的 `yields` 加上 `c.features.fuzzy`(试过,其余各组不变),同时改回归集那两条。 +模糊音关着时,第一名偏弱就由 `fuzzy_fallback` 补一两个模糊音的词,分数高出一截就排第一。这有两种情况,用户定的规矩是分开对待: + +- **照着打的读法本身是词库里一个够常用的词**(词频 ≥ `EXACT_PROTECT_MIN_FREQ`):它排第一,模糊音的词紧跟在后面。 + `penyou`:喷油、朋友;`zuijing`:最精、最近;`lindai`:林带、领带;`tiexiang`:铁箱、贴现。照着打的没打错,模糊音的词只是「加」。 +- **照着打只能几个字硬凑**(词库里没有这个读音的词,或者只有补全才凑得出词):模糊音的词照旧排第一。 + `shengme`:什么(没有 sheng me 这个词,「声门」是补全);`zhouba`:走吧(「周报」是 zhou bao,补全出来的);`heishe`:黑色。 + +实现是 `fuzzy_after_exact_word`(`lib.rs`,和 `completions_after_exact_words` 用同一个「打全了的常用词」的判断);用户选过的模糊音词不挪。 +检查是硬规则 `fuzzy-outranks-word`。以前只报告的 `fuzzy-outranks-typed`(57 条)去掉了:里面除了上面第一种的几条,都是第二种,按规矩是对的。 +回归集相应改了:`penyou` 期望「喷油」第一、「朋友」前两名,加了 `zuijing`;`shengme` → 什么 不变。排序评测其余各组不变(`mid` 多对一条)。 ### 其它几种机制 diff --git a/docs/ENGINE.md b/docs/ENGINE.md index 81fd2606..50584c3b 100644 --- a/docs/ENGINE.md +++ b/docs/ENGINE.md @@ -279,7 +279,8 @@ d 在 c 上面,「的」「得」的词频、神经语言模型给的分比固 - 第一名是纠错出来的时,句首词也按照着打的读法的音节边界对齐(`prefix_on_syllable_boundaries`): `yusezhi` 的第一名「越职」(yue zhi)一个边界都对不上字母,以前句首词和 yu 的单字全被筛掉,整个候选框只有 6 个。 -- 模糊音关着时兜底补进来的词(`fuzzy_fallback`:`penyou` → 朋友)带标记 `Feature::fuzzy`(不是排序特征)。 +- 模糊音关着时兜底补进来的词(`fuzzy_fallback`:`shengme` → 什么)带标记 `Feature::fuzzy`(不是排序特征)。照着打的读法本身是词库里的常用词时 + 它排在那个词后面(`fuzzy_after_exact_word`:`penyou` 出「喷油」「朋友」),只能硬凑时才排第一。 它排第一时不当「打全了的整词」,`compose_candidates` 不拿它去筛硬凑的整句:接着上文打 `ninke` 时补进来的「宁可」 曾经把照着打的「您可」整个筛掉。 diff --git a/tools/eval/baseline.tsv b/tools/eval/baseline.tsv index 5fe82e31..8f60d074 100644 --- a/tools/eval/baseline.tsv +++ b/tools/eval/baseline.tsv @@ -2,9 +2,9 @@ # 改了排序、要更新它:scripts/eval.sh <数据目录> --update-baseline,提交说明里贴前后对比(见 tools/eval/README.md)。 # 数据 2026.11.11.7 927e1cf1d3eeb9bf4be85e3f684dba4dd485b6f6 # 组 用例 top1 top3 top9 通过 -regress 69 63 65 69 69 +regress 72 64 68 72 72 common 1000 967 998 1000 967 -mid 1000 941 997 1000 941 +mid 1000 942 997 1000 942 rare 1000 888 986 1000 888 jianpin 1000 630 810 914 630 trunc 1000 922 984 994 922 diff --git a/tools/eval/regress.tsv b/tools/eval/regress.tsv index 7e3d138b..8d8d80a0 100644 --- a/tools/eval/regress.tsv +++ b/tools/eval/regress.tsv @@ -80,7 +80,11 @@ jitnian 今天 # 模糊音关着时不出硬拼的怪词(计划 R2-c) shengme 什么 -penyou 朋友 +# 照着打本身是词库里的常用词(pen you 喷油)时它排第一,模糊音兜底的词排第二;只能硬凑时(上面的 shengme)模糊音的词排第一 +penyou 喷油 +penyou 朋友 top=2 +zuijing 最精 +zuijing 最近 top=2 # 词频修正和热词(计划 R3) laoshi 老师