Qwen2.5

Führe Alibabas Qwen2.5-Mehrsprach-LLMs auf Clore.ai-GPUs aus

Führe Alibabas Qwen2.5-Modellfamilie aus – leistungsstarke mehrsprachige LLMs mit hervorragenden Code- und Mathematikfähigkeiten auf CLORE.AI-GPUs.

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

Warum Qwen2.5?

• Vielseitige Größen - 0,5B bis 72B Parameter

• Mehrsprachig - 29 Sprachen, darunter Chinesisch

• Langer Kontext - Bis zu 128K Tokens

• Spezialisierte Varianten - Coder-, Math-Editionen

• Open Source - Apache-2.0-Lizenz

Schnellbereitstellung auf CLORE.AI

Docker-Image:

vllm/vllm-openai:latest

Ports:

22/tcp
8000/http

Befehl:

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --host 0.0.0.0 \
    --port 8000

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

Wenn du HTTP 502 erhältst, warte 5–15 Minuten – das Modell wird noch von HuggingFace heruntergeladen.

Qwen3-Reasoning-Modus

Neu in Qwen3: Einige Qwen3-Modelle unterstützen einen Reasoning-Modus, der den Denkprozess des Modells in <think> Tags vor der endgültigen Antwort anzeigt.

Bei der Verwendung von Qwen3-Modellen über vLLM können Antworten Reasoning enthalten:

{
  "content": "<think>\nLass mich das Schritt für Schritt durchdenken...\n</think>\n\nDie Antwort ist..."
}

Um Qwen3 mit Reasoning zu verwenden:

vllm serve Qwen/Qwen3-0.6B --host 0.0.0.0 --port 8000

Modellvarianten

Basis-Modelle

Modell	Parameter	VRAM (FP16)	Kontext	Hinweise
Qwen2.5-0.5B	0.5B	2GB	32K	Edge/Tests
Qwen2.5-1.5B	1.5B	4 GB	32K	Sehr leicht
Qwen2.5-3B	3B	8 GB	32K	Budget
Qwen2.5-7B	7B	16 GB	128K	Ausgewogen
Qwen2.5-14B	14B	32 GB	128K	Hohe Qualität
Qwen2.5-32B	32B	70GB	128K	Sehr hohe Qualität
Qwen2.5-72B	72B	150GB	128K	Beste Qualität
Qwen2.5-72B-Instruct	72B	150GB	128K	Für Chat/Instruct optimiert

Spezialisierte Varianten

Modell	Fokus	Am besten geeignet für	VRAM (FP16)
Qwen2.5-Coder-7B-Instruct	Code	Programmierung, Debugging	16 GB
Qwen2.5-Coder-14B-Instruct	Code	Komplexe Code-Aufgaben	32 GB
Qwen2.5-Coder-32B-Instruct	Code	Bestes Codemodell	70GB
Qwen2.5-Math-7B-Instruct	Mathematik	Berechnungen, Beweise	16 GB
Qwen2.5-Math-72B-Instruct	Mathematik	Mathematik auf Forschungsniveau	150GB
Qwen2.5-Instruct	Chat	Allgemeiner Assistent	variiert

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.

Modell	Minimale GPU	Empfohlen	VRAM (Q4)
0,5B-3B	RTX 3060 12 GB	RTX 3080	2-6GB
7B	RTX 3090 24 GB	RTX 4090	6 GB
14B	A100 40GB	A100 80GB	12 GB
32B	A100 80GB	2x A100 40 GB	22 GB
72B	2x A100 80 GB	4x A100 80 GB	48GB
Coder-32B	A100 80GB	2x A100 40 GB	22 GB

Installation

Mit vLLM (empfohlen)

pip install vllm==0.7.3

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --host 0.0.0.0 \
    --port 8000

Verwendung von Ollama

# Standardmodelle
ollama pull qwen2.5:7b
ollama pull qwen2.5:14b
ollama pull qwen2.5:32b
ollama pull qwen2.5:72b       # Neu: größtes Qwen2.5

# Spezialisierte
ollama pull qwen2.5-coder:7b
ollama pull qwen2.5-coder:32b  # Neu: bestes Codemodell

# Chat starten
ollama run qwen2.5:7b

Mit Transformers

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "Qwen/Qwen2.5-7B-Instruct"

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

messages = [{"role": "user", "content": "Hallo!"}]
text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer([text], return_tensors="pt").to(model.device)

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

API-Nutzung

OpenAI-kompatible API

from openai import OpenAI

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

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
        {"role": "user", "content": "Erkläre maschinelles Lernen in einfachen Worten."}
    ],
    temperature=0.7,
    max_tokens=500
)

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

Streaming

stream = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "Schreibe ein Gedicht über KI"}],
    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": "Qwen/Qwen2.5-7B-Instruct",
        "messages": [
            {"role": "user", "content": "Was ist Python?"}
        ]
    }'

Qwen2.5-72B-Instruct

Das Flaggschiff-Modell von Qwen2.5 — das größte und leistungsfähigste der Familie. Es konkurriert mit GPT-4 bei vielen Benchmarks und ist unter Apache 2.0 vollständig Open Source.

Ausführung über vLLM (Multi-GPU)

# Einrichtung mit 4× A100 80GB
vllm serve Qwen/Qwen2.5-72B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \\
    --tensor-parallel-size 4 \
    --max-model-len 32768 \
    --gpu-memory-utilization 0.9

# AWQ-quantisiert — läuft auf 2× A100 80GB
vllm serve Qwen/Qwen2.5-72B-Instruct-AWQ \
    --host 0.0.0.0 \
    --port 8000 \\
    --tensor-parallel-size 2 \
    --quantization awq \\
    --max-model-len 32768

Ausführung über Ollama

# 72B-Modell herunterladen (erfordert 48GB+ VRAM für Q4)
ollama pull qwen2.5:72b

# Interaktive Sitzung starten
ollama run qwen2.5:72b

# API-Zugriff
curl http://localhost:11434/api/chat -d '{
  "model": "qwen2.5:72b",
  "messages": [{"role": "user", "content": "Analysiere dieses komplexe Szenario..."}],
  "stream": false
}'

Python-Beispiel

from openai import OpenAI

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

# Das 72B-Modell glänzt bei komplexen analytischen Aufgaben
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-72B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Du bist ein Expertenanalyst. Gib detaillierte, nuancierte Antworten."
        },
        {
            "role": "user",
            "content": """Vergleiche die architektonischen Unterschiede zwischen Transformer- und 
            Zustandsraummodellen (SSMs) für die Sequenzmodellierung. Berücksichtige die Effizienzkompromisse."""
        }
    ],
    temperature=0.7,
    max_tokens=2000
)

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

Qwen2.5-Coder-32B-Instruct

Das beste verfügbare Open-Source-Codemodell. Qwen2.5-Coder-32B-Instruct erreicht bei vielen Coding-Benchmarks GPT-4o oder übertrifft es und unterstützt über 40 Programmiersprachen.

Ausführung über vLLM

# Einzelne A100 80GB
vllm serve Qwen/Qwen2.5-Coder-32B-Instruct \
    --host 0.0.0.0 \
    --port 8000 \\
    --max-model-len 16384 \
    --gpu-memory-utilization 0.9

# Zwei RTX 4090 (24GB jeweils = 48GB gesamt, mit Q4-Quantisierung)
vllm serve Qwen/Qwen2.5-Coder-32B-Instruct-AWQ \
    --host 0.0.0.0 \
    --port 8000 \\
    --tensor-parallel-size 2 \
    --quantization awq

Ausführung über Ollama

# Coder-32B herunterladen (erfordert ca. 22GB VRAM für Q4)
ollama pull qwen2.5-coder:32b

# Ausführen
ollama run qwen2.5-coder:32b

# Mit einem Coding-Prompt testen
ollama run qwen2.5-coder:32b "Schreibe einen Python-Async-Web-Scraper mit aiohttp"

Beispiele zur Codegenerierung

from openai import OpenAI

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

# Full-Stack-Codegenerierung
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-32B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Du bist ein Experte für Softwareentwicklung. Schreibe sauberen, produktionsreifen Code mit ordentlicher Fehlerbehandlung und Dokumentation."
        },
        {
            "role": "user",
            "content": """Schreibe einen Python-FastAPI-Dienst, der:
1. POST /summarize mit JSON-Body {"text": "...", "max_length": 150} akzeptiert
2. Eine lokale Ollama-Instanz verwendet, um den Text zusammenzufassen
3. {"summary": "...", "original_length": N, "summary_length": N} zurückgibt
4. Ordentliche Fehlerbehandlung, Eingabevalidierung mit Pydantic und asynchrone Unterstützung enthält"""
        }
    ],
    temperature=0.1,  # Niedrige Temperatur für Code
    max_tokens=3000
)

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

# Code-Review und Debugging
code_to_review = """
def find_duplicates(lst):
    seen = []
    duplicates = []
    for item in lst:
        if item in seen:
            duplicates.append(item)
        seen.append(item)
    return duplicates
"""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-32B-Instruct",
    messages=[
        {
            "role": "user",
            "content": f"Überprüfe diesen Python-Code auf Leistungsprobleme und schlage Verbesserungen vor:\n\n```python\n{code_to_review}\n```"
        }
    ],
    temperature=0.3
)

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

Qwen2.5-Coder

Optimiert für Codegenerierung:

# Mit vLLM
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Coder-7B-Instruct \
    --host 0.0.0.0

# Mit Ollama
ollama run qwen2.5-coder:7b

prompt = """Schreibe eine Python-Funktion, die:
1. Eine Liste von Zahlen entgegennimmt
2. Den Medianwert zurückgibt
3. Leere Listen elegant behandelt
Typannotationen und Docstrings einschließen."""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Coder-7B-Instruct",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.2
)

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

Qwen2.5-Math

Speziell für mathematisches Schlussfolgern:

# Mit vLLM
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Math-7B-Instruct \
    --host 0.0.0.0

prompt = """Schritt für Schritt lösen:
Finde alle Werte von x, für die gilt: x^3 - 6x^2 + 11x - 6 = 0"""

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-Math-7B-Instruct",
    messages=[{"role": "user", "content": prompt}],
    temperature=0.1
)

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

Mehrsprachige Unterstützung

Qwen2.5 unterstützt 29 Sprachen:

# Chinesisch
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "用中文解释什么是人工智能"}]
)

# Japanisch
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "人工知能について日本語で説明してください"}]
)

# Koreanisch
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[{"role": "user", "content": "인공지능에 대해 한국어로 설명해주세요"}]
)

Langer Kontext (128K)

# Ein langes Dokument lesen
with open("long_document.txt", "r") as f:
    document = f.read()

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "user", "content": f"Fasse dieses Dokument zusammen:\n\n{document}"}
    ],
    max_tokens=2000
)

Quantisierung

GGUF mit Ollama

# 4-Bit-quantisiert
ollama pull qwen2.5:7b-instruct-q4_K_M
ollama pull qwen2.5:72b-instruct-q4_K_M   # 72B in 4-Bit (~48GB)

# 8-Bit-quantisiert
ollama pull qwen2.5:7b-instruct-q8_0

# Coder-Varianten
ollama pull qwen2.5-coder:32b-instruct-q4_K_M

AWQ mit vLLM

python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-72B-Instruct-AWQ \
    --quantization awq \\
    --tensor-parallel-size 2

GGUF mit llama.cpp

# GGUF herunterladen
wget https://huggingface.co/Qwen/Qwen2.5-7B-Instruct-GGUF/resolve/main/qwen2.5-7b-instruct-q4_k_m.gguf

# Server starten
./llama-server -m qwen2.5-7b-instruct-q4_k_m.gguf \
    --host 0.0.0.0 \
    --port 8080 \
    -ngl 35

Multi-GPU-Einrichtung

Tensor-Parallelismus

# 72B auf 4 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-72B-Instruct \
    --tensor-parallel-size 4 \
    --max-model-len 32768

# 32B auf 2 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-32B-Instruct \
    --tensor-parallel-size 2

# Coder-32B auf 2 GPUs
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-Coder-32B-Instruct \
    --tensor-parallel-size 2 \
    --max-model-len 16384

Leistung

Durchsatz (Tokens/Sek.)

Modell	RTX 3090	RTX 4090	A100 40GB	A100 80GB
Qwen2.5-0.5B	250	320	380	400
Qwen2.5-3B	150	200	250	280
Qwen2.5-7B	75	100	130	150
Qwen2.5-7B Q4	110	140	180	200
Qwen2.5-14B	-	55	70	85
Qwen2.5-32B	-	-	35	50
Qwen2.5-72B	-	-	20 (2x)	40 (2x)
Qwen2.5-72B Q4	-	-	-	55 (2x)
Qwen2.5-Coder-32B	-	-	32	48

Zeit bis zum ersten Token (TTFT)

Modell	RTX 4090	A100 40GB	A100 80GB
7B	60ms	40ms	35 ms
14B	120ms	80ms	60ms
32B	-	200ms	140ms
72B	-	400ms (2x)	280ms (2x)

Kontextlänge vs. VRAM (7B)

Kontext	FP16	Q8	Q4
8K	16 GB	10 GB	6 GB
32K	24 GB	16 GB	10 GB
64K	40 GB	26GB	16 GB
128K	72GB	48GB	28GB

Benchmarks

Modell	MMLU	HumanEval	GSM8K	MATH	LiveCodeBench
Qwen2.5-7B	74.2%	75.6%	85.4%	55.2%	42.1%
Qwen2.5-14B	79.7%	81.1%	89.5%	65.8%	51.3%
Qwen2.5-32B	83.3%	84.2%	91.2%	72.1%	60.7%
Qwen2.5-72B	86.1%	86.2%	93.2%	79.5%	67.4%
Qwen2.5-Coder-7B	72.8%	88.4%	86.1%	58.4%	64.2%
Qwen2.5-Coder-32B	83.1%	92.7%	92.3%	76.8%	78.5%

Docker Compose

version: '3.8'

services:
  qwen:
    image: vllm/vllm-openai:latest
    ports:
      - "8000:8000"
    volumes:
      - ~/.cache/huggingface:/root/.cache/huggingface
    command: >
      --model Qwen/Qwen2.5-7B-Instruct
      --host 0.0.0.0
      --port 8000
      --gpu-memory-utilization 0.9
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

Kostenschätzung

Übliche CLORE.AI-Marktplatzpreise:

GPU	Stundensatz	Am besten geeignet für
RTX 3090 24 GB	~$0.06	7B-Modelle
RTX 4090 24GB	~$0.10	7B-14B-Modelle
A100 40GB	~$0.17	14B-32B-Modelle
A100 80GB	~$0.25	32B-Modelle, Coder-32B
2x A100 80 GB	~$0.50	72B-Modelle
4x A100 80 GB	~$1.00	72B maximaler Kontext

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

Geld sparen:

• Verwende Spot Markt für flexible Workloads

• Bezahlen Sie mit CLORE Tokens

• Für Tests mit kleineren Modellen (7B) beginnen

Fehlerbehebung

Speicher erschöpft

# Kontext reduzieren
--max-model-len 8192

# Speicheroptimierung aktivieren
--gpu-memory-utilization 0.85

# Quantisiertes Modell verwenden
ollama pull qwen2.5:7b-instruct-q4_K_M

Langsame Generierung

# Flash Attention aktivieren
pip install flash-attn

# vLLM für höheren Durchsatz verwenden
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --enable-prefix-caching

Anzeige chinesischer Zeichen

# UTF-8-Kodierung sicherstellen
import sys
sys.stdout.reconfigure(encoding='utf-8')

Modell nicht gefunden

# Modellnamen prüfen
huggingface-cli search Qwen/Qwen2.5

# Gängige Namen:
# Qwen/Qwen2.5-7B-Instruct
# Qwen/Qwen2.5-72B-Instruct       ← Neu
# Qwen/Qwen2.5-Coder-7B-Instruct
# Qwen/Qwen2.5-Coder-32B-Instruct ← Neu
# Qwen/Qwen2.5-Math-7B-Instruct

Qwen2.5 im Vergleich zu anderen

Funktion	Qwen2.5-7B	Qwen2.5-72B	Llama 3.1 70B	GPT-4o
Kontext	128K	128K	128K	128K
Mehrsprachig	Hervorragend	Hervorragend	Gut	Hervorragend
Code	Hervorragend	Hervorragend	Gut	Hervorragend
Mathe	Hervorragend	Hervorragend	Gut	Hervorragend
Chinesisch	Hervorragend	Hervorragend	Schlecht	Gut
Lizenz	Apache 2.0	Apache 2.0	Llama 3.1	Proprietär
Kosten	Kostenlos	Kostenlos	Kostenlos	Bezahlte API

Qwen2.5 verwenden, wenn:

• Unterstützung für die chinesische Sprache benötigt wird

• Mathe-/Code-Aufgaben Priorität haben

• Langer Kontext erforderlich ist

• Apache-2.0-Lizenz gewünscht

• Bestes Open-Source-Codemodell benötigt (Coder-32B)

Nächste Schritte

• vLLM - Produktionseinsatz

• Ollama - Einfache lokale Einrichtung

• DeepSeek-V3 - Größeres Reasoning-Modell

• DeepSeek-R1 - Open-Source-Reasoning-Modell

• LLM feinabstimmen - Anpassungstraining