1語候補の未知bigramペナルティ緩和をリランキングに追加

辞書登録された複合語（意思決定、南極観測船等）を1語で変換する場合、
BOS/EOS との bigram が必ず未知になりデフォルトエッジコストが2回加算
されるため、分割候補に対して構造的に不利だった。

リランキング段階で token_count==1 && unknown_bigram_count==2 の候補に
対して unknown_bigram_weight を single_token_unk_discount (デフォルト0.5)
で割り引くことで改善。

評価結果: 再現率 93.27% → 93.33% (+0.06pt, Bad 3930→3910)
改善: 犬死、新潮新書、南極観測船、派生品、等閑視 等が1位に昇格
退行: いしのそつう（意志の疎通→石野疎通）1件

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: tokuhirom

Cargo.lock

@@ -245,6 +245,9 @@ struct CheckArgs {
     /// リランキング: skip-bigram コストの重み
     #[arg(long, default_value_t = 0.2)]
     skip_bigram_weight: f32,
+    /// リランキング: 1語候補の未知 bigram 割引率
+    #[arg(long, default_value_t = 0.5)]
+    single_token_unk_discount: f32,
 }
 
 /// 変換精度を評価する
@@ -273,6 +276,9 @@ struct EvaluateArgs {
     /// リランキング: skip-bigram コストの重み
     #[arg(long, default_value_t = 0.2)]
     skip_bigram_weight: f32,
+    /// リランキング: 1語候補の未知 bigram 割引率
+    #[arg(long, default_value_t = 0.5)]
+    single_token_unk_discount: f32,
 }
 
 /// インクリメンタル変換のベンチマーク
@@ -416,6 +422,7 @@ fn main() -> anyhow::Result<()> {
                 length_weight: opt.length_weight,
                 unknown_bigram_weight: opt.unknown_bigram_weight,
                 skip_bigram_weight: opt.skip_bigram_weight,
+                single_token_unk_discount: opt.single_token_unk_discount,
             },
         }),
         Commands::Evaluate(opt) => evaluate(
@@ -429,6 +436,7 @@ fn main() -> anyhow::Result<()> {
                 length_weight: opt.length_weight,
                 unknown_bigram_weight: opt.unknown_bigram_weight,
                 skip_bigram_weight: opt.skip_bigram_weight,
+                single_token_unk_discount: opt.single_token_unk_discount,
             },
         ),
         Commands::Bench(opt) => bench(BenchOptions {

akaza-data/src/main.rs

@@ -12,3 +12,4 @@ datetime	commit	branch	corpus_stats	good	top5	bad	recall
 2026-02-24 12:23	23307d65	main	v2026.0216.0	6776	343	3946	93.26708
 2026-02-24 16:30	7c93f16d	main	v2026.0216.0	6780	343	3942	93.27101
 2026-02-24 17:05	7c93f16d	fix/suki-bos-overfit	v2026.0216.0	6784	343	3938	93.29374
+2026-02-27 01:27	6ce304fd	fix/ishi-bos-bigram	v2026.0216.0	6805	350	3910	93.33365

default-model/evaluate-history.tsv

@@ -0,0 +1,130 @@
+# 1語候補の未知 bigram ペナルティ緩和
+
+## 背景
+
+辞書に登録された複合語（例: 「意思決定」「サイドバー」）を1語として変換する場合、
+BOS/EOS との bigram が必ず未知（unk_bi）になり、デフォルトエッジコスト（約14.3）が
+2回加算される。このため、分割された候補（例: 「医師/決定」）に対して構造的に不利になる。
+
+### 具体例: 「いしけってい」
+
+```
+[1] 医師/決定   (viterbi: 19.1, unk_bi: 0.0,  tokens: 2)
+[2] 意思決定     (viterbi: 28.4, unk_bi: 28.7, tokens: 1)
+```
+
+「意思決定」のコスト内訳:
+```
+BOS →[default: 14.3]→ 意思決定 →[default: 14.3]→ EOS
+Viterbi = 14.3 + (-0.25) + 14.3 = 28.35
+          ^^^^                ^^^^
+          BOS との unk_bi     EOS との unk_bi
+```
+
+「医師/決定」は語同士の既知 bigram でエッジコストが下がるため、
+unigram コストが高くても合計で勝ってしまう。
+
+## 問題の本質
+
+- BOS/EOS ノードは `word_id_and_score = None` のため、どの語との bigram も必ずデフォルトコストになる
+- 1語候補は BOS と EOS の両方に接するので、unk_bi ペナルティを必ず2回受ける
+- 2語以上の候補は語同士の既知 bigram でコストを下げられるが、1語候補にはその機会がない
+- コーパスで bigram を学習しても BOS/EOS との組み合わせは学習されにくい
+
+## 提案: リランキングでの1語候補 unk_bi 割引
+
+### 方針
+
+Viterbi 本体には触れず、リランキング段階で1語候補の unk_bi ペナルティを割り引く。
+
+### 判定条件
+
+- `token_count == 1`（BOS/EOS を除くトークンが1つ）
+- `unknown_bigram_count == 2`（BOS→語、語→EOS の2回が未知）
+
+この条件を満たす候補は「辞書に登録された複合語を1語で変換しようとしている」ケースに限定される。
+
+### 実装案
+
+`libakaza/src/graph/reranking.rs` を変更:
+
+```rust
+pub struct ReRankingWeights {
+    pub bigram_weight: f32,
+    pub length_weight: f32,
+    pub unknown_bigram_weight: f32,
+    pub skip_bigram_weight: f32,
+    pub single_token_unk_discount: f32,  // 新規: デフォルト 0.5
+}
+
+impl ReRankingWeights {
+    pub fn rerank(&self, paths: &mut [KBestPath]) {
+        for path in paths.iter_mut() {
+            let unk_weight = if path.token_count == 1 && path.unknown_bigram_count == 2 {
+                self.unknown_bigram_weight * self.single_token_unk_discount
+            } else {
+                self.unknown_bigram_weight
+            };
+
+            path.rerank_cost = path.unigram_cost
+                + self.bigram_weight * path.bigram_cost
+                + unk_weight * path.unknown_bigram_cost
+                + self.length_weight * path.token_count as f32
+                + self.skip_bigram_weight * path.skip_bigram_cost;
+        }
+        paths.sort_by(|a, b| a.rerank_cost.total_cmp(&b.rerank_cost));
+    }
+}
+```
+
+### 期待される効果
+
+discount=0.5 の場合の「いしけってい」:
+
+```
+[Before]
+  医師/決定:  rerank = 8.33 + 18.35 + 1.0*0.0 + 2.0*2 = 30.68
+  意思決定:   rerank = -0.25 + 1.0*0.0 + 1.0*28.67 + 2.0*1 = 30.42
+
+[After] discount=0.5
+  医師/決定:  rerank = 30.68 (変化なし)
+  意思決定:   rerank = -0.25 + 0.0 + 0.5*28.67 + 2.0 = 16.08
+  → 意思決定が1位になる
+```
+
+※ 上記は概算。実際の値はモデルに依存。
+
+### 影響範囲
+
+- **対象**: 1語候補 かつ BOS/EOS bigram が両方未知のケースのみ
+- **非対象**: 2語以上の候補、既知 bigram を持つ1語候補
+- Viterbi の候補生成には影響しない（k-best に含まれている候補の順位のみ変更）
+
+## 退行リスク
+
+### リスク1: 本来分割すべき入力で1語候補が不当に勝つ
+
+例えば「さいど」(再度) が辞書に1語として登録されている場合、
+「再/度」と分割される候補に対して不当に有利になる可能性がある。
+
+**対策**: `token_count == 1 && unknown_bigram_count == 2` の条件により、
+辞書登録された複合語に限定される。一般的な単語は unigram に登録されており
+BOS/EOS との bigram も学習済みのケースが多い。
+
+### リスク2: discount の値が不適切
+
+discount が小さすぎると1語候補が常に勝ち、大きすぎると効果がない。
+
+**対策**: evaluate コーパスで grid search して最適値を探索。
+デフォルト値（0.5）は保守的な出発点。
+
+## 検証手順
+
+1. 実装後、デフォルト値で `cargo test --all` が pass することを確認
+2. `akaza-data evaluate` で退行がないことを確認
+3. 以下の代表的なケースで手動確認:
+   - `いしけってい` → 意思決定（1位になることを期待）
+   - `さいどばー` → サイドバー（1位になることを期待）
+   - `いし` → 医師 or 石（退行しないこと）
+   - 通常の2語以上の変換が退行しないこと
+4. discount を 0.3〜0.7 で変えて evaluate の精度変化を観察

docs/src/internals/notes/single-token-unk-bigram-discount.md

@@ -15,6 +15,13 @@ pub struct ReRankingWeights {
     /// skip-bigram コストの重み（デフォルト 0.0 = 無効）
     #[serde(default)]
     pub skip_bigram_weight: f32,
+    /// 1語候補（BOS/EOS bigram が両方未知）の unk_bi 割引率（デフォルト 0.5）
+    #[serde(default = "default_single_token_unk_discount")]
+    pub single_token_unk_discount: f32,
+}
+
+fn default_single_token_unk_discount() -> f32 {
+    0.5
 }
 
 impl Default for ReRankingWeights {
@@ -24,6 +31,7 @@ impl Default for ReRankingWeights {
             length_weight: 2.0,
             unknown_bigram_weight: 1.0,
             skip_bigram_weight: 0.2,
+            single_token_unk_discount: 0.5,
         }
     }
 }
@@ -32,9 +40,15 @@ impl ReRankingWeights {
     /// パスの rerank_cost を再計算し、スコア昇順にソートする。
     pub fn rerank(&self, paths: &mut [KBestPath]) {
         for path in paths.iter_mut() {
+            let unk_weight = if path.token_count == 1 && path.unknown_bigram_count == 2 {
+                self.unknown_bigram_weight * self.single_token_unk_discount
+            } else {
+                self.unknown_bigram_weight
+            };
+
             path.rerank_cost = path.unigram_cost
                 + self.bigram_weight * path.bigram_cost
-                + self.unknown_bigram_weight * path.unknown_bigram_cost
+                + unk_weight * path.unknown_bigram_cost
                 + self.length_weight * path.token_count as f32
                 + self.skip_bigram_weight * path.skip_bigram_cost;
         }
@@ -105,6 +119,7 @@ mod tests {
             length_weight: 0.0,
             unknown_bigram_weight: 0.1,
             skip_bigram_weight: 0.0,
+            single_token_unk_discount: 1.0, // no discount
         };
 
         // path A: unigram=3, bigram=2, unknown=10 → 3 + 0.5*2 + 0.1*10 = 5.0
@@ -126,6 +141,7 @@ mod tests {
             length_weight: 2.0,
             unknown_bigram_weight: 1.0,
             skip_bigram_weight: 0.0,
+            single_token_unk_discount: 1.0,
         };
 
         // path A: unigram=3, bigram=2, unknown=1, tokens=5 → 3+2+1+2*5 = 16
@@ -140,6 +156,64 @@ mod tests {
         assert!((paths[1].rerank_cost - 16.0).abs() < f32::EPSILON);
     }
 
+    #[test]
+    fn test_single_token_unk_discount_applied() {
+        let weights = ReRankingWeights {
+            bigram_weight: 1.0,
+            length_weight: 2.0,
+            unknown_bigram_weight: 1.0,
+            skip_bigram_weight: 0.0,
+            single_token_unk_discount: 0.5,
+        };
+
+        // 1語候補: token_count=1, unknown_bigram_count=2 → discount 適用
+        // rerank = 1.0 + 1.0*0.0 + (1.0*0.5)*28.0 + 2.0*1 = 17.0
+        let mut paths = vec![make_path(29.0, 1.0, 0.0, 28.0, 2, 1)];
+        weights.rerank(&mut paths);
+        assert!(
+            (paths[0].rerank_cost - 17.0).abs() < f32::EPSILON,
+            "got {}",
+            paths[0].rerank_cost
+        );
+    }
+
+    #[test]
+    fn test_single_token_unk_discount_not_applied_to_multi_token() {
+        let weights = ReRankingWeights {
+            bigram_weight: 1.0,
+            length_weight: 2.0,
+            unknown_bigram_weight: 1.0,
+            skip_bigram_weight: 0.0,
+            single_token_unk_discount: 0.5,
+        };
+
+        // 2語候補: token_count=2 → discount 不適用
+        // rerank = 3.0 + 1.0*2.0 + 1.0*5.0 + 2.0*2 = 14.0
+        let mut paths = vec![make_path(10.0, 3.0, 2.0, 5.0, 1, 2)];
+        weights.rerank(&mut paths);
+        assert!(
+            (paths[0].rerank_cost - 14.0).abs() < f32::EPSILON,
+            "got {}",
+            paths[0].rerank_cost
+        );
+    }
+
+    #[test]
+    fn test_single_token_discount_changes_ranking() {
+        let weights = ReRankingWeights::default(); // discount=0.5
+
+        // 1語候補 (複合語): unigram=-0.25, bigram=0, unk_bi=28.67, tokens=1
+        let single = make_path(28.4, -0.25, 0.0, 28.67, 2, 1);
+        // 2語候補: unigram=8.33, bigram=10.0, unk_bi=0.0, tokens=2
+        let multi = make_path(19.1, 8.33, 10.0, 0.0, 0, 2);
+
+        let mut paths = vec![multi, single];
+        weights.rerank(&mut paths);
+
+        // 1語候補が1位になるはず
+        assert_eq!(paths[0].token_count, 1);
+    }
+
     #[test]
     fn test_is_default() {
         assert!(ReRankingWeights::default().is_default());
@@ -148,6 +222,7 @@ mod tests {
             length_weight: 0.0,
             unknown_bigram_weight: 1.0,
             skip_bigram_weight: 0.0,
+            single_token_unk_discount: 0.5,
         }
         .is_default());
     }