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:
- Utilice un modelo prediseñado, como uno de los modelos oficiales de TensorFlow Lite .
- Convierta un modelo de TensorFlow, un modelo de Keras o una función concreta a TensorFlow Lite.
Antes de que empieces
- Si aún no lo has hecho, agrega Firebase a tu proyecto de Android .
- En el archivo Gradle de su módulo (nivel de aplicación) (generalmente
<project>/<app-module>/build.gradle.ktso<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.8.0")) // 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") } - 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.