Adicione recomendações ao seu aplicativo com TensorFlow Lite e Firebase - Android Codelab

Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

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 aplicativo. Este codelab é baseado neste exemplo do TensorFlow Lite.

As recomendações permitem que os aplicativos usem o aprendizado de máquina para veicular 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 querer 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 usar esse modelo em um aplicativo Android para executar inferência e obter recomendações. Em particular, nossas recomendações sugerirão quais filmes um usuário provavelmente assistiria de acordo com a lista de filmes que o usuário gostou anteriormente.

O que você vai 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 do seu aplicativo
  • Executar na inferência do dispositivo usando o modelo para sugerir recomendações aos usuários

O que você precisará

  • Android Studio versão 3.4+.
  • Código de amostra.
  • Um dispositivo de teste com Android 2.3+ 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ê vai usar este tutorial?

Leia-o apenas Leia e complete os exercícios

Como classificaria sua experiência com a criação de aplicativos Android?

Novato Intermediário Proficiente

2. Obtenha o código de amostra

Clone o repositório do 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 codelab-recommendations-android ( android_studio_folder.png ) do download do código de exemplo ( 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

  1. Acesse o console do Firebase .
  2. Selecione Adicionar projeto (ou Criar um projeto se for o primeiro).
  3. Selecione ou insira um nome de projeto e clique em Continuar .
  4. Certifique-se de que "Ativar o Google Analytics para este projeto" esteja ativado.
  5. 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 o Firebase

  1. Na tela de visão geral do seu novo projeto, clique no ícone do Android para iniciar o fluxo de trabalho de configuração.
  2. Insira o nome do pacote do codelab: com.google.firebase.codelabs.recommendations
  3. 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 do Firebase Android e copie o arquivo google-services.json no diretório do 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 ser adicionadas aos arquivos build.gradle no projeto (marque para confirmar):

app/build.grade

apply plugin: 'com.google.gms.google-services'

build.grade

classpath 'com.google.gms:google-services:4.3.13'

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 você 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 ( execute.png ) 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 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 o Firebase Analytics ao aplicativo

Nesta etapa, você adicionará o Firebase Analytics ao aplicativo para registrar 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 dependência do Firebase Analytics

A dependência a seguir é necessária para adicionar o Firebase Analytics ao seu aplicativo. Ele já deve estar incluído no arquivo app/build.gradle (verificar).

app/build.grade

implementation 'com.google.firebase:firebase-analytics-ktx:21.1.0'

Configurar 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, queremos também enviar um evento de log de análise para registrar esse gosto.

Adicione a função onMovieLiked com o código abaixo para registrar um evento de análise quando o usuário clicar como em um filme.

GostouFilmesViewModel.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.

GostouFilmesViewModel.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 do Analytics

Nesta etapa, geraremos eventos do Analytics no aplicativo e verificaremos se eles estão sendo enviados ao Firebase Console.

Ativar o registro de depuração do Analytics

O Firebase Analytics foi desenvolvido para maximizar a vida útil da bateria do usuário e agrupará eventos no dispositivo e os enviará ao Firebase apenas ocasionalmente. Para fins de depuração, podemos desabilitar esse comportamento para ver os eventos conforme eles 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

  1. No Android studio, abra a janela Logcat para examinar o log do seu aplicativo.
  2. Defina o filtro Logcat para a string "Evento de log".
  3. Verifique se os eventos do Analytics "select_item" são emitidos sempre que você gosta de um filme no aplicativo.

Neste ponto, você integrou com êxito 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. Veja a seguir uma etapa opcional para ver os mesmos eventos do Analytics que você viu no Logcat também fazer streaming para o console do Firebase. Sinta-se à vontade para pular para a próxima página.

Opcional: confirme os eventos do Analytics no Firebase Console

  1. Acesse o console do Firebase .
  2. Selecione DebugView em Analytics
  3. No Android Studio, selecione Executar para iniciar o aplicativo e adicionar alguns filmes à sua lista de favoritos.
  4. No DebugView do console do Firebase, verifique se esses eventos estão sendo registrados à medida que você adiciona filmes ao aplicativo.

9. Exporte dados do Analytics para o Big Query

O 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 Google Analytics gerados pelo seu aplicativo sejam exportados automaticamente para o Big Query.

Ativar exportação do Big Query

  1. Acesse o console do Firebase .
  2. Selecione o ícone de engrenagem Configurações ao lado de Visão geral do projeto e selecione Configurações do projeto
  3. Selecione a guia Integrações .
  4. Selecione Link (ou Manage ) dentro do bloco do BigQuery .
  5. Selecione Avançar na etapa Sobre como vincular o Firebase ao BigQuery .
  6. 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 nenhuma interação adicional. No entanto, a primeira exportação que cria o conjunto de dados de análise 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 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 gera 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, nossos dados de eventos de análise de aplicativos serão exibidos 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 para treinar nosso modelo de recomendações.

Importar conjunto de dados de amostra para o BigQuery

  1. Acesse o painel do BigQuery no console do Google Cloud.
  2. Selecione o nome do seu projeto no menu.
  3. Selecione o nome do seu projeto na parte inferior da navegação à esquerda do BigQuery para ver os detalhes.
  4. Selecione Criar conjunto de dados para abrir o painel de criação do conjunto de dados.
  5. Insira 'firebase_recommendations_dataset' para o ID do conjunto de dados e selecione Criar conjunto de dados .
  6. O novo conjunto de dados aparecerá no menu à esquerda sob o nome do projeto. Clique.
  7. Selecione Criar tabela para abrir o painel de criação de tabela.
  8. Para criar tabela de selecione 'Google Cloud Storage'.
  9. No campo Select file from GCS bucket , insira 'gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt'.
  10. Selecione 'JSONL' no menu suspenso Formato de arquivo .
  11. Insira 'recommendations_table' para o nome da tabela .
  12. Marque a caixa em Esquema > Detecção automática > Esquema e parâmetros de entrada
  13. Selecione Criar tabela

Explorar o conjunto de dados de amostra

Neste ponto, você pode explorar opcionalmente o esquema e visualizar este conjunto de dados.

  1. Selecione firebase-recommendations-dataset no menu à esquerda para expandir as tabelas que ele contém.
  2. Selecione a tabela da tabela de recomendações para visualizar o esquema da tabela.
  3. Selecione Visualizar para ver os dados reais de eventos 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 a seguir para acessar e carregar nossos dados do BigQuery.

  1. Verifique se o faturamento está ativado para seu projeto do Google Cloud.
  2. Ative as APIs da API BigQuery e BigQuery Storage. < clique aqui >
  3. Vá para a página Criar chave de conta de serviço .
  4. Na lista Conta de serviço , selecione Nova conta de serviço .
  5. No campo Nome da conta de serviço , insira um nome.
  6. Na lista Função , selecione Projeto > Proprietário .
  7. Clique em Criar . Um arquivo JSON que contém seus downloads de chave para seu computador.

Na próxima etapa, usaremos o Google Colab para pré-processar esses dados e treinar nosso modelo de recomendações.

11. Dados de pré-processamento e modelo de recomendações de treinamento

Nesta etapa, usaremos um notebook Colab para realizar as seguintes etapas:

  1. importar os dados do BigQuery para o notebook do Colab
  2. pré-processar os dados para prepará-los para o treinamento do modelo
  3. treinar o modelo de recomendações nos dados analíticos
  4. exporte o modelo como um modelo TF lite
  5. 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 a API Firebase Model Management

Crie um bucket para armazenar seus modelos de ML

No Firebase Console, acesse Armazenamento e clique em Começar. fbbea78f0eb3dc9f.png

Siga o diálogo para configurar seu bucket.

19517c0d6d2aa14d.png

Ativar a API Firebase ML

Acesse a página da API Firebase ML no Google Cloud Console 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. 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 os modelos do Firebase Machine Learning no seu aplicativo. Ele já deve ser adicionado (verificar).

app/build.grade

implementation 'com.google.firebase:firebase-ml-modeldownloader:24.0.4'

Faça o 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 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 do Tensorflow Lite ao 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 pré-processamento para gerar as entradas para nosso modelo e pós-processamento onde extrairemos os resultados de nossa inferência .

Carregar dicionário e etiquetas

Os rótulos usados ​​para gerar os candidatos a 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, nós 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

Por fim, nesta etapa, pós-processamos a saída do 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 atender a outros tipos de recomendações também.

O que cobrimos

  • Firebase ML
  • Firebase Analytics
  • Exportar eventos de análise para o BigQuery
  • Eventos de análise de pré-processamento
  • Treinar recomendações do modelo TensorFlow
  • Exportar modelo e implantar no Firebase Console
  • Exiba recomendações de filmes em um aplicativo

Próximos passos

  • Implemente as recomendações do Firebase ML no seu aplicativo.

Saber mais

Ter uma questão?

Relatar problemas