trustformers-models 0.1.1

Model implementations for TrustformeRS
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

//! Reference value comparison utilities

use anyhow::{Error, Result};
use trustformers_core::tensor::Tensor;

use super::types::NumericalDifferences;

/// Reference value comparison utilities
pub struct ReferenceComparator {
    tolerance: f32,
}

impl ReferenceComparator {
    /// Create a new reference comparator
    pub fn new(tolerance: f32) -> Self {
        Self { tolerance }
    }

    /// Get the tolerance value
    pub fn tolerance(&self) -> f32 {
        self.tolerance
    }

    /// Compare model output with reference values
    pub fn compare_with_reference(
        &self,
        actual: &Tensor,
        expected: &Tensor,
    ) -> Result<NumericalDifferences> {
        match (actual, expected) {
            (Tensor::F32(actual_arr), Tensor::F32(expected_arr)) => {
                if actual_arr.shape() != expected_arr.shape() {
                    return Err(Error::msg("Tensor shapes don't match"));
                }

                let diffs: Vec<f32> = actual_arr
                    .iter()
                    .zip(expected_arr.iter())
                    .map(|(a, e)| (a - e).abs())
                    .collect();

                let max_abs_diff = diffs.iter().cloned().fold(0.0, f32::max);
                let mean_abs_diff = diffs.iter().sum::<f32>() / diffs.len() as f32;
                let rms_diff =
                    (diffs.iter().map(|d| d * d).sum::<f32>() / diffs.len() as f32).sqrt();
                let within_tolerance = diffs.iter().filter(|&&d| d <= self.tolerance).count();
                let within_tolerance_percent =
                    (within_tolerance as f32 / diffs.len() as f32) * 100.0;

                Ok(NumericalDifferences {
                    max_abs_diff,
                    mean_abs_diff,
                    rms_diff,
                    within_tolerance_percent,
                })
            },
            _ => Err(Error::msg("Unsupported tensor types for comparison")),
        }
    }

    /// Validate that differences are within acceptable bounds
    pub fn validate_differences(&self, differences: &NumericalDifferences) -> bool {
        differences.max_abs_diff <= self.tolerance && differences.within_tolerance_percent >= 95.0
    }
}