ExLlama

ExLlama: Implementación de Llama con Eficiencia de Memoria para Pesos Cuantificados

ExLlama es una implementación independiente en Python/C++/CUDA de Llama diseñada para la velocidad y la eficiencia de la memoria al usar pesos GPTQ de 4 bits en GPUs modernas. Este proyecto tiene como objetivo proporcionar una alternativa más rápida y con mayor eficiencia de memoria a la implementación de Hugging Face Transformers, particularmente para usuarios que trabajan con modelos cuantificados.

¿Qué es ExLlama?

ExLlama está diseñado para ser un motor de inferencia de alto rendimiento para la familia de modelos de lenguaje Llama. Aprovecha CUDA para la aceleración de la GPU y está optimizado para pesos cuantificados GPTQ de 4 bits, lo que permite a los usuarios ejecutar modelos de lenguaje grandes en GPUs con memoria limitada.

¿Cómo funciona ExLlama?

ExLlama optimiza el uso de la memoria y la velocidad de inferencia a través de varias técnicas:

• Implementación CUDA: Utiliza CUDA para una computación eficiente en la GPU.
• Soporte de Cuantificación: Diseñado específicamente para pesos cuantificados GPTQ de 4 bits.
• Eficiencia de Memoria: Reduce el espacio de memoria en comparación con las implementaciones estándar.

Características y Beneficios Clave:

• Alto Rendimiento: Optimizado para una inferencia rápida.
• Eficiencia de Memoria: Permite ejecutar modelos grandes en GPUs menos potentes.
• Implementación Independiente: No necesita la biblioteca Hugging Face Transformers.
• Web UI: Incluye una interfaz de usuario web simple para una fácil interacción con el modelo (JavaScript escrito por ChatGPT, ¡así que ten cuidado!).
• Soporte de Docker: Se puede ejecutar en un contenedor Docker para facilitar la implementación y la seguridad.

¿Cómo usar ExLlama?

1. Instalación:

   • Clonar el repositorio: git clone https://github.com/turboderp/exllama
   • Navegar al directorio: cd exllama
   • Instalar dependencias: pip install -r requirements.txt

2. Ejecutar el Benchmark:

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

3. Ejecutar el Ejemplo de Chatbot:

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

4. Web UI:

   • Instalar dependencias adicionales: pip install -r requirements-web.txt
   • Ejecutar la Web UI: python webui/app.py -d <path_to_model_files>

¿Por qué elegir ExLlama?

ExLlama ofrece varias ventajas:

• Rendimiento: Ofrece velocidades de inferencia más rápidas en comparación con otras implementaciones.
• Accesibilidad: Permite a los usuarios con memoria GPU limitada ejecutar modelos de lenguaje grandes.
• Flexibilidad: Se puede integrar en otros proyectos a través del módulo Python.
• Facilidad de Uso: Proporciona una interfaz de usuario web simple para interactuar con el modelo.

¿Para quién es ExLlama?

ExLlama es adecuado para:

• Investigadores y desarrolladores que trabajan con modelos de lenguaje grandes.
• Usuarios con GPUs NVIDIA (se recomienda la serie 30 y posteriores).
• Aquellos que buscan una solución de inferencia de alto rendimiento y con eficiencia de memoria.
• Cualquiera interesado en ejecutar modelos Llama con cuantificación GPTQ de 4 bits.

Requisitos de Hardware:

• GPUs NVIDIA (se recomienda RTX serie 30 o posterior)
• El soporte de ROCm es teórico pero no probado

Dependencias:

• Python 3.9+
• PyTorch (probado en 2.0.1 y 2.1.0 nightly) con CUDA 11.8
• safetensors 0.3.2
• sentencepiece
• ninja
• flask y waitress (para la Web UI)

Soporte de Docker:

ExLlama se puede ejecutar en un contenedor Docker para facilitar la implementación y la seguridad. La imagen de Docker es compatible con las GPU de NVIDIA.

Resultados y Benchmarks:

ExLlama demuestra mejoras significativas en el rendimiento en comparación con otras implementaciones, especialmente en términos de tokens por segundo (t/s) durante la inferencia. Se proporcionan benchmarks para varios tamaños de modelo Llama (7B, 13B, 33B, 65B, 70B) en diferentes configuraciones de GPU.

Ejemplo de uso

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

## Inicializar modelo y 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)

## Generar salida
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)

Compatibilidad y Soporte de Modelos:

ExLlama es compatible con una variedad de modelos Llama, incluyendo Llama 1 y Llama 2. El proyecto se actualiza continuamente para admitir nuevos modelos y características.

ExLlama es una herramienta poderosa para cualquiera que busque ejecutar modelos Llama de manera eficiente. Su enfoque en la optimización de la memoria y la velocidad la convierte en una excelente opción tanto para la investigación como para las aplicaciones prácticas.