Benchmark de Velocidad LLM

Repositorio GitHub del proyecto

Antecedentes

Construí LLM Speed Benchmark (LLMSB) durante mi tiempo como pasante 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 % 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 benchmark para el modelo codellama-13b-oasst-sft-v10 ejecutándose en una H100. 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, utilicé RunPod para “alquilar” GPU(s) y ejecutar mis benchmarks en ciertos modelos.

Esta fue la historia de 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 deseas revisarlo.

Acerca de

🚧 LLM Speed Benchmark (LLMSB) está actualmente en beta (v0). Por favor, no lo uses en producción, o úsalo bajo tu propio riesgo. Todavía estamos afinando algunos detalles y mejorando la funcionalidad. Si encuentras errores o tienes sugerencias, amablemente repórtalos en ISSUES. ¡Tu retroalimentación es invaluable!

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

Limitaciones

LLMSB está en v0, por lo que tiene limitaciones:

  • Sólo está diseñado para ejecutarse en sistemas operativos basados en Debian, es decir, no está pensado para Windows. Esto se debe a que LLMSB usa neofetch y nvidia-smi para recopilar métricas bajo el capó y la lógica de rutas de archivo está basada en sistemas Unix.
  • Debido a cómo se registran las métricas, el colector de métricas puede tardar hasta 1 segundo en realizar una recolección. Esto significa que, en el mejor de los casos, podemos recopilar métricas de hardware cada 1 segundo.
  • LLMSB sólo usa HuggingFace para cargar y ejecutar modelos. Esto funciona por ahora, pero el objetivo es que LLMSB soporte 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 utilizan las funciones AutoTokenizer() y AutoModelForCausalLM() para cargar y ejecutar un modelo. Esto funciona pero limita cómo podemos configurar/optimizar modelos específicos. Conociendo esto, 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 sólo recopila métricas generales de alto nivel. En el futuro, nos gustaría recopilar métricas de nivel inferior. Creemos que esto puede hacerse parcialmente usando el wrapper de profiler de Pytorch.

Salidas de Ejemplo

22 de noviembre de 2023

LLMSB se ejecutó/pruebo en GPUs 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 notan errores o problemas, por favor repórtalos en ISSUES.

Configuración

  1. Crear y activar el entorno python:

    python3 -m venv env
source env/bin/activate

  2. Instalar dependencias del paquete (usando APT):

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

  3. Instalar dependencias de python:

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

  4. Instalar Pytorch

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

  5. Instalar 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 la consola ejecutando el siguiente comando:

    huggingface-cli login

Cómo Ejecutar

  1. Completa los pasos listados 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 soportan los mismos parámetros
    {
  "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 la ruta al archivo de configuración que creaste en el paso anterior, ejecuta lo siguiente para iniciar el benchmark (elige una opción):

    # 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. Después de que el benchmark termine de ejecutarse, revisa los resultados finales en un archivo que debería tener un aspecto similar a este:

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

Configurando RunPod:

  1. Configura RunPod, configura tu certificado/clave SSH y pon un pod en funcionamiento. 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 algo así:

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

    • Este comando tendrá el siguiente formato:

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

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

  4. Si deseas copiar un archivo del pod a tu máquina local, ejecutarías un comando con este formato (se refiere 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 advertencia, si lo pones en pausa seguirás siendo cobrado, aunque mucho menos.

Grandes Fuentes: