LLM-Geschwindigkeitsbenchmark

GitHub-Repo des Projekts

Hintergrundgeschichte

Ich habe den LLM Speed Benchmark (LLMSB) während meiner Zeit als Teilzeit‑Engineering‑Praktikant bei Anarchy (YC W23) gebaut. LLMSB ist ein Benchmark‑Tool zur Bewertung der Leistung eines LLM‑Modells. Es verwendet die transformers-Bibliothek von HuggingFace zum Laden und Ausführen eines LLM‑Modells und misst:

  • Gesamtlaufzeit
  • Tokens pro Sekunde
  • Allgemeine Hardware‑Spezifikationen
  • CPU‑Auslastung (aktuelle Frequenz & Kern‑Auslastung % über die Zeit)
  • RAM‑Auslastung (RAM & Swap über die Zeit)
  • GPU‑Auslastung (Last, Speicherauslastung & Temperatur über die Zeit)

HIER ist ein Beispiel für einen Benchmark‑Durchlauf für das Modell codellama-13b-oasst-sft-v10, das auf einer H100 läuft. Ich besitze persönlich eine Nvidia RTX 2070 Ti mit 8 GB VRAM. Leider reicht für die meisten modernen LLM‑Modelle 8 GB VRAM nicht aus, um ein Modell zu betreiben. Deshalb habe ich RunPod verwendet, um GPU(s) zu „mieten“ und meine Benchmarks auf bestimmten Modellen auszuführen.

Dies war die Hintergrund‑/Entstehungsgeschichte von LLMSB. Da das Projekt Open‑Source ist, kannst du den Code HIER einsehen. Unten habe ich die README aus dem Repository eingefügt, falls du sie dir ansehen möchtest.

Über

🚧 LLM Speed Benchmark (LLMSB) befindet sich derzeit in der Beta (v0). Bitte verwende dies nicht in der Produktion oder nutze es auf eigenes Risiko. Wir arbeiten noch an einigen Feinheiten und verbessern die Funktionalität. Wenn du Bugs findest oder Vorschläge hast, melde sie bitte unter ISSUES. Dein Feedback ist von unschätzbarem Wert!

LLM Speed Benchmark (LLMSB) ist ein Benchmark‑Tool zur Bewertung der Leistung von LLM‑Modellen über verschiedene Hardware‑Plattformen hinweg. Sein ultimatives Ziel ist es, einen umfassenden Datensatz zu erstellen, der die Leistung von LLM‑Modellen auf verschiedenen Systemen detailliert beschreibt, sodass Nutzer*innen leichter das/die passende(n) LLM‑Modell(e) für ihre Projekte auswählen können.

Einschränkungen

LLMSB befindet sich in Version 0 und hat daher Einschränkungen:

  • Nur für Debian‑basierte Betriebssysteme konzipiert, d. h. nicht für Windows. Das liegt daran, dass LLMSB intern neofetch und nvidia-smi zur Datenerfassung nutzt und die Pfad‑Logik auf Unix‑Systemen basiert.
  • Aufgrund der Art, wie Metriken erfasst werden, kann der Metrik‑Collector bis zu 1 Sekunde für eine Erfassung benötigen. Das bedeutet, dass wir im besten Fall alle 1 Sekunde Hardware‑Metriken sammeln können.
  • LLMSB verwendet ausschließlich HuggingFace zum Laden und Ausführen von Modellen. Das funktioniert momentan, aber das Ziel ist, LLMSB mehrere Frameworks unterstützen zu lassen, nicht nur HuggingFace.
  • Derzeit werden alle Modelle über die Logik in der Funktion run_llm() in src/hf.py ausgeführt, wobei die Funktionen AutoTokenizer() und AutoModelForCausalLM() zum Laden und Ausführen eines Modells verwendet werden. Das funktioniert, schränkt aber die Konfiguration/Optimierung einzelner Modelle ein. Deshalb soll künftig für jedes populäre Modell eine eigene Klasse erstellt werden, die HuggingFaces modell‑spezifische Klassen wie LlamaTokenizer und LlamaForCausalLM nutzt.
  • LLMSB sammelt nur allgemeine, hoch‑level Metriken. In Zukunft möchten wir auch niedrig‑level Metriken erfassen. Wir denken, dass dies teilweise über den Profiler‑Wrapper von PyTorch realisierbar ist.

Beispielausgaben

22. November 2023

LLMSB wurde auf einer L40‑ und H100‑GPU über RunPod getestet. In diesen Benchmarks wurden die Modelle llama-2-7b-hf, codellama-13b-oasst-sft-v10 und mpt-7b geprüft. Sieh dir die Ergebnisse HIER an. Sollten Fehler/Probleme auftreten, melde sie bitte über ISSUES.

Einrichtung

  1. Erstelle und aktiviere eine Python‑Umgebung:

    python3 -m venv env
source env/bin/activate

  2. Installiere Paket‑Abhängigkeiten (mit APT):

    apt -y update
apt install -y vim
apt install -y neofetch

  3. Installiere Python‑Abhängigkeiten:

    pip3 install transformers
pip3 install psutil
pip3 install gputil
pip3 install tabulate
pip3 install sentencepiece
pip3 install protobuf

  4. Installiere Pytorch

    # install pytorch stable build, for linux, using CUDA 12.1:
pip3 install torch torchvision torchaudio

  5. Installiere LLM-VM:

    pip install llm-vm

  6. (optional) Wenn du Modelle wie LLAMA nutzt, benötigst du ein HuggingFace‑Zugriffstoken. Richte dein Zugriffstoken HIER ein und speichere es in deiner Konsole, indem du folgenden Befehl ausführst:

    huggingface-cli login

Wie man ausführt

  1. Schließe die im Abschnitt Einrichtung aufgeführten Schritte ab.

  2. Um dein Set zu konfigurieren, musst du eine JSON‑Datei mit den folgenden Parametern erstellen (hier ein Beispiel):

    • HINWEIS: Nicht jedes Framework unterstützt dieselben Parameter
    {
  "model": "bigscience/bloom-560m",   # Pfad/Repo des Modells auf HuggingFace (https://huggingface.co/models)
  "prompt": "Hello World!",           # Der Prompt, den du dem LLM‑Modell übergeben möchtest
  "device": "cuda:0",                 # Das Gerät, auf dem das LLM‑Modell laufen soll (GPU/CPU)
  "max_length": 50,                   # Maximale Länge der generierten Tokens
  "temperature": 0.9,                 # Temperaturwert für das LLM‑Modell
  "top_k": 50,                        # top‑k‑Wert für das LLM‑Modell
  "top_p": 0.9,                       # top‑p‑Wert für das LLM‑Modell
  "num_return_sequences": 1,          # Anzahl der unabhängig ausgeführten Instanzen des Modells
  "time_delay": 0,                    # Zeitverzögerung (Sekunden), die der Metrik‑Collector pro Iteration wartet
  "model_start_pause": 1,             # Zeit (Sekunden), die der Test VOR dem Start des LLM‑Modells wartet
  "model_end_pause": 1                # Zeit (Sekunden), die der Test NACH dem Abschluss des LLM‑Modells wartet,
  "framework": "llm-vm"               # Name des Frameworks/der Bibliothek, die du zum Ausführen des Modells verwenden möchtest
}

  3. Verwende den Pfad zur Konfigurationsdatei aus dem vorherigen Schritt und führe Folgendes aus, um den Benchmark zu starten (wähle eine Option):

    # einen Benchmark ausführen
python3 run.py --config ./configs/llmvm_test.json

# mehr als einen Benchmark ausführen (in diesem Fall 3)
python3 run.py --config ./configs/llmvm_test.json --loops 3

  4. Nachdem der Benchmark abgeschlossen ist, sieh dir die endgültigen Ergebnisse in einer Datei an, die etwa so aussieht:

    report_2023-11-25_05:55:04.207515_utc_1ffc4fa7-3aa9-4878-b874-1ff445e1ff8a.json

RunPod einrichten:

  1. Richte RunPod ein, konfiguriere dein SSH‑Zertifikat/‑Schlüssel und starte einen Pod. Du kannst deine Pods auf der RunPod‑Konsolenseite erreichen.

  2. Klicke auf die Schaltfläche „Connect“, um die SSH‑Verbindungsinformationen zu erhalten. Diese Informationen sehen etwa so aus:

    ssh root&12.345.678.90 -p 12345 -i ~/.ssh/id_example

    • Dieser Befehl wird folgendermaßen formatiert:

      ssh <user>@<ip-address> -p <port> -i <local-path-to-ssh-cert>

  3. Mit dem Befehl aus Schritt #2 solltest du dich per SSH in den Pod einloggen und die GPU nutzen können, die du in diesem RunPod‑Pod ausgewählt hast.

  4. Wenn du eine Datei vom Pod auf deine lokale Maschine kopieren möchtest, führe einen Befehl in diesem Format aus (bezogen auf die Variablen aus Schritt #2):

    scp -P <port> -i <local-path-to-ssh-cert> <user>@<ip-address>:<path-to-file-in-pod> <path-to-local-directory>

    • Hier ein Beispiel für einen solchen Befehl:

      scp -P 12345 -i ~/.ssh/id_example <user>@<ip-address>:/root/test.txt /home/user1/Downloads/

  5. Nachdem du mit dem Pod fertig bist, fahre ihn herunter oder pausiere ihn. Hinweis: Wenn du ihn pausierst, werden weiterhin Kosten berechnet, jedoch deutlich weniger.

Großartige Quellen: