1. Panoramica
|
|
Benvenuto ai suggerimenti con TensorFlow Lite e il codelab Firebase. In questo codelab imparerai come utilizzare TensorFlow Lite e Firebase per distribuire un modello di consigli nella tua app. Questo codelab è basato su questo esempio di TensorFlow Lite.
I consigli consentono alle app di utilizzare l'apprendimento automatico per fornire in modo intelligente i contenuti più pertinenti per ciascun utente. Tengono conto del comportamento passato degli utenti 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 suggerimenti da tali dati e quindi utilizzare tale modello in un'app Android per eseguire inferenze e ottenere consigli. In particolare, i nostri consigli suggeriranno quali film un utente probabilmente guarderebbe dato l'elenco dei film che gli sono piaciuti in precedenza.
Cosa imparerai
- Integra Firebase Analytics in un'app Android per raccogliere dati sul comportamento degli utenti
- Esporta questi dati in Google Big Query
- Preelaborare i dati e addestrare un modello di raccomandazioni TF Lite
- Distribuisci il modello TF Lite su Firebase ML e accedi dalla tua app
- Esegui l'inferenza del dispositivo utilizzando il modello per suggerire consigli agli utenti
Di cosa avrai bisogno
- Ultima versione di Android Studio .
- Codice d'esempio.
- Un dispositivo di prova con Android 7+ 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.
Come utilizzerai questo tutorial?
Come valuteresti la tua esperienza con la creazione di app Android?
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 iniziale
Da Android Studio, seleziona la directory codelab-recommendations-android ( 
) 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 della console Firebase
Crea un nuovo progetto
- Vai alla console Firebase .
- Seleziona Aggiungi progetto (o Crea un progetto se è il primo).
- Seleziona o inserisci un nome di progetto e fai clic su Continua .
- Assicurati che "Abilita Google Analytics per questo progetto" sia abilitato.
- Segui i restanti passaggi di configurazione nella console Firebase, quindi fai clic su Crea progetto (o Aggiungi Firebase, se utilizzi un progetto Google esistente).
5. Aggiungi Firebase
- Dalla schermata panoramica del tuo nuovo progetto, fai clic sull'icona Android per avviare il flusso di lavoro di configurazione.
- Inserisci il nome del pacchetto del codelab:
com.google.firebase.codelabs.recommendations - 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 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. Le seguenti righe dovrebbero già essere aggiunte ai file build.gradle.kts nel progetto (controlla per confermare):
app/build.grade.kts
plugins {
id("com.google.gms.google-services")
}
build.grade.kts
plugins {
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.
6. Esegui l'app iniziale
Ora che hai importato il progetto in Android Studio e configurato il plug-in 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 ( 
)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 Distinta materiali e Analisi di Firebase
Le seguenti dipendenze sono necessarie per aggiungere Firebase Analytics alla tua app. Dovrebbero essere già inclusi nel file app/build.gradle.kts (verifica).
app/build.grade.kts
implementation(platform("com.google.firebase:firebase-bom:32.0.0"))
implementation("com.google.firebase:firebase-analytics-ktx")
Configura Firebase Analytics nell'app
Il LikedMoviesViewModel contiene funzioni per memorizzare i film che piacciono all'utente. Ogni volta che all'utente piace un nuovo film, vogliamo anche inviare un evento di registro di analisi per registrare quel mi piace.
Aggiungi la funzione onMovieLiked con il codice seguente per registrare un evento di analisi quando l'utente fa clic su Mi piace su un film.
Mi è piaciutoMoviesViewModel.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 dei preferiti dell'utente.
Mi è piaciutoMoviesViewModel.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. Testa 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 Analytics
Firebase Analytics è progettato per massimizzare la durata della batteria dell'utente e raggruppa gli eventi sul dispositivo e li invia a Firebase solo occasionalmente. A scopo di debug, possiamo disabilitare questo comportamento per vedere gli eventi così come vengono registrati in tempo reale eseguendo il seguente comando nella shell.
terminale
adb shell setprop debug.firebase.analytics.app com.google.firebase.codelabs.recommendations
Verifica che gli eventi di Analytics vengano generati
- In Android Studio, apri la finestra Logcat per esaminare la registrazione dalla tua app.
- Imposta il filtro Logcat sulla stringa "Logging event".
- Verifica che gli eventi Analytics "select_item" vengano emessi ogni volta che ti piace un film nell'app.
A questo punto, hai integrato con successo Firebase Analytics nella tua app. Man mano che gli utenti utilizzano la tua app e apprezzano i film, i loro Mi piace verranno registrati in forma aggregata. Utilizzeremo questi dati aggregati nel resto di questo codelab per addestrare il nostro modello di consigli. Quello che segue è un passaggio facoltativo per visualizzare gli stessi eventi Analytics visualizzati in Logcat anche in streaming nella console Firebase. Sentiti libero di passare alla pagina successiva.
Facoltativo: conferma gli eventi di Analytics nella console Firebase
- Vai alla console Firebase .
- Seleziona DebugView in Analisi
- In Android Studio, seleziona Esegui per avviare l'app e aggiungere alcuni film all'elenco dei film preferiti.
- Nel DebugView della console Firebase, verifica che questi eventi vengano registrati quando 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 Analytics generati dalla tua app vengano automaticamente esportati in Big Query.
Abilita l'esportazione di Big Query
- Vai alla console Firebase .
- Seleziona l'icona a forma di ingranaggio Impostazioni accanto a Panoramica del progetto e quindi seleziona Impostazioni progetto
- Seleziona la scheda Integrazioni .
- Seleziona Collega (o Gestisci ) all'interno del blocco BigQuery .
- Seleziona Avanti nel passaggio Informazioni sul collegamento di Firebase a BigQuery .
- Nella sezione Configura integrazione , fai clic sull'interruttore per abilitare l'invio di dati di Google Analytics e seleziona Collega a BigQuery .
Ora hai abilitato il tuo progetto della console Firebase per inviare automaticamente i dati degli eventi Firebase Analytics a Big Query. Ciò avviene automaticamente senza alcuna ulteriore interazione, tuttavia, la prima esportazione che crea il set di dati di analisi in BigQuery potrebbe non avvenire prima di 24 ore. Dopo aver creato il set di dati, Firebase esporta continuamente nuovi eventi Analytics in Big Query nella tabella intraday e raggruppa gli eventi dei giorni passati nella tabella degli eventi.
L'addestramento 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. Utilizza BigQuery per ottenere 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 console BigQuery da utilizzare per addestrare il nostro modello di consigli.
Importa il set di dati di esempio in BigQuery
- Vai alla dashboard BigQuery nella console cloud di Google.
- Seleziona il nome del tuo progetto nel menu.
- Seleziona il nome del tuo progetto nella parte inferiore della barra di navigazione a sinistra di BigQuery per visualizzare i dettagli.
- Selezionare Crea set di dati per aprire il pannello di creazione del set di dati.
- Inserisci "firebase_recommendations_dataset" come ID del set di dati e seleziona Crea set di dati .
- Il nuovo set di dati verrà visualizzato nel menu a sinistra sotto il nome del progetto. Cliccalo.
- Seleziona Crea tabella per aprire il pannello di creazione della tabella.
- Per Crea tabella da seleziona "Google Cloud Storage".
- Nel campo Seleziona file dal bucket GCS , inserisci "gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt".
- Seleziona "JSONL" nel menu a discesa Formato file .
- Inserisci "tabella_raccomandazioni" come nome della tabella .
- Seleziona la casella in Schema > Rilevamento automatico > Schema e parametri di input
- 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.
- Seleziona firebase-recommendations-dataset nel menu a sinistra per espandere le tabelle in esso contenute.
- Seleziona la tabella della tabella dei consigli per visualizzare lo schema della tabella.
- Seleziona Anteprima per visualizzare i dati effettivi degli eventi Analytics contenuti in questa tabella.
Crea le credenziali dell'account di servizio
Ora creeremo le credenziali dell'account di servizio nel nostro progetto della console Google Cloud che potremo utilizzare nell'ambiente Colab nel passaggio successivo per accedere e caricare i nostri dati BigQuery.
- Assicurati che la fatturazione sia abilitata per il tuo progetto Google Cloud.
- Abilita le API BigQuery e BigQuery Storage API. < clicca qui >
- Vai alla pagina Crea chiave account di servizio .
- Dall'elenco Account di servizio , seleziona Nuovo account di servizio .
- Nel campo Nome account di servizio , inserisci un nome.
- Dall'elenco Ruolo , seleziona Progetto > Proprietario .
- Fare clic su Crea . Un file JSON che contiene la chiave viene scaricato sul tuo computer.
Nel passaggio successivo utilizzeremo Google Colab per preelaborare questi dati e addestrare il nostro modello di consigli.
11. Preelaborazione dei dati e modello di raccomandazioni sul treno
In questo passaggio utilizzeremo un notebook Colab per eseguire i seguenti passaggi:
- importare i dati BigQuery nel notebook Colab
- preelaborare i dati per prepararli per l'addestramento del modello
- addestrare il modello di raccomandazioni sui dati di analisi
- esportare il modello come modello TF Lite
- distribuisci il modello sulla console Firebase in modo da poterlo utilizzare nella nostra app
Prima di lanciare il notebook di formazione Colab, abiliteremo innanzitutto l'API Firebase Model Management in modo che Colab possa distribuire il modello addestrato sulla nostra console Firebase.
Abilita l'API di gestione dei modelli Firebase
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.
Utilizza il notebook Colab per addestrare e distribuire il modello
Apri il notebook Colab utilizzando il collegamento seguente e completa i passaggi all'interno. Dopo aver completato i passaggi nel notebook Colab, avrai un file del modello TF lite distribuito sulla console Firebase che potremo 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 che abbiamo appena addestrato da Firebase Machine Learning.
Aggiungi la dipendenza Firebase ML
La seguente dipendenza è necessaria per utilizzare i modelli Firebase Machine Learning nella tua app. Dovrebbe essere già aggiunto (verifica).
app/build.grade.kts
implementation("com.google.firebase:firebase-ml-modeldownloader:24.1.2")
Scarica il modello con l'API Firebase Model Manager
Copia il codice seguente in RecommendationClient.kt per impostare le condizioni in cui avviene il download del modello e creare un'attività di download per sincronizzare il modello remoto con la nostra app.
RecommendationClient.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, prima caricheremo un dizionario ed etichette per accompagnare il nostro modello nella fase di inferenza, quindi aggiungeremo la pre-elaborazione per generare gli input per il nostro modello e la post-elaborazione in cui estrarremo i risultati dalla nostra inferenza .
Carica dizionario ed etichette
Le etichette utilizzate per generare i candidati alla raccomandazione dal modello delle raccomandazioni sono elencate nel file sorted_movie_vocab.json nella cartella res/assets. Copia il seguente codice per caricare questi candidati.
RecommendationClient.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 da parte degli utenti. Copia il codice qui sotto:
RecommendationClient.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 l'interprete per generare consigli
Qui utilizziamo il modello 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 seguente codice nella tua app.
RecommendationClient.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-elaboriamo l'output del nostro modello, selezionando i risultati con la massima sicurezza e rimuovendo i valori contenuti (film che sono già piaciuti all'utente). Copia il seguente codice nella tua app.
RecommendationClient.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 l'app. Quando selezioni alcuni film, dovrebbe scaricare automaticamente il nuovo modello e iniziare a generare consigli!
14. Congratulazioni!
Hai integrato una funzionalità di consigli nella tua app utilizzando TensorFlow Lite e Firebase. Tieni presente che le tecniche e la pipeline mostrate in questo codelab possono essere generalizzate e utilizzate anche per servire altri tipi di raccomandazioni.
Di cosa abbiamo parlato
- FirebaseML
- Analisi Firebase
- Esporta eventi di analisi in BigQuery
- Preelaborare gli eventi di analisi
- Raccomandazioni per il treno Modello TensorFlow
- Esporta il modello e distribuiscilo nella console Firebase
- Fornisci consigli sui film in un'app
Prossimi passi
- Implementa i consigli Firebase ML nella tua app.