Introduction

When people ask how to reduce TensorFlow size on Android, they are usually talking about two different things: shrinking the model file and shrinking the native runtime that ships inside the app. You normally need to work on both if you want a meaningful APK or AAB size reduction.

The biggest wins usually come from converting to TensorFlow Lite, quantizing the model, and packaging only the native binaries your app actually needs.

Reduce the Model Size First

A full TensorFlow model is usually too heavy for a mobile app. For Android deployment, the standard move is to convert it to TensorFlow Lite:

1import tensorflow as tf
2
3model = tf.keras.Sequential(
4    [
5        tf.keras.layers.Input(shape=(8,)),
6        tf.keras.layers.Dense(16, activation="relu"),
7        tf.keras.layers.Dense(4, activation="softmax"),
8    ]
9)
10
11converter = tf.lite.TFLiteConverter.from_keras_model(model)
12tflite_model = converter.convert()
13
14with open("model.tflite", "wb") as f:
15    f.write(tflite_model)

That alone often cuts size, but quantization is where the next big reduction happens.

Use Quantization

Post-training quantization can shrink weights from float32 to smaller formats such as float16 or int8:

1import tensorflow as tf
2
3converter = tf.lite.TFLiteConverter.from_saved_model("saved_model")
4converter.optimizations = [tf.lite.Optimize.DEFAULT]
5tflite_quant_model = converter.convert()
6
7with open("model_quant.tflite", "wb") as f:
8    f.write(tflite_quant_model)

Why this helps:

• smaller model file
• lower memory usage
• often faster inference on mobile hardware

The tradeoff is possible accuracy loss, so always measure the result on representative data instead of assuming the smaller model is automatically good enough.

Avoid Shipping Unused Native ABIs

Even a compact .tflite model will not help much if the app ships native libraries for every CPU architecture under the sun. In Gradle, restrict the ABIs you actually support:

1android {
2    defaultConfig {
3        ndk {
4            abiFilters "arm64-v8a", "armeabi-v7a"
5        }
6    }
7}

If you ship x86, x86_64, ARM 32-bit, and ARM 64-bit all at once, the package grows quickly. Limiting ABIs or using App Bundles lets Google Play deliver only the relevant native code to each device.

Minimize the Runtime Footprint

Not every model needs the same TensorFlow Lite operators. If your model can run with built-in TensorFlow Lite ops only, avoid extra delegate or flex packages that pull in more native code.

In other words:

• use TensorFlow Lite, not full TensorFlow
• avoid unnecessary select TensorFlow ops if conversion can be adjusted
• include delegates only when you really use them

This part is easy to overlook. Developers often optimize the model file but keep a heavier-than-needed inference runtime.

Compression Helps Distribution, Not Runtime Memory

You can compress a model for shipping, but once Android unpacks the app, the runtime still needs the real model bytes. Compression is useful for download size, yet it is not the same as true model optimization.

That is why quantization and architecture trimming are better first steps than relying on zip-style compression alone.

Measure Before and After

Do not optimize blindly. Track:

• '.tflite file size'
• native library size by ABI
• final APK or AAB size
• runtime accuracy and latency

Without those numbers, it is easy to save a few megabytes in one place while accidentally reintroducing more size somewhere else.

Common Pitfalls

• Trying to ship a full TensorFlow model when TensorFlow Lite is the intended mobile runtime.
• Quantizing the model and never checking whether the resulting accuracy is still acceptable.
• Shipping native libraries for ABIs you do not really support.
• Pulling in select TensorFlow ops or delegates without confirming the model requires them.
• Focusing only on compressed download size instead of the actual installed and runtime footprint.

Summary

• Convert the model to TensorFlow Lite before worrying about fine-grained packaging details.
• Use quantization for one of the biggest model-size reductions.
• Restrict Android ABIs or use App Bundles so users receive only the native code they need.
• Keep the TensorFlow Lite runtime lean by avoiding unnecessary ops and delegates.
• Measure model size, package size, latency, and accuracy together before deciding the optimization is successful.