hyprstream_inference/runtime/
generation_metrics.rs1use serde::{Deserialize, Serialize};
13use std::collections::VecDeque;
14
15const NGRAM_BUFFER_SIZE: usize = 32;
17
18const NGRAM_SIZE: usize = 3;
20
21const BLOOM_K: usize = 3;
23
24const BLOOM_BITS: usize = 2048;
26
27#[derive(Debug, Clone)]
42pub struct GenerationMetricsAccumulator {
43 log_prob_mean: f64,
45 log_prob_m2: f64,
46
47 entropy_mean: f64,
49 entropy_m2: f64,
50
51 count: u64,
53
54 recent_tokens: VecDeque<u32>,
56
57 ngram_repeats: u32,
59
60 bloom_filter: [u64; 32],
63
64 ngram_insert_count: u32,
66}
67
68impl Default for GenerationMetricsAccumulator {
69 fn default() -> Self {
70 Self::new()
71 }
72}
73
74impl GenerationMetricsAccumulator {
75 pub fn new() -> Self {
77 Self {
78 log_prob_mean: 0.0,
79 log_prob_m2: 0.0,
80 entropy_mean: 0.0,
81 entropy_m2: 0.0,
82 count: 0,
83 recent_tokens: VecDeque::with_capacity(NGRAM_BUFFER_SIZE),
84 ngram_repeats: 0,
85 bloom_filter: [0u64; 32],
86 ngram_insert_count: 0,
87 }
88 }
89
90 pub fn add_token(&mut self, log_prob: f32, entropy: f32, token_id: u32) {
100 self.count += 1;
101 let n = self.count as f64;
102
103 let log_prob_f64 = log_prob as f64;
105 let delta_lp = log_prob_f64 - self.log_prob_mean;
106 self.log_prob_mean += delta_lp / n;
107 let delta2_lp = log_prob_f64 - self.log_prob_mean;
108 self.log_prob_m2 += delta_lp * delta2_lp;
109
110 let entropy_f64 = entropy as f64;
112 let delta_e = entropy_f64 - self.entropy_mean;
113 self.entropy_mean += delta_e / n;
114 let delta2_e = entropy_f64 - self.entropy_mean;
115 self.entropy_m2 += delta_e * delta2_e;
116
117 self.recent_tokens.push_back(token_id);
119 if self.recent_tokens.len() > NGRAM_BUFFER_SIZE {
120 self.recent_tokens.pop_front();
121 }
122
123 if self.recent_tokens.len() >= NGRAM_SIZE {
125 let ngram_hash = self.compute_current_ngram_hash();
126
127 if self.bloom_contains(ngram_hash) {
129 self.ngram_repeats += 1;
131 } else {
132 self.bloom_insert(ngram_hash);
134 self.ngram_insert_count += 1;
135 }
136 }
137 }
138
139 fn bloom_insert(&mut self, hash: u64) {
143 for i in 0..BLOOM_K {
144 let bit_index = self.bloom_hash(hash, i);
145 let word_index = bit_index / 64;
146 let bit_offset = bit_index % 64;
147 self.bloom_filter[word_index] |= 1 << bit_offset;
148 }
149 }
150
151 fn bloom_contains(&self, hash: u64) -> bool {
156 for i in 0..BLOOM_K {
157 let bit_index = self.bloom_hash(hash, i);
158 let word_index = bit_index / 64;
159 let bit_offset = bit_index % 64;
160 if (self.bloom_filter[word_index] & (1 << bit_offset)) == 0 {
161 return false;
162 }
163 }
164 true
165 }
166
167 fn bloom_hash(&self, hash: u64, i: usize) -> usize {
172 let h1 = (hash & 0xFFFFFFFF) as usize;
174 let h2 = ((hash >> 32) | 1) as usize; (h1.wrapping_add(i.wrapping_mul(h2))) % BLOOM_BITS
178 }
179
180 fn compute_current_ngram_hash(&self) -> u64 {
182 let len = self.recent_tokens.len();
183 if len < NGRAM_SIZE {
184 return 0;
185 }
186
187 let mut hash: u64 = 0;
189 for i in (len - NGRAM_SIZE)..len {
190 let token = self.recent_tokens[i] as u64;
191 hash = hash.wrapping_mul(31).wrapping_add(token);
192 }
193 if hash == 0 {
195 hash = 1;
196 }
197 hash
198 }
199
200 pub fn finalize(&self) -> GenerationQualityMetrics {
205 if self.count == 0 {
206 return GenerationQualityMetrics::default();
207 }
208
209 let perplexity = (-self.log_prob_mean).exp() as f32;
211
212 let avg_entropy = self.entropy_mean as f32;
214
215 let entropy_variance = if self.count > 1 {
217 (self.entropy_m2 / (self.count - 1) as f64) as f32
218 } else {
219 0.0
220 };
221
222 let total_ngrams = if self.count >= NGRAM_SIZE as u64 {
224 self.count - NGRAM_SIZE as u64 + 1
225 } else {
226 0
227 };
228 let repetition_ratio = if total_ngrams > 0 {
229 self.ngram_repeats as f32 / total_ngrams as f32
230 } else {
231 0.0
232 };
233
234 GenerationQualityMetrics {
235 perplexity,
236 avg_entropy,
237 entropy_variance,
238 repetition_ratio,
239 token_count: self.count as u32,
240 }
241 }
242
243 pub fn token_count(&self) -> u64 {
245 self.count
246 }
247
248 pub fn is_empty(&self) -> bool {
250 self.count == 0
251 }
252}
253
254#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize)]
261pub struct GenerationQualityMetrics {
262 pub perplexity: f32,
266
267 pub avg_entropy: f32,
271
272 pub entropy_variance: f32,
275
276 pub repetition_ratio: f32,
280
281 pub token_count: u32,
283}
284
285impl GenerationQualityMetrics {
286 pub fn is_concerning(&self) -> bool {
288 self.perplexity > 50.0 || self.repetition_ratio > 0.3 || self.entropy_variance > 2.0
289 }
290}
291
292#[derive(Debug, Clone, Default)]
294pub struct SessionMetrics {
295 turn_metrics: Vec<GenerationQualityMetrics>,
297
298 session_perplexity_sum: f64,
300
301 session_token_sum: u64,
303}
304
305impl SessionMetrics {
306 pub fn new() -> Self {
308 Self::default()
309 }
310
311 pub fn add_turn(&mut self, metrics: GenerationQualityMetrics) {
313 self.session_perplexity_sum += metrics.perplexity as f64 * metrics.token_count as f64;
314 self.session_token_sum += metrics.token_count as u64;
315 self.turn_metrics.push(metrics);
316 }
317
318 pub fn turn_count(&self) -> usize {
320 self.turn_metrics.len()
321 }
322
323 pub fn get_turn(&self, index: usize) -> Option<&GenerationQualityMetrics> {
325 self.turn_metrics.get(index)
326 }
327
328 pub fn turns(&self) -> &[GenerationQualityMetrics] {
330 &self.turn_metrics
331 }
332
333 pub fn avg_perplexity(&self) -> f32 {
335 if self.session_token_sum == 0 {
336 return 0.0;
337 }
338 (self.session_perplexity_sum / self.session_token_sum as f64) as f32
339 }
340
341 pub fn total_tokens(&self) -> u64 {
343 self.session_token_sum
344 }
345}
346
347#[cfg(test)]
348mod tests {
349 use super::*;
350
351 #[test]
352 fn test_accumulator_empty() {
353 let acc = GenerationMetricsAccumulator::new();
354 assert!(acc.is_empty());
355 let metrics = acc.finalize();
356 assert_eq!(metrics.token_count, 0);
357 }
358
359 #[test]
360 fn test_accumulator_single_token() {
361 let mut acc = GenerationMetricsAccumulator::new();
362 acc.add_token(-2.0, 1.5, 100);
363
364 let metrics = acc.finalize();
365 assert_eq!(metrics.token_count, 1);
366 assert!((metrics.perplexity - 7.389).abs() < 0.01);
368 assert!((metrics.avg_entropy - 1.5).abs() < 0.01);
369 assert_eq!(metrics.entropy_variance, 0.0); }
371
372 #[test]
373 fn test_accumulator_multiple_tokens() {
374 let mut acc = GenerationMetricsAccumulator::new();
375
376 for i in 0..10 {
378 acc.add_token(-1.0, 2.0, i);
379 }
380
381 let metrics = acc.finalize();
382 assert_eq!(metrics.token_count, 10);
383 assert!((metrics.perplexity - std::f32::consts::E).abs() < 0.01);
385 assert!((metrics.avg_entropy - 2.0).abs() < 0.01);
386 assert!(metrics.entropy_variance < 0.01);
388 }
389
390 #[test]
391 fn test_ngram_repetition() {
392 let mut acc = GenerationMetricsAccumulator::new();
393
394 for _ in 0..3 {
396 acc.add_token(-1.0, 1.0, 1);
397 acc.add_token(-1.0, 1.0, 2);
398 acc.add_token(-1.0, 1.0, 3);
399 }
400
401 let metrics = acc.finalize();
402 assert!(metrics.repetition_ratio > 0.0);
404 }
405
406 #[test]
407 fn test_session_metrics() {
408 let mut session = SessionMetrics::new();
409
410 session.add_turn(GenerationQualityMetrics {
412 perplexity: 5.0,
413 avg_entropy: 2.0,
414 entropy_variance: 0.5,
415 repetition_ratio: 0.1,
416 token_count: 50,
417 });
418
419 session.add_turn(GenerationQualityMetrics {
420 perplexity: 3.0,
421 avg_entropy: 1.5,
422 entropy_variance: 0.3,
423 repetition_ratio: 0.05,
424 token_count: 100,
425 });
426
427 assert_eq!(session.turn_count(), 2);
428 assert_eq!(session.total_tokens(), 150);
429
430 assert!((session.avg_perplexity() - 3.67).abs() < 0.1);
432 }
433}