Struct ModelPruner

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

Neural network pruner

Implementations

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

pub fn new(method: PruningMethod) -> Self

Create a new model pruner

Examples found in repository

examples/neural_advanced_features.rs (line 208)

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 generate_pruning_mask( &mut self, layer_name: String, weights: &ArrayD<F>, ) -> Result<ArrayD<bool>>

Generate pruning mask for a layer

Examples found in repository

examples/neural_advanced_features.rs (line 214)

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 apply_pruning_mask( &self, layer_name: &str, weights: &mut ArrayD<F>, ) -> Result<()>

Apply pruning mask to weights

pub fn update_step(&mut self, step: usize)

Update current step (for gradual pruning)

pub fn get_model_sparsity(&self) -> f64

Get overall model sparsity

Examples found in repository

examples/neural_advanced_features.rs (line 219)

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_sparsity_statistics(&self) -> &HashMap<String, SparsityStatistics>

Get sparsity statistics for all layers

Examples found in repository

examples/neural_advanced_features.rs (line 222)

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(())
}