Ranking-enhanced anomaly detection using Active Learning-assisted Attention Adversarial Dual AutoEncoder

TL;DR

This paper introduces a new method for detecting stealthy cyber threats using an improved autoencoder model and active learning to reduce the need for labeled data.

Contribution

The novel contribution is an Attention Adversarial Dual AutoEncoder framework enhanced by active learning for efficient APT detection.

Findings

The framework achieved significant improvements in detection rates during active learning.

It outperformed existing approaches on real-world imbalanced cybersecurity datasets.

The method works across multiple operating systems and attack scenarios.

Abstract

Advanced Persistent Threats (APTs) pose a significant challenge in cybersecurity due to their stealthy and long-term nature. Modern supervised learning methods require extensive labeled data, which is often scarce in real-world cybersecurity environments. In this paper, we propose an innovative approach that leverages AutoEncoders for unsupervised anomaly detection, augmented by active learning to iteratively improve the detection of APT anomalies. By selectively querying an oracle for labels on uncertain or ambiguous samples, we minimize labeling costs while improving detection rates, enabling the model to improve its detection accuracy with minimal data while reducing the need for extensive manual labeling. We provide a detailed formulation of the proposed Attention Adversarial Dual AutoEncoder-based anomaly detection framework and show how the active learning loop iteratively enhances the model. The framework is evaluated on real-world imbalanced provenance trace databases produced by the DARPA Transparent Computing program, where APT-like attacks constitute as little as 0.004% of the data. The datasets span multiple operating systems, including Android, Linux, BSD, and Windows, and cover two attack scenarios. The results have shown significant improvements in detection rates during active learning and better performance compared to other existing approaches.

Figures

nDCG score variation over Active Learning iterations for the Windows PA dataset (Bovia E2 scenario).

nDCG score variation over Active Learning iterations for the Android (Clearscope) PE dataset (Pandex E1 scenario).

nDCG score variation over Active Learning iterations for the Android (Clearscope) PE dataset (Bovia E2 scenario).

nDCG score variation over Active Learning iterations for BSD datasets (Pandex E1 scenario).

nDCG score variation over Active Learning iterations for BSD datasets (Bovia E2 scenario).

nDCG score variation over Active Learning iterations for Linux datasets (Pandex E1 scenario).

nDCG score variation over Active Learning iterations for Linux datasets (Bovia E2 scenario).

nDCG score variation over Active Learning iterations for Windows datasets (Pandex E1 scenario).

nDCG score variation over Active Learning iterations for Windows datasets (Bovia E2 scenario).

nDCG score variation over Active Learning iterations for Android datasets (Pandex E1 scenario).

Overall architecture of the *ALADAEN* framework: Active Learning-Assisted Attention Adversarial Dual AutoEncoders for anomaly detection. The framework is composed of three interconnected modules: (1) Data Preparation, which formats provenance events into process-level feature vectors; (2) ADAEN Backbone, a dual autoencoder with attention and adversarial training that learns a robust representation of benign behavior and computes reconstruction-based anomaly scores; and (3) Active Learning & GAN Augmentation, which iteratively selects the most informative unlabeled samples (based on uncertainty

nDCG score variation over Active Learning iterations for Android datasets (Bovia E2 scenario).

Relative improvement in nDCG (%) for ALADAEN with active learning compared to the baseline (active learning ablated). Values are computed as $\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\Delta = (\textrm{Max}_{AL} - \textrm{Baseline}) / \textrm{Baseline} \times 100$$\end{document}$ for each OS $\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \us

Step-by-step workflow of *ALADAEN*. Steps 1-2: Construct process-level feature vectors from the provenance graph and initialize the training set with a small subset of labeled benign data (cold start). Step 3: Train the ADAEN model to reconstruct benign samples and compute anomaly scores based on reconstruction error. Step 4: Rank all unlabeled samples by anomaly score to prioritize potential threats. Step 5: Apply active learning to select the most uncertain samples (i.e., those near the decision threshold) for oracle labeling. Step 6: Augment the newly labeled benign data using a GAN to miti

nDCG score comparison of anomaly detection algorithms across operating systems and attack scenarios. The rows represent the anomaly detection methods, while the columns represent the datasets. The subfigures on the left-hand side correspond to the first attack scenario, and the subfigures on the right-hand side correspond to the second attack scenario.

Reconstruction Error Histogram with Threshold, where the x-axis represents the reconstruction error values, and the y-axis indicates the frequency (count) of data points with a certain error.

nDCG score variation over Active Learning iterations for Linux PA dataset using the ALADAEN framework (Pandex E1 scenario). Values in x-axis represent active learning iterations, whereas y-axis contains nDCG scores. The raw nDCG data is represented by the blue dashed line, while the smoothed nDCG values are depicted by the red dashed line. On the right, a boxplot of the nDCG values shows the distribution of scores throughout the Active Learning process. The figure highlights the model’s performance improvements over iterations, stabilizing at higher nDCG scores as more data is incorporated.

nDCG score variation over Active Learning iterations for the Linux PA dataset (Bovia E2 scenario).

nDCG score variation over Active Learning iterations for the BSD (Cadets) PA dataset (Pandex E1 scenario).

nDCG score variation over Active Learning iterations for the BSD (Cadets) PP dataset (Bovia E2 scenario).

nDCG score variation over Active Learning iterations for the Windows PE dataset (Pandex E1 scenario).

Full text

Introduction

In today’s digital age, the prevalence of cyberattacks has increased drastically, putting critical infrastructure, government agencies, corporations, and private data at risk^1–3^. Among the most sophisticated and dangerous forms of cyberattacks are Advanced Persistent Threats (APTs), which are characterized by stealth, persistence, and a high degree of technical sophistication^4^. APTs often infiltrate networks, remaining undetected for extended periods, with the aim of stealing sensitive data or sabotaging operations^5^. Due to their long-term and tailored nature, detecting APTs poses a significant challenge to traditional cybersecurity tools, such as antivirus software or firewalls, which primarily rely on signature-based detection^6^.

APT actors use a combination of social engineering, zero-day vulnerabilities, custom malware, and lateral movement techniques to infiltrate a system and remain hidden while maintaining access to the network. This advanced nature makes them particularly difficult to detect with traditional signature-based security tools, which rely on predefined patterns of known malware or exploits. Since APTs often blend into normal network behavior and use legitimate credentials or sophisticated obfuscation techniques, they rarely trigger alarms in conventional systems^6,7^.

Safeguarding information systems from APT attacks remains a complex challenge. Numerous efforts have been made to design cybersecurity and intelligence tools, with Intrusion Detection Systems (IDS) being a key method to help organizations bolster their defenses against APTs^8^. Some solutions advocate for the use of network firewalls, which are security devices that monitor Internet traffic and filter unwanted content^9^. Other organizations opt for manual threat hunting strategies that involve security experts who continuously monitor networks around the clock to detect potential threats. In addition, partnering with cybersecurity service providers is another option; in the event of an attack, these companies can provide crucial assistance in responding to threats.

Although these IDS solutions offer considerable promise for detecting Advanced Persistent Threats (APTs), they are hindered by significant limitations related to the substantial investments required in time, personnel, and hardware resources. In cybersecurity, rapid response is paramount, as defensive measures must be deployed more swiftly than attackers can execute their intrusions. The concept of “breakout time”, referring to the duration between an intruder gaining initial access and beginning to compromise the network, underscores the necessity of a fast, automated defense system capable of replicating human-like intelligence for effective threat mitigation^10^.

Recently, anomaly detection (AD) has emerged as one of the key strategies in identifying cyber-security threats by detecting deviations from normal behavior. Unlike traditional IDS mechanisms, which rely on predefined signatures or rules, anomaly detection works by modeling typical behavior and detecting deviations that may indicate a breach.

However, since APT attacks often involve previously unseen exploits or behaviors not present in signature databases, therefore anomaly detection in the context of APTs presents several challenges, such as: (i) Low signal-to-noise ratio: In large networks, legitimate anomalies—for instance software updates, high-volume transactions, or administrative activities—can generate significant noise. This makes it difficult for an anomaly detection system to distinguish between benign deviations and true signs of a persistent threat. (ii) Stealth and low-activity operations: APT attackers operate in a highly stealthy manner, often mimicking legitimate user behavior. They make gradual and subtle changes to the network that are difficult to detect using traditional anomaly detection techniques that focus on detecting more dramatic deviations. (iii) Label rarity: Most cybersecurity datasets are heavily imbalanced, with a vast majority of data representing normal behavior and only a very small fraction representing anomalous or malicious activity. Moreover, labeled data is scarce, as most attacks are identified post-facto after significant damage has been done, and ground-truth data on APTs is difficult to obtain^6,11^.

To address these issues and challenges, this paper presents ALADAEN, an APT detection framework that comes up with a smart contribution, enabling the model to quickly improve its detection rate while reducing the need for extensive manual labeling and large training datasets, through the combination of Active Learning (AL), Generative Adversarial Neural Networks (GAN) and an Attention-based Adversarial Dual AutoEncoder (ADAEN).

Firstly, the proposed ADAEN neural network is trained to identify APT-like patterns within imbalanced trace databases, where malicious attacks represent only a small fraction of system activities. This deep neural network learns a low-dimensional representation of normal activity data, and any data that significantly deviates from this representation during decoding is flagged as anomalous and marked for further investigation. The incorporation of the attention mechanism further enhances the model’s ability to focus on the most relevant aspects of the input data. Attention mechanisms dynamically assign weights to different parts of the input, allowing the model to prioritize important features in long-sequence of events. The Adversarial Dual AutoEncoder offers, particularly in tasks like anomaly detection, several advantages over a baseline AutoEncoder such as: rich data representation, improved robustness to noise and adversarial attacks, enhanced feature learning, and most importantly support for active learning integration. In fact, the ADAEN neural network is enhanced here with an Active Learning (AL) strategy, that iteratively improves its performance^12^. By querying an oracle to label uncertain or anomalous samples, active learning enables a more efficient training process, reducing the amount of labeled data required while improving the model’s ability to detect novel and sophisticated attack patterns.

It is worth noting that active learning plays a pivotal role in our framework for APTs detection, especially since there is a scarcity of labeled data. In many real-world scenarios, obtaining a large and well-labeled dataset can be time-consuming, expensive, or impractical, particularly when the data involves rare events such as anomalies or cyberattacks. Our proposed solution addresses this challenge by allowing the model to intelligently select the most uncertain, ambiguous, or potentially informative data points and request labels for only those instances. Moreover, to further enhance the performance of the model, we incorporate data augmentation using a Generative Adversarial Network (GAN) during active learning^13^. This augmentation helps generate synthetic data resembling the labeled normal points, thereby enriching the training set and improving the model’s ability to generalize quickly.

The selective querying process makes an efficient use of the limited labeling resources by focusing on the data that will most significantly improve the model performance. In anomaly detection (e.g. APTs), where the dataset is often heavily imbalanced — with very few anomalies compared to normal data — the active learning implementation ensures that the model prioritizes the identification of outliers or unusual patterns. Consequently, this would accelerate the learning process, allowing the model to detect anomalies with higher accuracy even when only a small subset of the data is labeled. By continuously refining the ADAEN neural network with real minimal labeled examples that are augmented with a GAN, active learning minimizes the need for extensive human intervention while significantly enhancing the model’s ability to generalize from limited data, ultimately improving detection rates for rare but critical anomalies.

Our method has been implemented and tested using real provenance data from several operating systems and compared to many existing anomaly detection approaches. It has shown better detection rates than those methods when using the entire training datasets. Furthermore, when using smaller learning datasets, the combination of active learning and GAN allows our approach to iteratively improve its detection rate by selectively augmenting and refining the model’s performance over time.

The remainder of the paper is organized as follows. Section “Background and related work” provides a deeper introduction and discussion on APT attacks, and the anomaly detection methodologies and their application in cyber-security. Section “ALADAEN: an active learning-assisted adversarial dual autoEncoder for APTs detection” presents ALADAEN, our proposed Active Learning-assisted Attention Adversarial Dual AutoEncoder model for anomaly detection in the context of Advanced Persistent Threat (APT). The section also explains how the framework can be leveraged with the integration of active learning and GANs to refine the detection rates. Section “Experimental settings, results and analysis” summarizes the used datasets, the evaluation metrics, and the experimentation results. Section “Conclusion” concludes the paper with the main outcomes and finally section “Future work” gives some future perspectives.

Background and related work

Concept of advanced persistent threats (APTs)

An Advanced Persistent Threat (APT) is a highly targeted, sophisticated cyberattack in which an attacker gains unauthorized access to a network and remains undetected for an extended period^14^. The primary objectives of APTs are to steal sensitive information, sabotage operations, or establish long-term access to the target network^15^. Unlike typical cyberattacks that are opportunistic and often one-off, APTs are strategic, involving multiple phases over long periods^16,17^.

APTs typically operate in five distinct phases:

• Reconnaissance: The attacker conducts extensive research on the target, identifying vulnerabilities, network architecture, and potential entry points.
• Initial Exploitation: The attacker gains access to the target network, often through phishing, exploiting software vulnerabilities, or using stolen credentials.
• Establishing Persistence: Once inside, the attacker installs malware, such as back-doors or Remote Access Trojans (RATs), to maintain access to the network even if the initial vulnerability is patched.
• Lateral Movement: The attacker escalates privileges and moves laterally through the network to compromise more devices and access sensitive information.
• Data Exfiltration/Impact: After gathering valuable information, the attacker exfiltrates the data without raising alarms or uses the compromised systems for further exploitation.

Several notable APT attacks over the years have demonstrated the severity and complexity of these threats^10,18^. They have had far-reaching consequences, targeting critical infrastructure, government organizations, and global corporations^19^. Among the most famous APT attacks we can cite: Goblin Panda APT27, Fancy Bear APT28, Cozy Bear APT29, Ocean Buffalo APT32, Helix Kitten APT34, Wicked Panda APT41 APT19, Stuxnet, Deep panda, Epic Turla, Oldsmar, or more recently Pegasus^20,21^. This last cyber warfare tool has been capable of reading text messages, tracking calls, collecting passwords, location tracking, accessing the target device’s microphone and camera, through a zero-click exploit^22^. These well-known APT attacks illustrate the significant risks posed by APTs and highlight the need for robust detection strategies^23,24^. Detecting such anomalies requires advanced machine learning techniques to identify subtle deviations in normal patterns^25^. Indeed, anomaly detection methods, enhanced by modern machine learning techniques, are increasingly being explored as tools for detecting APT activities before they can cause significant harm^26^.

Anomaly detection plays a critical role in cybersecurity, as identifying abnormal behaviors within networks or systems is essential for detecting attacks like APTs, zero-day exploits, and insider threats. Over the years, various techniques, ranging from statistical approaches to advanced machine learning models, have been developed to tackle these cyber threats^27,28^. Below is an overview of the key methods and recent advancements in their field.

Anomaly detection methods in cybersecurity

Statistical methods

• Rule-Based Systems: Early anomaly detection systems relied on predefined rules and thresholds to detect anomalies^29^. For example, intrusion detection systems (IDS) like Snort (https://www.snort.org/) use signature-based and anomaly-based approaches where deviations from normal patterns trigger alerts. While effective for well-known patterns, these systems struggle to detect novel or evolving threats and can generate a high number of false positives^30^.
• Probability-Based Models: Techniques such as Gaussian Mixture Models (GMM) and statistical hypothesis testing use probability distributions to model normal system behavior^31,32^. When new data deviates significantly from the modeled behavior, it is flagged as anomalous. Though simple, these models are often limited in capturing the complexity of modern network traffic and application behavior^33^.

Machine learning-based approaches

• Clustering Algorithms: Unsupervised machine learning models like k-means and DBSCAN have been applied to group data points into clusters, where outliers (i.e., data points that don’t fit any cluster well) are considered anomalous^34–36^. While clustering can effectively detect outliers, it often struggles with high-dimensional data or imbalanced datasets, which are common in cybersecurity^37^.
• Support Vector Machines (SVMs): Support Vector Machines, particularly in their one-class variant (OC-SVM), have been used to define a boundary around normal data in high-dimensional space^38^. Anything falling outside this boundary is classified as an anomaly. Although OC-SVMs perform well for some types of anomalies, they often require extensive tuning and do not scale well for large-scale cybersecurity datasets^39^.
• Random Forests and Isolation Forests: Tree-based methods such as Isolation Forests (iForest) have gained popularity due to their ability to handle high-dimensional data efficiently^40^. Isolation Forests work by isolating anomalies through recursive partitioning of data. These models are computationally efficient and effective in detecting anomalies without requiring labeled data^41^.

Deep learning approaches

• Recurrent Neural Networks (RNNs) and Long Short-Term Memory Networks (LSTMs): Given the sequential nature of network traffic and system logs, RNNs and LSTMs are particularly well-suited for capturing temporal dependencies^42^. These models can learn patterns over time and identify deviations in data, making them effective for detecting real-time threats. LSTMs have been used in anomaly detection for detecting anomalies in log sequences, such as unusual access patterns or abnormal process behaviors^43^.
• Masked Features: Recent advances in self-supervised learning have popularized Masked Autoencoder (MAE) architectures for anomaly detection across diverse domains, including system provenance graphs, network traffic, and IoT telemetry. The core idea of MAE-AD is to randomly mask portions of the input data—whether graph nodes, network flow tokens, or feature vectors—and train the model to reconstruct the missing parts. This mask-and-reconstruct strategy forces the model to learn robust contextual representations of normal behavior without requiring labeled anomalies. In the context of APT detection, MAGIC^44^ extends this principle to provenance graphs through masked graph representation learning, enabling the capture of rich structural and behavioral dependencies among system entities while remaining fully self-supervised. Similar frameworks, such as the MTC-MAE for malware traffic classification^45^ and CompMAE for IoT intrusion detection^46^, demonstrate the generality of MAE-AD: they pretrain on large unlabeled datasets to learn unbiased feature embeddings, then fine-tune or apply reconstruction-error-based scoring to flag anomalies.
• Contrastive Learning: To address the limitations of traditional one-class anomaly detectors that rely solely on reconstruction error or distance from a fixed hypersphere, Deep One-Class Contrastive Learning (Deep OCCL) integrates contrastive representation learning into the one-class framework^47^. Instead of explicitly modeling normal data boundaries in input space, Deep OCCL learns a compact and discriminative latent manifold by generating multiple augmented views of each normal instance and optimizing a self-supervised contrastive objective that pulls positive pairs together while pushing other samples apart. This dual mechanism enables the network to learn intra-class compactness and inter-instance separability without requiring labeled anomalies, significantly enhancing generalization to unseen attacks or perturbations. During inference, anomalies are identified as samples that lie far from the learned latent center or violate the compact representation structure.

Hybrid and ensemble methods

• Hybrid approaches: Combining multiple models, such as clustering algorithms or SVMs for anomaly classification, can leverage the strengths of different methods^48^. For instance, in hybrid intrusion detection systems (IDS), traditional signature-based methods can be combined with anomaly detection techniques to detect both known and unknown threats^49^.
• Ensemble learning: Techniques like bagging and boosting, where multiple models are trained and their outputs aggregated, are gaining traction in cybersecurity. Isolation Forests, for instance, can be enhanced with ensemble methods to improve accuracy and robustness for attacks detection^50,51^.
• Hierarchical Architectures: Among recent developments, High Discrimination APT Intrusion Detection System (HDAPT-IDS)^52^ represents a hybrid intrusion detection framework that integrates traditional machine learning and deep learning for precise multi-level APT classification. The system is composed of two coordinated modules: the Cyber Clustering Module (CCM) and the Clustering Analysis Module (CAM). The CCM performs a preliminary, coarse-grained categorization of network traffic using a Random Forest model to predict a main class label. Based on this prediction, the CAM dynamically selects a Deep Neural Network specialized for that main class to perform fine-grained sub-class discrimination. This hierarchical design allows HDAPT-IDS to reduce category complexity while improving detection precision. Weng et al.^53^ proposed RT-APT, a method that constructs provenance graphs from kernel logs and applies the Weisfeiler–Lehman (WL) subtree kernel to capture contextual and structural dependencies between entities. RT-APT leverages the FlexSketch algorithm, which converts provenance graphs into compact sequences of feature vectors that preserve temporal and topological information. Unsupervised K-means clustering is then performed on benign feature vector sequences to model normal system states, enabling the identification of abnormal behaviors that deviate from learned patterns. Liu et al.^54^ introduced PGAE, a perturbation-based graph autoencoder framework designed to enhance the robustness and representational power of provenance-based APT detection. The method addresses two major challenges in existing graph neural network approaches: the presence of redundant or noisy edges in provenance graphs, and the limited ability of traditional GNNs to capture low-order semantic feature interactions. To overcome these issues, PGAE employs a dual-edge-node masking mechanism that perturbs the graph structure to improve generalization and robustness. It then utilizes a dual-encoder architecture to jointly learn explicit structural relationships and implicit feature dependencies, followed by a cross-correlation decoder that simultaneously optimizes feature reconstruction and topological rebuilding. This design enables unsupervised node-level APT detection without requiring labeled data.

Limitations of existing detection methods

The use of anomaly detection methods for identifying APTs presents several significant challenges. Traditional Intrusion Detection Systems (IDSs) rely on predefined signatures of known threats, which are ineffective in identifying new, unknown, or evolving APT tactics that do not match these signatures. Even machine-learning-based anomaly detection approaches, while more flexible, tend to generate a high number of false positives, mistaking benign activities for potential threats^6^. This can lead to alert fatigue, overwhelming cybersecurity teams and reducing the efficiency of the Security Operations Center (SOC). Early-stage APT activities, such as initial compromise or foothold establishment, are especially difficult to detect, as they involve subtle actions that blend in with normal system behavior. Moreover, APTs frequently employ advanced evasion techniques — such as encryption, polymorphism, and “living-off-the-land” tactics that leverage legitimate system tools — making it difficult for conventional IDSs to recognize their presence. Additionally, conventional approaches often fail to correlate seemingly unrelated events across multiple hosts and data streams that, when combined, are strong indicators of an APT in progress^5^.

Beyond signature-based methods, recent deep learning approaches have introduced adversarially trained AutoEncoders^55–57^ and transformer-enhanced variational models^58,59^ for unsupervised anomaly detection. While promising, these methods typically assume access to large volumes of clean normal data and are trained in a single-shot manner, making them vulnerable to distribution drift and ill-suited to settings with extreme label scarcity. Similarly, active learning approaches in anomaly detection^60^ have largely focused on improving classification accuracy rather than optimizing for ranking quality, which is critical for APT triage where only a handful of top-ranked alerts can be investigated by SOC analysts. Finally, most existing frameworks treat adversarial reconstruction, active querying, and data augmentation as independent modules, and do not provide a unified approach to exploit their synergy.

Recent advances outside the cybersecurity domain have proposed sophisticated architectures that combine adversarial training and representation learning to address label scarcity. USAD employs dual AutoEncoders with adversarial objectives for multivariate time series^60^, while Yao et al. introduced transformer-enhanced VAEs and scalable Trio-Attention U-Transformers with Siamese discriminators for unlabeled anomaly detection in hierarchical IoT settings^58,61,62^. More recently, they proposed a meta-learning powered dual-source representation differentiation framework that improves discrepancy analysis for unsupervised anomaly detection. Although these works represent significant progress, they primarily target low-dimensional time series or IoT data, assume relatively clean training sets, and do not optimize for ranking-centric evaluation. Furthermore, they do not offer a unified pipeline combining adversarial learning, data augmentation, and active querying in the context of high-dimensional, multi-view provenance graphs.

These limitations motivate the design of ALADAEN, which integrates (i) dual adversarial AutoEncoders for robust representation learning under extreme imbalance, (ii) GAN-based augmentation to densify the normal manifold, and (iii) a ranking-oriented active learning loop, ensuring that the most informative anomalies are prioritized for SOC analyst feedback.

Limitations of open-source implementation

Yet a major obstacle in the field of APT detection is the limited availability of open-source implementations for various proposed methods. This lack of publicly accessible code makes it challenging for researchers to replicate experiments, validate findings, or benchmark new approaches against existing ones. Without a standardized framework or reference implementations, conducting comprehensive comparisons between different APT detection techniques becomes difficult, hindering progress in evaluating their relative strengths and weaknesses across diverse datasets and operational environments. As a result, the development of more effective and universally applicable solutions remains a significant challenge.

Limitations of existing learning datasets

Another major challenge when dealing with APT detection concerns the learning datasets. Broadly, there are several characteristics used to categorize the learning databases in cyber-security, such as data provenance type, network traffic, system logs, the presence and relevance of labeled attack. Such a categorization would help to better understand the strengths and limitations of each dataset, facilitating the selection of the most suitable data for specific studies. However, there is a noticeable lack of publicly available datasets that accurately capture the behavior of APT attacks. This is a major scientific bottleneck, which significantly hampers the development of effective APT detection models^63^.

Many existing datasets, like KDDCUP98 (http://kdd.ics.uci.edu/databases/kddcup99/kddcup99.html), NSL-KDD 2009 (https://www.kaggle.com/datasets/hassan06/nslkdd), UNSW-NB15 (https://research.unsw.edu.au/projects/unsw-nb15-dataset) or CICIDS2017 (https://www.unb.ca/cic/datasets/ids-2017.html), were designed for general network intrusion detection but do not specifically target APTs^64,65^. While many researchers claim to focus on detecting Advanced Persistent Threats (APTs), a large portion of these studies rely on standard intrusion detection system (IDS) datasets that lack APT-specific attack patterns. These datasets typically include common threats such as denial-of-service attacks or basic malware, which do not reflect the complexity, persistence, or stealth of real-world APTs. Consequently, the results of such studies may fall short in addressing the true challenges of APT detection. This raises critical concerns about the relevance and reliability of these works, which often overlook the need for specialized datasets tailored to the unique characteristics of APTs. For example, the work in Sakthivelu and Vinoth Kumar^66^ applies ensemble learning to intrusion detection using the TRAbID dataset (https://secplab.ppgia.pucpr.br/?q=trabid), which focuses exclusively on Remote Desktop Protocol (RDP) netflow events within a single operating system—Windows. As a result, its scope for capturing diverse anomalous behaviors is inherently limited. In Martín Liras et al.^67^, the authors evaluate several classifiers—including SVM, random forest, kNN, and regression models—for APT detection. However, the dataset consists of Windows log files featuring PE32 executables, object code, and DLLs, based on a legacy 32-bit architecture that no longer reflects current 64-bit systems, thus limiting its relevance. Similarly, the model proposed in Abdullayeva^68^ introduces a deep neural network with additional layers for APT detection, but it was validated solely on a small, Windows-specific malware dataset (https://marcoramilli.com/2016/12/16/malware-training-sets-a-machine-learning-dataset-for-everyone/) hosted on a personal blog. The dataset lacks documentation on its provenance and curation, and its low citation count suggests limited use in the broader research community.

The study in Neuschmied et al.^69^ introduces another deep learning-based APT detection method, trained on a hybrid dataset combining CICIDS2017 and Contagio. While CICIDS2017 includes real-world network traffic, it does not contain APT-like patterns, and although Contagio is claimed to provide APT-relevant data, it is no longer accessible and was also hosted on a personal blog. As such, the validity of the evaluation results cannot be independently verified. Likewise, the authors of Min et al.^70^ validate their method using CICIDS2017 and KDDCUP99—neither of which includes APT attacks. Notably, over half of intrusion detection studies still rely on KDD datasets due to their availability^71^, despite longstanding criticisms regarding the artificial nature of their generation process^72^.

Recent work by Berrada et al.^25^ and Benabderrahmane et al.^26^ has advanced APT detection through system-wide provenance analysis and trace mining. These studies highlight that enriched provenance data can uncover causal dependencies between system events, enabling the detection of sophisticated attack patterns—such as data exfiltration—that often bypass traditional perimeter-based defenses. Their evaluation leveraged the DARPA [SPSVERBc1SPS] dataset, produced under the [SPSVERBc2SPS] program (https://www.darpa.mil/program/transparent-computing), which offers high-quality, heterogeneous provenance traces. Among the proposed methods, VF-ARM (Valid Frequent Association Rule Mining) flags anomalies when frequent behavioral patterns are violated, while VR-ARM (Valid Rare Association Rule Mining) detects infrequent but valid patterns indicative of anomalous activity^26^. Additional baseline methods include Attribute Value Frequency (AVF)^73^, which detects rare attribute values, and Frequent Pattern Outlier Factor (FPOF)^74^, which identifies low-frequency patterns as outliers. Outlier Degree (OD)^75^ scores anomalies based on association-rule violations, and One-Class Classification by Compression (OC3)^76^ identifies anomalous instances based on reduced compressibility, assuming that anomalies are less redundant than normal patterns.

In this paper, our proposed framework is trained and evaluated using provenance traces from the ADAPT project^25^, which includes APT-like attacks across multiple operating systems, including Windows, BSD, Linux, and Android. To our knowledge, the ADAPT project (https://gitlab.com/adaptdata) remains the only publicly available source that provides extensive, multi-OS log-event patterns and traces for realistic APT detection research. A significant challenge in training our model with these datasets is that APT attacks make up just 0.004% of the total samples, creating an extremely imbalanced classification problem.

In our experiments, we compared our model against both classical and recent state-of-the-art anomaly detection methods. The classical baselines follow^26^ and include AVF, FPOF, OD, OC3, VF-ARM, and VR-ARM, while the recent methods encompass MAE-AD (Masked AutoEncoder Anomaly Detection, as employed in MAGIC^44^), RT-APT^53^, DeepOCCL^47^, PGAE-APT^54^, and HDPT-IDS^52^. These more recent frameworks collectively represent modern directions in provenance-based, autoencoder-driven, and hybrid deep learning APT detection. All baselines were evaluated using the DARPA Transparent Computing datasets to ensure consistency and comparability under identical conditions. We deliberately excluded datasets that were too small, outdated, or unavailable online, as well as methods validated solely on such limited sources.

ALADAEN: an Active Learning-assisted Adversarial Dual AutoEncoder for APTs detection

Overview and global architecture

The global architecture of the ALADAEN framework is depicted in Fig. 1. It is composed of three major compartments. The first one is responsible for data formatting and preparation. The second one, called here ADAEN, handles the training of the neural network. The third compartment, called AL, is dedicated to active learning and GAN-based augmentation of normal labeled data.

Fig. 1. Overall architecture of the ALADAEN framework: Active Learning-Assisted Attention Adversarial Dual AutoEncoders for anomaly detection. The framework is composed of three interconnected modules: (1) Data Preparation, which formats provenance events into process-level feature vectors; (2) ADAEN Backbone, a dual autoencoder with attention and adversarial training that learns a robust representation of benign behavior and computes reconstruction-based anomaly scores; and (3) Active Learning & GAN Augmentation, which iteratively selects the most informative unlabeled samples (based on uncertainty), queries them from an oracle, and uses GAN-generated synthetic samples to enrich the benign pool before retraining. This modular design enables continuous refinement and improved anomaly ranking under scarce-label conditions.

The workflow of ALADAEN consists of seven main steps, as illustrated in Fig. 2 from top to bottom. It begins with features extraction from the provenance graph databases. The event sequences are represented row-wise in binary vectors, where each data (process) has its corresponding features (steps 1 and 2 in the figure). After that, ADAEN AutoEncoder neural network is initially trained with a subset of normal labeled data (step 3 in the figure), aimed at learning and extracting patterns of normal behavior by minimizing the reconstruction error for these normal instances. The size of the learning subset is intentionally reduced to simulate the rarity of labeled data in real-world scenarios, showcasing the main advantage of our framework, which can iteratively improve performance despite the limited availability of labeled data. After the training, ADAEN is assessed with a test dataset (including both normal and outliers), and anomalous entities which exhibit patterns deviating from normal data will have higher reconstruction errors. Anomaly scores are then computed for each input data based on the reconstruction error, and the pairwise list [data-point, score] is sorted in a descending order. Entities with high errors are considered anomalous and are ranked accordingly. This ranking serves as a prioritized list, where processes at the top are more likely to be anomalies (step 4 in the figure).

Fig. 2. Step-by-step workflow of ALADAEN. Steps 1-2: Construct process-level feature vectors from the provenance graph and initialize the training set with a small subset of labeled benign data (cold start). Step 3: Train the ADAEN model to reconstruct benign samples and compute anomaly scores based on reconstruction error. Step 4: Rank all unlabeled samples by anomaly score to prioritize potential threats. Step 5: Apply active learning to select the most uncertain samples (i.e., those near the decision threshold) for oracle labeling. Step 6: Augment the newly labeled benign data using a GAN to mitigate data scarcity and retrain the ADAEN model with the enriched dataset. Step 7: Repeat previous steps iteratively until the labeling budget is exhausted. This iterative cycle progressively improves anomaly ranking and detection robustness.

The active learning component is integrated into the ALADAEN pipeline to reduce the false positive rate and improve the detection of true anomalies (step 5). The algorithm applies a threshold to identify potential anomalies based on reconstruction error. Instead of asking an oracle to blindly label all points, which is extremely costly, it selects uncertain samples above a given threshold, that are at the top of the ranked list, for further labeling. Uncertainty is measured here for data points whose reconstruction error falls near the threshold boundary, indicating that the model is uncertain about whether they are anomalous. During each iteration of the active learning process: (i) The system queries an oracle (e.g., a human expert) to label uncertain data points from the ranked list, specifically those near the decision boundary. (ii) Based on the feedback, a new subset of normal labeled data is created. A synthetic dataset is then generated using a GAN, which is trained to replicate the data distribution of the normal subset. These two datasets—the real and synthetic—are merged and added back into the original training dataset to refine the model (step 6 in the figure). (iii) Finally, the neural network is retrained on the updated dataset, progressively improving its ability to distinguish between normal and anomalous processes (step 7).

The ultimate goal is to achieve an optimal ranking quickly where all anomalies are positioned at the top of the ranked list after a few iterations. Through active learning, the model continuously improves the accuracy of the rankings by making adjustments based on new labels. The process continues until the model achieves a stable state, where further iterations do not significantly change the ranking. At this point, the model is considered optimized for anomaly detection, having learned a more accurate representation of both normal and anomalous data.

In the next subsections, we will present in details the two important parts of ALADAEN framework, that are ADAEN AutoEncoders, and AL active learning combined with GANs.

ADAEN: Attention Adversarial Dual AutoEncoder Architecture

AutoEncoder fundamentals

AutoEncoders (AE) are unsupervised neural network models that aim to learn an efficient, lower-dimensional representation (latent representations encoding) of input data by minimizing the reconstruction error between the input and output. In the context of anomaly detection, the AutoEncoder is trained to capture the patterns of normal data and can be used to detect anomalies by identifying data points with high reconstruction errors. If an input is anomalous (i.e., different from the normal data), the AutoEncoder will struggle to reconstruct it accurately, leading to a high reconstruction error. This error can then be used as an indicator of anomalies.

Let \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathcal {X}=\{\textbf{x}^{(i)}\}_{i=1}^{m}$$\end{document} denote the dataset, where each \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\textbf{x}^{(i)} \in \mathbb {R}^{d}$$\end{document} is a d-dimensional feature vector representing a process trace (network or OS activity). The AutoEncoder consists of an encoder \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$f_{\theta }(\textbf{x}^{(i)})$$\end{document} and a decoder \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$g_{\theta }(\textbf{z}^{(i)})$$\end{document} , where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\textbf{z}^{(i)} \in \mathbb {R}^k$$\end{document} is a compressed latent representation of the input. The Encoder component is defined as follow:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} \textbf{z}^{(i)} = f_{\theta }\!\bigl (\textbf{x}^{(i)}\bigr ) = \sigma \!\left( W_{e}\textbf{x}^{(i)} + \textbf{b}_{e}\right) \end{aligned}$$\end{document}

where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$W_e$$\end{document} and \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$b_e$$\end{document} are the weights and biases of the encoder, \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\theta = (W_e, b_e)$$\end{document} , and \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\sigma$$\end{document} is a non-linear activation function. The Encoder’s role is to map the original data of dimension d onto a feature space of dimension k where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$k<< d$$\end{document} , whereas the decoder reconstructs the original data from its encoding in the feature space. The Decoder reconstructs the input:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} \hat{\textbf{x}}^{(i)} = g_{\phi }\!\bigl (\textbf{z}^{(i)}\bigr ) = \sigma \!\left( W_{d}\textbf{z}^{(i)} + \textbf{b}_{d}\right) \end{aligned}$$\end{document}

where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$W_d$$\end{document} and \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$b_d$$\end{document} are the weights and biases of the decoder, and \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\phi = (W_d, b_d)$$\end{document} . The AutoEncoder is trained to minimize the reconstruction error:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} \mathcal {L}_{\textrm{rec}} = \frac{1}{|\mathcal {X}|} \sum _{\textbf{x}^{(i)} \in \mathcal {X}} \left\| \textbf{x}^{(i)} - g_{\phi }\!\bigl (f_{\theta }(\textbf{x}^{(i)})\bigr ) \right\| _2^2 \end{aligned}$$\end{document}

Through training, the two networks learn to capture the most important compressed features of the normal data points that can be used to reconstruct the data as accurately as possible. As a result, whenever presented with data points with abnormal patterns and features, the trained networks will have more difficulties in correctly reconstructing that data. Consequently, such attempts will generate larger reconstruction errors. Hence, during inference, the reconstruction error \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$error(\textbf{x}^{(i)}) = \mathcal {L}_{\textrm{rec}}$$\end{document} is computed for each input. Data points with reconstruction error above a given threshold ( \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$error(\textbf{x}^{(i)}) > \tau$$\end{document} ) are flagged as potential anomalies. The anomaly detection decision rule with an AutoEncoder can be written as:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} \text {Anomaly}(\textbf{x}^{(i)}) = {\left\{ \begin{array}{ll} 1 & \text {if } error(\textbf{x}^{(i)}) \ > \tau , \\ 0 & \text {otherwise}. \end{array}\right. } \end{aligned}$$\end{document}

The reconstruction error of a data point \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\textbf{x}^{(i)}$$\end{document} after being passed through the AutoEncoder is also assigned as its anomaly score:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} Ascore(\textbf{x}^{(i)}) = error(\textbf{x}^{(i)}) \end{aligned}$$\end{document}

ADAEN architecture overview

The Attention Adversarial Dual AutoEncoder (ADAEN) architecture used in this paper is a variant of the baseline AutoEncoders that incorporates both adversarial training and dual autoencoding mechanisms, enhancing the detection of anomalies in complex data. It combines generative adversarial networks (GANs) with two AutoEncoders to enhance the detection of anomalies, especially in complex data distributions. The attention mechanism is applied to help the model focus on the most relevant features or timesteps of the encoded data, enhancing reconstruction and anomaly detection performance. ADAEN improves robustness and reconstruction capabilities by leveraging both a primary AutoEncoder for reconstruction and a secondary AutoEncoder to refine and balance the learning process.

Dual adversarial learning

The base of ADAEN consists of two AutoEncoders AE1 and AE2, each learning different but complementary representations of the data as represented in Fig. 2 (step 3). By definition:

• Primary AutoEncoder (AE1): Focuses on reconstructing the input data (normal instances) by minimizing the reconstruction error. For each input sample \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\textbf{x}^{(i)}$$\end{document} :

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} \text {Encoder 1:} \quad&\textbf{z}_{1}^{(i)} = f_{\theta _1}\!\bigl (\textbf{x}^{(i)}\bigr ) \\ \text {Decoder 1:} \quad&\hat{\textbf{x}}_{1}^{(i)} = g_{\phi _1}\!\bigl (\textbf{z}_{1}^{(i)}\bigr ) \end{aligned}$$\end{document}

• Secondary AutoEncoder (AE2): Works alongside AE1 to refine the reconstruction and capture complementary representations. For the same input sample \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\textbf{x}^{(i)}$$\end{document} :

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} \text {Encoder 2:} \quad&\textbf{z}_{2}^{(i)} = f_{\theta _2}\!\bigl (\textbf{x}^{(i)}\bigr ) \\ \text {Decoder 2:} \quad&\hat{\textbf{x}}_{2}^{(i)} = g_{\phi _2}\!\bigl (\textbf{z}_{2}^{(i)}\bigr ) \end{aligned}$$\end{document}

These two AutoEncoders help capture different but complementary representations of the data, which improves the robustness of the system.

The reconstruction losses for the two AutoEncoders are defined as:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} \mathcal {L}_{\textrm{rec}_1}= & \frac{1}{|\mathcal {X}|} \sum _{\textbf{x}^{(i)} \in \mathcal {X}} \left\| \textbf{x}^{(i)} - g_{\phi _1}\!\bigl (f_{\theta _1}(\textbf{x}^{(i)})\bigr ) \right\| _2^2 \end{aligned}$$\end{document} \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} \mathcal {L}_{\textrm{rec}_2}= & \frac{1}{|\mathcal {X}|} \sum _{\textbf{x}^{(i)} \in \mathcal {X}} \left\| \textbf{x}^{(i)} - g_{\phi _2}\!\bigl (f_{\theta _2}(\textbf{x}^{(i)})\bigr ) \right\| _2^2 \end{aligned}$$\end{document}

The total reconstruction error for the ADAEN is a weighted combination of these two errors:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} \mathcal {L}_{\textrm{rec}} = \alpha \mathcal {L}_{\textrm{rec}_1} + (1-\alpha )\mathcal {L}_{\textrm{rec}_2}, \quad \alpha \in [0,1] \end{aligned}$$\end{document}

where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\alpha \in [0,1]$$\end{document} is a hyper parameter that balances the contributions of the two AutoEncoders.

Adversarial component

ADAEN integrates adversarial training, inspired by GANs, to enhance the model’s ability to capture the data distribution. The discriminator \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D_{\psi }$$\end{document} is defined through the second AutoEncoder, which is trained to distinguish between real data samples and the reconstructed samples produced by the first AutoEncoder that plays the role of the generator (Fig. 2, step 3).

The discriminator \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D_{\psi }$$\end{document} assigns a probability that a sample \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\textbf{x}^{(i)}$$\end{document} is real (i.e., from the true data distribution), and helps improve the first AutoEncoder to generate more realistic reconstructions that closely resemble the original data. The adversarial loss for the discriminator is given by:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} \mathcal {L}_{D}&= - \mathbb {E}_{\textbf{x}^{(i)} \sim p_{\text {data}}} \bigl [\log D_{\psi }(\textbf{x}^{(i)})\bigr ] \nonumber \\&\quad - \mathbb {E}_{\hat{\textbf{x}}_1^{(i)}, \hat{\textbf{x}}_2^{(i)} \sim p_{\text {reconstruction}}} \!\bigl [ \log \!\bigl (1 - D_{\psi }(\hat{\textbf{x}}_1^{(i)})\bigr ) + \log \!\bigl (1 - D_{\psi }(\hat{\textbf{x}}_2^{(i)})\bigr ) \bigr ] \end{aligned}$$\end{document}

The generator (AE1) is trained to fool the discriminator by making its reconstructions indistinguishable from real samples. Its adversarial loss is:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} \mathcal {L}_{\textrm{adv}} = - \mathbb {E}_{\hat{\textbf{x}}_1^{(i)}, \hat{\textbf{x}}_2^{(i)} \sim p_{\text {reconstruction}}} \!\bigl [ \log D_{\psi }(\hat{\textbf{x}}_1^{(i)}) + \log D_{\psi }(\hat{\textbf{x}}_2^{(i)}) \bigr ] \end{aligned}$$\end{document}

Finally, the overall objective for ADAEN combines reconstruction and adversarial terms:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} \mathcal {L}_{\textrm{ADAEN}} = \mathcal {L}_{\textrm{rec}} + \lambda \mathcal {L}_{\textrm{adv}}, \quad \lambda > 0 \end{aligned}$$\end{document}

where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\lambda > 0$$\end{document} is a weighting hyperparameter that balances the contribution of the reconstruction and adversarial losses. In our experiments, we set \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\lambda = 0.5$$\end{document} as a simple and effective choice.

Training ADAEN involves the following steps:

1. Train Discriminator: Update the discriminator \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D_{\psi }$$\end{document} to minimize the adversarial loss \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathcal {L}_{D}$$\end{document} .
2. Train AutoEncoders: Update the parameters of both AutoEncoders \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\theta _1, \phi _1, \theta _2, \phi _2$$\end{document} to minimize the combined loss \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathcal {L}_{\text {ADAEN}}$$\end{document} . The training alternates between updating the discriminator and the AutoEncoders, that is similar to the GAN training process.

When applied to anomaly detection, ADAEN uses both AutoEncoders to compute the reconstructions, which are then compared to detect anomalies.

As in the case of a baseline AutoEncoder, for a given input sample \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\textbf{x}^{(i)}$$\end{document} , the final anomaly score is computed as the combined reconstruction loss:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} Anomaly(\textbf{x}^{(i)}) = \mathcal {L}_{\textrm{rec}}\!\bigl (\textbf{x}^{(i)}\bigr ) = \alpha \mathcal {L}_{\textrm{rec}_1}\!\bigl (\textbf{x}^{(i)}\bigr ) + (1-\alpha )\mathcal {L}_{\textrm{rec}_2}\!\bigl (\textbf{x}^{(i)}\bigr ) \end{aligned}$$\end{document}

If \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$Anomaly(\textbf{x}^{(i)}) > \tau$$\end{document} , the input is classified as an anomaly:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} \text {Anomaly}(\textbf{x}^{(i)}) = {\left\{ \begin{array}{ll} 1 & \text {if } Anomaly(\textbf{x}^{(i)}) > \tau , \\ 0 & \text {otherwise}. \end{array}\right. } \end{aligned}$$\end{document}

Attention mechanism

To enhance the generator’s reconstruction (AE1), an extra attention mechanism layer is added to the encoded features through Encoder 1 component. Its role is to help the model focus on key parts of the input data during the generation process, ensuring that important features are captured more effectively while generating synthetic data. This would help the generator create higher-quality reconstructions of normal data and better identify patterns, which is crucial when generating new synthetic data.

Given Encoder 1’s output \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$z \in \mathbb {R}^{T \times k}$$\end{document} (where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$T$$\end{document} is the number of timesteps and \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$k$$\end{document} is the feature dimension in the latent space), the attention mechanism computes an attention score \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\xi _i$$\end{document} for each timestep \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$i$$\end{document} , helping the model focus on important timesteps.

The attention score \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\xi _i$$\end{document} is computed as:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\xi _i = \frac{\exp (e_i)}{\sum _{j=1}^T \exp (e_j)}$$\end{document}

where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$e_i$$\end{document} is the relevance score for timestep \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$i$$\end{document} , typically computed as a dot product of the hidden state \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$h_i$$\end{document} and a learned context vector \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$v$$\end{document} :

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$e_i = v^\top h_i$$\end{document}

The context vector \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$c$$\end{document} is the weighted sum of the Encoder 1 outputs:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$c = \sum _{i=1}^{T} \xi _i h_i$$\end{document}

This context vector \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$c$$\end{document} is used by the Decoder 1 to reconstruct the input.

Rationale for dual AutoEncoder design

The choice of a dual AutoEncoder (AE) architecture with an adversarial component and an attention mechanism in ADAEN is motivated by the need to model highly complex and heterogeneous behaviors in cybersecurity provenance data. This design provides the following conceptual advantages:

• Enhanced data distribution modeling: Using two AutoEncoders allows the system to learn complementary latent representations, offering a richer description of normal behavior and improving sensitivity to subtle deviations.
• Error refinement through adversarial consistency: AE2 acts as a reconstruction-refiner for AE1, learning to produce outputs that are closer to the normal manifold. Anomalies that AE1 reconstructs too well still incur disagreement with AE2, which amplifies their anomaly scores.
• Robustness through redundancy: The presence of two reconstruction paths introduces diversity in learned representations, reducing the chance that both models will underfit or overfit the same features simultaneously.
• Generalization and stability: The adversarial objective forces AE1 to improve reconstructions iteratively so that they cannot be distinguished by AE2 as abnormal, encouraging better generalization and reducing overfitting.
• Attention-driven focus on key events: The attention mechanism highlights the most informative features of the input, improving reconstruction quality where it matters most for anomaly detection.

Together, these design elements allow ADAEN to better separate normal and anomalous behaviors, particularly under the severe class imbalance characteristic of APT detection. The resulting anomaly scores are more robust, stable, and aligned with operational needs, providing a principled foundation for the active learning loop and subsequent ranking-based triage.

To provide reproducibility and enable direct comparison with future work, we next summarize the detailed architecture of ADAEN and the GAN module employed.

Architectural details

Each AutoEncoder (AE1 and AE2) uses a fully-connected feedforward architecture whose layer widths are defined relative to the input dimension d (number of features per process). The encoder consists of three layers with widths \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$[d \rightarrow d/2 \rightarrow d/4 \rightarrow k]$$\end{document} , where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$k=32$$\end{document} is the latent dimension. The decoder is symmetric with widths \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$[k \rightarrow d/4 \rightarrow d/2 \rightarrow d]$$\end{document} . All hidden layers use LeakyReLU activation ( \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\alpha =0.2$$\end{document} ), followed by batch normalization. A dropout layer ( \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p=0.2$$\end{document} ) is applied after the first hidden layer to prevent overfitting.

For the adversarial component, the discriminator \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D_{\psi }$$\end{document} is a three-layer MLP with widths \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$[d \rightarrow d/2 \rightarrow d/4 \rightarrow 1]$$\end{document} , where the last layer outputs a probability score via a sigmoid activation. The generator is AE1, trained to minimize the non-saturating GAN loss. Both AE1/AE2 and \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D_{\psi }$$\end{document} are optimized using Adam ( \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\beta _1=0.5, \beta _2=0.999$$\end{document} , learning rate \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$10^{-4}$$\end{document} ).

Active learning

Background

Active learning is a paradigm where the model selectively queries the user (or an oracle) to label the most informative examples, aiming to improve the model with fewer labeled examples. This approach is especially useful when labeling data is costly or time-consuming which is the case with APTs where the learning databases are rare. The model focuses on uncertain or difficult examples that can help refine its accuracy. Intuitively, the motivation behind our utilization of active learning for APTs detection comes from rewards and penalties in cybersecurity. In such a context, positive rewards are typically given when there is a correct detection of an attack (e.g., DDoS, malware, phishing) by flagging the traffic as anomalous or malicious. The model could also consider a positive reward during a successful mitigation of an attack, i.e. if the relevant action is taken to successfully block an attack or reduce its impact (e.g., blocking malicious IPs, isolating infected systems). Inversely, a penalty would happen when the model fails to protect the system or causes unnecessary disruption. In fact, if the model incorrectly flags normal behavior as malicious, it will incur a penalty. For instance, blocking legitimate user access or flagging benign network traffic as malicious would cause the system to be disrupted, leading to a penalty.

Oracle querying

After the initial training of ADAEN neural network on a dataset primarily consisting of normal data, the goal is for the model to learn how to reconstruct normal patterns with minimal error. The framework passes the test data through the AutoEncoder and calculates the reconstruction error for each example. Then it uses a threshold on reconstruction error to flag potential anomalies (points with a high reconstruction error).

Instead of manually labeling a large number of data points, the framework uses active learning strategy to query the most informative samples. These could be: points near the threshold of reconstruction error (uncertain if they are anomalous or not); or points with the highest reconstruction error, likely to be anomalous. During the active learning loop, the most uncertain data points are identifier for labeling and the uncertainty of a sample \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$x$$\end{document} is quantified by its proximity to the decision boundary. Mathematically, this is often represented using the model’s confidence score: \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$U(x) = 1 - p(\hat{y}|x)$$\end{document} where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p(\hat{y}|x)$$\end{document} is the predicted probability for the most likely class label \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\hat{y}$$\end{document} . Data points with the highest uncertainty (lowest confidence) are selected for labeling. Then the framework queries an oracle (e.g., a human expert) to label these points as normal or anomalous.

After obtaining the labels for these ambiguous points from an oracle, the framework uses them to train a Generative Neural Network (GAN), and a synthetic dataset is produced by replicating the data distribution of the newly labeled ambiguous points. Both datasets are then merged and used to refine the AutoEncoder’s threshold for anomaly detection and retrain it with the newly labeled data.

Ambiguous points augmentation with GAN

We employ a Generative Adversarial Network (GAN) to augment the ambiguous (uncertain) data points during the active learning process. Specifically, once the most uncertain or ambiguous data points are identified and labeled by the oracle, a GAN is used to generate synthetic data that closely mimics the distribution of the normal labeled data. The uncertain points labeled as normal by the oracle are then combined with the synthetic data generated by the GAN, and this augmented dataset is used to retrain the AutoEncoders. This augmentation helps to enrich the dataset, especially in scenarios where labeled data is scarce. This should also improve the reconstruction capabilities of the AutoEncoders for normal data, leading to better detection of anomalies. By iteratively incorporating synthetic samples generated by the GAN into the training process, we enhance the model’s capacity to learn from limited data and improve its performance in distinguishing between normal and anomalous instances. This strategy is particularly effective in addressing the imbalance typically seen in anomaly detection tasks.

The used GAN consists of two neural networks, a generator \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$G$$\end{document} and a discriminator \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D$$\end{document} , that are trained together in a competitive process. Both are defined as follows:

The Generator \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$G$$\end{document} : Given a random noise vector \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$z \sim p_z(z)$$\end{document} , the generator tries to produce synthetic data \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$G(z)$$\end{document} that resembles the distribution of the uncertain points labeled as normal \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p_{\text {data}}(x)$$\end{document} . Thus:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$G: z \mapsto G(z) \quad \text {where} \quad z \sim \mathcal {N}(0, I)$$\end{document}

The Discriminator \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D$$\end{document} : is a classifier that attempts to distinguish between real data samples \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$x \sim p_{\text {data}}(x)$$\end{document} and synthetic data \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$G(z)$$\end{document} . The output of the discriminator is a probability \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D(x)$$\end{document} that indicates how likely a given sample is real:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D: x \mapsto [0, 1] \quad \text {where} \quad D(x) \text { is the probability that } x \text { is real.}$$\end{document}

The training objective is a minimax optimization problem:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\min _G \max _D \mathbb {E}_{x \sim p_{\text {data}}(x)}[\log D(x)] + \mathbb {E}_{z \sim p_z(z)}[\log (1 - D(G(z)))]$$\end{document}

Iterative loop

The whole process can be repeated iteratively: by reapplying the AutoEncoder to the augmented dataset, and using active learning to query additional informative samples. Over time, the model becomes better at distinguishing between normal and anomalous points, and the detection rate improves with fewer false positives and negatives.

There are several key benefits behind the utilization of active learning within our anomaly detection framework. For instance, it ensures an efficient labeling by minimizing the number of data that need to be labeled (hence the cost), focusing on the most ambiguous or informative points. This is particularly helpful when anomalies are rare and hard to label. Through the iterative learning, the model gets progressively better as more labeled data becomes available, without the need for massive amounts of labeled training data at the start.

The sampling strategies in the Active Learning process could be diverse. For example, with uncertainty sampling, the model selects data points that are close to the decision boundary for labeling (i.e., points with reconstruction errors near the anomaly threshold). These points are the most uncertain, and labeling them helps refine the boundary between normal and anomalous data. With diversity sampling, the model selects diverse points that cover different regions of the data space to ensure that the model learns about various types of potential anomalies. With outlier sampling, the model selects points with the highest reconstruction error, as they are most likely to be anomalous. In our case, the outlier and uncertainty sampling have been chosen since they are more appropriate to APTs detection.

Anomaly ranking and evaluation metrics

In Advanced Persistent Threat (APT) detection, where malicious processes typically comprise less than 0.1% of the dataset, relying on accuracy as a performance metric is misleading. A model could trivially attain near-perfect accuracy by labeling all processes as benign, thereby failing to detect actual threats. Consequently, we shift our focus from overall accuracy to the model’s ability to identify and prioritize APT-related anomalies.

This reframes the task as a ranking problem: instead of binary labels (“normal” vs. “anomalous”), the model assigns a score to each process that reflects its likelihood of being anomalous. The resulting ranked list allows security analysts to review the most suspicious processes first—a setting that better aligns with operational cybersecurity workflows. Ranking is also well-suited to active learning, where the model iteratively selects top-scored instances (i.e., most uncertain or anomalous) for expert labeling, thus accelerating the learning process with minimal supervision.

To evaluate the quality of this ranking, we use the Normalized Discounted Cumulative Gain (nDCG)^77^, a widely adopted metric in information retrieval. nDCG assesses how effectively a model places the truly anomalous instances near the top of the ranked list^26,25^. The score ranges from 0 to 1, with 1 indicating that all anomalies are perfectly ranked at the top, regardless of their internal order.

First, the Discounted Cumulative Gain (DCG) is computed as:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} DCG = \sum _{i=1}^{N} \frac{rel_i}{\log _2(i + 1)}, \end{aligned}$$\end{document}

where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$rel_i$$\end{document} denotes the binary relevance (1 for anomaly, 0 otherwise) of the \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$i^\text {th}$$\end{document} item in the ranked list of N processes. The DCG is then normalized by the ideal DCG (iDCG), which corresponds to a perfect ranking:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\begin{aligned} nDCG = \frac{DCG}{iDCG}. \end{aligned}$$\end{document}

In our setting, each process receives an anomaly score, and the nDCG evaluates how well true anomalies are ranked above benign processes. Maximum nDCG is achieved when all anomalous instances occupy the top k positions (where k is the number of anomalies), irrespective of their mutual order.

This ranking-based evaluation provides a robust and interpretable measure of detection performance, especially in highly imbalanced scenarios typical of APT campaigns, where the objective is to surface rare but critical threats.

ALADAEN Pseudo-code

Algorithm 1 gives the pseudo-code of ALADAEN framework. It iteratively trains the ADAEN AutoEncoder model, queries an oracle for labels, and refines the model using new labeled data. The algorithm uses a ranking system based on reconstruction errors and uncertainty scores to identify anomalies and enhance detection performance.

Algorithm 1ALADAEN(): Active Learning-Assisted Attention Adversarial Dual AutoEncoders

Step 1: AutoEncoder training

• Objective: Train the Attention Adversarial Dual AutoEncoder (ADAEN) model on a labeled sub-dataset to capture the normal data patterns and detect anomalies.
• The algorithm begins by training the ADAEN model on the labeled dataset \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D_L$$\end{document} , which consists of known normal data. The model is trained to minimize the reconstruction loss between the original data and the reconstructed data generated by the AutoEncoder.
• Reconstruction Error Calculation: After training, the algorithm computes the reconstruction error for each sample in the unlabeled dataset \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D_U$$\end{document} . The reconstruction error for a sample \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\textbf{x}^{(i)}$$\end{document} is computed as:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\text {error}\!\bigl (\textbf{x}^{(i)}\bigr ) = \left\| \textbf{x}^{(i)} - \text {ADAEN}\!\bigl (\textbf{x}^{(i)}\bigr ) \right\| _2^2,$$\end{document}

where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\text {ADAEN}(\cdot )$$\end{document} denotes the combined reconstruction produced by the dual autoencoder, i.e.,

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\text {ADAEN}\!\bigl (\textbf{x}^{(i)}\bigr ) = \alpha g_{\phi _1}\!\bigl (f_{\theta _1}(\textbf{x}^{(i)})\bigr ) + (1-\alpha )g_{\phi _2}\!\bigl (f_{\theta _2}(\textbf{x}^{(i)})\bigr ).$$\end{document}

• Anomaly Scoring: The reconstruction error is then used to compute the anomaly score for each sample:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$S(\textbf{x}^{(i)}) = \mathcal {L}_{\textrm{rec}}\!\bigl (\textbf{x}^{(i)}\bigr ) = \alpha \mathcal {L}_{\textrm{rec}_1}\!\bigl (\textbf{x}^{(i)}\bigr ) + (1-\alpha )\mathcal {L}_{\textrm{rec}_2}\!\bigl (\textbf{x}^{(i)}\bigr ).$$\end{document}

Samples with high reconstruction errors are more likely to be anomalies.

• Anomaly Classification: Each sample is classified as an anomaly if its anomaly score exceeds a predefined threshold \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\tau$$\end{document} :

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\text {Anomaly}(\textbf{x}^{(i)}) = {\left\{ \begin{array}{ll} 1 & \text {if } S(\textbf{x}^{(i)}) > \tau \\ 0 & \text {otherwise} \end{array}\right. }$$\end{document}

The choice of the threshold values is explained in the experiments section.

Step 2: Active Learning Loop

• Objective: Iteratively improve the model’s performance by querying the oracle for labels of uncertain samples and retraining the model with the newly labeled data.
• Anomaly Score Sorting: The anomaly scores are then sorted in descending order to prioritize the most anomalous samples for querying:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathcal {S}_{\textrm{sorted}} = \operatorname {sort}\!\bigl (\{S(\textbf{x}^{(i)}) \mid \textbf{x}^{(i)} \in D_{U}\}\bigr ), \quad \text {descending}.$$\end{document}

• Uncertainty Calculation: For each sample \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\textbf{x}^{(i)} \in D_{U}$$\end{document} , the uncertainty score is computed as the distance between its anomaly score and the decision threshold \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\tau$$\end{document} :

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$U(\textbf{x}^{(i)}) = \bigl | S(\textbf{x}^{(i)}) - \tau \bigr |.$$\end{document}

Samples with \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$U(\textbf{x}^{(i)})$$\end{document} close to zero are considered the most uncertain and are prioritized for oracle querying.In ALADAEN, the threshold \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\tau$$\end{document} is initialized based on the q-th percentile of the reconstruction errors in the current pool:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\tau = \operatorname {Percentile}\!\left( \{ s(\textbf{x}^{(i)}) \mid \textbf{x}^{(i)} \in D_{U} \}, q \right) ,$$\end{document}

where \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$q \in [0,100]$$\end{document} is a user-defined percentile (e.g., \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$q=80$$\end{document} for the 80th percentile). Samples with \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$s(\textbf{x}^{(i)}) > \tau$$\end{document} are flagged as potential anomalies.

Step 3: Compute nDCG Score

• Objective: Evaluate the quality of the ranking of anomaly scores using the normalized discounted cumulative gain (nDCG) metric.
• The nDCG score is computed by matching the sorted anomaly scores \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$S_{\text {sorted}}$$\end{document} with the ground truth labels \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathcal {Y}_{\text {ground truth}}$$\end{document} :

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$${nDCG}_{\text {score}}=nDCG(S_{\text {sorted}},\mathcal {Y}_{\text {ground truth}})$$\end{document}

The nDCG score reflects how well the model ranks the true anomalies at the top of the list, with a score close to 1 indicating a perfect ranking.

Step 4: Querying the Oracle

• Objective: Select the most uncertain samples and query the oracle (e.g., a human expert) to obtain their true labels.
• The algorithm selects the top Q samples with the highest uncertainty scores:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\{ x_1, x_2, \dots , x_Q \} = \arg \max _{\textbf{x}^{(i)} \in D_U} U(\textbf{x}^{(i)})$$\end{document}

• Oracle Interaction: The oracle provides the true labels for the selected samples:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathcal {Y}_{\text {uncertain}} = \text {Oracle}(\{ x_1, x_2, \dots , x_Q \})$$\end{document}

• Data augmentation with GAN: A generative neural network is trained with the newly labeled samples \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathcal {Y}_{\text {uncertain}}$$\end{document} to produce a similar synthetic dataset:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\hat{\mathcal {Y}}_{\text {uncertain}}=GAN( \mathcal {Y}_{\text {uncertain}}).$$\end{document}

Both \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathcal {Y}_{\text {uncertain}}$$\end{document} and \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\hat{\mathcal {Y}}_{\text {uncertain}}$$\end{document} are combined, and added to the labeled dataset \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D_L$$\end{document} for further training:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D_L \leftarrow D_L \cup \mathcal {Y}_{\text {uncertain}} \cup \hat{\mathcal {Y}}_{\text {uncertain}}$$\end{document}

Step 5: Retraining the AutoEncoder

• Objective: Retrain the ADAEN model on the updated labeled dataset that includes both the initial labels and the new labels from the oracle.
• After updating \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D_L$$\end{document} , the AutoEncoder is retrained to minimize the reconstruction loss:

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathcal {L}_{\text {reconstruction}} = \frac{1}{|D_L|} \sum _{\textbf{x}^{(i)} \in D_L} || \textbf{x}^{(i)} - \hat{\textbf{x}^{(i)}} ||^2$$\end{document}

• The retraining helps the model refine its understanding of both normal and anomalous data patterns, improving its ability to detect anomalies in future iterations.

Termination

The algorithm repeats the active learning loop until the query budget Q is exhausted or the predefined stopping criterion ( \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$N_{\text {iterations}}$$\end{document} ) is met. Once the loop terminates, the final trained AutoEncoder and the results (e.g., final nDCG scores) are output.

Output

The final output includes:

• The trained AutoEncoder model
• The updated labeled dataset \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$D_L$$\end{document}
• The final anomaly detection results
• The final nDCG scores, which indicate the quality of the anomaly ranking.

Contribution summary and distinction from prior work

The proposed ALADAEN framework introduces several distinctive design choices that set it apart from existing anomaly detection methods that combine AutoEncoders with adversarial training or active learning.

First, unlike adversarially trained AutoEncoder approaches such as ALAD^57^, GANomaly^78^, and ALOCC^79^, which couple a single AutoEncoder with a separate discriminator network, ALADAEN employs a dual-AutoEncoder adversarial design. In this setting, AE1 acts as a generator while AE2 functions as a reconstruction-refiner/discriminator, providing complementary latent representations and disagreement-aware reconstructions that sharpen anomaly signals under severe class imbalance.

Second, ALADAEN integrates an attention layer in the encoder path, allowing the model to focus on salient event/time steps within long and sparse provenance-derived behavioral sentences. To the best of our knowledge, this is the first time attention has been explicitly applied to provenance event sequences in an adversarial dual-AutoEncoder context.

Third, whereas prior active learning methods for anomaly detection typically rely on classifier-margin or uncertainty sampling and evaluate performance using AUROC or accuracy, ALADAEN adopts a ranking-centric active learning loop. We select near-threshold reconstruction-uncertain processes and directly optimize the nDCG metric, aligning the learning process with the operational requirements of Security Operations Center (SOC) workflows where analysts must prioritize top-ranked threats under strict time constraints.

Fourth, ALADAEN performs GAN-based augmentation exclusively on the oracle-confirmed normal pool obtained during active learning. This densifies the normal manifold without introducing synthetic anomalies that might shift the decision boundary, making the approach robust under extreme data scarcity.

Finally, we demonstrate the operational scope of ALADAEN through a comprehensive evaluation on 40 heterogeneous datasets (4 OS \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} 2 scenarios \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} 5 views) from the DARPA Transparent Computing (TC) program. Prior work such as USAD^60^ primarily targets multivariate time series and does not integrate attention, GAN-based augmentation, or ranking-driven active learning.

Experimental settings, results and analysis

In the following sections, we present the datasets and the benchmarking protocol for the evaluation of ALADAEN against the previously mentioned state-of-the-art anomaly detection methods, including classical baselines (AVF^25,73^, OC3^76^, OD^75^, FPOF^74^, VR-ARM^26^, VF-ARM^26^) and recent deep learning-based approaches such as MAE-AD (Masked AutoEncoder Anomaly Detection, as employed in MAGIC^44^), RT-APT^53^, DeepOCCL^47^, PGAE-APT^54^, and HDPT-IDS^52^.

For an initial comparison, we utilize the full training datasets without integrating active learning into ALADAEN. This evaluation allows us to benchmark ALADAEN’s core architecture against other established methods and assess its effectiveness in detecting anomalies within complex data environments. Following this, we will evaluate the impact of the active learning mechanism on ALADAEN’s performance. By iteratively querying an oracle, we aim to demonstrate the contribution of active learning in quickly improving detection rates and reducing reliance on large labeled datasets.

While the compared methods are diverse in their approaches to anomaly detection, our primary objective is not to just compare ALADAEN with these techniques. Rather, our main focus is to demonstrate how ALADAEN, by incorporating active learning, can significantly enhance anomaly detection performance using only a small labeled dataset. The key insight of our work is that by iteratively querying an oracle for the labels of the most uncertain samples in the dataset, we can improve the model’s understanding of both normal and anomalous data. This active learning loop allows us to maximize the utility of a small amount of labeled data, gradually refining the AutoEncoder model’s ability to detect anomalies with each iteration. Thus, the comparison with other methods serves primarily as a baseline, providing the context for the improvements that can be achieved by integrating active learning into the anomaly detection process. Our experiments aim to show that even with a limited initial labeled dataset—which is the case for APT—ALADAEN can iteratively improve its performance and achieve competitive or superior results in comparison to other state-of-the-art methods.

In the following subsections, we present the experimental setup, describe the datasets used, and discuss the results in detail. The databases, codes, and reproducibility guidelines are given in the project’s repository (https://github.com/aladaen/aladaen-apt).

Datasets

The datasets used in this study (https://gitlab.com/adaptdata) originate from DARPA’s [SPSVERBc2SPS] program (https://www.darpa.mil/program/transparent-computing) , which was designed to capture comprehensive system provenance across diverse operating systems and software layers. These datasets encompass system-level activities, background operations, and execution traces recorded during simulated APT-style attacks. By preserving detailed provenance information, the data enables fine-grained tracking of interactions and dependencies between system components. This holistic view facilitates the identification of behaviors that may appear benign in isolation but collectively reveal signs of abnormal or malicious activity.

More specifically, we utilize here a curated subset of DARPA’s provenance data that has been preprocessed by the [SPSVERBc1SPS] (Automatic Detection of Advanced Persistent Threats) project’s ingestion pipeline^26,25,80^. The datasets originate from four distinct operating systems: Android (referred to as Clearscope), Linux (Trace), BSD (Cadets), and Windows (Fivedirections or 5dir). For each OS, the data includes traces from two different attack scenarios: Scenario 1 (Pandex, also known as Engagement E1) and Scenario 2 (Bovia, or Engagement E2). The processing includes ingesting provenance graph data into a graph database as well as additional data integration and deduplication steps (Figure 2, step 1). The final data includes a number of Boolean-valued datasets , with each representing an aspect of the behavior of system processes (Figure 2, step 2). Each row in such a dataset is a data point representing a single process run on the respective OS. It is expressed as a Boolean vector whereby a value of 1 in a vector cell indicates the corresponding attribute applies to that process. For instance, in Figure 2 (step 2, left subfigure) the process with id

ee27fff2-a0fd-1f516db3d35f has the following sequence of events: \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\texttt {<}$$\end{document} /usr/sbin/avahi-autoipd, 216.73.87.152,

EVENT_OPEN, EVENT_CONNECT, ... \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\texttt {>}$$\end{document} . Specifically, the relevant datasets are interpreted as follows:

• ProcessEvent (PE): Its attributes are event types performed by the processes. A value of 1 in [SPSVERBc5SPS] means the process has performed at least one event of type i.
• ProcessExec (PX): The attributes are executable names that are used to start the processes.
• ProcessParent (PP): Its attributes are executable names that are used to start the parents of the processes.
• ProcessNetflow (PN): The attributes here represent IP addresses and port names that have been accessed by the processes.
• ProcessAll (PA): This dataset is described by the disjoint union of all attribute sets from the previous datasets.

Overall, with two attack scenarios (Pandex, Bovia), four OS (BSD, Windows, Linux, Android) and five aspects (PE, PX, PP, PN, PA), a total of forty individual datasets are composed, as illustrated in Fig. 2 (step 2, right subfigure). They are described in Table 1 whereby the last column provides the number of attacks in each dataset. The substantially imbalanced nature of the datasets is clearly seen here.Table 1. Experimental datasets of DARPA’s TC program used in our study.ScenarioSizePEPXPPPNPA \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$nb\_attacks$$\end{document} \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\%\frac{nb\_attacks}{nb\_processes}$$\end{document} BSD1288 MB76903 / 2976698 / 10776455 / 2431 / 13676903 / 296130.0221.27 GB224624 / 31224246 / 135223780 / 3742888 / 62224624 / 265110.004Windows1743 MB17569 / 2217552 / 21514007 / 7792 / 1396317569 / 1443180.0429.53 GB11151 / 3011077 / 38810922 / 84329 / 12511151 / 60680.07Linux12858 MB247160 / 24186726 / 154173211 / 403125 / 81247160 / 299250.01225.9 GB282087 / 25271088 / 140263730 / 456589 / 6225282104 / 6435460.01Android12688 MB102 / 21102 / 420 / 08 / 17102 / 8098.8210.9 GB12106 / 2712106 / 440 / 04550 / 21312106 / 295130.10A dataset entry (columns 4 to 8) is described by a number of rows (processes) / number of columns (attributes). For instance, with ProcessAll (PA) obtained from the second scenario using Linux, the dataset has 282104 rows and 6435 attributes with 46 APT attacks (0.01%)^26^.

Experimental setup and reproducibility

To ensure reproducibility, we summarize below the experimental setup used to train and evaluate ALADAEN.

Hyperparameters

Both AutoEncoders (AE1, AE2) and the discriminator were trained with the Adam optimizer ( \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\beta _1=0.5, \beta _2=0.999$$\end{document} ) using a learning rate of \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$10^{-4}$$\end{document} and batch size of 128. Each encoder projects the input to a latent dimension of \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$k=32$$\end{document} , followed by a dropout layer with rate \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$p=0.2$$\end{document} . Training was performed for up to 300 epochs with early stopping (patience = 10 epochs) based on validation reconstruction loss. The dual AutoEncoder reconstruction loss was weighted by \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\alpha =0.5$$\end{document} and the adversarial loss contribution by \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\lambda =0.5$$\end{document} . A fixed random seed was used for all runs to ensure reproducibility.

Dataset splits

For each DARPA dataset, benign processes were used to form the training pool for the AutoEncoders, while validation and test sets were constructed from disjoint subsets of both benign and anomalous processes. A fixed random seed was used for partitioning to ensure reproducibility.

Active learning protocol

ALADAEN starts from a cold-start setting with only 20% labeled normal samples iteratively queries a small batch of samples (by percentile) until the labeling budget is exhausted. Queried samples are incorporated into the labeled pool and the model is retrained incrementally.

Computational environment

The experiments were conducted on a machine running macOS 14.5 with an Apple M1 Max chip, 64 GB RAM. The anomaly detection models were tested on every one of the 40 datasets.

Results

Comparison with existing methods

Table 2 presents a performance comparison of the different anomaly detection algorithms across multiple operating systems (BSD, Windows, Linux, and Android) and attack scenarios (Pandex and Bovia). In addition to the table presenting the different nDCG scores for the anomaly detection methods, we also provide a heatmap in Fig. 3 to facilitate easy visual interpretation of the results. The rows in the heatmaps represent the anomaly detection methods, while the columns represent the datasets. The sub-figures on the left-hand side correspond to the first attack scenario, and the sub-figures on the right-hand side correspond to the second attack scenario. Empty cells in the heatmaps indicate cases where the algorithms did not finish processing.

Next, we provide a detailed performance comparison across different operating systems and attack scenarios, highlighting how each anomaly detection method performs in varying environments. This breakdown allows for a deeper understanding of the strengths and weaknesses of each approach in specific contexts.

• BSD (Cadets):
• In the Pandex scenario, ALADAEN demonstrates superior performance with the highest nDCG score of 0.88 in the PA dataset, outperforming traditional methods such as AVF (0.52) and OC3 (0.38), VF-ARM (0.67 in PP) and VR-ARM (0.64 in PE). MAE-AD and PGAE-APT show moderate results (0.67 and 0.31 respectively), while DeepOCCL and RT-APT trail behind (0.22 and 0.36 in PP). ALADAEN’s ability to effectively prioritize anomalies is further shown in the PX and PE configurations, where it scores 0.78 and 0.75 respectively, significantly better than the other approaches.
• For the Bovia scenario, ALADAEN continues to lead with an impressive nDCG score of 0.98 in the PP configuration, marking the highest score among all methods in this attack scenario. Notably, other methods like AVF, OC3, and FPOF either fail to complete (DNF) or produce much lower scores. This stark contrast highlights ALADAEN’s robustness in complex, real-world attack scenarios.
• Windows (5dir):
• In the Windows Pandex scenario, ALADAEN again stands out with an nDCG of 0.82 in the PE configuration, surpassing other methods like AVF and OC3. Additionally, VR-ARM also performs in this case with a high nDCG of 0.82 in the PE configuration, surpassing HDAPT-IDS (0.67 PE) and MAE-AD (0.77 PN). DeepOCCL and RT-APT achieve 0.57 and 0.67 (PN) respectively but remain below ALADAEN.
• For the Bovia scenario, ALADAEN maintains a competitive position with a score of 0.45 in the PA configuration, outperforming methods like VR-ARM (0.35) and OC3 (0.24). Notably, several traditional methods, such as OD and FPOF, fail to provide any valid results (DNF) across most configurations, indicating their struggle with this scenario.
• Linux (Trace):
• In the Linux Pandex scenario, ALADAEN achieves the highest nDCG score of 0.77 in the PA configuration, clearly outperforming HDAPT-IDS (0.55) and VR-ARM (0.58). ALADAEN also shows competitive performance in other configurations like PE (0.65), highlighting its versatility across different data distributions.
• For the Bovia scenario, ALADAEN reaches a high score of 0.87 (PA), while RT-APT achieves the best score 0.97 (PN), suggesting that RT-APT performs strongly for network-centric behaviors, whereas ALADAEN remains consistently superior in multi-view settings. It shows competitive performance in other configurations like PN (0.77), highlighting its versatility across different data distributions.
• Android (Clearscope):
• In the Android Pandex scenario, ALADAEN performs exceptionally well, achieving an nDCG score of 0.867 in the PE configuration, slightly ahead of VR-ARM (0.87), closely followed by MAE-AD (0.85 PX) and PGAE-APT (0.82 PN). ALADAEN’s strong performance in this scenario underlines its adaptability in mobile and embedded systems like Android.
• For the Bovia scenario, ALADAEN maintains good performance with a score of 0.67 in PE, showing that it remains competitive even in more challenging scenarios. VR-ARM method reaches 0.71 in PN, surpassing ALADAEN in this case.

Key insights

As shown in Fig. 3, ALADAEN consistently achieves the highest or near-highest nDCG scores across all operating systems and attack scenarios, demonstrating its ability to generalize across diverse environments and data distributions. In high-complexity attack cases such as BSD–Bovia and Linux–Pandex, ALADAEN not only surpasses classical baselines but also outperforms the most recent deep learning models (MAE-AD, RT-APT, DeepOCCL, PGAE-APT, and HDAPT-IDS). In several cases, ALADAEN outperforms its closest competitors by a significant margin. For example, in BSD Bovia (PP configuration), ALADAEN achieves a score of 0.98, while OC3, AVF, and FPOF fail to reach 0.50. ALADAEN’s attention-driven adversarial dual-AutoEncoder design provides stable ranking even in extremely imbalanced datasets, where APT samples constitute less than 0.01% of total processes. By contrast, methods like DeepOCCL and HDAPT-IDS exhibit high variance across configurations, struggling to maintain performance under cold-start or low-label regimes.

The integration of the adversarial loss stabilizes the latent representations, allowing ALADAEN to retain high nDCG scores even when the feature distributions differ across operating systems. This contrasts with MAE-AD, which shows stronger results on Android (mobile traces) but lower generalization to BSD and Linux server logs.

VR-ARM emerges as a strong competitor to ALADAEN, particularly in the Windows and Android environments, where it occasionally matches ALADAEN in specific configurations. For instance, VR-ARM achieves an nDCG of 0.82 in Windows \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} Pandex \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} PE, and 0.87 in Android \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} Pandex \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} PE forensic situations.

While AVF shows decent performance in some simpler scenarios (e.g., 0.84 in Android Pandex), it generally lags behind in more complex environments.

OC3 shows good performance in a few configurations, such as Android Pandex (PA), where it achieves a maximum score of 0.82. However, like AVF, OC3 struggles with complex scenarios, often producing DNF results, especially in higher-dimensional datasets.

OD (Outlier Degree) consistently ranks among the lowest-performing methods, with multiple DNF results across all operating systems and attack scenarios. This indicates that OD is not well-suited for detecting advanced threats in complex, high-dimensional environments.

Similarly, FPOF (Frequent Pattern Outlier Factor) struggles across most scenarios, failing to provide valid results in several configurations and consistently underperforming compared to ALADAEN and other methods.

Sometimes FPOF, OC3, and OD failed to produce results within a reasonable runtime, not terminating even after more than four hours on high-dimensional datasets. Such prolonged runtimes are undesirable in practical cybersecurity settings, where rapid anomaly detection and response are paramount to minimizing attack impact. In contrast, ALADAEN completed inference and ranking for all datasets within minutes, demonstrating not only higher detection accuracy but also superior suitability for time-sensitive operational environments.

The extended experiments reveal also distinct behavioral trends among the deep learning-based baselines. MAE-AD achieves competitive results in Android and BSD environments (e.g., 0.83 in Android–Pandex and 0.50 in BSD–Pandex), confirming the effectiveness of its masked reconstruction strategy in learning local feature dependencies. However, its reliance on context masking limits its ability to capture fine-grained, cross-view irregularities, leading to lower scores in Linux and Windows traces where temporal and causal diversity is higher. DeepOCCL demonstrates stable yet moderate performance across all datasets, reflecting its robust latent one-class modeling but also its sensitivity to high-dimensional feature noise in provenance graphs. HDAPT-IDS performs relatively well on Windows (0.67 in PE) and Android (0.75 in PE), leveraging hierarchical clustering to capture coarse attack patterns. Nonetheless, its multi-stage structure incurs computational overhead and fails to adapt rapidly under streaming data, causing inconsistent results in more dynamic domains such as Linux–Bovia. PGAE-APT, designed for graph-structured APT traces, produces strong outcomes in a few network-related views (e.g., PN on Android–Pandex = 0.82) but suffers performance degradation when applied to heterogeneous process-action data, highlighting its limited robustness outside graph formalisms. Finally, RT-APT stands out in network-intensive configurations, such as Linux–Bovia (0.97 in PN), validating the strength of its transformer-based temporal adaptivity. However, it underperforms in persistence-heavy, multi-phase contexts where reconstruction stability and balanced learning become crucial.

Overall, these results confirm that while each recent method excels within its architectural niche, none achieves ALADAEN’s uniform superiority across all operating systems and views. ALADAEN’s integration of attention-driven dual adversarial autoencoding, (and later GAN-based augmentation, and active learning) yields a uniquely stable ranking capability, allowing it to outperform both reconstruction-oriented (MAE-AD, PGAE-APT) and threshold-adaptive (RT-APT) baselines across diverse provenance modalities.

Table 3 summarizes these findings, emphasizing the highest nDCG scores and the corresponding winner methods. For each OS/attack scenario, the maximum nDCG value is highlighted in red. Observe that ALADAEN performed best among the competitors in 6 out of 8 forensic configurations and demonstrated superior performance, achieving the highest scores in multiple datasets and scenarios.

Table 2. Performance evaluation of anomaly detection methods using nDCG scores.Operating systemAttack scenarioAlgorithmPAPEPXPPPNCadets (BSD)PandexALADAEN 0.88 0.750.780.650.35AVF0.520.510.340.210.58OC30.380.430.490.430.24OD0.190.190.150.130.14FPOF0.210.20.150.130.13VR-ARM0.360.640.080.290.58VF-ARM0.180.330.530.670.11MAE-AD0.50.530.370.190.67DeepOCCL0.220.180.160.150.18HDAPT-IDS0.120.20.330.340.36PGAE-APT0.170.30.260.270.31RT-APT0.160.30.250.360.3BoviaALADAEN0.790.670.77 0.98 0.15AVFDNF0.190.170.170.18OC3DNF0.240.510.290.50OD0.150.170.170.090.20FPOF0.210.130.180.1DNFVR-ARM0.520.120.050.240.6VF-ARM0.140.120.060.060.18MAE-AD0.410.280.450.210.23DeepOCCL0.320.270.210.20.2HDAPT-IDS0.140.460.150.180.01PGAE-APT0.220.260.210.220.38RT-APT0.210.210.220.220.375dir (Windows)PandexALADAEN0.72 0.82 0.240.170.65AVF0.520.60.280.210.58OC30.490.30.280.210.65ODDNF0.20.150.10.36FPOFDNF0.20.150.10.36VR-ARM0.61 0.82 000.62VF-ARM0.50.33000MAE-AD0.620.480.190.160.77DeepOCCL0.260.180.150.130.57HDAPT-IDS0.10.670.110.270.51PGAE-APT0.160.160.160.140.38RT-APT0.160.160.160.150.67BoviaALADAEN 0.45 0.310.430.430.4AVFDNF0.210.220.220.18OC3DNF0.230.240.220.24ODDNFDNFDNFDNFDNFFPOFDNFDNFDNFDNFDNFVR-ARM0.350.19000.3VF-ARM0.070.13000MAE-AD0.320.260.260.240.34DeepOCCL0.240.240.230.250.28HDAPT-IDS0.170.20.320.340.36PGAE-APT0.260.310.260.320.31RT-APT0.250.260.310.270.31Trace (Linux)PandexALADAEN 0.77 0.650.360.230.45AVF0.290.270.430.20.31OC30.410.380.30.240.38OD0.180.180.180.170.23FPOF0.180.180.180.170.23VR-ARM0.540.130.1200.58VF-ARM0.130.220.10.120.42MAE-AD0.320.240.280.170.3DeepOCCL0.20.220.180.190.33HDAPT-IDS0.360.350.160.130.55PGAE-APTDNFDNFDNFDNF0.28RT-APT0.190.180.20.180.35BoviaALADAEN0.870.560.380.470.77AVFDNF0.290.420.250.42OC3DNF0.380.420.420.35ODDNF0.210.20.20.23FPOFDNF0.220.20.20.31VR-ARM0.450.14000.39VF-ARM0.090.10.0040.030.11MAE-AD0.480.410.370.190.31DeepOCCL0.280.30.240.180.31HDAPT-IDS0.480.170.280.20.45PGAE-APT0.260.250.250.270.61RT-APT0.230.230.260.27 0.97 Clearscope (Android)PandexALADAEN0.80 0.87 0.45NA0.68AVF0.830.840.39NA0.47OC30.820.740.39NA0.64OD0.340.330.22NA0.36FPOF0.310.290.22NA0.42VR-ARM0 0.87 0NA0.46VF-ARM00.770NA0MAE-AD0.760.830.85NA0.71DeepOCCL0.750.520.34NA0.68HDAPT-IDS0.740.750.53NA0.69PGAE-APT0.530.450.58NA0.82RT-APT0.390.70.72NA0.74BoviaALADAEN0.520.670.51NA0.41AVF0.350.30.38NA0.32OC30.400.320.39NA0.30OD0.200.220.29NA0.34FPOF0.370.360.29NA0.36VR-ARM0.510.50NA 0.71 VF-ARM0.430.120NA0.1MAE-AD0.340.360.3NA0.5DeepOCCL0.380.420.27NA0.51HDAPT-IDS0.240.380.33NA0.63PGAE-APT0.50.330.38NA0.52RT-APT0.330.330.32NA0.52Bold values represent the max nDCG for each forensic configuration (OS \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} attack scenario \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} dataset). NA: data not available. DNF: Did not finish.

Table 3. Highest nDCG scores achieved and the corresponding algorithms on all available datasets.OSScenarioPAPEPXPPPNCadets (BSD)PandexHighest nDCG 0.88 0.750.780.670.58Winning method ALADAEN ALADAENALADAENVR-ARMVR-ARMBoviaHighest nDCG0.790.670.77 0.98 0.60Winning methodALADAENALADAENALADAEN ALADAEN VR-ARM5dir (Windows)PandexHighest nDCG0.72 0.82 0.280.270.77Winning methodALADAEN VR-ARM, ALADAEN AVF,OC3HDAPT-IDSMAE-ADBoviaHighest nDCG 0.45 0.310.430.430.40Winning method ALADAEN ALADAENALADAENALADAENALADAENTrace (Linux)PandexHighest nDCG 0.77 0.650.430.240.58Winning method ALADAEN ALADAENAVFOC3VR-ARMBoviaHighest nDCG0.870.560.420.47 0.97 Winning methodALADAENALADAENAVF, OC3ALADAEN RT-APT Clearscope (Android)PandexHighest nDCG0.83 0.87 0.72NA0.68Winning methodAVF VR-ARM, ALADAEN RT-APTNAALADAENBoviaHighest nDCG0.520.670.51NA 0.71 Winning methodALADAENALADAENALADAENNA VR-ARM Bolditalics values represent the winner methods with their best nDCG score, for each forensic configuration: OS \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} attack scenario \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} dataset.

Fig. 3nDCG score comparison of anomaly detection algorithms across operating systems and attack scenarios. The rows represent the anomaly detection methods, while the columns represent the datasets. The subfigures on the left-hand side correspond to the first attack scenario, and the subfigures on the right-hand side correspond to the second attack scenario.

Active learning assessment

Next, we present the evaluation of ALADAEN when including the active learning loop. Given that we are working with forty databases, it is almost impractical to discuss and comment the nDCG scores variation for each single dataset. Hence, we will first present the results for the cases where ALADAEN achieved the best performances when compared with the previous anomaly detection approaches, as highlighted in Table 3. For the remaining datasets, a summary discussion will follow, providing insights into their behavior. This would allow us to focus on the most significant results, while still offering a comprehensive understanding of the model’s performance across all datasets.

For the active learning process implemented in ALADAEN, the parameter \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$N_{\text {iterations}}$$\end{document} has been set to 40. This number was selected to balance the need for model improvement with the practical constraints of real-world cybersecurity applications. In the context of cyber threats, security experts must act swiftly to mitigate risks and prevent potential attacks. Prolonged iteration cycles could delay critical decision-making, leaving systems vulnerable during the learning phase. By limiting the iterations to 40, we ensure that the model reaches an optimal performance level without causing delays that could compromise security response times. This approach aligns with the urgency required in cybersecurity, where timely interventions are paramount. While other values for the number of iterations are possible, they should not be too prolonged, as extended cycles could hinder the swift decision-making required in cybersecurity scenarios.

Uncertainty sample selection:

We first examine the reconstruction error distribution and the selection strategy for uncertain samples near the decision threshold \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\tau$$\end{document} . This analysis illustrates how ALADAEN identifies the most informative data points for oracle querying in each iteration, ensuring that the labeling budget is spent on samples that most improve the decision boundary. Figure 4 represents the reconstruction error histogram of the neural network with the threshold \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\tau$$\end{document} in red line, where the x-axis represents the reconstruction error values, and the y-axis indicates the frequency (count) of data points with a certain error. In this example data belongs to Linux \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} PA \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} Pandex forensic configuration (randomly chosen here for illustration purposes). We can observe that most data points have low reconstruction errors, concentrated near zero. This suggests that ADAEN AutoEncoder is performing well on most of the input data, reconstructing it with high accuracy.

The red dashed line represents the threshold marker \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\tau$$\end{document} that is chosen to distinguish between normal and anomalous data points (since \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\text {Anomaly}(x)=1 ~\text {if}~error(x)>\tau$$\end{document} ). Points with reconstruction error above the threshold would be classified as anomalies, while those below it are considered normal. Here, the uncertainty threshold \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\tau$$\end{document} for anomaly detection is determined using a percentile-based approach. Specifically, the threshold \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\tau$$\end{document} is set at the 80th percentile of the reconstruction error values calculated on the test dataset. This means that 80% of the data points are expected to have reconstruction errors below this threshold, and only the remaining 20% will be considered potentially anomalous. This method ensures that the threshold adapts to the distribution of reconstruction errors, enabling more flexible and data-driven anomaly detection. It is important to note that the choice of the 80th percentile as the uncertainty threshold is flexible and can be adjusted to fine-tune the algorithm’s performance. By selecting different percentile values, the threshold can be adapted to balance the trade-off between detecting anomalies and reducing false positives, allowing the algorithm to be tailored to the specific characteristics and requirements of the dataset or application scenario. Note that it is also possible for the model to update iteratively the threshold in an automatic manner. More specifically, the threshold could be recalibrated at each iteration of active learning, to a different percentile of the reconstruction error for normal instances. This allows the model to incorporate feedback and refine its detection sensitivity, improving its ability to distinguish between normal and anomalous data points over time.

This histogram is a useful way to visualize the performance of the AutoEncoder, as it shows how well the model distinguishes between normal and anomalous data based on reconstruction errors. Data points with high reconstruction error might represent the anomalous points that the model struggles to reconstruct, signaling potential attacks or anomalies. The AutoEncoder in this Linux \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} PA \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} Pandex forensic configuration has learned to accurately reconstruct the majority of normal data (errors close to zero), and the threshold helps detect anomalies by flagging instances with higher reconstruction errors. Similar behaviors have also been observed with the other datasets.

Fig. 4. Reconstruction Error Histogram with Threshold, where the x-axis represents the reconstruction error values, and the y-axis indicates the frequency (count) of data points with a certain error.

Fig. 5nDCG score variation over Active Learning iterations for Linux PA dataset using the ALADAEN framework (Pandex E1 scenario). Values in x-axis represent active learning iterations, whereas y-axis contains nDCG scores. The raw nDCG data is represented by the blue dashed line, while the smoothed nDCG values are depicted by the red dashed line. On the right, a boxplot of the nDCG values shows the distribution of scores throughout the Active Learning process. The figure highlights the model’s performance improvements over iterations, stabilizing at higher nDCG scores as more data is incorporated.

Ranking improvement across iterations:

We next evaluate how active learning improves anomaly ranking over time. Figure 5 presents the evolution of the nDCG scores over several Active Learning iterations for the Linux \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} PA \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} Pandex forensic configuration. It consists of two subfigures: The raw nDCG data is represented by the blue dashed line showing the progression of the nDCG scores over 40 iterations, while the smoothed nDCG values are depicted by the red curve. Initially, the nDCG score starts around 0.34 (min value at cold start) but gradually improves as iterations progress, stabilizing between 0.70 and 0.94 in later iterations. The median is about 0.84 and the mean over all values is 0.82. There are noticeable fluctuations in performance, indicating varying success rates at different stages. However, the overall trend is upward, demonstrating that the model is learning and improving its ranking accuracy with each iteration.

The figure provides several important insights into the evolution of nDCG scores during active learning iterations for this Linux \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} PA \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} Pandex configuration. The nDCG raw values exhibit fluctuations, especially in the early iterations, where the scores rise quickly, indicating that the model is learning and improving. However, there are some sharp drops followed by recoveries, signaling instability or challenging data points for the model. The smoothed values are obtained using a Gaussian filter. The smoothing reduces the noise from the raw values, giving a clearer trend. The red curve shows a general upward trajectory, indicating that the model is improving its ranking performance over time. The smoothing helps highlight that, despite some volatility, the model consistently improves after a certain number of iterations ( \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\approx$$\end{document} 15). After the initial low score, which is about 0.34, the detection rate quickly increases, showing the effectiveness of active learning and GANs in improving the model’s performance as it selects informative samples. During mid iterations, some fluctuations in the raw data suggest that the model might face difficult instances or noise, but the overall trend is still positive, with nDCG scores stabilizing around 0.8 after around 25 iterations. In later iterations, the smoothed curve flattens, indicating that the model has likely reached a plateau where additional iterations lead to marginal improvements. Observing such a plateau is an indication that it might not be useful to acquire new data to train the model since the generalization performance of the model will not increase anymore. A major outcome of this experiment also highlights the effectiveness of combining active learning with GAN-based data augmentation in improving anomaly detection performance. In fact, the model achieved a maximum nDCG score of around 0.94, surpassing the results obtained without active learning which is equal to 0.77. This improvement can be attributed to two key factors: (1) Active learning enables the model to focus on the most uncertain samples, which are critical in refining the decision boundary between normal and anomalous data. By iteratively selecting and labeling these ambiguous points, the model becomes more confident in its classifications. (2) The GAN-generated synthetic data enriches the training set by introducing realistic, diverse samples that reflect the normal data distribution. This enhanced dataset allows the model to generalize better, reducing overfitting and improving its ability to distinguish between normal and anomalous data. Together, these techniques contribute to the model’s improved performance, demonstrating their ability to boost detection accuracy in scenarios with limited labeled data.

The right Boxplot in the same figure summarizes the distribution of nDCG scores throughout the entire active learning process. The box (light blue) represents the Inter Quartile Range (IQR), which contains the middle of the nDCG scores. The median is around 0.84, showing that half the nDCG scores are above this value. The whiskers extend to show the range of most of the data. The lower whisker reaches down to about 0.34, representing the lowest scores from early iterations. The majority of nDCG scores are above 0.75, indicating that the model performs well overall, with only a few low outliers. The presence of outliers suggests that the model faced difficulty in some specific iterations but these instances are not representative of the overall trend. This boxplot gives a concise overview of the model’s performance, showing that the majority of the iterations achieved higher scores, but there were some underperforming iterations as well.

Similarly, in Fig. 6, we observe the variation of nDCG scores during the active learning process for the Linux PA - Bovia (E2) scenario. The raw nDCG scores show fluctuations during the initial iterations, followed by a steady improvement as the active learning process progresses. The smoothed nDCG curve provides a clearer trend, illustrating a general upward trajectory, indicating that the model is learning and improving over time.

The boxplot also shows here a median score around 0.73, and the IQR is relatively narrow, suggesting consistency in the nDCG performance. A few lower outliers are observed, but the model generally performs well, with a peak nDCG score of approximately 0.84. Overall, this suggests that active learning is helping the model refine its ability to distinguish between normal and anomalous instances in this attack scenario.

Fig. 6nDCG score variation over Active Learning iterations for the Linux PA dataset (Bovia E2 scenario).

Figure 7 shows the results across iterations for the BSD PA dataset with the Pandex (E1) attack scenario. The raw nDCG scores also show here fluctuating behavior but generally improve over the iterations, reaching peaks above 0.9. The smoothed curve captures the trend more clearly, showing an upward trajectory and stabilizing close to 0.9 in the latter iterations, indicating improved performance over time. The boxplot reveals a strong overall performance with a median around 0.89. The IRQ range is relatively tight, indicating stable performance. There are some lower outliers below 0.6, but most values are concentrated in the higher range, suggesting that the model has consistently good performance.

Fig. 7nDCG score variation over Active Learning iterations for the BSD (Cadets) PA dataset (Pandex E1 scenario).

The next Fig. 8 presents the scores variation for the BSD PP dataset with Bovia (E2) attack scenario. The raw nDCG scores show a rapid rise to almost 1.0 by the 5th iteration, and remain consistently high throughout the subsequent iterations. The smoothed data closely follows the raw data, indicating that the performance stabilizes around 1.0 after the initial iterations. The boxplot shows a highly concentrated nDCG score distribution near 1.0, with just one outlier below 0.70, indicating extremely high and consistent performance after the early stages of training. This figure indicates clearly that the model achieved near-optimal performance very early in the active learning process. After around 5 iterations, the nDCG score hovers around 1.0, demonstrating that the model effectively discriminates between normal and anomalous instances. The outlier in the boxplot likely corresponds to the initial phase of learning before the model stabilizes, but overall, the figure shows a robust and well-learned behavior under this attack scenario.

Fig. 8nDCG score variation over Active Learning iterations for the BSD (Cadets) PP dataset (Bovia E2 scenario).

The next Fig. 9 shows the convergences for Windows PE Dataset in Pandex Attack Scenario. Here, the nDCG values start relatively high and quickly rise, indicating an initial improvement in the model’s ranking performance within the first 10 iterations. After iteration 10, the performance fluctuates between 0.85 and 0.98, showing some variability in the ranking performance, which could be due to the attack scenario. The peak nDCG score approaches 1.0, which indicates the model is able to achieve optimal ranking performance during some iterations. The boxplot shows a median close to 0.98, suggesting that most iterations perform well. There are some outliers (below 0.80 and near 0.70), indicating occasional poor performance in certain iterations. While the general performance is strong, the fluctuations in the raw nDCG data show that there are points where the model could be further optimized.

Fig. 9nDCG score variation over Active Learning iterations for the Windows PE dataset (Pandex E1 scenario).

The graph in Fig. 10 concerns Windows PA dataset (Bovia E2 scenario) and shows fluctuations in the nDCG score over 40 iterations, both in the raw and smoothed data. The raw data shows notable ups and downs, particularly in the early iterations (up to around iteration 10). Over time, the nDCG score improves and stabilizes at higher values, with some smaller variations around the 20th and 30th iterations. After the initial phase of fluctuation, the smoothed nDCG score begins to rise steadily from around iteration 10, reaching values close to 1, indicating high accuracy. The smoothed curve illustrates the large variations in the raw data, reflecting the underlying trend of performance improvement. Toward the final iterations, the score reaches 1, indicating good ranking quality. The boxplot also indicates a median nDCG score slightly below 0.9, with the IRQ range extending from about 0.75 to 0.95. The whiskers indicate that some values go as low as 0.4 and as high as 1. There are no extreme outliers, but the lower bound suggests that at certain points, performance can drop substantially. However, the concentration of the IQR near the higher end shows that overall ranking quality is generally quite good. Hence, the performance of the model in this configuration is relatively good, as indicated by the final stabilized nDCG scores nearing 1. However, early iterations and occasional fluctuations suggest that the model took time to stabilize, and there were occasional challenges in ranking quality during the process. This scenario demonstrates that while the model performs well overall, there are points where its ranking quality can degrade temporarily, likely due to variations in data handling during the attack scenario.

Fig. 10nDCG score variation over Active Learning iterations for the Windows PA dataset (Bovia E2 scenario).

Figure 11 contains scores for the Android PE dataset within Pandex (E1) attack scenario. Here, the nDCG score fluctuates between approximately 0.4 and 1.0 showing high variability with frequent jumps and drops in score across iterations. The smoothed values show a clearer upward progression over time. It generally increases and stabilizes around 0.9 after the initial fluctuations. Similarly, the boxplot shows that the median nDCG score appears to be close to 1.0, and the IQR suggests that most nDCG scores are high. There are also some outliers between 0.7 and 0.4. Albeit there is some initial volatility in performance over iterations, but this stabilizes as the iterations progress. The presence of outliers in the boxplot indicates occasional poor performance during cold start, but after that these are relatively infrequent compared to the high overall scores.

Fig. 11nDCG score variation over Active Learning iterations for the Android (Clearscope) PE dataset (Pandex E1 scenario).

Next, in Fig. 12 the results are related to the Android-PE dataset within the Bovia (E2) scenario. There is noticeable variability, especially in the earlier iterations, where the score shows significant dips and peaks, indicating unstable performance during the beginning of the process. Smoother values show an increasing trend after 15th iteration, with scores gradually rising from around 0.7 to 0.8 before stabilizing and remaining relatively steady in the later iterations. The boxplot also illustrates a median score that appears to be close to 0.78, indicating acceptable performance, with numerous low-performing outliers, suggesting some challenges with achieving consistently high nDCG scores.

Fig. 12nDCG score variation over Active Learning iterations for the Android (Clearscope) PE dataset (Bovia E2 scenario).

Figures 13, 14, 15, 16, 17, 18, 19, and 20 represent the nDCG variations for all remaining datasets under both attack scenarios. Each subplot shows both the raw and smoothed nDCG scores across 40 iterations, alongside a boxplot summarizing the distribution of nDCG values for each dataset. These figures cover the BSD, Linux, Windows and Android operating system and the five datasets: PA, PE, PP, PX, and PN. The smoothed curves provide a clearer view of the trends and fluctuations in ranking quality, while the boxplots offer insights into the overall distribution and outliers in the nDCG scores. The overall trend for the larger datasets in these figures is upward, showing consistent improvement in nDCG scores as iterations progress. While some datasets exhibit fluctuations due to data sparsity (e.g. Linux-PX/PP in Pandex scenario), the nDCG scores after applying active learning are generally higher than the initial values obtained in Table 3, indicating that active learning has positively impacted the ranking performance.

Table 4 summarizes the assessment of the performance of ALADAEN algorithm in both settings: (1) without active learning (baseline)—previously reported in Table 2— and (2) with active learning, across different operating systems (BSD, Windows, Linux, and Android) and datasets (PA, PE, PX, PP, and PN) under two attack scenarios (Pandex and Bovia). We report the maximum, mean, and median nDCG scores to provide a holistic assessment of the model’s performance during active learning. The maximum nDCG score reflects the model’s peak performance during active learning, indicating its best ability to rank anomalies. The mean provides an overall average, showcasing the model’s consistency across iterations. The median, less affected by outliers, offers a more reliable measure of typical performance, especially in cases of fluctuating results. It’s worth noting that during the active learning process, when the nDCG score reaches 1, indicating perfect ranking performance, the learning process could have been ideally stopped, as the model has already achieved the best possible outcome and further iterations are unlikely to yield significant improvements.

The main observations are as follows:

• BSD Operating System: Across almost all datasets in both attack scenarios (Pandex and Bovia), active learning consistently improved the nDCG scores compared to the baseline. The maximum nDCG score with active learning often reached 1.0, especially in the Bovia attack scenario. There were some fluctuations in the median and mean nDCG scores for smaller datasets (e.g., PN), likely due to data sparsity. However, active learning still resulted in higher nDCG scores overall, particularly in scenarios like PA and PE where improvements were most pronounced.
• Windows Operating System: Active learning showed significant improvements across most datasets and attack scenarios. In the Pandex scenario, the maximum nDCG score consistently reached high values, with the mean and median values substantially higher than the baseline. The Bovia scenario also saw notable improvements, particularly in datasets like PA, PX and PP, where active learning helped push the nDCG scores to their highest possible values. Smaller datasets showed lower mean and median values, but the trend is upward with active learning.
• Linux Operating System: The application of active learning improved the performance in the majority of the datasets, with notable increases in the PA, PE, PX, and PN datasets. In particular, the maximum nDCG scores were consistently higher in the active learning setting compared to the baseline. Active learning reduced the variation between mean and median values, stabilizing the performance across multiple iterations.
• Android Operating System: Active learning resulted in higher maximum and median nDCG scores, especially in datasets like PA and PE. Notable improvements were observed in both Pandex and Bovia scenarios, with active learning increasing the maximum nDCG scores to 1.0 in several cases.

Fig. 13nDCG score variation over Active Learning iterations for BSD datasets (Pandex E1 scenario).

Fig. 14nDCG score variation over Active Learning iterations for BSD datasets (Bovia E2 scenario).

Fig. 15nDCG score variation over Active Learning iterations for Linux datasets (Pandex E1 scenario).

Fig. 16nDCG score variation over Active Learning iterations for Linux datasets (Bovia E2 scenario).

Fig. 17nDCG score variation over Active Learning iterations for Windows datasets (Pandex E1 scenario).

Fig. 18nDCG score variation over Active Learning iterations for Windows datasets (Bovia E2 scenario).

Fig. 19nDCG score variation over Active Learning iterations for Android datasets (Pandex E1 scenario).

Fig. 20nDCG score variation over Active Learning iterations for Android datasets (Bovia E2 scenario).

Table 4. Comparison of ALADAEN performance with and without Active Learning (Baseline).OperatingsystemAttackscenarioPAPEPXPPPNBaselineActive learningBaselineActive learningBaselineActive learningBaselineActive learningBaselineActive learningMaxMeanMedianMaxMeanMedianMaxMeanMedianMaxMeanMedianMaxMeanMedianBSDPandex0.880.910.870.890.7510.870.930.7810.780.870.650.360.210.150.350.360.210.27Bovia0.7910.9810.6710.9310.7710.900.970.9810.9910.150.150.140.15WindowsPandex0.7210.860.890.8210.960.970.240.790.560.580.170.750.530.510.650.910.720.73Bovia0.4510.820.860.310.620.510.560.430.940.720.770.430.970.780.750.40.360.160.19LinuxPandex0.770.940.820.840.650.780.620.610.360.690.390.360.230.470.240.190.450.870.820.87Bovia0.870.840.720.730.560.620.560.560.380.840.700.720.470.540.490.480.770.770.720.77AndroidPandex0.800.990.840.890.870.990.870.960.4510.880.97NANANANA0.680.690.690.69Bovia0.5210.850.930.6710.740.780.5110.850.96NANANANA0.410.390.380.39For each dataset, the first column represents the scores where the algorithm is trained on the entire dataset from the start without any iterative data augmentation. The remaining columns (Max, Mean, Median) represent the scores when running Active Learning. The maximum captures the peak performance, the mean reflects the overall average behavior across all iterations, and the median offers a robust measure of typical performance by minimizing the impact of outliers.

Analysis of active learning gains

Table 4 compares ALADAEN trained once without active learning (Baseline) against its performance during iterative oracle querying (Active Learning). The Baseline represents an ablation of the active learning component — no querying, no GAN augmentation , only a single training pass on the training database. The three remaining columns (Max, Mean, Median) summarize performance during active learning, capturing respectively the peak, average, and robust typical values across query iterations.

Figure 21 visualizes the maximum relative improvement in nDCG achieved during active learning across all OS \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} scenario \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} view combinations. The relative gain is computed as \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\Delta = (\textrm{Max}_{AL} - \textrm{Baseline}) / \textrm{Baseline} \times 100$$\end{document} . Because the maximum iteration is reported, all values are positive or zero, and the figure highlights the true potential of ALADAEN when its querying process reaches its best iteration. The strongest relative gains are observed for PX and PP views, where baseline performance is weakest. In several cases, the improvement exceeds \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$+100\%$$\end{document} , particularly for Windows and BSD scenarios, showing that active learning can more than double detection quality in the most challenging views.

In the previously reported nDCG curves, the figures (5-20) also show the convergence behavior of nDCG as a function of the number of queried samples, revealing that most gains occur in the first few iterations, confirming the label efficiency of the approach. The boxplots further summarize the distribution of relative improvements across all datasets, showing that gains are consistent across configurations and not driven by a small set of outliers.

Together, these results confirm that active learning not only consistently improves anomaly ranking performance but can achieve substantial peak improvements when allowed to query a small number of the most informative samples.

Fig. 21. Relative improvement in nDCG (%) for ALADAEN with active learning compared to the baseline (active learning ablated). Values are computed as \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\Delta = (\textrm{Max}_{AL} - \textrm{Baseline}) / \textrm{Baseline} \times 100$$\end{document} for each OS \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} scenario \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\times$$\end{document} view combination. Deeper red indicates a larger relative gain. Improvements are consistently positive, with the most pronounced gains observed for PX and PP views (often exceeding \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$+100\%$$\end{document} ), showing that active learning can more than double performance in the most challenging configurations.

Runtime and efficiency

In addition to accuracy, we evaluated the computational efficiency of ALADAEN. Across all DARPA datasets and views, inference and ranking (including reconstruction, score computation, sorting, and active learning selection) completed in \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$12.1 \pm 1.9$$\end{document} minutes on average on a single Apple M1 Max CPU core with 64 GB of RAM. This represents a substantial practical advantage: baselines such as FPOF, OC3, and OD frequently failed to terminate within \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$> 4$$\end{document} hours on high-dimensional views, underscoring their unsuitability for time-sensitive applications.

Table 5 compares the average inference time across all methods. Among recent SOTA baselines, RT-APT and MAE-AD demonstrate efficient execution with average runtimes of 10.15 and 11.4 minutes respectively, confirming their suitability for real-time or near-real-time analysis. ALADAEN maintains comparable efficiency at \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$12.1 \pm 1.9$$\end{document} minutes despite its dual-adversarial and active learning components, highlighting its optimized implementation and balanced computational cost. In contrast, traditional baselines such as VR-ARM and AVF exhibit moderate runtimes (15–22 minutes), while classical rule-mining approaches like FPOF and OC3 experience significant slowdowns, occasionally failing to complete within practical limits. Deep learning architectures with higher graph complexity, such as PGAE-APT and DeepOCCL, display longer runtimes ( \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$>30$$\end{document} minutes), underscoring their limited scalability for large-scale provenance data. Overall, ALADAEN achieves an ideal trade-off between accuracy and efficiency, confirming its operational readiness for deployment in Security Operations Center (SOC) environments where rapid anomaly prioritization is critical.

The runtime of ALADAEN scales linearly with the number of samples and can be further reduced by mini-batching or GPU acceleration. Because ALADAEN is trained and reused for streaming inference, its per-process latency (below 10 ms per process) satisfies near-real-time requirements typical in Security Operations Center (SOC) workflows, where timely anomaly prioritization is critical for effective incident response.

Table 5. Average inference + ranking runtime (minutes) across all datasets and views.MethodAverage runtime(min)Std. dev.(min)RT-APT10.153.1MAE-AD11.42.9 ALADAEN (ours)

\documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$\mathbf {12.1}$$\end{document} 1.9HD-APT12.542.1VR-ARM15.61.0AVF22.41.2FPOF26.02.5 (partial DNF)OC327.03.1 (partial DNF)PAGE-APT30.52.6OD31.34.0 (partial DNF)DeepOCCL35.73.2 (partial DNF)Significant values are in [bold].Values are computed over successful runs; FPOF, OC3, and OD exhibited DNFs on a subset of high-dimensional configurations ( \documentclass[12pt]{minimal} \usepackage{amsmath} \usepackage{wasysym} \usepackage{amsfonts} \usepackage{amssymb} \usepackage{amsbsy} \usepackage{mathrsfs} \usepackage{upgreek} \setlength{\oddsidemargin}{-69pt} \begin{document}$$>4$$\end{document} h).

Discussions

The integration of synthetic data generated by GAN plays a crucial role in enhancing the training process, especially when labeled data is limited. By mimicking the distribution of normal data, the GAN expands the training set, helping the model better capture normal behavior patterns. This additional data refines and stabilizes the decision boundary between normal and anomalous instances, leading to a clearer separation.

A major challenge with small data sets is overfitting, where the model struggles to generalize to unseen data. The variability introduced by the synthetic data acts as a regularizer, reducing overfitting and improving the model’s robustness. By learning from both real and synthetic data, the model becomes more adept at generalizing to new data points.

Anomaly detection tasks often face a class imbalance, with normal instances far outnumbering anomalies. The GAN-generated data balances this disparity, allowing the AutoEncoder to learn the normal distribution more thoroughly. This improves the model’s ability to detect subtle outliers and enhances its overall anomaly detection performance.

In the active learning process, synthetic data helps refine the decision boundary. The most uncertain data points, often near the decision boundary, are selected for labeling. By generating synthetic data around these points, the boundary is iteratively adjusted, improving the model’s ability to classify ambiguous instances with greater confidence. This iterative process, reinforced by both real and synthetic data, leads to a more accurate generalization.

The diversity provided by the GAN-generated data broadens the model’s understanding of normal behavior, reducing the likelihood of false positives. As a result, the decision boundary is more precisely defined, minimizing the misclassification of normal data and creating a sharper distinction between normal and anomalous data.

Conclusion

In this paper, we presented ALADAEN, an innovative framework which combines Deep Neural Networks with Active Learning to address the complex problem of anomaly detection in environments with limited labeled data. The inclusion of a GAN-based data augmentation mechanism further strengthens the approach by effectively dealing with data scarcity, enabling the model to generate synthetic data that enriches the training process and enhances overall performance. This novel integration of GANs is particularly valuable in addressing class imbalance and improving generalization, making ALADAEN more adaptable than traditional anomaly detection methods.

The emphasis on active learning is well-aligned with the practical challenges of real-world applications, where acquiring labeled data is both costly and time-consuming. By selectively querying uncertain data points, the framework optimizes resource usage and gradually improves the model’s performance with minimal human intervention. This incremental approach to labeling, combined with data augmentation, ensures that even with a small amount of labeled data, the model can still refine its ability to detect anomalies effectively.

Additionally, the use of real-world provenance data from various operating systems (OS) strengthens the practical applicability of the framework. In scenarios like Advanced Persistent Threat (APT) detection, where anomalies are rare but critical, this approach is highly relevant. The framework’s ability to detect such anomalies across different OS environments further highlights its robustness and versatility in real-world security contexts.

Finally, the comprehensive performance evaluation, which compares ALADAEN with other state-of-the-art anomaly detection methods, validates its effectiveness. The analysis clearly demonstrates the framework’s capacity to outperform traditional approaches, showcasing its ability to handle complex datasets and detect anomalies with higher accuracy. Additionally, since the baseline model was evaluated independently and compared against several state-of-the-art approaches without incorporating the active learning loop, it can also be interpreted as a form of ablation study highlighting the added value of active refinement.

Future work

For future work, several promising directions can be explored to further enhance the capabilities and effectiveness of the ALADAEN framework. For instance, we could focus on applying ALADAEN to more sophisticated and dynamic anomaly types, such as those emerging in IoT environments or evolving cyber-attacks. Expanding the framework to handle such complex, multi-modal anomalies would increase its applicability to a wider range of security threats.

We would also like to explore optimization of Active Learning strategies. While the current active learning approach relies on uncertainty-based sampling, exploring more advanced active learning techniques—such as diversity sampling or reinforcement learning-based strategies—could improve the efficiency of data selection. This may lead to faster convergence and more robust model performance with even fewer labeled samples.

We would also like to explore transfer learning and domain adaptation for investigating how ALADAEN can be adapted across different domains and datasets without retraining from scratch which could significantly reduce computational costs. Incorporating transfer learning methods could enable the model to generalize better when applied to new operating systems or attack scenarios.

Future work could explore dynamic GAN adaptation for improving the GAN-based data augmentation mechanism, making it more adaptive to the evolving distribution of data during the active learning process. Introducing dynamic feedback loops between the GAN and the active learning process could generate synthetic data that is more closely aligned with the most uncertain and informative samples.