Adicionar recomendações ao app com o TensorFlow Lite e o Firebase – Codelab para Android

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 o aprendizado de máquina para veicular de maneira inteligente o conteúdo mais relevante para cada usuário. Eles consideram o comportamento anterior do usuário para sugerir um conteúdo com que o usuário possa 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 app com o Firebase Analytics, criar um modelo de machine learning para as recomendações desses dados e usar esse modelo em um app Android para executar inferência e receber recomendações. Em particular, nossas recomendações vão sugerir a quais filmes um usuário provavelmente assistiria, considerando a lista de filmes que ele já gostou anteriormente.

Conteúdo

  • Integrar o Firebase Analytics a um aplicativo Android para coletar dados de comportamento do usuário
  • Exportar esses 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 inferências no dispositivo usando o modelo para sugerir recomendações aos usuários

O que é necessário

  • Versão mais recente do Android Studio
  • Exemplo de código.
  • Um dispositivo de teste com o Android 7 e versões mais recentes e o Google Play Services 9.8 ou mais recente, ou um emulador com o Google Play Services 9.8 ou mais recente
  • Se estiver usando um dispositivo, um cabo de conexão.

Como você usará este tutorial?

Apenas leitura Ler e fazer os exercícios

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

Iniciante Intermediário Proficiente

2. Acessar o exemplo de código

Clone o repositório do GitHub na linha de comando.

$ git clone https://github.com/FirebaseExtended/codelab-contentrecommendation-android.git

3. Importar o app inicial

No Android Studio, selecione o diretório codelab-recommendations-android ( android_studio_folder.png) no download do exemplo de código (File > Open > .../codelab-recommendations-android/start).

O projeto inicial está aberto no Android Studio.

4. Criar projeto do Console do Firebase

Criar um 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. Verifique se a opção "Ativar o Google Analytics para este projeto" está ativada.
  5. Siga as demais etapas de configuração no Console do Firebase e clique em "Criar projeto" (ou "Adicionar Firebase", se você estiver usando um projeto do Google).

5. Adicionar Firebase

  1. Na tela de visão geral do 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 Register app.

Adicionar o arquivo google-services.json ao seu app

Depois de adicionar o nome do pacote e selecionar "Registrar", clique em Fazer o download de google-services.json para receber o arquivo de configuração do Firebase para Android e copie o arquivo google-services.json no diretório app do seu projeto. Depois de fazer o download do arquivo, você pode clicar em Skip para pular as próximas etapas mostradas no console. Elas já foram realizadas no projeto build-android-start.

Adicionar o plug-in google-services ao app

O plug-in google-services usa o arquivo google-services.json para configurar seu aplicativo para usar o Firebase. As linhas abaixo já devem ter sido adicionadas aos arquivos build.gradle.kts no projeto (verifique para confirmar):

app/build.grade.kts (link em inglês)

plugins {
    id("com.google.gms.google-services")
}

build.grade.kts (link em inglês)

plugins {
    id("com.google.gms.google-services") version "4.3.15" apply false
}

Sincronizar seu projeto com arquivos do Gradle

Para garantir que todas as dependências estejam disponíveis para o app, sincronize seu projeto com os arquivos do Gradle nesse momento. Selecione File > Sync Project with Gradle Files na barra de ferramentas do Android Studio.

6. Executar o app inicial

Agora que você importou o projeto para o Android Studio e configurou o plug-in google-services com o arquivo JSON, está tudo pronto para executar o app pela primeira vez. Conecte o dispositivo Android e clique em Run ( executar.png) na barra de ferramentas do Android Studio.

O app vai ser aberto no 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". Clique em um filme na lista para adicioná-lo à sua lista de "gostei". Depois de concluir as etapas restantes do codelab, poderemos gerar recomendações de filmes na guia "Recomendações".

7. Adicionar o Firebase Analytics ao app

Nesta etapa, você adicionará o Firebase Analytics ao aplicativo para registrar dados de comportamento do usuário (nesse caso, que filma um usuário gosta). Esses dados vão ser usados de forma agregada nas próximas etapas para treinar o modelo de recomendações.

Adicionar dependência da Lista de materiais do Firebase e do Analytics

As seguintes dependências são necessárias para adicionar o Firebase Analytics ao seu app. Elas já devem estar incluídas no arquivo app/build.gradle.kts (verificação).

app/build.grade.kts (link em inglês)

implementation(platform("com.google.firebase:firebase-bom:32.0.0"))
implementation("com.google.firebase:firebase-analytics-ktx")

Configurar o Firebase Analytics no app

O LikedMoviesViewModel contém funções para armazenar os filmes que o usuário gosta. Sempre que um usuário gosta de um novo filme, queremos também enviar um evento de registro de análise para registrar essa marcação.

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

LikedMoviesViewModel.kt (link em inglês)

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 marcações "Gostei" do usuário.

LikedMoviesViewModel.kt (link em inglês)

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

O Firebase Analytics foi projetado para maximizar a duração da bateria do usuário. Ele agrupa os eventos no dispositivo e os envia ao Firebase apenas ocasionalmente. Para fins de depuração, podemos desativar esse comportamento para ver os eventos registrados em tempo real executando o seguinte comando no shell.

Terminal

adb shell setprop debug.firebase.analytics.app com.google.firebase.codelabs.recommendations

Verificar se os eventos do Analytics foram gerados

  1. No Android Studio, abra a janela do Logcat para examinar a geração de registros do app.
  2. Defina o filtro do Logcat para a string "Logging event".
  3. Verifique se os eventos "select_item" do Analytics são emitidos sempre que você marca um filme com "Gostei" no app.

Você integrou o Firebase Analytics ao seu app. À medida que os usuários usarem o app e, como em filmes, as marcações "gostei" serão registradas de forma agregada. Usaremos esses dados agregados no restante deste codelab para treinar nosso modelo de recomendações. A etapa a seguir é opcional para que os mesmos eventos do Analytics que você viu no Logcat também sejam 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

  1. Acesse o Console do Firebase.
  2. Selecione DebugView em Analytics.
  3. No Android Studio, selecione Executar para iniciar o app e adicionar alguns filmes à lista de marcações "Gostei".
  4. No DebugView do Console do Firebase, verifique se esses eventos estão sendo registrados à medida que você adiciona filmes no app.

9. Exportar dados do Google Analytics para o BigQuery

O Big Query é um produto do Google Cloud que permite examinar e processar grandes quantidades de dados. Nesta etapa, você conectará seu projeto do Console do Firebase ao BigQuery para que os dados do Analytics gerados pelo seu app sejam exportados automaticamente para o BigQuery.

Ativar a exportação do BigQuery

  1. Acesse o Console do Firebase.
  2. Selecione o ícone de engrenagem ao lado de Visão geral do projeto e depois Configurações do projeto.
  3. Selecione a guia Integrações.
  4. Selecione Vincular (ou Gerenciar) no bloco do BigQuery.
  5. Selecione Próxima na etapa Como vincular o Firebase ao BigQuery.
  6. 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 para o 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 até 24 horas. Após a criação do conjunto de dados, o Firebase exporta continuamente novos eventos do Analytics para o BigQuery na tabela intradiária e agrupa os eventos dos dias anteriores na tabela de eventos.

Treinar um modelo de recomendações requer muitos dados. Como ainda não temos um app 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 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 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 a fim de 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 projeto no menu.
  3. Selecione o nome do seu projeto na parte inferior do painel de 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" como o ID do conjunto de dados e selecione Criar conjunto de dados.
  6. O novo conjunto de dados vai aparecer no menu à esquerda, abaixo do nome do projeto. Clique nele.
  7. Selecione Criar tabela para abrir o painel de criação de tabelas.
  8. Em Criar tabela de, selecione "Google Cloud Storage".
  9. No campo Selecionar arquivo do bucket do GCS, insira "gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt".
  10. Selecione "JSONL" no menu suspenso Formato do arquivo.
  11. Insira "recommendations_table" como o Nome da tabela.
  12. Marque a caixa em Esquema > Detectar automaticamente > Parâmetros de esquema e entrada.
  13. Selecione Criar tabela.

Analisar o conjunto de dados de amostra

Neste ponto, é possível explorar o esquema e visualizar o conjunto de dados.

  1. Selecione firebase-recommendations-dataset no menu à esquerda para expandir as tabelas que ele contém.
  2. Selecione a tabela recommendations-table para ver o esquema dela.
  3. Selecione Visualizar para conferir os dados reais de eventos do Google Analytics que a 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 próxima etapa para acessar e carregar os dados do BigQuery.

  1. Verifique se a cobrança está ativada para o projeto do Google Cloud.
  2. Ative as APIs BigQuery e BigQuery Storage API. < clique aqui>
  3. Acesse a página Criar chave da 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 Papel, selecione Projeto > Proprietário.
  7. 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.

11. Pré-processar dados e treinar o modelo de recomendações

Nesta etapa, vamos usar um bloco do Colab para realizar as seguintes etapas:

  1. importar os dados do BigQuery para o bloco do Colab
  2. pré-processar os dados para prepará-los para o treinamento do modelo
  3. treinar o modelo de recomendações nos dados de análise
  4. exportar o modelo como TF Lite
  5. implantar o modelo no console do Firebase para que possamos usá-lo no nosso app

Antes de lançar o bloco 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 Storage e clique em "Começar". fbbea78f0eb3dc9f.png

Siga as mensagens para configurar o bucket.

19517c0d6d2aa14d.png

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 abaixo e conclua as etapas nele. Depois de concluir as etapas no bloco do Colab, você terá um arquivo de modelo do TF Lite implantado no console do Firebase que poderá ser sincronizado com nosso app.

Abrir no Colab

12. Fazer o download do modelo no seu app

Nesta etapa, modificaremos nosso app para fazer o download do modelo que acabamos de treinar com o 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. Ela já deve ter sido adicionada (verificar).

app/build.grade.kts (link em inglês)

implementation("com.google.firebase:firebase-ml-modeldownloader:24.1.2")

Fazer o download do modelo com a API Firebase Model Manager

Copie o código abaixo em RecommendationClient.kt para configurar as condições em que o download do modelo ocorre e crie uma tarefa de download para sincronizar o modelo remoto com nosso app.

RecommendationClient.kt (link em inglês)

    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 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 que transferimos por download. Nesta etapa, primeiro vamos carregar um dicionário e rótulos para acompanhar nosso modelo na etapa de inferência. Depois, vamos adicionar o pré-processamento para gerar as entradas e o pós-processamento, em que vamos 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 de recomendações são listados no arquivo sorted_movie_vocab.json na pasta res/assets. Copie o código a seguir para carregar esses candidatos.

RecommendationClient.kt (link em inglês)

    /** 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 o pré-processamento

Na etapa de pré-processamento, alteramos a forma dos dados de entrada para corresponder ao que o 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:

RecommendationClient.kt (link em inglês)

    /** 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
        }
    }


Executar o intérprete para gerar recomendações

Aqui, usamos o modelo salvo na etapa anterior para executar a inferência na entrada pré-processada. Definimos o tipo de entrada e saída do modelo e executamos inferência para gerar as recomendações de filmes. Copie o código a seguir no seu app.

RecommendationClient.kt (link em inglês)

    /** 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 o pós-processamento

Por fim, nesta etapa, fazemos o pós-processamento da saída do 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.

RecommendationClient.kt (link em inglês)

    /** 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 app

Execute o app novamente. Conforme você seleciona alguns filmes, ele faz o download automático do novo modelo e começa a gerar recomendações.

14. 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 disponibilizar 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 recomendações de modelo do TensorFlow
  • Exportar modelo e implantar no Console do Firebase
  • Veicular recomendações de filmes em um app

Próximas etapas

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

Saiba mais

Perguntas?

Informar problemas