Skip to main content

qualia_core_db/inference/qwen/
gated_deltanet.rs

1//! Compatibility exports for the canonical Etalon numerical implementation.
2pub use qualia_inference_kernel::recurrent::gated_deltanet::*;
3
4#[cfg(test)]
5mod tests {
6    use super::*;
7
8    #[test]
9    fn test_step_causal_conv1d() {
10        // 1 channel, kernel size 4
11        let mut state = [0.0f32; 3];
12        let weights = [0.1, 0.2, 0.3, 0.4];
13        let mut out = [0.0f32; 1];
14
15        // Step 1: input = 10.0
16        step_causal_conv1d(&mut state, &weights, &[10.0], &mut out).unwrap();
17        // out = 0.4 * 10 = 4.0
18        assert_eq!(out[0], 4.0);
19        assert_eq!(state, [0.0, 0.0, 10.0]);
20
21        // Step 2: input = 20.0
22        step_causal_conv1d(&mut state, &weights, &[20.0], &mut out).unwrap();
23        // out = 0.3 * 10.0 + 0.4 * 20.0 = 3.0 + 8.0 = 11.0
24        assert_eq!(out[0], 11.0);
25        assert_eq!(state, [0.0, 10.0, 20.0]);
26    }
27
28    #[test]
29    fn test_step_gated_deltanet() {
30        // d_state = 2, d_head = 2
31        let mut state = [0.0f32; 4];
32        let q = [1.0, 0.0];
33        let k = [1.0, 0.0];
34        let v = [5.0, 10.0];
35        let alpha = [1.0];
36        let beta = [1.0];
37        let mut out = [0.0f32; 2];
38
39        // Step 1: empty state, v_pred = 0, err = v
40        // S[0, 0] becomes 0 + 1 * 5 * 1 = 5
41        // S[0, 1] becomes 0 + 1 * 10 * 1 = 10
42        // out = S * q: out[0] = 5 * 1 = 5, out[1] = 10 * 1 = 10
43        step_gated_deltanet(&mut state, &q, &k, &v, &alpha, &beta, 2, 2, &mut out).unwrap();
44
45        assert_eq!(out[0], 5.0);
46        assert_eq!(out[1], 10.0);
47    }
48
49    #[test]
50    fn test_multistep_gated_deltanet_token_evolution_matches_oracle() {
51        // d_state = 3, d_head = 2
52        let d_state = 3;
53        let d_head = 2;
54        let mut state = vec![0.0f32; d_state * d_head];
55
56        // Reference state matrix for oracle computation: S[s, h]
57        let mut oracle_state = vec![0.0f32; d_state * d_head];
58
59        // 4 tokens of query, key, value, alpha, beta
60        let tokens_q = [
61            [0.5, 0.2, 0.1],
62            [0.1, 0.8, 0.3],
63            [0.4, 0.4, 0.2],
64            [0.9, 0.1, 0.0],
65        ];
66        let tokens_k = [
67            [0.6, 0.1, 0.3],
68            [0.2, 0.7, 0.1],
69            [0.3, 0.3, 0.4],
70            [0.8, 0.2, 0.0],
71        ];
72        let tokens_v = [[2.0, 4.0], [1.5, 3.0], [0.5, 2.5], [3.0, 1.0]];
73        let alphas = [0.9f32, 0.85, 0.95, 0.8];
74        let betas = [0.5f32, 0.6, 0.4, 0.7];
75
76        let mut out = [0.0f32; 2];
77
78        for t in 0..4 {
79            let q = &tokens_q[t];
80            let k = &tokens_k[t];
81            let v = &tokens_v[t];
82            let alpha = [alphas[t]];
83            let beta = [betas[t]];
84
85            // 1. Run actual step_gated_deltanet
86            step_gated_deltanet(
87                &mut state, q, k, v, &alpha, &beta, d_state, d_head, &mut out,
88            )
89            .unwrap();
90
91            // 2. Run explicit mathematical oracle:
92            // a) v_pred[h] = sum_s S_{t-1}[s, h] * k[s]
93            let mut v_pred = vec![0.0f32; d_head];
94            for h in 0..d_head {
95                for s in 0..d_state {
96                    v_pred[h] += oracle_state[s * d_head + h] * k[s];
97                }
98            }
99
100            // b) err[h] = v[h] - v_pred[h]
101            let mut err = vec![0.0f32; d_head];
102            for h in 0..d_head {
103                err[h] = v[h] - v_pred[h];
104            }
105
106            // c) S_t[s, h] = S_{t-1}[s, h] * alpha + beta * err[h] * k[s]
107            for s in 0..d_state {
108                for h in 0..d_head {
109                    let idx = s * d_head + h;
110                    oracle_state[idx] = oracle_state[idx] * alpha[0] + beta[0] * err[h] * k[s];
111                }
112            }
113
114            // d) y[h] = sum_s S_t[s, h] * q[s]
115            let mut expected_out = vec![0.0f32; d_head];
116            for h in 0..d_head {
117                for s in 0..d_state {
118                    expected_out[h] += oracle_state[s * d_head + h] * q[s];
119                }
120            }
121
122            // Verify state exact match
123            for i in 0..(d_state * d_head) {
124                assert!(
125                    (state[i] - oracle_state[i]).abs() < 1e-6,
126                    "Step {t} state mismatch at {i}: actual={}, expected={}",
127                    state[i],
128                    oracle_state[i]
129                );
130            }
131
132            // Verify output exact match
133            for h in 0..d_head {
134                assert!(
135                    (out[h] - expected_out[h]).abs() < 1e-6,
136                    "Step {t} output mismatch at {h}: actual={}, expected={}",
137                    out[h],
138                    expected_out[h]
139                );
140            }
141        }
142    }
143
144    #[test]
145    fn test_multichannel_causal_conv1d_evolution_matches_oracle() {
146        let channels = 2;
147        let mut state = vec![0.0f32; (CAUSAL_CONV_KERNEL - 1) * channels];
148        let weights = [
149            0.1, 0.2, 0.3, 0.4, // channel 0
150            0.5, 0.6, 0.7, 0.8, // channel 1
151        ];
152
153        let inputs = [[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0], [9.0, 10.0]];
154
155        // Track full history for oracle verification: history[c] = Vec<f32>
156        let mut full_history = vec![vec![0.0f32; 3]; channels];
157        let mut out = [0.0f32; 2];
158
159        for (t, inp) in inputs.iter().enumerate() {
160            step_causal_conv1d(&mut state, &weights, inp, &mut out).unwrap();
161
162            for c in 0..channels {
163                full_history[c].push(inp[c]);
164                let len = full_history[c].len();
165                // 4-tap FIR: w0*h0 + w1*h1 + w2*h2 + w3*h3
166                let w = &weights[c * 4..(c + 1) * 4];
167                let h0 = full_history[c][len - 4];
168                let h1 = full_history[c][len - 3];
169                let h2 = full_history[c][len - 2];
170                let h3 = full_history[c][len - 1];
171                let expected = w[0] * h0 + w[1] * h1 + w[2] * h2 + w[3] * h3;
172
173                assert!(
174                    (out[c] - expected).abs() < 1e-6,
175                    "Step {t} ch {c} mismatch: actual={}, expected={}",
176                    out[c],
177                    expected
178                );
179            }
180        }
181    }
182}