TFLite Quantization

Converts a pre-trained floating-point model to an integer model without retraining. This is the most common workflow for rapid deployment.

• Calibration: Uses a small, representative dataset to observe activation ranges and determine optimal scale and zero-point values.
• Target Precision: Primarily targets INT8 for weights and activations, offering a 4x model size reduction and significant speedup on integer-only hardware.
• Output: Produces a .tflite file with quantized weights and, for full integer models, quantized activations.

Simulates quantization effects during training to produce models that maintain higher accuracy when converted to integer format.

• Fake Quantization Nodes: Insert fake quantization ops into the training graph. These nodes round and clip values during the forward pass to mimic INT8 precision but maintain full-precision gradients for backward passes using the Straight-Through Estimator (STE).
• Higher Fidelity: Models learn to adapt to the quantization noise, typically recovering accuracy closer to the original FP32 model compared to Post-Training Quantization.
• Workflow: Requires retraining or fine-tuning the model, making it more involved but more accurate.

A lightweight form of Post-Training Quantization that quantizes weights to INT8 but keeps activations in FP32.

• On-the-Fly Scaling: The scaling factor for activations is calculated dynamically at runtime based on the observed range. This avoids the need for a calibration dataset.
• Use Case: Provides a fast path to a smaller model size (from weight quantization) and some CPU speedup, but does not enable acceleration on integer-only hardware like DSPs or NPUs.
• Simplicity: Ideal for a quick first optimization step with minimal setup.

Quantizes both weights and activations to integer values, enabling execution on integer-only hardware accelerators.

• Requires Calibration: A mandatory calibration step determines static scale/zero-point values for all tensors.
• Integer-Only Kernels: The TFLite runtime uses optimized integer arithmetic kernels, eliminating floating-point operations entirely. This is critical for microcontrollers, DSPs, and Edge TPUs.
• Input/Output Handling: Requires model inputs and outputs to be integers or a dedicated dequantization step, which must be managed by the application.

Defines the granularity at which quantization parameters are applied, impacting accuracy and hardware compatibility.

• Per-Tensor Quantization: A single scale and zero-point is applied to an entire tensor. This is simpler and widely supported.
• Per-Channel Quantization: A unique scale and zero-point is applied to each channel of a weight tensor (e.g., each output channel of a convolution layer). This accounts for variation across channels and typically yields higher accuracy but requires hardware support (e.g., modern ARM CPUs, NPUs).
• TFLite Support: The toolchain supports both, with per-channel being the default for convolutional and fully-connected layer weights in integer models.

A mixed-precision scheme that uses 16-bit integers for activations and 8-bit integers for weights.

• Accuracy vs. Speed Trade-off: Offers higher accuracy than INT8-only quantization, especially for models sensitive to precision, while still providing significant performance benefits over FP32.
• Hardware Support: Targets hardware with native support for 16-bit integer arithmetic operations. Provides a middle-ground option when INT8 accuracy loss is too high but FP32 is too slow or large.

Dynamic Range Quantization is a specific PTQ method supported by TFLite that offers a balance of ease-of-use and performance.

• Weight-Only: Converts weights to INT8 statically.
• Dynamic Activations: Activation tensors are quantized on-the-fly during inference based on their observed range. This avoids the need for a calibration dataset.
• Trade-off: Provides a smaller model size and some speedup (as weights are 4x smaller), but the runtime cost of dynamically quantizing activations means it's generally slower than full Static Quantization. It's a good starting point for rapid prototyping.