O Google tem o compromisso de promover a igualdade racial para as comunidades negras. Saiba como.

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

Bem-vindo às recomendações com o TensorFlow Lite e codelab do 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 servir 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 Firebase Analytics, construir um modelo de aprendizado de máquina para recomendações a partir desses dados e, em seguida, usar esse modelo em um aplicativo Android para executar 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 TF Lite
  • Implante o modelo TF Lite no Firebase ML e acesse-o de 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ê usará este tutorial?

Leia apenas na íntegra Leia e complete os exercícios

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

Novato Intermediário Proficiente

Clone o repositório GitHub a partir da linha de comando.

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

No Android Studio, selecione o codelab-recommendations-android ( android_studio_folder.png ) a partir do download do código de amostra ( Arquivo > Abrir > ... / codelab-responses-android / start).

Agora você deve ter o projeto inicial aberto no Android Studio.

Crie 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 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).
  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. Digite 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 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 do app em seu projeto. Depois que o arquivo for baixado, 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.4'

Sincronize seu projeto com arquivos do 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.

Agora que importou o projeto para o Android Studio e configurou o plug google-services 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 ser iniciado em 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 da lista de filmes para adicioná-lo à sua lista de favoritos. Depois de concluir as etapas restantes do codelab, seremos capazes de gerar recomendações de filmes na guia Recomendações.

Nesta etapa, você adicionará o Firebase Analytics ao aplicativo para registrar dados de comportamento do usuário (neste caso, filmes que 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 do Firebase Analytics

A seguinte dependência é 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:17.6.0'

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 de análise para registrar esse gosto.

Adicione a função onMovieLiked com o código abaixo para registrar um evento analítico quando o usuário clica 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 é adicionado à lista de gostos 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)
        }
    }

Nesta etapa, geraremos eventos do Analytics no aplicativo e verificaremos se eles estão sendo enviados ao 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 irá 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

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

Neste ponto, você integrou com êxito o Firebase Analytics ao seu aplicativo. Conforme 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 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 Firebase console, verifique se esses eventos estão sendo registrados conforme você adiciona filmes no aplicativo.

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 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 Gerenciar ) dentro do bloco 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 Link para 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. Depois que o conjunto de dados é criado, o Firebase exporta continuamente novos eventos do Analytics para Big Query na tabela intradiária e agrupa eventos de dias anteriores na tabela de eventos.

O treinamento de 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.

Agora que conectamos nosso Firebase console 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 fins deste tutorial, nesta etapa, importaremos um conjunto de dados de amostra existente em seu console do BigQuery para usar no treinamento de nosso modelo de recomendações.

Importar conjunto de dados de amostra para o BigQuery

  1. Acesse o painel do BigQuery no console da nuvem do Google.
  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. Digite '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 esquerdo sob o nome do projeto. Clique.
  7. Selecione Criar tabela para abrir o painel de criação de tabela.
  8. Para criar uma tabela de, selecione 'Google Cloud Storage'.
  9. No campo Selecionar arquivo do intervalo GCS , digite 'gs: //firebase-recommendations/recommendations-test/formatted_data_filtered.txt'.
  10. Selecione 'JSONL' na lista suspensa Formato de arquivo .
  11. Digite 'recomendação_tabela' 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

Explore o conjunto de dados de amostra

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

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

  1. Certifique-se de que o faturamento está ativado para seu projeto do Google Cloud.
  2. Ative as APIs BigQuery e BigQuery Storage API. < 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 os downloads de sua chave para o computador.

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

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

  1. importar os dados do BigQuery para o bloco de notas 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. exportar 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 caderno de treinamento Colab, primeiro habilitaremos a API Firebase Model Management para que o Colab possa implantar o modelo treinado em nosso Firebase console.

Ativar API Firebase Model Management

Crie um intervalo para armazenar seus modelos de ML

No console do Firebase, acesse Armazenamento e clique em Primeiros passos. fbbea78f0eb3dc9f.png

Siga o diálogo para configurar seu balde.

19517c0d6d2aa14d.png

Ativar 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 bloco de notas 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 console do Firebase que podemos sincronizar com nosso aplicativo.

Aberto no Colab

Nesta etapa, modificaremos nosso aplicativo para fazer o download do modelo que acabamos de treinar no Firebase Machine Learning.

Adicionar dependência do Firebase ML

A seguinte dependência é necessária para usar os modelos do Firebase Machine Learning em seu aplicativo. Já deve ser adicionado (verificar).

app / build.grade

implementation 'com.google.firebase:firebase-ml-model-interpreter:22.0.4'

Faça o download do modelo com a API Firebase Model Manager

Copie o código abaixo no 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çãoClient.kt

    private fun downloadModel(modelName: String) {
        val remoteModel = FirebaseCustomRemoteModel.Builder(modelName).build()
        val firebaseModelManager = FirebaseModelManager.getInstance()
        firebaseModelManager
            .isModelDownloaded(remoteModel)
            .continueWithTask { task ->
                // Create update condition if model is already downloaded, otherwise create download
                // condition.
                val conditions = if (task.result != null && task.result == true) {
                    FirebaseModelDownloadConditions.Builder()
                        .requireWifi()
                        .build() // Update condition that requires wifi.
                } else {
                    FirebaseModelDownloadConditions.Builder().build(); // Download condition.
                }
                firebaseModelManager.download(remoteModel, conditions)
            }
            .addOnSuccessListener {
                firebaseModelManager.getLatestModelFile(remoteModel)
                    .addOnCompleteListener {
                        val model = it.result
                        if (model == null) {
                            showToast(context, "Failed to get model file.")
                        } else {
                            showToast(context, "Downloaded remote model")
                            GlobalScope.launch { initializeInterpreter(model) }
                        }
                    }
            }
            .addOnFailureListener {
                showToast(context, "Model download failed for recommendations, please check your connection.")
            }
    }



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, em seguida, 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 de recomendação pelo modelo de recomendações são listados no arquivo Sort_movie_vocab.json na pasta res / assets. Copie o código a seguir para carregar esses candidatos.

RecomendaçãoClient.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çãoClient.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 intérprete para gerar recomendações

Aqui, usamos o modelo que baixamos em uma 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 filme. Copie o código a seguir em seu aplicativo.

RecomendaçãoClient.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çãoClient.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!

Você criou um recurso de recomendações em seu aplicativo usando TensorFlow Lite e Firebase. Observe que as técnicas e o pipeline mostrados neste codelab podem ser generalizados e usados ​​para servir 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
  • Modelo de recomendações de treinamento do TensorFlow
  • Exporte o modelo e implante no Firebase Console
  • Publique recomendações de filmes em um aplicativo

Próximos passos

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

Saber mais

Ter uma questão?

Reportar Problemas