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

1. Visão geral

1cbf855eda62c306.png

Este é o codelab de otimização de compras no app no dispositivo em tempo real. 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 de problema de aprendizado de máquina importante e amplamente aplicável 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
  • Treinar um modelo de ML simples para otimizar as compras no app (IAPs) no dispositivo
  • Implante modelos do TFLite no Firebase ML e acesse-os pelo seu 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
  • Conhecimento iniciante em 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 compra no app que ofereça 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 do Jupyter (.ipynb) que treina o modelo de personalização e o empacota em um modelo do TFLite
  2. Um app de exemplo em Kotlin que usa o modelo TFLite para fazer previsões no dispositivo.

4. Executar o app com o Firebase

Neste codelab, vamos otimizar as compras no app do nosso app de jogo fictício: 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, você pode criar um novo projeto do Firebase para este codelab. Se você precisar de ajuda para começar a usar o Firebase, consulte nossos tutoriais sobre esse tópico ( Android e iOS).

5. Coletar eventos de análise no seu app

Os eventos de análise 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 usuários que jogam por mais tempo têm mais chances de fazer uma compra no app para ganhar 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 próximas etapas, vamos usar o Firebase Analytics para registrar eventos de análise para usar no nosso modelo. Se você já tem 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 permite definir seus próprios eventos personalizados para medir os eventos exclusivos do seu app.

Como 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, vamos começar a registrar os eventos necessários para treinar o modelo.

Antes de fazer isso, é importante definir um ID do usuário no evento de análise. Assim, podemos associar os dados de análise desse usuário aos dados dele no app.

MainActivity.kt (link em inglês)

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 rastrearemos um offer_id exclusivo para que possamos usá-lo mais tarde na combinação desses dados e ver 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 quais ofertas de compra no app são apresentadas ao usuário e qual delas é clicada pelo usuário. Nesta etapa, vamos combinar esses dados de eventos com 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.

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 o ícone "Configurações" 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 para usar no treinamento do modelo. Se você quiser pular esta etapa por enquanto, vá para a seção "Como preparar dados no BigQuery" deste codelab, e você pode acompanhar os eventos do Firebase Analytics 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 no treinamento do modelo.

Para exportar suas coleções do Firestore para o BigQuery, instale a extensão do BigQuery Export do Firestore. Em seguida, una 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 recebe ou não um clique

Todos esses dados precisam ser organizados em uma única linha em uma tabela para que nosso modelo possa processá-los. 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, ela é consultada da mesma forma que uma tabela. Com isso, podemos limpar nossos dados de análise.

Para ver se cada oferta de compra no app é clicada, precisamos mesclar os eventos offer_iap e offer_accepted registrados 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 a fim de usá-lo no treinamento do modelo.

888daa7ba4db8e44.png

14d22bf474fae455.png

7. Treinar o modelo de otimização

Dados de amostra

Use os dados da etapa anterior, "Pré-processar dados no BigQuery", ou os dados de exemplo disponíveis para download aqui para acompanhar este codelab.

Definição do problema

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

Explicação dos bandidos contextuais

No início de cada nível no Flappy Sparky, o usuário recebe uma oferta de compra no app que dará um poder. Só podemos mostrar uma opção de IAP por vez e não sabemos quais vão ter a melhor conversão. Como 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 e o valor de compra no app, caso ela aceite. Para tentar maximizar seu prêmio, 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.

e7d3264141498bff.jpeg

Confira o que vamos usar na previsão:

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

Exploração x exploração

Em todos os problemas do tipo multi-armed bandit, 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 apenas 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 também). Para garantir que tenhamos dados de treinamento suficientes depois de usarmos o modelo, às vezes vamos precisar mostrar resultados aleatórios para os usuários do app (por exemplo, 30%). Essa estratégia de equilibrar exploração e exploração é chamada de Epsilon-greedy.

Como treinar o modelo

Você pode usar o script de treinamento (training.ipynb) fornecido com o codelab para começar. Nossa meta é treinar um modelo que preveja as recompensas esperadas para cada ação de acordo com um determinado estado. Em seguida, encontramos a ação que resulta nas recompensas mais altas.

Como treinar localmente

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 notebook da plataforma de IA para acelerar o treinamento.

No script de treinamento fornecido, criamos um iterador que gera dados de treinamento a partir dos arquivos CSV que exportamos do BigQuery. Depois, usamos os dados para começar a treinar o modelo com o Keras. Detalhes de como treinar o modelo podem ser encontrados nos comentários do notebook Python.

Medir o desempenho do modelo

Durante o treinamento do modelo, vamos compará-lo com um agente aleatório que seleciona ofertas de IAP de forma aleatória para ver se o modelo está de fato 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 um desempenho 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. É preciso exportar o modelo no formato TFLite para que ele possa ser executado em dispositivos móveis.

train.ipynb (em inglês)

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 deixe o Firebase hospedar seu modelo. 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. É possível encontrar um app de exemplo que faz o download de um modelo do Firebase ML na pasta app do exemplo de código que você transferiu por download e o utiliza para realizar inferência 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:

IapOptimzer.kt (link em inglês)

  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 poder de compra no app para esse usuário específico.

a3381dbcdbdf811e.png

Medir a acurácia 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, também é possível realizar testes A/B em diferentes iterações do modelo. Saiba mais sobre o teste A/B com o Firebase na documentação Criar experimentos de 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% das vezes e usar resultados aleatórios 30% das vezes.

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

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.

Em caso de dúvidas, entre em contato pelo e-mail 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