On-device ML feature ideas for your app
☐ Classify a photo the user takes (e.g. plant, receipt, document)
☐ Detect if text is likely spam before sending
☐ Recognise walking vs running from the accelerometer
☐ Suggest a category for a new expense
Pick one that saves users a step.

Is on-device ML right for this feature?
Needs to work offline?          Y / N
Uses private data (photos, text)?  Y / N
Needs instant response?          Y / N
Model can be small (< tens of MB)? Y / N
Mostly Y → good fit for on-device ML

import tensorflow as tf
from tensorflow import keras

# Example: classify 3 activities from 50 accelerometer features
model = keras.Sequential([
    keras.Input(shape=(50,)),
    keras.layers.Dense(64, activation="relu"),
    keras.layers.Dense(32, activation="relu"),
    keras.layers.Dense(3, activation="softmax"),
])
model.compile(optimizer="adam",
              loss="sparse_categorical_crossentropy",
              metrics=["accuracy"])
# model.fit(x_train, y_train, validation_data=(x_val, y_val), epochs=20)

import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_keras_model(model)
converter.optimizations = [tf.lite.Optimize.DEFAULT]   # dynamic range quantisation
tflite_model = converter.convert()

with open("activity.tflite", "wb") as f:
    f.write(tflite_model)
print(len(tflite_model) / 1024, "KB")

import android.content.Context
import org.tensorflow.lite.Interpreter
import java.io.FileInputStream
import java.nio.MappedByteBuffer
import java.nio.channels.FileChannel

fun loadModel(context: Context, name: String): MappedByteBuffer {
    val fd = context.assets.openFd(name)
    FileInputStream(fd.fileDescriptor).use { stream ->
        return stream.channel.map(FileChannel.MapMode.READ_ONLY, fd.startOffset, fd.declaredLength)
    }
}

class ActivityClassifier(context: Context) {
    private val interpreter = Interpreter(loadModel(context, "activity.tflite"))

    fun predict(features: FloatArray): FloatArray {
        val input = arrayOf(features)              // shape [1, 50]
        val output = arrayOf(FloatArray(3))        // shape [1, 3]
        interpreter.run(input, output)
        return output[0]
    }

    fun close() = interpreter.close()
}

// app/build.gradle.kts
android {
    androidResources {
        noCompress += "tflite"
    }
}

dependencies {
    // Check the TensorFlow Lite / LiteRT docs for the current artifact and version
    implementation("org.tensorflow:tensorflow-lite:2.16.1")
}

Weeks 1-2: Python and NumPy refresh, ML basics (train/validation, overfitting)
Weeks 3-4: Keras models for tabular and image data
Week 5:    Fine-tune a pretrained image model on your own classes
Week 6:    Convert to .tflite, quantise, compare accuracy
Week 7:    Integrate in an Android app with the interpreter
Week 8:    Polish: background inference, error handling, write-up

Model card for your app
Task: ____
Training data: ____ (source, size, classes)
Validation accuracy: ____  After quantisation: ____
Model size: ____ KB
Input shape and preprocessing: ____
Known limitations: ____

☐ .tflite in assets, not compressed
☐ Interpreter loaded once and reused
☐ Inference off the main thread
☐ Input preprocessing matches training
☐ Interpreter closed when no longer needed
☐ Fallback if the model fails to load