# Text Generation WebUI

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

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://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 :**

```bash
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

```bash
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 :**

```bash

# 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 :**

```bash

# 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 :**

```bash

# 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)

```bash

# 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

```python
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

```python
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

```bash
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 :

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

### Optimisation de la vitesse

```bash

# 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

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

## Sauvegarder votre travail

```bash

# 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`

{% hint style="danger" %}
**Mémoire insuffisante**
{% endhint %}

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*](https://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