Benchmarken lokaler LLM-Modelle

GitHub-Repository des Projekts

Hintergrundgeschichte

Ich habe LLM Speed Benchmark (LLMSB) während meiner Zeit als Teilzeit-Ingenieurpraktikant bei Anarchy (YC W23) entwickelt. LLMSB ist ein Benchmarking-Tool zur Bewertung der Leistung eines LLM-Modells. Es verwendet HuggingFaces transformers-Bibliothek zum Laden und Ausführen eines LLM-Modells und misst:

  • Gesamtlaufzeit
  • Token pro Sekunde
  • allgemeine Hardwarespezifikationen
  • CPU-Auslastung (aktuelle Frequenz & prozentuale Auslastung der Kerne ü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-Lauf des codellama-13b-oasst-sft-v10-Modells, das auf einer H100 ausgeführt wurde. Ich besitze persönlich eine Nvidia RTX 2070 Ti, die über 8 GB VRAM verfügt. Leider reichen 8 GB VRAM für die meisten modernen LLM-Modelle nicht aus, um mit einem Modell zu arbeiten. Deshalb habe ich RunPod verwendet, um GPU(s) zu „mieten“ und meine Benchmarks auf bestimmten Modellen auszuführen.

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

Über

🚧 LLM Speed Benchmark (LLMSB) befindet sich derzeit in Beta (v0). Bitte verwende dies nicht in der Produktion oder auf eigenes Risiko. Wir sind noch dabei, einige Probleme auszubügeln und die Funktionalität zu verbessern. Wenn du auf Fehler stößt oder Vorschläge hast, melde sie bitte unter ISSUES. Dein Feedback ist von unschätzbarem Wert!

LLM Speed Benchmark (LLMSB) ist ein Benchmarking-Tool zur Bewertung der Leistung von LLM-Modellen auf verschiedenen Hardwareplattformen. Sein oberstes Ziel ist es, einen umfassenden Datensatz zusammenzustellen, der die Leistung von LLM-Modellen auf verschiedenen Systemen beschreibt, sodass Benutzer das richtige/n LLM-Modell(e) für ihre Projekte effektiver auswählen können.

Einschränkungen

LLMSB ist in v0, daher hat es Einschränkungen:

  • Es ist nur für die Ausführung auf Debian-basierten Betriebssystemen ausgelegt, also ist es nicht für Windows gedacht. Das liegt daran, dass LLMSB unter der Haube neofetch und nvidia-smi verwendet, um Metriken zu erfassen, und die Pfadlogik auf Unix-Betriebssystemen basiert.
  • Aufgrund der Art und Weise, wie Metriken aufgezeichnet werden, kann es bis zu 1 Sekunde dauern, bis der Metrik-Sammler eine Erfassung durchführt. Das bedeutet, dass wir hardwarebezogene Metriken im schnellsten Fall alle 1 Sekunde erfassen können.
  • LLMSB verwendet zum Laden und Ausführen von Modellen nur HuggingFace. Das funktioniert im Moment, aber das Ziel ist es, dass LLMSB mehrere Frameworks unterstützt, nicht nur HuggingFace.
  • Derzeit werden alle Modelle über die in der Funktion run_llm() dargestellte Logik ausgeführt, die sich in src/hf.py befindet, wobei die Funktionen AutoTokenizer() und AutoModelForCausalLM() verwendet werden, um ein Modell zu laden und auszuführen. Das funktioniert, schränkt aber ein, wie wir bestimmte Modelle konfigurieren/optimieren können. In Anbetracht dessen ist das Ziel, separate Klassen für jedes beliebte Modell zu erstellen und stattdessen HuggingFaces modellspezifische Klassen wie LlamaTokenizer & LlamaForCausalLM zu nutzen.
  • LLMSB erfasst nur allgemeine, hochstufige Metriken. In Zukunft möchten wir niedrigstufigere Metriken erfassen. Wir glauben, dass dies teilweise mithilfe von PyTorchs Profiler-Wrapper erfolgen kann.

Beispielausgaben

22. November 2023

LLMSB wurde auf einer L40- und H100-GPU über RunPod ausgeführt/getestet. In diesen Benchmarks wurden die Modelle llama-2-7b-hf, codellama-13b-oasst-sft-v10 und mpt-7b getestet. Die Ergebnisse findest du HIER. Wenn Fehler/Probleme bemerkt werden, melde sie bitte an ISSUES.

Einrichtung

  1. Erstelle und aktiviere die Python-Umgebung:

    python3 -m venv env
source env/bin/activate

  2. Installiere Paketabhängigkeiten (unter Verwendung von 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 verwendest, benötigst du ein HuggingFace-Zugriffstoken. Richte dein Zugriffstoken HIER ein und speichere dein Token dann mit dem folgenden Befehl in deiner Konsole:

    huggingface-cli login

Ausführen

  1. Führe die im Abschnitt Einrichtung aufgeführten Schritte aus.

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

    • HINWEIS: Nicht jedes Framework unterstützt dieselben Parameter
    {
  "model": "bigscience/bloom-560m",   # the model's path/repo on HuggingFace (https://huggingface.co/models)
  "prompt": "Hello World!",           # the prompt you want to input into the LLM model
  "device": "cuda:0",                 # the device you want to run the LLM model on (GPU/CPU)
  "max_length": 50,                   # the maximun length of the generated tokens
  "temperature": 0.9,                 # temperatue value for the LLM model
  "top_k": 50,                        # top-k value for the LLM model
  "top_p": 0.9,                       # top-p value for the LLM model
  "num_return_sequences": 1,          # the number of independently ran instances of the model
  "time_delay": 0,                    # the time delay (seconds) the metrics-collecter will wait per interation
  "model_start_pause": 1,             # the time (seconds) the test will wait BEFORE running the LLM model
  "model_end_pause": 1                # the time (seconds) the test will wait AFTER the LLM model is done running,
  "framework": "llm-vm"               # the name of the framework/library you want to use to run the model
}

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

    # run one benchmark
python3 run.py --config ./configs/llmvm_test.json

# run more then one benchmark (in this case 3)
python3 run.py --config ./configs/llmvm_test.json --loops 3

  4. Nachdem der Benchmark fertig ausgeführt wurde, sieh dir die Endergebnisse in einer Datei an, die ungefähr so aussehen sollte:

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

RunPod einrichten:

  1. Richte RunPod ein, richte dein SSH-Zertifikat/Schlüssel ein und starte einen Pod. Du kannst auf deine(n) Pod(s) auf der RunPod-Console-Seite zugreifen.

  2. Klicke auf die Schaltfläche “Connect”, um die SSH-Verbindungsinformationen zu erhalten. Diese Informationen sollten ungefähr so aussehen:

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

    • Dieser Befehl würde so formatiert sein:

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

  3. Mit dem Befehl aus Schritt #2 solltest du dich per SSH mit dem Pod verbinden und die GPU verwenden können, die du in diesem RunPod-Pod ausgewählt hast.

  4. Wenn du eine Datei vom Pod auf deinen lokalen Rechner kopieren möchtest, würdest du einen Befehl in diesem Format verwenden (dies bezieht sich auf die in Schritt #2 gezeigten Variablen):

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

    • Hier ist 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. Aber Achtung: Wenn du ihn pausierst, werden dir weiterhin Kosten berechnet, nur deutlich weniger.

Gute Quellen: