ExLlamaV2

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

Exécutez les LLMs à pleine vitesse avec ExLlamaV2.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

Visitez CLORE.AI Marketplace
Filtrer par type de GPU, VRAM et prix
Choisir À la demande (tarif fixe) ou Spot (prix d'enchère)
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
Sélectionnez le paiement : CLORE, BTC, ou USDT/USDC
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@<adresse-proxy>

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
Excellente quantification (EXL2)
Faible utilisation de VRAM
Prend en charge le décodage spéculatif

Exigences

Taille du modèle

VRAM min

Recommandé

6 Go

RTX 3060

13B

10Go

RTX 3090

34B

20Go

RTX 4090

70B

40Go

A100

Déploiement rapide

Image Docker :

pytorch/pytorch:2.5.1-cuda12.4-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:

Aller à la Mes commandes page
Cliquez sur votre commande
Trouvez l' http_pub URL (par ex., abc123.clorecloud.net)

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

Installation


# Installer depuis PyPI
pip install exllamav2

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

Télécharger des 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

~3 Go

3.0

Bon

~4 Go

4.0

Excellent

~5 Go

5.0

Excellent

~6 Go

6.0

Proche du FP16

~7 Go

API Python

Génération basique

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 chat

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 serviable."},
    {"role": "user", "content": "What is 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 ça va ?",
        "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="non-nécessaire"
)

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

# Installer
pip install -r requirements.txt

# Configurer

# Éditez config.yml avec le chemin de votre modèle

# Exécuter
python main.py

Fonctionnalités de TabbyAPI

API compatible OpenAI
Prise en charge de plusieurs modèles
Hot-swapping LoRA
Streaming
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 de 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é EXL2

convert_model(
    input_dir="./llama-3.1-8b-hf",
    output_dir="./llama-3.1-8b-exl2-4bpw",
    cal_dataset="wikitext",  # Jeu de données de calibration
    bits=4.0,  # Bits par poids
    head_bits=6,  # Précision supérieure 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  # Croît selon les besoins

Multi-GPU

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

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

model = ExLlamaV2(config)
model.load()

Comparaison des performances

Modèle

Moteur

GPU

Tokens/sec

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 lot

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

CUDA Out of Memory


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

# Ou modèle avec bpw inférieur (3.0 au lieu de 4.0)

Chargement lent


# Activer le chargement rapide
config.fasttensors = True

Modèle introuvable


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

# Devrait 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 (à partir de 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 40GB

~$0.17

~$4.00

~$0.70

A100 80GB

~$0.25

~$6.00

~$1.00

Les prix varient selon le fournisseur et la demande. Vérifiez CLORE.AI Marketplace pour les tarifs actuels.

Économisez de l'argent :

Utilisez Spot market pour les charges de travail flexibles (souvent 30-50 % moins cher)
Payer avec CLORE jetons
Comparer les prix entre différents fournisseurs

Prochaines étapes

vLLM Inference - Service à haut débit
Serveur llama.cpp - Multi-plateforme
Text Generation WebUI - Interface web

PrécédentText Generation WebUI SuivantLocalAI

Mis à jour il y a 1 jour

Ce contenu vous a-t-il été utile ?

hashtagLocation sur CLORE.AI

hashtagAccédez à votre serveur

hashtagQu'est-ce qu'ExLlamaV2 ?

hashtagExigences

hashtagDéploiement rapide

hashtagAccéder à votre service

hashtagInstallation

hashtagTélécharger des modèles

hashtagModèles quantifiés EXL2

hashtagBits par poids (bpw)

hashtagAPI Python

hashtagGénération basique

hashtagGénération en streaming

hashtagFormat de chat

hashtagMode Serveur

hashtagDémarrer le serveur

hashtagUtilisation de l'API

hashtagComplétions de chat

hashtagTabbyAPI (Serveur recommandé)

hashtagFonctionnalités de TabbyAPI

hashtagDécodage spéculatif

hashtagQuantifiez vos propres modèles

hashtagConvertir en EXL2

hashtagLigne de commande

hashtagGestion de la mémoire

hashtagAllocation du cache

hashtagMulti-GPU

hashtagComparaison des performances

hashtagParamètres avancés

hashtagParamètres d'échantillonnage

hashtagGénération par lot

hashtagDépannage

hashtagCUDA Out of Memory

hashtagChargement lent

hashtagModèle introuvable

hashtagIntégration avec LangChain

hashtagEstimation des coûts

hashtagProchaines étapes

Location sur CLORE.AI

Accédez à votre serveur

Qu'est-ce qu'ExLlamaV2 ?

Exigences

Déploiement rapide

Accéder à votre service

Installation

Télécharger des modèles

Modèles quantifiés EXL2

Bits par poids (bpw)

API Python

Génération basique

Génération en streaming

Format de chat

Mode Serveur

Démarrer le serveur

Utilisation de l'API

Complétions de chat

TabbyAPI (Serveur recommandé)

Fonctionnalités de TabbyAPI

Décodage spéculatif

Quantifiez vos propres modèles

Convertir en EXL2

Ligne de commande

Gestion de la mémoire

Allocation du cache

Multi-GPU

Comparaison des performances

Paramètres avancés

Paramètres d'échantillonnage

Génération par lot

Dépannage

CUDA Out of Memory

Chargement lent

Modèle introuvable

Intégration avec LangChain

Estimation des coûts

Prochaines étapes