GPT-Chat-German/README.md

---
license: mit
language:
- de
base_model: kkirchheim/german-gpt2-medium
tags:
- german
- gpt2
- gpt2-medium
- reasoning
- chain-of-thought
- sft
- full-finetuning
pipeline_tag: text-generation
datasets:
- Atomic-Ai/GPT-Think
---

# 🧠 German GPT-2 Medium – Reasoning Edition (Full SFT)

Dieses Modell ist eine vollständig feinabgestimmte ("Full Fine-Tuned") Version von [kkirchheim/german-gpt2-medium](https://huggingface.co/kkirchheim/german-gpt2-medium). Es wurde auf **über 50 MB** deutschsprachigen Textdaten trainiert, die auf **logisches Denken und Chain-of-Thought-Reasoning** ausgerichtet sind.

> ⚠️ **Dieses Modell ist ausschließlich auf Deutsch trainiert.** Englische Eingaben werden wahrscheinlich nicht korrekt verarbeitet.

## 💡 Besonderheiten

* **Reasoning-Fähigkeit:** Das Modell generiert einen internen Denkprozess (`<think>...</think>`), bevor es antwortet – ähnlich wie Chain-of-Thought-Prompting.
* **GPT-2 Medium Basis:** Mit ~355M Parametern deutlich leistungsfähiger als die Small-Variante (124M).
* **Full Fine-Tuning:** Keine Adapter (LoRA etc.) – 100% der Parameter wurden auf den Reasoning-Datensatz angepasst.
* **100% Deutsch:** Trainiert ausschließlich auf deutschen Daten. Englisch wird nicht unterstützt.

## 📝 Prompt-Format (Wichtig!)

Das Modell erwartet eine strikte Eingabestruktur. Wenn dieses Format nicht eingehalten wird, funktioniert die Reasoning-Funktion möglicherweise nicht.

```text
<user> Deine Frage hier <End> <AI Assistent>
```

Das Modell wird dann einen `<think>`-Block generieren, ihn mit `</think>` schließen und anschließend die endgültige Antwort ausgeben. Die Generierung stoppt automatisch beim `<End>`-Token oder wenn das Modell versucht, eine neue `<user>`-Runde zu starten.

## 💻 Nutzung

### Einfache Nutzung

```python
import torch
from transformers import AutoTokenizer, AutoModelForCausalLM

model_name = "Atomic-Ai/GPT-Chat-German"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32
)

device = "cuda" if torch.cuda.is_available() else "cpu"
model = model.to(device)

def generate_response(user_input):
    prompt = f"<user> {user_input} <End> <AI Assistent>"
    inputs = tokenizer(prompt, return_tensors="pt").to(device)

    with torch.no_grad():
        output_ids = model.generate(
            **inputs,
            max_new_tokens=1024,
            do_sample=True,
            temperature=0.7,
            top_p=0.9,
            repetition_penalty=1.2,
            pad_token_id=tokenizer.eos_token_id,
            eos_token_id=[
                tokenizer.eos_token_id,
                tokenizer.convert_tokens_to_ids("<user>")
            ]
        )

    full_output = tokenizer.decode(output_ids[0], skip_special_tokens=False)

    # Antwort nach dem <AI Assistent> Tag extrahieren
    if "<AI Assistent>" in full_output:
        response = full_output.split("<AI Assistent>")[-1]
    else:
        response = full_output

    # Bereinigung
    response = response.replace("<End>", "").replace("<user>", "").strip()
    return response

print(generate_response("Was ist die Hauptstadt von Deutschland?"))
```

### Interaktiver Chat

```python
# Nach dem Laden des Modells (siehe oben):
while True:
    user_input = input("Du: ")
    if user_input.lower() in ["exit", "quit", "ende"]:
        print("👋 Tschüss!")
        break
    print(f"Bot: {generate_response(user_input)}\n")
```

## ⚙️ Trainings-Details

Das Training wurde auf einer **NVIDIA T4 GPU** mit Mixed Precision (FP16) durchgeführt.

| Parameter | Wert |
| :--- | :--- |
| **Base Model** | kkirchheim/german-gpt2-medium (~355M Parameter) |
| **Methode** | Full Fine-Tuning (100% Parameter) |
| **Trainingsdaten** | ~50 MB kuratierter deutscher Text (Reasoning-fokussiert) |
| **Epochen** | 1 |
| **Batch Size** | 4 |
| **Gradient Accumulation** | 2 (effektive Batch Size: 8) |
| **Max Sequence Length** | 512 Token |
| **Learning Rate** | 5e-5 |
| **Scheduler** | Linear mit 3% Warmup |
| **Optimizer** | AdamW (Fused) |
| **Precision** | FP16 (Mixed Precision) |
| **Weight Decay** | 0.01 |

### 📉 Trainingsverlauf (Loss)

| Step | Loss |
| :--- | :--- |
| 1450 | 1.188 |
| 1500 | 1.063 |
| 1550 | 1.155 |
| 1600 | 1.124 |
| 1650 | 1.125 |
| 1700 | 1.109 |
| 1750 | 1.099 |
| 1800 | 1.063 |

Der Loss konvergiert stabil im Bereich von **~1.06–1.19**, was auf ein gut angepasstes Modell ohne starkes Overfitting hindeutet.

### Special Tokens

| Token | Funktion |
| :--- | :--- |
| `<user>` | Markiert den Beginn der Nutzereingabe |
| `<AI Assistent>` | Markiert den Beginn der Modellantwort |
| `<think>` / `</think>` | Umschließt den internen Denkprozess |
| `<End>` | End-of-Sequence Token |

## ⚠️ Limitierungen

* **Nur Deutsch:** Das Modell wurde ausschließlich auf deutschen Daten trainiert. Englische oder mehrsprachige Eingaben führen zu schlechten Ergebnissen.
* **Kontextfenster:** Begrenzt auf 1024 Token (GPT-2 Architektur).
* **Modellgröße:** Trotz Medium-Variante (~355M) ist die Kapazität für komplexes Weltwissen begrenzt.
* **Reasoning:** Der Chain-of-Thought-Ansatz verbessert die Antwortqualität, kann aber bei sehr einfachen Fragen unnötig ausführlich sein.

---

*Erstellt mit Liebe und viel GPU-Power. 🚀*