> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/modelle/tutorials/qwen3-how-to-run-and-fine-tune.md). # Qwen3 – Wie man ausführt und feinabstimmt Lerne, Qwen3 lokal mit Unsloth + unseren Dynamic 2.0 Quants auszuführen und feinabzustimmen Die neuen Qwen3-Modelle von Qwen bieten hochmoderne Fortschritte beim logischen Denken, beim Befolgen von Anweisungen, bei Agentenfähigkeiten und bei der mehrsprachigen Unterstützung. {% hint style="success" %} **NEU!** Qwen3 erhielt im Juli 2025 ein Update. Führen Sie das neueste Modell aus und fine-tunen Sie es: [**Qwen-2507**](/docs/de/modelle/tutorials/qwen3-next.md) {% endhint %} Alle Uploads verwenden Unsloth [Dynamic 2.0](/docs/de/grundlagen/dynamic-3.0-ggufs.md) für SOTA-5-Shot-MMLU- und KL-Divergenz-Leistung, was bedeutet, dass Sie quantisierte Qwen-LLMs mit minimalem Genauigkeitsverlust ausführen und feinabstimmen können. Wir haben außerdem Qwen3 mit nativer 128K-Kontextlänge hochgeladen. Qwen erreicht dies, indem YaRN verwendet wird, um sein ursprüngliches 40K-Fenster auf 128K zu erweitern. [Unsloth](https://github.com/unslothai/unsloth) unterstützt jetzt auch Fine-Tuning und [Reinforcement Learning (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-tunen Sie Qwen3 (14B) kostenlos mit unserem [Colab-Notebook.](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(14B\)-Reasoning-Conversational.ipynb) Tutorial: Qwen3 ausführen Qwen3 feinabstimmen #### **Qwen3 - Unsloth Dynamic 2.0** mit optimalen Konfigurationen: | Dynamic 2.0 GGUF (zum Ausführen) | 128K-Kontext-GGUF | Dynamisches 4-Bit-Safetensor-Format (zum Feinabstimmen/Bereitstellen) | | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | | | | ## 🖥️ **Qwen3 ausführen** Um Inferenzgeschwindigkeiten von 6+ Token pro Sekunde zu erreichen, empfehlen wir, dass der verfügbare Speicher der Größe des von Ihnen verwendeten Modells entspricht oder diese übersteigt. Beispielsweise benötigt ein 30GB groß quantisiertes 1-Bit-Modell mindestens 150GB Speicher. Die Q2\_K\_XL-Quantisierung, die 180GB umfasst, erfordert mindestens **180GB einheitlichen 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 eine geringere Gesamtsumme). Dies führt jedoch zu langsameren Inferenzgeschwindigkeiten. Ausreichender Speicher ist nur erforderlich, wenn Sie den Durchsatz maximieren und die schnellsten Inferenzzeiten erreichen möchten. ### :gear: Offiziell empfohlene Einstellungen Laut Qwen sind dies die empfohlenen Einstellungen für die Inferenz: | Einstellungen für den Nicht-Denkmodus: | Einstellungen für den Denkmodus: | | ------------------------------------------------------------------------------------------- | ----------------------------------------------------------------- | | **Temperature = 0.7** | **Temperature = 0.6** | | Min\_P = 0.0 (optional, aber 0.01 funktioniert gut; der Standardwert von 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 mit nichts 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" %} **Verwenden Sie im Denkmodus KEIN Greedy Decoding**, da dies zu Leistungseinbußen und endlosen Wiederholungen führen kann. {% endhint %} ### Zwischen Denk- und Nicht-Denkmodus wechseln Qwen3-Modelle verfügen über einen integrierten „Denkmodus“, um das logische Denken zu verbessern und die Antwortqualität zu erhöhen – ähnlich wie [QwQ-32B](/docs/de/modelle/tutorials/qwq-32b-how-to-run-effectively.md) es funktioniert hat. Die Anweisungen zum Wechseln unterscheiden sich je nach verwendetem Inferenz-Engine, stellen Sie also sicher, dass Sie die richtigen Anweisungen verwenden. #### Anweisungen für llama.cpp und Ollama: Sie können `/think` und `/no_think` zu Benutzer-Prompts oder Systemnachrichten hinzufügen, um den Denkmodus des Modells von Runde zu Runde zu wechseln. Das Modell befolgt in mehrstufigen Gesprächen die aktuellste Anweisung. Hier ist ein Beispiel für ein mehrstufiges Gespräch: ``` > Wer sind Sie /no_think Ich bin Qwen, ein von Alibaba Cloud entwickeltes Large-Scale-Sprachmodell. [...] > Wie viele „r“ sind in „strawberries“? /think Okay, schauen wir mal. Der Benutzer 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 bei Qwen3 aktiviert. Wenn Sie `tokenizer.apply_chat_template`, dann **müssen Sie nichts manuell einstellen.** ```python text = tokenizer.apply_chat_template( messages, tokenize=False, add_generation_prompt=True, enable_thinking=True # Standardwert ist True ) ``` Im Denkmodus erzeugt das Modell einen zusätzlichen `...` Block vor der endgültigen Antwort — so kann es „planen“ und seine Antworten schärfen. **Nicht-Denk-Modus:** `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 die endgültigen Antworten direkt — keine `` Blöcke, kein Chain-of-Thought. ### 🦙 Ollama: Tutorial zum Ausführen von Qwen3 1. Installieren `ollama` falls Sie das noch nicht getan haben! Sie können nur Modelle bis zu einer Größe von 32B ausführen. Um das vollständige 235B-A22B-Modell auszuführen, [sehen Sie hier](#running-qwen3-235b-a22b). ```bash apt-get update apt-get install pciutils -y curl -fsSL https://ollama.com/install.sh | sh ``` 2. Führen Sie das Modell aus! Beachten Sie, dass Sie `ollama serve`in einem anderen Terminal aufrufen können, falls es fehlschlägt! Wir enthalten alle unsere Korrekturen und empfohlenen 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, verwenden Sie (oder Sie können es im System-Prompt festlegen): ``` >>> Schreiben Sie hier Ihren Prompt /nothink ``` {% hint style="warning" %} Wenn Sie Schleifen beobachten, hat Ollama möglicherweise Ihr Kontextlängenfenster auf etwa 2.048 gesetzt. Wenn das der Fall ist, erhöhen Sie es auf 32.000 und prüfen Sie, ob das Problem weiterhin besteht. {% endhint %} ### 📖 Llama.cpp: Tutorial zum Ausführen von Qwen3 1. Holen Sie sich die neueste `llama.cpp` auf [hier auf GitHub](https://github.com/ggml-org/llama.cpp). Sie können auch die folgenden Build-Anweisungen befolgen. Ändern Sie `-DGGML_CUDA=ON` zu `-DGGML_CUDA=OFF` wenn Sie keine GPU haben oder nur CPU-Inferenz möchten. **Für Apple-Mac-/Metal-Geräte**, setzen Sie `-DGGML_CUDA=OFF` und fahren Sie 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 über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Sie können 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 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, verwenden Sie (oder Sie können es im System-Prompt festlegen): ``` >>> Schreiben Sie hier Ihren Prompt /nothink ``` ### Qwen3-235B-A22B ausführen Für Qwen3-235B-A22B verwenden wir speziell Llama.cpp für optimierte Inferenz und eine Vielzahl von Optionen. 1. Wir folgen ähnlichen Schritten wie oben, müssen diesmal jedoch auch zusätzliche Schritte durchführen, da das Modell so groß ist. 2. Lade das Modell über (nach der Installation von `pip install huggingface_hub hf_transfer` ). Ihr könnt 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 Prompt aus. 4. Bearbeiten `--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 auf wie viele Layer. Versuche, ihn anzupassen, wenn deiner GPU der Speicher ausgeht. Entferne ihn auch, wenn du nur CPU-Inferenz hast. {% hint style="success" %} Verwenden Sie `-ot ".ffn_.*_exps.=CPU"` um alle MoE-Layer auf die CPU auszulagern! Dadurch können Sie effektiv alle Nicht-MoE-Layer auf 1 GPU unterbringen, was die Generierungsgeschwindigkeit verbessert. Sie können den Regex-Ausdruck anpassen, um mehr Layer unterzubringen, wenn Sie mehr GPU-Kapazität haben. {% 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\nErstellen Sie ein Flappy-Bird-Spiel in Python. Sie müssen Folgendes enthalten:\n1. Sie müssen pygame verwenden.\n2. Die Hintergrundfarbe sollte zufällig gewählt werden und ein heller Farbton sein. Beginnen Sie mit einem hellblauen Farbton.\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. Platzieren Sie unten etwas Land, das zufällig dunkelbraun oder gelb gefärbt ist.\n6. Zeigen Sie oben rechts eine Punktzahl an. Erhöhen Sie sie, wenn Sie Rohre passieren und sie nicht treffen.\n7. Erstellen Sie zufällig verteilte Rohre mit genügend Abstand. Färben Sie sie zufällig dunkelgrün, hellbraun oder einem dunklen Grauton.\n8. Wenn Sie verlieren, zeigen Sie die beste Punktzahl an. Platzieren Sie den Text innerhalb des Bildschirms. Durch Drücken von q oder Esc beenden Sie das Spiel. Ein Neustart erfolgt durch erneutes Drücken von SPACE.\nDas fertige Spiel sollte sich in einem Markdown-Abschnitt in Python befinden. Überprüfen Sie Ihren Code auf Fehler und beheben Sie diese vor dem finalen Markdown-Abschnitt.<|im_end|>\n<|im_start|>assistant\n" ``` {% endcode %} ## 🦥 Qwen3 mit Unsloth feinabstimmen Unsloth macht das Feinabstimmen 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 logisches Denken als auch Nicht-Denken unterstützt, können Sie es mit einem Datensatz ohne logisches Denken feinabstimmen, dies kann jedoch seine Denkfähigkeit beeinträchtigen. Wenn Sie seine Denkfähigkeiten beibehalten möchten (optional), können Sie eine Mischung aus direkten Antworten und Chain-of-Thought-Beispielen verwenden. Verwenden Sie 75 % Reasoning und 25 % Nicht-Reasoning in Ihrem Datensatz, damit das Modell seine Reasoning-Fähigkeiten beibehält. Unser Conversational-Notebook verwendet eine Kombination aus 75 % von NVIDIAs Open-Math-Reasoning-Datensatz und 25 % von Maximes FineTome-Datensatz (ohne logisches Denken). Hier sind kostenlose Unsloth-Colab-Notebooks zum Feinabstimmen von Qwen3: * [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) **- Fortgeschrittene 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 feinabstimmst, installiere die neueste Version von Unsloth: ``` pip install --upgrade --force-reinstall --no-cache-dir unsloth unsloth_zoo ``` ### Feinabstimmung von Qwen3-MoE-Modellen Die Unterstützung für Feinabstimmungen umfasst unser neues 2026 [Schnelleres MoE ](/docs/de/grundlagen/faster-moe.md)Update: 30B-A3B und 235B-A22B. Qwen3-30B-A3B funktioniert mit Unsloth bereits auf nur 17,5 GB VRAM. Beim Feinabstimmen von MoEs ist es wahrscheinlich keine gute Idee, die Router-Schicht feinabzustimmen, daher haben wir sie standardmäßig deaktiviert. Das 30B-A3B passt in 17,5 GB VRAM, aber Ihnen kann RAM oder Speicherplatz fehlen, da das vollständige 16-Bit-Modell für die QLoRA-Feinabstimmung heruntergeladen und unterwegs in 4-Bit umgewandelt 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 quantization to reduce memory load_in_8bit = False, # [NEU!] Etwas genauer, benötigt doppelt so viel Speicher full_finetuning = False, # [NEW!] We have full finetuning now! # token = "hf_...", # verwende einen, wenn du gesperrte Modelle nutzt ) ``` ### Notebook-Leitfaden:
Um die Notebooks zu verwenden, klicken Sie einfach auf „Runtime“ und dann auf „Run all“. Sie können die Einstellungen im Notebook nach Belieben ändern. Wir haben sie standardmäßig automatisch festgelegt. Ändern Sie den Modellnamen nach Wunsch, indem Sie ihn mit dem Modellnamen auf Hugging Face abgleichen, z. B. 'unsloth/Qwen3-8B' oder 'unsloth/Qwen3-0.6B-unsloth-bnb-4bit'. Es gibt weitere Einstellungen, die Sie umschalten können: * **`max_seq_length = 2048`** – Steuert die Kontextlänge. Obwohl Qwen3 40960 unterstützt, empfehlen wir zum Testen 2048. Unsloth ermöglicht eine 8× längere Kontext-Feinabstimmung. * **`load_in_4bit = True`** – Aktiviert 4-Bit-Quantisierung und reduziert den Speicherverbrauch für das Feinabstimmen auf 16GB-GPUs um das 4-Fache. * Für **Vollständige Feinabstimmung** - festlegen `full_finetuning = True` und **8-Bit-Feinabstimmung** - festlegen `load_in_8bit = True` Wenn Sie eine vollständige End-to-End-Anleitung zur Verwendung von Unsloth-Notebooks für die Feinabstimmung lesen oder einfach mehr über Feinabstimmung und das Erstellen erfahren möchten [datasets](/docs/de/loslegen/fine-tuning-llms-guide/datasets-guide.md) usw., sehen Sie sich unsere [vollständige Anleitung 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" %} [Datensatz-Leitfaden](/docs/de/loslegen/fine-tuning-llms-guide/datasets-guide.md) {% endcontent-ref %} ### GRPO mit Qwen3 Wir haben ein neues fortgeschrittenes GRPO-Notebook zum Feinabstimmen von Qwen3 erstellt. Lernen Sie, unsere neue nähebasierte Belohnungsfunktion zu verwenden (nähere Antworten = belohnt) und den Open-R1-Mathe-Datensatz von Hugging Face.\ Unsloth verfügt jetzt außerdem über bessere Auswertungen 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** Erfahren Sie mehr über: * Das logische Denken in Qwen3 (Base) aktivieren + es dazu anleiten, eine bestimmte Aufgabe auszuführen * Vorab-Feinabstimmung, um GRPOs Tendenz zu umgehen, Formatierung zu lernen * Verbesserte Bewertungsgenauigkeit durch neues Regex-Matching * Benutzerdefinierte GRPO-Templates über bloßes 'think' hinaus, z. B. \\ * Näherungsbasiertes Scoring: Bessere Antworten erhalten mehr Punkte (z. B. wenn 9 vorhergesagt wird, obwohl die richtige Antwort 10 ist), und Ausreißer werden bestraft
--- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation by asking a question. Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters: ``` GET https://unsloth.ai/docs/de/modelle/tutorials/qwen3-how-to-run-and-fine-tune.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case. 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.