Teaching Language Models How to Code Like Learners: Conversational Serialization for Student Simulation

1. Problématique et Contexte

Le domaine de l'éducation informatique cherche à simuler le comportement des apprenants pour évaluer à grande échelle les stratégies de tutorat et les mécanismes de feedback. Bien que des modèles existent pour tracer les connaissances (Knowledge Tracing), ils se concentrent souvent sur l'estimation de la maîtrise des concepts plutôt que sur la simulation du processus de résolution de problèmes (comment un étudiant agit, réagit et progresse).

Les approches actuelles utilisant les grands modèles de langage (LLM) pour générer du code d'étudiant souffrent de plusieurs limites :

• Dépendance et coût : Elles reposent souvent sur le prompting de modèles propriétaires (fermés), soulevant des problèmes de confidentialité des données et de coûts.
• Manque de réalisme procédural : Les modèles basés uniquement sur le prompting tendent à reproduire des erreurs de surface ou à fournir des solutions correctes trop rapidement, sans capturer la nature itérative et dynamique du débogage réel (échecs, corrections, feedbacks).
• Absence de feedback environnemental : La plupart des méthodes ignorent les retours du système d'évaluation automatique (tests, erreurs d'exécution) qui guident l'étudiant.

L'objectif de ce travail est de créer des "étudiants artificiels" capables de simuler fidèlement les trajectoires de débogage réelles en utilisant des modèles open-weight entraînés sur des données de processus authentiques.

2. Méthodologie

Les auteurs proposent une approche novatrice combinant la sérialisation des données de logs en format conversationnel et une optimisation par préférence.

A. Sérialisation Conversationnelle (Conversational Serialization)

Au lieu de traiter les logs bruts comme une simple séquence de code, les auteurs transforment l'interaction entre l'étudiant et son environnement d'apprentissage en un dialogue structuré :

• Rôle Utilisateur (User) : Représente le système d'évaluation automatique (autograder). Il fournit la description de l'exercice et, après chaque tentative, le feedback (résultats des tests, erreurs d'exécution, notes).
• Rôle Assistant (Assistant) : Représente l'étudiant. Il génère le code soumis.
• Structure : Une trajectoire d'apprentissage devient une alternance de tours de conversation : Code de l'étudiant -> Feedback du système -> Code corrigé -> Nouveau feedback, etc.
  Cette transformation permet d'utiliser des modèles de langage conversationnels standards pour apprendre les schémas de débogage itératif sans modification architecturale.

B. Pipeline d'Entraînement

L'entraînement se déroule en deux phases principales sur des modèles Qwen (4B et 8B) :

1. Fine-Tuning Supervisé (SFT) :

   • Le modèle est entraîné à prédire le prochain code soumis par l'étudiant en fonction de l'historique du dialogue (code précédent + feedback).
   • La perte est calculée uniquement sur les tours de l'assistant (le code de l'étudiant).

2. Optimisation par Préférence (Preference Optimization) :
   Pour aligner le modèle sur le comportement réel des étudiants et éviter qu'il ne saute prématurément vers une solution parfaite, les auteurs utilisent deux méthodes :

   • DPO (Direct Preference Optimization - Hors ligne) : Construction de paires de préférence à partir des données réelles.
     • Préféré : La soumission immédiate suivante de l'étudiant ($a_{t+1}$).
     • Non préféré : La première soumission ultérieure ayant une note différente (souvent une solution plus avancée ou différente).
     • L'objectif est d'apprendre au modèle pourquoi un étudiant choisit une solution spécifique à une étape donnée, plutôt que de sauter directement à la solution finale.
   • DAPO (Online Preference Optimization) : Une variante basée sur GRPO (Group Relative Preference Optimization). Le modèle génère plusieurs candidats, qui sont notés selon leur alignement fonctionnel (note obtenue) et leur similarité syntaxique (AST) avec la vraie soumission de l'étudiant.

3. Contributions Clés

1. Sérialisation Étudiant-Environnement : Introduction d'une formulation conversationnelle qui permet aux LLM d'apprendre les processus de débogage itératifs en intégrant le feedback de l'environnement comme partie du dialogue.
2. Méthodologie d'Entraînement : Proposition d'un pipeline combinant SFT et optimisation par préférence (DPO/DAPO) pour aligner les modèles sur les trajectoires de codage authentiques.
3. Évaluation Empirique : Validation sur un grand jeu de données (FalconCode, 3,8 millions de traces d'étudiants en Python) montrant que le feedback environnemental et l'optimisation par préférence améliorent significativement le réalisme de la simulation.

4. Résultats Expérimentaux

Les expériences ont été menées sur le dataset FalconCode (Académie de l'Air des États-Unis) en utilisant des modèles Qwen3-4B et Qwen3-8B.

• Supériorité des modèles entraînés : Les modèles fine-tunés surpassent largement les modèles de base (BASE) et les modèles propriétaires (GPT-5-mini) en prompting. Les modèles de base ont tendance à générer des solutions correctes trop tôt, ce qui réduit leur couverture (coverage) et leur réalisme.
• Impact du Feedback Environnemental : L'ajout des retours de l'autograder (SFT avec feedback) améliore les métriques par rapport aux modèles entraînés uniquement sur le code (PARA), même si le contexte est plus court. Le feedback est plus informatif que l'historique de code supplémentaire.
• Performance de l'Optimisation par Préférence :
  • DPO (Hors ligne) : Obtient les meilleurs résultats globaux, avec la couverture la plus élevée (0,982 pour le 4B, 0,957 pour le 8B) et la proximité de note la plus forte. Il réussit à maintenir la simulation sur plusieurs étapes de déroulement (rollout) sans dégrader la qualité.
  • DAPO (En ligne) : Donne des résultats mitigés, parfois inférieurs au SFT simple, probablement en raison de contraintes de calcul (échantillonnage limité) et de l'absence de traces de raisonnement explicites (Chain-of-Thought).
• Métriques :
  • Couverture (Coverage) : Capacité du modèle à générer une soumission à chaque étape où l'étudiant réel en a fait une (évite de terminer la trajectoire trop tôt).
  • Proximité de note (Grade Proximity) : Alignement fonctionnel entre le code généré et le code réel.
  • CodeBLEU : Similarité syntaxique et sémantique.
  • Les modèles DPO suivent la progression des notes des étudiants réels de manière beaucoup plus fidèle que les autres approches.

5. Signification et Perspectives

Signification :
Ce travail démontre que pour simuler efficacement des étudiants, il ne suffit pas de prédire le code final ; il faut modéliser le processus de résolution incluant les erreurs et les corrections guidées par le feedback. La méthode proposée offre une alternative pratique, peu coûteuse et respectueuse de la vie privée (données locales, modèles open-weight) aux solutions propriétaires.

Limites :

• Les données sont biaisées vers les étudiants réussissant (95% de réussite finale), ce qui limite la simulation des étudiants en difficulté ou ceux qui abandonnent.
• Évaluation limitée à un seul langage (Python) et un seul contexte institutionnel.
• Absence de validation sur des applications en aval (ex: efficacité réelle pour entraîner des tuteurs IA).

Travaux Futurs :

• Développer des agents étudiants dotés d'outils d'exécution et d'édition.
• Améliorer l'optimisation en ligne en intégrant des traces de raisonnement explicites (Chain-of-Thought).
• Personnaliser les simulations en intégrant l'historique des étudiants sur des exercices précédents.
• Étendre la validation à d'autres langages et contextes éducatifs.

En résumé, cette recherche établit un nouveau standard pour la simulation d'étudiants en éducation informatique, prouvant que la combinaison de la sérialisation conversationnelle et de l'optimisation par préférence permet de créer des agents artificiels capables de reproduire fidèlement les comportements de débogage humains.