Paper deep dive
Cognitive Graph Intelligence for Adaptive and Robust DDoS Attack Detection in Next Generation Networks
Mohammad Arif Hossain, Yeahia Sarker, Md Jafrin Hossain, Most. Humayra Khanom Rime, Nirwan Ansari
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 94%
Last extracted: 8/19/2026, 4:50:44 AM
Summary
The paper proposes GraphGAN, a Graph-based Generative Adversarial Network designed for adaptive and robust DDoS attack detection in next-generation networks. It addresses class imbalance and non-stationary conditions by converting sequential network flows into k-nearest neighbor graphs using sliding windows. A generator synthesizes realistic minority-class DDoS samples to balance the dataset, while a Graph Convolutional Network (GCN) discriminator and classifier handle the structural and topological features of the traffic data. Evaluations on four benchmark datasets demonstrate superior accuracy, precision, and recall compared to state-of-the-art methods, particularly in data-scarce scenarios.
Entities (7)
Relation Signals (6)
GraphGAN → detects → DDoS
confidence 100% · Cognitive Graph Intelligence for Adaptive and Robust DDoS Attack Detection in Next Generation Networks
GraphGAN → addresses → Class Imbalance
confidence 95% · GraphGAN captures the relational structure among traffic flows while addressing imbalance through adversarial generation of synthetic samples.
GraphGAN → uses → GCN
confidence 95% · A separate GCN classifier, trained on the balanced dataset, performs the final detection decision.
GraphGAN → uses → GAN
confidence 95% · The generator learns the distribution of DDoS attacks to synthesize realistic minority samples, while a Graph Convolutional Network (GCN)-based discriminator distinguishes real from synthetic graph data.
GraphGAN → uses → k-NN
confidence 90% · Sequential flows are converted into k-nearest neighbor graphs using sliding windows to preserve feature-similarity and temporal dependencies among flows.
NIDS → struggleswith → Class Imbalance
confidence 85% · Statistical anomaly detectors... often suffer from high false-positive rates... severe class imbalance... degrades sensitivity to minority intrusion classes
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:Distributed Denial-of-Service (DDoS) attacks threaten network availability, requiring a cognitive detection process that senses traffic, infers intent, and supports an adaptive response under severe class imbalance and non-stationary conditions. This paper proposes a Graph-based Generative Adversarial Network (GraphGAN) that serves as the cognitive detection engine for this task. GraphGAN captures the relational structure among traffic flows while addressing imbalance through adversarial generation of synthetic samples. Sequential flows are converted into $k$-nearest neighbor graphs using sliding windows to preserve feature-similarity and temporal dependencies among flows. The generator learns the distribution of DDoS attacks to synthesize realistic minority samples, while a Graph Convolutional Network (GCN)-based discriminator distinguishes real from synthetic graph data. A separate GCN classifier, trained on the balanced dataset, performs the final detection decision. Evaluations on four benchmark datasets show that GraphGAN achieves superior accuracy, precision, and recall compared to state-of-the-art approaches, particularly in data-scarce scenarios. By integrating temporal graph construction, adversarial augmentation, and GCN classification, GraphGAN effectively models coordinated attack behaviors and mitigates class imbalance, providing a robust and topology-aware solution for intrusion detection in data-constrained environments.
Tags
Links
- Source: https://arxiv.org/abs/2608.17352v1
- Canonical: https://arxiv.org/abs/2608.17352v1
Trouble viewing inline? Open PDF directly →
Full Text
82,588 characters extracted from source content.
Expand or collapse full text
Cognitive Graph Intelligence for Adaptive and Robust DDoS Attack Detection in Next Generation Networks Mohammad Arif Hossain Yeahia Sarker Md Jafrin Hossain Most. Humayra Khanom Rime Nirwan Ansari Thanks: M. A. Hossain, Y. Sarker, and M. H. K. Rime are with Middle Tennessee State University, USA, M. J. Hossain is with C2C Tech, Germany, and N. Ansari is with New Jersey Institute of Technology, USA. Corresponding author: Mohammad Arif Hossain (e-mail: mohammad.hossain@mtsu.edu). Abstract Distributed Denial-of-Service (DDoS) attacks threaten network availability, requiring a cognitive detection process that senses traffic, infers intent, and supports an adaptive response under severe class imbalance and non-stationary conditions. This paper proposes a Graph-based Generative Adversarial Network (GraphGAN) that serves as the cognitive detection engine for this task. GraphGAN captures the relational structure among traffic flows while addressing imbalance through adversarial generation of synthetic samples. Sequential flows are converted into k-nearest neighbor graphs using sliding windows to preserve feature-similarity and temporal dependencies among flows. The generator learns the distribution of DDoS attacks to synthesize realistic minority samples, while a Graph Convolutional Network (GCN)-based discriminator distinguishes real from synthetic graph data. A separate GCN classifier, trained on the balanced dataset, performs the final detection decision. Evaluations on four benchmark datasets show that GraphGAN achieves superior accuracy, precision, and recall compared to state-of-the-art approaches, particularly in data-scarce scenarios. By integrating temporal graph construction, adversarial augmentation, and GCN classification, GraphGAN effectively models coordinated attack behaviors and mitigates class imbalance, providing a robust and topology-aware solution for intrusion detection in data-constrained environments. Index Terms: Cognitive networking, DDoS resilience, graph neural networks, generative adversarial networks, class imbalance, and network intrusion detection systems. I Introduction Distributed Denial-of-Service (DDoS) attacks have emerged as one of the most persistent and devastating threats in modern cybersecurity, causing billions of dollars in annual damages and disrupting critical infrastructure worldwide [38]. Unlike targeted intrusions, DDoS attacks exploit the distributed nature of compromised hosts to overwhelm services, making real-time mitigation extremely challenging. The scale and sophistication of these attacks continue to escalate: botnets such as Mirai have demonstrated the ability to mobilize millions of compromised IoT devices into coordinated flooding campaigns [2, 23], while modern multi-vector attacks combine volumetric, protocol, and application-layer techniques to evade single-point defenses [41]. These developments highlight the inadequacy of static, rule-based protection mechanisms and motivate the need for intelligent, adaptive detection frameworks. Traditional network intrusion detection systems (NIDS) rely primarily on signature-based rules and statistical anomaly detection, both of which struggle to adapt to rapidly evolving attack vectors [19]. Signature-based systems require prior knowledge of attack patterns and are inherently reactive, limiting their ability to detect zero-day or polymorphic variants. Statistical anomaly detectors, while more general, often suffer from high false-positive rates and limited capability to model complex, non-linear relationships in high-dimensional traffic data [15, 16]. Meanwhile, the exponential growth in traffic volume and complexity has rendered conventional flow-based analysis insufficient, as processing flows independently fails to capture the interconnected and coordinated nature of modern network communications [26, 24, 18]. With the proliferation of cloud computing, IoT ecosystems, and high-speed 5G/6G networks, network defense increasingly relies on cognitive, learning-driven detection that can observe traffic, reason about threats, and support adaptive mitigation across heterogeneous environments [33]. In this setting, an intrusion detector is most useful as the learning core of a sense–infer–act process rather than a standalone classifier. Deep learning has shown promise for automated feature extraction [32]; however, most methods treat traffic flows as independent feature vectors, discarding the relational structure that a cognitive detector could exploit. Furthermore, severe class imbalance, where benign traffic vastly outnumbers attack instances, degrades sensitivity to minority intrusion classes and remains a persistent challenge [34]. Addressing structural modeling and distributional imbalance together is therefore a prerequisite for adaptive, robust detection and motivates the framework we develop here. I-A Motivation The growing complexity of DDoS attacks and the limitations of traditional detection approaches necessitate new methods that capture the structural and distributional properties of modern network data. We highlight three key motivations for our graph-based adversarial framework. Non-Euclidean Structure in Network Traffic: Network communications inherently exhibit graph-structured relationships through temporal sequences, source-destination interactions, and feature similarities that are often overlooked by conventional approaches [4]. Treating flows as independent samples discards relational information essential for recognizing coordinated and distributed attacks. Graph neural networks have recently demonstrated strong potential in network security by modeling such dependencies [44]; however, their integration with adversarial augmentation remains largely unexplored. Our k-nearest neighbor (k-N) graph construction captures flow interdependencies by forming temporal subgraphs that link flows by feature similarity within each time window, preserving both feature-space proximity and temporal locality. Real-World Class Imbalance: Network datasets are highly imbalanced, with benign traffic overwhelmingly dominating attack instances, significantly reducing model sensitivity to minority intrusion classes [30]. Conventional interpolation-based oversampling techniques, such as SMOTE, fail to capture the nonlinear and topological dependencies inherent in high-dimensional traffic data [8]. Although recent GAN-based augmentation methods have improved the generation of synthetic attacks [43], they operate on vectorized representations and produce isolated samples without graph-structural context. To address this limitation, our adversarial framework employs a generator trained against a graph-based discriminator to synthesize realistic minority samples that preserve both statistical distributions and relational fidelity across network nodes, thereby enhancing robustness and detection performance. Topology-Aware Adversarial Training: Many generative models synthesize isolated samples without incorporating relational context, resulting in data that may be statistically plausible yet topologically inconsistent [3]. Even advanced generative architectures such as Wasserstein GANs [3] and VAE-GAN hybrids [36] generate point-wise samples that neglect inter-flow dependencies. Our framework integrates graph neural networks (GNNs) with adversarial training to ensure that synthetic DDoS samples reflect both intrinsic flow characteristics and realistic relationships with neighboring flows, producing topology-consistent augmentation that existing generative approaches cannot achieve. I-B Literature Review DDoS attacks have evolved from volumetric floods to multi-vector campaigns, exposing the limitations of traditional detection methods that treat flows independently and ignore relational structures [44]. While machine learning improves on rule-based systems, most approaches rely on vectorized traffic representations, which miss topological patterns critical to distributed attacks. Combined with severe class imbalance as benign traffic dominates, this gap reduces detection accuracy and minority-class sensitivity. Feature Learning-based DDoS Detection. Chouhan et al. [9] proposed a non-linear kernel-based support vector machine for classifying DDoS attacks in software-defined networking (SDN). This lightweight model can detect live attacks but requires manual feature extraction. An LSTM-autoencoder-based approach [12] reduces feature overhead and false alarms by addressing irrelevant features and non-representative SDN datasets, yet it still overlooks the inherent class-imbalance problem. To capture temporal information, a CNN-LSTM hybrid was introduced by Rajan and Aravindhar [31]. On the ensemble learning front, He et al. [14] proposed a feature-weighted random forest for application-layer DDoS defense, achieving high detection rates but remaining limited to hand-crafted feature spaces. Yang et al. [40] combined attention mechanisms with BiGRU and Inception-CNN for IIoT intrusion detection, using mixed sampling to address class imbalance; however, the model still processes flows independently without structural context. Federated learning has also emerged as a promising direction: Li et al. [21] proposed an iterative model averaging (IMA) based gated recurrent unit (GRU) protocol at the fog/edge layer for collaborative and privacy-preserving DDoS mitigation in Industrial IoT networks. Despite these advances, the aforementioned methods fail to capture relational interdependencies within network traffic. Graph-based DDoS Attack Classification. Graph networks have shown significant performance improvements in modeling data relationships by converting datasets into node-edge structures [29]. A comprehensive survey by Zhong et al. [44] systematically categorized GNN-based IDS methods across graph construction strategies and deployment paradigms, identifying scalability and adversarial robustness as open challenges. Li et al. [22] proposed a vanilla graph network to exploit relationships among packet attributes, time intervals, and device characteristics. A spatio-temporal GCN [7] improved SDN-based DDoS detection by incorporating temporal information, though class imbalance remained unaddressed. Bakar et al. [4] proposed a similar approach combining multiple graph networks to extract features from non-Euclidean spaces. Lo et al. [25] introduced E-GraphSAGE, an edge-feature-aware extension of GraphSAGE that represents flows as graph edges with rich feature vectors, enabling joint learning from host and flow attributes for IoT intrusion detection. Wang et al. [37] proposed BS-GAT, a graph attention network that constructs behavioral similarity graphs with edge weights incorporated into the attention mechanism, achieving over 99% accuracy in edge computing environments. Duan et al. [11] proposed a graph model in a semi-supervised setting to mitigate data scarcity in DDoS detection. Although this approach improves detection performance, it still struggles with class imbalance. Adversarial Training for DDoS Detection. Recent advances in deep generative models have demonstrated the potential of adversarial training for DDoS detection [27]. Shieh et al. [35] proposed a dual-discriminator strategy for detecting adversarial DDoS traffic in SDN. A GAN model [27] was introduced to generate synthetic data for highly imbalanced datasets, improving classification accuracy by reframing DDoS detection as a supervised learning task. Zhao et al. [43] employed a conditional GAN to oversample rare attack categories, preventing category omission in heavily skewed datasets through label-consistent synthetic generation. Arafah et al. [3] combined a denoising autoencoder with a Wasserstein GAN, using the WGAN’s Lipschitz-constrained training to synthesize more stable and realistic minority-class traffic. Tian et al. [36] extended this line by integrating a variational autoencoder with an auxiliary-classifier WGAN-GP, thereby improving both the fidelity and the class-conditioned diversity of generated intrusion samples. Despite these advances, none of these generative approaches operate on graph-structured data, producing isolated synthetic samples that lack topological context. Learning-Driven Cognitive Network Defense. A parallel line of work embeds learning inside the network control plane so that defense adapts online rather than through static rules. Collaborative and decentralized learning has been explored for 5G+ core and edge environments [16], and meta- and resource-aware learning has been applied to offloading and control in IoT networks [17]. Federated designs push detection to the fog/edge layer for privacy-preserving, in-network mitigation [17], while flow-level detectors have been deployed at SDN controllers to close the loop between sensing and actuation [12]. These efforts frame intrusion detection as one stage of a cognitive networking pipeline, but they largely operate on vectorized traffic and do not exploit the relational topology of coordinated attacks. GraphGAN targets exactly this gap: it supplies a topology-aware cognitive engine whose output can drive an edge/SDN mitigation decision, uniting structural modeling with the adaptive control that cognitive communication networks require. I-C Contributions To address these challenges, we propose a Graph-based Generative Adversarial Network (GraphGAN), a novel framework that unifies structure-aware modeling with generative augmentation for intelligent DDoS detection. Unlike prior work, our approach treats traffic as inherently relational and leverages adversarial training to mitigate class imbalance while preserving topological integrity. The main contributions are summarized as follows: • A structure-aware graph construction strategy using k-N connectivity over sliding temporal windows to capture flow co-occurrence and feature-similarity patterns within temporal neighborhoods that are ignored by vector-based detection approaches. • An adversarial graph neural architecture integrating GCNs with generative training, where the discriminator processes entire graph structures, enabling topology-conditioned synthetic sample generation over fixed real topology templates. • An imbalance-aware generative mechanism that produces realistic minority-class DDoS samples while preserving both statistical fidelity and relational consistency within the graph. • A detection framework based on GCN classification that exploits structural flow relationships to identify coordinated attack patterns. The remainder of this manuscript is organized as follows. Section I introduces the proposed GraphGAN framework. Section I presents the experimental results and performance evaluation. Section IV includes the concluding remarks. I Methodology The proposed GraphGAN integrates graph neural networks with adversarial training to address class imbalance while modeling topological relationships in network traffic. The framework is illustrated in Fig. 1. I-A Cognitive Detection Process We frame GraphGAN as the cognitive detection stage of a sense–infer–act process that a network controller (e.g., an SDN controller) can use to maintain service availability under attack. In the sense stage, per-flow statistics i∈ℝdx_i ^d are exported from switches or gateways (e.g., via telemetry or flow-export) and streamed to the detector. In the infer stage, the proposed GraphGAN pipeline converts a sliding window of flows into a temporal graph tG_t and produces a subgraph-level decision P(y∣t)P(y _t); adversarial augmentation supplies the minority-class fidelity that keeps this decision reliable under the imbalance typical of live traffic. In the act stage, a decision of “DDoS” can trigger a mitigation policy (e.g., rate limiting or flow-rule installation), while benign decisions leave forwarding untouched. Two properties make this framing attractive. First, the detector consumes only exported flow features, so it imposes no per-packet inference cost on the forwarding path. Second, because the decision is made at the granularity of a temporal window rather than a single flow, detection reacts to coordinated behavior—the regime in which distributed attacks are distinguishable (Theorem 1)—rather than to isolated flows. I-B Graph Construction from Network Traffic Our graph construction methodology transforms sequential network flow data into graph-structured representations that preserve both feature-level similarities and temporal dependencies. I-B1 Feature Space Representation and Normalization Let =(i,yi)i=1ND=\(x_i,y_i)\_i=1^N denote the traffic dataset, where i∈ℝdx_i ^d is the d-dimensional feature vector of the i-th flow and yi∈0,1y_i∈\0,1\ is the binary label (benign or DDoS). Each ix_i consists of flow-level statistics, including packet size, inter-arrival time, flow duration, and protocol-related features. To avoid dominance of large-magnitude features and, crucially, to confine every feature to a bounded range that the generator can reproduce, we standardize each feature to the interval [−1,1][-1,1] via min–max normalization, ~i=2i−minmax−min−, x_i=2\, x_i-x_ x_ -x_ -1, (1) where minx_ and maxx_ are the element-wise minimum and maximum computed over the training dataset and all operations are applied element-wise. Beyond balancing feature contributions in graph construction, bounding features to [−1,1][-1,1] aligns their support with the codomain of the generator’s tanh output, a property we exploit to keep the adversarial distribution-matching objective (Theorem 3) well-posed. I-B2 Temporal Graph Construction via Sliding Windows Network attacks, particularly DDoS attacks, exhibit temporal patterns crucial for accurate detection. To capture these patterns while maintaining computational tractability, we employ a sliding-window mechanism that partitions sequential network flows into temporal subgraphs. For window size w and step size s, we define temporal subgraphs t=(t,ℰt,t),G_t=(V_t,E_t,X_t), where t=vt,1,…,vt,wV_t=\v_t,1,…,v_t,w\ is the vertex set of w consecutive flows, ℰtE_t represents the edge set encoding relational dependencies among flows, and t∈ℝw×dX_t ^w× d is the standardized feature matrix. The sliding window ensures temporal locality, and overlapping windows (s<ws<w) capture transitional patterns for robust representation learning. Because overlapping windows share raw flows, windows are never allowed to span across data partitions: the chronological splitting protocol used in our experiments (Section I) partitions the flow stream before windowing, preventing any flow from leaking across the training, validation, and test sets. Fig. 1: Overview of the proposed GraphGAN framework. (Left) Raw flow vectors are segmented using sliding windows and transformed into k-N subgraphs. (Center) The adversarial training loop optimizes a generator to synthesize realistic node features over fixed topology templates, while a GCN-based discriminator distinguishes real from synthetic graphs. (Right) A GCN classifier operates on the augmented dataset to perform binary DDoS classification. I-B3 k-Nearest Neighbor Graph Construction Constructing meaningful graph topology is critical for capturing the relational structure inherent in network traffic. We employ k-nearest neighbor (k-N) graph construction based on feature similarity, creating edges between network flows with similar characteristics. The k-N graph construction begins by computing the pairwise Euclidean distance matrix for all flows within each temporal window: Dij(t)=‖~t,i−~t,j‖2=∑ℓ=1d(x~t,i,ℓ−x~t,j,ℓ)2D_ij^(t)=\| x_t,i- x_t,j\|_2= _ =1^d( x_t,i, - x_t,j, )^2 (2) where ~t,i x_t,i represents the standardized feature vector for the i-th node in temporal window t. The Euclidean distance metric is chosen for its interpretability and computational efficiency, though other distance metrics could be employed depending on the feature characteristics. For each node viv_i in the temporal window, we identify its k nearest neighbors: k(vi)=vj:j∈argminj≠ikDij(t)N_k(v_i)=\v_j:j _j≠ i^kD_ij^(t)\ (3) This operation selects the k nodes most similar to node viv_i in the feature space, excluding viv_i itself. The parameter k controls the graph’s connectivity and must be chosen to balance capturing local neighborhoods (small k) and ensuring connectivity (large k). The adjacency matrix t∈0,1w×wA_t∈\0,1\^w× w is then constructed to create an undirected graph: Aij(t)=1,if vj∈k(vi) or vi∈k(vj),0,otherwise.A_ij^(t)= cases1,&if v_j _k(v_i) or v_i _k(v_j),\\ 0,&otherwise. cases (4) The symmetric construction ensures that if node viv_i considers vjv_j a neighbor, then vjv_j also considers viv_i a neighbor, yielding an undirected graph that better captures bidirectional relationships in network communications. Two important structural properties follow directly from this symmetric k-N construction: the adjacency matrix is guaranteed to be symmetric, and every node has a degree bounded between k and w−1w-1. We formalize these properties below. Lemma 1 (Symmetry and Bounded Degree of k-N Graph). The adjacency matrix tA_t constructed via symmetric k-N satisfies: (i) t=t⊤A_t=A_t (symmetry), and (i) for every node viv_i, the degree deg(vi)=∑jAij(t) (v_i)= _jA_ij^(t) satisfies k≤deg(vi)≤w−1k≤ (v_i)≤ w-1, where w is the window size. Proof Property (i) follows directly from the construction rule in Eq. (4): Aij(t)=1A_ij^(t)=1 if and only if vj∈k(vi)v_j _k(v_i) or vi∈k(vj)v_i _k(v_j), which is symmetric by definition. For property (i), each node viv_i selects exactly k neighbors, so deg(vi)≥k (v_i)≥ k. Since the graph contains w nodes and self-loops are excluded, the degree is bounded above by w−1w-1. This bounded-degree property ensures that each node maintains at least k connections while remaining constrained by the finite window size w, preventing degenerate graph structures and providing a well-conditioned topology for subsequent GCN processing. I-B4 Graph Label Assignment Each temporal subgraph requires a label for supervised learning. Since individual network flows within a window may have different labels, we employ majority voting to assign a single label to the entire subgraph as: yt=argmaxc∈0,1∑i=1w(yt,i=c),y_t=argmax_c∈\0,1\ _i=1^wI(y_t,i=c), (5) where (⋅)I(·) is the indicator function that returns 1 if the condition is true and 0 otherwise, and yt,iy_t,i is the label of the i-th flow in window t. For even window sizes, an exact tie between the two classes is possible; we break such ties toward the attack (DDoS) class, a security-conservative choice that favors recall over precision. This approach assumes that the majority class within a temporal window reflects the overall behavior pattern, which is reasonable for DDoS attacks, which typically involve sustained malicious activity across multiple flows. A natural question is whether this majority-voting scheme reliably assigns labels for the window sizes used in our experiments, including the even default w=30w=30. The following lemma confirms that the assigned label is always supported by at least a simple majority, which strengthens to a strict majority for odd window sizes. Lemma 2 (Label Consistency of Majority Voting). Let αt=1w∑i=1w(yt,i=yt) _t= 1w _i=1^wI(y_t,i=y_t) denote the fraction of flows in window t agreeing with the label yty_t assigned by Eq. (5), with ties broken toward the attack class. Then, αt≥12 _t≥ 12 for any window size w. Moreover, when w is odd, tie is not allowed and the bound strengthens to a strict majority, αt≥12+12w _t≥ 12+ 12w. Under temporal locality, where DDoS flows form contiguous segments so that most windows lie within a single regime, αt→1 _t→ 1; the worst case αt=12 _t= 12 arises only at an exact class split within a window. Proof For binary labels, one of the two classes must account for at least ⌈w/2⌉ w/2 of the w flows, so the majority-voted winner satisfies ∑i=1w(yt,i=yt)≥⌈w/2⌉ _i=1^wI(y_t,i=y_t)≥ w/2 ; the tie-breaking rule guarantees this even at an exact w/2w/2 split. Dividing by w yields αt≥⌈w/2⌉/w≥12 _t≥ w/2 /w≥ 12. When w is odd, the class counts ∑i(yt,i=1) _iI(y_t,i=1) and w−∑i(yt,i=1)w- _iI(y_t,i=1) have opposite parities and cannot be equal, so tie is not possible and the winning count is at least w+12 w+12. Dividing by w gives αt≥w+12w=12+12w _t≥ w+12w= 12+ 12w, which establishes the strict-majority case. I-B5 When Graph Structure Carries Information We formalize two properties of DDoS traffic that together establish when graph structure provides a detection advantage over single-flow models. The first says individual flows are ambiguous; the second says they are jointly informative. Both are necessary for structure to help, and we state them as explicit hypotheses. Definition 1 (Feature Ambiguity). Flows are η-ambiguous if the optimal single-flow (vector) classifier has irreducible Bayes risk Rflow⋆=[min(p(y=0∣),p(y=1∣))]=η>0.R _flow=E_x\! [ \! (p(y=0 ),\,p(y=1 ) ) ]=η>0. Definition 2 (Coordination). DDoS traffic is coordinated if, for flows i,ji,j connected by the k-N rule, the labels retain dependence after conditioning on their features: I(Yi;Yj∣i,j)=c>0.I\! (Y_i;Y_j _i,X_j )=c>0. Definition 2 captures the intuition that botnet flows are not independent draws: knowing a neighbor is malicious raises the posterior that a feature-similar flow is malicious too, beyond what the features alone reveal. We now show that a neighborhood-aware predictor strictly beats the best single-flow predictor exactly in this regime. Theorem 1 (Graph Advantage under Feature-Ambiguous Coordination). Assume flows are η-ambiguous (Definition 1) and coordinated with strength c>0c>0 (Definition 2). Let Rgraph⋆R _graph be the Bayes risk of a predictor that observes a node together with its k-N neighborhood within the window. Then, Rflow⋆−Rgraph⋆≥Φ(c,m¯)> 0,R _flow-R _graph\;≥\; (c, m)\;>\;0, where m¯ m is the expected number of same-class neighbors and Φ is strictly increasing in both arguments, with Φ(0,⋅)=0 (0,·)=0. Proof The neighborhood supplies side information Zi=(Yj)j∈k(vi)Z_i=(Y_j)_j _k(v_i) about YiY_i. By Definition 2, I(Yi;Zi∣i)≥cm¯>0I(Y_i;Z_i _i)≥ c\, m>0, so the conditional entropy strictly drops: H(Yi∣i,Zi)<H(Yi∣i)H(Y_i _i,Z_i)<H(Y_i _i). Fano’s inequality lower-bounds any predictor’s risk by an increasing function of the conditional entropy of the target; a strict entropy reduction therefore admits a neighborhood predictor whose Bayes risk is strictly smaller, with the gap controlled by the mutual information drop. Setting Φ to the induced risk decrease gives the claim; Φ(0,⋅)=0 (0,·)=0 because c=0c=0 removes the side information. Scope. The hypothesis η>0η>0 is essential: if flows are already separable in feature space, then Rflow⋆=0R _flow=0 and no model can improve on it, so the advantage vanishes. The theorem, therefore, characterizes when structure helps (ambiguous yet coordinated traffic) rather than asserting structure is universally required. This is the regime that DDoS occupies, and that motivates the entire framework. The advantage above lies in the dependence between features and the topology they induce. Because the k-N adjacency is a deterministic function of the window’s features, this dependence is real and, crucially, invisible to any feature-only model. Proposition 1 (Feature–Topology Information Gap). Let a vector or vectorized-GAN model act on X alone, i.e. its predictor and generator are measurable with respect to features only. Then, no such model can exploit the feature–topology mutual information Idata(,)I_data(X;A). A model that processes (,)(X,A) jointly, as our GCN does, has access to this term. Proof A feature-only predictor factors through X, so by the data-processing inequality, its accessible information about Y is at most I(,Y)I(X;Y). The joint predictor’s accessible information is I(,,Y)=I(,Y)+I(;Y∣)I(X,A;Y)=I(X;Y)+I(A;Y ), and the second term is non-zero precisely when topology is label-informative given features—the coordinated regime of Definition 2. The quantity Idata(,)I_data(X;A) reappears as the irreducible residual in the adversarial augmentation analysis (Theorem 4) and connects to the generalization bound of Theorem 5, forming the information-theoretic thread that links graph construction, adversarial training, and classification throughout the framework. I-C Adversarial Learning Framework By learning the underlying distribution of minority class samples (DDoS attacks), our GAN-based approach generates realistic synthetic samples that preserve both statistical properties and topological relationships. I-C1 Generator Network Architecture The generator network Gθ:ℝz→ℝdG_θ:R^z ^d transforms random noise vectors sampled from a prior distribution into synthetic node features that mimic the characteristics of real DDoS traffic. The architecture employs multiple fully connected layers with batch normalization and dropout for regularization. Given a noise vector ∼(,z)z (0,I_z) sampled from a multivariate standard normal distribution, where z is the noise dimension, the generator produces synthetic features through the following sequence of transformations: 1 _1 =ReLU(BN(1G+1G)), =ReLU(BN(W_1^Gz+b_1^G)), (6) 2 _2 =Dropout(ReLU(BN(2G1+2G)),p=0.3), =Dropout(ReLU(BN(W_2^Gh_1+b_2^G)),p=0.3), (7) 3 _3 =Dropout(ReLU(BN(3G2+3G)),p=0.3), =Dropout(ReLU(BN(W_3^Gh_2+b_3^G)),p=0.3), (8) x =tanh(4G3+4G), = (W_4^Gh_3+b_4^G), (9) where iG∈ℝhi×hi−1W_i^G ^h_i× h_i-1 and iG∈ℝhib_i^G ^h_i are the weight matrices and bias vectors for the i-th layer, respectively, with h0=zh_0=z and h4=dh_4=d. The batch normalization operation BN(⋅)BN(·) normalizes the pre-activation values to have zero mean and unit variance, accelerating training and improving stability. The ReLU activation function ReLU(x)=max(0,x)ReLU(x)= (0,x) introduces non-linearity while maintaining computational efficiency. Dropout with probability p=0.3p=0.3 randomly sets a fraction of input units to zero during training, preventing overfitting. The final activation tanh(x)=ex−e−xex+e−x (x)= e^x-e^-xe^x+e^-x bounds each synthetic feature to [−1,1][-1,1], stabilizing adversarial training and, by construction, matching the support of the real node features that were min–max normalized to the same interval in Eq. (1). This shared support is essential: were the synthetic and real features confined to different ranges, the discriminator could separate them by feature range alone, and the Jensen–Shannon optimum of Theorem 3 (attained at pG=pdatap_G=p_data) could never be reached. I-C2 Graph-based Discriminator Network The discriminator network DϕD_φ employs Graph Convolutional Networks (GCNs) to process graph-structured data and distinguish between real and synthetic samples. Unlike traditional discriminators that operate on individual samples, our graph-based approach considers the entire graph topology, enabling more sophisticated pattern recognition. For a graph =(,ℰ,)G=(V,E,X), each GCN layer performs localized convolution operations that aggregate information from neighboring nodes. The fundamental GCN operation is defined as: (l+1)=σ(^−12^^−12(l)(l)),H^(l+1)=σ\! ( D^- 12 A D^- 12H^(l)W^(l) ), (10) where ^=+ A=A+I is the adjacency matrix with added self-loops to include each node’s own features in the aggregation, ^ii=∑jA^ij D_i= _j A_ij is the corresponding degree matrix, (l)∈ℝ||×h(l)H^(l) ^|V|× h^(l) denotes the node representations at layer l with (0)=H^(0)=X, (l)∈ℝh(l)×h(l+1)W^(l) ^h^(l)× h^(l+1) is the trainable weight matrix, and σ(⋅)σ(·) is the activation function. The normalization term ^−12^^−12 D^- 12 A D^- 12 ensures degree-normalized feature propagation, preventing high-degree nodes from disproportionately influencing the learned representations. This propagation rule arises as a first-order Chebyshev approximation of spectral graph convolutions [10]. I-C3 Adversarial Training Objective Adversarial training follows a two-player minimax game in which the generator attempts to fool the discriminator, while the discriminator tries to correctly identify real and synthetic samples. The minimax objective is formulated as: minθmaxϕℒGAN(Gθ,Dϕ), _θ _φL_GAN(G_θ,D_φ), (11) where θ and ϕφ represent the parameters of the generator and discriminator, respectively. The objective function captures the adversarial nature of the training as ℒGAN(Gθ,Dϕ)=∼pdata[logDϕ()]+∼pG[log(1−Dϕ())].L_GAN(G_θ,D_φ)=E_G p_data[ D_φ(G)]+E_G p_G[ (1-D_φ(G))]. Here, pdatap_data denotes the distribution of real minority-class (DDoS) subgraphs, since the augmentation targets only the under-represented attack class and benign graphs are never synthesized, while pGp_G is the generator-induced distribution over synthetic DDoS graphs. The first term encourages the discriminator to correctly identify real graphs by maximizing logDϕ() D_φ(G), while the second term encourages correct identification of fake graphs by maximizing log(1−Dϕ()) (1-D_φ(G)). From the generator’s perspective, minimizing this objective encourages it to increase the discriminator’s misclassification probability on synthetic samples. The construction of fake graphs preserves the topological structure of real graphs while replacing node features with generator outputs, fake=(real,ℰreal,Gθ()),G_fake=(V_real,E_real,G_θ(Z)), where =[1,2,…,||]TZ=[z_1,z_2,…,z_|V|]^T is a matrix of independently sampled noise vectors. This approach ensures that synthetic graphs maintain realistic topological properties while introducing novel feature combinations. The individual loss functions for training are: ℒD _D =−∼pdata[logDϕ()]−∼pG[log(1−Dϕ())], =-E_G p_data[ D_φ(G)]-E_G p_G[ (1-D_φ(G))], (12) ℒG _G =−∼pG[logDϕ()]. =-E_G p_G[ D_φ(G)]. (13) The discriminator loss ℒDL_D is minimized to improve classification accuracy on both real and fake samples, while the generator loss ℒGL_G is minimized to increase the probability that synthetic samples are classified as real, viz., to produce more realistic synthetic samples. Having defined the adversarial objective, we now characterize the equilibrium behavior of this minimax game. We first derive the closed-form optimal discriminator for a fixed generator, and then show that the global optimum is achieved when the generator perfectly recovers the real data distribution. Theorem 2 (Optimal Discriminator). For a fixed generator GθG_θ, the optimal discriminator Dϕ∗D_φ^* is given by Dϕ∗()=pdata()pdata()+pG(),D_φ^*(G)= p_data(G)p_data(G)+p_G(G), (14) where pdatap_data is the distribution of real graph data and pGp_G is the distribution induced by the generator [13]. Proof For fixed GθG_θ, the discriminator objective ℒGANL_GAN can be written as ∫[pdata()logD()+pG()log(1−D())]. [p_data(G) D(G)+p_G(G) \! (1-D(G) ) ]dG. (15) For any (a,b)(a,b) with a,b≥0a,b≥ 0 and a+b>0a+b>0, the function f(D)=alogD+blog(1−D)f(D)=a D+b (1-D) attains its maximum at D∗=a+bD^*= aa+b, obtained by setting dfdD=aD−b1−D=0 dfdD= aD- b1-D=0. Substituting a=pdata()a=p_data(G) and b=pG()b=p_G(G) yields the result. Building on this result, we can now analyze the global optimum of the minimax game by substituting the optimal discriminator back into the objective function. Theorem 3 (Global Optimality of Adversarial Training). The global minimum of the minimax objective ℒGAN(Gθ,Dϕ)L_GAN(G_θ,D_φ) is achieved if and only if pG=pdatap_G=p_data. At this optimum, Dϕ∗()=12D_φ^*(G)= 12 for all G, and minθmaxϕℒGAN=−log4 _θ _φL_GAN=- 4 [13]. Proof Substituting D∗D^* from Theorem 2 into the objective yields C(G) C(G) =∼pdata[logpdata()pdata()+pG()] =E_G p_data\! [ p_data(G)p_data(G)+p_G(G) ] (16) +∼pG[logpG()pdata()+pG()]. +E_G p_G\! [ p_G(G)p_data(G)+p_G(G) ]. This can be rewritten as C(G) C(G) =−log4+KL(pdata∥pdata+pG2) =- 4+KL\! (p_data \| p_data+p_G2 ) (17) +KL(pG∥pdata+pG2) +KL\! (p_G \| p_data+p_G2 ) =−log4+2⋅JSD(pdata∥pG), =- 4+2·JSD(p_data\|p_G), where JSDJSD denotes the Jensen–Shannon divergence. Since JSD≥0JSD≥ 0 with equality if and only if pG=pdatap_G=p_data, the global minimum C(G)=−log4C(G)=- 4 is attained uniquely when pG=pdatap_G=p_data. Theorems 2 and 3 provide the theoretical foundation for our adversarial framework: when the generator successfully learns the distribution of DDoS attack graphs, the discriminator can no longer distinguish synthetic from real attack traffic, ensuring high-fidelity augmentation for downstream classification. Because our generator produces features independently of the template topology, the equilibrium of Theorem 3 does not guarantee that the joint distribution over features and adjacency is matched. The following result identifies the irreducible gap. Theorem 4 (Residual Divergence of Topology-Independent Generation). Because templates are real and features are generated independently of them, the generator induces pfake(,)=pG()pdata()p_fake(X,A)=p_G(X)\,p_data(A). Here, KL(⋅∥⋅)KL(·\|·) denotes the Kullback–Leibler divergence [20]. Then, minθKL(pdata∥pfake) is attained at pG()=pdata(), _θ\,KL\! (p_data\,\|\,p_fake ) is attained at p_G(X)=p_data(X), and the irreducible value equals the feature–topology mutual information, KL(pdata∥pdata()pdata())=Idata(;).KL\! (p_data\,\|\,p_data(X)\,p_data(A) )=I_data(X;A). Proof By the chain rule of KL divergence and the factorized form of pfakep_fake, KL(pdata∥pfake)=[KL(pdata(∣)∥pG())]KL(p_data\|p_fake)=E_A\! [KL (p_data(X )\,\|\,p_G(X) ) ]. This is minimized over pGp_G at the A-averaged conditional pG()=[pdata(∣)]=pdata()p_G(X)=E_A[p_data(X )]=p_data(X). Substituting back leaves exactly the mutual information between X and A. Theorem 4 closes the loop with Proposition 1: the single quantity Idata(,)I_data(X;A) is both what vector methods miss and what a topology-independent generator cannot reproduce. Corollary 1 (Topology-Stable Consistency). If generated features are topology-stable—the k-N graph they induce matches the template up to bounded edge-edit distance—then Idata(,)I_data(X;A) contributed by the synthetic samples vanishes and augmentation is asymptotically consistent. This condition is the precise sense in which a future topology-conditioned generator would be strictly more expressive. I-D Graph-based Classification Network The classification network serves as the final component of our framework, leveraging both original and synthetically augmented data to perform DDoS detection. I-D1 Classifier Architecture and Feature Learning The DDoS classifier CψC_ψ employs the same GCN-based architecture as the discriminator to ensure consistent graph-structured processing, but it is trained independently with a classification objective rather than an adversarial one, allowing it to focus specifically on distinguishing benign from malicious traffic patterns. The classifier processes input graphs through multiple GCN layers that progressively refine node representations: C(1) _C^(1) =ReLU(GCN(,)), =ReLU(GCN(X,A)), (18) C(2) _C^(2) =Dropout(ReLU(GCN(C(1),)),p=0.3), =Dropout(ReLU(GCN(H_C^(1),A)),p=0.3), (19) C(3) _C^(3) =Dropout(ReLU(GCN(C(2),)),p=0.3), =Dropout(ReLU(GCN(H_C^(2),A)),p=0.3), (20) C,pool _C,pool =1||∑i=1||(3)C,i,:, = 1|V| _i=1^|V|H^(3)_C,\,i,:, (21) P(y∣) P(y ) =Softmax(CC,pool+C). =Softmax(W_Ch_C,pool+b_C). (22) The softmax activation function in the final layer converts the output logits into a probability distribution over the two classes: Softmax()i=exp(oi)∑j=12exp(oj),Softmax(o)_i= (o_i) _j=1^2 (o_j), (23) where =CC,pool+Co=W_Ch_C,pool+b_C represents the pre-activation logits. This formulation ensures that ∑i=12P(y=i|)=1 _i=1^2P(y=i|G)=1 and enables probabilistic interpretation of the classification results. An important design consideration for the GCN classifier is its receptive field, i.e., how far information propagates across multiple graph layers. The following proposition quantifies the receptive field size in terms of the number of GCN layers and the graph’s bounded degree established in Lemma 1. Proposition 2 (Receptive Field of L-Layer GCN Classifier). In an L-layer GCN, the representation i(L)h_i^(L) of node viv_i aggregates information from all nodes within its L-hop neighborhood (L)(vi)=vj:d(vi,vj)≤LN^(L)(v_i)=\v_j:d_G(v_i,v_j)≤ L\, where d_G denotes the shortest-path distance on G. For our k-N graphs with maximum degree Δ≤w−1 ≤ w-1 (Lemma 1), the receptive field size is bounded by |(L)(vi)|≤min(∑ℓ=0LΔℓ,w)|N^(L)(v_i)|≤ \! ( _ =0^L ,\,w ) [39]. With L=3L=3 layers, k=5k=5, and window size w=30w=30, the symmetric OR-construction of Eq. (4) yields an expected node degree on the order of 2k=102k=10, so the receptive field saturates the window within two hops: |(L)(vi)|≤min(∑ℓ=03Δℓ,w)=w=30|N^(L)(v_i)|≤ \! ( _ =0^3 ,\,w )=w=30. Each node’s representation, therefore, incorporates information from the entire temporal window, allowing the classifier to capture global attack coordination patterns within each subgraph while avoiding the over-smoothing that occurs with deeper architectures. The bounded degree of Lemma 1 also yields a certified radius within which classifier predictions cannot flip, providing a formal robustness guarantee for the GCN architecture. Proposition 3 (Stability under Feature and Topology Perturbation). For the L-layer normalized GCN classifier on a symmetric k-N graph with degrees in [k,w−1][k,w-1]: (i) if ‖δ‖F≤ϵ\| \|_F≤ε, the change in output logits is at most ϵ∏l=1L‖(l)‖σε _l=1^L\|W^(l)\|_σ; (i) modifying m edges changes the normalized adjacency operator by at most 2m/k2m/k in Frobenius norm, so the logit change is at most (2m/k)∏l=1L‖(l)‖σ‖F(2m/k) _l=1^L\|W^(l)\|_σ\,\|X\|_F. Proof (i) Each normalized GCN layer is ^−1/2^^−1/2 D^-1/2 A D^-1/2HW; the symmetric normalized operator has spectral norm at most 11, and ReLU is 11-Lipschitz, so the per-layer Lipschitz constant is ‖(l)‖σ\|W^(l)\|_σ and they compose multiplicatively. (i) By Lemma 1 every degree is at least k, so each entry of ^−1/2 D^-1/2 is at most 1/k1/ k; a single edge edit perturbs the operator by at most 2/k2/k in Frobenius norm, and m edits by at most 2m/k2m/k. Propagating through the layers gives the bound. Part (i) shows graceful degradation: a few mis-assigned k-N edges arising from feature noise cannot flip predictions abruptly, with the tolerance scaling as 1/k1/k. I-D2 Data Augmentation Strategy for Class Imbalance Our strategy leverages the trained generator to create synthetic DDoS samples, balancing class distribution and improving the classifier’s ability to recognize attack patterns. The augmented dataset combines original and synthetic samples as aug=real∪syn,D_aug=D_real _syn, (24) where real=(i,yi)i=1NrealD_real=\(G_i,y_i)\_i=1^N_real contains original graphs and syn=(syn(i),1)i=1NsynD_syn=\(G_syn^(i),1)\_i=1^N_syn contains synthetic DDoS graphs. The number of synthetic samples is determined by: Nsyn=min(max(0,N0−N1),Nmax),N_syn= ( (0,N_0-N_1),N_max), (25) where N0N_0 and N1N_1 are benign and DDoS samples, and NmaxN_max prevents excessive generation that may cause noise or overfitting. Each synthetic graph syn(i)G_syn^(i) is built from a template structure of real DDoS samples, populated with generator-produced features: syn(i)=(template,ℰtemplate,Gθ((i))).G_syn^(i)=(V_template,E_template,G_θ(Z^(i))). (26) Together, Eqs. (24)–(26) define a principled augmentation pipeline that respects graph topology. The following corollary shows that this strategy provably reduces class imbalance, achieving perfect balance when the generation budget is sufficiently large. Corollary 2 (Class Balance Guarantee). Let N0N_0 and N1N_1 denote the number of benign and DDoS samples, respectively, with N0>N1N_0>N_1 (class imbalance). After augmentation with Nsyn=min(N0−N1,Nmax)N_syn= (N_0-N_1,N_max) synthetic DDoS samples, the class imbalance ratio satisfies ρ=N1+NsynN0=1,if N0−N1≤Nmax,N1+NmaxN0,otherwise.ρ= N_1+N_synN_0= cases1,&if N_0-N_1≤ N_max,\\ N_1+N_maxN_0,&otherwise. cases In particular, when Nmax≥N0−N1N_max≥ N_0-N_1, the augmented dataset achieves perfect class balance (ρ=1ρ=1). By Theorem 3, the synthetic samples generated at convergence are drawn from pG≈pdatap_G≈ p_data, ensuring that the balanced dataset preserves the statistical properties of real DDoS traffic rather than introducing distributional artifacts. Corollary 2 establishes that augmentation achieves class balance; the next result quantifies what that balance is worth for generalization by connecting GAN training quality to the downstream classifier through the domain-adaptation bound of Ben-David et al. Theorem 5 (Generalization Gap Controlled by Discriminator Error). Let CψC_ψ be the GCN classifier trained on aug=real∪synD_aug=D_real _syn, and let Rreal(C)R_real(C) be its risk had it trained on an equally sized balanced set of real DDoS graphs. With εD _D the optimal discriminator’s real-vs-synthetic error rate at convergence and λ⋆λ the joint risk of the best classifier over both distributions, Rreal(C)≤Raug(C)+ 2(1−2εD)+λ⋆.R_real(C)\;≤\;R_aug(C)\;+\;2\,(1-2 _D)\;+\;λ . Proof Apply the Ben-David et al. target-risk bound [5] with the augmented distribution as source and the real balanced distribution as target. The ℋΔℋH divergence between the two is estimated by the A-distance d=2(1−2εD)d_A=2(1-2 _D), where εD _D is the error of the optimal real-vs-synthetic discriminator. Substituting yields the bound. As training approaches the equilibrium of Theorem 3 (D⋆→12D \!→\! 12, εD→12 _D\!→\! 12), the divergence term 2(1−2εD)→02(1-2 _D)\!→\!0 and the augmented-data classifier generalizes as well as one trained on real balanced data, up to the irreducible λ⋆λ . This makes the empirical fake detection rate of 45.3% reported in the generator-architecture ablation (Section I) a direct, measurable proxy for the generalization gap. Corollary 3 (Real-Sample Efficiency). Under the coordinated regime of Definition 2, each real DDoS window carries up to m¯ m correlated same-class labels rather than a single independent one. The effective sample size per window is inflated accordingly, so to reach a target risk, the number of real DDoS samples required by graph augmentation is smaller than that required by vector augmentation by the corresponding factor. I-D3 Classification Training Objective The classifier is trained using the cross-entropy loss function, which is well-suited for probabilistic classification tasks and provides gradient information that encourages confident predictions on correctly classified samples while heavily penalizing confident misclassifications. The training objective minimizes the cross-entropy loss over the augmented dataset as ℒC=−1|aug|∑(,y)∈aug∑c=01yclogP(y=c|),L_C=- 1|D_aug| _(G,y) _aug _c=0^1y_c P(y=c|G), (27) where ycy_c represents the one-hot encoding of the true label, such that yc=1y_c=1 if c is the correct class and yc=0y_c=0 otherwise. This formulation ensures that confident, correct predictions yield small updates, while uncertain or incorrect predictions drive stronger corrective updates. Indeed, for the softmax output, the gradient of the cross-entropy loss with respect to the pre-activation logits =CC,pool+Co=W_Ch_C,pool+b_C reduces to the well-known compact form ∂ℒC∂=1|aug|∑(,y)∈aug(P(y∣)−), _C = 1|D_aug| _(G,y) _aug (P(y )-y ), (28) where y is the one-hot label vector. The update is thus proportional to the prediction error P(y∣)−P(y )-y: it vanishes when the predicted distribution matches the true label and grows toward its maximum for confident misclassifications, supplying strong corrective gradients precisely where the classifier errs. I Experimental Results In this section, we present the experimental settings, quantitative results, and comprehensive ablation studies of the proposed GraphGAN framework across four benchmark datasets. I-A Experimental Settings and Datasets We evaluate GraphGAN on four widely used network intrusion detection benchmarks to demonstrate its generalizability: CIC-IDS-2017 contains approximately 2.8 million flow records collected over seven days, encompassing 14 attack types (e.g., DDoS, PortScan, Web Attack, Infiltration, Botnet) and normal flows. Each record includes 80 network flow features. CIC-IDS-2018 extends the 2017 dataset with approximately 16–17 million records collected over 10 days, covering seven attack scenarios, including Brute Force, DoS, DDoS, Web Attack, Infiltration, Botnet, and Heartbleed, and includes 80 extracted flow-level features. UNSW-NB15 comprises approximately 2.5 million records generated in a hybrid real and synthetic environment, containing nine attack categories (Fuzzers, Analysis, Backdoors, DoS, Exploits, Generic, Reconnaissance, Shellcode, Worms) with 49 flow-based and content-based features. ToN-IoT is an IoT/IIoT-focused dataset with approximately 461,000 records collected from heterogeneous IoT services (weather, fridge, garage door, GPS, modbus, light, motion, thermostat), encompassing nine attack types including DDoS, DoS, ransomware, backdoor, injection, XSS, password cracking, scanning, and man-in-the-middle, with 44 features. For all datasets, the GraphGAN framework employs consistent hyperparameters unless otherwise stated. The generator synthesizes node features from Gaussian noise (z=128z=128), while the discriminator operates on graph-structured data using three GCN layers. Graph construction uses k-N with k=5k=5, window size w=30w=30, and step size s=10s=10. The GCN-based classifier uses three graph convolutional layers, followed by global mean pooling and fully connected layers, and is trained with the Adam optimizer (learning rate 0.0010.001), dropout regularization (p=0.3p=0.3), and cross-entropy loss. All models were implemented in PyTorch with the PyTorch Geometric backend and trained on a GPU with a batch size of 3232 for up to 5050 epochs. To prevent temporal leakage arising from overlapping sliding windows (s<ws<w), we order each dataset chronologically and partition the raw flow stream into 60% training, 20% validation, and 20% testing segments before graph construction. Sliding windows are then generated independently within each segment, so that no window crosses a split boundary and no raw flow is shared across splits; a guard band of w flows is discarded at each boundary to eliminate residual overlap. This chronological protocol (training on earlier traffic and testing on later traffic) reflects realistic deployment and avoids the inflated accuracy that random window-level splitting can produce. Performance is evaluated primarily using classification accuracy, while precision, recall, and F1-score are reported in subsequent analyses. We stress that all baselines are re-implemented under an identical, leakage-controlled protocol: the flow stream is ordered chronologically and partitioned before windowing, with a guard band discarded at each boundary. This is a strictly harder evaluation than the random, window-level splits under which several published graph baselines report near-saturated accuracy; accordingly, our reproduced figures for these baselines are lower than their originally reported values, and the gap reflects protocol rigor rather than implementation disadvantage. TABLE I: Comparative analysis of GraphGAN against state-of-the-art methods across four benchmark datasets (test accuracy %). Method CIC-IDS-2017 CIC-IDS-2018 UNSW-NB15 ToN-IoT Causal Deep Learning [42] 82.35 81.23 79.56 80.89 CNN [28] 90.56 89.78 87.34 88.56 GRU-BiLSTM [1] 90.35 89.45 87.12 88.34 SMOTE Oversampling [8] 84.72 84.08 82.19 82.87 Vanilla GAN-based Classifier 86.43 85.67 83.45 84.56 WGAN [3] 88.46 87.92 85.76 86.48 VAE-GAN [36] 89.23 88.64 86.31 87.12 DDP-DAR (Diffusion) [6] 91.48 90.76 88.95 89.62 E-GraphSAGE [25] 92.03 91.35 89.41 90.18 BS-GAT [37] 93.18 92.47 90.86 91.73 Ensemble GNN [4] 92.55 91.89 89.78 90.67 GraphGAN (Proposed) 95.31 94.87 93.42 94.56 I-B Quantitative Results and Analysis To ensure a fair and comprehensive evaluation, we compare GraphGAN against representative state-of-the-art methods spanning different architectural paradigms in network intrusion detection. Causal Deep Learning [42] represents feature-level causal modeling approaches designed to enhance interpretability and robustness. CNN [28] captures spatial correlations in features through convolutional filters and serves as a strong deep learning baseline for tabular traffic data. GRU-BiLSTM [1] models sequential dependencies in traffic flows using recurrent architectures. The Vanilla GAN-based classifier integrates adversarial training without a graph structure to evaluate whether generative augmentation alone is sufficient. Ensemble GNN [4] represents advanced graph-based detection approaches without adversarial augmentation. To stress-test our claims against the strongest generative and graph paradigms, we additionally include: SMOTE oversampling [8] as a classical interpolation-based augmenter; a Wasserstein GAN [3], a VAE-GAN [36], and the diffusion-based DDP-DAR [6] as advanced vectorized generative augmenters; and E-GraphSAGE [25] and BS-GAT [37] as state-of-the-art graph neural baselines. All baselines were implemented using identical preprocessing and data-splitting protocols to ensure a fair comparison. We evaluated all baseline methods and GraphGAN across all four benchmark datasets using 60% of the training data, and the results are shown in Table I. On CIC-IDS-2017, GraphGAN achieves 95.31% accuracy, substantially outperforming all competitors. The pattern is consistent across datasets: GraphGAN attains 94.87% on CIC-IDS-2018, 93.42% on UNSW-NB15, and 94.56% on ToN-IoT. Traditional methods show limited effectiveness across all benchmarks: Causal Deep Learning (79.56%–82.35%), CNN (87.34%–90.56%), GRU-BiLSTM (87.12%–90.35%), and standalone GAN (83.45%–86.43%). Among the baselines, Ensemble GNN is the strongest, achieving 89.78%–92.55% accuracy but remaining 2.76–3.64 percentage points below GraphGAN across all datasets. GraphGAN’s superiority stems from three synergistic innovations: temporal graph construction via k-N topology that captures coordinated attack patterns, adversarial training that generates realistic minority samples while preserving topological relationships, and GCN-based classification that leverages structural patterns for robust boundaries. The consistent improvements across diverse datasets confirm the generalizability of our approach. I-C Necessity of Data Augmentation Using GraphGAN While GraphGAN demonstrates strong overall accuracy, we further investigate whether its advantage stems specifically from adversarial augmentation in the presence of class imbalance. To validate the necessity of adversarial augmentation, we conducted ablation studies on CIC-IDS-2017 across varying class imbalance ratios (1:2, 1:5, 1:10, and 1:20), comparing GraphGAN with full augmentation against baselines without augmentation and with random feature generation. As shown in Table I, GraphGAN consistently outperforms both variants across all metrics. At moderate imbalance (1:2), GraphGAN achieves 95.31% accuracy, a 1.55 point improvement over the non-augmented baseline (93.76%). The performance gap widens dramatically as imbalance intensifies: at 1:10 ratio, GraphGAN maintains 91.82% accuracy while the baseline degrades to 78.91% (12.91 point gap), and at extreme imbalance (1:20), GraphGAN achieves 89.47% compared to 67.23% without augmentation (22.24 point improvement). Random augmentation provides only marginal benefits (2.91 points at 1:20) and fails to capture distributional and topological properties. These results confirm that GraphGAN’s adversarial training generates topology-aware synthetic samples that preserve both statistical fidelity and structural relationships. TABLE I: Quantitative Result of Class Imbalance Ratio for GraphGAN on CIC-IDS-2017 Ratio Model Variant Accuracy Precision Recall F1 Score 1:2 GraphGAN (Full) 95.31 95.58 95.31 95.07 w/o Augmentation 93.76 94.12 93.76 93.52 + Random 93.89 94.28 93.89 93.64 1:5 GraphGAN (Full) 93.58 93.92 93.58 93.41 w/o Augmentation 87.34 88.16 87.34 86.92 + Random 88.12 88.79 88.12 87.68 1:10 GraphGAN (Full) 91.82 92.26 91.82 91.54 w/o Augmentation 78.91 80.47 78.91 78.23 + Random 80.67 81.92 80.67 79.94 1:20 GraphGAN (Full) 89.47 90.15 89.47 89.08 w/o Augmentation 67.23 71.34 67.23 65.87 + Random 70.14 73.28 70.14 68.79 TABLE I: Impact of (a) Graph Construction Method and (b) Pooling Strategy on Accuracy (%) (a) Graph Construction Method CIC17 CIC18 NB15 ToN k-N 95.31 94.87 93.42 94.56 Fully Conn. 92.87 92.34 90.78 91.93 Threshold 91.43 90.91 89.56 90.67 Random 88.76 88.12 87.34 88.45 (b) Pooling Strategy Method CIC17 CIC18 NB15 ToN Mean 95.31 94.87 93.42 94.56 Max 93.78 93.23 91.89 92.78 Sum 92.91 92.34 91.12 92.23 Attention 94.67 94.12 92.78 93.89 I-D Impact of Different Training Ratio To evaluate the robustness and data efficiency of our proposed GraphGAN framework, we conducted experiments with training data ratios ranging from 10% to 90%, while maintaining a consistent test set composition and preserving the original class distribution. As illustrated in Fig. 2, GraphGAN consistently achieves the highest accuracy across all training ratios, with particularly pronounced advantages under low-data regimes, where traditional deep learning approaches experience significant performance degradation. The superior data efficiency stems from a graph construction mechanism that captures stable flow relationships regardless of the training set size, an adversarial augmentation that generates high-quality synthetic samples while preserving topological relationships, and a GCN-based architecture that leverages parameter sharing to improve generalization under data-limited conditions. (a) Accuracy (b) Loss Fig. 2: Impact of training data ratio on (a) accuracy and (b) loss of data-driven methods, including GraphGAN. I-E Impact of Graph Construction Method To validate our k-N graph construction approach, we compared it against alternative graph topologies: (1) fully connected graphs, where all nodes within a temporal window are connected; (2) threshold-based graphs, where edges are formed only if similarity exceeds a fixed threshold; and (3) random graphs with the same average degree. As shown in Table I(a), the k-N approach consistently achieves the highest accuracy across all four datasets, reaching 95.31% on CIC-IDS-2017, 94.87% on CIC-IDS-2018, 93.42% on UNSW-NB15, and 94.56% on ToN-IoT. Fully connected graphs suffer from over-connectivity, which introduces noise (90.78%–92.87%); threshold-based methods fragment the graph into disconnected components (89.56%–91.43%); and random graphs lack meaningful structural information (87.34%–88.76%). The k-N approach optimally balances the preservation of local structure and computational efficiency across diverse network environments. I-F Effect of Window Size and Step Size We investigated the impact of temporal window size w∈10,20,30,40,50w∈\10,20,30,40,50\ and step size s∈5,10,15,20s∈\5,10,15,20\ on detection performance of our proposed method (GraphGAN) across all four datasets. As illustrated in Fig. 3, the configuration w=30w=30 and s=10s=10 yields optimal results across all benchmarks: 95.31% on CIC-IDS-2017, 94.87% on CIC-IDS-2018, 93.42% on UNSW-NB15, and 94.56% on ToN-IoT. Smaller windows (w=10w=10) fail to capture extended attack patterns (89.56%–91.23%), whereas larger windows (w=50w=50) introduce noise from unrelated flows (91.45%–92.67%). Regarding the step size, s=10s=10 provides the best trade-off: excessively large steps (s=20s=20) may miss transitional attack patterns, whereas very small steps (s=5s=5) produce redundant, overlapping windows without significant performance improvement. These trends remain consistent across all datasets. Fig. 3: Effect of (a) window size w and (b) step size s on detection accuracy of our proposed GraphGAN. I-G Importance of the Number of Nearest Neighbors (k) The choice of k in k-N graph construction critically affects the quality of the resulting topology. We evaluated k∈3,5,7,10,15k∈\3,5,7,10,15\ across all four datasets, with results presented in Fig. 4(a). Across all benchmarks, k=5k=5 consistently provides the optimal balance between capturing local neighborhood structure and maintaining graph connectivity, achieving 95.31% on CIC-IDS-2017, 94.87% on CIC-IDS-2018, 93.42% on UNSW-NB15, and 94.56% on ToN-IoT. Lower values (k=3k=3) produce overly sparse graphs with disconnected components (90.67%–92.45%), thereby limiting effective message passing. Higher values (k=15k=15) introduce noisy long-range connections that dilute meaningful local patterns (91.78%–93.78%). The consistent optimality of k=5k=5 across diverse datasets confirms that this connectivity level effectively captures feature-based similarities without degrading graph topology. I-H Analysis of GCN Layer Depth We examined the impact of GCN depth by varying the number of graph convolutional layers in both the discriminator and the classifier from 1 to 5. As shown in Fig. 4(b), the three-layer architecture achieves the highest accuracy across all datasets: 95.31% on CIC-IDS-2017, 94.87% on CIC-IDS-2018, 93.42% on UNSW-NB15, and 94.56% on ToN-IoT. Shallow networks (1–2 layers) capture only immediate neighborhood information, thereby missing multi-hop structural patterns essential for distributed attack detection. Conversely, deeper networks (4–5 layers) suffer from over-smoothing, in which node representations become increasingly indistinguishable, as well as from gradient vanishing effects that impede effective training. The three-layer configuration provides an optimal balance between receptive field expansion and representation discrimination, a finding that remains consistent across all four benchmarks. I-I Study of Generator Architecture Complexity To assess the necessity of the proposed multi-layer generator architecture, we compared variants with different depths: 2-layer (linear output), 3-layer (a 4-layer architecture without one hidden layer), 4-layer (the proposed architecture), and 5-layer. The 4-layer generator produces the highest-quality synthetic samples, as measured by discriminator confusion (45.3% fake detection rate) and downstream classifier performance (95.31% accuracy). Simpler 2-layer generators produce easily distinguishable synthetic samples (78.2% fake detection rate, 89.45% classifier accuracy), while 5-layer generators exhibit training instability and only marginal improvements (47.1% fake detection rate, 94.89% accuracy), indicating diminishing returns beyond four layers. (a) (b) Fig. 4: Effect of hyperparameters on detection accuracy of our proposed GraphGAN: (a) number of nearest neighbors k, and (b) GCN layer depth. I-J Aggregation Function in Graph Pooling We compared different graph-level pooling strategies across all four datasets: global mean pooling (proposed), global max pooling, global sum pooling, and attention-based pooling. As shown in Table I(b), mean pooling consistently achieves the highest accuracy across all benchmarks: 95.31% on CIC-IDS-2017, 94.87% on CIC-IDS-2018, 93.42% on UNSW-NB15, and 94.56% on ToN-IoT. Max pooling (91.89%–93.78%) focuses on extreme features but loses information about overall flow patterns. Sum pooling (91.12%–92.91%) is sensitive to variations in graph size and introduces scale inconsistencies. Attention-based pooling (92.78%–94.67%) shows promise but introduces additional parameters and training complexity without sufficient performance gains to justify the computational overhead. IV Concluding Remarks We introduced GraphGAN, an adversarial graph neural network framework that models network traffic as temporal graphs and employs generative augmentation to address class imbalance and data scarcity in DDoS detection. Through temporal graph construction, adversarial augmentation, and GCN-based classification, GraphGAN achieves superior performance compared to existing CNN-LSTM variants across four diverse benchmarks, including CIC-IDS-2017, CIC-IDS-2018, UNSW-NB15, and ToN-IoT, with consistent improvements in accuracy, precision, and recall. Comprehensive ablation studies confirm the robustness of key design choices, including k-N graph construction, three-layer GCN depth, a noise dimension of 128, and mean pooling, across all evaluated datasets. Key limitations include reliance on feature-similarity assumptions in graph construction and training instabilities inherent to adversarial architectures. A detailed system-architecture instantiation and its runtime/mitigation-cost evaluation are left as future work. Future research directions encompass multi-vector attack classification, hierarchical graph structures, federated learning frameworks, explainable threat attribution mechanisms, and extension to broader network security domains, including encrypted traffic analysis and IoT anomaly detection. Data Availability The datasets analyzed in this study are publicly available benchmark datasets: CIC-IDS-2017, CIC-IDS-2018, UNSW-NB15, and ToN-IoT. Code to reproduce the experiments is available from the authors on reasonable request. References [1] A. M. Al-Eryani, F. A. Omara, and E. Hossny (2025) A deep learning gru-bilstm for ddos attack detection. SN Computer Science 6 (6), p. 605. Cited by: §I-B, TABLE I. [2] M. Antonakakis, T. April, M. Bailey, M. Bernhard, E. Bursztein, J. Cochran, Z. Durumeric, J. A. Halderman, L. Invernizzi, M. Kallitsis, et al. (2017) Understanding the mirai botnet. In 26th USENIX security symposium (USENIX Security 17), p. 1093–1110. Cited by: §I. [3] M. Arafah, I. Phillips, A. Adnane, W. Hadi, M. Alauthman, and A. Al-Banna (2025) Anomaly-based network intrusion detection using denoising autoencoder and wasserstein gan synthetic attacks. Applied Soft Computing 168, p. 112455. Cited by: §I-A, §I-B, §I-B, TABLE I. [4] R. A. Bakar, L. De Marinis, F. Cugini, and F. Paolucci (2024) FTG-net-e: a hierarchical ensemble graph neural network for ddos attack detection. Computer Networks 250, p. 110508. Cited by: §I-A, §I-B, §I-B, TABLE I. [5] S. Ben-David, J. Blitzer, K. Crammer, A. Kulesza, F. Pereira, and J. W. Vaughan (2010) A theory of learning from different domains. Machine Learning 79 (1–2), p. 151–175. External Links: Document Cited by: §I-D2. [6] S. Cai, Y. Zhao, J. Lyu, S. Wang, Y. Hu, M. Cheng, and G. Zhang (2025) DDP-dar: network intrusion detection based on denoising diffusion probabilistic model and dual-attention residual network. Neural Networks 184, p. 107064. Cited by: §I-B, TABLE I. [7] Y. Cao, H. Jiang, Y. Deng, J. Wu, P. Zhou, and W. Luo (2021) Detecting and mitigating ddos attacks in sdn using spatial-temporal graph convolutional network. IEEE Transactions on Dependable and Secure Computing 19 (6), p. 3855–3872. Cited by: §I-B. [8] N. V. Chawla, K. W. Bowyer, L. O. Hall, and W. P. Kegelmeyer (2002) SMOTE: synthetic minority over-sampling technique. Journal of Artificial Intelligence Research 16, p. 321–357. Cited by: §I-A, §I-B, TABLE I. [9] R. K. Chouhan, M. Atulkar, and N. K. Nagwani (2023) A framework to detect ddos attack in ryu controller based software defined networks using feature extraction and classification. Applied Intelligence 53 (4), p. 4268–4288. Cited by: §I-B. [10] M. Defferrard, X. Bresson, and P. Vandergheynst (2016) Convolutional neural networks on graphs with fast localized spectral filtering. Advances in neural information processing systems 29. Cited by: §I-C2. [11] G. Duan, H. Lv, H. Wang, and G. Feng (2022) Application of a dynamic line graph neural network for intrusion detection with semisupervised learning. IEEE Transactions on Information Forensics and Security 18, p. 699–714. Cited by: §I-B. [12] M. S. El Sayed, N. Le-Khac, M. A. Azer, and A. D. Jurcut (2022) A flow-based anomaly detection approach with feature selection method against ddos attacks in sdns. IEEE Transactions on Cognitive Communications and Networking 8 (4), p. 1862–1880. Cited by: §I-B, §I-B. [13] I. J. Goodfellow, J. Pouget-Abadie, M. Mirza, B. Xu, D. Warde-Farley, S. Ozair, A. Courville, and Y. Bengio (2014) Generative adversarial nets. Advances in neural information processing systems 27. Cited by: Theorem 2, Theorem 3. [14] J. He, W. Fang, X. Lan, G. Yang, Z. Chen, Y. Chen, T. Li, and J. Chen (2024) Efficient based on improved random forest defense system against application-layer ddos attacks. International Journal of Intelligent Systems 2024 (1), p. 9044391. Cited by: §I-B. [15] M. A. Hossain and N. Ansari (2023) Hybrid multiple access for network slicing aware mobile edge computing. IEEE Transactions on Cloud Computing 11 (3), p. 2910–2921. Cited by: §I. [16] M. A. Hossain, A. R. Hossain, W. Liu, N. Ansari, A. Kiani, and T. Saboorian (2023) A decentralized collaborative learning approach in 5G+ core networks. IEEE Network 38 (1), p. 288–295. Cited by: §I-B, §I. [17] M. A. Hossain, W. Liu, and N. Ansari (2024) Computation-efficient offloading and power control for mec in iot networks by meta-reinforcement learning. IEEE Internet of Things Journal 11 (9), p. 16722–16730. External Links: Document Cited by: §I-B. [18] M. A. Hossain, N. Sadat, N. Ansari, and F. Amsaad (2026) Split learning over noma-enabled hetnets for scalable iot-based precision agriculture. IEEE Transactions on Cognitive Communications and Networking 12 (), p. 7145–7156. External Links: Document Cited by: §I. [19] G. A. Jaafar, S. M. Abdullah, and S. Ismail (2019) Review of recent detection methods for http ddos attack. Journal of Computer Networks and Communications 2019 (1), p. 1283472. Cited by: §I. [20] S. Kullback and R. A. Leibler (1951) On information and sufficiency. The Annals of Mathematical Statistics 22 (1), p. 79–86. External Links: Document Cited by: Theorem 4. [21] J. Li, L. Lyu, X. Liu, X. Zhang, and X. Lyu (2021) FLEAM: a federated learning empowered architecture to mitigate ddos in industrial iot. IEEE Transactions on Industrial Informatics 18 (6), p. 4059–4068. Cited by: §I-B. [22] Y. Li, R. Li, Z. Zhou, J. Guo, W. Yang, M. Du, and Q. Liu (2022) Graphddos: effective ddos attack detection using graph neural networks. In 2022 IEEE 25th International Conference on Computer Supported Cooperative Work in Design (CSCWD), p. 1275–1280. Cited by: §I-B. [23] W. Liu, M. Arif Hossain, and N. Ansari (2025) Mobile-edge computing for multi-services digital twin-enabled iot heterogeneous networks. IEEE Transactions on Cognitive Communications and Networking 11 (3), p. 1845–1853. External Links: Document Cited by: §I. [24] W. Liu, M. A. Hossain, N. Ansari, A. Kiani, and T. Saboorian (2024) Reinforcement learning-based network slicing scheme for optimized ue-qos in future networks. IEEE Transactions on Network and Service Management 21 (3), p. 3454–3464. External Links: Document Cited by: §I. [25] W. W. Lo, S. Layeghy, M. Sarhan, M. Gallagher, and M. Portmann (2022) E-graphsage: a graph neural network based intrusion detection system for iot. In NOMS 2022-2022 IEEE/IFIP network operations and management symposium, p. 1–9. Cited by: §I-B, §I-B, TABLE I. [26] Y. Luo, M. He, and X. Wang (2025) ERFS: efficient feature graph representation for intrusion detection based on flow semantic association. IEEE Transactions on Cognitive Communications and Networking 11 (6), p. 3711–3728. External Links: Document Cited by: §I. [27] A. Mustapha, R. Khatoun, S. Zeadally, F. Chbib, A. Fadlallah, W. Fahs, and A. El Attar (2023) Detecting ddos attacks using adversarial neural network. Computers & Security 127, p. 103117. Cited by: §I-B. [28] A. A. Najar and S. M. Naik (2024) Cyber-secure sdn: a cnn-based approach for efficient detection and mitigation of ddos attacks. Computers & Security 139, p. 103716. Cited by: §I-B, TABLE I. [29] N. Nishanth and A. Mujeeb (2021) Modeling and detection of flooding-based denial of service attacks in wireless ad hoc networks using uncertain reasoning. IEEE Transactions on Cognitive Communications and Networking 7 (3), p. 893–904. External Links: Document Cited by: §I-B. [30] Y. Qing, X. Liu, and Y. Du (2024) Mitigating data imbalance to improve the generalizability in iot ddos detection tasks. The Journal of Supercomputing 80 (7), p. 9935–9960. Cited by: §I-A. [31] D. M. Rajan and D. J. Aravindhar (2023) Detection and mitigation of DDoS attack in SDN environment using hybrid CNN-LSTM. Migration Letters 20, p. 407–419. Cited by: §I-B. [32] M. S. E. Sayed, N. Le-Khac, M. A. Azer, and A. D. Jurcut (2022) A flow-based anomaly detection approach with feature selection method against ddos attacks in sdns. IEEE Transactions on Cognitive Communications and Networking 8 (4), p. 1862–1880. External Links: Document Cited by: §I. [33] H. Sedjelmaci and N. Ansari (2024) Zero trust architecture empowered attack detection framework to secure 6g edge computing. IEEE Network 38 (1), p. 196–202. External Links: ISSN 0890-8044, Document Cited by: §I. [34] A. Shahraki, M. Abbasi, A. Taherkordi, and A. D. Jurcut (2022) Active learning for network traffic classification: a technical study. IEEE Transactions on Cognitive Communications and Networking 8 (1), p. 422–439. External Links: Document Cited by: §I. [35] C. Shieh, T. Nguyen, W. Lin, Y. Huang, M. Horng, T. Lee, and D. Miu (2022) Detection of adversarial ddos attacks using generative adversarial networks with dual discriminators. Symmetry 14 (1), p. 66. Cited by: §I-B. [36] W. Tian, Y. Shen, N. Guo, J. Yuan, and Y. Yang (2024) VAE-wacgan: an improved data augmentation method based on vaegan for intrusion detection. Sensors 24 (18), p. 6035. Cited by: §I-A, §I-B, §I-B, TABLE I. [37] Y. Wang, Z. Han, Y. Du, J. Li, and X. He (2025) BS-gat: a network intrusion detection system based on graph neural network for edge computing. Cybersecurity 8 (1), p. 27. Cited by: §I-B, §I-B, TABLE I. [38] Y. Wang, X. Zhang, Y. Lai, Z. Zhao, and Y. Deng (2025) Hifoots: a highly efficient ddos attack detection scheme deployed in smart iot homes. IEEE Transactions on Cognitive Communications and Networking 11 (1), p. 519–533. External Links: Document Cited by: §I. [39] K. Xu, W. Hu, J. Leskovec, and S. Jegelka (2018) How powerful are graph neural networks?. arXiv preprint arXiv:1810.00826. Cited by: Proposition 2. [40] K. Yang, J. Wang, and M. Li (2024) An improved intrusion detection method for IIoT using attention mechanisms, bigru, and inception-cnn. Scientific Reports 14 (1), p. 19339. Cited by: §I-B. [41] S. T. Zargar, J. Joshi, and D. Tipper (2013) A survey of defense mechanisms against distributed denial of service (ddos) flooding attacks. IEEE communications surveys & tutorials 15 (4), p. 2046–2069. Cited by: §I. [42] Z. Zeng, W. Peng, and D. Zeng (2022) Improving the stability of intrusion detection with causal deep learning. IEEE Transactions on Network and Service Management 19 (4), p. 4750–4763. Cited by: §I-B, TABLE I. [43] G. Zhao, P. Liu, K. Sun, Y. Yang, T. Lan, and H. Yang (2023) Research on data imbalance in intrusion detection using cgan. Plos one 18 (10), p. e0291750. Cited by: §I-A, §I-B. [44] M. Zhong, M. Lin, C. Zhang, and Z. Xu (2024) A survey on graph neural networks for intrusion detection systems: methods, trends and challenges. Computers & Security 141, p. 103821. Cited by: §I-A, §I-B, §I-B.