Aphrodite Engine

Ejecuta Aphrodite Engine para inferencia de LLMs en GPU antiguas y modernas en Clore.ai

Aphrodite Engine es un servidor de inferencia LLM optimizado construido sobre vLLM, específicamente diseñado para la comunidad de escritura creativa y roleplay. Admite una amplia gama de GPU a partir de 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 más comunes.

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

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 soporta GPU de la generación Pascal (serie GTX 10xx). Esto lo hace ideal para servidores económicos en CLORE.AI con GPUs antiguas que tienen precios de alquiler bajos.

Despliegue rápido en CLORE.AI

Imagen 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

El amplio soporte de GPU de Aphrodite te permite conseguir servidores económicos en CLORE.AI Marketplace:

• Pascal (GTX 1060–1080 Ti): 6–11 GB de VRAM — ejecutar 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, a toda velocidad

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

2. Conéctate vía SSH

ssh -p <PORT> root@<SERVER_IP>

3. Descargar la imagen de Aphrodite Engine

docker pull alpindale/aphrodite-engine:latest

4. Lanzar Aphrodite Engine

Lanzamiento 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 soporta 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 lanza 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. Verifique el Servidor

# Comprobar logs
docker logs -f aphrodite

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

# Listar modelos cargados
curl http://localhost:2242/v1/models

6. Acceso vía Proxy HTTP de CLORE.AI

El panel de pedidos de CLORE.AI proporciona un http_pub URL para el puerto 2242. Úsalo 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 ficción fantástica."},
      {"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 soporta muestreo Mirostat para textos largos más coherentes:

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 usar con frontends basados en KoboldAI:

# Endpoint de generación Kobold
curl http://localhost:2242/api/v1/generate \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "prompt": "La nave espacial entró en el 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 a medida
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 en 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 lanzamiento

Parámetro	Por defecto	Descripción
--model	requerido	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	ninguna	awq, gptq, squeezellm, fp8
--max-model-len	máx. del modelo	Anular la longitud máxima del contexto
--gpu-memory-utilization	0.90	Fracción de memoria 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 de modelo personalizado
--api-keys	ninguna	Claves API separadas por comas para autenticación
--served-model-name	nombre del modelo	Nombre personalizado para las respuestas de la API

Añadiendo autenticación por 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 use Authorization: Bearer mysecretkey1 en las solicitudes.

Cargando modelos locales

# Monta tu directorio de modelos y refiérelo
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 GPU	Modelo 7B	Modelo 13B	Modelo 30B
6 GB	GPTQ/AWQ Q4	❌	❌
8 GB	GPTQ Q4	GPTQ Q4 (apretado)	❌
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 GPU

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

Comienza más bajo y aumenta si no obtienes errores OOM.

3. Usar bfloat16 en GPUs Ampere+

--dtype bfloat16

Mejor estabilidad numérica que float16, misma velocidad.

4. Optimizar 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 GPU Pascal (GTX 10xx)

Para GPUs Pascal, evita Flash Attention (no soportado):

--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 tratamiento especial. Usa:

--dtype float16

Si aún falla, 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: "fuera de memoria" en GPUs pequeñas

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

Problema: Generación de tokens lenta

• Comprueba que la GPU esté siendo usada realmente: nvidia-smi dentro del contenedor

• Habilita tamaños de lote mayores: --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 del 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 sale silenciosamente

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

---

Enlaces

• GitHub

• Documentación

• Docker Hub

• Modelos compatibles

• CLORE.AI Marketplace

---

Recomendaciones de GPU en Clore.ai

Caso de uso	GPU recomendada	Coste estimado en Clore.ai
Desarrollo/Pruebas	RTX 3090 (24GB)	~$0.12/gpu/hr
Producción (7B–13B)	RTX 4090 (24GB)	~$0.70/gpu/hr
Modelos grandes (70B+)	A100 80GB / H100	~$1.20/gpu/hr

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