Choosing TensorFlow Lite Quantization for Android CNNs: A Decision Guide

The Decision: Balancing Size, Latency, and Accuracy

When deploying a Keras CNN to Android edge devices, you face a trade-off between model size, inference latency, and prediction accuracy. The goal is to shrink the model under 20MB while keeping latency under 50ms on mid-range ARM CPUs, with no more than 2% accuracy drop compared to the original float32 model.

Quantization Options Compared

Option	Size vs Float32	Latency Trend	Accuracy Impact	Requirements
Float32 baseline	1x	baseline	none	no conversion
Float16	~0.5x	similar to float	minimal	converter optimization, hardware support
Dynamic Range Quantization	~0.5x	lower CPU	small	weights INT8, activations float
Full Integer Quantization	~0.25x	lowest CPU	moderate	representative calibration dataset, ops supported

Key Trade-offs Explained

Float32 preserves accuracy perfectly but typically produces models larger than 20MB and may exceed the 50ms latency budget on mid-range devices.

Float16 halves model size with minimal accuracy loss. However, latency improvements depend on whether the device's NNAPI or GPU delegate supports native fp16 operations.

Dynamic Range Quantization converts weights to INT8 while keeping activations in float. This reduces size and improves CPU-bound latency without requiring a calibration dataset. Accuracy impact is usually negligible for CNNs with ReLU activations.

Full Integer Quantization converts both weights and activations to INT8, offering the smallest footprint and lowest latency. The catch: you must provide a representative dataset for calibration, and ops without INT8 kernels will fall back to float, potentially breaking the integer-only pipeline.

Implementation: Full Integer Quantization

Below is a concrete pattern for full integer quantization. Run this in a Python environment with access to the same SavedModel used for deployment.

import tensorflow as tf

# Step 1: Define a representative dataset generator
# Must yield batches matching training input shape and dtype

def representative_dataset():
    for _ in range(100):
        # Replace with actual data loader from training pipeline
        data = next(data_iterator)  # shape: (1, H, W, C)
        yield [data.astype(tf.float32)]

# Step 2: Create converter and set optimization flags
converter = tf.lite.TFLiteConverter.from_saved_model('/path/to/saved_model')
converter.optimizations = [tf.lite.Optimize.DEFAULT]

# Step 3: Enable full integer quantization
converter.representative_dataset = representative_dataset
converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
converter.inference_input_type = tf.uint8
converter.inference_output_type = tf.uint8

# Step 4: Convert and save
quantized_tflite = converter.convert()
with open('model_quant_int8.tflite', 'wb') as f:
    f.write(quantized_tflite)

Validation Checklist

1. Size check: Verify the output file is under 20MB. Shell: ls -lh model_quant_int8.tflite
2. Accuracy check: Load both models in Python, run inference on a held-out validation set, and compare predictions. Use tflite.Interpreter for the quantized model.
3. Operator support check: Inspect the TFLite model metadata for any "unsupported op" warnings. Integer-only ops should show INT8 input/output tensors.
4. Latency check: Deploy to a target Android device and run the TensorFlow Lite benchmark tool: benchmark_model --graph=model_quant_int8.tflite --num_threads=4

Common Pitfalls and Mitigations

• Representative dataset coverage: If the calibration data doesn't reflect real-world inputs, accuracy can degrade sharply. Use data that spans the full range of expected images, lighting conditions, and preprocessing variations.
• Custom layer fallback: Layers without INT8 kernels (e.g., certain padding or normalization ops) will execute in float, adding overhead. Test with interpreter.get_tensor_details() to confirm all tensors are INT8.
• Hardware variance: NNAPI behavior differs across Android versions and SoCs. A model that meets latency on a Pixel device may be slower on a budget phone. Always validate on the slowest target device in your fleet.

Final Recommendation

If your validation shows less than 2% accuracy loss and latency under 50ms, Full Integer Quantization is the optimal choice. If accuracy degrades beyond the threshold, fall back to Float16 or Dynamic Range Quantization and re-measure. Document the chosen quantization level and the representative dataset used, as this information is critical for future model updates.