Aphrodite Engine

Führe Aphrodite Engine für LLM-Inferenz auf älteren und modernen GPUs auf Clore.ai aus

Aphrodite Engine ist ein optimierter LLM-Inferenzserver, der auf vLLM aufbaut und speziell auf die Community für kreatives Schreiben und Rollenspiele zugeschnitten ist. Er unterstützt eine breite Palette von GPUs ab Pascal (GTX-1000-Serie) und ist damit die perfekte Wahl, um Sprachmodelle auf älteren oder günstigen CLORE.AI-GPU-Servern auszuführen, auf denen andere Frameworks versagen. Aphrodite bietet Kobold-kompatible APIs, Mirostat-Sampling und fortgeschrittene Text-Sampling-Algorithmen, die in gängigen Serving-Frameworks nicht zu finden sind.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Serveranforderungen

Parameter	Minimum	Empfohlen
RAM	16 GB	32 GB+
VRAM	6 GB	16 GB+
Festplatte	40 GB	150 GB+
GPU	NVIDIA Pascal+ (GTX 1060+)	RTX 3090, A100

Aphrodite Engine ist einer der wenigen LLM-Server, die GPUs der Pascal-Generation (GTX-10xx-Serie) unterstützen. Das macht ihn ideal für Budget-Server auf CLORE.AI mit älteren GPUs, die niedrige Mietpreise haben.

Schnellbereitstellung auf CLORE.AI

Docker-Image: alpindale/aphrodite-engine:latest

Ports: 22/tcp, 2242/http

Umgebungsvariablen:

Variable	Beispiel	Beschreibung
HF_TOKEN	hf_xxx...	HuggingFace-Token für gesperrte Modelle
APHRODITE_MODEL	mistralai/Mistral-7B-Instruct-v0.3	Zu ladendes Modell

Schritt-für-Schritt-Einrichtung

1. Mieten Sie einen GPU-Server auf CLORE.AI

Aphrodites breite GPU-Unterstützung ermöglicht es Ihnen, kostengünstige Server auf CLORE.AI-Marktplatz:

• Pascal (GTX 1060–1080 Ti): 6–11 GB VRAM — kleine 3B-7B-Modelle mit Quantisierung ausführen

• Turing (RTX-2000-Serie): 8–24 GB VRAM — 7B-13B-Modelle, bessere Leistung

• Ampere (RTX-3000/A100): 24–80 GB VRAM — 30B-70B-Modelle, volle Geschwindigkeit

• Ada (RTX-4000-Serie): 16–24 GB VRAM — bestes Leistungs-/Preisverhältnis

2. Verbinden Sie sich per SSH

ssh -p <PORT> root@<SERVER_IP>

3. Aphrodite-Engine-Image herunterladen

docker pull alpindale/aphrodite-engine:latest

4. Aphrodite Engine starten

Einfacher Start mit einem 7B-Modell:

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

Mit HuggingFace-Token (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

Mit GPTQ-Quantisierung (für begrenzten VRAM):

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

Mit AWQ-Quantisierung:

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

Ausführen eines GGUF-Modells (Aphrodite unterstützt GGUF nativ):

# Zuerst die GGUF-Datei herunterladen
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'
)\"
"

# Dann mit GGUF starten
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. Den Server überprüfen

# Protokolle prüfen
docker logs -f aphrodite

# Gesundheitsprüfung
curl http://localhost:2242/health

# Geladene Modelle auflisten
curl http://localhost:2242/v1/models

6. Zugriff über den CLORE.AI-HTTP-Proxy

Das CLORE.AI-Bestellpanel stellt eine http_pub URL für Port 2242 bereit. Verwenden Sie sie in Ihren Client-Anwendungen:

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

---

Anwendungsbeispiele

Beispiel 1: OpenAI-kompatibler Chat

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": "Du bist ein kreativer Schriftsteller, der sich auf Fantasy-Fiktion spezialisiert hat."},
      {"role": "user", "content": "Beginne eine Kurzgeschichte über einen Drachen, der das Malen lernt."}
    ],
    "max_tokens": 500,
    "temperature": 0.9,
    "top_p": 0.95
  }'

Beispiel 2: Fortgeschrittenes Sampling mit Mirostat

Aphrodite unterstützt Mirostat-Sampling für zusammenhängenderen Langtext:

curl http://localhost:2242/v1/completions \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "model": "mistralai/Mistral-7B-Instruct-v0.3",
    "prompt": "Es war einmal in einer Cyberpunk-Stadt,",
    "max_tokens": 400,
    "mirostat_mode": 2,
    "mirostat_tau": 5.0,
    "mirostat_eta": 0.1
  }'

Beispiel 3: Kobold-kompatible API

Aphrodite enthält einen Kobold-kompatiblen Endpunkt zur Verwendung mit auf KoboldAI basierenden Frontends:

# Kobold-Generierungs-Endpunkt
curl http://localhost:2242/api/v1/generate \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
    "prompt": "Das Raumschiff trat in den Hyperraum ein,",
    "max_length": 200,
    "temperature": 0.8,
    "top_p": 0.92,
    "rep_pen": 1.15
  }'

Beispiel 4: Python-Client mit benutzerdefinierten Samplern

from openai import OpenAI

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

# Kreatives Schreiben mit angepassten Samplern
response = client.chat.completions.create(
    model="mistralai/Mistral-7B-Instruct-v0.3",
    messages=[
        {
            "role": "user",
            "content": "Schreibe ein Gedicht über die Stille zwischen den Sternen.",
        }
    ],
    max_tokens=300,
    temperature=1.1,
    top_p=0.95,
    frequency_penalty=0.3,
    presence_penalty=0.2,
)

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

Beispiel 5: Batch-Vervollständigungen

import requests

BASE_URL = "http://localhost:2242"

prompts = [
    "Der uralte Zauberer öffnete sein Buch und",
    "In der neonbeleuchteten Gasse bemerkte der Detektiv",
    "Die letzte KI auf der Erde sagte zum Roboter:",
]

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"Fortsetzung: {result['choices'][0]['text']}\n")

---

Konfiguration

Wichtige Startparameter

Parameter	Standard	Beschreibung
--model	erforderlich	Modell-ID oder lokaler Pfad
--host	127.0.0.1	Bind-Adresse
--port	2242	Server-Port
--dtype	auto	float16, bfloat16, float32
--quantization	none	awq, gptq, squeezellm, fp8
--max-model-len	max. Modell	Maximale Kontextlänge überschreiben
--gpu-memory-utilization	0.90	Anteil des GPU-Speichers
--tensor-parallel-size	1	Anzahl der GPUs für Tensor Parallelism
--max-num-seqs	256	Maximale gleichzeitige Sequenzen
--trust-remote-code	false	Benutzerdefinierten Modellcode erlauben
--api-keys	none	Kommagetrennte API-Schlüssel zur Authentifizierung
--served-model-name	Modellname	Benutzerdefinierter Name für API-Antworten

API-Schlüssel-Authentifizierung hinzufügen

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"

Dann verwenden Authorization: Bearer mysecretkey1 in Anfragen.

Lokale Modelle laden

# Mounten Sie Ihr Modellverzeichnis und verweisen Sie darauf
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

---

Leistungstipps

1. Wählen Sie die richtige Quantisierung für Ihre GPU

GPU-VRAM	7B-Modell	13B-Modell	30B-Modell
6 GB	GPTQ/AWQ Q4	❌	❌
8 GB	GPTQ Q4	GPTQ Q4 (knapp)	❌
12 GB	Float16	GPTQ Q4	❌
16 GB	Float16	Float16	GPTQ Q4
24 GB	Float16	Float16	GPTQ Q4
48 GB	Float16	Float16	Float16

2. GPU-Speicherauslastung optimieren

--gpu-memory-utilization 0.93  # Mehr KV-Cache herausquetschen

Fangen Sie niedriger an und erhöhen Sie den Wert, wenn keine OOM-Fehler auftreten.

3. bfloat16 auf Ampere+-GPUs verwenden

--dtype bfloat16

Bessere numerische Stabilität als float16, gleiche Geschwindigkeit.

4. Für Rollenspiel/Kreatives Schreiben optimieren

Diese Sampler eignen sich gut für narrative Texte:

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

5. Tipps für Pascal-GPUs (GTX 10xx)

Bei Pascal-GPUs Flash Attention vermeiden (nicht unterstützt):

--dtype float16  # float32, wenn Sie NaN-Fehler erhalten
--max-model-len 2048  # Kontext für mehr Speichereinsparung reduzieren

---

Fehlerbehebung

Problem: "CUDA capability sm_6x not supported"

Pascal-GPUs erfordern eine besondere Behandlung. Verwenden Sie:

--dtype float16

Wenn es immer noch fehlschlägt, prüfen Sie, ob die Image-Version Pascal unterstützt:

docker pull alpindale/aphrodite-engine:v0.5.4  # Bestimmte Version ausprobieren

Problem: "out of memory" auf kleinen GPUs

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

Problem: Langsame Token-Generierung

• Prüfen Sie, ob die GPU tatsächlich verwendet wird: nvidia-smi im Container

• Größere Batch-Größen aktivieren: --max-num-seqs 64

• AWQ statt GPTQ verwenden (schnellere Inferenz)

Problem: Modell nicht gefunden / 404-Fehler

Prüfen Sie immer, ob Ihr Modellname exakt übereinstimmt:

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

Verwenden Sie in Ihren Anfragen den exakten Modellnamen aus der Antwort.

Problem: Wiederholte Ausgaben

Wiederholungsstrafe hinzufügen:

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

Problem: Docker-Container beendet sich ohne Meldung

docker logs aphrodite 2>&1 | tail -100
# Häufige Ursachen: unzureichender VRAM, ungültiger Modellpfad

---

Links

• GitHub

• Dokumentation

• Docker Hub

• Unterstützte Modelle

• CLORE.AI-Marktplatz

---

GPU-Empfehlungen für Clore.ai

Anwendungsfall	Empfohlene GPU	Geschätzte Kosten bei Clore.ai
Entwicklung/Testen	RTX 3090 (24 GB)	0,07–0,21 $/GPU/Stunde
Produktion (7B–13B)	RTX 4090 (24 GB)	0,14–0,42 $/GPU/Stunde
Große Modelle (70B+)	A100 80GB / H100	~$1.04/GPU/Stunde

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.