---
title: "LLM vor dem Wechsel evaluieren – Eval-Set und LLM-Judge"
description: "Bauen Sie aus echtem Traffic ein kleines Eval-Set, bewerten Sie es mit Code-Checks und einem entzerrten LLM-Judge und vergleichen Sie Qualität, Kosten und Latenz."
url: https://broadrouter.com/de/blog/evaluate-llm-before-switching/
lang: de
updated: 2026-11-14
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Mit KI-Unterstützung aus dem Englischen übersetzt. [Englisches Original lesen](https://broadrouter.com/blog/evaluate-llm-before-switching/) (aktualisiert am 2026-11-14).

# Wie Sie ein LLM vor dem Anbieterwechsel evaluieren

Vom Team von BroadNet Inference · 5 Min. Lesezeit · Veröffentlicht 2026-11-14

Sammeln Sie 50 bis 200 echte Prompts mit bekannten guten Ergebnissen. Bewerten Sie beide Modelle zuerst mit Code-Checks und nur dort mit einem LLM-Judge, wo Code nicht entscheiden kann. Tauschen Sie die Reihenfolge der Antworten gegen Positions-Bias, nutzen Sie einen Judge aus einer dritten Modellfamilie, gleichen Sie ihn mit Ihren eigenen Labels ab und legen Sie die Bestehensregel samt Kosten und Latenz vorher fest.

## Das Wichtigste in Kürze

-   Bauen Sie das Eval-Set aus echten Logs statt aus erfundenen Prompts, und nehmen Sie schwierige und fehlschlagende Fälle auf.
-   Bevorzugen Sie deterministische Checks (JSON lässt sich parsen, Feld stimmt, Test besteht). Nutzen Sie einen LLM-Judge nur für Eigenschaften, die Code nicht prüfen kann.
-   LLM-Judges zeigen Positions-, Längen- und Selbstbevorzugungs-Bias. Bewerten Sie jedes Paar zweimal mit vertauschter Reihenfolge.
-   Bei 100 Fällen hat ein Ergebnis von 80 % eine 95-%-Fehlerspanne von etwa ±8 Punkten. Kleine Unterschiede sind Rauschen.
-   Legen Sie die Bestehensregel vorher fest, einschließlich Kosten, Latenz und keiner Verschlechterung bei kritischen Fällen.

**Auf dieser Seite**

1.  Wie bauen Sie ein Eval-Set aus echtem Traffic?
2.  Welche Checks sollten Code sein und welche ein Judge?
3.  Was geht bei LLM-as-a-Judge schief?
4.  Wie führen Sie einen direkten Vergleich durch?
5.  Wie groß muss ein Unterschied sein, um echt zu sein?
6.  Wie sollte die Entscheidungsregel aussehen?
7.  Wo BroadNet Inference passt

Um ein LLM vor einem Wechsel zu evaluieren, lassen Sie beide Modelle auf 50 bis 200 echten Prompts mit bekannten guten Ergebnissen laufen. Bewerten Sie zuerst mit Code-Checks und nur dort mit einem entzerrten LLM-Judge, wo Code nicht entscheiden kann, protokollieren Sie Kosten und Latenz und legen Sie die Bestehensregel vorher fest.

Die Codeänderung selbst ist klein: Bei einer [OpenAI-kompatiblen API](https://broadrouter.com/de/glossary/openai-compatible-api/) sind es eine [Base-URL](https://broadrouter.com/de/glossary/base-url/) und eine Modell-ID. Die [Migrations-Checkliste](https://broadrouter.com/de/blog/openai-compatible-api-migration-checklist/) behandelt diesen Teil, die [Checkliste zur Anbieterwahl](https://broadrouter.com/de/blog/choose-llm-api-provider-checklist/) Preise, Limits und Datenschutz. Schwierig ist, zu wissen, ob das neue Modell **für Ihre Aufgaben** genauso gut ist. Öffentliche Leaderboards beantworten das nicht; [Artificial Analysis und seine Alternativen](https://broadrouter.com/de/blog/artificial-analysis-alternatives/) dienen dazu, eine Vorauswahl zu treffen. Ein kleines [Eval](https://broadrouter.com/de/glossary/eval/)\-Set aus Ihrem eigenen Traffic beantwortet es, mit ein bis zwei Tagen Arbeit.

## Wie bauen Sie ein Eval-Set aus echtem Traffic?

1.  **Ziehen Sie 300 bis 1.000 aktuelle Anfragen** aus Ihren [Nutzungsprotokollen](https://broadrouter.com/de/blog/llm-api-usage-logging/), nach der Schwärzung sensibler Daten.
2.  **Gruppieren Sie nach Aufgabentyp**: Extraktion, Klassifikation, Zusammenfassung, Chat-Antwort, Code-Änderung, Tool Call.
3.  **Ziehen Sie 10 bis 40 Stichproben pro Typ**, mehr bei Typen mit hohem Volumen oder hohem Risiko. Nehmen Sie lange Prompts, nicht-englische Eingaben und die Fälle auf, über die sich Nutzer beschwert haben.
4.  **Schreiben Sie das erwartete Ergebnis** für jeden Fall auf: einen exakten Wert, ein Schema, einen Test, der bestehen muss, oder eine kurze Bewertungsrubrik („nennt die Rückgabefrist; keine erfundenen Richtlinien“).
5.  **Markieren Sie kritische Fälle.** Eine falsche Rechnungssumme oder eine durchgesickerte Anweisung ist etwas anderes als ein etwas schlechterer Ton.
6.  **Frieren Sie das Set ein**, in der Versionsverwaltung. Fügen Sie Fälle hinzu, wenn Sie neue Fehler finden, und löschen Sie nie welche, um ein Modell besser aussehen zu lassen.

## Welche Checks sollten Code sein und welche ein Judge?

Nutzen Sie für jeden Fall den günstigsten zuverlässigen Check:

| Aufgabe | Check | Judge nötig? |
| --- | --- | --- |
| JSON-Extraktion | Lässt sich parsen, Schema validiert, Felder entsprechen dem Erwarteten | Nein |
| Klassifikation | Label entspricht dem Erwarteten | Nein |
| Code-Änderung | Tests bestehen | Nein |
| Tool Call | Richtige Funktion, Argumente validieren | Nein |
| Zusammenfassung | Enthält die nötigen Fakten; keine Fakten, die in der Quelle fehlen | Manchmal |
| Chat-Antwort, Ton, Hilfsbereitschaft | Rubrik | Ja |

Deterministische Checks kosten nichts, sind wiederholbar und lassen sich nicht schmeicheln; verlagern Sie also so viele Fälle wie möglich in Code-Checks.

## Was geht bei LLM-as-a-Judge schief?

Ein [LLM-as-a-Judge](https://broadrouter.com/de/glossary/llm-as-judge/) ist ein Modell, das die Antworten anderer Modelle anhand einer Rubrik bewertet. Die MT-Bench-Studie (Zheng et al.) ergab, dass starke Judges in mehr als 80 % der Fälle mit menschlichen Präferenzen übereinstimmten, etwa so oft wie Menschen untereinander. Dasselbe Paper benennt die Verzerrungen, die Sie beim Aufbau berücksichtigen müssen:

| Bias | Was passiert | Gegenmaßnahme |
| --- | --- | --- |
| Position | Bevorzugt die zuerst (oder als zweite) gezeigte Antwort | Jedes Paar zweimal bewerten, Reihenfolge vertauscht; Sieg nur zählen, wenn beide übereinstimmen |
| Länge | Bevorzugt längere Antworten | Rubrik, die Korrektheit und Kürze belohnt; Länge im Prompt begrenzen |
| Selbstbevorzugung | Bevorzugt Antworten im eigenen Stil | Judge aus einer anderen Modellfamilie als beide Kandidaten |
| Schwaches Schlussfolgern | Übersieht Fehler in Mathematik oder Code | Für diese Fälle stattdessen Code-Checks nutzen |

Zwei weitere Regeln aus der Praxis. **Fixieren Sie den Judge**: dieselbe Modellversion, derselbe Prompt, Temperature 0, für den ganzen Vergleich. Und **kalibrieren Sie ihn**: Labeln Sie 30 bis 50 Paare selbst, lassen Sie den Judge darauf laufen und vertrauen Sie ihm nur, wenn er meistens mit Ihnen übereinstimmt. Der Evaluator-Leitfaden von Arize gibt denselben Rat („Collect 20–100 examples“, Übersetzung: „Sammeln Sie 20–100 Beispiele“) mit menschlichen Labels und empfiehlt kategoriale Labels wie pass/fail statt großer numerischer Skalen.

## Wie führen Sie einen direkten Vergleich durch?

Lassen Sie beide Kandidaten auf jedem Fall laufen, verblinden Sie den Judge, vertauschen Sie die Reihenfolge und protokollieren Sie Kosten und Zeit:

```python
import os, random, time, json
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
A, B = "broadnet/deepseek-v4.1-flash", "broadnet/qwen3.8-27b"
JUDGE = "broadnet/glm-5.3"  # a third family, pinned

def run(model, case):
    t0 = time.perf_counter()
    r = client.chat.completions.create(model=model, messages=case["messages"], max_tokens=4000, temperature=0)
    return {"text": r.choices[0].message.content or "", "usage": r.usage.model_dump(),
            "secs": time.perf_counter() - t0}

def judge(case, first, second):
    prompt = (f"Task:\n{case['task']}\n\nRubric:\n{case['rubric']}\n\n"
              f"Answer 1:\n{first}\n\nAnswer 2:\n{second}\n\n"
              'Reply with JSON only: {"winner": 1 or 2 or 0 for tie, "reason": "..."}')
    r = client.chat.completions.create(model=JUDGE, temperature=0, max_tokens=2000,
                                       response_format={"type": "json_object"},
                                       messages=[{"role": "user", "content": prompt}])
    return int(json.loads(r.choices[0].message.content or "{}").get("winner", 0))

def compare(case):
    a, b = run(A, case), run(B, case)
    if case.get("check"):                       # deterministic first
        return {"a_ok": case["check"](a["text"]), "b_ok": case["check"](b["text"]), "a": a, "b": b}
    w1 = judge(case, a["text"], b["text"])      # A shown first
    w2 = judge(case, b["text"], a["text"])      # B shown first
    winner = "A" if (w1, w2) == (1, 2) else "B" if (w1, w2) == (2, 1) else "tie"
    return {"winner": winner, "a": a, "b": b}
```

Durch die Tauschregel gewinnt ein Modell nur, wenn der Judge es in beiden Positionen bevorzugt; jede Abweichung zählt als Unentschieden. Der Anteil der Abweichungen ist selbst aufschlussreich: Eine hohe Rate bedeutet, dass der Judge oder die Rubrik zu vage ist. Beachten Sie `max_tokens=4000`: Bei Reasoning-Modellen zählt das Nachdenken zum Limit, und eine niedrige Obergrenze erzeugt leere Antworten, die wie Fehlschläge aussehen. Siehe [warum Reasoning-Modelle leere Antworten liefern](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/).

## Wie groß muss ein Unterschied sein, um echt zu sein?

Eval-Ergebnisse sind Stichproben. Für eine Bestehensquote p über n Fälle ist der Standardfehler √(p × (1 − p) ÷ n), und eine 95-%-Fehlerspanne beträgt etwa das Doppelte davon.

| Fälle | Bestehensquote | 95-%-Fehlerspanne |
| --- | --- | --- |
| 50 | 80 % | etwa ±11 Punkte |
| 100 | 80 % | etwa ±8 Punkte |
| 200 | 80 % | etwa ±6 Punkte |
| 400 | 80 % | etwa ±4 Punkte |

Ein Modell mit 82 % gegenüber 79 % bei 100 Fällen ist also nicht nachweislich besser. Schauen Sie stattdessen auf **Unterschiede pro Fall**: Welche Fälle sind von bestanden zu nicht bestanden gekippt? Das sagt Ihnen mehr als die Summen, und bei kritischen Fällen kann ein einziger Kipper über den Wechsel entscheiden.

## Wie sollte die Entscheidungsregel aussehen?

Schreiben Sie sie auf, bevor Sie die Evaluation laufen lassen, damit das Ergebnis sie nicht verbiegen kann. Eine praktische Vorlage:

1.  Keine Verschlechterung bei einem als kritisch markierten Fall.
2.  Gesamte Bestehensquote nicht um mehr als die Fehlerspanne niedriger als beim aktuellen Modell.
3.  p95-Latenz innerhalb Ihres Budgets; wie Sie sie messen, steht unter [TTFT vs. Durchsatz](https://broadrouter.com/de/blog/llm-latency-ttft-throughput/).
4.  Kosten pro erfolgreichem Fall niedriger, oder nur um einen Betrag höher, den Sie als die Qualität wert vereinbart haben. Berechnen Sie die monatliche Differenz mit dem [LLM-API-Kostenrechner](https://broadrouter.com/tools/llm-api-cost-calculator/).
5.  Eine Schattenphase: Senden Sie einen Teil des Live-Traffics an das neue Modell, protokollieren Sie beide und vergleichen Sie, bevor Sie umstellen.

Dasselbe Eval-Set ist der Ausgangspunkt, wenn Sie ein eigenes Modell erwägen: [Vor dem Fine-Tuning](https://broadrouter.com/de/blog/fine-tuning-readiness/) behandelt, wann Prompts und Retrieval genügen.

## Wo BroadNet Inference passt

BroadNet Inference bietet mehrere Modellfamilien hinter einem OpenAI-kompatiblen Endpoint an, darunter [DeepSeek V4.1 Flash](https://broadrouter.com/de/models/deepseek-v4.1-flash/), [GLM 5.3](https://broadrouter.com/de/models/glm-5.3/) und [Qwen3.8 27B](https://broadrouter.com/de/models/qwen3.8-27b/); Kandidaten und ein Judge aus einer anderen Familie können also über denselben Client und Schlüssel laufen. Jede Antwort enthält den Token-Verbrauch für den Kostenvergleich, und neue Konten starten mit $5 Guthaben; ohne Aufladung deckt dieses Guthaben nur [Gemma 4 VL 26B](https://broadrouter.com/de/models/gemma-4-vl-26b/) ab, planen Sie also eine kleine Aufladung ein, um die größeren Modelle zu vergleichen. Ein Evaluations-Harness oder gehostete Judge-Werkzeuge gehören nicht dazu; den Code oben führen Sie selbst aus. Für arabische Workloads listet [ein LLM für Arabisch auswählen](https://broadrouter.com/de/blog/choosing-an-llm-for-arabic/) auf, was Sie testen sollten. Preise im direkten Vergleich finden Sie auf der [Vergleichsseite](https://broadrouter.com/compare/).

Kostenlose Tools zum Thema (auf Englisch)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Kostenlose Tools (auf Englisch)](https://broadrouter.com/tools/)

## Begriffe in diesem Artikel

[LLM-as-a-Judge (LLM als Bewerter)](https://broadrouter.com/de/glossary/llm-as-judge/)

LLM-as-a-Judge ist eine Evaluierungsmethode, bei der ein Sprachmodell die Ausgaben anderer Modelle bewertet: Es benotet eine einzelne Antwort anhand einer Rubrik oder wählt die bessere von zwei Antworten. Das nähert menschliches Urteil zu viel geringeren Kosten an, hat aber bekannte Verzerrungen, etwa eine Vorliebe für die erste oder längere Antwort.

[Eval (LLM-Evaluierung)](https://broadrouter.com/de/glossary/eval/)

Ein Eval (kurz für Evaluation) ist ein wiederholbarer Test eines Sprachmodells oder Prompts: eine feste Menge an Inputs, eine Beschreibung, wie ein guter Output aussieht, und ein Bewerter (Code, ein Mensch oder ein anderes Modell), der jeden Output benotet, damit sich Versionen vergleichen lassen.

[Fine-Tuning (Feinabstimmung)](https://broadrouter.com/de/glossary/fine-tuning/)

Fine-Tuning ist das Weitertrainieren eines vortrainierten Sprachmodells mit einem kleineren, aufgabenspezifischen Datensatz, etwa Beispielgesprächen, sodass sich seine Gewichte ändern und es diese Aufgabe oder diesen Stil zuverlässiger beherrscht, ohne lange Anweisungen oder Beispiele in jedem Prompt.

[Prepaid-Guthaben (Prepaid Credit)](https://broadrouter.com/de/glossary/prepaid-credit/)

Prepaid-Guthaben ist Geld, das vor der Nutzung auf ein API-Konto eingezahlt wird. Jede Anfrage zieht ihre Kosten vom Guthaben ab, und wenn es aufgebraucht ist, stoppen abgerechnete Anfragen, bis Sie aufladen. So sind die Ausgaben auf das eingezahlte Geld begrenzt.

[Temperatur (Temperature)](https://broadrouter.com/de/glossary/temperature/)

Die Temperatur ist ein Sampling-Parameter, der steuert, wie zufällig der Output eines Sprachmodells ist. Das Modell teilt seine Token-Scores durch die Temperatur, bevor es sie in Wahrscheinlichkeiten umrechnet: Niedrige Werte lassen das wahrscheinlichste Token dominieren, hohe Werte glätten die Verteilung, sodass seltenere Tokens öfter gewählt werden.

[Tool Calling (Function Calling)](https://broadrouter.com/de/glossary/tool-calling/)

Tool Calling, auch Function Calling genannt, ist eine Funktion von LLM-APIs, bei der das Modell eine strukturierte Anfrage zurückgibt, eine vom Entwickler definierte Funktion mit JSON-Argumenten auszuführen. Die Anwendung führt die Funktion aus und sendet das Ergebnis zurück; das Modell selbst führt nie Code aus.

[Durchsatz (Throughput)](https://broadrouter.com/de/glossary/throughput/)

Durchsatz (Throughput) ist beim Betrieb von LLMs die gesamte Arbeit, die ein System pro Zeiteinheit über alle gleichzeitigen Anfragen erledigt, meist gemessen in Output-Tokens pro Sekunde oder Anfragen pro Sekunde. Er unterscheidet sich von der Geschwindigkeit pro Stream, also davon, wie schnell eine einzelne Anfrage ihre Tokens erhält.

[Latenz (LLM)](https://broadrouter.com/de/glossary/latency/)

Latenz ist bei einer Sprachmodell-API die Zeit, die eine Anfrage vom Senden bis zum Empfang des letzten Output-Tokens braucht. Sie ist die Summe aus Time to First Token und Generierungszeit und wird meist als Perzentile wie p50 und p95 angegeben statt als Durchschnitt.

## Häufige Fragen

### Wie viele Beispiele brauche ich in einem Eval-Set für LLMs?

Fünfzig reichen, um große Verschlechterungen zu erkennen, 200, um Unterschiede von etwa 5 bis 10 Punkten zu sehen. Abdeckung ist wichtiger als Größe; nehmen Sie also jeden Aufgabentyp und Ihre bekannten Fehlerfälle auf.

### Ist LLM-as-a-Judge zuverlässig?

Teilweise. In der MT-Bench-Studie stimmten starke Judges in über 80 % der Fälle mit menschlichen Präferenzen überein, etwa so oft wie Menschen untereinander. Sie zeigten aber auch Positions-, Längen- und Selbstaufwertungs-Bias; entzerren Sie sie also und prüfen Sie Stichproben.

### Sollte das Judge-Modell dasselbe sein wie das getestete Modell?

Nein. Judges bevorzugen tendenziell Antworten, die wie ihre eigenen aussehen. Nutzen Sie einen Judge aus einer anderen Modellfamilie und halten Sie ihn für den ganzen Vergleich auf einer festen Version.

### Was ist Positions-Bias bei der LLM-Evaluation?

Der Judge bevorzugt die Antwort, die zuerst (oder als zweite) erscheint, unabhängig von der Qualität. Beheben Sie das, indem Sie jedes Paar zweimal mit vertauschter Reihenfolge bewerten und einen Sieg nur zählen, wenn beide Durchgänge übereinstimmen.

### Sollte ich Kosten und Latenz in derselben Evaluation vergleichen?

Ja. Protokollieren Sie Tokens und Zeit für jeden Eval-Aufruf. Ein Modell, das zwei Punkte besser abschneidet, aber das Dreifache an Kosten oder Latenz hat, kann trotzdem der falsche Wechsel sein.

## Weiterlesen

-   [LLM-API-Anbieter auswählen: Checkliste mit 20 Punkten](https://broadrouter.com/de/blog/choose-llm-api-provider-checklist/)
-   [Wechsel zu einer OpenAI-kompatiblen API: die Migrations-Checkliste](https://broadrouter.com/de/blog/openai-compatible-api-migration-checklist/)
-   [LLM-API für Arabisch auswählen: Was Sie testen sollten](https://broadrouter.com/de/blog/choosing-an-llm-for-arabic/)
-   [LLM-API-Nutzung loggen: Kosten pro Nutzer und Feature, ohne PII](https://broadrouter.com/de/blog/llm-api-usage-logging/)
-   [LLM-Latenz: TTFT vs. Tokens pro Sekunde vs. End-to-End-Zeit](https://broadrouter.com/de/blog/llm-latency-ttft-throughput/)
-   [Vor dem Fine-Tuning: das Problem klar benennen](https://broadrouter.com/de/blog/fine-tuning-readiness/)
-   [GPU-Hardware und Serving von BroadNet, wie BroadNet sie beschreibt](https://broadrouter.com/de/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM-Antworten cachen, Kosten senken: ein Exact-Match-Cache in Python](https://broadrouter.com/de/blog/cache-llm-responses-cut-cost/)
-   [Anleitung: OpenAI Python SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-python-sdk/)
-   [Anleitung: Warum ein Reasoning-Modell eine leere Antwort liefert](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/)

Testen Sie es mit Ihrem echten Workload. Neue Konten starten mit USD 5 Guthaben für Gemma und Transkription. DeepSeek, GLM und Qwen3.8 erfordern eine Aufladung.

[Loslegen](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-evaluate-llm-before-switching&utm_content=page-cta) ·

**Quellen**

-   [Zheng et al., Judging LLM-as-a-Judge with MT-Bench and Chatbot Arena, arXiv 2306.05685 (abgerufen am 2026-11-14)](https://arxiv.org/abs/2306.05685)
-   [Arize-Dokumentation, Best Practices für Evaluatoren (abgerufen am 2026-11-14)](https://arize.com/docs/ax/concepts/evaluators/evaluator-best-practices)
-   [API-Referenz von BroadNet Inference (abgerufen am 2026-11-14) (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-evaluate-llm-before-switching&utm_content=sources)
-   [Maschinenlesbare Preise von BroadNet Inference, pricing.json (abgerufen am 2026-11-14) (auf Englisch)](https://inference.broadnet.ai/pricing.json?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-evaluate-llm-before-switching&utm_content=sources)
