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 CLORE.AI Marketplace.

Location sur CLORE.AI

1. Visitez CLORE.AI Marketplace

2. Filtrer par type de GPU, VRAM et prix

3. Choisir À 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@<adresse-proxy>

Pourquoi Text Generation WebUI ?

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

• Modes chat, carnet 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 min	Recommandé
7B (Q4)	6 Go	RTX 3060
13B (Q4)	10Go	RTX 3080
30B (Q4)	20Go	RTX 4090
70B (Q4)	40Go	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.1.0-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. Aller à la Mes commandes page

2. Cliquez sur votre commande

3. 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.

Accéder à WebUI

1. Attendre le déploiement

2. Trouver le mappage du port 7860 dans Mes commandes

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

Télécharger des modèles

Depuis HuggingFace (dans WebUI)

1. Aller à la Modèle onglet

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

3. Cliquez 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 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électionner le dossier du modèle

2. Chargeur de modèle : llama.cpp

3. Définir n-gpu-layers :

   • RTX 3090 : 35-40

   • RTX 4090 : 45-50

   • A100 : 80+

4. Cliquez 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. Aller à la Paramètres → Personnage

2. Créer ou charger une fiche de personnage

3. Définir :

   • Nom

   • Contexte/persona

   • Dialogue exemple

Mode Instruct

Pour les modèles ajustés par instruction :

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

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

   • Llama-2-chat

   • Mistral

   • ChatML

   • Alpaca

Utilisation de l'API

Activer l'API

Commencez par --api flag (port par défaut 5000)

API compatible 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": "Bonjour !"}]
)
print(response.choices[0].message.content)

API native

import requests

response = requests.post(
    "http://localhost:5000/api/v1/generate",
    json={
        "prompt": "Écrire une histoire sur",
        "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, activer dans l'UI

Activer les extensions

1. Session onglet → Extensions

2. Cochez les cases des extensions souhaitées

3. Cliquez Appliquer et redémarrer

Extensions populaires

Extension	But
silero_tts	Sortie vocale
whisper_stt	Entrée vocale
superbooga	Questions/Réponses de documents
sd_api_pictures	Génération d'images
multimodal	Compréhension d'image

Réglage 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

Fine-tuning (LoRA)

Onglet d'entraînement

1. Aller à la Entraînement onglet

2. Charger le modèle de base

3. Téléverser le jeu de données (format JSON)

4. Configurer :

   • Rang LoRA : 8-32

   • Taux d'apprentissage : 1e-4

   • Époques : 3-5

5. Démarrer l'entraînement

Format du jeu de données

[
  {"instruction": "Résumé :", "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érifier l'utilisation de la VRAM : nvidia-smi

• Réduire n_gpu_layers

• Utiliser une quantification plus petite (Q4_K_M → Q4_K_S)

Génération lente

• Augmentez n_gpu_layers

• Utiliser EXL2 au lieu de GGUF

• Activez --no-mmap

Mémoire insuffisante

pendant la génération - Réduire `n_ctx` (longueur du contexte) - Utiliser `--n-gpu-layers 0` pour CPU uniquement - Essayer un modèle plus petit

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