Aphrodite Engine

Exécuter Aphrodite Engine pour l'inférence LLM sur GPU anciens et modernes sur Clore.ai

Aphrodite Engine est un serveur d'inférence LLM optimisé construit sur vLLM, spécialement adapté à la communauté de l'écriture créative et du jeu de rôle. Il prend en charge un large éventail de GPU à partir de Pascal (série GTX 1000), ce qui en fait le choix parfait pour exécuter des modèles de langage sur des serveurs GPU CLORE.AI anciens ou économiques où d'autres frameworks échouent. Aphrodite ajoute des API compatibles Kobold, l'échantillonnage Mirostat et des algorithmes d'échantillonnage de texte avancés non présents dans les frameworks de service grand public.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Exigences serveur

Paramètre	Minimum	Recommandé
RAM	16 Go	32 Go+
VRAM	6 Go	16 Go+
Disque	40 Go	150 Go+
GPU	NVIDIA Pascal+ (GTX 1060+)	RTX 3090, A100

Aphrodite Engine est l'un des rares serveurs LLM à prendre en charge les GPU de génération Pascal (série GTX 10xx). Cela le rend idéal pour les serveurs économiques sur CLORE.AI avec des GPU plus anciens dont les tarifs de location sont bas.

Déploiement rapide sur CLORE.AI

Image Docker : alpindale/aphrodite-engine:latest

Ports : 22/tcp, 2242/http

Variables d’environnement :

Variable	Exemple	Description
HF_TOKEN	hf_xxx...	Jeton HuggingFace pour les modèles protégés
APHRODITE_MODEL	mistralai/Mistral-7B-Instruct-v0.3	Modèle à charger

Configuration étape par étape

1. Louez un serveur GPU sur CLORE.AI

La large compatibilité GPU d'Aphrodite vous permet de trouver des serveurs économiques sur CLORE.AI Marketplace:

• Pascal (GTX 1060–1080 Ti): 6–11 Go de VRAM — exécutez de petits modèles 3B–7B avec quantification

• Turing (série RTX 2000): 8–24 Go de VRAM — modèles 7B–13B, meilleures performances

• Ampere (RTX 3000/A100): 24–80 Go de VRAM — modèles 30B–70B, pleine vitesse

• Ada (série RTX 4000): 16–24 Go de VRAM — meilleur rapport performance/coût

2. Se connecter via SSH

ssh -p <PORT> root@<SERVER_IP>

3. Récupérer l'image Aphrodite Engine

docker pull alpindale/aphrodite-engine:latest

4. Lancer Aphrodite Engine

Lancement basique avec un modèle 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

Avec un token 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

Avec quantification GPTQ (pour VRAM limitée) :

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

Avec quantification 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

Exécution d'un modèle GGUF (Aphrodite prend en charge GGUF nativement) :

# D'abord téléchargez le fichier 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'
)\"
"

# Puis lancez avec 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. Vérifiez le serveur

# Vérifier les logs
docker logs -f aphrodite

# Vérification de l'état
curl http://localhost:2242/health

# Lister les modèles chargés
curl http://localhost:2242/v1/models

6. Accès via le proxy HTTP de CLORE.AI

Le panneau de commande de commande CLORE.AI fournit une http_pub URL pour le port 2242. Utilisez-la dans vos applications clientes :

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

---

Exemples d’utilisation

Exemple 1 : Chat compatible 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": "Vous êtes un écrivain créatif spécialisé dans la fiction fantastique."},
      {"role": "user", "content": "Commencez une courte histoire sur un dragon qui apprend à peindre."}
    ],
    "max_tokens": 500,
    "temperature": 0.9,
    "top_p": 0.95
  }'

Exemple 2 : Échantillonnage avancé avec Mirostat

Aphrodite prend en charge l'échantillonnage Mirostat pour des textes longs plus cohérents :

curl http://localhost:2242/v1/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.3",
    "prompt": "Il était une fois dans une ville cyberpunk,",
    "max_tokens": 400,
    "mirostat_mode": 2,
    "mirostat_tau": 5.0,
    "mirostat_eta": 0.1
  }'

Exemple 3 : API compatible Kobold

Aphrodite inclut un endpoint compatible Kobold pour une utilisation avec des frontends basés sur KoboldAI :

# Endpoint de génération Kobold
curl http://localhost:2242/api/v1/generate \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "prompt": "Le vaisseau spatial entra en hyperespace,",
    "max_length": 200,
    "temperature": 0.8,
    "top_p": 0.92,
    "rep_pen": 1.15
  }'

Exemple 4 : Client Python avec échantillonneurs personnalisés

from openai import OpenAI

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

# Écriture créative avec des échantillonneurs adaptés
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    messages=[
        {
            "role": "user",
            "content": "Écrivez un poème sur le silence entre les étoiles.",
        }
    ],
    max_tokens=300,
    temperature=1.1,
    top_p=0.95,
    frequency_penalty=0.3,
    presence_penalty=0.2,
)

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

Exemple 5 : Complétions par lots

import requests

BASE_URL = "http://localhost:2242"

prompts = [
    "Le vieux magicien ouvrit son grimoire et",
    "Dans la ruelle éclairée au néon, le détective remarqua",
    "La dernière IA sur Terre dit au 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"Continuation: {result['choices'][0]['text']}\n")

---

Configuration

Principaux paramètres de lancement

Paramètre	Par défaut	Description
--model	requis	ID du modèle ou chemin local
--host	127.0.0.1	Adresse de liaison
--port	2242	Port du serveur
--dtype	auto	float16, bfloat16, float32
--quantization	aucune	awq, gptq, squeezellm, fp8
--max-model-len	max du modèle	Remplacer la longueur maximale du contexte
--gpu-memory-utilization	0.90	Fraction de mémoire GPU
--tensor-parallel-size	1	Nombre de GPU pour le parallélisme tensoriel
--max-num-seqs	256	Nombre maximal de séquences simultanées
--trust-remote-code	false	Autoriser le code personnalisé du modèle
--api-keys	aucune	Clés API séparées par des virgules pour l'authentification
--served-model-name	nom du modèle	Nom personnalisé pour les réponses de l'API

Ajout de l'authentification par clé 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"

Puis utilisez Authorization: Bearer mysecretkey1 dans les requêtes.

Chargement de modèles locaux

# Montez votre répertoire de modèles et référencez-le
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

---

Conseils de performance

1. Choisissez la bonne quantification pour votre GPU

VRAM GPU	Modèle 7B	Modèle 13B	Modèle 30B
6 Go	GPTQ/AWQ Q4	❌	❌
8 Go	GPTQ Q4	GPTQ Q4 (serré)	❌
12 Go	Float16	GPTQ Q4	❌
16 Go	Float16	Float16	GPTQ Q4
24 Go	Float16	Float16	GPTQ Q4
48 GB	Float16	Float16	Float16

2. Ajustez l'utilisation de la mémoire GPU

--gpu-memory-utilization 0.93  # Serrer davantage le cache KV

Commencez plus bas et augmentez si vous n'obtenez pas d'erreurs OOM.

3. Utiliser bfloat16 sur les GPU Ampere+

--dtype bfloat16

Meilleure stabilité numérique que le float16, même vitesse.

4. Optimiser pour le jeu de rôle / l'écriture créative

Ces échantillonneurs fonctionnent bien pour le texte narratif :

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

5. Conseils pour GPU Pascal (GTX 10xx)

Pour les GPU Pascal, évitez Flash Attention (non pris en charge) :

--dtype float16  # float32 si vous obtenez des erreurs NaN
--max-model-len 2048  # Réduire le contexte pour économiser la mémoire

---

Dépannage

Problème : "capacité CUDA sm_6x non prise en charge"

Les GPU Pascal nécessitent un traitement spécial. Utilisez :

--dtype float16

Si cela échoue toujours, vérifiez si la version de l'image prend en charge Pascal :

docker pull alpindale/aphrodite-engine:v0.5.4  # Essayez une version spécifique

Problème : "mémoire insuffisante" sur les petits GPU

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

Problème : génération de tokens lente

• Vérifiez que le GPU est réellement utilisé : nvidia-smi à l'intérieur du conteneur

• Activez des tailles de lots plus grandes : --max-num-seqs 64

• Utilisez AWQ au lieu de GPTQ (inférence plus rapide)

Problème : modèle introuvable / erreurs 404

Vérifiez toujours que le nom de votre modèle correspond exactement :

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

Utilisez le nom exact du modèle à partir de la réponse dans vos requêtes.

Problème : sortie répétitive

Ajoutez une pénalité de répétition :

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

Problème : le conteneur Docker se termine silencieusement

docker logs aphrodite 2>&1 | tail -100
# Causes courantes : VRAM insuffisante, chemin de modèle invalide

---

Liens

• GitHub

• Documentation

• Docker Hub

• Modèles pris en charge

• CLORE.AI Marketplace

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24GB)	~$0.12/gpu/hr
Production (7B–13B)	RTX 4090 (24GB)	~$0.70/gpu/hr
Grands modèles (70B+)	A100 80GB / H100	~$1.20/gpu/hr

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.