Benchmark dei modelli LLM locali

Repository GitHub del Progetto

Retroscena

Ho creato LLM Speed Benchmark (LLMSB) durante il mio periodo come stagista di ingegneria part-time presso Anarchy (YC W23). LLMSB è uno strumento di benchmarking per valutare le prestazioni di un modello LLM. Utilizza la libreria di HuggingFace transformers per caricare ed eseguire un modello LLM e misura:

  • tempo di esecuzione totale
  • token al secondo
  • specifiche hardware generali
  • utilizzo CPU (frequenza corrente e % di utilizzo dei core nel tempo)
  • utilizzo RAM (RAM e swap nel tempo)
  • utilizzo GPU (carico, utilizzo memoria e temperatura nel tempo)

QUI c’è un esempio di una esecuzione di benchmark per il modello codellama-13b-oasst-sft-v10 eseguito su una H100. Possiedo personalmente una Nvidia RTX 2070 Ti, che ha 8 GB di VRAM. Purtroppo, per la maggior parte dei modelli LLM moderni, 8 GB di VRAM non sono sufficienti per interagire con un modello. Per questo motivo, ho usato RunPod per “noleggiare” GPU e eseguire i miei benchmark su alcuni modelli.

Questa è stata la storia/origine di LLMSB. Poiché il progetto è open-source, puoi vedere il codice QUI. Di seguito, ho incluso il README del repository se vuoi consultarlo.

Informazioni

🚧 LLM Speed Benchmark (LLMSB) è attualmente in beta (v0). Per favore non usare questo in produzione, o usalo a tuo rischio. Stiamo ancora risolvendo alcuni problemi e migliorando le funzionalità. Se incontri bug o hai suggerimenti, gentilmente segnalali sotto SEGNALAZIONI. Il tuo feedback è inestimabile!

LLM Speed Benchmark (LLMSB) è uno strumento di benchmarking per valutare le prestazioni dei modelli LLM su diverse piattaforme hardware. Il suo obiettivo finale è compilare un dataset completo che dettagli le prestazioni dei modelli LLM su vari sistemi, permettendo agli utenti di scegliere più efficacemente il/i modello/i LLM giusto/i per i loro progetti.

Limitazioni

LLMSB è alla versione v0, quindi ha limitazioni:

  • Progettato solo per funzionare su sistemi operativi basati su Debian, ovvero non è progettato per funzionare su Windows. Questo perché LLMSB usa neofetch e nvidia-smi per raccogliere metriche sotto il cofano e la logica dei percorsi dei file è basata su sistemi operativi Unix.
  • A causa di come vengono registrate le metriche, il raccoglitore di metriche può impiegare fino a 1 secondo per effettuare una raccolta. Questo significa che, al massimo, possiamo raccogliere metriche hardware ogni 1 secondo.
  • LLMSB utilizza solo HuggingFace per caricare ed eseguire i modelli. Questo funziona per ora, ma l’obiettivo è far sì che LLMSB supporti più framework, non solo HuggingFace.
  • Attualmente, tutti i modelli vengono eseguiti attraverso la logica presentata nella funzione run_llm(), situata in src/hf.py, dove le funzioni AutoTokenizer() e AutoModelForCausalLM() sono usate per caricare ed eseguire un modello. Questo funziona ma limita come possiamo configurare/ottimizzare modelli specifici. Tenendo conto di ciò, l’obiettivo è creare classi separate per ogni modello popolare e utilizzare le classi specifiche di HuggingFace, come LlamaTokenizer & LlamaForCausalLM, invece.
  • LLMSB raccoglie solo metriche generali e di alto livello. In futuro, vorremmo raccogliere metriche di livello più basso. Pensiamo che questo possa essere parzialmente fatto usando il profiler wrapper di Pytorch.

Esempi di Output

22 novembre 2023

LLMSB è stato eseguito/testato su GPU L40 e H100 tramite RunPod. In quei benchmark i modelli llama-2-7b-hf, codellama-13b-oasst-sft-v10, e mpt-7b sono stati testati. Consulta i risultati QUI. Se vengono notati errori/problemi, per favore segnalali in SEGNALAZIONI.

Installazione

  1. Crea e attiva l’ambiente Python:

    python3 -m venv env
source env/bin/activate

  2. Installa le dipendenze del sistema (usando APT):

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

  3. Installa le dipendenze Python:

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

  4. Installa Pytorch

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

  5. Installa LLM-VM:

    pip install llm-vm

  6. (opzionale) Se stai usando modelli come LLAMA, avrai bisogno di un token di accesso HuggingFace. Configura il tuo token di accesso QUI poi salva il tuo token nella console eseguendo il seguente comando:

    huggingface-cli login

Come Eseguire

  1. Completa i passaggi elencati nella sezione Installazione.

  2. Per configurare il tuo set, devi creare un file json con i seguenti parametri (qui c’è un esempio):

    • NOTA: non tutti i framework supportano gli stessi parametri
    {
  "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. Usando il percorso al file di configurazione che crei nel passo precedente, esegui quanto segue per avviare il benchmark (scegli un’opzione):

    # 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. Dopo che il benchmark ha terminato l’esecuzione, controlla i risultati finali in un file che dovrebbe assomigliare a questo:

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

Configurare RunPod:

  1. Configura RunPod, configura il tuo certificato/chiave ssh e avvia un pod. Puoi accedere al tuo/i tuo/i pod sul RunPod Console Page.

  2. Clicca il pulsante “Connect” per ottenere le informazioni di connessione ssh. Queste informazioni dovrebbero apparire qualcosa del genere:

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

    • Questo comando sarà formattato così:

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

  3. Usando il comando del passo #2, dovresti essere in grado di ssh nel pod e usare la GPU che hai selezionato in quel pod RunPod.

  4. Se vuoi copiare un file dal pod alla tua macchina locale, eseguirai un comando in questo formato (questo si riferisce alle variabili mostrate nel passo #2):

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

    • Ecco un esempio di tale comando:

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

  5. Dopo aver terminato con il pod, spegnilo o mettilo in pausa. Attenzione, se lo metti in pausa continuerai a essere addebitato, solo molto meno.

Ottime Risorse: