{"conversations": [
  {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
  {"role": "user", "content": "Was ist Machine Learning?"},
  {"role": "assistant", "content": "Machine Learning ist ein Teilbereich..."}
]}
{"conversations": [
  {"role": "system", "content": "Du bist ein hilfreicher Assistent."},
  {"role": "user", "content": "Erkläre neuronale Netze."},
  {"role": "assistant", "content": "Neuronale Netze sind..."}
]}

import json
from collections import Counter

def analyze_dataset(jsonl_path):
    """
    Analysiere Trainingsdaten auf häufige Probleme
    """
    with open(jsonl_path, 'r') as f:
        data = [json.loads(line) for line in f]
    
    # Statistiken
    print(f"📊 Gesamt-Beispiele: {len(data)}")
    
    # Token-Längen (approximiert)
    lengths = []
    for example in data:
        text = ' '.join([msg['content'] for msg in example['conversations']])
        lengths.append(len(text.split()))
    
    print(f"📏 Durchschnittliche Länge: {sum(lengths)/len(lengths):.0f} Wörter")
    print(f"📏 Min: {min(lengths)}, Max: {max(lengths)}")
    
    # Duplikate prüfen
    user_prompts = [ex['conversations'][1]['content'] for ex in data]
    duplicates = len(user_prompts) - len(set(user_prompts))
    print(f"⚠️  Duplikate: {duplicates} ({duplicates/len(data)*100:.1f}%)")
    
    # Empfehlungen
    if duplicates > len(data) * 0.1:
        print("❌ WARNUNG: >10% Duplikate - Datensatz bereinigen!")
    if max(lengths) > 4000:
        print("⚠️  Einige Beispiele sehr lang - Context-Window beachten!")
    
analyze_dataset('training_data.jsonl')

# Conda Environment erstellen
conda create -n unsloth python=3.11 -y
conda activate unsloth

# PyTorch mit CUDA
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

# Unsloth installieren (2026 Version)
pip install "unsloth[colab-new] @ git+https://github.com/unslothai/unsloth.git"
pip install --no-deps trl peft accelerate bitsandbytes triton xformers

import torch
from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset

# ═══════════════════════════════════════════════════════════
# 1. MODELL LADEN (4-bit Quantisierung für weniger VRAM)
# ═══════════════════════════════════════════════════════════
model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/Llama-3.2-3B-Instruct",  # oder: mistralai/Mistral-7B-v0.3
    max_seq_length=2048,
    dtype=None,  # Auto-detect
    load_in_4bit=True,  # Reduziert VRAM um ~75%
)

# ═══════════════════════════════════════════════════════════
# 2. LoRA ADAPTER KONFIGURIEREN
# ═══════════════════════════════════════════════════════════
model = FastLanguageModel.get_peft_model(
    model,
    r=16,                # LoRA Rank (8-64, höher = mehr Kapazität)
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj",
                    "gate_proj", "up_proj", "down_proj"],
    lora_alpha=16,
    lora_dropout=0,      # Optimiert für Unsloth
    bias="none",
    use_gradient_checkpointing="unsloth",  # 30% weniger VRAM
    random_state=42,
)

# ═══════════════════════════════════════════════════════════
# 3. DATENSATZ LADEN
# ═══════════════════════════════════════════════════════════
dataset = load_dataset("json", data_files="training_data.jsonl", split="train")

def format_prompts(examples):
    texts = []
    for conv in examples['conversations']:
        text = tokenizer.apply_chat_template(conv, tokenize=False)
        texts.append(text)
    return {"text": texts}

dataset = dataset.map(format_prompts, batched=True)

# ═══════════════════════════════════════════════════════════
# 4. TRAINING STARTEN
# ═══════════════════════════════════════════════════════════
trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,  # Effektive Batch Size: 8
        warmup_steps=10,
        num_train_epochs=3,
        learning_rate=2e-4,
        fp16=not torch.cuda.is_bf16_supported(),
        bf16=torch.cuda.is_bf16_supported(),
        logging_steps=10,
        output_dir="outputs",
        optim="adamw_8bit",
        seed=42,
    ),
)

# Training starten
trainer_stats = trainer.train()
print(f"✅ Training abgeschlossen in {trainer_stats.metrics['train_runtime']:.0f}s")

# Als LoRA Adapter speichern (klein, ~50MB)
model.save_pretrained("lora_model")
tokenizer.save_pretrained("lora_model")

# Für Ollama: Als GGUF exportieren
model.save_pretrained_gguf(
    "model_gguf",
    tokenizer,
    quantization_method="q4_k_m"  # Beste Balance: Qualität/Größe
)

# Modelfile
FROM ./model_gguf/unsloth.Q4_K_M.gguf

PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 4096

SYSTEM """Du bist ein hilfreicher KI-Assistent, spezialisiert auf 
technische Fragen rund um Webentwicklung und Machine Learning."""

# Modell erstellen
ollama create mein-modell -f Modelfile

# Testen
ollama run mein-modell "Erkläre mir Docker in 3 Sätzen"

# API verfügbar unter
curl http://localhost:11434/api/generate -d '{
  "model": "mein-modell",
  "prompt": "Hallo!",
  "stream": false
}'

// lib/ollama.ts
interface OllamaResponse {
  response: string;
  done: boolean;
}

export async function generateText(prompt: string): Promise<string> {
  const response = await fetch('http://localhost:11434/api/generate', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      model: 'mein-modell',
      prompt,
      stream: false,
      options: {
        temperature: 0.7,
        num_predict: 500,
      }
    })
  });
  
  const data: OllamaResponse = await response.json();
  return data.response;
}

// Verwendung
const antwort = await generateText('Was ist TypeScript?');
console.log(antwort);