Allgemeine Einführung

DeepGEMM ist ein System von DeepSeek Die vom Team entwickelte Open-Source-Bibliothek FP8 GEMM (Generalised Matrix Multiplication) ist auf die effiziente Unterstützung von Matrixoperationen ausgerichtet. Sie wurde speziell für den Tensor Core der NVIDIA Hopper-Architektur entwickelt und unterstützt sowohl allgemeine Matrixoperationen als auch gruppierte GEMM-Operationen für gemischte Expertenmodelle (MoE). Die in CUDA geschriebene Bibliothek wird zur Laufzeit im Kernel kompiliert, wobei eine leichtgewichtige Just-In-Time (JIT)-Kompilierung verwendet wird. Dadurch entfällt die Notwendigkeit einer Vorkompilierung während der Installation und der Bereitstellungsprozess wird erheblich vereinfacht.DeepGEMM liefert eine herausragende Leistung bei gleichzeitiger Beibehaltung eines sauberen Codes und erreicht eine FP8-Berechnungsleistung von mehr als 1.350 TFLOPS auf Hopper-GPUs. DeepGEMM eignet sich nicht nur für das Training von Machine-Learning-Modellen und die Beschleunigung von Inferenzen, sondern ist aufgrund seines Open-Source-Charakters und seiner Zugänglichkeit auch eine hervorragende Ressource für das Erlernen der FP8-Matrixoptimierung.

Funktionsliste

-Unterstützt FP8-Matrix-OperationenFP8 Generalised Matrix Multiplication (GEMM): Bietet effiziente FP8 Generalised Matrix Multiplication (GEMM) für Hochleistungs-Computing-Szenarien.
-Optimierung des MoE-ModellsUnterstützung für gruppierte GEMM für hybride Expertenmodelle, die nur für die M-Achse gruppiert sind, wobei die Anpassungsexperten die gleiche Form der Szene teilen.
-Just-in-Time (JIT)-ZusammenstellungKompilieren Sie den Kernel zur Laufzeit, um ihn ohne Vorkompilierung an verschiedene Hardwareumgebungen anzupassen.
-Hochleistungsrechnen (HPC)FP8-Rechendurchsatz von über 1350 TFLOPS auf NVIDIA Hopper GPUs erreicht.
-Einfacher CodeentwurfEtwa 300 Zeilen Kerncode, leicht zu erlernen und sekundäre Entwicklung.
-hohe KompatibilitätEs unterstützt sowohl normales GEMM als auch Paket-GEMM mit Maske, was für verschiedene Inferenzszenarien geeignet ist.
-Quelloffen und kostenlosVeröffentlicht unter dem MIT-Protokoll für Forschung und kommerzielle Nutzung.

Hilfe verwenden

DeepGEMM ist eine Open-Source-Matrix-Arithmetik-Bibliothek für Entwickler, hauptsächlich für Benutzer mit grundlegenden CUDA-Programmier- und Machine-Learning-Kenntnissen. Im Folgenden finden Sie einen detaillierten Leitfaden, der Ihnen hilft, schnell loszulegen und die Bibliothek in Ihr Projekt zu integrieren.

Ablauf der Installation

DeepGEMM erfordert keinen komplexen Vorkompilierungsprozess und kann in wenigen Schritten installiert und die Laufzeitumgebung konfiguriert werden:
1.Vorbereitung der Umwelt::

• Systemanforderungen: Grafikprozessoren, die die NVIDIA Hopper-Architektur unterstützen (z. B. H100).
• Software-Abhängigkeiten: Installieren Sie CUDA Toolkit (empfohlene Version 11.8 oder höher) und Python (3.8+).
• Hardware-Unterstützung: Stellen Sie sicher, dass Ihr Gerät mit einem NVIDIA-Grafikprozessor mit mindestens 40 GB Videospeicher ausgestattet ist.
  2.Klon-Lager::
  Laden Sie das DeepGEMM-Repository lokal herunter, indem Sie den folgenden Befehl in einem Terminal ausführen:

git clone https://github.com/deepseek-ai/DeepGEMM.git**
cd DeepGEMM**

3. Installieren Sie die Abhängigkeit:
   Verwenden Sie die Python-Paketverwaltungswerkzeuge, um die erforderlichen Abhängigkeiten zu installieren:

pip install torch numpy

DeepGEMM selbst erfordert keine zusätzliche Kompilierung, da es sich auf On-the-fly-Kompilierungstechniken stützt und alle Kernel automatisch zur Laufzeit generiert werden.
4 Überprüfen Sie die Installation:
Führen Sie die mitgelieferten Testskripte aus, um sicherzustellen, dass die Umgebung korrekt konfiguriert ist:

python test/deep_gemm_test.py

Wenn die Ausgabe normale Ergebnisse der Matrixarithmetik zeigt, war die Installation erfolgreich.

Hauptfunktionen

1. grundlegende FP8-GEMM-Operationen durchführen

DeepGEMM bietet eine einfach zu bedienende Schnittstelle zur Durchführung von ungruppierten FP8-Matrixmultiplikationen:

• Betriebsverfahren:
  • Bibliotheken und Funktionen importieren:

Fackel importieren
von deep_gemm importieren gemm_fp8_fp8_bf16_nt

• Bereiten Sie die Eingabedaten vor (Matrizen A und B, müssen im FP8-Format sein):

A = torch.randn(1024, 512, dtype=torch.float8_e4m3fn).cuda()
B = torch.randn(512, 1024, dtype=torch.float8_e4m3fn).cuda()

• Rufen Sie die Funktion auf, um eine Matrixmultiplikation durchzuführen:

C = gemm_fp8_fp8_bf16_nt(A, B)
print(C)

• Vorbehalte:
  • Die Eingabematrix muss sich auf der GPU befinden und im FP8-Format (E4M3 oder E5M2) vorliegen.
  • Die Ausgabe erfolgt im BF16-Format, das sich für nachfolgende Berechnungen oder die Speicherung eignet.

2. die Gruppierung von GEMM zur Unterstützung des MoE-Modells

Für Benutzer, die mit MoE-Modellen arbeiten müssen, bietet DeepGEMM gruppierte GEMM-Unterstützung:

• Betriebsverfahren:
  • GEMM-Funktionen gruppieren importieren:

from deep_gemm import m_grouped_gemm_fp8_fp8_bf16_nt_contiguous

• Bereiten Sie die Eingabedaten für das kontinuierliche Layout vor:

A = torch.randn(4096, 512, dtype=torch.float8_e4m3fn).cuda() # Input-Splicing für mehrere Experten
B = torch.randn(512, 1024, dtype=torch.float8_e4m3fn).cuda()
group_sizes = [1024, 1024, 1024, 1024] # Die einzelnen Experten Token häufig

• Gruppe GEMM durchführen:

C = m_grouped_gemm_fp8_fp8_bf16_nt_contiguous(A, B, group_sizes)
print(C)

• Vorbehalte:
  • Die M-Achsen der Eingabematrix A müssen von Experten gruppiert werden, und die Größe jeder Gruppe muss an die GEMM M-Blockgröße (verfügbar) angepasst werden. get_m_alignment_for_contiguous_layout() (Zugang).
  • Die Achsen N und K der B-Matrix müssen feststehen.

3. die Maskengruppierung in der Inferenzphase GEMM

In der Inferenzdekodierungsphase unterstützt DeepGEMM gruppierte GEMM mit Masken für die dynamische Tokenzuweisung:

• Betriebsverfahren:
  • Importieren Sie die Maskengruppierungsfunktion:

from deep_gemm import m_grouped_gemm_fp8_fp8_bf16_nt_masked

• Bereiten Sie die Eingabedaten und die Maske vor:

A = torch.randn(4096, 512, dtype=torch.float8_e4m3fn).cuda()
B = torch.randn(512, 1024, dtype=torch.float8_e4m3fn).cuda()
mask = torch.ones(4096, dtype=torch.bool).cuda() # mask zeigt gültiges Token an

• Maskengruppierung GEMM durchführen:

C = m_grouped_gemm_fp8_fp8_bf16_nt_masked(A, B, mask)
print(C)

• Vorbehalte:
  • Masken werden verwendet, um anzugeben, welche Token berechnet werden müssen, und eignen sich für dynamische Schlussfolgerungen, wenn CUDA-Graphen aktiviert sind.

Ausgewählte Funktionen Bedienung Ablauf

Leistungsstarke Optimierung und Fehlersuche

Die Hauptstärke von DeepGEMM liegt in seiner Effizienz und Einfachheit, die Entwickler mit Hilfe der folgenden Schritte weiter optimieren und debuggen können:

• Leistungsdaten anzeigen:
  Hinzufügen von Protokollausgaben zur Überwachung von TFLOPS bei der Ausführung von Testskripten:

  importieren logging
  logging.basicConfig(level=logging.INFO)
  C = gemm_fp8_fp8_bf16_nt(A, B)
  

Anpassungsparameter*:
Passen Sie die Blockgröße (TMA-Parameter) an die spezifische Hardware an, um die Datenbewegung und die rechnerische Überlappung zu optimieren; siehe dazu das Beispiel im Ordner test/ in der Dokumentation.
Lernen und Erweiterung*:
Der Kerncode befindet sich in deep_gemm/gemm_kernel.cu, etwa 300 Zeilen, und kann von Entwicklern direkt gelesen und an die eigenen Anforderungen angepasst werden.
Empfehlungen für die Verwendung
Hardware-Voraussetzung*: Unterstützt derzeit nur NVIDIA Hopper-Architektur-GPUs, andere Architekturen sind noch nicht angepasst.
Hinweis auf die Dokumentation*: Ausführliche Funktionsbeschreibungen und Beispielcode finden Sie in den Ordnern README.md und test/ der GitHub-Repositories.
Unterstützung der Gemeinschaft*: Wenn Sie auf Probleme stoßen, können Sie auf der GitHub Issues-Seite Feedback einreichen und das DeepSeek-Team wird positiv darauf reagieren.
Mit diesen Schritten können Sie DeepGEMM einfach in Ihre Machine-Learning-Projekte integrieren und von der effizienten FP8-Matrix-Rechenleistung profitieren.