Améliorer les modèles de code pour des contextes sans symboles

Les modèles de code basés sur la technologie Transformer ont montré un grand succès dans les tâches d’ingénierie logicielle. Cependant, ces modèles galèrent quand ils tombent sur du code sans symboles ni infos utiles. Quand les symboles manquent, c'est chaud pour les modèles de capter les relations entre les différentes parties du code. Cet article propose une nouvelle manière d'entraîner ces modèles de manière efficace, même dans les situations où les symboles ne sont pas dispos.

#Aperçu du problème

Quand le code est dépouillé de ses symboles, il ressemble souvent à une forme super basique d'un langage de programmation, sans contexte significatif. Ça complique la tâche tant pour les humains que pour les modèles pour déchiffrer le sens du code. Par exemple, dans le code binaire, les variables peuvent être représentées seulement par des adresses mémoire ou des registres, ce qui rend difficile de suivre les Dépendances ou de comprendre comment les différentes parties du code interagissent.

#Méthode proposée

Pour surmonter ces défis, on propose une méthode qui utilise l'analyse de programme pour capturer le contexte avant d'entraîner le modèle. Cette analyse permet au modèle de se concentrer sur les relations pertinentes, même sans symboles. Au lieu de s'appuyer sur des symboles comme dans les modèles traditionnels, notre approche utilise une stratégie de masquage spéciale pour aider le modèle à apprendre quelles parties du code sont les plus importantes.

#Processus d'entraînement

On améliore la tokenisation standard et on ajuste le design du modèle pour qu'il fonctionne mieux avec notre méthode. L'entraînement comprend une phase de pré-entraînement où le modèle est exposé à un gros dataset contenant plein de fonctions binaires. Dans notre cas, on a utilisé 26 millions de fonctions binaires pour aider le modèle à apprendre les motifs sous-jacents dans le code.

Pendant l'entraînement, le modèle apprend à reconnaître les relations importantes dans le code, ce qui l'aide à mieux performer dans différentes tâches, comme identifier des binaires similaires, inférer des types et classer des malwares. Notre modèle a montré des améliorations significatives par rapport aux méthodes existantes, boostant la performance dans plusieurs tâches.

#Architecture du modèle

Notre approche se base sur un modèle Transformer similaire à BERT mais avec quelques modifications clés. Le modèle utilise un mécanisme d'attention régularisé qui se concentre sur des interactions spécifiques dans le code. En dirigeant l'attention seulement sur les tokens pertinents, on peut s'assurer que le modèle mette en avant les relations significatives et ignore les infos inutiles.

Dans le cœur du modèle, on utilise des blocs Transformer multi-couches qui traitent des séquences de tokens d'entrée. Chaque couche du modèle utilise les masques d'attention spéciaux que nous avons conçus pour réguler sur quoi le modèle se concentre. Cette architecture permet au modèle de mieux comprendre la sémantique du code, même sans symboles clairs.

#Régularisation de l'attention

Une partie majeure de notre méthodologie est la régularisation de l'attention. On construit des masques qui dictent quels tokens peuvent faire attention les uns aux autres selon les dépendances du programme. Comme ça, quand un token traite son contexte, il ne considère que les tokens pertinents selon les règles de dépendance qu'on a établies.

On décompose l'attention en trois contextes clés :

1. Contexte global : Ça permet aux tokens d'avoir une vue d'ensemble de tous les tokens dans l'entrée, pour que le modèle puisse capter les relations générales à travers tout le code.

2. Contexte local : Ça se concentre sur les tokens dans la même instruction, s'assurant que le modèle prête attention à tout le sens de l'instruction sans être distrait par d'autres instructions.

3. Contexte de dépendance : Ça permet au modèle de reconnaître les relations entre les instructions basées sur leurs dépendances, s'assurant qu'il peut apprendre comment différentes parties du code se relient entre elles.

#Pré-entraînement et ajustement

Le processus de pré-entraînement implique deux objectifs principaux : le Modèle de Langage Masqué (MLM) et le Modèle de Dépendance Masqué (MDM). Dans le MLM, des tokens aléatoires dans l'entrée sont masqués, et le modèle apprend à les prédire selon leurs contextes. Le MDM, quant à lui, se concentre sur la prédiction des dépendances de programme tout en masquant certains liens pour éviter des corrélations artificielles.

Après le pré-entraînement, notre modèle peut être ajusté pour des tâches spécifiques. Cette flexibilité lui permet d'être utilisé efficacement dans diverses applications sans avoir besoin de repartir de zéro à chaque fois.

#Résultats

Notre modèle a été testé à travers plusieurs tâches, notamment l'analyse de similarité binaire, la classification de familles de malwares et l'inférence de types pour les binaires. Dans chaque cas, notre modèle a surpassé les modèles d'état de l'art existants, prouvant l'efficacité de notre approche.

Pour les tâches de similarité binaire, on a constaté que notre modèle améliore considérablement les taux de rappel, aidant à identifier correctement des fonctions similaires avec plus de précision. En classification de malwares, il a réussi à regrouper efficacement les malwares en familles selon leur comportement, améliorant les taux de détection.

Dans le domaine de l'inférence de types, notre modèle a montré une forte capacité à prédire des types de haut niveau à partir du code binaire, aidant les reverse engineers à comprendre la structure et le but du code.

#Comparaison avec d'autres modèles

Quand on le compare à d'autres techniques comme GraphCodeBERT et des modèles traditionnels, notre approche a montré une meilleure adaptabilité quand les symboles manquent. Alors que GraphCodeBERT dépend beaucoup des symboles, notre méthode fonctionne même sans, ce qui la rend plus polyvalente pour des applications réelles où le code peut être dépouillé de cette info.

#Conclusion

En résumé, notre travail présente une nouvelle méthodologie d'entraînement pour les modèles de code basés sur Transformer qui excellent même en l'absence de symboles. En s'appuyant sur l'analyse de programme et une régulation attentionnelle soignée, on permet aux modèles d'apprendre des relations significatives dans le code, menant à une performance améliorée dans diverses tâches. Cette approche ouvre de nouvelles voies pour comprendre et analyser le code binaire, en faisant un outil précieux pour l'ingénierie logicielle, la sécurité, et au-delà.

Avec le développement et les tests continus, on s'attend à affiner encore plus ces techniques et à explorer leur potentiel dans encore plus d'applications.