1. Visão Geral
|
|
Bem-vindo ao codelab Recomendações com TensorFlow Lite e 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 aplicativos usem aprendizado de máquina para fornecer de forma inteligente o conteúdo mais relevante para cada usuário. Eles levam em consideração o comportamento passado do usuário para sugerir o conteúdo do aplicativo com o qual o usuário gostaria de interagir no futuro, usando um modelo treinado no comportamento agregado de um grande número de outros usuários.
Este tutorial mostra como obter dados dos usuários do seu aplicativo com o Firebase Analytics, criar um modelo de aprendizado de máquina para recomendações desses dados e, em seguida, usar esse modelo em um aplicativo iOS para executar inferências e obter recomendações. Em particular, nossas recomendações sugerirão quais filmes um usuário provavelmente assistiria, dada a lista de filmes que o usuário gostou anteriormente.
O que você aprenderá
- Integre o Firebase Analytics a um aplicativo Android para coletar dados de comportamento do usuário
- Exporte esses dados para o Google Big Query
- Pré-processe os dados e treine um modelo de recomendações do TF Lite
- Implante o modelo TF Lite no Firebase ML e acesse-o no seu aplicativo
- Execute a inferência do dispositivo usando o modelo para sugerir recomendações aos usuários
O que você precisará
- Xcode 11 (ou superior)
- CocoaPods 1.9.1 (ou superior)
Como você usará este tutorial?
Como avaliaria sua experiência com a criação de aplicativos iOS?
2. Crie um projeto de console do Firebase
Adicione o Firebase ao projeto
- Vá para o console do Firebase .
- Selecione Criar novo projeto e nomeie seu projeto como "Firebase ML iOS Codelab".
3. Obtenha o projeto de amostra
Baixe o código
Comece clonando o projeto de amostra 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, também poderá baixar o projeto de amostra na página do GitHub ou clicando neste link . Depois de baixar o projeto, execute-o no Xcode e experimente a recomendação para ter uma ideia de como ele funciona.
Configurar o Firebase
Siga a documentação para criar um novo projeto Firebase. Depois de obter seu projeto, baixe o arquivo GoogleService-Info.plist do console do Firebase e arraste-o para a raiz do projeto Xcode.
Adicione o Firebase ao seu Podfile e execute pod install.
pod 'FirebaseAnalytics' pod 'FirebaseMLModelDownloader', '9.3.0-beta' pod 'TensorFlowLiteSwift'
No método didFinishLaunchingWithOptions do seu AppDelegate , importe o Firebase na parte superior do arquivo
import FirebaseCore
E adicione uma chamada para configurar o Firebase.
FirebaseApp.configure()
Execute o projeto novamente para garantir que o aplicativo esteja configurado corretamente e não trave na inicialização.
- Certifique-se de que "Ativar Google Analytics para este projeto" esteja ativado.
- Siga as etapas de configuração restantes no console do Firebase e clique em Criar projeto (ou Adicionar Firebase, se estiver usando um projeto existente do Google).
4. Adicione Firebase Analytics ao aplicativo
Nesta etapa, você adicionará o Firebase Analytics ao aplicativo para registrar dados de comportamento do usuário (nesse caso, quais filmes o usuário gosta). Esses dados serão usados de forma agregada em etapas futuras para treinar o modelo de recomendações.
Configure o Firebase Analytics no aplicativo
O LikedMoviesViewModel contém funções para armazenar os filmes que o usuário gosta. Cada vez que o usuário gosta de um novo filme, queremos também enviar um evento de log analítico para registrar essa curtida.
Adicione o código abaixo para registrar um evento analítico quando o usuário clicar como em um filme.
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. Teste sua integração com o Analytics
Nesta etapa, geraremos eventos do Analytics no aplicativo e verificaremos se eles estão sendo enviados para o Firebase Console.
Ativar registro de depuração do Analytics
Geralmente, os eventos registrados pelo seu aplicativo são agrupados em lote durante um período de aproximadamente uma hora e carregados juntos. Essa abordagem conserva a bateria dos dispositivos dos usuários finais e reduz o uso de dados da rede. No entanto, para fins de validação de sua implementação de análise (e para visualizar suas análises no relatório DebugView), você pode ativar o modo de depuração em seu dispositivo de desenvolvimento para fazer upload de eventos com um atraso mínimo.
Para ativar o modo Analytics Debug em seu dispositivo de desenvolvimento, especifique o seguinte argumento de linha de comando no Xcode:
-FIRDebugEnabled
Neste ponto, você integrou com sucesso o Firebase Analytics ao seu aplicativo. À medida que os usuários usam seu aplicativo e gostam de filmes, suas curtidas serão registradas de forma agregada. Usaremos esses dados agregados no restante deste codelab para treinar nosso modelo de recomendações. A seguir está uma etapa opcional para ver os mesmos eventos do Analytics que você viu no Logcat também transmitidos para o console do Firebase. Sinta-se à vontade para pular para a próxima página.
Opcional: confirme eventos do Analytics no Firebase Console
- Vá para o console do Firebase .
- Selecione DebugView em Analytics
- No Xcode, selecione Executar para iniciar o aplicativo e adicionar alguns filmes à sua lista de curtidas.
- No DebugView do console do Firebase, verifique se esses eventos estão sendo registrados conforme você adiciona filmes no aplicativo.
6. Exporte dados do Analytics para Big Query
Big Query é um produto do Google Cloud que permite examinar e processar grandes quantidades de dados. Nesta etapa, você conectará seu projeto do Firebase Console ao Big Query para que os dados do Analytics gerados pelo seu aplicativo sejam exportados automaticamente para o Big Query.
Ativar exportação do BigQuery
- Vá para o console do Firebase .
- Selecione o ícone de engrenagem Configurações ao lado de Visão geral do projeto e selecione Configurações do projeto
- Selecione a guia Integrações .
- Selecione Link (ou Manage ) dentro do bloco BigQuery .
- Selecione Próximo na etapa Sobre como vincular o Firebase ao BigQuery .
- Na seção Configurar integração , clique no botão para ativar o envio de dados do Google Analytics e selecione Vincular ao BigQuery .
Agora você ativou seu projeto do Firebase console para enviar automaticamente dados de eventos do Firebase Analytics para o Big Query. Isso acontece automaticamente, sem qualquer interação adicional. No entanto, a primeira exportação que cria o conjunto de dados analíticos no BigQuery pode demorar 24 horas para ocorrer. Depois que o conjunto de dados é criado, o Firebase exporta continuamente novos eventos do Analytics para o Big Query na tabela intradiária e agrupa eventos de dias anteriores na tabela de eventos.
Treinar 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 para o BigQuery para usar no restante deste tutorial.
7. Use o BigQuery para obter dados de treinamento de modelo
Agora que conectamos nosso Firebase Console para exportar para o BigQuery, os dados de eventos de análise do aplicativo aparecerão automaticamente no console do BigQuery após algum tempo. Para obter alguns dados iniciais para os fins deste tutorial, nesta etapa importaremos um conjunto de dados de amostra existente para o console do BigQuery para usar no treinamento de nosso modelo de recomendações.
Importe um conjunto de dados de amostra para o BigQuery
- Acesse o painel do BigQuery no console da nuvem do Google.
- Selecione o nome do seu projeto no menu.
- Selecione o nome do seu projeto na parte inferior da navegação esquerda do BigQuery para ver os detalhes.
- Selecione Criar conjunto de dados para abrir o painel de criação de conjunto de dados.
- Insira 'firebase_recommendations_dataset' como ID do conjunto de dados e selecione Criar conjunto de dados .
- O novo conjunto de dados aparecerá no menu esquerdo sob o nome do projeto. Clique.
- Selecione Criar tabela para abrir o painel de criação de tabela.
- Para Criar tabela, 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 de arquivo .
- Insira 'recommendations_table' para o nome da tabela .
- Marque a caixa em Esquema > Detecção automática > Esquema e parâmetros de entrada
- Selecione Criar tabela
Explorar conjunto de dados de amostra
Neste ponto, você pode opcionalmente explorar o esquema e visualizar esse conjunto de dados.
- Selecione firebase-recommendations-dataset no menu esquerdo para expandir as tabelas que ele contém.
- Selecione a tabela de recomendações para visualizar o esquema da tabela.
- Selecione Visualizar para ver os dados reais do evento do Analytics que esta tabela contém.
Criar credenciais de conta de serviço
Agora, criaremos credenciais de conta de serviço em nosso projeto de console do Google Cloud que poderemos usar no ambiente Colab na etapa seguinte para acessar e carregar nossos dados do BigQuery.
- Verifique se o faturamento está ativado para seu projeto do Google Cloud.
- Ative as APIs BigQuery e BigQuery Storage API. < clique aqui >
- Vá para a página Criar chave de 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 Função , selecione Projeto > Proprietário .
- Clique em Criar . Um arquivo JSON que contém seus downloads de chave para o seu computador.
Na próxima etapa, usaremos o Google Colab para pré-processar esses dados e treinar nosso modelo de recomendações.
8. Pré-processar dados e treinar modelo de recomendações
Nesta etapa, utilizaremos um notebook Colab para realizar as seguintes etapas:
- importe os dados do BigQuery para o notebook Colab
- pré-processar os dados para prepará-los para o treinamento do modelo
- treinar o modelo de recomendações nos dados analíticos
- exportar o modelo como um modelo TF Lite
- implantar o modelo no Firebase Console para que possamos usá-lo em nosso aplicativo
Antes de lançarmos o notebook de treinamento do Colab, primeiro habilitaremos a API Firebase Model Management para que o Colab possa implantar o modelo treinado em nosso console do Firebase.
Ativar API de gerenciamento de modelos do Firebase
Crie um bucket para armazenar seus modelos de ML
No Console do Firebase, acesse Armazenamento e clique em Primeiros passos. 
Siga o diálogo para configurar seu balde.
Ativar API Firebase ML
Acesse a página da API Firebase ML no Console do Google Cloud e clique em Ativar.
Use o notebook Colab para treinar e implantar o modelo
Abra o notebook colab usando o link a seguir e conclua as etapas contidas nele. Depois de concluir as etapas no notebook Colab, você terá um arquivo de modelo TF Lite implantado no console do Firebase que podemos sincronizar com nosso aplicativo.
Abrir no Colab
9. Baixe o modelo em seu aplicativo
Nesta etapa, modificaremos nosso aplicativo para baixar o 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 do Firebase Machine Learning no seu aplicativo. Já deve estar adicionado (verificar).
Podfile
import FirebaseCore
import FirebaseMLModelDownloader
Faça 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 ocorre o download do modelo e crie uma tarefa de download para sincronizar o modelo remoto com nosso aplicativo.
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. Integre o modelo de recomendação Tensorflow Lite em seu aplicativo
O tempo de execução do Tensorflow Lite permitirá que você use seu modelo no aplicativo para gerar recomendações. Na etapa anterior inicializamos um interpretador TFlite com o arquivo de modelo que baixamos. Nesta etapa, primeiro carregaremos um dicionário e rótulos para acompanhar nosso modelo na etapa de inferência, depois adicionaremos o pré-processamento para gerar as entradas para o nosso modelo e o pós-processamento onde extrairemos os resultados da nossa inferência .
Carregar dicionário e rótulos
Os rótulos utilizados para gerar os candidatos à recomendação pelo modelo de recomendações estão listados no arquivo sorted_movie_vocab.json na pasta assets. Copie o código a seguir para carregar esses candidatos.
RecomendaçõesViewController.swift
func getMovies() -> [MovieItem] {
let barController = self.tabBarController as! TabBarController
return barController.movies
}
Implementar pré-processamento
Na etapa de pré-processamento, alteramos a forma dos dados de entrada para corresponder ao que nosso modelo espera. Aqui, preenchemos o comprimento da entrada com um valor de espaço reservado se ainda não tivermos gerado muitas curtidas de usuários. Copie o código abaixo:
RecomendaçõesViewController.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
}
Execute o interpretador para gerar recomendações
Aqui usamos o modelo que baixamos na etapa anterior para executar inferência em nossa entrada pré-processada. Definimos o tipo de entrada e saída para nosso modelo e executamos inferência para gerar nossas recomendações de filmes. Copie o código a seguir em seu aplicativo.
RecomendaçõesViewController.swift
import TensorFlowLite
RecomendaçõesViewController.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)")
}
}
Implementar 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 em seu aplicativo.
RecomendaçõesViewController.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]))
}
}
Teste seu aplicativo!
Execute novamente seu aplicativo. Ao selecionar alguns filmes, ele deverá baixar automaticamente o novo modelo e começar a gerar recomendações!
11. Parabéns!
Você incorporou um recurso de recomendações em seu aplicativo usando o TensorFlow Lite e o Firebase. Observe que as técnicas e o pipeline mostrados neste codelab podem ser generalizados e usados também para servir outros tipos de recomendações.
O que cobrimos
- FirebaseML
- Análise do Firebase
- Exportar eventos de análise para o BigQuery
- Pré-processar eventos de análise
- Recomendações de treinamento do modelo TensorFlow
- Exportar modelo e implantar no Firebase Console
- Servir recomendações de filmes em um aplicativo
Próximos passos
- Implemente recomendações do Firebase ML no seu aplicativo.
Saber mais
Ter uma questão?
Relatar problemas