Implantar uma carga de trabalho de machine learning em lote

Autopilot Padrão

---

Neste tutorial, demonstramos como usar o Google Kubernetes Engine (GKE) para gerenciar cargas de trabalho em lote tolerantes a falhas e manter seus custos baixos. Siga este tutorial para saber como usar jobs e pods do Spot otimizados para custos, além de ver como configurar uma fila de jobs do Redis no cluster no GKE.

Segundo plano

Uma carga de trabalho em lote é um processo geralmente criado para ter um ponto de partida e de conclusão. Considere as cargas de trabalho em lote no GKE se a arquitetura envolver a ingestão, o processamento e a saída de dados em vez de usar dados brutos. Áreas como machine learning, inteligência artificial, e computação de alto desempenho (HPC) apresentam diferentes tipos de cargas de trabalho em lote, como treinamento de modelos off-line, previsão em lote, análise de dados, simulação de sistemas físicos e processamento de vídeo.

Ao projetar cargas de trabalho em lote em contêineres, é possível aproveitar os seguintes benefícios do GKE:

• Uma comunidade ampla, um padrão aberto e um serviço gerenciado.
• Eficiência de custos com orquestração efetiva de cargas de trabalho e infraestrutura e recursos computacionais especializados.
• Isolamento e portabilidade de contentorização, permitindo o uso da nuvem como capacidade excedente, mantendo a segurança dos dados.
• Disponibilidade da capacidade de burst, seguida pela redução rápida do escalonamento dos clusters do GKE.

Objetivos

Este tutorial é voltado a engenheiros de machine learning ou cientistas de dados que querem executar cargas de trabalho de machine learning em lote no GKE com a seguinte arquitetura econômica e escalonável:

Este tutorial inclui as etapas a seguir:

1. Criar um cluster do GKE Autopilot. Como alternativa, é possível usar um cluster padrão do GKE neste tutorial.
2. Criar um volume NFS do Filestore.
3. Criar uma fila de jobs do Redis no cluster
4. Transferir conjuntos de dados para o volume NFS e enfileirá-los para serem consumidos pela carga de trabalho.
5. Executar uma carga de trabalho de machine learning em lote no cluster do GKE.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

• Compute Engine
• Autopilot do GKE
• Filestore

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.

---

Para seguir as instruções passo a passo desta tarefa diretamente no console do Google Cloud, clique em Orientação:

Orientações

---

Antes de começar

1. Faça login na sua conta do Google Cloud. Se você começou a usar o Google Cloud agora, crie uma conta para avaliar o desempenho de nossos produtos em situações reais. Clientes novos também recebem US$ 300 em créditos para executar, testar e implantar cargas de trabalho.

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

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

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

4. Ative as APIs Compute Engine, GKE, and Filestore.

   Ative as APIs

5. No console do Google Cloud, na página do seletor de projetos, selecione ou crie um projeto do Google Cloud.

   Observação: se você não pretende manter os recursos criados neste procedimento, crie um projeto novo em vez de selecionar um que já existe. Depois de concluir essas etapas, é possível excluir o projeto. Para fazer isso, basta remover todos os recursos associados a ele.

   Acessar o seletor de projetos

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

7. Ative as APIs Compute Engine, GKE, and Filestore.

   Ative as APIs

8. No Console do Google Cloud, ative o Cloud Shell.

   Ativar o Cloud Shell

   Na parte inferior do Console do Google Cloud, uma sessão do Cloud Shell é iniciada e exibe um prompt de linha de comando. O Cloud Shell é um ambiente shell com a CLI do Google Cloud já instalada e com valores já definidos para o projeto atual. A inicialização da sessão pode levar alguns segundos.

Prepare o ambiente

1. Clone o repositório de amostra usado neste tutorial:

   git clone https://github.com/GoogleCloudPlatform/kubernetes-engine-samples
   cd kubernetes-engine-samples/batch/aiml-workloads
   

2. Crie um cluster do GKE Autopilot:

   gcloud container clusters create-auto batch-aiml \
       --region=us-central1
   

   Essa etapa pode levar até cinco minutos para ser concluída.

Configurar o armazenamento de conjuntos de dados com um Network File System (NFS)

A carga de trabalho de machine learning requer uma solução de armazenamento para os conjuntos de dados e arquivos de saída. Nesta seção, você cria uma instância Filestore e fornece acesso a ela usando um PersistentVolume e um PersistentVolumeClaim.

Para saber mais, confira como projetar uma estratégia de armazenamento ideal e como acessar instâncias do Filestore dos clusters do GKE.

Criar uma instância do Filestore

1. Criar uma instância do Filestore:

   gcloud filestore instances create batch-aiml-filestore \
       --zone=us-central1-b \
       --tier=BASIC_HDD \
       --file-share=name="NFSVol",capacity=1TB \
       --network=name="default"
   

   Este comando especifica as seguintes opções:

   • tier: o nível de serviço da instância do Filestore. Esse exemplo usa o nível básico. Para saber mais sobre as outras opções, consulte Níveis de serviço.

   • network=name: o nome da rede de nuvem privada virtual (VPC) da instância do Filestore. O cluster do GKE precisa estar na mesma rede VPC que a instância do Filestore.

   • capacity: o tamanho desejado do volume. Especifique o valor de armazenamento em uma das unidades compatíveis descritas em Quantidades de recursos.

   Observação: esta etapa pode levar até cinco minutos para ser concluída.

2. Verifique se a instância do Filestore foi implantada:

   gcloud filestore instances list \
       --project=PROJECT_ID \
       --zone=us-central1-b
   

   Substitua o PROJECT_ID pelo ID do projeto do Google Cloud.

   O resultado será assim:

   INSTANCE_NAME: batch-aiml-filestore
   LOCATION: us-central1-b
   TIER: BASIC_HDD
   CAPACITY_GB: 1024
   FILE_SHARE_NAME: NFSVol
   IP_ADDRESS: 203.0.113.54
   STATE: READY
   CREATE_TIME: 2022-03-15T18:23:51
   

3. Anote o valor no campo IP_ADDRESS para usar na seção a seguir.

Criar um PersistentVolume

Uma especificação PersistentVolume do Kubernetes permite que o cluster do GKE se conecte à instância do Filestore.

1. Atualize o arquivo kubernetes-manifests/persistent-volume.yaml com o endereço IP da instância do Filestore:

   sed -i "\
     s/<FILESTORE_IP_ADDRESS>/IP_ADDRESS/g" \
     kubernetes-manifests/persistent-volume.yaml
   

   Substitua IP_ADDRESS pelo endereço IP que você anotou ao criar a instância do Filestore na seção anterior.

2. Implante o PersistentVolume:

   kubectl apply -f kubernetes-manifests/persistent-volume.yaml
   

Criar um PersistentVolumeClaim

Um PersistentVolumeClaim do Kubernetes permite que os pods e jobs do Kubernetes acessem os recursos de armazenamento de um PersistentVolume.

Implante o PersistentVolumeClaim:

kubectl apply -f kubernetes-manifests/persistent-volume-claim.yaml

Consumir a PersistentVolumeClaim

Com o PersistentVolume e o PersistentVolumeClaim configurados no cluster do GKE, é possível configurar o servidor Redis e os jobs em lote para consumir o PersistentVolumeClaim. Isso aparece como um volume de armazenamento montável.

Inspecione os arquivos kubernetes-manifests/redis-pod.yaml e kubernetes-manifests/workload.yaml. As configurações do manifesto são semelhantes às seguintes:

  spec:
  …
  containers:
  - name: workload
    image: "us-central1-docker.pkg.dev/gke-batch-aiml/batch-aiml-docker-repo/workload"
    volumeMounts:
    - mountPath: /mnt/fileserver
      name: workload-pvc
  volumes:
  - name: workload-pvc
    persistentVolumeClaim:
      claimName: fileserver-claim
      readOnly: false

Nesse manifesto:

• spec.volumes especifica o PersistentVolumeClaim para consumo.
• spec.containers.volumeMounts especifica o caminho do arquivo local em que o pod pode acessar o compartilhamento de arquivos do Filestore.

Configurar uma fila de jobs do Redis

A carga de trabalho processa dados em lotes para treinar iterativamente um modelo de detecção de fraudes. Para gerenciar os conjuntos de dados que estão sendo processados ou ainda na fila, implante o servidor Redis no cluster do GKE.

Para este tutorial, inicie uma única instância do Redis. Para implantar o Redis de maneira escalonável e redundante, consulte Criar um aplicativo da Web de várias camadas com Redis e PHP.

1. Implante a especificação do servidor do Redis.

   kubectl apply -f kubernetes-manifests/redis-pod.yaml
   

2. Verifique se ele está em execução:

   kubectl get pods
   

   O resultado será assim:

   NAME           READY   STATUS    RESTARTS   AGE
   redis-leader   1/1     Running   0          118s
   

   O pod pode levar até dois minutos para começar a ser executado.

3. Transfira os arquivos que contêm os conjuntos de dados de treinamento e teste para o volume NFS.

   sh scripts/transfer-datasets.sh
   

   Esse script copia os arquivos do repositório de código de amostra para o diretório /mnt/fileserver/datasets/ no pod redis-leader.

4. Preencha a fila do Redis.

   sh scripts/queue-jobs.sh
   

   Esse script envia os caminhos de arquivo para os conjuntos de dados de treinamento a uma lista chamada datasets no banco de dados do Redis. Essa fila será usada pela carga de trabalho para localizar o próximo conjunto de dados a ser processado.

5. Implante o Serviço para tornar o servidor Redis detectável no cluster do GKE.

   kubectl apply -f ./kubernetes-manifests/redis-service.yaml
   

Executar a carga de trabalho em lote

Neste ponto, você preparou o cluster do GKE, a fila de jobs do Redis e o compartilhamento de arquivos. Agora, é possível executar sua carga de trabalho em lote.

Nesta seção, você usará uma imagem de contêiner de uma carga de trabalho de amostra para treinar um modelo de detecção de fraudes usando lotes de dados de transações financeiras. O processo de treinamento pode ser resumido da seguinte forma:

1. Um cliente Redis reivindica jobs (caminhos de arquivo para conjuntos de dados) na fila e os remove da fila depois de concluído.

2. Uma classe de gerenciador de treinamento de modelo, FraudDetectionModelTrainer, carrega um novo lote de dados e, opcionalmente, um estado salvo de um modelo de machine learning. O conjunto de dados é usado para refinar o modelo. Esse processo é conhecido como treinamento "inicialização com estado salvo".

3. O novo estado do modelo e um relatório de detalhes do lote e pontuações de desempenho são salvos no volume NFS do Filestore, que pode ser acessado no cluster do GKE usando um PersistentVolumeClaim.

Para saber mais, conheça o código-fonte.

Definir o job

O manifesto a seguir descreve o job do Kubernetes da imagem da carga de trabalho em lote.

apiVersion: batch/v1
kind: Job
metadata:
  name: workload
spec:
  parallelism: 1
  template:
    metadata:
      name: workload
    spec:
      nodeSelector:
        cloud.google.com/gke-spot: "true"
      containers:
      - name: workload
        image: "us-docker.pkg.dev/google-samples/containers/gke/batch-ml-workload"
        volumeMounts:
        - mountPath: /mnt/fileserver
          name: workload-pvc
      volumes:
      - name: workload-pvc
        persistentVolumeClaim:
          claimName: fileserver-claim
          readOnly: false
      restartPolicy: OnFailure

Observação: ao configurar uma carga de trabalho em que os lotes possam ser executados em paralelo (por exemplo, classificação de lotes de imagens, análise de dados de longa duração etc.), é possível aumentar o valor de parallelism para permitir que muitos pods executem o job simultaneamente até que a condição de conclusão seja atendida. A especificação nodeSelector diz ao GKE para usar pods do Spot.

Implantar a carga de trabalho

1. Implante o job:

   kubectl apply -f ./kubernetes-manifests/workload.yaml
   

2. Verifique se o status do pod workload-XXX é Completed.

   watch kubectl get pods
   

   Isso pode demorar alguns segundos… Para voltar à linha de comando, pressione Ctrl+C.

   O resultado será assim:

   NAME             READY   STATUS      RESTARTS   AGE
   redis-leader     1/1     Running     0          16m
   workload-4p55d   0/1     Completed   0          83s
   

3. Verifique os registros do job workload:

   kubectl logs job/workload
   

   O resultado será assim:

   Worker with sessionID: b50f9459-ce7f-4da8-9f84-0ab5c3233a72
   Initial queue state: empty=False
   Processing dataset: datasets/training/2018-04-04.pkl
   Processing dataset: datasets/training/2018-04-03.pkl
   Processing dataset: datasets/training/2018-04-02.pkl
   Processing dataset: datasets/training/2018-04-01.pkl
   Queue empty, exiting
   

   Os arquivos .pkl são serializações de conjuntos de dados que contêm um lote de transações de cartão de crédito, marcadas como válidas ou fraudulentas. O job workload itera esses arquivos, descompactando os conjuntos de dados e usando-os para treinar o modelo de machine learning, antes de removê-los da fila do Redis. A carga de trabalho continua a processar os dados em lotes, até que a fila do Redis seja esvaziada, antes de sair com sucesso.

Analisar o volume NFS

Durante a operação, a carga de trabalho cria arquivos no volume NFS montado, acessível em todo o cluster a outros jobs em lote ou aplicativos on-line.

1. Liste os arquivos criados pela carga de trabalho:

   kubectl exec --stdin --tty redis-leader -- /bin/sh -c "ls -1 /mnt/fileserver/output"
   

   A saída será a seguinte:

   model_cpt_2018-04-01.pkl
   model_cpt_2018-04-02.pkl
   model_cpt_2018-04-03.pkl
   model_cpt_2018-04-04.pkl
   report.txt
   

   Os checkpoints do modelo treinado (nomes de arquivos como model_cpt_XXX.pkl) e um relatório do desempenho do modelo (report.txt) foram criados no diretório /mnt/fileserver/output no volume NFS.

2. Inspecione o relatório de desempenho do modelo:

   kubectl exec --stdin --tty redis-leader -- /bin/sh -c "cat /mnt/fileserver/output/report.txt"
   

   Confira a seguir um trecho da saída:

   Report generated on: 2022-02-09 14:19:42.303619
   Training dataset: 2018-04-04.pkl
   Model checkpoint: model_cpt_2018-04-04.pkl
   ---
   Accuracy on training data: 0.9981112277019937
   Accuracy on testing data: 0.9977204434773599
   

   O arquivo contém entradas detalhando o tempo de treinamento, o conjunto de dados usado, a precisão alcançada e o nome do arquivo do checkpoint do modelo associado ao treinamento.

Para saber mais sobre volumes NFS, confira os guias do Filestore.

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.

Remover recursos individuais

Para remover os recursos individuais criados para este tutorial, execute os comandos a seguir.

1. Exclua o cluster:

   gcloud container clusters delete batch-aiml \
       --region=us-central1
   

2. Excluir a instância do Filestore:

   gcloud filestore instances delete batch-aiml-filestore \
       --zone=us-central1-b
   

Excluir o projeto

Cuidado: excluir um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto existente para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos no projeto.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um código do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja passar por várias arquiteturas, tutoriais ou guias de início rápido, a reutilização de projetos pode evitar que você exceda os limites da cota do projeto.

1. No Console do Google Cloud, acesse a página Gerenciar recursos.

   Acessar "Gerenciar recursos"

2. Na lista de projetos, selecione o projeto que você quer excluir e clique em Excluir .
3. Na caixa de diálogo, digite o ID do projeto e clique em Encerrar para excluí-lo.

A seguir

• Consulte a documentação do GKE.

• Conheça melhor o recurso Volumes persistentes.

• Saiba mais sobre os jobs no GKE.

• Aprenda a usar VMs spot para executar cargas de trabalho tolerantes a falhas.

• Explore outros tutoriais do Kubernetes Engine.

• Confira arquiteturas de referência, diagramas, tutoriais e práticas recomendadas do Google Cloud. Confira o Centro de arquitetura do Cloud.