DeepSeek-V3

Führe DeepSeek-V3 mit außergewöhnlichem Reasoning auf Clore.ai-GPUs aus

Führen Sie DeepSeek-V3 aus, das hochmoderne Open-Source-LLM mit außergewöhnlichen Schlussfolgerungsfähigkeiten auf CLORE.AI-GPUs.

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

Aktualisiert: DeepSeek-V3-0324 (März 2024) — Die neueste Revision von DeepSeek-V3 bringt deutliche Verbesserungen bei der Codegenerierung, dem mathematischen Schlussfolgern und der allgemeinen Problemlösung. Siehe den Änderungsprotokoll Abschnitt für Details.

Warum DeepSeek-V3?

• Auf dem neuesten Stand der Technik - Kann mit GPT-4o und Claude 3.5 Sonnet mithalten

• 671B MoE - 671B Gesamtparameter, 37B aktiv pro Token (effiziente Inferenz)

• Verbessertes Schlussfolgern - DeepSeek-V3-0324 ist bei Mathematik und Code deutlich besser

• Effizient - Die MoE-Architektur reduziert die Rechenkosten im Vergleich zu dichten Modellen

• Open Source - Vollständig offene Gewichte unter MIT-Lizenz

• Langer Kontext - 128K-Token-Kontextfenster

Was ist neu in DeepSeek-V3-0324

DeepSeek-V3-0324 (Revision vom März 2024) bringt in wichtigen Bereichen spürbare Verbesserungen mit sich:

Codegenerierung

• +8–12 % bei HumanEval im Vergleich zum ursprünglichen V3

• Besser bei Codebasen mit mehreren Dateien und komplexen Refactoring-Aufgaben

• Verbessertes Verständnis moderner Frameworks (FastAPI, Pydantic v2, LangChain v0.3)

• Zuverlässiger beim Generieren vollständigen, lauffähigen Codes ohne Auslassungen

Mathematisches Schlussfolgern

• +5 % bei MATH-500 Benchmark

• Bessere schrittweise Beweiskonstruktion

• Verbesserte numerische Genauigkeit bei mehrstufigen Problemen

• Erweiterte Fähigkeit, Fehler mitten in der Lösung zu erkennen und zu korrigieren

Allgemeines Schlussfolgern

• Stärkere logische Deduktion und kausale Inferenz

• Besser bei mehrstufigen Planungsaufgaben

• Konsistentere Leistung bei Randfällen und mehrdeutigen Prompts

• Verbesserte Befolgung von Anweisungen bei komplexen Anfragen mit mehreren Einschränkungen

Schnellbereitstellung auf CLORE.AI

Docker-Image:

vllm/vllm-openai:latest

Ports:

22/tcp
8000/http

Befehl (Multi-GPU erforderlich):

python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --host 0.0.0.0 \
    --port 8000 \\
    --tensor-parallel-size 8 \
    --trust-remote-code

Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine http_pub URL in Meine Bestellungen:

1. Gehe zu Meine Bestellungen Seite

2. Klicke auf deine Bestellung

3. Finde die http_pub URL (z. B. abc123.clorecloud.net)

Verwende https://YOUR_HTTP_PUB_URL anstelle von localhost in den folgenden Beispielen.

Prüfen, ob es funktioniert

# Prüfen, ob der Dienst bereit ist
curl https://your-http-pub.clorecloud.net/health

# Verfügbare Modelle auflisten
curl https://your-http-pub.clorecloud.net/v1/models

# Version abrufen
curl https://your-http-pub.clorecloud.net/version

Wichtig: DeepSeek-V3 benötigt 8x A100 80 GB GPUs und eine erhebliche Downloadzeit. HTTP 502 kann 15–30 Minuten lang bestehen bleiben, während das Modell heruntergeladen wird.

Modellvarianten

Modell	Parameter	Aktiv	Erforderlicher VRAM	HuggingFace
DeepSeek-V3-0324	671B	37B	8x80GB	deepseek-ai/DeepSeek-V3-0324
DeepSeek-V3	671B	37B	8x80GB	deepseek-ai/DeepSeek-V3
DeepSeek-V3-Base	671B	37B	8x80GB	deepseek-ai/DeepSeek-V3-Base
DeepSeek-V2.5	236B	21B	4x80GB	deepseek-ai/DeepSeek-V2.5
DeepSeek-V2-Lite	16B	2.4B	16 GB	deepseek-ai/DeepSeek-V2-Lite
DeepSeek-Coder-V2	236B	21B	4x80GB	deepseek-ai/DeepSeek-Coder-V2-Instruct

Hardware-Anforderungen

Multi-GPU-Rigs der 80GB-Klasse sind auf dem Clore.ai-Marktplatz nicht gelistet. Die größten heute gelisteten Systeme sind 4× RTX PRO 6000 Blackwell (je 96 GB, 380 GB gesamt) und 8–11× RTX 5090 (je 32 GB). Kapazitäten für A100 / H200 / B200 werden als Bare Metal auf Anfrage verkauft. Prüfe GPU-Preise & Verfügbarkeit bevor du eine Bereitstellung dimensionierst.

Volle Präzision

Modell	Minimum	Empfohlen
DeepSeek-V3-0324	8x A100 80 GB	8x H100 80GB
DeepSeek-V2.5	4x A100 80 GB	4x H100 80GB
DeepSeek-V2-Lite	RTX 4090 24GB	A100 40GB

Quantisiert (AWQ/GPTQ)

Modell	Quantisierung	VRAM
DeepSeek-V3-0324	INT4	4x80GB
DeepSeek-V2.5	INT4	2x80GB
DeepSeek-V2-Lite	INT4	8 GB

Installation

Mit vLLM (empfohlen)

pip install vllm==0.7.3

# DeepSeek-V3-0324 (neueste, 8 GPUs)
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --tensor-parallel-size 8 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

# Original-V3 (weiterhin verfügbar)
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3 \
    --tensor-parallel-size 8 \
    --trust-remote-code \
    --host 0.0.0.0 \
    --port 8000

Mit Transformers

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "deepseek-ai/DeepSeek-V3-0324"

tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.bfloat16,
    device_map="auto",
    trust_remote_code=True
)

messages = [{"role": "user", "content": "Erkläre Quantencomputing in einfachen Worten."}]
inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device)

outputs = model.generate(inputs, max_new_tokens=512, temperature=0.7)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Verwendung von Ollama

# DeepSeek-V3 abrufen (erfordert erhebliche Ressourcen)
ollama pull deepseek-v3

# Oder leichtere Variante
ollama pull deepseek-coder-v2:16b

# Ausführen
ollama run deepseek-v3

API-Nutzung

OpenAI-kompatible API (vLLM)

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="not-needed"
)

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[
        {"role": "system", "content": "Du bist ein hilfreicher KI-Assistent."},
        {"role": "user", "content": "Schreibe eine Python-Funktion, um Primzahlen zu finden."}
    ],
    temperature=0.7,
    max_tokens=1000
)

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

Streaming

stream = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": "Erkläre maschinelles Lernen"}],
    stream=True
)

for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

cURL

curl http://localhost:8000/v1/chat/completions \\
    -H "Content-Type: application/json" \\
    -d '{
        "model": "deepseek-ai/DeepSeek-V3-0324",
        "messages": [
            {"role": "user", "content": "Was ist die Hauptstadt von Frankreich?"}
        ],
        "temperature": 0.7
    }'

DeepSeek-V2-Lite (Einzel-GPU)

Für Nutzer mit eingeschränkter Hardware:

# Mit vLLM
python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V2-Lite \
    --trust-remote-code \
    --host 0.0.0.0

# Mit Ollama
ollama run deepseek-coder-v2:16b

# Verwendung von Transformers auf einer einzelnen GPU
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model = AutoModelForCausalLM.from_pretrained(
    "deepseek-ai/DeepSeek-V2-Lite",
    torch_dtype=torch.float16,
    device_map="cuda",
    trust_remote_code=True
)
tokenizer = AutoTokenizer.from_pretrained("deepseek-ai/DeepSeek-V2-Lite", trust_remote_code=True)

Codegenerierung

DeepSeek-V3-0324 ist erstklassig für Code:

prompt = """Schreibe eine Python-Klasse für einen binären Suchbaum mit:
- Einfügen
- Suchen
- Löschen
- In-Order-Traversierung
Typannotationen und Docstrings einschließen."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.2  # Niedriger für Code
)

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

Fortgeschrittene Codeaufgaben, bei denen V3-0324 glänzt:

# Refactoring mehrerer Dateien
prompt = """Ich habe eine Flask-Anwendung, deren gesamter Code in app.py (500 Zeilen) liegt.
Strukturiere sie um, sodass das Application-Factory-Muster mit Blueprints für Folgendes verwendet wird:
- auth (Anmeldung, Registrierung, Abmeldung)
- api (REST-Endpunkte)
- admin (Dashboard)
Zeige die vollständige Dateistruktur und alle Dateien."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1,
    max_tokens=4000
)

Mathematik & Schlussfolgern

# Komplexes Mathematikproblem
prompt = """Beweise, dass für jede ganze Zahl n >= 1 die Summe 1^2 + 2^2 + ... + n^2 = n(n+1)(2n+1)/6.
Verwende vollständige Induktion und zeige alle Schritte klar auf."""

response = client.chat.completions.create(
    model="deepseek-ai/DeepSeek-V3-0324",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1  # Sehr niedrig für Mathematik
)

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

Multi-GPU-Konfiguration

8x GPU (Gesamtmodell — V3-0324)

python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V3-0324 \
    --tensor-parallel-size 8 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.9 \\
    --trust-remote-code

4x GPU (V2.5)

python -m vllm.entrypoints.openai.api_server \
    --model deepseek-ai/DeepSeek-V2.5 \\
    --tensor-parallel-size 4 \
    --max-model-len 16384 \
    --trust-remote-code

Leistung

Durchsatz (Tokens/Sek.)

Modell	GPUs	Kontext	Tokens/Sek.
DeepSeek-V3-0324	8x H100	32K	~85
DeepSeek-V3-0324	8x A100 80 GB	32K	~52
DeepSeek-V3-0324 INT4	4x A100 80 GB	16K	~38
DeepSeek-V2.5	4x A100 80 GB	16K	~70
DeepSeek-V2.5	2x A100 80 GB	8K	~45
DeepSeek-V2-Lite	RTX 4090	8K	~40
DeepSeek-V2-Lite	RTX 3090	4K	~25

Zeit bis zum ersten Token (TTFT)

Modell	Konfiguration	TTFT
DeepSeek-V3-0324	8x H100	~750ms
DeepSeek-V3-0324	8x A100	~1100ms
DeepSeek-V2.5	4x A100	~500ms
DeepSeek-V2-Lite	RTX 4090	~150ms

Speichernutzung

Modell	Präzision	Erforderlicher VRAM
DeepSeek-V3-0324	FP16	8x 80GB
DeepSeek-V3-0324	INT4	4x 80GB
DeepSeek-V2.5	FP16	4x 80GB
DeepSeek-V2.5	INT4	2x 80GB
DeepSeek-V2-Lite	FP16	20 GB
DeepSeek-V2-Lite	INT4	10 GB

Benchmarks

DeepSeek-V3-0324 vs. Konkurrenz

Benchmark	V3-0324	V3 (ursprünglich)	GPT-4o	Claude 3.5 Sonnet
MMLU	88.5%	87.1%	88.7%	88.3%
HumanEval	90.2%	82.6%	90.2%	92.0%
MATH-500	67.1%	61.6%	76.6%	71.1%
GSM8K	92.1%	89.3%	95.8%	96.4%
LiveCodeBench	72.4%	65.9%	71.3%	73.8%
Codeforces-Rating	1850	1720	1780	1790

Hinweis: Die Verbesserung von MATH-500 von V3 → V3-0324 beträgt +5,5 Prozentpunkte.

Docker Compose

version: '3.8'

services:
  deepseek:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    environment:
      - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN}
    command: >
      --model deepseek-ai/DeepSeek-V2-Lite
      --host 0.0.0.0
      --port 8000
      --trust-remote-code
      --gpu-memory-utilization 0.9
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

Zusammenfassung der GPU-Anforderungen

Anwendungsfall	Empfohlene Einrichtung	Kosten/Stunde
Vollständiges DeepSeek-V3-0324	8x A100 80 GB	~$2.00
DeepSeek-V2.5	4x A100 80 GB	~$1.00
Entwicklung/Testen	RTX 4090 (V2-Lite)	~$0.10
Produktions-API	8x H100 80GB	~$3.00

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise:

GPU-Konfiguration	Stundensatz	Tagessatz
RTX 4090 24GB	~$0.10	~$2.30
A100 40GB	~$0.17	~$4.00
A100 80GB	~$0.25	~$6.00
4x A100 80 GB	~$1.00	~$24.00
8x A100 80 GB	~$2.00	~$48.00

Preise variieren je nach Anbieter. Prüfen CLORE.AI-Marktplatz für aktuelle Preise.

Geld sparen:

• Nutzen Sie den Spot Markt für Entwicklung — etwa ein Drittel der Serverpreise liegt im Spot unter dem On-Demand-Preis (Median ~13 % Rabatt), der Rest entspricht ihm

• Bezahlen Sie mit CLORE Tokens

• Verwenden Sie DeepSeek-V2-Lite zum Testen, bevor Sie skalieren

Fehlerbehebung

Speicher erschöpft

# Kontextlänge reduzieren
--max-model-len 8192

# Oder Quantisierung verwenden
--quantization awq

# Für V2-Lite auf 12-GB-GPU
--gpu-memory-utilization 0.85
--max-model-len 4096

Langsamer Modell-Download

# Vorab herunterladen
huggingface-cli download deepseek-ai/DeepSeek-V3-0324

# Oder Mirror verwenden
export HF_ENDPOINT=https://hf-mirror.com

Fehler bei trust_remote_code

# Fügen Sie dieses Flag für DeepSeek-Modelle immer hinzu
--trust-remote-code

Multi-GPU funktioniert nicht

# NCCL prüfen
nvidia-smi topo -m

# NCCL-Variablen setzen
export NCCL_DEBUG=INFO
export NCCL_P2P_DISABLE=0

DeepSeek vs. andere

Funktion	DeepSeek-V3-0324	Llama 3.1 405B	Mixtral 8x22B
Parameter	671B (37B aktiv)	405B	176B (44B aktiv)
Kontext	128K	128K	64K
Code	Hervorragend	Großartig	Gut
Mathe	Hervorragend	Gut	Gut
Min. VRAM	8x80GB	8x80GB	2x80GB
Lizenz	MIT	Llama 3.1	Apache 2.0

DeepSeek-V3 verwenden, wenn:

• Beste Schlussfolgerungsleistung benötigt wird

• Codegenerierung der Hauptanwendungsfall ist

• Mathe-/Logikaufgaben wichtig sind

• Eine Multi-GPU-Einrichtung verfügbar ist

• Sie vollständig offene Open-Source-Gewichte (MIT-Lizenz) möchten

Nächste Schritte

• vLLM - Bereitstellungsserver

• DeepSeek-R1 - Auf Schlussfolgern spezialisierte Variante

• DeepSeek Coder - Code-spezifische Variante

• Ollama - Einfachere Bereitstellung

• LLM feinabstimmen - Anpassungstraining