hyprstream_decision/
confidence.rs1use thiserror::Error;
14
15use crate::spec::QuestionKind;
16
17pub const PRODUCER_SUM_TOLERANCE: f32 = 1e-6;
20
21pub const CONSUMER_SUM_TOLERANCE: f32 = 1e-2;
24
25#[derive(Debug, Clone, PartialEq, Error)]
27pub enum DistributionError {
28 #[error("distribution is empty")]
30 Empty,
31 #[error("component {index} = {value} is not a finite probability in [0, 1]")]
33 OutOfRange {
34 index: usize,
36 value: f32,
38 },
39 #[error("distribution sums to {sum}, beyond tolerance {tolerance}")]
41 SumOutOfTolerance {
42 sum: f32,
44 tolerance: f32,
46 },
47}
48
49pub fn check_distribution(probabilities: &[f32], tolerance: f32) -> Result<(), DistributionError> {
52 if probabilities.is_empty() {
53 return Err(DistributionError::Empty);
54 }
55 let mut sum = 0.0f32;
56 for (index, &value) in probabilities.iter().enumerate() {
57 if !value.is_finite() || !(0.0..=1.0).contains(&value) {
58 return Err(DistributionError::OutOfRange { index, value });
59 }
60 sum += value;
61 }
62 if (sum - 1.0).abs() > tolerance {
63 return Err(DistributionError::SumOutOfTolerance { sum, tolerance });
64 }
65 Ok(())
66}
67
68pub fn argmax_index(probabilities: &[f32]) -> Option<usize> {
71 let mut best: Option<(usize, f32)> = None;
72 for (index, &value) in probabilities.iter().enumerate() {
73 match best {
74 Some((_, best_value)) if value <= best_value => {}
75 _ => best = Some((index, value)),
76 }
77 }
78 best.map(|(index, _)| index)
79}
80
81pub fn choice_confidence(probabilities: &[f32]) -> f32 {
84 let n = probabilities.len();
85 if n <= 1 {
86 return 1.0;
87 }
88 let p_max = probabilities
89 .iter()
90 .copied()
91 .fold(f32::NEG_INFINITY, f32::max);
92 let uniform = 1.0 / n as f32;
93 ((p_max - uniform) / (1.0 - uniform)).clamp(0.0, 1.0)
94}
95
96pub fn score_confidence(probabilities: &[f32]) -> f32 {
102 let n = probabilities.len();
103 if n <= 1 {
104 return 1.0;
105 }
106 let Some(mode) = argmax_index(probabilities) else {
107 return 1.0;
108 };
109 let mad_mode: f32 = probabilities
110 .iter()
111 .enumerate()
112 .map(|(index, &p)| p * index.abs_diff(mode) as f32)
113 .sum();
114 let center = (n - 1) as f32 / 2.0;
115 let mad_uniform: f32 = (0..n)
116 .map(|index| (index as f32 - center).abs())
117 .sum::<f32>()
118 / n as f32;
119 if mad_uniform == 0.0 {
120 return 1.0;
121 }
122 (1.0 - mad_mode / mad_uniform).max(0.0)
123}
124
125pub fn confidence(kind: QuestionKind, probabilities: &[f32]) -> f32 {
129 match kind {
130 QuestionKind::Noul | QuestionKind::Choice => choice_confidence(probabilities),
131 QuestionKind::Score => score_confidence(probabilities),
132 QuestionKind::Span | QuestionKind::Derived => 0.0,
134 }
135}
136
137pub fn expected_score(probabilities: &[f32]) -> f32 {
140 probabilities
141 .iter()
142 .enumerate()
143 .map(|(index, &p)| index as f32 * p)
144 .sum()
145}
146
147#[cfg(test)]
148mod tests {
149 use super::*;
150
151 #[test]
152 fn argmax_breaks_ties_toward_earliest_index() {
153 assert_eq!(argmax_index(&[0.5, 0.5]), Some(0));
154 assert_eq!(argmax_index(&[0.1, 0.4, 0.4]), Some(1));
155 assert_eq!(argmax_index(&[]), None);
156 }
157
158 #[test]
159 fn degenerate_distributions_are_certain() {
160 assert_eq!(choice_confidence(&[1.0]), 1.0);
161 assert_eq!(score_confidence(&[1.0]), 1.0);
162 assert_eq!(score_confidence(&[0.0, 0.0, 0.0, 1.0]), 1.0);
163 }
164}