HDLFORGE: A Two-Stage Multi-Agent Framework for Efficient Verilog Code Generation with Adaptive Model Escalation

HDLFORGE est un cadre multi-agents à deux étapes qui optimise le compromis entre vitesse et précision pour la génération de code Verilog en utilisant un modèle de taille moyenne par défaut et en escaladant dynamiquement vers un modèle plus puissant uniquement lorsque des diagnostics indiquent des erreurs, tout en intégrant un agent de vérification formelle guidé par des contre-exemples pour accélérer la correction des bugs.

L'essentiel

🏗️ HDLFORGE : L'Architecte Intelligente qui Évite le Gaspillage

Imaginez que vous devez construire une maison très complexe (un circuit électronique) en donnant des instructions à un architecte. Le problème, c'est que les architectes actuels (les intelligences artificielles) ont deux défauts majeurs :

1. Les petits architectes sont rapides et peu chers, mais ils font souvent des erreurs de plomberie ou de structure.
2. Les grands architectes (les super-intelligences) sont très précis, mais ils sont lents, coûteux et épuisants à utiliser pour chaque petite tâche.

HDLFORGE est une nouvelle méthode qui combine le meilleur des deux mondes. C'est comme avoir une équipe de construction en deux étapes qui sait exactement quand faire appel à l'expert.

🚀 Comment ça marche ? (L'Analogie du "Double Regard")

Le système fonctionne comme un processus de contrôle qualité en deux temps :

Étape 1 : Le "Bricoleur Rapide" (Le Modèle Compact)

Tout commence avec un architecte junior (un modèle d'IA de taille moyenne, comme Qwen-7B).

• Son travail : Il dessine les plans et construit la maison.
• Son super-pouvoir : Il ne travaille pas seul. Il est assisté par une équipe de vérificateurs automatiques (des robots) qui font des tests rapides :
  • Le test de fumée (Smoke Test) : "Est-ce que le toit tient ?" (Compilation).
  • Le test de code : "Y a-t-il des fautes de grammaire ?" (Linting).
  • Le test de sécurité : "Si je pousse la porte, est-ce qu'elle s'ouvre bien ?" (Simulation rapide).
• L'innovation clé : Si le robot trouve un défaut, il ne se contente pas de dire "Erreur". Il crée un mini-exercice (un "micro-test") qui reproduit exactement le problème. C'est comme si le robot disait : "Attention, si tu mets ce clou ici, la porte tombe. Voici un petit test pour vérifier que tu as corrigé ça."

Étape 2 : Le "Gardien de la Précision" (Le Modèle Ultra-Puissant)

Le système a un chef d'orchestre (un contrôleur) qui surveille le travail du bricoleur.

• Il regarde les résultats des tests. Si tout va bien, le travail est fini ! C'est rapide et pas cher.
• Mais si le bricoleur semble bloqué, fait trop d'erreurs, ou si les tests montrent un problème persistant, le chef d'orchestre dit : "Stop ! On a besoin du Grand Expert."
• Il appelle alors un architecte de génie (un modèle géant comme Claude 3.5) une seule fois.
• L'astuce : Le Grand Expert ne commence pas de zéro. Il reçoit le rapport du bricoleur, les erreurs trouvées et les "mini-exercices" créés précédemment. Il sait exactement où regarder et corrige le problème en un coup de baguette magique.

💡 Pourquoi c'est génial ? (Les Analogies)

1. L'Escalade Adaptative (Le "Téléphone à Enfant")
   Imaginez que vous cherchez une aiguille dans une botte de foin.

   • Les systèmes anciens utilisent soit un enfant (rapide mais il rate l'aiguille), soit un détective privé (très cher et lent) pour toutes les bottes.
   • HDLFORGE, c'est comme donner la botte à l'enfant d'abord. Si l'enfant trouve l'aiguille, super ! Si l'enfant ne trouve rien après avoir fouillé un peu, on appelle le détective. On économise ainsi l'argent du détective pour les cas difficiles.

2. Le "Test de Fumée" (La Sécurité)
   Avant de construire un pont, on ne teste pas tout le trafic pendant 24h. On fait un petit test de charge. HDLFORGE fait des milliers de ces "micro-tests" instantanés. Si un code échoue, le système apprend de l'erreur et crée un petit test pour s'assurer que l'erreur ne se reproduira plus jamais. C'est comme un mémorisation des pièges.

3. La Boîte Noire Portatile
   Le plus beau dans cette invention, c'est que ce "chef d'orchestre" peut s'ajouter à n'importe quel système existant. C'est comme un filtre à café universel : vous pouvez le mettre sur n'importe quelle machine à café (n'importe quel logiciel de code actuel) pour améliorer le goût du café sans avoir à changer la machine elle-même.

📊 Les Résultats en Bref

• Vitesse et Précision : HDLFORGE est beaucoup plus rapide que les systèmes qui utilisent uniquement les grands experts, tout en étant beaucoup plus précis que ceux qui n'utilisent que les petits.
• Moins d'erreurs : Grâce aux "micro-tests", le système trouve et corrige les bugs beaucoup plus vite (comme un détective qui a déjà vu le type de crime).
• Économie : On utilise l'IA la plus chère seulement quand c'est vraiment nécessaire (environ 15% du temps), ce qui réduit considérablement le coût et le temps de calcul.

🎯 En Résumé

HDLFORGE, c'est l'art de ne pas utiliser un marteau-piqueur pour écraser une mouche, mais de savoir exactement quand il faut l'utiliser. C'est un système intelligent qui commence petit, apprend de ses erreurs grâce à des tests automatisés, et n'appelle le "super-héros" de l'IA que lorsque la situation devient trop complexe pour le petit modèle.

C'est une avancée majeure pour rendre la conception de puces électroniques (les cerveaux de nos ordinateurs et téléphones) plus rapide, moins chère et plus fiable.

Résumé technique

1. Problématique

L'adoption des modèles de langage (LLM) pour la génération de code en Verilog (HDL) a considérablement augmenté, permettant d'automatiser des tâches fastidieuses. Cependant, les LLMs actuels souffrent de plusieurs limitations critiques lorsqu'ils sont appliqués à la conception matérielle :

• Erreurs de syntaxe et de fonctionnalité : Ils produisent souvent du code contenant des bugs, des hallucinations ou des erreurs de compilation, même pour des designs simples.
• Compromis Coût-Précision : Les systèmes existants utilisent généralement un seul modèle de taille fixe. Utiliser un modèle massif (ultra-grand) pour chaque tâche est coûteux en temps et en ressources, tandis que l'utilisation exclusive de modèles compacts (moyens) sacrifie la précision et la fiabilité.
• Manque d'adaptation : Il n'existe pas de mécanisme dynamique pour décider quand passer d'un modèle léger à un modèle puissant en fonction de la difficulté de la tâche ou de la qualité des résultats intermédiaires.

L'objectif est donc de concevoir un système capable de maximiser la précision tout en minimisant la latence et le coût computationnel, en adaptant dynamiquement la puissance du modèle utilisé.

2. Méthodologie : Architecture HDLFORGE

HDLFORGE propose un cadre multi-agent à deux étapes (two-stage) qui orchestre la génération de code Verilog via une cascade adaptative.

A. Architecture à Deux Étapes

Le système fonctionne selon un flux de travail en cascade :

1. Étape A (Résolveur Principal) : Utilise un modèle LLM de taille moyenne (ex: Qwen-7B) pour générer et réparer le code de manière itérative. C'est l'étape par défaut, rapide et peu coûteuse.
2. Étape B (Tentative Finale) : N'est activée que si l'Étape A échoue à progresser. Elle utilise un modèle LLM ultra-grand (ex: Claude 3.5 Sonnet) pour fournir une tentative finale de haute qualité.

B. Les Agents et le Flux de Travail

Le système coordonne plusieurs agents (certains basés sur des LLM, d'autres sur des outils) :

• Planificateur ($A_{plan}$) : Génère plusieurs stratégies de haut niveau.
• Codeur ($A_{code}$) : Produit des implémentations candidates basées sur les plans.
• Juge et "Smoke Test" ($A_{judge}$) : Effectue des vérifications rapides (compilation, linting, simulations courtes) pour éliminer les candidats non viables.
• Traceur ($A_{trace}$) : En cas d'échec, analyse l'arbre de syntaxe abstraite (AST) pour identifier la "cône de suspicion" (lieu probable du bug).
• Réflexion ($A_{refl}$) : Propose des correctifs ciblés basés sur l'analyse d'échec.
• Amplificateur Formel ($A_{form}$) : Un agent clé qui utilise la vérification de modèle bornée (BMC) pour transformer les traces de contre-exemples en micro-tests réutilisables.

C. Le Contrôleur d'Escalade Adaptatif

Le cœur de l'innovation réside dans le contrôleur qui décide du passage de l'Étape A à l'Étape B. Il calcule un score d'escalade ($Z$) basé sur cinq signaux diagnostiques peu coûteux :

1. Succès de la compilation ($s_{comp}$).
2. Qualité du code (nombre d'avertissements Lint) ($s_{lint}$).
3. Cohérence des tests "smoke" ($s_{smoke}$).
4. Stabilité des échecs (le bug est-il toujours au même endroit ?) ($s_{trace}$).
5. Budget restant (nombre d'essais) ($s_{budget}$).

Si le score $Z$ tombe en dessous d'un seuil calibré ($\tau$) ou si le budget d'essais est épuisé, le système escalade vers l'Étape B. Ce contrôleur est portable et peut envelopper des pipelines existants (comme AutoVCoder ou VerilogCoder) sans modifier leur logique interne.

D. Amplification par Micro-tests (CEGIS)

L'agent formel ($A_{form}$) exécute une vérification de modèle bornée. Lorsqu'une violation est détectée, la trace de contre-exemple est convertie en un micro-test déterministe. Ces micro-tests sont ajoutés à un pool auxiliaire ($U_k$) et utilisés lors des étapes de "smoke testing" futures. Cela permet de rejeter immédiatement tout candidat qui réintroduit le même bug, réduisant drastiquement le nombre d'itérations nécessaires pour la réparation.

3. Contributions Clés

1. HDLFORGE : Un cadre multi-agent à deux étapes qui optimise le compromis précision-latence en utilisant un modèle compact par défaut et en escaladant uniquement si nécessaire.
2. Contrôleur Portable : Une couche de décision indépendante qui peut améliorer n'importe quel pipeline de génération Verilog existant sans réentraînement ni modification des prompts internes.
3. Amplificateur Formel CEGIS : Transformation des traces de contre-exemples formels en micro-tests réutilisables, accélérant la détection de bugs et réduisant les itérations de réparation.
4. Système en Boucle Fermée : Une interaction purement basée sur des signaux d'outils (scores, traces, tests) entre les agents, évitant la complexité de la communication directe entre LLMs.

4. Résultats Expérimentaux

Les évaluations ont été menées sur les benchmarks VerilogEval Human, VerilogEval V2 et RTLLM.

• Performance Précision-Latence :

  • HDLFORGE-Qwen (basé sur un modèle 7B + escalade vers Claude 3.5) atteint 91,2 % de Pass@1 sur VerilogEval Human et 91,8 % sur V2. Cela représente une amélioration massive par rapport aux systèmes basés uniquement sur des modèles 7B (ex: AutoVCoder à 48,5 %).
  • Il réalise ces performances avec une latence médiane réduite d'environ 50 % par rapport aux systèmes utilisant uniquement des modèles massifs.
  • HDLFORGE-GPT4o atteint des scores records (95,5 % / 96,8 % Pass@1) tout en restant compétitif en termes de temps.
  • Sur RTLLM, le système atteint 97,2 % de Pass@5.

• Portabilité :

  • En enveloppant AutoVCoder et VerilogCoder, HDLFORGE améliore leur Pass@1 de 3 à 5 points de pourcentage avec une augmentation de temps inférieure à 10 %, prouvant que le contrôleur fonctionne efficacement sur des architectures existantes.

• Étude d'Abalation et Bugs :

  • L'ablation montre que chaque agent (Juge, Traceur, Réflexion, Micro-tests) contribue significativement à la précision et à l'efficacité.
  • Sur un benchmark d'injection de bugs, l'utilisation des micro-tests augmente le taux de détection de bugs de 82,5 % à 95,0 % et réduit le nombre d'itérations de réparation de 7 à 3, tout en diminuant le temps total d'exécution.

5. Signification et Impact

HDLFORGE représente une avancée significative dans l'automatisation de la conception matérielle assistée par IA :

• Efficacité Économique : Il résout le problème du coût computationnel excessif en évitant d'utiliser des modèles massifs pour des tâches simples, tout en garantissant la qualité pour les tâches complexes.
• Généralisation : La capacité à "envelopper" des pipelines existants rend cette approche immédiatement applicable à l'industrie sans nécessiter de réinventer des modèles de base.
• Fiabilité : L'intégration de la vérification formelle (BMC) et des micro-tests réutilisables apporte une rigueur mathématique à la génération de code, réduisant les erreurs subtiles que les LLMs seuls ne peuvent pas corriger.

En résumé, HDLFORGE démontre qu'une architecture multi-agent adaptative, couplée à des signaux de diagnostic peu coûteux et à une vérification formelle ciblée, peut surpasser les approches monolithiques en termes de vitesse, de coût et de précision pour la génération de code Verilog.