Voraussetzungen

Hardware:

• Für vollständiges Fine-Tuning benötigt man sehr viel VRAM.
• Sehr kleine Modelle (z.B. 0.5B) benötigen schon 10-12 GB VRAM
• Und kleine Modelle (z.B. 7B) brauchen bereits 40–60 GB VRAM.
• Für LoRA/QLoRA reichen oft schon 12–24 GB VRAM für kleine Modelle.

🔎 Faustformel für Speicherbedarf

Grobformel (pro Schritt, pro Gerät/GPU):

Speicher ≈ Batch_Size × max_length × Modellgröße-Faktor × 4 Byte × Sicherheitsfaktor

Aufgeschlüsselt:

📐 Beispiel Qwen3-0.6B (600 Mio Parameter)

• Parameterzahl: 0,6 Milliarden
• Modellgröße-Faktor ≈ 1,2 bis 1,5 Milliarden (wegen Zwischenspeicherungen/Layer-States)
• 1,5B × 4 Byte ≈ 6 GB theoretischer Bedarf (nur Modell)

👉 Aber:

• Das Modell selbst ist nur einmal im Speicher.
• Der Batch multipliziert sich mit der Aktivierungsspeicherung und Gradienten.

🔢 Beispiel mit Werten aus der Praxis

Batch_Size = 2
max_length = 253
Modellgröße-Faktor ≈ 1,5e9
Precision = bf16 → 2 Byte
Sicherheitsfaktor ≈ 1.5 (wegen Gradient, Optimizer, Sampler usw.)

Berechnung:

Speicher ≈ 2 × 253 × 1,5e9 × 2 Byte × 1.5

Das gibt:

≈ 2 × 253 × 1.5e9 × 2 × 1.5
≈ 2 × 253 × 3e9
≈ 1.518e12 Bytes
≈ 1.518 TB → unrealistisch!

Warum?
Die einfache Formel überschätzt, weil sie davon ausgeht, dass jede Kombination von Batch × Länge × Modellparametern separat gespeichert werden muss (was nicht stimmt).

🧠 Realistischere Faustregel (transformers + PyTorch)

In der Praxis gilt für Causal LM Training:

Speicherverbrauch ≈ Basismodell (6 GB bei 0.6B) +
                   Batch_Size × max_length × 0.001 bis 0.005 GB

🔎 Beispiel konkret:

Gesamt: ≈ 8,5–9 GB
(0.003 ist erfahrungsbasiert für Qwen3 + bf16 + Trainer.)
(Speicherbedarf während des Full-Fine-Tunings war ~7,4 GB → sehr plausibel!)

🔥 Kurzformel VRAM Bedarf

Speicher (GB) ≈ 6 + (Batch_Size × max_length × 0.003) + 1

Speicherbedarf reduzieren

Um den Speicherbedarf eines gegebenen Modells zu reduzieren, haben Sie zwei Stellschrauben zur Verfügung: Zum einen die Batch_Size und zum anderen die max_length. Die Reduzierung der Batch_Size führt zu einem deutlich längeren Trainingslauf. Um die max_length zu verkleinern, ist eine Aufbereitung des Trainingsdatensatzes notwendig.

Für Datensätze, die für Modelle der Qwen-Reihe verwendet werden, wurde ein Python-Skript erstellt, das die Token zählt und die Datensätze, die unter einem angegebenen Schwellwert liegen, in einer neuen Datei speichert.

# token_length_analyse_tool.py Tokens zaehlen und aussortieren

from transformers import AutoTokenizer
import json
import argparse

def analyse_token_lengths(input_file, model_path, output_file=None, max_output_tokens=None):
    tokenizer = AutoTokenizer.from_pretrained(model_path, trust_remote_code=True)

    with open(input_file, "r", encoding="utf-8") as f:
        data = json.load(f)

    bins = {128: 0, 256: 0, 512: 0, 1024: 0, 2048: 0, 4096: 0}
    total_examples = 0
    max_tokens_found = 0
    filtered = []

    for item in data:
        # 👇 Erkennen, ob "messages" oder "question"/"answer"
        if "messages" in item:
            chat = ""
            for msg in item["messages"]:
                role = msg.get("role", "").strip()
                content = msg.get("content", "").strip()
                chat += f"<|im_start|>{role}\n{content}<|im_end|>\n"
        else:
            question = item.get("question", "")
            answer = item.get("answer", "")
            chat = f"<|im_start|>user\n{question}<|im_end|>\n<|im_start|>assistant\n{answer}<|im_end|>\n"

        total_tokens = len(tokenizer(chat)["input_ids"])
        total_examples += 1
        max_tokens_found = max(max_tokens_found, total_tokens)

        for limit in bins:
            if total_tokens <= limit:
                bins[limit] += 1

        if max_output_tokens and total_tokens <= max_output_tokens:
            filtered.append(item)

    print(f"Gesamtzahl der Beispiele: {total_examples}")
    print(f"Längster Eintrag hat {max_tokens_found} Tokens.\n")

    for limit in sorted(bins):
        prozent = bins[limit] / total_examples * 100
        print(f"≤ {limit} Tokens: {bins[limit]} Beispiele ({prozent:.1f}%)")

    if output_file and max_output_tokens:
        with open(output_file, "w", encoding="utf-8") as out_f:
            json.dump(filtered, out_f, indent=2, ensure_ascii=False)
        print(f"\n✅ {len(filtered)} Beispiele mit ≤ {max_output_tokens} Tokens gespeichert in {output_file}")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Tokenlängen-Analyse mit optionalem Speichern kurzer Beispiele.")
    parser.add_argument("--input_file", type=str, required=True)
    parser.add_argument("--model_path", type=str, required=True)
    parser.add_argument("--output_file", type=str, default=None)
    parser.add_argument("--max_output_tokens", type=int, default=None)

    args = parser.parse_args()
    analyse_token_lengths(
        input_file=args.input_file,
        model_path=args.model_path,
        output_file=args.output_file,
        max_output_tokens=args.max_output_tokens
    )

Starten mit:

python3 token_length_analyse_tool.py --input_file synthetic_latex_tables.json --model_path /home/user/Qwen3  --output_file latex_table_small.json --max_output_tokens 256

Gesamtzahl der Beispiele: 1000
Längster Eintrag hat 646 Tokens.

≤ 128 Tokens: 0 Beispiele (0.0%)
≤ 256 Tokens: 63 Beispiele (6.3%)
≤ 512 Tokens: 911 Beispiele (91.1%)
≤ 1024 Tokens: 1000 Beispiele (100.0%)
≤ 2048 Tokens: 1000 Beispiele (100.0%)
≤ 4096 Tokens: 1000 Beispiele (100.0%)

✅ 63 Beispiele mit ≤ 256 Tokens gespeichert in latex_table_small.json

Vorbereitung Full Finetuning

🖥️ 1. Vorbereitung des Servers

🔹 1.1. Notwendige Pakete installieren

Zuerst aktualisieren wir das System und installieren grundlegende Abhängigkeiten:

sudo apt update && sudo apt upgrade -y
sudo apt install -y python3 python3-venv python3-pip git wget unzip curl

Falls noch nicht vorhanden, installiere NVIDIA-Treiber und CUDA:

sudo apt install -y nvidia-driver-xxx
sudo apt install -y cuda-toolkit-12-0

🔹 1.2. NVIDIA- und CUDA-Version prüfen

nvidia-smi  # Zeigt verfügbare GPUs an
nvcc --version  # Prüft die CUDA-Version

Falls CUDA noch nicht aktiv ist:

export PATH=/usr/local/cuda-12.0/bin:$PATH
export LD_LIBRARY_PATH=/usr/local/cuda-12.0/lib64:$LD_LIBRARY_PATH

🐍 2. Erstellen einer Python-Umgebung

Erstelle eine virtuelle Umgebung für das Training:

python3 -m venv ~/qwen3-finetune
source ~/qwen3-finetune/bin/activate

Installiere die benötigten Python-Pakete:

pip install --upgrade pip
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
pip install transformers datasets accelerate bitsandbytes peft gradio

📦 3. Modell herunterladen

Für das Training nutzen wir ein kompaktes Modell wie Qwen3-0.6B:

mkdir -p /user/Qwen3
cd /user/Qwen3
wget https://huggingface.co/Qwen/Qwen3-0.6B/resolve/main/config.json
wget https://huggingface.co/Qwen/Qwen3-0.6B/resolve/main/generation_config.json
wget https://huggingface.co/Qwen/Qwen3-0.6B/resolve/main/merges.txt
wget https://huggingface.co/Qwen/Qwen3-0.6B/resolve/main/model.safetensors
wget https://huggingface.co/Qwen/Qwen3-0.6B/resolve/main/tokenizer.json
wget https://huggingface.co/Qwen/Qwen3-0.6B/resolve/main/tokenizer_config.json
wget https://huggingface.co/Qwen/Qwen3-0.6B/resolve/main/vocab.json

🔢 4. Trainer aus der Praxis

# 🚀 tabular_trainer_corrected.py – Fine-Tuning für Qwen3-0.6B (Tabellenumgebung (Standard))

import torch
from transformers import (
    AutoModelForCausalLM,
    AutoTokenizer,
    TrainingArguments,
    Trainer,
    DataCollatorForLanguageModeling,
)
from datasets import load_dataset

MODEL_PATH = "/home/user/Qwen3"
DATA_PATH = "/home/user/datasets/tabular_messages.json"
OUTPUT_PATH = "/home/user/tabular_qwen3_results"

model = AutoModelForCausalLM.from_pretrained(
    MODEL_PATH,
    torch_dtype=torch.bfloat16 if torch.cuda.is_available() else torch.float32,
    device_map="auto"
)

tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, trust_remote_code=True)
tokenizer.pad_token = tokenizer.eos_token

dataset = load_dataset("json", data_files=DATA_PATH, split="train")
split = dataset.train_test_split(test_size=0.1, seed=42)
train_dataset = split["train"]
eval_dataset = split["test"]

def tokenize_function(examples):
    input_texts, label_texts = [], []

    for messages in examples["messages"]:
        if not messages:
            continue
        chat = ""
        for msg in messages:
            role = msg.get("role", "").strip()
            content = msg.get("content", "").strip()
            if not role or not content:
                continue
            chat += "<|im_start|>" + role + "\\n" + content + "<|im_end|>\\n"

        assistant_start = chat.find("<|im_start|>assistant\\n")
        if assistant_start == -1:
            continue

        input_part = chat[:assistant_start] + "<|im_start|>assistant\\n"
        response_part = chat[assistant_start + len("<|im_start|>assistant\\n"):].strip()
        if not response_part:
            continue

        input_texts.append(input_part)
        label_texts.append(response_part + tokenizer.eos_token)

    if not input_texts:
        return {}

    model_inputs = tokenizer(input_texts, truncation=True, padding="max_length", max_length=256)
    with tokenizer.as_target_tokenizer():
        labels = tokenizer(label_texts, truncation=True, padding="max_length", max_length=256)["input_ids"]

    labels = [
        [-100 if token == tokenizer.pad_token_id else token for token in label_seq]
        for label_seq in labels
    ]

    model_inputs["labels"] = labels
    return model_inputs

train_dataset = train_dataset.map(tokenize_function, batched=True, remove_columns=["messages"], num_proc=4)
eval_dataset = eval_dataset.map(tokenize_function, batched=True, remove_columns=["messages"], num_proc=4)

collator = DataCollatorForLanguageModeling(tokenizer=tokenizer, mlm=False)

args = TrainingArguments(
    output_dir=OUTPUT_PATH,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=8,
    bf16=True,
    num_train_epochs=5,
    logging_steps=10,
    save_strategy="epoch",
    eval_strategy="epoch",
    learning_rate=2e-5,
    warmup_ratio=0.1,
    lr_scheduler_type="cosine",
    remove_unused_columns=False,
    report_to="none"
)

trainer = Trainer(
    model=model,
    args=args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    data_collator=collator,
)

trainer.train()
trainer.save_model(OUTPUT_PATH)
tokenizer.save_pretrained(OUTPUT_PATH)
print("✅ Fine-Tuning abgeschlossen:", OUTPUT_PATH)

Starten mit: CUDA_VISIBLE_DEVICES=0 python3 tabular_trainer_corrected.py

Vorbereitung auf das Finetuning Lora

• Basismodell: TinyLlama, Mistral, Phi-2
• Python-Pakete: transformers, datasets, peft, bitsandbytes
• Hardware: 12–24 GB VRAM für LoRA empfohlen

pip install transformers datasets peft bitsandbytes unsloth 

Praxis: Finetuning mit LoRA

Wenn nur vergleichsweise kleine Grafikkarten zur Verfügung stehen, wird bei LoRA das Programm unsloth (unsloth.ai) verwendet, da es teilweise deutliche Einsparungen beim benötigten VRAM-Speicher bietet.

🔢 Trainer aus der Praxis

# Neu_Coder_1-5B_train_qwen.py
import os
import json
import torch
from unsloth import FastLanguageModel
from peft import LoraConfig, get_peft_model
from transformers import AutoTokenizer, TrainingArguments, Trainer
from datasets import Dataset

# 1️⃣ 🚀 GPU-Check
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"🚀 Using device: {device}")

# 2️⃣ 🔥 Modell & Tokenizer laden
MODEL_PATH = "/home2/mike/Qwen2.5-Coder-1.5B"
tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)

# 3️⃣ 🔥 LaTeX-Spezialtokens hinzufügen
SPECIAL_TOKENS = [
    "\\frac", "\\sum", "\\int", "\\begin{align}", "\\end{align}",
    "\\begin{equation}", "\\end{equation}", "\\begin{tabular}", "\\end{tabular}",
    "\\hline", "\\multicolumn", "\\includegraphics", "\\ce{}", "\\chemfig{}",
    "\\begin{itemize}", "\\end{itemize}", "\\begin{frame}", "\\end{frame}",
]
num_added_tokens = tokenizer.add_tokens(SPECIAL_TOKENS)
print(f"✅ {num_added_tokens} neue LaTeX-Spezialtokens hinzugefügt!")

# 4️⃣ 🔥 Tokenizer speichern
tokenizer.save_pretrained("/home2/mike/Qwen2.5-Coder-1.5B-LaTeX-Finetuned/tokenizer")

# 5️⃣ 🔥 Modell mit QLoRA laden
model, _ = FastLanguageModel.from_pretrained(
    model_name=MODEL_PATH,
    load_in_4bit=True,
    max_seq_length=2048,
    attn_implementation="flash_attention_2",
    device_map="auto",  # 🔥 Automatische Multi-GPU-Zuweisung
)

# 🔥 LoRA-Adapter konfigurieren
lora_config = LoraConfig(
    r=8,
    lora_alpha=16,
    lora_dropout=0.05,
    bias="none",
    target_modules=["q_proj", "v_proj"],  # Optimiert für Qwen
)

# 🔥 QLoRA aktivieren (Fix)
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()

# 6️⃣ 🔥 Trainingsdaten laden
DATASET_PATH = "/home2/mike/combined_latex_data.json"
with open(DATASET_PATH, "r", encoding="utf-8") as f:
    raw_data = json.load(f)

# 7️⃣ 🔥 Dataset formatieren
dataset = Dataset.from_list(raw_data)
dataset = dataset.shuffle(seed=42)
print(f"📌 Beispiel-Datensatz: {dataset[0]}")

def tokenize_function(examples):
    questions = [q if isinstance(q, str) and q.strip() else "Was ist LaTeX?" for q in examples["question"]]
    answers = [a if isinstance(a, str) and a.strip() else "LaTeX ist ein Textsatzsystem." for a in examples["answer"]]

    return tokenizer(
        questions,
        text_target=answers,
        truncation=True,
        padding="max_length",
        max_length=512
    )

# 8️⃣ 🔥 Tokenisierung
dataset = dataset.map(tokenize_function, batched=True, remove_columns=["question", "answer"])

# 9️⃣ 🔥 Trainings- & Testdaten splitten
split = dataset.train_test_split(test_size=0.2)
train_dataset, eval_dataset = split["train"], split["test"]

# 🔟 🔥 Trainingsparameter
training_args = TrainingArguments(
    output_dir="Qwen2.5-Coder-1.5B-LaTeX-Finetuned",
    evaluation_strategy="steps",
    eval_steps=500,
    save_strategy="epoch",
    per_device_train_batch_size=64,
    per_device_eval_batch_size=64,
    gradient_checkpointing=True,
    gradient_accumulation_steps=16,
    num_train_epochs=3,
    save_total_limit=2,
    logging_dir="./logs",
    logging_steps=100,
    learning_rate=5e-5,
    weight_decay=0.01,
    fp16=False,
    bf16=True,
    push_to_hub=False,
    report_to="none",
    remove_unused_columns=False,
)

# 🔥 Trainer definieren
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=eval_dataset,
    tokenizer=tokenizer,
)
# Stelle sicher, dass LoRA-Gewichte Gradient-Berechnung aktiv haben
#for param in model.parameters():
 #   param.requires_grad = True


# Stelle sicher, dass nur trainierbare LoRA-Parameter Gradienten haben
for param in model.parameters():
    if param.dtype in [torch.float16, torch.float32, torch.bfloat16]:  # ✅ Nur Gleitkommazahlen
        param.requires_grad = True


# 🔥 Fine-Tuning starten!
trainer.train()

# 🔥 Speichern des trainierten Modells
trainer.save_model("Qwen2.5-Coder-1.5B-LaTeX-Finetuned")
print("✅ Training abgeschlossen & Modell gespeichert!")

Jetzt: Dataset laden, Tokenisieren und Training starten!

Vergleich: Vollständiges Finetuning vs. LoRA

🧠 Grundidee: Mixture of Experts (MoE)

• Statt eines großen Monolith-Modells (z. B. 7B) → mehrere kleine Modelle (z. B. 8×0.6B)
• Bei jeder Inferenz (Anfrage) wird nur ein Teil der Experten aktiviert (z. B. 2 von 8)
• Router-Modul entscheidet, welcher Experte für welche Token zuständig ist
• Vorteile: schneller, skalierbarer, sparsamer in GPU-Ressourcen

🛠️ Beispiel Anwendung

• 🧱 Eine Basisstruktur für:

  • 1 Router-Modell
  • 3 Fine-Tuned Expertenmodelle
  • gemeinsames Interface

• 🖥️ Gradio-Frontend, das je nach Eingabe automatisch den passenden Experten anspricht

  
  # 🌐 gradio_router_qwen3.py – Web-Oberfläche für den Qwen3-Router
  
  from transformers import AutoModelForCausalLM, AutoTokenizer
  import torch
  import gradio as gr
  
  DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
  
  experts = {
      "math": "/home/user/math_qwen3_results/checkpoint-228",
      "tabular": "/home/user/tabular_qwen3_results/checkpoint-228",
      "biblatex": "/home/user/biblatex_qwen3_results/checkpoint-228",
  }
  
  models = {}
  tokenizers = {}
  for name, path in experts.items():
      print(f"🔹 Lade {name}...")
      models[name] = AutoModelForCausalLM.from_pretrained(path, device_map="auto", torch_dtype=torch.bfloat16)
      tokenizers[name] = AutoTokenizer.from_pretrained(path, trust_remote_code=True)
      tokenizers[name].pad_token = tokenizers[name].eos_token
  
  def route(question):
      q = question.lower()
      if any(k in q for k in ["cite", "bibliography", "biblatex", "isbn", "literaturverzeichnis", "zitat"]):
          return "biblatex"
      if any(k in q for k in ["table", "tabelle", "tabellen", "spalten", "zeilen", "tabular", "column", "row"]):
          return "tabular"
      if any(k in q for k in ["frac", "sum", "equation", "integral", "math", "bruch", "summe", "gleichung"]):
          return "math"
      return None
  
  def build_prompt(question):
      return f"""<|im_start|>system
  Du bist ein hilfsbereiter LaTeX-Assistent.<|im_end|>
  <|im_start|>user
  {question}<|im_end|>
  <|im_start|>assistant
  """
  
  def ask_expert(expert_name, question):
      model = models[expert_name]
      tokenizer = tokenizers[expert_name]
      prompt = build_prompt(question)
      inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
  
      with torch.no_grad():
          outputs = model.generate(
              **inputs,
              max_new_tokens=512,
              do_sample=False,
              temperature=0.7,
              top_k=50,
              top_p=0.95,
              eos_token_id=tokenizer.eos_token_id
          )
  
      decoded = tokenizer.decode(outputs[0], skip_special_tokens=False)
      start = decoded.find("<|im_start|>assistant\n") + len("<|im_start|>assistant\n")
      answer = decoded[start:].split("<|im_end|>")[0].strip()
      return answer
  
  def router_interface(user_input):
      expert = route(user_input)
      if expert:
          response = ask_expert(expert, user_input)
          return f"🔁 Experte: {expert}\n\n📤 Antwort:\n{response}"
      return "🤷‍♂️ Kein passender Experte gefunden."
  
  demo = gr.Interface(
      fn=router_interface,
      inputs=gr.Textbox(lines=3, label="Deine LaTeX-Frage"),
      outputs=gr.Textbox(label="Antwort"),
      title="Qwen3 Router – Multi-Experten-Assistent",
      description="Stellt Fragen zu LaTeX! Der Router entscheidet automatisch, welcher Experte (math, tabular, biblatex) antwortet."
  )
  
  if __name__ == "__main__":
      demo.launch(server_name="127.0.0.1", server_port=7860)  # Für lokalen Zugriff
  

🛠️ Paralleles Training

Wenn der verwendete Rechner mehrere Grafikkarten zur Verfügung hat, können mehrere Modelle parallel trainiert werden. Insbesondere bei sehr kleinen Modellen, wie zum Beispiel Qwen3-0.6B, lässt sich die Trainingszeit auf diese Weise deutlich reduzieren.

Auf dem Testrechner standen 4 NVIDIA GeForce GTX TITAN X zur Verfügung, sodass alle drei Trainer parallel arbeiten konnten. Der Start des Trainings erfolgt mit den folgenden Befehlen:

CUDA_VISIBLE_DEVICES=0 python3 math_trainer_corrected.py &
CUDA_VISIBLE_DEVICES=1 python3 tabular_trainer_corrected.py &
CUDA_VISIBLE_DEVICES=2 python3 biblatex_trainer_corrected.py 

Dabei wird CUDA_VISIBLE_DEVICES=Nummer verwendet, um eine bestimmte Grafikkarte einem bestimmten Trainer zuzuordnen.

Nach dem Training wurde das Webinterface gestartet und das Ergebnis getestet:

CUDA_VISIBLE_DEVICES=0 python3 gradio_router_qwen3.py

Übungen

1. Wähle ein kleines Modell und tune es mit einem eigenen Mini-Dataset.
2. Vergleiche Antworten vor und nach dem Finetuning.

Zusammenfassung

• Finetuning macht LLMs anpassungsfähig.
• LoRA/QLoRA spart Speicher und Zeit.
• MoE fassen mehrere kleine LLMs zu einem großen zusammen.
• Gute Datensätze sind wichtiger als große.

Besser 500 hochwertige Beispiele als 50.000 schlechte!

Warum sind Datensätze wichtig?

LLMs lernen ausschließlich durch Beispiele. Die Qualität der Daten bestimmt direkt die Qualität des Modells.

Garbage in - Garbage out!

Datenarten für LLMs

Tipp: Für kleine Projekte reichen oft Instruktionsdatensätze.

Quellen für Datensätze

• Open-Source: Alpaca, Dolly, OpenAssistant (Lizenz prüfen!)
• Eigene Erstellung: Vollständig angepasst, aber aufwendiger
• Aufbereitung eigener Daten: FAQs, Support-Daten etc.

🔥 Optimales Verhältnis zwischen echten und synthetischen Daten für ein LLM

Das Verhältnis zwischen realen Daten und synthetischen Daten hängt stark vom Ziel des Modells ab. Je nachdem, was Ihr Fine-Tuning erreichen soll, kann das Verhältnis variieren.

📌 1️⃣ Wichtige Faktoren für die Mischung

✅ Echte Daten

• Enthalten reale Fehler & Workarounds → wichtig für echte Nutzerfragen
• Zeigen echte Struktur & Stil → z. B. Mathematik, Dokumente
• Sind begrenzt verfügbar

✅ Synthetische LaTeX-Daten

• Erlauben vollständige Kontrolle über Syntax & Struktur
• Können spezielle Edge-Cases abdecken (z. B. seltene Aufgaben / Fragen)
• Vermeiden Tippfehler & schlechte Praktiken → Modell lernt "saubere" Version

💡 Ziel: Eine Kombination aus beidem, um ein möglichst robustes Modell zu erhalten.

🔥 2️⃣ Optimale Verhältnisse für verschiedene Modelle

Je nach Ziel des Modells gibt es unterschiedliche empfohlene Mischverhältnisse, hier als Beispiel bei einem LaTeX ChatBot:

In Fall eines LaTeX-Kurs-Chatbot wäre 50% echte Daten + 50% synthetische Daten eine sehr gute Mischung. 🚀

Soll das LLM nur Beispiele generieren, können 100% synthetische Daten verwendet werden. Je mehr Interaktion zwischen Modell und Nutzer stattfindet, desto mehr reale Daten werden benötigt.

Eigene Datensätze erstellen

1. Thema wählen (z.B. Nachhaltigkeit)
2. Aufgaben formulieren (klar, realistisch)
3. Antworten schreiben (präzise, vollständig)
4. Format speichern (JSON oder JSONL)

{
  "instruction": "Nenne drei Vorteile von Solarenergie.",
  "input": "",
  "output": "Solarenergie ist umweltfreundlich, erneuerbar und senkt Energiekosten."
}

Hinweis: Der Aufbau der Daten unterscheidet sich zwischen den verschiedenen Modellfamilien, sodass der Datensatz für andere Modellfamilien in der Regel überarbeitet bzw. konvertiert werden muss.

Qwen Daten Format Aufbau

[
  {
    "messages": [
      {
        "role": "user",
        "content": "Frage oder Aufgabe"
      },
      {
        "role": "assistant",
        "content": "Eine Erklärung / Antwort oder Beispiel zu der Frage."
      }
    ]
  }
]

Tipp: Aufgaben und Antworten leicht variieren, um Überanpassung zu vermeiden!

Einfluss der Datenqualität

Qualitätsmerkmale: Vielfalt, Klarheit, Korrektheit, konsistenter Stil.

Balance und Sampling

Empfohlene Mischung:

• 80–90% einfache Aufgaben (z.B. Verständnisfragen)
• 10–20% komplexe Aufgaben (z.B. Schritt-für-Schritt-Analysen)

Zusätzlich:

• Themenvielfalt sicherstellen
• Regelmäßig Stichproben prüfen
• Lizenzen beachten

Übungen

1. Erstelle ein Mini-Dataset (10–20 Aufgaben + Antworten)
2. Nutze klare Aufgabenstellungen und korrekte Antworten
3. Speichere dein Dataset als JSON
4. (Optional) Teste dein Dataset auf einem LLM

Zusammenfassung

• Datensätze sind entscheidend für gutes Modellverhalten.
• Instruktionsdatensätze eignen sich ideal für den Einstieg.
• Qualität schlägt Quantität.
• Kleine, saubere Datensätze reichen oft völlig aus.

# generator_datensatz_local.py
import requests
import json

# Server-IPs
TEACHER_IP = "localhost"  # oder "127.0.0.1" # Teacher-Server (Mixtral-8x7B)
TEACHER_MODEL = "mixtral:8x7b"

# Basis-Prompts (werden an Mixtral geschickt)
base_prompts = [
    "Wie erstelle ich eine Tabelle in LaTeX?",
    "Was ist der Unterschied zwischen \\textbf{} und \\textit{} in LaTeX?",
    "Wie kann ich eine Grafik in LaTeX einbinden?",
    "Wie erstelle ich eine Matrix in LaTeX?"
]

# Variationen für jede Anfrage (werden nicht an Mixtral geschickt, aber im Datensatz gespeichert)
prompt_variations = {
    "Wie erstelle ich eine Tabelle in LaTeX?": [
        "Wie kann ich eine Tabelle in LaTeX formatieren?",
        "Welche Befehle nutze ich für Tabellen in LaTeX?",
        "Wie kann ich Spalten und Zeilen in LaTeX anpassen?",
        "Wie funktioniert die tabular-Umgebung in LaTeX?",
    ],
    "Was ist der Unterschied zwischen \\textbf{} und \\textit{} in LaTeX?": [
        "Wann sollte ich \\textbf{} anstelle von \\textit{} in LaTeX verwenden?",
        "Gibt es eine Regel für \\textbf{} vs. \\textit{}?",
        "Was sind die Vorteile von \\textbf{} und \\textit{}?",
        "Wie kann ich fette und kursive Schrift in LaTeX kombinieren?",
    ],
    "Wie kann ich eine Grafik in LaTeX einbinden?": [
        "Wie binde ich Bilder in LaTeX-Dokumente ein?",
        "Was ist der beste Weg, um eine Grafik in LaTeX darzustellen?",
        "Welche Pakete brauche ich für Bilder in LaTeX?",
        "Wie kann ich die Größe von Grafiken in LaTeX ändern?",
    ],
    "Wie erstelle ich eine Matrix in LaTeX?": [
        "Wie funktioniert die Matrix-Umgebung in LaTeX?",
        "Welche Matrix-Typen gibt es in LaTeX?",
        "Wie kann ich eine große Matrix in LaTeX setzen?",
        "Was ist der Unterschied zwischen bmatrix und pmatrix?",
    ]
}

# API-Funktion, um Modellantworten zu generieren
def generate_response(prompt):
    """ Sendet Anfrage an Mixtral-8x7B und gibt Antwort zurück """
    url = f"http://{TEACHER_IP}:11434/api/generate"
    data = {"model": TEACHER_MODEL, "prompt": prompt, "stream": False}
    
    try:
        response = requests.post(url, headers={"Content-Type": "application/json"}, json=data)
        response_json = response.json()
        return response_json.get("response", "").strip()
    except Exception as e:
        print(f"⚠ Fehler bei der API-Anfrage für '{prompt}': {e}")
        return None  # Falls die API fehlschlägt, speichern wir nichts

# **Trainingsdaten generieren**
dataset = []

for base_prompt in base_prompts:
    mixtral_response = generate_response(base_prompt)  # Eine Antwort von Mixtral holen
    
    if mixtral_response:  # Nur speichern, wenn die API-Antwort gültig ist
        all_prompts = [base_prompt] + prompt_variations.get(base_prompt, [])  # Basis + Variationen
        
        for prompt in all_prompts:
            dataset.append({
                "messages": [
                    {"role": "system", "content": "Du bist ein hilfreicher Assistent für LaTeX-Fragen."},
                    {"role": "user", "content": prompt},
                    {"role": "assistant", "content": mixtral_response + " <|endoftext|>"}
                ]
            })

# Speichern als JSON-Datei
with open("qwen_training_data.json", "w", encoding="utf-8") as f:
    json.dump(dataset, f, ensure_ascii=False, indent=4)

print(f"✅ Trainingsdaten für Qwen gespeichert in 'qwen_training_data.json' ({len(dataset)} Einträge)")

📚 Modul 6: Eigene Systeme online bringen – Gradio-Apps erstellen [Anfänger/Fortgeschritten]

pip install gradio

import gradio as gr

def antworten(text):
    return "Ihre Eingabe war: " + text

g.Interface(fn=antworten, inputs="text", outputs="text").launch()

from transformers import pipeline
import gradio as gr

model = pipeline("text-generation", model="dein_modell")

def respond(message):
    output = model(message, max_length=200, temperature=0.7)
    return output[0]['generated_text']

g.Interface(fn=respond, inputs="text", outputs="text").launch()

import subprocess

def chatbot(input_text):
    command = f"ollama run mistral \"{input_text}\""
    result = subprocess.run(command, shell=True, capture_output=True, text=True)
    return result.stdout.strip()

📚 Modul 7: Abschlussprojekt – Ihr intelligenter FAQ-Bot [Fortgeschritten]

import gradio as gr
from transformers import pipeline

model = pipeline("text-generation", model="dein_finetuned_model")

def faq_bot(question):
    response = model(question, max_length=200, do_sample=False)
    return response[0]['generated_text']

interface = gr.Interface(fn=faq_bot, inputs="text", outputs="text",
                         title="Mein FAQ-Bot",
                         description="Stelle eine Frage zu [Thema]!")
interface.launch()

✨ Damit haben Sie den vollständigen Prozess von der Idee bis zur Web-App durchlaufen!