Aphrodite Engine

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

Aphrodite Engine est un serveur d'inférence LLM optimisé, basé sur vLLM, spécialement conçu pour la communauté de l'écriture créative et du jeu de rôle. Il prend en charge une large gamme de GPU à partir de Pascal (série GTX 1000), ce qui en fait le choix idéal pour exécuter des modèles de langage sur des serveurs GPU CLORE.AI anciens ou à petit budget, là où d'autres frameworks échouent. Aphrodite ajoute des API compatibles Kobold, l'échantillonnage Mirostat et des algorithmes avancés d'échantillonnage de texte absents des frameworks de service courants.

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Exigences du 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 prenant en charge les GPU de génération Pascal (série GTX 10xx). Cela en fait un choix idéal pour les serveurs à petit budget sur CLORE.AI, avec d'anciens GPU à faible prix de location.

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 prendre des serveurs économiques sur la place de marché CLORE.AI:

• 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 ratio performances/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 de base 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 jeton 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 une 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) :

# Téléchargez d'abord 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érifier le serveur

# Vérifier les journaux
docker logs -f aphrodite

# Vérification de santé
curl http://localhost:2242/health

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

6. Accéder via le proxy HTTP CLORE.AI

Le panneau de commande CLORE.AI fournit un 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 un texte long plus cohérent :

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 point de terminaison compatible Kobold pour une utilisation avec des interfaces basées sur KoboldAI :

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

Exemple 4 : client Python avec des é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 lot

import requests

BASE_URL = "http://localhost:2242"

prompts = [
    "Le sorcier ancien ouvrit son grimoire et",
    "Dans la ruelle éclairée au néon, le détective remarqua",
    "Le dernier 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"Invite : {prompt}")
    print(f"Suite : {result['choices'][0]['text']}\n")

---

Configuration

Paramètres de lancement clés

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	none	awq, gptq, squeezellm, fp8
--max-model-len	modèle max	Remplacer la longueur de contexte maximale
--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 de modèle personnalisé
--api-keys	none	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 /chemin/vers/votre/modèle:/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 Go	Float16	Float16	Float16

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

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

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

3. Utilisez bfloat16 sur les GPU Ampere+

--dtype bfloat16

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

4. Optimisez 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 les 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éduisez le contexte pour économiser de la mémoire

---

Dépannage

Problème : "CUDA capability sm_6x not supported"

Les GPU Pascal nécessitent une prise en charge spéciale. Utilisez :

--dtype float16

Si cela échoue encore, 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 : "out of memory" sur les petits GPU

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

Problème : génération lente des jetons

• Vérifiez que le GPU est bien utilisé : nvidia-smi dans le conteneur

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

• Utilisez AWQ à la place 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 fourni dans 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 ferme silencieusement

docker logs aphrodite 2>&1 | tail -100
# Causes fréquentes : VRAM insuffisante, chemin du modèle invalide

---

Liens

• GitHub

• Documentation

• Docker Hub

• Modèles pris en charge

• la place de marché CLORE.AI

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Développement/Test	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Production (7B–13B)	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Grands modèles (70B+)	A100 80 Go / H100	~1,04 $/GPU/h

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