# Qwen3 - So führst du es aus und feinstimmst es Qwens neue Qwen3-Modelle liefern modernste Fortschritte in den Bereichen Schlussfolgern, Befolgen von Anweisungen, Agentenfähigkeiten und mehrsprachige Unterstützung. {% hint style="success" %} **NEU!** Qwen3 erhielt im Juli 2025 ein Update. Führe das neueste Modell aus und fine-tune es: [**Qwen-2507**](/docs/de/modelle/tutorials/qwen3-next.md) {% endhint %} Alle Uploads verwenden Unsloth [Dynamic 2.0](/docs/de/grundlagen/unsloth-dynamic-2.0-ggufs.md) für SOTA 5-Shot-MMLU- und KL-Divergenz-Performance, was bedeutet, dass du quantisierte Qwen-LLMs mit minimalem Genauigkeitsverlust ausführen und fine-tunen kannst. Wir haben außerdem Qwen3 mit nativer 128K-Kontextlänge hochgeladen. Qwen erreicht dies, indem YaRN verwendet wird, um das ursprüngliche 40K-Fenster auf 128K zu erweitern. [Unsloth](https://github.com/unslothai/unsloth) unterstützt jetzt auch Fine-Tuning und [Verstärkendes Lernen (RL)](/docs/de/loslegen/reinforcement-learning-rl-guide.md) von Qwen3- und Qwen3-MOE-Modellen — 2x schneller, mit 70 % weniger VRAM und 8x längeren Kontextlängen. Fine-tune Qwen3 (14B) kostenlos mit unserem [Colab-Notebook.](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(14B\)-Reasoning-Conversational.ipynb) Qwen3-Tutorial ausführen Qwen3 fine-tunen #### **Qwen3 - Unsloth Dynamic 2.0** mit optimalen Konfigurationen: | Dynamic 2.0 GGUF (zum Ausführen) | 128K-Kontext-GGUF | Dynamic 4-bit Safetensor (zum Fine-Tunen/Deployen) | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | | | ## 🖥️ **Qwen3 ausführen** Um Inferenzgeschwindigkeiten von 6+ Tokens pro Sekunde zu erreichen, empfehlen wir, dass der verfügbare Speicher der Größe des verwendeten Modells entspricht oder sie übersteigt. Ein beispielsweise 30GB großes 1-Bit-quantisiertes Modell benötigt mindestens 150GB Speicher. Die Q2\_K\_XL-Quantisierung, die 180GB groß ist, erfordert mindestens **180GB vereinheitlichten Speicher** (VRAM + RAM) oder **180GB RAM** für optimale Leistung. **HINWEIS:** Es ist möglich, das Modell mit **weniger Gesamtspeicher** als seiner Größe auszuführen (d. h. weniger VRAM, weniger RAM oder ein niedrigerer kombinierter Gesamtwert). Dies führt jedoch zu langsameren Inferenzgeschwindigkeiten. Ausreichender Speicher ist nur erforderlich, wenn du den Durchsatz maximieren und die schnellsten Inferenzzeiten erreichen möchtest. ### :gear: Offizielle empfohlene Einstellungen Laut Qwen sind dies die empfohlenen Einstellungen für die Inferenz: | Einstellungen für Nicht-Denkmodus: | Einstellungen für Denkmodus: | | ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------- | | **Temperatur = 0.7** | **Temperatur = 0.6** | | Min\_P = 0.0 (optional, aber 0.01 funktioniert gut; der Standardwert in llama.cpp ist 0.1) | Min\_P = 0.0 | | Top\_P = 0.8 | Top\_P = 0.95 | | TopK = 20 | TopK = 20 | **Chat-Template/Prompt-Format:** {% code overflow="wrap" %} ``` <|im_start|>user\nWas ist 2+2?<|im_end|>\n<|im_start|>assistant\n ``` {% endcode %} {% hint style="success" %} Für den NICHT-Denkmodus schließen wir \ und \ absichtlich leer ein: {% endhint %} {% code overflow="wrap" %} ``` <|im_start|>user\nWas ist 2+2?<|im_end|>\n<|im_start|>assistant\n\n\n\n\n ``` {% endcode %} {% hint style="warning" %} **Im Denkmodus solltest du KEIN Greedy Decoding verwenden**, da dies zu Leistungsverlust und endlosen Wiederholungen führen kann. {% endhint %} ### Wechsel zwischen Denk- und Nicht-Denkmodus Qwen3-Modelle verfügen über einen eingebauten „Denkmodus“, um das Schlussfolgern zu verbessern und die Antwortqualität zu steigern – ähnlich wie [QwQ-32B](/docs/de/modelle/tutorials/qwq-32b-how-to-run-effectively.md) funktionierte. Die Anweisungen zum Wechseln unterscheiden sich je nach verwendetem Inferenz-Engine, stelle also sicher, dass du die richtigen Anweisungen verwendest. #### Anweisungen für llama.cpp und Ollama: Du kannst `/think` und `/no_think` zu User-Prompts oder Systemnachrichten hinzufügen, um den Denkmodus des Modells von Runde zu Runde zu wechseln. Das Modell folgt in mehrstufigen Gesprächen der jeweils neuesten Anweisung. Hier ist ein Beispiel für ein mehrstufiges Gespräch: ``` > Wer bist du /no_think Ich bin Qwen, ein von Alibaba Cloud entwickeltes Sprachmodell im großen Maßstab. [...] > Wie viele „r“ sind in „strawberries“? /think Okay, schauen wir mal. Der Nutzer fragt, wie oft der Buchstabe „r“ im Wort „strawberries“ vorkommt. [...] Das Wort strawberries enthält 3 Vorkommen des Buchstabens r. [...] ``` #### Anweisungen für transformers und vLLM: **Denkmodus:** `enable_thinking=True` Standardmäßig ist das Denken in Qwen3 aktiviert. Wenn du `tokenizer.apply_chat_template`aufrufst, **musst du nichts manuell setzen.** ```python text = tokenizer.apply_chat_template( messages, tokenize=False, add_generation_prompt=True, enable_thinking=True # Standard ist True ) ``` Im Denkmodus erzeugt das Modell einen zusätzlichen `...` Block vor der endgültigen Antwort — dadurch kann es „planen“ und seine Antworten schärfen. **Nicht-Denkmodus:** `enable_thinking=False` Wenn der Nicht-Denkmodus aktiviert wird, überspringt Qwen3 alle Denkschritte und verhält sich wie ein normales LLM. ```python text = tokenizer.apply_chat_template( messages, tokenize=False, add_generation_prompt=True, enable_thinking=False # Deaktiviert den Denkmodus ) ``` Dieser Modus liefert endgültige Antworten direkt — keine `` Blöcke, kein Chain-of-Thought. ### 🦙 Ollama: Qwen3-Tutorial ausführen 1. Installiere `ollama` falls du es noch nicht getan hast! Du kannst nur Modelle bis zu einer Größe von 32B ausführen. Um das vollständige 235B-A22B-Modell auszuführen, [siehe hier](#running-qwen3-235b-a22b). ```bash apt-get update apt-get install pciutils -y curl -fsSL https://ollama.com/install.sh | sh ``` 2. Führe das Modell aus! Beachte, dass du `ollama serve`in einem anderen Terminal aufrufen kannst, falls es fehlschlägt! Wir haben alle unsere Fixes und vorgeschlagenen Parameter (Temperatur usw.) in `params` in unserem Hugging-Face-Upload! ```bash ollama run hf.co/unsloth/Qwen3-8B-GGUF:UD-Q4_K_XL ``` 3. Um das Denken zu deaktivieren, verwende (oder du kannst es im System-Prompt setzen): ``` >>> Schreibe hier deinen Prompt /nothink ``` {% hint style="warning" %} Wenn du Schleifen beobachtest, hat Ollama möglicherweise dein Kontextfenster auf etwa 2.048 gesetzt. Falls das der Fall ist, erhöhe es auf 32.000 und prüfe, ob das Problem weiterhin besteht. {% endhint %} ### 📖 Llama.cpp: Qwen3-Tutorial ausführen 1. Hole dir das Neueste `llama.cpp` auf [GitHub hier](https://github.com/ggml-org/llama.cpp). Du kannst auch die Build-Anweisungen unten befolgen. Ändere `-DGGML_CUDA=ON` auf `-DGGML_CUDA=OFF` wenn du keine GPU hast oder einfach nur CPU-Inferenz möchtest. **Für Apple-Mac-/Metal-Geräte**, setze `-DGGML_CUDA=OFF` und fahre dann wie gewohnt fort – Metal-Unterstützung ist standardmäßig aktiviert. ```bash apt-get update apt-get install pciutils build-essential cmake curl libcurl4-openssl-dev -y git clone https://github.com/ggml-org/llama.cpp cmake llama.cpp -B llama.cpp/build \\ -DBUILD_SHARED_LIBS=OFF -DGGML_CUDA=ON -DLLAMA_CURL=ON cmake --build llama.cpp/build --config Release -j --clean-first --target llama-cli llama-gguf-split cp llama.cpp/build/bin/llama-* llama.cpp ``` 2. Lade das Modell herunter über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Du kannst Q4\_K\_M oder andere quantisierte Versionen wählen. ```python # !pip install huggingface_hub hf_transfer import os os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1" from huggingface_hub import snapshot_download snapshot_download( repo_id = "unsloth/Qwen3-14B-GGUF", local_dir = "unsloth/Qwen3-14B-GGUF", allow_patterns = ["*UD-Q4_K_XL*"], ) ``` 3. Führe das Modell aus und probiere einen beliebigen Prompt aus. ```bash ./llama.cpp/llama-cli \\ --model unsloth/Qwen3-14B-GGUF/Qwen3-14B-UD-Q2_K_XL.gguf \\ --ctx-size 16384 \\ --n-gpu-layers 99 \\ -ot ".ffn_.*_exps.=CPU" \\ --seed 3407 \\ --prio 3 \\ --temp 0.6 \\ --min-p 0.0 \\ --top-p 0.95 \\ --top-k 20 \\ -no-cnv ``` Um das Denken zu deaktivieren, verwende (oder du kannst es im System-Prompt setzen): ``` >>> Schreibe hier deinen Prompt /nothink ``` ### Qwen3-235B-A22B ausführen Für Qwen3-235B-A22B werden wir speziell Llama.cpp für optimierte Inferenz und eine Vielzahl von Optionen verwenden. 1. Wir folgen ähnlichen Schritten wie oben, müssen diesmal aber auch zusätzliche Schritte durchführen, da das Modell so groß ist. 2. Lade das Modell herunter über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Du kannst UD-Q2\_K\_XL oder andere quantisierte Versionen wählen.. ```python # !pip install huggingface_hub hf_transfer import os os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1" from huggingface_hub import snapshot_download snapshot_download( repo_id = "unsloth/Qwen3-235B-A22B-GGUF", local_dir = "unsloth/Qwen3-235B-A22B-GGUF", allow_patterns = ["*UD-Q2_K_XL*"], ) ``` 3. Führe das Modell aus und probiere einen beliebigen Prompt aus. 4. Bearbeite `--threads 32` für die Anzahl der CPU-Threads, `--ctx-size 16384` für die Kontextlänge, `--n-gpu-layers 99` für GPU-Offloading, für wie viele Schichten. Versuche, es anzupassen, wenn deinem GPU der Speicher ausgeht. Entferne es auch, wenn du nur CPU-Inferenz hast. {% hint style="success" %} Verwende `-ot ".ffn_.*_exps.=CPU"` um alle MoE-Schichten auf die CPU auszulagern! Dadurch kannst du effektiv alle Nicht-MoE-Schichten auf 1 GPU unterbringen, was die Generierungsgeschwindigkeiten verbessert. Du kannst den Regex-Ausdruck anpassen, um mehr Schichten auszulagern, wenn du mehr GPU-Kapazität hast. {% endhint %} {% code overflow="wrap" %} ```bash ./llama.cpp/llama-cli \\ --model unsloth/Qwen3-235B-A22B-GGUF/Qwen3-235B-A22B-UD-Q2_K_XL.gguf \\ --ctx-size 16384 \\ --n-gpu-layers 99 \\ -ot ".ffn_.*_exps.=CPU" \\ --seed 3407 \\ --prio 3 \\ --temp 0.6 \\ --min-p 0.0 \\ --top-p 0.95 \\ --top-k 20 \\ -no-cnv \\ --prompt "<|im_start|>user\nErstelle ein Flappy-Bird-Spiel in Python. Du musst diese Dinge einbeziehen:\n1. Du musst pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Farbton sein. Beginne mit einer hellblauen Farbe.\n3. Mehrfaches Drücken von SPACE beschleunigt den Vogel.\n4. Die Form des Vogels sollte zufällig als Quadrat, Kreis oder Dreieck gewählt werden. Die Farbe sollte zufällig als dunkle Farbe gewählt werden.\n5. Platziere unten etwas Land, das zufällig dunkelbraun oder gelb gefärbt ist.\n6. Zeige oben rechts eine Punktzahl an. Erhöhe sie, wenn du an Rohren vorbeifliegst und sie nicht berührst.\n7. Erstelle zufällig verteilte Rohre mit ausreichend Platz. Färbe sie zufällig dunkelgrün, hellbraun oder einem dunklen Grauton.\n8. Wenn du verlierst, zeige die Bestpunktzahl an. Platziere den Text innerhalb des Bildschirms. Das Drücken von q oder Esc beendet das Spiel. Neustart erfolgt durch erneutes Drücken von SPACE.\nDas fertige Spiel soll in einem Markdown-Abschnitt in Python stehen. Prüfe deinen Code auf Fehler und behebe sie vor dem endgültigen Markdown-Abschnitt.<|im_end|>\n<|im_start|>assistant\n" ``` {% endcode %} ## 🦥 Qwen3 mit Unsloth fine-tunen Unsloth macht das Fine-Tuning von Qwen3 2x schneller, verbraucht 70 % weniger VRAM und unterstützt 8x längere Kontextlängen. Qwen3 (14B) passt problemlos auf eine Google-Colab-Tesla-T4-GPU mit 16 GB VRAM. Da Qwen3 sowohl Schlussfolgern als auch Nicht-Schlussfolgern unterstützt, kannst du es mit einem Nicht-Schlussfolgern-Datensatz fine-tunen, aber das kann seine Schlussfolgerungsfähigkeit beeinträchtigen. Wenn du seine Schlussfolgerungsfähigkeiten beibehalten möchtest (optional), kannst du eine Mischung aus direkten Antworten und Chain-of-Thought-Beispielen verwenden. Verwende 75 % Schlussfolgern und 25 % Nicht-Schlussfolgern in deinem Datensatz, damit das Modell seine Schlussfolgerungsfähigkeiten behält. Unser Conversational-Notebook verwendet eine Kombination aus 75 % von NVIDIAs Open-Math-Reasoning-Datensatz und 25 % von Maximes FineTome-Datensatz (Nicht-Schlussfolgern). Hier sind kostenlose Unsloth-Colab-Notebooks, um Qwen3 finezutunen: * [Qwen3 (14B) Reasoning + Conversational Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(14B\)-Reasoning-Conversational.ipynb) (empfohlen) * [**Qwen3 (4B)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(4B\)-GRPO.ipynb) **- Erweiterte GRPO LoRA** * [Qwen3 (14B) Alpaca-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(14B\)-Alpaca.ipynb) (für Basismodelle) Wenn du eine alte Version von Unsloth hast und/oder lokal fine-tunest, installiere die neueste Version von Unsloth: ``` pip install --upgrade --force-reinstall --no-cache-dir unsloth unsloth_zoo ``` ### Qwen3 MOE-Modelle fine-tunen Die Fine-Tuning-Unterstützung umfasst unser neues 2026 [Schnelleres MOE ](/docs/de/grundlagen/faster-moe.md)Update: 30B-A3B und 235B-A22B. Qwen3-30B-A3B läuft mit Unsloth bereits mit nur 17,5 GB VRAM. Beim Fine-Tuning von MoEs ist es wahrscheinlich keine gute Idee, die Router-Schicht mitzutunen, daher haben wir sie standardmäßig deaktiviert. Das 30B-A3B passt in 17,5 GB VRAM, aber dir könnten RAM oder Speicherplatz fehlen, da das vollständige 16-Bit-Modell heruntergeladen und für das QLoRA-Fine-Tuning unterwegs in 4-Bit konvertiert werden muss. Das liegt an Problemen beim direkten Import von 4-Bit-BnB-MOE-Modellen. Dies betrifft nur MOE-Modelle. ```python from unsloth import FastModel import torch model, tokenizer = FastModel.from_pretrained( model_name = "unsloth/Qwen3-30B-A3B", max_seq_length = 2048, # Wähle beliebig für langen Kontext! load_in_4bit = True, # 4-Bit-Quantisierung zur Speicherreduzierung load_in_8bit = False, # [NEU!] Etwas genauer, verwendet 2x Speicher full_finetuning = False, # [NEU!] Wir haben jetzt vollständiges Fine-Tuning! # token = "hf_...", # verwende einen, wenn du gesperrte Modelle verwendest ) ``` ### Notebook-Anleitung:
Um die Notebooks zu verwenden, klicke einfach auf Runtime und dann auf Run all. Du kannst die Einstellungen im Notebook nach Belieben ändern. Wir haben sie standardmäßig automatisch gesetzt. Ändere den Modellnamen nach Wunsch, indem du ihn mit dem Namen des Modells auf Hugging Face abgleichst, z. B. 'unsloth/Qwen3-8B' oder 'unsloth/Qwen3-0.6B-unsloth-bnb-4bit'. Es gibt weitere Einstellungen, die du umschalten kannst: * **`max_seq_length = 2048`** – Steuert die Kontextlänge. Obwohl Qwen3 40960 unterstützt, empfehlen wir 2048 zum Testen. Unsloth ermöglicht ein 8× längeres Kontext-Fine-Tuning. * **`load_in_4bit = True`** – Aktiviert 4-Bit-Quantisierung und reduziert den Speicherverbrauch für das Fine-Tuning auf 16GB-GPUs um das Vierfache. * Für **Full-Finetuning** - setze `full_finetuning = True` und **8-Bit-Finetuning** - setze `load_in_8bit = True` Wenn du eine vollständige End-to-End-Anleitung dazu lesen möchtest, wie man Unsloth-Notebooks zum Fine-Tuning verwendet oder einfach mehr über Fine-Tuning, das Erstellen von [Datensätzen](/docs/de/loslegen/fine-tuning-llms-guide/datasets-guide.md) usw. erfahren möchtest, sieh dir unseren [vollständigen Leitfaden hier an](/docs/de/loslegen/fine-tuning-llms-guide.md): {% content-ref url="/pages/44aed34263310d67280841ab6b72ea1e5648761f" %} [Fine-tuning Guide](/docs/de/loslegen/fine-tuning-llms-guide.md) {% endcontent-ref %} {% content-ref url="/pages/079b6ad30e8c25b4a6caae0d2dc5378a166d54c9" %} [Anleitung zu Datensätzen](/docs/de/loslegen/fine-tuning-llms-guide/datasets-guide.md) {% endcontent-ref %} ### GRPO mit Qwen3 Wir haben ein neues fortgeschrittenes GRPO-Notebook zum Fine-Tuning von Qwen3 erstellt. Lerne, unsere neue proximitätsbasierte Belohnungsfunktion zu verwenden (nähere Antworten = belohnt) und Hugging Faces Open-R1-Math-Datensatz.\ Unsloth hat jetzt auch bessere Evaluierungen und verwendet die neueste Version von vLLM. [**Qwen3 (4B)**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(4B\)-GRPO.ipynb) **Notebook - Fortgeschrittenes GRPO LoRA** Erfahre mehr über: * Reasoning in Qwen3 (Base) aktivieren und es zu einer bestimmten Aufgabe anleiten * Vor-Finetuning, um Qwen3s Tendenz zu umgehen, Formatierungen zu lernen * Verbesserte Evaluierungsgenauigkeit durch neues Regex-Matching * Benutzerdefinierte GRPO-Templates über nur „think“ hinaus, z. B. \\ * Proximitätsbasierte Bewertung: bessere Antworten erhalten mehr Punkte (z. B. 9 vorhersagen, wenn die Antwort 10 ist), und Ausreißer werden bestraft
--- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://unsloth.ai/docs/de/modelle/tutorials/qwen3-how-to-run-and-fine-tune.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.