Introduction

When you train a TensorFlow model from scratch and try to run it with the TensorFlow Classify Android example, you will often hit runtime exceptions like IllegalArgumentException, IOException, or input/output tensor shape mismatches. These errors happen because the example app expects a specific model format, input shape, and label file structure that a custom-trained model may not match. This article walks through the most common causes and provides concrete fixes.

Understanding the Android Classify Example

The TensorFlow Android classify example (and its TensorFlow Lite successor) is built to work with models like MobileNet or Inception. These models expect a fixed input size (commonly 224x224x3 or 299x299x3), produce a fixed number of output classes, and ship with a labels file that maps output indices to human-readable names.

When you substitute your own model, every one of these assumptions can break. The example code does not dynamically adapt to a different model's requirements.

Common Exceptions and Their Causes

1. Input Tensor Shape Mismatch

The most frequent exception looks like this:

java.lang.IllegalArgumentException: Cannot copy to a TensorFlowLite
tensor (input_1) with 150528 bytes from a Java Buffer with 602112 bytes.

This happens when the input image buffer size does not match what the model expects. The example app might prepare a 224x224x3 float buffer (224 * 224 * 3 * 4 = 602,112 bytes), but your model expects a different resolution.

Fix: Update the image preprocessing to match your model's input dimensions.

1// In your classifier class, set these to match your model
2private static final int INPUT_WIDTH = 128;
3private static final int INPUT_HEIGHT = 128;
4private static final int NUM_CHANNELS = 3;
5private static final int BATCH_SIZE = 1;
6
7// Resize the bitmap to match
8Bitmap resizedBitmap = Bitmap.createScaledBitmap(
9    originalBitmap, INPUT_WIDTH, INPUT_HEIGHT, true
10);

You can verify what your model expects by inspecting it with Python before deploying:

1import tensorflow as tf
2
3interpreter = tf.lite.Interpreter(model_path="model.tflite")
4interpreter.allocate_tensors()
5
6input_details = interpreter.get_input_details()
7output_details = interpreter.get_output_details()
8
9print("Input shape:", input_details[0]['shape'])
10print("Input dtype:", input_details[0]['dtype'])
11print("Output shape:", output_details[0]['shape'])
12print("Output dtype:", output_details[0]['dtype'])

2. Output Label Count Mismatch

If your model classifies 10 categories but the labels file contains 1,000 entries (or vice versa), the app crashes or produces garbage results.

java.lang.ArrayIndexOutOfBoundsException: length=10; index=999

Fix: Make sure your labels.txt file has exactly as many lines as your model has output classes, in the correct order.

1cat
2dog
3bird
4fish
5horse
6cow
7sheep
8rabbit
9hamster
10turtle

Place this file in the assets folder of your Android project and update the code to reference it:

private static final String LABEL_FILE = "labels.txt";
private static final int NUM_CLASSES = 10;

3. Model File Not Found or Corrupted

java.io.IOException: Error reading model file

This error usually means the .tflite file is not in the correct location, the filename in code does not match the actual file, or the file was corrupted during transfer.

Fix: Place the model file in app/src/main/assets/ and verify the path in your code:

1private static final String MODEL_FILE = "model.tflite";
2
3// Load from assets
4MappedByteBuffer modelBuffer = loadModelFile(activity, MODEL_FILE);

Check the file size after copying. If it is zero bytes or significantly smaller than expected, the file was not copied correctly.

4. Quantization Type Mismatch

The example app may use a quantized model (uint8 inputs) while your custom model uses float32 inputs, or the reverse.

java.lang.IllegalArgumentException: DataType (2) of input data
does not match with the DataType (1) of model inputs.

Fix: Either quantize your model to match, or update the app to use float inputs.

To convert a SavedModel to a float TFLite model:

1import tensorflow as tf
2
3converter = tf.lite.TFLiteConverter.from_saved_model("saved_model_dir")
4# For float model (no quantization)
5tflite_model = converter.convert()
6
7with open("model.tflite", "wb") as f:
8    f.write(tflite_model)

To apply post-training quantization:

1converter = tf.lite.TFLiteConverter.from_saved_model("saved_model_dir")
2converter.optimizations = [tf.lite.Optimize.DEFAULT]
3quantized_model = converter.convert()
4
5with open("model_quantized.tflite", "wb") as f:
6    f.write(quantized_model)

Then update the Android code to use the correct input type. For float models, the input buffer should be a ByteBuffer of floats. For quantized models, it should be a ByteBuffer of unsigned bytes.

5. Normalization Mismatch

Even when shapes and types match, incorrect normalization produces wildly wrong predictions without throwing an exception. If your model was trained with pixel values in the range [0, 1] but the app feeds values in [0, 255], every prediction will be wrong.

1// Normalize to [0, 1] for a float model
2float pixelValue = (float) Color.red(pixel) / 255.0f;
3
4// Or normalize to [-1, 1] for models trained with that range
5float pixelValue = (Color.red(pixel) - 127.5f) / 127.5f;

Check how your training pipeline preprocessed images and replicate the same normalization in the Android app.

Common Pitfalls

• Training with one version of TensorFlow and converting with another. Version mismatches between the training framework and the TFLite converter can produce invalid models. Use the same TensorFlow version for both.
• Forgetting to include all custom ops when converting. If your model uses operations not built into TFLite by default, you need to add them through the Select TF Ops package.
• Not testing the converted model in Python before deploying to Android. Always run inference in Python first to confirm the model produces correct results after conversion.
• Hardcoding image dimensions from the original example without updating them for your model.
• Ignoring the difference between NHWC and NCHW tensor layouts. TFLite typically uses NHWC (batch, height, width, channels), but some training configurations produce NCHW models.

Summary

Most exceptions when running a custom TensorFlow model in the Android classify example come from mismatches between what the app sends and what the model expects. Inspect your model's input and output tensors with the TFLite Interpreter in Python. Match the image dimensions, normalization range, data type (float vs quantized), and label count in your Android code. Test inference in Python before deploying to mobile, and use the same TensorFlow version for training and conversion.