Benchmark de Velocidade LLM

Repositório GitHub do Projeto

História de Origem

Construí o LLM Speed Benchmark (LLMSB) durante meu período como Estagiário de Engenharia em tempo parcial na Anarchy (YC W23). LLMSB é uma ferramenta de benchmark para avaliar o desempenho de um modelo LLM. Ela usa a biblioteca transformers da HuggingFace para carregar e executar um modelo LLM e mede:

  • tempo total de execução
  • tokens por segundo
  • especificações gerais de hardware
  • uso da CPU (frequência atual e % de uso dos núcleos ao longo do tempo)
  • uso de RAM (RAM e swap ao longo do tempo)
  • uso da GPU (carga, uso de memória e temperatura ao longo do tempo)

AQUI está um exemplo de execução de benchmark para o modelo codellama-13b-oasst-sft-v10 rodando em uma H100. Eu pessoalmente possuo uma Nvidia RTX 2070 Ti, que tem 8 GB de VRAM. Infelizmente, para a maioria dos modelos LLM modernos, 8 GB de VRAM não são suficientes para interagir com um modelo. Por isso, usei o RunPod para “alugar” GPU(s) e executar meus benchmarks em determinados modelos.

Esta foi a história de origem do LLMSB. Como o projeto é de código aberto, você pode ver o código AQUI. Abaixo, incluí o README do repositório caso queira conferir.

Sobre

🚧 LLM Speed Benchmark (LLMSB) está atualmente em beta (v0). Por favor, não use isso em produção, ou use por sua conta e risco. Ainda estamos resolvendo alguns problemas e aprimorando a funcionalidade. Se você encontrar bugs ou tiver sugestões, gentilmente reporte-os em ISSUES. Seu feedback é inestimável!

LLM Speed Benchmark (LLMSB) é uma ferramenta de benchmark para avaliar o desempenho de modelos LLM em diferentes plataformas de hardware. Seu objetivo final é compilar um conjunto de dados abrangente detalhando o desempenho de modelos LLM em vários sistemas, permitindo que os usuários escolham de forma mais eficaz o(s) modelo(s) LLM adequado(s) para seus projetos.

Limitações

LLMSB está na versão v0, portanto tem limitações:

  • Projetado apenas para sistemas operacionais baseados em Debian, ou seja, não foi projetado para rodar no Windows. Isso ocorre porque o LLMSB usa neofetch e nvidia-smi para coletar métricas nos bastidores e a lógica de caminhos de arquivos é baseada em sistemas Unix.
  • Devido à forma como as métricas são registradas, o coletor de métricas pode levar até 1 segundo para fazer uma coleta. Isso significa que, no melhor caso, podemos coletar métricas de hardware a cada 1 segundo.
  • LLMSB usa apenas a HuggingFace para carregar e executar modelos. Isso funciona por enquanto, mas o objetivo é que o LLMSB suporte múltiplas estruturas, não apenas a HuggingFace.
  • Atualmente, todos os modelos são executados através da lógica apresentada na função run_llm() localizada em src/hf.py, onde as funções AutoTokenizer() e AutoModelForCausalLM() são usadas para carregar e executar um modelo. Isso funciona, mas limita como podemos configurar/otimizar modelos específicos. Sabendo disso, o objetivo é criar classes separadas para cada modelo popular e utilizar as classes específicas da HuggingFace, como LlamaTokenizer e LlamaForCausalLM, por exemplo.
  • LLMSB coleta apenas métricas gerais, de alto nível. No futuro, gostaríamos de coletar métricas de nível inferior. Acreditamos que isso pode ser parcialmente feito usando o wrapper de profiler do Pytorch.

Exemplos de Saída

22 de Novembro de 2023

LLMSB foi executado/testado em GPUs L40 e H100 através do RunPod. Nestes benchmarks, os modelos llama-2-7b-hf, codellama-13b-oasst-sft-v10 e mpt-7b foram testados. Confira os resultados AQUI. Se quaisquer erros/questões forem notados, por favor reporte-os em ISSUES.

Configuração

  1. Crie e ative o ambiente python:

    python3 -m venv env
source env/bin/activate

  2. Instale dependências do pacote (usando APT):

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

  3. Instale dependências python:

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

  4. Instale Pytorch

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

  5. Instale LLM-VM:

    pip install llm-vm

  6. (opcional) Se você estiver usando modelos como LLAMA, precisará de um token de acesso da HuggingFace. Configure seu token de acesso AQUI e então salve seu token no console executando o seguinte comando:

    huggingface-cli login

Como Executar

  1. Complete os passos listados na seção Configuração.

  2. Para configurar seu conjunto, você precisa criar um arquivo JSON com os seguintes parâmetros (aqui está um exemplo):

    • NOTA: nem todo framework suporta os mesmos 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 o caminho para o arquivo de configuração que você criou no passo anterior, execute o seguinte para iniciar o benchmark (escolha uma opção):

    # 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. Depois que o benchmark terminar de rodar, confira os resultados finais em um arquivo que deve ter a seguinte aparência:

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

Configurando RunPod:

  1. Configure o RunPod, configure seu certificado/chave SSH e inicie um pod. Você pode acessar seu(s) pod(s) na Página de Console do RunPod.

  2. Clique no botão “Connect” para obter as informações de conexão SSH. Essas informações devem ter a seguinte aparência:

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

    • Este comando será formatado assim:

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

  3. Usando o comando do passo #2, você deve conseguir fazer SSH no pod e usar a GPU que selecionou naquele pod RunPod.

  4. Se quiser copiar um arquivo do pod para sua máquina local, execute o comando neste formato (referindo‑se às variáveis mostradas no passo #2):

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

    • Aqui está um exemplo de tal comando:

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

  5. Depois de terminar com o pod, desligue‑o ou pause‑o. Mas atenção, se você pausá‑lo ainda será cobrado, apenas bem menos.

Ótimas Fontes: