Benchmark de Modelos LLM Locais

Repositório GitHub do Projeto

Contexto

Eu construí o LLM Speed Benchmark (LLMSB) durante meu tempo como Estagiário de Engenharia em meio período na Anarchy (YC W23). O LLMSB é uma ferramenta de benchmarking para avaliar o desempenho de um modelo LLM. Ele usa a biblioteca transformers do 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 da 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 uma execução de benchmark para o modelo codellama-13b-oasst-sft-v10 executando em um H100. Eu possuo pessoalmente 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 é suficiente para interagir com um modelo. Por causa disso, usei RunPod para “alugar” GPU(s) e executar meus benchmarks em certos modelos.

Esta foi a história de contexto/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 dar uma olhada.

Sobre

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

O LLM Speed Benchmark (LLMSB) é uma ferramenta de benchmarking 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 certo(s) para seus projetos.

Limitações

O LLMSB está na v0, então tem limitações:

  • Foi projetado apenas para rodar em sistemas operacionais baseados em Debian, ou seja, não foi projetado para rodar no Windows. Isso porque o LLMSB usa neofetch e nvidia-smi para coletar métricas nos bastidores e a lógica dos caminhos de arquivo é baseada em sistemas operacionais Unix.
  • Devido à forma como as métricas são registradas, o coletor de métricas pode levar até 1 segundo para realizar uma coleta. Isso significa que, no mínimo, podemos coletar métricas de hardware a cada 1 segundo.
  • O LLMSB usa apenas o HuggingFace para carregar e executar modelos. Isso funciona por enquanto, mas o objetivo é que o LLMSB suporte múltiplas estruturas, não apenas o HuggingFace.
  • Atualmente, todos os modelos são executados por meio 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 de modelo do HuggingFace, como LlamaTokenizer e LlamaForCausalLM, em vez disso.
  • O LLMSB apenas coleta métricas gerais, de alto nível. No futuro, gostaríamos de coletar métricas de nível mais baixo. Acreditamos que isso pode ser feito em parte usando o wrapper de profiler do Pytorch.

Saídas de Exemplo

22 de novembro de 2023

O LLMSB foi executado/testado em uma GPU L40 e H100 por meio do RunPod. Nesses benchmarks, os modelos llama-2-7b-hf, codellama-13b-oasst-sft-v10 e mpt-7b foram testados. Confira os resultados AQUI. Se algum erro/problema for notado, 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 as dependências do pacote (usando APT):

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

  3. Instale as dependências do Python:

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

  4. Instale o Pytorch

    # instalar a build estável do pytorch, para linux, usando CUDA 12.1:
pip3 install torch torchvision torchaudio

  5. Instale o LLM-VM:

    pip install llm-vm

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

    huggingface-cli login

Como Executar

  1. Conclua as etapas listadas 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):

    • OBSERVAÇÃO: nem toda estrutura suporta os mesmos parâmetros
    {
  "model": "bigscience/bloom-560m",   # o caminho/repositório do modelo no HuggingFace (https://huggingface.co/models)
  "prompt": "Hello World!",           # o prompt que você quer inserir no modelo LLM
  "device": "cuda:0",                 # o dispositivo em que você quer executar o modelo LLM (GPU/CPU)
  "max_length": 50,                   # o comprimento máximo dos tokens gerados
  "temperature": 0.9,                 # valor de temperatura para o modelo LLM
  "top_k": 50,                        # valor de top-k para o modelo LLM
  "top_p": 0.9,                       # valor de top-p para o modelo LLM
  "num_return_sequences": 1,          # o número de instâncias executadas independentemente do modelo
  "time_delay": 0,                    # o atraso de tempo (segundos) que o coletor de métricas aguardará por iteração
  "model_start_pause": 1,             # o tempo (segundos) que o teste aguardará ANTES de executar o modelo LLM
  "model_end_pause": 1                # o tempo (segundos) que o teste aguardará DEPOIS que o modelo LLM terminar de executar,
  "framework": "llm-vm"               # o nome da estrutura/biblioteca que você quer usar para executar o modelo
}

  3. Usando o caminho para o arquivo de configuração que você criou na etapa anterior, execute o seguinte para iniciar o benchmark (escolha uma opção):

    # executar um benchmark
python3 run.py --config ./configs/llmvm_test.json

# executar mais de um benchmark (neste caso, 3)
python3 run.py --config ./configs/llmvm_test.json --loops 3

  4. Depois que o benchmark terminar de executar, confira os resultados finais em um arquivo que deve parecer algo assim:

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

Configurando o RunPod:

  1. Configure o RunPod, configure seu certificado/chave ssh e obtenha um pod em execução. Você pode acessar seu(s) pod(s) na Página do Console do RunPod.

  2. Clique no botão “Connect” para obter as informações de conexão ssh. Essas informações devem parecer algo assim:

    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 na etapa #2, você deverá conseguir fazer ssh no pod e usar a GPU que você selecionou naquele pod do RunPod.

  4. Se você quiser copiar um arquivo do pod para sua máquina local, você usaria um comando neste formato (isto se refere às variáveis mostradas na etapa #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 que terminar com o pod, desligue-o ou pause-o. Mas atenção: se você pausá-lo, ainda será cobrado, só que bem menos.

Ótimas Fontes: