Du bist in einem ML Engineer Vorstellungsgespräch bei Google. Interviewer: Wir müssen ein LLM über 1.000 GPUs trainieren. Wie würdest du sicherstellen, dass alle GPUs teilen, was sie gelernt haben? Du: Verwende einen zentralen Parameter-Server, um die Gewichte zu aggregieren und neu zu verteilen. Interview vorbei. Hier ist, was du verpasst hast:

Ein großes Laufzeitengpass beim Training mit mehreren GPUs tritt während der GPU-Synchronisation auf. Zum Beispiel beim Training mit mehreren GPUs über Datenparallelismus: - Das gleiche Modell wird auf verschiedene GPUs verteilt. - Jede GPU verarbeitet eine andere Teilmenge des gesamten Datensatzes. Überprüfen Sie das 👇

Dies führt zu unterschiedlichen Gradienten auf verschiedenen Geräten. Bevor wir die Modellparameter auf jedem GPU-Gerät aktualisieren, müssen wir die Gradienten an alle anderen Geräte kommunizieren, um sie zu synchronisieren. Lass uns als Nächstes 2 gängige Strategien verstehen!

Algorithmus 1) All-reduce Eine offensichtliche Methode besteht darin, die Gradienten von einem Gerät an alle anderen Geräte zu senden, um sie zu synchronisieren. Aber das nutzt hohe Bandbreite. Wenn jede GPU "N" Elemente hat und es "G" GPUs gibt, ergibt sich ein Gesamttransfer von G*(G-1)*N Elementen 👇

Wir können dies optimieren, indem wir alle Elemente auf eine GPU übertragen, den endgültigen Wert berechnen und ihn an alle anderen GPUs zurücksenden. Das ist eine erhebliche Verbesserung. Aber jetzt muss eine einzelne GPU die Gradienten empfangen, berechnen und zurückkommunizieren, sodass dies nicht skalierbar ist.

Algorithmus 2) Ring-Reduzierung Phase #1) Share-Reduzierung Zuerst werden die Gradienten auf jeder GPU in G Segmente unterteilt (G = Gesamtzahl der GPUs). Überprüfen Sie dies 👇

In einer Iteration sendet jede GPU ein Segment an die nächste GPU: - GPU1 sendet a₁ an GPU2, wo es zu b₁ addiert wird - GPU2 sendet b₂ an GPU3, wo es zu c₂ addiert wird - GPU3 sendet c₃ an GPU4, wo es zu d₃ addiert wird - GPU4 sendet d₄ an GPU1, wo es zu a₄ addiert wird Überprüfen Sie dies 👇

Dieser Prozess wird erneut durchgeführt: - GPU1 sendet (d₄+a₄) an GPU2, wo es zu b₄ addiert wird. - GPU2 sendet (a₁+b₁) an GPU3, wo es zu c₁ addiert wird. - GPU3 sendet (b₂+c₂) an GPU4, wo es zu d₂ addiert wird. - GPU4 sendet (c₃+d₃) an GPU1, wo es zu a₃ addiert wird. Überprüfen Sie dies 👇

In der letzten Iteration werden die folgenden Segmente an die nächste GPU übertragen. Dies führt zu einem Zustand, in dem jede GPU ein ganzes Segment hat, und wir können diese kompletten Segmente an alle anderen GPUs übertragen. Überprüfen Sie dies 👇

Phase #2) Nur teilen Jetzt, da jede GPU ein ganzes Segment hat, können wir diese kompletten Segmente an alle anderen GPUs übertragen. Der Prozess wird ähnlich durchgeführt wie das, was wir oben besprochen haben, daher werden wir nicht ins Detail gehen. Iteration 1 ist unten dargestellt👇

Als Nächstes führen wir die Iterationen 2 und 3 durch. Diese werden ähnlich durchgeführt wie das, was wir in Phase 1 gelernt haben. Überprüfe das 👇

Und da hast du es! Die Modellgewichte wurden über die GPUs synchronisiert. Während die insgesamt übertragenen Elemente immer noch die gleichen sind wie bei unserem „Single-GPU-Master“-Ansatz, ist dieser Ringansatz viel skalierbarer, da er die gesamte Last nicht auf eine GPU legt. Überprüfe das 👇

Standardmäßig nutzen Deep-Learning-Modelle nur eine einzelne GPU für das Training, selbst wenn mehrere GPUs verfügbar sind. Eine ideale Möglichkeit, Modelle zu trainieren, besteht darin, die Trainingslast auf mehrere GPUs zu verteilen. Die Grafik zeigt vier Strategien für das Training mit mehreren GPUs👇