Benchmark de Vitesse LLM

Dépôt GitHub du projet

Contexte

J’ai créé LLM Speed Benchmark (LLMSB) pendant mon stage à temps partiel d’ingénieur chez Anarchy (YC W23). LLMSB est un outil de benchmark pour évaluer les performances d’un modèle LLM. Il utilise la bibliothèque transformers de HuggingFace pour charger et exécuter un modèle LLM et il mesure :

  • temps d’exécution total
  • tokens par seconde
  • spécifications matérielles générales
  • utilisation du CPU (fréquence actuelle & pourcentage d’utilisation des cœurs au fil du temps)
  • utilisation de la RAM (RAM & swap au fil du temps)
  • utilisation du GPU (charge, utilisation de la mémoire, & température au fil du temps)

ICI est un exemple d’exécution de benchmark pour le modèle codellama-13b-oasst-sft-v10 fonctionnant sur un H100. Je possède personnellement un Nvidia RTX 2070 Ti, qui dispose de 8 Go de VRAM. Malheureusement, pour la plupart des modèles LLM modernes, 8 Go de VRAM ne suffisent pas pour charger un modèle. À cause de cela, j’ai utilisé RunPod pour « louer » des GPU et exécuter mes benchmarks sur certains modèles.

Cela était l’historique/origine de LLMSB. Puisque le projet est open-source, vous pouvez voir le code ICI. Ci-dessous, j’ai inclus le README du dépôt si vous voulez le consulter.

À propos

🚧 LLM Speed Benchmark (LLMSB) est actuellement en version bêta (v0). Veuillez ne pas l’utiliser en production, ou utilisez-le à vos propres risques. Nous corrigeons encore quelques problèmes et améliorons les fonctionnalités. Si vous rencontrez des bugs ou avez des suggestions, veuillez les signaler sous ISSUES. Vos retours sont inestimables!

LLM Speed Benchmark (LLMSB) est un outil de benchmark pour évaluer les performances des modèles LLM sur différentes plateformes matérielles. Son objectif ultime est de compiler un ensemble de données complet détaillant les performances des modèles LLM sur divers systèmes, permettant aux utilisateurs de choisir plus efficacement le(s) bon(s) modèle(s) LLM pour leurs projets.

Limitations

LLMSB est en version v0, il a donc des limitations :

  • Conçu uniquement pour fonctionner sur des systèmes d’exploitation basés sur Debian, c’est-à-dire qu’il n’est pas conçu pour fonctionner sous Windows. Cela est dû au fait que LLMSB utilise neofetch et nvidia-smi pour collecter les métriques en interne et que la logique des chemins de fichiers est basée sur les systèmes Unix.
  • En raison de la façon dont les métriques sont enregistrées, le collecteur de métriques peut prendre jusqu’à 1 seconde pour effectuer une collecte. Cela signifie qu’au mieux, nous pouvons collecter les métriques matérielles toutes les 1 seconde.
  • LLMSB n’utilise que HuggingFace pour charger et exécuter les modèles. Cela fonctionne pour l’instant, mais l’objectif est que LLMSB prenne en charge plusieurs frameworks, pas seulement HuggingFace.
  • Actuellement, tous les modèles sont exécutés via la logique présentée dans la fonction run_llm() située dans src/hf.py, où les fonctions AutoTokenizer() et AutoModelForCausalLM() sont utilisées pour charger et exécuter un modèle. Cela fonctionne mais limite la façon dont nous pouvons configurer/optimiser des modèles spécifiques. En sachant cela, l’objectif est de créer des classes séparées pour chaque modèle populaire et d’utiliser les classes spécifiques de modèle de HuggingFace, comme LlamaTokenizer et LlamaForCausalLM, à la place.
  • LLMSB ne collecte que des métriques générales, de haut niveau. À l’avenir, nous aimerions recueillir des métriques de niveau inférieur. Nous pensons que cela peut être partiellement réalisé en utilisant le wrapper de profilage de Pytorch.

Exemples de Sorties

22 novembre 2023

LLMSB a été exécuté/testé sur des GPU L40 et H100 via RunPod. Dans ces benchmarks, les modèles llama-2-7b-hf, codellama-13b-oasst-sft-v10 et mpt-7b ont été testés. Consultez les résultats ICI. Si des erreurs/problèmes sont constatés, veuillez les signaler dans ISSUES.

Configuration

  1. Créer et activer l’environnement python :

    python3 -m venv env
source env/bin/activate

  2. Installer les dépendances du paquet (en utilisant APT) :

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

  3. Installer les dépendances python :

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

  4. Installer Pytorch

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

  5. Installer LLM-VM

    pip install llm-vm

  6. (optionnel) Si vous utilisez des modèles comme LLAMA, vous aurez besoin d’un jeton d’accès HuggingFace. Configurez votre jeton d’accès ICI puis enregistrez votre jeton dans votre console en exécutant la commande suivante :

    huggingface-cli login

Comment Exécuter

  1. Complétez les étapes listées dans la section Configuration.

  2. Pour configurer votre ensemble, vous devez créer un fichier json avec les paramètres suivants (voici un exemple) :

    • NOTE : tous les frameworks ne supportent pas les mêmes paramètres
    {
  "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. En utilisant le chemin vers le fichier de configuration que vous avez créé à l’étape précédente, exécutez ce qui suit pour démarrer le benchmark (choisissez une 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. Après que le benchmark ait fini de s’exécuter, consultez les résultats finaux dans un fichier qui devrait ressembler à ceci :

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

Configurer RunPod :

  1. Configurez RunPod, configurez votre certificat/clé ssh, et lancez un pod. Vous pouvez accéder à votre/vos pod(s) sur la page Console de RunPod.

  2. Cliquez sur le bouton « Connect » pour obtenir les informations de connexion ssh. Ces informations devraient ressembler à ceci :

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

    • Cette commande sera formatée ainsi :

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

  3. En utilisant la commande de l’étape #2, vous devriez pouvoir vous connecter en ssh au pod et utiliser le GPU que vous avez sélectionné dans ce pod RunPod.

  4. Si vous souhaitez copier un fichier du pod vers votre machine locale, vous devez exécuter la commande dans ce format (cela fait référence aux variables montrées à l’étape #2) :

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

    • Voici un exemple de telle commande :

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

  5. Après avoir terminé avec le pod, arrêtez-le ou mettez-le en pause. Mais attention, si vous le mettez en pause, vous serez quand même facturé, mais beaucoup moins.

Excellentes Sources :