Vorgefertigte Arbeitslasten ausführen

Wenn Sie an Gemini Enterprise Agent Platform Managed Training interessiert sind, wenden Sie sich an Ihren Vertriebsmitarbeiter, um Zugriff zu erhalten.

In dieser Anleitung wird gezeigt, wie Sie das NVIDIA NeMo-Ökosystem in einem verwalteten Trainingscluster für die End-to-End-Entwicklung generativer KI-Modelle verwenden. Sie enthält detaillierte Anleitungen für die folgenden unterschiedlichen, aber zusammenhängenden Workflows, die jeweils in einem eigenen Abschnitt behandelt werden:

  • NVIDIA NeMo: Folgen Sie dieser Anleitung, um für die Entwicklung von Foundation Models umfangreiches Pre-Training, kontinuierliches Pre-Training (CPT) und überwachte Feinabstimmung (SFT) durchzuführen.
  • NVIDIA NeMo-RL: In diesem Abschnitt können Sie erweiterte Techniken wie Reinforcement Learning (RL) anwenden, um Ihr Modell an menschliche Anweisungen und Präferenzen anzupassen.

Unabhängig davon, ob Sie ein Modell von Grund auf neu erstellen oder ein vorhandenes Modell optimieren, führt Sie dieses Dokument durch die Einrichtung Ihrer Umgebung, die Verwaltung von containerisierten Jobs und das Starten von Trainingsskripts im Cluster.

NVIDIA NeMo

Das NVIDIA NeMo-Framework ist eine End-to-End-Plattform zum Erstellen, Anpassen und Bereitstellen von generativen KI-Modellen. Dieser Abschnitt des Leitfadens richtet sich speziell an Entwickler und Forscher, die sich auf die grundlegenden Phasen der Modellentwicklung konzentrieren. Sie enthält eine detaillierte Anleitung zur Verwendung von NeMo für umfangreiches Vortraining, kontinuierliches Vortraining (CPT) und überwachte Feinabstimmung (SFT) in einem verwalteten Trainingscluster.

Dieser Leitfaden für Trainingscluster enthält den vollständigen Workflow zum Ausführen eines Trainingsjobs mit dem NeMo-Framework. Der Prozess ist in zwei Hauptteile unterteilt: die Ersteinrichtung Ihrer Umgebung und die wiederkehrenden Schritte zum Starten eines Jobs.

Umgebung einrichten

Bevor Sie einen Job starten, müssen Sie Ihre Umgebung vorbereiten. Dazu benötigen Sie ein Container-Image und die erforderlichen Trainingsskripts.

NeMo-Run installieren

pip install git+https://github.com/NVIDIA/NeMo-Run.git

Container-Image vorbereiten

Sie haben zwei Optionen für das Container-Image: Sie können ein vordefiniertes Image verwenden (empfohlen) oder ein benutzerdefiniertes Image erstellen.

Vordefiniertes Image verwenden (empfohlen)

Vordefinierte Container-Images werden im Format .squashfs bereitgestellt. Kopieren Sie das entsprechende Image für Ihre Region in Ihr Arbeitsverzeichnis.

# Example for the US region
gcloud storage cp gs://vmds-containers-us/vmds_nemo_squashfs/nemo-20250721.sqsh .
Benutzerdefinierten Container erstellen (erweitert)

Führen Sie diese Schritte nur aus, wenn die vordefinierten Container Ihre Anforderungen nicht erfüllen. In diesem Verfahren wird beschrieben, wie Sie ein benutzerdefiniertes Container-Image mit enroot in das .squashfs-Format konvertieren.

Schritt 1: Mit Google Cloudauthentifizieren.

Verwenden Sie die folgenden Befehle, um sicherzustellen, dass sowohl Ihr Google Cloud -Nutzerkonto als auch die Docker-Registry, in der Ihr Image gehostet wird, authentifiziert sind:

gcloud auth login
gcloud auth configure-docker us-docker.pkg.dev

Schritt 2: Conversion-Script erstellen

Erstellen Sie eine Datei mit dem Namen enroot-convert.sh und fügen Sie den folgenden Skriptinhalt hinzu. Bevor Sie dieses Script ausführen, müssen Sie die Variablen REMOTE_IMG und LOCAL_IMG so aktualisieren, dass sie auf Ihr Container-Image und den ausgewählten Ausgabepfad verweisen.

#!/bin/bash

#SBATCH --gpus-per-node=8
#SBATCH --exclusive
#SBATCH --mem=0
#SBATCH --ntasks-per-node=1

# Run this script on the slurm login node:
# sbatch -N 1 enroot-convert.sh

set -x
set -e

# The remote docker image URI.
REMOTE_IMG="docker://us-docker.pkg.dev/{YOUR_CONTAINER_IMG_URI}:{YOUR_CONTAINER_IMAGE_TAG}"

# The local path to the to be imported enroot squash file.
LOCAL_IMG="${HOME}/my_nemo.sqsh"

# The path to the enroot config file.
TMP_ENROOT_CONFIG_PATH="/tmp/\$(id -u --name)/config/enroot"

# Download the docker image to each node.
srun -l -N "${SLURM_NNODES}" \
bash -c "
mkdir -p ${TMP_ENROOT_CONFIG_PATH};
echo 'machine us-docker.pkg.dev login oauth2accesstoken password $(gcloud auth print-access-token)' > ${TMP_ENROOT_CONFIG_PATH}/.credentials;
rm -f ${LOCAL_IMG};
ENROOT_CONFIG_PATH=${TMP_ENROOT_CONFIG_PATH} ENROOT_MAX_PROCESSORS=$(( $(nproc) / 2 )) enroot import -o ${LOCAL_IMG} ${REMOTE_IMG};
"

Schritt 3: Script ausführen und Ausgabe prüfen

Führen Sie das Script auf dem Slurm-Login-Knoten aus.

sbatch -N 1 enroot-convert.sh

Nach Abschluss des Jobs finden Sie die Konvertierungslogs in einer Datei mit dem Namen slurm-<JOB_ID>.out und das endgültige Container-Image im Pfad, den Sie für LOCAL_IMG angegeben haben.

Trainingsrezepte herunterladen

Die Trainingsrezepte werden in einem privaten googlesource.com-Repository gespeichert. Wenn Sie über die Git-Befehlszeile darauf zugreifen möchten, müssen Sie zuerst Authentifizierungsdaten generieren.

  1. Authentifizierungsdaten generieren

    Rufen Sie die folgende URL auf und folgen Sie der Anleitung auf dem Bildschirm. Dadurch wird Ihre lokale Umgebung für die Authentifizierung beim Repository konfiguriert. https://www.googlesource.com/new-password

  2. Klonen Sie das Repository.

    Nachdem die Anmeldedaten authentifiziert wurden, führen Sie den folgenden Befehl aus, um die Rezepte herunterzuladen.

    git clone -b release-allowlist-ga https://vertex-model-garden.googlesource.com/vertex-oss-training
    

Trainingsjob starten

Sobald Ihre Umgebung eingerichtet ist, können Sie einen Trainingsjob starten.

Schritt 1: Umgebungsvariablen festlegen

Die folgenden Umgebungsvariablen sind möglicherweise für Ihren Job erforderlich:

  • Das HF_TOKEN ist erforderlich, um Modelle und Datasets von Hugging Face herunterzuladen.
  • Der WANDB_API_KEY ist erforderlich, um Weights & Biases für die Analyse von Experimenten zu verwenden.
export HF_TOKEN=YOUR_HF_TOKEN
export WANDB_API_KEY=YOUR_WANDB_API_KEY

Schritt 2: Startskript ausführen

Wechseln Sie zu Ihrem Arbeitsverzeichnis und führen Sie das Skript run.py aus, um einen Job zu starten. In diesem Beispiel wird ein Demo-Trainingsjob mit Llama 3.1-2b gestartet.

# Set the working directory
export WORK_DIR=$HOME/vertex-oss-training/nemo
cd $WORK_DIR

gcloud storage cp
gs://vmds-containers-<region>/vmds_nemo_squashfs/nemo-20250721.sqsh nemo-demo.sqsh

# Launch the training job
export NEMORUN_HOME=$WORK_DIR && \
python3 run.py -e slurm --slurm-type hcc-a3m --partition a3m \
  -d $WORK_DIR -i $WORK_DIR/nemo-demo.sqsh \
  -s pretrain/llama3p1_2b_pt.py -n 2 \
  --experiment-name nemo-demo-run

Startparameter

  • --slurm-type wird basierend auf dem Clustertyp festgelegt (z. B. hcc-a3m, hcc-a3u, hcc-a4).
  • --partition muss auf eine verfügbare Partition festgelegt sein. Sie können Partitionsnamen mit dem Befehl sinfo prüfen.
  • Das Skript run.py stellt automatisch mehrere Verzeichnisse im Docker-Container bereit, darunter --log-dir, --cache-dir und --data-dir, sofern sie festgelegt sind.

Jobstatus und Logs überwachen

Nachdem Sie den Job gestartet haben, wird ein Statusblock angezeigt:

Experiment Status for nemo-demo-run_1753123402

Task 0: nemo-demo-run
- Status: RUNNING
- Executor: SlurmExecutor on @localhost
- Job id: 75
- Local Directory: $NEMORUN_HOME/experiments/nemo-demo-run/nemo-demo-run_1753123402/nemo-demo-run

Die Ausführungsprotokolle werden in den Pfad geschrieben, der in der Statusausgabe im Feld Local Directory angezeigt wird. Die Logdateien finden Sie beispielsweise unter einem Pfad wie diesem:

$NEMORUN_HOME/experiments/nemo-demo-run/nemo-demo-run_1753123402/nemo-demo-run/<JOB_ID>.log

Häufige Fehler und Lösungen

In diesem Abschnitt werden häufige Probleme beschrieben, die bei der Jobausführung auftreten können, und empfohlene Schritte zur Behebung dieser Probleme.

Fehler „Ungültige Partition“

Standardmäßig wird versucht, Jobs auf der allgemeinen Partition zu starten. Wenn die allgemeine Partition nicht vorhanden oder nicht verfügbar ist, schlägt der Job mit dem folgenden Fehler fehl:

sbatch: error: invalid partition specified: general
sbatch: error: Batch job submission failed: Invalid partition name specified

Lösung:

Geben Sie im Startbefehl mit dem Argument --partition oder -p eine verfügbare Partition an. Führen Sie den Befehl sinfo auf dem Slurm-Login-Knoten aus, um eine Liste der verfügbaren Partitionen aufzurufen.

sinfo

Die Ausgabe zeigt die verfügbaren Partitionsnamen, in diesem Beispiel a3u:

PARTITION AVAIL TIMELIMIT KNOTEN STATUS NODELIST
a3u* Nach-oben infinite 2 idle~ alice-a3u-[2-3]
a3u* Nach-oben infinite 2 inaktiv alice-a3u-[0-1]

Fehler beim Herunterladen des Tokenizers

Wenn das Skript versucht, den GPT2-Tokenizer herunterzuladen, kann ein OSError im Zusammenhang mit einem geräteübergreifenden Link auftreten:

OSError: [Errno 18] Invalid cross-device link: 'gpt2-vocab.json' -> '/root/.cache/torch/megatron/megatron-gpt-345m_vocab'

Lösungen:

Sie haben zwei Möglichkeiten, dieses Problem zu beheben:

  • Option 1: Führen Sie den Job noch einmal aus. Dieser Fehler ist oft vorübergehend. Das Problem lässt sich möglicherweise beheben, wenn Sie den Job mit derselben --cache-dir noch einmal ausführen.
  • Option 2: Laden Sie die Tokenizer-Dateien manuell herunter. Wenn die erneute Ausführung des Jobs fehlschlägt, gehen Sie so vor:
    • Laden Sie die folgenden beiden Dateien herunter:
      • gpt2-vocab.json
      • gpt2-merges.txt
    • Verschieben Sie die heruntergeladenen Dateien in das Unterverzeichnis torch/megatron/ in Ihrem Cache-Verzeichnis (z. B. <var>YOUR_CACHE_DIR</var>/torch/megatron/).
    • Benennen Sie die Dateien so um:
      • gpt2-vocab.json in megatron-gpt-345m_vocab umbenennen.
      • gpt2-merges.txt in megatron-gpt-345m_merges umbenennen.

NVIDIA NeMo-RL

Das NVIDIA NeMo-RL-Framework wurde entwickelt, um Large Language Models an menschliche Präferenzen und Anweisungen anzupassen. In diesem Abschnitt wird beschrieben, wie Sie NeMo-RL auf einem Cluster verwenden, um erweiterte Alignment-Aufgaben auszuführen, einschließlich überwachter Feinabstimmung (Supervised Fine-Tuning, SFT), Präferenzabstimmung (z. B. Direct Preference Optimization, DPO) und Reinforcement Learning (RL).

In der Anleitung werden zwei Hauptworkflows behandelt: das Ausführen eines Standard-Batch-Trainingsjobs und die Verwendung der interaktiven Entwicklungsumgebung für das Debugging.

Vorbereitung

Erstellen Sie zuerst einen Cluster. Folgen Sie dazu der Anleitung auf der Seite Cluster erstellen oder verwenden Sie einen vorhandenen Cluster für verwaltetes Training, falls Sie einen haben.

Verbindung zum Login-Knoten des Clusters herstellen

Wenn Sie eine Verbindung zum Login-Knoten des Clusters herstellen möchten, rufen Sie in der Google Cloud Console die Seite Compute Engine-VM auf und klicken Sie auf „SSH“ > „Google Cloud CLI-Befehl ansehen“, um den richtigen Google Cloud CLI-Befehl zu finden. Die Ausgabe sieht etwa so aus:

ssh $USER_NAME@machine-addr

Beispiel:

ssh $USER_NAME@nic0.sliua3m1-login-001.europe-north1-c.c.infinipod-shared-dev.internal.gcpnode.com

Vordefiniertes Docker-Image verwenden

Für vordefinierte Container-Images werden konvertierte .sqsh-Dateien bereitgestellt. Sie können einen Container für Ihre Region auswählen und ihn entweder direkt als Container-Image-Parameter festlegen oder in das Dateisystem des Clusters herunterladen.

Wenn Sie es direkt als Container-Image-Parameter festlegen möchten, verwenden Sie einen der folgenden Pfade. Ersetzen Sie <region> durch Ihre spezifische Region (z. B. europe, asia, us):

/gcs/vmds-containers-<region>/vmds_nemo_rl_squashfs/nemo_rl-h20260302.sqsh

Verwenden Sie den folgenden Befehl, um das Image in den Lustre-Speicher des Clusters herunterzuladen:

gs://vmds-containers-<region>/vmds_nemo_rl_squashfs/nemo_rl-h20260302.sqsh DESTINATION

Code herunterladen

Wenn Sie mit der Git-Befehlszeile auf das Trainingsrezept zugreifen möchten, rufen Sie https://www.googlesource.com/new-password auf. Das Rezept kann mit dem folgenden Befehl heruntergeladen werden:

cd $HOME
git clone -b release-allowlist-ga https://vertex-model-garden.googlesource.com/vertex-oss-training

Jobs starten

Schritt 1: Umgebungsvariablen festlegen

Um Modelle und Daten von Hugging Face abzurufen, muss möglicherweise HF_TOKEN festgelegt werden. Wenn Sie Weights & Biases für die Testanalyse verwenden möchten, muss WANDB_API_KEY festgelegt werden. Aktualisieren Sie diese Variablen in der folgenden Datei:

Zu aktualisierende Datei: $HOME/vertex-oss-training/nemo_rl/configs/auth.sh

Wenn Sie Weights & Biases nicht verwenden möchten, setzen Sie logger.wandb_enabled in Ihrem Startskript auf False.

Schritt 2: Laden Sie die Containerdatei herunter oder kopieren Sie sie in Ihren Startordner.

Hier einige Beispiele:

gcloud storage cp \
  gs://vmds-containers-<region>/vmds_nemo_rl_squashfs/nemo_rl-h20260302.sqsh \
  $HOME/vertex-oss-training/nemo_rl/nemo_rl-h20260302.sqsh


# OR

/gcs/vmds-containers-<region>/vmds_nemo_rl_squashfs/nemo_rl-h20260302.sqsh \
  $HOME/vertex-oss-training/nemo_rl/nemo_rl-h20260302.sqsh

cd $HOME/vertex-oss-training/nemo_rl/

# Where region is either `us`, `asia`, or `europe`

Schritt 3: NeMo-RL-Repository vorbereiten oder klonen.

Erstellen Sie einen Klon des NeMo-RL-Codes, falls noch nicht vorhanden. Möglicherweise müssen Sie git submodule update --init --recursive verwenden, wenn Sie das Repository bereits ohne das Flag --recursive geklont haben.

git clone https://github.com/NVIDIA-NeMo/RL --recursive

Schritt 4: Trainingsjob starten

sbatch -N <num_nodes> launch.sh --cluster_type hcc-a3m --job_script algorithms/dpo.sh

Wobei:

  • --cluster-type wird basierend auf dem Clustertyp festgelegt:
    • A3-Mega: hcc-a3m
    • A3-Ultra: hcc-a3u
    • A4: hcc-a4
    • A3H: hcc-a3h
  • --partition sollte entsprechend festgelegt werden. Mit sinfo können die Slurm-Partitionen geprüft werden.

Nachdem der Job gestartet wurde, wird an Ihrem aktuellen Speicherort ein neues Verzeichnis erstellt, das nach der SLURM-Job-ID benannt ist. Darin finden Sie alle Logs und Prüfpunkte, die zu diesem Job gehören. Genauer gesagt finden Sie darin die folgenden Verzeichnisse und Dateien:

  • checkpoints/ → Dieses Verzeichnis wird im NeMo-RL-Container bereitgestellt und enthält alle Prüfpunkte aus dem Training.
  • ray-logs/: Dieses Verzeichnis enthält die Logs von Ray Head und Ray Workern.
  • nemo_rl_output.log: Diese Datei enthält die Slurm-Logs des eingereichten Jobs.
  • attach.sh (nur interaktive Jobs) → Dies ist ein Bash-Script, mit dem Sie eine Verbindung zu einem interaktiven Job herstellen können. Wenn Ihr Job erfolgreich gestartet wurde, kann es einige Minuten dauern, bis diese Datei erstellt wird.

Entwicklung mit NeMo-RL

Interaktive Einrichtung

Für die schnelle interaktive Entwicklung mit NeMo-RL stehen zwei Optionen zur Verfügung.

nemorlinteractive

Dies ist ein einfacher Hilfsbefehl, mit dem Sie einen GPU-Knoten aus dem Cluster auswählen können (z. B. Knotennummer 5). Anschließend werden Sie zu einem laufenden Container für NeMo-RL im ausgewählten Knoten weitergeleitet. Dieser Befehl ist für Workflows mit einem einzelnen Knoten hilfreich.

Damit Sie nemorlinteractive verwenden können, müssen Sie die folgenden Schritte ausführen:

  1. Geben Sie alle Authentifizierungstokens (z. B. HF und WandB) an, die in der Datei configs/auth.sh in den Job geladen werden sollen.
  2. Legen Sie die Umgebungsvariable CLUSTER_TYPE gemäß der folgenden Richtlinie fest:

    export CLUSTER_TYPE="hcc-a3m" # --> if you have A3-Mega cluster
    export CLUSTER_TYPE="hcc-a3u" # --> if you have A3-Ultra cluster
    export CLUSTER_TYPE="hcc-a4"  # --> If you have A4 cluster
    export CLUSTER_TYPE="hcc-a3h" # --> If you have A3H cluster
    
  3. Importieren Sie nemorlinteractive in Ihr Bash-Terminal, indem Sie die bash_utils.sh-Datei einbinden:

    source bash_utils.sh
    
  4. Führen Sie den Befehl nemorlinteractive aus: Beispiel:

    # Assuming you want to take the compute node number 5.
    nemorlinteractive 5
    

Interaktiver Start

Mit dieser Option können Sie Arbeitslasten interaktiv auf mehreren Rechenknoten ausführen. Interaktive Jobs eignen sich am besten für die Fehlerbehebung und Verifizierung. Diese Arbeitslasten reservieren den Knoten auf unbestimmte Zeit, bis der Entwickler entscheidet, dass das Debugging abgeschlossen ist und die Ressourcen freigegeben werden sollen.

Für diese Option müssen folgende Schritte ausgeführt werden:

Geben Sie in der Datei configs/auth.sh alle Authentifizierungstokens an, die Sie in den Job laden möchten (z. B. HF und WandB).

sbatch -N <num_nodes> launch.sh --cluster_type hcc-a3m --interactive
  • Warten Sie 2–5 Minuten. Dann sollte <job_id>/attach.sh erstellt sein.

  • Wenn Sie den Fortschritt des Starts überwachen möchten, prüfen Sie <job_id>/nemo_rl_output.log, um den Fortschritt des Startskripts zu sehen, und <job_id>/ray_logs/, um den Fortschritt des Starts von Ray Head und Workern zu sehen.

  • Stellen Sie eine Verbindung zum interaktiven Job her. Mit diesem Script können Sie die Verbindung wiederherstellen, auch wenn sie unterbrochen wird:

bash <job_id>/attach.sh

Nächste Schritte

Durch das Ausführen einer vordefinierten Arbeitslast wird der Betriebsstatus des Clusters überprüft. Im nächsten Schritt führen Sie Ihre eigene benutzerdefinierte Trainingsanwendung aus.