Sensitivity Analysis

This core technique measures the accuracy degradation when compression is applied individually to each layer. It identifies critical layers (e.g., final classification layers) that suffer high loss and robust layers (e.g., early feature extractors) that can tolerate aggressive compression. The output is a ranked list or heatmap used to allocate higher precision (e.g., FP16) to sensitive layers and lower precision (e.g., INT4) to robust ones, forming the basis for mixed-precision quantization.

A granular analysis that evaluates the importance of individual channels in convolutional layers or neurons in fully connected layers. Common scoring methods include:

• Magnitude-based: Using the L1/L2 norm of filter weights.
• Gradient-based: Assessing the gradient of the loss with respect to the channel.
• Reconstruction error: Measuring the output distortion after removal. Channels with low scores are prime candidates for structured pruning, as their removal has minimal impact on the network's output fidelity.

This feature simulates the effect of quantization noise without performing full model conversion. It injects simulated quantization error into weights or activations and measures the resultant output divergence (e.g., using KL Divergence). This allows for rapid, iterative bit-width selection by answering: "What is the expected accuracy drop if this tensor is quantized to 4-bit vs. 8-bit?" It relies on a small, representative calibration dataset to estimate activation ranges.

Determines the optimal order and method for applying compression techniques based on sensitivity results. A standard schedule is:

1. Prune low-sensitivity channels first (large compression gain, low accuracy cost).
2. Quantize remaining weights, using higher precision for sensitive layers.
3. Fine-tune the compressed model to recover accuracy. This sequential approach prevents compounding errors and is more effective than applying all techniques simultaneously.

Analyzes how sensitivity patterns differ across model architectures (e.g., ResNet vs. ViT vs. LSTM). Key findings include:

• Vision Transformers (ViTs): Attention layers often show different sensitivity profiles than convolutional networks.
• Recurrent Networks: May exhibit high sensitivity in temporal feedback loops. This analysis prevents the blind application of one model's optimal compression strategy to another and informs hardware-aware compression for target accelerators.

Evaluates how compression affects model performance beyond standard validation accuracy. Sensitivity analysis must test:

• Out-of-distribution (OOD) data: Does compression degrade OOD robustness disproportionately?
• Adversarial examples: Does quantization increase vulnerability?
• Edge cases: Performance on rare but critical inputs. This ensures the compressed model meets the degradation threshold for all real-world scenarios, not just the validation set.

The measurement of how a model's accuracy degrades when compression is applied to individual layers, channels, or parameters. This granular analysis is the foundation of sensitivity analysis, identifying which components are most critical for preserving accuracy.

• Purpose: Guides heterogeneous compression strategies, such as mixed-precision quantization, where sensitive layers are kept at higher precision.
• Method: Often involves iterative profiling, compressing one element at a time and measuring the resulting accuracy drop on a validation set.
• Output: A sensitivity ranking or heatmap used to create a compression plan.

The numerical discrepancy introduced when converting continuous floating-point values (e.g., FP32) to discrete, lower-bit integer representations (e.g., INT8). This is a primary source of accuracy degradation in post-training quantization.

• Cause: The rounding and clipping operations inherent to quantization.
• Impact: Acts as additive noise that perturbs weights and activations, propagating through the network and potentially distorting outputs.
• Mitigation: Techniques like quantization-aware training (QAT) simulate this error during training, allowing the model to adapt, or using a calibration dataset to better estimate activation ranges.

The degree to which a compressed model's outputs and internal behaviors match those of the original, uncompressed golden model. It is a broader measure than just task accuracy.

• Metrics: Measured using statistical divergences like KL Divergence (for output distributions) or cosine similarity (for embeddings/activations).
• Importance: High fidelity ensures the compressed model not only gets the same answers but does so for the same reasons, which is critical for robustness and explainability.
• Trade-off: Directly conflicts with aggressive compression ratios; high-fidelity compression often requires more conservative techniques.

In compression-accuracy analysis, the set of optimal points on a tradeoff curve where no other configuration can improve one metric (e.g., accuracy) without worsening another (e.g., model size or latency).

• Visualization: A plot with accuracy on one axis and a compression metric (size, latency, FLOPs) on the other. The frontier is the "knee" of the curve.
• Engineering Goal: To find compression configurations that lie on this frontier, representing the best possible efficiency for a given accuracy target.
• Use: Enables informed decision-making by showing the explicit cost in accuracy for gains in efficiency.

The process of regaining performance lost after applying lossy compression techniques. It is a crucial step to make compressed models viable for deployment.

• Primary Method: Fine-tuning after compression, where the compressed model is further trained on the task-specific dataset. The model learns to adapt to the introduced quantization noise or pruned architecture.
• Advanced Method: Quantization-Aware Training (QAT), which bakes the quantization simulation into the training loop for superior recovery.
• Outcome: Aims to bring the model's validation accuracy back to or near its original performance baseline while retaining compression benefits.

The critical final stage of tradeoff analysis where a compressed model is benchmarked on the actual target hardware (e.g., a mobile SoC or microcontroller). This moves beyond theoretical metrics to measure real-world deployment viability.

• Metrics: Real inference latency, memory footprint, power consumption, and sustained accuracy under device thermal/power constraints.
• Purpose: Validates that software-level compression translates to actual gains on the target hardware-aware architecture. A model that is small on disk may still run slowly due to unsupported ops.
• Result: Provides the definitive data for the compression-accuracy tradeoff decision before production rollout.