Chitu (Red Rabbit): Ein hochleistungsfähiges Reasoning-Framework für große Sprachmodelle, vorgestellt vom Tsinghua-Team

Allgemeine Einführung

Chitu ist ein vom PACMAN-Team an der Tsinghua-Universität entwickeltes Open-Source-Framework mit dem Namen "Red Rabbit", das speziell für die Ausführung großer Sprachmodelle konzipiert ist. Chitu unterstützt eine Vielzahl von Hardware, wie NVIDIAs GPUs und einheimische Chips, und kann von Einzelplatzrechnern bis hin zu großen Clustern verwendet werden.Das Highlight ist die Inferenz mit FP8-Modellen, die die Kosten drastisch senken kann, wie z. B. die Ausführung von DeepSeek-671B auf einem A800, der die Hälfte der GPUs benötigt und mehr als dreimal schneller ist als vLLM.Der Code ist auf GitHub öffentlich zugänglich und kann von Unternehmen oder Einzelpersonen kostenlos heruntergeladen und verwendet werden. Es handelt sich um ein sofort einsatzbereites Tool für Produktionsumgebungen und eignet sich für Teams, die Geld sparen wollen, aber auch Wert auf Leistung legen.

Funktionsliste

• Es unterstützt FP8- und BF16-Modellinferenz und kann auf alten GPUs und einheimischen Chips mit geringen Kosten und hoher Leistung laufen.
• Passt sich an eine breite Palette von Hardware an, von reinen CPUs über GPUs wie NVIDIA A800, H20 usw. bis hin zu großen Clustern.
• Optimieren Sie die Inferenzgeschwindigkeit mit CUDA Graph für eine schnellere Ausgabe in einer einzigen Anfrage.
• Bietet eine Serviceschnittstelle, über die Modelle direkt über HTTP-Anfragen aufgerufen werden können.
• Unterstützt verteiltes Reasoning mit mehreren Knoten, geeignet für die Verarbeitung großer Mengen von Aufgaben.
• Offener Quellcode, den Unternehmen nach Bedarf ändern oder optimieren können.

Hilfe verwenden

Ablauf der Installation

Die Installation von Chitu ist nicht kompliziert, erfordert aber einige Vorbereitungen. Nachfolgend finden Sie die detaillierten Schritte:

1. Vorbereiten der Umgebung
   • System: Ubuntu 22.04 empfohlen, Rechner mit NVIDIA GPU (z.B. A800 oder H20).
   • Software: Installieren Sie Git, Python 3.10, CUDA 12.1 (angepasst an Ihre GPU-Version), PyTorch 2.1.
   • Beispiel für einen Befehl:

     sudo apt update && sudo apt install -y git python3.10 python3-pip
     pip install -U torch==2.1 --index-url https://download.pytorch.org/whl/cu121
     

2. Code herunterladen
   • Klonen Sie den Code von Chitu lokal mit Git:

     git clone --recursive https://github.com/thu-pacman/chitu
     cd chitu
     

3. Installation von Abhängigkeiten
   • Installieren Sie die erforderlichen Python-Pakete und die Kompilierungsumgebung:

     pip install -r anforderungen-build.txt
     pip install flash-attn
     

4. kompilieren und installieren
   • Stellen Sie die Kompilierungsparameter ein (passen Sie TORCH_CUDA_ARCH_LIST entsprechend Ihrer GPU an, z. B. 8.0 für A800) und kompilieren Sie:

     TORCH_CUDA_ARCH_LIST=8.0 CHITU_SETUP_JOBS=4 MAX_JOBS=4 pip install --no-build-isolation .
     

5. Überprüfung der Installation
   • Führen Sie einen Test durch, um sicherzustellen, dass es in Ordnung ist:

     torchrun --nproc_per_node 1 test/single_req_test.py
     

Wie zu verwenden

Sobald Chitu geladen ist, können Sie den Dienst über die Befehlszeile starten oder einen einzelnen Test durchführen. So geht's:

Argumentationsdienst einleiten

1. Modellpfade konfigurieren
   • Bereiten Sie die Modelldateien, z. B. DeepSeek-R1, in einem lokalen Verzeichnis (z. B. /data/DeepSeek-R1).
   • im Bearbeitungsbefehl models.ckpt_dir Der Parameter zeigt auf den Modellpfad.
2. Neue Dienste
   • Starten Sie den eigenständigen Dienst mit torchrun, der auf Port 21002 lauscht:

     export WORLD_SIZE=1
     torchrun --nproc_per_node 1 chitu/serve.py \
     serve.port=21002 \
     models=DeepSeek-R1 \\
     models.ckpt_dir=/data/DeepSeek-R1 \
     infer.use_cuda_graph=True \
     request.max_new_tokens=100
     

3. Test-Dienstleistungen
   • Senden Sie eine Anfrage mit curl und prüfen Sie, ob das Modell ordnungsgemäß antwortet:

     curl localhost:21002/v1/chat/completions \
     -H "Content-Type: application/json" \
     -d '{"messages": [{"role": "user", "content": "Hallo, was ist Chitu?"}]}'
     

   • Das Rückgabeergebnis liegt im JSON-Format vor und enthält die Antwort des Modells.

Durchführung eines einzelnen Reasoning-Tests

• Wenn Sie den Dienst nicht starten wollen, können Sie nur die Modellausgabe testen:

  torchrun --nproc_per_node 1 test/single_req_test.py \
  models=DeepSeek-R1 \\
  models.ckpt_dir=/data/DeepSeek-R1 \
  request.max_new_tokens=64

• Die Ausgabe wird im Terminal angezeigt und gibt Auskunft darüber, was das Modell erzeugt hat.

Verteiltes Rechnen mit mehreren Knoten

1. Mehrere Maschinen vorbereiten
   • Stellen Sie sicher, dass Chitu und Abhängigkeiten auf jedem Rechner geladen sind und dass die Modelldateien auf einem gemeinsamen Speicher liegen.
2. Verteilte Dienste starten
   • Führen Sie es auf 2 Rechnern mit je 8 GPUs aus:

     torchrun --nnodes 2 --nproc_per_node 8 test/single_req_test.py \
     request.max_new_tokens=64 \
     infer.pp_size=2 \
     infer.tp_size=8 \\
     models=DeepSeek-R1 \ \
     models.ckpt_dir=/data/DeepSeek-R1
     

3. Überprüfen Sie die Wirkung
   • Nach einem Multi-Node-Lauf ist die Ausgabe schneller als bei einem einzelnen Rechner, was für die Bearbeitung großer Mengen von Anfragen geeignet ist.

Featured Function Bedienung

Sparen Sie Geld und Geschwindigkeit mit den FP8-Modellen

• Chitu unterstützt Modelle im FP8-Format, die weniger GPUs benötigen und schneller sind als BF16.
• Vorgang: Beim Start hinzufügen infer.soft_fp8=TrueWenn das Modell z.B. im FP8-Format ist, sollte es auch im FP8-Format sein. Zum Beispiel:

  torchrun --nproc_per_node 1 chitu/serve.py \
  serve.port=21002 \
  models=DeepSeek-R1 \\
  models.ckpt_dir=/data/DeepSeek-R1 \
  infer.soft_fp8=True
  

Beschleunigt mit CUDA Graph

• Einzelne Anfragen können mit CUDA Graph beschleunigt werden, indem man den Parameter infer.use_cuda_graph=True.
• Testeffekt: Führen Sie eine einzelne Schlussfolgerung durch und vergleichen Sie den Geschwindigkeitsunterschied mit und ohne den Zusatz.

Leistungsprüfung

• Chitu verfügt über Benchmarking-Tools zur Messung von Durchsatz und Latenz:

  python benchmarks/benchmark_serving.py \
  --model "Tiefensuche-r1" \
  --iterations 10 \
  --seq-len 10 \
  --base-url http://localhost:21002
  

• Das Ergebnis zeigt die Anzahl der Token Zahlen, die Ihnen helfen, Ihre Zuweisung zu optimieren.

caveat

• Wenn Sie mehrere Knoten verwenden, muss das Netz stabil sein, sonst bricht es zusammen.
• Unzureichender GPU-Speicher kann zu einem OOM-Fehler führen, senken Sie ihn. infer.max_seq_len oder mit weniger Knotenpunkten.
• Die Unterstützung für Inlandschips ist noch in der Optimierungsphase, möglicherweise muss der Code geändert werden, um sich anzupassen.

Chitu ist nicht schwer zu benutzen, folgen Sie einfach den Schritten und Sie werden sofort loslegen können. Die Dokumentation und die Community sind ebenfalls auf GitHub zu finden, so dass Sie bei Fragen eine Anfrage stellen können.