⚠️Fehlerbehebung & FAQs

Tipps zur Lösung von Problemen und häufig gestellte Fragen.

Wenn Sie weiterhin Probleme mit Versionen oder Abhängigkeiten haben, verwenden Sie bitte unser Docker-Image das alles vorinstalliert enthält.

Versuchen Sie, Unsloth immer zu aktualisieren, wenn Sie Probleme finden.

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

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

Unsloth funktioniert mit jedem Modell, das unterstützt wird von transformers. Wenn ein Modell nicht in unseren Uploads ist oder nicht sofort funktioniert, wird es in der Regel dennoch 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:

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 4 Bit, um den Speicherverbrauch zu reduzieren. False für 16-Bit-LoRA.
    auto_model = AutoModel,
    trust_remote_code = True, # Aktivieren, um neue Modelle zu unterstützen
    unsloth_force_compile = True,
    use_gradient_checkpointing = "unsloth", # True oder "unsloth" für langen Kontext
)

Das Ausführen in Unsloth funktioniert gut, aber nach dem Export und dem Ausführen auf anderen Plattformen sind die Ergebnisse schlecht

Es kann vorkommen, dass dein Modell in Unsloth läuft und gute Ergebnisse liefert, aber wenn du es auf einer anderen Plattform wie Ollama oder vLLM verwendest, sind die Ergebnisse schlecht oder du bekommst Kauderwelsch oder endlose/unendliche Generierungen oder wiederholte Ausgaben.

• Die häufigste Ursache für diesen Fehler ist die Verwendung eines falschen Chat-Templates. Es ist entscheidend, dass du dasselbe Chat-Template verwendest, das beim Training des Modells in Unsloth genutzt wurde, und später auch dann, wenn du es in einem anderen Framework wie llama.cpp oder Ollama ausführst. Bei der Inferenz eines gespeicherten Modells ist es entscheidend, das richtige Template anzuwenden.

• Es könnte auch daran liegen, dass deine Inferenz-Engine ein unnötiges "Start-of-Sequence"-Token hinzufügt (oder umgekehrt keines hinzufügt), also prüfe unbedingt beide Hypothesen!

• Verwende unsere Konversations-Notebooks, um das Chat-Template zu erzwingen – das behebt die meisten Probleme.

  • Qwen-3 14B Konversations-Notebook In Colab öffnen

  • Gemma-3 4B Konversations-Notebook In Colab öffnen

  • Llama-3.2 3B Konversations-Notebook In Colab öffnen

  • Phi-4 14B Konversations-Notebook In Colab öffnen

  • Mistral v0.3 7B Konversations-Notebook In Colab öffnen

  • Weitere Notebooks in unserer Notebook-Dokumentation

Beim Speichern in GGUF / vLLM 16 Bit kommt es zu Abstürzen

Du kannst versuchen, die maximale GPU-Auslastung während des Speicherns zu reduzieren, indem du maximum_memory_usage.

Standardmäßig ist model.save_pretrained(..., maximum_memory_usage = 0.75). Reduziere es beispielsweise auf 0.5, um 50 % des GPU-Spitzenspeichers oder weniger zu nutzen. Das kann OOM-Abstürze beim Speichern verringern.

Wie speichere ich manuell in GGUF?

Speichere zuerst dein Modell über Folgendes in 16 Bit:

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

Kompiliere llama.cpp wie unten aus dem Quellcode:

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

Speichere dann das Modell in F16:

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

# 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 konvertiert einige Schichten nach BF16 hoch, daher die Verlangsamung. Wir ändern unseren Konvertierungsprozess aktiv, damit F16 die Standardwahl für Q8_K_XL wird, um Leistungseinbußen zu verringern.

Wie man Evaluierung durchführt

Um die Evaluierung in Ihrem Trainingslauf einzurichten, müssen Sie zuerst Ihren Datensatz in einen Trainings- und einen Test-Split aufteilen. Sie sollten die Auswahl des Datensatzes immer mischen, sonst ist Ihre Evaluierung falsch!

new_dataset = dataset.train_test_split(
    test_size = 0.01, # 1 % für die 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 Evaluierung

Dann können wir die Trainingsargumente festlegen, um die Evaluierung zu aktivieren. Erinnerung: Die Evaluierung kann sehr, sehr langsam sein, insbesondere wenn Sie eval_steps = 1 setzen, was bedeutet, dass Sie bei jedem einzelnen Schritt evaluieren. Falls ja, versuchen Sie, die Größe von eval_dataset auf etwa 100 Zeilen oder so zu reduzieren.

from trl import SFTTrainer, SFTConfig
trainer = SFTTrainer(
    args = SFTConfig(
        fp16_full_eval = True,         # Setzen Sie dies, um den Speicherverbrauch zu reduzieren
        per_device_eval_batch_size = 2,# Wenn Sie diesen Wert erhöhen, wird mehr Speicher verwendet
        eval_accumulation_steps = 4,   # Sie können dies im Verhältnis zur Batch-Größe erhöhen
        eval_strategy = "steps",       # Führt die Evaluierung alle paar Schritte oder Epochen aus.
        eval_steps = 1,                # Wie viele Evaluierungen pro # Trainingsschritten durchgeführt werden
    ),
    train_dataset = new_dataset["train"],
    eval_dataset = new_dataset["test"],
    ...
)
trainer.train()

Evaluierungs-Loop - Kein Speicher mehr oder Absturz.

Ein häufiges Problem bei OOM ist, dass Sie Ihre Batch-Größe zu hoch eingestellt haben. Setzen Sie sie niedriger als 2, um weniger VRAM zu verwenden. Verwenden Sie außerdem fp16_full_eval=True um Float16 für die Evaluierung zu verwenden, was den Speicherbedarf halbiert.

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

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"],
    ...
)

Dies führt zu keinen OOMs und macht es 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 Fine-Tuning-/Trainingslauf stoppen möchten, weil der Evaluierungsverlust nicht sinkt, können Sie Early Stopping verwenden, das den Trainingsprozess stoppt. Verwenden Sie EarlyStoppingCallback.

Richte wie üblich deinen Trainer und deinen Evaluierungsdatensatz ein. Das Folgende wird verwendet, um den Trainingslauf zu stoppen, wenn der eval_loss (der Evaluierungsverlust) nach etwa 3 Schritten nicht sinkt.

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", # Ort der gespeicherten Checkpoints für Early Stopping
        save_strategy = "steps",             # speichere das Modell alle N Schritte
        save_steps = 10,                     # wie viele Schritte, bis wir das Modell speichern
        save_total_limit = 3,                # behalte nur 3 gespeicherte Checkpoints, um Speicherplatz zu sparen
        eval_strategy = "steps",             # alle N Schritte evaluieren
        eval_steps = 10,                     # wie viele Schritte, bis wir die Evaluation durchführen
        load_best_model_at_end = True,       # MUSS für Early Stopping VERWENDET WERDEN
        metric_for_best_model = "eval_loss", # Metrik, auf 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:

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 soll, bis
                                     # wir Early Stopping berücksichtigen. Z. B. bedeutet 0.01, dass wenn der Verlust
                                     # 0.02 war, dann 0.01, betrachten wir den Lauf als frühzeitig zu stoppen.
)
trainer.add_callback(early_stopping_callback)

Dann trainiere das Modell wie üblich über trainer.train() .

Das Herunterladen bleibt bei 90 bis 95 % hängen

Wenn Ihr Modell lange bei 90, 95 % hängen bleibt, können Sie einige schnelle Downloadprozesse deaktivieren, um Downloads zu erzwingen, synchron zu laufen und mehr Fehlermeldungen auszugeben.

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

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

from unsloth import FastLanguageModel

RuntimeError: CUDA-Fehler: geräteseitige Assertion ausgelöst

Neu starten und alles ausführen, aber setzen Sie dies an den Anfang vor jeden Unsloth-Import. Bitte reichen Sie außerdem so bald wie möglich einen Fehlerbericht ein, danke!

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 bestimmte Modell falsch ist. train_on_responses_only ermöglicht es Ihnen, die Benutzerfrage zu maskieren und Ihr Modell darauf zu trainieren, die Assistentenantwort mit höherer Gewichtung auszugeben. Dies erhöht bekanntermaßen die Genauigkeit um 1 % oder mehr. Siehe unseren Leitfaden zu LoRA-Hyperparametern für weitere Details.

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

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 bitte das Folgende:

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

Unsloth ist langsamer als erwartet?

Wenn Ihre Geschwindigkeit anfangs langsamer erscheint, liegt das wahrscheinlich daran, dass torch.compile normalerweise etwa 5 Minuten (oder länger) zum Hochfahren und Abschließen der Kompilierung benötigt. Stellen Sie sicher, dass Sie den Durchsatz messen nach es vollständig geladen ist; bei längeren Läufen sollte Unsloth deutlich schneller sein.

Zum Deaktivieren verwenden Sie:

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ührt. Dies kann normalerweise durch ein Upgrade von Unsloth behoben werden

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

Aktualisieren Sie dann transformers und timm:

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

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

NotImplementedError: Eine UTF-8-Locale ist erforderlich. Erhalten: ANSI

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

Führen Sie in einer neuen Zelle Folgendes aus:

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