Unsloth 2x schnellere Feinabstimmung

LLMs 2x schneller mit 70% weniger VRAM mit Unsloth auf Clore.ai feinabstimmen

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

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

Hauptmerkmale

• 2x schnelleres Training — benutzerdefinierte Triton‑Kernels für Attention, RoPE, Kreuzentropie und RMS‑Norm

• 70% weniger VRAM — intelligente Gradient‑Checkpointing und speicherabbildbare Gewichte

• Drop‑in Ersatz für HuggingFace — nur ein Importwechsel, nichts weiter

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

• Native Exportfunktion — direkt in GGUF (alle Quantisierungstypen), LoRA‑Adapter oder zusammengeführtes 16‑Bit speichern

• Breite Modellunterstützung — 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	11.8	12.1+
Python	3.10	3.11

Clore.ai-Preise: RTX 4090 ≈ $0.5–2/Tag · RTX 3090 ≈ $0.3–1/Tag · RTX 3060 ≈ $0.15–0.3/Tag

Ein 7B‑Modell mit 4‑Bit‑QLoRA passt in ~10 GB VRAM, wodurch sogar eine RTX 3060 nutzbar wird.

Schnellstart

1. Unsloth installieren

# Erstelle ein venv (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% VRAM‑Einsparung
    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"Training loss: {stats.training_loss:.4f}")

Modell exportieren

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

Export nach GGUF für Ollama / llama.cpp

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

# Andere Optionen: q5_k_m, q8_0, f16

Nach dem Export mit Ollama bereitstellen:

# Erstelle eine Ollama Modelfile
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 Transformers‑Architektur zusammen"

Beispielanwendungen

Feinabstimmung auf einem eigenen 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": "You are a helpful assistant."},
        {"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 Alignment Training

from trl import DPOTrainer, DPOConfig

dpo_trainer = DPOTrainer(
    model=model,
    ref_model=None,          # Unsloth verwaltet 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()

VRAM-Nutzungsreferenz

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" — dies ist der größte einzelne VRAM‑Sparer, einzigartig bei Unsloth

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

• Verwenden Sie packing=True im SFTTrainer, um Padding‑Verschwendung bei kurzen Beispielen zu vermeiden

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

• Mit wandb überwachen — füge hinzu report_to="wandb" in TrainingArguments zur Verlustüberwachung

• Batch-Größen-Tuning — erhöhe per_device_train_batch_size bis du an die VRAM‑Grenze kommst, kompensiere dann mit gradient_accumulation_steps

Fehlerbehebung

Problem	Lösung
OutOfMemoryError während des Trainings	Batch‑Größe auf 1 reduzieren, max_seq_length, oder 4‑Bit‑Quantisierung verwenden
Triton‑Kernel‑Kompilierungsfehler	Ausführen pip install triton --upgrade und sicherstellen, dass das CUDA‑Toolkit übereinstimmt
Langsamer erster Schritt (Kompilierung)	Normal — Triton kompiliert die Kernels beim ersten Lauf, danach werden sie gecacht
bitsandbytes CUDA‑Versionsfehler	Installiere die passende Version: pip install bitsandbytes --upgrade
Verlustspitzen während des Trainings	Lernrate auf 1e-4 senken, Warmup‑Schritte hinzufügen
GGUF‑Export stürzt ab	Stelle genügend RAM (2× Modellgröße) und Festplattenspeicher für die Konvertierung sicher

Ressourcen

• Unsloth GitHub

• Unsloth Wiki — Alle Notebooks

• CLORE.AI Marketplace