Unsloth 2x schnelleres Fine-Tuning

Feinabstimme LLMs 2x schneller mit 70 % weniger VRAM mithilfe von Unsloth auf Clore.ai

Unsloth schreibt die leistungs­kritischen Teile von HuggingFace Transformers mit handoptimierten Triton-Kernels neu und liefert 2x Trainingsgeschwindigkeit und 70% weniger VRAM bei keinem Genauigkeitsverlust. Es ist ein Drop-in-Ersatz — Ihre vorhandenen TRL/PEFT-Skripte funktionieren nach dem Austausch des Imports unverändert.

Alle Beispiele laufen auf GPU-Servern, die über die CLORE.AI-Marktplatz.

Hauptfunktionen

• 2x schnelleres Training — benutzerdefinierte Triton-Kernels für Attention, RoPE, Cross-Entropy und RMS-Norm

• 70% weniger VRAM — intelligentes Gradient Checkpointing und speicherabgebildete Gewichte

• Drop-in-Ersatz für HuggingFace — nur eine Import-Änderung, sonst nichts

• QLoRA / LoRA / vollständiges Fine-Tuning — alle Modi werden sofort unterstützt

• Natives Exportieren — direkt als GGUF speichern (alle Quantisierungsarten), LoRA-Adapter oder zusammengeführt in 16-Bit

• Breite Modellabdeckung — Llama 3.x, Mistral, Qwen 2.5, Gemma 2, DeepSeek-R1, Phi-4 und mehr

• Kostenlos und Open Source (Apache 2.0)

Anforderungen

Komponente	Minimum	Empfohlen
GPU	RTX 3060 12 GB	RTX 4090 24 GB
VRAM	10 GB	24 GB
RAM	16 GB	32 GB
Festplatte	40 GB	80 GB
CUDA	12.8+	12.8+
Python	3.10	3.11

Clore.ai-Preise: RTX 4090 ≈ $0.14–0.42/Stunde · RTX 3090 ≈ $0.07–0.21/Stunde · RTX 3060 ≈ $0.03–0.07/Stunde

Ein 7B-Modell mit 4-Bit-QLoRA passt in ~10 GB VRAM, wodurch sogar eine RTX 3060 geeignet ist.

Schnellstart

1. Unsloth installieren

# Eine virtuelle Umgebung erstellen (empfohlen)
python -m venv /workspace/unsloth-env
source /workspace/unsloth-env/bin/activate

pip install --upgrade pip
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes xformers

2. Ein Modell mit 4-Bit-Quantisierung laden

from unsloth import FastLanguageModel
import torch

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Meta-Llama-3.1-8B-Instruct-bnb-4bit",
    max_seq_length=2048,
    dtype=None,            # automatische Erkennung (float16 auf Ampere, bfloat16 auf Ada)
    load_in_4bit=True,
)

3. LoRA-Adapter anwenden

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=16,
    lora_dropout=0,
    bias="none",
    use_gradient_checkpointing="unsloth",   # 70% weniger VRAM
    random_state=42,
    use_rslora=False,
    loftq_config=None,
)

4. Daten vorbereiten und trainieren

from datasets import load_dataset
from trl import SFTTrainer
from transformers import TrainingArguments

dataset = load_dataset("yahma/alpaca-cleaned", split="train")

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    dataset_num_proc=2,
    packing=True,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        warmup_steps=10,
        num_train_epochs=1,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=10,
        optim="adamw_8bit",
        weight_decay=0.01,
        lr_scheduler_type="linear",
        seed=42,
        output_dir="/workspace/outputs",
    ),
)

stats = trainer.train()
print(f"Trainingsverlust: {stats.training_loss:.4f}")

Modell exportieren

Nur den LoRA-Adapter speichern

model.save_pretrained("/workspace/lora-adapter")
tokenizer.save_pretrained("/workspace/lora-adapter")

Vollständiges Modell zusammenführen und speichern (float16)

model.save_pretrained_merged(
    "/workspace/merged-model",
    tokenizer,
    save_method="merged_16bit",
)

Für Ollama / llama.cpp nach GGUF exportieren

# Zu Q4_K_M quantisieren (guter Kompromiss aus Größe und Qualität)
model.save_pretrained_gguf(
    "/workspace/gguf-output",
    tokenizer,
    quantization_method="q4_k_m",
)

# Weitere Optionen: q5_k_m, q8_0, f16

Nach dem Export mit Ollama bereitstellen:

# Eine Ollama-Modelfile erstellen
cat > Modelfile <<EOF
FROM /workspace/gguf-output/unsloth.Q4_K_M.gguf
TEMPLATE "{{ .System }}\n{{ .Prompt }}"
PARAMETER temperature 0.7
EOF

ollama create my-finetuned -f Modelfile
ollama run my-finetuned "Fasse die wichtigsten Punkte der Transformer-Architektur zusammen"

Anwendungsbeispiele

Fine-Tuning auf einem benutzerdefinierten Chat-Datensatz

from unsloth.chat_templates import get_chat_template

tokenizer = get_chat_template(tokenizer, chat_template="llama-3.1")

def format_chat(example):
    messages = [
        {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
        {"role": "user", "content": example["instruction"]},
        {"role": "assistant", "content": example["output"]},
    ]
    return {"text": tokenizer.apply_chat_template(messages, tokenize=False)}

dataset = dataset.map(format_chat)

DPO / ORPO Ausrichtungstraining

from trl import DPOTrainer, DPOConfig

dpo_trainer = DPOTrainer(
    model=model,
    ref_model=None,          # Unsloth behandelt das Referenzmodell intern
    args=DPOConfig(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        learning_rate=5e-6,
        num_train_epochs=1,
        beta=0.1,
        output_dir="/workspace/dpo-output",
    ),
    train_dataset=dpo_dataset,
    tokenizer=tokenizer,
)
dpo_trainer.train()

Referenz für VRAM-Nutzung

Modell	Quant	Methode	VRAM	GPU
Llama 3.1 8B	4-Bit	QLoRA	~10 GB	RTX 3060
Llama 3.1 8B	16-Bit	LoRA	~18 GB	RTX 3090
Qwen 2.5 14B	4-Bit	QLoRA	~14 GB	RTX 3090
Mistral 7B	4-Bit	QLoRA	~9 GB	RTX 3060
DeepSeek-R1 7B	4-Bit	QLoRA	~10 GB	RTX 3060
Llama 3.3 70B	4-Bit	QLoRA	~44 GB	2× RTX 3090

Tipps

• Immer verwenden use_gradient_checkpointing="unsloth" — das ist der größte einzelne VRAM-Sparer und einzigartig bei Unsloth

• Setze lora_dropout=0 — Unsloths Triton-Kernels sind für kein Dropout optimiert und laufen schneller

• Verwende packing=True in SFTTrainer, um Padding-Verschwendung bei kurzen Beispielen zu vermeiden

• Beginnen Sie mit r=16 für den LoRA-Rang — nur auf 32 oder 64 erhöhen, wenn der Validierungsverlust stagniert

• Mit wandb überwachen — hinzufügen report_to="wandb" in TrainingArguments für die Verlustverfolgung

• Batch-Size-Tuning — erhöhen per_device_train_batch_size bis Sie sich dem VRAM-Limit nähern, und dann ausgleichen mit gradient_accumulation_steps

Fehlerbehebung

Problem	Lösung
OutOfMemoryError während des Trainings	Batch-Größe auf 1 senken, max_seq_length, oder 4-Bit-Quantisierung verwenden
Triton-Kernel-Kompilierfehler	Ausführen pip install triton --upgrade und sicherstellen, dass das CUDA-Toolkit übereinstimmt
Langsamer erster Schritt (Kompilieren)	Normal — Triton kompiliert die Kernels beim ersten Lauf und speichert sie danach im Cache
bitsandbytes CUDA-Versionsfehler	Passende Version installieren: pip install bitsandbytes --upgrade
Loss-Spitzen während des Trainings	Lernrate auf 1e-4 senken, Warmup-Schritte hinzufügen
GGUF-Export stürzt ab	Sicherstellen, dass genug RAM (2× Modellgröße) und Speicherplatz für die Konvertierung vorhanden sind

Ressourcen

• Unsloth GitHub

• Unsloth Wiki — Alle Notebooks

• CLORE.AI-Marktplatz