Text Generation WebUI

Ejecuta text-generation-webui para inferencia LLM en GPUs de Clore.ai

Ejecuta la interfaz de LLM más popular con soporte para todos los formatos de modelo.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

Alquilar en CLORE.AI

1. Visita CLORE.AI Marketplace

2. Filtrar por tipo de GPU, VRAM y precio

3. Elegir Bajo demanda (tarifa fija) o Spot (precio de puja)

4. Configura tu pedido:

   • Selecciona imagen Docker

   • Establece puertos (TCP para SSH, HTTP para interfaces web)

   • Agrega variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera el despliegue

Accede a tu servidor

• Encuentra los detalles de conexión en Mis Pedidos

• Interfaces web: Usa la URL del puerto HTTP

• SSH: ssh -p <port> root@<proxy-address>

¿Por qué Text Generation WebUI?

• Admite formatos GGUF, GPTQ, AWQ, EXL2, HF

• Modos integrados: chat, cuaderno y API

• Extensiones: voz, personajes, multimodal

• Soporte para fine-tuning

• Cambio de modelo sobre la marcha

Requisitos

Tamaño del modelo	VRAM mínima	Recomendado
7B (Q4)	6GB	RTX 3060
13B (Q4)	10GB	RTX 3080
30B (Q4)	20GB	RTX 4090
70B (Q4)	40GB	A100

Despliegue rápido

Imagen Docker:

atinoda/text-generation-webui:default-nvidia

Puertos:

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

Entorno:

EXTRA_LAUNCH_ARGS=--listen --api

Instalación manual

Imagen:

nvidia/cuda:12.1.0-devel-ubuntu22.04

Puertos:

22/tcp
7860/http
5000/http

Comando:

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

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis Pedidos:

1. Ir a Mis Pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Acceder a WebUI

1. Esperar a que se despliegue

2. Buscar el mapeo del puerto 7860 en Mis Pedidos

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

Descargar modelos

Desde HuggingFace (en WebUI)

1. Ir a Modelo pestaña

2. Ingrese el nombre del modelo: bartowski/Meta-Llama-3.1-8B-Instruct-GGUF

3. Hacer clic Descargar

Vía línea de comandos

cd /workspace/text-generation-webui

# Descargar modelo GGUF
python download-model.py bartowski/Meta-Llama-3.1-8B-Instruct-GGUF

# Descargar archivo específico
python download-model.py bartowski/Meta-Llama-3.1-8B-Instruct-GGUF --specific-file Meta-Llama-3.1-8B-Instruct-Q4_K_M.gguf

Modelos recomendados

Para chat:

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

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

# OpenHermes (gran todoterreno)
python download-model.py bartowski/OpenHermes-2.5-Mistral-7B-GGUF

Para programación:

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

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

Para juegos de roles:

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

Cargando modelos

GGUF (Recomendado para la mayoría de los usuarios)

1. Modelo pestaña → Seleccionar carpeta del modelo

2. Cargador de modelos: llama.cpp

3. Establecer n-gpu-layers:

   • RTX 3090: 35-40

   • RTX 4090: 45-50

   • A100: 80+

4. Hacer clic Cargar

GPTQ (rápido, cuantizado)

1. Descargar modelo GPTQ

2. Cargador de modelos: ExLlama_HF o AutoGPTQ

3. Cargar modelo

EXL2 (Mejor velocidad)

# Instalar exllamav2
pip install exllamav2

1. Descargar modelo EXL2

2. Cargador de modelos: ExLlamav2_HF

3. Cargar

Configuración de chat

Configuración de personaje

1. Ir a Parámetros → Personaje

2. Crear o cargar ficha de personaje

3. Establecer:

   • Nombre

   • Contexto/persona

   • Diálogo de ejemplo

Modo Instruct

Para modelos afinados con instrucciones:

1. Parámetros → Plantilla de instrucción

2. Seleccionar la plantilla que coincida con su modelo:

   • Llama-2-chat

   • Mistral

   • ChatML

   • Alpaca

Uso de la API

Habilitar API

Comience con --api bandera (puerto predeterminado 5000)

API compatible con OpenAI

import openai

openai.api_base = "http://localhost:5000/v1"
openai.api_key = "no-necesaria"

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

API nativa

import requests

response = requests.post(
    "http://localhost:5000/api/v1/generate",
    json={
        "prompt": "Escribe una historia sobre",
        "max_new_tokens": 200,
        "temperature": 0.7
    }
)
print(response.json()["results"][0]["text"])

Extensiones

Instalando extensiones

cd /workspace/text-generation-webui/extensions

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

# SuperBoogav2 (RAG/memoria a largo plazo)

# Ya incluido, habilitar en la UI

Habilitar extensiones

1. Sesión pestaña → Extensiones

2. Marcar las casillas de las extensiones deseadas

3. Hacer clic Aplicar y reiniciar

Extensiones populares

Extensión	Propósito
silero_tts	Salida de voz
whisper_stt	Entrada de voz
superbooga	Preguntas y respuestas sobre documentos
sd_api_pictures	Generación de imágenes
multimodal	Comprensión de imágenes

Ajuste de rendimiento

Configuración GGUF

n_gpu_layers: 35    # Capas de GPU (más = más rápido)
n_ctx: 4096         # Longitud del contexto
n_batch: 512        # Tamaño del lote
threads: 8          # Hilos de CPU

Optimización de memoria

Para VRAM limitada:

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

Optimización de velocidad

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

Ajuste fino (LoRA)

Pestaña de entrenamiento

1. Ir a Entrenamiento pestaña

2. Cargar modelo base

3. Subir conjunto de datos (formato JSON)

4. Configurar:

   • Rango LoRA: 8-32

   • Tasa de aprendizaje: 1e-4

   • Épocas: 3-5

5. Iniciar entrenamiento

Formato del conjunto de datos

[
  {"instruction": "Resume esto:", "input": "Texto largo...", "output": "Resumen..."},
  {"instruction": "Traducir al francés:", "input": "Hello", "output": "Bonjour"}
]

Guardando tu trabajo

# Guardar modelos
rsync -avz /workspace/text-generation-webui/models/ backup-server:/models/

# Guardar personajes
rsync -avz /workspace/text-generation-webui/characters/ backup-server:/characters/

# Guardar LoRAs
rsync -avz /workspace/text-generation-webui/loras/ backup-server:/loras/

Solución de problemas

El modelo no se carga

• Comprobar el uso de VRAM: nvidia-smi

• Reducir n_gpu_layers

• Usar cuantización más pequeña (Q4_K_M → Q4_K_S)

Generación lenta

• Aumente n_gpu_layers

• Usar EXL2 en lugar de GGUF

• Habilite --no-mmap

Fuera de memoria

durante la generación - Reducir `n_ctx` (longitud del contexto) - Usar `--n-gpu-layers 0` para solo CPU - Probar un modelo más pequeño

Estimación de costos

Tarifas típicas del marketplace de CLORE.AI (a fecha de 2024):

GPU	Tarifa por hora	Tarifa diaria	Sesión de 4 horas
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

Los precios varían según el proveedor y la demanda. Consulta CLORE.AI Marketplace para las tarifas actuales.

Ahorra dinero:

• Usa Spot market para cargas de trabajo flexibles (a menudo 30-50% más barato)

• Paga con CLORE tokens

• Compara precios entre diferentes proveedores