Struct QuantConverter 

pub struct QuantConverter { /* private fields */ }

Quantization converter.

Implementations

impl QuantConverter

pub fn new(stats: &QuantStats, num_bits: u32, signed: bool) -> Self

Create a new quantization converter.

pub fn quantize(&self, value: f32) -> i32

Quantize float32 to integer.

pub fn dequantize(&self, value: i32) -> f32

Dequantize integer to float32.

pub fn quantize_tensor(&self, tensor: &ArrayD<f32>) -> Result<Vec<i32>>

Quantize entire tensor.

Examples found in repository

examples/full_inference_pipeline.rs (line 135)

fn quantize_model() {
    println!("3. Model Quantization");

    let calibration_data = vec![
        Tensor::random(&[1, 224, 224, 3]).data,
        Tensor::random(&[1, 224, 224, 3]).data,
        Tensor::random(&[1, 224, 224, 3]).data,
    ];

    let ptq = PTQEngine::new(8, false);
    match ptq.calibrate(&calibration_data) {
        Ok(converter) => {
            println!("   ✓ Calibration complete");
            
            let sample = &calibration_data[0];
            let stats = QuantStats::from_tensor(sample);
            println!("   Calibration Stats:");
            println!("   - Min: {:.6}", stats.min_val);
            println!("   - Max: {:.6}", stats.max_val);
            println!("   - Mean: {:.6}", stats.mean_val);
            println!("   - Std: {:.6}", stats.std_val);
            
            match converter.quantize_tensor(sample) {
                Ok(quantized) => {
                    println!("   ✓ Quantization complete: {} values", quantized.len());
                    println!("   Compression: {:.2}x\n", 
                        (sample.len() * 4) as f64 / quantized.len() as f64
                    );
                }
                Err(e) => println!("   ✗ Quantization failed: {}\n", e),
            }
        }
        Err(e) => println!("   ✗ Calibration failed: {}\n", e),
    }
}

pub fn dequantize_tensor(&self, quantized: &[i32]) -> Result<ArrayD<f32>>

Dequantize tensor.