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 Android 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á
- Versão mais recente do Android Studio .
- Código de amostra.
- Um dispositivo de teste com Android 7+ e Google Play Services 9.8 ou posterior, ou um emulador com Google Play Services 9.8 ou posterior
- Se estiver usando um dispositivo, um cabo de conexão.
Como você usará este tutorial?
Como avaliaria sua experiência com a criação de aplicativos Android?
2. Obtenha o código de exemplo
Clone o repositório GitHub na linha de comando.
$ git clone https://github.com/FirebaseExtended/codelab-contentrecommendation-android.git
3. Importe o aplicativo inicial
No Android Studio, selecione o diretório codelab-recommendations-android ( 
) no download do código de amostra ( Arquivo > Abrir > .../codelab-recommendations-android/start).
Agora você deve ter o projeto inicial aberto no Android Studio.
4. Crie um projeto de console do Firebase
Crie um novo projeto
- Vá para o console do Firebase .
- Selecione Adicionar projeto (ou Criar um projeto se for o primeiro).
- Selecione ou insira um nome de projeto e clique em Continuar .
- 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).
5. Adicione Firebase
- Na tela de visão geral do seu novo projeto, clique no ícone do Android para iniciar o fluxo de trabalho de configuração.
- Insira o nome do pacote do codelab:
com.google.firebase.codelabs.recommendations - Selecione Registrar aplicativo .
Adicione o arquivo google-services.json ao seu aplicativo
Depois de adicionar o nome do pacote e selecionar Registrar, clique em Baixar google-services.json para obter o arquivo de configuração do Firebase Android e copie o arquivo google-services.json para o diretório app em seu projeto. Após o download do arquivo, você pode pular as próximas etapas mostradas no console (elas já foram feitas para você no projeto build-android-start).
Adicione o plugin google-services ao seu aplicativo
O plug-in google-services usa o arquivo google-services.json para configurar seu aplicativo para usar o Firebase. As seguintes linhas já devem estar adicionadas aos arquivos build.gradle.kts do projeto (marque para confirmar):
app/build.grade.kts
plugins {
id("com.google.gms.google-services")
}
build.grade.kts
plugins {
id("com.google.gms.google-services") version "4.3.15" apply false
}
Sincronize seu projeto com arquivos Gradle
Para ter certeza de que todas as dependências estão disponíveis para seu aplicativo, você deve sincronizar seu projeto com arquivos gradle neste momento. Selecione Arquivo > Sincronizar projeto com arquivos Gradle na barra de ferramentas do Android Studio.
6. Execute o aplicativo inicial
Agora que importou o projeto para o Android Studio e configurou o plug-in google-services com seu arquivo JSON, você está pronto para executar o aplicativo pela primeira vez. Conecte seu dispositivo Android e clique em Executar ( 
)na barra de ferramentas do Android Studio.
O aplicativo deve ser iniciado no seu dispositivo. Neste ponto, você pode ver um aplicativo em funcionamento que mostra uma guia com uma lista de filmes, uma guia Filmes curtidos e uma guia Recomendações. Você pode clicar em um filme na lista de filmes para adicioná-lo à sua lista de favoritos. Depois de concluir as etapas restantes do codelab, poderemos gerar recomendações de filmes na guia Recomendações.
7. 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.
Adicionar dependência de lista de materiais e análise do Firebase
As dependências a seguir são necessárias para adicionar o Firebase Analytics ao seu aplicativo. Eles já devem estar incluídos no arquivo app/build.gradle.kts (verificar).
app/build.grade.kts
implementation(platform("com.google.firebase:firebase-bom:32.0.0"))
implementation("com.google.firebase:firebase-analytics-ktx")
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 a função onMovieLiked com o código abaixo para registrar um evento analítico quando o usuário clica como em um filme.
LikedMoviesViewModel.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())
}
}
Adicione o campo e a função a seguir para registrar um evento do Analytics quando um filme for adicionado à lista de Curtidas do usuário.
LikedMoviesViewModel.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. 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
O Firebase Analytics foi projetado para maximizar a vida útil da bateria do usuário e agrupa eventos no dispositivo e os envia ao Firebase apenas ocasionalmente. Para fins de depuração, podemos desabilitar esse comportamento para ver os eventos à medida que são registrados em tempo real, executando o seguinte comando no shell.
terminal
adb shell setprop debug.firebase.analytics.app com.google.firebase.codelabs.recommendations
Verifique se os eventos do Analytics são gerados
- No Android Studio, abra a janela Logcat para examinar o registro em log do seu aplicativo.
- Defina o filtro Logcat para a string "Logging event".
- Verifique se os eventos do Analytics "select_item" são emitidos sempre que você curte um filme no aplicativo.
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 Android Studio, 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.
9. 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 acontecer. 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.
10. 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.
11. 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
12. 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).
app/build.grade.kts
implementation("com.google.firebase:firebase-ml-modeldownloader:24.1.2")
Faça download do modelo com a API Firebase Model Manager
Copie o código abaixo em RecommendationClient.kt 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.
RecomendaçãoClient.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. 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 res/assets. Copie o código a seguir para carregar esses candidatos.
RecomendaçãoCliente.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.")
}
}
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çãoCliente.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
}
}
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çãoCliente.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()
}
}
}
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çãoCliente.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
}
}
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!
14. 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.