Aggiungi Firebase alla tua app Android basata su TFLite

1. Panoramica

Firebase ML ti consente di distribuire il tuo modello over-the-air. Ciò ti consente di mantenere ridotte le dimensioni dell'app e di scaricare il modello ML solo quando necessario, sperimentare più modelli o aggiornare il modello ML senza dover ripubblicare l'intera app.

In questo codelab convertirai un'app Android utilizzando un modello TFLite statico in un'app utilizzando un modello servito dinamicamente da Firebase.

Cosa imparerai

• Distribuisci i modelli TFLite su Firebase ML e accedi dalla tua app
• Tieni traccia del feedback degli utenti per misurare l'accuratezza del modello con Firebase Analytics
• Prestazioni del modello del profilo tramite Firebase Performance
• Selezionare quale dei più modelli distribuiti viene caricato tramite Remote Config
• Sperimenta diversi modelli tramite Firebase A/B Testing

Di cosa avrai bisogno

• Ultima versione di Android Studio .
• Codice d'esempio.
• Un dispositivo di prova con Android 5.0+ e Google Play Services 9.8 o versioni successive oppure un emulatore con Google Play Services 9.8 o versioni successive
• Se si utilizza un dispositivo, un cavo di collegamento.

2. Ottieni il codice di esempio

Clona il repository GitHub dalla riga di comando.

$ git clone https://github.com/FirebaseExtended/codelab-digitclassifier-android.git

Se non hai git installato, puoi anche scaricare il progetto di esempio dalla sua pagina GitHub o facendo clic su questo collegamento .

3. Importa l'app iniziale

Da Android Studio, seleziona la directory codelab-digitclassifier-android ( ) dal download del codice di esempio ( File > Apri > .../codelab-digitclassifier-android/start).

Ora dovresti avere il progetto iniziale aperto in Android Studio.

4. Esegui l'app iniziale

Ora che hai importato il progetto in Android Studio, sei pronto per eseguire l'app per la prima volta. Collega il tuo dispositivo Android e fai clic su Esegui ( )nella barra degli strumenti di Android Studio.

L'app dovrebbe avviarsi sul tuo dispositivo. A questo punto, se provi a disegnare una cifra, l'app dovrebbe essere in grado di riconoscerla.

5. Crea un progetto della console Firebase

Aggiungi Firebase al progetto

1. Vai alla console Firebase .
2. Seleziona Aggiungi progetto .
3. Seleziona o inserisci un nome di progetto.
4. Segui i restanti passaggi di configurazione nella console Firebase, quindi fai clic su Crea progetto (o Aggiungi Firebase, se utilizzi un progetto Google esistente).

6. Aggiungi Firebase

1. Dalla schermata panoramica del tuo nuovo progetto, fai clic sull'icona Android per avviare il flusso di lavoro di configurazione.
2. Inserisci il nome del pacchetto codelab: org.tensorflow.lite.examples.digitclassifier

Aggiungi il file google-services.json alla tua app

Dopo aver registrato il nome del pacchetto e selezionato Avanti, fai clic su Scarica google-services.json per ottenere il file di configurazione Android Firebase, quindi copia il file google-services.json nella directory app nel tuo progetto. Dopo aver scaricato il file puoi saltare i passaggi successivi mostrati nella console (sono già stati eseguiti per te nel progetto build-android-start).

Aggiungi il plug-in dei servizi Google alla tua app

Il plug-in google-services utilizza il file google-services.json per configurare la tua applicazione per utilizzare Firebase. Aggiungi la seguente riga al blocco plugins nella parte superiore del file build.gradle.kts nella directory app del tuo progetto:

app/build.gradle.kts

id("com.google.gms.google-services")

Quindi aggiungi la seguente riga al blocco plugins del tuo file build.gradle.kts nel progetto:

progetto/build.gradle.kts

id("com.google.gms.google-services") version "4.3.15" apply false

Sincronizza il tuo progetto con i file Gradle

Per essere sicuro che tutte le dipendenze siano disponibili per la tua app, a questo punto dovresti sincronizzare il tuo progetto con i file Gradle. Seleziona File > Sincronizza progetto con file Gradle dalla barra degli strumenti di Android Studio.

7. Esegui l'app con Firebase

Ora che hai configurato il plug-in google-services con il tuo file JSON, sei pronto per eseguire l'app con Firebase. Collega il tuo dispositivo Android e fai clic su Esegui ( )nella barra degli strumenti di Android Studio.

L'app dovrebbe avviarsi sul tuo dispositivo. A questo punto, la tua app dovrebbe essere comunque creata correttamente.

8. Distribuisci un modello su Firebase ML

La distribuzione di un modello su Firebase ML è utile per due motivi principali:

1. Possiamo mantenere ridotte le dimensioni di installazione dell'app e scaricare il modello solo se necessario
2. Il modello può essere aggiornato regolarmente e con un ciclo di rilascio diverso rispetto all'intera app

Prima di poter sostituire il modello statico nella nostra app con un modello scaricato dinamicamente da Firebase, dobbiamo distribuirlo su Firebase ML. Il modello può essere distribuito tramite la console o a livello di programmazione utilizzando Firebase Admin SDK. In questo passaggio eseguiremo la distribuzione tramite la console.

Per semplificare le cose, utilizzeremo il modello TensorFlow Lite già presente nella nostra app. Innanzitutto, apri la console Firebase e fai clic su Machine Learning nel pannello di navigazione a sinistra. Fai clic su "Inizia" se stai aprendo questa prima volta. Quindi vai su "Personalizzato" e fai clic sul pulsante "Aggiungi modello personalizzato".

Quando richiesto, assegna al modello un nome descrittivo come mnist_v1 e carica il file dalla directory del progetto codelab in start/app/src/main/assets/mnist.tflite . Quindi puoi eliminare questo file del modello TF Lite dal progetto Android.

9. Scarica il modello da Firebase ML

Scegliere quando scaricare il modello remoto da Firebase nella tua app può essere complicato poiché i modelli TFLite possono diventare relativamente grandi. Idealmente vogliamo evitare di caricare il modello immediatamente all'avvio dell'app, poiché se il nostro modello viene utilizzato per una sola funzionalità e l'utente non utilizza mai quella funzionalità, avremo scaricato una quantità significativa di dati senza motivo. Possiamo anche impostare opzioni di download come il recupero dei modelli solo quando siamo connessi al Wi-Fi. Se vuoi essere sicuro che il modello sia disponibile anche senza connessione di rete, è importante includerlo anche senza l'app come backup.

Per motivi di semplicità, rimuoveremo il modello in bundle predefinito e scaricheremo sempre un modello da Firebase all'avvio dell'app. In questo modo quando esegui il riconoscimento delle cifre puoi essere sicuro che l'inferenza viene eseguita con il modello fornito da Firebase.

Nel file app/build.gradle.kts, aggiungi la dipendenza Firebase Machine Learning

app/build.gradle.kts

implementation("com.google.firebase:firebase-ml-modeldownloader:24.1.2")

Quindi aggiungi la logica per scaricare il modello da Firebase.

Sostituiremo digitClassifier.initialize(loadModelFile()) con downloadModel("mnist_v1") e implementeremo questo metodo.

MainActivity.kt

  private fun downloadModel(modelName: String): Task<CustomModel> {
    val conditions = CustomModelDownloadConditions.Builder()
    .requireWifi()
    .build()
    return FirebaseModelDownloader.getInstance()
        .getModel(modelName, DownloadType.LOCAL_MODEL, conditions)
        .addOnCompleteListener {
          val model = it.result
          if (model == null) {
            showToast("Failed to get model file.")
          } else {
            showToast("Downloaded remote model: $modelName")
            digitClassifier.initialize(model)
          }
        }
      .addOnFailureListener {
        showToast("Model download failed for $modelName, please check your connection.")
      }
  }

Esegui nuovamente l'app e disegna una cifra nel classificatore di cifre. Una volta terminato il download, dovresti vedere un messaggio Toast che informa che il modello remoto è stato scaricato e un registro che indica che il tuo nuovo modello è in uso.

10. Tieni traccia del feedback e della conversione degli utenti per misurare l'accuratezza del modello

Google Analytics per Firebase ti consente di comprendere il modo in cui gli utenti si muovono all'interno della tua applicazione, dove hanno successo e dove rimangono bloccati e tornano indietro. Può anche essere utilizzato per comprendere le parti più utilizzate della tua applicazione.

Misureremo l'accuratezza del modello monitorando il feedback degli utenti sulle previsioni del modello. Se un utente fa clic su "SÌ", indicherà che la previsione era accurata.

Possiamo registrare un evento Analytics per monitorare l'accuratezza del nostro modello. Innanzitutto, dobbiamo aggiungere Analytics alla dipendenza prima che possa essere utilizzato nel progetto:

Aggiungi la dipendenza Firebase Analytics

app/build.gradle.kts

implementation(platform("com.google.firebase:firebase-bom:32.0.0"))
implementation("com.google.firebase:firebase-analytics-ktx")

Registra eventi

Quindi, nella funzione onCreate , imposteremo il listener onclick per registrare l'evento correct_inference su Firebase.

MainActivity.kt (onCreate)

// Setup YES button
yesButton?.setOnClickListener {
  Firebase.analytics.logEvent("correct_inference", null)
}

Esegui nuovamente l'app e disegna una cifra. Premi il pulsante "Sì" un paio di volte per inviare un feedback sull'accuratezza dell'inferenza.

Analisi di debug

In genere, gli eventi registrati dalla tua app vengono raggruppati nell'arco di un periodo di circa un'ora e caricati insieme. Questo approccio preserva la batteria dei dispositivi degli utenti finali e riduce l'utilizzo dei dati di rete. Tuttavia, allo scopo di convalidare l'implementazione dell'analisi (e per visualizzare l'analisi nel report DebugView), puoi abilitare la modalità Debug sul tuo dispositivo di sviluppo per caricare gli eventi con un ritardo minimo.

Per abilitare la modalità debug di Analytics su un dispositivo Android, esegui i seguenti comandi:

adb shell setprop debug.firebase.analytics.app org.tensorflow.lite.examples.digitclassifier

Esegui nuovamente l'app e disegna una cifra. Premi il pulsante "Sì" un paio di volte per inviare un feedback sull'accuratezza dell'inferenza. Ora puoi visualizzare gli eventi del registro quasi in tempo reale tramite la visualizzazione debug nella console Firebase. Fai clic su Analytics > DebugView dalla barra di navigazione sinistra.

11. Analizzare le prestazioni del modello

Firebase Performance Monitoring è un servizio che ti aiuta a ottenere informazioni dettagliate sulle caratteristiche prestazionali delle tue app iOS, Android e Web.

Utilizzi l'SDK Performance Monitoring per raccogliere dati sulle prestazioni dalla tua app, quindi rivedi e analizza tali dati nella console Firebase. Il monitoraggio delle prestazioni ti aiuta a capire dove e quando è possibile migliorare le prestazioni della tua app in modo da poter utilizzare tali informazioni per risolvere i problemi di prestazioni.

Qui aggiungiamo tracce di perf relative all'inferenza e al download

Questo è importante perché i modelli più grandi utilizzati nel deep learning hanno il potenziale per essere più accurati, ma possono anche richiedere più tempo per restituire una risposta. Nel nostro esperimento stiamo cercando di trovare il giusto equilibrio tra precisione e velocità.

Aggiungi la dipendenza Firebase Performance

progetto/build.gradle.kts

plugins {
  // ...

  // Add the dependency for the Performance Monitoring plugin
  id("com.google.firebase.firebase-perf") version "1.4.2" apply false
}

app/build.gradle.kts

plugins {
  // ...

  // Add the Performance Monitoring plugin
  id("com.google.firebase.firebase-perf")
}

// ...

dependencies {
  // ...

  // Add the dependency for the Performance Monitoring library
  implementation("com.google.firebase:firebase-perf")
}

Aggiungi tracce personalizzate

Nella funzione setupDigitClassifier() crea un nuovo downloadTrace e avvialo subito prima di scaricare il modello. Quindi aggiungi un ascoltatore onsuccess che interrompe la traccia.

Nella funzione classifyDrawing() crea un nuovo classifyTrace e avvialo subito prima della classificazione. Quindi interrompi la traccia nel listener onsuccess.

MainActivity.kt

class MainActivity : AppCompatActivity() {
  // ...
  
  private val firebasePerformance = FirebasePerformance.getInstance()
  
  // ...

  private fun setupDigitClassifier() {
    // Add these lines to create and start the trace
    val downloadTrace = firebasePerformance.newTrace("download_model")
    downloadTrace.start()
    downloadModel("mnist_v1")
      // Add these lines to stop the trace on success
      .addOnSuccessListener {
        downloadTrace.stop()
      }
  }

// ...

  private fun classifyDrawing() {
    val bitmap = drawView?.getBitmap()

    if ((bitmap != null) && (digitClassifier.isInitialized)) {
      // Add these lines to create and start the trace
      val classifyTrace = firebasePerformance.newTrace("classify")
      classifyTrace.start()
      digitClassifier
        .classifyAsync(bitmap)
        .addOnSuccessListener { resultText -> 
          // Add this line to stop the trace on success
          classifyTrace.stop()
          predictedTextView?.text = resultText
        }
        .addOnFailureListener { e ->
          predictedTextView?.text = getString(
            R.string.tfe_dc_classification_error_message,
            e.localizedMessage
          )
          Log.e(TAG, "Error classifying drawing.", e)
        }
    }
  }

Visualizza i messaggi di registro per gli eventi di prestazione

1. Abilita la registrazione del debug per il monitoraggio delle prestazioni in fase di creazione aggiungendo un elemento <meta-data> al file AndroidManifest.xml della tua app, in questo modo:

AndroidManifest.xml

<application>
    <meta-data
      android:name="firebase_performance_logcat_enabled"
      android:value="true" />
</application>

2. Controlla i messaggi di registro per eventuali messaggi di errore.
3. Performance Monitoring tagga i suoi messaggi di log con FirebasePerformance . Utilizzando il filtro logcat, puoi visualizzare in modo specifico la traccia della durata e la registrazione delle richieste di rete HTTP/S eseguendo il comando seguente:

adb logcat -s FirebasePerformance

4. Verificare la presenza dei seguenti tipi di log che indicano che il monitoraggio delle prestazioni registra gli eventi relativi alle prestazioni:

• Logging TraceMetric
• Logging NetworkRequestMetric

12. Distribuisci un secondo modello su Firebase ML

Quando creiamo una nuova versione del tuo modello, ad esempio una con un'architettura del modello migliore o una addestrata su un set di dati più grande o aggiornato, potremmo sentirci tentati di sostituire il nostro modello attuale con la nuova versione. Tuttavia, un modello che ha ottenuto buoni risultati nei test non necessariamente ha prestazioni altrettanto buone in produzione. Pertanto, eseguiamo dei test A/B in produzione per confrontare il nostro modello originale e quello nuovo.

Abilita l'API di gestione dei modelli Firebase

In questo passaggio, abiliteremo l'API Firebase Model Management per distribuire una nuova versione del nostro modello TensorFlow Lite utilizzando il codice Python.

Crea un bucket per archiviare i tuoi modelli ML

Nella console Firebase, vai su Archiviazione e fai clic su Inizia.

Segui la finestra di dialogo per impostare il secchio.

Abilita l'API Firebase ML

Vai alla pagina API Firebase ML su Google Cloud Console e fai clic su Abilita.

Seleziona l'app Classificatore cifre quando richiesto.

Addestra un nuovo modello e pubblica su Firebase ML

Ora addestreremo una nuova versione del modello utilizzando un set di dati più grande e quindi lo distribuiremo a livello di programmazione direttamente dal notebook di training utilizzando Firebase Admin SDK.

Scarica la chiave privata per l'account di servizio

Prima di poter utilizzare l'SDK Admin Firebase, dovremo creare un account di servizio. Apri il pannello Account di servizio della console Firebase facendo clic su questo collegamento e fai clic sul pulsante per creare un nuovo account di servizio per Firebase Admin SDK. Quando richiesto, fare clic sul pulsante Genera nuova chiave privata. Utilizzeremo la chiave dell'account di servizio per autenticare le nostre richieste dal notebook colab.

Ora possiamo addestrare e implementare il nuovo modello.

1. Apri questo taccuino di collaborazione e creane una copia nel tuo Drive.
2. Esegui la prima cella "Addestra un modello TensorFlow Lite migliorato" facendo clic sul pulsante di riproduzione alla sua sinistra. Questa operazione addestrerà un nuovo modello e potrebbe richiedere del tempo.
3. L'esecuzione della seconda cella creerà una richiesta di caricamento del file. Carica il file json scaricato dalla console Firebase durante la creazione del tuo account di servizio.

4. Esegui le ultime due celle.

Dopo aver eseguito il notebook colab, dovresti vedere un secondo modello nella console Firebase. Assicurati che il secondo modello sia denominato mnist_v2 .

13. Selezionare un modello tramite Remote Config

Ora che abbiamo due modelli separati, aggiungeremo un parametro per selezionare quale modello scaricare in fase di esecuzione. Il valore del parametro ricevuto dal client determinerà quale modello verrà scaricato dal client.

Aggiungi regole di configurazione nella console Firebase

Innanzitutto, apri la console Firebase e fai clic sul pulsante Remote Config nel menu di navigazione a sinistra. Quindi, fare clic sul pulsante "Aggiungi parametro".

Assegna un nome al nuovo parametro model_name e assegnagli il valore predefinito "mnist_v1" . Inserendo il nome del modello nel parametro di configurazione remota, possiamo testare più modelli senza aggiungere un nuovo parametro per ogni modello che vogliamo testare. Fare clic su Pubblica modifiche per applicare gli aggiornamenti.

Aggiungi la dipendenza Firebase RemoteConfig

app/build.gradle.kts

implementation("com.google.firebase:firebase-config-ktx")

Configura la configurazione remota di Firebase

MainActivity.kt

  private fun configureRemoteConfig() {
    remoteConfig = Firebase.remoteConfig
    val configSettings = remoteConfigSettings {
      minimumFetchIntervalInSeconds = 3600
    }
    remoteConfig.setConfigSettingsAsync(configSettings)
  }

Richiedi e utilizza la configurazione

Crea una richiesta di recupero per la configurazione e aggiungi un gestore di completamento per raccogliere e utilizzare i parametri di configurazione.

MainActivity.kt

 private fun setupDigitClassifier() {
    configureRemoteConfig()
    remoteConfig.fetchAndActivate()
      .addOnCompleteListener { task ->
        if (task.isSuccessful) {
          val modelName = remoteConfig.getString("model_name")
          val downloadTrace = firebasePerformance.newTrace("download_model")
          downloadTrace.start()
          downloadModel(modelName)
            .addOnSuccessListener {
              downloadTrace.stop()
            }
        } else {
          showToast("Failed to fetch model name.")
        }
      }
  }

Testare la configurazione remota

1. Clicca il Pulsante Esegui .
2. Verifica di visualizzare il messaggio Toast che indica che il modello mnist_v1 è stato scaricato.
3. Torna alla console Firebase, modifica il valore predefinito in mnist_v2 e seleziona Pubblica modifiche per applicare gli aggiornamenti.
4. Riavvia l'app e controlla se viene visualizzato il messaggio Toast che indica che questa volta il modello mnist_v2 è stato scaricato.

14. Efficacia del modello di test A/B

Firebase A/B Testing ti aiuta a ottimizzare l'esperienza della tua app semplificando l'esecuzione, l'analisi e la scalabilità degli esperimenti di prodotto e di marketing. Infine, possiamo utilizzare il comportamento di test A/B integrato di Firebase per vedere quale dei nostri due modelli funziona meglio.

Vai ad Analisi -> Eventi nella console Firebase. Se viene visualizzato l'evento correct_inference , contrassegnalo come "Evento di conversione", in caso contrario puoi andare su Analytics -> Eventi di conversione e fare clic su "Crea un nuovo evento di conversione" e inserire correct_inference.

Ora vai su "Remote Config nella console Firebase, seleziona il pulsante "Test A/B" dal menu Altre opzioni sul parametro "nome_modello" che abbiamo appena aggiunto.

Nel menu che segue, accetta il nome predefinito.

Seleziona la tua app dal menu a discesa e modifica i criteri di targeting al 50% degli utenti attivi.

Se in precedenza sei riuscito a impostare l'evento correct_inference come conversione, utilizza questo evento come metrica principale da monitorare. Altrimenti, se non vuoi aspettare che l'evento venga visualizzato in Analytics, puoi aggiungere correct_inference manually .

Infine, nella schermata Varianti, imposta la variante del tuo gruppo di controllo per utilizzare mnist_v1 e il tuo gruppo Variante A per utilizzare mnist_v2 .

Fai clic sul pulsante Rivedi nell'angolo in basso a destra.

Congratulazioni, hai creato con successo un test A/B per i tuoi due modelli separati! Il test A/B è attualmente allo stato di bozza e può essere avviato in qualsiasi momento facendo clic sul pulsante "Avvia esperimento".

Per uno sguardo più approfondito ai test A/B, consulta la documentazione sui test A/B .

15. Congratulazioni!

In questo codelab hai imparato come sostituire una risorsa tflite raggruppata staticamente nella tua app con un modello TFLite caricato dinamicamente da Firebase. Per ulteriori informazioni su TFLite e Firebase, dai un'occhiata ad altri esempi di TFLite e alle guide introduttive di Firebase.

Di cosa abbiamo parlato

• TensorFlow Lite
• FirebaseML
• Analisi Firebase
• Monitoraggio delle prestazioni di Firebase
• Configurazione remota Firebase
• Test A/B di Firebase

Prossimi passi

• Implementa Firebase ML Deployment nella tua app.

Saperne di più

• Documentazione sul machine learning di Firebase
• Documentazione di TensorFlow Lite
• Modelli di test A/B con Firebase

Hai una domanda?

• Stackoverflow 'firebase-apprendimento automatico'

Segnala problemi

• Problemi con Github