💻 computer science

A Systematic Methodology for Evaluating Failure Independence in LLM-Generated Code

Diese Arbeit führt eine systematische Methodik zur Bewertung der Unabhängigkeit von Fehlern in LLM-generiertem Code ein und zeigt auf, dass heterogene Modelle zwar eine gewisse Diversität bieten, ihre Implementierungen jedoch häufig dieselben Grundursachen aufweisen und an denselben Testfällen scheitern, wodurch die für effektive N-Version-Programmierung erforderliche Annahme der Unabhängigkeit verletzt wird.

Ursprüngliche Autoren: Rodrigo Pato Nogueira, Karthik Pattabiraman, Marco Vieira, João R. Campos

Veröffentlicht 2026-07-07

📖 5 Min. Lesezeit🧠 Tiefgang

CC BY 4.0

Ursprüngliche Autoren: Rodrigo Pato Nogueira, Karthik Pattabiraman, Marco Vieira, João R. Campos

Originalarbeit lizenziert unter CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Dies ist eine KI-generierte Erklärung des untenstehenden Papers. Sie wurde nicht von den Autoren verfasst oder gebilligt. Für technische Genauigkeit konsultieren Sie das Originalpaper. Vollständigen Haftungsausschluss lesen

Stellen Sie sich vor, Sie bauen eine kritische Brücke. Um sicherzustellen, dass sie nicht einstürzt, beschließen Sie, fünf verschiedene Ingenieurteams zu engagieren, die exakt denselben Stützbalken entwerfen sollen. Die Idee dahinter ist: Wenn Team A einen Fehler macht, trifft Team B es vielleicht richtig, und wenn Team C ebenfalls richtig liegt, können Sie sich einfach der Mehrheitsmeinung anschließen. Dies wird als N-Version-Programmierung bezeichnet. Es ist ein Sicherheitsnetz, das auf einer großen Annahme beruht: dass die Teams unabhängig genug sind, damit sie nicht alle exakt denselben Fehler machen.

Seit Jahrzehnten wissen wir, dass menschliche Teams diesen Test oft nicht bestehen: Sie lesen dieselben Baupläne, nutzen dieselben Lehrbücher und machen am Ende dieselben Fehler. Doch nun haben wir Large Language Models (LLMs) – KI-Systeme, die Code sofort und kostengünstig schreiben können. Die Hoffnung war, dass diese KI-Modelle, da sie „unterschiedlich“ sind, wie ein perfektes Team unabhängiger Ingenieure agieren könnten, die auf unterschiedliche Weise scheitern, sodass wir uns immer auf die Mehrheit verlassen können.

Diese Arbeit stellt eine einfache, entscheidende Frage: Ist diese Hoffnung real? Scheitern diese KI-Modelle tatsächlich unabhängig voneinander, oder stolpern sie alle über dieselbe unsichtbare Bananenschale?

Das Experiment: Eine „Code-Olympiade“

Die Forscher setzten ein massives Experiment auf, vergleichbar mit einer Coding-Olympiade.

Die Athleten: Sie verwendeten 12 verschiedene KI-Modelle (einige von großen Tech-Unternehmen, einige Open-Source, einige sehr intelligent, andere weniger so).
Die Disziplinen: Sie gaben ihnen 224 verschiedene Programmieraufgaben, die sie lösen sollten.
Die Regeln: Sie baten die KIs, Lösungen in 5 verschiedenen Programmiersprachen (wie Python, C++, Java) zu schreiben, und probierten 3 verschiedene Wege der Abfrage aus (einfache Prompts, schrittweise Argumentation oder „Sei kreativ“-Prompts).
Die Preisrichter: Sie betrachteten nicht nur den Code; sie ließen den Code gegen tausende Testfälle laufen, um zu sehen, wo er versagte.

Die Ergebnisse: Der „Echo-Kammer“-Effekt

Hier ist das, was sie herausgefunden haben, unterteilt in einfache Konzepte:

1. Das „Gleiche Gehirn“-Problem (Strukturelle Diversität)

Als die Forscher den Code selbst untersuchten, stellten sie fest: Wenn man ein spezifisches KI-Modell bittet, dieselbe Lösung fünfmal zu schreiben, schreibt es fast jedes Mal exakt denselben Code. Es ist, als würde man einer einzelnen Person bitten, fünf verschiedene Aufsätze zum selben Thema zu schreiben; sie werden wahrscheinlich denselben Wortschatz und dieselbe Satzstruktur verwenden.

Die Metapher: Wenn Sie fünf verschiedene Menschen bitten, eine Katze zu zeichnen, zeichnen sie vielleicht verschiedene Rassen. Aber wenn Sie dieselbe Person fünfmal bitten, eine Katze zu zeichnen, wird sie dieselbe Katze fünfmal zeichnen.
Das Ergebnis: Um unterschiedlicher aussehenden Code zu erhalten, müssen Sie verschiedene KI-Modelle verwenden. Dieselbe KI mit unterschiedlichen „Prompts“ (Anweisungen) zu verwenden, half kaum.

2. Die „Gemeinsame Schwachstelle“ (Verhaltensbezogene Diversität)

Selbst als der Code unterschiedlich aussah, prüften die Forscher, wo der Code scheiterte.

Die Metapher: Stellen Sie sich fünf verschiedene Fahrer vor, die eine Testfahrt machen. Fahrer A und Fahrer B fahren vielleicht unterschiedliche Autos und nehmen leicht unterschiedliche Routen, aber beide stoßen exakt zur gleichen Zeit in dasselbe Schlagloch.
Das Ergebnis: Die KIs waren nicht unabhängig. Sie scheiterten häufig an exakt denselben Testfällen. Selbst wenn 12 verschiedene Modelle im Einsatz waren, gerieten sie oft in dieselben logischen Fallen. Wenn eine KI bei einer bestimmten Matheaufgabe scheiterte, war eine andere KI sehr wahrscheinlich ebenfalls bei eben dieser Aufgabe am Scheitern.

3. Das Sicherheitsnetz hat Löcher (Zuverlässigkeitsgewinne)

Die Forscher versuchten die Strategie des „Mehrheitsvotierens“ (wenn 3 von 5 KIs sagen, die Antwort ist X, dann nehmen wir X).

Das Ergebnis: Es half ein wenig, aber bei weitem nicht so viel, wie die Theorie es vorhersagte.
- Wenn die KIs wirklich unabhängig gewesen wären, sollte die Kombination von fünf von ihnen das System nahezu perfekt gemacht haben.
- In der Realität war die Verbesserung weniger als halb so groß wie erwartet.
- Die harte Wahrheit: Keine Kombination mehrerer KIs war jemals zuverlässiger als das einzelne beste KI-Modell für sich allein. Das „Sicherheitsnetz“ hatte zu viele Löcher, weil alle durch dieselben Löcher fielen.

4. Warum sind sie gescheitert? (Fehleranalyse)

Die Forscher gruben tief nach dem Warum hinter den Fehlern der KIs. Sie fanden heraus, dass die Fehler an der Oberfläche zwar unterschiedlich aussehen mögen, aber oft auf die gleiche Grundursache zurückzuführen sind.

Die Metapher: Eine KI scheitert vielleicht, weil sie vergessen hat zu prüfen, ob eine Zahl negativ ist, während eine andere scheitert, weil sie mit einer großen Zahl verwirrt wurde. Aber beide scheitern eigentlich daran, dass sie das Konzept von „Grenzwerten“ auf die gleiche Weise nicht verstehen. Sie teilen dieselbe „Denkschwäche“.
Das Ergebnis: Die KIs machen keine zufälligen Fehler; sie machen systematische Fehler, die auf die Art und Weise ihrer Ausbildung basieren.

Das Fazit

Das Paper kommt zu dem Schluss, dass aktuelle KI-Modelle nicht unabhängig genug sind, um in einem „Sicherheitsnetz“-System verwendet zu werden, bei dem man sich auf eine Mehrheitsentscheidung verlässt, um Fehler abzufangen.

Die Verwendung verschiedener Modelle hilft ein wenig: Es ist besser, Modelle zu mischen, als dasselbe Modell fünfmal zu verwenden.
Das Ändern der Sprache oder des Prompts hilft kaum: Die KI zu bitten, „kreativ zu sein“, oder in Java statt in Python zu schreiben, verhinderte nicht, dass sie dieselben Fehler machten.
Die „Unabhängigkeits“-Annahme ist widerlegt: Die Idee, dass „verschiedene KIs auf unterschiedliche Weise scheitern werden“, ist derzeit ein Mythos. Sie scheitern gemeinsam.

Kurz gesagt: Wenn Sie ein kritisches System bauen und denken: „Ich frage einfach fünf verschiedene KIs und entscheide nach der Mehrheit“, warnt Sie dieses Paper: Tun Sie das nicht. Sie werden höchstwahrscheinlich alle das Gleiche falsch machen, und Sie werden nicht sicherer sein, als wenn Sie einfach nur einmal die klügste einzelne KI gefragt hätten.

Technisches Resümee: Eine systematische Methodik zur Evaluierung der Fehlerunabhängigkeit von LLM-generiertem Code

Problemstellung

N-Version-Programmierung (NVP) ist eine Technik zur Fehlertoleranz, die die Softwarezuverlässigkeit verbessert, indem sie mehrere unabhängige Implementierungen derselben Spezifikation ausführt und deren Ausgaben kombiniert (z. B. via Mehrheitsentscheidung). Ihre Wirksamkeit beruht auf der Annahme, dass unabhängig entwickelte Versionen auch unabhängig voneinander ausfallen. Empirische Studien haben jedoch gezeigt, dass von Menschen entwickelte Versionen oft bei denselben Eingaben ausfallen, was auf gemeinsame Interpretationen ambivalenter Spezifikationen und gängiger Designstrategien zurückzuführen ist, wodurch die Zuverlässigkeitsgewinne erheblich reduziert werden. Darüber hinaus hat der hohe Aufwand für die Entwicklung und Wartung mehrerer menschlicher Teams die Einführung von NVP begrenzt.

Große Sprachmodelle (LLMs) bieten eine potenzielle Lösung für die Kostenbarriere, indem sie mehrere Implementierungen in großem Maßstab generieren. Es bleibt jedoch unklar, ob LLM-generierte Lösungen die kritische Annahme der Fehlerunabhängigkeit erfüllen. Die aktuelle Forschung zur LLM-Codegenerierung konzentriert sich auf funktionale Korrektheit, syntaktische Diversität und Codequalität, lässt aber eine Methodik vermissen, um zu bestimmen, ob unabhängig generierte Implementierungen unabhängig voneinander ausfallen. Ohsten eine solche Methodik fehlt, ist es unmöglich zu beurteilen, ob NVP mit LLMs rentabel ist oder um den durch Redundanz erzielbaren Zuverlässigkeitsgewinn zu quantifizieren.

Methodik

Die Autoren schlagen die erste systematische Methodik vor, um die Fehlerunabhängigkeit in LLM-generiertem Code zu bewerten. Das Framework evaluiert Implementierungen über drei komplementäre Dimensionen hinweg:

Strukturelle Diversität: Misst die Unterschiede in der statischen Struktur des Codes (Organisation, Kontrollfluss, Syntax) mittels CodeBLEU-Ähnlichkeit. Dies erfasst oberflächliche Unterschiede in der Art und Weise, wie Lösungen geschrieben werden.
Behaviorale Diversität: Misst, ob Implementierungen auf denselben Eingaben häufiger ausfallen als durch Zufall zu erwarten wäre. Die Autoren passen das Hypergeometrische-Verteilungsmodell an (ursprünglich von Knight und Leveson verwendet), um einen Z-Score ( $Z_{ij}$ ) für Paare von Lösungen zu berechnen. Dieser Score quantifiziert die Abweichung der beobachteten Kofehler von der erwarteten Überschneidung unter der Nullhypothese der Unabhängigkeit, wobei die Gesamtausfallrate jeder Lösung kontrolliert wird.
Zuverlässigkeitsgewinne: Simuliert N-Version-Mehrheitsentscheidungen ( $N \in \{3, 5\}$ ), um die praktische Zuverlässigkeitsverbesserung zu quantifizieren. Die Studie führt eine Metrik namens Redundanzeffektivität ein, definiert als der Bruchteil des theoretischen Zuverlässigkeitsgewinns (der unter perfekter Unabhängigkeit erreichbar wäre), der tatsächlich durch das Ensemble realisiert wird.

Experimentelles Setup:

Datensatz: Abgeleitet vom PROBE-Benchmark (1.651 wettbewerbsorientierte Probleme). Die Autoren kuratierten eine Teilmenge von 224 Problemen, indem sie triviale oder unlösbare Aufgaben herausfilterten und die Test-Suites durch Fuzzing und Multi-Agenten-Generierung erweiterten, um eine hohe Abdeckung (96,7 % Zeilen, 94,8 % Zweige) und Robustheit gegenüber Grenzfällen zu gewährleisten.
Systeme: Evaluiert wurden 12 diverse LLMs (proprietär und Open-Source, variierend in Größe und Architektur) über 5 Programmiersprachen (Python, C++, Java, C, Rust) und 3 Prompting-Strategien (Baseline, Chain-of-Thought, Out-of-the-box).
Verfahren: Die generierten Lösungen wurden auf grundlegende Korrektheit gefiltert, gegen die erweiterten Test-Suites evaluiert und einer strukturellen/behavioralen Analyse unterzogen. Eine manuelle Fehleranalyse wurde an einer Teilmenge teilweise korrekter Implementierungen durchgeführt, um die Ursachen zu identifizieren.

Zentrale Beiträge

Eine neuartige Methodik: Das Paper führt das erste systematische Framework zur Evaluierung der Fehlerunabhängigkeit in LLM-generiertem Code ein und geht über Korrektheitsmetriken hinaus, indem es direkt die Fehlerkorrelation und die Redundanzeffektivität misst.
Umfassende empirische Studie: Die Studie wendet diese Methodik auf einen großen Datensatz an (224 Probleme, 12 Modelle, 5 Sprachen, 3 Strategien) und bietet damit die bisher umfangreichste Evaluierung der Fehlerkorrelation in LLM-Code.
Öffentlicher Datensatz: Die Autoren stellen einen Datensatz mit Prompts, generiertem Code, Unit-Tests und Metriken zur Verfügung, um die Reproduzierbarkeit und zukünftige Forschung zu ermöglichen.
Detaillierte Analyse: Die Studie liefert granulare Einblicke in strukturelle vs. behaviorale Diversität, Zuverlässigkeitsgewinne und Fehler-Ebene-Ähnlichkeiten, wobei zwischen oberflächlichen Code-Unterschieden und zugrunde liegenden Fehlermodi unterschieden wird.

Ergebnisse

Strukturelle Diversität (RQ1)

Implementierungen aus dem selben Modell sind strukturell hochgradig ähnlich (z. B. CodeBLEU-Scores von 0,76 für C++ innerhalb desselben Modells vs. 0,55 über verschiedene Modelle hinweg).
Verschiedene Modelle produzieren deutlichere Lösungen, aber die Diversität konzentriert sich weitgehend auf die Oberfläche (n-Gramme, Syntax). Tiefere strukturelle Eigenschaften (AST, Datenfluss) zeigen weniger Variation.
Prompting-Strategien haben im Vergleich zur Modellwahl einen vernachvernachlässigbaren Einfluss auf die strukturelle Diversität.

Behaviorale Diversität (RQ2)

Hohe Korrelation: Fehler sind stark korreliert. Der durchschnittliche paarweise Ähnlichkeitswert ( $Z_{ij}$ ) beträgt 2,04, was eine signifikante Abweichung von der Unabhängigkeit anzeigt. 65,9 % der Implementationspaare zeigen eine statistisch signifikante positive Abweichung.
Modell-Einfluss: Die Modellwahl ist der stärkste Faktor. Lösungen desselben Modells fallen auf denselben Eingaben weita viel häufiger aus als erwartet. Während stärkere Modelle im Vergleich zu anderen Modellen deutlichere Fehlermuster aufweisen, bleiben sie intern hochgradig korreliert.
Grenzfälle: Die Korrelation steigt bei Grenzfällen (Ähnlichkeitswert steigt auf 3,39), was darauf hindeutet, dass schwierige Bedingungen die Fehlermodi noch stärker angleichen.
Sprache/Prompting: Die Sprache hat einen moderaten Effekt (Python zeigt eine höhere interne Ausrichtung), während Prompting-Strategien vernachlässigbare Auswirkungen haben.

Zuverlässigkeitsgewinne (RQ3)

Bescheidene Gewinne: N-Version-Mehrheitsentscheidungen liefern nur bescheidene Zuverlässigkeitsverbesserungen. Die Zuverlässigkeit steigt von 0,88 (Einzelversion) auf 0,90 ( $N=3$ ) und 0,91 ( $N=5$ ).
Geringe Effektivität: Die Redundanzeffektivität ist gering (0,43 für $N=3$ , 0,44 für $N=5$ ), was bedeutet, dass Ensembles weniger als die Hälfte des Zuverlässigkeitsgewinns erfassen, der unter Unabhängigkeit möglich wäre.
Modellselektion: Heterogene Ensembles (verschiedene Modelle) performen signifikant besser als homogene, aber selbst die besten heterogenen Kombinationen übertreffen nicht die Zuverlässigkeit des stärksten Einzelmodells (GPT-OSS).
Abnehmender Ertrag: Das Hinzufügen weiterer Versionen führt zu abnehmenden Erträgen und erreicht die theoretischen Grenzen der Unabhängigkeit nicht.

Fehleranalyse (RQ4)

Gemeinsame Ursachen: Manuelle Inspektionen zeigen, dass selbst wenn Fehlermuster unterschiedlich erscheinen, sie oft auf dieselben zugrunde liegenden Fehler zurückzuführen sind (z. B. Abhängigkeit von globalen Heuristiken, Integer-Überläufe oder suboptimaler algorithmischer Komplexität).
Modellspezifische Muster: Spezifische Modelle reproduzieren konsistent dieselben fehlerhaften Denkprozesse. Stärkere Modelle vermeiden zwar einfache Fehler, zeigen aber dennoch konsistente interne Fehlermuster bei komplexen Eingaben.

Signifikanz und Behauptungen

Das Paper behauptet, dass die die Unabhängigkeit der Fehler voraussetzende Annahme von NVP für aktuelle LLMs nicht gilt. Trotz der Fähigkeit von LLMs, Code kostengünstig zu generieren, teilen die resultierenden Implementierungen korrelierte Fehlermodi, die die Vorteile der Redundanz erheblich einschränken.

Praktische Implikation: Das bloße Generieren mehrerer Versionen von Code mit demselben Modell (oder sogar verschiedenen Modellen) reicht nicht aus, um die Vorteile der Fehlermaskierung von NVP zu erzielen. Die Zuverlässigkeitsgewinne sind bescheiden, und kein Ensemble übertrifft das beste Einzelmodell.
Methodischer Wert: Die vorgeschlagene Methodik dient als kritisches Werkzeug, um die Fehlerunabhängigkeit systematisch zu bewerten, während sich die Modelle weiterentwickeln. Sie verdeutlicht, dass strukturelle Diversität ein schlechter Stellvertreter für Fehlerunabhängigkeit ist und dass behaviorale Diversität und Analysen auf Fehler-Ebene notwendig sind, um die wahre Robustheit von LLM-generiertem Code zu bewerten.
Zukünftige Richtungen: Die Autoren legen nahe, dass zukünftige Arbeiten sich auf Techniken konzentrieren müssen, die explizit auf behaviorale Diversität und Unabhängigkeit optimieren (z. B. diversitätsorientiertes Prompting oder Fine-Tuning), anstatt sich auf ad-hoc Modellkombinationen zu verlassen.

Die Studie kommt zu dem Schluss, dass LLMs zwar die Kosten von NVP senken, die fundamentale Barriere der Fehlerkorrelation jedoch bestehen bleibt, was neue Strategien erfordert, um echte Diversität in generierten Lösungen zu gewährleisten.