Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

Bestärkendes Lernen mit NVIDIA NeMo RL in GKE optimieren und skalieren

Standard

In dieser Anleitung erfahren Sie, wie Sie eine verteilte Trainingsumgebung für Reinforcement Learning (RL) in Google Kubernetes Engine (GKE) orchestrieren. Sie verwenden Ray und das NVIDIA NeMo RL-Framework, um eine verteilte Trainingsumgebung zum Feinabstimmen eines Modells einzurichten.

In dieser Anleitung geht es um die Trainingspipeline für die Group Relative Policy Optimization (GRPO) in GKE mit Ray und NeMo RL. GRPO ist ein Reinforcement-Learning-Algorithmus, der die Denkfähigkeit eines Modells verbessern soll. Dieser speichereffiziente Algorithmus vereinfacht den RL-Prozess, indem er den Critic oder das Wertmodell eliminiert und stattdessen eine relative gruppenbasierte Berechnung verwendet.

Bevor Sie diese Anleitung durcharbeiten, empfehlen wir Ihnen, die Anleitung Verstärkungslernen mit verl in GKE optimieren und skalieren durchzuarbeiten. In der folgenden Anleitung wird dieselbe Clusterkonfiguration wie in der Anleitung zum Feinabstimmen und Skalieren von RL mit VERL verwendet.

Hintergrund

In den folgenden Abschnitten erhalten Sie einen kurzen Überblick über die in dieser Anleitung verwendeten Konzepte.

Bestärkendes Lernen (Reinforcement Learning, RL)

Beim bestärkenden Lernen werden Modelle durch Erfahrung, Erkundung und Feedback trainiert, anstatt durch statische Imitation. Beim Vortraining wird einem Modell beigebracht, was es sagen soll. Beim bestärkenden Lernen durch menschliches Feedback (Reinforcement Learning from Human Feedback, RLHF) wird ihm beigebracht, wie es hilfreich, sicher und logisch sein kann. RL dient als Brücke zwischen einem Basismodell und einem feinabgestimmten Modell für einen speziellen Anwendungsfall.

Weitere Informationen finden Sie unter Was ist bestärkendes Lernen?

Gruppenrelative Richtlinienoptimierung (Group Relative Policy Optimization, GRPO)

GRPO, ein von DeepSeek entwickelter Algorithmus, bietet eine speichereffiziente Alternative zur Proximal Policy Optimization (PPO) für die LLM-Abstimmung, da das Critic-Modell entfernt wird. Anstelle eines Critic-Netzwerks generiert GRPO eine Gruppe von Antworten für denselben Prompt und verwendet die durchschnittliche Belohnung dieser Gruppe als Baseline.

Weitere Informationen finden Sie unter GRPO.

NVIDIA NeMo RL

NeMo RL ist die Open-Source-Bibliothek von NVIDIA für das Post-Training, die für skalierbares RL entwickelt wurde. NeMo RL ist Teil des umfassenderen NeMo-Framework-Ökosystems und ermöglicht sowohl kleine Experimente auf einer einzelnen GPU als auch Multi-Node-Bereitstellungen auf Tausenden von GPUs.

Weitere Informationen finden Sie unter NVIDIA NeMo RL.

GSM8k-Dataset

In dieser Anleitung verwenden Sie das GSM8k-Dataset, das 8.500 hochwertige, sprachlich vielfältige Textaufgaben für Grundschulmathematik enthält.

Mit GSM8k und GRPO generiert das Modell n verschiedene Antworten auf dasselbe Problem. GRPO vergleicht diese Antworten mit dem Gruppendurchschnitt. Das Modell wird stärker für Pfade belohnt, die im Vergleich zum Rest der Gruppe durchgehend richtig und logisch sind. Im Laufe der Zeit lernt das Modell, dass die klare Formulierung seiner Schritte die zuverlässigste Methode ist, um die Belohnung zu maximieren. Dadurch wird die Belohnung für Antworten mit geringer Leistung effektiv reduziert.

Weitere Informationen finden Sie unter GSM8k.

Ziele

In dieser Anleitung erfahren Sie, wie Sie RL in GKE mit NeMo RL einrichten. Dazu führen Sie die folgenden Schritte aus:

Bereiten Sie Ihre Umgebung vor.
GKE-Cluster mit B200- oder H200-GPUs einrichten
KubeRay zum Verwalten eines verteilten Ray-Clusters konfigurieren
Verwenden Sie Managed Lustre für Hochleistungsspeicher.
Führen Sie einen GRPO-Trainingsjob aus, der NeMo RL verwendet.

Hinweis

Melden Sie sich in Ihrem Google Cloud -Konto an. Wenn Sie mit Google Cloudnoch nicht vertraut sind, erstellen Sie ein Konto, um die Leistungsfähigkeit unserer Produkte in der Praxis sehen und bewerten zu können. Neukunden erhalten außerdem ein Guthaben von 300 $, um Arbeitslasten auszuführen, zu testen und bereitzustellen.

Installieren Sie die Google Cloud CLI.

Hinweis:Wenn Sie die gcloud CLI zuvor installiert haben, prüfen Sie, ob Sie die aktuelle Version haben, indem Sie gcloud components update ausführen.

Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

Führen Sie den folgenden Befehl aus, um die gcloud CLI zu initialisieren:

gcloud init

Erstellen Sie ein Google Cloud Projekt oder wählen Sie eines aus.

Rollen, die zum Auswählen oder Erstellen eines Projekts erforderlich sind

Projekt auswählen: Für die Auswahl eines Projekts ist keine bestimmte IAM-Rolle erforderlich. Sie können jedes Projekt auswählen, für das Ihnen eine Rolle zugewiesen wurde.
Projekt erstellen: Zum Erstellen eines Projekts benötigen Sie die Rolle „Projektersteller“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Weitere Informationen zum Zuweisen von Rollen

So erstellen Sie ein Google Cloud Projekt:
```
gcloud projects create PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch einen Namen für das Google Cloud Projekt, das Sie erstellen.
Wählen Sie das von Ihnen erstellte Google Cloud Projekt aus:
```
gcloud config set project PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch den Namen Ihres Projekts in Google Cloud .

Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Projekt aktiviert ist.

Aktivieren Sie die erforderlichen APIs:

Rollen, die zum Aktivieren von APIs erforderlich sind

Zum Aktivieren von APIs benötigen Sie die IAM-Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin), die die Berechtigung serviceusage.services.enable enthält. Weitere Informationen zum Zuweisen von Rollen

gcloud services enable container.googleapis.com storage.googleapis.com compute.googleapis.com

Installieren Sie die Google Cloud CLI.

Hinweis:Wenn Sie die gcloud CLI zuvor installiert haben, prüfen Sie, ob Sie die aktuelle Version haben, indem Sie gcloud components update ausführen.

Wenn Sie einen externen Identitätsanbieter (IdP) verwenden, müssen Sie sich zuerst mit Ihrer föderierten Identität in der gcloud CLI anmelden.

Führen Sie den folgenden Befehl aus, um die gcloud CLI zu initialisieren:

gcloud init

Erstellen Sie ein Google Cloud Projekt oder wählen Sie eines aus.

Rollen, die zum Auswählen oder Erstellen eines Projekts erforderlich sind

Projekt auswählen: Für die Auswahl eines Projekts ist keine bestimmte IAM-Rolle erforderlich. Sie können jedes Projekt auswählen, für das Ihnen eine Rolle zugewiesen wurde.
Projekt erstellen: Zum Erstellen eines Projekts benötigen Sie die Rolle „Projektersteller“ (roles/resourcemanager.projectCreator), die die Berechtigung resourcemanager.projects.create enthält. Weitere Informationen zum Zuweisen von Rollen

So erstellen Sie ein Google Cloud Projekt:
```
gcloud projects create PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch einen Namen für das Google Cloud Projekt, das Sie erstellen.
Wählen Sie das von Ihnen erstellte Google Cloud Projekt aus:
```
gcloud config set project PROJECT_ID
```
Ersetzen Sie PROJECT_ID durch den Namen Ihres Projekts in Google Cloud .

Prüfen Sie, ob die Abrechnung für Ihr Google Cloud Projekt aktiviert ist.

Aktivieren Sie die erforderlichen APIs:

Rollen, die zum Aktivieren von APIs erforderlich sind

gcloud services enable container.googleapis.com storage.googleapis.com compute.googleapis.com

Weisen Sie Ihrem Nutzerkonto Rollen zu. Führen Sie den folgenden Befehl für jede der folgenden IAM-Rollen einmal aus: roles/container.admin, roles/iam.serviceAccountAdmin, roles/storage.admin
```
gcloud projects add-iam-policy-binding PROJECT_ID --member="user:USER_IDENTIFIER" --role=ROLE
```
Ersetzen Sie Folgendes:
- PROJECT_ID: Ihre Projekt-ID.
- USER_IDENTIFIER: Die Kennung für Ihr Nutzerkonto . Beispiel: myemail@example.com
- ROLE: Die IAM-Rolle, die Sie Ihrem Nutzerkonto zuweisen.

Erstellen Sie ein Hugging Face-Konto, falls Sie noch keines haben.
Sie benötigen ein Hugging Face-Token.
Prüfen Sie, ob Ihr Projekt ein ausreichendes Kontingent für B200- und H200-GPUs hat. Weitere Informationen finden Sie unter GPU-Kontingent planen und GPU-Kontingent.

Umgebung vorbereiten

In dieser Anleitung verwenden Sie Cloud Shell.

Rufen Sie die Google Cloud Console auf.
Klicken Sie oben im Google Cloud Console-Fenster auf den Button Cloud Shell aktivieren.
Legen Sie die folgenden Umgebungsvariablen fest:
```
export PROJECT_ID=$(gcloud config get project)
export PROJECT_NUMBER=$(gcloud projects describe ${PROJECT_ID} --format="value(projectNumber)")
export CONTROL_PLANE_REGION=CONTROL_PLANE_REGION
export NODE_ZONE=NODE_ZONE
export CLUSTER_NAME=CLUSTER_NAME
export GPU_TYPE=GPU_TYPE
export MACHINE_TYPE=MACHINE_TYPE
export KSA_NAME=generic-ksa
export NAMESPACE=default
export RESERVATION=RESERVATION
export LUSTRE_NAME=LUSTRE_NAME
export HF_TOKEN=YOUR_HF_TOKEN
export WANDB_API_KEY=YOUR_WANDB_API_KEY
```
Ersetzen Sie die folgenden Werte:
- CLUSTER_NAME: Name Ihres GKE-Clusters.
- CONTROL_PLANE_REGION: die Compute Engine-Region für die GKE-Cluster-Steuerungsebene.
- NODE_ZONE: Die Zone für Ihre Knoten. Wählen Sie eine Zone aus, in der NVIDIA B200- oder H200-GPUs verfügbar sind.
- GPU_TYPE: der Beschleuniger, den Sie in der Compute Engine-Kapazitätsreservierung reserviert haben. Muss einer der folgenden Werte sein:
  - nvidia-b200: NVIDIA B200 (180 GB)
  - nvidia-h200-141gb: NVIDIA H200 (141 GB)
- MACHINE_TYPE: der zu verwendende Maschinentyp:
  - Verwenden Sie für NVIDIA B200-GPUs (180 GB) a4-highgpu-8g oder höher.
  - Verwenden Sie für NVIDIA H200-GPUs (141 GB) a3-ultragpu-8g oder höher.
- RESERVATION: Der Name Ihrer GPU-Reservierung.
- LUSTRE_NAME: der Name Ihrer Lustre-Instanz.
- YOUR_HF_TOKEN: Ihr Hugging Face-Token.
- YOUR_WANDB_API_KEY: Ihr Wandb-API-Schlüssel.
Erstellen Sie die folgenden Umgebungsvariablen für das Netzwerk:
```
export NETWORK="NETWORK-NAME"
export GVNIC_NETWORK_PREFIX="GVNIC-NAME"
export RDMA_NETWORK_PREFIX="RDMA-NAME"
```
Ersetzen Sie die folgenden Werte:
- NETWORK-NAME: Der Netzwerkname für GKE.
- GVNIC-NAME: Das Präfix für den Namen des gVNIC-Netzwerks. Sie können ein beliebiges Präfix verwenden.
- RDMA-NAME: Das Präfix für das RDMA-Netzwerk (Remote Direct Memory Access). Sie können ein beliebiges Präfix verwenden.

Infrastruktur einrichten

In diesem Abschnitt erstellen Sie VPC-Netzwerke und einen GKE-Cluster.

VPC-Netzwerk erstellen

VPC-Netzwerk für die gVNIC-Schnittstelle erstellen:

gcloud compute networks create ${NETWORK} --subnet-mode=auto
gcloud compute networks create ${GVNIC_NETWORK_PREFIX}-net \
    --subnet-mode=custom
gcloud compute networks subnets create ${GVNIC_NETWORK_PREFIX}-sub \
    --network=${GVNIC_NETWORK_PREFIX}-net \
    --region=${CONTROL_PLANE_REGION} \
    --range=192.168.0.0/24
gcloud compute firewall-rules create ${GVNIC_NETWORK_PREFIX}-internal \
    --network=${GVNIC_NETWORK_PREFIX}-net \
    --action=ALLOW \
    --rules=tcp:0-65535,udp:0-65535,icmp \
    --source-ranges=192.168.0.0/16

Erstellen Sie ein VPC-Netzwerk und Subnetze für RDMA, das acht Subnetze für acht GPUs enthält:

gcloud compute networks create ${RDMA_NETWORK_PREFIX}-net \
    --network-profile=${NODE_ZONE}-vpc-roce \
    --subnet-mode=custom

for N in $(seq 0 7); do
  gcloud compute networks subnets create ${RDMA_NETWORK_PREFIX}-sub-$N \
    --network=${RDMA_NETWORK_PREFIX}-net \
    --region=${CONTROL_PLANE_REGION} \
    --range=192.168.$((N+1)).0/24 &
done
wait

GKE-Cluster erstellen

Sie können NeMo RL in einem GKE Standard-Cluster festlegen.

Standardcluster erstellen:

gcloud container clusters create ${CLUSTER_NAME} \
    --location=${CONTROL_PLANE_REGION} \
    --workload-pool=${PROJECT_ID}.svc.id.goog \
    --enable-dataplane-v2 \
    --enable-ip-alias \
    --enable-multi-networking \
    --addons=RayOperator,LustreCsiDriver \
    --enable-legacy-lustre-port \
    --machine-type=n2-highmem-80 \
    --num-nodes=1 \
    --min-nodes=1 \
    --max-nodes=5 \
    --enable-autoscaling \
    --network=${NETWORK}

Rufen Sie Anmeldedaten für Ihren Cluster ab:

gcloud container clusters get-credentials ${CLUSTER_NAME} \
    --location=${CONTROL_PLANE_REGION}

Erstellen Sie den GPU-Knotenpool:

gcloud container node-pools create gpu-pool \
    --cluster=${CLUSTER_NAME} \
    --location=${CONTROL_PLANE_REGION} \
    --node-locations=${NODE_ZONE} \
    --machine-type=${MACHINE_TYPE} \
    --accelerator=type=${GPU_TYPE},count=8,gpu-driver-version=DEFAULT \
    --reservation-affinity=specific \
    --reservation=${RESERVATION} \
    --enable-autoscaling \
    --num-nodes=0 \
    --total-max-nodes=2 \
    --additional-node-network=network=${GVNIC_NETWORK_PREFIX}-net,subnetwork=${GVNIC_NETWORK_PREFIX}-sub \
    --additional-node-network=network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-0 \
    --additional-node-network=network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-1 \
    --additional-node-network=network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-2 \
    --additional-node-network=network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-3 \
    --additional-node-network=network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-4 \
    --additional-node-network=network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-5 \
    --additional-node-network=network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-6 \
    --additional-node-network=network=${RDMA_NETWORK_PREFIX}-net,subnetwork=${RDMA_NETWORK_PREFIX}-sub-7

Installieren Sie das NCCL RDMA-Installationsprogramm:

kubectl apply -f https://raw.githubusercontent.com/GoogleCloudPlatform/container-engine-accelerators/refs/heads/master/gpudirect-rdma/nccl-rdma-installer.yaml

Netzwerkzuordnungen konfigurieren

Speichern Sie das folgende Manifest als network-mapping.yaml:

# Copyright 2026 Google LLC. All rights reserved.
#
# 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: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: gvnic-1
spec:
  vpc: ${GVNIC_NETWORK_PREFIX}-net
  vpcSubnet: ${GVNIC_NETWORK_PREFIX}-sub
  deviceMode: NetDevice
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: gvnic-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: gvnic-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-0
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-0
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-0
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-0
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-1
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-1
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-1
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-1
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-2
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-2
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-2
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-2
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-3
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-3
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-3
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-3
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-4
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-4
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-4
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-4
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-5
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-5
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-5
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-5
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-6
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-6
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-6
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-6
---
apiVersion: networking.gke.io/v1
kind: GKENetworkParamSet
metadata:
  name: rdma-7
spec:
  vpc: ${RDMA_NETWORK_PREFIX}-net
  vpcSubnet: ${RDMA_NETWORK_PREFIX}-sub-7
  deviceMode: RDMA
---
apiVersion: networking.gke.io/v1
kind: Network
metadata:
  name: rdma-7
spec:
  type: "Device"
  parametersRef:
    group: networking.gke.io
    kind: GKENetworkParamSet
    name: rdma-7

Wenden Sie das Manifest an:

envsubst < network-mapping.yaml > network-mapping-updated.yaml
kubectl apply -f network-mapping-updated.yaml

Speicher vorbereiten

In diesem Abschnitt erstellen Sie eine Managed Lustre-Instanz, die den leistungsstarken Speicher bereitstellt, der für Ihre RL-Arbeitslast erforderlich ist.

IP-Adressbereich für den Zugriff auf private Dienste zuweisen:

gcloud compute addresses create ${LUSTRE_NAME}-range \
    --global --purpose=VPC_PEERING \
    --prefix-length=20 --network=${NETWORK}

Peering-Verbindung herstellen:

gcloud services vpc-peerings connect \
    --service=servicenetworking.googleapis.com \
    --ranges=${LUSTRE_NAME}-range \
    --network=${NETWORK}

Managed Lustre-Instanz erstellen:

gcloud lustre instances create ${LUSTRE_NAME} \
    --per-unit-storage-throughput=500 \
    --capacity-gib=18000 \
    --filesystem=lustrefs \
    --location=${NODE_ZONE} \
    --network=projects/${PROJECT_ID}/global/networks/${NETWORK} \
    --gke-support-enabled

Mit dem Managed Lustre-CSI-Treiber auf eine vorhandene Managed Lustre-Instanz zugreifen

Extrahieren Sie die IP-Adresse der Managed Lustre-Instanz.

export LUSTRE_IP=$(gcloud lustre instances describe ${LUSTRE_NAME} \
    --location=$NODE_ZONE --format="value(mountPoint)" | awk -F'@' '{print $1}')

lustre-pv.yaml-Manifest prüfen

# Copyright 2026 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: v1
kind: PersistentVolume
metadata:
  name: lustre-pv
spec:
  storageClassName: lustre-rwx-500mbps-per-tib
  capacity:
    storage: 18000Gi
  accessModes:
    - ReadWriteMany
  persistentVolumeReclaimPolicy: Retain
  volumeMode: Filesystem
  claimRef:
    namespace: default
    name: lustre-pvc
  csi:
    driver: lustre.csi.storage.gke.io
    volumeHandle: "${PROJECT_ID}/${NODE_ZONE}/${LUSTRE_NAME}"
    volumeAttributes:
      ip: ${LUSTRE_IP}
      filesystem: lustrefs

Wenden Sie das Manifest an:

envsubst < lustre-pv.yaml > lustre-pv-updated.yaml
kubectl apply -f lustre-pv-updated.yaml

lustre-pvc.yaml-Manifest prüfen

# Copyright 2026 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: v1
kind: PersistentVolumeClaim
metadata:
  name: lustre-pvc
spec:
  accessModes:
    - ReadWriteMany
  storageClassName: lustre-rwx-500mbps-per-tib
  volumeName: lustre-pv
  resources:
    requests:
      storage: 18000Gi

Wenden Sie das Manifest an:
```
kubectl apply -f lustre-pvc.yaml
```

RayCluster bereitstellen

In diesem Abschnitt klonen Sie das Beispiel-Repository, bereiten die Manifeste vor und stellen den Ray-Cluster bereit:

Klonen Sie das Beispiel-Repository:

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

Wechseln Sie zum Arbeitsverzeichnis:
```
cd ai-ml/nemo-rl-on-gke/nemoRL
```

Prüfen Sie das values.yaml-Manifest:

# Copyright 2026 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.

image:
  repository: "nvcr.io/nvidia/nemo-rl"
  tag: "v0.5.0" 
  pullPolicy: Always

nameOverride: "kuberay"
fullnameOverride: ""

common:
  containerEnv: {}

configMap:
  fluentbit:
    data:
      fluent-bit.conf: |
        [INPUT]
            Name              tail
            Path              /tmp/ray/session_latest/logs/worker-*
            Tag               ray-worker
        [INPUT]
            Name              tail
            Path              /tmp/ray/session_latest/logs/raylet*
            Tag               raylet
        [INPUT]
            Name              tail
            Path              /tmp/ray/session_latest/logs/*
            Exclude_Path      /tmp/ray/session_latest/logs/debug_state.txt,/tmp/ray/session_latest/logs/raylet*,/tmp/ray/session_latest/logs/worker-*
            Tag               ray-misc
        [OUTPUT]
            Name              stackdriver
            Match             *
            resource          gce_instance
            labels_key        labels

# --- Head Node Configuration ---
head:
  enableInTreeAutoscaling: false
  serviceAccountName: ""
  rayStartParams:
    dashboard-host: '0.0.0.0'
  template:
    metadata:
      annotations:
        gke-gcsfuse/volumes: "true"
        networking.gke.io/default-interface: 'eth0'
  containerEnv:
  - name: RAY_GROUP
    value: "head"
  nodeSelector:
    cloud.google.com/gke-nodepool: default-pool
  resources:
    limits:
      cpu: "64"
      memory: "500G"
      nvidia.com/gpu: 0
    requests:
      cpu: "64"
      memory: "500G"
      nvidia.com/gpu: 0
  tolerations:
    # - operator: "Exists"
    #   key: "components.gke.io/gke-managed-components"
    # - key: "nvidia.com/gpu"
    #   operator: "Exists"
    #   effect: "NoSchedule"
  volumeMounts:
    - mountPath: /data
      name: lustre-data

  volumes:
    - name: log-volume
      emptyDir: {}
    - name: fluentbit-config-volume
      configMap:
        name: "ray-cluster-kuberay-fluentbit-config"
    - name: lustre-data
      persistentVolumeClaim:
        claimName: lustre-pvc
  sidecarContainers:
    - name: fluent-bit
      image: fluent/fluent-bit:latest
      env:
      - name: RAY_GROUP
        value: "head"
      volumeMounts:
        - name: fluentbit-config-volume
          mountPath: /fluent-bit/etc/
        - mountPath: /tmp/ray
          name: log-volume

  # --- HEAD POD STARTUP SCRIPT ---
  command:
    - "bash"
    - "-c"
    - |
      set -ex
      echo "--- Head Pod Setup ---"
      apt-get update
      apt-get install -y sudo netcat-openbsd pciutils
      cd /opt/nemo-rl
      /usr/bin/python -m pip install uv
      /usr/bin/python -m uv venv
      echo "Head pod setup complete. Starting Ray..."

      exec ${KUBERAY_GEN_RAY_START_CMD}

  args: []
  headService: {}
  # nodeSelector:
  #   cloud.google.com/gke-accelerator: nvidia-b200 #cloud.google.com/gke-nodepool: cpu-node-pool-llama #cpu-node-pool

# --- Default Worker (Disabled) ---
worker:
  disabled: true

# --- A4 GPU Worker Groups ---
additionalWorkerGroups:
  worker-grp-0:
    disabled: false
    replicas: 4
    annotations:
      networking.gke.io/default-interface: 'eth0'
      networking.gke.io/interfaces: |
        [
          {"interfaceName":"eth0","network":"default"},
          {"interfaceName":"eth1","network":"gvnic-1"},
          {"interfaceName":"eth2","network":"rdma-0"},
          {"interfaceName":"eth3","network":"rdma-1"},
          {"interfaceName":"eth4","network":"rdma-2"},
          {"interfaceName":"eth5","network":"rdma-3"},
          {"interfaceName":"eth6","network":"rdma-4"},
          {"interfaceName":"eth7","network":"rdma-5"},
          {"interfaceName":"eth8","network":"rdma-6"},
          {"interfaceName":"eth9","network":"rdma-7"}
        ]
    containerEnv:
      - name: RAY_GROUP
        valueFrom:
          fieldRef:
            fieldPath: metadata.labels['ray.io/group']
      - name: NCCL_NET  
        value: "gIB"
      - name: NCCL_IB_GID_INDEX
        value: "3"   
      - name: GLOO_SOCKET_IFNAME
        value: "eth0"
      - name: NCCL_CROSS_NIC
        value: "0"
      - name: NCCL_SOCKET_IFNAME
        value: "eth0"
      - name: TP_SOCKET_IFNAME # Specific to DTensor/PyTorch Distributed
        value: "eth0"
      - name: NCCL_TUNER_CONFIG_PATH
        value: "/usr/local/gib/configs/tuner_config_a4.txtpb"
      - name: NCCL_NET_GDR_LEVEL
        value: "PIX"
      - name: LD_LIBRARY_PATH
        value: /usr/local/nvidia/lib64
    resources:
      limits:
        nvidia.com/gpu: 8
        cpu: "206"
        memory: "2400Gi"
      requests:
        nvidia.com/gpu: 8
        cpu: "206"
        memory: "2400Gi"

    nodeSelector:
      cloud.google.com/gke-accelerator: nvidia-b200
    tolerations:
      - operator: "Exists"
        key: "nvidia.com/gpu"
      - operator: "Exists"
        key: "cloud.google.com/impending-node-termination"
      - operator: "Exists"
        key: "user-workload"
    securityContext:
      privileged: true
    volumes:
      - name: log-volume
        emptyDir: {}
      - name: shared-memory
        emptyDir:
          medium: "Memory"
          sizeLimit: 240Gi
      - name: ray-tmp
        emptyDir:
          medium: "Memory"
      - name: fluentbit-config-volume
        configMap:
          name: "ray-cluster-kuberay-fluentbit-config"
      - name: nvidia-install-dir-host
        hostPath:
          path: /home/kubernetes/bin/nvidia
      - name: gib-nccl-plugin-volume
        hostPath: 
          path: /home/kubernetes/bin/gib
      - name: lustre-data
        persistentVolumeClaim:
          claimName: lustre-pvc
    volumeMounts:
      - mountPath: /tmp/ray
        name: log-volume
      - name: shared-memory
        mountPath: /dev/shm
      - name: nvidia-install-dir-host
        mountPath: /usr/local/nvidia
      - name: gib-nccl-plugin-volume
        mountPath: /usr/local/gib
      - mountPath: /data
        name: lustre-data   
    # --- WORKER POD STARTUP SCRIPT ---
    command:
      - "bash"
      - "-c"
      - |
        set -ex

        echo "--- Worker Pod Setup ---"
        apt-get update
        apt-get install -y sudo netcat-openbsd pciutils
        cd /opt/nemo-rl
        /usr/bin/python -m pip install uv
        /usr/bin/python -m uv venv

        ldconfig /usr/local/nvidia/lib64/
        ldconfig -p | grep libcuda | sed 's/^/  /'
        export LD_LIBRARY_PATH="/usr/local/gib/lib64:$LD_LIBRARY_PATH"
        source /usr/local/gib/scripts/set_nccl_env.sh

        echo "Worker pod setup complete. Starting Ray..."

        exec ${KUBERAY_GEN_RAY_START_CMD}


    sidecarContainers:
      - name: fluent-bit
        env:
          - name: RAY_GROUP
            valueFrom:
              fieldRef:
                fieldPath: metadata.labels['ray.io/group']
        image: fluent/fluent-bit:latest
        volumeMounts:
          - name: fluentbit-config-volume
            mountPath: /fluent-bit/etc/
          - mountPath: /tmp/ray
            name: log-volume

# --- Service Config ---
service:
  type: ClusterIP

Ersetzen Sie NCCL_TUNER_CONFIG_PATH durch einen der folgenden Werte, je nachdem, welchen Beschleuniger Sie in diesem Tutorial verwenden:

NVIDIA B200 (180 GB): /usr/local/gib/configs/tuner_config_a4.txtpb
NVIDIA H200 (141 GB): /usr/local/gib/configs/tuner_config_a3u.txtpb

In diesem Manifest verwaltet der Head-Knoten den Job und hostet das Ray-Dashboard. Die Trainingsjobs werden von den Worker-Knoten ausgeführt.

Ray-Cluster bereitstellen:
```
export REPLICA_COUNT=2
helm install ray-cluster . \
  --set additionalWorkerGroups.worker-grp-0.replicas=$REPLICA_COUNT
```
In dieser Anleitung verwenden Sie zwei Worker-Knoten. Wenn Sie die Anzahl der Worker-Knoten ändern möchten, ändern Sie den Wert von REPLICA_COUNT.

Prüfen Sie, ob die Worker- und Head-Knoten ausgeführt werden:

kubectl get pods

Die Ausgabe sieht etwa so aus:

NAME                                          READY STATUS RESTARTS AGE
ray-cluster-kuberay-head-sw7dp                3/3   Running 0      33h
ray-cluster-kuberay-worker-grp-0-worker-gkbxw 3/3   Running 0      33h
ray-cluster-kuberay-worker-grp-0-worker-kdg62 3/3   Running 0      33h

Prüfen Sie, ob der Ray-Cluster ausgeführt wird:

kubectl ray get cluster

Die Ausgabe sieht etwa so aus:

NAME                 NAMESPACE DESIRED WORKERS AVAILABLE WORKERS CPUS GPUS TPUS MEMORY CONDITION STATUS AGE
ray-cluster-kuberay  default   2       2           618     17   0    1573741824k RayClusterProvisioned ready 33h

GRPO-Job starten

Sobald Ihr Ray-Cluster bereit ist, können Sie einen Ray-Job an Ihren laufenden Ray-Cluster in GKE senden. NeMo RL lädt das Modell automatisch während der Ausführung des RL-Trainingsjobs herunter.

Wenn Sie einen Ray-Job senden möchten, starten Sie eine interaktive Sitzung, um den Job auszuführen.

Führen Sie diesen Befehl aus, um eine lokale Verbindung zu Ihrem Ray-Cluster herzustellen:
```
  kubectl ray session ray-cluster-kuberay
```
Mit diesem Befehl wird die Portweiterleitung zwischen Ihrem lokalen Computer und dem Ray-Head-Knoten in Ihrem GKE-Cluster initiiert. Beachten Sie, dass Ihr Terminal belegt ist, solange diese Sitzung aktiv ist. Öffnen Sie eine separate Terminalinstanz, um fortzufahren.

Bearbeiten Sie die Datei gemma3-27b-gsm8k.sh.

# Copyright 2026 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.

#!/bin/bash
WANDB_API_KEY='YOUR_WANDB_API_KEY' # Update this with your WANDB API key
HF_TOKEN='YOUR_HF_TOKEN' # Update this with your HF token
WORLD_SIZE=16

# --- Step 1: Find the Ray Head Pod ---
echo "Finding Ray head pod..."
export HEAD_POD_NAME=$(kubectl get pods --selector=ray.io/node-type=head -o jsonpath='{.items[0].metadata.name}')
if [ -z "$HEAD_POD_NAME" ]; then
    echo "Error: No running Ray head pod found. Please check your cluster."
    exit 1
fi
echo "Found head pod: $HEAD_POD_NAME"
echo ""

# --- Step 2: Define the Job Script to Run ---
# This is the script that will be executed *inside* the head pod.
# It assumes the 'uv venv' setup from the values.yaml is already done.
JOB_SCRIPT=$(cat <<EOF
set -ex

echo "--- Running on Ray Head Pod ($HOSTNAME) ---"
cd /opt/nemo-rl

git pull && git checkout main

sed -i 's/subset: Optional\[str\] = None/subset: Optional[str] = "main"/' /opt/nemo-rl/nemo_rl/data/datasets/response_datasets/response_dataset.py
sed -i 's/raw_dataset = load_dataset(data_path)/raw_dataset = load_dataset(data_path, "main")/' /opt/nemo-rl/nemo_rl/data/datasets/utils.py

echo "Setting environment variables..."
export WANDB_API_KEY=$WANDB_API_KEY
export HF_TOKEN=$HF_TOKEN
export HF_HOME=/opt/nemo-rl/

###-----Example to launch Gemma3-27B on 2 nodes (16 GPUs)----------
uv run python examples/run_grpo_math.py \
  --config examples/configs/recipes/llm/grpo-gemma3-27b-it-8n4g-fsdp2tp4-actckpt-long.yaml \
  cluster.num_nodes=2 \
  cluster.gpus_per_node=8 \
  grpo.max_num_steps=10 \
  checkpointing.checkpoint_dir=/data/nemo_rl_gemma3_27b_3_17 \
  data.dataset_name=ResponseDataset \
  +data.train_data_path=openai/gsm8k \
  +data.val_data_path=openai/gsm8k \
  +data.val_split=test \
  +data.train_split=train \
  +data.subset="main" \
  +data.input_key="question" \
  +data.output_key="answer" \
  logger.tensorboard_enabled=False \
  logger.wandb_enabled=True \
  logger.wandb.name='nemo_rl_gemma3_27b_3_17' \
  grpo.num_prompts_per_step=16 \
  grpo.num_generations_per_prompt=32 \
  policy.generation.colocated.enabled=False \
  policy.generation.colocated.resources.num_nodes=1 \
  policy.generation.colocated.resources.gpus_per_node=8 \
  policy.generation.vllm_cfg.tensor_parallel_size=8 \
  policy.generation.vllm_cfg.gpu_memory_utilization=0.9 \
  policy.dtensor_cfg.tensor_parallel_size=8

echo "--- Job Finished ---"
EOF
)

# --- Step 3: Execute the Job ---
echo "Submitting job to $HEAD_POD_NAME..."
echo "$JOB_SCRIPT" | tr -d '\r' | kubectl exec -i $HEAD_POD_NAME -c ray-head -- /bin/bash

echo ""
echo "Job submission complete."

Ersetzen Sie die folgenden Werte in der Datei gemma3-27b-gsm8k.sh:

YOUR_WANDB_API_KEY: Ihr WandB-API-Schlüssel.
YOUR_HF_TOKEN: Ihr Hugging Face-Token.

In dieser Datei sehen Sie die Konfiguration zum Ausführen eines Jobs mit dem Modell „gemma3-27b-it“ für den GSM8k-Datensatz. Für die GRPO-Trainingspipeline werden in diesem Skript die folgenden Parameter definiert:

num_prompts_per_step: 16 und num_generations_per_prompt: 32: Das Modell „Gemma3-27b-it“ generiert für jeden Prompt eine große Gruppe von Antworten. In dieser Konfiguration generiert das Modell insgesamt 512 Antworten (16 × 32 = 512).
policy.generation.colocated.enabled=False: Mit diesem Parameter wird die Funktion für die gemeinsame Generierung deaktiviert. Das bedeutet, dass das Modell keine Antworten im selben Knoten wie der Trainingsprozess generiert. Beim Standard-RL werden sowohl Training als auch Generierung von denselben GPUs übernommen. Bei dieser NeMo RL-Einrichtung weisen Sie bestimmte Knoten (die mit dem Parameter policy.generation.colocated.resources verwaltet werden) ausschließlich der vLLM-Inferenz zu, während sich der Rest des Clusters auf die rechenintensive Trainingsmathematik konzentriert. Durch die Trennung dieser Arbeitslasten verhindern Sie Ressourcenkonflikte zwischen den speicherintensiven Trainingspuffern und den rechenintensiven Inferenzarbeitslasten.

Führen Sie den folgenden Befehl aus, um den Job zu senden:
```
bash gemma3-27b-it/gemma3-27b-gsm8k.sh
```
Während der Job ausgeführt wird, werden in der Ausgabe die Trainingsergebnisse, das Timing und die Leistungsmesswerte angezeigt.

Integrität des GRPO-Jobs überwachen

Nachdem Ray den Job abgeschlossen hat, speichert NeMo RL die Prüfpunkte im konfigurierten Pfad.

Wenn Sie die Ausgabe des GRPO-Jobs prüfen möchten, stellen Sie eine SSH-Verbindung zum ray-head-Container her:
```
kubectl exec -it $(kubectl get pods -l ray.io/node-type=head -o name) -c ray-head -- bash
```

Installieren Sie das apt-tree-Dienstprogramm im Terminal des ray-head-Containers:

apt update && apt install -y tree

Die Ausgabe sieht etwa so aus:

 root@ray-cluster-kuberay-worker-grp-0-worker-gkbxw:/opt/nemo-rl# tree /data/nemo_rl_gemma3_27b_3_17/
 /data/nemo_rl_gemma3_27b_3_17/
 `-- step_10
     |-- config.yaml
     |-- policy
     |   |-- optimizer
     |   |   |-- __0_0.distcp
     |   |   |-- __10_0.distcp
     |   |   |-- __11_0.distcp
     |   |   |-- __12_0.distcp
     |   |   |-- __13_0.distcp
     |   |   |-- __14_0.distcp
     |   |   |-- __15_0.distcp
     |   |   |-- __1_0.distcp
     |   |   |-- __2_0.distcp
     |   |   |-- __3_0.distcp
     |   |   |-- __4_0.distcp
     |   |   |-- __5_0.distcp
     |   |   |-- __6_0.distcp
     |   |   |-- __7_0.distcp
     |   |   |-- __8_0.distcp
     |   |   `-- __9_0.distcp
     |   |-- tokenizer
     |   |   |-- chat_template.jinja
     |   |   |-- special_tokens_map.json
     |   |   |-- tokenizer.json
     |   |   `-- tokenizer_config.json
     |   `-- weights
     |       |-- __0_0.distcp
     |       |-- __10_0.distcp
     |       |-- __11_0.distcp
     |       |-- __12_0.distcp
     |       |-- __13_0.distcp
     |       |-- __14_0.distcp
     |       |-- __15_0.distcp
     |       |-- __1_0.distcp
     |       |-- __2_0.distcp
     |       |-- __3_0.distcp
     |       |-- __4_0.distcp
     |       |-- __5_0.distcp
     |       |-- __6_0.distcp
     |       |-- __7_0.distcp
     |       |-- __8_0.distcp
     |       `-- __9_0.distcp
     |-- train_dataloader.pt
     `-- training_info.json

 6 directories, 39 files
 ```

Bereinigen

Löschen Sie die Ressourcen, um Gebühren zu vermeiden:

helm delete ray-cluster
gcloud container clusters delete ${CLUSTER_NAME} \
    --location=${CONTROL_PLANE_REGION} \
    --quiet
gcloud lustre instances delete ${LUSTRE_NAME} --location=${NODE_ZONE} --quiet
gcloud services vpc-peerings delete \
    --service=servicenetworking.googleapis.com \
    --network=${NETWORK}
gcloud compute addresses delete ${LUSTRE_NAME}-range --global --quiet
gcloud compute firewall-rules delete ${GVNIC_NETWORK_PREFIX}-internal --quiet
gcloud compute networks subnets delete ${GVNIC_NETWORK_PREFIX}-sub \
    --region=${CONTROL_PLANE_REGION} --quiet
gcloud compute networks delete ${GVNIC_NETWORK_PREFIX}-net --quiet
for N in $(seq 0 7); do
  gcloud compute networks subnets delete ${RDMA_NETWORK_PREFIX}-sub-$N \
    --region=${CONTROL_PLANE_REGION} --quiet &
done
wait
gcloud compute networks delete ${RDMA_NETWORK_PREFIX}-net --quiet
gcloud compute networks delete ${NETWORK} --quiet

Bestärkendes Lernen mit NVIDIA NeMo RL in GKE optimieren und skalieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Hintergrund

Bestärkendes Lernen (Reinforcement Learning, RL)

Gruppenrelative Richtlinienoptimierung (Group Relative Policy Optimization, GRPO)

NVIDIA NeMo RL

GSM8k-Dataset

Ziele

Hinweis

Umgebung vorbereiten

Infrastruktur einrichten

VPC-Netzwerk erstellen

GKE-Cluster erstellen

Netzwerkzuordnungen konfigurieren

Speicher vorbereiten

RayCluster bereitstellen

GRPO-Job starten

Integrität des GRPO-Jobs überwachen

Bereinigen

Nächste Schritte

Bestärkendes Lernen mit NVIDIA NeMo RL in GKE optimieren und skalieren