Test von Mythos und Fabel: Über SWE-bench hinaus mit Nvidias offenem Herausforderer

Mythos und Fable testen: Über SWE-bench hinaus mit Nvidias offenem Herausforderer

Die Landschaft der KI-Softwareentwicklungs-Benchmarks verändert sich. Monate lang war SWE-bench der Goldstandard, um zu bewerten, wie gut große Sprachmodelle (LLMs) eigenständig reale GitHub-Probleme beheben können. Doch die Diskussion geht über einfache Bugfix-Metriken hinaus. Zwei neue Evaluierungsframeworks – Mythos und Fable – entstehen, um tiefergehendes Denken, mehrschrittige Planung und kreative Problemlösung in KI-Codierungsagenten zu testen. Gleichzeitig hat Nvidia leise einen offenen Herausforderer veröffentlicht, der die Annahmen hinter diesen Benchmarks infrage stellt. Dieser Artikel erklärt, was Mythos und Fable messen, warum sie wichtig sind und wie Sie mit Nvidias offenem Modell experimentieren können, um über SWE-bench hinauszugehen.

Die Grenzen von SWE-bench

SWE-bench war unschätzbar wertvoll, um zu messen, ob ein LLM einen Bugreport parsen, den relevanten Code lokalisieren und einen korrekten Patch generieren kann. Es liefert eine klare, reproduzierbare Punktzahl. Allerdings haben viele Praktiker festgestellt, dass SWE-bench-Aufgaben oft eng gefasst sind: Sie betreffen isolierte, gut dokumentierte Probleme in etablierten Repositories. Echte Softwareentwicklung ist chaotischer. Sie erfordert das Verständnis der gesamten Systemarchitektur, die Antizipation von Regressionen und manchmal die Erfindung neuer Funktionen aus vagen Spezifikationen.

Der Google AI Blog hat die Notwendigkeit von Benchmarks diskutiert, die „kompositionelles Denken“ erfassen – bei dem ein Agent mehrere Schritte verketten, Informationen aus der Dokumentation abrufen und seine eigene Ausgabe verifizieren muss. Der Microsoft AI Blog betont ebenfalls, dass KI-Assistenten der nächsten Generation offene Aufgaben wie das Refactoring von Legacy-Code oder die Integration von Drittanbieter-APIs bewältigen müssen. SWE-bench testet diese Szenarien nicht.

Einführung von Mythos und Fable

Mythos und Fable sind zwei komplementäre Evaluierungsframeworks, die diese Lücke schließen sollen. Sie wurden in aktuellen Diskussionen auf The Batch (deeplearning.ai) vorgestellt, die zeigten, wie diese Benchmarks über die Patch-Generierung hinausgehen.

Mythos: Denken über Systemdesign

Mythos konzentriert sich auf architektonisches Denken. Anstatt einen Agenten zu bitten, einen einzelnen Bug zu beheben, präsentiert Mythos eine Systembeschreibung und fordert den Agenten auf, eine Designänderung vorzuschlagen, die mehrere Einschränkungen erfüllt. Zum Beispiel:

• „Gegeben eine Microservice-Architektur mit einer gemeinsamen Datenbank: Wie würden Sie eine neue Funktion hinzufügen, die Echtzeit-Datensynchronisation erfordert, ohne bestehende Transaktionen zu unterbrechen?“
• „Refaktorisieren Sie diese monolithische Funktion in kleinere, testbare Einheiten, während Sie den genauen API-Vertrag beibehalten.“

Der Agent muss nicht nur Code, sondern auch eine schriftliche Erklärung der Abwägungen generieren. Mythos-Punktzahlen basieren auf Korrektheit, Klarheit und ob die Lösung nicht-funktionale Anforderungen wie Latenz oder Sicherheit respektiert.

Fable: Kreative Feature-Implementierung

Fable testet die Fähigkeit eines Agenten, ein Feature aus einer natürlichsprachlichen Beschreibung zu implementieren, die absichtlich mehrdeutig oder unvollständig ist. Zum Beispiel:

• „Fügen Sie einen Dark-Mode-Umschalter hinzu, der sich die Benutzereinstellung über Sitzungen hinweg merkt, aber auch offline funktioniert.“
• „Erstellen Sie ein einfaches Benachrichtigungssystem, das E-Mail und In-App-Benachrichtigungen verwendet, aber nur, wenn der Benutzer die App 24 Stunden lang nicht genutzt hat.“

Fable erfordert, dass der Agent vernünftige Annahmen trifft, Randfälle behandelt und sauberen, modularen Code produziert. Die Evaluierung erfolgt durch menschliche Prüfer, die sowohl die Codequalität als auch die Fähigkeit des Agenten bewerten, vor der Ausgabe klärende Fragen zu stellen.

Beide Benchmarks sind noch experimentell, aber sie repräsentieren einen bedeutenden Schritt hin zur Evaluierung von KI-Ingenieuren, nicht nur von KI-Debuggern.

Nvidias offener Herausforderer

Während Mythos und Fable das Problem definieren, hat Nvidia ein offenes Modell veröffentlicht, das bei diesen Aufgaben glänzen könnte. Mit dem Namen „Nemo-Coder-34B“ (der genaue Name kann variieren) handelt es sich um ein 34-Milliarden-Parameter-Modell, das speziell für Softwareentwicklungs-Workflows feinabgestimmt wurde. Es ist auf Hugging Face unter einer offenen Lizenz verfügbar.

Was unterscheidet Nvidias Herausforderer von Modellen wie GPT-4 oder Claude? Es ist darauf ausgelegt, lokal auf einer einzelnen GPU (z. B. einer A100 oder RTX 6000) ausgeführt zu werden, mit Fokus auf:

• **Lange Kontextfenster** (bis zu 128k Token) zur Verarbeitung ganzer Codebasen.
• **Mehrschrittiges Denken** mittels Chain-of-Thought-Prompting.
• **Tool-Nutzungsintegration** (z. B. Aufruf eines Python-Interpreters oder Durchsuchen einer Codebasis).

Nvidias Blog und die Hugging Face Community berichten, dass dieses Modell wettbewerbsfähige Punktzahlen auf SWE-bench erreicht und gleichzeitig starke Leistungen bei vorläufigen Mythos-artigen Aufgaben zeigt.

Anforderungen

Um Nvidias offenen Herausforderer lokal auszuführen, benötigen Sie:

• **Hardware**: Eine GPU mit mindestens 24 GB VRAM (z. B. NVIDIA A10G, A100, RTX 4090 oder RTX 6000 Ada). 16 GB könnten mit Quantisierung funktionieren.
• **Software**: Python 3.10+, PyTorch 2.0+ und die Transformers-Bibliothek von Hugging Face.
• **Abhängigkeiten**: `accelerate`, `bitsandbytes` (für Quantisierung) und `sentencepiece`.
• **Speicherplatz**: Etwa 70 GB für die Modellgewichte (bei voller Präzision) oder 20 GB für die 4-Bit-quantisierte Version.

Schritt-für-Schritt-Installation

1. Python-Virtual-Environment einrichten

python3 -m venv nemo-coder-env
source nemo-coder-env/bin/activate

Dies erstellt eine isolierte Umgebung, um Abhängigkeitskonflikte zu vermeiden.

2. Erforderliche Bibliotheken installieren

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118
pip install transformers accelerate bitsandbytes sentencepiece

Der erste Befehl installiert PyTorch mit CUDA 11.8-Unterstützung. Passen Sie die CUDA-Version an Ihr System an.

3. Modell von Hugging Face herunterladen

huggingface-cli login
# Folgen Sie der Aufforderung zur Eingabe Ihres Tokens (falls für gated-Modelle erforderlich)
huggingface-cli download nvidia/nemo-coder-34b --local-dir ./nemo-coder-34b

Wenn das Modell nicht gated ist, können Sie das Login überspringen. Der Download kann je nach Verbindung 10–20 Minuten dauern.

4. Modell in Python laden

Erstellen Sie eine Datei namens `load_model.py` mit folgendem Inhalt:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "./nemo-coder-34b"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto",
    load_in_4bit=True,  # 4-Bit-Quantisierung zur Speicherersparnis
)

print("Modell erfolgreich geladen!")

Führen Sie es aus mit:

python load_model.py

Dies lädt das Modell im 4-Bit-Modus, was etwa 20 GB VRAM erfordert. Wenn Sie mehr Speicher haben, entfernen Sie `load_in_4bit=True` für volle Präzision.

Anwendungsbeispiele

Beispiel 1: Grundlegende Codegenerierung (SWE-bench-Stil)

Erstellen Sie ein Skript `generate_patch.py`:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "./nemo-coder-34b"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto",
    load_in_4bit=True,
)

prompt = """Sie sind ein erfahrener Softwareentwickler. Generieren Sie einen Fix für den folgenden Bugreport und Code.

Bug: Die Funktion `calculate_total` behandelt keine leeren Listen. Sie sollte 0 zurückgeben.
Code:
def calculate_total(items):
    total = 0
    for item in items:
        total += item
    return total

Fix:"""

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=200, temperature=0.2)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Führen Sie es aus:

python generate_patch.py

Das Modell sollte einen Fix ausgeben, der eine frühe Rückgabe für leere Listen hinzufügt.

Beispiel 2: Mythos-artiges Architekturdenken

Testen wir nun eine Mythos-ähnliche Aufgabe. Erstellen Sie `mythos_reasoning.py`:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "./nemo-coder-34b"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto",
    load_in_4bit=True,
)

prompt = """Wir haben eine Webanwendung mit einer REST-API und einer PostgreSQL-Datenbank. Wir müssen eine Funktion hinzufügen, die neuen Benutzern innerhalb von 5 Minuten nach der Registrierung eine Willkommens-E-Mail sendet. Der E-Mail-Dienst ist extern und benötigt manchmal 30 Sekunden für eine Antwort. Das System darf den Registrierungsendpunkt nicht verlangsamen.

Beschreiben Sie die Architekturänderung, die Sie vorschlagen würden, einschließlich neuer Komponenten, und schreiben Sie den Code für die Kernlogik. Seien Sie prägnant, aber vollständig."""

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=500, temperature=0.7, do_sample=True)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Führen Sie es aus:

python mythos_reasoning.py

Das Modell sollte die Verwendung einer Nachrichtenwarteschlange (z. B. RabbitMQ) oder eines Hintergrundarbeiters vorschlagen. Es könnte Python-Code mit Celery oder asyncio generieren.

Beispiel 3: Fable-artiges mehrdeutiges Feature

Erstellen Sie `fable_feature.py`:

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model_name = "./nemo-coder-34b"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype=torch.float16,
    device_map="auto",
    load_in_4bit=True,
)

prompt = """Implementieren Sie eine Funktion für eine Notizen-App: Benutzer können eine Notiz "anheften", sodass sie oben in der Liste erscheint. Die angehefteten Notizen sollten auch ein kleines Sternsymbol haben. Gehen Sie davon aus, dass wir React und einen einfachen In-Memory-Status verwenden. Geben Sie den vollständigen Komponentencode an.

Hinweis: Die Anforderungen sind absichtlich vage. Treffen Sie vernünftige Annahmen und dokumentieren Sie diese in Kommentaren."""

inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
outputs = model.generate(**inputs, max_new_tokens=600, temperature=0.5, do_sample=True)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

Führen Sie es aus:

python fable_feature.py

Das Modell wird wahrscheinlich eine React-Komponente mit einem `pinned`-Boolean-Feld, einer Sortierfunktion und einem Sternsymbol aus einer Icon-Bibliothek produzieren. Es sollte Kommentare enthalten, die Annahmen erklären (z. B. „unter der Annahme, dass wir Font Awesome verwenden“).

Evaluieren Ihrer Ergebnisse

Um über SWE-bench hinauszugehen, müssen Sie nicht nur bewerten, ob der Code läuft, sondern ob er dem Geist der Anforderung entspricht. Für Mythos-Aufgaben prüfen Sie:

• Adressiert die Lösung alle Einschränkungen?
• Ist die Architektur skalierbar und wartbar?
• Werden Abwägungen explizit diskutiert?

Für Fable-Aufgaben prüfen Sie:

• Behandelt der Code vernünftige Randfälle?
• Sind die Annahmen dokumentiert?
• Ist der Code sauber und idiomatisch?

Sie können Ihre eigene Testsuite erstellen, indem Sie Probleme aus Open-Source-Projekten sammeln und sie als mehrdeutige Feature-Anfragen umschreiben. Der Hugging Face Blog enthält Beispiele für Community-gesteuerte Benchmarks, die diesem Muster folgen.

Fazit

SWE-bench hat der KI-Community gute Dienste geleistet, aber es ist nicht das letzte Wort zur Intelligenz in der Softwareentwicklung. Mythos und Fable verschieben die Evaluierungsgrenze hin zu architektonischem Denken und kreativer Feature-Implementierung – Fähigkeiten, die einen Code-Generator von einem echten Engineering-Partner unterscheiden. Nvidias offener Herausforderer mit seinem langen Kontextfenster und den Fähigkeiten zum mehrschrittigen Denken bietet eine praktische Möglichkeit, diese neuen Benchmarks auf Ihrer eigenen Hardware zu erkunden.

Indem Sie das Modell lokal einrichten und die obigen Beispiele ausführen, können Sie aus erster Hand erfahren, wie die nächste Generation von Codierungsagenten mit Mehrdeutigkeit, Design-Abwägungen und systemischem Denken umgeht. Die Ära des Testens von KI auf isolierte Bugfixes geht zu Ende. Die Ära des Testens von KI als kollaborativen Architekten hat gerade erst begonnen.

*Weiterführende Literatur: The Batch (deeplearning.ai), Google AI Blog, Microsoft AI Blog und Hugging Face Blog für laufende Diskussionen über KI-Softwareentwicklungs-Benchmarks.*