Utilice un modelo personalizado de TensorFlow Lite en Android

Si tu aplicación usa modelos personalizados de TensorFlow Lite , puedes usar Firebase ML para implementar tus modelos. Al implementar modelos con Firebase, puedes reducir el tamaño de descarga inicial de tu aplicación y actualizar los modelos de aprendizaje automático de tu aplicación sin lanzar una nueva versión de tu aplicación. Y, con Remote Config y A/B Testing, puede servir dinámicamente diferentes modelos a diferentes conjuntos de usuarios.

Modelos TensorFlow Lite

Los modelos TensorFlow Lite son modelos ML que están optimizados para ejecutarse en dispositivos móviles. Para obtener un modelo de TensorFlow Lite:

Antes de que empieces

  1. Si aún no lo has hecho, agrega Firebase a tu proyecto de Android .
  2. En el archivo Gradle de su módulo (nivel de aplicación) (generalmente <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle ), agregue la dependencia para Firebase ML Biblioteca de descarga de modelos para Android. Recomendamos utilizar Firebase Android BoM para controlar el control de versiones de la biblioteca.

    Además, como parte de la configuración del descargador de modelos de Firebase ML, debes agregar el SDK de TensorFlow Lite a tu aplicación.

    dependencies {
        // Import the BoM for the Firebase platform
        implementation(platform("com.google.firebase:firebase-bom:32.7.2"))
    
        // Add the dependency for the Firebase ML model downloader library
        // When using the BoM, you don't specify versions in Firebase library dependencies
        implementation("com.google.firebase:firebase-ml-modeldownloader")
    // Also add the dependency for the TensorFlow Lite library and specify its version implementation("org.tensorflow:tensorflow-lite:2.3.0")
    }

    Al usar Firebase Android BoM , su aplicación siempre usará versiones compatibles de las bibliotecas de Firebase Android.

    (Alternativa) Agregue dependencias de la biblioteca de Firebase sin usar la BoM

    Si elige no utilizar la BoM de Firebase, debe especificar cada versión de la biblioteca de Firebase en su línea de dependencia.

    Tenga en cuenta que si usa varias bibliotecas de Firebase en su aplicación, le recomendamos encarecidamente usar la BoM para administrar las versiones de la biblioteca, lo que garantiza que todas las versiones sean compatibles.

    dependencies {
        // Add the dependency for the Firebase ML model downloader library
        // When NOT using the BoM, you must specify versions in Firebase library dependencies
        implementation("com.google.firebase:firebase-ml-modeldownloader:24.2.3")
    // Also add the dependency for the TensorFlow Lite library and specify its version implementation("org.tensorflow:tensorflow-lite:2.3.0")
    }
    ¿Busca un módulo de biblioteca específico de Kotlin? A partir de octubre de 2023 (Firebase BoM 32.5.0) , tanto los desarrolladores de Kotlin como los de Java podrán depender del módulo de biblioteca principal (para más detalles, consulte las preguntas frecuentes sobre esta iniciativa ).
  3. En el manifiesto de su aplicación, declare que se requiere permiso de INTERNET:
    <uses-permission android:name="android.permission.INTERNET" />

1. Implementa tu modelo

Implementa tus modelos personalizados de TensorFlow usando Firebase console o los SDK de Firebase Admin Python y Node.js. Consulte Implementar y administrar modelos personalizados .

Después de agregar un modelo personalizado a tu proyecto de Firebase, puedes hacer referencia al modelo en tus aplicaciones usando el nombre que especificaste. En cualquier momento, puedes implementar un nuevo modelo de TensorFlow Lite y descargarlo en los dispositivos de los usuarios llamando a getModel() (ver más abajo).

2. Descargue el modelo en el dispositivo e inicialice un intérprete de TensorFlow Lite.

Para usar su modelo de TensorFlow Lite en su aplicación, primero use el SDK de Firebase ML para descargar la última versión del modelo en el dispositivo. Luego, cree una instancia de un intérprete de TensorFlow Lite con el modelo.

Para iniciar la descarga del modelo, llame al método getModel() del descargador de modelos, especificando el nombre que le asignó al modelo cuando lo cargó, si desea descargar siempre el último modelo y las condiciones bajo las cuales desea permitir la descarga.

Puede elegir entre tres comportamientos de descarga:

Tipo de descarga Descripción
MODELO_LOCAL Obtenga el modelo local del dispositivo. Si no hay ningún modelo local disponible, esto se comporta como LATEST_MODEL . Utilice este tipo de descarga si no está interesado en buscar actualizaciones de modelos. Por ejemplo, está utilizando Remote Config para recuperar nombres de modelos y siempre carga modelos con nombres nuevos (recomendado).
LOCAL_MODEL_UPDATE_IN_BACKGROUND Obtenga el modelo local del dispositivo y comience a actualizar el modelo en segundo plano. Si no hay ningún modelo local disponible, esto se comporta como LATEST_MODEL .
ULTIMO MODELO Consigue el último modelo. Si el modelo local es la última versión, devuelve el modelo local. De lo contrario, descargue el último modelo. Este comportamiento se bloqueará hasta que se descargue la última versión (no recomendado). Utilice este comportamiento solo en los casos en los que necesite explícitamente la última versión.

Debe deshabilitar la funcionalidad relacionada con el modelo (por ejemplo, atenuar u ocultar parte de su interfaz de usuario) hasta que confirme que el modelo se ha descargado.

Kotlin+KTX

val conditions = CustomModelDownloadConditions.Builder()
        .requireWifi()  // Also possible: .requireCharging() and .requireDeviceIdle()
        .build()
FirebaseModelDownloader.getInstance()
        .getModel("your_model", DownloadType.LOCAL_MODEL_UPDATE_IN_BACKGROUND,
            conditions)
        .addOnSuccessListener { model: CustomModel? ->
            // Download complete. Depending on your app, you could enable the ML
            // feature, or switch from the local model to the remote model, etc.

            // The CustomModel object contains the local path of the model file,
            // which you can use to instantiate a TensorFlow Lite interpreter.
            val modelFile = model?.file
            if (modelFile != null) {
                interpreter = Interpreter(modelFile)
            }
        }

Java

CustomModelDownloadConditions conditions = new CustomModelDownloadConditions.Builder()
    .requireWifi()  // Also possible: .requireCharging() and .requireDeviceIdle()
    .build();
FirebaseModelDownloader.getInstance()
    .getModel("your_model", DownloadType.LOCAL_MODEL_UPDATE_IN_BACKGROUND, conditions)
    .addOnSuccessListener(new OnSuccessListener<CustomModel>() {
      @Override
      public void onSuccess(CustomModel model) {
        // Download complete. Depending on your app, you could enable the ML
        // feature, or switch from the local model to the remote model, etc.

        // The CustomModel object contains the local path of the model file,
        // which you can use to instantiate a TensorFlow Lite interpreter.
        File modelFile = model.getFile();
        if (modelFile != null) {
            interpreter = new Interpreter(modelFile);
        }
      }
    });

Muchas aplicaciones inician la tarea de descarga en su código de inicialización, pero puede hacerlo en cualquier momento antes de necesitar usar el modelo.

3. Realizar inferencias sobre los datos de entrada.

Obtenga las formas de entrada y salida de su modelo

El intérprete del modelo TensorFlow Lite toma como entrada y produce como salida una o más matrices multidimensionales. Estas matrices contienen valores byte , int , long o float . Antes de poder pasar datos a un modelo o utilizar su resultado, debe conocer el número y las dimensiones ("forma") de las matrices que utiliza su modelo.

Si creó el modelo usted mismo, o si el formato de entrada y salida del modelo está documentado, es posible que ya tenga esta información. Si no conoce la forma y el tipo de datos de la entrada y salida de su modelo, puede usar el intérprete de TensorFlow Lite para inspeccionar su modelo. Por ejemplo:

Pitón

import tensorflow as tf

interpreter = tf.lite.Interpreter(model_path="your_model.tflite")
interpreter.allocate_tensors()

# Print input shape and type
inputs = interpreter.get_input_details()
print('{} input(s):'.format(len(inputs)))
for i in range(0, len(inputs)):
    print('{} {}'.format(inputs[i]['shape'], inputs[i]['dtype']))

# Print output shape and type
outputs = interpreter.get_output_details()
print('\n{} output(s):'.format(len(outputs)))
for i in range(0, len(outputs)):
    print('{} {}'.format(outputs[i]['shape'], outputs[i]['dtype']))

Salida de ejemplo:

1 input(s):
[  1 224 224   3] <class 'numpy.float32'>

1 output(s):
[1 1000] <class 'numpy.float32'>

Ejecute el intérprete

Después de haber determinado el formato de entrada y salida de su modelo, obtenga sus datos de entrada y realice cualquier transformación en los datos que sea necesaria para obtener una entrada con la forma correcta para su modelo.

Por ejemplo, si tiene un modelo de clasificación de imágenes con una forma de entrada de [1 224 224 3] valores de punto flotante, podría generar un ByteBuffer de entrada a partir de un objeto Bitmap como se muestra en el siguiente ejemplo:

Kotlin+KTX

val bitmap = Bitmap.createScaledBitmap(yourInputImage, 224, 224, true)
val input = ByteBuffer.allocateDirect(224*224*3*4).order(ByteOrder.nativeOrder())
for (y in 0 until 224) {
    for (x in 0 until 224) {
        val px = bitmap.getPixel(x, y)

        // Get channel values from the pixel value.
        val r = Color.red(px)
        val g = Color.green(px)
        val b = Color.blue(px)

        // Normalize channel values to [-1.0, 1.0]. This requirement depends on the model.
        // For example, some models might require values to be normalized to the range
        // [0.0, 1.0] instead.
        val rf = (r - 127) / 255f
        val gf = (g - 127) / 255f
        val bf = (b - 127) / 255f

        input.putFloat(rf)
        input.putFloat(gf)
        input.putFloat(bf)
    }
}

Java

Bitmap bitmap = Bitmap.createScaledBitmap(yourInputImage, 224, 224, true);
ByteBuffer input = ByteBuffer.allocateDirect(224 * 224 * 3 * 4).order(ByteOrder.nativeOrder());
for (int y = 0; y < 224; y++) {
    for (int x = 0; x < 224; x++) {
        int px = bitmap.getPixel(x, y);

        // Get channel values from the pixel value.
        int r = Color.red(px);
        int g = Color.green(px);
        int b = Color.blue(px);

        // Normalize channel values to [-1.0, 1.0]. This requirement depends
        // on the model. For example, some models might require values to be
        // normalized to the range [0.0, 1.0] instead.
        float rf = (r - 127) / 255.0f;
        float gf = (g - 127) / 255.0f;
        float bf = (b - 127) / 255.0f;

        input.putFloat(rf);
        input.putFloat(gf);
        input.putFloat(bf);
    }
}

Luego, asigne un ByteBuffer lo suficientemente grande como para contener la salida del modelo y pase el búfer de entrada y el búfer de salida al método run() del intérprete de TensorFlow Lite. Por ejemplo, para una forma de salida de [1 1000] valores de punto flotante:

Kotlin+KTX

val bufferSize = 1000 * java.lang.Float.SIZE / java.lang.Byte.SIZE
val modelOutput = ByteBuffer.allocateDirect(bufferSize).order(ByteOrder.nativeOrder())
interpreter?.run(input, modelOutput)

Java

int bufferSize = 1000 * java.lang.Float.SIZE / java.lang.Byte.SIZE;
ByteBuffer modelOutput = ByteBuffer.allocateDirect(bufferSize).order(ByteOrder.nativeOrder());
interpreter.run(input, modelOutput);

La forma de utilizar la salida depende del modelo que esté utilizando.

Por ejemplo, si está realizando una clasificación, como siguiente paso, puede asignar los índices del resultado a las etiquetas que representan:

Kotlin+KTX

modelOutput.rewind()
val probabilities = modelOutput.asFloatBuffer()
try {
    val reader = BufferedReader(
            InputStreamReader(assets.open("custom_labels.txt")))
    for (i in probabilities.capacity()) {
        val label: String = reader.readLine()
        val probability = probabilities.get(i)
        println("$label: $probability")
    }
} catch (e: IOException) {
    // File not found?
}

Java

modelOutput.rewind();
FloatBuffer probabilities = modelOutput.asFloatBuffer();
try {
    BufferedReader reader = new BufferedReader(
            new InputStreamReader(getAssets().open("custom_labels.txt")));
    for (int i = 0; i < probabilities.capacity(); i++) {
        String label = reader.readLine();
        float probability = probabilities.get(i);
        Log.i(TAG, String.format("%s: %1.4f", label, probability));
    }
} catch (IOException e) {
    // File not found?
}

Apéndice: Seguridad del modelo

Independientemente de cómo hagas que tus modelos de TensorFlow Lite estén disponibles para Firebase ML, Firebase ML los almacena en el formato protobuf serializado estándar en el almacenamiento local.

En teoría, esto significa que cualquiera puede copiar su modelo. Sin embargo, en la práctica, la mayoría de los modelos son tan específicos de la aplicación y están tan confusos por las optimizaciones que el riesgo es similar al de que los competidores desensamblen y reutilicen su código. Sin embargo, debes ser consciente de este riesgo antes de utilizar un modelo personalizado en tu aplicación.

En el nivel de API de Android 21 (Lollipop) y posteriores, el modelo se descarga en un directorio que está excluido de la copia de seguridad automática .

En el nivel de API de Android 20 y anteriores, el modelo se descarga en un directorio denominado com.google.firebase.ml.custom.models en el almacenamiento interno privado de la aplicación. Si habilitó la copia de seguridad de archivos usando BackupAgent , puede optar por excluir este directorio.