1. Panoramica
|
|
Ti diamo il benvenuto nel codelab Suggerimenti con TensorFlow Lite e Firebase. In questo codelab imparerai a utilizzare TensorFlow Lite e Firebase per eseguire il deployment di un modello di consigli nella tua app. Questo codelab si basa su questo esempio di TensorFlow Lite.
I consigli consentono alle app di utilizzare il machine learning per mostrare in modo intelligente i contenuti più pertinenti per ogni utente. Prendono in considerazione il comportamento passato degli utenti per suggerire i contenuti dell'app con cui l'utente potrebbe interagire in futuro utilizzando un modello addestrato sul comportamento aggregato di un gran numero di altri utenti.
Questo tutorial mostra come ottenere i dati degli utenti della tua app con Firebase Analytics, creare un modello di machine learning per i consigli a partire da questi dati e poi utilizzare il modello in un'app per iOS per eseguire l'inferenza e ottenere i consigli. In particolare, i nostri consigli suggeriranno i film che un utente ha più probabilità di guardare in base all'elenco dei film che ha apprezzato in precedenza.
Obiettivi didattici
- Integrare Firebase Analytics in un'app per Android per raccogliere i dati sul comportamento degli utenti
- Esportare questi dati in Google BigQuery
- Preelabora i dati e addestra un modello di suggerimenti TF Lite
- Esegui il deployment del modello TF Lite su Firebase ML e accedi da un'app
- Esegui l'inferenza sul dispositivo utilizzando il modello per suggerire consigli agli utenti
Che cosa ti serve
- Xcode 11 (o versioni successive)
- CocoaPods 1.9.1 o versioni successive
Come utilizzerai questo tutorial?
Come valuteresti la tua esperienza di creazione di app per iOS?
2. Crea un progetto nella console Firebase
Aggiungi Firebase al progetto
- Vai alla Console Firebase.
- Seleziona Crea nuovo progetto e assegna al progetto il nome "Firebase ML iOS Codelab".
3. Ottieni il progetto di esempio
Scarica il codice
Inizia clonando il progetto di esempio ed eseguendo pod update nella directory del progetto:
git clone https://github.com/FirebaseExtended/codelab-contentrecommendation-ios.git cd codelab-contentrecommendation-ios/start pod install --repo-update
Se non hai installato git, puoi anche scaricare il progetto di esempio dalla relativa pagina GitHub o facendo clic su questo link. Dopo aver scaricato il progetto, eseguilo in Xcode e prova il suggerimento per capire come funziona.
Configura Firebase
Segui la documentazione per creare un nuovo progetto Firebase. Una volta creato il progetto, scarica il file GoogleService-Info.plist del progetto dalla console Firebase e trascinalo nella root del progetto Xcode.
Aggiungi Firebase al tuo podfile ed esegui pod install.
pod 'FirebaseAnalytics' pod 'FirebaseMLModelDownloader', '9.3.0-beta' pod 'TensorFlowLiteSwift'
Nel metodo didFinishLaunchingWithOptions di AppDelegate, importa Firebase all'inizio del file
import FirebaseCore
e aggiungi una chiamata per configurare Firebase.
FirebaseApp.configure()
Esegui di nuovo il progetto per assicurarti che l'app sia configurata correttamente e non si arresti in modo anomalo all'avvio.
- Assicurati che l'opzione "Abilita Google Analytics per questo progetto" sia attivata.
- Segui i passaggi di configurazione rimanenti nella console Firebase, quindi fai clic su Crea progetto (o Aggiungi Firebase, se utilizzi un progetto Google esistente).
4. Aggiungere Firebase Analytics all'app
In questo passaggio, aggiungerai Firebase Analytics all'app per registrare i dati sul comportamento degli utenti (in questo caso, i film che piacciono a un utente). Questi dati verranno utilizzati in forma aggregata nei passaggi futuri per addestrare il modello di consigli.
Configurare Firebase Analytics nell'app
LikedMoviesViewModel contiene funzioni per memorizzare i film che piacciono all'utente. Ogni volta che l'utente mette Mi piace a un nuovo film, vogliamo inviare anche un evento di log di Analytics per registrare il Mi piace.
Aggiungi il codice riportato di seguito per registrare un evento Analytics quando l'utente mette Mi piace a un film.
AllMoviesCollectionViewController.swift
import FirebaseAnalytics
//
override func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
//
if movie.liked == nil {
movie.liked = true
Analytics.logEvent(AnalyticsEventSelectItem, parameters: [AnalyticsParameterItemID: movie.id])
} else {
movie.liked?.toggle()
}
}
5. Testare l'integrazione di Analytics
In questo passaggio, genereremo eventi Analytics nell'app e verificheremo che vengano inviati alla console Firebase.
Attivare la registrazione di debug di Analytics
In genere, gli eventi registrati dalla tua app vengono raggruppati in batch per un periodo di circa un'ora e caricati insieme. Questo approccio consente di risparmiare la batteria dei dispositivi degli utenti finali e di ridurre l'utilizzo dei dati di rete. Tuttavia, ai fini della convalida dell'implementazione di Analytics (e per visualizzare i dati di Analytics nel report DebugView), puoi attivare la modalità di debug sul tuo dispositivo di sviluppo per caricare gli eventi con un ritardo minimo.
Per attivare la modalità di debug di Analytics sul tuo dispositivo di sviluppo, specifica il seguente argomento della riga di comando in Xcode:
-FIRDebugEnabled
A questo punto, hai integrato correttamente Firebase Analytics nella tua app. Man mano che gli utenti utilizzano la tua app e mettono Mi piace ai 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. Il seguente è un passaggio facoltativo per visualizzare gli stessi eventi Analytics che hai visto in Logcat anche in streaming nella console Firebase. Puoi passare alla pagina successiva.
(Facoltativo) Conferma gli eventi Analytics nella console Firebase
- Vai alla Console Firebase.
- Seleziona DebugView in Analytics
- In Xcode, seleziona Run (Esegui) per avviare l'app e aggiungere alcuni film all'elenco Mi piace.
- In DebugView della console Firebase, verifica che questi eventi vengano registrati mentre aggiungi film nell'app.
6. Esportare i dati di Analytics in BigQuery
BigQuery è un prodotto Google Cloud che consente di esaminare ed elaborare grandi quantità di dati. In questo passaggio, collegherai il progetto della console Firebase a BigQuery in modo che i dati di Analytics generati dalla tua app vengano esportati automaticamente in BigQuery.
Attiva BigQuery Export
- Vai alla Console Firebase.
- Seleziona l'icona a forma di ingranaggio Impostazioni accanto a Panoramica del 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 sul pulsante per attivare l'invio dei dati di Google Analytics e seleziona Collega a BigQuery.
Ora hai attivato l'invio automatico dei dati degli eventi di Firebase Analytics a BigQuery per il tuo progetto della console Firebase. Questa operazione avviene automaticamente senza ulteriori interazioni, tuttavia la prima esportazione che crea il set di dati Analytics in BigQuery potrebbe non avvenire per 24 ore. Dopo la creazione del set di dati, Firebase esporta continuamente nuovi eventi Analytics in BigQuery nella tabella infragiornaliera e raggruppa gli eventi dei giorni precedenti nella tabella degli eventi.
L'addestramento di un modello di consigli richiede molti dati. Poiché non abbiamo ancora 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.
7. Utilizzare BigQuery per ottenere i dati di addestramento del modello
Ora che abbiamo collegato la Console Firebase per l'esportazione in BigQuery, i dati degli eventi di analisi delle 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 suggerimenti.
Importare il set di dati di esempio in BigQuery
- Vai alla dashboard BigQuery nella console Google Cloud.
- Seleziona il nome del progetto nel menu.
- Seleziona il nome del tuo progetto nella parte inferiore del riquadro di navigazione a sinistra di BigQuery per visualizzare i dettagli.
- Seleziona Crea set di dati per aprire il riquadro di creazione del set di dati.
- Inserisci "firebase_recommendations_dataset" per l'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. Fai clic sull'icona.
- Seleziona Crea tabella per aprire il riquadro 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 Nome tabella.
- Seleziona la casella in Schema > Rilevamento automatico > Parametri di schema e input.
- Seleziona Crea tabella.
Esplora il set di dati di esempio
A questo punto, puoi facoltativamente esplorare lo schema e visualizzare l'anteprima di questo set di dati.
- Seleziona firebase-recommendations-dataset nel menu a sinistra per espandere le tabelle che contiene.
- Seleziona la tabella recommendations-table per visualizzare lo schema della tabella.
- Seleziona Anteprima per visualizzare i dati effettivi degli eventi Analytics contenuti in questa tabella.
Crea le credenziali del service account
Ora creeremo le credenziali dell'account di servizio nel progetto della console Google Cloud che potremo utilizzare nell'ambiente Colab nel passaggio successivo per accedere ai dati BigQuery e caricarli.
- Verifica che la fatturazione sia attivata per il tuo progetto Google Cloud.
- Abilita le API BigQuery e BigQuery Storage. < fai clic qui>
- Vai alla pagina Crea chiave service account.
- Nell'elenco Service account, seleziona Nuovo service account.
- Nel campo Nome service account, inserisci un nome.
- Nell'elenco Ruolo, seleziona Progetto > Proprietario.
- Fai clic su Crea. Un file JSON contenente la chiave viene scaricato sul computer.
Nel passaggio successivo, utilizzeremo Google Colab per preelaborare questi dati e addestrare il nostro modello di consigli.
8. Preelabora i dati e addestra il modello di consigli
In questo passaggio, utilizzeremo un blocco note Colab per eseguire i seguenti passaggi:
- importa i dati BigQuery nel notebook Colab
- pre-elaborare i dati per prepararli all'addestramento del modello
- addestrare il modello di consigli sui dati di analisi
- esportare il modello come modello TF Lite
- esegui il deployment del modello nella console Firebase in modo da poterlo utilizzare nella nostra app
Prima di lanciare il notebook di addestramento Colab, attiveremo l'API Firebase Model Management in modo che Colab possa eseguire il deployment del modello addestrato nella nostra console Firebase.
Abilita l'API Firebase Model Management
Crea un bucket per archiviare i modelli ML
Nella console Firebase, vai a Storage e fai clic su Inizia. 
Segui la finestra di dialogo per configurare il bucket.
Abilitare l'API Firebase ML
Vai alla pagina dell'API Firebase ML nella console Google Cloud e fai clic su Abilita.
Utilizza il notebook Colab per addestrare ed eseguire il deployment del modello
Apri il notebook Colab utilizzando il seguente link e completa i passaggi. Dopo aver completato i passaggi nel blocco note Colab, nella console Firebase verrà eseguito il deployment di un file del modello TF Lite che possiamo sincronizzare con la nostra app.
Apri in Colab
9. Scaricare il modello nell'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à stata aggiunta (verifica).
Podfile
import FirebaseCore
import FirebaseMLModelDownloader
Scaricare il modello con l'API Firebase Model Manager
Copia il codice riportato di seguito in ModelLoader.swift per configurare le condizioni in cui viene eseguito il download del modello e creare un'attività di download per sincronizzare il modello remoto con la nostra app.
ModelLoader.swift
static func downloadModel(named name: String,
completion: @escaping (CustomModel?, DownloadError?) -> Void) {
guard FirebaseApp.app() != nil else {
completion(nil, .firebaseNotInitialized)
return
}
guard success == nil && failure == nil else {
completion(nil, .downloadInProgress)
return
}
let conditions = ModelDownloadConditions(allowsCellularAccess: false)
ModelDownloader.modelDownloader().getModel(name: name, downloadType: .localModelUpdateInBackground, conditions: conditions) { result in
switch (result) {
case .success(let customModel):
// Download complete.
// The CustomModel object contains the local path of the model file,
// which you can use to instantiate a TensorFlow Lite classifier.
return completion(customModel, nil)
case .failure(let error):
// Download was unsuccessful. Notify error message.
completion(nil, .downloadFailed(underlyingError: error))
}
}
}
10. Integra il modello di suggerimenti TensorFlow Lite nella tua app
TensorFlow Lite runtime ti consentirà di utilizzare il modello nell'app per generare consigli. Nel passaggio precedente abbiamo inizializzato un interprete TFlite con il file del modello scaricato. In questo passaggio, caricheremo prima un dizionario e le etichette da accompagnare al nostro modello nel passaggio di inferenza, poi aggiungeremo la pre-elaborazione per generare gli input del nostro modello e la post-elaborazione in cui estrarremo i risultati dell'inferenza.
Carica dizionario ed etichette
Le etichette utilizzate per generare i candidati per i suggerimenti dal modello di suggerimenti sono elencate nel file sorted_movie_vocab.json nella cartella degli asset. Copia il seguente codice per caricare questi candidati.
RecommendationsViewController.swift
func getMovies() -> [MovieItem] {
let barController = self.tabBarController as! TabBarController
return barController.movies
}
Implementare la pre-elaborazione
Nel passaggio di pre-elaborazione, modifichiamo la forma dei dati di input in modo che corrispondano a quelli previsti dal nostro modello. Qui, riempiamo la lunghezza dell'input con un valore segnaposto se non abbiamo ancora generato molti Mi piace degli utenti. Copia il codice riportato di seguito:
RecommendationsViewController.swift
// Given a list of selected items, preprocess to get tflite input.
func preProcess() -> Data {
let likedMovies = getLikedMovies().map { (MovieItem) -> Int32 in
return MovieItem.id
}
var inputData = Data(copyingBufferOf: Array(likedMovies.prefix(10)))
// Pad input data to have a minimum of 10 context items (4 bytes each)
while inputData.count < 10*4 {
inputData.append(0)
}
return inputData
}
Esegui l'interprete per generare consigli
Qui utilizziamo il modello scaricato in un passaggio precedente per eseguire l'inferenza sull'input pre-elaborato. Impostiamo il tipo di input e output per il nostro modello ed eseguiamo l'inferenza per generare i nostri suggerimenti sui film. Copia il seguente codice nella tua app.
RecommendationsViewController.swift
import TensorFlowLite
RecommendationsViewController.swift
private var interpreter: Interpreter?
func loadModel() {
// Download the model from Firebase
print("Fetching recommendations model...")
ModelDownloader.fetchModel(named: "recommendations") { (filePath, error) in
guard let path = filePath else {
if let error = error {
print(error)
}
return
}
print("Recommendations model download complete")
self.loadInterpreter(path: path)
}
}
func loadInterpreter(path: String) {
do {
interpreter = try Interpreter(modelPath: path)
// Allocate memory for the model's input `Tensor`s.
try interpreter?.allocateTensors()
let inputData = preProcess()
// Copy the input data to the input `Tensor`.
try self.interpreter?.copy(inputData, toInputAt: 0)
// Run inference by invoking the `Interpreter`.
try self.interpreter?.invoke()
// Get the output `Tensor`
let confidenceOutputTensor = try self.interpreter?.output(at: 0)
let idOutputTensor = try self.interpreter?.output(at: 1)
// Copy output to `Data` to process the inference results.
let confidenceOutputSize = confidenceOutputTensor?.shape.dimensions.reduce(1, {x, y in x * y})
let idOutputSize = idOutputTensor?.shape.dimensions.reduce(1, {x, y in x * y})
let confidenceResults =
UnsafeMutableBufferPointer<Float32>.allocate(capacity: confidenceOutputSize!)
let idResults =
UnsafeMutableBufferPointer<Int32>.allocate(capacity: idOutputSize!)
_ = confidenceOutputTensor?.data.copyBytes(to: confidenceResults)
_ = idOutputTensor?.data.copyBytes(to: idResults)
postProcess(idResults, confidenceResults)
print("Successfully ran inference")
DispatchQueue.main.async {
self.tableView.reloadData()
}
} catch {
print("Error occurred creating model interpreter: \(error)")
}
}
Implementare la post-elaborazione
Infine, in questo passaggio post-elaboriamo l'output del nostro modello, selezionando i risultati con la massima confidenza e rimuovendo i valori contenuti (i film che l'utente ha già apprezzato). Copia il seguente codice nella tua app.
RecommendationsViewController.swift
// Postprocess to get results from tflite inference.
func postProcess(_ idResults: UnsafeMutableBufferPointer<Int32>, _ confidenceResults: UnsafeMutableBufferPointer<Float32>) {
for i in 0..<10 {
let id = idResults[i]
let movieIdx = getMovies().firstIndex { $0.id == id }
let title = getMovies()[movieIdx!].title
recommendations.append(Recommendation(title: title, confidence: confidenceResults[i]))
}
}
Testa l'app.
Esegui di nuovo l'app. Quando selezioni alcuni film, il nuovo modello dovrebbe essere scaricato automaticamente e iniziare a generare consigli.
11. Complimenti!
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 pubblicare altri tipi di consigli.
Argomenti trattati
- Firebase ML
- Firebase Analytics
- Esportare gli eventi di analisi in BigQuery
- Preelaborare gli eventi di analisi
- Addestra il modello TensorFlow di suggerimenti
- Esportare il modello ed eseguirne il deployment nella console Firebase
- Mostrare consigli sui film in un'app
Passaggi successivi
- Implementa i consigli di Firebase ML nella tua app.
Scopri di più
Hai una domanda?
Segnala problemi