DeepSeek Coder

Erstklassige Codegenerierung mit DeepSeek Coder auf Clore.ai

Neuere Versionen verfügbar! DeepSeek-R1 (Schlussfolgerung + Codierung) und DeepSeek-V3 (Allzweck) sind deutlich leistungsfähiger. Siehe auch Qwen2.5-Coder für eine starke Alternative zur Codierung.

Beste Codegenerierung ihrer Klasse mit DeepSeek Coder-Modellen.

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

Mieten auf CLORE.AI

Besuchen Sie CLORE.AI Marketplace
Nach GPU-Typ, VRAM und Preis filtern
Wählen On-Demand (Festpreis) oder Spot (Gebotspreis)
Konfigurieren Sie Ihre Bestellung:
- Docker-Image auswählen
- Ports festlegen (TCP für SSH, HTTP für Web-UIs)
- Umgebungsvariablen bei Bedarf hinzufügen
- Startbefehl eingeben
Zahlung auswählen: CLORE, BTC, oder USDT/USDC
Bestellung erstellen und auf Bereitstellung warten

Zugriff auf Ihren Server

Verbindungsdetails finden Sie in Meine Bestellungen
Webschnittstellen: Verwenden Sie die HTTP-Port-URL
SSH: ssh -p <port> root@<proxy-address>

Was ist DeepSeek Coder?

DeepSeek Coder bietet:

Modernste Codegenerierung
338 Programmiersprachen
Fill-in-the-middle-Unterstützung
Repository-übergreifendes Verständnis

Modellvarianten

Modell

Parameter

VRAM

Kontext

DeepSeek-Coder-1.3B

1,3B

3GB

16K

DeepSeek-Coder-6.7B

6.7B

8GB

16K

DeepSeek-Coder-33B

33B

40GB

16K

DeepSeek-Coder-V2

16B/236B

20GB+

128K

Schnelle Bereitstellung

Docker-Image:

pytorch/pytorch:2.5.1-cuda12.4-cudnn9-runtime

Ports:

22/tcp
8000/http

Befehl:

pip install vllm && \
vllm serve deepseek-ai/deepseek-coder-6.7b-instruct --port 8000

Zugriff auf Ihren Dienst

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

Gehen Sie zur Meine Bestellungen Seite
Klicken Sie auf Ihre Bestellung
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.

Verwendung von Ollama


# DeepSeek Coder ausführen
ollama run deepseek-coder

# Spezifische Größen
ollama run deepseek-coder:1.3b
ollama run deepseek-coder:6.7b
ollama run deepseek-coder:33b

# V2 (neueste)
ollama run deepseek-coder-v2

Installation

pip install transformers accelerate torch

Codegenerierung

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "deepseek-ai/deepseek-coder-6.7b-instruct"

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

messages = [
    {"role": "user", "content": """
Schreibe eine Python-Klasse für einen REST-API-Client mit:
- Unterstützung für Authentifizierung
- Retry-Logik mit exponentiellem Backoff
- Anfrage-/Antwort-Protokollierung
"""}
]

inputs = tokenizer.apply_chat_template(
    messages,
    add_generation_prompt=True,
    return_tensors="pt"
).to("cuda")

outputs = model.generate(
    inputs,
    max_new_tokens=1024,
    temperature=0.2,
    do_sample=True
)

print(tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True))

Fill-in-the-Middle (FIM)

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "deepseek-ai/deepseek-coder-6.7b-base"

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

# Fill-in-the-middle-Format
prefix = """def calculate_statistics(data):
    \"\"\"Berechne Mittelwert, Median und Std einer Liste.\"\"\"
    import statistics

    mean = statistics.mean(data)
"""

suffix = """
    return {
        'mean': mean,
        'median': median,
        'std': std
    }
"""

# FIM-Tokens
prompt = f"<｜fim▁begin｜>{prefix}<｜fim▁hole｜>{suffix}<｜fim▁end｜>"

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=128)

print(tokenizer.decode(outputs[0], skip_special_tokens=True))

DeepSeek-Coder-V2

Neueste und leistungsstärkste:

from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "deepseek-ai/DeepSeek-Coder-V2-Lite-Instruct"

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

messages = [
    {"role": "user", "content": "Implementiere einen threadsicheren LRU-Cache in Python"}
]

inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to("cuda")
outputs = model.generate(inputs, max_new_tokens=1024, temperature=0.2)
print(tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True))

vLLM-Server

vllm serve deepseek-ai/deepseek-coder-6.7b-instruct \
    --port 8000 \
    --dtype bfloat16 \
    --max-model-len 16384 \
    --trust-remote-code

API-Nutzung

from openai import OpenAI

client = OpenAI(base_url="http://localhost:8000/v1", api_key="x")

response = client.chat.completions.create(
    model="deepseek-ai/deepseek-coder-6.7b-instruct",
    messages=[
        {"role": "system", "content": "Du bist ein erfahrener Programmierer."},
        {"role": "user", "content": "Schreibe einen FastAPI Websocket-Server"}
    ],
    temperature=0.2,
    max_tokens=1500
)

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

Code-Review

code_to_review = """
def process_data(data):
    result = []
    for i in range(len(data)):
        if data[i] > 0:
            result.append(data[i] * 2)
    return result
"""

messages = [
    {"role": "user", "content": f"""
Überprüfe diesen Code und schlage Verbesserungen vor:

```python
{code_to_review}

Fokus auf:

Leistung
Lesbarkeit
Best Practices """} ]


## Bugfixing

```python
buggy_code = """
def merge_sorted_lists(list1, list2):
    result = []
    i = j = 0
    while i < len(list1) and j < len(list2):
        if list1[i] < list2[j]:
            result.append(list1[i])
            i += 1
        else:
            result.append(list2[j])
    return result
"""

messages = [
    {"role": "user", "content": f"""
Finde und behebe den Fehler in diesem Code:

```python
{buggy_code}

"""} ]


## Gradio-Oberfläche

```python
import gradio as gr
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch

model_id = "deepseek-ai/deepseek-coder-6.7b-instruct"
tokenizer = AutoTokenizer.from_pretrained(model_id, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(
    model_id, torch_dtype=torch.bfloat16, device_map="auto", trust_remote_code=True
)

def generate_code(prompt, temperature, max_tokens):
    messages = [{"role": "user", "content": prompt}]
    inputs = tokenizer.apply_chat_template(messages, return_tensors="pt").to("cuda")
    outputs = model.generate(inputs, max_new_tokens=max_tokens, temperature=temperature, do_sample=True)
    return tokenizer.decode(outputs[0][inputs.shape[1]:], skip_special_tokens=True)

demo = gr.Interface(
    fn=generate_code,
    inputs=[
        gr.Textbox(label="Prompt", lines=5, placeholder="Beschreibe den Code, den du brauchst..."),
        gr.Slider(0.1, 1.0, value=0.2, label="Temperature"),
        gr.Slider(256, 2048, value=1024, step=128, label="Max Tokens")
    ],
    outputs=gr.Code(language="python", label="Generierter Code"),
    title="DeepSeek Coder"
)

demo.launch(server_name="0.0.0.0", server_port=7860)

Leistung

Modell

GPU

Tokens/sec

DeepSeek-1.3B

RTX 3060

~120

DeepSeek-6.7B

RTX 3090

~70

DeepSeek-6.7B

RTX 4090

~100

DeepSeek-33B

A100

~40

DeepSeek-V2-Lite

RTX 4090

~50

Vergleich

Modell

HumanEval

Codequalität

DeepSeek-Coder-33B

79.3%

Ausgezeichnet

CodeLlama-34B

53.7%

Gut

GPT-3.5-Turbo

72.6%

Gut

Fehlerbehebung

Codevervollständigung funktioniert nicht

Stelle das korrekte Prompt-Format sicher mit <|fim_prefix|>, <|fim_suffix|>, <|fim_middle|>
Setze geeignete max_new_tokens für die Codegenerierung

Modell liefert Müll

Überprüfe, ob das Modell vollständig heruntergeladen ist
Verifiziere, dass CUDA verwendet wird: model.device
Versuche eine niedrigere Temperatur (0,2–0,5 für Code)

Langsame Inferenz

Verwende vLLM für 5–10x Geschwindigkeit
Aktivieren Sie torch.compile() für transformers
Verwende quantisiertes Modell für große Varianten

Importfehler

Installiere Abhängigkeiten: pip install transformers accelerate
Aktualisiere PyTorch auf 2.0+

Kostenabschätzung

Typische CLORE.AI-Marktplatztarife (Stand 2024):

GPU

Stundensatz

Tagessatz

4-Stunden-Sitzung

RTX 3060

~$0.03

~$0.70

~$0.12

RTX 3090

~$0.06

~$1.50

~$0.25

RTX 4090

~$0.10

~$2.30

~$0.40

A100 40GB

~$0.17

~$4.00

~$0.70

A100 80GB

~$0.25

~$6.00

~$1.00

Preise variieren je nach Anbieter und Nachfrage. Prüfen Sie CLORE.AI Marketplace auf aktuelle Preise.

Geld sparen:

Verwenden Sie Spot Markt für flexible Workloads (oft 30–50% günstiger)
Bezahlen mit CLORE Token
Preise bei verschiedenen Anbietern vergleichen

Nächste Schritte

DeepSeek-V3 - Neuestes DeepSeek-Flaggschiffmodell
CodeLlama - Alternatives Codemodell
Qwen2.5-Coder - Alibabas Codemodell
vLLM - Produktionsbereitstellung

VorherigeMistral & Mixtral NächsteDeepSeek-V3

Zuletzt aktualisiert vor 1 Tag

War das hilfreich?

hashtagMieten auf CLORE.AI

hashtagZugriff auf Ihren Server

hashtagWas ist DeepSeek Coder?

hashtagModellvarianten

hashtagSchnelle Bereitstellung

hashtagZugriff auf Ihren Dienst

hashtagVerwendung von Ollama

hashtagInstallation

hashtagCodegenerierung

hashtagFill-in-the-Middle (FIM)

hashtagDeepSeek-Coder-V2

hashtagvLLM-Server

hashtagAPI-Nutzung

hashtagCode-Review

hashtagLeistung

hashtagVergleich

hashtagFehlerbehebung

hashtagCodevervollständigung funktioniert nicht

hashtagModell liefert Müll

hashtagLangsame Inferenz

hashtagImportfehler

hashtagKostenabschätzung

hashtagNächste Schritte

Mieten auf CLORE.AI

Zugriff auf Ihren Server

Was ist DeepSeek Coder?

Modellvarianten

Schnelle Bereitstellung

Zugriff auf Ihren Dienst

Verwendung von Ollama

Installation

Codegenerierung

Fill-in-the-Middle (FIM)

DeepSeek-Coder-V2

vLLM-Server

API-Nutzung

Code-Review

Leistung

Vergleich

Fehlerbehebung

Codevervollständigung funktioniert nicht

Modell liefert Müll

Langsame Inferenz

Importfehler

Kostenabschätzung

Nächste Schritte