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 consigli da tali dati e quindi utilizzare quel modello in un'app iOS 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
- Xcode 11 (o successivo)
- CocoaPods 1.9.1 (o successiva)
Come utilizzerai questo tutorial?
Come valuteresti la tua esperienza con la creazione di app iOS?
2. Crea un progetto della console Firebase
Aggiungi Firebase al progetto
- Vai alla console Firebase .
- Seleziona Crea nuovo progetto e dai un nome al tuo progetto "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 git installato, puoi anche scaricare il progetto di esempio dalla sua pagina GitHub o facendo clic su questo collegamento . Una volta scaricato il progetto, eseguilo in Xcode e gioca con i consigli per avere un'idea di come funziona.
Configura Firebase
Segui la documentazione per creare un nuovo progetto Firebase. Una volta ottenuto il progetto, scarica il file GoogleService-Info.plist del progetto dalla console Firebase e trascinalo nella radice del progetto Xcode.
Aggiungi Firebase al tuo Podfile ed esegui l'installazione pod.
pod 'FirebaseAnalytics' pod 'FirebaseMLModelDownloader', '9.3.0-beta' pod 'TensorFlowLiteSwift'
Nel metodo didFinishLaunchingWithOptions di AppDelegate , importa Firebase nella parte superiore del file
import FirebaseCore
E aggiungi una chiamata per configurare Firebase.
FirebaseApp.configure()
Esegui nuovamente il progetto per assicurarti che l'app sia configurata correttamente e non si blocchi all'avvio.
- 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).
4. 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.
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 il codice seguente per registrare un evento di analisi quando l'utente fa clic su Mi piace su 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. 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
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 sul tuo dispositivo di sviluppo, specifica il seguente argomento della riga di comando in Xcode:
-FIRDebugEnabled
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 Xcode, seleziona Esegui per avviare l'app e aggiungere alcuni film all'elenco dei preferiti.
- Nel DebugView della console Firebase, verifica che questi eventi vengano registrati quando aggiungi film nell'app.
6. 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.
7. 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.
8. Preelaborazione dei dati e modello di raccomandazioni del 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
9. 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).
Podfile
import FirebaseCore
import FirebaseMLModelDownloader
Scarica il modello con l'API Firebase Model Manager
Copia il codice seguente in ModelLoader.swift 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.
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 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 ai consigli dal modello dei consigli sono elencate nel file sorted_movie_vocab.json nella cartella asset. Copia il seguente codice per caricare questi candidati.
RaccomandazioniViewController.swift
func getMovies() -> [MovieItem] {
let barController = self.tabBarController as! TabBarController
return barController.movies
}
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:
RaccomandazioniViewController.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 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.
RaccomandazioniViewController.swift
import TensorFlowLite
RaccomandazioniViewController.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 sicurezza e rimuovendo i valori contenuti (film che sono già piaciuti all'utente). Copia il seguente codice nella tua app.
RaccomandazioniViewController.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]))
}
}
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!
11. 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.
Saperne di più
Hai una domanda?
Segnala problemi