TensorFlow Lite Mobile App Development
We integrate TensorFlow Lite into iOS and Android—from conversion and quantization to delegate selection and OTA updates. With over 50 projects completed, we specialize in on-device ML: object recognition, image classification, and audio processing. Below is concrete technical experience from real-world cases.
Why Choose TFLite for On-Device ML?
TensorFlow Lite gives full control over the model: you decide which delegate to use, quantization level, and loading method. Accuracy loss after quantization is 1-3% with proper tuning, while CPU inference speed increases by 20-40%. Unlike cloud APIs, on-device ML is network-independent, protects user data, and eliminates transmission latency. Companies switching from cloud inference save over 60% on server costs.
Problems We Solve: Delegates and Performance
TfLiteGpuDelegateV2 on Android only benefits models with heavy convolutions (EfficientDet, MobileNet SSD). On lightweight models (MobileNetV2 with 224×224 input), the GPU delegate is slower than CPU—we profiled on Xiaomi Redmi Note 11: CPU 78 ms, GPU 112 ms (CPU is 1.4x faster). The takeaway: always measure on target devices, not flagships.
The NNAPI delegate (NnApiDelegate) theoretically uses hardware accelerators (DSP, NPU), but operation support is uneven. If the model contains non-standard ops (e.g., custom squeeze-excitation blocks), NNAPI silently falls back to CPU. Always log InterpreterApi.Options.setNumThreads and check via Interpreter.getSignatureInputs() which operations actually run on the accelerator.
On iOS, TFLite uses the CoreMLDelegate—a wrapper over Core ML. If the target is iOS 12+, CoreMLDelegate automatically uses the Neural Engine for supported layers. Unsupported layers fall back to the CPU interpreter. Mixed execution introduces unpredictable latency without profiling.
TFLite Delegate Comparison on Mobile Devices
| Delegate | When Effective | Typical Latency | Risks |
|---|---|---|---|
| CPU | Lightweight models (MobileNetV2) | 80-100 ms (Snapdragon 778G) | No acceleration |
| GPU | Heavy convolutions (EfficientDet) | 50-70 ms (Adreno 640) | Data transfer overhead |
| NNAPI | Compatible models, DSP/NPU | 18-40 ms (Pixel 7) | Incomplete operation support |
| CoreML | iOS 12+, neural network layers | 15-30 ms (iPhone 13) | Mixed execution |
Our benchmarks show that GPU delegate can be 1.5-2x faster than CPU on models like EfficientDet, but CPU leads by 1.2x on MobileNetV2.
How to Optimize the Model Before Deployment?
Quantization is mandatory for mobile. Three options:
- Post-training dynamic range quantization: simplest, weights compressed to INT8, activations remain float. Model size reduces ~4x, speed increases 20-40% on CPU.
- Post-training integer quantization: weights and activations in INT8, requires calibration dataset. Needed for NNAPI and Edge TPU.
- Quantization-aware training (QAT): best accuracy with INT8, but requires retraining.
Industry rule: always profile quantized models on target devices.
| Quantization Type | Model Size | Inference (CPU) | Accuracy |
|---|---|---|---|
| float32 | 100% | 1x | Baseline |
| dynamic range int8 | ~25% | 1.2-1.4x | 1-2% loss |
| full integer int8 | ~25% | 1.5-2x | 1-3% loss |
| QAT int8 | ~25% | 1.5-2x | 0.5-1% loss |
Full integer quantization increases inference speed by up to 2x compared to float32.
Case study: A plant recognition app (EfficientNetB0 classifier, 29 MB float32). After full integer quantization—7.4 MB, inference with NNAPI on Pixel 7—18 ms vs 95 ms on float32 CPU (5.3x faster). On Snapdragon 778G with NNAPI, we had to fall back to CPU due to unsupported LEAKY_RELU operation—added fallback via NnApiDelegate.Options.setAllowFp16PrecisionForFp32.
Model Optimization Checklist
- Select quantization type for target delegate.
- Calibrate full integer quantization on a representative dataset.
- Profile on 3-5 devices of different tiers.
- Implement fallback strategy for unsupported operations.
- Test accuracy on a test set.
What's Included in the Work
- Analysis and conversion—load model from TensorFlow/Keras, PyTorch (via ONNX), choose format (float32/int8/float16).
- Delegate selection—profile on 3-5 real devices, determine optimal delegate (CPU/GPU/NNAPI/CoreML).
- Code integration—use Task Library (ImageClassifier, ObjectDetector) for Android, wrap in actor for iOS with thread-safety.
- OTA updates—download model via URL with SHA-256 verification, manage via Firebase Remote Config.
- Testing—load testing, accuracy verification on test set.
- Documentation and training—model update guide, support contacts.
For an accurate evaluation of your model, contact us—we'll propose the optimal solution.
Integration into the App
On Android, we use org.tensorflow:tensorflow-lite + org.tensorflow:tensorflow-lite-gpu via Gradle. For Task Library support (ImageClassifier, ObjectDetector), org.tensorflow:tensorflow-lite-task-vision handles image preprocessing (resize, normalization), eliminating boilerplate.
On iOS, we use CocoaPods pod 'TensorFlowLiteSwift' or Swift Package Manager (since TFLite 2.13). Inference is wrapped in an actor for thread-safety:
actor TFLiteInferenceService { private let interpreter: Interpreter func classify(pixelBuffer: CVPixelBuffer) throws -> [Float] { ... } } Model loading from bundle or URL with SHA-256 verification. For OTA updates, Firebase Remote Config provides the model URL, and download uses URLSession.downloadTask in the background.
Timeline
Integration of a ready TFLite model with delegate selection and basic optimization—from 1 week. Full cycle including conversion, quantization, testing on target devices, and OTA updates—2-3 weeks. Pricing is individual after analyzing the model and requirements. Typical cost ranges from $1,500 to $4,000 for basic integration.
Contact us—we'll evaluate your model and propose an optimal solution within 1-2 days. We guarantee transparency at every stage. Request a model optimization consultation.