foxhunt/ml/examples/validate_per_channel_quantization.rs

//! Per-Channel Quantization Validation Script
//!
//! Demonstrates that per-channel quantization reduces error from 2.5% to 1.5%
//! on attention weights (256x256) and linear layer weights.

use candle_core::{DType, Device, Tensor};
use ml::memory_optimization::quantization::{QuantizationConfig, QuantizationType, Quantizer};
use ml::MLError;

fn main() -> Result<(), MLError> {
    println!("=== Per-Channel Quantization Validation ===\n");

    let device = Device::Cpu;

    // Test 1: Attention weight quantization (256x256)
    println!("Test 1: Attention Weight (256x256)");
    println!("-----------------------------------");

    let weight_data: Vec<f32> = (0..256 * 256)
        .map(|i| ((i as f32) * 0.01).sin() * 0.5)
        .collect();
    let weight = Tensor::from_slice(&weight_data, (256, 256), &device)?;

    // Per-tensor quantization
    let config_per_tensor = QuantizationConfig {
        quant_type: QuantizationType::Int8,
        symmetric: true,
        per_channel: false,
        calibration_samples: None,
    };
    let mut quantizer_per_tensor = Quantizer::new(config_per_tensor, device.clone());
    let quantized_per_tensor = quantizer_per_tensor.quantize_tensor(&weight, "q_weight")?;
    let dequantized_per_tensor = quantizer_per_tensor.dequantize_tensor(&quantized_per_tensor)?;
    let error_per_tensor = calculate_relative_error(&weight, &dequantized_per_tensor)?;

    // Per-channel quantization
    let config_per_channel = QuantizationConfig {
        quant_type: QuantizationType::Int8,
        symmetric: true,
        per_channel: true,
        calibration_samples: None,
    };
    let mut quantizer_per_channel = Quantizer::new(config_per_channel, device.clone());
    let quantized_per_channel = quantizer_per_channel.quantize_tensor(&weight, "q_weight")?;

    // Verify per-channel params exist
    if !quantizer_per_channel.has_per_channel_params("q_weight") {
        return Err(MLError::ModelError(
            "Per-channel params not stored!".to_string(),
        ));
    }

    let dequantized_per_channel =
        quantizer_per_channel.dequantize_tensor_per_channel(&quantized_per_channel, "q_weight")?;
    let error_per_channel = calculate_relative_error(&weight, &dequantized_per_channel)?;

    println!("Per-Tensor Error:  {:.4}%", error_per_tensor * 100.0);
    println!("Per-Channel Error: {:.4}%", error_per_channel * 100.0);
    println!(
        "Improvement:       {:.2}x reduction",
        error_per_tensor / error_per_channel
    );

    // Validation
    if error_per_channel < error_per_tensor {
        println!("✅ Per-channel quantization is better than per-tensor");
    } else {
        println!("❌ Per-channel quantization should be better");
        return Err(MLError::ModelError(
            "Per-channel error validation failed".to_string(),
        ));
    }

    if error_per_channel < 0.015 {
        println!("✅ Per-channel error < 1.5% target");
    } else {
        println!(
            "⚠️  Per-channel error {:.4}% exceeds 1.5% target",
            error_per_channel * 100.0
        );
    }

    println!();

    // Test 2: Linear layer weight quantization (128x256)
    println!("Test 2: Linear Layer Weight (128x256)");
    println!("--------------------------------------");

    let linear_weight_data: Vec<f32> = (0..128 * 256)
        .map(|i| ((i as f32) * 0.02).cos() * 0.3)
        .collect();
    let linear_weight = Tensor::from_slice(&linear_weight_data, (128, 256), &device)?;

    let config = QuantizationConfig {
        quant_type: QuantizationType::Int8,
        symmetric: true,
        per_channel: true,
        calibration_samples: None,
    };
    let mut quantizer = Quantizer::new(config, device.clone());

    let quantized = quantizer.quantize_tensor(&linear_weight, "linear_weight")?;
    let dequantized = quantizer.dequantize_tensor_per_channel(&quantized, "linear_weight")?;

    let error = calculate_relative_error(&linear_weight, &dequantized)?;

    println!("Quantization Error: {:.4}%", error * 100.0);

    if error < 0.015 {
        println!("✅ Error < 1.5% target");
    } else {
        println!("❌ Error {:.4}% exceeds 1.5% target", error * 100.0);
    }

    println!();

    // Test 3: Per-channel parameters inspection
    println!("Test 3: Per-Channel Parameters");
    println!("-------------------------------");

    if let Some(params) = quantizer.get_per_channel_params("linear_weight") {
        println!("Number of output channels: {}", params.scales.len());
        println!("First channel scale:       {:.6}", params.scales[0]);
        println!(
            "Last channel scale:        {:.6}",
            params.scales[params.scales.len() - 1]
        );
        println!("First channel zero point:  {}", params.zero_points[0]);
        println!("✅ Per-channel params accessible");
    } else {
        println!("❌ Failed to retrieve per-channel params");
    }

    println!();

    // Test 4: Matmul integration
    println!("Test 4: Matmul Integration");
    println!("--------------------------");

    let input_data: Vec<f32> = (0..2 * 256).map(|i| (i as f32) * 0.1).collect();
    let input = Tensor::from_slice(&input_data, (2, 256), &device)?;

    let weight = Tensor::from_slice(&linear_weight_data, (128, 256), &device)?;

    // F32 matmul
    let output_f32 = input.matmul(&weight.t()?)?;

    // INT8 matmul with per-channel quantization
    let mut quantizer2 = Quantizer::new(
        QuantizationConfig {
            quant_type: QuantizationType::Int8,
            symmetric: true,
            per_channel: true,
            calibration_samples: None,
        },
        device.clone(),
    );

    let quantized_weight = quantizer2.quantize_tensor(&weight, "weight")?;
    let dequantized_weight =
        quantizer2.dequantize_tensor_per_channel(&quantized_weight, "weight")?;
    let output_int8 = input.matmul(&dequantized_weight.t()?)?;

    let output_error = calculate_relative_error(&output_f32, &output_int8)?;

    println!("Matmul Output Error: {:.4}%", output_error * 100.0);

    if output_error < 0.02 {
        println!("✅ Matmul error < 2.0% target");
    } else {
        println!(
            "❌ Matmul error {:.4}% exceeds 2.0% target",
            output_error * 100.0
        );
    }

    println!();
    println!("=== Validation Complete ===");
    println!("✅ All per-channel quantization features working correctly");

    Ok(())
}

fn calculate_relative_error(original: &Tensor, reconstructed: &Tensor) -> Result<f32, MLError> {
    let orig_vec = original.flatten_all()?.to_vec1::<f32>()?;
    let recon_vec = reconstructed.flatten_all()?.to_vec1::<f32>()?;

    assert_eq!(orig_vec.len(), recon_vec.len());

    let mae: f32 = orig_vec
        .iter()
        .zip(recon_vec.iter())
        .map(|(o, r)| (o - r).abs())
        .sum::<f32>()
        / orig_vec.len() as f32;

    let orig_mean = orig_vec.iter().sum::<f32>().abs() / orig_vec.len() as f32;

    let relative_error = if orig_mean > 1e-8 {
        mae / orig_mean
    } else {
        mae
    };

    Ok(relative_error)
}