Dieses Tutorial zeigt Schritt für Schritt, wie du (1) in Visual Studio Code ein Fine‑Tuning mit Hugging Face (Transformers/PEFT/TRL) einrichtest und (2) das Ergebnis lokal mit Ollama im Editor nutzt – inklusive Continue‑Extension‑Konfiguration. Fokus: Windows 10/11 und Debian 12.

— Stand: 27.08.2025 —

0) Voraussetzungen

• Hardware: 16 GB RAM (Minimum), NVIDIA‑GPU empfohlen (>= 8 GB VRAM).
• OS: Windows 10/11 oder Debian 12 (Bookworm).
• Software:
– Visual Studio Code (aktuell)
– Git + Git LFS
– Python 3.11+
– Optional: CUDA Toolkit (Windows) bzw. NVIDIA‑Treiber + CUDA (Linux) für GPU‑Training

Tipp (Windows): Für stabile Linux‑Workflows lohnt sich WSL2 (Ubuntu) mit NVIDIA CUDA‑Unterstützung.

1) Installationen

1.1 VS Code Erweiterungen

Installiere in VS Code:

• Python (Microsoft)
• Jupyter (Microsoft)
• Continue (by Continue)
• Hugging Face (LLM / Playground)

1.2 Ollama installieren

Windows (Installer von ollama.com verwenden) und Dienst starten.
Linux (Debian 12, als Root oder via sudo):

curl -fsSL https://ollama.com/install.sh | sh

Service prüfen:

ollama --version
ollama list

1.3 Git LFS aktivieren

git lfs install

2) Python‑Umgebung für Fine‑Tuning

Projektordner anlegen, Python‑Umgebung aufsetzen, Kernpakete installieren.

Windows (PowerShell):

cd C:\pfad\zu\projekt
py -3.11 -m venv .venv
.\.venv\Scripts\Activate.ps1
python -m pip install --upgrade pip
pip install transformers accelerate datasets peft trl bitsandbytes sentencepiece

Debian 12:

sudo apt update && sudo apt install -y python3.11-venv python3-pip git
mkdir -p ~/projekt && cd ~/projekt
python3.11 -m venv .venv
source .venv/bin/activate
python -m pip install --upgrade pip
pip install transformers accelerate datasets peft trl bitsandbytes sentencepiece

Hinweise:
• GPU: bitsandbytes nutzt CUDA; achte auf passende NVIDIA‑Treiber/CUDA.
• CPU‑Fallback: Entferne bitsandbytes, wenn keine GPU verfügbar ist.

3) Hugging Face Zugang einrichten

CLI‑Login (für private Modelle/Uploads):

pip install huggingface_hub
huggingface-cli login

Optional: Repo für Adapter/Artefakte vorbereiten (öffentlich oder privat).

4) Workspace‑Struktur

projekt/
  data/                 # Datensätze (CSV/JSONL/Parquet)
  scripts/
    train_sft.py        # Trainingsskript (SFT + QLoRA)
  output/
    adapter/            # LoRA/QLoRA Adapter-Ergebnis
  Modelfile             # Für Ollama (ADAPTER)
  continue-config.json  # Continue-Konfiguration (VS Code)
  requirements.txt

Optional: Notebook (notebooks/finetune.ipynb) für interaktive Runs.

5) Datensatz vorbereiten

Beispiel: JSONL mit Instruktionsdaten (input → output). Minimalformat:

{"instruction": "Frage...", "input": "Kontext...", "output": "Antwort..."}

Konvertiere/valdiere Daten; bei freien Textaufgaben genügt oft ein Feld „text“ mit Dialog‑ oder QA‑Beispielen. Nutze datasets.load_dataset, um CSV/JSONL elegant zu laden.

6) Trainingsskript (SFT + QLoRA)

Beispiel (scripts/train_sft.py). Passt Base‑Modell, Hyperparameter und Datenpfade an.

import os
from datasets import load_dataset
from transformers import AutoTokenizer
from trl import SFTTrainer, SFTConfig
from peft import LoraConfig

BASE_MODEL = os.getenv("BASE_MODEL", "mistralai/Mistral-7B-Instruct-v0.3")
DATA_PATH = os.getenv("DATA_PATH", "data/train.jsonl")
OUTPUT_DIR = os.getenv("OUTPUT_DIR", "output/adapter")

tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL, use_fast=True)

ds = load_dataset("json", data_files=DATA_PATH, split="train")

def formatting_func(example):
    if "text" in example:
        return example["text"]
    instr = example.get("instruction", "")
    inp = example.get("input", "")
    out = example.get("output", "")
    if inp:
        prompt = f"Instruction: {instr}\nInput: {inp}\nAnswer: {out}"
    else:
        prompt = f"Instruction: {instr}\nAnswer: {out}"
    return prompt

lora = LoraConfig(
    r=16,
    lora_alpha=32,
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM",
)

cfg = SFTConfig(
    output_dir=OUTPUT_DIR,
    num_train_epochs=1,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    learning_rate=2e-4,
    logging_steps=10,
    save_steps=200,
    bf16=True,
    dataset_text_field=None,
    packing=False,
    max_seq_length=2048,
)

trainer = SFTTrainer(
    model=BASE_MODEL,
    tokenizer=tokenizer,
    train_dataset=ds,
    peft_config=lora,
    formatting_func=formatting_func,
    args=cfg,
)

trainer.train()
trainer.model.save_pretrained(OUTPUT_DIR)
tokenizer.save_pretrained(OUTPUT_DIR)

Start Training (Beispiel):

BASE_MODEL=mistralai/Mistral-7B-Instruct-v0.3 \
DATA_PATH=data/train.jsonl \
OUTPUT_DIR=output/adapter \
python scripts/train_sft.py

Tipps:
• Für sehr kleine GPUs: reduziere max_seq_length, Batch‑Größen, aktiviere 4‑Bit (bnb 4‑bit) im LLM‑Load.
• Alternative: Unsloth/QLoRA für besonders speichereffizientes Training.

7) Ergebnis prüfen (lokal)

Schneller Smoke‑Test (reines HF‑Inference mit Adapter):

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel

base = "mistralai/Mistral-7B-Instruct-v0.3"
adapter_dir = "output/adapter"

tok = AutoTokenizer.from_pretrained(base)
model = AutoModelForCausalLM.from_pretrained(base, device_map="auto")
model = PeftModel.from_pretrained(model, adapter_dir)

prompt = "Fasse die Bedeutung von Fine‑Tuning in 2 Sätzen zusammen."
inputs = tok(prompt, return_tensors="pt").to(model.device)
out = model.generate(**inputs, max_new_tokens=128)
print(tok.decode(out[0], skip_special_tokens=True))

8) Adapter in Ollama nutzen

Variante A (empfohlen): ADAPTER im Modelfile referenzieren.

Modelfile (im Projektwurzelordner):

FROM mistral:7b-instruct
PARAMETER num_ctx 8192
ADAPTER ./output/adapter
SYSTEM Du bist ein hilfreicher, knapper Assistent.

Erstellen und laufen lassen:

ollama create my-mistral-sft -f Modelfile
ollama run my-mistral-sft

Hinweise:
• Pfad hinter ADAPTER zeigt auf den LoRA/QLoRA‑Adapter‑Ordner (oder Binärdatei, je nach Tooling).
• Falls dein Adapter in Binärform (gguf/ggml) vorliegt, ebenfalls per ADAPTER referenzieren.

Variante B: Merge (vollständige Gewichte) → ggf. Konvertierung nach GGUF und dann FROM auf dein GGUF‑Artefakt. Diese Variante ist speicher‑ und zeitintensiver; nutze sie nur, wenn ADAPTER nicht reicht.

9) Continue (VS Code) mit Ollama verbinden

Continue‑Seitenleiste öffnen → Zahnrad → Konfiguration bearbeiten. Beispiel‑config (continue-config.json):

{
  "models": [
    {
      "title": "Local SFT",
      "provider": "ollama",
      "model": "my-mistral-sft",
      "apiBase": "http://127.0.0.1:11434"
    }
  ],
  "allowAnonymousTelemetry": false
}

Funktionen:
• Chat im Editor (Dateikontext)
• Inline‑Vervollständigungen
• Slash‑Befehle (z. B. /explain, /tests)

Optional: Zweites Modell (z. B. „base“) parallel eintragen und pro Aufgabe umschalten.

10) Hugging Face VS Code (Playground)

• In der Command Palette „Llm: Login“ ausführen und HF‑Token eingeben.
• Modelle vom Hub ausprobieren (Inference API) oder lokalen Endpunkt verwenden.
• Für eigene, private Adapter/Repos: in der Extension anmelden, dann Modelle/Spaces durchsuchen.

11) Typische Fehler & Lösungen

• CUDA/VRAM‑Fehler: Batch kleiner, seq‑length kleiner, 4‑Bit nutzen, Gradient Accumulation erhöhen.
• Langsame I/O: Datensatz lokal cachen (HF Datasets Cache), num_proc beim Preprocessing verwenden.
• Mismatch Chat‑Vorlage: Achte auf Prompt‑Template des Base‑Modells; ggf. TEMPLATE im Modelfile anpassen.
• Adapter wird von Ollama nicht geladen: Pfad prüfen, Dateirechte prüfen; notfalls Binär‑Adapter (gguf/ggml) verwenden.
• Continue sieht das Modell nicht: Läuft Ollama (Port 11434)? Model‑Name exakt? config.json korrekt?

12) Lizenz & Sicherheit

• Prüfe die Lizenz des Base‑Modells (kommerzieller Einsatz).
• Anonymisiere Trainingsdaten (DSGVO).
• Nutze getrennte Umgebungen für Training (HF/PEFT) und Serving (Ollama).

13) Schnell‑Checkliste

1. VS Code + Extensions installiert
2. Python‑Env + HF‑Pakete installiert
3. HF Login + Git LFS aktiv
4. Datensatz sauber
5. Training (SFT/QLoRA) → output/adapter
6. Modelfile mit ADAPTER
7. ollama create + run
8. Continue → Modell auswählen und im Editor nutzen

Fertig.