Catch up on everthing we announced at this year's Firebase Summit. Learn more

Distribuisci e gestisci modelli personalizzati

Puoi distribuire e gestire modelli personalizzati e modelli addestrati ad AutoML utilizzando la console Firebase o gli SDK Firebase Admin Python e Node.js. Se desideri semplicemente distribuire un modello e aggiornarlo occasionalmente, di solito è più semplice utilizzare la console Firebase. L'SDK Admin può essere utile durante l'integrazione con le pipeline di compilazione, l'utilizzo di notebook Colab o Jupyter e altri flussi di lavoro.

Distribuisci e gestisci i modelli nella console Firebase

Modelli TensorFlow Lite

Per distribuire un modello TensorFlow Lite utilizzando la console Firebase:

  1. Aprire la pagina di modello di Firebase ML personalizzato nella console Firebase.
  2. Fare clic su Aggiungi modello personalizzato (o aggiungere un altro modello).
  3. Specificare un nome che verrà utilizzato per identificare il proprio modello nel progetto Firebase, quindi caricare il file del modello tensorflow Lite (di solito terminano in .tflite o .lite ).

Dopo aver distribuito il modello, puoi trovarlo nella pagina Personalizza. Da lì, puoi completare attività come l'aggiornamento del modello con un nuovo file, il download del modello e l'eliminazione del modello dal progetto.

Distribuisci e gestisci i modelli con Firebase Admin SDK

Questa sezione mostra come completare le attività comuni di distribuzione e gestione del modello con Admin SDK. Vedere il riferimento SDK per Python o Node.js per ulteriore assistenza.

Per esempi di SDK in uso, vedere l' esempio delle Guide rapide Python e campione Node.js QuickStart .

Prima di iniziare

  1. Se non si dispone già di un progetto Firebase, creare un nuovo progetto nella console Firebase . Quindi, apri il tuo progetto e procedi come segue:

    1. Nella Impostazioni pagina, creare un account di servizio e scaricare il file chiave di account di servizio. Mantieni questo file al sicuro, poiché garantisce l'accesso come amministratore al tuo progetto.

    2. Nella pagina Archiviazione, abilita Archiviazione cloud. Prendi nota del nome del tuo secchio.

      Hai bisogno di un bucket Cloud Storage per archiviare temporaneamente i file del modello mentre li aggiungi al tuo progetto Firebase. Se utilizzi il piano Blaze, puoi creare e utilizzare un bucket diverso da quello predefinito per questo scopo.

    3. Nella pagina Firebase ML, fai clic su Inizia se non l'hai ancora abilitato Firebase ML.

  2. Nella API console di Google , aprire il progetto Firebase e attivare l'API Firebase ML.

  3. Installare e inizializzare l'Admin SDK .

    Quando inizializzi l'SDK, specifica le credenziali dell'account di servizio e il bucket Cloud Storage che desideri utilizzare per archiviare i tuoi modelli:

    Pitone

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

Distribuire modelli

File TensorFlow Lite

Per distribuire un modello TensorFlow Lite da un file modello, caricalo nel tuo progetto e poi pubblicalo:

Pitone

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

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

Modelli TensorFlow e Keras

Con Python SDK, puoi convertire un modello dal formato di modello salvato TensorFlow a TensorFlow Lite e caricarlo nel tuo bucket Cloud Storage in un unico passaggio. Quindi, distribuiscilo nello stesso modo in cui distribuisci un file TensorFlow Lite.

Pitone

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

Se hai un modello Keras, puoi anche convertirlo in TensorFlow Lite e caricarlo in un unico passaggio. Puoi utilizzare un modello Keras salvato in un file HDF5:

Pitone

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

Oppure puoi convertire e caricare un modello Keras direttamente dal tuo script di allenamento:

Pitone

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

Modelli AutoML TensorFlow Lite

Se ti sei allenato un modello Edge con l'AutoML cloud API o con l'interfaccia utente di Google Cloud Console, è possibile distribuire il modello per Firebase utilizzando l'Admin SDK.

Dovrai specificare l'identificatore di risorsa del modello, che è una stringa simile all'esempio seguente:

projects/PROJECT_NUMBER/locations/STORAGE_LOCATION/models/MODEL_ID
PROJECT_NUMBER Il numero di progetto del bucket Cloud Storage che contiene il modello. Questo potrebbe essere il tuo progetto Firebase o un altro progetto Google Cloud. Puoi trovare questo valore nella pagina Impostazioni della console Firebase o nella dashboard di Google Cloud Console.
STORAGE_LOCATION La posizione della risorsa del bucket Cloud Storage che contiene il modello. Questo valore è sempre us-central1 .
MODEL_ID L'ID del modello, ottenuto dall'API Cloud di AutoML.

Pitone

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

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

Elenca i modelli del tuo progetto

Puoi elencare i modelli del tuo progetto, eventualmente filtrando i risultati:

Pitone

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

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

Puoi filtrare in base ai seguenti campi:

Campo Esempi
display_name display_name = example_model
display_name != example_model

Tutti i nomi visualizzati con experimental_ prefisso:

display_name : experimental_*

Tieni presente che è supportata solo la corrispondenza del prefisso.

tags tags: face_detector
tags: face_detector AND tags: experimental
state.published state.published = true
state.published = false

Combinate con filtri l' AND , OR e NOT operatori e parentesi ( ( , ) ).

Aggiorna modelli

Dopo aver aggiunto un modello al progetto, è possibile aggiornare il suo nome visualizzato, tag e tflite file del modello:

Pitone

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

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

Annulla la pubblicazione o elimina i modelli

Per annullare la pubblicazione o eliminare un modello, passare l'ID modello ai metodi di annullamento della pubblicazione o eliminazione. Quando annulli la pubblicazione, un modello rimane nel tuo progetto, ma non è disponibile per il download delle tue app. Quando elimini un modello, questo viene completamente rimosso dal tuo progetto. (L'annullamento della pubblicazione di un modello non è previsto in un flusso di lavoro standard, ma è possibile utilizzarlo per annullare immediatamente la pubblicazione di un nuovo modello pubblicato per errore e che non viene ancora utilizzato da nessuna parte, o nei casi in cui è peggio per gli utenti scaricare un "cattivo" modello piuttosto che ottenere errori di modello non trovato.)

Se non hai ancora un riferimento all'oggetto Model, probabilmente dovrai ottenere l'ID modello elencando i modelli del tuo progetto con un filtro. Ad esempio, per eliminare tutti i modelli taggati "face_detector":

Pitone

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

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