Implantar uma carga de trabalho de machine learning em lote

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.

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

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"
   

   Veja a seguir um trecho da resposta:

   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.