Layerwise Convergence Fingerprints for Runtime Misbehavior Detection in Large Language Models

1. Énoncé du problème

Les Grands Modèles de Langage (LLM) déployés en production font face à trois classes distinctes de menaces en temps d'exécution que la validation standard sur des données propres échoue souvent à détecter :

1. Portes dérobées au moment de l'entraînement : Un fine-tuning malveillant (par exemple via LoRA) qui reste dormant jusqu'à la présence d'un déclencheur spécifique, provoquant l'émission par le modèle d'un comportement choisi par l'attaquant.
2. Jailbreaks : Des invites adverses (par exemple, le jeu de rôle "DAN", des suffixes optimisés par gradient) qui subvertissent l'alignement de sécurité.
3. Injections d'instructions : Des instructions intégrées dans le contenu utilisateur (par exemple, e-mails, extraits de code) qui annulent la tâche prévue par le système.

Limites des défenses existantes :
Les défenses en temps d'exécution actuelles sont souvent spécifiques à une menace, nécessitent un modèle de référence "propre" de confiance, requièrent la connaissance des jetons déclencheurs, ou imposent la modification des poids du modèle (fine-tuning/élagage). Ces hypothèses tiennent rarement pour des artefacts opaques de tiers déployés dans des environnements cloud ou périphériques. Il existe un besoin d'un moniteur sans réglage, agnostique de la menace et en boîte blanche qui fonctionne sans réentraînement ni modèles externes.

2. Méthodologie : Empreintes de convergence par couche (LCF)

Les auteurs proposent LCF, un moniteur en temps d'exécution qui traite la trajectoire des états cachés entre les couches du transformateur comme un "signal de santé". L'intuition centrale est que, lors d'une inférence propre, les états cachés évoluent de manière fluide ; les entrées induisant un comportement erroné provoquent des "sauts" anormaux dans ces différences inter-couches.

Composants clés :

1. Vitesse de représentation ($\delta_\ell$) :
   Au lieu de surveiller les activations brutes, LCF calcule la différence entre les états cachés de couches adjacentes :
   $$\delta_\ell = h_{\ell+1} - h_\ell$$
   Cela capture la "vitesse" de la maturation de la représentation.

2. Score d'anomalie par couche (Mahalanobis diagonal) :
   Pour chaque couche $\ell$, LCF calcule une distance de Mahalanobis sur $\delta_\ell$. Crucialement, il utilise une matrice de covariance diagonale pour amplifier les dimensions à faible variance où le traitement propre est stable mais où un comportement erroné provoque de grands déplacements :
   $$s_\ell = \left\| \frac{\delta_\ell - \mu_\ell}{\sigma_\ell} \right\|^2$$
   où $\mu_\ell$ et $\sigma_\ell$ sont estimés à partir d'un petit ensemble de calibration propre.

3. Agrégation sur toutes les couches (Rétrécissement Ledoit–Wolf) :
   Puisque l'emplacement de l'anomalie varie selon l'architecture et le type de menace, LCF agrège les scores sur toutes les $L$ couches. Il résout le problème "échantillon petit, dimension élevée" ($n=200$ échantillons, $L \approx 30\text{--}50$ couches) en appliquant un rétrécissement Ledoit–Wolf pour estimer une matrice de précision régularisée $P$.
   $$D = \sqrt{(z - \bar{z})^\top P (z - \bar{z})}$$
   où $z$ est le vecteur des scores de couches normalisés en z. Cela capture les déviations corrélées à travers le réseau.

4. Calibration et seuillage :

   • Entrée : Un petit ensemble de données propres (200 exemples) issu de la distribution de déploiement.
   • Seuil ($\tau$) : Déterminé via une calibration Leave-One-Out (LOO) pour cibler un taux de faux positifs (FPR) spécifique (par exemple, 10 %).
   • Décision : Si $D > \tau$, le système s'abstient (renvoie une réponse de repli sûre) avant la génération de tout jeton. Sinon, la sortie passe sans modification.

3. Contributions principales

1. Détection unifiée des menaces : LCF est le premier moniteur en temps d'exécution à détecter les portes dérobées, les jailbreaks et les injections d'instructions en utilisant un score unique, agnostique de la menace, sans nécessiter de connaissance des déclencheurs, de modèles de référence ou d'édition des poids.
2. Stratification de profondeur à trois bandes : L'article identifie empiriquement que différentes menaces concentrent les anomalies à différentes profondeurs :
   • Jailbreaks : Couches précoces (perturbation du traitement initial des jetons).
   • Injections d'instructions : Couches intermédiaires (concurrence avec le contexte prévu).
   • Portes dérobées : Couches tardives (spécifiques à l'architecture, là où le modèle s'engage à produire une sortie).
   • Signification : Cela explique pourquoi une agrégation sur toutes les couches est nécessaire ; aucune couche unique ne fournit une couverture universelle.
3. Efficacité : LCF fonctionne avec moins de 0,1 % de surcharge d'inférence, en inspectant uniquement l'étape de préremplissage (étape 0) et sans nécessiter de passes avant supplémentaires ni de modèles auxiliaires.

4. Résultats expérimentaux

La méthode a été évaluée sur quatre architectures (Llama-3-8B, Qwen2.5-7B, Gemma-2-9B, Qwen2.5-14B) à travers 56 combinaisons de portes dérobées, 3 techniques de jailbreak et des benchmarks d'injection d'instructions (BIPIA).

• Défense contre les portes dérobées :
  • Réduction du taux moyen de réussite de l'attaque (ASR) à <1 % sur Qwen2.5-7B (0,9 %) et Gemma-2 (0,7 %).
  • Atteinte d'un ASR de 1,3 % sur le plus grand Qwen2.5-14B.
  • Surpassement des lignes de base comme CleanGen (qui nécessite un modèle de référence) et CROW (qui nécessite une édition des poids).
• Détection des jailbreaks :
  • Détection de 92–100 % des jailbreaks de style DAN.
  • Détection de 62–100 % des attaques GCG et des jeux de rôle plus doux.
  • Atteinte d'une quasi-équivalence avec les détecteurs supervisés d'états cachés (LLMScan) mais à un coût computationnel 65–113 fois inférieur (préremplissage unique contre 65+ passes avant).
• Injections d'instructions :
  • Signalement de 100 % des injections de charge utile textuelle sur tous les modèles et domaines.
  • Détection des injections de charge utile de code avec une haute précision (augmentant avec la taille du modèle ; 100 % sur Qwen2.5-14B).
• Robustesse :
  • Sous des attaques adaptatives (où l'attaquant minimise le score LCF), LCF est resté robuste à des niveaux de régularisation modérés, tandis que les variantes à couche unique étaient facilement contournées.

5. Signification et impact

• Couche de sécurité polyvalente : LCF fournit un mécanisme de sécurité pratique, "plug-and-play" pour les LLM servis dans le cloud et sur appareil, qui ne repose pas sur l'hypothèse irréaliste d'un modèle de référence propre ou de déclencheurs connus.
• Faisabilité opérationnelle : En opérant avec une surcharge négligeable et sans réentraînement, il résout le goulot d'étranglement du déploiement où les défenses existantes sont trop lentes ou trop gourmandes en ressources.
• Insight théorique : La découverte de la "stratification de profondeur à trois bandes" offre une nouvelle perspective pour comprendre comment différents types d'entrées adverses perturbent le graphe computationnel interne des transformateurs, suggérant que différentes familles de menaces engagent des étapes computationnelles distinctes.
• Limites : La méthode nécessite actuellement un accès en boîte blanche aux états cachés. Elle présente également un taux de faux positifs plus élevé (12–22 %) que le 10 % cible en raison de la variance d'échantillon finie, et elle détecte le "déplacement" (changements de moyenne) mais pas la "dispersion" (changements de variance), ce qui signifie qu'elle peut manquer des types d'erreurs d'hallucination qui ne modifient pas la trajectoire moyenne.

En conclusion, LCF représente une étape significative vers une sécurité robuste et agnostique du temps d'exécution pour les LLM, exploitant les propriétés géométriques de la convergence par couche pour détecter un large spectre de comportements erronés avec un coût computationnel minimal.