microflow 0.1.3

A robust and efficient TinyML inference engine
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

use libm::roundf;
use nalgebra::Scalar;
use simba::scalar::{SubsetOf, SupersetOf};

/// Represents the trait to constrain a type to be quantized.
pub trait Quantized: Scalar + Copy + Ord + SubsetOf<i32> + SubsetOf<f32> {}
impl<T: Scalar + Copy + Ord + SubsetOf<i32> + SubsetOf<f32>> Quantized for T {}

/// Performs quantization on the given floating-point input.
///
/// # Arguments
/// * `input` - The input value to quantize
/// * `scale` - The quantization scale
/// * `zero_point` - The quantization zero point
///
pub fn quantize<T: Quantized>(input: f32, scale: f32, zero_point: T) -> T {
    roundf(input / scale + f32::from_subset(&zero_point)).to_subset_unchecked()
}

/// Performs dequantization on the given integer input.
///
/// # Arguments
/// * `input` - The input value to dequantize
/// * `scale` - The quantization scale
/// * `zero_point` - The quantization zero point
///
pub fn dequantize<T: Quantized>(input: T, scale: f32, zero_point: T) -> f32 {
    scale * (f32::from_subset(&input) - f32::from_subset(&zero_point))
}

#[cfg(test)]
mod tests {
    use super::*;

    const VALUE: f32 = 1.;
    const SCALE: f32 = 0.2;
    const ZERO_POINT: i8 = 3;
    const VALUE_QUANTIZED: i8 = 8;
    const VALUE_DEQUANTIZED: f32 = 1.;

    #[test]
    fn quantize_value() {
        assert_eq!(quantize(VALUE, SCALE, ZERO_POINT), VALUE_QUANTIZED);
    }

    #[test]
    fn dequantize_value() {
        assert_eq!(
            dequantize(VALUE_QUANTIZED, SCALE, ZERO_POINT),
            VALUE_DEQUANTIZED
        );
    }
}