1. Visão geral
|
|
Este é o codelab Recomendações com o TensorFlow Lite e o Firebase. Neste codelab, você aprenderá a usar o TensorFlow Lite e o Firebase para implantar um modelo de recomendação no seu app. Este codelab é baseado neste exemplo do TensorFlow Lite.
As recomendações permitem que os apps usem aprendizado de máquina para exibir de maneira inteligente o conteúdo mais relevante para cada usuário. Eles consideram o comportamento anterior do usuário para sugerir conteúdo do app com o qual o usuário pode gostar de interagir no futuro usando um modelo treinado no comportamento agregado de um grande número de outros usuários.
Neste tutorial, mostramos como receber dados dos usuários do seu aplicativo com o Firebase Analytics, criar um modelo de machine learning para recomendações desses dados e usar esse modelo em um app iOS para executar inferência e receber recomendações. Em particular, nossas recomendações sugerirão quais filmes um usuário provavelmente assistiria, dada a lista de filmes de que o usuário gostou anteriormente.
O que você vai aprender
- Integrar o Firebase Analytics a um app Android para coletar dados de comportamento do usuário
- Exportar os dados para o Google BigQuery
- Pré-processar os dados e treinar um modelo de recomendações do TF Lite
- Implante o modelo do TF Lite no Firebase ML e acesse-o pelo app
- Executar na inferência do dispositivo usando o modelo para sugerir recomendações aos usuários
Pré-requisitos
- Xcode 11 (ou versão mais recente)
- CocoaPods 1.9.1 (ou versão mais recente)
Como você usará este tutorial?
Como você classificaria sua experiência com a criação de apps iOS?
2. Criar projeto do console do Firebase
Adicionar o Firebase ao projeto
- Acesse o Console do Firebase.
- Selecione Criar novo projeto e dê o nome "Firebase ML iOS Codelab".
3. Acessar o projeto de amostra
Faça o download do código
Comece clonando o projeto de exemplo e executando pod update no diretório do projeto:
git clone https://github.com/FirebaseExtended/codelab-contentrecommendation-ios.git cd codelab-contentrecommendation-ios/start pod install --repo-update
Se você não tiver o git instalado, faça o download do projeto de exemplo na página do GitHub ou clique neste link (link em inglês). Depois de fazer o download do projeto, execute-o no Xcode e teste a recomendação para ter uma ideia de como ele funciona.
Configurar o Firebase
Siga a documentação para criar um novo projeto do Firebase. Quando tiver seu projeto, faça o download do arquivo GoogleService-Info.plist dele no Console do Firebase e arraste-o para a raiz do projeto Xcode.
Adicione o Firebase ao seu Podfile e execute a instalação do pod.
pod 'FirebaseAnalytics' pod 'FirebaseMLModelDownloader', '9.3.0-beta' pod 'TensorFlowLiteSwift'
No método didFinishLaunchingWithOptions do AppDelegate, importe o Firebase na parte de cima do arquivo
import FirebaseCore
E adicione uma chamada para configurar o Firebase.
FirebaseApp.configure()
Execute o projeto novamente para garantir que o app esteja configurado corretamente e não apresente falhas na inicialização.
- Certifique-se de que a opção "Ativar o Google Analytics para este projeto" está ativado.
- Siga as demais etapas de configuração no Console do Firebase e clique em Criar projeto (ou Adicionar Firebase, se estiver usando um projeto atual do Google).
4. Adicionar o Firebase Analytics ao app
Nesta etapa, você adicionará o Firebase Analytics ao app para registrar dados de comportamento do usuário (nesse caso, de quais filmes ele gosta). Esses dados serão usados de forma agregada em etapas futuras para treinar o modelo de recomendações.
Configurar o Firebase Analytics no app
O LikedMoviesViewModel contém funções para armazenar os filmes de que o usuário gosta. Sempre que o usuário gosta de um novo filme, queremos enviar também um evento de registro do Analytics para registrar isso.
Adicione o código abaixo para registrar um evento de análise quando o usuário clicar como em um filme.
AllMoviesCollectionViewController.swift (em inglês)
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. Testar sua integração com o Google Analytics
Nesta etapa, vamos gerar eventos do Analytics no app e verificar se eles estão sendo enviados para o Console do Firebase.
Ativar os registros de depuração do Analytics
Em geral, os eventos registrados pelo app são agrupados durante aproximadamente uma hora e enviados juntos. Essa abordagem economiza a bateria dos usuários finais e reduz o uso de dados de rede. No entanto, para validar sua implementação de análise e visualizá-la no relatório do DebugView, você pode ativar o modo de depuração no seu dispositivo de desenvolvimento para fazer upload de eventos com um atraso mínimo.
Para ativar o modo de Depuração do Analytics no seu dispositivo de desenvolvimento, especifique o seguinte argumento de linha de comando no Xcode:
-FIRDebugEnabled
Neste ponto, você integrou o Firebase Analytics ao seu aplicativo. À medida que os usuários usam seu app e gostam de filmes, as marcações "Gostei" são registradas de forma agregada. Usaremos esses dados agregados no restante deste codelab para treinar nosso modelo de recomendações. Confira a seguir uma etapa opcional para que os mesmos eventos do Analytics que você viu no Logcat também sejam transmitidos para o Console do Firebase. Se quiser, pule para a próxima página.
Opcional: confirme eventos do Google Analytics no Console do Firebase
- Acesse o Console do Firebase.
- Selecione DebugView no Google Analytics.
- No Xcode, selecione Run para iniciar o app e adicionar alguns filmes à sua lista de vídeos marcados com "Gostei".
- No DebugView do Console do Firebase, verifique se esses eventos estão sendo registrados à medida que você adiciona filmes ao app.
6. Exportar dados do Google Analytics para o BigQuery
O BigQuery é um produto do Google Cloud que permite analisar e processar grandes quantidades de dados. Nesta etapa, você conectará seu projeto do console do Firebase ao BigQuery para que os dados do Google Analytics gerados pelo seu aplicativo sejam exportados automaticamente para o BigQuery.
Ativar a exportação do BigQuery
- Acesse o Console do Firebase.
- Selecione o ícone de engrenagem ao lado de Visão geral do projeto e selecione Configurações do projeto.
- Selecione a guia Integrações.
- Selecione Vincular (ou Gerenciar) dentro do bloco BigQuery.
- Selecione Próxima na etapa Sobre a vinculação do Firebase ao BigQuery.
- Na seção Configurar integração, clique na chave para ativar o envio de dados do Google Analytics e selecione Vincular ao BigQuery.
Você ativou seu projeto do Console do Firebase para enviar automaticamente dados de eventos do Firebase Analytics ao BigQuery. Isso acontece automaticamente sem outras interações. No entanto, a primeira exportação que cria o conjunto de dados de análise no BigQuery pode levar 24 horas. Depois que o conjunto de dados é criado, o Firebase exporta continuamente novos eventos do Google Analytics para o BigQuery para a tabela intradiária e agrupa os eventos dos dias anteriores na tabela de eventos.
O treinamento de um modelo de recomendações requer muitos dados. Como ainda não temos um aplicativo que gere grandes quantidades de dados, na próxima etapa importaremos um conjunto de dados de amostra no BigQuery para usar no restante deste tutorial.
7. Usar o BigQuery para receber dados de treinamento de modelo
Agora que conectamos o console do Firebase para exportar para o BigQuery, os dados de eventos de análise de aplicativos serão exibidos automaticamente no console do BigQuery depois de algum tempo. Para conseguir alguns dados iniciais para a finalidade deste tutorial, nesta etapa vamos importar um conjunto de dados de amostra para o console do BigQuery a ser usado para treinar nosso modelo de recomendações.
Importar um conjunto de dados de amostra para o BigQuery
- Acesse o painel do BigQuery no console do Google Cloud.
- Selecione o nome do projeto no menu.
- Selecione o nome do seu projeto na parte de baixo da navegação à esquerda do BigQuery para conferir os detalhes.
- Selecione Criar conjunto de dados para abrir o painel de criação do conjunto de dados.
- Insira "firebase_recommendations_dataset". como ID do conjunto de dados e selecione Criar conjunto de dados.
- O novo conjunto de dados será exibido no menu à esquerda abaixo do nome do projeto. Clique nele.
- Selecione Criar tabela para abrir o painel de criação da tabela.
- Em Criar tabela de, selecione "Google Cloud Storage".
- No campo Selecionar arquivo do bucket do GCS, insira "gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt".
- Selecione "JSONL" no menu suspenso Formato do arquivo.
- Insira "recommendations_table" para o Nome da tabela.
- Marque a caixa em Esquema > Detectar automaticamente > parâmetros de esquema e entrada
- Selecione Criar tabela.
analisar um conjunto de dados de amostra
Neste ponto, você tem a opção de explorar o esquema e visualizar esse conjunto de dados.
- Selecione firebase-recommendations-dataset no menu à esquerda para expandir as tabelas contidas nele.
- Selecione a tabela recommendations-table para ver o esquema da tabela.
- Selecione Visualizar para conferir os dados reais de eventos do Google Analytics que essa tabela contém.
Criar credenciais de conta de serviço
Agora, vamos criar credenciais de conta de serviço no projeto do console do Google Cloud que podem ser usadas no ambiente do Colab na etapa a seguir para acessar e carregar dados do BigQuery.
- Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
- Ative as APIs BigQuery e BigQuery Storage. < clique aqui>
- Acesse a página Criar chave da conta de serviço.
- Na lista Conta de serviço, selecione Nova conta de serviço.
- No campo Nome da conta de serviço, insira um nome.
- Na lista Papel, selecione Projeto > Proprietário.
- Clique em Criar. O download de um arquivo JSON com sua chave é feito no seu computador.
Na próxima etapa, vamos usar o Google Colab para pré-processar esses dados e treinar nosso modelo de recomendações.
8. Pré-processar dados e treinar o modelo de recomendações
Nesta etapa, vamos usar um bloco do Colab para realizar as seguintes etapas:
- importar os dados do BigQuery para o bloco do Colab
- pré-processar os dados para prepará-los para o treinamento do modelo
- treinar o modelo de recomendações com os dados de análise
- exportar o modelo como um modelo do TF Lite
- implantar o modelo no console do Firebase para que possamos usá-lo no app
Antes de lançarmos o notebook de treinamento do Colab, vamos ativar a API Firebase Model Management para que o Colab possa implantar o modelo treinado no console do Firebase.
Ativar a API Firebase Model Management
Crie um bucket para armazenar seus modelos de ML
No Console do Firebase, acesse "Armazenamento" e clique em "Começar". 
Siga a caixa de diálogo para configurar o bucket.
Ativar a API Firebase ML
Acesse a página da API Firebase ML no console do Google Cloud e clique em "Ativar".
Usar o bloco do Colab para treinar e implantar o modelo
Abra o notebook do Colab usando o link a seguir e conclua as etapas. Depois de concluir as etapas no bloco do Colab, você terá um arquivo de modelo do TF Lite implantado no console do Firebase que podemos sincronizar com nosso aplicativo.
Abrir no Colab
9. Fazer o download do modelo no app
Nesta etapa, modificaremos nosso app para fazer o download do modelo que acabamos de treinar no Firebase Machine Learning.
Adicionar dependência do Firebase ML
A dependência a seguir é necessária para usar modelos de machine learning do Firebase no seu app. Ele já deve ter sido adicionado (verificar).
Podfile (link em inglês)
import FirebaseCore
import FirebaseMLModelDownloader
Faça o download do modelo com a API Firebase Model Manager
Copie o código abaixo em ModelLoader.swift para configurar as condições sob as quais o download do modelo ocorre e crie uma tarefa de download para sincronizar o modelo remoto com nosso app.
ModelLoader.swift (link em inglês)
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. Integrar o modelo de recomendação do Tensorflow Lite ao seu app
O ambiente de execução do Tensorflow Lite permite que você use seu modelo no app para gerar recomendações. Na etapa anterior, inicializamos um intérprete do TFlite com o arquivo de modelo baixado. Nesta etapa, primeiro carregaremos um dicionário e rótulos para acompanhar nosso modelo na etapa de inferência. Em seguida, adicionaremos o pré-processamento para gerar as entradas ao modelo e o pós-processamento para extrair os resultados da inferência.
Carregar dicionário e rótulos
Os rótulos usados para gerar os candidatos a recomendação pelo modelo estão listados no arquivo sorted_movie_vocab.json na pasta de recursos. Copie o código a seguir para carregar esses candidatos.
RecommendationsViewController.swift (em inglês)
func getMovies() -> [MovieItem] {
let barController = self.tabBarController as! TabBarController
return barController.movies
}
Implementar o pré-processamento
Na etapa de pré-processamento, mudamos a forma dos dados de entrada para corresponder ao que nosso modelo espera. Aqui, preenchemos o comprimento da entrada com um valor de marcador se ainda não tivermos gerado muitas curtidas do usuário. Copie o código abaixo:
RecommendationsViewController.swift (em inglês)
// 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
}
Executar um intérprete para gerar recomendações
Aqui, usamos o modelo baixado em uma etapa anterior para executar a inferência na entrada pré-processada. Definimos o tipo de entrada e saída para o nosso modelo e executamos a inferência para gerar nossas recomendações de filmes. Copie o código a seguir no seu app.
RecommendationsViewController.swift (em inglês)
import TensorFlowLite
RecommendationsViewController.swift (em inglês)
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)")
}
}
Implementar o pós-processamento
Por fim, nesta etapa, pós-processamos a saída do nosso modelo, selecionando os resultados com maior confiança e removendo os valores contidos (filmes que o usuário já gostou). Copie o código a seguir no seu app.
RecommendationsViewController.swift (em inglês)
// 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]))
}
}
Teste seu app.
Execute o app novamente. Conforme você seleciona alguns filmes, o download do novo modelo é automático e as recomendações começam a ser geradas.
11. Parabéns!
Você criou um recurso de recomendações no app usando o TensorFlow Lite e o Firebase. As técnicas e o pipeline mostrados neste codelab podem ser generalizados e usados para atender a outros tipos de recomendações.
O que vimos
- Firebase ML
- Firebase Analytics
- Exportar eventos de análise para o BigQuery
- Pré-processar eventos de análise
- Treinar o modelo do TensorFlow de recomendações
- Exportar modelo e implantar no Console do Firebase
- Exibir recomendações de filmes em um app
Próximas etapas
- Implemente as recomendações do Firebase ML no seu app.
Saiba mais
Perguntas?
Informar problemas