Résumé Technique : SecRL-Prune

Problématique

Les grands modèles de langage pour le code (CodeLLMs) possèdent la capacité de générer et de réécrire des programmes, une fonctionnalité qui peut être exploitée pour créer diverses variantes de logiciels malveillants afin d'échapper à la détection basée sur les signatures. Une question de sécurité critique se pose : ces modèles peuvent-ils être compressés (via l'élagage/pruning, la distillation ou la quantification) pour tenir dans des budgets matériels limités (par exemple, intégrés dans des charges utiles de malwares ou exécutés sur du matériel grand public) tout en conservant leur capacité à effectuer des mutations de code préservant la sémantique ?

La recherche actuelle sur la compression de modèles cible largement les tâches de langage naturel, laissant peu exploré l'impact d'une compression structurée sur la correction d'exécution et la diversité de mutation des CodeLLMs. De plus, les méthodes d'élagage structuré existantes nécessitent souvent des ressources de calcul importantes, comme le maintien simultané du modèle enseignant et de l'étudiant en mémoire GPU pendant l'entraînement, ce qui limite leur faisabilité dans des scénarios adverses à ressources contraintes.

Méthodologie : SecRL-Prune

Les auteurs proposent SecRL-Prune, un cadre d'apprentissage par renforcement (RL) structuré conçu pour élaguer les CodeLLMs tout en préservant la fidélité de la mutation du code. L'approche opère sur les canaux des réseaux de propagation avant (FFN/MLP) au sein des blocs transformeurs, car ces couches contiennent la majorité des paramètres du modèle.

Composants Clés

1. Apprentissage de Politique par RL :

   • Le problème est formulé comme une recherche du masque d'élagage optimal (une décision binaire de conserver ou de supprimer chaque canal MLP) à travers toutes les couches.
   • Un réseau de politique apprend à attribuer des scores d'importance à chaque canal. Pendant l'entraînement, la politique échantillonne des masques pour créer des modèles « étudiants ».
   • L'objectif est d'identifier quels canaux sont essentiels pour maintenir le comportement du modèle enseignant et lesquels peuvent être supprimés en toute sécurité.

2. Signal de Récompense par Divergence KL :

   • La fonction de récompense est basée sur la distillation de connaissances. Le modèle étudiant élagué est évalué par rapport au modèle « enseignant » original.
   • La récompense est définie comme la divergence de Kullback-Leibler (KL) négative entre la distribution de probabilité du prochain jeton (next-token) de l'enseignant et la distribution de l'étudiant.
   • Pour garantir que l'étudiant préserve les capacités de l'enseignant, la politique est mise à jour (en utilisant l'algorithme REINFORCE) pour maximiser cette récompense, minimisant ainsi efficacement la divergence.

3. Mécanisme de Mise en Cache Top-$P$ :

   • Une innovation clé pour améliorer l'efficacité est la mise en cache des sorties de l'enseignant. Au lieu d'exécuter les modèles enseignant et étudiant en parallèle (ce qui nécessite le double de mémoire GPU), l'enseignant est exécuté une seule fois sur un ensemble de calibration.
   • Seules les prédictions de jetons Top-$P$ (logits et indices) ainsi qu'un compartiment « Autre » agrégé sont mis en cache pour chaque étape temporelle.
   • Pendant l'entraînement par RL, l'étudiant est évalué uniquement par rapport à cette cible compacte mise en cache. Cela réduit considérablement l'utilisation de la mémoire GPU de pointe, car seul le modèle étudiant réside en mémoire pendant l'optimisation.

Principales Contributions

Le document présente quatre contributions principales :

1. Cadre SecRL-Prune : Un nouveau cadre d'élagage structuré basé sur le RL pour les CodeLLMs qui utilise un objectif guidé par la KL pour préserver le comportement de l'enseignant sous compression.
2. Entraînement Économe en Mémoire : L'introduction d'un mécanisme de mise en cache qui pré-calcule les sorties de l'enseignant, permettant d'entraîner la politique d'élagage avec seulement le modèle étudiant en mémoire. Cela permet d'obtenir une utilisation de la mémoire GPU de pointe bien inférieure aux techniques d'élagage structuré précédentes.
3. Étude Empirique sur la Mutation : Une évaluation systématique de la manière dont la compression structurée affecte la capacité des CodeLLMs à effectuer des mutations de code diversifiées syntaxiquement mais préservant la fonctionnalité, en utilisant des métriques basées sur l'exécution.
4. Étude de Cas sur l'Évasion de Malware : Une évaluation de la manière dont les mutations générées par des modèles élagués affectent les taux de détection via les moteurs de détection standards de l'industrie (VirusTotal).

Résultats Expérimentaux

Les auteurs ont évalué SecRL-Prune sur trois CodeLLM de 7B (CodeLlama-7B-Instruct, CodeLlama-7B-Python, et Qwen2.5-Coder-7B-Instruct) à des taux de compression de 10 % à 30 %, en comparaison avec le modèle enseignant non compressé et la ligne de base de l'état de l'art PruneNet.

Métriques de Performance

• Correctitude d'Exécution (pass@k) : SecRL-Prune a systématiquement surpassé PruneNet. À 10 % de compression, il conserve 80 à 85 % de la performance pass@k de l'enseignant, alors que PruneNet n'en conserve que 45 à 72 %. À une compression agressive de 30 %, SecRL-Prune maintient une correction nettement plus élevée (par exemple, 63,7 % contre 35,7 % sur Qwen2.5-Coder).
• Diversité de Mutation (var@k) : Le cadre préserve mieux la diversité des solutions correctes que la ligne de base. Notamment, à 10 % de compression, SecRL-Prune sur Qwen2.5-Coder améliore légèrement la diversité des solutions par rapport au modèle dense, tandis que PruneNet montre un déclin brutal.
• Efficacité des Ressources : En termes d'utilisation de la mémoire GPU de pointe lors de l'entraînement à 20 % de compression, SecRL-Prune utilise moins de la moitié de la mémoire de PruneNet (réduisant l'utilisation de ~33–37 GiB à ~14–16 GiB), soit une réduction de ~55–60 %.

Étude de Cas sur l'Évasion de Malware

En utilisant des échantillons de malwares réels (Python et JavaScript), les auteurs ont testé si les mutations générées par un CodeLLM élagué à 20 % pouvaient échapper à la détection.

• Résultats : Les modèles élagués ont réussi à générer des réécritures préservant la sémantique qui réduisent considérablement les taux de détection sur VirusTotal.
  • Un échantillon Python a vu sa détection chuter de 28/63 à 9/63 (réduction de 68 %).
  • Un échantillon JavaScript a vu sa détection s'effondrer de 9/62 à 1/62 (réduction de 88 %).
• Implication : Même avec une compression significative, les modèles conservent la capacité de générer des variantes capables de contourner l'analyse statique et la détection par signature.

Signification et Revendications

Le papier affirme que la capacité de mutation de code peut survivre à un élagage structuré important. Cette conclusion souligne un risque de sécurité critique : la faisabilité du déploiement de CodeLLMs spécialisés et hautement compressés directement au sein de charges utiles de malwares ou sur du matériel grand public pour automatiser la génération de variantes de malwares évasifs.

Les auteurs soulignent que, bien que les modèles élagués restent capables, ils ne sont pas des remplaçants parfaits du modèle enseignant dense (un écart de performance persiste). Cependant, la capacité de compresser ces modèles tout en conservant leur utilité adversaire abaisse la barrière à l'entrée pour la création de « moteurs de mutation miniaturisés ». Ce travail sert d'avertissement aux défenseurs, suggérant que les futurs malwares pourraient exploiter des modèles compressés et élagués par RL pour automatiser le polymorphisme, nécessitant de nouveaux mécanismes de défense qui vont au-delà des signatures statiques.

Le papier conclut en notant des limites, telles que la dépendance à un support Top-$P$ tronqué pour la fonction de récompense et l'exclusion de l'élagage des têtes d'attention, suggérant que les travaux futurs devraient explorer des données de calibration plus larges et des stratégies d'élagage conjointes.