> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/grundlagen/multi-gpu-training-with-unsloth/ddp.md). # Multi-GPU-Feinabstimmung mit Distributed Data Parallel (DDP) Nehmen wir an, wir haben mehrere GPUs und möchten ein Modell mit allen feinabstimmen! Die direkteste Strategie hierfür ist Distributed Data Parallel (DDP), bei dem auf jeder GPU-Karte eine Kopie des Modells erstellt wird, jede Kopie während des Trainings unterschiedliche Proben aus dem Datensatz erhält und ihre Beiträge zu den Gewichtsupdates pro Optimizer-Schritt zusammengeführt werden. Warum sollten wir das tun? Wenn wir dem Trainingsprozess mehr GPUs hinzufügen, erhöhen wir die Anzahl der Proben, auf denen unsere Modelle pro Schritt trainieren, machen damit jedes Gradientenupdate stabiler und steigern unseren Trainingsdurchsatz mit jeder hinzugefügten GPU erheblich. Hier ist eine Schritt-für-Schritt-Anleitung, wie man das mit der Befehlszeilenschnittstelle (CLI) von Unsloth macht! **Hinweis:** Unsloth DDP funktioniert mit jedem Ihrer Trainingsskripte, nicht nur über unsere CLI! Weitere Details unten. #### Unsloth aus dem Quellcode installieren Wir klonen Unsloth von GitHub und installieren es. Bitte erwägen Sie die Verwendung einer [virtuellen Umgebung](https://docs.python.org/3/tutorial/venv.html); wir verwenden gern `uv venv –python 3.12 && source .venv/bin/activate`, aber jedes Werkzeug zur Erstellung virtueller Umgebungen ist geeignet. ```bash git clone https://github.com/unslothai/unsloth.git cd unsloth pip install . ``` #### Zielmodell und Datensatz für die Feinabstimmung auswählen In diesem Demo werden wir feinabstimmen [Qwen/Qwen3-8B](https://huggingface.co/Qwen/Qwen3-8B) auf dem [yahma/alpaca-cleaned](https://huggingface.co/datasets/yahma/alpaca-cleaned) Chat-Datensatz. Dies ist eine Supervised Fine-Tuning (SFT)-Aufgabe, die üblicherweise verwendet wird, um ein Basismodell an einen gewünschten Konversationsstil anzupassen oder die Leistung des Modells für eine nachgelagerte Aufgabe zu verbessern. ### Verwenden Sie die Unsloth-CLI! Zuerst schauen wir uns die Hilfemeldung an, die in die CLI eingebaut ist (wir haben hier an verschiedenen Stellen mit „...“ zur Kürze abgekürzt): {% code expandable="true" %} ```bash $ python unsloth-cli.py --help usage: unsloth-cli.py [-h] [--model_name MODEL_NAME] [--max_seq_length MAX_SEQ_LENGTH] [--dtype DTYPE] [--load_in_4bit] [--dataset DATASET] [--r R] [--lora_alpha LORA_ALPHA] [--lora_dropout LORA_DROPOUT] [--bias BIAS] [--use_gradient_checkpointing USE_GRADIENT_CHECKPOINTING] … 🦥 Feinabstimmen Ihres LLMs schneller mit unsloth! Optionen: -h, --help zeigt diese Hilfemeldung an und beendet das Programm 🤖 Modelloptionen: --model_name MODEL_NAME Zu ladender Modellname --max_seq_length MAX_SEQ_LENGTH Maximale Sequenzlänge, Standard ist 2048. Wir unterstützen intern automatisch RoPE-Scaling! intern! … 🧠 LoRA-Optionen: Diese Optionen werden zur Konfiguration des LoRA-Modells verwendet. --r R Rang für das LoRA-Modell, Standard ist 16. (gängige Werte: 8, 16, 32, 64, 128) --lora_alpha LORA_ALPHA LoRA-Alpha-Parameter, Standard ist 16. (gängige Werte: 8, 16, 32, 64, 128) … 🎓 Trainingsoptionen: --per_device_train_batch_size PER_DEVICE_TRAIN_BATCH_SIZE Batch-Größe pro Gerät während des Trainings, Standard ist 2. --per_device_eval_batch_size PER_DEVICE_EVAL_BATCH_SIZE Batch-Größe pro Gerät während der Auswertung, Standard ist 4. --gradient_accumulation_steps GRADIENT_ACCUMULATION_STEPS Anzahl der Schritte zur Gradientenakkumulation, Standard ist 4. … ``` {% endcode %} Das sollte Ihnen einen Eindruck davon geben, welche Optionen Sie der CLI für das Training Ihres Modells übergeben können! Für Multi-GPU-Training (DDP in diesem Fall) verwenden wir den [torchrun](https://docs.pytorch.org/docs/stable/elastic/run.html) Launcher, der es ermöglicht, mehrere verteilte Trainingsprozesse in Single-Node- oder Multi-Node-Setups zu starten. In unserem Fall konzentrieren wir uns auf den Single-Node-Fall (d. h. eine Maschine) mit zwei H100-GPUs. Prüfen wir auch den Status unserer GPUs mit dem `nvidia-smi` Kommandozeilenwerkzeug: {% code expandable="true" %} ```bash $ nvidia-smi Mon Nov 24 12:53:00 2025 +-----------------------------------------------------------------------------------------+ | NVIDIA-SMI 580.95.05 Treiberversion: 580.95.05 CUDA-Version: 13.0 | +-----------------------------------------+------------------------+----------------------+ | GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC | | Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. | | | | MIG M. | |=========================================+========================+======================| | 0 NVIDIA H100 80GB HBM3 On | 00000000:04:00.0 Off | 0 | | N/A 32C P0 69W / 700W | 0MiB / 81559MiB | 0% Default | | | | Disabled | +-----------------------------------------+------------------------+----------------------+ | 1 NVIDIA H100 80GB HBM3 On | 00000000:05:00.0 Off | 0 | | N/A 30C P0 68W / 700W | 0MiB / 81559MiB | 0% Default | | | | Disabled | +-----------------------------------------+------------------------+----------------------+ +-----------------------------------------------------------------------------------------+ | Prozesse: | | GPU GI CI PID Typ Prozessname GPU-Speicher | | ID ID Nutzung | |=========================================================================================| | Keine laufenden Prozesse gefunden | +-----------------------------------------------------------------------------------------+ ``` {% endcode %} Großartig! Wir haben wie erwartet zwei H100-GPUs. Beide zeigen 0MiB Speichernutzung, da wir derzeit nichts trainieren oder kein Modell im Speicher geladen ist. Um Ihren Trainingslauf zu starten, führen Sie einen Befehl wie den folgenden aus: {% code expandable="true" %} ```bash # erforderlich: # --model_name # --dataset # optional; experimentieren Sie mit diesen: # --learning_rate, --max_seq_length, --per_device_train_batch_size, --gradient_accumulation_steps, --max_steps # um das Modell am Ende des Trainings zu speichern: # --save_model torchrun --nproc_per_node=2 unsloth-cli.py \ --model_name=Qwen/Qwen3-8B \ --dataset=yahma/alpaca-cleaned \ --learning_rate=2e-5 \ --max_seq_length=2048 \ --per_device_train_batch_size=1 \ --gradient_accumulation_steps=4 \ --max_steps=1000 \ --save_model ``` {% endcode %} Wenn Sie mehr GPUs haben, können Sie `--nproc_per_node` entsprechend setzen, um sie zu nutzen. **Hinweis:** Sie können den `torchrun` Launcher mit jedem Ihrer Unsloth-Trainingsskripte verwenden, einschließlich der [Skripte](https://github.com/unslothai/notebooks/tree/main/python_scripts) aus unseren kostenlosen Colab-Notebooks konvertierten, und DDP wird automatisch aktiviert, wenn mit mehr als 1 GPU trainiert wird! Ein weiterer Blick auf `nvidia-smi` während das Training läuft: {% code expandable="true" %} ```bash $ nvidia-smi Mon Nov 24 12:58:42 2025 +-----------------------------------------------------------------------------------------+ | NVIDIA-SMI 580.95.05 Treiberversion: 580.95.05 CUDA-Version: 13.0 | +-----------------------------------------+------------------------+----------------------+ | GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC | | Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. | | | | MIG M. | |=========================================+========================+======================| | 0 NVIDIA H100 80GB HBM3 On | 00000000:04:00.0 Off | 0 | | N/A 38C P0 193W / 700W | 18903MiB / 81559MiB | 25% Default | | | | Disabled | +-----------------------------------------+------------------------+----------------------+ | 1 NVIDIA H100 80GB HBM3 On | 00000000:05:00.0 Off | 0 | | N/A 37C P0 199W / 700W | 18905MiB / 81559MiB | 28% Default | | | | Disabled | +-----------------------------------------+------------------------+----------------------+ +-----------------------------------------------------------------------------------------+ | Prozesse: | | GPU GI CI PID Typ Prozessname GPU-Speicher | | ID ID Nutzung | |=========================================================================================| | 0 N/A N/A 4935 C ...und/unsloth/.venv/bin/python3 18256MiB | | 0 N/A N/A 4936 C ...und/unsloth/.venv/bin/python3 630MiB | | 1 N/A N/A 4935 C ...und/unsloth/.venv/bin/python3 630MiB | | 1 N/A N/A 4936 C ...und/unsloth/.venv/bin/python3 18258MiB | +-----------------------------------------------------------------------------------------+ ``` {% endcode %} Wir sehen, dass beide GPUs nun etwa 19GB VRAM pro H100-GPU nutzen! Beim Blick in die Trainingslogs sehen wir, dass wir mit einer Rate von \~1,1 Iterationen/s trainieren können. Diese Trainingsgeschwindigkeit ist annähernd konstant, auch wenn wir mehr GPUs hinzufügen, sodass unser Trainingsdurchsatz ungefähr linear mit der Anzahl der GPUs steigt! ### Trainingsmetriken Wir führten einige kurze Rang-16-LoRA-Feinabstimmungen auf [unsloth/Llama-3.2-1B-Instruct](https://huggingface.co/unsloth/Llama-3.2-1B-Instruct) auf dem [yahma/alpaca-cleaned](https://huggingface.co/datasets/yahma/alpaca-cleaned) Datensatz durch, um den verbesserten Trainingsdurchsatz bei DDP-Training mit mehreren GPUs zu demonstrieren.
Die obige Abbildung vergleicht den Trainingsverlust zwischen zwei Llama-3.2-1B-Instruct LoRA-Feinabstimmungen über 500 Trainingsschritte, mit Single-GPU-Training (rosa) vs. Multi-GPU-DDP-Training (blau). Beachten Sie, dass die Verlustkurven in Skalierung und Trend übereinstimmen, aber ansonsten ein *wenig* anders sind, da *die Multi-GPU-Trainingsprozesse pro Schritt doppelt so viele Trainingsdaten verarbeiten*. Dies führt zu einer leicht unterschiedlichen Trainingskurve mit weniger Variabilität auf Schritt-für-Schritt-Basis.
Die obige Abbildung stellt den Trainingsfortschritt für dieselben beiden Feinabstimmungen dar. Beachten Sie, dass das Multi-GPU-DDP-Training eine Epoche der Trainingsdaten in halb so vielen Schritten durchläuft wie das Single-GPU-Training. Das liegt daran, dass jede GPU pro Schritt ein eigenes Batch (der Größe `per_device_train_batch_size`) verarbeiten kann. Allerdings ist die Zeit pro Schritt beim DDP-Training aufgrund der verteilten Kommunikation für die Modellgewichtsupdates etwas langsamer. Wenn Sie die Anzahl der GPUs erhöhen, wird der Trainingsdurchsatz weiterhin ungefähr linear zunehmen (jedoch mit einer kleinen, aber wachsenden Strafe für die verteilte Kommunikation). Diese gleichen Verhaltensweisen bezüglich Verlust und Trainingsepoche gelten auch für QLoRA-Feinabstimmungen, bei denen wir die Basismodelle in 4-Bit-Präzision geladen haben, um zusätzlichen GPU-Speicher zu sparen. Das ist besonders nützlich, um große Modelle mit begrenztem GPU-VRAM zu trainieren:
Vergleich des Trainingsverlusts zwischen zwei Llama-3.2-1B-Instruct QLoRA-Feinabstimmungen über 500 Trainingsschritte, mit Single-GPU-Training (orange) vs. Multi-GPU-DDP-Training (lila).
Vergleich des Trainingsfortschritts für dieselben beiden Feinabstimmungen. --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://unsloth.ai/docs/de/grundlagen/multi-gpu-training-with-unsloth/ddp.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.