Como treinar o NCF no Cloud TPU (TF 2.x)

Visão geral

Esta é uma implementação do framework de filtragem colaborativa neural (NCF, na sigla em inglês) com o modelo de fatoração de matriz neural (NeuMF, na sigla em inglês), conforme descrito no documento de filtragem colaborativa neural. A implementação atual se baseia no código do código NCF dos autores e na implementação de Stanford no Repo MLPerf.

O NCF é um framework geral para filtragem colaborativa de recomendações em que uma arquitetura de rede neural é usada para modelar as interações do item de usuários. Ao contrário dos modelos tradicionais, o NCF não utiliza a Fatoração de Matriz (MF) com um produto interno sobre recursos latentes de usuários e itens. Ele substitui o produto interno por um periférico de várias camadas que pode aprender uma função arbitrária a partir dos dados.

Duas implementações de NCF são a fatoração de matriz generalizada (GMF, na sigla em inglês) e o periférico de várias camadas (MLP, na sigla em inglês). A GMF aplica um kernel linear para modelar as interações de recursos latentes, e o MLP usa um kernel não linear para aprender a função de interação a partir dos dados. NeuMF é um modelo combinado de GMF e MLP para melhor modelar as interações complexas entre itens de usuários e unifica as forças da linearidade de MF e da não linearidade do MLP para modelar as estruturas latentes do item de usuário. O NeuMF permite que a GMF e o MLP aprendam os embeddings separados. Ele combina os dois modelos concatenando a última camada oculta. O neumf_model.py define os detalhes da arquitetura.

Nas instruções abaixo, presume-se que você conheça o treinamento de um modelo na Cloud TPU. Se você conhece a Cloud TPU há pouco tempo, consulte o guia de início rápido para ver os conceitos básicos.

Dataset

Os conjuntos de dados MovieLens são usados para treinamento e avaliação de modelos. Especificamente, usamos dois conjuntos de dados: ml-1m (abreviação de MovieLens 1 milhão) e ml-20m (abreviação de MovieLens 20 milhões).

ml-1m

O conjunto de dados ml-1m contém 1.000.209 avaliações anônimas de aproximadamente 3.706 filmes feitas por 6.040 usuários que entraram para o MovieLens em 2000. Todas as classificações estão contidas no arquivo "ratings.dat" sem uma linha de cabeçalho e estão no seguinte formato:

UserID::MovieID::Rating::Timestamp

  • Os códigos dos usuários variam entre 1 e 6040.
  • Os códigos dos filmes estão entre 1 e 3952.
  • As classificações são feitas em uma escala de 5 estrelas (somente classificações com estrelas inteiras).

ml-20m

O conjunto de dados ml-20m contém 20.000.263 classificações de 26.744 filmes por 138493 usuários. Todas as avaliações estão contidas no arquivo "notas.csv". Cada linha desse arquivo depois da linha do cabeçalho representa uma classificação de um filme por um usuário e tem o seguinte formato:

userId,movieId,rating,timestamp

As linhas dentro desse arquivo são ordenadas primeiro por código de usuário, depois, na parte de usuário, por código de filme. As classificações são feitas em uma escala de 5 estrelas, com incrementos de meia estrela (0,5 estrelas - 5 estrelas). Nos dois conjuntos de dados, o carimbo de data / hora é representado em segundos desde a meia-noite do horário universal coordenado (UTC, na sigla em inglês) de 1º de janeiro de 1970. Cada usuário tem pelo menos 20 avaliações.

Objetivos

  • Criar um bucket do Cloud Storage para armazenar o conjunto de dados e a saída do modelo.
  • Preparar o conjunto de dados do MovieLens
  • Configurar uma VM do Compute Engine e um nó da Cloud TPU para treinamento e avaliação.
  • Executar treinamento e avaliação

Custos

Neste tutorial, há componentes faturáveis do Google Cloud, entre eles:

  • Compute Engine
  • Cloud TPU
  • Cloud Storage

Use a calculadora de preços para gerar uma estimativa de custos baseada na projeção de uso. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

Antes de começar

Antes de começar o tutorial, verifique se o projeto do Google Cloud foi configurado corretamente.

  1. Faça login na sua conta do Google.

    Se você ainda não tiver uma, inscreva-se.

  2. No Console do Cloud, na página do seletor de projetos, selecione ou crie um projeto do Cloud.

    Acessar a página do seletor de projetos

  3. Verifique se a cobrança está ativada para o seu projeto do Google Cloud. Saiba como confirmar se a cobrança está ativada para o seu projeto.

  4. Este tutorial usa componentes faturáveis do Google Cloud. Consulte a página de preços da Cloud TPU para fazer uma estimativa dos custos. Para evitar cobranças desnecessárias, não se esqueça de apagar os recursos criados ao terminar de usá-los.

Configurar os recursos

Nesta seção, fornecemos informações sobre como configurar os recursos do Cloud Storage, da VM e do Cloud TPU para este tutorial.

  1. Abra uma janela do Cloud Shell.

    Abra o Cloud Shell

  2. Crie uma variável de ambiente para o código do projeto.

    export PROJECT_ID=project-id
  3. Configure a ferramenta de linha de comando da gcloud para usar o projeto em que o Cloud TPU será criado.

    gcloud config set project ${PROJECT_ID}
    
  4. Crie uma conta de serviço para o projeto da Cloud TPU.

    gcloud beta services identity create --service tpu.googleapis.com --project $PROJECT_ID
    

    O comando retorna uma conta de serviço do Cloud TPU com o formato a seguir:

    service-PROJECT_NUMBER@cloud-tpu.iam.gserviceaccount.com
    
  5. Crie um bucket do Cloud Storage usando o seguinte comando:

    gsutil mb -p ${PROJECT_ID} -c standard -l europe-west4 -b on gs://bucket-name
    

    Esse bucket do Cloud Storage armazena os dados usados para treinar o modelo e os resultados do treinamento. A ferramenta ctpu up usada neste tutorial configura permissões padrão para a conta de serviço do Cloud TPU configurada na etapa anterior. Caso queira permissões mais específicas, consulte as permissões de nível de acesso.

    O local do bucket precisa estar na mesma região da máquina virtual (VM) e do nó da TPU. As VMs e os nós da TPU estão localizados em zonas específicas, que são subdivisões dentro de uma região.

  6. Inicie uma VM do Compute Engine usando o comando ctpu up.

    $ ctpu up --zone=europe-west4-a \
     --vm-only \
     --disk-size-gb=300 \
     --machine-type=n1-standard-8 \
     --name=ncf-tutorial \
     --tf-version=2.3.1
    

    Descrições de sinalizações de comando

    zone
    A zona em que você planeja criar a Cloud TPU.
    vm-only
    Crie somente uma VM. Por padrão, o comando ctpu up cria uma VM e uma Cloud TPU.
    disk-size-gb
    O tamanho do disco para a VM em GB.
    machine_type
    O tipo de máquina da VM que o comando ctpu up cria.
    name
    O nome da VM do Compute Engine a ser criada.
    tf-version
    A versão do Tensorflow ctpu é instalada na VM.
  7. A configuração especificada aparecerá. Digite y para aprovar ou n para cancelar.

  8. Quando o comando ctpu up terminar a execução, verifique se o prompt do shell foi alterado de username@projectname para username@vm-name. Essa alteração mostra que você fez login na VM do Compute Engine.

    gcloud compute ssh ncf-tutorial --zone=europe-west4-a
    

    Ao seguir essas instruções, execute cada comando iniciado por (vm)$ na janela de sessão da VM.

Prepare os dados

  1. Adicione uma variável de ambiente para seu bucket de armazenamento. Substitua bucket-name pelo nome do seu bucket.

    (vm)$ export STORAGE_BUCKET=gs://bucket-name
    
  2. Adicione uma variável de ambiente para o diretório de dados.

    (vm)$ export DATA_DIR=${STORAGE_BUCKET}/ncf_data
    
  3. Adicione uma variável de ambiente para o caminho do Python.

    (vm)$ export PYTHONPATH="${PYTHONPATH}:/usr/share/models"
    
  4. Gere dados de treinamento e avaliação para o conjunto de dados ml-20m em DATA_DIR:

    (vm)$ python3 /usr/share/models/official/recommendation/create_ncf_data.py \
        --dataset ml-20m \
        --num_train_epochs 4 \
        --meta_data_file_path ${DATA_DIR}/metadata \
        --eval_prebatch_size 160000 \
        --data_dir ${DATA_DIR}
    

Esse script gera e pré-processa o conjunto de dados na VM. O pré-processamento converte os dados para o formato TFRecord necessário para o modelo. O download e o pré-processamento levam aproximadamente 25 minutos e geram uma saída semelhante a esta:

I0804 23:03:02.370002 139664166737728 movielens.py:124] Successfully downloaded /tmp/tmpicajrlfc/ml-20m.zip 198702078 bytes
I0804 23:04:42.665195 139664166737728 data_preprocessing.py:223] Beginning data preprocessing.
I0804 23:04:59.084554 139664166737728 data_preprocessing.py:84] Generating user_map and item_map...
I0804 23:05:20.934210 139664166737728 data_preprocessing.py:103] Sorting by user, timestamp...
I0804 23:06:39.859857 139664166737728 data_preprocessing.py:194] Writing raw data cache.
I0804 23:06:42.375952 139664166737728 data_preprocessing.py:262] Data preprocessing complete. Time: 119.7 sec.

General:
  Num users: 138493
  Num items: 26744

Training:
  Positive count:          19861770
  Batch size:              99000
  Batch count per epoch:   1004

Eval:
  Positive count:          138493
  Batch size:              160000
  Batch count per epoch:   866

I0804 23:07:14.137242 139664166737728 data_pipeline.py:887] Negative total vector built. Time: 31.8 seconds
I0804 23:11:25.013135 139664166737728 data_pipeline.py:588] Epoch construction complete. Time: 250.9 seconds
I0804 23:15:46.391308 139664166737728 data_pipeline.py:674] Eval construction complete. Time: 261.4 seconds
I0804 23:19:54.345858 139664166737728 data_pipeline.py:588] Epoch construction complete. Time: 248.0 seconds
I0804 23:24:09.182484 139664166737728 data_pipeline.py:588] Epoch construction complete. Time: 254.8 seconds
I0804 23:28:26.224653 139664166737728 data_pipeline.py:588] Epoch construction complete. Time: 257.0 seconds

Configurar e começar a treinar o Cloud TPU

  1. Execute o comando a seguir para criar o Cloud TPU.

    (vm)$ ctpu up --tpu-only \
      --tpu-size=v3-8 \
      --zone=europe-west4-a \
      --name=ncf-tutorial \
      --tf-version=2.3.1

    Descrições de sinalizações de comando

    tpu-only
    Cria a Cloud TPU sem criar uma VM. Por padrão, o comando ctpu up cria uma VM e uma Cloud TPU.
    tpu-size
    O tipo da Cloud TPU a ser criada.
    zone
    A zona em que você planeja criar a Cloud TPU.
    name
    O nome da Cloud TPU a ser criada.
    tf-version
    A versão do Tensorflow ctpu é instalada na VM.
  2. A configuração especificada aparecerá. Digite y para aprovar ou n para cancelar.

    Você verá a mensagem: Operation success; not ssh-ing to Compute Engine VM due to --tpu-only flag. Como você já concluiu a propagação de chave SSH anteriormente, ignore essa mensagem.

  3. Adicione uma variável de ambiente para o nome do Cloud TPU.

    (vm)$ export TPU_NAME=ncf-tutorial
    

Executar o treinamento e a avaliação

O script a seguir executa um exemplo de treinamento para três épocas.

  1. Adicione uma variável de ambiente para o diretório de modelos para salvar os checkpoints e os resumos do TensorBoard:

    (vm)$ export MODEL_DIR=${STORAGE_BUCKET}/ncf
    
  2. Execute o comando a seguir para treinar o modelo NCF:

    (vm)$ python3 /usr/share/models/official/recommendation/ncf_keras_main.py \
         --model_dir=${MODEL_DIR} \
         --data_dir=${DATA_DIR} \
         --train_dataset_path=${DATA_DIR}/training_cycle_*/* \
         --eval_dataset_path=${DATA_DIR}/eval_data/* \
         --input_meta_data_path=${DATA_DIR}/metadata \
         --learning_rate=3e-5 \
         --train_epochs=3 \
         --dataset=ml-20m \
         --eval_batch_size=160000 \
         --learning_rate=0.00382059 \
         --beta1=0.783529 \
         --beta2=0.909003 \
         --epsilon=1.45439e-07 \
         --dataset=ml-20m \
         --num_factors=64 \
         --hr_threshold=0.635 \
         --keras_use_ctl=true \
         --layers=256,256,128,64 \
         --use_synthetic_data=false \
         --distribution_strategy=tpu \
         --download_if_missing=false
     

O treinamento e a avaliação levam cerca de dois minutos e geram uma saída final semelhante a esta:

I0805 21:23:05.134161 139825684965184 ncf_keras_main.py:493] Done training epoch 3, epoch loss=0.097
I0805 21:23:06.722786 139825684965184 ncf_keras_main.py:506] Done eval epoch 3, hit_rate=0.585
I0805 21:23:16.005549 139825684965184 ncf_keras_main.py:523] Saving model as TF checkpoint: gs://gm-bucket-eu/ncf/ctl_checkpoint
I0805 21:23:16.058367 139825684965184 ncf_keras_main.py:562] Result is {'loss': , 'eval_loss': None, 'eval_hit_rate': , 'step_timestamp_log': ['BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTim
estamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp',
 'BatchTimestamp', 'BatchTimestamp', 'BatchTimestamp', 'BatchTime
stamp', 'BatchTimestamp', 'BatchTimestamp'], 'train_finish_time': 1596662568.102817, 'avg_exp_per_second': 4474047.406912873}

Como fazer a limpeza

Para evitar cobranças dos recursos usados neste tutorial na conta do Google Cloud Platform:

Limpe a instância de VM do Compute Engine e os recursos da Cloud TPU.

  1. Desconecte-se da instância do Compute Engine, caso ainda não tenha feito isso:

    (vm)$ exit
    

    Agora, o prompt será username@projectname, mostrando que você está no Cloud Shell.

  2. Na VM ou no Cloud Shell, execute ctpu delete com as sinalizações --name e --zone usadas ao configurar o Cloud TPU para excluir a TPU:

    $ ctpu delete --name=ncf-tutorial \
      --zone=europe-west4-a
    
  3. Execute o seguinte comando para verificar se a VM do Compute Engine e a Cloud TPU foram encerradas:

    $ ctpu status --name=ncf-tutorial --zone=europe-west4-a
    

    A exclusão pode levar vários minutos. Uma resposta como esta indica que não há mais instâncias alocadas:

    2018/04/28 16:16:23 WARNING: Setting zone to "europe-west4-a"
    No instances currently exist.
            Compute Engine VM:     --
            Cloud TPU:             --
    
  4. Execute gsutil conforme mostrado. Substitua bucket-name pelo nome do bucket do Cloud Storage criado para este tutorial:

    $ gsutil rm -r gs://bucket-name
    

A seguir

Neste tutorial, você treinou o modelo NCF usando um conjunto de dados de amostra. Os resultados deste treinamento (na maioria dos casos) não podem ser usados para inferência. Para usar um modelo para inferência, é possível treinar os dados em um conjunto de dados disponível publicamente ou no seu próprio conjunto de dados. Os modelos treinados nas Cloud TPUs exigem que os conjuntos de dados estejam no formato TFRecord.

Use a amostra da ferramenta de conversão de conjunto de dados para converter um conjunto de dados de classificação de imagem no formato TFRecord. Se você não estiver usando um modelo de classificação de imagem, converta manualmente o conjunto de dados para o TFRecord. Para mais informações, consulte TFRecord e tf.Example

Ajuste de hiperparâmetros

Para melhorar o desempenho do modelo com o conjunto de dados, é possível ajustar os hiperparâmetros. Encontre informações sobre hiperparâmetros comuns a todos os modelos compatíveis com a TPU no GitHub. As informações sobre hiperparâmetros específicos do modelo podem ser encontradas no código-fonte de cada modelo. Para mais informações sobre o ajuste de hiperparâmetros, consulte Visão geral do ajuste de hiperparâmetros, Como usar o serviço de ajuste de hiperparâmetros e Ajustar hiperparâmetros.

Inferência

Depois de treinar o modelo, é possível usá-lo para inferência (também chamada de previsão). O AI Platform é uma solução baseada em nuvem para desenvolver, treinar e implantar modelos de machine learning. Depois que um modelo é implantado, use o serviço do AI Platform Prediction.