# Quantisierungsbewusstes Training (QAT)

In Zusammenarbeit mit PyTorch führen wir QAT (Quantization-Aware Training) in Unsloth ein, um **trainierbare Quantisierung** zu ermöglichen, die so viel Genauigkeit wie möglich wiederherstellt. Dies führt zu einer deutlich besseren Modellqualität im Vergleich zur standardmäßigen naiven 4-Bit-Quantisierung. QAT kann bis zu **70% der verlorenen Genauigkeit** wiederherstellen und erzielt eine **1–3%** Verbesserung der Modellleistung in Benchmarks wie GPQA und MMLU Pro.

> **Probieren Sie QAT mit unserem kostenlosen** [**Qwen3 (4B) Notebook**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(4B\)_Instruct-QAT.ipynb)

### :books:Quantisierung

{% columns %}
{% column width="50%" %}
Ein Modell naiv zu quantisieren wird **Post-Training-Quantisierung** (PTQ) genannt. Zum Beispiel, nehmen wir an, wir wollen auf 8-Bit-Ganzzahlen quantisieren:

1. Finden Sie `max(abs(W))`
2. Finden Sie `a = 127/max(abs(W))` wobei a der maximale Bereich von int8 ist, der 127 beträgt
3. Quantisieren via `qW = int8(round(W * a))`
   {% endcolumn %}

{% column width="50%" %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-f3e1cee8e4047dcbbbace7548694ad63af9869de%2Fquant-freeze.png?alt=media" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

Zurückdequantisieren auf 16 Bit macht einfach die umgekehrte Operation durch `float16(qW) / a` . Post-Training-Quantisierung (PTQ) kann Speicher- und Inferenzkosten stark reduzieren, verschlechtert jedoch oft die Genauigkeit, wenn hochpräzise Werte mit weniger Bits dargestellt werden - besonders bei 4 Bit oder weniger. Eine Möglichkeit, dies zu lösen, ist die Nutzung unserer [**dynamischen GGUF-Quants**](https://unsloth.ai/docs/de/grundlagen/unsloth-dynamic-2.0-ggufs), die ein Kalibrierungsdatensatz verwendet, um das Quantisierungsverfahren so zu ändern, dass wichtigeren Gewichten mehr Bedeutung beigemessen wird. Die andere Möglichkeit ist, die **Quantisierung intelligenter zu machen, indem sie trainierbar oder lernbar gemacht wird**!

### :fire:Intelligentere Quantisierung

<div><figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-1f6260ef5c041ada2f8b1fb4c6aad114f61061d4%2F4bit_QAT_recovery_sideways_clipped75_bigtext_all(1).png?alt=media" alt=""><figcaption></figcaption></figure> <figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-ad1ac9d29482ea07cbabb6efa18a0d1f06b297e9%2FQLoRA_QAT_Accuracy_Boosts_v7_bigaxes_nogrid_600dpi.png?alt=media" alt=""><figcaption></figcaption></figure></div>

Um intelligentere Quantisierung zu ermöglichen, haben wir mit dem [TorchAO](https://github.com/pytorch/ao) Team zusammengearbeitet, um **Quantization-Aware Training (QAT)** direkt in Unsloth hinzuzufügen – so können Sie jetzt Modelle in Unsloth feinabstimmen und sie dann direkt im 4-Bit-QAT-Format mit Genauigkeitsverbesserungen exportieren!

Tatsächlich **stellt QAT 66,9%** von Gemma3-4B auf GPQA wieder her und erhöht die rohe Genauigkeit um +1,0%. Gemma3-12B auf BBH stellt 45,5% wieder her, und **erhöhte die rohe Genauigkeit um +2,1%**. QAT verursacht während der Inferenz keinen zusätzlichen Aufwand und verwendet dieselbe Festplatten- und Speichernutzung wie die normale naive Quantisierung! Sie erhalten also alle Vorteile der Niedrigbit-Quantisierung, aber mit deutlich höherer Genauigkeit!

### :mag:Quantization-Aware Training

QAT simuliert das tatsächliche Quantisierungsverfahren durch "**Fake-Quantisierung**" von Gewichten und optional Aktivierungen während des Trainings, was typischerweise bedeutet, hochpräzise Werte auf quantisierte Werte zu runden (während sie in hochpräzisem Datentyp bleiben, z. B. bfloat16) und sie dann sofort wieder zu dequantisieren.

TorchAO ermöglicht QAT zunächst indem es (1) Fake-Quantize-Operationen in linearen Schichten einfügt und (2) die Fake-Quantize-Operationen nach dem Training in echte Quantize- und Dequantize-Operationen umwandelt, um sie infrerenztauglich zu machen. Schritt 1 ermöglicht es uns, eine genauere Quantisierungsdarstellung zu trainieren.

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-3d990e2bf19ef1aa7e65a8dd07e4b71cf8882a2a%2Fqat_diagram.png?alt=media" alt=""><figcaption></figcaption></figure>

### :sparkles:QAT + LoRA-Finetuning

QAT in Unsloth kann zusätzlich mit LoRA-Finetuning kombiniert werden, um die Vorteile beider Welten zu ermöglichen: deutliche Reduzierung von Speicher- und Rechenanforderungen während des Trainings bei gleichzeitiger Minderung der Quantisierungsverschlechterung! Wir unterstützen mehrere Methoden über `qat_scheme` einschließlich `fp8-int4`, `fp8-fp8`, `int8-int4`, `int4` . Wir planen außerdem, in einem Folge-Release benutzerdefinierte Definitionen für QAT hinzuzufügen!

{% code overflow="wrap" %}

```python
from unsloth import FastLanguageModel
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name = "unsloth/Qwen3-4B-Instruct-2507",
    max_seq_length = 2048,
    load_in_16bit = True,
)
model = FastLanguageModel.get_peft_model(
    model,
    r = 16,
    target_modules = ["q_proj", "k_proj", "v_proj", "o_proj",
                      "gate_proj", "up_proj", "down_proj",],
    lora_alpha = 32,
    
    # Wir unterstützen fp8-int4, fp8-fp8, int8-int4, int4
    qat_scheme = "int4",
)
```

{% endcode %}

### :teapot:Exportieren von QAT-Modellen

Nach dem Finetuning in Unsloth können Sie aufrufen `model.save_pretrained_torchao` um Ihr trainiertes Modell im PTQ-Format von TorchAO zu speichern. Sie können diese auch auf dem HuggingFace-Hub hochladen! Wir unterstützen jede Konfiguration und planen, auch textbasierte Methoden bereitzustellen und den Prozess für alle zu vereinfachen! Zunächst müssen wir das QAT-Modell jedoch für den finalen Konvertierungsschritt vorbereiten über:

{% code overflow="wrap" %}

```python
from torchao.quantization import quantize_
from torchao.quantization.qat import QATConfig
quantize_(model, QATConfig(step = "convert"))
```

{% endcode %}

Und nun können wir auswählen, welchen QAT-Stil Sie möchten:

{% code overflow="wrap" %}

```python
# Verwenden Sie dieselbe Konfiguration wie QAT (praktische Funktion)
model.save_pretrained_torchao(
    model, "tokenizer", 
    torchao_config = model._torchao_config.base_config,
)

# Int4 QAT
from torchao.quantization import Int4WeightOnlyConfig
model.save_pretrained_torchao(
    model, "tokenizer",
    torchao_config = Int4WeightOnlyConfig(),
)

# Int8 QAT
from torchao.quantization import Int8DynamicActivationInt8WeightConfig
model.save_pretrained_torchao(
    model, "tokenizer",
    torchao_config = Int8DynamicActivationInt8WeightConfig(),
)
```

{% endcode %}

Sie können dann das zusammengeführte QAT-Niedrigpräzisionsmodell in vLLM, Unsloth und anderen Systemen zur Inferenz ausführen! Diese finden Sie alle im [Qwen3-4B QAT Colab-Notebook](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(4B\)_Instruct-QAT.ipynb) das wir ebenfalls haben!

### :teapot:Modelle quantisieren ohne Training

Sie können auch `model.save_pretrained_torchao` direkt aufrufen, ohne QAT durchzuführen! Das ist einfach PTQ oder native Quantisierung. Zum Beispiel ist das Speichern im Dynamic-Float8-Format wie folgt:

{% code overflow="wrap" %}

```python
# Float8
from torchao.quantization import PerRow
from torchao.quantization import Float8DynamicActivationFloat8WeightConfig
torchao_config = Float8DynamicActivationFloat8WeightConfig(granularity = PerRow())
model.save_pretrained_torchao(torchao_config = torchao_config)
```

{% endcode %}

### :mobile\_phone:ExecuTorch - QAT für mobile Bereitstellung

{% columns %}
{% column %}
Mit Unsloth und der QAT-Unterstützung von TorchAO können Sie ein Modell in Unsloth feinabstimmen und nahtlos zu [ExecuTorch](https://github.com/pytorch/executorch) (PyTorchs Lösung für On-Device-Inferenz) exportieren und direkt auf Mobilgeräten bereitstellen. Siehe ein Beispiel in Aktion [hier](https://huggingface.co/metascroy/Qwen3-4B-int8-int4-unsloth) mit detaillierteren Workflows, die in Arbeit sind!

**Ankündigung folgt in Kürze!**
{% endcolumn %}

{% column %}

<figure><img src="https://797013937-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FxhOjnexMCB3dmuQFQ2Zq%2Fuploads%2Fgit-blob-53631bae5588644d2c64cec18f371f0a7e2688c6%2Fswiftpm_xcode.png?alt=media" alt=""><figcaption></figcaption></figure>
{% endcolumn %}
{% endcolumns %}

### :sunflower:Wie man QAT aktiviert

Aktualisieren Sie Unsloth auf die neueste Version und installieren Sie außerdem das neueste TorchAO!

Dann **probieren Sie QAT mit unserem kostenlosen** [**Qwen3 (4B) Notebook**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(4B\)_Instruct-QAT.ipynb)

{% code overflow="wrap" %}

```bash
pip install --upgrade --no-cache-dir --force-reinstall unsloth unsloth_zoo
pip install torchao==0.14.0 fbgemm-gpu-genai==1.3.0
```

{% endcode %}

### :person\_tipping\_hand:Danksagungen

Ein großes Dankeschön an das gesamte PyTorch- und TorchAO-Team für ihre Hilfe und Zusammenarbeit! Besonderer Dank gilt Andrew Or, Jerry Zhang, Supriya Rao, Scott Roy und Mergen Nachin für ihre Unterstützung in vielen Diskussionen zu QAT und bei der Integration in Unsloth! Ebenfalls Dank an das Executorch-Team!


---

# 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/blog/quantization-aware-training-qat.md?ask=<question>
```

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.