Model Degradation

The most direct and measurable form of degradation, defined as a decrease in a model's performance on a validation or test set after compression. This is quantified using standard task metrics like Top-1/Top-5 accuracy for classification or mean Average Precision (mAP) for detection.

• Primary Cause: The lossy nature of compression techniques like quantization and pruning, which introduce approximation errors.
• Measurement: Accuracy Drop = Baseline Accuracy - Compressed Model Accuracy.
• Example: A vision model's Top-1 accuracy falling from 94.2% to 91.7% after 8-bit post-training quantization represents a 2.5 percentage point accuracy drop.

This refers to a shift in the model's internal behavior and output distributions, even if final task accuracy appears stable. The compressed model's predictions become less aligned with the original golden model.

• Key Metrics: Measured using KL Divergence or Cosine Similarity between the output logits/probabilities of the original and compressed models.
• Implication: High divergence can break downstream systems that rely on specific confidence scores or logit values, not just the final class label.
• Symptom: The model may still get the same answer, but with much lower (or incorrectly higher) confidence, indicating a loss of calibration.

Paradoxically, some compression techniques can increase inference time despite reducing parameter count, a critical form of degradation for real-time applications.

• Common Causes: Extreme sparsity from pruning can lead to irregular memory access patterns that underutilize parallel hardware. Low-bit quantization (e.g., INT4) may require dequantization overhead or lack efficient kernel support on the target hardware.
• Measurement: Requires on-device evaluation to profile end-to-end latency and frames-per-second (FPS).
• Example: A pruned model might have 50% fewer weights but run slower on a GPU due to inefficient sparse matrix multiplication.

Compression can disproportionately degrade performance on challenging or out-of-distribution (OOD) data, making the model more brittle. This is often missed by standard validation-set accuracy checks.

• Affected Scenarios: Performance on adversarial examples, corner cases, noisy inputs, or data from a slightly different distribution than the training set.
• Mechanism: Compression acts as a regularizer but can also remove the model's capacity to learn robust, generalizable features, leaving it more sensitive to input perturbations.
• Analysis Requirement: Requires dedicated robustness analysis using OOD datasets or stress tests.

Predictable, structured errors introduced by the lossy compression process itself, analogous to visual artifacts in image compression. Quantization noise is the error signal from mapping continuous values to discrete levels.

• Manifestation: In generative models (e.g., Stable Diffusion), this can cause visible noise or texture degradation. In audio models, it may introduce audible artifacts.
• In Classification/Detection: Can cause label flipping where a confidently correct prediction becomes a confidently wrong one due to perturbed activations in critical layers.
• Modeling: Often analyzed by treating quantization error as additive noise to understand its propagation through the network.

The model's predicted confidence scores (probabilities) no longer reflect the true likelihood of correctness. A model is poorly calibrated if a prediction made with 90% confidence is correct only 70% of the time.

• Impact: Critical for risk-sensitive applications where confidence thresholds dictate actions. Compression, especially post-training quantization, often worsens calibration.
• Measurement: Using Expected Calibration Error (ECE) or reliability diagrams.
• Example: After quantization, a model may become overconfident in its (sometimes incorrect) predictions, reducing the utility of its confidence scores for downstream decision-making.

The numerical discrepancy introduced when converting continuous floating-point values (e.g., FP32) to discrete integer representations (e.g., INT8). This is the fundamental source of accuracy degradation in post-training quantization. The error acts as additive noise that perturbs weights and activations, propagating through the computational graph and altering the model's final output. Calibration datasets are used to minimize this error by estimating optimal scaling factors.

A systematic evaluation to determine which components of a neural network are most vulnerable to compression. This involves measuring the accuracy drop when techniques like pruning or quantization are applied to individual layers, channels, or parameters. The results guide heterogeneous compression strategies, such as mixed-precision quantization, where more sensitive layers retain higher bit-widths while less critical ones are aggressively compressed. This is key to optimizing the compression-accuracy tradeoff.

The process of regaining predictive performance lost during compression. This is not automatic and requires specific techniques:

• Quantization-Aware Training (QAT): Simulates quantization noise during training, allowing the model to learn robust representations.
• Fine-Tuning After Compression: A post-compression training step on a task-specific dataset to adjust the compressed weights.
• Knowledge Distillation: Using the original golden model as a teacher to guide the training of the compressed student model, transferring generalization capability.

In compression-accuracy analysis, the set of optimal points on a tradeoff curve. A point is on the Pareto frontier if no other compressed model configuration can improve one metric (e.g., accuracy) without worsening another (e.g., model size or latency). Engineering decisions involve selecting an operating point on this frontier that meets the application's degradation threshold and resource constraints. This concept moves analysis from single-point comparisons to multi-objective optimization.

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. Common fidelity metrics include:

• KL Divergence: Quantifies the difference between the output probability distributions of the original and compressed models.
• Cosine Similarity: Measures the alignment of embedding vectors or internal activations.
• Output Divergence: A general term for any deviation in predictions. High fidelity is critical for ensuring the compressed model behaves deterministically relative to its validated predecessor.

The critical final stage of tradeoff analysis where theoretical metrics meet hardware reality. A compressed model must be benchmarked on the actual target edge hardware (e.g., a specific mobile SoC or NPU) to measure:

• Real-World Latency: Affected by memory bandwidth, cache hierarchies, and kernel efficiency.
• Power Consumption: Directly tied to battery life in mobile/IoT deployments.
• Thermal Performance: Sustained inference speed under thermal constraints. This step often reveals hardware-aware inefficiencies not captured by software simulators, validating the compression ratio and acceptable loss in a production context.