qualia_core_db/inference/qwen/
gated_deltanet.rs1pub 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 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_causal_conv1d(&mut state, &weights, &[10.0], &mut out).unwrap();
17 assert_eq!(out[0], 4.0);
19 assert_eq!(state, [0.0, 0.0, 10.0]);
20
21 step_causal_conv1d(&mut state, &weights, &[20.0], &mut out).unwrap();
23 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 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_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 let d_state = 3;
53 let d_head = 2;
54 let mut state = vec![0.0f32; d_state * d_head];
55
56 let mut oracle_state = vec![0.0f32; d_state * d_head];
58
59 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 step_gated_deltanet(
87 &mut state, q, k, v, &alpha, &beta, d_state, d_head, &mut out,
88 )
89 .unwrap();
90
91 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 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 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 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 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 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, 0.5, 0.6, 0.7, 0.8, ];
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 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 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}