Codelab de otimização de compras no app em tempo real no dispositivo

1. Visão geral

Este é o codelab de otimização de compras no app em tempo real no dispositivo. Neste codelab, você vai aprender a usar o TensorFlow Lite e o Firebase para treinar e implantar um modelo de personalização personalizada no seu app.

Este tutorial mostra como criar um modelo de machine learning para personalização, em especial um que prevê a oferta de compra no app (IAP) ideal, considerando o estado em que o usuário está. Este é um exemplo de problema de bandido contextual, um tipo importante e amplamente aplicável de problema de aprendizado de máquina que você vai conhecer melhor neste codelab.

O que você vai aprender

• Coletar dados de análise com o Firebase Analytics
• Pré-processar dados de análise usando o BigQuery
• Treine um modelo de ML simples para otimizar as compras no app (IAPs) no dispositivo
• Implantar modelos do TFLite no Firebase ML e acessá-los no app
• Medir e testar diferentes modelos com o Teste A/B do Firebase
• Treine e implante novos modelos usando os dados mais recentes em uma cadência recorrente

Pré-requisitos

• Android Studio versão 3.4 ou mais recente
• Um dispositivo de teste físico com o Android 2.3 ou versões mais recentes e o Google Play Services 9.8 ou versões mais recentes, ou um emulador com o Google Play Services 9.8 ou versões mais recentes
• Se você estiver usando um dispositivo de teste físico, um cabo de conexão
• Conhecimentos básicos de ML

Como você usará este tutorial?

Apenas leitura Leitura e exercícios

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

Iniciante Intermediário Proficiente

2. Declaração do problema

Digamos que você seja um desenvolvedor de jogos que quer mostrar sugestões personalizadas de compras no app (IAP) no final de cada nível. Você só pode mostrar um número limitado de opções de IAP a cada vez e não sabe quais vão ter a melhor conversão. Considerando que cada usuário e cada sessão são diferentes, como encontrar a oferta de IAP que oferece a maior recompensa esperada?

3. Acessar o exemplo de código

Clone o repositório do GitHub (link em inglês) na linha de comando.

git clone https://github.com/googlecodelabs/firebase-iap-optimization.git

Este repositório contém:

1. Um notebook Jupyter (.ipynb) que treina o modelo de personalização e o empacota em um modelo do TFLite
2. Um app Kotlin de exemplo que usa o modelo TFLite para fazer previsões no dispositivo

4. Executar o app com o Firebase

Neste codelab, vamos otimizar os IAPs do nosso app de jogo fictício, o Flappy Sparky. O jogo é um side-scroller em que o jogador controla um Sparky, tentando voar entre colunas de paredes sem bater nelas. No início do nível, o usuário recebe uma oferta de compra no app que concede um power-up. Neste codelab, vamos implementar apenas a parte de otimização de IAP do app.

Você poderá aplicar o que aprender aqui ao seu próprio app conectado a um projeto do Firebase. Como alternativa, crie um novo projeto do Firebase para este codelab. Se precisar de ajuda para começar a usar o Firebase, consulte nossos tutoriais sobre esse assunto ( Android e iOS).

5. Coletar eventos de análise no seu app

Os eventos do Google Analytics fornecem insights sobre o comportamento do usuário e são usados para treinar o modelo de ML. Por exemplo, o modelo pode aprender que os usuários que jogam por mais tempo têm mais probabilidade de fazer uma compra no app para ter vidas extras. O modelo de ML precisa de eventos de análise como entrada para aprender essas informações.

Alguns eventos de análise que talvez você queira registrar incluem:

• Quanto tempo o usuário joga o jogo
• O nível que o usuário alcança
• Quantas moedas o usuário gasta
• Quais itens o usuário compra

Fazer o download de dados de amostra (opcional)

Nas etapas a seguir, vamos usar o Firebase Analytics para registrar eventos de análise para usar no nosso modelo. Se você já tiver dados de análise que quer usar, vá para a seção "Treinar o modelo de otimização" deste codelab e siga os dados de exemplo.

Coletar dados com o SDK do Firebase Analytics

Vamos usar o Firebase Analytics para ajudar a coletar esses eventos de análise. O SDK do Firebase Analytics captura automaticamente vários eventos e propriedades do usuário. Também é possível definir seus próprios eventos personalizados para medir os eventos exclusivos do seu app.

Instalar o SDK do Firebase Analytics

Para começar a usar o Firebase Analytics no seu app, siga a documentação de Primeiros passos com o Google Analytics. O repositório firebase-iap-optimization clonado no início deste codelab já inclui o SDK do Firebase Analytics.

Registrar eventos personalizados

Depois de configurar o SDK do Firebase Analytics, podemos começar a registrar os eventos necessários para treinar nosso modelo.

Antes disso, é importante definir um ID do usuário no evento de análise para que possamos associar os dados de análise desse usuário aos dados existentes no app.

MainActivity.kt

firebaseAnalytics.setUserId("player1")

Em seguida, podemos registrar os eventos do jogador. Para otimizar o IAP, queremos registrar cada oferta de IAP apresentada ao usuário e se ele clicou nela. Isso vai gerar dois eventos de análise: offer_iap e offer_accepted. Também vamos acompanhar um offer_id exclusivo para podermos usá-lo mais tarde e combinar esses dados para saber se uma oferta foi aceita.

MainActivity.kt

predictButton?.setOnClickListener {
  predictionResult = iapOptimizer.predict()

  firebaseAnalytics.logEvent("offer_iap"){
    param("offer_type", predictionResult)
    param("offer_id", sessionId)
  }
}

acceptButton?.setOnClickListener {
  firebaseAnalytics.logEvent("offer_accepted") {
    param("offer_type", predictionResult)
    param("offer_id", sessionId)
  }
}

Para mais informações sobre como registrar eventos personalizados, acesse a documentação de eventos de registro do Firebase Analytics.

6. Pré-processar dados no BigQuery

Na última etapa, coletamos eventos sobre qual oferta de IAP é apresentada ao usuário e qual é clicada por ele. Nesta etapa, vamos combinar esses dados de eventos com os dados do usuário para que nosso modelo possa aprender com uma imagem completa.

Para isso, precisamos começar exportando os eventos do Google Analytics para o BigQuery.

Vincular o projeto do Firebase ao BigQuery

Para vincular seu projeto do Firebase e os aplicativos dele ao BigQuery, faça as seguintes ações:

1. Faça login no Firebase.
2. Clique em e selecione "Configurações do projeto".
3. Na página "Configurações do projeto", clique na guia "Integrações".
4. No cartão do BigQuery, clique em Vincular.

(Opcional) Exportar suas coleções do Firestore para o BigQuery

Nesta etapa, você tem a opção de exportar outros dados do usuário do Firestore para o BigQuery e usar para ajudar a treinar o modelo. Se você quiser pular esta etapa por enquanto, vá para a seção "Preparar dados no BigQuery" deste codelab e siga os eventos do Google Analytics para Firebase registrados na última etapa.

O Firestore pode ser onde você armazenou a data de inscrição dos usuários, as compras no app feitas, os níveis do jogo, as moedas no saldo ou qualquer outro atributo que possa ser útil para treinar o modelo.

Para exportar suas coleções do Firestore para o BigQuery, instale a extensão de exportação do BigQuery para o Firestore. Em seguida, agrupe tabelas no BigQuery para combinar esses dados com os do Google Analytics e usar no modelo de personalização e no restante deste codelab.

Como preparar dados no BigQuery

Nas próximas etapas, vamos usar o BigQuery para transformar nossos dados brutos de análise em dados úteis para treinar nosso modelo.

Para que nosso modelo aprenda qual oferta de IAP apresentar com base no usuário e no estado do jogo, precisamos organizar dados sobre o seguinte:

• o usuário
• o estado do jogo
• a oferta apresentada
• se a oferta apresentada recebeu ou não um clique

Todos esses dados precisam ser organizados em uma única linha em uma tabela para que nosso modelo os processe. Felizmente, o BigQuery foi configurado para ajudar a fazer isso.

O BigQuery permite criar "visualizações" para manter a consulta organizada. Uma visualização é uma tabela virtual definida por uma consulta SQL. Ao criar uma visualização, você a consulta da mesma forma que faz com uma tabela. Com isso, podemos limpar nossos dados de análise.

Para saber se cada oferta de compra no app é clicada, precisamos juntar os eventos offer_iap e offer_accepted que registramos na etapa anterior.

all_offers_joined: visualização do BigQuery

SELECT
  iap_offers.*,
  CASE
    WHEN accepted_offers.accepted IS NULL THEN FALSE ELSE TRUE
  END
  is_clicked,
FROM
  `iap-optimization.ml_sample.accepted_offers` AS accepted_offers
RIGHT JOIN
  `iap-optimization.ml_sample.iap_offers` AS iap_offers
ON
 accepted_offers.offer_id =iap_offers.offer_id;

all_offers_with_user_data: visualização do BigQuery

SELECT
  offers.is_clicked,
  offers.presented_powerup,
  offers.last_run_end_reason,
  offers.event_timestamp,
  users.*
FROM
  `iap-optimization.ml_sample.all_offers_joined` AS offers
LEFT JOIN
  `iap-optimization.ml_sample.all_users` AS users
ON
  users.user_id = offers.user_id;

Exportar um conjunto de dados do BigQuery para o Google Cloud Storage

Por fim, podemos exportar o conjunto de dados do BigQuery para o GCS para usá-lo no treinamento do modelo.

7. Treinar o modelo de otimização

Dados de amostra

Use os dados da etapa anterior, "Pré-processar dados no BigQuery", ou os exemplos de dados para download fornecidos aqui para acompanhar o restante deste codelab.

Definição do problema

Antes de começarmos a treinar o modelo, vamos definir o problema dos bandidos contextuais.

Explicação sobre os bandidos contextuais

No início de cada nível no Flappy Sparky, o usuário recebe uma oferta de IAP que dá um powerup. Só podemos mostrar uma opção de IAP por vez e não sabemos quais vão ter a melhor conversão. Considerando que cada usuário e cada sessão são diferentes, como encontrar a oferta de IAP que oferece a maior recompensa esperada?

Nesse caso, vamos definir a recompensa como 0 se o usuário não aceitar a oferta do IAP e como o valor do IAP se ele aceitar. Para tentar maximizar sua recompensa, podemos usar nossos dados históricos para treinar um modelo que prevê a recompensa esperada para cada ação dada a um usuário e encontrar a ação com a maior recompensa.

Confira o que vamos usar na previsão:

• Estado: informações sobre o usuário e a sessão atual
• Ação: ofertas de IAP que podemos mostrar
• Recompensa: valor da oferta de compra no app

Exploração x exploração

Para todos os problemas de bandidos com vários braços, o algoritmo precisa equilibrar a exploração (obter mais dados para aprender qual ação gera o resultado ideal) e a exploração (usar o resultado ideal para receber a maior recompensa).

Na nossa versão do problema, vamos simplificar isso para treinar o modelo periodicamente na nuvem e fazer previsões apenas ao usar o modelo no dispositivo do usuário (em vez de treinar no dispositivo do usuário). Para garantir que temos dados de treinamento suficientes após o uso do modelo, às vezes precisamos mostrar resultados aleatórios aos usuários do app (por exemplo, 30%). Essa estratégia de equilíbrio entre exploração e aproveitamento é chamada de Epsilon-greedy.

Como treinar o modelo

Você pode usar o script de treinamento (training.ipynb) fornecido com o codelab para começar. Nosso objetivo é treinar um modelo que preveja as recompensas esperadas para cada ação em um estado e, em seguida, encontrar a ação que oferece as recompensas esperadas mais altas.

Treinamento local

A maneira mais fácil de começar a treinar seu próprio modelo é fazer uma cópia do notebook no exemplo de código deste codelab.

Você não precisa de uma GPU para este codelab, mas, se precisar de uma máquina mais potente para explorar seus dados e treinar seu modelo, use uma instância do AI Platform Notebook para acelerar o treinamento.

No script de treinamento fornecido, criamos um iterador que gera dados de treinamento dos arquivos CSV exportados do BigQuery. Em seguida, usamos os dados para começar a treinar nosso modelo com o Keras. Os detalhes sobre como treinar o modelo podem ser encontrados nos comentários do notebook Python.

Medir a performance do modelo

Durante o treinamento do modelo, vamos compará-lo com um agente aleatório que seleciona ofertas de IAP aleatoriamente para saber se o modelo está realmente aprendendo. Essa lógica está em ValidationCallback.

No final do treinamento, usamos os dados em test.csv para testar o modelo novamente. O modelo nunca tinha visto esses dados antes, então podemos ter certeza de que o resultado não é devido a overfitting. Nesse caso, o modelo tem uma performance 28% melhor do que o agente aleatório.

Exportar o modelo do TFLite

Agora temos um modelo treinado pronto para uso, mas ele está no formato do TensorFlow. Vamos exportar o modelo no formato TFLite para que ele possa ser executado em dispositivos móveis.

train.ipynb

converter = tflite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()

with tf.io.gfile.GFile('iap-optimizer.tflite', 'wb') as f:
  f.write(tflite_model)

Aqui, você pode fazer o download do modelo e agrupá-lo com seu app.

Opcionalmente, para um app de produção, recomendamos que você implante o modelo no Firebase ML e hospede o modelo no Firebase. Isso é útil por dois motivos principais:

1. Podemos manter o tamanho da instalação do app pequeno e fazer o download do modelo apenas quando necessário.
2. O modelo pode ser atualizado regularmente e com um ciclo de lançamento diferente do app inteiro

Para saber como implantar o modelo no Firebase ML, siga o codelab Adicionar o Firebase ao seu app Android com tecnologia do TFLite. Você tem a opção de implantar usando o console do Firebase ou a API Python.

8. Como fazer previsões no dispositivo

A próxima etapa é fazer previsões usando o modelo no dispositivo. Você pode encontrar um exemplo de app que faz o download de um modelo do Firebase ML na pasta app do código de exemplo que você fez o download e usá-lo para realizar inferências com alguns dados do lado do cliente.

Como aplicamos um pré-processamento durante o treinamento do modelo, precisamos aplicar o mesmo pré-processamento à entrada do modelo ao executar no dispositivo. Uma maneira simples de fazer isso é usar um formato independente de plataforma e idioma, como um arquivo JSON contendo um mapa de todos os recursos para metadados sobre como o pré-processamento é feito. Confira mais detalhes sobre como fazer isso no app de exemplo.

Em seguida, fornecemos ao modelo uma entrada de teste da seguinte maneira:

IapOptimizer.kt

  val testInput = mapOf(
    "coins_spent" to                       2048f,
    "distance_avg" to                      1234f,
    "device_os" to                         "ANDROID",
    "game_day" to                          10f,
    "geo_country" to                       "Canada",
    "last_run_end_reason" to               "laser"
  )

O modelo sugere que sparky_armor é o melhor powerup de IAP para esse usuário em particular.

Medir a precisão do modelo

Para medir a precisão do modelo, basta acompanhar as ofertas de IAP previstas pelo modelo e se elas são clicadas usando o Firebase Analytics. Você pode usar isso com o Teste A/B do Firebase para medir o desempenho real do modelo. Além disso, você também pode realizar testes A/B em diferentes iterações do modelo. Saiba mais sobre os testes A/B com o Firebase na documentação Criar experimentos da Configuração remota do Firebase com o Teste A/B.

9. Opcional: atualizar o modelo regularmente com novos dados

Se você precisar atualizar o modelo à medida que novos dados forem recebidos, configure um pipeline para treinar o modelo novamente de forma recorrente. Para fazer isso, primeiro verifique se você tem novos dados para usar no treinamento usando a estratégia de epsilon-greedy mencionada acima. Por exemplo, usar o resultado da previsão do modelo 70% do tempo e usar resultados aleatórios 30% do tempo.

Configurar um pipeline para treinamento e implantação com novos dados está fora do escopo deste codelab. Para começar, confira o Google Cloud AI Platform e o TFX.

10. Parabéns!

Neste codelab, você aprendeu a treinar e implantar um modelo do TFLite no dispositivo para otimizar as compras no app usando o Firebase. Para saber mais sobre o TFLite e o Firebase, confira outros exemplos do TFLite e os guias de início do Firebase.

Se tiver dúvidas, envie para o Stack Overflow #firebase-machine-learning.

O que vimos

• TensorFlow Lite
• Firebase ML
• Firebase Analytics
• BigQuery

Próximas etapas

• Treine e implante um modelo de otimizador para seu app.

Saiba mais

• Documentação do Firebase Machine Learning
• Documentação do TensorFlow Lite
• Testes A/B de modelos com o Firebase