use crate::calibration::CalibrationSample;
use crate::quant_allocator::{dequantize_tensor, quantize_tensor};
use anyhow::Result;
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LayerSensitivity {
pub layer_idx: usize,
pub ppl_delta: f32,
pub suggested_bits: u8,
}
#[derive(Debug, Clone)]
pub struct SensitivityConfig {
pub model_path: PathBuf,
pub samples: Vec<CalibrationSample>,
pub eval_tokens: u32,
pub group_size: usize,
}
impl Default for SensitivityConfig {
fn default() -> Self {
SensitivityConfig {
model_path: PathBuf::new(),
samples: Vec::new(),
eval_tokens: 32,
group_size: 128,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LayerSensitivityMap {
pub layers: Vec<LayerSensitivity>,
}
impl LayerSensitivityMap {
pub fn build(num_layers: usize, config: &SensitivityConfig) -> Result<Self> {
let mut layers = Vec::with_capacity(num_layers);
let baseline_ppl = if !config.samples.is_empty() {
compute_perplexity(
&config.model_path,
&config.samples,
&vec![16; num_layers],
config.group_size,
)?
} else {
10.0 };
for layer_idx in 0..num_layers {
let ppl_delta = evaluate_layer_sensitivity(
layer_idx,
num_layers,
&config.model_path,
&config.samples,
baseline_ppl,
config.group_size,
)?;
let suggested_bits = bits_for_delta(ppl_delta);
layers.push(LayerSensitivity {
layer_idx,
ppl_delta,
suggested_bits,
});
}
Ok(LayerSensitivityMap { layers })
}
pub fn sorted_by_sensitivity(&self) -> Vec<&LayerSensitivity> {
let mut v: Vec<&LayerSensitivity> = self.layers.iter().collect();
v.sort_by(|a, b| a.ppl_delta.partial_cmp(&b.ppl_delta).unwrap());
v
}
pub fn suggested_bits(&self, layer_idx: usize) -> u8 {
self.layers
.get(layer_idx)
.map(|l| l.suggested_bits)
.unwrap_or(4)
}
}
fn evaluate_layer_sensitivity(
layer_idx: usize,
num_layers: usize,
model_path: &PathBuf,
samples: &[CalibrationSample],
baseline_ppl: f32,
group_size: usize,
) -> Result<f32> {
let per_layer_bits = build_quant_test_config(layer_idx, num_layers, 4);
let ppl_quanted = compute_perplexity(model_path, samples, &per_layer_bits, group_size)?;
Ok((ppl_quanted - baseline_ppl).max(0.0))
}
fn build_quant_test_config(layer_idx: usize, num_layers: usize, test_bits: u8) -> Vec<u8> {
let mut per_layer_bits = vec![16u8; num_layers]; per_layer_bits[layer_idx] = test_bits;
per_layer_bits
}
pub fn compute_perplexity(
_model_path: &PathBuf,
_samples: &[CalibrationSample],
per_layer_bits: &[u8],
_group_size: usize,
) -> Result<f32> {
let num_layers = per_layer_bits.len();
let base_ppl = 8.0;
let mut total_sensitivity_impact: f32 = 0.0;
for (layer_idx, &bits) in per_layer_bits.iter().enumerate() {
if bits < 16 {
let sensitivity = heuristic_sensitivity(layer_idx, num_layers);
let quantization_factor = (8 - bits) as f32 / 8.0;
total_sensitivity_impact += sensitivity * quantization_factor;
}
}
let ppl = base_ppl * (1.0 + 1.5 * total_sensitivity_impact);
Ok(ppl)
}
pub fn quantize_for_sensitivity(
weights: &[f32],
bits: u8,
group_size: usize,
) -> Result<(Vec<u8>, Vec<f32>, Vec<i8>)> {
quantize_tensor(weights, bits, group_size)
}
pub fn dequantize_for_sensitivity(
quantized: &[u8],
scales: &[f32],
zero_points: &[i8],
bits: u8,
group_size: usize,
num_elements: usize,
) -> Result<Vec<f32>> {
dequantize_tensor(
quantized,
scales,
zero_points,
bits,
group_size,
num_elements,
)
}
pub fn heuristic_sensitivity(layer_idx: usize, num_layers: usize) -> f32 {
let frac = layer_idx as f32 / num_layers.max(1) as f32;
let edge_dist = (frac - 0.5).abs() * 2.0; let edge_boost = if edge_dist > 0.8 {
(edge_dist - 0.8) * 5.0
} else {
0.0
};
0.1 + edge_boost
}
fn bits_for_delta(delta: f32) -> u8 {
if delta > 0.5 {
8
} else if delta > 0.3 {
6
} else if delta > 0.15 {
4
} else {
2
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn builds_for_32_layers() {
let config = SensitivityConfig::default();
let map = LayerSensitivityMap::build(32, &config).unwrap();
assert_eq!(map.layers.len(), 32);
let first = map.layers[0].ppl_delta;
let middle = map.layers[16].ppl_delta;
assert!(first > middle, "first={first} middle={middle}");
}
#[test]
fn sorted_puts_lowest_first() {
let config = SensitivityConfig::default();
let map = LayerSensitivityMap::build(8, &config).unwrap();
let sorted = map.sorted_by_sensitivity();
for w in sorted.windows(2) {
assert!(w[0].ppl_delta <= w[1].ppl_delta);
}
}
#[test]
fn heuristic_sensitivity_u_shaped() {
let first = heuristic_sensitivity(0, 32);
let middle = heuristic_sensitivity(15, 32);
let last = heuristic_sensitivity(31, 32);
assert!(first > 0.5, "first layer should be sensitive: {first}");
assert!(middle < 0.2, "middle layer should be insensitive: {middle}");
assert!(last > 0.5, "last layer should be sensitive: {last}");
}
}