# Qwen2.5

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

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die über [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Warum Qwen2.5?

* **Vielseitige Größen** - 0,5B bis 72B Parameter
* **Mehrsprachig** - 29 Sprachen einschließlich Chinesisch
* **Langer Kontext** - Bis zu 128K Token
* **Spezialisierte Varianten** - Coder-, Math-Editionen
* **Open Source** - Apache-2.0-Lizenz

## Schnelle Bereitstellung auf CLORE.AI

**Docker-Image:**

```
vllm/vllm-openai:latest
```

**Ports:**

```
22/tcp
8000/http
```

**Befehl:**

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

## 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

```bash
# 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
```

{% hint style="warning" %}
Wenn Sie HTTP 502 erhalten, warten Sie 5–15 Minuten – das Modell wird noch von HuggingFace heruntergeladen.
{% endhint %}

## Qwen3 Reasoning-Modus

{% hint style="info" %}
**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.
{% endhint %}

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

```json
{
  "content": "<think>\nLass mich Schritt für Schritt darüber nachdenken...\n</think>\n\nDie Antwort ist..."
}
```

Um Qwen3 mit Reasoning zu verwenden:

```bash
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      | 4GB         | 32K     | Sehr leicht                   |
| Qwen2.5-3B           | 3B        | 8GB         | 32K     | Budget                        |
| Qwen2.5-7B           | 7B        | 16GB        | 128K    | Ausgeglichen                  |
| Qwen2.5-14B          | 14B       | 32GB        | 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    | Chat-/Instruct-Feinabgestimmt |

### Spezialisierte Varianten

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

## Hardware-Anforderungen

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

## Installation

### Verwendung von vLLM (empfohlen)

```bash
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

```bash
# 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

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

# Chat ausführen
ollama run qwen2.5:7b
```

### Verwendung von Transformers

```python
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

```python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8000/v1",
    api_key="nicht benötigt"
)

response = client.chat.completions.create(
    model="Qwen/Qwen2.5-7B-Instruct",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Erklären Sie maschinelles Lernen in einfachen Worten."}
    ],
    temperature=0.7,
    max_tokens=500
)

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

### Streaming

```python
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

```bash
curl http://localhost:8000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d '{
        "model": "Qwen/Qwen2.5-7B-Instruct",
        "messages": [
            {"role": "user", "content": "What is Python?"}
        ]
    }'
```

## Qwen2.5-72B-Instruct

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

### Ausführung über vLLM (Multi-GPU)

```bash
# 4x A100 80GB Setup
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 2x 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

```bash
# Ziehen Sie das 72B-Modell (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

```python
from openai import OpenAI

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

# Das 72B-Modell eignet sich hervorragend für komplexe analytische Aufgaben
response = client.chat.completions.create(
    model="Qwen/Qwen2.5-72B-Instruct",
    messages=[
        {
            "role": "system",
            "content": "Sie sind ein Experte für Analyse. Geben Sie detaillierte, nuancierte Antworten."
        },
        {
            "role": "user",
            "content": """Vergleichen Sie die architektonischen Unterschiede zwischen Transformer und 
            State-Space-Modellen (SSMs) für die Sequenzmodellierung. Schließen Sie Effizienzkompromisse ein."""
        }
    ],
    temperature=0.7,
    max_tokens=2000
)

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

## Qwen2.5-Coder-32B-Instruct

Das beste Open-Source-Codemodell, das verfügbar ist. Qwen2.5-Coder-32B-Instruct erreicht in vielen Coding-Benchmarks das Niveau von GPT-4o oder übertrifft es und unterstützt über 40 Programmiersprachen.

### Ausführung über vLLM

```bash
# 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

# Duale RTX 4090 (24GB jeweils = 48GB insgesamt, Verwendung von 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

```bash
# Ziehen Sie Coder-32B (erfordert ~22GB VRAM für Q4)
ollama pull qwen2.5-coder:32b

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

# Testen mit einer Coding-Aufforderung
ollama run qwen2.5-coder:32b "Schreibe einen asynchronen Python-Web-Scraper mit aiohttp"
```

### Beispiele zur Codegenerierung

```python
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": "Sie sind ein erfahrener Softwareingenieur. Schreiben Sie sauberen, produktionsreifen Code mit geeigneter Fehlerbehandlung und Dokumentation."
        },
        {
            "role": "user",
            "content": """Schreiben Sie 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. Geeignete Fehlerbehandlung, Eingabevalidierung mit Pydantic und Async-Unterstützung enthält"""
        }
    ],
    temperature=0.1,  # Niedrige Temperatur für Code
    max_tokens=3000
)

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

````python
# 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üfen Sie diesen Python-Code auf Performance-Probleme und schlagen Sie 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:

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

# Verwendung von Ollama
ollama run qwen2.5-coder:7b
```

```python
prompt = """Schreiben Sie eine Python-Funktion, die:
1. Eine Liste von Zahlen entgegennimmt
2. Den Medianwert zurückgibt
3. Leere Listen elegant behandelt
Fügen Sie Typannotationen und Docstrings hinzu."""

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

Spezialisiert für mathematisches Denken:

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

```python
prompt = """Lösen Sie Schritt für Schritt:
Finden Sie 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:

```python
# 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)

```python
# Lesen Sie ein langes Dokument
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"Fassen Sie dieses Dokument zusammen:\n\n{document}"}
    ],
    max_tokens=2000
)
```

## Quantisierung

### GGUF mit Ollama

```bash
# 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

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

### GGUF mit llama.cpp

```bash
# 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-Setup

### Tensor-Parallele Verarbeitung

```bash
# 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       | 35ms       |
| 14B    | 120ms    | 80ms       | 60ms       |
| 32B    | -        | 200ms      | 140ms      |
| 72B    | -        | 400ms (2x) | 280ms (2x) |

### Kontextlänge vs. VRAM (7B)

| Kontext | FP16 | Q8   | Q4   |
| ------- | ---- | ---- | ---- |
| 8K      | 16GB | 10GB | 6GB  |
| 32K     | 24GB | 16GB | 10GB |
| 64K     | 40GB | 26GB | 16GB |
| 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

```yaml
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]
```

## Kostenabschätzung

Typische CLORE.AI-Marktplatzpreise:

| GPU           | Stundensatz | Am besten geeignet für |
| ------------- | ----------- | ---------------------- |
| RTX 3090 24GB | \~$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 80GB  | \~$0.50     | 72B-Modelle            |
| 4x A100 80GB  | \~$1.00     | 72B maximaler Kontext  |

*Preise variieren je nach Anbieter. Prüfe* [*CLORE.AI Marketplace*](https://clore.ai/marketplace) *auf aktuelle Preise.*

**Geld sparen:**

* Verwenden Sie **Spot** Markt für flexible Workloads
* Bezahlen mit **CLORE** Token
* Beginnen Sie mit kleineren Modellen (7B) zum Testen

## Fehlerbehebung

### Kein Speicher mehr

```bash
# Kontext reduzieren
--max-model-len 8192

# Aktivieren Sie Speicheroptimierung
--gpu-memory-utilization 0.85

# Verwenden Sie quantisiertes Modell
ollama pull qwen2.5:7b-instruct-q4_K_M
```

### Langsame Generierung

```bash
# Flash-Attention aktivieren
pip install flash-attn

# Verwenden Sie vLLM für besseren Durchsatz
python -m vllm.entrypoints.openai.api_server \
    --model Qwen/Qwen2.5-7B-Instruct \
    --enable-prefix-caching
```

### Anzeige chinesischer Zeichen

```python
# Stellen Sie UTF-8-Codierung sicher
import sys
sys.stdout.reconfigure(encoding='utf-8')
```

### Modell nicht gefunden

```bash
# Überprüfen Sie den Modellnamen
huggingface-cli search Qwen/Qwen2.5

# Geläufige 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 vs. Andere

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

**Verwenden Sie Qwen2.5, wenn:**

* Unterstützung der chinesischen Sprache erforderlich ist
* Mathematik-/Code-Aufgaben Priorität haben
* Ein langer Kontext erforderlich ist
* Sie die Apache-2.0-Lizenz wünschen
* Sie das beste Open-Source-Codemodell benötigen (Coder-32B)

## Nächste Schritte

* [vLLM](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/vllm) - Produktionsbereitstellung
* [Ollama](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/ollama) - Einfache lokale Einrichtung
* [DeepSeek-V3](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/deepseek-v3) - Größeres Reasoning-Modell
* [DeepSeek-R1](https://docs.clore.ai/guides/guides_v2-de/sprachmodelle/deepseek-r1) - Open-Source-Reasoning-Modell
* [LLM feinabstimmen](https://docs.clore.ai/guides/guides_v2-de/training/finetune-llm) - Benutzerdefiniertes Training