1. Panoramica
|
|
Benvenuto nelle Raccomandazioni con il codelab TensorFlow Lite e Firebase. 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 il machine learning per offrire in modo intelligente i contenuti più pertinenti per ciascun utente. Prendono in considerazione il comportamento passato dell'utente 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 utilizzare tale 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 dei film che l'utente ha gradito 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-elaborare i dati e addestrare un modello di raccomandazioni TF Lite
- Distribuisci il modello TF Lite in Firebase ML e accedi dall'app
- Esegui sull'inferenza del dispositivo utilizzando il modello per suggerire consigli agli utenti
Di cosa avrai bisogno
- Android Studio versione 3.4+.
- Codice d'esempio.
- Un dispositivo di prova con Android 2.3+ e Google Play Services 9.8 o successivo oppure un emulatore con Google Play Services 9.8 o successivo
- Se si utilizza un dispositivo, un cavo di connessione.
Come utilizzerai questo tutorial?
Come valuteresti la tua esperienza con la creazione di app Android?
2. Ottieni il codice di esempio
Clonare 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 il progetto della console Firebase
Crea un nuovo progetto
- Vai alla console di Firebase .
- Seleziona Aggiungi progetto (o Crea un progetto se è il primo).
- Seleziona o inserisci un nome per il progetto e fai clic su Continua .
- Assicurati che "Abilita Google Analytics per questo progetto" sia abilitato.
- Segui i passaggi di configurazione rimanenti nella console Firebase, quindi fai clic su Crea progetto (o Aggiungi Firebase, se stai utilizzando un progetto Google esistente).
5. Aggiungi Firebase
- Dalla schermata panoramica del tuo nuovo progetto, fai clic sull'icona di 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 aver 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 che il file è stato scaricato puoi saltare i passaggi successivi mostrati nella console (sono già stati fatti 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 in modo che utilizzi Firebase. Le seguenti righe dovrebbero già essere aggiunte ai file build.gradle nel progetto (selezionare per confermare):
app/build.grado
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. Eseguire l'app iniziale
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 ( 
) 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 Mi piace. 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 consigli.
Aggiungi dipendenza 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.grado
implementation 'com.google.firebase:firebase-analytics-ktx:21.1.0'
Configura Firebase Analytics nell'app
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 log di analisi per registrare quel like.
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.
LikeMoviesViewModel.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 di Analytics quando un film viene aggiunto all'elenco dei Mi piace dell'utente.
LikeMoviesViewModel.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 l'integrazione di 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. Per scopi di debug, possiamo disabilitare questo comportamento per vedere gli eventi mentre 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 correttamente 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 modo aggregato. Utilizzeremo questi dati aggregati nel resto di questo codelab per addestrare il nostro modello di suggerimenti. Di seguito è riportato un passaggio facoltativo per visualizzare gli stessi eventi di Analytics visualizzati in Logcat anche nella console Firebase. Sentiti libero di saltare alla pagina successiva.
Facoltativo: conferma gli eventi di Analytics nella console di Firebase
- Vai alla console di Firebase .
- Selezionare DebugView in Analytics
- In Android Studio, seleziona Esegui per avviare l'app e aggiungere alcuni film all'elenco dei Mi piace.
- 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
BigQuery è un prodotto Google Cloud che ti 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 automaticamente esportati in Big Query.
Abilita l'esportazione BigQuery
- Vai alla console di Firebase .
- Seleziona l'icona a forma di ingranaggio Impostazioni accanto a Panoramica progetto , 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 dei 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 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 prima di 24 ore. Dopo la creazione del set di dati, Firebase esporta continuamente nuovi eventi di Analytics in Big Query nella tabella intraday e raggruppa gli eventi dei giorni precedenti 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 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 di 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 suggerimenti.
Importa set di dati di esempio in BigQuery
- Vai alla dashboard di BigQuery nella console cloud di Google.
- Seleziona il nome del tuo progetto nel menu.
- Seleziona il nome del tuo progetto nella parte inferiore del riquadro 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 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.
- Selezionare 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 'recommendations_table' per il nome della tabella .
- Selezionare 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 che contiene.
- Selezionare la tabella delle raccomandazioni per visualizzare lo schema della tabella.
- Seleziona Anteprima per visualizzare i dati effettivi degli eventi di 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 possiamo 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 selezionare Progetto > Proprietario .
- Fai clic su Crea . Un file JSON che contiene i download della chiave sul tuo computer.
Nella fase successiva, utilizzeremo Google Colab per preelaborare questi dati e addestrare il nostro modello di consigli.
11. Preelaborare i dati e formare il modello di raccomandazione
In questo passaggio, utilizzeremo un taccuino Colab per eseguire i seguenti passaggi:
- importare i dati BigQuery nel taccuino Colab
- preelaborare i dati per prepararli per l'addestramento del modello
- addestrare il modello di raccomandazioni sui dati analitici
- esportare il modello come modello TF lite
- distribuisci il modello alla console Firebase in modo da poterlo utilizzare nella nostra app
Prima di lanciare il taccuino di formazione Colab, abiliteremo prima l'API Firebase Model Management in modo che Colab possa distribuire il modello addestrato alla nostra console Firebase.
Abilita l'API Firebase Model Management
Crea un bucket per archiviare i tuoi modelli ML
Nella tua console Firebase, vai su Archiviazione e fai clic su Inizia. 
Segui il dialogo per configurare il tuo bucket.
Abilita l'API Firebase ML
Vai alla pagina dell'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 collegamento e completa i passaggi all'interno. Dopo aver terminato i passaggi nel notebook Colab, avrai un file modello TF lite distribuito nella console Firebase che possiamo sincronizzare con la nostra app.
Aperto a 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 dipendenza Firebase ML
La seguente dipendenza è necessaria per utilizzare i modelli Firebase Machine Learning nella tua app. Dovrebbe essere già stato aggiunto (verificare).
app/build.grado
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 crea 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 del modello che abbiamo scaricato. In questo passaggio, caricheremo prima un dizionario e le 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 i candidati alla raccomandazione 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 ciò che si aspetta il nostro modello. Qui, riempiamo la lunghezza di 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
}
}
Eseguire l'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 seguente codice 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-elaboriamo l'output del nostro modello, selezionando i risultati con la massima sicurezza e rimuovendo i valori contenuti (film che l'utente ha già apprezzato). Copia il seguente codice 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!
Riesegui la tua app. Quando selezioni alcuni film, dovrebbe scaricare automaticamente il nuovo modello e iniziare a generare consigli!
14. Congratulazioni!
Hai creato 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 raccomandazioni.
Di cosa abbiamo parlato
- Base di fuoco ML
- Analisi Firebase
- Esporta gli eventi di analisi in BigQuery
- Preelaborare gli eventi di analisi
- Raccomandazioni del treno Modello TensorFlow
- Esporta il modello e implementalo nella console Firebase
- Offri consigli sui film in un'app
Prossimi passi
- Implementa i consigli di Firebase ML nella tua app.