Treinar um modelo com GPUs no modo padrão do GKE

Clone o repositório de exemplo

No Cloud Shell, execute este comando:

git clone https://github.com/GoogleCloudPlatform/ai-on-gke/ ai-on-gke
cd ai-on-gke/tutorials-and-examples/gpu-examples/training-single-gpu

Criar um cluster no modo padrão e um pool de nós de GPU

Use o Cloud Shell para fazer o seguinte:

1. Crie um cluster padrão que use a federação de identidade da carga de trabalho para o GKE e instale o driver do Cloud Storage FUSE:

   gcloud container clusters create gke-gpu-cluster \
       --addons GcsFuseCsiDriver \
       --location=us-central1 \
       --num-nodes=1 \
       --workload-pool=PROJECT_ID.svc.id.goog
   

   Substitua o PROJECT_ID pelo ID do projeto do Google Cloud.

   A criação do cluster pode levar vários minutos.

2. Crie um pool de nós de GPU:

   gcloud container node-pools create gke-gpu-pool-1 \
       --accelerator=type=nvidia-tesla-t4,count=1,gpu-driver-version=default \
       --machine-type=n1-standard-16 --num-nodes=1 \
       --location=us-central1 \
       --cluster=gke-gpu-cluster
   

Crie um bucket do Cloud Storage

1. No Console do Google Cloud, acesse a página Criar um bucket:

   Acessar "Criar um bucket"

2. No campo Nomeie seu bucket, insira o seguinte nome:

   PROJECT_ID-gke-gpu-bucket
   

3. Clique em Continuar.

4. Em Tipo de local, selecione Região.

5. Na lista Região, selecione us-central1 (Iowa) e clique em Continuar.

6. Na seção Escolha uma classe de armazenamento para seus dados, clique em Continuar.

7. Na seção Escolha como controlar o acesso a objetos, em Controle de acesso, selecione Uniforme.

8. Clique em Criar.

9. Na caixa de diálogo O acesso público será impedido verifique se a caixa de seleção Aplicar a prevenção contra acesso público neste bucket está marcada e clique em Confirmar.

Configurar o cluster para acessar o bucket usando a federação de identidade da carga de trabalho do GKE

Para permitir que o cluster acesse o bucket do Cloud Storage, faça o seguinte:

1. Crie uma conta de serviço do Google Cloud.
2. Crie uma conta de serviço do Kubernetes no cluster.
3. Vincular a conta de serviço do Kubernetes à conta de serviço do Google Cloud.

Criar uma conta de serviço do Google Cloud.

1. No Console do Google Cloud, acesse a página Criar conta de serviço.

   Acesse "Criar conta de serviço"

2. No campo ID da conta de serviço, digite gke-ai-sa.

3. Clique em Criar e continuar.

4. Na lista Papel, selecione o papel Cloud Storage > Serviço de coletor do Insights.

5. Clique em add Adicionar outro papel.

6. Na lista Selecionar um papel, selecione o papel Cloud Storage > Administrador de objetos do Storage.

7. Clique em Continuar e depois em Concluído.

Criar uma conta de serviço do Kubernetes no cluster

No Cloud Shell, faça o seguinte:

1. Crie um namespace do Kubernetes:

   kubectl create namespace gke-ai-namespace
   

2. Crie uma conta de serviço do Kubernetes no namespace:

   kubectl create serviceaccount gpu-k8s-sa --namespace=gke-ai-namespace
   

Vincular a conta de serviço do Kubernetes à conta de serviço do Google Cloud

No Cloud Shell, execute os seguintes comandos:

1. Adicione uma vinculação do IAM à conta de serviço do Google Cloud:

   gcloud iam service-accounts add-iam-policy-binding gke-ai-sa@PROJECT_ID.iam.gserviceaccount.com \
       --role roles/iam.workloadIdentityUser \
       --member "serviceAccount:PROJECT_ID.svc.id.goog[gke-ai-namespace/gpu-k8s-sa]"
   

   A sinalização --member fornece a identidade completa da conta de serviço do Kubernetes no Google Cloud.

2. Anote a conta de serviço do Kubernetes:

   kubectl annotate serviceaccount gpu-k8s-sa \
       --namespace gke-ai-namespace \
       iam.gke.io/gcp-service-account=gke-ai-sa@PROJECT_ID.iam.gserviceaccount.com
   

Verifique se os pods podem acessar o bucket do Cloud Storage

1. No Cloud Shell, crie as seguintes variáveis de ambiente:

   export K8S_SA_NAME=gpu-k8s-sa
   export BUCKET_NAME=PROJECT_ID-gke-gpu-bucket
   

   Substitua o PROJECT_ID pelo ID do projeto do Google Cloud.

2. Crie um pod que tenha um contêiner do TensorFlow:

   envsubst < src/gke-config/standard-tensorflow-bash.yaml | kubectl --namespace=gke-ai-namespace apply -f -
   

   Esse comando substitui as variáveis de ambiente que você criou nas referências correspondentes no manifesto. Também é possível abrir o manifesto em um editor de texto e substituir $K8S_SA_NAME e $BUCKET_NAME pelos valores correspondentes.

3. Crie um arquivo de amostra no bucket:

   touch sample-file
   gcloud storage cp sample-file gs://PROJECT_ID-gke-gpu-bucket
   

4. Aguarde até que o pod esteja pronto:

   kubectl wait --for=condition=Ready pod/test-tensorflow-pod -n=gke-ai-namespace --timeout=180s
   

   Quando o pod estiver pronto, a saída será a seguinte:

   pod/test-tensorflow-pod condition met
   

5. Abra um shell no contêiner do TensorFlow:

   kubectl -n gke-ai-namespace exec --stdin --tty test-tensorflow-pod --container tensorflow -- /bin/bash
   

6. Tente ler o arquivo de amostra que você criou:

   ls /data
   

   A saída mostra o arquivo de amostra.

7. Verifique os registros para identificar a GPU anexada ao pod:

   python -c "import tensorflow as tf; print(tf.config.list_physical_devices('GPU'))"
   

   A saída mostra a GPU anexada ao pod, semelhante à seguinte:

   ...
   PhysicalDevice(name='/physical_device:GPU:0',device_type='GPU')
   

8. Saia do contêiner:

   exit
   

9. Exclua o pod de amostra:

   kubectl delete -f src/gke-config/standard-tensorflow-bash.yaml \
       --namespace=gke-ai-namespace
   

Treinar e prever usando o conjunto de dados MNIST

Nesta seção, você executará uma carga de trabalho de treinamento no conjunto de dados de exemplo MNIST.

1. Copie os dados de exemplo para o bucket do Cloud Storage:

   gcloud storage cp src/tensorflow-mnist-example gs://PROJECT_ID-gke-gpu-bucket/ --recursive
   

2. Crie as variáveis de ambiente a seguir:

   export K8S_SA_NAME=gpu-k8s-sa
   export BUCKET_NAME=PROJECT_ID-gke-gpu-bucket
   

3. Revise o job de treinamento:

   # Copyright 2023 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #      http://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   apiVersion: batch/v1
   kind: Job
   metadata:
     name: mnist-training-job
   spec:
     template:
       metadata:
         name: mnist
         annotations:
           gke-gcsfuse/volumes: "true"
       spec:
         nodeSelector:
           cloud.google.com/gke-accelerator: nvidia-tesla-t4
         tolerations:
         - key: "nvidia.com/gpu"
           operator: "Exists"
           effect: "NoSchedule"
         containers:
         - name: tensorflow
           image: tensorflow/tensorflow:latest-gpu 
           command: ["/bin/bash", "-c", "--"]
           args: ["cd /data/tensorflow-mnist-example; pip install -r requirements.txt; python tensorflow_mnist_train_distributed.py"]
           resources:
             limits:
               nvidia.com/gpu: 1
               cpu: 1
               memory: 3Gi
           volumeMounts:
           - name: gcs-fuse-csi-vol
             mountPath: /data
             readOnly: false
         serviceAccountName: $K8S_SA_NAME
         volumes:
         - name: gcs-fuse-csi-vol
           csi:
             driver: gcsfuse.csi.storage.gke.io
             readOnly: false
             volumeAttributes:
               bucketName: $BUCKET_NAME
               mountOptions: "implicit-dirs"
         restartPolicy: "Never"

4. Implante o job de treinamento:

   envsubst < src/gke-config/standard-tf-mnist-train.yaml | kubectl -n gke-ai-namespace apply -f -
   

   Esse comando substitui as variáveis de ambiente que você criou nas referências correspondentes no manifesto. Também é possível abrir o manifesto em um editor de texto e substituir $K8S_SA_NAME e $BUCKET_NAME pelos valores correspondentes.

5. Aguarde até que o job tenha o status Completed:

   kubectl wait -n gke-ai-namespace --for=condition=Complete job/mnist-training-job --timeout=180s
   

   O resultado será assim:

   job.batch/mnist-training-job condition met
   

6. Verifique os registros do contêiner do TensorFlow:

   kubectl logs -f jobs/mnist-training-job -c tensorflow -n gke-ai-namespace
   

   A saída mostra que os seguintes eventos ocorrem:

   • Instalar os pacotes Python necessários
   • Fazer o download do conjunto de dados MNIST
   • Treinar o modelo usando uma GPU
   • Salvar o modelo
   • Avalie o modelo

   ...
   Epoch 12/12
   927/938 [============================>.] - ETA: 0s - loss: 0.0188 - accuracy: 0.9954
   Learning rate for epoch 12 is 9.999999747378752e-06
   938/938 [==============================] - 5s 6ms/step - loss: 0.0187 - accuracy: 0.9954 - lr: 1.0000e-05
   157/157 [==============================] - 1s 4ms/step - loss: 0.0424 - accuracy: 0.9861
   Eval loss: 0.04236088693141937, Eval accuracy: 0.9861000180244446
   Training finished. Model saved
   

7. Exclua a carga de trabalho de treinamento:

   kubectl -n gke-ai-namespace delete -f src/gke-config/standard-tf-mnist-train.yaml
   

Implantar uma carga de trabalho de inferência

Nesta seção, você implantará uma carga de trabalho de inferência que usa um conjunto de dados de amostra como entrada e retorna previsões.

1. Copie as imagens para predição para o bucket:

   gcloud storage cp data/mnist_predict gs://PROJECT_ID-gke-gpu-bucket/ --recursive
   

2. Revise a carga de trabalho de inferência:

   # Copyright 2023 Google LLC
   #
   # Licensed under the Apache License, Version 2.0 (the "License");
   # you may not use this file except in compliance with the License.
   # You may obtain a copy of the License at
   #
   #      http://www.apache.org/licenses/LICENSE-2.0
   #
   # Unless required by applicable law or agreed to in writing, software
   # distributed under the License is distributed on an "AS IS" BASIS,
   # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   # See the License for the specific language governing permissions and
   # limitations under the License.
   
   apiVersion: batch/v1
   kind: Job
   metadata:
     name: mnist-batch-prediction-job
   spec:
     template:
       metadata:
         name: mnist
         annotations:
           gke-gcsfuse/volumes: "true"
       spec:
         nodeSelector:
           cloud.google.com/gke-accelerator: nvidia-tesla-t4
         tolerations:
         - key: "nvidia.com/gpu"
           operator: "Exists"
           effect: "NoSchedule"
         containers:
         - name: tensorflow
           image: tensorflow/tensorflow:latest-gpu 
           command: ["/bin/bash", "-c", "--"]
           args: ["cd /data/tensorflow-mnist-example; pip install -r requirements.txt; python tensorflow_mnist_batch_predict.py"]
           resources:
             limits:
               nvidia.com/gpu: 1
               cpu: 1
               memory: 3Gi
           volumeMounts:
           - name: gcs-fuse-csi-vol
             mountPath: /data
             readOnly: false
         serviceAccountName: $K8S_SA_NAME
         volumes:
         - name: gcs-fuse-csi-vol
           csi:
             driver: gcsfuse.csi.storage.gke.io
             readOnly: false
             volumeAttributes:
               bucketName: $BUCKET_NAME
               mountOptions: "implicit-dirs"
         restartPolicy: "Never"

3. Implante a carga de trabalho de inferência:

   envsubst < src/gke-config/standard-tf-mnist-batch-predict.yaml | kubectl -n gke-ai-namespace apply -f -
   

   Esse comando substitui as variáveis de ambiente que você criou nas referências correspondentes no manifesto. Também é possível abrir o manifesto em um editor de texto e substituir $K8S_SA_NAME e $BUCKET_NAME pelos valores correspondentes.

4. Aguarde até que o job tenha o status Completed:

   kubectl wait -n gke-ai-namespace --for=condition=Complete job/mnist-batch-prediction-job --timeout=180s
   

   O resultado será assim:

   job.batch/mnist-batch-prediction-job condition met
   

5. Verifique os registros do contêiner do TensorFlow:

   kubectl logs -f jobs/mnist-batch-prediction-job -c tensorflow -n gke-ai-namespace
   

   A saída é a previsão para cada imagem e a confiança do modelo na previsão, semelhante ao seguinte:

   Found 10 files belonging to 1 classes.
   1/1 [==============================] - 2s 2s/step
   The image /data/mnist_predict/0.png is the number 0 with a 100.00 percent confidence.
   The image /data/mnist_predict/1.png is the number 1 with a 99.99 percent confidence.
   The image /data/mnist_predict/2.png is the number 2 with a 100.00 percent confidence.
   The image /data/mnist_predict/3.png is the number 3 with a 99.95 percent confidence.
   The image /data/mnist_predict/4.png is the number 4 with a 100.00 percent confidence.
   The image /data/mnist_predict/5.png is the number 5 with a 100.00 percent confidence.
   The image /data/mnist_predict/6.png is the number 6 with a 99.97 percent confidence.
   The image /data/mnist_predict/7.png is the number 7 with a 100.00 percent confidence.
   The image /data/mnist_predict/8.png is the number 8 with a 100.00 percent confidence.
   The image /data/mnist_predict/9.png is the number 9 with a 99.65 percent confidence.