Aggiungi consigli alla tua app con TensorFlow Lite e Firebase - Android Codelab

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

1. Panoramica

Benvenuto nelle Raccomandazioni con TensorFlow Lite e Firebase codelab. In questo codelab imparerai come utilizzare TensorFlow Lite e Firebase per distribuire un modello di raccomandazione alla tua app. Questo codelab si basa su questo esempio di TensorFlow Lite.

I consigli consentono alle app di utilizzare l'apprendimento automatico per offrire in modo intelligente i contenuti più rilevanti per ciascun utente. Tengono conto del comportamento dell'utente passato per suggerire il contenuto dell'app con cui l'utente potrebbe voler interagire in futuro utilizzando un modello addestrato sul comportamento aggregato di un gran numero di altri utenti.

Questo tutorial mostra come ottenere dati dagli utenti della tua app con Firebase Analytics, creare un modello di machine learning per i consigli da tali dati e quindi usare quel modello in un'app Android per eseguire l'inferenza e ottenere consigli. In particolare, i nostri consigli suggeriranno quali film un utente guarderebbe molto probabilmente, dato l'elenco di film che l'utente ha apprezzato in precedenza.

Cosa imparerai

  • Integra Firebase Analytics in un'app Android per raccogliere dati sul comportamento degli utenti
  • Esporta quei dati in Google Big Query
  • Pre-elabora i dati e addestra un modello di raccomandazioni TF Lite
  • Distribuisci il modello TF Lite su Firebase ML e accedi ad esso dalla tua app
  • Esegui sull'inferenza del dispositivo usando il modello per suggerire consigli agli utenti

Di cosa avrai bisogno

  • Android Studio versione 3.4+.
  • Codice di esempio.
  • Un dispositivo di prova con Android 2.3+ e servizi Google Play 9.8 o successivi, o un emulatore con servizi Google Play 9.8 o successivi
  • Se si utilizza un dispositivo, un cavo di connessione.

Come utilizzerai questo tutorial?

Leggilo solo fino in fondo Leggilo e completa gli esercizi

Come valuteresti la tua esperienza con la creazione di app Android?

Novizio Intermedio Esperto

2. Ottieni il codice di esempio

Clona il repository GitHub dalla riga di comando.

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

3. Importa l'app di avviamento

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

Ora dovresti avere il progetto iniziale aperto in Android Studio.

4. Crea un progetto per la console Firebase

Crea un nuovo progetto

  1. Vai alla console Firebase .
  2. Seleziona Aggiungi progetto (o Crea un progetto se è il primo).
  3. Selezionare o immettere un nome di progetto e fare clic su Continua .
  4. Assicurati che "Abilita Google Analytics per questo progetto" sia abilitato.
  5. Segui i restanti passaggi di configurazione nella console Firebase, quindi fai clic su Crea progetto (o Aggiungi Firebase, se stai utilizzando un progetto Google esistente).

5. Aggiungi Firebase

  1. Dalla schermata di panoramica del tuo nuovo progetto, fai clic sull'icona Android per avviare il flusso di lavoro di configurazione.
  2. Inserisci il nome del pacchetto del codelab: com.google.firebase.codelabs.recommendations
  3. Seleziona Registra app .

Aggiungi il file google-services.json alla tua app

Dopo aver aggiunto il nome del pacchetto e selezionato Registra, fai clic su Scarica google-services.json per ottenere il file di configurazione Android di 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 l'applicazione per l'utilizzo di Firebase. Le seguenti righe dovrebbero già essere aggiunte ai file build.gradle nel progetto (controlla per confermare):

app/build.grade

apply plugin: 'com.google.gms.google-services'

build.grade

classpath 'com.google.gms:google-services:4.3.13'

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.

6. Esegui l'app di avviamento

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

L'app dovrebbe avviarsi sul tuo dispositivo. A questo punto, puoi vedere un'applicazione funzionante che mostra una scheda con un elenco di film, una scheda Film piaciuti e una scheda Consigli. Puoi fare clic su un film nell'elenco dei film per aggiungerlo all'elenco dei preferiti. Dopo aver completato i passaggi rimanenti del codelab, saremo in grado di generare consigli sui film nella scheda Consigli.

7. Aggiungi Firebase Analytics all'app

In questo passaggio, aggiungerai Firebase Analytics all'app per registrare i dati sul comportamento degli utenti (in questo caso, quali film piacciono a un utente). Questi dati verranno utilizzati in forma aggregata nei passaggi futuri per addestrare il modello di raccomandazioni.

Aggiungi la dipendenza di Firebase Analytics

La seguente dipendenza è necessaria per aggiungere Firebase Analytics alla tua app. Dovrebbe essere già incluso nel file app/build.gradle (verifica).

app/build.grade

implementation 'com.google.firebase:firebase-analytics-ktx:21.1.0'

Configura Firebase Analytics nell'app

LikedMoviesViewModel contiene funzioni per archiviare i film che piacciono all'utente. Ogni volta che l'utente apprezza un nuovo film, vogliamo anche inviare un evento del registro di analisi per registrarlo.

Aggiungi la funzione onMovieLiked con il codice seguente per registrare un evento di analisi quando l'utente fa clic come su un film.

LikedMoviesViewModel.kt

import com.google.firebase.analytics.FirebaseAnalytics
import com.google.firebase.analytics.ktx.analytics
import com.google.firebase.analytics.ktx.logEvent
import com.google.firebase.ktx.Firebase


class LikedMoviesViewModel internal constructor (application: Application) : AndroidViewModel(application) {

    ...

    fun onMovieLiked(movie: Movie) {
        movies.setLike(movie, true)
        logAnalyticsEvent(movie.id.toString())
    }
       
}

Aggiungi il campo e la funzione seguenti per registrare un evento Analytics quando un film viene aggiunto all'elenco Mi piace dell'utente.

LikedMoviesViewModel.kt

import com.google.firebase.analytics.FirebaseAnalytics
import com.google.firebase.analytics.ktx.analytics
import com.google.firebase.analytics.ktx.logEvent
import com.google.firebase.ktx.Firebase


class LikedMoviesViewModel internal constructor (application: Application) : AndroidViewModel(application) {
    ...
    private val firebaseAnalytics = Firebase.analytics

    ...

    /**
     * Logs an event in Firebase Analytics that is used in aggregate to train the recommendations
     * model.
     */
    private fun logAnalyticsEvent(id: String) {
        firebaseAnalytics.logEvent(FirebaseAnalytics.Event.SELECT_ITEM) {
            param(FirebaseAnalytics.Param.ITEM_ID, id)
        }
    }

8. Verifica la tua integrazione con Analytics

In questo passaggio, genereremo eventi Analytics nell'app e verificheremo che vengano inviati alla console Firebase.

Abilita la registrazione del debug di analisi

Firebase Analytics è progettato per massimizzare la durata della batteria dell'utente e raggruppa gli eventi sul dispositivo e li invia a Firebase solo occasionalmente. Per scopi di debug, possiamo disabilitare questo comportamento per vedere gli eventi mentre vengono registrati in tempo reale eseguendo il comando seguente nella shell.

terminale

adb shell setprop debug.firebase.analytics.app com.google.firebase.codelabs.recommendations

Verifica che gli eventi di Analytics siano generati

  1. In Android Studio, apri la finestra Logcat per esaminare la registrazione dalla tua app.
  2. Imposta il filtro Logcat sulla stringa "Evento di registrazione".
  3. Verifica che gli eventi Analytics "select_item" vengano emessi ogni volta che ti piace un film nell'app.

A questo punto, hai integrato correttamente Firebase Analytics nella tua app. Quando gli utenti utilizzano la tua app e mettono Mi piace ai film, i loro Mi piace verranno registrati in modo aggregato. Utilizzeremo questi dati aggregati nel resto di questo codelab per addestrare il nostro modello di consigli. Quello che segue è un passaggio facoltativo per vedere gli stessi eventi di Analytics che hai visto in Logcat anche in streaming sulla console Firebase. Sentiti libero di saltare alla pagina successiva.

Facoltativo: conferma gli eventi di Analytics in Firebase Console

  1. Vai alla console Firebase .
  2. Seleziona DebugView in Analytics
  3. In Android Studio, seleziona Esegui per avviare l'app e aggiungere alcuni film all'elenco Mi piace.
  4. In DebugView della console Firebase, verifica che questi eventi vengano registrati mentre aggiungi film nell'app.

9. Esporta i dati di Analytics in Big Query

Big Query è un prodotto Google Cloud che consente di esaminare ed elaborare grandi quantità di dati. In questo passaggio, collegherai il tuo progetto Firebase Console a Big Query in modo che i dati di Analytics generati dalla tua app vengano esportati automaticamente in Big Query.

Abilita esportazione Big Query

  1. Vai alla console Firebase .
  2. Seleziona l'icona a forma di ingranaggio Impostazioni accanto a Panoramica progetto , quindi seleziona Impostazioni progetto
  3. Seleziona la scheda Integrazioni .
  4. Seleziona Collega (o Gestisci ) all'interno del blocco BigQuery .
  5. Seleziona Avanti nel passaggio Informazioni sul collegamento di Firebase a BigQuery .
  6. Nella sezione Configura integrazione , fai clic sull'interruttore per abilitare l'invio dei dati di Google Analytics e seleziona Collega a BigQuery .

Ora hai abilitato il progetto della tua console Firebase per inviare automaticamente i dati degli eventi di Firebase Analytics a Big Query. Ciò avviene automaticamente senza ulteriori interazioni, tuttavia, la prima esportazione che crea il set di dati di analisi in BigQuery potrebbe non avvenire per 24 ore. Dopo la creazione del set di dati, Firebase esporta continuamente i nuovi eventi Analytics in Big Query nella tabella intraday e raggruppa gli eventi dei giorni precedenti nella tabella degli eventi.

La formazione di un modello di raccomandazioni richiede molti dati. Poiché non disponiamo già di un'app che genera grandi quantità di dati, nel passaggio successivo importeremo un set di dati di esempio in BigQuery da utilizzare per il resto di questo tutorial.

10. Usa BigQuery per ottenere i dati di addestramento del modello

Ora che abbiamo collegato la nostra console Firebase per l'esportazione in BigQuery, i dati degli eventi di analisi delle nostre app verranno visualizzati automaticamente nella console BigQuery dopo un po' di tempo. Per ottenere alcuni dati iniziali ai fini di questo tutorial, in questo passaggio importeremo un set di dati di esempio esistente nella tua console BigQuery da utilizzare per addestrare il nostro modello di consigli.

Importa un set di dati di esempio in BigQuery

  1. Vai alla dashboard di BigQuery nella console cloud di Google.
  2. Seleziona il nome del tuo progetto nel menu.
  3. Seleziona il nome del tuo progetto nella parte inferiore della barra di navigazione a sinistra di BigQuery per visualizzare i dettagli.
  4. Selezionare Crea set di dati per aprire il pannello di creazione del set di dati.
  5. Immettere 'firebase_recommendations_dataset' per l' ID del set di dati e selezionare Crea set di dati .
  6. Il nuovo set di dati verrà visualizzato nel menu a sinistra sotto il nome del progetto. Cliccalo.
  7. Seleziona Crea tabella per aprire il pannello di creazione della tabella.
  8. Per Crea tabella da seleziona "Google Cloud Storage".
  9. Nel campo Seleziona file dal bucket GCS , inserisci 'gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt'.
  10. Seleziona 'JSONL' nell'elenco a discesa Formato file .
  11. Immettere 'recommendations_table' per il nome della tabella .
  12. Seleziona la casella in Schema > Rilevamento automatico > Schema e parametri di input
  13. Seleziona Crea tabella

Esplora il set di dati di esempio

A questo punto, puoi facoltativamente esplorare lo schema e visualizzare in anteprima questo set di dati.

  1. Seleziona firebase-recommendations-dataset nel menu a sinistra per espandere le tabelle che contiene.
  2. Selezionare la tabella della tabella dei suggerimenti per visualizzare lo schema della tabella.
  3. Seleziona Anteprima per vedere i dati effettivi dell'evento Analytics contenuti in questa tabella.

Crea le credenziali dell'account di servizio

Ora creeremo le credenziali dell'account di servizio nel nostro progetto di console Google Cloud che possiamo utilizzare nell'ambiente Colab nel passaggio successivo per accedere e caricare i nostri dati BigQuery.

  1. Assicurati che la fatturazione sia abilitata per il tuo progetto Google Cloud.
  2. Abilita le API BigQuery e BigQuery Storage API. < clicca qui >
  3. Vai alla pagina Crea chiave account di servizio .
  4. Dall'elenco Account di servizio , seleziona Nuovo account di servizio .
  5. Nel campo Nome account di servizio , inserisci un nome.
  6. Dall'elenco Ruolo , selezionare Progetto > Proprietario .
  7. Fare clic su Crea . Un file JSON che contiene la tua chiave viene scaricato sul tuo computer.

Nella fase successiva, utilizzeremo Google Colab per preelaborare questi dati e addestrare il nostro modello di consigli.

11. Preelabora il modello dei dati e delle raccomandazioni del treno

In questo passaggio, utilizzeremo un notebook Colab per eseguire i seguenti passaggi:

  1. importa i dati BigQuery nel notebook Colab
  2. preelaborare i dati per prepararli per l'addestramento del modello
  3. addestrare il modello di raccomandazioni sui dati analitici
  4. esportare il modello come modello TF lite
  5. distribuire il modello sulla console Firebase in modo da poterlo utilizzare nella nostra app

Prima di lanciare il notebook di formazione Colab, abiliteremo prima l'API di gestione del modello Firebase in modo che Colab possa distribuire il modello addestrato sulla nostra console Firebase.

Abilita l'API di gestione del modello Firebase

Crea un bucket per archiviare i tuoi modelli ML

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

Segui il dialogo per impostare il tuo secchio.

19517c0d6d2aa14d.png

Abilita l'API Firebase ML

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

Usa il notebook Colab per addestrare e distribuire il modello

Apri il taccuino colab utilizzando il seguente link e completa i passaggi all'interno. Dopo aver completato i passaggi nel notebook Colab, avrai un file modello TF lite distribuito sulla console Firebase che possiamo sincronizzare con la nostra app.

Aperto in Colab

12. Scarica il modello nella tua app

In questo passaggio, modificheremo la nostra app per scaricare il modello appena addestrato da Firebase Machine Learning.

Aggiungi la dipendenza di Firebase ML

La dipendenza seguente è necessaria per utilizzare i modelli di Firebase Machine Learning nella tua app. Dovrebbe essere già aggiunto (verifica).

app/build.grade

implementation 'com.google.firebase:firebase-ml-modeldownloader:24.0.4'

Scarica il modello con l'API Firebase Model Manager

Copia il codice seguente in RecommendationClient.kt per impostare le condizioni in cui si verifica il download del modello e creare un'attività di download per sincronizzare il modello remoto con la nostra app.

RaccomandazioneClient.kt

    private fun downloadModel(modelName: String) {
        val conditions = CustomModelDownloadConditions.Builder()
            .requireWifi()
            .build()
        FirebaseModelDownloader.getInstance()
            .getModel(modelName, DownloadType.LOCAL_MODEL, conditions)
            .addOnCompleteListener {
                if (!it.isSuccessful) {
                    showToast(context, "Failed to get model file.")
                } else {
                    showToast(context, "Downloaded remote model: $modelName")
                    GlobalScope.launch { initializeInterpreter(it.result) }
                }
            }
            .addOnFailureListener {
                showToast(context, "Model download failed for recommendations, please check your connection.")
            }
    }

13. Integra il modello di raccomandazione Tensorflow Lite nella tua app

Il runtime di Tensorflow Lite ti consentirà di utilizzare il tuo modello nell'app per generare consigli. Nel passaggio precedente abbiamo inizializzato un interprete TFlite con il file modello che abbiamo scaricato. In questo passaggio, caricheremo prima un dizionario e delle etichette per accompagnare il nostro modello nella fase di inferenza, quindi aggiungeremo la pre-elaborazione per generare gli input al nostro modello e la post-elaborazione dove estrarremo i risultati dalla nostra inferenza .

Carica dizionario ed etichette

Le etichette utilizzate per generare le raccomandazioni candidate dal modello di raccomandazioni sono elencate nel file sorted_movie_vocab.json nella cartella res/assets. Copia il codice seguente per caricare questi candidati.

RaccomandazioneClient.kt

    /** Load recommendation candidate list.  */
    private suspend fun loadCandidateList() {
        return withContext(Dispatchers.IO) {
            val collection = MovieRepository.getInstance(context).getContent()
            for (item in collection) {
                candidates[item.id] = item
            }
            Log.v(TAG, "Candidate list loaded.")
        }
    }

Implementare la pre-elaborazione

Nella fase di pre-elaborazione, modifichiamo la forma dei dati di input in modo che corrispondano a quanto previsto dal nostro modello. Qui, riempiamo la lunghezza dell'input con un valore segnaposto se non abbiamo già generato molti Mi piace degli utenti. Copia il codice qui sotto:

RaccomandazioneClient.kt

    /** Given a list of selected items, preprocess to get tflite input.  */
    @Synchronized
    private suspend fun preprocess(selectedMovies: List<Movie>): IntArray {
        return withContext(Dispatchers.Default) {
            val inputContext = IntArray(config.inputLength)
            for (i in 0 until config.inputLength) {
                if (i < selectedMovies.size) {
                    val (id) = selectedMovies[i]
                    inputContext[i] = id
                } else {
                    // Padding input.
                    inputContext[i] = config.pad
                }
            }
            inputContext
        }
    }


Esegui interprete per generare consigli

Qui usiamo il modello che abbiamo scaricato in un passaggio precedente per eseguire l'inferenza sul nostro input pre-elaborato. Impostiamo il tipo di input e output per il nostro modello ed eseguiamo l'inferenza per generare i nostri consigli sui film. Copia il codice seguente nella tua app.

RaccomandazioneClient.kt

    /** Given a list of selected items, and returns the recommendation results.  */
    @Synchronized
    suspend fun recommend(selectedMovies: List<Movie>): List<Result> {
        return withContext(Dispatchers.Default) {
            val inputs = arrayOf<Any>(preprocess(selectedMovies))

            // Run inference.
            val outputIds = IntArray(config.outputLength)
            val confidences = FloatArray(config.outputLength)
            val outputs: MutableMap<Int, Any> = HashMap()
            outputs[config.outputIdsIndex] = outputIds
            outputs[config.outputScoresIndex] = confidences
            tflite?.let {
                it.runForMultipleInputsOutputs(inputs, outputs)
                postprocess(outputIds, confidences, selectedMovies)
            } ?: run {
                Log.e(TAG, "No tflite interpreter loaded")
                emptyList()
            }
        }
    }



Implementare la post-elaborazione

Infine, in questo passaggio post-processiamo l'output del nostro modello, selezionando i risultati con la massima confidenza e rimuovendo i valori contenuti (film che l'utente ha già apprezzato). Copia il codice seguente nella tua app.

RaccomandazioneClient.kt

    /** Postprocess to gets results from tflite inference.  */
    @Synchronized
    private suspend fun postprocess(
        outputIds: IntArray, confidences: FloatArray, selectedMovies: List<Movie>
    ): List<Result> {
        return withContext(Dispatchers.Default) {
            val results = ArrayList<Result>()

            // Add recommendation results. Filter null or contained items.
            for (i in outputIds.indices) {
                if (results.size >= config.topK) {
                    Log.v(TAG, String.format("Selected top K: %d. Ignore the rest.", config.topK))
                    break
                }
                val id = outputIds[i]
                val item = candidates[id]
                if (item == null) {
                    Log.v(TAG, String.format("Inference output[%d]. Id: %s is null", i, id))
                    continue
                }
                if (selectedMovies.contains(item)) {
                    Log.v(TAG, String.format("Inference output[%d]. Id: %s is contained", i, id))
                    continue
                }
                val result = Result(
                    id, item,
                    confidences[i]
                )
                results.add(result)
                Log.v(TAG, String.format("Inference output[%d]. Result: %s", i, result))
            }
            results
        }
    }


Metti alla prova la tua app!

Esegui nuovamente la tua app. Quando selezioni alcuni film, dovrebbe scaricare automaticamente il nuovo modello e iniziare a generare consigli!

14. Congratulazioni!

Hai integrato una funzione di consigli nella tua app utilizzando TensorFlow Lite e Firebase. Si noti che le tecniche e la pipeline mostrate in questo codelab possono essere generalizzate e utilizzate anche per servire altri tipi di consigli.

Di cosa abbiamo parlato

  • Firebase ML
  • Analisi Firebase
  • Esporta gli eventi di analisi in BigQuery
  • Eventi di analisi preliminare
  • Consigli sui treni Modello TensorFlow
  • Esporta il modello e distribuiscilo su Firebase Console
  • Fornisci consigli sui film in un'app

Prossimi passi

  • Implementa i consigli di Firebase ML nella tua app.

Per saperne di più

Hai una domanda?

Segnala problemi