DEV Community

vmodal_ai
vmodal_ai

Posted on

TensorFlow Lite Android Tutorial: Build Fast Offline AI Apps with Kotlin

#tensorflow #android #kotlin #ai


Artificial Intelligence is transforming mobile applications, from real-time object detection and image classification to speech recognition and OCR. However, sending data to cloud servers can increase latency, consume bandwidth, and raise privacy concerns.

TensorFlow Lite (TFLite) solves these challenges by enabling machine learning models to run directly on Android devices. In this tutorial, you'll learn how to integrate TensorFlow Lite into an Android app using Kotlin and perform on-device inference.

What you'll learn

  • What TensorFlow Lite is
  • Add TensorFlow Lite to an Android project
  • Load a .tflite model
  • Prepare input data
  • Run inference
  • Process prediction results
  • Best practices for production apps

Why TensorFlow Lite?

TensorFlow Lite is Google's lightweight machine learning framework designed specifically for mobile and edge devices.

Benefits

  • 🚀 Fast on-device inference
  • 📱 Works offline
  • 🔒 Better user privacy
  • ⚡ Low latency
  • 🔋 Optimized for battery efficiency
  • 🤖 Supports image, audio, text, and custom ML models

Typical use cases include:

  • Image Classification
  • Object Detection
  • OCR
  • Face Recognition
  • Pose Detection
  • Voice Recognition
  • Chatbots
  • Medical AI
  • Smart Camera Apps

Prerequisites

You'll need:

  • Android Studio
  • Kotlin
  • Android SDK
  • A TensorFlow Lite model (model.tflite)
  • Basic Android development knowledge

Step 1: Add TensorFlow Lite

Add the TensorFlow Lite dependency to your build.gradle file.

dependencies {
    implementation("org.tensorflow:tensorflow-lite:2.17.0")
}
Enter fullscreen mode Exit fullscreen mode

Then sync your project.

Step 2: Add the Model

Create an assets folder.

app/
 └── src/
      └── main/
           └── assets/
                └── model.tflite
Enter fullscreen mode Exit fullscreen mode

Place your TensorFlow Lite model inside the assets directory.

Step 3: Load the Model

Read the model from assets.

private fun loadModelFile(context: Context): MappedByteBuffer {
    val fileDescriptor = context.assets.openFd("model.tflite")
    val inputStream = FileInputStream(fileDescriptor.fileDescriptor)
    val channel = inputStream.channel

    return channel.map(
        FileChannel.MapMode.READ_ONLY,
        fileDescriptor.startOffset,
        fileDescriptor.declaredLength
    )
}
Enter fullscreen mode Exit fullscreen mode

Initialize the interpreter.

val interpreter = Interpreter(loadModelFile(this))
Enter fullscreen mode Exit fullscreen mode

The interpreter loads your machine learning model into memory.

Step 4: Prepare Input Data

Most computer vision models expect normalized floating-point values.

val input = Array(1) {
    Array(224) {
        Array(224) {
            FloatArray(3)
        }
    }
}
Enter fullscreen mode Exit fullscreen mode

For production applications, convert a Bitmap into this tensor while applying the same preprocessing used during model training.

Step 5: Prepare the Output

Create an output array.

val output = Array(1) {
    FloatArray(1000)
}
Enter fullscreen mode Exit fullscreen mode

The output size depends on your model.

For example:

  • 2 classes
  • 10 classes
  • 1000 ImageNet classes

Step 6: Run Inference

Execute the model.

interpreter.run(input, output)
Enter fullscreen mode Exit fullscreen mode

TensorFlow Lite processes the input and fills the output array with prediction scores.

Step 7: Process the Results

Retrieve the predicted class.

val prediction = output[0]

val maxIndex = prediction.indices.maxByOrNull {
    prediction[it]
}

println("Predicted class: $maxIndex")
Enter fullscreen mode Exit fullscreen mode

You can map the index to human-readable labels stored in a text file.

Optimize Performance

For the best performance:

  • Load the model only once.
  • Reuse the interpreter.
  • Run inference using Kotlin Coroutines.
  • Resize images before inference.
  • Quantize models when possible.
  • Avoid allocating large arrays repeatedly.

These practices improve both speed and memory usage.

Common Errors

Model Not Found 

FileNotFoundException
Enter fullscreen mode Exit fullscreen mode

Verify the model exists inside the assets folder.

Wrong Input Shape 

Cannot copy between tensors
Enter fullscreen mode Exit fullscreen mode

Ensure the input tensor matches the model's expected dimensions.

Slow Predictions

Large models can increase inference time.

Solutions include:

  • Quantization
  • Smaller model architectures
  • Hardware acceleration
  • Image resizing

Real-World Applications

TensorFlow Lite powers many Android applications, including:

  • 📷 Document scanners
  • 🚗 License plate recognition
  • 🌿 Plant disease detection
  • 🏥 Medical diagnosis assistance
  • 🛒 Product recognition
  • 😊 Face detection
  • 🎙️ Speech recognition
  • 🧠 AI-powered camera filters
  • 📦 Barcode scanning

Best Practices

  • Keep inference off the main thread.
  • Cache the interpreter.
  • Match preprocessing with model training.
  • Validate model inputs before inference.
  • Test on multiple Android devices.
  • Monitor memory usage when processing large images.

TensorFlow Lite vs ONNX Runtime

Feature TensorFlow Lite ONNX Runtime
Offline AI ✅ ✅
Android Support ✅ Excellent ✅ Excellent
Google Ecosystem ✅ Native ❌
PyTorch Models Conversion Required Native ONNX
TensorFlow Models ✅ Best Choice Requires Conversion
Performance Excellent Excellent

If your model was trained using TensorFlow, TensorFlow Lite is usually the easiest deployment option. If you work with multiple frameworks, ONNX Runtime offers greater flexibility.

Conclusion

TensorFlow Lite makes it easy to deploy machine learning models directly on Android devices, enabling fast, offline, and privacy-friendly AI experiences. Whether you're building an image classifier, OCR scanner, object detector, or voice assistant, TensorFlow Lite provides a reliable and efficient runtime optimized for mobile devices.

As AI becomes a standard feature in modern mobile apps, understanding TensorFlow Lite is an essential skill for Android developers who want to deliver intelligent, responsive, and secure applications.

Frequently Asked Questions

What is TensorFlow Lite?

TensorFlow Lite is Google's lightweight machine learning framework for running AI models on mobile and edge devices.

Does TensorFlow Lite work offline?

Yes. Models are executed locally on the device without requiring an internet connection.

Can I use my own trained model?

Absolutely. You can convert TensorFlow models to the .tflite format using the TensorFlow Lite Converter.

Is TensorFlow Lite free?

Yes. TensorFlow Lite is open source and free to use.


SDK Flutter: https://github.com/v-modal/vmodal_sdk_flutter
SDK Android: https://github.com/v-modal/vmodal_sdk_android
Discord: https://discord.gg/K72z28KUx

Tags

android kotlin tensorflow machinelearning ai mobiledevelopment

Top comments (0)