Implementa y administra modelos personalizados

Puedes implementar y administrar modelos personalizados y modelos entrenados por AutoML con Firebase console o los SDK de Firebase Admin para Python y Node.js. Si solo quieres implementar un modelo y actualizarlo de vez en cuando, generalmente la opción más fácil es usar Firebase console. El SDK de Admin puede ser útil cuando se realizan integraciones en canalizaciones de compilación, se trabaja con notebooks de Colab o Jupyter, y otros flujos de trabajo.

Implementa y administra modelos en Firebase console

Modelos de TensorFlow Lite

Para implementar un modelo de TensorFlow Lite con Firebase console, sigue estos pasos:

1. Abre la página del modelo personalizado de AA de Firebase en Firebase console.
2. Haz clic en Agregar modelo personalizado (o Agregar otro modelo).
3. Especifica el nombre que se usará para identificar el modelo en tu proyecto de Firebase. Luego, sube el archivo del modelo de TensorFlow Lite (generalmente, con la extensión .tflite o .lite).

Después de implementar el modelo, podrás encontrarlo en la página Personalizados. Desde allí, puedes completar tareas como actualizar el modelo con un archivo nuevo, descargarlo y borrarlo de tu proyecto.

Implementa y administra modelos con el SDK de Firebase Admin

En esta sección, se explica cómo realizar tareas comunes de implementación y administración de modelos con el SDK de Admin. Consulta la referencia del SDK para Python o Node.js a fin de obtener ayuda adicional.

Si quieres ver ejemplos del SDK en uso, consulta la muestra de la guía de inicio rápido de Python y la muestra de la guía de inicio rápido de Node.js.

Antes de comenzar

1. Si aún no tienes un proyecto de Firebase, crea uno nuevo en Firebase console. Luego, abre tu proyecto y haz lo siguiente:

   1. En la página Configuración, crea una cuenta de servicio y descarga su archivo de claves. Conserva este archivo seguro, ya que otorga acceso de administrador a tu proyecto.

   2. En la página de Storage, habilita Cloud Storage. Toma nota del nombre del bucket.

      Necesitas un bucket de Cloud Storage para almacenar archivos de modelo de forma temporal mientras los agregas a tu proyecto de Firebase. Si tienes el plan Blaze, puedes crear y usar un bucket que no sea el predeterminado para este propósito.

   3. En la página AA de Firebase, haz clic en Comenzar si aún no has habilitado el AA de Firebase.

2. En la consola de las API de Google, abre tu proyecto de Firebase y habilita la API de AA de Firebase.

3. Instala y, luego, inicializa el SDK de Admin.

   Cuando inicialices el SDK, especifica las credenciales de tu cuenta de servicio y el bucket de Cloud Storage que quieres usar para almacenar tus modelos:

   Python

   import firebase_admin
   from firebase_admin import ml
   from firebase_admin import credentials
   
   firebase_admin.initialize_app(
     credentials.Certificate('/path/to/your/service_account_key.json'),
     options={
         'storageBucket': 'your-storage-bucket',
     })
   

   Node.js

   const admin = require('firebase-admin');
   const serviceAccount = require('/path/to/your/service_account_key.json');
   admin.initializeApp({
     credential: admin.credential.cert(serviceAccount),
     storageBucket: 'your-storage-bucket',
   });
   const ml = admin.machineLearning();
   

   Nota: En entornos de Google Cloud, incluido Cloud Functions para Firebase, el SDK de Admin puede inicializarse automáticamente con las credenciales de tu cuenta de servicio. Consulta la guía de configuración.

Implementa modelos

Archivos de TensorFlow Lite

Para implementar un modelo de TensorFlow Lite desde un archivo del modelo, súbelo a tu proyecto y, luego, publícalo:

Python

# First, import and initialize the SDK as shown above.

# Load a tflite file and upload it to Cloud Storage
source = ml.TFLiteGCSModelSource.from_tflite_model_file('example.tflite')

# Create the model object
tflite_format = ml.TFLiteFormat(model_source=source)
model = ml.Model(
    display_name="example_model",  # This is the name you use from your app to load the model.
    tags=["examples"],             # Optional tags for easier management.
    model_format=tflite_format)

# Add the model to your Firebase project and publish it
new_model = ml.create_model(model)
ml.publish_model(new_model.model_id)

Node.js

// First, import and initialize the SDK as shown above.

(async () => {
  // Upload the tflite file to Cloud Storage
  const storageBucket = admin.storage().bucket('your-storage-bucket');
  const files = await storageBucket.upload('./example.tflite');

  // Create the model object and add the model to your Firebase project.
  const bucket = files[0].metadata.bucket;
  const name = files[0].metadata.name;
  const gcsUri = `gs:/⁠/${bucket}/${name}`;
  const model = await ml.createModel({
    displayName: 'example_model',  // This is the name you use from your app to load the model.
    tags: ['examples'],  // Optional tags for easier management.
    tfliteModel: { gcsTfliteUri: gcsUri },
  });

  // Publish the model.
  await ml.publishModel(model.modelId);

  process.exit();
})().catch(console.error);

Modelos de TensorFlow y Keras

Si tienes un modelo en formato de modelo guardado de TensorFlow, con el SDK de Python puedes convertirlo al formato de TensorFlow Lite y subirlo a tu bucket de Cloud Storage en un solo paso. Luego, impleméntalo de la misma manera en que implementas un archivo de TensorFlow Lite.

Python

# First, import and initialize the SDK as shown above.

# Convert the model to TensorFlow Lite and upload it to Cloud Storage
source = ml.TFLiteGCSModelSource.from_saved_model('./model_directory')

# Create the model object
tflite_format = ml.TFLiteFormat(model_source=source)
model = ml.Model(
    display_name="example_model",  # This is the name you use from your app to load the model.
    tags=["examples"],             # Optional tags for easier management.
    model_format=tflite_format)

# Add the model to your Firebase project and publish it
new_model = ml.create_model(model)
ml.publish_model(new_model.model_id)

Si tienes un modelo de Keras, también puedes convertirlo al formato de TensorFlow Lite y subirlo en un solo paso. Puedes usar un modelo de Keras guardado en un archivo HDF5:

Python

import tensorflow as tf

# Load a Keras model, convert it to TensorFlow Lite, and upload it to Cloud Storage
model = tf.keras.models.load_model('your_model.h5')
source = ml.TFLiteGCSModelSource.from_keras_model(model)

# Create the model object, add the model to your project, and publish it. (See
# above.)
# ...

O bien, puedes convertir y subir un modelo de Keras directamente desde tu secuencia de comandos de entrenamiento:

Python

import tensorflow as tf

# Create a simple Keras model.
x = [-1, 0, 1, 2, 3, 4]
y = [-3, -1, 1, 3, 5, 7]

model = tf.keras.models.Sequential(
    [tf.keras.layers.Dense(units=1, input_shape=[1])])
model.compile(optimizer='sgd', loss='mean_squared_error')
model.fit(x, y, epochs=3)

# Convert the model to TensorFlow Lite and upload it to Cloud Storage
source = ml.TFLiteGCSModelSource.from_keras_model(model)

# Create the model object, add the model to your project, and publish it. (See
# above.)
# ...

Modelos de TensorFlow Lite con AutoML

Si entrenaste un modelo de Edge con la API de Cloud para AutoML o con la IU de la consola de Google Cloud, puedes implementar el modelo en Firebase mediante el SDK de Admin.

Las funciones de AutoML Vision Edge del AA de Firebase dejaron de estar disponibles. Considera usar Vertex AI si quieres entrenar automáticamente modelos de AA, que puedes exportar como modelos de TensorFlow Lite para usarlos en el dispositivo o implementarlos para la inferencia basada en la nube.

Deberás especificar el identificador de recursos del modelo, que es una cadena similar a este ejemplo:

projects/PROJECT_NUMBER/locations/STORAGE_LOCATION/models/MODEL_ID

PROJECT_NUMBER	El número de proyecto del bucket de Cloud Storage que contiene el modelo. Este puede ser tu proyecto de Firebase o algún otro proyecto de Google Cloud. Encuentra este valor en la página Configuración de Firebase console o en el panel de la consola de Google Cloud.
STORAGE_LOCATION	La ubicación del recurso del bucket de Cloud Storage que contiene el modelo. Este valor siempre es us-central1.
MODEL_ID	El ID del modelo, que obtuviste de la API de Cloud para AutoML.

Python

# First, import and initialize the SDK as shown above.

# Get a reference to the AutoML model
source = ml.TFLiteAutoMlSource('projects/{}/locations/{}/models/{}'.format(
    # See above for information on these values.
    project_number,
    storage_location,
    model_id
))

# Create the model object
tflite_format = ml.TFLiteFormat(model_source=source)
model = ml.Model(
    display_name="example_model",  # This is the name you will use from your app to load the model.
    tags=["examples"],             # Optional tags for easier management.
    model_format=tflite_format)

# Add the model to your Firebase project and publish it
new_model = ml.create_model(model)
new_model.wait_for_unlocked()
ml.publish_model(new_model.model_id)

Node.js

// First, import and initialize the SDK as shown above.

(async () => {
  // Get a reference to the AutoML model. See above for information on these
  // values.
  const automlModel = `projects/${projectNumber}/locations/${storageLocation}/models/${modelId}`;

  // Create the model object and add the model to your Firebase project.
  const model = await ml.createModel({
    displayName: 'example_model',  // This is the name you use from your app to load the model.
    tags: ['examples'],  // Optional tags for easier management.
    tfliteModel: { automlModel: automlModel },
  });

  // Wait for the model to be ready.
  await model.waitForUnlocked();

  // Publish the model.
  await ml.publishModel(model.modelId);

  process.exit();
})().catch(console.error);

Enumera los modelos del proyecto

Puedes enumerar los modelos de tu proyecto y, de forma opcional, filtrar los resultados:

Python

# First, import and initialize the SDK as shown above.

face_detectors = ml.list_models(list_filter="tags: face_detector").iterate_all()
print("Face detection models:")
for model in face_detectors:
  print('{} (ID: {})'.format(model.display_name, model.model_id))

Node.js

// First, import and initialize the SDK as shown above.

(async () => {
  let listOptions = {filter: 'tags: face_detector'}
  let models;
  let pageToken = null;
  do {
    if (pageToken) listOptions.pageToken = pageToken;
    ({models, pageToken} = await ml.listModels(listOptions));
    for (const model of models) {
      console.log(`${model.displayName} (ID: ${model.modelId})`);
    }
  } while (pageToken != null);

  process.exit();
})().catch(console.error);

Puedes filtrar por los siguientes campos:

Campo	Ejemplos
display_name	display_name = example_model display_name != example_model Todos los nombres visibles con el prefijo experimental_: display_name : experimental_* Ten en cuenta que solo se admite la coincidencia de prefijos.
tags	tags: face_detector tags: face_detector AND tags: experimental
state.published	state.published = true state.published = false

Combina los filtros con los operadores y paréntesis AND, OR y NOT ((, )).

Actualiza modelos

Después de agregar un modelo a tu proyecto, puedes actualizar su nombre visible, etiquetas y archivo de modelo tflite:

Python

# First, import and initialize the SDK as shown above.

model = ...   # Model object from create_model(), get_model(), or list_models()

# Update the model with a new tflite model. (You could also update with a
# `TFLiteAutoMlSource`)
source = ml.TFLiteGCSModelSource.from_tflite_model_file('example_v2.tflite')
model.model_format = ml.TFLiteFormat(model_source=source)

# Update the model's display name.
model.display_name = "example_model"

# Update the model's tags.
model.tags = ["examples", "new_models"]

# Add a new tag.
model.tags += "experimental"

# After you change the fields you want to update, save the model changes to
# Firebase and publish it.
updated_model = ml.update_model(model)
ml.publish_model(updated_model.model_id)

Node.js

// First, import and initialize the SDK as shown above.

(async () => {
  const model = ... // Model object from createModel(), getModel(), or listModels()

  // Upload a new tflite file to Cloud Storage.
  const files = await storageBucket.upload('./example_v2.tflite');
  const bucket = files[0].metadata.bucket;
  const name = files[0].metadata.name;

  // Update the model. Any fields you omit will be unchanged.
  await ml.updateModel(model.modelId, {
    displayName: 'example_model',  // Update the model's display name.
    tags: model.tags.concat(['new']),  // Add a tag.
    tfliteModel: {gcsTfliteUri: `gs:/⁠/${bucket}/${name}`},
  });

  process.exit();
})().catch(console.error);

Anula publicaciones o borra modelos

Para anular la publicación de un modelo o borrarlo, pasa el ID del modelo a los métodos de anulación de publicación o eliminación. Cuando anulas la publicación de un modelo, este permanece en tu proyecto, pero no está disponible para que lo descarguen tus apps. Cuando borras un modelo, se quita por completo de tu proyecto. No se espera anular la publicación de un modelo en un flujo de trabajo estándar, pero puedes usarlo de inmediato para anular la publicación de un modelo nuevo que hayas publicado accidentalmente y que aún no se haya usado, o en los casos en que sea peor para los usuarios descargar modelos “malos” que obtener errores de modelos no encontrados.

Si aún no tienes una referencia al objeto Modelo, es probable que debas obtener el ID del modelo con una lista de los modelos de tu proyecto con un filtro. Por ejemplo, para borrar todos los modelos etiquetados como “face_detector”:

Python

# First, import and initialize the SDK as shown above.

face_detectors = ml.list_models(list_filter="tags: 'face_detector'").iterate_all()
for model in face_detectors:
  ml.delete_model(model.model_id)

Node.js

// First, import and initialize the SDK as shown above.

(async () => {
  let listOptions = {filter: 'tags: face_detector'}
  let models;
  let pageToken = null;
  do {
    if (pageToken) listOptions.pageToken = pageToken;
    ({models, pageToken} = await ml.listModels(listOptions));
    for (const model of models) {
      await ml.deleteModel(model.modelId);
    }
  } while (pageToken != null);

  process.exit();
})().catch(console.error);