Skip to main content

qualia_core_db/inference/qwen/
ple_ngram.rs

1#[cfg(test)]
2use crate::gguf_sharder::Qwen4ExpPleConfig;
3#[cfg(test)]
4use qualia_inference_kernel::qwen::ple::PleNgramConfigSource;
5// Compatibility with the canonical inference PLE selector.
6pub use etalon_inference::qwen::ple_ngram::*;
7#[cfg(test)]
8mod tests {
9    use super::*;
10
11    fn config() -> Qwen4ExpPleConfig {
12        let mut config = Qwen4ExpPleConfig {
13            ngram_size: 3,
14            heads_per_ngram: 2,
15            eos_token_id: 99,
16            embedding_row_width: 8,
17            layer_count: 1,
18            layers: [1; 8],
19            multiplier_count: 3,
20            layer_multipliers: [3, 5, 7, 0, 0, 0, 0, 0],
21            head_count: 4,
22            head_offsets: [0; 32],
23            head_vocab_sizes: [0; 32],
24        };
25        config.head_offsets[..4].copy_from_slice(&[0, 11, 24, 41]);
26        config.head_vocab_sizes[..4].copy_from_slice(&[11, 13, 17, 19]);
27        config
28    }
29
30    #[test]
31    fn rows_are_stable_and_stay_in_their_head_ranges() {
32        let cfg = config();
33        let mut history = PleTokenHistory::default();
34        let mut rows = [0u64; 4];
35        assert_eq!(history.select_and_push(&cfg, 7, 60, &mut rows).unwrap(), 4);
36        assert!(rows[0] < 11 && (11..24).contains(&rows[1]));
37        assert!((24..41).contains(&rows[2]) && (41..60).contains(&rows[3]));
38        let first = rows;
39        let mut fresh = PleTokenHistory::default();
40        assert_eq!(fresh.select_and_push(&cfg, 7, 60, &mut rows).unwrap(), 4);
41        assert_eq!(rows, first);
42    }
43
44    #[test]
45    fn eos_resets_history_before_the_following_token() {
46        let cfg = config();
47        let mut history = PleTokenHistory::default();
48        let mut rows = [0u64; 4];
49        history.select_and_push(&cfg, 7, 60, &mut rows).unwrap();
50        history
51            .select_and_push(&cfg, cfg.eos_token_id, 60, &mut rows)
52            .unwrap();
53        let after_eos = {
54            history.select_and_push(&cfg, 8, 60, &mut rows).unwrap();
55            rows
56        };
57        let mut fresh = PleTokenHistory::default();
58        fresh.select_and_push(&cfg, 8, 60, &mut rows).unwrap();
59        assert_eq!(after_eos, rows);
60    }
61
62    #[test]
63    fn dedup_is_in_place() {
64        let mut rows = [9, 2, 9, 7, 2];
65        assert_eq!(sort_dedup_rows(&mut rows), 3);
66        assert_eq!(&rows[..3], &[2, 7, 9]);
67    }
68    #[test]
69    fn host_projection_borrows_exact_arrays_and_preserves_completeness() {
70        let mut cfg = config();
71        cfg.layer_count = 0;
72        cfg.layers = [u32::MAX; 8];
73        let view = cfg.ple_ngram_config();
74        assert!(core::ptr::eq(
75            view.layer_multipliers,
76            &cfg.layer_multipliers
77        ));
78        assert!(core::ptr::eq(view.head_offsets, &cfg.head_offsets));
79        assert!(core::ptr::eq(view.head_vocab_sizes, &cfg.head_vocab_sizes));
80        assert_eq!(view.ngram_size, cfg.ngram_size);
81        assert_eq!(view.heads_per_ngram, cfg.heads_per_ngram);
82        assert_eq!(view.eos_token_id, cfg.eos_token_id);
83        assert_eq!(view.embedding_row_width, cfg.embedding_row_width);
84        assert_eq!(view.multiplier_count, cfg.multiplier_count);
85        assert_eq!(view.head_count, cfg.head_count);
86        assert_eq!(view.is_complete(), cfg.is_complete());
87        for ngram in [0, 1, 2, 8, 9, u32::MAX] {
88            cfg.ngram_size = ngram;
89            assert_eq!(cfg.ple_ngram_config().is_complete(), cfg.is_complete());
90        }
91        cfg = config();
92        cfg.embedding_row_width = 0;
93        assert!(!cfg.ple_ngram_config().is_complete());
94    }
95
96    #[test]
97    fn concrete_legacy_calls_share_canonical_history_and_error_types() {
98        use qualia_inference_kernel::qwen::ple as canonical;
99        type Select = fn(
100            &Qwen4ExpPleConfig,
101            u32,
102            &PleTokenHistory,
103            u64,
104            &mut [u64],
105        ) -> Result<usize, PleNgramError>;
106        type Advance = fn(
107            &mut PleTokenHistory,
108            &Qwen4ExpPleConfig,
109            u32,
110            u64,
111            &mut [u64],
112        ) -> Result<usize, PleNgramError>;
113        let select: Select = select_rows;
114        let advance: Advance = PleTokenHistory::select_and_push;
115        let cfg = config();
116        let mut history: canonical::PleTokenHistory = PleTokenHistory::default();
117        let mut rows = [u64::MAX; 6];
118        let mut expected = rows;
119        assert_eq!(
120            select(&cfg, 7, &history, 60, &mut rows),
121            canonical::select_rows(&cfg, 7, &history, 60, &mut expected)
122        );
123        assert_eq!(rows, expected);
124        assert_eq!(advance(&mut history, &cfg, 7, 60, &mut rows), Ok(4));
125        let error: canonical::PleNgramError = select(&cfg, 8, &history, 60, &mut []).unwrap_err();
126        assert_eq!(error, PleNgramError::OutputTooSmall);
127        assert_eq!(MAX_PLE_NGRAM, canonical::MAX_PLE_NGRAM);
128        assert_eq!(MAX_PLE_HEADS, canonical::MAX_PLE_HEADS);
129    }
130}