arnomatic/moe-combined-all3-v9-156k-finetuned

🇩🇪 German MoE v9 - Fine-Tuned (156k + Evol-Instruct)

Custom Mixture-of-Experts Model für deutsche Text-Generierung.

Solo Research Project - Trainiert auf einer einzelnen RTX 4090! 🚀

📊 Model Details

• Architecture: Hybrid Dense + MoE GPT (Custom)
• Parameters: 381M total, 183M active
• Hidden Size: 1024
• Layers: 20 (Hybrid Dense + MoE pattern)
• Experts: 32 per MoE layer
• Expert Activation: Top-2 routing
• Tokenizer: Llama 3.2 (128,256 vocab)
• Context Length: 2048 tokens

🎯 Training

Pre-Training

• Steps: 156,000
• Dataset: German Wikipedia + Belletristik
• Objective: Causal Language Modeling
• Hardware: Single RTX 4090

Fine-Tuning

• Dataset: Evol-Instruct German (38k samples)
• Epochs: 3
• Max Sequence Length: 2048 tokens
• Precision: BF16
• Batch Size: 16 (effective)
• Learning Rate: 2e-4
• Optimizer: AdamW
• Format: Llama 3.2 (question\n\nanswer)

🚀 Quick Start

⚠️ WICHTIG

Dieses Modell verwendet eine Custom MoE Architecture und kann NICHT mit der Standard transformers.pipeline() API geladen werden!

Installation

pip install transformers torch huggingface-hub

Verwendung

import torch
from transformers import AutoTokenizer
import sys
import os
from huggingface_hub import hf_hub_download

MODEL_NAME = "arnomatic/moe-combined-all3-v9-156k-finetuned"

# 1. Download Custom Model Code
print("🔄 Downloading custom model code...")
model_files = ["moe_config.py", "moe_layers.py", "moe_model.py"]
download_dir = "/tmp/moe_code"
os.makedirs(download_dir, exist_ok=True)

for filename in model_files:
    hf_hub_download(
        repo_id=MODEL_NAME,
        filename=filename,
        local_dir=download_dir,
        local_dir_use_symlinks=False
    )

sys.path.insert(0, download_dir)

# 2. Import Custom Model
from moe_model import MoEGPTForCausalLM

# 3. Load Model & Tokenizer
print("🔄 Loading model...")
model = MoEGPTForCausalLM.from_pretrained(
    MODEL_NAME,
    device_map="auto",  # Auto FP32 detection
)
tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
model.eval()

# 4. Generate Response (Llama 3.2 Format!)
prompt = "Was ist künstliche Intelligenz?\n\n"
inputs = tokenizer(prompt, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(
        **inputs,
        max_new_tokens=300,
        temperature=0.6,
        top_p=0.7,
        do_sample=True,
        repetition_penalty=1.2,
        eos_token_id=tokenizer.eos_token_id,
    )

# Decode only the answer (without prompt)
answer_tokens = outputs[0][inputs['input_ids'].shape[1]:]
answer = tokenizer.decode(answer_tokens, skip_special_tokens=True)
print(answer)

📝 Prompt Format

KRITISCH: Das Modell erwartet Llama 3.2 Format:

question\n\nanswer

Der Tokenizer fügt automatisch <|begin_of_text|> hinzu. Das \n\n am Ende der Frage ist erforderlich!

Beispiele

"Wie heisst die Hauptstadt der Schweiz?\n\n"
"Erkläre mir Machine Learning in einem Satz:\n\n"
"Schreibe ein Gedicht über Leidenschaft und Liebe:\n\n"
"Wie funktioniert ein Computer?\n\n"

🎨 Example Outputs

1. Faktische Frage

Prompt: "Wie heisst die Hauptstadt der Schweiz?\n\n"

Output:

Die Hauptstadt der Schweiz ist Bern.

2. Kreative Aufgabe

Prompt: "Schreibe ein Gedicht über Leidenschaft und Liebe:\n\n"

Output:

In den Tiefen des Lebens entdecke ich die Kraft,  
Liebe ist ein Sturm, der unerbittlich sein kann.  

Leidenschaft, ein Fluss,  
In diesem stürmischen Meer fließt das Leben,  
Wo Sonnenstrahlen tanzen und Wellen schlagen,  
Die Freude liegt in deinen Augen.  

Mit jedem Schlag, jeder Anblick,  
Von wildem Glanz, von glühendem Licht,  
Wiegen sich Träume durch die Nacht,  
Ein Wunder, das niemand versteht.

3. Technische Erklärung

Prompt: "Erkläre mir Machine Learning in einem Satz:\n\n"

Output:

Machine Learning ist der Prozess der künstlichen Intelligenz, bei dem 
Algorithmen auf Daten aus Beispielen abrufen und analysieren, wie sie 
Muster erkennen, Vorhersagen treffen und Entscheidungen treffen.

4. Komplexe Frage

Prompt: "Wie funktioniert ein Computer?\n\n"

Output:

Ein Computer ist ein leistungsfähiges Werkzeug, das viele Anwendungen in 
verschiedenen Bereichen wie Bildverarbeitung, Grafikdesign, Datenanalyse 
und Programmierung bietet. Es verfügt über eine Vielzahl von Funktionen, 
die es einem Computer ermöglichen, komplexe Aufgaben zu erledigen und 
große Datenmengen schnell zu analysieren. Darüber hinaus unterstützt der 
Computer die Arbeit mit großen Datenmengen, so dass er schnelle 
Entscheidungsfindungen, Fehlerbehebung und -korrektur durchführt. 
Insgesamt ist ein Computer für seine Fähigkeit bekannt, komplexe Aufgaben 
mit hoher Genauigkeit und Effizienz zu erledigen.

🎨 Use Cases

• ✅ Frage-Antwort (Deutsche Fakten)
• ✅ Kreative Texte (Gedichte, Geschichten)
• ✅ Technische Erklärungen (ML, AI, Computer Science)
• ✅ Zusammenfassungen
• ✅ Textgenerierung (Allgemein)

⚙️ Recommended Generation Parameters

# Balanced (Empfohlen)
temperature=0.6
top_p=0.7
top_k=50
repetition_penalty=1.2
max_new_tokens=300

# Kreativer (für Gedichte/Geschichten)
temperature=0.7
top_p=0.9
repetition_penalty=1.1
max_new_tokens=500

# Präziser (für Fakten)
temperature=0.4
top_p=0.6
top_k=40
repetition_penalty=1.3
max_new_tokens=200

📊 Performance

Kategorie	Score	Beschreibung
Kreative Texte	9/10	Exzellente Poesie, fließende Geschichten
Faktische Fragen	7/10	Korrekte Antworten, manchmal zu ausführlich
Technische Erklärungen	8/10	Gute Konzeptverständnis, strukturiert
Kohärenz	8/10	Sehr gute Satzstruktur, konsistenter Stil
Deutsch-Qualität	9/10	Native-level Grammatik und Stil

Stärken

• ✅ Exzellente poetische/kreative Outputs
• ✅ Sehr gute deutsche Grammatik
• ✅ Kohärente, strukturierte Antworten
• ✅ Versteht Kontext gut

Limitierungen

• ⚠️ Manchmal zu ausführlich bei einfachen Fragen
• ⚠️ Gelegentlich konzeptionelle Verwechslungen
• ⚠️ Optimiert für ~300 Token Outputs

🔬 Technical Details

Architecture

• Type: Custom GPT with Hybrid Dense+MoE layers
• Attention: Multi-head self-attention
• Position Encoding: Rotary Position Embedding (RoPE)
• Activation: GELU
• Normalization: LayerNorm

Training Hardware

• GPU: Single NVIDIA RTX 4090 (24GB)
• Training Time:
  • Pre-training: ~2 weeks (156k steps)
  • Fine-tuning: ~8 hours (3 epochs @ 2048 tokens)

Framework

• PyTorch: 2.0+
• Transformers: 4.56.1
• TRL: Latest (SFTTrainer)
• Precision: BF16 for training, FP32 auto for inference

📄 License

Apache 2.0

🙏 Credits

• Base Training Data: German Wikipedia, Belletristik
• Fine-Tuning Dataset: Evol-Instruct German by SebastianBodza
• Tokenizer: Based on Llama 3.2
• Framework: HuggingFace Transformers + TRL

👤 Author

Solo Research Project by Michael Hager

Built from scratch with a single RTX 4090. Demonstrating that quality language models can be trained with consumer hardware! 💪

📮 Contact & Feedback

Found a bug? Have suggestions? Open an issue or discussion on HuggingFace!

---

Note: This is a research model with a custom architecture. Standard pipeline() API is not supported. Please use the code examples provided above.

🔄 Version History

• v9-156k-finetuned: Current version (3 epochs Evol-Instruct)
• v9-156k: Pre-trained base (156k steps)
• v9-146k: Earlier checkpoint (146k steps)

---

Happy Generating! 🚀