> 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/grundlagen/troubleshooting-and-faqs.md).

# Fehlerbehebung & FAQs

Wenn Sie immer noch auf Probleme mit Versionen oder Abhängigkeiten stoßen, verwenden Sie bitte unser [Docker-Image](/docs/de/loslegen/install/docker.md) das alles vorinstalliert enthält.

{% hint style="success" %}
**Versuchen Sie immer, Unsloth zu aktualisieren, wenn Sie auf Probleme stoßen.**

`pip install --upgrade --force-reinstall --no-cache-dir --no-deps unsloth unsloth_zoo`
{% endhint %}

### Ein neues Modell feinabstimmen, das von Unsloth nicht unterstützt wird?

Unsloth funktioniert mit jedem Modell, das von `transformers`. Wenn ein Modell nicht in unseren Uploads vorhanden ist oder nicht direkt out of the box läuft, wird es in der Regel trotzdem unterstützt; einige neuere Modelle benötigen möglicherweise nur eine kleine manuelle Anpassung aufgrund unserer Optimierungen.

In den meisten Fällen können Sie die Kompatibilität aktivieren, indem Sie `trust_remote_code=True` in Ihrem Fine-Tuning-Skript setzen. Hier ist ein Beispiel mit [DeepSeek-OCR](/docs/de/modelle/tutorials/deepseek-ocr-how-to-run-and-fine-tune.md):

<pre class="language-python" data-expandable="true"><code class="lang-python">from huggingface_hub import snapshot_download
snapshot_download("unsloth/DeepSeek-OCR", local_dir = "deepseek_ocr")
model, tokenizer = FastVisionModel.from_pretrained(
    "./deepseek_ocr",
    load_in_4bit = False, # Verwenden Sie 4bit, um den Speicherverbrauch zu reduzieren. False für 16bit LoRA.
    auto_model = AutoModel,
    <a data-footnote-ref href="#user-content-fn-1">trust_remote_code = True</a>, # Aktivieren, um neue Modelle zu unterstützen
    unsloth_force_compile = True,
    use_gradient_checkpointing = "unsloth", # True oder "unsloth" für langen Kontext
)
</code></pre>

### Die Ausführung in Unsloth funktioniert gut, aber nach dem Export und der Ausführung auf anderen Plattformen sind die Ergebnisse schlecht

Es kann vorkommen, dass Ihr Modell in Unsloth ausgeführt wird und gute Ergebnisse liefert, aber wenn Sie es auf einer anderen Plattform wie Ollama oder vLLM verwenden, sind die Ergebnisse schlecht oder Sie erhalten Kauderwelsch, endlose/unendliche Generierungen *oder* wiederholte Ausgabe&#x6E;**.**

* Die häufigste Ursache für diesen Fehler ist die Verwendung einer <mark style="background-color:blue;">**falschen Chat-Vorlage**</mark>**.** Es ist wichtig, dieselbe Chat-Vorlage zu verwenden, die beim Training des Modells in Unsloth genutzt wurde, und später auch dann, wenn Sie es in einem anderen Framework wie llama.cpp oder Ollama ausführen. Beim Inferenzieren aus einem gespeicherten Modell ist es entscheidend, die richtige Vorlage anzuwenden.
* Es könnte auch daran liegen, dass Ihre Inferenz-Engine ein unnötiges "Start-of-Sequence"-Token hinzufügt (oder umgekehrt eines fehlt) – stellen Sie also sicher, dass Sie beide Hypothesen überprüfen!
* <mark style="background-color:green;">**Verwenden Sie unsere Konversations-Notebooks, um die Chat-Vorlage zu erzwingen – das behebt die meisten Probleme.**</mark>
  * Qwen-3 14B Konversations-Notebook [**In Colab öffnen**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Qwen3_\(14B\)-Reasoning-Conversational.ipynb)
  * Gemma-3 4B Konversations-Notebook [**In Colab öffnen**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Gemma3_\(4B\).ipynb)
  * Llama-3.2 3B Konversations-Notebook [**In Colab öffnen**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Llama3.2_\(1B_and_3B\)-Conversational.ipynb)
  * Phi-4 14B Konversations-Notebook [**In Colab öffnen**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Phi_4-Conversational.ipynb)
  * Mistral v0.3 7B Konversations-Notebook [**In Colab öffnen**](https://colab.research.google.com/github/unslothai/notebooks/blob/main/nb/Mistral_v0.3_\(7B\)-Conversational.ipynb)
  * **Weitere Notebooks in unseren** [**Notebook-Dokumentationen**](/docs/de/loslegen/unsloth-notebooks.md)

### Speichern nach GGUF / vLLM 16 Bit stürzt ab

Sie können versuchen, die maximale GPU-Nutzung während des Speicherns zu reduzieren, indem Sie `maximum_memory_usage`.

Die Voreinstellung ist `model.save_pretrained(..., maximum_memory_usage = 0.75)`. Reduzieren Sie es beispielsweise auf 0,5, um 50 % des GPU-Spitzen-speichers oder weniger zu nutzen. Dies kann OOM-Abstürze beim Speichern reduzieren.

### Wie speichere ich manuell nach GGUF?

Speichern Sie zuerst Ihr Modell über 16 Bit mit:

```python
model.save_pretrained_merged("merged_model", tokenizer, save_method = "merged_16bit",)
```

Kompilieren Sie llama.cpp wie unten aus dem Quellcode:

```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=ON -DGGML_CUDA=ON -DLLAMA_CURL=ON
cmake --build llama.cpp/build --config Release -j --clean-first --target llama-quantize llama-cli llama-gguf-split llama-mtmd-cli
cp llama.cpp/build/bin/llama-* llama.cpp
```

Speichern Sie dann das Modell als F16:

```bash
python llama.cpp/convert_hf_to_gguf.py merged_model \
    --outfile model-F16.gguf --outtype f16 \
    --split-max-size 50G
```

```bash
# Für BF16:
python llama.cpp/convert_hf_to_gguf.py merged_model \
    --outfile model-BF16.gguf --outtype bf16 \
    --split-max-size 50G
    
# Für Q8_0:
python llama.cpp/convert_hf_to_gguf.py merged_model \
    --outfile model-Q8_0.gguf --outtype q8_0 \
    --split-max-size 50G
```

### Warum ist Q8\_K\_XL langsamer als Q8\_0 GGUF?

Auf Mac-Geräten scheint BF16 langsamer zu sein als F16. Q8\_K\_XL hebt einige Schichten auf BF16 an, daher die Verlangsamung. Wir ändern derzeit aktiv unseren Konvertierungsprozess, um F16 zur Standardwahl für Q8\_K\_XL zu machen und Leistungseinbußen zu reduzieren.

### So führen Sie die Evaluation durch

Um die Evaluation in Ihrem Trainingslauf einzurichten, müssen Sie zuerst Ihren Datensatz in einen Trainings- und einen Test-Split aufteilen. Sie sollten <mark style="background-color:green;">**die Auswahl des Datensatzes immer mischen**</mark>, andernfalls ist Ihre Evaluation falsch!

```python
new_dataset = dataset.train_test_split(
    test_size = 0.01, # 1 % als Testgröße; kann auch eine ganze Zahl für die # der Zeilen sein
    shuffle = True, # Sollte immer auf True gesetzt werden!
    seed = 3407,
)

train_dataset = new_dataset["train"] # Datensatz für das Training
eval_dataset = new_dataset["test"] # Datensatz für die Evaluation
```

Dann können wir die Trainingsargumente so setzen, dass die Evaluation aktiviert wird. Erinnerung: Evaluation kann sehr, sehr langsam sein, besonders wenn Sie `eval_steps = 1` setzen, was bedeutet, dass Sie jeden einzelnen Schritt evaluieren. Falls ja, versuchen Sie, die Größe von eval\_dataset auf etwa 100 Zeilen oder so zu reduzieren.

```python
from trl import SFTTrainer, SFTConfig
trainer = SFTTrainer(
    args = SFTConfig(
        fp16_full_eval = True,         # Setzen Sie dies, um die Speichernutzung zu reduzieren
        per_device_eval_batch_size = 2,# Eine Erhöhung davon verwendet mehr Speicher
        eval_accumulation_steps = 4,   # Sie können dies im Verhältnis zur batch_size erhöhen
        eval_strategy = "steps",       # Führt die Evaluation alle paar Schritte oder Epochen aus.
        eval_steps = 1,                # Wie viele Evaluationen pro # Trainingsschritte durchgeführt werden
    ),
    train_dataset = new_dataset["train"],
    eval_dataset = new_dataset["test"],
    ...
)
trainer.train()
```

### Evaluation Loop - Speicher voll oder Absturz.

Ein häufiges Problem bei OOM ist, dass die Batch-Größe zu hoch eingestellt wurde. Stellen Sie sie auf unter 2 ein, um weniger VRAM zu verwenden. Verwenden Sie außerdem `fp16_full_eval=True` um float16 für die Evaluation zu verwenden, wodurch der Speicherbedarf um die Hälfte reduziert wird.

Teilen Sie zuerst Ihren Trainingsdatensatz in einen Trainings- und einen Test-Split auf. Setzen Sie die Trainer-Einstellungen für die Evaluation auf:

```python
new_dataset = dataset.train_test_split(test_size = 0.01)

from trl import SFTTrainer, SFTConfig
trainer = SFTTrainer(
    args = SFTConfig(
        fp16_full_eval = True,
        per_device_eval_batch_size = 2,
        eval_accumulation_steps = 4,
        eval_strategy = "steps",
        eval_steps = 1,
    ),
    train_dataset = new_dataset["train"],
    eval_dataset = new_dataset["test"],
    ...
)
```

Dadurch werden keine OOMs verursacht und es wird etwas schneller. Sie können auch `bf16_full_eval=True` für bf16-Maschinen verwenden. Standardmäßig sollte Unsloth diese Flags seit Juni 2025 standardmäßig gesetzt haben.

### Wie mache ich Early Stopping?

Wenn Sie den Finetuning-/Trainingslauf stoppen möchten, weil der Evaluationsverlust nicht sinkt, können Sie Early Stopping verwenden, das den Trainingsprozess beendet. Verwenden Sie `EarlyStoppingCallback`.

Wie üblich richten Sie Ihren Trainer und Ihren Evaluierungsdatensatz ein. Das Folgende wird verwendet, um den Trainingslauf zu stoppen, wenn der `eval_loss` (der Evaluierungsverlust) nach etwa 3 Schritten nicht sinkt.

```python
from trl import SFTConfig, SFTTrainer
trainer = SFTTrainer(
    args = SFTConfig(
        fp16_full_eval = True,
        per_device_eval_batch_size = 2,
        eval_accumulation_steps = 4,
        output_dir = "training_checkpoints", # Speicherort der gespeicherten Checkpoints für Early Stopping
        save_strategy = "steps",             # Modell alle N Schritte speichern
        save_steps = 10,                     # wie viele Schritte bis zum Speichern des Modells
        save_total_limit = 3,                # nur 3 gespeicherte Checkpoints behalten, um Speicherplatz zu sparen
        eval_strategy = "steps",             # alle N Schritte evaluieren
        eval_steps = 10,                     # wie viele Schritte bis zur Evaluation
        load_best_model_at_end = True,       # MUSS für Early Stopping verwendet werden
        metric_for_best_model = "eval_loss", # Metrik, bei der wir Early Stopping anwenden wollen
        greater_is_better = False,           # je niedriger der Evaluierungsverlust, desto besser
    ),
    model = model,
    tokenizer = tokenizer,
    train_dataset = new_dataset["train"],
    eval_dataset = new_dataset["test"],
)
```

Dann fügen wir den Callback hinzu, der ebenfalls angepasst werden kann:

```python
from transformers import EarlyStoppingCallback
early_stopping_callback = EarlyStoppingCallback(
    early_stopping_patience = 3,     # Wie viele Schritte wir warten, wenn der Evaluierungsverlust nicht sinkt
                                     # Zum Beispiel könnte der Verlust steigen, aber nach 3 Schritten wieder sinken
    early_stopping_threshold = 0.0,  # Kann höher gesetzt werden - legt fest, um wie viel der Verlust sinken muss, bis
                                     # wir Early Stopping in Betracht ziehen. Z. B. bedeutet 0.01, dass wenn der Verlust war
                                     # 0.02 dann 0.01, betrachten wir den Lauf als frühzeitig gestoppt.
)
trainer.add_callback(early_stopping_callback)
```

Dann trainieren Sie das Modell wie üblich über `trainer.train() .`

### Der Download bleibt bei 90 bis 95 % hängen

Wenn Ihr Modell längere Zeit bei 90, 95 % hängen bleibt, können Sie einige schnelle Download-Prozesse deaktivieren, um Downloads erzwungen synchron auszuführen und mehr Fehlermeldungen auszugeben.

Verwenden Sie einfach `UNSLOTH_STABLE_DOWNLOADS=1` vor jedem Unsloth-Import.

```python
import os
os.environ["UNSLOTH_STABLE_DOWNLOADS"] = "1"

from unsloth import FastLanguageModel
```

### RuntimeError: CUDA-Fehler: Device-seitiger Assert ausgelöst

Starten Sie neu und führen Sie alles aus, aber setzen Sie dies an den Anfang, vor jeden Unsloth-Import. Bitte reichen Sie außerdem so schnell wie möglich einen Fehlerbericht ein, danke!

```python
import os
os.environ["UNSLOTH_COMPILE_DISABLE"] = "1"
os.environ["UNSLOTH_DISABLE_FAST_GENERATION"] = "1"
```

### Alle Labels in Ihrem Datensatz sind -100. Die Trainingsverluste werden alle 0 sein.

Das bedeutet, dass Ihre Verwendung von `train_on_responses_only` für dieses spezielle Modell nicht korrekt ist. train\_on\_responses\_only ermöglicht es Ihnen, die Benutzerfrage zu maskieren und Ihr Modell darauf zu trainieren, die Antwort des Assistenten mit höherer Gewichtung auszugeben. Dies erhöht nachweislich die Genauigkeit um 1 % oder mehr. Siehe unseren [**LoRA-Hyperparameter-Leitfaden**](/docs/de/loslegen/fine-tuning-llms-guide/lora-hyperparameters-guide.md) für weitere Details.

Für Modelle vom Typ Llama 3.1, 3.2, 3.3 verwenden Sie bitte das Folgende:

```python
from unsloth.chat_templates import train_on_responses_only
trainer = train_on_responses_only(
    trainer,
    instruction_part = "<|start_header_id|>user<|end_header_id|>\n\n",
    response_part = "<|start_header_id|>assistant<|end_header_id|>\n\n",
)
```

Für Gemma 2, 3. 3n Modelle verwenden Sie das Folgende:

```python
from unsloth.chat_templates import train_on_responses_only
trainer = train_on_responses_only(
    trainer,
    instruction_part = "<start_of_turn>user\n",
    response_part = "<start_of_turn>model\n",
)
```

### Ist Unsloth langsamer als erwartet?

Wenn Ihre Geschwindigkeit anfangs langsamer erscheint, liegt das wahrscheinlich daran, dass `torch.compile` typischerweise etwa 5 Minuten (oder länger) benötigt, um aufzuwärmen und das Kompilieren abzuschließen. Stellen Sie sicher, dass Sie den Durchsatz messen **nachdem** es vollständig geladen ist, denn über längere Läufe sollte Unsloth deutlich schneller sein.

Zum Deaktivieren verwenden Sie:

```python
import os
os.environ["UNSLOTH_COMPILE_DISABLE"] = "1"
```

### Einige Gewichte von Gemma3nForConditionalGeneration wurden nicht aus dem Modell-Checkpoint initialisiert

Dies ist ein kritischer Fehler, da dies bedeutet, dass einige Gewichte nicht korrekt geparst wurden, was zu falschen Ausgaben führen wird. Dies kann normalerweise durch ein Upgrade von Unsloth behoben werden

`pip install --upgrade --force-reinstall --no-cache-dir --no-deps unsloth unsloth_zoo`

Dann aktualisieren Sie transformers und timm:

`pip install --upgrade --force-reinstall --no-cache-dir --no-deps transformers timm`

Wenn das Problem jedoch weiterhin besteht, reichen Sie bitte so schnell wie möglich einen Fehlerbericht ein!

### NotImplementedError: Eine UTF-8-Locale ist erforderlich. ANSI erhalten

Siehe <https://github.com/googlecolab/colabtools/issues/3409>

Führen Sie in einer neuen Zelle Folgendes aus:

```python
import locale
locale.getpreferredencoding = lambda: "UTF-8"
```

### Unsloth zitieren

Wenn Sie die Verwendung unserer Modell-Uploads zitieren, verwenden Sie bitte das folgende Bibtex. Dies gilt für Qwen3-30B-A3B-GGUF Q8\_K\_XL:

```
@misc{unsloth_2025_qwen3_30b_a3b,
  author       = {Unsloth AI and Han-Chen, Daniel and Han-Chen, Michael},
  title        = {Qwen3-30B-A3B-GGUF:Q8\_K\_XL},
  year         = {2025},
  publisher    = {Hugging Face},
  howpublished = {\url{https://huggingface.co/unsloth/Qwen3-30B-A3B-GGUF}}
}
```

Um die Verwendung unseres GitHub-Pakets oder unserer Arbeit im Allgemeinen zu zitieren:

```
@misc{unsloth,
  author       = {Unsloth AI and Han-Chen, Daniel and Han-Chen, Michael},
  title        = {Unsloth},
  year         = {2025},
  publisher    = {Github},
  howpublished = {\url{https://github.com/unslothai/unsloth}}
}
```

[^1]: Aktivieren Sie diese Codezeile und sehen Sie, ob es funktioniert.


---

# 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 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/grundlagen/troubleshooting-and-faqs.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.
