FreeMOCA : Apprentissage Continu sans Mémoire pour l'Analyse de Code Malveillant

Zahra Asadi*, Haeseung Jeon*, Sohyun Han, Md Mahmuduzzaman Kamol, Se Eun Oh, Mohammad Saidur Rahman†

*Auteurs ayant contribué à égalité. †Auteur correspondant.

[!NOTE] Ceci est l'implémentation officielle de l'article FreeMOCA: Memory-Free Continual Learning for Malicious Code Analysis.

Pipeline FreeMOCA

FreeMOCA fonctionne selon le processus suivant :

Les tâches arrivent séquentiellement, chacune introduisant de nouvelles familles de malwares.
Le modèle de chaque tâche est initialisé à partir de la tâche précédente (warm-start) afin d'aligner les minima des tâches dans l'espace des paramètres.
Après l'entraînement, une interpolation basée sur la connectivité des modes est calculée entre l'optimum de la tâche courante et celui de la tâche précédente. Ce processus peut utiliser une interpolation adaptative par couche basée sur l'amplitude de mise à jour des paramètres.
Le modèle interpolé remplace le modèle courant et est utilisé pour la tâche suivante.
Aucune donnée passée, caractéristique ou échantillon généré n'est stocké, résultant en un apprentissage continu sans mémoire.

L'ensemble du processus construit une chaîne de solutions connectées qui se trouvent sur une variété à faible perte, réduisant significativement l'oubli catastrophique.

Jeux de données

FreeMOCA a été évalué avec deux grands jeux de données de malwares, EMBER et Androzoo. Sources des jeux de données :

EMBER : https://github.com/elastic/ember
Androzoo (AZ) : https://zenodo.org/records/14537891

Téléchargez et configurez le jeu de données dans le répertoire suivant :

FreeMOCA/data/
├── AZ_Class
│   ├── AZ_Class_Test.npz
│   └── AZ_Class_Train.npz
│
├── AZ_Domain
│   ├── 2008_Domain_AZ_Test_Transfo...
│   ├── 2008_Domain_AZ_Train_Transfo...
│   ├── 2009_Domain_AZ_Test_Transfo...
│   └── ...
│
├── EMBER_Class
│   ├── XY_test.npz
│   └── XY_train.npz
│
└── EMBER_Domain
    ├── 2018-01
    ├── 2018-02
    ├── 2018-03
    └── ...

Exécution de FreeMOCA

Ce dépôt prend en charge deux scénarios d'apprentissage continu :

Apprentissage par incrément de classes (Class-IL) : de nouvelles classes (familles de malwares) sont introduites au fil des tâches.
Apprentissage par incrément de domaine (Domain-IL) : l'espace des étiquettes est fixe, mais la distribution des données évolue dans le temps (par exemple, mois/années).

Étape 1. Installation

Exécutez la commande suivante pour :

conda create -n freemoca python=3.9
conda activate freemoca
pip install -r requirements.txt

Étape 2. Exécuter FreeMOCA (Class-IL & Domain-IL)

# EMBER Class-IL
cd ./FreeMOCA_Class/EMBER_Class
CUDA_VISIBLE_DEVICES=0 python main.py --train_data /path/to/data --test_data /path/to/data

# AZ Class-IL
cd ./FreeMOCA_Class/AZ_Class
CUDA_VISIBLE_DEVICES=0 python main.py --train_data /path/to/data --test_data /path/to/data

# EMBER Domain-IL
cd ./FreeMOCA_Domain/EMBER_Domain
CUDA_VISIBLE_DEVICES=0 python main.py --data_root /path/to/data/directory

# AZ Domain-IL
cd ./FreeMOCA_Domain/AZ_Domain
CUDA_VISIBLE_DEVICES=0 python main.py --data_root /path/to/data/directory

Pour une configuration plus détaillée des hyperparamètres, consultez l'Annexe A : Arguments communs pour FreeMOCA.

Annexe A : Arguments communs pour FreeMOCA

Pour ajuster les hyperparamètres ou les paramètres expérimentaux, utilisez les arguments suivants :

Pour modifier les paramètres par défaut, consultez le fichier arguments.py.

Modèles de référence (Baselines)

Notre dépôt prend en charge les expériences sur les modèles de base standards suivants :

None : Entraînement uniquement sur la tâche courante (limite inférieure)
Joint : Entraînement sur toutes les données vues jusqu'à présent (limite supérieure, peu pratique)

Vous pouvez les exécuter avec la commande suivante :

cd /path/to/experiment/directory
CUDA_VISIBLE_DEVICES=0 python none.py --arugment_you_want
CUDA_VISIBLE_DEVICES=0 python joint.py --arugment_you_want

ainsi que les travaux précédents suivants :

CLeWI : Modifié à partir de ce dépôt GitHub, travail de "Continual Learning with Weight Interpolation."
WSC : Modifié à partir de ce dépôt GitHub, travail de "Forget Forgetting: Continual Learning in a World of Abundant Memory."
Generative Replay (GR) : Modifié à partir de ce dépôt GitHub, travail de "Continual learning with deep generative replay."
EWC : Modifié à partir de ce dépôt GitHub, travail de "Overcoming catastrophic forgetting in neural networks."
LwF : Modifié à partir de ce dépôt GitHub, travail de "Learning without Forgetting."
iCaRL : Modifié à partir de ce dépôt GitHub, travail de "iCaRL: Incremental Classifier and Representation Learning."
TAMiL : Modifié à partir de ce dépôt GitHub, travail de "Task-Aware Information Routing from Common Representation Space in Lifelong Learning."
MalCL : Modifié à partir de ce dépôt GitHub, travail de "MalCL: Leveraging GAN-Based Generative Replay to Combat Catastrophic Forgetting in Malware Classification."

Vous pouvez exécuter les modèles de base avec la commande suivante :

# CLeWI pour EMBER-Class
cd ./baselines/CLeWI
CUDA_VISIBLE_DEVICES=6 python main.py --model="clewi" \
  --dataset="seq_ember" --n_tasks=11 \
  --lr=0.001 --buffer_size=500 --n_epochs=50 \
  --seed=42 --optim_wd=0.0 --optim_mom=0.0 \
  --batch_size=512 --sub_dataset="ember"

# CLeWI pour AZ-Class
cd ./baselines/CLeWI
CUDA_VISIBLE_DEVICES=6 python main.py --model="clewi" \
  --dataset="seq_ember" --n_tasks=11 \
  --lr=0.001 --buffer_size=500 --n_epochs=50 \
  --seed=42 --optim_wd=0.0 --optim_mom=0.0 \
  --batch_size=512 --sub_dataset="az"

# WSC pour EMBER-Class
cd ./baselines/WSC
MODEL_NAME=wsc_20_ember
python main.py --config=./exps/wsc_memory/$MODEL_NAME.json

# WSC pour AZ-Class
cd ./baselines/WSC
MODEL_NAME=wsc_20_az
python main.py --config=./exps/wsc_memory/$MODEL_NAME.json

# GR pour EMBER-Class
cd ./baselines/GR_EWC_LwF_iCaRL_EMBER
CUDA_VISIBLE_DEVICES=0 python main.py --data_set=EMBER --tasks=11 --replay=generative --metrics --logger_file gr --scenario=class

# GR pour AZ-Class
cd ./baselines/GR_EWC_LwF_iCaRL_AZ
CUDA_VISIBLE_DEVICES=0 python main.py --data_set=ANDROZOO --tasks=11 --replay=generative --metrics --logger_file gr --scenario=class

# EWC pour EMBER-Class
cd ./baselines/GR_EWC_LwF_iCaRL_EMBER
CUDA_VISIBLE_DEVICES=0 python main.py --data_set=EMBER --tasks=11 --ewc --lambda=50 --metrics --logger_file ewc --scenario=class

# EWC pour AZ-Class
cd ./baselines/GR_EWC_LwF_iCaRL_AZ
CUDA_VISIBLE_DEVICES=0 python main.py --data_set=ANDROZOO --tasks=11 --ewc --lambda=50 --metrics --logger_file ewc --scenario=class

# LwF pour EMBER-Class
cd ./baselines/GR_EWC_LwF_iCaRL_EMBER
CUDA_VISIBLE_DEVICES=0 python main.py --data_set=EMBER  --tasks=11 --replay=current --distill --metrics --logger_file lwf --scenario=class

# LwF pour AZ-Class
cd ./baselines/GR_EWC_LwF_iCaRL_AZ
CUDA_VISIBLE_DEVICES=0 python main.py --data_set=AZ  --tasks=11 --replay=current --distill --metrics --logger_file lwf --scenario=class

# iCaRL pour EMBER-Class
cd ./baselines/GR_EWC_LwF_iCaRL_EMBER
CUDA_VISIBLE_DEVICES=1 python main.py --data_set=EMBER --tasks=11 --icarl --budget=2000 --metrics --logger_file=icarl --scenario=class

# iCaRL pour AZ-Class
cd ./baselines/GR_EWC_LwF_iCaRL_AZ
CUDA_VISIBLE_DEVICES=0 python main.py --data_set=ANDROZOO --tasks=11 --icarl --budget=2000 --metrics --logger_file=icarl --scenario=class

# TAMiL pour EMBER-Class
cd ./baselines/TAMiL_EMBER
CUDA_VISIBLE_DEVICES=0 python main.py

# TAMiL pour AZ-Class
cd ./baselines/TAMiL_AZ
CUDA_VISIBLE_DEVICES=0 python main.py

# MalCL pour EMBER-Class
cd ./baselines/MalCL_EMBER
CUDA_VISIBLE_DEVICES=0 python main.py --train_data /path/to/data --test_data /path/to/data

# MalCL pour AZ-Class
cd ./baselines/AZ_EMBER
CUDA_VISIBLE_DEVICES=0 python main.py --train_data /path/to/data --test_data /path/to/data

`--init_classes`	Nombre de classes à la tâche 0
`--epochs`	Époques par tâche
`--batchsize`	Taille du lot
`--lr`	Taux d'apprentissage
`--momentum`	Momentum SGD
`--weight_decay`	Décroissance du poids
`--lambda_min`	Poids d'interpolation minimum
`--lambda_max`	Poids d'interpolation maximum

FreeMOCA

Populaires