Benchmark de Modelos LLM Locais

Repositório GitHub do Projeto

História

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 benchmark para avaliar o desempenho de um modelo LLM. Ele 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 de 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 de 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 rodando em um 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 é suficiente para interagir com um modelo. Devido a isso, eu usei o RunPod para “alugar” GPU(s) e executar meus benchmarks em certos modelos.

Esta foi a história de origem do LLMSB. Como o projeto é de código aberto, você pode visualizar o código AQUI. Abaixo, incluí o README do repositório se você quiser dar uma olhada.

Sobre

🚧 O 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 melhorando a funcionalidade. Se você encontrar algum bug ou tiver sugestões, por favor, relate-os em ISSUES. Seu feedback é inestimável!

O 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 certo(s) para seus projetos.

Limitações

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

  • Projetado apenas para rodar em sistemas operacionais baseados em Debian, ou seja, não é 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 do caminho do arquivo é baseada em sistemas operacionais Unix.
  • Devido à forma como as métricas são registradas, pode levar até 1 segundo para o coletor de métricas fazer uma coleta. Isso significa que, na melhor das hipóteses, podemos coletar métricas de hardware a cada 1 segundo.
  • O 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 de modelo da HuggingFace, como LlamaTokenizer e LlamaForCausalLM, em vez disso.
  • O LLMSB apenas coleta métricas gerais e de alto nível. No futuro, gostaríamos de coletar métricas de nível mais baixo. Acreditamos que isso pode ser feito parcialmente usando o wrapper de profiler do Pytorch.

Exemplos de Saídas

22 de Novembro de 2023

O LLMSB foi executado/testado em uma GPU L40 e H100 através 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, relate-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

    # instale a versão 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, precisará de um token de acesso da HuggingFace. Configure seu token de acesso AQUI e salve seu token no seu 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 todas as estruturas suportam os mesmos parâmetros
    {
  "model": "bigscience/bloom-560m",   # o caminho/repositório do modelo na HuggingFace (https://huggingface.co/models)
  "prompt": "Olá Mundo!",              # o prompt que você deseja inserir no modelo LLM
  "device": "cuda:0",                  # o dispositivo que você deseja usar para 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 top-k para o modelo LLM
  "top_p": 0.9,                        # valor top-p para o modelo LLM
  "num_return_sequences": 1,           # o número de instâncias do modelo executadas independentemente
  "time_delay": 0,                     # o atraso de tempo (segundos) que o coletor de métricas aguardará por interaçã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ê deseja 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. Após o benchmark terminar de rodar, confira os resultados finais em um arquivo que deve ter uma aparência semelhante a esta:

    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 inicie um pod. Você pode acessar seu(s) pod(s) na Página do Console do RunPod.

  2. Clique no botão “Conectar” para obter as informações de conexão ssh. Essas informações devem ter uma aparência semelhante a esta:

    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ê deve ser capaz de 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ê deve executar o comando neste formato (referindo-se à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 de terminar com o pod, desligue-o ou pause-o. Mas atenção, se você pausar, ainda será cobrado, apenas muito menos.

Ótimas Fontes: