Text Generation WebUI

Exécutez text-generation-webui pour l'inférence LLM sur les GPU Clore.ai

Exécutez l’interface LLM la plus populaire avec prise en charge de tous les formats de modèles.

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>

Pourquoi Text Generation WebUI ?

• Prend en charge les formats GGUF, GPTQ, AWQ, EXL2, HF

• Modes chat, notebook et API intégrés

• Extensions : voix, personnages, multimodal

• Prise en charge du fine-tuning

• Changement de modèle à la volée

Exigences

Taille du modèle	VRAM minimale	Recommandé
7B (Q4)	6 Go	RTX 3060
13B (Q4)	10GB	RTX 3080
30B (Q4)	20 Go	RTX 4090
70B (Q4)	40 Go	A100

Déploiement rapide

Image Docker :

atinoda/text-generation-webui:default-nvidia

Ports :

22/tcp
7860/http
5000/http
5005/http

Environnement :

EXTRA_LAUNCH_ARGS=--listen --api

Installation manuelle

Image :

nvidia/cuda:12.8.1-devel-ubuntu22.04

Ports :

22/tcp
7860/http
5000/http

Commande :

apt-get update && apt-get install -y git python3 python3-pip && \
cd /workspace && \
git clone https://github.com/oobabooga/text-generation-webui.git && \
cd text-generation-webui && \
pip install -r requirements.txt && \
python server.py --listen --api

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.

Accéder à l’interface WebUI

1. Attendez le déploiement

2. Trouvez le mappage du port 7860 dans Mes commandes

3. Ouvrir : http://<proxy>:<port>

Télécharger les modèles

Depuis HuggingFace (dans WebUI)

1. Accédez à Modèle onglet

2. Entrez le nom du modèle : bartowski/Meta-Llama-3.1-8B-Instruct-GGUF

3. Cliquez sur Télécharger

Via la ligne de commande

cd /workspace/text-generation-webui

# Télécharger le modèle GGUF
python download-model.py bartowski/Meta-Llama-3.1-8B-Instruct-GGUF

# Télécharger un fichier spécifique
python download-model.py bartowski/Meta-Llama-3.1-8B-Instruct-GGUF --specific-file Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf

Modèles recommandés

Pour le chat :

# Llama 2 Chat (7B, rapide)
python download-model.py bartowski/Meta-Llama-3.1-8B-Instruct-GGUF

# Mistral Instruct (excellent)
python download-model.py bartowski/Mistral-7B-Instruct-v0.3-GGUF

# OpenHermes (excellent modèle polyvalent)
python download-model.py bartowski/OpenHermes-2.5-Mistral-7B-GGUF

Pour le codage :

# CodeLlama
python download-model.py bartowski/CodeLlama-13B-Instruct-GGUF

# DeepSeek Coder
python download-model.py bartowski/DeepSeek-Coder-V2-Lite-Instruct-GGUF

Pour le jeu de rôle :

# MythoMax
python download-model.py bartowski/MythoMax-L2-13B-GGUF

Chargement des modèles

GGUF (recommandé pour la plupart des utilisateurs)

1. Modèle onglet → Sélectionnez le dossier du modèle

2. Chargeur de modèle : llama.cpp

3. Définissez n-gpu-layers :

   • RTX 3090 : 35-40

   • RTX 4090 : 45-50

   • A100 : 80+

4. Cliquez sur Charger

GPTQ (rapide, quantifié)

1. Télécharger le modèle GPTQ

2. Chargeur de modèle : ExLlama_HF ou AutoGPTQ

3. Charger le modèle

EXL2 (meilleure vitesse)

# Installer exllamav2
pip install exllamav2

1. Télécharger le modèle EXL2

2. Chargeur de modèle : ExLlamav2_HF

3. Charger

Configuration du chat

Configuration du personnage

1. Accédez à Paramètres → Personnage

2. Créer ou charger une carte de personnage

3. Définir :

   • Nom

   • Contexte/persona

   • Dialogue d'exemple

Mode Instruct

Pour les modèles ajustés pour les instructions :

1. Paramètres → Modèle d'instructions

2. Sélectionnez le modèle correspondant à votre modèle :

   • Llama-2-chat

   • Mistral

   • ChatML

   • Alpaca

Utilisation de l’API

Activer l'API

Commencez avec --api option (port par défaut 5000)

API compatible avec OpenAI

import openai

openai.api_base = "http://localhost:5000/v1"
openai.api_key = "not-needed"

response = openai.ChatCompletion.create(
    model="any",
    messages=[{"role": "user", "content": "Hello!"}]
)
print(response.choices[0].message.content)

API native

import requests

response = requests.post(
    "http://localhost:5000/api/v1/generate",
    json={
        "prompt": "Write a story about",
        "max_new_tokens": 200,
        "temperature": 0.7
    }
)
print(response.json()["results"][0]["text"])

Extensions

Installation des extensions

cd /workspace/text-generation-webui/extensions

# Silero TTS (voix)
git clone https://github.com/oobabooga/text-generation-webui-extensions

# SuperBoogav2 (RAG/mémoire à long terme)

# Déjà inclus, activez-le dans l’interface

Activer les extensions

1. Session onglet → Extensions

2. Cochez les cases des extensions souhaitées

3. Cliquez sur Appliquer et redémarrer

Extensions populaires

Extension	Objectif
silero_tts	Sortie vocale
whisper_stt	Entrée vocale
superbooga	Questions-réponses sur documents
sd_api_pictures	Génération d'images
multimodal	Compréhension d'image

Optimisation des performances

Paramètres GGUF

n_gpu_layers: 35    # Couches GPU (plus = plus rapide)
n_ctx: 4096         # Longueur du contexte
n_batch: 512        # Taille du lot
threads: 8          # Threads CPU

Optimisation de la mémoire

Pour une VRAM limitée :

python server.py --listen --n-gpu-layers 20 --no-mmap

Optimisation de la vitesse

# Utiliser llama.cpp avec cuBLAS
python server.py --listen --loader llama.cpp --n-gpu-layers 50 --threads 8

Ajustement fin (LoRA)

Onglet d'entraînement

1. Accédez à Entraînement onglet

2. Charger le modèle de base

3. Importer le jeu de données (format JSON)

4. Configurer :

   • Rang LoRA : 8-32

   • Taux d'apprentissage : 1e-4

   • Époques : 3-5

5. Lancez l’entraînement

Format du jeu de données

[
  {"instruction": "Résumez ceci :", "input": "Long texte...", "output": "Résumé..."},
  {"instruction": "Traduire en français :", "input": "Hello", "output": "Bonjour"}
]

Sauvegarder votre travail

# Sauvegarder les modèles
rsync -avz /workspace/text-generation-webui/models/ backup-server:/models/

# Sauvegarder les personnages
rsync -avz /workspace/text-generation-webui/characters/ backup-server:/characters/

# Sauvegarder les LoRA
rsync -avz /workspace/text-generation-webui/loras/ backup-server:/loras/

Dépannage

Le modèle ne se charge pas

• Vérifiez l'utilisation de la VRAM : nvidia-smi

• Réduisez n_gpu_layers

• Utilisez une quantification plus petite (Q4_K_M → Q4_K_S)

Génération lente

• Augmentez n_gpu_layers

• Utilisez EXL2 au lieu de GGUF

• Activer --no-mmap

Mémoire insuffisante

pendant la génération - Réduisez `n_ctx` (longueur du contexte) - Utilisez `--n-gpu-layers 0` pour un usage CPU uniquement - Essayez un modèle plus petit

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