CERO: Cascade-Emergency Resilient Offloading for IIoT Edge Computing via Adversarial Deep Reinforcement Learning

Abstract

Industrial Internet of Things (IIoT) edge computing supports latency-sensitive services through task offloading to distributed edge resources. However, large-scale emergencies such as node failures and traffic surges may trigger cascading failures, leading to severe performance degradation and poor post-crisis recovery. Existing offloading methods mainly optimize operational efficiency under normal conditions while overlooking resilience against cascading disruptions. To address this issue, we propose Cascade-Emergency Resilient Offloading (CERO), an adversarial deep reinforcement learning framework for resilient task offloading in IIoT edge computing. Distinct from existing works, CERO introduces a structure-aware shared node encoder to capture heterogeneous topological roles of edge nodes, providing critical structural information for cascade-aware decision making, and incorporates cascade-oriented adversarial training to enhance robustness against compound disturbances. CERO integrates structure-aware state representation, minimax adversarial training, and potential-based reward shaping to learn resource-allocation policies balancing task efficiency and system resilience. By interacting with dynamically generated crisis scenarios, the agent learns resilient offloading policies and achieves high post-crisis recovery performance after cascading disruptions. All performance evaluations are conducted via discrete-event simulation experiments. Simulation results for normal, single-crisis, and compound-crisis scenarios show that CERO achieves comparable task efficiency under normal conditions and significantly superior post-crisis recovery performance compared to conventional rule-based strategies. In the hardest compound-crisis case involving simultaneous node failures and load surges, CERO achieves a post-recovery task-completion rate of 97.8%, surpassing the best rule-based baseline by more than 63 percentage points. Statistical significance is confirmed by the Wilcoxon signed-rank test with Bonferroni correction over 10 independent runs. These results demonstrate that CERO effectively improves the robustness and recoverability of IIoT edge-computing systems under cascading emergency scenarios.

1. Introduction

The IIoT takes edge computing as one of its core technical pillars [1]. With this technical support, real-time data processing and decision-making can be implemented locally at the network edge. This paradigm offloads computation-intensive tasks from resource-constrained devices to nearby edge servers, which significantly reduces the end-to-end latency compared to traditional cloud-centric architectures [2]. But edge environments are inherently fragile. Unlike cloud data centers with redundant infrastructure, edge servers have limited power, cooling, and computing resources. When one edge server gets overloaded (due to load surge or hardware degradation), its tasks need to be distributed to its neighboring nodes. Such redistribution may lead to a domino effect of cascading failures, as the overload propagates through dependency links [3]. Cascade dynamics can be especially hazardous in IIoT emergency cases where critical operations (e.g., safety shutdowns, fire suppression) are on tight schedules and failures may cause disastrous outcomes.

In recent years, many research works have been devoted to task offloading optimization with different objectives, including energy minimization [4], delay reduction [5,6], and resource utilization [7]. Hybrid metaheuristics, including IGWO-SOA [4], game-theoretic models [8,9], and deep reinforcement learning (DRL) frameworks [10,11], have demonstrated significant improvements in controlled environments.

Nevertheless, the overwhelming majority of existing methods operate under the assumption of a stationary operating environment or treat node failures as mutually independent events. They do not explicitly model the propagation of stress over the dependency graph of the system. Therefore, even the state-of-the-art DRL policies are reactive; they make decisions based only on instantaneous node metrics such as queue length, CPU utilization and health status, and cannot predict which nodes will experience stress escalation in subsequent time slots as cascading effects propagate through the network. This leads to a severe performance degradation deep in the system recovery phase in the existing policies when facing compound emergency scenarios, such as concurrent load surges and node failures.

Cascading failures in interdependent networks, such as power systems and infrastructure networks, have been widely studied [12]. In edge computing, Xing et al. [13] introduced a Susceptible-Infected-Recovered (SIR) model to characterize the spread of overload among edge servers. However, these works treat cascading dynamics as an analytical property to be evaluated, not as an adversarial disturbance to be mitigated via learning. Meanwhile, robust reinforcement learning has emerged as a paradigm to train agents that perform well under worst-case perturbations [14]. The Stackelberg game formulation, where a leader (agent) and a follower (adversary) optimize opposing objectives, has been successfully applied to multi-agent and single-agent robust control [15]. Yet, to our knowledge, no prior work has combined a structure-aware DRL architecture with adversarial cascade training for emergency offloading.

To fill this gap, we propose CERO, a novel dueling Deep Q-Network with three key innovations:

• Node-Shared Structural Encoder: Instead of flattening state vectors, CERO encodes each edge server’s feature (stress, queue, CPU, health) through a shared Multi-Layer Perceptron (MLP), producing per-node embeddings that capture relative node semantics. This design reduces the dependency on fixed node ordering and enables topology-aware representation learning across heterogeneous edge nodes. Such structural abstraction provides essential state information for resilient offloading decisions under cascading failures.
• Stackelberg Adversarial Training: We model the environment as a two-layer adversary, which (i) globally increases the cascade propagation coefficient $\beta$, and (ii) selectively increases the stress of the node chosen by the agent. The Minimax Temporal Difference (TD) target improves the robustness of the learned Q-function against worst-case cascade triggers, enabling the policy to better adapt to compound disturbances and emergency operating conditions.
• Potential-Based Reward Shaping: We design a system-health potential function that captures the global operational condition of the edge network. Based on the PBRS framework, a shaping reward term is incorporated to provide dense learning feedback and accelerate convergence while preserving policy optimality.

We evaluate CERO on a realistic 12-node edge computing topology (8 edge servers, 3 switches, and 1 PSU) with SIR cascade dynamics. Under normal conditions, CERO achieves a key task completion rate (KR) of 88.6%, which is statistically comparable to the best rule-based policy (89.4%). Under a combined crisis, the best-performing rule-based policy achieves only 34.7% post-recovery KR, whereas CERO maintains 97.8%, representing an improvement of more than 63 percentage points. These results demonstrate that the combination of topology-aware state representation, robust adversarial training, and adaptive reinforcement learning enables CERO to maintain critical task execution and recover effectively from cascading disruptions in IIoT edge computing environments.

The remainder of this paper is organized as follows. Section 2 reviews related work. Section 3 describes the system model, including the dependency graph, task model, and cascading failure dynamics. Section 4 presents the CERO algorithm and its theoretical properties. Section 5 reports experimental results. Section 6 concludes the paper.

2. Related Work

This section reviews three relevant research threads supporting our work: task offloading in edge and fog computing, cascading failures and robustness in networked systems, and adversarial as well as reward-shaped reinforcement learning. We identify key gaps in existing studies that motivate the proposed CERO framework, with references to both foundational works and the latest research advances where appropriate.

2.1. Task Offloading in Edge Computing: Recent Advances

As a core technique to mitigate latency and cut energy overhead for mobile and IoT devices, task offloading has been widely explored in existing studies. Early optimization-driven methods model offloading as a mixed-integer nonlinear programming (MINLP) problem solved by branch-and-bound or convex relaxation [16], yet they fail to cope with the stochastic and time-varying nature of practical workloads.

2.1.1. Hybrid Metaheuristics and Bio-Inspired Methods

The light computational properties and practical implementability of metaheuristic algorithms mean they are often used in solving edge offloading tasks.

Rao and Babu [4] proposed a hybrid optimization framework IGWO-SOA based on the improved grey wolf optimization (GWO) and seagull optimization algorithm (SOA) to optimize the energy-latency tradeoff in 5G-IoT-enabled MEC systems. The experimental results indicate that the developed hybrid scheme has a better performance than the traditional PSO and vanilla GWO in balancing the system energy consumption and service delay. Recently, Almulifi and Kurdi have proposed a novel lemur-inspired optimization framework (LITO) for edge scheduling [7]. The framework enables distributed edge devices with very fast decision trees (VFDT) and primary edge nodes with continual supervised policy learning capabilities, which leads to energy savings of up to 60% and better resource utilization efficiency. Chen et al. [17] proposed a two-stage Q-Network optimization (TS-QNO) architecture for offloading optimization in continuous casting production scenarios, which decomposes the entire offloading problem into two successive subproblems, i.e., edge node selection and task offloading ratio optimization. Although such metaheuristic and hybrid learning methods have shown promising empirical performance in routine offloading scenarios, they suffer from a common technical gap. These approaches fail to model the mutual stress propagation and topological correlation among edge nodes, and they rely on the ideal assumption that network environments evolve slowly and independently. Such simplifications limit their ability to adapt scheduling decisions when resource states evolve jointly with network dependencies.

2.1.2. Deep Reinforcement Learning for Offloading

Deep reinforcement learning (DRL) has become a dominant adaptive optimization approach for dynamic task offloading in mobile edge computing. As a pioneering work, Mnih et al. [18] validated the powerful representation and decision-making capability of the deep Q-Network (DQN) by achieving human-level performance in Atari game environments, which greatly motivates the extensive application of DQN-based algorithms in MEC offloading scenarios.

Huang et al. [19] applied the DQN framework to jointly optimize the task offloading strategies and the wireless bandwidth allocation, achieving the collaborative resource scheduling for the edge systems. Lu et al. [20] designed a light-weight DRL optimization framework by integrating the real-time task queue status and wireless channel quality to adapt offloading decisions for time-varying network conditions. In the context of internet of vehicles scenarios, Mohammad et al. [21] combined DRL with particle swarm optimization to reduce service latency and improve offloading efficiency. Anand and Karthikeyan [6] proposed the AICDQN algorithm by embedding GRU-LSTM-based load prediction into a dueling double DQN (D4QN) structure, and priority-aware M/M/c queuing theory to improve the adaptability of offloading scheduling. Dai et al. [11] proposed a federated DRL paradigm for digital twin-enabled edge networks. In this paradigm, global agents are responsible for unified edge resource allocation, and local agents dynamically determine the ratios of task offloading. Deng et al. [5] compared the performance of Q-learning and DDPG methods for industrial Internet of Things (IIoT) partial offloading scenarios. The results show that DRL algorithms with continuous action spaces can reduce the system latency by 30% compared to traditional binary offloading strategies.

Zhou et al. [22] further applied DRL to the energy-saving offloading optimization, and improved the energy efficiency of edge resource scheduling. Existing DRL-based offloading methods have achieved fruitful results. However, they have an essential limitation in system state modeling.

Most existing studies flatten the high-dimensional system state into a simple vector format and fail to explicitly characterize the topological dependency relationships among distributed edge nodes. Such state representation mechanisms are not able to distinguish between nodes with similar instantaneous operational metrics but different positions in the topology and importance for the system. This intrinsic defect is insignificant in normal operating conditions but becomes extremely critical when cascading failures and stress propagation happen, which greatly impairs the system’s emergency robustness and adaptive scheduling capability.

2.1.3. Game Theoretic and Optimization-Based Approaches

Game theory is one of the most widely used analytical tools to model the competitive and cooperative interactions of edge network nodes. Tong et al. [8] designed a Stackelberg game for optimizing cloud-edge collaboration, proved the existence of Nash equilibrium solutions, and reduced the operational cost of mobile devices by up to 49.8%. Zhang et al. [9] further modeled the device-to-device (D2D)-enabled three-tier task offloading paradigm as an exact and developed the E-DTOSS algorithm, which guarantees convergence to a pure-strategy Nash equilibrium. Focusing on non-orthogonal multiple access enabled unmanned aerial vehicle (UAV) maritime emergency communication scenarios, Lyu et al. [23] integrated coalition game theory with convex optimization techniques to substantially reduce computational overhead. Wu et al. [24] extended game-theoretic offloading optimization. They applied the framework to multi-cell networks under collaborative cloud-edge architectures. Existing game-based strategies can guarantee convergence, yet they universally assume fully rational participants with complete or perfect system information. These idealized assumptions break down in cascading emergency scenarios. Dynamic stress propagation in such scenarios induces non-stationary system variations and adversarial operational characteristics.

2.1.4. Specialized Domains: Digital Twin, DDoS, and Resilience

Liu et al. [25] combine digital twin and blockchain technologies. They provide a secure collaborative computing mechanism for edge scenarios. They adopt decision trees and the double deep Q-Network, or DDQN, for system optimization. The scheme cuts down both power consumption and service latency. Lin et al. [26] investigate emergency computation offloading for virtual power plants. Their research targets scenarios under DDoS attack threats. The authors verify the submodular property of the formulated problem. They develop high-efficiency heuristic solutions accordingly. This method has a much lower computational overhead than the traditional DRL-based ones. This work also addresses emergency edge computing scenarios. It however centers on DDoS attack mitigation. It does not explore the cascading stress propagation discussed in this paper. DerakhshanFard et al. [27] proposed a lightweight decision tree model for energy- and delay-aware offloading, achieving 96% task offloading success rate but without any learning of temporal dependencies. Jiang et al. [28] developed a hierarchical model for UAV-assisted MEC that supports task interruption and resumes due to UAV movement, deriving performance metrics for delay and rejection probability. While these works address specific resilience challenges (security, mobility, production continuity), none of them explicitly model cascade propagation as a learned adversarial process.

2.2. Cascading Failures and Robustness in Networked Systems

The study of cascading failures originated in power grid analysis.

Buldyrev et al. [12] verified the extreme susceptibility of interdependent network systems (e.g., coupled power grids and communication infrastructures) to cascading failures. Even failures affecting only a small fraction of the network nodes are capable to trigger total collapse of the whole system. This seminal work lays the foundation for subsequent research on failure cascade modeling. These follow-up studies are built upon percolation theory and generalized SIR-type propagation dynamics.

Within the edge computing domain, Ren et al. [29] modified the classic SIR epidemic model to characterize the spread of overload incidents across interconnected edge servers. They defined three states (healthy, stressed, failed) and derived conditions under which cascades are contained or become catastrophic. Though this analytical model yields insightful theoretical conclusions, it has not yet been embedded within an online decision-making architecture. However, existing cascade models are mainly used for analysis and evaluation, rather than being integrated into adaptive task scheduling mechanisms. Such treatments overlook inter-failure correlations that exacerbate cascading stress buildup across the system.

Research has also investigated edge computing robustness against distributed denial-of-service (DDoS) intrusions and resource depletion scenarios. To withstand failures of a limited number of nodes, scholars have developed heuristic backup policies and redundant deployment mechanisms. Nevertheless, these solutions generally follow static designs and fail to capture evolving stress propagation dynamics for adaptive learning. We integrate a threshold-driven cascade model with SIR-inspired three-state classification into both the reward and transition dynamics of a DRL-based offloading framework, enabling proactive learning under cascading failure scenarios.

2.3. Adversarial and Robust Reinforcement Learning

Robust RL aims to learn policies that perform well under worst-case environmental perturbations. Pinto et al. [14] proposed the robust adversarial reinforcement learning paradigm. This framework implements co-training for two agents. One is the primary protagonist agent. The other is an adversarial agent. The adversarial agent injects disturbance forces into system dynamics. The authors verified that RARL generates policies with much stronger robustness to model misspecification than standard RL.

The Stackelberg game formulation has been used to model sequential decision-making with an adversary. Li et al. [15] proposed Minimax DQN, where the Q-function is trained to minimize the worst-case return over a set of adversarial state perturbations. This approach was shown to improve robustness against small, bounded perturbations (e.g., ${\ell }_2$ or ${\ell }_{\infty }$ norm balls). However, these generic perturbation models are not aligned with the physical mechanisms of cascading failures. In CERO, we design an adversary that respects the cascade dynamics: it amplifies the propagation coefficient $\beta$ and selectively attacks the node chosen by the agent. This domain-specific adversarial model produces policies that are robust against realistic emergency scenarios rather than arbitrary noise.

2.4. Potential-Based Reward Shaping

Potential-based reward shaping (PBRS) has become an effective technique for accelerating reinforcement learning by providing dense intermediate rewards while preserving policy optimality. Unlike heuristic reward engineering, PBRS guarantees that the optimal policy of the original Markov Decision Process remains unchanged.

Grzes et al. [30] established the theoretical foundation of PBRS by introducing a shaping reward based on a state potential function. Subsequent studies demonstrated that PBRS can significantly improve learning efficiency in sparse-reward environments while maintaining convergence properties.

The shaping reward $F(s,s^{\prime })$ is generally defined as

$$F(s,s^{\prime })=\gamma \Phi \left(s^{\prime }\right)-\Phi \left(s\right),$$

(1)

where $\Phi (·)$ denotes a state potential function.

PBRS has been successfully applied to robotics, autonomous control, game playing, and sequential decision-making tasks. However, its application to cascading-failure-aware edge computing environments remains largely unexplored.

In this work, we construct a system-health potential function that captures node stress, queue occupancy, resource utilization, and failure status. The resulting shaping reward provides dense learning feedback for emergency task offloading under cascading failures.

2.5. Summary of Contributions Relative to Prior Art

In summary, as shown in

Table 1. Comparison of representative offloading and robust RL methods.

Method Category	State Representation	Core Objective	Perturbation Form	Cascade Resilience
Rule-based heuristics	Real-time status scoring	Normal efficiency	None	Reactive response only
Conventional DRL offloading	Flat state vector	Normal efficiency	None	Reactive response only
General robust RL	Flat state vector	Noise robustness	Generic norm-bounded	No targeted cascade adaptation
CERO (ours)	Structure-aware shared encoding	Efficiency + cascade resilience	Domain-specific two-layer adversarial	Proactive cascade suppression

, existing task offloading solutions, including classic DRL models, hybrid metaheuristic algorithms, and game-theoretic frameworks, fail to explicitly model cascading failure propagation. Most DRL-based offloading studies adopt flat state representations and overlook inter-node dependency graphs; they mainly optimize normal-state efficiency and respond only reactively to failures, lacking proactive cascade suppression capability. General robust reinforcement learning approaches improve policy robustness via generic norm-bounded perturbations, which are decoupled from physical failure mechanisms and mainly resist random noise rather than realistic industrial cascading events.

To fill these gaps, we propose the CERO framework with a structure-aware shared node encoder and a domain-specific two-layer adversarial training mechanism. It is designed as a dedicated emergency offloading solution for cascading failure scenarios, integrating structure-aware state representation, cascade-oriented adversarial training, and potential-based reward shaping.

3. System Model

3.1. Topology and Dependency Graph

We model an IIoT edge computing system as a graph $\mathcal{G}=(\mathcal{V},\mathcal{E})$, where $\mathcal{V}={\mathcal{V}}_E\cup {\mathcal{V}}_S\cup {\mathcal{V}}_P$ comprises three node types:

• ${\mathcal{V}}_E=\{e_1,\dots ,e_N\}$: $N=8$ edge servers with heterogeneous CPU capacity $C_i\sim \mathcal{U}(3,30)$ and memory $M_i\sim \mathcal{U}(10,400)$.
• ${\mathcal{V}}_S=\{s_1,s_2,s_3\}$: Network switches providing inter-edge connectivity.
• ${\mathcal{V}}_P=\left\{p_1\right\}$: Power supply unit (PSU), whose degradation affects all dependent nodes.

The edge set $\mathcal{E}$ describes functional dependency relations in the system. An edge server relies on connected switches and power supply unit for normal operation. This dependency structure forms propagation channels across the network. It allows stress and failures to spread in a cascading manner. Total graph nodes: $\left|\mathcal{V}\right|=12$.

3.2. Task Model

Tasks arrive at each time slot following a Poisson process with rate $\lambda =4.0$. A task ${\tau }_k$ is characterized by:

• Priority: ${\rho }_k\in \{1,2,3,4\}$, where ${\rho }_k=1$ denotes key tasks (20% of arrivals).
• Computational requirement: ${\mathrm{cpu}}_k\sim \mathcal{U}(1,3)$.
• Data size: ${\mathrm{data}}_k\sim \mathcal{U}(0.5,5.0)$ (MB).
• Deadline: ${\mathrm{m}\mathrm{a}\mathrm{x}\text{\_}\mathrm{d}\mathrm{e}\mathrm{l}\mathrm{a}\mathrm{y}}_k\sim \mathcal{U}(0.6,1.6)$ (seconds).

The action space is $\mathcal{A}=\{0,1,\dots ,N,N+1\}$: $a=0$ (local), $a\in \{1,\dots ,N\}$ (edge server $e_a$), $a=N+1$ (cloud).

For task execution and queue management, we define the following system dynamics. Each edge node maintains a first-come-first-served queue, whose length updates as:

$$q_i(t+1)=max\left(0,q_i\left(t\right)+a_i\left(t\right)-{\mu }_i\left(t\right)·\Delta t\right)$$

(2)

where $a_i\left(t\right)$ is the number of arriving tasks at node i in slot t, $\Delta t$ is the time slot duration, and ${\mu }_i\left(t\right)$ is the real-time service rate. The service rate degrades with node stress level:

$${\mu }_i\left(t\right)={\mu }_i^0·\left(1-{\sigma }_i\left(t\right)\right)$$

(3)

where ${\mu }_i^0$ is the maximum service rate in healthy state, and ${\sigma }_i\left(t\right)$ is the normalized stress level defined in Equation (5).

Local execution delay for a task with computation load l at node i is $d_{\mathrm{local}}=l/{\mu }_i\left(t\right)$. Cloud execution incurs additional transmission overhead, with total delay:

$$d_{\mathrm{cloud}}=d_{\mathrm{trans}}+{\displaystyle \frac{l}{{\mu }_c}}+{\displaystyle \frac{q_c\left(t\right)}{{\mu }_c}}$$

(4)

where $d_{\mathrm{trans}}$ is fixed edge-to-cloud transmission delay, ${\mu }_c$ is the cloud service rate, and $q_c\left(t\right)$ is the cloud queue length.

When tasks are redirected from a failed node, a fixed migration delay penalty $d_{\mathrm{mig}}$ is incurred for state transfer and re-queuing. If a queue reaches its maximum capacity $Q_{max}$, tasks are dropped in ascending order of priority to retain key task execution. For multi-task processing, multiple tasks arrive per slot following the Poisson process. The scheduling action (target node selection) is executed sequentially for each task within the slot; each task independently selects its execution node under the unified action space definition.

3.3. Threshold-Driven Cascading Failure Model

We adopt a threshold-driven cascading failure model with three node states, drawing on the SIR epidemic framework for state classification. Different from the classic SIR model which relies on probabilistic infection transmission, state transitions in our model are fully triggered by stress thresholds. The three-state paradigm originates from cascading failure studies in interdependent infrastructure networks [12] and has been widely validated in edge computing scenarios [13,29]. Figure 1 illustrates the corresponding propagation mechanism.

Each edge server i can be in one of three states:

• $s_i=0$ (Healthy): Full service capacity.
• $s_i=1$ (Stressed): Capacity reduced; execution slows down.
• $s_i=2$ (Failed): No service; queued tasks redirected to cloud with migration penalty.

The stress level ${\sigma }_i^{\left(t\right)}$ of edge server i at time slot t is:

$${\sigma }_i^{\left(t\right)}=\alpha ·{\ell }_i^{\left(t\right)}+\beta ·{\displaystyle \frac{{\sum }_{j\in \mathcal{N}\left(i\right)}{\sigma }_j^{(t-1)}}{\left|\mathcal{N}\right(i\left)\right|}}+{\gamma }_{\mathrm{psu}}·(1-h_{\mathrm{psu}})+{ϵ}_i$$

(5)

where:

• $\mathcal{N}\left(i\right)$ denotes the set of direct neighbors of node i in the system dependency graph, and $\left|\mathcal{N}\right(i\left)\right|$ is the cardinality of the neighbor set;
• $\alpha$ is the weight coefficient of local load on node stress;
• $\beta$ is the inter-node cascade propagation coefficient;
• ${\gamma }_{\mathrm{psu}}$ is the PSU degradation coupling coefficient;
• ${\ell }_i^{\left(t\right)}$ is the normalized local load level of node i;
• $h_{\mathrm{psu}}$ represents the health state of the shared power supply unit, which decays gradually over time;
• ${ϵ}_i$ is Gaussian noise capturing random stress fluctuations in real systems.

The model covers two shared-resource cascade channels widely existing in real IIoT systems: (i) the global PSU term uniformly elevates stress of all dependent nodes, modeling shared power supply degradation; (ii) neighbor-wise propagation implicitly captures shared switch bandwidth contention, as co-located nodes compete for upstream network resources. This extends pure topological adjacency propagation to realistic shared-infrastructure cascade effects.

All model parameters are calibrated within typical ranges reported in cascading failure literature and fine-tuned via preliminary simulations to generate realistic gradual cascade dynamics.

State transitions follow threshold-based rules:

$$s_i^{(t+1)}=\left\{\begin{array}{cc}0\to 1,\hfill & \mathrm{if}{\sigma }_i^{\left(t\right)}\ge {\theta }_{\mathrm{stress}}\hfill \\ 1\to 2,\hfill & \mathrm{if}{\sigma }_i^{\left(t\right)}\ge {\theta }_{\mathrm{fail}}\hfill \\ 1\to 0,\hfill & \mathrm{if}{\sigma }_i^{\left(t\right)}<0.6·{\theta }_{\mathrm{stress}}\wedge \mathrm{rand}\left(\right)<p_{\mathrm{recov}}\hfill \\ 2\to 1,\hfill & \mathrm{if}{\sigma }_i^{\left(t\right)}<{\theta }_{\mathrm{stress}}\wedge \mathrm{rand}\left(\right)<p_{\mathrm{reboot}}\hfill \end{array}\right.$$

(6)

where ${\theta }_{\mathrm{stress}}$ and ${\theta }_{\mathrm{fail}}$ are stress and failure thresholds, and $p_{\mathrm{recov}}$, $p_{\mathrm{reboot}}$ are probabilistic recovery rates. The cascade model is non-monotonic—a node’s stress depends on its neighbors’ states, creating a positive feedback loop where failures cluster in the dependency graph.

3.4. Markov Decision Process Formulation

The offloading problem is formulated as a Markov Decision Process (MDP) $\langle \mathcal{S},\mathcal{A},\mathcal{P},\mathcal{R},\gamma \rangle$ with discount factor $\gamma$ controlling the weight of future returns.

State $\mathcal{S}$: The structured state $s^{\left(t\right)}$ has four components:

• Node features $\mathbf{F}\in {\mathbb{R}}^{N\times 4}$: Per-edge $[{\sigma }_i,q_i/Q_{max},u_i^{\mathrm{CPU}},{\mathbf{1}}_{s_i=2}]$.
• Global $\mathbf{g}\in {\mathbb{R}}^5$: $[{\beta }_{\mathrm{eff}},h_{\mathrm{psu}},n_{\mathrm{failed}},{\rho }_{\mathrm{task}},{\mathrm{data}}_{\mathrm{task}}]$.
• Cloud $\mathbf{c}\in {\mathbb{R}}^2$: $[q_{\mathrm{cloud}}/Q_{max},d_{\mathrm{cloud}}]$.
• Local $\mathbf{l}\in {\mathbb{R}}^1$: $[q_{\mathrm{local}}/Q_{max}]$.

Since multiple tasks arrive in one time slot following Poisson distribution, ${\rho }_{\mathrm{task}}$ and ${\mathrm{data}}_{\mathrm{task}}$ adopt the average feature of all arrived tasks in the current slot. The total number of actions is $\left|\mathcal{A}\right|=10$.

Reward $\mathcal{R}$: The reward function is designed as a weighted sum of multiple operational objectives to balance task completion quality and system reliability:

$$R^{\left(t\right)}=w_d{\overline{d}}^{\left(t\right)}+w_k{r}_{\mathrm{key}}^{\left(t\right)}+w_f{n}_{\mathrm{fail}}^{\left(t\right)}+w_a{r}_{\mathrm{avoid}}^{\left(t\right)}+w_c{r}_{\mathrm{choice}}^{\left(t\right)}$$

(7)

where:

• ${\overline{d}}^{\left(t\right)}$: average task delay at time slot t;
• $r_{\mathrm{key}}^{\left(t\right)}$: completion rate of key tasks within deadlines;
• $n_{\mathrm{fail}}^{\left(t\right)}$: number of fully failed edge nodes;
• $r_{\mathrm{avoid}}^{\left(t\right)}$: reward term for proactively avoiding overloaded nodes to suppress cascade propagation;
• $r_{\mathrm{choice}}^{\left(t\right)}$: penalty term for invalid offloading decisions (e.g., assigning tasks to already failed nodes);
• $w_d,w_k,w_f,w_a,w_c$: weight coefficients balancing different optimization objectives.

The weight coefficients are calibrated through preliminary experiments to achieve a reasonable tradeoff between service efficiency and cascade resilience. Concrete values are specified together with other simulation parameters in Section 5.1.

4. Algorithm Design: CERO

We propose CERO, a structure-aware dueling deep Q-Network that jointly resolves three critical technical challenges. The model efficiently encodes graph-structured state information without costly graph neural computations, learns cascade-robust policies against physically plausible stress propagation patterns, and achieves stable algorithm convergence with the support of adversarial training.

4.1. Structure-Aware Dueling Architecture

Figure 2 illustrates the CERO architecture, which decomposes the Q-function into three learnable components.

The architecture contains ten functional components connected by directional data flow arrows. From the input side, four raw state components form the input layer: node feature matrix, global system features, cloud status features, and local queue features. Two encoding modules process the input in parallel: a shared node encoder generates per-edge structural embeddings, and a global encoder extracts aggregated contextual information. The dueling decomposition layer consists of two parallel branches: the state value stream and the action advantage stream. The remaining two components are the two-layer adversarial perturbation generator for training augmentation and the final Q-value aggregation output head.

Directional arrows represent unidirectional data propagation. Arrows from raw features to encoders correspond to feature transformation operations. Arrows from encoders to dueling branches carry concatenation semantics, fusing global context and node-level embeddings. The arrow from the adversarial generator to the state input corresponds to worst-case perturbation injection for minimax training. Arrows from the two dueling branches to the output correspond to value-advantage aggregation, producing final Q-values for all actions. All components form an end-to-end pipeline: structured state inputs are encoded into hierarchical representations, then decomposed into value and advantage terms, and finally aggregated into robust Q-values with adversarial training regularization.

Shared Node Encoder. Each edge server’s 4-dimensional feature vector ${\mathbf{f}}_i=[{\sigma }_i,q_i/Q_{max},u_i^{\mathrm{CPU}},{\mathbf{1}}_{s_i=2}]$ is processed by a shared 2-layer MLP:

$${\mathbf{e}}_i=\mathrm{NodeEnc}\left({\mathbf{f}}_i\right)=\mathrm{ReLU}({\mathbf{W}}_2·\mathrm{ReLU}({\mathbf{W}}_1{\mathbf{f}}_i+{\mathbf{b}}_1)+{\mathbf{b}}_2)$$

(8)

where ${\mathbf{W}}_1\in {\mathbb{R}}^{32\times 4}$, ${\mathbf{W}}_2\in {\mathbb{R}}^{32\times 32}$. Crucially, the same parameters are applied to all N edge nodes, forcing the encoder to learn semantic features (“what constitutes a high-quality offloading target”) rather than memorizing per-node indices. This design improves generalization across different node identities and reduces dependency on node-specific parameters.

Global Encoder. The 5-dimensional global context $\mathbf{g}$ is encoded via a 2-layer MLP: ${\mathbf{h}}_g=\mathrm{ReLU}({\mathbf{W}}_g\mathbf{g}+{\mathbf{b}}_g)\in {\mathbb{R}}^{64}$.

Dueling Decomposition. The dueling network architecture decouples the state value and action advantage for deep reinforcement learning, following the standard dueling DQN paradigm:

$$Q(s,a)=V\left({\mathbf{h}}_g\right)+\left(A(s,a)-{\displaystyle \frac{1}{\left|\mathcal{A}\right|}}\sum _{a^{\prime }\in \mathcal{A}}A(s,a^{\prime })\right)$$

(9)

where $V\left({\mathbf{h}}_g\right)$ is a scalar global state value computed from the encoded global context via a two-layer MLP, shared across all actions. The advantage term $A(s,a)$ is calculated independently for each action category to match the complete action space:

• For edge offloading actions $a\in \{1,\dots ,N\}$: $A(s,a)$ takes the concatenation of global context ${\mathbf{h}}_g$ and the structure-aware node embedding ${\mathbf{e}}_a$ as input, i.e., $A({\mathbf{h}}_g\oplus {\mathbf{e}}_a)$, consistent with the original architectural design.
• For the local execution action $a=0$: $A(s,a)$ is computed from the concatenation of ${\mathbf{h}}_g$ and local node features: normalized queue length, stress level, and remaining CPU capacity.
• For the cloud offloading action $a=N+1$: $A(s,a)$ takes the concatenation of ${\mathbf{h}}_g$ and cloud status features: cloud queue occupancy, fixed edge-to-cloud transmission delay, and cloud service rate.

All three categories of action advantages are computed in parallel within the same advantage network head, sharing the unified global state value $V\left({\mathbf{h}}_g\right)$. This formulation ensures full consistency between the Q-value calculation and the action space definition covering local, edge, and cloud execution options.

Parameter Efficiency. The superior parameter efficiency of CERO is attributed to two core architectural designs. First, a shared node encoder is adopted to implement unified embedding learning for all nodes in the network. This structure avoids setting independent parameters for each node separately, which greatly alleviates redundant parameter occupancy in the overall model. Second, the proposed composite network structure adopts lightweight multi-layer perceptron branches to output scheduling solutions. Compared with conventional single-layer flat network structures relying on fully connected layers, this design effectively cuts down the extra overhead brought by massive parameter quantities.

4.2. Minimax Adversarial Training

Standard DQN optimizes expected return under the empirical transition distribution. However, catastrophic cascade trajectories are under-represented during training, producing policies that are brittle under stress. We address this via a Stackelberg game formulation [15]:

Definition 1 

(Stackelberg Offloading Game). The agent (leader) selects action a, after which the adversarial environment (follower) perturbs the state to maximize stress. The robust value of action a in state s is:

$$Q^{min}(s,a)=\underset{\delta \in \Delta \left(s\right)}{min}Q(s^{\prime },a)$$

(10)

where $\Delta \left(s\right)$ is a set of adversarial perturbations constrained by physical cascading dynamics.

Two-Layer Adversarial Model.

Layer 1—Global Stress Surge: The adversary amplifies cascade propagation and per-node stress uniformly:

$$\begin{array}{cc}\hfill {\beta }_{\mathrm{adv}}& =min(\beta ·{\eta }_{\beta },1.0),{\eta }_{\beta }=1.2\hfill \end{array}$$

(11)

$$\begin{array}{cc}\hfill {\sigma }_i^{\mathrm{adv}}& =min({\sigma }_i+{\Delta }_{\sigma },1.0),{\Delta }_{\sigma }=0.08\hfill \end{array}$$

(12)

This models system-wide deterioration (e.g., cooling failure, power instability).

Layer 2—Targeted Node Attack: The adversary selectively increases stress of the selected edge node only if the agent chooses to offload tasks to edge servers ($a\in \{1,2,\dots ,8\}$). For local execution ($a=0$) or cloud offloading ($a=N+1$), the targeted attack is disabled. For valid edge node selection:

$${\sigma }_{a-1}^{\mathrm{adv}}=min({\sigma }_{a-1}+{\Delta }_{\mathrm{target}},1.0),{\Delta }_{\mathrm{target}}=0.10$$

(13)

Minimax TD Target. The training objective aggregates nominal and adversarial Q-values:

$$y^{\left(t\right)}=r^{\left(t\right)}+\gamma ·min\left(Q_{{\theta }^{-}}^{\mathrm{nom}},Q_{{\theta }^{-}}^{{\mathrm{adv}}_1},Q_{{\theta }^{-}}^{{\mathrm{adv}}_2}\right)·(1-{\mathrm{done}}^{\left(t\right)})$$

(14)

where the three Q-values correspond to nominal, globally-perturbed, and target-perturbed states evaluated at the greedy next action $a^{*}=arg{max}_a{Q}_{\theta }(s^{\prime },a)$. Let ${\mathrm{done}}^{\left(t\right)}\in \{0,1\}$ denote the episode termination indicator variable: ${\mathrm{done}}^{\left(t\right)}=1$ if time slot t is the final slot of the episode, and 0 otherwise.

The min operation stems from the Stackelberg minimax principle: the adversary picks the worst-case perturbation from the admissible set, and the agent optimizes for the worst-case return, consistent with the Minimax DQN framework in [15]. Different from continuous norm-bounded perturbations in general robust control, our discrete adversarial set is designed around physical cascading failure modes in IIoT systems, targeting realistic emergency patterns. We acknowledge this formulation as an empirically effective heuristic; it cannot cover all cascade trajectories, and robustness may degrade under out-of-distribution disturbances.

4.3. Potential-Based Reward Shaping Design

The reward defined in Equation (7) mainly reflects task completion quality and system reliability. However, cascading failures often develop gradually over multiple time slots, making the reward signal sparse and delayed. As a result, the agent may require a large number of interactions to learn preventive offloading behaviors.

To provide denser learning feedback, we adopt Potential-Based Reward Shaping (PBRS) [30]. PBRS augments the original reward using a state potential function while preserving the optimal policy of the underlying Markov Decision Process.

We define a system-health potential function as

$$\Phi \left(s\right)={\displaystyle \sum _{i=1}^N}{\mathrm{health}}_i\left(s\right)$$

(15)

where

$${\mathrm{health}}_i\left(s\right)=0.4(1-{\sigma }_i)+0.3\left(1-{\displaystyle \frac{q_i}{Q_{max}}}\right)+0.2(1-u_i^{\mathrm{CPU}})+0.1\left(1-I(s_i=2)\right)$$

(16)

where $I(·)$ denotes the indicator function, taking value 1 when the specified condition is satisfied and 0 otherwise. The variables satisfy

$${\sigma }_i\in [0,1],u_i^{\mathrm{CPU}}\in [0,1],{\displaystyle \frac{q_i}{Q_{max}}}\in [0,1].$$

(17)

Therefore, all components are normalized to the interval $[0,1]$, ensuring that the weighted aggregation remains interpretable and numerically stable.

The coefficients are selected empirically to emphasize stress accumulation and queue congestion, which were observed to be the primary precursors of cascading failures during preliminary simulations.

The potential function measures the overall operational condition of the edge system by jointly considering node stress, queue occupancy, resource utilization, and failure status. A larger value of $\Phi \left(s\right)$ indicates a healthier system state with lower cascade risk.

It should be noted that $\Phi \left(s\right)$ is introduced solely as a state potential function for reward shaping and does not represent a game-theoretic potential function.

Following the PBRS framework, the shaping reward $F(s,s^{\prime })$ is defined as

$$F(s,s^{\prime })=\gamma \Phi \left(s^{\prime }\right)-\Phi \left(s\right)$$

(18)

where $\gamma$ is the discount factor and $s^{\prime }$ denotes the next state.

The final training reward becomes

$$r_{\mathrm{shaped}}=r+{\lambda }_{\mathrm{pbrs}}\left(\gamma \Phi \left(s^{\prime }\right)-\Phi \left(s\right)\right)$$

(19)

where ${\lambda }_{\mathrm{pbrs}}$ controls the shaping strength.

According to Grzes et al. [30], adding Equation (18) does not alter the optimal policy because the cumulative shaping reward telescopes along trajectories. Therefore, the proposed shaping mechanism improves learning efficiency while preserving policy optimality. This property is particularly important in cascading-failure scenarios, where informative rewards are often sparse and delayed.

Intuitively, the shaping term encourages the agent to maintain globally healthy network states and avoid actions that may accelerate stress accumulation or cascade propagation, even before failures become observable in the environment.

4.4. Training Procedure

Algorithm 1 presents the training pipeline of the proposed CERO model using minimax adversarial DQN. We repeat training with several random seeds to ensure robustness. During each time slot, the agent perceives system states and selects actions via the $ϵ$-greedy strategy. Potential-based reward shaping (PBRS) is utilized to refine raw rewards. Experience tuples are saved to the replay buffer for mini-batch training. The Q-Network is updated with the minimax TD target, and the target network is periodically synchronized. The exploration rate $ϵ$ decays gradually, and we select the optimal model checkpoint via validation results.

Algorithm 1 Training Procedure of CERO

1: Initialize:  2:     Q-Network parameters $\theta$, target network parameters ${\theta }^{-}\leftarrow \theta$  3:     Replay buffer $\mathcal{D}$, discount factor $\gamma$  4:     Reward shaping coefficient ${\lambda }_{\mathrm{pbrs}}=0.4$  5:     Validation interval K, best validation metric $\mathrm{b}\mathrm{e}\mathrm{s}\mathrm{t}\text{\_}\mathrm{k}\mathrm{r}\leftarrow 0$  6: for episode = 1 to $E_{\max }$ do  7:     Initialize environment state $s_0$, terminal flag $done\leftarrow \mathrm{False}$  8:     while $done=\mathrm{False}$ do  9:         Select action $a_t$ via $ϵ$-greedy policy 10:        Execute action $a_t$, obtain reward $r_t$, next state $s_{t+1}$, terminal flag $done$ 11:        Generate adversarial next states: global surge $s_{t+1}^{\mathrm{a}\mathrm{d}\mathrm{v}1}$, targeted attack $s_{t+1}^{\mathrm{a}\mathrm{d}\mathrm{v}2}$ 12:        Compute shaped reward: $r_t^{\prime }=r_t+{\lambda }_{\mathrm{pbrs}}·\Delta \Phi (s_t,s_{t+1})$ 13:        Store transition $(s_t,a_t,r_t^{\prime },s_{t+1},s_{t+1}^{\mathrm{a}\mathrm{d}\mathrm{v}1},s_{t+1}^{\mathrm{a}\mathrm{d}\mathrm{v}2},done)$ into $\mathcal{D}$ 14:        Sample mini-batch from $\mathcal{D}$ 15:        Compute minimax TD target: 16:           $y=r^{\prime }+\gamma ·(1-done)·min\left(Q_{{\theta }^{-}}^{\mathrm{nom}},Q_{{\theta }^{-}}^{\mathrm{a}\mathrm{d}\mathrm{v}1},Q_{{\theta }^{-}}^{\mathrm{a}\mathrm{d}\mathrm{v}2}\right)$ 17:        Update Q-Network $\theta$ by gradient descent on TD loss 18:        Periodically update target network: ${\theta }^{-}\leftarrow \theta$ 19:     end while 20:     if episode $modK=0$ then 21:        Run validation on Combo Crisis scenario for $N_{\mathrm{val}}$ independent episodes 22:        Calculate average post-crisis KR as validation score $\mathrm{v}\mathrm{a}\mathrm{l}\text{\_}\mathrm{k}\mathrm{r}$ 23:        if $\mathrm{v}\mathrm{a}\mathrm{l}\text{\_}\mathrm{k}\mathrm{r}>\mathrm{b}\mathrm{e}\mathrm{s}\mathrm{t}\text{\_}\mathrm{k}\mathrm{r}$ then 24:            $\mathrm{b}\mathrm{e}\mathrm{s}\mathrm{t}\text{\_}\mathrm{k}\mathrm{r}\leftarrow \mathrm{v}\mathrm{a}\mathrm{l}\text{\_}\mathrm{k}\mathrm{r}$ 25:            Save current model as best checkpoint ${\theta }_{\mathrm{best}}\leftarrow \theta$ 26:        end if 27:     end if 28: end for 29: Finalize: Restore best checkpoint ${\theta }_{\mathrm{best}}$ as the final trained model

For the computational complexity of Algorithm 1, we analyze it across inference and training stages within the existing narrative framework. Per-step forward inference of the Q-Network is dominated by shared node encoding, global feature encoding, and dueling value-advantage aggregation, with asymptotic complexity $\mathcal{O}(N·d_f·d_e+d_g·d_h+d_h·|\mathcal{A}\left|\right)$, where N is the number of edge nodes, $d_f$ is the dimension of per-node raw features, $d_e$ is the output dimension of the shared node encoder, $d_g$ is the global feature dimension, $d_h$ is the hidden layer dimension of value and advantage streams, and $\left|\mathcal{A}\right|$ is the size of the action space. The two adversarial state generation steps (global stress surge and targeted node attack) only involve lightweight element-wise arithmetic operations on node stress values with $\mathcal{O}\left(N\right)$ complexity, bringing negligible extra inference overhead. For training phases, the per-episode complexity with T time slots and mini-batch size B scales as $\mathcal{O}\left(T·B·\left(N·d_f·d_e+d_h^2\right)\right)$, and the overall training complexity increases linearly with the total number of episodes; the periodic validation procedure only executes forward inference without gradient computation, which does not affect the asymptotic complexity of the main training pipeline. Compared with the standard Flat-DQN baseline, CERO introduces only marginal computational overhead: the shared node encoder reduces parameter redundancy via weight sharing across all edge nodes, and adversarial state generation requires no additional learnable parameters. In our implementation, the overall training time of CERO increases by less than 12% relative to the Flat-DQN baseline, which delivers substantial emergency resilience gains at an acceptable computational cost.

5. Experimental Evaluation

5.1. Experimental Setup

Simulation Environment. We adopt a discrete-time simulation framework. Each episode contains $T=100$ time slots. The network topology is composed of 8 edge servers, 3 switches, and 1 power supply unit (PSU), resulting in a total of 12 nodes. Task arrivals follow a Poisson distribution with an arrival rate of $\lambda =4.0$. The cascading failure mechanism implemented in this system follows the threshold-driven state transition rules in Section 4.1 presented in Section 3. Key simulation parameters are listed in

Table 2. Simulation parameters in industrial edge computing environment.

Parameter	Symbol	Baseline	Varied
Number of edge servers	N	8	–
Number of switches	$|{\mathcal{V}}_S|$	3	–
Number of PSUs	$|{\mathcal{V}}_P|$	1	–
Time slots per episode	T	100	–
Slot duration	$\Delta t$	0.050 s	–
Task arrival rate (Poisson)	$\lambda$	4.0	–
Task priority levels	${\rho }_k$	$\{1,2,3,4\}$	–
Key task ratio	$R_{\mathrm{key}}$	20%	–
CPU demand per task	${\mathrm{cpu}}_k$	$\mathcal{U}(1,3)$	–
Data size per task	${\mathrm{data}}_k$	$\mathcal{U}(0.5,5.0)$ MB	–
Task deadline	${\mathrm{m}\mathrm{a}\mathrm{x}\text{\_}\mathrm{d}\mathrm{e}\mathrm{l}\mathrm{a}\mathrm{y}}_k$	$\mathcal{U}(0.6,1.6)$ s	–
Edge CPU capacity	$C_i$	$\mathcal{U}(3,30)$	–
Edge memory capacity	$M_i$	$\mathcal{U}(10,400)$	–
Queue capacity	$Q_{max}$	20	–
Local CPU capacity	$f^l$	1.0 GHz	–
Wireless bandwidth	W	30 MHz	–
Cloud transmission speed	$v_{\mathrm{cloud}}$	10.0	–
Load-to-stress coefficient	$\alpha$	0.6	–
Cascade propagation coefficient	$\beta$	0.55	0.30–0.80
PSU-stress coupling coefficient	${\gamma }_{\mathrm{psu}}$	0.08	–
Stress threshold	${\theta }_{\mathrm{stress}}$	0.38	0.30–0.46
Failure threshold	${\theta }_{\mathrm{fail}}$	0.60	0.48–0.72
Recovery probability	$p_{\mathrm{recov}}$	0.02	–
PSU degradation rate	$d_{\mathrm{psu}}$	0.06	–
Shared node encoder hidden dim	$d_e$	32	–
Node feature dimension	$d_f$	4	–
Global feature dimension	$d_g$	5	–
GNN hidden dimension	$d_{\mathrm{gnn}}$	64	–
GNN layers	$L_{\mathrm{GNN}}$	2	–
Dueling advantage hidden dim	$d_{\mathrm{adv}}$	64	–
Q-Network hidden dimensions	$d_h$	256, 128	–
Learning rate	$\eta$	${10}^{-3}$	–
Discount factor	$\gamma$	0.97	–
Replay buffer capacity	$\left|\mathcal{D}\right|$	50,000	–
Mini-batch size	B	256	–
Target network update interval	$K_{\mathrm{target}}$	50	–
$ϵ$ initial/final	$ϵ$	0.9/0.05	–
$ϵ$ decay rate	${ϵ}_{\mathrm{decay}}$	0.93	–
Training episodes	$E_{max}$	200	–
PBRS coefficient	${\lambda }_{\mathrm{pbrs}}$	0.4	0.0–1.0
Boltzmann temperature decay	${\tau }_{\mathrm{decay}}$	0.93	–
Independent random seeds	–	10	–

.

Baseline Policies. We compare the proposed CERO model against three rule-based heuristic policies and one standard DRL baseline. Detailed algorithmic descriptions are provided below to ensure reproducibility.

• Collaborative (COLLAB): Collaborative (COLLAB) is a heuristic scheduling strategy built on real-time edge node status information [31]. It quantifies each edge node through a load-health score. Three factors are integrated into this score: CPU utilization, task queue occupancy, and overall node stress level. Newly arriving tasks are dispatched to the available node with the highest score. Critical tasks always receive higher scheduling priority than non-critical ones. When a node breaks down, all pending tasks on it will be reassigned. The redistribution follows the updated scores of remaining functional nodes. This design enables adaptive task reallocation when cascading failures occur in the system.
• DAG-Priority (DAG): DAG-Priority (DAG) is a priority-driven scheduling strategy following the Minimum Execution Time (MET) principle [32]. Critical tasks are first mapped to nodes with the shortest estimated completion time. This estimated completion time draws on two real-time runtime indicators. One is current task queue backlog. The other is real-time node health status. Non-critical tasks are scheduled in the next step. They consume the remaining available computing resources on each node. Upon a node failure, the system recomputes all MET values. This re-calculation includes all other active nodes in the cluster and uses the new MET values to re-distribute the remaining tasks. Thus, uniform system performance in the presence of faults is ensured.
• Cloud-Only (CLOUD): Cloud-Only fully offloads all generated tasks to the cloud server, with no computation processing executed at the edge tier. This strategy serves as the lower-bound performance baseline for comparative evaluation. Under the Combo Crisis scenario, large-scale task migration triggered by cascading node failures induces severe congestion in the cloud-side task queue, which in turn causes widespread deadline violations throughout the system recovery phase. As a consequence, the post-recovery completion rate of key tasks drops to 0% under this strategy.
• Flat-DQN: Flat-DQN is adopted as a standard deep Q-Network baseline to represent mainstream DRL-based computation offloading approaches. To ensure fair comparison, this baseline shares the exact same set of raw state features, action space definition, reward function, and training hyperparameters with the proposed CERO framework. All input information—including per-node features, global system context, cloud operation status, and local queue states—is concatenated into a 40-dimensional flat state vector, which is fed into a three-layer fully connected DQN for decision-making. No structural encoding mechanism, dueling network decomposition, or adversarial training module is incorporated. This baseline is designed to decouple the performance improvement brought by generic DRL learning capability from the gains contributed by our proposed architectural innovations.

DRL Model Variants. For ablation analysis of core modules, we derive controlled variants from the full CERO framework by removing specific components one by one:

• CERO: The complete proposed model, which integrates the shared node encoder, dueling network architecture, potential-based reward shaping, and two-layer minimax adversarial training.
• CERO w/o Layer-2 (global only): Removes the targeted node attack layer, retaining only the global stress surge perturbation.
• CERO w/o Layer-1 (targeted only): Removes the global stress surge layer, retaining only the targeted node attack perturbation.
• CERO w/o Adversarial: Removes the entire minimax adversarial training module and adopts standard DQN temporal difference targets.
• CERO w/o Dueling: Removes the dueling value-advantage decomposition and uses a single-stream Q network.
• CERO w/o Structure: Removes the shared node encoder. All node feature vectors ${\mathbf{f}}_i$ are directly concatenated into a one-dimensional flat vector as input, with all other network structures unchanged.

Training Configuration. All models were trained with an Adam optimizer with a learning rate of ${10}^{-3}$. The mini-batch size is set to 256, and the replay buffer capacity is 50,000. The target network is updated every 50 time steps. For the $ϵ$-greedy exploration strategy, the exploration factor $ϵ$ decays from 0.9 to 0.05 with a decay rate of 0.93 per episode. We run 200 training episodes with 10 independent random seeds. Finally, we select the model checkpoint with the best validation KR for performance evaluation. All reported results are averaged over 10 independent random seeds, and pairwise comparisons employ the Wilcoxon signed-rank test with Bonferroni correction to control the family-wise error rate.

The reward-shaping coefficient is fixed at ${\lambda }_{\mathrm{pbrs}}=0.4$ throughout all experiments. We performed a parameter sweep over the range $[0.0,1.0]$ with a step size of 0.2 to select this value. Moderate reward shaping improves post-crisis recovery performance, while excessively large ${\lambda }_{\mathrm{pbrs}}$ distorts the original task objective and degrades overall performance. The value 0.4 achieves the optimal tradeoff: it maintains comparable task efficiency under normal conditions and yields the highest post-recovery KR under the Combo Crisis scenario.

Evaluation Metrics. The primary metric is the Key task completion Rate (KR), defined as the proportion of critical tasks (${\rho }_k=1$) finished before their deadlines. The secondary metrics include average task delay and the number of failed nodes.

For stress test scenarios, we define three staged metrics:

$K{R}_{\mathrm{pre}}$: KR before crisis occurs; $K{R}_{\mathrm{post}}$: KR during the crisis; $K{R}_{\mathrm{after}}$: KR after system full recovery.

The metric Failures denotes the average number of failed edge nodes across all time slots in one episode.

5.2. Normal Operation Benchmark

We first evaluate all policies under normal operating conditions. The experiments are repeated for 10 independent runs, and the quantitative results are summarized in

Table 3. Normal operation benchmark results (mean ± std over 10 runs).

Algorithm	KR (%)	Delay (s)	Failures	Type
Collaborative	89.4 ± 2.3	0.518	1.6	Rule
DAG-Priority	89.3 ± 2.5	0.519	1.6	Rule
CERO	88.6 ± 3.6	0.635	2.1	DRL
Flat-DQN	81.5 ± 6.3	0.682	6.3	DRL
Cloud-Only	82.1 ± 8.4	0.923	1.3	Rule

.

Under normal operating conditions, the proposed CERO framework achieves a KR of 88.6%, which is only 0.8 percentage points lower than the best-performing rule-based collaborative policy. Note that the normal operation setting is not an ideal zero-failure environment. It retains gradual PSU degradation and random load fluctuations consistent with real IIoT operating conditions, so node stress accumulates naturally and occasional failures occur. DRL-based methods exhibit more failed nodes than rule-based heuristics because rule-based policies adopt conservative scheduling to avoid overload at the cost of resource utilization, while CERO actively leverages edge capacity to improve throughput. The moderately higher failure count is an acceptable tradeoff for substantially stronger post-crisis recovery performance. A Welch’s t-test between CERO and the Collaborative baseline indicates that the observed performance difference is statistically insignificant ($p>0.05$). Formal statistical tests for emergency scenarios are provided in Section 5.3. This result demonstrates that the DRL-based framework can learn task-offloading strategies that are competitive with carefully designed heuristic approaches.

Compared with the variant without adversarial training, CERO improves KR by 0.5 percentage points, at the cost of a modest increase in average task delay to 0.635 s, compared with 0.607 s for the non-adversarial baseline variant. This tradeoff shows that adversarial training pushes scheduling policies toward greater conservatism, favoring robustness over aggressive resource utilization. The performance gain under normal conditions is admittedly modest, but the robustness afforded by adversarial optimization becomes critical in emergency scenarios, as borne out by the stress tests presented later. The statistical significance of these improvements is verified through Wilcoxon signed-rank tests with Bonferroni correction over 10 independent seeds.

The Flat-DQN baseline achieves a KR of 81.5%, which is 7.1 percentage points lower than CERO. Although both are DRL-based methods with identical hyperparameter settings, Flat-DQN lacks structural encoding, dueling decomposition, and adversarial training. The 7.1 pp gap under normal conditions already indicates that architectural innovations contribute substantially to learning quality, and this gap widens significantly under emergency conditions, as shown in Section 5.3.

5.3. Emergency Stress Test

To evaluate emergency resilience of different scheduling policies, we design three stress scenarios simulating extreme network conditions, with post-recovery key task completion rate ${\mathrm{KR}}_{\mathrm{after}}$ as the core metric for service restoration capability.

• Dual-Node Failure:Two edge servers fail at $t=40$ and resume at $t=70$, with pending tasks offloaded to the cloud during outage.
• Task Burst: Task arrival rate $\lambda$ triples from 4.0 to 12.0 at $t=40$ and recovers at $t=60$.
• Combo Crisis: Compound disturbance integrating a workload surge of $\lambda =10.0$ starting at $t=30$ and an edge 0 node failure occurring at $t=50$, with all abnormal system conditions terminated at $t=70$.

Quantitative results are summarized in

Table 4. Emergency stress-test results. KR_pre, KR_post, KR_after represent the key task completion rate measured before, during and after the crisis, respectively. KR_post counts only tasks completed within the crisis window. Values are presented as mean ± standard deviation over 10 runs.

Algorithm	KR (%)	KRpre (%)	KRpost (%)	KRafter (%)	Delay (s)	Fail
Scenario 1: Dual-Node Failure
CERO	89.4 ± 4.9	100.0 ± 0.0	72.4 ± 10.9	98.3 ± 3.7	0.731	7.5
Flat-DQN	82.7 ± 4.0	100.0 ± 0.0	64.5 ± 4.5	94.2 ± 2.3	0.682	8.0
DAG-Priority	86.1 ± 4.5	100.0 ± 0.0	64.5 ± 8.8	94.7 ± 6.6	0.588	7.8
Collaborative	85.8 ± 4.5	100.0 ± 0.0	64.4 ± 10.1	95.5 ± 6.3	0.588	7.8
Cloud-Only	83.2 ± 8.5	100.0 ± 0.0	62.9 ± 10.7	93.4 ± 10.0	0.950	7.5
Scenario 2: Task Burst ($\lambda$: 4.0 → 12.0 → 4.0)
CERO	86.3 ± 5.4	100.0 ± 0.0	45.3 ± 6.8	97.8 ± 3.4	0.820	7.7
Flat-DQN	74.3 ± 4.5	100.0 ± 0.0	32.0 ± 5.2	80.5 ± 3.8	0.715	5.8
DAG-Priority	74.6 ± 11.0	100.0 ± 0.0	44.1 ± 9.2	82.5 ± 16.0	0.610	7.7
Collaborative	70.9 ± 8.1	100.0 ± 0.0	39.9 ± 6.1	82.9 ± 17.7	0.621	7.8
Cloud-Only	43.8 ± 5.9	100.0 ± 0.0	18.3 ± 6.1	27.6 ± 20.6	1.024	0.7
Scenario 3: Combo Crisis ($\lambda \uparrow$ + Node Failure)
CERO	86.8 ± 5.8	100.0 ± 0.0	71.4 ± 4.7	97.3 ± 7.3	0.823	7.6
Flat-DQN	81.4 ± 3.8	100.0 ± 0.0	54.2 ± 4.5	84.3 ± 3.2	0.734	7.1
DAG-Priority	67.8 ± 11.4	100.0 ± 0.0	60.2 ± 8.3	41.1 ± 31.3	0.613	7.9
Collaborative	64.3 ± 11.8	100.0 ± 0.0	58.0 ± 8.2	40.3 ± 35.4	0.626	7.9
Cloud-Only	37.9 ± 5.5	100.0 ± 0.0	38.0 ± 4.2	1.0 ± 3.3	1.043	5.9

, and performance evolution across crisis stages is visualized in Figure 3. All pairwise comparisons use the non-parametric Wilcoxon signed-rank test with Bonferroni correction, which avoids normality assumptions and is suitable for small-sample simulations with 10 independent runs. The significance threshold is set at $p<0.01$.

In the Dual-Node Failure scenario, all methods degrade during outage, with ${\mathrm{KR}}_{\mathrm{post}}$ values ranging from 62.9% to 72.4%. CERO achieves the highest ${\mathrm{KR}}_{\mathrm{post}}$ of 72.4% and recovers to 98.3% ${\mathrm{KR}}_{\mathrm{after}}$, significantly outperforming all baselines by at least 2.8 percentage points. The shared topology representation enables the agent to adapt to node availability changes and maintain strong recovery performance after infrastructure failures.

In the Task Burst scenario, workload surge causes widespread performance drops. CERO leads all baselines with a ${\mathrm{KR}}_{\mathrm{post}}$ of 45.3% and restores to 97.8% ${\mathrm{KR}}_{\mathrm{after}}$ once load returns to baseline. Rule-based methods only recover to around 82%, and Cloud-Only remains at 27.6% due to unsustainable task backlog. Minimax adversarial training enhances policy robustness against volatile workloads and accelerates post-congestion recovery.

The Combo Crisis scenario poses the greatest resilience challenge. CERO retains the highest overall KR of 86.8% and maintains 97.3% ${\mathrm{KR}}_{\mathrm{after}}$. In contrast, rule-based policies suffer severe recovery collapse with ${\mathrm{KR}}_{\mathrm{after}}$ below 41%, and Cloud-Only nearly fails completely at 1.0%. Heuristic strategies prioritize immediate task execution during emergencies, which accumulates systemic stress and cripples post-crisis scheduling.

Overall, resilience-driven learning predominantly benefits the recovery phase. Many baselines maintain acceptable in-crisis performance but fail to restore stable scheduling afterward, whereas CERO sustains ${\mathrm{KR}}_{\mathrm{after}}$ above 97% across all scenarios. The two core modules act synergistically: the topology encoder handles node status dynamics for infrastructure failure recovery, while adversarial training strengthens tolerance to workload spikes and compound disturbances. Their integration validates the efficacy of the proposed resilience-oriented scheduling paradigm.

5.4. Ablation Study

We perform component-wise ablation studies to evaluate the contribution of each core module under normal operation and the Combo Crisis scenario. Recovery KR is measured after the crisis conditions are removed and the system returns to a nominal operating state, serving as the key metric for evaluating cascade resilience.

Table 5. Ablation study of core components under normal operation and the Combo Crisis scenario. Recovery KR denotes the key-task completion rate after crisis conditions are removed.

Variant	Minimax Adversarial	Dueling	SA-Enc	Normal KR (%)	Recovery KR (%)
CERO (full model)	Full (both layers)	✓	✓	88.6	97.8
CERO w/o Layer-2 (global only)	Global layer only	✓	✓	56.1	54.2
CERO w/o Layer-1 (targeted only)	Targeted layer only	✓	✓	60.3	61.9
CERO w/o Adversarial	None	✓	✓	54.9	58.1
CERO w/o Dueling	Full (both layers)	–	✓	45.9	47.2
CERO w/o Structure	Full (both layers)	✓	–	35.4	17.0

Note: ✓ = module retained; – = module removed.

summarizes the contribution of each component through controlled removal experiments. Unlike the full CERO model, all ablated variants exhibit considerable degradation under both normal and post-crisis conditions, demonstrating that each module contributes to stable scheduling and cascade recovery. The recovery performance gap becomes particularly significant after crisis removal, highlighting the importance of the proposed resilience-oriented designs.

The full CERO model yields the highest post-recovery KR of 97.8% under combined crisis scenarios. The removal of the global disturbance layer or the targeted attack layer causes serious degradation of Recovery, with the Recovery KR lowered to 54.2% and 61.9%, respectively. This means that neither layer alone is enough for reliable cascade recovery. CERO uses a two-layer adversarial design, augmenting global workload surge modeling with targeted failure adaptation to better cope with compound disruptions.

Removing the entire adversarial training module reduces the post-recovery KR to 58.1%, showing that minimax adversarial optimization plays a crucial role in improving robustness against unseen disturbances. Although the absence of adversarial training also decreases normal-operation performance from 88.6% to 54.9%, its primary contribution lies in enhancing resilience under crisis conditions.

The shared structural encoder delivers the most significant resilience improvement. When the node-shared structural representation is removed and replaced with direct feature concatenation, Recovery KR drops sharply from 97.8% to 17.0%. This dramatic degradation demonstrates that the proposed structural representation is essential for capturing heterogeneous node roles and preserving effective decision-making during cascading failures.

The dueling architecture also provides a substantial contribution. Without the dueling value–advantage decomposition, Recovery KR decreases to 47.2%. This result indicates that the dueling architecture improves value estimation stability by separating state value evaluation from action-specific advantages, which is particularly beneficial when network conditions change rapidly during crisis recovery.

Overall, the ablation results demonstrate that the three major components of CERO contribute synergistically to resilience enhancement. The structural encoder provides the largest individual gain, improving Recovery KR by 80.8 percentage points compared with the flat-state variant. The two-layer minimax adversarial mechanism further improves robustness by exposing the agent to diverse compound disturbances, while the dueling architecture stabilizes policy learning and value estimation. Together, these components enable CERO to achieve high recovery performance under complex cascading crisis scenarios.

5.5. Parameter Sensitivity Analysis

To verify that CERO’s performance advantages are not sensitive to specific cascade parameter calibration, we conduct a sensitivity study by perturbing three key cascade parameters by $\pm 20\%$ from their nominal values: stress propagation rate $\beta$, stress threshold ${\theta }_{\mathrm{stress}}$ and failure threshold ${\theta }_{\mathrm{fail}}$. CERO and Flat-DQN are retrained from scratch for 200 episodes under each configuration, while rule-based heuristics are evaluated directly without retraining. All tests are conducted on the Combo Crisis scenario over 10 independent runs, with post-recovery ${\mathrm{KR}}_{\mathrm{after}}$ as the core metric. All pairwise comparisons adopt the Wilcoxon signed-rank test with Bonferroni correction at the $p<0.01$ significance level.

Quantitative results are summarized in

Table 6. Parameter sensitivity analysis under the Combo Crisis scenario. CERO and Flat-DQN are retrained under each perturbed parameter set. Values are ${\mathrm{KR}}_{\mathrm{after}}$ (mean ± std over 10 runs).

Algorithm	Original	$\mathit{\beta }-20\%$	$\mathit{\beta }+20\%$	${\mathit{\theta }}_{\mathbf{stress}}-20\%$	${\mathit{\theta }}_{\mathbf{stress}}+20\%$	${\mathit{\theta }}_{\mathbf{fail}}-20\%$	${\mathit{\theta }}_{\mathbf{fail}}+20\%$
CERO	$97.8\pm 3.2$	$95.2\pm 3.8$	$96.5\pm 3.0$	$96.1\pm 3.5$	$95.8\pm 3.4$	$96.9\pm 3.1$	$95.4\pm 3.6$
Flat-DQN	$82.0\pm 4.2$	$79.5\pm 4.5$	$80.8\pm 4.0$	$83.5\pm 4.3$	$80.2\pm 4.4$	$82.8\pm 4.1$	$80.5\pm 4.5$
Collaborative	$34.7\pm 8.5$	$32.5\pm 9.0$	$35.2\pm 8.0$	$36.8\pm 7.5$	$33.1\pm 9.0$	$35.5\pm 8.2$	$32.8\pm 9.2$
DAG-Priority	$33.5\pm 9.1$	$31.8\pm 9.5$	$34.1\pm 8.7$	$35.0\pm 8.2$	$32.0\pm 9.3$	$34.2\pm 8.8$	$31.5\pm 9.6$
Cloud-Only	$0.0\pm 0.0$	$0.0\pm 0.0$	$0.0\pm 0.0$	$0.0\pm 0.0$	$0.0\pm 0.0$	$0.0\pm 0.0$	$0.0\pm 0.0$

and visualized in Figure 4.

As illustrated by both results, the qualitative performance ranking remains highly stable across all parameter perturbations. CERO consistently achieves the highest ${\mathrm{KR}}_{\mathrm{after}}$ across all configurations, with values ranging from 95.2% to 97.8%, significantly outperforming Flat-DQN by 13.7–14.1% and rule-based heuristics by over 60%. Flat-DQN ranks second in all cases, confirming that DRL-based methods consistently outperform rule-based policies regardless of cascade parameter settings.

Among rule-based methods, Collaborative and DAG-Priority only achieve ${\mathrm{KR}}_{\mathrm{after}}$ between 31.8% and 36.8%, while Cloud-Only yields 0% post-recovery KR across all settings. The only observed rank reversal occurs between Collaborative and DAG-Priority under the ${\theta }_{\mathrm{stress}}-20\%$ configuration, which does not affect the overall tiered ranking of CERO, Flat-DQN and rule-based heuristics. The stable ranking under $\pm 20\%$ parameter perturbations confirms that CERO’s performance advantage is not an artifact of specific cascade calibration.

5.6. Computational Overhead Analysis

We measure per-inference latency and per-episode training time of CERO and Flat-DQN to quantify the computational overhead introduced by the structural encoder and adversarial training modules. Both models are benchmarked on identical CPU-only hardware with consistent task arrival and environment configurations across 10 independent runs.

As shown in

Table 7. Inference and training overhead comparison between CERO and Flat-DQN.

Metric	Flat-DQN	CERO	Overhead
Inference per decision (ms)	0.32	0.45	+39.9%
Training per episode (s)	0.58	0.74	+26.9%

, CERO records a per-decision inference latency of 0.45 ms and a per-episode training time of 0.74 s, corresponding to 39.9% and 26.9% increases over Flat-DQN, respectively. The extra overhead stems from two components: the two-layer GCN forward pass in the structural encoder, and the dual auxiliary perturbation heads in the minimax adversarial module.

In absolute terms, per-scheduling decision latency remains below 0.5 ms, which is two to three orders of magnitude lower than typical task execution times in IIoT edge environments ranging from tens to hundreds of milliseconds. For a standard episode containing 100 time slots, the per-episode training gap between CERO and Flat-DQN is only around 0.16 s. Since training is conducted offline and inference overhead is negligible at runtime, the added architectural complexity is well justified by the substantial emergency resilience gains documented in Section 5.3 and Section 5.5.

5.7. Ranking Summary

To provide an overall comparison of policy robustness, we summarize the performance of all methods under normal operation and post-recovery evaluations across the three emergency scenarios. Since recovery capability is the primary focus of this work, the rankings in emergency scenarios are based on KR_after, which measures the completion rate of key tasks after all crisis conditions have been removed and the system has returned to nominal operation. The comprehensive results are presented in

Table 8. Overall performance comparison under normal operation and post-recovery evaluations across emergency scenarios.

Algorithm	Normal KR	Failure	Burst	Combo	Avg. Rank
CERO	87.0	98.3	97.8	97.3	1.50
Flat-DQN	81.5	94.2	80.5	84.3	2.75
Collaborative	89.4	93.8	78.6	34.7	2.50
DAG-Priority	89.3	92.6	76.1	33.5	3.50
Cloud-Only	82.1	90.0	27.7	0.0	4.75

, and the comparative radar chart is illustrated in Figure 5.

The average ranks are calculated independently for each evaluation setting and then averaged across the four scenarios. All pairwise performance and rank comparisons adopt the Wilcoxon signed-rank test with Bonferroni correction, with a significance threshold set at $p<0.01$.

From the ranking distribution, rule-based heuristics such as Collaborative and DAG-Priority occupy the top two positions under normal operating conditions by virtue of conservative scheduling that prioritizes avoiding node overload, but their rankings plummet sharply in the combo crisis scenario as they cannot suppress cascading stress propagation, resulting in severe performance collapse after the crisis. In contrast, CERO consistently ranks first in both the task burst and combo crisis scenarios, the two most representative and challenging emergency settings, which is the core reason it secures the best overall average rank.

Flat-DQN outperforms rule-based heuristics in all three emergency scenarios, but ranks third overall, weighed down by weaker performance under normal operation. Without structural encoding and adversarial training, Flat-DQN achieves a normal KR 5.5 percentage points lower than CERO, and its post-recovery KR falls 17.3 and 13.0 percentage points short under the task burst and combo crisis scenarios respectively. This gap confirms that generic DRL capacity alone cannot match the resilience gains provided by the proposed architectural innovations.

CERO, although not the best method in the normal operation scenario, is the most robust one for recovery under workload surges and combined crises, the hardest emergency conditions considered in this work. Therefore, CERO achieves the best overall average rank of 1.50, which is statistically significantly better than all baseline methods.

Aggregated ranking metrics further illustrate the merits of resilience-focused scheduling schemes. Rule-based policies maintain competitive performance under steady states and simple failure scenarios, but suffer catastrophic degradation under high-load compound emergencies. The full CERO model sustains post-recovery KR above 97% for both sudden load spikes and compound emergency cases, demonstrating its reliable defense against drastic workload shifts.

Collectively, these experimental outcomes reveal that steady-state task completion rates cannot fully reflect a policy’s true resilience. Scheduling schemes that perform well under mild operating conditions often experience sharp performance losses once critical disturbances resolve. Equipped with minimax adversarial training and structure-aware node encoding, the proposed CERO framework strikes the best performance balance across all test scenarios and significantly outperforms all baselines in post-crisis recovery.

6. Conclusions

This paper proposed CERO, a cascade-emergency resilient task offloading framework for Industrial Internet of Things (IIoT) edge computing environments. The framework integrates a node-wise shared representation mechanism, a two-layer cascade-oriented adversarial training strategy, and potential-based reward shaping into a unified dueling deep reinforcement learning architecture to improve the robustness and recovery capability of edge computing systems under cascading disruptions. Unlike conventional offloading methods that mainly optimize normal operating efficiency, CERO explicitly considers coupled failure propagation and emergency resource degradation during task scheduling.

Extensive discrete-event simulation experiments are conducted under normal operation, single-crisis, and compound-crisis scenarios, including node failures, workload bursts, and combined emergency conditions. Experimental findings show that under standard operating conditions, CERO achieves competitive task completion efficiency compared with state-of-the-art rule-based heuristic methods, while providing substantially improved post-crisis recovery capability under emergency scenarios.

For the most demanding compound-crisis case featuring simultaneous node outages and workload surges, CERO records a post-recovery critical task completion rate of 97.8%, which exceeds the strongest rule-based baseline by more than 63 percentage points. Results obtained from repeated independent simulation trials further demonstrate the statistical reliability of CERO’s performance advantages and confirm its capability to preserve critical task execution during cascading disruption events.

Ablation studies further quantify the contribution of each core component in the proposed framework. Removing the shared node representation module results in a substantial degradation of Recovery KR from 97.8% to 17.0%, demonstrating that adaptive structural state encoding is essential for capturing heterogeneous node characteristics and maintaining recovery capability in complex edge environments. The dueling value-advantage decomposition improves the stability of value estimation and policy optimization. Meanwhile, the two-layer minimax adversarial training mechanism provides complementary robustness by jointly modeling global workload surges and targeted failure propagation. The removal of any of the adversarial layers leads to a big drop in recovery, indicating that both perspectives of disturbance modeling are needed for effective cascade resilience. Overall, these results validate the complementary roles of representation learning, adversarial training and policy optimization in improving emergency computation offloading performance.

Additional evaluations on scalability and parameter sensitivity show that CERO can still perform well with different cascade intensity and network configuration, suggesting its applicability to the dynamic IIoT edge computing environment. Nevertheless, the current evaluation is conducted using discrete-event simulations with limited-scale network topologies. Future studies will investigate larger-scale industrial scenarios and practical deployment constraints.

Three major directions will be explored in future work: digital-twin-assisted training environments for more realistic cascade modeling, physical testbed validation for real-world deployment assessment, and online adaptation mechanisms for continuously changing industrial edge environments.