Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

A/B-Tests für Prompts

Lektion 15 von 16 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. A/B-Tests für Prompts
  2. Prinzip
  3. A/B-Test-Framework
  4. Bewertungsmetriken
  5. Komplettes Beispiel: Testen zweier Prompt-Stile
  6. Statistische Signifikanz
  7. Durchführen Ihres ersten Experiments
  8. Kernaussagen

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 mit medium reasonieren. Aufrufe, die diese Parameter setzen, müssen daher reasoning={"effort": "none"} (Responses API) oder reasoning_effort="none" (Chat Completions) angeben. Quellen: Using GPT-6 · GPT-5.6 Terra.

A/B-Tests für Prompts

Mit A/B-Tests für Prompts können Sie zwei Versionen eines Prompts objektiv unter Verwendung echten Datenverkehrs vergleichen. Anstatt einen Prompt basierend auf Intuition auszuwählen, messen Sie, welche Version bessere Ergebnisse gemäß Ihren Geschäftsmetriken liefert. Dies ist der obligatorische Schritt zwischen Prototyping und Produktion.

Prinzip

Der eingehende Datenverkehr wird zufällig zwischen zwei (oder mehr) Prompt-Varianten aufgeteilt. Jede Antwort wird anhand vordefinierter Kriterien bewertet, und die siegreiche Variante wird für 100 % des Datenverkehrs bereitgestellt.

Die Stärke dieser Methode liegt darin, dass beide Varianten denselben Datenverkehr unter denselben Bedingungen zur gleichen Zeit sehen. Alle externen Quellen für Variationen – Saisonalität, Netzwerkvorfälle, die Ankunft einer neuen Kategorie von Anfragen – wirken sich auf beide Gruppen gleich aus und heben sich im Vergleich auf. Ein sequentieller Test kann dies nicht garantieren: Wenn Sie den alten Prompt eine Woche lang und den neuen in der folgenden Woche ausführen, können Sie nicht feststellen, ob die Verbesserung auf Ihrer Umschreibung oder auf dem Kalender beruht.

A/B-Test-Framework

Die PromptExperiment-Klasse hat drei Verantwortlichkeiten. assign_variant entscheidet, welche Variante einer bestimmten Anfrage dient, run führt den Aufruf aus und protokolliert das Ergebnis, und get_stats aggregiert die Daten.

Die Zuordnung verdient eine Anmerkung. Wenn eine user_id bereitgestellt wird, ist sie deterministisch und wird aus einem Hash des Experiment-Nutzer-Paares berechnet. Der gleiche Nutzer bleibt von einem Aufruf zum nächsten in derselben Gruppe. Diese Kontinuität ist keine theoretische Verfeinerung: Ein Kunde, der eine warme Antwort erhält und dann drei Minuten später eine trockene Antwort auf seine Nachfolgeanfrage, wird dies für einen Fehler halten, und seine Unzufriedenheit wird beide Varianten verschmutzen.

Jede Ausführung protokolliert die Eingabe, den Ausgabeinhalt, die verbrauchten Tokens und den Zeitstempel. Diese Tokens dienen nicht der Dekoration: Eine Variante könnte in der Qualität gewinnen, aber die Antwortlänge verdoppeln, und _estimate_cost übersetzt diese Lücke in Dollar, damit Sie eine informierte Abwägung treffen können.

import random
import json
from datetime import datetime
from openai import OpenAI

client = OpenAI()

class PromptExperiment:
    """A/B-Test-Framework für Prompts."""

    def __init__(self, name: str, variants: dict[str, dict]):
        """
        variants = {
            "control": {"system_prompt": "...", "model": "gpt-5.6-terra",
                        "temperature": 0.3},
            "variant_a": {"system_prompt": "...", "model": "gpt-5.6-terra",
                          "temperature": 0.1},
        }
        """
        self.name = name
        self.variants = variants
        self.results = {v: [] for v in variants}

    def assign_variant(self, user_id: str = None) -> str:
        """Weist eine Variante zu (sticky bei Bereitstellung von user_id)."""
        if user_id:
            # Deterministische Zuordnung durch Nutzer
            hash_val = hash(f"{self.name}:{user_id}") % 100
            keys = sorted(self.variants.keys())
            split = 100 // len(keys)
            for i, key in enumerate(keys):
                if hash_val < (i + 1) * split:
                    return key
            return keys[-1]
        return random.choice(list(self.variants.keys()))

    def run(self, input_text: str, user_id: str = None,
            schema: dict = None) -> dict:
        """Führt den Prompt mit der zugewiesenen Variante aus."""
        variant_name = self.assign_variant(user_id)
        variant = self.variants[variant_name]

        kwargs = {
            "model": variant["model"],
            "instructions": variant["system_prompt"],
            "input": input_text,
            "temperature": variant.get("temperature", 0.3)
        }

        if schema:
            kwargs["text"] = {
                "format": {
                    "type": "json_schema",
                    "name": "response",
                    "schema": schema,
                    "strict": True
                }
            }

        response = client.responses.create(**kwargs)

        result = {
            "variant": variant_name,
            "input": input_text,
            "output": response.output_text,
            "tokens_input": response.usage.input_tokens,
            "tokens_output": response.usage.output_tokens,
            "timestamp": datetime.now().isoformat()
        }

        self.results[variant_name].append(result)
        return result

    def get_stats(self) -> dict:
        """Berechnet Statistiken pro Variante."""
        stats = {}
        for variant, results in self.results.items():
            if not results:
                continue
            tokens_in = [r["tokens_input"] for r in results]
            tokens_out = [r["tokens_output"] for r in results]
            stats[variant] = {
                "count": len(results),
                "avg_tokens_input": sum(tokens_in) / len(tokens_in),
                "avg_tokens_output": sum(tokens_out) / len(tokens_out),
                "total_cost_estimate": self._estimate_cost(
                    sum(tokens_in), sum(tokens_out)
                )
            }
        return stats

    def _estimate_cost(self, tokens_in: int,
                        tokens_out: int) -> float:
        """Schätzt Kosten in USD."""
        return (tokens_in * 2.5 + tokens_out * 10) / 1_000_000

Bewertungsmetriken

Metriken hängen von Ihrem Anwendungsfall ab, und zwei Familien decken die meisten Szenarien ab. Wenn die Aufgabe eine richtige Antwort hat – eine Ticket-Klassifizierung, das Extrahieren eines Feldes – reduziert sich die Bewertung auf den Vergleich mit einem Referenzlabel. Dies ist die Rolle von evaluer_classification. Beachten Sie eine lehrreiche Wahl hier: Parsing-Fehler werden als leere Vorhersagen behandelt, anstatt eine Ausnahme auszulösen, da eine Variante, die ungültiges JSON erzeugt, im Score bestraft werden sollte, nicht die Messung abstürzen lassen.

Wenn die Aufgabe freien Text erzeugt, gibt es keine einzelne richtige Antwort, also bitten Sie das Modell um Schiedsrichterfunktion. evaluer_qualite_texte zerlegt das Urteil in vier Kriterien – Relevanz, Klarheit, Vollständigkeit, professioneller Ton –, anstatt nach einer direkten Gesamtnote zu fragen. Diese Zerlegung macht die Bewertung stabiler und zeigt Ihnen, auf welcher Achse die siegreiche Variante überlegen ist: Zu wissen, dass der Gewinn aus dem Ton und nicht aus der Vollständigkeit stammt, ist genau die Information, die Sie benötigen, um die nächste Version zu schreiben.

def evaluer_classification(result: dict,
                            label_attendu: str) -> dict:
    """Bewertet eine Klassifizierungsantwort."""
    try:
        output = json.loads(result["output"])
        prediction = output.get("category", "")
    except json.JSONDecodeError:
        prediction = ""

    return {
        "correct": prediction == label_attendu,
        "prediction": prediction,
        "attendu": label_attendu
    }

def evaluer_qualite_texte(result: dict) -> dict:
    """Bewertet die Qualität einer Textantwort unter Verwendung des LLM."""
    eval_response = client.responses.create(
        model="gpt-5.6-terra",
        reasoning={"effort": "none"},  # temperature erfordert effort none
        instructions="Sie sind ein Textqualitätsbewerter. "
                     "Bewerten Sie von 10 basierend auf: Relevanz, Klarheit, "
                     "Vollständigkeit, professioneller Ton.",
        input=f"Frage: {result['input']}\n\n"
              f"Antwort: {result['output']}",
        text={
            "format": {
                "type": "json_schema",
                "name": "evaluation",
                "schema": {
                    "type": "object",
                    "properties": {
                        "pertinence": {"type": "integer"},
                        "clarte": {"type": "integer"},
                        "completude": {"type": "integer"},
                        "ton": {"type": "integer"},
                        "note_globale": {"type": "number"},
                        "commentaire": {"type": "string"}
                    },
                    "required": ["pertinence", "clarte",
                                 "completude", "ton",
                                 "note_globale", "commentaire"],
                    "additionalProperties": False
                },
                "strict": True
            }
        },
        temperature=0.1
    )
    return json.loads(eval_response.output_text)

Komplettes Beispiel: Testen zweier Prompt-Stile

Das folgende Experiment kontrastiert zwei Ansätze für den Kundensupport. Die Kontrollgruppe verwendet eine minimale, professionelle und neutrale Anweisung. Die „empathische” Variante verhängt eine dreistufige Struktur: das Problem anerkennen, Empathie zeigen und dann eine konkrete Lösung mit Schritten vorschlagen. Alles andere ist identisch, vom Modell bis zur Temperatur. Diese Symmetrie ist die Bedingung, um jegliche gemessene Lücke dem Prompt zuzuschreiben. Die gleichzeitige Änderung von Ton und Temperatur würde ein uninterpretierbares Ergebnis liefern.

Die fünf Test-Tickets decken absichtlich verschiedene Register ab: ein emotional aufgeladenes Lieferungsereignis, ein funktionales Bug, eine neutrale Passwortfrage, einen kontroversen Rückerstattungsantrag und einen API-Ausfall, der von einem technischen Profil gemeldet wurde. Sie erwarten, dass die empathische Variante die ersten beiden dominiert und auf dem letzten bestraft wird, wo der Gesprächspartner einen Status und eine ETA wünscht, nicht Mitleid. Dies ist die Nuance, die ein globaler Durchschnitt maskiert und die eine Ticket-für-Ticket-Untersuchung aufdeckt – was oft zur echten Entscheidung führt: basierend auf der Anfrageart routen, anstatt einen einzigen Ton zu wählen.

experiment = PromptExperiment(
    name="customer-support-style",
    variants={
        "control": {
            "system_prompt": "Sie sind ein Support-Mitarbeiter. "
                             "Antworten Sie professionell.",
            "model": "gpt-5.6-terra",
            "temperature": 0.3
        },
        "empathique": {
            "system_prompt": "Sie sind ein fürsorglicher Support-Mitarbeiter. "
                             "Beginnen Sie damit, das Problem des Kunden anzuerkennen, "
                             "zeigen Sie Empathie und schlagen Sie dann eine konkrete Lösung "
                             "mit Schritten vor.",
            "model": "gpt-5.6-terra",
            "temperature": 0.3
        }
    }
)

# Datenverkehr simulieren
test_tickets = [
    "Meine Sendung ist seit zwei Wochen nicht angekommen.",
    "Die App stürzt ab, wenn ich auf Einstellungen klicke.",
    "Wie ändere ich mein Passwort?",
    "Ich möchte eine Rückerstattung, das Produkt ist defekt.",
    "Ihre API gibt seit heute Morgen einen 500-Fehler zurück.",
]

for ticket in test_tickets:
    result = experiment.run(ticket)
    quality = evaluer_qualite_texte(result)
    print(f"Variante: {result['variant']} | "
          f"Score: {quality['note_globale']}/10")

print("\nStatistiken:")
print(json.dumps(experiment.get_stats(), indent=2))

Statistische Signifikanz

Ziehen Sie keine Schlüsse zu schnell. Bei wenig Daten sind die Ergebnisse verrauscht, und der klassische Fehler besteht darin, 7,4 gegenüber 6,9 über zwölf Beobachtungen zu sehen und einen Gewinner zu erklären. Der untenstehende t-Test von Student beantwortet die einzige Frage, die zählt: Ist die beobachtete Lücke größer als das, was Zufall zwischen zwei äquivalenten Reihen natürlicherweise produzieren würde?

Ein p_value unter 0,05 bedeutet, dass eine solche Lücke unwahrscheinlich wäre, wenn die beiden Varianten gleich wären. Darüber hinaus haben Sie nichts bewiesen – was nicht dasselbe ist wie die Demonstration der Gleichheit. Meistens fehlt Ihnen einfach nur Daten. Zählen Sie auf ein Minimum von hundert Beobachtungen pro Variante, bevor Sie schlussfolgern, und wachen Sie vor dem Drang auf, die Ergebnisse jeden Morgen zu prüfen. Wenn Sie oft genug schauen, werden Sie immer einen Moment finden, in dem die Lücke bedeutsam erscheint.

from scipy import stats

def test_significativite(scores_a: list[float],
                          scores_b: list[float]) -> dict:
    """Student's t-Test zum Vergleich zweier Varianten."""
    t_stat, p_value = stats.ttest_ind(scores_a, scores_b)

    return {
        "moyenne_a": sum(scores_a) / len(scores_a),
        "moyenne_b": sum(scores_b) / len(scores_b),
        "p_value": p_value,
        "significatif": p_value < 0.05,
        "recommandation": (
            "Signifikante Differenz, deployen Sie die siegreiche Variante"
            if p_value < 0.05
            else "Nicht genügend Daten oder keine signifikante Differenz"
        )
    }

Durchführen Ihres ersten Experiments

Nehmen Sie eine Aufgabe, die Sie gut kennen, und richten Sie eine PromptExperiment mit zwei Varianten ein, wobei Sie nur eine Sache zwischen der Kontrollgruppe und der Variante ändern: einen Ton, eine auferlegte Struktur oder eine zusätzliche Anweisung. Definieren Sie zwei oder drei Metriken, bevor Sie etwas starten, denn die Wahl der Metrik nach dem Sehen der Ergebnisse ist wie das Vorauswählen des Gewinners, und es ist der häufigste Bias in hausgemachten Tests.

Führen Sie das Experiment auf zwanzig Eingaben aus und analysieren Sie es. Schauen Sie auf den Durchschnitt, aber öffnen Sie vor allem die Fälle, in denen sich die beiden Varianten am stärksten unterscheiden: diese erklären die Lücke. Zwanzig Beobachtungen werden offensichtlich nicht ausreichen, um Signifikanz zu erreichen, und dies selbst zu erkennen, ist besser als es hier zu lesen. Dokumentieren Sie schließlich die Entscheidung und archivieren Sie die rohen Ergebnisse mit dem Datum und der genauen Variant-Konfiguration – dieses Archiv wird verhindern, dass Sie in einem Jahr dasselbe Experiment erneut durchführen.

Kernaussagen

  • A/B-Tests ersetzen Intuition durch messbare Daten
  • Weisen Sie Varianten deterministisch nach Nutzer zu
  • Messen Sie Geschäftsmetriken, nicht nur wahrgenommene Qualität
  • Warten Sie auf statistische Signifikanz, bevor Sie schlussfolgern
  • Dokumentieren Sie jedes Experiment und seine Ergebnisse