DeepSeek-V3

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

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

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

Aktualisiert: DeepSeek-V3-0324 (März 2024) — Die neueste Revision von DeepSeek-V3 bringt erhebliche Verbesserungen bei der Codeerzeugung, mathematischen Argumentation und allgemeinen Problemlösung. Siehe das Changelog Abschnitt für Details.

Warum DeepSeek-V3?

• State-of-the-art - Konkuriert mit GPT-4o und Claude 3.5 Sonnet

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

• Verbesserte Schlussfolgerung - DeepSeek-V3-0324 ist deutlich besser in Mathematik und Code

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

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

• Langer Kontext - 128K Token Kontexfenster

Was ist neu in DeepSeek-V3-0324

DeepSeek-V3-0324 (Revision März 2024) führt bedeutende Verbesserungen in Schlüsselbereichen ein:

Codegenerierung

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

• Besser bei Multi-Datei-Codebasen und komplexen Refaktorierungsaufgaben

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

• Zuverlässiger bei der Erzeugung vollständigen, ausführbaren Codes ohne Auslassungen

Mathematische Argumentation

• +5% beim MATH-500 Benchmark

• Besserer schrittweiser Beweisaufbau

• Verbesserte numerische Genauigkeit bei mehrstufigen Problemen

• Erhöhte Fähigkeit, Fehler mitten in einer Lösung zu identifizieren und zu korrigieren

Allgemeine Schlussfolgerungen

• Stärkere logische Deduktion und kausale Inferenz

• Besser bei mehrstufigen Planungsaufgaben

• Konsistentere Leistung bei Randfällen und mehrdeutigen Eingaben

• Verbesserte Befolgung von Anweisungen bei komplexen, mehrfachen Einschränkungen

Schnelle Bereitstellung auf CLORE.AI

Docker-Image:

vllm/vllm-openai:latest

Ports:

22/tcp
8000/http

Befehl (Mehrere GPUs 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

Zugriff auf Ihren Dienst

Nach der Bereitstellung finden Sie Ihre http_pub URL in Meine Bestellungen:

1. Gehen Sie zur Meine Bestellungen Seite

2. Klicken Sie auf Ihre Bestellung

3. Finden Sie die http_pub URL (z. B., abc123.clorecloud.net)

Verwenden Sie https://IHRE_HTTP_PUB_URL anstelle von localhost in den Beispielen unten.

Überprü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 erfordert 8x A100 80GB GPUs und erhebliche Downloadzeit. HTTP 502 kann 15–30 Minuten bestehen bleiben, während das Modell heruntergeladen wird.

Modellvarianten

Modell	Parameter	Aktiv	Benötigter 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	16GB	deepseek-ai/DeepSeek-V2-Lite
DeepSeek-Coder-V2	236B	21B	4x80GB	deepseek-ai/DeepSeek-Coder-V2-Instruct

Hardware-Anforderungen

Volle Präzision

Modell	Minimum	Empfohlen
DeepSeek-V3-0324	8x A100 80GB	8x H100 80GB
DeepSeek-V2.5	4x A100 80GB	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	8GB

Installation

Verwendung von 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 (noch 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

Verwendung von 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 herunterladen (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="nicht benötigt"
)

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 (Single GPU)

Für Nutzer mit begrenzter Hardware:

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

# Verwendung von 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
- Inorder-Traversal
Fügen Sie Typannotationen und Docstrings hinzu."""

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)

Erweiterte Codeaufgaben, in denen V3-0324 brilliert:

# Multi-Datei-Refactoring
prompt = """Ich habe eine Flask-Anwendung mit dem gesamten Code in app.py (500 Zeilen).
Refaktoriere sie, um das Application-Factory-Muster mit Blueprints zu verwenden für:
- auth (Login, Registrierung, Logout)
- api (REST-Endpunkte)
- admin (Dashboard)
Zeige die komplette 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 & Schlussfolgerung

# 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 gilt.
Verwende vollständige Induktion und zeige alle Schritte deutlich."""

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 (Vollständiges Modell — 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/sec
DeepSeek-V3-0324	8x H100	32K	~85
DeepSeek-V3-0324	8x A100 80GB	32K	~52
DeepSeek-V3-0324 INT4	4x A100 80GB	16K	~38
DeepSeek-V2.5	4x A100 80GB	16K	~70
DeepSeek-V2.5	2x A100 80GB	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	Benötigter 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	20GB
DeepSeek-V2-Lite	INT4	10GB

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: MATH-500-Verbesserung 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

Einsatzgebiet	Empfohlene Konfiguration	Kosten/Stunde
Volles DeepSeek-V3-0324	8x A100 80GB	~$2.00
DeepSeek-V2.5	4x A100 80GB	~$1.00
Entwicklung/Testing	RTX 4090 (V2-Lite)	~$0.10
Produktions-API	8x H100 80GB	~$3.00

Kostenabschätzung

Typische 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 80GB	~$1.00	~$24.00
8x A100 80GB	~$2.00	~$48.00

Preise variieren je nach Anbieter. Prüfe CLORE.AI Marketplace auf aktuelle Preise.

Geld sparen:

• Verwenden Sie Spot Markt für Entwicklung (oft 30–50% günstiger)

• Bezahlen mit CLORE Token

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

Fehlerbehebung

Kein Speicher mehr

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

# Oder Quantisierung verwenden
--quantization awq

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

Modell-Download langsam

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

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

trust_remote_code-Fehler

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

Multi-GPU funktioniert nicht

# Prüfe NCCL
nvidia-smi topo -m

# Setze NCCL-Variablen
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	Ausgezeichnet	Großartig	Gut
Mathematik	Ausgezeichnet	Gut	Gut
Min. VRAM	8x80GB	8x80GB	2x80GB
Lizenz	MIT	Llama 3.1	Apache 2.0

Verwenden Sie DeepSeek-V3, wenn:

• Beste Schlussfolgerungsleistung benötigt wird

• Codegenerierung die primäre Verwendung ist

• Mathematik/Logikaufgaben wichtig sind

• Eine Multi-GPU-Umgebung verfügbar ist

• Vollständig Open-Source-Gewichte (MIT-Lizenz) gewünscht sind

Nächste Schritte

• vLLM - Bereitstellungsserver

• DeepSeek-R1 - Auf Schlussfolgerungen spezialisiertes Varianten

• DeepSeek Coder - Code-spezifische Variante

• Ollama - Einfachere Bereitstellung

• LLM feinabstimmen - Benutzerdefiniertes Training