💻 computer science

NL2Scratch: An Executable Benchmark and Evaluation for Block-Based Programming

Cet article introduit NL2Scratch, un benchmark exécutable à grande échelle, ainsi que la métrique de Cohérence d'Alignement Sémantique (SAC) pour remédier aux limites de l'évaluation conventionnelle du NL2Code dans la programmation par blocs, révélant que les modèles de langage actuels atteignent souvent une similitude lexicale élevée tout en échouant à capturer l'alignement sémantique nécessaire pour générer des programmes Scratch corrects.

Auteurs originaux : Heejin Do, Alexandre Ballenghien, Yang Wu, April Yi Wang

Publié 2026-06-23

📖 5 min de lecture🧠 Analyse approfondie

CC BY 4.0

Auteurs originaux : Heejin Do, Alexandre Ballenghien, Yang Wu, April Yi Wang

Article original sous licence CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Ceci est une explication générée par l'IA de l'article ci-dessous. Elle n'a pas été rédigée ni approuvée par les auteurs. Pour une précision technique, consultez l'article original. Lire la clause de non-responsabilité complète

Imaginez que vous enseigniez à un robot à dessiner un tableau en suivant vos instructions orales. Si vous dites : « Dessine un cercle rouge », le robot doit comprendre exactement ce que « rouge » et « cercle » signifient et comment les assembler.

Ce document présente un nouveau test appelé NL2Scratch, conçu pour évaluer la capacité de l'IA à accomplir cela, mais avec une particularité : au lieu d'écrire du code textuel (comme Python), l'IA doit construire des programmes en utilisant des blocs Scratch. Scratch est le langage de programmation coloré et par glisser-déposer que les enfants utilisent pour créer des jeux et des animations.

Voici la décomposition de l'histoire de ce document, en utilisant des analogies simples :

1. Le Problème : Le piège du « Ça a l'air bon »

Pendant des années, les chercheurs ont testé l'IA sur le codage textuel. Ils vérifient si la réponse de l'IA ressemble à la réponse correcte (comme vérifier si deux phrases partagent les mêmes mots).

Mais Scratch est différent. C'est comme un ensemble de LEGO.

Dans le codage textuel, si vous oubliez une virgule, toute la phrase peut se briser.
Dans Scratch, vous pouvez avoir les bons types de blocs (un bloc « avancer », un bloc « répéter ») et les bons mots à l'intérieur de ceux-ci, mais si vous les placez dans le mauvais ordre ou si vous les connectez au mauvais déclencheur, le jeu ne fonctionnera pas.

Le document soutient que les tests actuels de l'IA sont comme juger un château en LEGO en comptant simplement les briques. Si l'IA utilise le bon nombre de briques rouges et bleues, le test dit : « Très bien ! », même si le château s'effondre parce que les briques sont empilées à l'envers.

2. La Solution : Un nouveau test et une nouvelle règle

Les auteurs ont construit NL2Scratch, une immense bibliothèque de 311 000 exemples.

La Source : Ils ont pris de vrais projets Scratch créés par des humains.
La Traduction : Ils ont utilisé l'IA pour écrire des descriptions en anglais naturel pour ces projets (ex : « Quand le drapeau vert est cliqué, faire avancer le chat de 10 pas »).
Le Filtre : Ils se sont assurés que chaque exemple fonctionne réellement dans le moteur Scratch.

La Nouvelle Règle (SAC) :
Au lieu de simplement compter les mots correspondants, ils ont inventé une nouvelle règle de mesure appelée Cohérence de l'Alignement Sémantique (SAC).

Pensez à cela comme une liste de contrôle (checklist).
Est-ce que la description mentionne le bon déclencheur (comme le drapeau vert) ?
Est-ce qu'elle mentionne la bonne action (comme avancer) ?
Est-ce qu'elle contient les bons nombres (comme 10 pas) ?
Le SAC vérifie chaque élément de cette liste. Si l'IA réussit le « déclencheur » mais se trompe sur le « nombre », la liste de contrôle affiche une croix rouge, même si le reste de la phrase semble parfait.

3. La Grande Découverte : L'IA est bonne pour l'imitation, mauvaise pour le sens

Les chercheurs ont testé plusieurs modèles d'IA intelligents (comme GPT-4 et des modèles open-source) sur ce nouveau test. Voici ce qu'ils ont trouvé :

L'Illusion du Succès : Lorsqu'ils utilisaient les anciens tests (comptage de mots), l'IA semblait incroyable. Elle obtenait 93 % à 97 % des mots corrects. Elle donnait l'impression de savoir exactement quoi faire.
Le Test de Réalité : Lorsqu'ils ont utilisé la nouvelle liste de contrôle SAC, le score de l'IA a chuté de manière spectaculaire. Seulement environ 18 % des réponses de l'IA étaient parfaitement correctes en termes de sens.
Le Problème du « Jeu de Longue Durée » : Plus le projet Scratch était long et complexe, plus l'IA devenait mauvaise pour obtenir les détails exacts, même si elle semblait toujours très similaire à la réponse correcte.

Où l'IA a-t-elle échoué ?
L'IA était douée pour la « vue d'ensemble » (savoir qu'elle a besoin d'une « boucle » ou d'une « variable »). Mais elle continuait de rater les détails opérationnels :

Elle disait « avancer » quand elle aurait dû dire « reculer ».
Elle disait « répéter 10 fois » quand elle aurait dû dire « répéter 5 fois ».
Elle se trompait de condition (ex : « si touche le mur » au lieu de « si touche le chat »).

C'est comme un étudiant qui a mémorisé parfaitement la liste de vocabulaire mais qui a échoué à l'exercice de mathématiques parce qu'il a additionné au lieu de soustraire.

4. La Solution : Un « Deuxième Avis »

Le document montre également que vous pouvez utiliser cette nouvelle liste de contrôle (SAC) pour corriger les erreurs de l'IA après qu'elle a généré une réponse.

Imaginez que l'IA écrive 10 versions différentes du programme.
Au lieu de simplement choisir la première, vous passez les 10 versions à travers la liste de contrôle SAC.
Vous choisissez celle qui correspond le mieux à la liste de contrôle.
Résultat : Cette étape simple a considérablement amélioré la précision de l'IA sans nécessifité de réentraîner l'IA ou de lui apprendre quoi que ce soit de nouveau.

Résumé

Le document conclut que pour la programmation par blocs (comme Scratch), avoir l'air similaire ne suffit pas. Une IA peut avoir l'air d'un programmeur sans pour autant en être un. Pour évaluer véritablement l'IA dans ce domaine, nous devons vérifier les « engrenages et les roues » (les actions spécifiques et les nombres), et non seulement la « carrosserie » (les mots). Ils ont construit les outils pour faire précisément cela.

Résumé Technique : NL2Scratch

Problématique

La recherche sur la génération de code à partir du langage naturel (NL2Code) s'est principalement concentrée sur les langages de programmation séquentiels et textuels (ex. : Python, SQL, Java), en s'appuyant sur des métriques d'évaluation telles que le chevauchement lexical au niveau des jetons (BLEU, CodeBLEU) ou l'exécution de tests unitaires. Cependant, les environnements de programmation par blocs comme Scratch, largement utilisés dans l'enseignement K-12, opèrent sous des paradigmes fondamentalement différents : les programmes sont pilotés par des événements, visuellement compositionnels et distribués à travers de multiples scripts concurrents.

Dans ce contexte, les protocoles d'évaluation conventionnels sont insuffisants. Un programme Scratch présentant une forte similitude textuelle de surface avec une référence peut tout de même échouer à l'exécution ou se comporter de manière incorrecte en raison de déclencheurs d'événements mal alignés, d'un flux de contrôle erroné ou d'arguments discordants. De plus, la recherche actuelle en IA appliquée à l'éducation via Scratch s'est largement concentrée sur le tutorat conversationnel, le débogage ou la compréhension de programmes, manquant d'un banc d'essai pour la génération de Scratch à partir du langage naturel exécutable qui valide à la fois la correction structurelle et la fidélité sémantique.

Méthodologie

1. Construction du benchmark NL2Scratch

Les auteurs introduisent NL2Scratch, un benchmark exécutable comprenant 311 648 paires de Langage Naturel (NL)–programme valides pour le parseur. Le pipeline de construction comprend trois étapes :

Extraction Scratchblocks : De vrais projets Scratch (issus du corpus d'Aivaloglou et al.) sont convertis en scratchblocks, une notation textuelle normalisée qui préserve les déclencheurs d'événements, l'ordre des blocs et la hiérarchie du flux de contrôle. Les scripts sont validés à l'aide du parseur Scratch VM pour garantir la validité structurelle.
Génération de Langage Naturel : Pour chaque programme valide, une description déterministe est générée via un convertisseur basé sur des règles. Celle-ci est ensuite réécrite par un LLM pour améliorer la fluidité et le naturel « de type étudiant » tout en présant strictement la sémantique exécutable (événements, actions, conditions, arguments numériques).
Vérification Sémantique : Un processus de filtrage en deux étapes garantit la qualité des données. Premièrement, des vérifications basées sur le parseur confirment la validité structurelle. Deuxièmement, l'Alignement de Cohérence Sémantique (SAC) est appliqué pour vérifier que la description NL réécrite correspond sémantiquement au programme sous-jacent.

2. Alignement de Cohérence Sémantique (SAC)

Pour remédier aux limites des métriques de chevauchement de surface, les auteurs proposent le SAC, un cadre de vérification interprétable au niveau des créneaux (slots).

Extraction de Créneaux (Slots) : Le SAC extrait 11 créneaux comportementaux de la description NL et du programme Scratch (représenté en scratchblocks). Ceux-ci incluent :
- Déclencheurs d'événements (ex. : drapeau vert, pression de touche).
- Actions (ex. : mouvement, mises à jour de variables).
- Structures de contrôle (boucles, conditionnels).
- Détails opérationnels (arguments numériques, noms de variables, noms de costumes/décors, messages de diffusion).
Score : L'accord est calculé par créneau. Les attributs scalaires nécessitent des correspondances exactes ; les attributs de type ensemble utilisent le chevauchement de Jaccard. Le score SAC final est la moyenne de tous les créneaux comparables non vides.
Seuil : Les paires avec un $SAC \geq 0,85$ sont considérées comme ayant un alignement de haute confiance.

3. Benchmark Diagnostique

À partir du jeu de données complet, les auteurs ont construit un benchmark diagnostique de 800 exemples. Ce sous-ensemble a été sélectionné pour maximiser la diversité des attributs sémantiques spécifiques à Scratch (types d'événements, types de boucles, arguments numériques, etc.) et pour s'assurer que les distributions de lisibilité correspondent aux requêtes réelles des apprenants. Cet ensemble sert de terrain d'évaluation principal pour l'analyse des performances des modèles.

4. Configuration Expérimentale

L'étude évalue une gamme de modèles, incluant des modèles propriétaires (GPT-4.1, GPT-4o-mini) et des modèles à poids ouverts (FLAN-T5, Qwen2.5-7B-Instruct, Llama-3.1-8B-Instruct).

Stratégies d'Entraînement : Les modèles sont testés sous des conditions de zero-shot, few-shot (apprentissage en contexte basé sur la récupération) et de fine-tuning supervisé (SFT).
Métriques : La performance est mesurée à l'aide de métriques conventionnelles (Exact Match, F1 au niveau des jetons, Succès de l'analyse syntaxique) et des métriques SAC proposées ( $SAC_{nl}$ pour l'alignement avec le NL d'entrée, $SAC_{ref}$ pour l'alignement avec le programme de référence).
Sélection au moment de l'inférence : Les auteurs étudient l'utilisation du SAC comme signal de re-classement (reranking) pour sélectionner le candidat le plus fidèle sémantiquement parmi un ensemble de programmes générés.

Résultats Clés

1. Le fossé entre similitude lexicale et alignement sémantique

Les expériences révèlent une divergence significative entre les métriques conventionnelles et la correction sémantique.

Les modèles atteignent fréquemment des scores F1 élevés au niveau des jetons (souvent > 0,93) et des taux de succès de parsing élevés.
Cependant, un alignement sémantique parfait ( $SAC = 100\%$ ) n'est atteint que sur moins de 18,9 % des exemples, même pour les modèles les plus puissants (ex. : GPT-4.1 avec un prompting few-shot).
Cela indique qu'une forte similitude lexicale ne garantit pas que le programme généré reproduise fidèlement le comportement voulu.

2. Concentration des erreurs dans les créneaux opérationnels

L'analyse par créneau identifie des modes de défaillance spécifiques :

Échafaudage Structurel : Les modèles réussissent bien sur les créneaux structurels et centrés sur les entités, tels que les types d'événements, les noms de variables et les noms de costumes, atteignant un alignement proche du plafond.
Détails Opérationnels : Les erreurs se concentrent sur les créneaux qui déterminent directement le comportement du programme, spécifiquement les types d'actions, les types de conditions et les arguments numériques. Ces erreurs rendent souvent le programme fonctionnellement incorrect malgré le passage des vérifications du parseur et l'obtention de scores F1 élevés.

3. Impact de la complexité du programme

Le fossé entre similitude lexicale et alignement sémantique s'élargit à mesure que la complexité du programme augmente.

Pour les programmes plus longs, l'Exact Match (EM) et l'alignement sémantique parfait se dégradent brutalement.
Le F1 au niveau des jetons reste relativement stable, suggérant que la récupération locale des jetons est plus facile que la préservation de la structure exécutable globale et des dépendances complexes entre les blocs.

4. Utilité du SAC pour le Re-classement (Reranking)

L'utilisation du SAC comme signal de sélection lors de l'inférence améliore significativement la qualité de la génération sans réentraînement.

Le re-classement basé sur le SAC a augmenté l'alignement parfait $SAC_{ref}$ jusqu'à 32,6 points de pourcentage pour les modèles à poids ouverts.
Cela démontre qu'une vérification sémantique explicite est un signal de sélection plus efficace qu'un classement basé sur la vraisemblance (likelihood) ou uniquement sur le parseur.

Signification et Revendications

L'article affirme que la programmation par blocs constitue un régime de NL2Code distinct où les métriques d'évaluation traditionnelles sont insuffisantes.

Premier Benchmark Exécutable : NL2Scratch est présenté comme le premier benchmark fournissant des paires NL–Scratch exécutables à grande échelle avec une vérification de qualité alignée dérivée de projets réels.
Révélation de modes de défaillance cachés : L'étude démontre que les LLM robustes actuels, même après fine-tuning, présentent un « écart notable » entre la similitude de surface et l'exactitude structurelle. Ces échecs sont largement invisibles sous les métriques conventionnelles mais critiques pour les applications éducatives où la correction comportementale est primordiale.
Cadre d'Évaluation : Le SAC est proposé non seulement comme un filtre de données, mais comme un outil de diagnostic nécessaire pour évaluer l'accord sémantique dans les systèmes pilotés par des événements et par blocs.

Les auteurs concluent que les travaux futurs dans ce domaine doivent dépasser le simple chevauchement lexical et la validité du parseur pour tendre vers des méthodes de génération et d'évaluation sensibles à la structure qui vérifient explicitement la sémantique opérationnelle.