TGI (Text Generation Inference)

Exécuter HuggingFace Text Generation Inference (TGI) pour le déploiement en production de LLM sur les GPU Clore.ai

Text Generation Inference (TGI) est le framework de service de modèles de langage à l'échelle de production de HuggingFace, conçu pour des inférences à haut débit et à faible latence. Il prend en charge Flash Attention 2, le batching continu, PagedAttention et le parallélisme tensoriel dès la sortie de la boîte — en faisant la solution de référence pour déployer des grands modèles de langage à grande échelle sur les serveurs GPU CLORE.AI.

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

Exigences serveur

Paramètre	Minimum	Recommandé
RAM	16 Go	32 Go+
VRAM	8 Go	24 Go+
Disque	50 Go	200 Go+
GPU	N'importe quel GPU NVIDIA (Ampere+ pour Flash Attention)	A100, H100, RTX 4090

Flash Attention 2 nécessite une architecture Ampere ou plus récente (RTX 3000+, A100, H100). Pour les GPU plus anciens, TGI reviendra automatiquement à l'attention standard.

Déploiement rapide sur CLORE.AI

Image Docker : ghcr.io/huggingface/text-generation-inference:latest

Ports : 22/tcp, 8080/http

Variables d’environnement :

Variable	Exemple	Description
MODEL_ID	mistralai/Mistral-7B-Instruct-v0.3	Identifiant de modèle HuggingFace
HF_TOKEN	hf_xxx...	Jeton HuggingFace (pour les modèles protégés)
NUM_SHARD	2	Nombre de GPU pour le parallélisme tensoriel
MAX_INPUT_LENGTH	4096	Nombre maximal de tokens d'entrée
MAX_TOTAL_TOKENS	8192	Nombre maximal de tokens entrée + sortie
QUANTIZE	bitsandbytes-nf4	Méthode de quantification

Configuration étape par étape

1. Louez un serveur GPU sur CLORE.AI

Aller à CLORE.AI Marketplace et filtrer les serveurs par :

• VRAM ≥ 24 Go pour les modèles 7B (précision complète)

• VRAM ≥ 12 Go pour les modèles 7B (quantification 4 bits)

• VRAM ≥ 80 Go pour les modèles 70B (précision complète, GPU unique)

2. Se connecter via SSH

Après la confirmation de votre commande, connectez-vous à votre serveur en utilisant les détails SSH depuis votre tableau de bord CLORE.AI :

ssh -p <PORT> root@<SERVER_IP>

Ou utilisez le terminal web depuis le panneau de votre commande CLORE.AI.

3. Récupérer l'image Docker TGI

docker pull ghcr.io/huggingface/text-generation-inference:latest

4. Lancer TGI avec un modèle

Lancement de base (Mistral 7B) :

docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /root/models:/data \
  -e MODEL_ID=mistralai/Mistral-7B-Instruct-v0.3 \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id mistralai/Mistral-7B-Instruct-v0.3 \
  --max-input-length 4096 \
  --max-total-tokens 8192

Avec le token HuggingFace (pour les modèles protégés comme Llama 3) :

docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /root/models:/data \
  -e HUGGING_FACE_HUB_TOKEN=hf_your_token_here \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id meta-llama/Meta-Llama-3-8B-Instruct \
  --max-input-length 8192 \
  --max-total-tokens 16384

Avec quantification 4 bits (pour une VRAM plus petite) :

docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /root/models:/data \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id mistralai/Mixtral-8x7B-Instruct-v0.1 \
  --quantize bitsandbytes-nf4 \
  --max-input-length 4096 \
  --max-total-tokens 8192

Parallélisme tensoriel multi-GPU (pour les modèles 70B) :

docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 2g \
  -p 8080:80 \
  -v /root/models:/data \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id meta-llama/Meta-Llama-3-70B-Instruct \
  --num-shard 2 \
  --max-input-length 8192 \
  --max-total-tokens 16384

5. Vérifier que le serveur fonctionne

# Vérifier les logs
docker logs -f tgi

# Attendre le message "Connected", puis tester :
curl http://localhost:8080/health

Réponse attendue : {"status":"ok"}

6. Accéder via le proxy HTTP de CLORE.AI

Dans le panneau de votre commande CLORE.AI, vous verrez votre http_pub URL pour le port 8080. Cela permet l'accès via navigateur/API sans tunnel SSH :

https://<order-id>.clore.ai/

---

Exemples d’utilisation

Exemple 1 : Génération de texte basique

curl http://localhost:8080/generate \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "inputs": "Quelle est la capitale de la France ?",
    "parameters": {
      "max_new_tokens": 100,
      "temperature": 0.7
    }
  }'

Exemple 2 : Complétions de chat (compatible OpenAI)

TGI prend en charge le format d'API de complétions de chat d'OpenAI :

curl http://localhost:8080/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "tgi",
    "messages": [
      {"role": "system", "content": "You are a helpful assistant."},
      {"role": "user", "content": "Expliquez l'intrication quantique en termes simples."}
    ],
    "max_tokens": 512,
    "temperature": 0.8,
    "stream": false
  }'

Exemple 3 : Réponse en streaming

curl http://localhost:8080/generate_stream \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "inputs": "Écrivez une fonction Python pour calculer les nombres de Fibonacci :",
    "parameters": {
      "max_new_tokens": 300,
      "temperature": 0.2
    }
  }' \
  --no-buffer

Exemple 4 : Client Python

from huggingface_hub import InferenceClient

# Remplacez par votre URL http_pub CLORE.AI
client = InferenceClient(model="http://localhost:8080")

# Génération simple
response = client.text_generation(
    "Traduire en français : Hello, how are you?",
    max_new_tokens=100,
    temperature=0.7,
)
print(response)

# Chat
for token in client.chat_completion(
    messages=[{"role": "user", "content": "Qu'est-ce que l'apprentissage automatique ?"}],
    max_tokens=200,
    stream=True,
):
    print(token.choices[0].delta.content, end="", flush=True)

Exemple 5 : Requêtes par lot

import requests

BASE_URL = "http://localhost:8080"  # ou votre URL http_pub CLORE.AI

prompts = [
    "Résumez la Révolution française en 3 phrases.",
    "Écrivez un haïku sur le calcul GPU.",
    "Quels sont les principaux avantages de Rust par rapport à C++ ?",
]

results = []
for prompt in prompts:
    response = requests.post(
        f"{BASE_URL}/generate",
        json={"inputs": prompt, "parameters": {"max_new_tokens": 150}},
    )
    results.append(response.json()["generated_text"])

for prompt, result in zip(prompts, results):
    print(f"Prompt: {prompt}\nAnswer: {result}\n{'-'*50}")

---

Configuration

Paramètres CLI clés

Paramètre	Par défaut	Description
--model-id	requis	ID du modèle HuggingFace ou chemin local
--num-shard	1	Nombre de fragments GPU (parallélisme tensoriel)
--max-concurrent-requests	128	Nombre maximum de requêtes simultanées
--max-input-length	1024	Longueur maximale des tokens d'entrée
--max-total-tokens	2048	Nombre maximal de tokens entrée + sortie
--max-batch-total-tokens	auto	Nombre maximal de tokens par lot
--quantize	aucune	Quantification : bitsandbytes-nf4, gptq, awq
--dtype	auto	float16, bfloat16
--trust-remote-code	false	Autoriser le code personnalisé du modèle
--port	80	Port du serveur

Utilisation d'un modèle local

Si vous avez un modèle téléchargé localement :

docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /path/to/your/model:/model \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id /model

Quantification AWQ (plus rapide que NF4)

docker run -d \
  --name tgi \
  --gpus all \
  --shm-size 1g \
  -p 8080:80 \
  -v /root/models:/data \
  ghcr.io/huggingface/text-generation-inference:latest \
  --model-id casperhansen/mistral-7b-instruct-v0.2-awq \
  --quantize awq

---

Conseils de performance

1. Activer Flash Attention 2

Flash Attention 2 est activé automatiquement sur les GPU Ampere+ (RTX 3000+, A100, H100). Aucune configuration supplémentaire requise.

2. Ajuster la taille maximale de lot

Pour des scénarios à haut débit, augmentez la taille de lot :

--max-batch-total-tokens 32000 \
--max-waiting-tokens 20

3. Utiliser bfloat16 sur les GPU Ampere+

--dtype bfloat16

Ceci est plus stable numériquement que le float16 et offre des performances identiques sur les GPU modernes.

4. Pré-télécharger les modèles vers un stockage persistant

# Sur le serveur, pré-téléchargez avant de démarrer TGI
pip install huggingface_hub
python -c "
from huggingface_hub import snapshot_download
snapshot_download('mistralai/Mistral-7B-Instruct-v0.3', local_dir='/root/models/mistral-7b')
"

Ensuite, montez le chemin local pour éviter de retélécharger lors des redémarrages.

5. Gestion de la mémoire GPU

Pour RTX 3090/4090 (24 Go de VRAM) :

# Le modèle 7B en float16 tient parfaitement
--max-total-tokens 8192

# Le modèle 13B nécessite une quantification
--quantize bitsandbytes-nf4
--max-total-tokens 4096

6. Décodage spéculatif

Pour une génération plus rapide avec des modèles plus petits en tant que brouillon :

--speculate 4  # Nombre de tokens spéculatifs

---

Dépannage

Problème : "CUDA out of memory"

Erreur : CUDA out of memory. Tentative d'allouer X Gio

Solution : Réduire --max-total-tokens ou activer la quantification :

--quantize bitsandbytes-nf4
--max-total-tokens 4096

Problème : le téléchargement du modèle est lent

Solution : Utilisez un miroir HuggingFace ou pré-téléchargez :

# Définir le miroir
-e HF_ENDPOINT=https://hf-mirror.com

Problème : serveur inaccessible via http_pub

Solution : Assurez-vous que le port 8080 est correctement mappé. TGI écoute sur le port 80 en interne, mais vous le mappez sur 8080 en externe :

-p 8080:80  # hôte:conteneur

Problème : "trust_remote_code est requis"

Certains modèles (par ex., Falcon, Phi) nécessitent du code personnalisé :

--trust-remote-code

Problème : première réponse lente

La première requête déclenche le chargement du modèle en VRAM. C'est normal. Les requêtes suivantes seront rapides.

# Vérifier la progression du chargement
docker logs -f tgi | grep -E "Connected|Error|Loading"

Problème : le conteneur se ferme immédiatement

# Vérifier les erreurs
docker logs tgi

# Solution courante : augmenter la mémoire partagée
--shm-size 2g

---

Liens

• GitHub

• Documentation

• Docker Hub / GHCR

• Modèles pris en charge

• CLORE.AI Marketplace

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24GB)	~$0.12/gpu/hr
Production (7B–13B)	RTX 4090 (24GB)	~$0.70/gpu/hr
Grands modèles (70B+)	A100 80GB / H100	~$1.20/gpu/hr

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.