Implementar y gestionar modelos personalizados

Puedes implementar y administrar modelos personalizados y modelos entrenados en AutoML mediante Firebase console o los SDK de Firebase Admin Python y Node.js. Si solo desea implementar un modelo y actualizarlo ocasionalmente, generalmente lo más sencillo es usar Firebase console. El SDK de administración puede resultar útil al integrarse con canalizaciones de compilación, trabajar con portátiles Colab o Jupyter y otros flujos de trabajo.

Implementar y administrar modelos en Firebase console

Modelos TensorFlow Lite

Para implementar un modelo de TensorFlow Lite usando Firebase console:

1. Abra la página del modelo personalizado de Firebase ML en Firebase console.
2. Haga clic en Agregar modelo personalizado (o Agregar otro modelo ).
3. Especifica un nombre que se utilizará para identificar tu modelo en tu proyecto de Firebase, luego carga el archivo del modelo de TensorFlow Lite (que generalmente termina en .tflite o .lite ).

Después de implementar su modelo, podrá encontrarlo en la página Personalizado. Desde allí, puede completar tareas como actualizar el modelo con un archivo nuevo, descargarlo y eliminarlo de su proyecto.

Implementar y administrar modelos con el SDK de Firebase Admin

Esta sección muestra cómo puede completar tareas comunes de implementación y administración de modelos con Admin SDK. Consulte la referencia del SDK para Python o Node.js para obtener ayuda adicional.

Para ver ejemplos del SDK en uso, consulte el ejemplo de inicio rápido de Python y el ejemplo de inicio rápido de Node.js.

Antes de que empieces

1. Si aún no tienes un proyecto de Firebase, crea un nuevo proyecto en Firebase console . Luego, abra su proyecto y haga lo siguiente:

   1. En la página Configuración , cree una cuenta de servicio y descargue el archivo de clave de la cuenta de servicio. Mantenga este archivo seguro, ya que otorga acceso de administrador a su proyecto.

   2. En la página Almacenamiento, habilite Almacenamiento en la nube. Tome nota del nombre de su depósito.

      Necesita un depósito de Cloud Storage para almacenar temporalmente archivos de modelo mientras los agrega a su proyecto de Firebase. Si tiene el plan Blaze, puede crear y utilizar un depósito distinto al predeterminado para este propósito.

   3. En la página de Firebase ML, haga clic en Comenzar si aún no ha habilitado Firebase ML.

2. En la consola de API de Google , abra su proyecto de Firebase y habilite la API de Firebase ML.

3. Instale e inicialice el SDK de administrador .

   Cuando inicialices el SDK, especifica las credenciales de tu cuenta de servicio y el depósito de Cloud Storage que deseas usar para almacenar tus modelos:

   Pitón

   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',
     })
   

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

Implementar modelos

Archivos TensorFlow Lite

Para implementar un modelo de TensorFlow Lite desde un archivo de modelo, cárguelo en su proyecto y luego publíquelo:

# 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)

// 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 TensorFlow y Keras

Con el SDK de Python, puedes convertir un modelo del formato de modelo guardado de TensorFlow a TensorFlow Lite y cargarlo en tu depósito de Cloud Storage en un solo paso. Luego, impleméntelo de la misma manera que implementa un archivo TensorFlow Lite.

# 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 a TensorFlow Lite y subirlo en un solo paso. Puede utilizar un modelo de Keras guardado en un archivo HDF5:

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 puede convertir y cargar un modelo de Keras directamente desde su script de entrenamiento:

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 AutoML TensorFlow Lite

Si entrenó un modelo de Edge con la API de AutoML Cloud o con la interfaz de usuario de la consola de Google Cloud, puede implementar el modelo en Firebase mediante el SDK de administración.

Deberá especificar el identificador de recursos del modelo, que es una cadena similar al siguiente ejemplo:

projects/PROJECT_NUMBER/locations/STORAGE_LOCATION/models/MODEL_ID

# 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)

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

Lista los modelos de tu proyecto

Puede enumerar los modelos de su proyecto y, opcionalmente, filtrar los resultados:

# 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))

// 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:

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

Actualizar modelos

Después de haber agregado un modelo a su proyecto, puede actualizar su nombre para mostrar, etiquetas y archivo de modelo tflite :

# 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)

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

Anular la publicación o eliminar modelos

Para anular la publicación o eliminar un modelo, pase el ID del modelo a los métodos de anular publicación o eliminar. Cuando cancelas la publicación de un modelo, permanece en tu proyecto, pero no está disponible para que tus aplicaciones lo descarguen. Cuando eliminas un modelo, se elimina por completo de tu proyecto. (No se espera cancelar la publicación de un modelo en un flujo de trabajo estándar, pero puede usarlo para cancelar inmediatamente la publicación de un nuevo modelo que publicó accidentalmente y que aún no se está utilizando en ninguna parte, o en los casos en los que es peor para los usuarios descargar un modelo "malo". modelo que obtener errores de modelo no encontrado).

Si todavía no tiene una referencia al objeto Modelo, probablemente necesitará obtener el ID del modelo enumerando los modelos de su proyecto con un filtro. Por ejemplo, para eliminar todos los modelos etiquetados como "face_detector":

# 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)

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