So optimieren Sie LLMs lokal

Für die lokale Feinabstimmung eines großen Sprachmodells war früher ein GPU-Rack erforderlich. Im Jahr 2026 können Sie dank Quantisierung und Parameter-effizienter Methoden wie LoRA ein 7-8B-Parametermodell auf einer einzelnen Verbraucher-GPU mit 12-24 GB VRAM verfeinern – oder sogar auf Apple Silicon mit einheitlichem Speicher. Dieser Leitfaden führt Sie durch die gesamte Pipeline: Vorbereiten von Daten, Ausführen der LoRA-Feinabstimmung und Zusammenführen des Ergebnisses in ein Modell, das Sie tatsächlich ausführen können.

Inhaltsverzeichnis

• Warum Feinabstimmung statt Aufforderung
• Hardware- und Softwareanforderungen
• Vorbereiten eines Trainingsdatensatzes
• Feinabstimmung mit LoRA
• Ausführen der Trainingsschleife
• Zusammenführen und Exportieren des Modells
• Lokales Ausführen Ihres fein abgestimmten Modells
• Häufige Fallstricke
• FAQ

Warum Feinabstimmung statt Aufforderung

Prompt Engineering und RAG lösen die meisten Probleme – probieren Sie diese zuerst aus. Die Feinabstimmung lohnt sich insbesondere dann, wenn das Modell konsistent einem engen Ausgabeformat folgen, über Tausende von Generationen hinweg einen bestimmten Ton annehmen oder eine Aufgabe ausführen soll, die das Basismodell trotz guter Eingabeaufforderungen und Beispiele inkonsistent erledigt. Es bindet das Verhalten in die Gewichte ein, anstatt es bei jeder Eingabeaufforderung erneut zu erklären.

Hardware- und Softwareanforderungen

Für ein 7-8B-Parameter-Basismodell mit 4-Bit-Quantisierung und LoRA sind 12-16 GB VRAM auf einer einzelnen GPU realistisch. Größere 13-14B-Modelle tendieren zu 24-GB-Karten. Installieren Sie den Core-Stack:

pip install torch transformers peft bitsandbytes accelerate datasets trl

peft(Parameter-Efficient Fine-Tuning) implementiert LoRA.bitsandbytesBewältigt die 4-Bit-Quantisierung, sodass das Basismodell in den Speicher passt.trlBietet eine Trainingsschleife, die speziell für die Feinabstimmung des Sprachmodells entwickelt wurde.

Vorbereiten eines Trainingsdatensatzes

Bei engen Aufgaben ist das Format wichtiger als die Lautstärke – 200–500 hochwertige Beispiele übertreffen oft 5.000 verrauschte. Verwenden Sie ein einfaches Anweisungsformat als JSONL:

{"instruction": "Summarize this support ticket in one sentence.", "input": "Customer reports login failures since the 2.3 update...", "output": "User cannot log in after updating to version 2.3."}
{"instruction": "Summarize this support ticket in one sentence.", "input": "Payment declined for annual plan renewal...", "output": "Annual plan renewal payment was declined."}

Laden Sie es mitdatasetsBibliothek:

from datasets import load_dataset

dataset = load_dataset("json", data_files="train.jsonl", split="train")

def format_example(example):
    return {
        "text": f"### Instruction:\n{example['instruction']}\n\n### Input:\n{example['input']}\n\n### Response:\n{example['output']}"
    }

dataset = dataset.map(format_example)

Feinabstimmung mit LoRA

LoRA friert die Gewichte des Basismodells ein und trainiert stattdessen kleine Adaptermatrizen mit niedrigem Rang, die in Aufmerksamkeitsschichten eingefügt werden. Dadurch werden trainierbare Parameter von Milliarden auf Millionen reduziert, weshalb es auf Verbraucherhardware passt:

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model
import torch

model_name = "meta-llama/Meta-Llama-3-8B"

bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
)

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(model_name, quantization_config=bnb_config, device_map="auto")

lora_config = LoraConfig(
    r=16,
    lora_alpha=32,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

In der letzten Zeile wird normalerweise etwas wie „trainierbare Parameter: 0,06 % des Gesamtwerts“ ausgegeben – eine konkrete Erinnerung daran, warum dies auf eine einzelne GPU passt, wo eine vollständige Feinabstimmung nicht möglich wäre.

Ausführen der Trainingsschleife

trlistSFTTrainerumhüllt Hugging Face’sTrainermit sinnvollen Standardwerten für die Befehlsoptimierung:

from trl import SFTTrainer, SFTConfig

training_args = SFTConfig(
    output_dir="./lora-output",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    num_train_epochs=3,
    learning_rate=2e-4,
    logging_steps=10,
    save_strategy="epoch",
    bf16=True,
)

trainer = SFTTrainer(
    model=model,
    train_dataset=dataset,
    args=training_args,
    dataset_text_field="text",
)

trainer.train()

Mit der Gradientenakkumulation können Sie eine größere Batchgröße simulieren, als Ihr VRAM zulässt, indem Sie Gradienten über mehrere kleine Batches akkumulieren, bevor Sie die Gewichte aktualisieren – legen Sieper_device_train_batch_sizefest so hoch wie der Speicher zulässt, danngradient_accumulation_stepserhöhen um eine effektive Chargengröße von 8-16 zu erreichen.

Zusammenführen und Exportieren des Modells

Führen Sie nach dem Training die Gewichte des LoRA-Adapters wieder in das Basismodell ein, um einen eigenständigen Prüfpunkt zu erhalten, den Sie verteilen oder konvertieren können:

from peft import PeftModel

base_model = AutoModelForCausalLM.from_pretrained(model_name, torch_dtype=torch.bfloat16, device_map="auto")
merged_model = PeftModel.from_pretrained(base_model, "./lora-output/checkpoint-final")
merged_model = merged_model.merge_and_unload()

merged_model.save_pretrained("./merged-model")
tokenizer.save_pretrained("./merged-model")

Lokales Ausführen Ihres fein abgestimmten Modells

Konvertieren Sie das zusammengeführte Modell in das GGUF-Format für eine schnelle lokale Inferenz mitllama.cppoder Ollama:

python convert_hf_to_gguf.py ./merged-model --outfile my-model.gguf --outtype q4_k_m

ollama create my-model -f Modelfile
ollama run my-model

Dasq4_k_mDurch die Quantisierung bleibt die Qualität nahe an der des Vollpräzisionsmodells, während die Dateigröße etwa um das Vierfache reduziert wird, was für die komfortable Ausführung des Modells auf einem Laptop wichtig ist.

Häufige Fallstricke

Überanpassung bei kleinen Datensätzen ist der häufigste Fehler – wenn Ihr Verlust innerhalb einer Epoche nahe Null sinkt, merken Sie sich wahrscheinlich eher als zu verallgemeinern, und der Validierungsverlust sollte getrennt vom Trainingsverlust beobachtet werden. Die Lernrate ist das zweithäufigste Problem: 2e-4 funktioniert für die meisten 7-8B-LoRA-Setups, aber eine höhere Geschwindigkeit bei kleinen Datensätzen destabilisiert das Training schnell.

Achten Sie auch auf die Konsistenz der Formatierung. Wenn Ihre Trainingsdaten eine bestimmte Anweisungsvorlage verwenden, müssen Ihre Inferenzaufrufe genau dieselbe Vorlage verwenden – ein nicht übereinstimmendes Format zum Inferenzzeitpunkt verschlechtert stillschweigend die Ausgabequalität, ohne dass ein Fehler ausgegeben wird.

Weitere Informationen zum effizienten Betrieb von Modellen nach der Feinabstimmung finden Sie in unseremHeimlabor und DevOps-Leitfadendeckt die Self-Hosting-Infrastruktur ab. Wenn Sie eine API rund um Ihr Modell erstellen, lesen Sie unsereFastAPI REST-Tutorial.

FAQ

Wie viele Daten benötige ich eigentlich?
Für enge, klar definierte Aufgaben reichen oft 200–500 hochwertige Beispiele. Umfassendere Verhaltensänderungen (Tonfall, Befolgen mehrerer Aufgaben) profitieren von Tausenden unterschiedlicher Beispiele.

Kann ich auf einem MacBook eine Feinabstimmung vornehmen?
Ja, mit der Schulungsunterstützung von MLX oder llama.cpp auf Apple Silicon. Einheitlicher Speicher bedeutet, dass ein MacBook mit 32–64 GB 7–8 GB LoRA-Feinabstimmung bewältigen kann, allerdings langsamer als eine dedizierte NVIDIA-GPU.

Was ist der Unterschied zwischen LoRA und QLoRA?
QLoRA fügt zusätzlich zu LoRA eine 4-Bit-Quantisierung des eingefrorenen Basismodells hinzu, wodurch der Speicherbedarf bei minimalem Qualitätsverlust weiter gesenkt wird – das macht 8B-Modelle auf 12-16-GB-GPUs trainierbar.

Muss ich eine Feinabstimmung vornehmen oder würde RAG funktionieren?
Wenn das Problem lautet: „Das Modell kennt diese Informationen nicht“, verwenden Sie RAG. Wenn das Problem lautet: „Das Modell kennt die Informationen, formatiert sich aber nicht oder verhält sich nicht so, wie ich es brauche“, ist die Feinabstimmung das bessere Werkzeug.

Wie lange dauert die Feinabstimmung von LoRA?
Für 500 Beispiele und 3 Epochen auf einer einzelnen Verbraucher-GPU können Sie je nach Sequenzlänge und GPU-Klasse mit einer Zeitspanne zwischen 20 Minuten und einigen Stunden rechnen.

Bereit für die Feinabstimmung?

Beginnen Sie mit einem kleinen, sauberen Datensatz von 200–300 Beispielen für eine einzelne, eng gefasste Aufgabe, bevor Sie die Größe vergrößern. Die obige Pipeline – LoRA-Adapter, SFTTrainer, Merge, GGUF-Export – hat die gleiche Form, die für Produktionsfeinabstimmungen verwendet wird, nur in einem Maßstab, der auf die Hardware passt, die Sie wahrscheinlich bereits besitzen.