Modello di benchmark per LLM locali

Repository GitHub del progetto

Retroscena

Ho realizzato LLM Speed Benchmark (LLMSB) durante il periodo in cui ero stagista part-time in Ingegneria presso Anarchy (YC W23). LLMSB è uno strumento di benchmark per valutare le prestazioni di un modello LLM. Utilizza la libreria transformers di HuggingFace per caricare ed eseguire un modello LLM e misura:

  • tempo totale di esecuzione
  • token al secondo
  • specifiche generali dell’hardware
  • utilizzo della cpu (frequenza attuale e percentuale di utilizzo dei core nel tempo)
  • utilizzo della ram (ram e swap nel tempo)
  • utilizzo della gpu (carico, utilizzo della memoria e temperatura nel tempo)

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

Questa era la storia del retroscena/origine di LLMSB. Poiché il progetto è open-source, puoi vedere il codice QUI. Sotto, ho incluso il README del repository se vuoi dargli un’occhiata.

Informazioni

🚧 LLM Speed Benchmark (LLMSB) è attualmente in beta (v0). Si prega di non usarlo in produzione, oppure di usarlo a proprio rischio. Stiamo ancora limando alcuni problemi e migliorando la funzionalità. Se riscontri bug o hai suggerimenti, segnalarli gentilmente nella sezione ISSUES. Il tuo feedback è prezioso!

LLM Speed Benchmark (LLMSB) è uno strumento di benchmark per valutare le prestazioni dei modelli LLM su diverse piattaforme hardware. Il suo obiettivo finale è compilare un dataset completo che dettaglia le prestazioni dei modelli LLM su vari sistemi, consentendo agli utenti di scegliere in modo più efficace il o i modelli LLM giusti per i propri progetti.

Limiti

LLMSB è alla v0, quindi ha dei limiti:

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

Output di esempio

22 novembre 2023

LLMSB è stato eseguito/testato su una GPU L40 e H100 tramite RunPod. In quei benchmark sono stati testati i modelli llama-2-7b-hf, codellama-13b-oasst-sft-v10, e mpt-7b. Controlla i risultati QUI. Se vengono notati errori/problemi, segnalarli a ISSUES.

Configurazione

  1. Crea e attiva l’ambiente Python:

    python3 -m venv env
source env/bin/activate

  2. Installa le dipendenze del pacchetto (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, quindi salva il tuo token nella console eseguendo il seguente comando:

    huggingface-cli login

Come eseguire

  1. Completa i passaggi elencati nella sezione Configurazione.

  2. Per configurare il tuo set, devi creare un file json con i seguenti parametri (ecco 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 del file di configurazione che hai creato nel passaggio 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 essere simile a questo:

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

Configurazione di RunPod:

  1. Configura RunPod, configura il tuo certificato/chiave ssh e avvia un pod. Puoi accedere al o ai tuoi pod sulla pagina della console di RunPod.

  2. Fai clic sul pulsante “Connect” per ottenere le informazioni di connessione ssh. Queste informazioni dovrebbero essere simili a queste:

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

    • Questo comando sarà formattato in questo modo:

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

  3. Usando il comando del passaggio #2, dovresti essere in grado di connetterti via ssh al pod e utilizzare la GPU che hai selezionato in quel pod di RunPod.

  4. Se vuoi copiare un file dal pod alla tua macchina locale, eseguiresti un comando in questo formato (questo si riferisce alle variabili mostrate nel passaggio #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. Una volta finito con il pod, spegnilo o mettilo in pausa. Ma attenzione, se lo metti in pausa continuerai comunque a essere addebitato, solo molto meno.

Grandi fonti: