Dans le monde moderne, de vastes quantités d'informations sont stockées dans des entrepôts numériques appelés bases de données. Pour poser une question à ces entrepôts, les gens utilisent un langage spécifique connu sous le nom de SQL, qui sert d'interface principale pour la récupération de données structurées. Bien que l'écriture correcte de ce langage nécessite une compréhension profonde des relations complexes et de la logique, même les humains expérimentés commettent des erreurs qui mènent à de mauvaises réponses. Récemment, de puissants systèmes informatiques connus sous le nom de grands modèles de langage ont été enseignés pour écrire ces requêtes automatiquement, promettant de rendre les données accessibles à tous. Cependant, ces modèles produisent souvent des requêtes qui semblent correctes mais qui ne répondent pas à la véritable question de l'utilisateur, ou qui contiennent des erreurs subtiles qui font planter l'ordinateur ou renvoient des résultats trompeurs. Corriger ces erreurs est difficile car un petit changement dans une partie d'une requête peut modifier complètement le sens de la requête entière.

Une équipe de chercheurs de l'Université Renmin de Chine et de ByteDance a développé une nouvelle façon d'aider ces systèmes informatiques à corriger leurs propres erreurs. Au lieu d'essayer de corriger une requête erronée en une seule ligne droite, leur système, appelé ACTS-SQL, traite le processus comme un chemin embranché où l'ordinateur peut explorer plusieurs possibilités à la fois. Si l'ordinateur prend un mauvais tournant, il peut revenir en arrière et essayer une route différente plutôt que de rester bloqué sur une hypothèse erronée. Cette approche a été testée sur des benchmarks standards et dans un système industriel réel, où elle a considérablement amélioré la précision des questions générées par l'ordinateur. Les chercheurs ont constaté qu'en permettant au système de faire une pause, de vérifier son travail et de reconsidérer ses choix, il pouvait résoudre des problèmes que les méthodes précédentes ne pouvaient pas résoudre, rendant la technologie beaucoup plus fiable pour une utilisation quotidienne.

Le problème central que les chercheurs ont abordé est que les systèmes informatiques actuels se retrouvent souvent piégés dans une boucle d'erreurs. Lorsqu'un modèle génère une requête erronée, les anciennes méthodes de correction essaient généralement de la corriger étape par étape selon un raisonnement linéaire. Si le modèle commet une erreur au début, comme mal comprendre ce qu'un utilisateur voulait dire par un mot spécifique, chaque correction ultérieure se construit sur cette erreur initiale. C'est comme essayer de naviguer dans un labyrinthe en ne faisant que progresser vers l'avant ; si vous prenez un mauvais tournant au début, vous risquez de continuer à avancer dans une impasse, convaincu d'être sur le bon chemin, jusqu'à ce que vous manquiez d'options. Les chercheurs ont observé que ces méthodes linéaires sont fragiles car elles ne peuvent pas facilement revenir en arrière pour reconsidérer leur premier choix. Une fois que l'ordinateur s'engage dans une interprétation spécifique de la requête d'un utilisateur, il change rarement d'avis, même lorsque les résultats prouvent qu'il a tort.

Pour résoudre cela, l'équipe a conçu un système qui organise le processus de correction sous forme de structure arborescente. Imaginez un arbre de décision où l'ordinateur commence au sommet et, chaque fois qu'un outil introduit un nouveau point de décision — comme lorsque l'outil « Detect Ambiguities » identifie des phrases ambiguës spécifiques dans la requête de l'utilisateur — il se divise en différentes branches, chacune représentant une signification possible différente. Une branche pourrait supposer que l'utilisateur veut voir toutes les ventes pour une année, tandis qu'une autre suppose qu'il veut voir les ventes pour un mois spécifique. Le système teste ensuite chaque branche indépendamment. Si une branche mène à un résultat qui ne correspond pas à ce que l'utilisateur souhaitait probablement, le système peut couper cette branche et revenir à la division pour essayer un autre chemin. Cette capacité de revenir en arrière et d'explorer des alternatives empêche l'ordinateur de rester bloqué sur une seule idée incorrecte.

Le système fonctionne en utilisant un « cerveau » central qui crée un plan pour corriger la requête. Ce plan n'est pas une simple liste d'étapes, mais une carte d'actions potentielles. L'ordinateur utilise des outils spéciaux pour l'aider à naviguer sur cette carte. Un outil aide le système à repérer les mots ambigus dans la question de l'utilisateur et à générer différentes façons de les comprendre. Un autre outil permet à l'ordinateur d'exécuter de petites parties de la requête contre la base de données réelle pour voir quelles données en ressortent, agissant comme un test rapide pour voir si une idée fonctionne. Si l'ordinateur trouve une erreur de syntaxe, c'est-à-dire une erreur dans la grammaire de la requête, un outil spécialisé décompose la requête en morceaux plus petits pour trouver exactement où la grammaire a échoué sans avoir à réécrire toute la chose à partir de zéro.

Les chercheurs ont testé leur système sur un benchmark appelé BIRD-Critic, qui contient de nombreux exemples de requêtes SQL difficiles avec divers types d'erreurs. Ils ont comparé leur méthode à plusieurs autres approches, y compris des modèles puissants qui ont été entraînés spécifiquement pour corriger le SQL et d'autres systèmes qui tentaient de corriger les erreurs en utilisant une méthode linéaire, étape par étape. Les résultats ont montré que leur approche structurée en arbre était nettement plus précise. Sur le benchmark, le nouveau système a amélioré le taux de réussite de 9,42 points de pourcentage par rapport à la meilleure méthode précédente. Cette amélioration s'est confirmée à travers différents types de langages de bases de données, suggérant que la méthode est robuste et ne dépend pas d'un style spécifique d'écriture de requêtes.

Pour prouver que le système fonctionne dans le monde réel, les chercheurs l'ont déployé dans un environnement de production chez ByteDance, spécifiquement au sein d'un service d'analyse de logs appelé Torch Log Service. Dans ce cadre, le système a été utilisé pour corriger les requêtes générées par un modèle de langage puissant avant qu'elles ne soient envoyées aux utilisateurs. Les résultats ont été frappants : la précision des requêtes qui ont été réellement exécutées avec succès est passée de 36,77 % à 53,61 %. Cela signifie que dans un scénario réel avec des données complexes et personnalisées, le système a été capable de transformer une majorité de tentatives échouées en succès. Les chercheurs ont noté que cette amélioration s'est produite sans avoir besoin de réentraîner le modèle informatique sous-jacent sur de nouvelles données, ce qui rend la solution pratique et facile à intégrer dans les systèmes existants.

L'étude a également souligné l'importance de pouvoir revenir en arrière. Dans une étude de cas détaillée, les chercheurs ont montré comment une méthode linéaire échouerait à corriger une requête concernant les « ventes mensuelles » car elle restait bloquée sur l'idée que l'utilisateur parlait de ventes annuelles. Peu importe le nombre de fois où le système linéaire essayait d'ajuster la requête, il ne pouvait pas échapper à cette hypothèse initiale erronée. En revanche, le système structuré en arbre a reconnu l'ambiguïté, a testé l'idée des ventes annuelles, a constaté qu'elle échouait, puis est immédiatement passé à une branche qui interprétait correctement la requête comme des données mensuelles. Cette capacité à changer de direction en fonction des preuves a été la clé de son succès.

Bien que le nouveau système soit plus efficace, il prend un peu plus de temps pour s'exécuter car il explore plusieurs chemins et effectue plus de tests. Les chercheurs ont mesuré le temps nécessaire pour corriger une requête et ont constaté que cela ajoutait quelques minutes au processus, ce qui est un compromis raisonnable pour le gain significatif en précision. Ils ont également trouvé que le système fonctionnait bien avec différents types de modèles informatiques, pas seulement celui qu'ils ont utilisé pour les tests, indiquant que l'approche est flexible et peut être appliquée largement.

Ce travail démontre que pour des tâches complexes comme l'écriture de requêtes de base de données, une approche structurée basée sur un plan est supérieure à une approche linéaire simple. En donnant à l'ordinateur la capacité de faire une pause, de considérer plusieurs options et de revenir en arrière lorsqu'il commet une erreur, le système devient beaucoup plus fiable. Cette conclusion suggère que les futures améliorations de l'intelligence artificielle pour l'analyse de données reposeront probablement moins sur le fait de rendre les modèles plus intelligents de manière isolée que sur le fait de leur donner de meilleurs outils et processus pour vérifier leur propre travail. Les chercheurs ont rendu leur code et leurs données disponibles, permettant à d'autres de s'appuyer sur cette méthode pour améliorer davantage la façon dont les ordinateurs interagissent avec les données humaines.