Aphrodite Engine

Ejecuta Aphrodite Engine para inferencia de LLM en GPUs antiguas y modernas en Clore.ai

Aphrodite Engine es un servidor de inferencia LLM optimizado construido sobre vLLM, diseñado específicamente para la comunidad de escritura creativa y roleplay. Admite una amplia gama de GPUs desde Pascal (serie GTX 1000), lo que lo convierte en la opción perfecta para ejecutar modelos de lenguaje en servidores GPU CLORE.AI antiguos o económicos donde otros marcos fallan. Aphrodite añade APIs compatibles con Kobold, muestreo Mirostat y algoritmos avanzados de muestreo de texto que no se encuentran en los marcos de servicio convencionales.

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

Requisitos del servidor

Parámetro	Mínimo	Recomendado
RAM	16 GB	32 GB+
VRAM	6 GB	16 GB+
Disco	40 GB	150 GB+
GPU	NVIDIA Pascal+ (GTX 1060+)	RTX 3090, A100

Aphrodite Engine es uno de los pocos servidores LLM que admiten GPUs de la generación Pascal (serie GTX 10xx). Esto lo hace ideal para servidores económicos en CLORE.AI con GPUs antiguas y precios de alquiler bajos.

Despliegue rápido en CLORE.AI

Imagen de Docker: alpindale/aphrodite-engine:latest

Puertos: 22/tcp, 2242/http

Variables de entorno:

Variable	Ejemplo	Descripción
HF_TOKEN	hf_xxx...	Token de HuggingFace para modelos restringidos
APHRODITE_MODEL	mistralai/Mistral-7B-Instruct-v0.3	Modelo a cargar

Configuración paso a paso

1. Alquila un servidor GPU en CLORE.AI

La amplia compatibilidad de GPUs de Aphrodite te permite conseguir servidores económicos en Marketplace de CLORE.AI:

• Pascal (GTX 1060–1080 Ti): 6–11 GB de VRAM — ejecuta modelos pequeños de 3B-7B con cuantización

• Turing (serie RTX 2000): 8–24 GB de VRAM — modelos 7B-13B, mejor rendimiento

• Ampere (RTX 3000/A100): 24–80 GB de VRAM — modelos 30B-70B, velocidad completa

• Ada (serie RTX 4000): 16–24 GB de VRAM — mejor relación rendimiento/coste

2. Conéctate vía SSH

ssh -p <PORT> root@<SERVER_IP>

3. Descarga la imagen de Aphrodite Engine

docker pull alpindale/aphrodite-engine:latest

4. Inicia Aphrodite Engine

Inicio básico con un modelo 7B:

docker run -d \\
  --name aphrodite \
  --gpus all \\
  --ipc host \
  -p 2242:2242 \
  -v /root/models:/root/.cache/huggingface \
  alpindale/aphrodite-engine:latest \
  python3 -m aphrodite.endpoints.openai.api_server \
    --model mistralai/Mistral-7B-Instruct-v0.3 \
    --host 0.0.0.0 \\
    --port 2242 \
    --max-model-len 4096

Con token de HuggingFace (Llama 3):

docker run -d \\
  --name aphrodite \
  --gpus all \\
  --ipc host \
  -p 2242:2242 \
  -v /root/models:/root/.cache/huggingface \
  -e HF_TOKEN=hf_your_token_here \
  alpindale/aphrodite-engine:latest \
  python3 -m aphrodite.endpoints.openai.api_server \
    --model meta-llama/Meta-Llama-3-8B-Instruct \
    --host 0.0.0.0 \\
    --port 2242 \
    --dtype bfloat16 \\
    --max-model-len 8192

Con cuantización GPTQ (para VRAM limitada):

docker run -d \\
  --name aphrodite \
  --gpus all \\
  --ipc host \
  -p 2242:2242 \
  -v /root/models:/root/.cache/huggingface \
  alpindale/aphrodite-engine:latest \
  python3 -m aphrodite.endpoints.openai.api_server \
    --model TheBloke/Mistral-7B-Instruct-v0.2-GPTQ \
    --host 0.0.0.0 \\
    --port 2242 \
    --quantization gptq \
    --max-model-len 4096

Con cuantización AWQ:

docker run -d \\
  --name aphrodite \
  --gpus all \\
  --ipc host \
  -p 2242:2242 \
  -v /root/models:/root/.cache/huggingface \
  alpindale/aphrodite-engine:latest \
  python3 -m aphrodite.endpoints.openai.api_server \
    --model casperhansen/mistral-7b-instruct-v0.2-awq \
    --host 0.0.0.0 \\
    --port 2242 \
    --quantization awq \\
    --max-model-len 4096

Ejecutando un modelo GGUF (Aphrodite admite GGUF de forma nativa):

# Primero descarga el archivo GGUF
docker exec -it aphrodite bash -c "
pip install huggingface_hub
python3 -c \"from huggingface_hub import hf_hub_download; hf_hub_download(
    repo_id='TheBloke/Mistral-7B-Instruct-v0.2-GGUF',
    filename='mistral-7b-instruct-v0.2.Q4_K_M.gguf',
    local_dir='/root/models/mistral-gguf'
\"
"

# Luego inicia con GGUF
docker run -d \\
  --name aphrodite \
  --gpus all \\
  --ipc host \
  -p 2242:2242 \
  -v /root/models:/models \
  alpindale/aphrodite-engine:latest \
  python3 -m aphrodite.endpoints.openai.api_server \
    --model /models/mistral-gguf/mistral-7b-instruct-v0.2.Q4_K_M.gguf \
    --host 0.0.0.0 \\
    --port 2242 \
    --tokenizer mistralai/Mistral-7B-Instruct-v0.2

5. Verifica el servidor

# Ver registros
docker logs -f aphrodite

# Comprobación de salud
curl http://localhost:2242/health

# Lista los modelos cargados
curl http://localhost:2242/v1/models

6. Accede a través del proxy HTTP de CLORE.AI

El panel de pedidos de CLORE.AI proporciona una http_pub URL para el puerto 2242. Úsala en tus aplicaciones cliente:

https://<order-id>-2242.clore.ai/v1

---

Ejemplos de uso

Ejemplo 1: Chat compatible con OpenAI

curl http://localhost:2242/v1/chat/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.3",
    "messages": [
      {"role": "system", "content": "Eres un escritor creativo especializado en fantasía."},
      {"role": "user", "content": "Comienza un cuento corto sobre un dragón que aprende a pintar."}
    ],
    "max_tokens": 500,
    "temperature": 0.9,
    "top_p": 0.95
  }'

Ejemplo 2: Muestreo avanzado con Mirostat

Aphrodite admite muestreo Mirostat para un texto largo más coherente:

curl http://localhost:2242/v1/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.3",
    "prompt": "Érase una vez en una ciudad cyberpunk,",
    "max_tokens": 400,
    "mirostat_mode": 2,
    "mirostat_tau": 5.0,
    "mirostat_eta": 0.1
  }'

Ejemplo 3: API compatible con Kobold

Aphrodite incluye un endpoint compatible con Kobold para su uso con frontends basados en KoboldAI:

# Endpoint de generación de Kobold
curl http://localhost:2242/api/v1/generate \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "prompt": "La nave espacial entró en hiperespacio,",
    "max_length": 200,
    "temperature": 0.8,
    "top_p": 0.92,
    "rep_pen": 1.15
  }'

Ejemplo 4: Cliente Python con muestreadores personalizados

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:2242/v1",
    api_key="none",
)

# Escritura creativa con muestreadores personalizados
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    messages=[
        {
            "role": "user",
            "content": "Escribe un poema sobre el silencio entre las estrellas.",
        }
    ],
    max_tokens=300,
    temperature=1.1,
    top_p=0.95,
    frequency_penalty=0.3,
    presence_penalty=0.2,
)

print(response.choices[0].message.content)

Ejemplo 5: Completaciones por lotes

import requests

BASE_URL = "http://localhost:2242"

prompts = [
    "El antiguo mago abrió su tomo y",
    "En el callejón iluminado por neón, el detective notó",
    "La última IA de la Tierra le dijo al robot:",
]

for prompt in prompts:
    response = requests.post(
        f"{BASE_URL}/v1/completions",
        json={
            "model": "mistralai/Mistral-7B-Instruct-v0.3",
            "prompt": prompt,
            "max_tokens": 150,
            "temperature": 0.85,
            "top_k": 50,
            "top_p": 0.95,
            "repetition_penalty": 1.1,
        },
    )
    result = response.json()
    print(f"Prompt: {prompt}")
    print(f"Continuación: {result['choices'][0]['text']}\n")

---

Configuración

Parámetros clave de inicio

Parámetro	Valor predeterminado	Descripción
--model	obligatorio	ID del modelo o ruta local
--host	127.0.0.1	Dirección de enlace
--port	2242	Puerto del servidor
--dtype	auto	float16, bfloat16, float32
--quantization	ninguno	awq, gptq, squeezellm, fp8
--max-model-len	máximo del modelo	Sobrescribe la longitud máxima del contexto
--gpu-memory-utilization	0.90	fracción de memoria de GPU
--tensor-parallel-size	1	Número de GPUs para paralelismo tensorial
--max-num-seqs	256	Máximo de secuencias concurrentes
--trust-remote-code	false	Permitir código personalizado del modelo
--api-keys	ninguno	Claves API separadas por comas para autenticación
--served-model-name	nombre del modelo	Nombre personalizado para las respuestas de la API

Añadir autenticación con clave API

python3 -m aphrodite.endpoints.openai.api_server \
  --model mistralai/Mistral-7B-Instruct-v0.3 \
  --host 0.0.0.0 \\
  --port 2242 \
  --api-keys "mysecretkey1,mysecretkey2"

Luego usa Authorization: Bearer mysecretkey1 en las solicitudes.

Carga de modelos locales

# Monta el directorio de tu modelo y haz referencia a él
docker run -d \\
  --name aphrodite \
  --gpus all \\
  --ipc host \
  -p 2242:2242 \
  -v /path/to/your/model:/model \
  alpindale/aphrodite-engine:latest \
  python3 -m aphrodite.endpoints.openai.api_server \
    --model /model \
    --host 0.0.0.0 \\
    --port 2242

---

Consejos de rendimiento

1. Elige la cuantización adecuada para tu GPU

VRAM de GPU	Modelo 7B	Modelo 13B	Modelo 30B
6 GB	GPTQ/AWQ Q4	❌	❌
8 GB	GPTQ Q4	GPTQ Q4 (ajustado)	❌
12 GB	Float16	GPTQ Q4	❌
16 GB	Float16	Float16	GPTQ Q4
24 GB	Float16	Float16	GPTQ Q4
48 GB	Float16	Float16	Float16

2. Ajusta la utilización de memoria de la GPU

--gpu-memory-utilization 0.93  # Aprieta más la caché KV

Empieza con un valor bajo y aumenta si no obtienes errores de OOM.

3. Usa bfloat16 en GPUs Ampere+

--dtype bfloat16

Mejor estabilidad numérica que float16, misma velocidad.

4. Optimiza para roleplay/escritura creativa

Estos muestreadores funcionan bien para texto narrativo:

{
  "temperature": 0.85,
  "top_p": 0.92,
  "top_k": 40,
  "repetition_penalty": 1.12,
  "mirostat_mode": 2,
  "mirostat_tau": 5.0
}

5. Consejos para GPUs Pascal (GTX 10xx)

Para GPUs Pascal, evita Flash Attention (no es compatible):

--dtype float16  # float32 si obtienes errores NaN
--max-model-len 2048  # Reduce el contexto para ahorrar memoria

---

Solución de problemas

Problema: "CUDA capability sm_6x not supported"

Las GPUs Pascal requieren un tratamiento especial. Usa:

--dtype float16

Si sigue fallando, comprueba si la versión de la imagen admite Pascal:

docker pull alpindale/aphrodite-engine:v0.5.4  # Prueba una versión específica

Problema: "out of memory" en GPUs pequeñas

--gpu-memory-utilization 0.85
--max-model-len 2048
--quantization gptq  # O awq

Problema: generación lenta de tokens

• Comprueba que realmente se esté usando la GPU: nvidia-smi dentro del contenedor

• Activa tamaños de lote más grandes: --max-num-seqs 64

• Usa AWQ en lugar de GPTQ (inferencia más rápida)

Problema: modelo no encontrado / errores 404

Comprueba siempre que el nombre de tu modelo coincida exactamente:

curl http://localhost:2242/v1/models

Usa el nombre exacto del modelo de la respuesta en tus solicitudes.

Problema: salida repetitiva

Añade penalización por repetición:

{
  "repetition_penalty": 1.15,
  "frequency_penalty": 0.3
}

Problema: el contenedor Docker se cierra silenciosamente

docker logs aphrodite 2>&1 | tail -100
# Causas comunes: VRAM insuficiente, ruta del modelo inválida

---

Enlaces

• GitHub

• Documentación

• Docker Hub

• Modelos compatibles

• Marketplace de CLORE.AI

---

Recomendaciones de GPU para Clore.ai

Caso de uso	GPU recomendada	Costo estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
Producción (7B–13B)	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
Modelos grandes (70B+)	A100 80GB / H100	~$1.04/gpu/h

💡 Todos los ejemplos de esta guía pueden desplegarse en Clore.ai servidores GPU. Explora las GPUs disponibles y alquila por hora: sin compromisos, acceso root completo.