Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Automatisierte Prompt-Bewertung

Lektion 16 von 16 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Automatisierte Prompt-Bewertung
  2. Bewertungstypen
  3. Komplette Bewertungspipeline
  4. Format der Test-Suite
  5. Integration in CI/CD
  6. Bewertungs-Dashboard
  7. Einrichtung Ihrer Guardrails
  8. Kernaussagen
  9. Wissen prüfen

Lektion aktualisiert am 3. November 2026 basierend auf der OpenAI-Dokumentation: temperature und top_p werden nur mit einem Reasoning-Effort von none akzeptiert, während GPT-5.6-Modelle standardmäßig rechnerisch arbeiten (medium). Aufrufe, die diese Parameter setzen, müssen daher reasoning={"effort": "none"} (Responses API) oder reasoning_effort="none" (Chat Completions) angeben. Quellen: Verwendung von GPT-6 · GPT-5.6 Terra.

Automatisierte Prompt-Bewertung

Die automatisierte Bewertung ist das Fundament eines ausgereiften Prompt-Engineering-Pipelines. Sie ermöglicht es Ihnen, Regressionen zu erkennen, Modelle zu vergleichen und Änderungen vor der Bereitstellung zu validieren. Ohne sie ist jede Prompt-Änderung ein blindes Wagnis.

Bewertungstypen

Drei Familien von Evaluatoren teilen die Arbeit basierend auf der Art des erwarteten Outputs, und Sie werden fast immer mehrere davon kombinieren.

Exakte Übereinstimmung

Für Aufgaben mit einer einzigen erwarteten Antwort reicht ein direkter Vergleich aus. eval_exact_match normalisiert Groß-/Kleinschreibung und Leerzeichen vor dem Vergleich: Ohne diese Vorsicht würden “Bug” und “bug” als Fehler gewertet, was Sie dazu veranlassen würde, ein Problem zu beheben, das nicht existiert.

eval_set_match behandelt Fälle, in denen die Antwort eine Menge ist – Entitäten, die in einem Dokument gefunden wurden, Kategorien, die einem Artikel zugewiesen wurden. Sie leitet Präzision und Recall ab, zwei Kennzahlen, die unterschiedliche Geschichten erzählen: Hohe Präzision bei niedrigem Recall signalisiert ein zu vorsichtiges Modell, das nur das extrahiert, worauf es sich sicher ist; das Gegenteil verrät ein Modell, das halluziniert, um Lücken zu füllen. F1 fasst sie bequem zusammen, ersetzt sie aber nicht für die Diagnose.

def eval_exact_match(prediction: str, reference: str) -> bool:
    """Exakte Übereinstimmung nach Normalisierung."""
    return prediction.strip().lower() == reference.strip().lower()

def eval_set_match(prediction: set, reference: set) -> dict:
    """Mengenübereinstimmung (Entitäten, Kategorien)."""
    tp = len(prediction & reference)
    fp = len(prediction - reference)
    fn = len(reference - prediction)

    precision = tp / (tp + fp) if (tp + fp) > 0 else 0
    recall = tp / (tp + fn) if (tp + fn) > 0 else 0
    f1 = (2 * precision * recall / (precision + recall)
          if (precision + recall) > 0 else 0)

    return {"precision": precision, "recall": recall, "f1": f1}

Semantische Bewertung (Embedding)

Bei Textantworten, bei denen die Wortwahl variieren kann, wird exakte Übereinstimmung absurd: “Ihre Bestellung wird morgen geliefert” und “Die Lieferung ist für morgen geplant” sagen dasselbe, würden aber eine Punktzahl von null erhalten. Die Kosinus-Ähnlichkeit zwischen Embeddings misst die semantische Nähe statt der Zeichenübereinstimmung und gibt einen kontinuierlichen Wert zurück.

Sie legen den Schwellenwert fest, oberhalb dessen eine Antwort als akzeptabel gilt. Kalibrieren Sie ihn an einigen Dutzend Paaren, die Sie manuell als “äquivalent” oder “unterschiedlich” klassifiziert haben, und wählen Sie dann den Wert, der die beiden Gruppen am besten trennt: Ein Schwellenwert, der auf Bauchgefühl basiert, erzeugt Ergebnisse, die willkürlich sind wie eine Messung gar nicht, mit der zusätzlichen Illusion von Strenge.

from openai import OpenAI
import numpy as np

client = OpenAI()

def eval_semantic_similarity(prediction: str,
                              reference: str) -> float:
    """Kosinus-Ähnlichkeit zwischen Embeddings."""
    response = client.embeddings.create(
        model="text-embedding-3-large",
        input=[prediction, reference]
    )
    emb_pred = np.array(response.data[0].embedding)
    emb_ref = np.array(response.data[1].embedding)

    similarity = float(
        np.dot(emb_pred, emb_ref) /
        (np.linalg.norm(emb_pred) * np.linalg.norm(emb_ref))
    )
    return similarity

LLM-Bewertung (LLM-as-Judge)

Das Modell bewertet die Qualität einer Antwort. Dies ist der einzige gangbare Ansatz, wenn kein Referenzwert existiert: Niemand wird hunderte Support-Antworten handschriftlich verfassen.

Was ein Richter nutzbar macht, hängt von wenigen Dingen ab. Erstens das verwendete Modell: Sie wählen ein leistungsfähigeres Modell als Richter, hier gpt-5.6-sol, da ein Richter auf demselben Niveau wie das zu bewertende Modell dazu neigt, seine eigenen Fehler zu validieren. Zweitens die Anforderung einer Begründung: Die Motivation jeder Punktzahl stabilisiert das Urteil und ermöglicht es Ihnen, einen Evaluator zu erkennen, der das falsche Kriterium anwendet – eine Begründung, die die Länge diskutiert, während das Kriterium die Klarheit war, ist ein Warnsignal. Schließlich sorgt temperature bei 0,1 für die Stabilität der Punktzahl über mehrere Durchläufe hinweg.

def eval_llm_judge(question: str, prediction: str,
                    criteria: list[str]) -> dict:
    """Bewertung durch ein Richtermodell."""
    criteria_text = "\n".join(
        f"- {c}: score von 1 bis 5" for c in criteria
    )

    response = client.responses.create(
        model="gpt-5.6-sol",  # Leistungsfähigeres Modell als Richter
        reasoning={"effort": "none"},  # temperature erfordert effort none
        instructions="Sie sind ein erfahrener, unparteiischer Evaluator.",
        input=f"""Bewerten Sie diese Antwort gemäß den folgenden Kriterien:

Gestellte Frage: {question}

Zu bewertende Antwort: {prediction}

Kriterien:
{criteria_text}

Für jedes Kriterium geben Sie eine Punktzahl von 1 bis 5 mit Begründung an.""",
        text={
            "format": {
                "type": "json_schema",
                "name": "evaluation",
                "schema": {
                    "type": "object",
                    "properties": {
                        "scores": {
                            "type": "array",
                            "items": {
                                "type": "object",
                                "properties": {
                                    "criterion": {"type": "string"},
                                    "score": {"type": "integer"},
                                    "justification": {"type": "string"}
                                },
                                "required": ["criterion", "score",
                                              "justification"],
                                "additionalProperties": False
                            }
                        },
                        "overall_score": {"type": "number"},
                        "verdict": {"type": "string"}
                    },
                    "required": ["scores", "overall_score", "verdict"],
                    "additionalProperties": False
                },
                "strict": True
            }
        },
        temperature=0.1
    )
    return json.loads(response.output_text)

Komplette Bewertungspipeline

EvalPipeline fasst diese Bausteine zusammen: Sie lädt eine Test-Suite, führt den Prompt für jeden Fall aus, wendet alle bereitgestellten Evaluatoren an und aggregiert die Punktzahlen. Evaluatoren werden als Liste von Funktionen übergeben, die alle mit derselben Signatur aufgerufen werden; das Hinzufügen einer Metrik erfordert daher keine Änderung der Pipeline, und Sie können exakte Übereinstimmung, semantische Ähnlichkeit und einen Richter im selben Durchlauf ausführen, ohne drei Mal für die Generierung zu bezahlen.

Die summary-Methode sammelt auch die verbrauchten Tokens. Diese scheinbar sekundäre Zeile schützt Sie vor einem häufigen Fallstrick: Eine Prompt-Version, die zwei Punkte mehr erzielt, während die Rechnung verdreifacht wird, ist nicht unbedingt die richtige Wahl, und es ist besser, dies zum Zeitpunkt des Kompromisses zu lernen als wenn die monatliche Rechnung eintrifft.

import json
from dataclasses import dataclass
from pathlib import Path

@dataclass
class TestCase:
    """Ein Testfall für die Bewertung."""
    input_text: str
    expected_output: str = None
    metadata: dict = None

class EvalPipeline:
    """Automatisierte Bewertungspipeline."""

    def __init__(self, test_suite_path: str):
        """Lädt die Test-Suite aus einer JSON-Datei."""
        data = json.loads(Path(test_suite_path).read_text())
        self.test_cases = [TestCase(**tc) for tc in data]
        self.results = []

    def run(self, prompt_config: dict,
            evaluators: list[callable]) -> dict:
        """Führt alle Tests aus und bewertet die Ergebnisse."""
        self.results = []

        for tc in self.test_cases:
            # Antwort generieren
            response = client.responses.create(
                model=prompt_config["model"],
                reasoning={"effort": "none"},  # temperature erfordert effort none
                instructions=prompt_config["system_prompt"],
                input=tc.input_text,
                temperature=prompt_config.get("temperature", 0.1)
            )

            prediction = response.output_text

            # Bewertung mit jedem Evaluator
            scores = {}
            for evaluator in evaluators:
                score = evaluator(
                    question=tc.input_text,
                    prediction=prediction,
                    reference=tc.expected_output
                )
                scores[evaluator.__name__] = score

            self.results.append({
                "input": tc.input_text,
                "expected": tc.expected_output,
                "prediction": prediction,
                "scores": scores,
                "tokens": {
                    "input": response.usage.input_tokens,
                    "output": response.usage.output_tokens
                }
            })

        return self.summary()

    def summary(self) -> dict:
        """Fasst die Bewertungsergebnisse zusammen."""
        if not self.results:
            return {"error": "Keine Ergebnisse"}

        # Aggregiert Punktzahlen nach Evaluator
        all_scores = {}
        for result in self.results:
            for eval_name, score in result["scores"].items():
                if eval_name not in all_scores:
                    all_scores[eval_name] = []
                if isinstance(score, (int, float)):
                    all_scores[eval_name].append(score)
                elif isinstance(score, dict) and "f1" in score:
                    all_scores[eval_name].append(score["f1"])

        summary = {
            "total_tests": len(self.results),
            "average_scores": {
                name: sum(scores) / len(scores)
                for name, scores in all_scores.items()
                if scores
            },
            "total_token_cost": sum(
                r["tokens"]["input"] + r["tokens"]["output"]
                for r in self.results
            )
        }
        return summary

Format der Test-Suite

Das Format der Test-Suite bleibt absichtlich minimalistisch: eine Eingabe, der erwartete Output und frei formatierte Metadaten. Diese Metadaten sind nützlicher, als sie auf den ersten Blick erscheinen: Durch das Taggen jedes Falls nach Kategorie können Sie die Punktzahlen aufschlüsseln und feststellen, dass Ihr Klassifikator nicht zufällig versagt, sondern bei einer bestimmten Familie von Anfragen, was ein globaler Durchschnitt von 88 % nicht offenbart. Die drei Beispiele unten zeigen auch, was eine gute Suite enthalten sollte: klare Fälle, wie ein Start-up-Crash, aber auch Fälle, die an eine andere Kategorie grenzen – eine Frage nach einer fehlenden Funktion sieht sehr viel aus wie ein Bug-Report, und genau an dieser Grenze wird die Qualität eines Klassifikators entschieden.

[
    {
        "input_text": "Mein Paket ist nicht angekommen",
        "expected_output": "Beschwerde",
        "metadata": {"category": "Lieferung"}
    },
    {
        "input_text": "Wie aktiviere ich den Dunkelmodus?",
        "expected_output": "Frage",
        "metadata": {"category": "Funktion"}
    },
    {
        "input_text": "Die App stürzt beim Start auf iOS 18 ab",
        "expected_output": "Bug",
        "metadata": {"category": "Technisch"}
    }
]

Integration in CI/CD

Führen Sie die Bewertung bei jeder Prompt-Änderung durch. Die Funktion ci_eval_check verwandelt die Messung in eine Sicherung: Sie führt die Pipeline aus, vergleicht die durchschnittliche Punktzahl mit einem Schwellenwert und gibt einen booleschen Wert zurück, den Ihre Integrationskette als erfolgreichen oder fehlgeschlagenen Build interpretiert. Eine Änderung, die die Präzision unter 85 % senkt, erreicht nicht mehr die Produktion, genau wie ein defekter Unit-Test einen Merge blockiert.

Legen Sie den Schwellenwert basierend auf der bereits erreichten Punktzahl der aktuellen Version fest, nicht auf einem Ideal. Setzen Sie ihn zu hoch, und Sie verurteilen das Team dazu, die Verifizierung mit temporären Deaktivierungen zu umgehen, die dann permanent werden; setzen Sie ihn zu niedrig, und Sie prüfen nichts, während Sie ein grünes Abzeichen anzeigen. Denken Sie schließlich daran, dass die Suite repräsentativ für den echten Verkehr bleiben muss: Ein Schwellenwert, der an zwanzig vor zwei Jahren geschriebenen Fällen erfüllt wird, beweist nichts über die heutigen Anfragen.

def ci_eval_check(prompt_config: dict,
                   test_suite: str,
                   min_score: float = 0.85) -> bool:
    """CI/CD-Gate: Prüft, ob der Prompt den Mindestwert erreicht."""
    pipeline = EvalPipeline(test_suite)

    def accuracy(question, prediction, reference):
        return 1.0 if prediction.strip().lower() == reference.strip().lower() else 0.0

    results = pipeline.run(prompt_config, [accuracy])
    avg_score = results["average_scores"].get("accuracy", 0)

    print(f"Durchschnittliche Punktzahl: {avg_score:.2%}")
    print(f"Mindestschwellenwert: {min_score:.2%}")

    if avg_score < min_score:
        print("FEHLER: Punktzahl unter Schwellenwert")
        return False

    print("ERFOLG: Prompt validiert")
    return True

Bewertungs-Dashboard

Verfolgen Sie die Entwicklung der Punktzahlen über die Zeit. Eine einzelne Punktzahl sagt nichts aus; die Reihe erzählt die Geschichte Ihres Prompts und beantwortet die Frage, die in Meetings immer wieder aufkommt: Machen wir Fortschritte? Die Funktion unten erzeugt eine Markdown-Tabelle, die nebeneinander für jede Version die durchschnittliche Punktzahl, verbrauchte Tokens und die geschätzten Kosten anzeigt. Das Format ist nicht zufällig: Es lässt sich direkt in einen Pull-Request kopieren, wodurch der Vergleich für Personen lesbar wird, die Ihren Code niemals öffnen werden.

def comparison_report(results: dict[str, dict]) -> str:
    """Erstellt einen Vergleichsbericht zwischen Prompt-Versionen."""
    report = "# Vergleichender Bewertungsbericht\n\n"
    report += "| Version | Durchschnittliche Punktzahl | Durchschnittliche Tokens | Kosten |\n"
    report += "|---------|---------------|----------------|------|\n"

    for version, data in results.items():
        score = data.get("average_scores", {})
        score_val = list(score.values())[0] if score else 0
        tokens = data.get("total_token_cost", 0)
        report += (f"| {version} | {score_val:.2%} | "
                   f"{tokens} | ${tokens * 5 / 1e6:.4f} |\n")

    return report

Einrichtung Ihrer Guardrails

Erstellen Sie eine Suite mit zwanzig Testfällen für einen echten Prompt, indem Sie einige Randfälle anstelle von zwanzig komfortablen Beispielen platzieren: Eine Suite, die beim ersten Versuch zu 100 % besteht, lehrt Ihnen nichts. Implementieren Sie die drei Bewertungstypen und führen Sie sie gemeinsam auf zwei Versionen Ihres Prompts aus. Exakte Übereinstimmung liefert eine saubere Zahl, semantische Ähnlichkeit erfasst legitime Neuformulierungen, und der Richter beleuchtet Fälle, in denen die ersten beiden nicht übereinstimmen – diese Diskrepanzen sind am reichhaltigsten an Lehren darüber, was Sie tatsächlich vom Modell erwarten.

Vergleichen Sie, identifizieren Sie die gewinnende Version und richten Sie dann das CI-Skript ein, das die Bereitstellung blockiert, wenn die Punktzahl sinkt. Sie werden wissen, dass das System funktioniert, an dem Tag, an dem es eine Änderung ablehnt, die Sie für offensichtlich gehalten haben.

Kernaussagen

  • Automatisierte Bewertung ist unerlässlich, um mit Zuversicht zu iterieren
  • Kombinieren Sie exakte, semantische und LLM-as-Judge-Bewertung je nach Bedarf
  • Pflegen Sie eine Test-Suite, die sich mit Ihrer Anwendung entwickelt
  • Integrieren Sie die Bewertung in Ihre CI/CD mit einem Mindestschwellenwert
  • Verwenden Sie ein leistungsfähigeres Modell als Richter, um ein kostengünstigeres Modell zu bewerten
  • Dokumentieren Sie die Punktzahlen jeder Version, um die Entwicklung zu verfolgen

Wissen prüfen

Fortgeschrittene Techniken und Industrialisierung: die letzte Kontrolle.

1. Was enthält ein effektives System-Prompt?

Antwort: Rolle, Umfang, Verhaltensregeln, Ausgabeformat und Behandlung von Randfällen – geschrieben wie eine Spezifikation, getestet wie Code.

2. Wann sollten Sie Selbstkonsistenz anwenden?

Antwort: Bei Aufgaben mit logischem Schlussfolgern und überprüfbaren Antworten: Generieren Sie mehrere unabhängige Schlussfolgerungen und behalten Sie die Mehrheitsantwort – Varianz wird zum Verbündeten.

3. Was garantiert JSON-Modus mit Schema-Enforcement?

Antwort: Eine Ausgabe, die strikt dem Schema entspricht (Typen, erforderliche Felder, Aufzählungen) – validiert auf der API-Seite und erneut im Code (JSON Schema, Zod) für eine unerwartungsfreie Kette.

4. Was ist Grounding?

Antwort: Das Ankeren von Antworten in bereitgestellten Fakten (Dokumente, abgerufene Daten) statt im Gedächtnis des Modells – mit der Anforderung, Quellen anzuführen oder sich zu enthalten.

5. Was ist der Zweck eines versionierten Prompt-Katalogs?

Antwort: Prompts als Artefakte zu behandeln: Versionen, A/B-Tests, automatisierte Bewertungen bei jeder Änderung – Sie wissen, was in der Produktion läuft und warum.

Der letzte Loop des Kurses – versionieren, testen, automatisch bewerten – verwandelt handwerkliches Prompt-Engineering in eine Teampraxis.