Einführung in das Fine-Tuning von Open-Source-KI-Modellen

Hallo!

Da Sie hier sind, möchten Sie wahrscheinlich Open-Source-KI-Modelle feinabstimmen, um sie für Ihre eigenen Anwendungsfälle zu nutzen (Chatbots, Coding-Assistenten, Domänenexperten usw.). Hier ist ein leicht verständlicher Leitfaden für Anfänger, der direkt im Kontext von Laravel und der allgemeinen Webentwicklung verwendet werden kann.

1. Was bedeutet „Open-Source-KI-Modell feinabstimmen“?

Fine-Tuning bedeutet, ein bestehendes, vortrainiertes Modell (z. B. LLaMA‑2, Mistral oder ein Modell auf Hugging Face) mit Ihren eigenen Daten leicht weiterzutrainieren, um:

Es an Ihre Domäne anzupassen (Recht, Finanzen, Medizin, Spiele usw.)
Es Ihren Ton und Stil erlernen zu lassen
Bestimmte Aufgaben zu verbessern (QA, Codierung, Klassifizierung, Support usw.)

Anstatt von Grund auf neu zu trainieren (was kostspielig und zeitaufwändig ist), nutzen Sie ein leistungsstarkes Basismodell wieder, um es zu spezialisieren.

2. Wichtige Optionen für das Fine-Tuning

Es gibt drei Hauptansätze, die Sie häufig sehen werden:

2.1 Full Fine-Tuning

Aktualisiert alle Modellgewichte.
Vorteile: Maximale Flexibilität und Leistung.
Nachteile: Benötigt viel GPU, Zeit und Speicher.

Dies ist in der Regel überdimensioniert, es sei denn, Sie sind eine Forschungseinrichtung oder ein großes Unternehmen.

2.2 LoRA / PEFT (Parameter-Efficient Fine-Tuning)

Friert das Basismodell ein und trainiert nur kleine Adapter-Layer (LoRA-Matrizen).
Verwendet Bibliotheken wie:
- PEFT (Hugging Face)
- LoRA paper

Vorteile:

Viel geringere VRAM-Anforderungen
Schneller
Sie können nur die Adapter freigeben, nicht das gesamte Modell

Nachteile:

Etwas weniger ausdrucksstark als Full Fine-Tuning, aber normalerweise ausreichend.

2.3 QLoRA (Quantized LoRA)

Kombiniert Quantisierung (z. B. 4-Bit) mit LoRA:
- Lädt das Basismodell mit geringerer Präzision (int4 oder int8).
- Trainiert LoRA-Adapter darauf.

Vorteile:

Sie können große Modelle mit einer einzigen GPU feinabstimmen (sogar mit einer Consumer-GPU wie 24 GB).
Sehr beliebt für Modelle im LLaMA-Stil.

Für die meisten einzelnen Entwickler zu empfehlen.

3. Auswahl eines Open-Source-Basismodells

Wo Sie Modelle finden:

Beliebte Optionen:

Chat/Assistent:
- mistralai/Mistral-7B-Instruct-v0.2
- meta-llama/Llama-3-8b-instruct (wenn Lizenz und Zugriff für Ihren Anwendungsfall passen)
Code:
- codellama/CodeLlama-7b-Instruct-hf
- deepseek-ai/deepseek-coder-6.7b-instruct

Zu beachten:

Lizenz (kommerziell vs. nicht-kommerziell)
Modellgröße (7B ist ein guter Ausgangspunkt)
Instruction‑tuned vs. base: Wählen Sie für Chatbots ein instruct/chat-Modell.

4. Vorbereiten von Daten für das Fine-Tuning

Das Format Ihrer Daten ist wichtiger als die meisten Leute denken.

4.1 Welche Daten sollten Sie verwenden?

Beispiele:

Kundensupport-Chatprotokolle
FAQ-Dokumente
Knowledge-Base-Artikel
Code-Repositories + Beschreibungen
Domänenspezifische Forschungsarbeiten

Bereinigen Sie Ihre Daten:

Entfernen Sie PII / Geheimnisse (API-Schlüssel, E-Mails, Passwörter).
Entfernen Sie Duplikate ähnlicher Texte.
Beheben Sie offensichtliche Formatierungsprobleme.

4.2 Häufige Anweisungsformate

Für Chatmodelle ist das gebräuchliche Format von Hugging Face:

{
  "instruction": "Erklären Sie kurz, was Fine-Tuning ist.",
  "input": "",
  "output": "Fine-Tuning bedeutet, ein bestehendes, vortrainiertes Modell zu nehmen und es mit Ihren eigenen Daten weiter zu trainieren ..."
}

Oder ein eher Chat-ähnliches Format:

{
  "messages": [
    {"role": "system", "content": "Sie sind ein Assistent, der bei Fragen zur Buchhaltung hilft."},
    {"role": "user", "content": "Wie erfasse ich die Zahlung einer Rechnung?"},
    {"role": "assistant", "content": "Um die Zahlung einer Rechnung zu erfassen, müssen Sie ..."
  ]
}

Speichern Sie dies als .jsonl (ein JSON-Objekt pro Zeile), .json oder als Hugging Face Dataset.

5. Minimales Beispiel: Fine-Tuning mit Hugging Face + LoRA

Im Allgemeinen benötigen Sie:

Python 3.10+
Eine GPU (idealerweise >= 16 GB VRAM für 7B, 24 GB sind komfortabler)
Bibliotheken:
- transformers
- datasets
- peft
- bitsandbytes
- accelerate

5.1 Installation der Abhängigkeiten

pip install "transformers>=4.39.0" "datasets" "accelerate" "peft" "bitsandbytes"

5.2 Einfaches QLoRA-Skript (Konzept)

from datasets import load_dataset
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments, Trainer
from peft import LoraConfig, get_peft_model
import torch

model_name = "mistralai/Mistral-7B-Instruct-v0.2"
dataset_path = "path_or_hf_dataset"  # Beispiel: "my-username/my-dataset"

tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

model = AutoModelForCausalLM.from_pretrained(
    model_name,
    load_in_4bit=True,
    device_map="auto"
)

dataset = load_dataset(dataset_path, split="train")

def format_example(example):
    user = example["instruction"]
    answer = example["output"]
    prompt = f"User: {user}
Assistant:"
    return {"input_ids": tokenizer(prompt, truncation=True, padding="max_length", max_length=512)["input_ids"],
            "labels":    tokenizer(answer, truncation=True, padding="max_length", max_length=512)["input_ids"]}

tokenized = dataset.map(format_example, remove_columns=dataset.column_names)

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

model = get_peft_model(model, lora_config)

training_args = TrainingArguments(
    output_dir="./mistral-finetuned",
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    learning_rate=2e-4,
    num_train_epochs=3,
    fp16=True,
    logging_steps=10,
    save_steps=500,
    save_total_limit=2,
)

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized
)

trainer.train()
model.save_pretrained("./mistral-finetuned-lora")
tokenizer.save_pretrained("./mistral-finetuned-lora")

Dies ist eine vereinfachte Referenz. Für den Produktionseinsatz siehe:

6. Integration eines feinabgestimmten Modells in eine Laravel-Anwendung

Sobald Sie ein feinabgestimmtes Modell haben, müssen Sie es bereitstellen und von Laravel aus aufrufen.

6.1 Verschiedene Möglichkeiten, ein Modell bereitzustellen

FastAPI / Flask Microservice (Python)
- Führen Sie Inferenz mit transformers oder vLLM durch.
- Stellen Sie einen /generate-Endpunkt bereit.
Text Generation Inference (TGI)
- Hugging Face TGI ist für die Bereitstellung von LLMs optimiert.
Ollama (für einige Modelle)
- Ollama läuft unter macOS/Linux und bietet eine einfache HTTP-API.

6.2 Grundlegender Inferenz-Endpunkt (Beispiel Python + FastAPI)

from fastapi import FastAPI
from pydantic import BaseModel
from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

app = FastAPI()

model_name = "./mistral-finetuned-lora"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto"
)

class GenerateRequest(BaseModel):
    prompt: str
    max_new_tokens: int = 256
    temperature: float = 0.7

@app.post("/generate")
def generate(req: GenerateRequest):
    inputs = tokenizer(req.prompt, return_tensors="pt").to(model.device)
    output = model.generate(
        **inputs,
        max_new_tokens=req.max_new_tokens,
        temperature=req.temperature,
        do_sample=True,
        pad_token_id=tokenizer.eos_token_id
    )
    text = tokenizer.decode(output[0], skip_special_tokens=True)
    return {"result": text}

Führen Sie dies auf einer Maschine mit einer GPU aus.

6.3 Aufrufen des Modells von Laravel aus

Verwenden Sie in Laravel Http::post() (aus Illuminate\Support\Facades\Http), um mit dem Python-Dienst zu kommunizieren.

use Illuminate\Support\Facades\Http;

$response = Http::post('http://your-python-host:8000/generate', [
    'prompt' => 'Erklären Sie kurz, was Fine-Tuning ist.',
    'max_new_tokens' => 256,
    'temperature' => 0.7,
]);

 $$result = $$ response->json()['result'] ?? null;

Sie können dies in eine Serviceklasse (z. B. App\Services\AIClient) verpacken und von Ihren Controllern aus aufrufen.

7. Tipps für bessere Fine-Tuning-Ergebnisse

Klein anfangen: Beginnen Sie mit einem 7B-Modell und einem kleinen Datensatz (1k–10k Beispiele).
Konsistente Prompts: Verwenden Sie die gleiche Struktur wie bei der Inferenz.
Häufig evaluieren:
- Erstellen Sie einen kleinen Satz von Evaluierungsfragen.
- Überprüfen Sie die Antworten für jeden Trainingslauf.
Überanpassung vermeiden:
- Verwenden Sie einen Validierungssatz.
- Prüfen Sie, ob das Modell anfängt, sich Dinge zu merken.
Konfiguration dokumentieren:
- LoRA-Rang, Lernrate, Epochen, Datensatzversion.
- Dies hilft Ihnen, gute Läufe zu reproduzieren.

8. Häufige Tools und Frameworks, die es wert sind, erkundet zu werden

Hugging Face Ökosystem
vLLM – High-Throughput Serving: https://github.com/vllm-project/vllm
Axolotl – LLM Fine-tuning Toolkit: https://github.com/OpenAccess-AI-Collective/axolotl
Deepspeed / FSDP für groß angelegtes Training: DeepSpeed

9. Wenn Fine-Tuning nicht erforderlich ist

In einigen Fällen können Sie das Benötigte erreichen durch:

Prompt Engineering (bessere Anweisungen und Beispiele)
RAG (Retrieval‑Augmented Generation) – Füttern externer Dokumente zur Abfragezeit, ohne die Gewichte zu ändern
- Verwenden Sie Haystack, LlamaIndex oder LangChain

RAG ist oft einfacher zu warten und zu aktualisieren als ein vollständiges Fine-Tuning, insbesondere bei sich schnell änderndem Wissen.

10. Nächste Schritte

Wenn Sie gerade erst anfangen:

Wählen Sie ein instruct-Modell von Hugging Face aus.
Erstellen Sie einen kleinen instruction dataset aus Ihrer eigenen Domäne.
Führen Sie mit QLoRA + PEFT einen kurzen Fine-Tuning-Lauf durch.
Stellen Sie das Modell über eine kleine Python-API bereit.
Rufen Sie es von Laravel aus mit Http::post() auf und erstellen Sie eine Schnittstelle.

Lassen Sie mich wissen:

Welche Anwendungsfälle Sie haben (Chatbot, Code-Assistent, internes Tool usw.)
Auf welche Hardware (GPU / RAM) Sie Zugriff haben

Ich kann einen Schritt-für-Schritt-Fine-Tuning-Plan skizzieren, der auf Ihr genaues Setup zugeschnitten ist.

Einführung in das Fine-Tuning von Open-Source-KI-Modellen

1. Was bedeutet „Open-Source-KI-Modell feinabstimmen“?

2. Wichtige Optionen für das Fine-Tuning

2.1 Full Fine-Tuning

2.2 LoRA / PEFT (Parameter-Efficient Fine-Tuning)

2.3 QLoRA (Quantized LoRA)

3. Auswahl eines Open-Source-Basismodells

4. Vorbereiten von Daten für das Fine-Tuning

4.1 Welche Daten sollten Sie verwenden?

4.2 Häufige Anweisungsformate

5. Minimales Beispiel: Fine-Tuning mit Hugging Face + LoRA

5.1 Installation der Abhängigkeiten

5.2 Einfaches QLoRA-Skript (Konzept)

6. Integration eines feinabgestimmten Modells in eine Laravel-Anwendung

6.1 Verschiedene Möglichkeiten, ein Modell bereitzustellen

6.2 Grundlegender Inferenz-Endpunkt (Beispiel Python + FastAPI)

6.3 Aufrufen des Modells von Laravel aus

7. Tipps für bessere Fine-Tuning-Ergebnisse

8. Häufige Tools und Frameworks, die es wert sind, erkundet zu werden

9. Wenn Fine-Tuning nicht erforderlich ist

10. Nächste Schritte

Bonus Posts

So finden Sie eine andere Person mit der WhereAreYou App

1. Was bedeutet „Open-Source-KI-Modell feinabstimmen“?

2. Wichtige Optionen für das Fine-Tuning

2.1 Full Fine-Tuning

2.2 LoRA / PEFT (Parameter-Efficient Fine-Tuning)

2.3 QLoRA (Quantized LoRA)

3. Auswahl eines Open-Source-Basismodells

4. Vorbereiten von Daten für das Fine-Tuning

4.1 Welche Daten sollten Sie verwenden?

4.2 Häufige Anweisungsformate

5. Minimales Beispiel: Fine-Tuning mit Hugging Face + LoRA

5.1 Installation der Abhängigkeiten

5.2 Einfaches QLoRA-Skript (Konzept)

6. Integration eines feinabgestimmten Modells in eine Laravel-Anwendung

6.1 Verschiedene Möglichkeiten, ein Modell bereitzustellen

6.2 Grundlegender Inferenz-Endpunkt (Beispiel Python + FastAPI)

6.3 Aufrufen des Modells von Laravel aus

7. Tipps für bessere Fine-Tuning-Ergebnisse

8. Häufige Tools und Frameworks, die es wert sind, erkundet zu werden

9. Wenn Fine-Tuning nicht erforderlich ist

10. Nächste Schritte

Related Posts

Bonus Posts