Benchmark de modelos LLM locales

Repositorio de GitHub del proyecto

Historia de fondo

Construí LLM Speed Benchmark (LLMSB) durante mi tiempo como becario de ingeniería a tiempo parcial en Anarchy (YC W23). LLMSB es una herramienta de benchmarking para evaluar el rendimiento de un modelo LLM. Utiliza la biblioteca transformers de HuggingFace para cargar y ejecutar un modelo LLM y mide:

  • tiempo total de ejecución
  • tokens por segundo
  • especificaciones generales del hardware
  • uso de CPU (frecuencia actual y porcentaje de uso de los núcleos a lo largo del tiempo)
  • uso de RAM (RAM y swap a lo largo del tiempo)
  • uso de GPU (carga, uso de memoria y temperatura a lo largo del tiempo)

AQUÍ hay un ejemplo de una ejecución de benchmarking para el modelo codellama-13b-oasst-sft-v10 ejecutándose en una H100. Yo personalmente poseo una Nvidia RTX 2070 Ti, que tiene 8 GB de VRAM. Lamentablemente, para la mayoría de los modelos LLM modernos, 8 GB de VRAM no son suficientes para interactuar con un modelo. Debido a esto, usé RunPod para “alquilar” GPU(s) y ejecutar mis benchmarks en ciertos modelos.

Esta fue la historia de fondo/origen de LLMSB. Dado que el proyecto es de código abierto, puedes ver el código AQUÍ. A continuación, incluí el README del repositorio por si quieres echarle un vistazo.

Acerca de

🚧 LLM Speed Benchmark (LLMSB) actualmente está en beta (v0). Por favor, no lo uses en producción, o úsalo bajo tu propio riesgo. Todavía estamos puliendo algunos detalles y mejorando la funcionalidad. Si encuentras algún error o tienes sugerencias, por favor repórtalas en ISSUES. ¡Tus comentarios son invaluables!

LLM Speed Benchmark (LLMSB) es una herramienta de benchmarking para evaluar el rendimiento de modelos LLM en distintas plataformas de hardware. Su objetivo final es compilar un conjunto de datos exhaustivo que detalle el rendimiento de modelos LLM en varios sistemas, permitiendo a los usuarios elegir más eficazmente el/los modelo(s) LLM adecuados para sus proyectos.

Limitaciones

LLMSB está en v0, así que tiene limitaciones:

  • Solo está diseñado para ejecutarse en sistemas operativos basados en Debian, es decir, no está diseñado para ejecutarse en Windows. Esto se debe a que LLMSB usa neofetch y nvidia-smi para recopilar métricas internamente y la lógica de rutas de archivo se basa en sistemas operativos Unix.
  • Debido a cómo se registran las métricas, el colector de métricas puede tardar hasta 1 segundo en hacer una recolección. Esto significa que, como mínimo, podemos recopilar métricas de hardware cada 1 segundo.
  • LLMSB solo usa HuggingFace para cargar y ejecutar modelos. Esto funciona por ahora, pero el objetivo es que LLMSB admita múltiples frameworks, no solo HuggingFace.
  • Actualmente, todos los modelos se ejecutan mediante la lógica presentada en la función run_llm(), ubicada en src/hf.py, donde se usan las funciones AutoTokenizer() y AutoModelForCausalLM() para cargar y ejecutar un modelo. Esto funciona, pero limita cómo podemos configurar/optimizar modelos específicos. Teniendo esto en cuenta, el objetivo es crear clases separadas para cada modelo popular y utilizar las clases específicas de modelo de HuggingFace, como LlamaTokenizer y LlamaForCausalLM, en su lugar.
  • LLMSB solo recopila métricas generales de alto nivel. En el futuro, nos gustaría recopilar métricas de nivel más bajo. Creemos que esto puede hacerse en parte usando el envoltorio de profiler de Pytorch.

Ejemplos de salida

22 de noviembre de 2023

LLMSB fue ejecutado/probado en una GPU L40 y H100 a través de RunPod. En esos benchmarks se probaron los modelos llama-2-7b-hf, codellama-13b-oasst-sft-v10 y mpt-7b. Consulta los resultados AQUÍ. Si se observan errores/problemas, por favor repórtenlos a ISSUES.

Configuración

  1. Crea y activa el entorno de Python:

    python3 -m venv env
source env/bin/activate

  2. Instala las dependencias del paquete (usando APT):

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

  3. Instala las dependencias de Python:

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

  4. Instala Pytorch

    # instala la versión estable de pytorch, para Linux, usando CUDA 12.1:
pip3 install torch torchvision torchaudio

  5. Instala LLM-VM:

    pip install llm-vm

  6. (opcional) Si estás usando modelos como LLAMA, necesitarás un token de acceso de HuggingFace. Configura tu token de acceso AQUÍ y luego guarda tu token en tu consola ejecutando el siguiente comando:

    huggingface-cli login

Cómo ejecutar

  1. Completa los pasos enumerados en la sección Configuración.

  2. Para configurar tu conjunto, necesitas crear un archivo json con los siguientes parámetros (aquí hay un ejemplo):

    • NOTA: no todos los frameworks admiten los mismos parámetros
    {
  "model": "bigscience/bloom-560m",   # la ruta/repo del modelo en HuggingFace (https://huggingface.co/models)
  "prompt": "Hello World!",           # el prompt que quieres introducir en el modelo LLM
  "device": "cuda:0",                 # el dispositivo en el que quieres ejecutar el modelo LLM (GPU/CPU)
  "max_length": 50,                   # la longitud máxima de los tokens generados
  "temperature": 0.9,                 # valor de temperatura para el modelo LLM
  "top_k": 50,                        # valor top-k para el modelo LLM
  "top_p": 0.9,                       # valor top-p para el modelo LLM
  "num_return_sequences": 1,          # el número de instancias del modelo ejecutadas de forma independiente
  "time_delay": 0,                    # el retraso de tiempo (segundos) que el colector de métricas esperará por iteración
  "model_start_pause": 1,             # el tiempo (segundos) que la prueba esperará ANTES de ejecutar el modelo LLM
  "model_end_pause": 1                # el tiempo (segundos) que la prueba esperará DESPUÉS de que el modelo LLM haya terminado de ejecutarse,
  "framework": "llm-vm"               # el nombre del framework/biblioteca que quieres usar para ejecutar el modelo
}

  3. Usando la ruta al archivo de configuración que creaste en el paso anterior, ejecuta lo siguiente para iniciar el benchmark (elige una opción):

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

# ejecutar más de un benchmark (en este caso 3)
python3 run.py --config ./configs/llmvm_test.json --loops 3

  4. Después de que el benchmark termine de ejecutarse, revisa los resultados finales en un archivo que debería verse más o menos así:

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

Configuración de RunPod:

  1. Configura RunPod, configura tu certificado/clave ssh y levanta un pod. Puedes acceder a tu(s) pod(s) en la Página de Consola de RunPod.

  2. Haz clic en el botón “Connect” para obtener la información de conexión ssh. Esta información debería verse más o menos así:

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

    • Este comando se formateará así:

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

  3. Usando el comando del paso #2, deberías poder hacer ssh al pod y usar la GPU que seleccionaste en ese pod de RunPod.

  4. Si quieres copiar un archivo del pod a tu máquina local, ejecutarías un comando con este formato (esto hace referencia a las variables mostradas en el paso #2):

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

    • Aquí hay un ejemplo de dicho comando:

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

  5. Después de terminar con el pod, apágalo o ponlo en pausa. Pero ten en cuenta que, si lo pones en pausa, seguirás siendo cobrado, solo que mucho menos.

Grandes fuentes: