Chaîne de Code : Raisonnement avec un Émulateur de Code Augmenté par un Modèle de Langage

Chain of Code: Reasoning with a Language Model-Augmented Code Emulator

December 7, 2023

Auteurs: Chengshu Li, Jacky Liang, Andy Zeng, Xinyun Chen, Karol Hausman, Dorsa Sadigh, Sergey Levine, Li Fei-Fei, Fei Xia, Brian Ichter

cs.AI

Résumé

Le code fournit une structure syntaxique générale pour construire des programmes complexes et effectuer des calculs précis lorsqu'il est associé à un interpréteur de code. Nous émettons l'hypothèse que les modèles de langage (LMs) peuvent exploiter l'écriture de code pour améliorer le raisonnement en chaîne de pensée (Chain of Thought), non seulement pour les tâches logiques et arithmétiques, mais aussi pour les tâches linguistiques (et en particulier celles qui mélangent les deux). Par exemple, imaginez demander à un LM d'écrire un code qui compte le nombre de fois où il détecte du sarcasme dans un essai : le LM pourrait peiner à écrire une implémentation pour "detect_sarcasm(string)" qui puisse être exécutée par l'interpréteur (gérer les cas particuliers serait insurmontable). Cependant, les LMs pourraient tout de même produire une solution valide s'ils sont utilisés non seulement pour écrire le code, mais aussi pour "émuler" sélectivement l'interpréteur en générant le résultat attendu de "detect_sarcasm(string)" et d'autres lignes de code (par exemple, que l'interpréteur ne pourrait pas compiler). Dans ce travail, nous proposons Chain of Code (CoT), une extension simple mais étonnamment efficace qui améliore le raisonnement des LMs piloté par le code. L'idée clé est d'encourager les LMs à formater les sous-tâches linguistiques dans un programme sous forme de pseudocode flexible, permettant au compilateur de détecter explicitement les comportements non définis et de les confier à une simulation par un LM (en tant que "LMulator"). Les expériences démontrent que Chain of Code surpasse Chain of Thought et d'autres méthodes de référence sur une variété de benchmarks ; sur BIG-Bench Hard, Chain of Code atteint 84 %, soit une amélioration de 12 % par rapport à Chain of Thought. CoT s'adapte bien aux modèles de grande et petite taille, et élargit le champ des questions de raisonnement que les LMs peuvent résoudre correctement en "pensant en code". Page web du projet : https://chain-of-code.github.io/.

English

Code provides a general syntactic structure to build complex programs and perform precise computations when paired with a code interpreter -- we hypothesize that language models (LMs) can leverage code-writing to improve Chain of Thought reasoning not only for logic and arithmetic tasks, but also for linguistic ones (and in particular, those that are a mix of both). For example, consider prompting an LM to write code that counts the number of times it detects sarcasm in an essay: the LM may struggle to write an implementation for "detect_sarcasm(string)" that can be executed by the interpreter (handling the edge cases would be insurmountable). However, LMs may still produce a valid solution if they are used not only to write the code, but also to selectively "emulate" the interpreter by generating the expected output of "detect_sarcasm(string)" and other lines of code (e.g., that the interpreter could not compile). In this work, we propose Chain of Code (CoT), a simple yet surprisingly effective extension that improves LM code-driven reasoning. The key idea is to encourage LMs to format linguistic sub-tasks in a program as flexible pseudocode that the compiler can explicitly catch undefined behaviors and hand off to simulate with an LM (as an "LMulator"). Experiments demonstrate that Chain of Code outperforms Chain of Thought and other baselines across a variety of benchmarks; on BIG-Bench Hard, Chain of Code achieves 84%, a gain of 12% over Chain of Thought. CoT scales well with large and small models alike, and broadens the scope of reasoning questions that LMs can correctly answer by "thinking in code". Project webpage: https://chain-of-code.github.io/.