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

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

As recomendações permitem que os aplicativos usem aprendizado de máquina para atender 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 gostar de 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, em seguida, usar esse modelo em um aplicativo iOS 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 do TF Lite
  • Implante o modelo TF Lite no Firebase ML e acesse-o em seu aplicativo
  • Execute a inferência de dispositivo usando o modelo para sugerir recomendações aos usuários

O que você precisará

  • Xcode 11 (ou superior)
  • CocoaPods 1.9.1 (ou superior)

Como você usará este tutorial?

Leia apenas Leia-o e complete os exercícios

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

Novato Intermediário Proficiente

2. Crie um projeto de console do Firebase

Adicionar Firebase ao projeto

  1. Acesse o console do Firebase .
  2. Selecione Create New Project e nomeie seu projeto como "Firebase ML iOS Codelab".

3. Obtenha o Projeto de Amostra

Baixe o código

Comece clonando o projeto de amostra e executando pod update no diretório do projeto:

git clone https://github.com/FirebaseExtended/codelab-contentrecommendation-ios.git
cd codelab-contentrecommendation-ios/start
pod install --repo-update

Se você não tiver o git instalado, também pode baixar o projeto de amostra em sua página do GitHub ou clicando neste link . Depois de baixar o projeto, execute-o no Xcode e experimente a recomendação para ter uma ideia de como funciona.

Configurar o Firebase

Siga a documentação para criar um novo projeto do Firebase. Depois de obter seu projeto, baixe o arquivo GoogleService-Info.plist do seu projeto no console do Firebase e arraste-o para a raiz do projeto Xcode.

4a923d5c7ae0d8f3.png

Adicione Firebase ao seu Podfile e execute pod install.

pod 'FirebaseAnalytics'
pod 'FirebaseMLModelDownloader', '9.3.0-beta'
pod 'TensorFlowLiteSwift'

No método didFinishLaunchingWithOptions do AppDelegate , importe Firebase na parte superior do arquivo

import FirebaseCore

E adicione uma chamada para configurar o Firebase.

FirebaseApp.configure()

Execute o projeto novamente para garantir que o aplicativo esteja configurado corretamente e não falhe ao iniciar.

  1. Certifique-se de que "Ativar o Google Analytics para este projeto" esteja ativado.
  2. 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).

4. Adicione o Firebase Analytics ao aplicativo

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

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

Adicione o código abaixo para registrar um evento analítico quando o usuário clicar como em um filme.

AllMoviesCollectionViewController.swift

import FirebaseAnalytics
//


override func collectionView(_ collectionView: UICollectionView, didSelectItemAt indexPath: IndexPath) {
//

if movie.liked == nil {
      movie.liked = true
      Analytics.logEvent(AnalyticsEventSelectItem, parameters: [AnalyticsParameterItemID: movie.id])
    } else {
      movie.liked?.toggle()
    }
       
}

5. Teste sua integração com o Analytics

Nesta etapa, vamos gerar eventos do Analytics no app e verificar se estão sendo enviados para o Console do Firebase.

Ativar registro de depuração do Analytics

Geralmente, os eventos registrados pelo seu aplicativo são agrupados em lotes durante o período de aproximadamente uma hora e carregados juntos. Essa abordagem economiza a bateria dos dispositivos dos usuários finais e reduz o uso de dados da rede. No entanto, para fins de validação de sua implementação de análise (e, para visualizar sua análise no relatório DebugView), você pode habilitar o modo de depuração em seu dispositivo de desenvolvimento para carregar eventos com um atraso mínimo.

Para habilitar o modo Analytics Debug em seu dispositivo de desenvolvimento, especifique o seguinte argumento de linha de comando no Xcode:

-FIRDebugEnabled

Neste ponto, você integrou com sucesso o Firebase Analytics em 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. A etapa a seguir é opcional para ver os mesmos eventos do Analytics que você viu no Logcat também serem 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 Xcode, selecione Executar para iniciar o aplicativo e adicionar alguns filmes à sua lista de curtidos.
  4. No DebugView do console do Firebase, verifique se esses eventos estão sendo registrados à medida que você adiciona filmes ao aplicativo.

6. Exporte os dados do Analytics para o Big Query

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

Ativar exportação do BigQuery

  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 BigQuery .
  5. Selecione Next na etapa About Linking Firebase to 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 .

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. 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 os eventos dos últimos dias na tabela de eventos.

Treinar um modelo de recomendações requer muitos dados. Como ainda não temos um aplicativo gerando grandes quantidades de dados, na próxima etapa importaremos um conjunto de dados de amostra para o BigQuery para usar no restante deste tutorial.

7. Use o BigQuery para obter dados de treinamento do modelo

Agora que conectamos nosso console do Firebase 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 propósitos deste tutorial, nesta etapa importaremos um conjunto de dados de amostra existente para seu 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. Em Create table from selecione 'Google Cloud Storage'.
  9. No campo Select file from GCS bucket , digite 'gs://firebase-recommendations/recommendations-test/formatted_data_filtered.txt'.
  10. Selecione 'JSONL' no menu suspenso Formato de arquivo .
  11. Digite '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 conjunto de dados de amostra

Neste ponto, opcionalmente, você pode explorar 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 de recomendações para visualizar o esquema da tabela.
  3. Selecione Visualizar para ver os dados reais do evento 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 seguinte 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 BigQuery e BigQuery Storage API. < clique aqui >
  3. Acesse 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 o seu computador.

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

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

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

  1. importar os dados do BigQuery para o notebook Colab
  2. pré-processar os dados para prepará-los para o treinamento do modelo
  3. treine 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 notebook de treinamento do Colab, primeiro habilitaremos a Firebase Model Management API para que o Colab possa implantar o modelo treinado em nosso Firebase console.

Ativar a API Firebase Model Management

Crie um bucket para armazenar seus modelos de ML

No Firebase Console, vá para Storage e clique em Começar. fbbea78f0eb3dc9f.png

Siga o diálogo para configurar seu balde.

19517c0d6d2aa14d.png

Ativar Firebase ML API

Acesse a página Firebase ML API no Console do Google Cloud 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 nele. Depois de concluir as etapas no notebook Colab, você terá um arquivo de modelo TF Lite implantado no Firebase console que podemos sincronizar com nosso aplicativo.

Aberto no Colab

9. 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 Firebase Machine Learning em seu aplicativo. Já deve estar adicionado (verificar).

Podfile

import FirebaseCore
import FirebaseMLModelDownloader

Baixe o modelo com a API Firebase Model Manager

Copie o código abaixo em ModelLoader.swift 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.

ModelLoader.swift

static func downloadModel(named name: String,
                            completion: @escaping (CustomModel?, DownloadError?) -> Void) {
    guard FirebaseApp.app() != nil else {
      completion(nil, .firebaseNotInitialized)
      return
    }
    guard success == nil && failure == nil else {
      completion(nil, .downloadInProgress)
      return
    }
    let conditions = ModelDownloadConditions(allowsCellularAccess: false)
    ModelDownloader.modelDownloader().getModel(name: name, downloadType: .localModelUpdateInBackground, conditions: conditions) { result in
            switch (result) {
            case .success(let customModel):
                    // Download complete.
                    // The CustomModel object contains the local path of the model file,
                    // which you can use to instantiate a TensorFlow Lite classifier.
                    return completion(customModel, nil)
            case .failure(let error):
                // Download was unsuccessful. Notify error message.
              completion(nil, .downloadFailed(underlyingError: error))
            }
    }
  }

10. Integre o modelo de recomendação Tensorflow Lite em 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 um pré-processamento para gerar as entradas para nosso modelo e um pós-processamento onde extrairemos os resultados de nossa inferência .

Carregar Dicionário e Etiquetas

Os rótulos usados ​​para gerar os candidatos à recomendação pelo modelo de recomendações estão listados no arquivo sorted_movie_vocab.json na pasta assets. Copie o código a seguir para carregar esses candidatos.

RecomendaçõesViewController.swift

  func getMovies() -> [MovieItem] {
    let barController = self.tabBarController as! TabBarController
    return barController.movies
  }

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çõesViewController.swift

  // Given a list of selected items, preprocess to get tflite input.
  func preProcess() -> Data {
    let likedMovies = getLikedMovies().map { (MovieItem) -> Int32 in
      return MovieItem.id
    }
    var inputData = Data(copyingBufferOf: Array(likedMovies.prefix(10)))

    // Pad input data to have a minimum of 10 context items (4 bytes each)
    while inputData.count < 10*4 {
      inputData.append(0)
    }
    return inputData
  }

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çõesViewController.swift

import TensorFlowLite

RecomendaçõesViewController.swift

 private var interpreter: Interpreter?

 func loadModel() {
    // Download the model from Firebase
    print("Fetching recommendations model...")
    ModelDownloader.fetchModel(named: "recommendations") { (filePath, error) in
      guard let path = filePath else {
        if let error = error {
          print(error)
        }
        return
      }
      print("Recommendations model download complete")
      self.loadInterpreter(path: path)
    }
  }

 func loadInterpreter(path: String) {
    do {
      interpreter = try Interpreter(modelPath: path)

      // Allocate memory for the model's input `Tensor`s.
      try interpreter?.allocateTensors()

      let inputData = preProcess()

      // Copy the input data to the input `Tensor`.
      try self.interpreter?.copy(inputData, toInputAt: 0)

      // Run inference by invoking the `Interpreter`.
      try self.interpreter?.invoke()

      // Get the output `Tensor`
      let confidenceOutputTensor = try self.interpreter?.output(at: 0)
      let idOutputTensor = try self.interpreter?.output(at: 1)

      // Copy output to `Data` to process the inference results.
      let confidenceOutputSize = confidenceOutputTensor?.shape.dimensions.reduce(1, {x, y in x * y})

      let idOutputSize = idOutputTensor?.shape.dimensions.reduce(1, {x, y in x * y})

      let confidenceResults =
        UnsafeMutableBufferPointer<Float32>.allocate(capacity: confidenceOutputSize!)
      let idResults =
        UnsafeMutableBufferPointer<Int32>.allocate(capacity: idOutputSize!)
      _ = confidenceOutputTensor?.data.copyBytes(to: confidenceResults)
      _ = idOutputTensor?.data.copyBytes(to: idResults)

      postProcess(idResults, confidenceResults)

      print("Successfully ran inference")
      DispatchQueue.main.async {
        self.tableView.reloadData()
      }
    } catch {
      print("Error occurred creating model interpreter: \(error)")
    }
  }

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çõesViewController.swift

  // Postprocess to get results from tflite inference.
  func postProcess(_ idResults: UnsafeMutableBufferPointer<Int32>, _ confidenceResults: UnsafeMutableBufferPointer<Float32>) {
    for i in 0..<10 {
      let id = idResults[i]
      let movieIdx = getMovies().firstIndex { $0.id == id }
      let title = getMovies()[movieIdx!].title
      recommendations.append(Recommendation(title: title, confidence: confidenceResults[i]))
    }
  }

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!

11. 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 servir também a outros tipos de recomendações.

O que cobrimos

  • Firebase ML
  • Firebase Analytics
  • Exportar eventos de análise para o BigQuery
  • Pré-processar eventos analíticos
  • Recomendações de treinamento do modelo do TensorFlow
  • Exportar modelo e implantar no Console do Firebase
  • Exiba 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?

Relatar problemas