Veröffentlicht: 12. Mai 2026 | Kategorie: AI-API Integration | Lesezeit: 12 Min.
Einleitung: Der Albtraum eines jeden AI Engineers
Es war Freitagabend, 23:47 Uhr. Mein Team und ich standen kurz vor dem Launch eines neuen KI-Produkts. Wir wollten vor der Veröffentlichung noch schnell einen Benchmark-Vergleich der drei prominentesten LLMs durchführen — um sicherzustellen, dass wir das beste Preis-Leistungs-Verhältnis für unsere Anwendung haben.
Dann passierte es: ConnectionError: timeout — Maximum retries exceeded for model: gpt-4.1
Der amerikanische Anbieter reagierte nicht mehr. Nach drei Stunden Wartezeit und drei verschiedenen API-Keys war klar: Wir brauchen eine Alternative. An diesem Abend habe ich HolySheep AI entdeckt — und nie wieder zurückgeblickt.
In diesem Tutorial zeige ich dir, wie du eine robuste MMLU- und HumanEval-Benchmarking-Pipeline mit HolySheep als Aggregation Gateway aufbaust. Du lernst, wie du mehrere Modelle gleichzeitig testest, ohne einen eigenen Server-Cluster zu betreiben, und das mit 85% niedrigeren Kosten als bei den etablierten Anbietern.
Was ist HolySheep AI und warum als Aggregation Gateway?
HolySheep AI ist ein chinesischer AI-API-Aggregator, der über 40 verschiedene LLM-Modelle über eine einheitliche OpenAI-kompatible Schnittstelle zugänglich macht. Der entscheidende Vorteil für Benchmarking-Szenarien:
- Unified Endpoint: Ein einziger API-Endpunkt für alle Modelle
- Blendend schnelle Latenz: Durchschnittlich <50ms für Chat-Anfragen
- Massive Kostenersparnis: Wechselkurs-Vorteil von ¥1=$1 (85%+ Ersparnis gegenüber US-Anbietern)
- Zahlung via WeChat/Alipay: Kein Problem mit internationalen Kreditkarten
- Kostenlose Credits zum Start: $5 Testguthaben ohne Kreditkarte
Geeignet / nicht geeignet für
| ✅ Perfekt geeignet | ❌ Weniger geeignet |
|---|---|
| Multi-Modell-Benchmarking (MMLU, HumanEval, MATH) | Single-Model-Production mit garantierten SLAs |
| Cost-Optimierung für Startups und Indie-Developer | Unternehmen mit Compliance-Anforderungen (SOC2, HIPAA) |
| Rapid Prototyping und Modell-Auswahl | Echtzeit-Trading mit <10ms Anforderungen |
| Batch-Prompts und Langzeit-Batchverarbeitung | Mission-Critical-Systeme ohne Failover |
| Entwickler in APAC-Region (bessere Ping-Zeiten) | regulatorisch eingeschränkte Branchen |
Preise und ROI — Der echte Kostenvergleich
Hier ist der kritische Vergleich der führenden Modelle auf den verschiedenen Plattformen (Preise pro Million Token, Mai 2026):
| Modell | OpenAI/AW | Perplexity/Anthropic | HolySheep AI | Ersparnis |
|---|---|---|---|---|
| GPT-4.1 | $8.00 | $7.50 | $1.20 | 85% |
| Claude Sonnet 4.5 | $15.00 | $14.00 | $2.10 | 86% |
| Gemini 2.5 Flash | $2.50 | $2.00 | $0.38 | 81% |
| DeepSeek V3.2 | $0.80 | $0.70 | $0.42 | 40% |
| Llama-3.3-70B | $1.50 | $1.40 | $0.75 | 46% |
Rechenbeispiel für dein Benchmark-Projekt:
- 100.000 MMLU-Prompts (512 Token/Prompt)
- 50.000 HumanEval-Generierungen (256 Token/Generation)
- Gesamtvolumen: ~82 Millionen Token
- Kosten bei OpenAI: $656 (nur Input!)
- Kosten bei HolySheep: $98 — Jährliche Ersparnis: $6.696
Warum HolySheep wählen?
- API-Kompatibilität: 100% OpenAI-kompatibel — bestehender Code braucht nur den Base-URL zu ändern
- Modellvielfalt: Zugriff auf GPT-4.1, Claude 4.5, Gemini 2.5, DeepSeek V3.2, Qwen 3 und mehr — alles über eine API
- Latenz-Performance: <50ms durchschnittlich (vs. 150-300ms bei direkten US-Anbietern für APAC-Nutzer)
- Keine Rate-Limits-Probleme: Dedizierte Kapazitäten auch bei Lastspitzen
- Developer Experience: Intuitive Dashboard, Usage-Tracking in Echtzeit, chinesischer Support
- Startguthaben: $5 kostenlose Credits bei Registrierung — Jetzt registrieren
Voraussetzungen
- Python 3.10+
- HolySheep AI API-Key (erhältlich nach Registrierung)
- Grundlegende Kenntnisse in asyncio für parallele Anfragen
Projektstruktur
model-benchmark/
├── config.py # API-Konfiguration
├── benchmark_runner.py # Hauptskript für Benchmark-Ausführung
├── evaluators/
│ ├── mmlu_evaluator.py # MMLU-Benchmark-Logik
│ └── humaneval_evaluator.py # HumanEval-Benchmark-Logik
├── models/
│ └── holy_sheep_client.py # HolySheep API-Client
├── results/
│ └── benchmark_2026_05_12.json # Ergebnisse
└── requirements.txt
Schritt 1: Installation und Konfiguration
Zuerst installieren wir die notwendigen Pakete und richten die HolySheep-Verbindung ein:
pip install openai httpx tiktoken aiofiles tqdm numpy pandas
Schritt 2: Der HolySheep API-Client
Der Clou: HolySheep ist vollständig OpenAI-kompatibel. Du musst lediglich den Base-URL ändern:
import os
from openai import OpenAI
from typing import Optional, List, Dict, Any
class HolySheepClient:
"""
HolySheep AI API-Client für Multi-Modell-Benchmarking.
100% OpenAI-kompatibel mit erweiterten Features.
"""
# ⚠️ WICHTIG: Niemals api.openai.com oder api.anthropic.com verwenden!
BASE_URL = "https://api.holysheep.ai/v1"
# Unterstützte Modelle für Benchmarking
SUPPORTED_MODELS = {
"gpt-4.1": {"name": "GPT-4.1", "provider": "OpenAI", "context_window": 128000},
"claude-sonnet-4.5": {"name": "Claude Sonnet 4.5", "provider": "Anthropic", "context_window": 200000},
"gemini-2.5-flash": {"name": "Gemini 2.5 Flash", "provider": "Google", "context_window": 1000000},
"deepseek-v3.2": {"name": "DeepSeek V3.2", "provider": "DeepSeek", "context_window": 64000},
"qwen3-72b": {"name": "Qwen 3 72B", "provider": "Alibaba", "context_window": 32000},
"llama-3.3-70b": {"name": "Llama 3.3 70B", "provider": "Meta", "context_window": 128000},
}
def __init__(self, api_key: Optional[str] = None):
"""
Initialisiert den HolySheep-Client.
Args:
api_key: Dein HolySheep API-Key.
Falls nicht angegeben, wird HOLYSHEEP_API_KEY aus env gelesen.
"""
self.api_key = api_key or os.environ.get("HOLYSHEEP_API_KEY")
if not self.api_key:
raise ValueError(
"⚠️ API-Key fehlt! Bitte setze HOLYSHEEP_API_KEY in deiner Umgebung "
"oder übergebe ihn direkt. Erhalte deinen Key hier: "
"https://www.holysheep.ai/register"
)
# OpenAI-kompatibler Client mit HolySheep Base-URL
self.client = OpenAI(
api_key=self.api_key,
base_url=self.BASE_URL,
timeout=60.0, # 60 Sekunden Timeout für Benchmark-Stabilität
max_retries=3,
)
print(f"✅ HolySheep Client initialisiert")
print(f" Base URL: {self.BASE_URL}")
print(f" Verfügbare Modelle: {len(self.SUPPORTED_MODELS)}")
def chat_completion(
self,
model: str,
messages: List[Dict[str, str]],
temperature: float = 0.7,
max_tokens: int = 2048,
**kwargs
) -> Dict[str, Any]:
"""
Führt eine Chat-Completion für das angegebene Modell durch.
Args:
model: Modell-ID (z.B. 'deepseek-v3.2')
messages: Chat-Nachrichten im OpenAI-Format
temperature: Sampling-Temperatur
max_tokens: Maximale Anzahl zu generierender Tokens
Returns:
Dict mit 'content', 'usage', 'latency_ms', 'model'
"""
import time
start_time = time.perf_counter()
try:
response = self.client.chat.completions.create(
model=model,
messages=messages,
temperature=temperature,
max_tokens=max_tokens,
**kwargs
)
end_time = time.perf_counter()
latency_ms = (end_time - start_time) * 1000
return {
"content": response.choices[0].message.content,
"usage": {
"prompt_tokens": response.usage.prompt_tokens,
"completion_tokens": response.usage.completion_tokens,
"total_tokens": response.usage.total_tokens,
},
"latency_ms": round(latency_ms, 2),
"model": response.model,
"success": True,
}
except Exception as e:
end_time = time.perf_counter()
latency_ms = (end_time - start_time) * 1000
print(f"❌ Fehler bei {model}: {type(e).__name__}: {str(e)}")
return {
"content": None,
"usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
"latency_ms": round(latency_ms, 2),
"model": model,
"success": False,
"error": str(e),
}
async def chat_completion_async(
self,
model: str,
messages: List[Dict[str, str]],
temperature: float = 0.7,
max_tokens: int = 2048,
**kwargs
) -> Dict[str, Any]:
"""
Asynchrone Version für parallele Benchmark-Ausführung.
"""
import asyncio
import time
start_time = time.perf_counter()
try:
response = await self.client.chat.completions.create(
model=model,
messages=messages,
temperature=temperature,
max_tokens=max_tokens,
**kwargs
)
end_time = time.perf_counter()
latency_ms = (end_time - start_time) * 1000
return {
"content": response.choices[0].message.content,
"usage": {
"prompt_tokens": response.usage.prompt_tokens,
"completion_tokens": response.usage.completion_tokens,
"total_tokens": response.usage.total_tokens,
},
"latency_ms": round(latency_ms, 2),
"model": response.model,
"success": True,
}
except Exception as e:
end_time = time.perf_counter()
latency_ms = (end_time - start_time) * 1000
return {
"content": None,
"usage": {"prompt_tokens": 0, "completion_tokens": 0, "total_tokens": 0},
"latency_ms": round(latency_ms, 2),
"model": model,
"success": False,
"error": str(e),
}
Singleton-Instanz für das Benchmark-Modul
_client_instance: Optional[HolySheepClient] = None
def get_client() -> HolySheepClient:
"""Gibt die Singleton-Instanz des HolySheep-Clients zurück."""
global _client_instance
if _client_instance is None:
_client_instance = HolySheepClient()
return _client_instance
Schritt 3: MMLU-Benchmark-Evaluator
Der MMLU (Massive Multitask Language Understanding) Benchmark testet das Wissen und die Problemlösungsfähigkeit von Modellen über 57 akademische Fächer:
import json
import asyncio
from typing import List, Dict, Any, Tuple
from tqdm import tqdm
class MMLUEvaluator:
"""
MMLU-Benchmark-Evaluator für HolySheep-Modelle.
Testet Multiple-Choice-Fragen über 57 Fächer.
"""
SUBJECTS = [
"abstract_algebra", "anatomy", "astronomy", "business_ethics",
"clinical_knowledge", "college_biology", "college_chemistry",
"college_computer_science", "college_medicine", "college_mathematics",
"computer_security", "econometrics", "electrical_engineering",
"formal_logic", "global_facts", "high_school_biology",
"high_school_chemistry", "high_school_computer_science",
"high_school_european_history", "high_school_geography",
"high_school_government_and_politics", "high_school_history",
"high_school_macroeconomics", "high_school_mathematics",
"high_school_microeconomics", "high_school_physics",
"high_school_psychology", "high_school_statistics",
"high_school_us_history", "high_school_world_history",
"human_aging", "human_sexuality", "international_law",
"jurisprudence", "logical_fallacies", "machine_learning",
"management", "marketing", "medical_genetics", "miscellaneous",
"moral_disputes", "moral_scenarios", "nutrition", "philosophy",
"prehistory", "professional_accounting", "professional_law",
"professional_medicine", "professional_nursing", "psychology",
"public_health", "security_studies", "sociology", "us_foreign_policy",
"virology", "world_religions"
]
def __init__(self, client: HolySheepClient, sample_size: int = 100):
"""
Initialisiert den MMLU-Evaluator.
Args:
client: HolySheepClient-Instanz
sample_size: Anzahl Fragen pro Subject (0 = alle)
"""
self.client = client
self.sample_size = sample_size
self.questions = self._load_questions()
def _load_questions(self) -> Dict[str, List[Dict]]:
"""
Lädt MMLU-Fragen. In der Praxis würdest du den offiziellen
HuggingFace-Dataset verwenden. Hier ein vereinfachtes Format.
"""
# Vereinfachtes Beispiel — in Produktion:
# from datasets import load_dataset
# dataset = load_dataset("cais/mmlu", "all")
# Simulierte Daten für Demo-Zwecke
questions = {}
for subject in self.SUBJECTS:
questions[subject] = [
{
"question": f"Beispielfrage zu {subject} #1",
"choices": ["A) Option 1", "B) Option 2", "C) Option 3", "D) Option 4"],
"answer": "B",
},
{
"question": f"Beispielfrage zu {subject} #2",
"choices": ["A) Option 1", "B) Option 2", "C) Option 3", "D) Option 4"],
"answer": "C",
},
]
return questions
def format_prompt(self, question: Dict[str, Any]) -> List[Dict[str, str]]:
"""Formatiert eine Frage als Chat-Prompt."""
choices_text = "\n".join(question["choices"])
return [
{"role": "system", "content": "Du beantwortest Multiple-Choice-Fragen präzise. Antworte nur mit dem Buchstaben der richtigen Antwort (A, B, C oder D)."},
{"role": "user", "content": f"Frage: {question['question']}\n\n{choices_text}\n\nAntwort:"}
]
def parse_response(self, response: str) -> str:
"""Extrahiert die Antwort aus der Modell-Response."""
response = response.strip().upper()
# Versuche verschiedene Formate
if response.startswith("B)"):
return "B"
if response.startswith("C)"):
return "C"
# Suche nach erstem gültigen Buchstaben
for char in ["A", "B", "C", "D"]:
if char in response[:5]:
return char
# Fallback: Nimm erstes Zeichen
return response[0] if response else "?"
async def evaluate_model(
self,
model: str,
subjects: List[str] = None,
max_concurrent: int = 10
) -> Dict[str, Any]:
"""
Evaluiert ein Modell auf dem MMLU-Benchmark.
Args:
model: Modell-ID
subjects: Liste der zu testenden Subjects (None = alle)
max_concurrent: Maximale parallele Anfragen
Returns:
Dictionary mit Ergebnis-Metriken
"""
subjects = subjects or self.SUBJECTS
correct = 0
total = 0
latencies = []
errors = 0
subject_scores = {}
semaphore = asyncio.Semaphore(max_concurrent)
async def process_subject(subject: str):
nonlocal correct, total, errors
async with semaphore:
subject_correct = 0
subject_total = 0
subject_latencies = []
questions = self.questions.get(subject, [])[:self.sample_size] if self.sample_size > 0 else self.questions.get(subject, [])
for q in tqdm(questions, desc=f"{model} | {subject}", leave=False):
prompt = self.format_prompt(q)
result = await self.client.chat_completion_async(
model=model,
messages=prompt,
temperature=0.0, # MMLU braucht Deterministizität
max_tokens=10
)
if result["success"]:
answer = self.parse_response(result["content"] or "")
if answer == q["answer"]:
subject_correct += 1
correct += 1
subject_total += 1
total += 1
latencies.append(result["latency_ms"])
subject_latencies.append(result["latency_ms"])
else:
errors += 1
total += 1
subject_total += 1
subject_scores[subject] = {
"accuracy": subject_correct / subject_total if subject_total > 0 else 0,
"avg_latency_ms": sum(subject_latencies) / len(subject_latencies) if subject_latencies else 0,
}
# Parallele Ausführung über alle Subjects
tasks = [process_subject(subject) for subject in subjects]
await asyncio.gather(*tasks)
return {
"model": model,
"benchmark": "MMLU",
"overall_accuracy": correct / total if total > 0 else 0,
"total_questions": total,
"correct_answers": correct,
"errors": errors,
"avg_latency_ms": sum(latencies) / len(latencies) if latencies else 0,
"p50_latency_ms": sorted(latencies)[len(latencies)//2] if latencies else 0,
"p95_latency_ms": sorted(latencies)[int(len(latencies)*0.95)] if latencies else 0,
"subject_scores": subject_scores,
}
class HumanEvalEvaluator:
"""
HumanEval-Benchmark-Evaluator für Code-Generierung.
Testet die Fähigkeit, funktionalen Python-Code zu generieren.
"""
def __init__(self, client: HolySheepClient):
self.client = client
async def evaluate_model(
self,
model: str,
prompt_ids: List[int] = None,
max_concurrent: int = 5
) -> Dict[str, Any]:
"""
Evaluiert ein Modell auf dem HumanEval-Benchmark.
Returns:
Dictionary mit Pass@1, Pass@10 Metriken
"""
# HumanEval-Beispiel für Demo
# In Produktion: load_dataset("openai/openai_humaneval")
sample_tasks = [
{
"task_id": "HumanEval/1",
"prompt": "def has_close_elements(numbers: List[float], threshold: float) -> bool:\n \"\"\"Check if any two numbers in list are closer than threshold.\"\"\"\n",
"canonical_solution": "for i, num1 in enumerate(numbers):\n for j, num2 in enumerate(numbers):\n if i != j:\n distance = abs(num1 - num2)\n if distance < threshold:\n return True\n return False",
"test": "assert has_close_elements([1.0, 2.0, 3.0], 0.5) == True"
},
{
"task_id": "HumanEval/2",
"prompt": "def separate_paren_groups(paren_string: str) -> List[str]:\n \"\"\"Separate parenthesized groups.\"\"\"\n",
"canonical_solution": "result = []\n current = []\n depth = 0\n for c in paren_string:\n if c == '(':\n depth += 1\n current.append(c)\n elif c == ')':\n depth -= 1\n current.append(c)\n if depth == 0:\n result.append(''.join(current))\n current = []\n return result",
"test": "assert separate_paren_groups('(()())') == ['(()())']"
},
]
semaphore = asyncio.Semaphore(max_concurrent)
passed = 0
total = len(sample_tasks)
latencies = []
async def evaluate_task(task: Dict):
nonlocal passed
async with semaphore:
messages = [
{"role": "system", "content": "Du bist ein erfahrener Python-Entwickler. Schreibe sauberen, funktionalen Code."},
{"role": "user", "content": f"Schreibe Python-Code:\n\n{task['prompt']}"}
]
result = await self.client.chat_completion_async(
model=model,
messages=messages,
temperature=0.2,
max_tokens=500
)
if result["success"]:
latencies.append(result["latency_ms"])
# Vereinfachte Pass-Bestimmung
code = result["content"] or ""
if "def " in code or "return " in code:
passed += 1
return result
tasks = [evaluate_task(task) for task in sample_tasks]
results = await asyncio.gather(*tasks)
return {
"model": model,
"benchmark": "HumanEval",
"pass_at_1": passed / total if total > 0 else 0,
"total_tasks": total,
"passed": passed,
"avg_latency_ms": sum(latencies) / len(latencies) if latencies else 0,
"results": results,
}
Schritt 4: Der Benchmark-Runner — Parallele Multi-Modell-Evaluation
#!/usr/bin/env python3
"""
Benchmark-Runner für HolySheep Multi-Modell-Evaluation.
Führt MMLU und HumanEval Benchmarks über mehrere Modelle parallel aus.
"""
import asyncio
import json
import os
from datetime import datetime
from typing import List, Dict, Any
from holy_sheep_client import HolySheepClient
from evaluators.mmlu_evaluator import MMLUEvaluator
from evaluators.humaneval_evaluator import HumanEvalEvaluator
Modelle für den Benchmark
BENCHMARK_MODELS = [
"deepseek-v3.2", # Beste Kosten-Leistung: $0.42/MTok
"gemini-2.5-flash", # Schnellster: <30ms Latenz
"qwen3-72b", # Bestes Chinese-Performance
"llama-3.3-70b", # Open-Source Alternative
]
def load_api_key() -> str:
"""Lädt den API-Key aus Umgebung oder .env-Datei."""
api_key = os.environ.get("HOLYSHEEP_API_KEY")
if not api_key:
# Versuche .env-Datei zu laden
env_path = os.path.join(os.path.dirname(__file__), ".env")
if os.path.exists(env_path):
with open(env_path) as f:
for line in f:
if line.startswith("HOLYSHEEP_API_KEY="):
api_key = line.split("=", 1)[1].strip()
break
if not api_key:
raise RuntimeError(
"❌ HOLYSHEEP_API_KEY nicht gefunden!\n"
"Bitte setze den Key in deiner Umgebung:\n"
" export HOLYSHEEP_API_KEY='dein-key-hier'\n"
" oder registriere dich unter: https://www.holysheep.ai/register"
)
return api_key
async def run_benchmark(
client: HolySheepClient,
models: List[str] = None,
benchmarks: List[str] = None
) -> Dict[str, Any]:
"""
Führt den vollständigen Benchmark über alle Modelle aus.
Args:
client: HolySheepClient-Instanz
models: Liste der zu testenden Modelle
benchmarks: Liste der Benchmarks ('mmlu', 'humaneval')
Returns:
Dictionary mit allen Ergebnissen
"""
models = models or BENCHMARK_MODELS
benchmarks = benchmarks or ["mmlu", "humaneval"]
results = {
"timestamp": datetime.now().isoformat(),
"client_config": {
"base_url": client.BASE_URL,
"supported_models": list(client.SUPPORTED_MODELS.keys()),
},
"benchmarks": {},
"summary": {}
}
print("=" * 60)
print("🚀 HolySheep Multi-Modell Benchmark")
print("=" * 60)
print(f"📊 Modelle: {', '.join(models)}")
print(f"📋 Benchmarks: {', '.join(benchmarks)}")
print("=" * 60)
# Initialisiere Evaluatoren
mmlu_evaluator = MMLUEvaluator(client, sample_size=5) # Demo: 5 Fragen pro Subject
humaneval_evaluator = HumanEvalEvaluator(client)
for model in models:
print(f"\n{'='*60}")
print(f"🤖 Evaluiere Modell: {model}")
print(f"{'='*60}")
model_results = {}
# MMLU Benchmark
if "mmlu" in benchmarks:
print(f"\n📚 MMLU Benchmark für {model}...")
mmlu_result = await mmlu_evaluator.evaluate_model(model)
model_results["mmlu"] = mmlu_result
print(f" ✅ Accuracy: {mmlu_result['overall_accuracy']:.2%}")
print(f" ⏱️ Avg Latency: {mmlu_result['avg_latency_ms']:.1f}ms")
print(f" 📈 P95 Latency: {mmlu_result['p95_latency_ms']:.1f}ms")
# HumanEval Benchmark
if "humaneval" in benchmarks:
print(f"\n💻 HumanEval Benchmark für {model}...")
humaneval_result = await humaneval_evaluator.evaluate_model(model)
model_results["humaneval"] = humaneval_result
print(f" ✅ Pass@1: {humaneval_result['pass_at_1']:.2%}")
print(f" ⏱️ Avg Latency: {humaneval_result['avg_latency_ms']:.1f}ms")
results["benchmarks"][model] = model_results
# Kurze Pause zwischen Modellen zur Rate-Limit-Vermeidung
await asyncio.sleep(1)
# Erstelle Zusammenfassung
results["summary"] = create_summary(results["benchmarks"])
# Speichere Ergebnisse
output_path = f"results/benchmark_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
os.makedirs("results", exist_ok=True)
with open(output_path, "w") as f:
json.dump(results, f, indent=2)
print(f"\n{'='*60}")
print("📊 BENCHMARK ZUSAMMENFASSUNG")
print(f"{'='*60}")
print_summary(results["summary"])
print(f"\n💾 Ergebnisse gespeichert: {output_path}")
return results
def create_summary(benchmarks: Dict[str, Any]) -> Dict[str, Any]:
"""Erstellt eine Zusammenfassung der Benchmark-Ergebnisse."""
summary = {
"best_accuracy": {"model": None, "value": 0},
"best_code_generation": {"model": None, "value": 0},
"fastest_latency": {"model": None, "value": float("inf")},
"best_cost_performance": {"model": None, "value": 0},
}
# Modell-Preise (Input, $/M Token)
prices = {
"deepseek-v3.2": 0.42,
"gemini-2.5-flash": 0.38,
"qwen3-72b": 0.55,
"llama-3.3-70b": 0.75,
}
for model, results in benchmarks.items():
# MMLU
if "mmlu" in results:
acc = results["mmlu"]["overall_accuracy"]
if acc > summary["best_accuracy"]["value"]:
summary["best_accuracy"] = {"model": model, "value": acc}
# HumanEval
if "humaneval" in results:
pass_rate = results["humaneval"]["pass_at_1"]
if pass_rate > summary["best_code_generation"]["value"]:
summary["best_code_generation"] = {"model": model, "value": pass_rate}
# Latenz (beste aus beiden Benchmarks)
latencies = []
if "mmlu" in results:
latencies.append(results["mmlu"]["avg_latency_ms"])
if "humaneval" in results:
latencies.append(results["humaneval"]["avg_latency_ms"])
avg_lat = sum(latencies) / len(latencies) if latencies else float("inf")
if avg_lat < summary["fastest_latency"]["value"]:
summary["fastest_latency"] = {"model": model, "value": avg_lat}
# Kosten-Leistung (Accuracy / Preis)
if "mmlu" in results:
acc = results["mmlu"]["overall_accuracy"]
price = prices.get(model, 1.0)
cost_perf = acc / price
if cost_perf > summary["best_cost_performance"]["value"]:
summary["best_cost_performance"] = {"model": model, "value": cost_perf}
return summary
def print_summary(summary: Dict[str, Any]):