ExLlamaV2

Inférence LLM à vitesse maximale avec ExLlamaV2 sur les GPU Clore.ai

Exécutez les LLM à vitesse maximale avec ExLlamaV2.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

2. Filtrez par type de GPU, VRAM et prix

3. Choisissez À la demande (tarif fixe) ou Spot (prix d'enchère)

4. Configurez votre commande :

   • Sélectionnez l'image Docker

   • Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)

   • Ajoutez des variables d'environnement si nécessaire

   • Entrez la commande de démarrage

5. Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC

6. Créez la commande et attendez le déploiement

Accédez à votre serveur

• Trouvez les détails de connexion dans Mes commandes

• Interfaces web : utilisez l'URL du port HTTP

• SSH : ssh -p <port> root@<proxy-address>

Qu'est-ce qu'ExLlamaV2 ?

ExLlamaV2 est le moteur d'inférence le plus rapide pour les grands modèles de langage :

• 2 à 3 fois plus rapide que les autres moteurs

• Quantification excellente (EXL2)

• Faible utilisation de la VRAM

• Prend en charge le décodage spéculatif

Exigences

Taille du modèle	VRAM minimale	Recommandé
7B	6 Go	RTX 3060
13B	10GB	RTX 3090
34B	20 Go	RTX 4090
70B	40 Go	A100

Déploiement rapide

Image Docker :

pytorch/pytorch:2.11.0-cuda12.8-cudnn9-devel

Ports :

22/tcp
8080/http

Commande :

pip install exllamav2 && \\
huggingface-cli download turboderp/Llama2-7B-exl2 --local-dir ./model && \\
python -m exllamav2.server --model_dir ./model --host 0.0.0.0 --port 8080

Accéder à votre service

Après le déploiement, trouvez votre http_pub URL dans Mes commandes:

1. Accédez à Mes commandes la page

2. Cliquez sur votre commande

3. Trouvez le http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://YOUR_HTTP_PUB_URL au lieu de localhost dans les exemples ci-dessous.

Installation

# Installer depuis PyPI
pip install exllamav2

# Ou depuis les sources (dernières fonctionnalités)
git clone https://github.com/turboderp/exllamav2
cd exllamav2
pip install .

Télécharger les modèles

Modèles quantifiés EXL2

# Llama 3.1 8B (4.0 bpw)
huggingface-cli download turboderp/Llama2-7B-exl2 \\
    --revision 4.0bpw \\
    --local-dir ./llama2-7b-exl2

# Llama 3.1 8B (4.0 bpw)
huggingface-cli download turboderp/Llama2-13B-exl2 \\
    --revision 4.0bpw \\
    --local-dir ./llama2-13b-exl2

# Mistral 7B (4.0 bpw)
huggingface-cli download turboderp/Mistral-7B-instruct-exl2 \\
    --revision 4.0bpw \\
    --local-dir ./mistral-7b-exl2

# Mixtral 8x7B
huggingface-cli download turboderp/Mixtral-8x7B-instruct-exl2 \\
    --revision 4.0bpw \\
    --local-dir ./mixtral-exl2

Bits par poids (bpw)

BPW	Qualité	VRAM (7B)
2.0	Faible	~3GB
3.0	Bon	~4 Go
4.0	Excellent	~5GB
5.0	Excellente	~6GB
6.0	Près de FP16	~7GB

API Python

Génération de base

from exllamav2 import ExLlamaV2, ExLlamaV2Config, ExLlamaV2Cache, ExLlamaV2Tokenizer
from exllamav2.generator import ExLlamaV2StreamingGenerator, ExLlamaV2Sampler

# Charger le modèle
config = ExLlamaV2Config()
config.model_dir = "./llama2-7b-exl2"
config.prepare()

model = ExLlamaV2(config)
model.load()

tokenizer = ExLlamaV2Tokenizer(config)
cache = ExLlamaV2Cache(model, lazy=True)

# Créer le générateur
generator = ExLlamaV2StreamingGenerator(model, cache, tokenizer)

# Définir les paramètres d'échantillonnage
settings = ExLlamaV2Sampler.Settings()
settings.temperature = 0.7
settings.top_k = 50
settings.top_p = 0.9

# Générer
prompt = "L'avenir de l'intelligence artificielle est"
output = generator.generate_simple(prompt, settings, num_tokens=200)
print(output)

Génération en streaming

from exllamav2.generator import ExLlamaV2StreamingGenerator

generator = ExLlamaV2StreamingGenerator(model, cache, tokenizer)

prompt = "Écris une courte histoire sur un robot :"
input_ids = tokenizer.encode(prompt)

generator.set_stop_conditions([tokenizer.eos_token_id])
generator.begin_stream(input_ids, settings)

while True:
    chunk, eos, _ = generator.stream()
    if eos:
        break
    print(chunk, end="", flush=True)

Format de discussion

def format_chat(messages):
    text = ""
    for msg in messages:
        role = msg["role"]
        content = msg["content"]
        if role == "system":
            text += f"[INST] <<SYS>>\n{content}\n<</SYS>>\n\n"
        elif role == "user":
            text += f"{content} [/INST]"
        elif role == "assistant":
            text += f" {content}</s><s>[INST] "
    return text

messages = [
    {"role": "system", "content": "Vous êtes un assistant utile."},
    {"role": "user", "content": "Qu'est-ce que Python ?"}
]

prompt = format_chat(messages)
output = generator.generate_simple(prompt, settings, num_tokens=300)

Mode serveur

Démarrer le serveur

python -m exllamav2.server \\
    --model_dir ./llama2-7b-exl2 \\
    --host 0.0.0.0 \
    --port 8080 \
    --max_seq_len 4096 \\
    --cache_size 4096

Utilisation de l’API

import requests

response = requests.post(
    "http://localhost:8080/v1/completions",
    json={
        "prompt": "Bonjour, comment allez-vous ?",
        "max_tokens": 100,
        "temperature": 0.7
    }
)

print(response.json()["choices"][0]["text"])

Complétions de chat

import openai

client = openai.OpenAI(
    base_url="http://localhost:8080/v1",
    api_key="not-needed"
)

response = client.chat.completions.create(
    model="llama2-7b",
    messages=[{"role": "user", "content": "Bonjour !"}],
    temperature=0.7
)

print(response.choices[0].message.content)

TabbyAPI (Serveur recommandé)

TabbyAPI fournit un serveur ExLlamaV2 riche en fonctionnalités :

# Cloner TabbyAPI
git clone https://github.com/theroyallab/tabbyAPI
cd tabbyAPI

# Installation
pip install -r requirements.txt

# Configurer

# Modifiez config.yml avec le chemin de votre modèle

# Exécuter
python main.py

Fonctionnalités de TabbyAPI

• API compatible avec OpenAI

• Prise en charge de plusieurs modèles

• Remplacement à chaud de LoRA

• Flux continu

• Appel de fonctions

• API d'administration

Décodage spéculatif

Utilisez un modèle plus petit pour accélérer la génération :

from exllamav2 import ExLlamaV2, ExLlamaV2Config, ExLlamaV2Cache

# Charger le modèle principal (13B)
main_config = ExLlamaV2Config()
main_config.model_dir = "./llama2-13b-exl2"
main_config.prepare()
main_model = ExLlamaV2(main_config)
main_model.load()

# Charger le modèle brouillon (7B)
draft_config = ExLlamaV2Config()
draft_config.model_dir = "./llama2-7b-exl2"
draft_config.prepare()
draft_model = ExLlamaV2(draft_config)
draft_model.load()

# Créer le générateur spéculatif
from exllamav2.generator import ExLlamaV2DraftGenerator

generator = ExLlamaV2DraftGenerator(
    main_model, draft_model,
    cache_main, cache_draft,
    tokenizer
)

# Générer (plus rapide avec la spéculation)
output = generator.generate_simple(prompt, settings, num_tokens=500)

Quantifiez vos propres modèles

Convertir en EXL2

from exllamav2 import ExLlamaV2, ExLlamaV2Config
from exllamav2.conversion import convert_model

# Source : modèle HuggingFace

# Cible : quantifié en EXL2

convert_model(
    input_dir="./llama-3.1-8b-hf",
    output_dir="./llama-3.1-8b-exl2-4bpw",
    cal_dataset="wikitext",  # Jeu de calibration
    bits=4.0,  # Bits par poids
    head_bits=6,  # Précision plus élevée pour l'attention
)

Ligne de commande

python convert.py \\
    -i ./llama-3.1-8b-hf \\
    -o ./llama-3.1-8b-exl2 \\
    -cf ./llama-3.1-8b-exl2 \\
    -b 4.0 \\
    -hb 6

Gestion de la mémoire

Allocation du cache

# Taille de cache fixe
cache = ExLlamaV2Cache(model, max_seq_len=4096)

# Cache dynamique
cache = ExLlamaV2Cache(model, lazy=True)
cache.current_seq_len = 0  # Augmente selon les besoins

Multi-GPU

config = ExLlamaV2Config()
config.model_dir = "./large-model"

# Répartir entre les GPU
config.set_auto_split([0.5, 0.5])  # 50 % par GPU

model = ExLlamaV2(config)
model.load()

Comparaison des performances

Modèle	Moteur	GPU	Jetons/s
Llama 3.1 8B	ExLlamaV2	RTX 3090	~150
Llama 3.1 8B	llama.cpp	RTX 3090	~100
Llama 3.1 8B	vLLM	RTX 3090	~120
Llama 3.1 8B	ExLlamaV2	RTX 3090	~90
Mixtral 8x7B	ExLlamaV2	A100	~70

Paramètres avancés

Paramètres d'échantillonnage

settings = ExLlamaV2Sampler.Settings()
settings.temperature = 0.7
settings.top_k = 50
settings.top_p = 0.9
settings.token_repetition_penalty = 1.1
settings.token_frequency_penalty = 0.0
settings.token_presence_penalty = 0.0
settings.mirostat = False
settings.mirostat_tau = 5.0
settings.mirostat_eta = 0.1

Génération par lots

prompts = [
    "Le sens de la vie est",
    "L'intelligence artificielle va",
    "Le changement climatique est"
]

outputs = []
for prompt in prompts:
    output = generator.generate_simple(prompt, settings, num_tokens=100)
    outputs.append(output)

Dépannage

Mémoire CUDA insuffisante

# Utiliser un cache plus petit
cache = ExLlamaV2Cache(model, max_seq_len=2048)

# Ou un modèle avec un bpw plus faible (3.0 au lieu de 4.0)

Chargement lent

# Activer le chargement rapide
config.fasttensors = True

Modèle introuvable

# Vérifier que les fichiers du modèle existent
ls ./model/

# Doit contenir : config.json, *.safetensors, tokenizer.json

Intégration avec LangChain

from langchain.llms.base import LLM
from typing import Optional, List

class ExLlamaV2LLM(LLM):
    model: ExLlamaV2
    tokenizer: ExLlamaV2Tokenizer
    generator: ExLlamaV2StreamingGenerator
    settings: ExLlamaV2Sampler.Settings

    @property
    def _llm_type(self) -> str:
        return "exllamav2"

    def _call(self, prompt: str, stop: Optional[List[str]] = None) -> str:
        return self.generator.generate_simple(prompt, self.settings, num_tokens=500)

# Utilisation
llm = ExLlamaV2LLM(model=model, tokenizer=tokenizer, generator=generator, settings=settings)
result = llm("Qu'est-ce que l'informatique quantique ?")

Estimation des coûts

Tarifs typiques du marché CLORE.AI (en 2024) :

GPU	Tarif horaire	Tarif journalier	Session de 4 heures
RTX 3060	~$0.03	~$0.70	~$0.12
RTX 3090	~$0.06	~$1.50	~$0.25
RTX 4090	~$0.10	~$2.30	~$0.40
A100 40 Go	~$0.17	~$4.00	~$0.70
A100 80 Go	~$0.25	~$6.00	~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez la place de marché CLORE.AI les tarifs actuels.

Économisez de l'argent :

• Utilisez le Spot marché pour les travaux interrompables — environ un tiers des serveurs ont un prix spot inférieur au tarif à la demande (médiane ~13 % de remise), les autres s'alignent dessus

• Payez avec CLORE jetons

• Comparez les prix entre différents fournisseurs

Étapes suivantes

• Inférence vLLM - service à haut débit

• Serveur llama.cpp - Multiplateforme

• Text Generation WebUI - Interface Web