Alcune o tutte le informazioni in questa pagina potrebbero non essere applicabili a Trusted Cloud by S3NS.

Questa pagina è stata tradotta dall'API Cloud Translation.

Addestra un modello con GPU in modalità GKE Standard

Standard

Questo tutorial di avvio rapido mostra come eseguire il deployment di un modello di addestramento con GPU in Google Kubernetes Engine (GKE) e archiviare le previsioni in Cloud Storage. Questo tutorial utilizza un modello TensorFlow e cluster GKE Standard. Puoi anche eseguire questi carichi di lavoro sui cluster Autopilot con meno passaggi di configurazione. Per istruzioni, consulta Addestra un modello con GPU in modalità GKE Autopilot.

Questo documento è destinato agli amministratori GKE che dispongono di cluster Standard esistenti e vogliono eseguire workload GPU per la prima volta.

Prima di iniziare

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

Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

Go to project selector
Verify that billing is enabled for your Trusted Cloud project.
Enable the Kubernetes Engine and Cloud Storage APIs.
Enable the APIs

In the Trusted Cloud console, activate Cloud Shell.

Activate Cloud Shell

At the bottom of the Trusted Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

Clona il repository di esempio

In Cloud Shell, esegui questo 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

Crea un cluster in modalità Standard e un pool di nodi GPU

Utilizza Cloud Shell per svolgere le seguenti operazioni:

Crea un cluster Standard che utilizza la federazione delle identità per i carichi di lavoro per GKE e installa il driver 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
```
Sostituisci PROJECT_ID con l'ID del tuo progetto Trusted Cloud.

La creazione del cluster potrebbe richiedere diversi minuti.

Crea un pool di nodi 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

Crea un bucket Cloud Storage

Nella console Trusted Cloud , vai alla pagina Crea un bucket:

Vai a Crea un bucket
Nel campo Assegna un nome al bucket, inserisci il seguente nome:
```
PROJECT_ID-gke-gpu-bucket
```
Fai clic su Continua.
Per Tipo di località, seleziona Regione.
Nell'elenco Regione, seleziona us-central1 (Iowa) e fai clic su Continua.
Nella sezione Scegli una classe di archiviazione per i tuoi dati, fai clic su Continua.
Nella sezione Scegli come controllare l'accesso agli oggetti, seleziona Uniforme per Controllo dell'accesso.
Fai clic su Crea.
Nella finestra di dialogo L'accesso pubblico verrà vietato, assicurati che la casella di controllo Applica la prevenzione dell'accesso pubblico in questo bucket sia selezionata e fai clic su Conferma.

Configura il cluster per accedere al bucket utilizzando Workload Identity Federation for GKE

Per consentire al cluster di accedere al bucket Cloud Storage:

Crea un Trusted Cloud service account.
Crea un ServiceAccount Kubernetes nel cluster.
Associa il service account Kubernetes al service account Trusted Cloud .

Crea un Trusted Cloud service account

Nella console Trusted Cloud , vai alla pagina Crea service account:

Vai a Crea service account
Nel campo ID service account, inserisci gke-ai-sa.
Fai clic su Crea e continua.
Nell'elenco Ruolo, seleziona il ruolo Cloud Storage > Servizio di raccolta di Storage Insights.
Fai clic su Aggiungi un altro ruolo.
Nell'elenco Seleziona un ruolo, seleziona il ruolo Cloud Storage > Amministratore oggetti Storage.
Fai clic su Continua, poi su Fine.

Crea un ServiceAccount Kubernetes nel tuo cluster

In Cloud Shell:

Crea uno spazio dei nomi Kubernetes:

kubectl create namespace gke-ai-namespace

Crea un ServiceAccount Kubernetes nello spazio dei nomi:

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

Associa il service account Kubernetes al service account Trusted Cloud

In Cloud Shell, esegui questi comandi:

Aggiungi un binding IAM al service account Trusted Cloud :

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

Il flag --member fornisce l'identità completa di Kubernetes ServiceAccount in Trusted Cloud.

Annota il service account Kubernetes:

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

Verifica che i pod possano accedere al bucket Cloud Storage

In Cloud Shell, crea le seguenti variabili di ambiente:
```
export K8S_SA_NAME=gpu-k8s-sa
export BUCKET_NAME=PROJECT_ID-gke-gpu-bucket
```
Sostituisci PROJECT_ID con l'ID del tuo progetto Trusted Cloud.
Crea un pod con un container TensorFlow:
```
envsubst < src/gke-config/standard-tensorflow-bash.yaml | kubectl --namespace=gke-ai-namespace apply -f -
```
Questo comando sostituisce le variabili di ambiente che hai creato con i riferimenti corrispondenti nel manifest. Puoi anche aprire il manifest in un editor di testo e sostituire $K8S_SA_NAME e $BUCKET_NAME con i valori corrispondenti.

Crea un file di esempio nel bucket:

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

Attendi che il pod sia pronto:

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

Quando il pod è pronto, l'output è il seguente:

pod/test-tensorflow-pod condition met

Apri una shell nel container Tensorflow:

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

Prova a leggere il file di esempio che hai creato:
```
ls /data
```
L'output mostra il file di esempio.

Controlla i log per identificare la GPU collegata al pod:

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

L'output mostra la GPU collegata al pod, in modo simile al seguente:

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

Esci dal container:
```
exit
```

Elimina il pod di esempio:

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

Addestra e prevedi utilizzando il set di dati `MNIST`

In questa sezione, esegui un carico di lavoro di addestramento sul set di dati di esempio MNIST.

Copia i dati di esempio nel bucket Cloud Storage:

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

Crea le seguenti variabili di ambiente:

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

Esamina il job di addestramento:

# 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"

Esegui il deployment del job di addestramento:
```
envsubst < src/gke-config/standard-tf-mnist-train.yaml | kubectl -n gke-ai-namespace apply -f -
```
Questo comando sostituisce le variabili di ambiente che hai creato con i riferimenti corrispondenti nel manifest. Puoi anche aprire il manifest in un editor di testo e sostituire $K8S_SA_NAME e $BUCKET_NAME con i valori corrispondenti.

Attendi che il job abbia lo stato Completed:

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

L'output è simile al seguente:

job.batch/mnist-training-job condition met

Controlla i log del container TensorFlow:

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

L'output mostra i seguenti eventi:

Installa i pacchetti Python richiesti
Scarica il set di dati MNIST
Addestra il modello utilizzando una GPU
Salva il modello
Valuta il modello

...
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

Elimina il workload di addestramento:

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

Esegui il deployment di un carico di lavoro di inferenza

In questa sezione, esegui il deployment di un carico di lavoro di inferenza che accetta un set di dati di esempio come input e restituisce le previsioni.

Copia le immagini per la previsione nel bucket:

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

Esamina il workload di inferenza:

# 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"

Esegui il deployment del carico di lavoro di inferenza:
```
envsubst < src/gke-config/standard-tf-mnist-batch-predict.yaml | kubectl -n gke-ai-namespace apply -f -
```
Questo comando sostituisce le variabili di ambiente che hai creato con i riferimenti corrispondenti nel manifest. Puoi anche aprire il manifest in un editor di testo e sostituire $K8S_SA_NAME e $BUCKET_NAME con i valori corrispondenti.

Attendi che il job abbia lo stato Completed:

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

L'output è simile al seguente:

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

Controlla i log del container TensorFlow:

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

L'output è la previsione per ogni immagine e l'affidabilità del modello nella previsione, simile alla seguente:

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.

Esegui la pulizia

Per evitare che al tuo account Trusted Cloud vengano addebitati costi relativi alle risorse che hai creato in questa guida, procedi in uno dei seguenti modi:

Mantieni il cluster GKE: elimina le risorse Kubernetes nel cluster e le risorse Trusted Cloud
Mantieni il Trusted Cloud progetto: elimina il cluster GKE e le Trusted Cloud risorse
Eliminare il progetto

Elimina le risorse Kubernetes nel cluster e le risorse Trusted Cloud

Elimina lo spazio dei nomi Kubernetes e i carichi di lavoro di cui hai eseguito il deployment:

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

Elimina il bucket Cloud Storage:
1. Vai alla pagina Bucket:
  
  Vai a Bucket
2. Seleziona la casella di controllo per PROJECT_ID-gke-gpu-bucket.
3. Fai clic su Elimina.
4. Per confermare l'eliminazione, digita DELETE e fai clic su Elimina.
Elimina il service account Trusted Cloud :
1. Vai alla pagina Service Accounts:
  
  Vai ad Account di servizio
2. Seleziona il progetto.
3. Seleziona la casella di controllo per gke-ai-sa@PROJECT_ID.s3ns-system.iam.gserviceaccount.com.
4. Fai clic su Elimina.
5. Per confermare l'eliminazione, fai clic su Elimina.

Elimina il cluster GKE e le Trusted Cloud risorse

Elimina il cluster GKE:
1. Vai alla pagina Cluster:
  
  Vai a Cluster
2. Seleziona la casella di controllo per gke-gpu-cluster.
3. Fai clic su Elimina.
4. Per confermare l'eliminazione, digita gke-gpu-cluster e fai clic su Elimina.
Elimina il bucket Cloud Storage:
1. Vai alla pagina Bucket:
  
  Vai a Bucket
2. Seleziona la casella di controllo per PROJECT_ID-gke-gpu-bucket.
3. Fai clic su Elimina.
4. Per confermare l'eliminazione, digita DELETE e fai clic su Elimina.
Elimina il service account Trusted Cloud :
1. Vai alla pagina Service Accounts:
  
  Vai ad Account di servizio
2. Seleziona il progetto.
3. Seleziona la casella di controllo per gke-ai-sa@PROJECT_ID.s3ns-system.iam.gserviceaccount.com.
4. Fai clic su Elimina.
5. Per confermare l'eliminazione, fai clic su Elimina.

Elimina il progetto

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:

L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività descritte in questo documento, quando lo elimini, elimini anche tutto il lavoro che hai svolto nel progetto.
Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.

Se intendi esplorare più architetture, tutorial o guide rapide, puoi riutilizzare i progetti ed evitare così di superare i limiti di quota.

In the Trusted Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Passaggi successivi

Scopri di più sull'utilizzo delle GPU in GKE