ExLlama

ExLlama: Implementação de Llama com Eficiência de Memória para Pesos Quantizados

ExLlama é uma implementação independente em Python/C++/CUDA de Llama projetada para velocidade e eficiência de memória ao usar pesos GPTQ de 4 bits em GPUs modernas. Este projeto visa fornecer uma alternativa mais rápida e com maior eficiência de memória à implementação do Hugging Face Transformers, particularmente para usuários que trabalham com modelos quantizados.

O que é ExLlama?

ExLlama é projetado para ser um mecanismo de inferência de alto desempenho para a família de modelos de linguagem Llama. Ele aproveita CUDA para aceleração de GPU e é otimizado para pesos quantizados GPTQ de 4 bits, permitindo que os usuários executem modelos de linguagem grandes em GPUs com memória limitada.

Como o ExLlama funciona?

ExLlama otimiza o uso de memória e a velocidade de inferência por meio de várias técnicas:

• Implementação CUDA: Utiliza CUDA para computação eficiente em GPU.
• Suporte de Quantização: Projetado especificamente para pesos quantizados GPTQ de 4 bits.
• Eficiência de Memória: Reduz a ocupação de memória em comparação com implementações padrão.

Principais Características e Benefícios:

• Alto Desempenho: Otimizado para inferência rápida.
• Eficiência de Memória: Permite executar modelos grandes em GPUs menos potentes.
• Implementação Independente: Não precisa da biblioteca Hugging Face Transformers.
• Web UI: Inclui uma interface de usuário web simples para fácil interação com o modelo (JavaScript escrito por ChatGPT, então cuidado!).
• Suporte a Docker: Pode ser executado em um contêiner Docker para facilitar a implantação e a segurança.

Como usar o ExLlama?

1. Instalação:

   • Clone o repositório: git clone https://github.com/turboderp/exllama
   • Navegue até o diretório: cd exllama
   • Instale as dependências: pip install -r requirements.txt

2. Executando o Benchmark:

   • python test_benchmark_inference.py -d <path_to_model_files> -p -ppl

3. Executando o Exemplo de Chatbot:

   • python example_chatbot.py -d <path_to_model_files> -un "Jeff" -p prompt_chatbort.txt

4. Web UI:

   • Instale dependências adicionais: pip install -r requirements-web.txt
   • Execute a Web UI: python webui/app.py -d <path_to_model_files>

Por que escolher ExLlama?

ExLlama oferece várias vantagens:

• Desempenho: Oferece velocidades de inferência mais rápidas em comparação com outras implementações.
• Acessibilidade: Permite que usuários com memória GPU limitada executem modelos de linguagem grandes.
• Flexibilidade: Pode ser integrado a outros projetos através do módulo Python.
• Facilidade de Uso: Fornece uma interface de usuário web simples para interagir com o modelo.

Para quem é o ExLlama?

ExLlama é adequado para:

• Pesquisadores e desenvolvedores que trabalham com modelos de linguagem grandes.
• Usuários com GPUs NVIDIA (série 30 e posteriores recomendadas).
• Aqueles que buscam uma solução de inferência de alto desempenho e com eficiência de memória.
• Qualquer pessoa interessada em executar modelos Llama com quantização GPTQ de 4 bits.

Requisitos de Hardware:

• GPUs NVIDIA (RTX série 30 ou posterior recomendada)
• O suporte a ROCm é teórico, mas não testado

Dependências:

• Python 3.9+
• PyTorch (testado em 2.0.1 e 2.1.0 nightly) com CUDA 11.8
• safetensors 0.3.2
• sentencepiece
• ninja
• flask e waitress (para a Web UI)

Suporte a Docker:

ExLlama pode ser executado em um contêiner Docker para facilitar a implantação e a segurança. A imagem Docker oferece suporte a GPUs NVIDIA.

Resultados e Benchmarks:

ExLlama demonstra melhorias significativas de desempenho em comparação com outras implementações, especialmente em termos de tokens por segundo (t/s) durante a inferência. Os benchmarks são fornecidos para vários tamanhos de modelo Llama (7B, 13B, 33B, 65B, 70B) em diferentes configurações de GPU.

Exemplo de uso

import torch
from exllama.model import ExLlama, ExLlamaCache, ExLlamaConfig
from exllama.tokenizer import ExLlamaTokenizer

## Inicializar modelo e tokenizer
model_directory = "/path/to/your/model"
tokenizer_path = os.path.join(model_directory, "tokenizer.model")
model_config_path = os.path.join(model_directory, "config.json")

config = ExLlamaConfig(model_config_path)
config.model_path = os.path.join(model_directory, "model.safetensors")

tokenizer = ExLlamaTokenizer(tokenizer_path)
model = ExLlama(config)
cache = ExLlamaCache(model)

## Preparar entrada
prompt = "The quick brown fox jumps over the lazy"
input_ids = tokenizer.encode(prompt)

## Gerar saída
model.forward(input_ids, cache)
token = model.sample(temperature = 0.7, top_k = 50, top_p = 0.7)

output = tokenizer.decode([token])
print(prompt + output)

Compatibilidade e Suporte de Modelo:

ExLlama é compatível com uma variedade de modelos Llama, incluindo Llama 1 e Llama 2. O projeto é continuamente atualizado para oferecer suporte a novos modelos e recursos.

ExLlama é uma ferramenta poderosa para quem procura executar modelos Llama de forma eficiente. Seu foco na otimização de memória e velocidade o torna uma excelente escolha para pesquisa e aplicações práticas.