Quantization (Data)

Uniform quantization maps floating-point values to integers using a linear scaling function with a constant step size. It is the most common and hardware-friendly technique.

• Mechanism: Defines a scale factor (delta) and a zero point (offset). Values are quantized via: Q = round(x / delta) + zero_point.
• Types: Includes symmetric quantization (zero point is 0) and asymmetric quantization (zero point is adjusted to better fit the data range).
• Use Case: Standard for post-training quantization (PTQ) of neural network weights and activations, especially for efficient integer-only inference on CPUs and NPUs.

Non-uniform quantization uses variable step sizes, allowing more precision to be allocated to regions of the value range where it is most needed (e.g., where values are densely clustered).

• Mechanism: Employs non-linear functions like logarithmic scaling or learned codebooks to map values.
• Benefit: Can achieve higher accuracy for a given bit-width compared to uniform quantization when the data distribution is highly non-uniform.
• Drawback: Requires more complex dequantization logic and is less directly supported by standard hardware arithmetic logic units (ALUs).

Quantization-aware training simulates the effects of quantization during the model training process, allowing the model weights to adapt to the precision loss.

• Process: Fake quantization nodes are inserted into the model's computational graph. During forward passes, values are quantized and dequantized, but gradients are calculated using the full-precision (FP32) values.
• Outcome: Models trained with QAT typically suffer significantly less accuracy degradation compared to post-training quantization, especially at very low bit-widths (e.g., INT4).
• Application: Critical for deploying highly accurate, ultra-low-bit models on edge devices.

Post-training quantization converts a pre-trained, full-precision model to a lower-precision format without requiring retraining. It is faster and requires no labeled data.

• Static PTQ: Calibrates the quantization ranges (scale/zero-point) using a representative dataset once. These fixed ranges are then used for all inference.
• Dynamic PTQ: Calculates quantization ranges on-the-fly for each input during inference. More flexible but adds computational overhead.
• Typical Target: Reducing 32-bit floating point (FP32) models to 8-bit integers (INT8) for a 4x memory reduction and faster inference on supported hardware.

Mixed-precision quantization assigns different numerical precisions (bit-widths) to different layers, tensors, or even channels within a neural network.

• Principle: Not all parts of a model are equally sensitive to quantization. This technique allocates higher precision (e.g., FP16) to sensitive layers and aggressive quantization (e.g., INT4) to robust layers.
• Optimization: Finding the optimal bit-width configuration is a hardware-aware neural architecture search (NAS) problem, often automated using reinforcement learning or sensitivity analysis.
• Result: Achieves an optimal trade-off between model size/ speed and accuracy, pushing the Pareto frontier for edge deployment.

Binary quantization constrains weights or activations to +1/-1 (1 bit). Ternary quantization allows values of -1, 0, or +1 (effectively ~2 bits). These are extreme forms of quantization.

• Mechanism: Replaces multiplication operations with efficient bitwise XNOR and popcount operations, leading to massive theoretical speedups.
• Challenge: Causes severe information loss, leading to large accuracy drops unless the model architecture is specifically designed for it (e.g., Binary Neural Networks).
• Use Case: Research area for ultra-low-power inference on microcontrollers (TinyML) where memory and compute are extremely constrained.

Quantization accelerates computation by leveraging hardware optimized for low-precision arithmetic. Modern AI accelerators, such as NVIDIA Tensor Cores, Google TPUs, and Apple Neural Engines, achieve peak performance with INT8 or BFLOAT16 data types. Key benefits include:

• Higher throughput: More operations per second (OPS) within the same thermal design power (TDP).
• Reduced memory bandwidth pressure, as lower-bit data transfers faster.
• Support for larger batch sizes or more complex models within fixed memory budgets. This is essential for scaling data processing in data centers and reducing cloud inference costs.

Quantizing raw datasets—such as sensor telemetry, medical images, or audio samples—before storage or transmission conserves critical resources in edge and IoT networks.

• Storage Efficiency: Converting FP32 sensor data to INT16 can halve storage requirements, enabling longer data retention on devices.
• Bandwidth Reduction: Transmitting quantized data over low-power wide-area networks (LPWAN) like LoRaWAN or NB-IoT reduces latency and power use.
• In-Memory Processing: Quantized data structures allow more extensive datasets to be cached in RAM for rapid access by on-device models, a key technique for edge-specific RAG systems.

Quantization is not a one-size-fits-all process; it requires co-design with target hardware. Different strategies are applied based on the accelerator:

• Weight-Only Quantization: For memory-bound applications, only weights are quantized to INT8, while activations remain in FP16.
• Dynamic Range Quantization: Activations are quantized on-the-fly during inference, ideal for models with highly variable activation ranges.
• Per-Channel Quantization: Weights are quantized with separate scaling factors for each output channel, yielding higher accuracy on GPUs and NPUs. This co-design is central to TinyML deployment on microcontrollers.

Data compression is the process of encoding information using fewer bits than the original representation. Unlike quantization, which reduces numerical precision, compression focuses on eliminating statistical redundancy.

• Lossless vs. Lossy: Lossless (e.g., GZIP, Zstandard) allows perfect reconstruction; lossy (e.g., JPEG, MP3) permanently discards less critical information for greater size reduction.
• Use Case: Critical for reducing the storage footprint and transmission bandwidth of large datasets, especially for over-the-air updates to edge devices.
• Combined with Quantization: Often used in sequence—first quantizing model weights to lower precision, then applying compression algorithms for final deployment.

Dimensionality reduction is a set of techniques for reducing the number of random variables (features) in a dataset while preserving its essential structure. It operates on the feature space, not the numerical precision of individual values.

• Core Methods: Includes Principal Component Analysis (PCA), which finds orthogonal axes of maximum variance, and t-SNE or UMAP for non-linear, visualization-focused reduction.
• Purpose: Mitigates the 'curse of dimensionality,' reduces training time, decreases memory usage, and can help remove noise.
• Edge Relevance: Enables more compact feature representations, which are crucial for efficient on-device inference and storage of processed data.

Data pruning is the process of removing redundant, noisy, or low-quality samples from a training dataset. The goal is to create a smaller, higher-quality dataset that trains models more efficiently and improves generalization.

• Pruning Criteria: Samples can be removed based on metrics like training loss (easy-to-learn samples), memorization score, or embedding similarity (redundant samples).
• Impact: Directly reduces the computational cost of training passes and can improve model robustness by filtering out mislabeled or outlier data.
• Synergy with Quantization: A pruned dataset requires less memory, which complements the memory savings achieved by quantizing the model that trains on it.

Core-set selection is a formal data subset selection method that aims to identify a small, representative subset of a large dataset. The core-set approximates the full dataset's statistical or geometric properties for efficient model training.

• Mathematical Foundation: Often based on submodular optimization or geometric covering to ensure the selected subset maximally represents the data distribution.
• Application: Used for active learning initialization, dataset distillation, and enabling federated learning with efficient client sampling.
• Edge Training: Essential for on-device training scenarios where only a highly informative subset of locally generated data can be used for model updates.

Data distillation (or dataset condensation) is a technique for synthesizing a small, informative, artificial dataset. When used for training, this synthetic set yields model performance comparable to training on the original, much larger dataset.

• Mechanism: Typically involves a bi-level optimization process where synthetic data parameters are updated to minimize the difference between gradients (or loss landscapes) produced by the synthetic and real data.
• Extreme Compression: Can achieve compression ratios of 1000:1 or more, creating a 'dataset in a bottle.'
• Edge Paradigm: Enables the deployment of a potent, tiny training dataset directly onto an edge device for continual learning, bypassing the need to store massive raw data.

Feature engineering is the process of using domain knowledge to create new, more effective input features (predictors) from raw data. Well-engineered features are often more compact and informative, reducing the burden on the model.

• Goals: Improve model accuracy, interpretability, and training efficiency. Good features can allow for simpler, smaller models.
• Edge-Specific Tactics: Includes creating statistical aggregates (means, variances over time windows), frequency-domain features (FFT coefficients), or domain-specific embeddings that are low-dimensional.
• Pre-Quantization Step: Effective feature engineering can reduce the input dimensionality and dynamic range, making subsequent quantization more stable and less lossy.