TGI (Text Generation Inference)

Exécutez HuggingFace Text Generation Inference (TGI) pour la mise en service de LLM en production sur les GPU Clore.ai

Text Generation Inference (TGI) est le framework de diffusion de LLM prêt pour la production de HuggingFace, conçu pour une inférence à haut débit et à faible latence. Il prend en charge Flash Attention 2, le batching continu, PagedAttention et le parallélisme tensoriel dès le départ — ce qui en fait 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 la place de marché CLORE.AI.

Exigences du serveur

Paramètre	Minimum	Recommandé
RAM	16 Go	32 Go+
VRAM	8 Go	24 Go+
Disque	50 Go	200 Go+
GPU	Tout 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 basculera automatiquement vers 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	ID du modèle HuggingFace
HF_TOKEN	hf_xxx...	Jeton HuggingFace (pour les modèles à accès restreint)
NUM_SHARD	2	Nombre de GPU pour le parallélisme tensoriel
MAX_INPUT_LENGTH	4096	Nombre maximal de tokens en entrée
MAX_TOTAL_TOKENS	8192	Nombre maximal de tokens d'entrée + de sortie
QUANTIZE	bitsandbytes-nf4	Méthode de quantification

Configuration étape par étape

1. Louez un serveur GPU sur CLORE.AI

Accédez à la place de marché CLORE.AI 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

Une fois votre commande confirmée, connectez-vous à votre serveur en utilisant les détails SSH de votre tableau de bord CLORE.AI :

ssh -p <PORT> root@<SERVER_IP>

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

3. Télécharger 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 un jeton HuggingFace (pour les modèles à accès restreint 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 faible) :

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 journaux
docker logs -f tgi

# Attendez le message "Connected", puis testez :
curl http://localhost:8080/health

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

6. Accédez via le proxy HTTP CLORE.AI

Dans votre panneau de 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 simple

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 API de complétions de chat OpenAI :

curl http://localhost:8080/v1/chat/completions \\
  -X POST \
  -H 'Content-Type: application/json' \\
  -d '{
    "model": "tgi",
    "messages": [
      {"role": "system", "content": "Vous êtes un assistant utile."},
      {"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 CLORE.AI http_pub
client = InferenceClient(model="http://localhost:8080")

# Génération simple
response = client.text_generation(
    "Traduisez en français : Bonjour, comment allez-vous ?",
    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 lots

import requests

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

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}\nRéponse : {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 shards GPU (parallélisme tensoriel)
--max-concurrent-requests	128	Nombre maximal de requêtes simultanées
--max-input-length	1024	Longueur maximale des tokens d'entrée
--max-total-tokens	2048	Nombre maximal de tokens d'entrée + de sortie
--max-batch-total-tokens	auto	Nombre maximal de tokens par lot
--quantize	aucun	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 téléchargé un modèle 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 automatiquement activé sur les GPU Ampere+ (RTX 3000+, A100, H100). Aucune configuration supplémentaire n'est nécessaire.

2. Ajuster la taille maximale des lots

Pour les scénarios à haut débit, augmentez la taille du lot :

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

3. Utiliser bfloat16 sur les GPU Ampere+

--dtype bfloat16

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

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

# Sur le serveur, pré-téléchargez avant de lancer 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')
"

Montez ensuite le chemin local pour éviter un nouveau téléchargement 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 de plus petits modèles comme brouillon :

--speculate 4  # Nombre de tokens spéculatifs

---

Dépannage

Problème : "CUDA out of memory"

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

Solution : Réduisez --max-total-tokens ou activez 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 is required"

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 dans la 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

# Correctif courant : augmenter la mémoire partagée
--shm-size 2g

---

Liens

• GitHub

• Documentation

• Docker Hub / GHCR

• Modèles pris en charge

• la place de marché CLORE.AI

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Production (7B–13B)	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Grands modèles (70B+)	A100 80 Go / H100	~1,04 $/GPU/heure

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