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 Firebase ML 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 Firebase ML, haz clic en Comenzar si aún no has habilitado Firebase ML.

  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();

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 usando el SDK de Admin.

Deberás especificar el identificador de recursos del modelo, que es una string 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. Puedes encontrar este valor en la página Configuración de la consola de Firebase 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);