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 em seu app. Este codelab é baseado neste exemplo do TensorFlow Lite.
As recomendações permitem que os aplicativos usem aprendizado de máquina para atender de forma inteligente o conteúdo mais relevante para cada usuário. Eles levam em consideração o comportamento anterior do usuário para sugerir o conteúdo do aplicativo 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.
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 a inferência e obter recomendações. Em particular, nossas recomendações irão sugerir 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 em 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 em seu aplicativo
- Execute a inferência de dispositivo usando o modelo para sugerir recomendações aos usuários
O que você precisará
- Última versão 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 classificaria sua experiência com a criação de aplicativos Android?
2. Obtenha o código de amostra
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 ( 
) do download do código de amostra ( File > Open > .../codelab-recommendations-android/start).
Agora você deve ter o projeto inicial aberto no Android Studio.
4. Crie um projeto de console do Firebase
Criar um novo projeto
- Acesse 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 o 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. Adicionar 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 Register, clique em Download google-services.json para obter o arquivo de configuração Firebase Android e copie o arquivo google-services.json no 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 plug-in de serviços do Google 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 no 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 File > Sync Project with Gradle Files na barra de ferramentas do Android Studio.
6. Execute o aplicativo inicial
Agora que você importou o projeto para o Android Studio e configurou o plug-in google-services com seu arquivo JSON, 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 iniciar no seu dispositivo. Neste ponto, você pode ver um aplicativo em funcionamento que mostra uma guia com uma lista de filmes, uma guia de filmes curtidos e uma guia de 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 o Firebase Analytics ao aplicativo
Nesta etapa, você adicionará o Firebase Analytics ao aplicativo para registrar os dados de comportamento do usuário (neste caso, quais filmes um usuário gosta). Esses dados serão usados de forma agregada em etapas futuras para treinar o modelo de recomendações.
Adicionar lista de materiais do Firebase e dependência do Analytics
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. Toda vez que o usuário gosta de um novo filme, também queremos enviar um evento de log de análise para registrar essa curtida.
Adicione a função onMovieLiked com o código abaixo para registrar um evento analítico quando o usuário clicar em curtir 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 seguinte campo e função 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, vamos gerar eventos do Analytics no app e verificar se estão sendo enviados para o Console do Firebase.
Ativar registro de depuração do Analytics
O Firebase Analytics foi projetado para maximizar a duração da bateria do usuário e agrupar eventos no dispositivo e enviá-los ao Firebase apenas ocasionalmente. Para fins de depuração, podemos desativar 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 estúdio Android, abra a janela do Logcat para examinar o log do seu aplicativo.
- Defina o filtro Logcat para a string "Evento de registro".
- Verifique se os eventos do Analytics "select_item" são emitidos toda vez que você gosta de um filme no aplicativo.
Neste ponto, você integrou com sucesso o Firebase Analytics em 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, 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 os eventos do Analytics no Console do Firebase
- Acesse o console do Firebase .
- Selecione DebugView em Analytics
- No Android Studio, selecione Executar para iniciar o aplicativo e adicionar alguns filmes à sua lista de curtidos.
- No DebugView do console do Firebase, verifique se esses eventos estão sendo registrados à medida que você adiciona filmes ao aplicativo.
9. Exporte os dados do Analytics para o Big Query
Big Query é um produto do Google Cloud que permite examinar e processar grandes quantidades de dados. Nesta etapa, você conectará seu projeto Firebase Console ao BigQuery para que os dados do Analytics gerados pelo seu aplicativo sejam exportados automaticamente para o BigQuery.
Ativar exportação do BigQuery
- Acesse 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 Next na etapa About Linking Firebase to BigQuery .
- Na seção Configurar integração , clique na chave para ativar o envio de dados do Google Analytics e selecione Vincular ao BigQuery .
Agora você habilitou seu projeto do Firebase console para enviar automaticamente dados de eventos do Firebase Analytics para o Big Query. Isso acontece automaticamente sem nenhuma interação adicional. No entanto, a primeira exportação que cria o conjunto de dados analíticos no BigQuery pode demorar 24 horas. Após a criação do conjunto de dados, o Firebase exporta continuamente novos eventos do Analytics para o Big Query na tabela intradiária e agrupa os eventos dos últimos dias na tabela de eventos.
Treinar um modelo de recomendações requer muitos dados. Como ainda não temos um aplicativo gerando 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 do modelo
Agora que conectamos nosso console do Firebase para exportar para o BigQuery, nossos dados de eventos de análise de aplicativos aparecerão automaticamente no console do BigQuery após algum tempo. Para obter alguns dados iniciais para os propósitos deste tutorial, nesta etapa importaremos um conjunto de dados de amostra existente para seu console do BigQuery para usar para treinar nosso modelo de recomendações.
Importar conjunto de dados de amostra para o BigQuery
- Acesse o painel do BigQuery no console do Google Cloud.
- 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 do conjunto de dados.
- Insira 'firebase_recommendations_dataset' para o ID do conjunto de dados e selecione Criar conjunto de dados .
- O novo conjunto de dados aparecerá no menu à esquerda sob o nome do projeto. Clique.
- Selecione Criar tabela para abrir o painel de criação de tabela.
- Em Create table from selecione 'Google Cloud Storage'.
- No campo Select file from GCS bucket , digite 'gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt'.
- Selecione 'JSONL' no menu suspenso Formato de arquivo .
- Digite '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, opcionalmente, você pode explorar o esquema e visualizar este conjunto de dados.
- Selecione firebase-recommendations-dataset no menu à esquerda 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 podemos 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 >
- Acesse 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 o modelo de recomendações
Nesta etapa, usaremos um notebook Colab para realizar as seguintes etapas:
- importar os dados do BigQuery para o notebook Colab
- pré-processar os dados para prepará-los para o treinamento do modelo
- treine 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 Firebase Model Management API para que o Colab possa implantar o modelo treinado em nosso Firebase console.
Ativar a API Firebase Model Management
Crie um bucket para armazenar seus modelos de ML
No Firebase Console, vá para Storage e clique em Começar. 
Siga o diálogo para configurar seu balde.
Ativar Firebase ML API
Acesse a página Firebase ML API 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 nele. Depois de concluir as etapas no notebook Colab, você terá um arquivo de modelo TF Lite implantado no Firebase console que podemos sincronizar com nosso aplicativo.
Aberto 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 os modelos Firebase Machine Learning em seu aplicativo. Já deve estar adicionado (verificar).
app/build.grade.kts
implementation("com.google.firebase:firebase-ml-modeldownloader:24.1.2")
Baixe o modelo com a API Firebase Model Manager
Copie o código abaixo em RecommendationClient.kt 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 aplicativo.
RecomendaçãoCliente.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 um pré-processamento para gerar as entradas para nosso modelo e um pós-processamento onde extrairemos os resultados de nossa inferência .
Carregar Dicionário e Etiquetas
Os rótulos usados 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 de entrada com um valor de espaço reservado se ainda não tivermos gerado muitas curtidas do usuário. 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 em uma etapa anterior para executar a inferência em nossa entrada pré-processada. Definimos o tipo de entrada e saída para nosso modelo e executamos a 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
Finalmente, nesta etapa, pós-processamos a saída de nosso modelo, selecionando os resultados com a 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. Conforme você seleciona alguns filmes, ele deve baixar automaticamente o novo modelo e começar a gerar recomendações!
14. Parabéns!
Você criou 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 para servir também a outros tipos de recomendações.
O que cobrimos
- Firebase ML
- Firebase Analytics
- Exportar eventos de análise para o BigQuery
- Pré-processar eventos analíticos
- Recomendações de treinamento do modelo do TensorFlow
- Exportar modelo e implantar no Console do Firebase
- Exiba recomendações de filmes em um aplicativo
Próximos passos
- Implemente as recomendações do Firebase ML em seu aplicativo.