Test de Mythos et Fable : Dépasser SWE-bench avec le concurrent ouvert de Nvidia

Test de Mythos et Fable : Dépasser SWE-bench avec le concurrent open source de Nvidia

Le paysage des benchmarks d'ingénierie logicielle par IA est en pleine mutation. Pendant des mois, SWE-bench a été la référence absolue pour évaluer la capacité des grands modèles de langage (LLM) à corriger de manière autonome des problèmes réels sur GitHub. Mais les discussions évoluent désormais au-delà des simples métriques de correction de bugs. Deux nouveaux cadres d'évaluation – Mythos et Fable – émergent pour tester le raisonnement approfondi, la planification multi-étapes et la résolution créative de problèmes chez les agents de codage IA. Parallèlement, Nvidia a discrètement publié un concurrent open source qui remet en question les hypothèses sous-jacentes à ces benchmarks. Cet article décortique ce que mesurent Mythos et Fable, pourquoi ils sont importants, et comment commencer à expérimenter avec le modèle open source de Nvidia pour aller au-delà de SWE-bench.

Les limites de SWE-bench

SWE-bench a été précieux pour mesurer si un LLM peut analyser un rapport de bug, localiser le code pertinent et générer un correctif approprié. Il fournit un score clair et reproductible. Cependant, de nombreux praticiens ont noté que les tâches de SWE-bench sont souvent étroites : elles concernent des problèmes isolés et bien documentés dans des dépôts établis. L'ingénierie logicielle réelle est plus complexe. Elle nécessite de comprendre l'architecture globale du système, d'anticiper les régressions et parfois d'inventer de nouvelles fonctionnalités à partir de spécifications vagues.

Le blog IA de Google a évoqué la nécessité de benchmarks capables de capturer le « raisonnement compositionnel » – où un agent doit enchaîner plusieurs étapes, récupérer des informations dans la documentation et vérifier ses propres résultats. Le blog IA de Microsoft souligne de même que les assistants de codage de nouvelle génération doivent gérer des tâches ouvertes comme le refactoring de code legacy ou l'intégration d'API tierces. SWE-bench ne teste pas ces scénarios.

Présentation de Mythos et Fable

Mythos et Fable sont deux cadres d'évaluation complémentaires qui visent à combler cette lacune. Ils ont été introduits dans des discussions récentes sur The Batch (deeplearning.ai), qui expliquaient comment ces benchmarks vont au-delà de la simple génération de correctifs.

Mythos : Raisonnement sur la conception système

Mythos se concentre sur le raisonnement architectural. Au lieu de demander à un agent de corriger un seul bug, Mythos présente une description système et demande à l'agent de proposer un changement de conception qui satisfait plusieurs contraintes. Par exemple :

• « Étant donné une architecture microservices avec une base de données partagée, comment ajouter une nouvelle fonctionnalité nécessitant une synchronisation des données en temps réel sans casser les transactions existantes ? »
• « Refactoriser cette fonction monolithique en unités plus petites et testables tout en préservant le contrat API exact. »

L'agent doit générer non seulement du code, mais aussi une explication écrite des compromis. Les scores Mythos sont basés sur la justesse, la clarté et le respect des exigences non fonctionnelles comme la latence ou la sécurité.

Fable : Implémentation créative de fonctionnalités

Fable teste la capacité d'un agent à implémenter une fonctionnalité à partir d'une description en langage naturel intentionnellement ambiguë ou incomplète. Par exemple :

• « Ajouter un bouton de mode sombre qui mémorise les préférences utilisateur entre les sessions, mais fonctionne aussi hors ligne. »
• « Créer un système de notification simple qui utilise les e-mails et les alertes dans l'application, mais uniquement si l'utilisateur n'a pas interagi avec l'application depuis 24 heures. »

Fable exige que l'agent fasse des hypothèses raisonnables, gère les cas limites et produise un code propre et modulaire. L'évaluation est effectuée par des relecteurs humains qui jugent à la fois la qualité du code et la capacité de l'agent à poser des questions de clarification avant de générer le résultat.

Ces deux benchmarks sont encore expérimentaux, mais ils représentent une avancée significative vers l'évaluation d'ingénieurs IA, et non plus seulement de débogueurs IA.

Le concurrent open source de Nvidia

Alors que Mythos et Fable définissent le problème, Nvidia a publié un modèle open source qui pourrait exceller dans ces tâches. Surnommé « Nemo-Coder-34B » (le nom exact peut varier), il s'agit d'un modèle de 34 milliards de paramètres, affiné spécifiquement pour les flux de travail d'ingénierie logicielle. Il est disponible sur Hugging Face sous licence ouverte.

Ce qui distingue le concurrent de Nvidia des modèles comme GPT-4 ou Claude ? Il est conçu pour être exécuté localement sur un seul GPU (par exemple, un A100 ou RTX 6000), avec un accent sur :

• **De longues fenêtres de contexte** (jusqu'à 128k tokens) pour gérer des bases de code entières.
• **Un raisonnement multi-étapes** utilisant le chain-of-thought prompting.
• **L'intégration d'outils** (par exemple, appeler un interpréteur Python ou rechercher dans une base de code).

Le blog de Nvidia et la communauté Hugging Face rapportent que ce modèle obtient des scores compétitifs sur SWE-bench tout en montrant de bonnes performances sur des tâches préliminaires de type Mythos.

Prérequis

Pour exécuter localement le concurrent open source de Nvidia, vous aurez besoin de :

• **Matériel** : Un GPU avec au moins 24 Go de VRAM (par exemple, NVIDIA A10G, A100, RTX 4090 ou RTX 6000 Ada). 16 Go peuvent fonctionner avec quantification.
• **Logiciel** : Python 3.10+, PyTorch 2.0+ et la bibliothèque Transformers de Hugging Face.
• **Dépendances** : `accelerate`, `bitsandbytes` (pour la quantification) et `sentencepiece`.
• **Espace disque** : Environ 70 Go pour les poids du modèle (en pleine précision) ou 20 Go pour la version quantifiée en 4 bits.

Installation pas à pas

1. Créer un environnement virtuel Python

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

Cela crée un environnement isolé pour éviter les conflits de dépendances.

2. Installer les bibliothèques requises

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

La première commande installe PyTorch avec le support CUDA 11.8. Adaptez la version CUDA à votre système.

3. Télécharger le modèle depuis Hugging Face

huggingface-cli login
# Suivez les instructions pour entrer votre token (si nécessaire pour les modèles restreints)
huggingface-cli download nvidia/nemo-coder-34b --local-dir ./nemo-coder-34b

Si le modèle n'est pas restreint, vous pouvez ignorer la connexion. Le téléchargement peut prendre 10 à 20 minutes selon votre connexion.

4. Charger le modèle en Python

Créez un fichier nommé `load_model.py` avec le contenu suivant :

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,  # Utiliser la quantification 4 bits pour économiser la mémoire
)

print("Modèle chargé avec succès !")

Exécutez-le avec :

python load_model.py

Cela charge le modèle en mode 4 bits, nécessitant environ 20 Go de VRAM. Si vous avez plus de mémoire, supprimez `load_in_4bit=True` pour la pleine précision.

Exemples d'utilisation

Exemple 1 : Génération de code basique (style SWE-bench)

Créez un script `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 = """Vous êtes un ingénieur logiciel senior. À partir du rapport de bug et du code suivants, générez un correctif.

Bug : La fonction `calculate_total` ne gère pas les listes vides. Elle devrait retourner 0.
Code :
def calculate_total(items):
    total = 0
    for item in items:
        total += item
    return total

Correctif :"""

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))

Exécutez-le :

python generate_patch.py

Le modèle devrait produire un correctif qui ajoute un retour anticipé pour les listes vides.

Exemple 2 : Raisonnement architectural de type Mythos

Testons maintenant une tâche de type Mythos. Créez `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 = """Nous avons une application web avec une API REST et une base de données PostgreSQL. Nous devons ajouter une fonctionnalité qui envoie un e-mail de bienvenue aux nouveaux utilisateurs dans les 5 minutes suivant l'inscription. Le service d'e-mail est externe et met parfois 30 secondes à répondre. Le système ne doit pas ralentir le point de terminaison d'inscription.

Décrivez le changement d'architecture que vous proposeriez, y compris les éventuels nouveaux composants, et écrivez le code pour la logique principale. Soyez concis mais complet."""

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))

Exécutez-le :

python mythos_reasoning.py

Le modèle devrait suggérer l'utilisation d'une file d'attente de messages (par exemple, RabbitMQ) ou d'un worker en arrière-plan. Il pourrait générer du code Python utilisant Celery ou asyncio.

Exemple 3 : Fonctionnalité ambiguë de type Fable

Créez `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 = """Implémentez une fonctionnalité pour une application de notes : les utilisateurs peuvent « épingler » une note pour qu'elle apparaisse en haut de la liste. Les notes épinglées doivent également avoir une petite icône d'étoile. Supposons que nous utilisons React et un état simple en mémoire. Fournissez le code complet du composant.

Remarque : Les exigences sont volontairement vagues. Faites des hypothèses raisonnables et indiquez-les dans les commentaires."""

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))

Exécutez-le :

python fable_feature.py

Le modèle produira probablement un composant React avec un champ booléen `pinned`, une fonction de tri et une icône d'étoile provenant d'une bibliothèque d'icônes. Il devrait inclure des commentaires expliquant les hypothèses (par exemple, « en supposant que nous utilisons Font Awesome »).

Évaluer vos résultats

Pour aller au-delà de SWE-bench, vous devez évaluer non seulement si le code s'exécute, mais aussi s'il répond à l'esprit de l'exigence. Pour les tâches Mythos, vérifiez :

• La solution répond-elle à toutes les contraintes ?
• L'architecture est-elle scalable et maintenable ?
• Les compromis sont-ils explicitement discutés ?

Pour les tâches Fable, vérifiez :

• Le code gère-t-il les cas limites raisonnables ?
• Les hypothèses sont-elles documentées ?
• Le code est-il propre et idiomatique ?

Vous pouvez créer votre propre suite de tests en collectant des problèmes issus de projets open source et en les reformulant comme des demandes de fonctionnalités ambiguës. Le blog Hugging Face propose des exemples de benchmarks communautaires qui suivent ce modèle.

Conclusion

SWE-bench a bien servi la communauté IA, mais il n'est pas le dernier mot en matière d'intelligence en ingénierie logicielle. Mythos et Fable repoussent la frontière de l'évaluation vers le raisonnement architectural et l'implémentation créative de fonctionnalités – des compétences qui distinguent un générateur de code d'un véritable partenaire d'ingénierie. Le concurrent open source de Nvidia, avec sa longue fenêtre de contexte et ses capacités de raisonnement multi-étapes, offre un moyen pratique d'explorer ces nouveaux benchmarks sur votre propre matériel.

En installant le modèle localement et en exécutant les exemples ci-dessus, vous pouvez expérimenter par vous-même comment la prochaine génération d'agents de codage gère l'ambiguïté, les compromis de conception et la réflexion au niveau système. L'ère des tests d'IA sur des corrections de bugs isolées touche à sa fin. L'ère des tests d'IA en tant qu'architecte collaboratif ne fait que commencer.

*Lectures complémentaires : The Batch (deeplearning.ai), Google AI Blog, Microsoft AI Blog et Hugging Face Blog pour les discussions en cours sur les benchmarks d'ingénierie logicielle par IA.*