Struct PostTrainingQuantizer

pub struct PostTrainingQuantizer<F: Float + Debug> { /* private fields */ }

Post-training quantization manager

Implementations

impl<F: Float + Debug + 'static> PostTrainingQuantizer<F>

pub fn new( bits: QuantizationBits, scheme: QuantizationScheme, calibration: CalibrationMethod, ) -> Self

Create a new post-training quantizer

Examples found in repository

examples/neural_advanced_features.rs (lines 184-188)

fn demonstrate_model_compression() -> Result<()> {
    println!("🗜️  Model Compression Demonstration");
    println!("==================================\n");

    // 1. Post-training quantization
    println!("1. Post-training Quantization:");
    let mut quantizer = PostTrainingQuantizer::<f64>::new(
        QuantizationBits::Int8,
        QuantizationScheme::Symmetric,
        CalibrationMethod::MinMax,
    );

    // Simulate layer activations
    let activations =
        Array::from_shape_fn((100, 256), |(i, j)| ((i + j) as f64 / 10.0).sin() * 2.0).into_dyn();

    quantizer.calibrate("conv1".to_string(), &activations)?;

    let quantized = quantizer.quantize_tensor("conv1", &activations)?;
    let _dequantized = quantizer.dequantize_tensor("conv1", &quantized)?;

    println!("   Original shape: {:?}", activations.shape());
    println!("   Quantized shape: {:?}", quantized.shape());
    println!(
        "   Compression ratio: {:.1}x",
        quantizer.get_compression_ratio()
    );

    // 2. Model pruning
    println!("\n2. Model Pruning:");
    let mut pruner = ModelPruner::<f64>::new(PruningMethod::MagnitudeBased { threshold: 0.1 });

    // Simulate model weights
    let weights =
        Array::from_shape_fn((128, 256), |(i, j)| ((i * j) as f64 / 1000.0).tanh()).into_dyn();

    let mask = pruner.generate_pruning_mask("fc1".to_string(), &weights)?;
    println!("   Weights shape: {:?}", weights.shape());
    println!("   Pruning mask shape: {:?}", mask.shape());
    println!(
        "   Model sparsity: {:.1}%",
        pruner.get_model_sparsity() * 100.0
    );

    let sparsity_stats = pruner.get_sparsity_statistics();
    for (layer_name, stats) in sparsity_stats {
        println!(
            "   {}: {:.1}% sparse ({}/{} params)",
            layer_name,
            stats.sparsity_ratio * 100.0,
            stats.pruned_params,
            stats.total_params
        );
    }

    println!("✅ Model compression demonstration completed!\n");
    Ok(())
}

pub fn calibrate( &mut self, layer_name: String, activations: &ArrayD<F>, ) -> Result<()>

Calibrate quantization parameters using sample data

Examples found in repository

examples/neural_advanced_features.rs (line 194)

fn demonstrate_model_compression() -> Result<()> {
    println!("🗜️  Model Compression Demonstration");
    println!("==================================\n");

    // 1. Post-training quantization
    println!("1. Post-training Quantization:");
    let mut quantizer = PostTrainingQuantizer::<f64>::new(
        QuantizationBits::Int8,
        QuantizationScheme::Symmetric,
        CalibrationMethod::MinMax,
    );

    // Simulate layer activations
    let activations =
        Array::from_shape_fn((100, 256), |(i, j)| ((i + j) as f64 / 10.0).sin() * 2.0).into_dyn();

    quantizer.calibrate("conv1".to_string(), &activations)?;

    let quantized = quantizer.quantize_tensor("conv1", &activations)?;
    let _dequantized = quantizer.dequantize_tensor("conv1", &quantized)?;

    println!("   Original shape: {:?}", activations.shape());
    println!("   Quantized shape: {:?}", quantized.shape());
    println!(
        "   Compression ratio: {:.1}x",
        quantizer.get_compression_ratio()
    );

    // 2. Model pruning
    println!("\n2. Model Pruning:");
    let mut pruner = ModelPruner::<f64>::new(PruningMethod::MagnitudeBased { threshold: 0.1 });

    // Simulate model weights
    let weights =
        Array::from_shape_fn((128, 256), |(i, j)| ((i * j) as f64 / 1000.0).tanh()).into_dyn();

    let mask = pruner.generate_pruning_mask("fc1".to_string(), &weights)?;
    println!("   Weights shape: {:?}", weights.shape());
    println!("   Pruning mask shape: {:?}", mask.shape());
    println!(
        "   Model sparsity: {:.1}%",
        pruner.get_model_sparsity() * 100.0
    );

    let sparsity_stats = pruner.get_sparsity_statistics();
    for (layer_name, stats) in sparsity_stats {
        println!(
            "   {}: {:.1}% sparse ({}/{} params)",
            layer_name,
            stats.sparsity_ratio * 100.0,
            stats.pruned_params,
            stats.total_params
        );
    }

    println!("✅ Model compression demonstration completed!\n");
    Ok(())
}

pub fn quantize_tensor( &self, layer_name: &str, tensor: &ArrayD<F>, ) -> Result<ArrayD<i32>>

Quantize a tensor using the calibrated parameters

Examples found in repository

examples/neural_advanced_features.rs (line 196)

fn demonstrate_model_compression() -> Result<()> {
    println!("🗜️  Model Compression Demonstration");
    println!("==================================\n");

    // 1. Post-training quantization
    println!("1. Post-training Quantization:");
    let mut quantizer = PostTrainingQuantizer::<f64>::new(
        QuantizationBits::Int8,
        QuantizationScheme::Symmetric,
        CalibrationMethod::MinMax,
    );

    // Simulate layer activations
    let activations =
        Array::from_shape_fn((100, 256), |(i, j)| ((i + j) as f64 / 10.0).sin() * 2.0).into_dyn();

    quantizer.calibrate("conv1".to_string(), &activations)?;

    let quantized = quantizer.quantize_tensor("conv1", &activations)?;
    let _dequantized = quantizer.dequantize_tensor("conv1", &quantized)?;

    println!("   Original shape: {:?}", activations.shape());
    println!("   Quantized shape: {:?}", quantized.shape());
    println!(
        "   Compression ratio: {:.1}x",
        quantizer.get_compression_ratio()
    );

    // 2. Model pruning
    println!("\n2. Model Pruning:");
    let mut pruner = ModelPruner::<f64>::new(PruningMethod::MagnitudeBased { threshold: 0.1 });

    // Simulate model weights
    let weights =
        Array::from_shape_fn((128, 256), |(i, j)| ((i * j) as f64 / 1000.0).tanh()).into_dyn();

    let mask = pruner.generate_pruning_mask("fc1".to_string(), &weights)?;
    println!("   Weights shape: {:?}", weights.shape());
    println!("   Pruning mask shape: {:?}", mask.shape());
    println!(
        "   Model sparsity: {:.1}%",
        pruner.get_model_sparsity() * 100.0
    );

    let sparsity_stats = pruner.get_sparsity_statistics();
    for (layer_name, stats) in sparsity_stats {
        println!(
            "   {}: {:.1}% sparse ({}/{} params)",
            layer_name,
            stats.sparsity_ratio * 100.0,
            stats.pruned_params,
            stats.total_params
        );
    }

    println!("✅ Model compression demonstration completed!\n");
    Ok(())
}

pub fn dequantize_tensor( &self, layer_name: &str, quantized: &ArrayD<i32>, ) -> Result<ArrayD<F>>

Dequantize a tensor back to floating point

Examples found in repository

examples/neural_advanced_features.rs (line 197)

fn demonstrate_model_compression() -> Result<()> {
    println!("🗜️  Model Compression Demonstration");
    println!("==================================\n");

    // 1. Post-training quantization
    println!("1. Post-training Quantization:");
    let mut quantizer = PostTrainingQuantizer::<f64>::new(
        QuantizationBits::Int8,
        QuantizationScheme::Symmetric,
        CalibrationMethod::MinMax,
    );

    // Simulate layer activations
    let activations =
        Array::from_shape_fn((100, 256), |(i, j)| ((i + j) as f64 / 10.0).sin() * 2.0).into_dyn();

    quantizer.calibrate("conv1".to_string(), &activations)?;

    let quantized = quantizer.quantize_tensor("conv1", &activations)?;
    let _dequantized = quantizer.dequantize_tensor("conv1", &quantized)?;

    println!("   Original shape: {:?}", activations.shape());
    println!("   Quantized shape: {:?}", quantized.shape());
    println!(
        "   Compression ratio: {:.1}x",
        quantizer.get_compression_ratio()
    );

    // 2. Model pruning
    println!("\n2. Model Pruning:");
    let mut pruner = ModelPruner::<f64>::new(PruningMethod::MagnitudeBased { threshold: 0.1 });

    // Simulate model weights
    let weights =
        Array::from_shape_fn((128, 256), |(i, j)| ((i * j) as f64 / 1000.0).tanh()).into_dyn();

    let mask = pruner.generate_pruning_mask("fc1".to_string(), &weights)?;
    println!("   Weights shape: {:?}", weights.shape());
    println!("   Pruning mask shape: {:?}", mask.shape());
    println!(
        "   Model sparsity: {:.1}%",
        pruner.get_model_sparsity() * 100.0
    );

    let sparsity_stats = pruner.get_sparsity_statistics();
    for (layer_name, stats) in sparsity_stats {
        println!(
            "   {}: {:.1}% sparse ({}/{} params)",
            layer_name,
            stats.sparsity_ratio * 100.0,
            stats.pruned_params,
            stats.total_params
        );
    }

    println!("✅ Model compression demonstration completed!\n");
    Ok(())
}

pub fn get_compression_ratio(&self) -> f64

Get compression ratio achieved

Examples found in repository

examples/neural_advanced_features.rs (line 203)

fn demonstrate_model_compression() -> Result<()> {
    println!("🗜️  Model Compression Demonstration");
    println!("==================================\n");

    // 1. Post-training quantization
    println!("1. Post-training Quantization:");
    let mut quantizer = PostTrainingQuantizer::<f64>::new(
        QuantizationBits::Int8,
        QuantizationScheme::Symmetric,
        CalibrationMethod::MinMax,
    );

    // Simulate layer activations
    let activations =
        Array::from_shape_fn((100, 256), |(i, j)| ((i + j) as f64 / 10.0).sin() * 2.0).into_dyn();

    quantizer.calibrate("conv1".to_string(), &activations)?;

    let quantized = quantizer.quantize_tensor("conv1", &activations)?;
    let _dequantized = quantizer.dequantize_tensor("conv1", &quantized)?;

    println!("   Original shape: {:?}", activations.shape());
    println!("   Quantized shape: {:?}", quantized.shape());
    println!(
        "   Compression ratio: {:.1}x",
        quantizer.get_compression_ratio()
    );

    // 2. Model pruning
    println!("\n2. Model Pruning:");
    let mut pruner = ModelPruner::<f64>::new(PruningMethod::MagnitudeBased { threshold: 0.1 });

    // Simulate model weights
    let weights =
        Array::from_shape_fn((128, 256), |(i, j)| ((i * j) as f64 / 1000.0).tanh()).into_dyn();

    let mask = pruner.generate_pruning_mask("fc1".to_string(), &weights)?;
    println!("   Weights shape: {:?}", weights.shape());
    println!("   Pruning mask shape: {:?}", mask.shape());
    println!(
        "   Model sparsity: {:.1}%",
        pruner.get_model_sparsity() * 100.0
    );

    let sparsity_stats = pruner.get_sparsity_statistics();
    for (layer_name, stats) in sparsity_stats {
        println!(
            "   {}: {:.1}% sparse ({}/{} params)",
            layer_name,
            stats.sparsity_ratio * 100.0,
            stats.pruned_params,
            stats.total_params
        );
    }

    println!("✅ Model compression demonstration completed!\n");
    Ok(())
}