Esta página foi traduzida pela API Cloud Translation.

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

Visão geral

Esta é uma implementação da estrutura de filtragem colaborativa neural (NCF, na sigla em inglês) usando um modelo de fatoração de matriz neural (NeuMF), conforme descrito nas Documento sobre filtragem colaborativa neural. A implementação atual é baseada no código dos autores código NCF e a implementação de Stanford no repositório MLPerf.

O NCF é um framework geral para filtragem colaborativa de recomendações em uma arquitetura de rede neural é usada para modelar interações entre itens e usuários. O NCF substitui o produto interno por um perceptron de várias camadas que pode aprender uma função arbitrária 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). O GMF aplica um kernel linear para modelar o interações de atributos, e o MLP usa um kernel não linear para aprender a interação função com os dados. O NeuMF é um modelo combinado de GMF e MLP para criar modelos melhores interações complexas do usuário e item, e unifica os pontos fortes da linearidade do MF e a não linearidade do MLP para modelar as estruturas latentes de item e usuário. NeuMF permite que GMF e MLP aprendam embeddings separados e combina os dois modelos concatenando a última camada escondida. neumf_model.py define os detalhes da arquitetura.

As instruções a seguir pressupõem que você esteja familiarizado com o treinamento de um modelo em Cloud TPU: Se você ainda não conhece o Cloud TPU, consulte Consulte o artigo Começar para conferir uma introdução básica.

Conjunto de dados

Os conjuntos de dados MovieLens são usados para treinamento e avaliação de modelos. Usamos duas conjuntos de dados: ml-1m (abreviação de MovieLens 1 Million) 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 por 6.040 usuários que entraram no MovieLens em 2000. Todas as classificações estão contidas em o 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 deste arquivo após a linha de cabeçalho representa a classificação de um único usuário para um filme e tem o valor formato:

userId,movieId,rating,timestamp

As linhas nesse arquivo são ordenadas primeiro por userId, depois, dentro de user, por movieId As classificações são feitas em uma escala de 5 estrelas, com incrementos de meia estrela (0,5 estrelas a 5,0 estrelas). Em ambos os conjuntos de dados, o carimbo de data/hora é representado segundos desde a meia-noite do Horário Universal Coordenado (UTC, na sigla em inglês) de 1o 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 documento, você usará os seguintes componentes faturáveis do Google Cloud:

Compute Engine
Cloud TPU
Cloud Storage

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. 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.

Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

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

In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

Go to project selector

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

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.

Abra uma janela do Cloud Shell.

Abrir o Cloud Shell
Crie uma variável de ambiente para o código do projeto.
```
export PROJECT_ID=project-id
```
Configure a CLI do Google Cloud para usar o projeto em que você quer criar o Cloud TPU:
```
gcloud config set project ${PROJECT_ID}
```
Na primeira vez que você executar esse comando em uma nova VM do Cloud Shell, uma A página Autorizar o Cloud Shell será exibida. Clique em Autorizar no parte inferior da página para permitir que gcloud faça chamadas de API com suas credenciais.

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

Crie um bucket do Cloud Storage usando o seguinte comando:

Observação: no comando a seguir, substitua bucket-name pelo nome que você quer atribuir ao bucket.
```
gcloud storage buckets create gs://bucket-name --project=${PROJECT_ID} --location=europe-west4
```
Esse bucket do Cloud Storage armazena os dados usados para treinar o modelo e os resultados do treinamento. O comando gcloud usado neste tutorial para configurar a TPU também 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 que sua VM da TPU. As VMs da TPU são localizadas em zonas específicas, que são subdivisões dentro de uma região.
Criar uma VM do Cloud TPU.
```
$ gcloud compute tpus tpu-vm create ncf-tutorial \
  --zone=europe-west4-a \
  --accelerator-type=v3-8 \
  --version=tpu-vm-tf-2.17.0-pjrt
```
Descrições de sinalizações de comando

zone

A zona em que você planeja criar a Cloud TPU.

accelerator-type

O tipo de acelerador especifica a versão e o tamanho do Cloud TPU que você quer criar. Para mais informações sobre os tipos de aceleradores compatíveis com cada versão de TPU, consulte versões de TPU.

version

A versão do software do Cloud TPU.

Observação: se você tiver mais de um projeto, especifique o ID dele com a sinalização --project.

Para mais informações sobre o comando gcloud, consulte a referência da gcloud.

Observação: a primeira vez que você executar gcloud compute tpus em um projeto, ele levará cerca de cinco minutos para realizar tarefas de inicialização, como propagação de chave SSH e ativação da API.
Conecte-se à instância do Compute Engine usando SSH. Quando você estiver conectado para a VM, o prompt do shell muda de username@projectname para username@vm-name:
```
gcloud compute tpus tpu-vm ssh ncf-tutorial --zone=europe-west4-a
```
Importante: a partir deste ponto, o prefixo (vm) $ significa que você deve executar o comando na instância de VM do Compute Engine.

Prepare os dados

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
```
Adicione uma variável de ambiente para o diretório de dados.
```
(vm)$ export DATA_DIR=${STORAGE_BUCKET}/ncf_data
```

Configurar o local do modelo e definir o PYTHONPATH variável de ambiente.

(vm)$ git clone https://github.com/tensorflow/models.git
(vm)$ pip3 install -r models/official/requirements.txt

(vm)$ export PYTHONPATH="${PWD}/models:${PYTHONPATH}"

Mude para o diretório que armazena os arquivos de processamento do modelo:
```
  (vm)$ cd ~/models/official/recommendation
```
Gere dados de treinamento e avaliação para o conjunto de dados ml-20m em DATA_DIR:

Observação: é recomendável incluir antes o comando de download nohup ou use tela para evitar que o download seja encerrado se o Cloud Shell for desconectado.
```
(vm)$ python3 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. Pré-processamento converte os dados para o formato TFRecord necessário no modelo. A fase de download e o pré-processamento leva aproximadamente 25 minutos e gera uma saída semelhante a o seguinte:

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.
%lt;BisectionDataConstructor(Thread-1, initial daemon)>
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

Defina a variável de nome da Cloud TPU.
```
  (vm)$ export TPU_NAME=local
```

Executar o treinamento e a avaliação

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

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
```
Ao criar sua TPU, se você definir o parâmetro --version como uma versão que termina com -pjrt, defina as seguintes variáveis de ambiente para ativar o ambiente de execução PJRT:
```
  (vm)$ export NEXT_PLUGGABLE_DEVICE_USE_C_API=true
  (vm)$ export TF_PLUGGABLE_DEVICE_LIBRARY_PATH=/lib/libtpu.so
```

Execute o comando a seguir para treinar o modelo NCF:

(vm)$ python3 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:

Result is {'loss': <tf.Tensor: shape=(), dtype=float32, numpy=0.10950611>,
'train_finish_time': 1618016422.1377568, 'avg_exp_per_second': 3062557.5070816963}

Limpar

Para evitar cobranças na sua conta do Google Cloud pelos recursos usados no tutorial, exclua o projeto que os contém ou mantenha o projeto e exclua os recursos individuais.

Desconecte-se da instância do Compute Engine, caso ainda não tenha feito isso:
```
(vm)$ exit
```
Agora, o prompt precisa ser username@projectname, mostrando que você está no Cloud Shell.

Exclua os recursos do Cloud TPU.

  $ gcloud compute tpus tpu-vm delete ncf-tutorial \
    --zone=europe-west4-a

Execute gcloud compute tpus tpu-vm list para verificar se os recursos foram excluídos. A exclusão pode levar vários minutos. Uma resposta como esta indica suas instâncias foram excluídas.
```
  $ gcloud compute tpus tpu-vm list \
    --zone=europe-west4-a
```
```
Listed 0 items.
```
Execute a CLI gcloud conforme mostrado, substituindo bucket-name por o nome do bucket do Cloud Storage criado para este tutorial:
```
$ gcloud storage rm gs://bucket-name --recursive
```

A seguir

Geralmente, os tutoriais do Cloud TPU do TensorFlow treinam o modelo usando um conjunto de dados de amostra. Os resultados desse treinamento não são utilizáveis para inferência. Para um modelo para inferência, é possível treinar os dados em uma conjunto de dados ou seu próprio conjunto de dados. Modelos do TensorFlow treinados em Cloud TPUs geralmente exigem que os conjuntos de dados estejam TFRecord.

Você pode usar a ferramenta de conversão do conjunto de dados sample para converter uma imagem conjunto de dados de classificação no formato TFRecord. Se você não estiver usando uma imagem modelo de classificação, você terá que converter seu conjunto de dados para Formato do TFRecord você mesmo. 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 a e ajustar os hiperparâmetros. É possível encontrar informações sobre hiperparâmetros comuns a todos Modelos com suporte a TPU em GitHub. As informações sobre hiperparâmetros específicos do modelo podem ser encontradas na fonte para cada um modelo de machine learning. Para mais informações sobre o ajuste de hiperparâmetros, consulte a Visão geral do ajuste de hiperparâmetros e Ajuste e ajustar os hiperparâmetros.

Inferência

Depois de treinar o modelo, você pode usá-lo para inferência (também chamado de previsão). Use o conversor de inferência do Cloud TPU ferramenta para preparar e otimizar Modelo do TensorFlow para inferência no Cloud TPU v5e. Para mais informações sobre inferência no Cloud TPU v5e, consulte Inferência do Cloud TPU v5e introdução.

Saiba mais sobre ctpu, incluindo como instalá-lo em uma máquina local.
Conheça as ferramentas de TPU no TensorBoard.