Résumé technique : Self-CTRL : Entraînement à l'auto-cohérence par apprentissage par renforcement

Énoncé du problème

Les grands modèles de langage (LLM) produisent fréquemment des explications qui ne sont pas fidèles à leurs processus de décision réels. Les modèles énoncent souvent des principes (par exemple, « Je ne générerai pas de contenu discriminatoire ») qu'ils ne parviennent pas à respecter lors de la réponse à des requêtes spécifiques d'utilisateurs. Ce manque d'auto-cohérence mine la confiance des utilisateurs, complique l'audit et entrave la capacité des développeurs à surveiller l'alignement des modèles. L'entraînement standard optimise les modèles pour produire des réponses plausibles à des requêtes individuelles isolées, sans imposer de relation entre les explications de méta-niveau (ce que le modèle dit qu'il va faire) et les comportements d'objet-niveau (ce que le modèle fait réellement). Par conséquent, les modèles peuvent apprendre à répondre de manière plausible aux méta-questions sans que ces réponses ne prédisent leur comportement sur des entrées liées.

Méthodologie : Self-CTRL

Le document présente le Self-Consistency Training with Reinforcement Learning (Self-CTRL), un cadre qui optimise explicitement les LLM pour la cohérence entre leurs auto-explications et leurs comportements. La méthode traite l'explication et le comportement comme des sorties appariées générées à partir d'entrées distinctes mais liées :

• Entrée de méta-niveau ($x_{meta}$) : une requête demandant au modèle de décrire son comportement sur une classe d'entrées (par exemple, « Décrivez comment vous gérez les requêtes impliquant de la discrimination »).
• Entrée d'objet-niveau ($x$) : une instance concrète de cette classe (par exemple, une demande spécifique de génération de texte discriminatoire).

Le modèle échantillonne séparément une explication ($y_{meta}$) et un comportement ($y$). Une fonction de cohérence externe, $\phi(y_{meta}, y; x_{meta}, x)$, évalue si l'explication prédit ou justifie correctement le comportement.

Cadre d'optimisation

Self-CTRL formule la cohérence comme un problème d'apprentissage par renforcement. L'objectif est de minimiser une fonction de perte dérivée du score de cohérence négatif attendu :
$$L(x, x_{meta}) = -\mathbb{E}_{y, y_{meta}}[\phi(y_{meta}, y; x_{meta}, x)]$$

Le cadre prend en charge deux directions d'apprentissage complémentaires, qui peuvent être optimisées indépendamment ou conjointement via une combinaison convexe ($\lambda$) :

1. Entraînement de l'explication ($\lambda = 0$) : met à jour le modèle pour générer des explications qui prédisent mieux son comportement existant. Cela produit des auto-rapports plus fidèles sans nécessairement changer les actions du modèle.
2. Entraînement du comportement ($\lambda = 1$) : met à jour le comportement du modèle pour qu'il satisfasse mieux ses explications énoncées. Cela aligne les actions du modèle avec ses principes.
3. Entraînement mixte ($0 < \lambda < 1$) : optimise simultanément les explications et les comportements.

L'entraînement utilise un estimateur de type GRPO, échantillonnant des groupes d'explications et de comportements candidats. Un comportement (ou une explication) de référence est fixé, et des récompenses sont attribuées sur la base du score de cohérence $\phi$.

Instanciation de $\phi$

La fonction de cohérence $\phi$ est instanciée différemment selon le domaine :

• Domaine formel/probabiliste : $\phi$ est calculée comme la log-vraisemblance du comportement observé sous la distribution probabiliste décrite par l'explication (par exemple, un biais de pièce de monnaie déclaré prédisant une séquence de lancers de pièces).
• Domaine constitutionnel/langage naturel : Puisque les règles en langage naturel n'induisent pas de vraisemblances directes, $\phi$ est instanciée à l'aide d'un Jury de LLM. Plusieurs LLM agissant comme des juges avec différents cadres éthiques (par exemple, l'utilitarisme, la déontologie) évaluent si le comportement est conforme à la règle énoncée. Le score final est la moyenne des verdicts de ces jurés.

Contributions clés et expériences

Le document valide Self-CTRL dans deux domaines distincts :

1. Raisonnement probabiliste avec des explications formelles

• Configuration : Les modèles sont entraînés pour générer des échantillons à partir de pièces biaisées (comportement) et rapporter le biais sous forme de programme (explication).
• Résultats : Initialement, les modèles pouvaient générer des échantillons calibrés mais échouaient à articuler le biais sous-jacent (faible $R^2$). Après l'entraînement de l'explication par Self-CTRL, la corrélation entre le biais articulé et le comportement empirique s'est considérablement améliorée ($R^2$ passant de 0,24 à 0,64 sur les distributions hors échantillon). Cela correspondait à la performance de généralisation d'un modèle entraîné par supervision directe de vérité terrain, démontnant que l'entraînement à la cohérence peut récupérer une structure latente sans étiquetage explicite.

2. IA Constitutionnelle avec des explications en langage naturel

• Configuration : Les modèles sont entraînés pour décrire des principes de gestion de requêtes liées à la sécurité (par exemple, discours de haine, discrimination) puis pour répondre à ces requêtes.
• Résultats :
  • Entraînement de l'explication : A amélioré la capacité d'un auditeur tiers à prédire les refus du modèle basés sur les règles énoncées par le modèle. La précision de la prédiction des refus par un modèle auditeur est passée de 36 % à 92 %.
  • Entraînement du comportement : A amélioré l'alignement en réduant le taux de succès des attaques HarmBench de 15,0 % à 0,5 % sans augmenter sensiblement le sur-refus de contenus inoffensifs.
  • Entraînement mixte : A atteint un compromis Pareto-optimal, améliorant simultanément la simulatibilité (les explications prédisant le comportement) et la sécurité (réduction des sorties nuisibles).

Résultats et importance

Le document affirme que Self-CTRL fournit une recette générale pour entraîner les modèles d'IA à être plus sûrs, plus transparents et plus contrôlables. Les résultats clés incluent :

• Fidélité : La méthode aligne avec succès ce que les modèles disent avec ce qu'ils font, traitant le problème de l'« explication infidèle ».
• Scalabilité : Comme la cohérence est évaluée en utilisant le modèle lui-même (ou un jury de LLM) plutôt que l'étiquetage humain, la méthode passe à l'échelle pour générer de grandes quantités de preuves appariées.
• Interface native : Les auto-explications sont sollicitées via le même canal que celui utilisé par les utilisateurs, ce qui les rend directement utiles pour la confiance et le débogage.
• Généralisation : La méthode démontre une généralisation hors contexte, récupérant des biais latents et affinant les frontières de refus sur des données non supervisées.

Les auteurs positionnent Self-CTRL comme un complément à l'interprétabilité externe. Contra lecture des audits externes, il entraîne les modèles à rendre leurs propres régularités comportementales explicites en langage naturel. Le document note modestement des limites, telles que le potentiel des modèles à converger vers des points fixes triviaux (par exemple, des règles vagues du type « soyez prudent ») si l'espace d'explication n'est pas contraint, et la dépendance à la qualité du juge de cohérence (le jury de LLM). Cependant, les expériences suggèrent qu'avec une conception soignée (prompts structurés, jurys diversifiés), ces problèmes peuvent être atténués.