Qwen2.5

Führen Sie Alibabas Qwen2.5 mehrsprachige LLMs auf Clore.ai GPUs aus

Führen Sie 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 über CLORE.AI Marketplace.

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:

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:

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.

Ü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

Wenn Sie HTTP 502 erhalten, warten Sie 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 Schritt für Schritt darüber nachdenken...\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

4GB

32K

Sehr leicht

Qwen2.5-3B

8GB

32K

Budget

Qwen2.5-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

Installation

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

# 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

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="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

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": "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)

# 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

# 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

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

# 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

# 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

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)

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

# 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

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:

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

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:

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

# 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

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

Tensor-Parallele Verarbeitung

# 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

100

130

150

Qwen2.5-7B Q4

110

140

180

200

Qwen2.5-14B

Qwen2.5-32B

Qwen2.5-72B

20 (2x)

40 (2x)

Qwen2.5-72B Q4

55 (2x)

Qwen2.5-Coder-32B

Zeit bis zum ersten Token (TTFT)

Modell

RTX 4090

A100 40GB

A100 80GB

60ms

40ms

35ms

14B

120ms

80ms

60ms

32B

200ms

140ms

72B

400ms (2x)

280ms (2x)

Kontextlänge vs. VRAM (7B)

Kontext

FP16

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

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

# 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

# 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

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

Modell nicht gefunden

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

Mehrsprachig

Ausgezeichnet

Gut

Ausgezeichnet

Code

Ausgezeichnet

Gut

Ausgezeichnet

Mathematik

Ausgezeichnet

Gut

Ausgezeichnet

Chinesisch

Ausgezeichnet

Schlecht

Gut

Lizenz

Apache 2.0

Llama 3.1

Proprietär

Kosten

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 - Produktionsbereitstellung
Ollama - Einfache lokale Einrichtung
DeepSeek-V3 - Größeres Reasoning-Modell
DeepSeek-R1 - Open-Source-Reasoning-Modell
LLM feinabstimmen - Benutzerdefiniertes Training

VorherigeDeepSeek-R1 Reasoning-Modell NächsteCodeLlama

Zuletzt aktualisiert vor 1 Tag

War das hilfreich?

hashtagWarum Qwen2.5?

hashtagSchnelle Bereitstellung auf CLORE.AI

hashtagZugriff auf Ihren Dienst

hashtagÜberprüfen, ob es funktioniert

hashtagQwen3 Reasoning-Modus

hashtagModellvarianten

hashtagBasis-Modelle

hashtagSpezialisierte Varianten

hashtagHardware-Anforderungen

hashtagInstallation

hashtagVerwendung von vLLM (empfohlen)

hashtagVerwendung von Ollama

hashtagVerwendung von Transformers

hashtagAPI-Nutzung

hashtagOpenAI‑kompatible API

hashtagStreaming

hashtagcURL

hashtagQwen2.5-72B-Instruct

hashtagAusführung über vLLM (Multi-GPU)

hashtagAusführung über Ollama

hashtagPython-Beispiel

hashtagQwen2.5-Coder-32B-Instruct

hashtagAusführung über vLLM

hashtagAusführung über Ollama

hashtagBeispiele zur Codegenerierung

hashtagQwen2.5-Coder

hashtagQwen2.5-Math

hashtagMehrsprachige Unterstützung

hashtagLanger Kontext (128K)

hashtagQuantisierung

hashtagGGUF mit Ollama

hashtagAWQ mit vLLM

hashtagGGUF mit llama.cpp

hashtagMulti-GPU-Setup

hashtagTensor-Parallele Verarbeitung

hashtagLeistung

hashtagDurchsatz (Tokens/Sek)

hashtagZeit bis zum ersten Token (TTFT)

hashtagKontextlänge vs. VRAM (7B)

hashtagBenchmarks

hashtagDocker Compose

hashtagKostenabschätzung

hashtagFehlerbehebung

hashtagKein Speicher mehr

hashtagLangsame Generierung

hashtagAnzeige chinesischer Zeichen

hashtagModell nicht gefunden

hashtagQwen2.5 vs. Andere

hashtagNächste Schritte

Warum Qwen2.5?

Schnelle Bereitstellung auf CLORE.AI

Zugriff auf Ihren Dienst

Überprüfen, ob es funktioniert

Qwen3 Reasoning-Modus

Modellvarianten

Basis-Modelle

Spezialisierte Varianten

Hardware-Anforderungen

Installation

Verwendung von vLLM (empfohlen)

Verwendung von Ollama

Verwendung von Transformers

API-Nutzung

OpenAI‑kompatible API

Streaming

cURL

Qwen2.5-72B-Instruct

Ausführung über vLLM (Multi-GPU)

Ausführung über Ollama

Python-Beispiel

Qwen2.5-Coder-32B-Instruct

Ausführung über vLLM

Ausführung über Ollama

Beispiele zur Codegenerierung

Qwen2.5-Coder

Qwen2.5-Math

Mehrsprachige Unterstützung

Langer Kontext (128K)

Quantisierung

GGUF mit Ollama

AWQ mit vLLM

GGUF mit llama.cpp

Multi-GPU-Setup

Tensor-Parallele Verarbeitung

Leistung

Durchsatz (Tokens/Sek)

Zeit bis zum ersten Token (TTFT)

Kontextlänge vs. VRAM (7B)

Benchmarks

Docker Compose

Kostenabschätzung

Fehlerbehebung

Kein Speicher mehr

Langsame Generierung

Anzeige chinesischer Zeichen

Modell nicht gefunden

Qwen2.5 vs. Andere

Nächste Schritte