ExLlama

ExLlama: Implémentation de Llama à Efficacité Mémoire pour les Poids Quantifiés

ExLlama est une implémentation autonome en Python/C++/CUDA de Llama conçue pour la vitesse et l'efficacité de la mémoire lors de l'utilisation de poids GPTQ 4 bits sur les GPUs modernes. Ce projet vise à fournir une alternative plus rapide et plus économe en mémoire à l'implémentation Hugging Face Transformers, en particulier pour les utilisateurs travaillant avec des modèles quantifiés.

Qu'est-ce que ExLlama ?

ExLlama est conçu pour être un moteur d'inférence haute performance pour la famille de modèles de langage Llama. Il exploite CUDA pour l'accélération GPU et est optimisé pour les poids quantifiés GPTQ 4 bits, permettant aux utilisateurs d'exécuter de grands modèles de langage sur des GPUs avec une mémoire limitée.

Comment fonctionne ExLlama ?

ExLlama optimise l'utilisation de la mémoire et la vitesse d'inférence grâce à plusieurs techniques :

• Implémentation CUDA: Utilise CUDA pour un calcul GPU efficace.
• Support de la quantification: Spécifiquement conçu pour les poids quantifiés GPTQ 4 bits.
• Efficacité de la mémoire: Réduit l'empreinte mémoire par rapport aux implémentations standard.

Principales caractéristiques et avantages:

• Haute performance: Optimisé pour une inférence rapide.
• Efficacité de la mémoire: Permet d'exécuter de grands modèles sur des GPUs moins puissants.
• Implémentation autonome: Pas besoin de la bibliothèque Hugging Face Transformers.
• Interface utilisateur web: Inclut une interface utilisateur web simple pour une interaction facile avec le modèle (JavaScript écrit par ChatGPT, alors méfiez-vous !).
• Support Docker: Peut être exécuté dans un conteneur Docker pour un déploiement et une sécurité plus faciles.

Comment utiliser ExLlama ?

1. Installation:

   • Cloner le dépôt : git clone https://github.com/turboderp/exllama
   • Naviguer vers le répertoire : cd exllama
   • Installer les dépendances : pip install -r requirements.txt

2. Exécution du benchmark:

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

3. Exécution de l'exemple de chatbot:

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

4. Interface utilisateur web:

   • Installer les dépendances supplémentaires : pip install -r requirements-web.txt
   • Exécuter l'interface utilisateur web : python webui/app.py -d <path_to_model_files>

Pourquoi choisir ExLlama ?

ExLlama offre plusieurs avantages :

• Performance: Offre des vitesses d'inférence plus rapides par rapport à d'autres implémentations.
• Accessibilité: Permet aux utilisateurs disposant d'une mémoire GPU limitée d'exécuter de grands modèles de langage.
• Flexibilité: Peut être intégré à d'autres projets via le module Python.
• Facilité d'utilisation: Fournit une interface utilisateur web simple pour interagir avec le modèle.

À qui s'adresse ExLlama ?

ExLlama convient à :

• Les chercheurs et développeurs travaillant avec de grands modèles de langage.
• Les utilisateurs disposant de GPUs NVIDIA (série 30 et ultérieures recommandées).
• Ceux qui recherchent une solution d'inférence haute performance et économe en mémoire.
• Toute personne intéressée par l'exécution de modèles Llama avec une quantification GPTQ 4 bits.

Configuration matérielle requise:

• GPUs NVIDIA (RTX série 30 ou ultérieure recommandée)
• Le support ROCm est théorique mais non testé

Dépendances:

• Python 3.9+
• PyTorch (testé sur 2.0.1 et 2.1.0 nightly) avec CUDA 11.8
• safetensors 0.3.2
• sentencepiece
• ninja
• flask et waitress (pour l'interface utilisateur web)

Support Docker:

ExLlama peut être exécuté dans un conteneur Docker pour faciliter le déploiement et la sécurité. L'image Docker prend en charge les GPUs NVIDIA.

Résultats et benchmarks:

ExLlama démontre des améliorations significatives des performances par rapport à d'autres implémentations, en particulier en termes de tokens par seconde (t/s) pendant l'inférence. Des benchmarks sont fournis pour différentes tailles de modèle Llama (7B, 13B, 33B, 65B, 70B) sur différentes configurations GPU.

Exemple d'utilisation

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

## Initialiser le modèle et le 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)

## Préparer l'entrée
prompt = "The quick brown fox jumps over the lazy"
input_ids = tokenizer.encode(prompt)

## Générer la sortie
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)

Compatibilité et support des modèles:

ExLlama est compatible avec une gamme de modèles Llama, y compris Llama 1 et Llama 2. Le projet est continuellement mis à jour pour prendre en charge de nouveaux modèles et fonctionnalités.

ExLlama est un outil puissant pour quiconque cherche à exécuter efficacement des modèles Llama. Son accent sur l'optimisation de la mémoire et la vitesse en fait un excellent choix tant pour la recherche que pour les applications pratiques.