Dynamic Flexible Job Shop Scheduling via an Adaptive Genetic Algorithm and Deep Learning

Abstract

To address the scheduling problem of dynamic flexible job shop, this study proposes a hybrid scheduling method that integrates an adaptive genetic algorithm, dynamic target smoothing, and a deep Q-network (DQN). The scheduling process is formulated as a Markov decision process, where a graph convolutional network (GCN) extracts feature representations from evolving job and machine states. The adaptive genetic algorithm dynamically generates target values, while the dynamic target smoothing mechanism—based on sliding windows or exponential smoothing—further stabilizes target updates and enhances training efficiency. Experiments on the Brandimarte benchmark with stochastic job arrivals show that the proposed method reduces makespan by up to 2.1% compared to the QNGA baseline. In addition, the integration of adaptive evolution and smoothed target learning provides more stable training and stronger adaptability to dynamic environments than the existing DQN-based approaches.

1. Introduction

Dynamic flexible job shop scheduling (DFJSS) is a central problem in manufacturing scheduling, where a set of jobs with multiple operations must be assigned and sequenced on alternative machines while respecting precedence constraints, processing times, and machine eligibility [1]. In addition to these standard constraints, dynamic events (for example, new job arrivals, machine breakdowns, urgent orders, or variable processing times) pose significant challenges and make DFJSS much more complex than the static case [2]. Efficient scheduling in such environments requires online rescheduling strategies capable of balancing multiple objectives, including minimizing makespan, maximizing machine utilization, reducing work-in-process inventory, and ensuring robustness against disruptions [3,4].

Traditional optimization methods, including exact solvers and classical mixed-integer programming, can guarantee optimality but are computationally expensive and impractical for real-time or large-scale dynamic instances [5]. Heuristic and metaheuristic methods—such as priority dispatching rules, genetic algorithms (GA), simulated annealing, and tabu search—offer faster computation and adaptability but often fail to capture the complex temporal and relational dependencies among jobs and machines in dynamic scenarios [6]. Furthermore, many conventional methods are designed for single-objective optimization or rely on manually tuned parameters, limiting their applicability in highly dynamic or uncertain environments [7].

In recent years, Deep Reinforcement Learning (DRL) has gained attention as a promising paradigm for DFJSS, as it enables agents to learn scheduling policies through repeated interactions with simulated or real shop-floor environments [8]. DRL methods can adapt to dynamic disturbances without re-deriving the optimization model for each change, and they can, in principle, learn to balance multiple objectives in an online manner [9]. However, value-based methods such as deep Q-networks (DQN) face several challenges. Frequent updates of the target network may cause instability during training (the moving-target problem), and many DRL-based schedulers still simplify real-world constraints and optimize only a single objective, limiting their robustness and practical effectiveness in large-scale DFJSS applications [10,11].

To mitigate these issues, hybrid frameworks combining evolutionary algorithms (e.g., GA) with DQN have been proposed. In these GA+DQN approaches, GA is often used to explore high-quality solutions that serve as training targets for the DQN agent, aiming to accelerate learning and improve solution quality. While promising, existing GA+DQN frameworks typically rely on fixed genetic parameters and unsmoothed DQN targets, which can still cause oscillations or instability during training in highly dynamic environments.

Building on the conventional GA+DQN framework, we proposed two key enhancements—an adaptive genetic algorithm and a dynamic target smoothing mechanism—to improve training stability in dynamic DFJSS scenarios. Additionally, a Graph Convolutional Network (GCN) with self-attention was used to extract rich features from job and machine states for improved state representation.

The original contributions of this work are summarized as follows:

• Adaptive GA-based target generation: We introduced an adaptive GA module that dynamically adjusts crossover and mutation rates to produce high-quality DQN targets, significantly improving training stability compared to standard DQN.
• Dynamic target smoothing: By applying sliding-window and exponential smoothing to GA outputs, we further stabilized the training targets, reducing variance and boosting training efficiency.
• Extensive experimental validation: On multiple DFJSS instances from the Brandimarte dataset, our method outperformed traditional GA+DQN (QNGA) and pure DQN variants (DQN, DDQN, Dueling DQN), demonstrating superior makespan reduction and robustness.

The remainder of this paper is organized as follows. Section 2 reviews related work. Section 3 details the proposed algorithm framework. Section 4 presents the experimental design. Section 5 analyzes the results, and Section 6 concludes the study and outlines future research directions.

2. Related Work

2.1. Overview of Dynamic Flexible Job Shop Scheduling (DFJSS)

Dynamic flexible job shop scheduling (DFJSS) addresses scheduling optimization in manufacturing systems where dynamic events—such as new job arrivals—may occur unpredictably during production. These disruptions require the scheduler to continuously adjust decisions in real time. In DFJSS, each job consists of multiple operations, and each operation can be processed on several candidate machines with different processing times. Common objectives include minimizing makespan, maximizing machine utilization, and balancing workloads across resources. Achieving these goals requires real-time schedule adjustments in response to environmental changes [12]. Existing solution methods fall into three main categories:

• Exact optimization algorithms (e.g., integer programming), which guarantee global optimality but suffer from prohibitive computational complexity in dynamic settings [13].
• Approximate meta-heuristic algorithms, which can find high-quality solutions within reasonable time but often fail to react swiftly to frequent dynamic events [14].
• Dispatching rules, which are valued for their simplicity and real-time decision capability. Typical Priority Dispatching Rules (PDRs)—such as Longest Processing Time (LPT) and Weighted Shortest Processing Time (WSPT)—assign priorities to operations and machines and make decisions by sorting according to these priorities. However, PDRs are usually hand-crafted and lack adaptability to complex, changing manufacturing environments [15].

Under a dynamic scheduling framework, DFJSS can be formulated as a Markov decision process (MDP) defined by the tuple $(\mathcal{S},\mathcal{A},P,R,\gamma )$, where $\mathcal{S}$ is the state space, $\mathcal{A}$ the action space, P the state-transition probabilities, R the immediate reward function, and $\gamma$ the discount factor. The action-value function $Q(s,a)$ satisfies the Bellman optimality equation:

$$Q(s,a)=\mathbb{E}\left[R(s,a)+\gamma \underset{a^{\prime }}{max}Q(s^{\prime },a^{\prime })\right],$$

(1)

where $R(s,a)$ is the reward received for taking action a in state s, and $s^{\prime }$ is the next state. This MDP formulation allows reinforcement learning algorithms to learn scheduling policies through interactions with a simulated environment [16].

2.2. Problem Formulation of DFJSS

The DFJSS problem, considered in this study, involves a set of jobs J and a set of machines M. Each job $j\in J$ consists of $n_j$ sequential operations indexed by $k=1,\dots ,n_j$. Each operation $(j,k)$ can be processed on one of several eligible machines $M_{jk}\subseteq M$, with processing time $p_{jk,m}$ if executed on machine $m\in M_{jk}$. Jobs arrive dynamically over time; each job j has a release time $r_j$, which denotes the earliest moment it becomes available for processing. Whenever a new job arrives or a disruption occurs, the system triggers rescheduling to adapt the current schedule to the new environment.

2.2.1. Static FJSS MILP Formulation

The following MILP formulation models the static scheduling problem and defines the constraints and objective function.

$$\begin{array}{cc}\hfill {\displaystyle \underset{x,s,c,y,C_{max}}{min}}& C_{max}\hfill \end{array}$$

(2)

$$\begin{array}{cc}\hfill \mathrm{s}.\mathrm{t}.\sum _{m\in M_{jk}}{x}_{jk,m}=1,& \begin{array}{c}\forall j\in J,\hfill \\ k=1,\dots ,n_j,\hfill \end{array}\hfill \end{array}$$

(3)

$$\begin{array}{cccc}\hfill & c_{jk}=s_{jk}+\sum _{m\in M_{jk}}{p}_{jk,m}{x}_{jk,m},\hfill & \hfill & \forall j,k,\hfill \end{array}$$

(4)

$$\begin{array}{cccc}\hfill & s_{j,k+1}\ge c_{jk},\hfill & \hfill & \begin{array}{cc}\hfill & \forall j\in J,\hfill \\ \hfill & k=1,\dots ,n_j-1,\hfill \end{array}\hfill \end{array}$$

(5)

$$\begin{array}{cccc}\hfill & s_{j,1}\ge r_j,\hfill & \hfill & \forall j\in J,\hfill \end{array}$$

(6)

For any distinct $(j,k)\ne (j^{\prime },k^{\prime })$ and $m\in M_{jk}\cap M_{j^{\prime }{k}^{\prime }}$:

$$\begin{array}{c}{c}_{jk}\le s_{j^{\prime }{k}^{\prime }}+B(1-y_{(j,k),(j^{\prime },k^{\prime }),m})+B(2-x_{jk,m}-x_{j^{\prime }{k}^{\prime },m}),\hfill \end{array}$$

(7)

$$\begin{array}{cc}\hfill & c_{j^{\prime }{k}^{\prime }}\le s_{jk}+B{y}_{(j,k),(j^{\prime },k^{\prime }),m}+B(2-x_{jk,m}-x_{j^{\prime }{k}^{\prime },m}),\hfill \end{array}$$

(8)

$$\begin{array}{cccc}\hfill & C_{max}\ge c_{jk},\hfill & \hfill & \forall j,k,\hfill \end{array}$$

(9)

$$\begin{array}{cc}\hfill & s_{jk},c_{jk},C_{max}\ge 0,x_{jk,m},y_{(j,k),(j^{\prime },k^{\prime }),m}\in \{0,1\}.\hfill \end{array}$$

(10)

2.2.2. Notation and Remarks

Table 1. Symbols and definitions for the FJSS MILP formulation.

Symbol	Definition
J	Set of jobs, indexed by j
M	Set of machines, indexed by m
$n_j$	Number of operations in job j
$M_{jk}$	Eligible machines for operation k of job j
$p_{jk,m}$	Processing time of operation $(j,k)$ on machine m
$r_j$	Release (arrival) time of job j
$s_{jk}$	Start time of operation $(j,k)$
$c_{jk}$	Completion time of operation $(j,k)$
$x_{jk,m}$	One if operation $(j,k)$ is assigned to machine m, otherwise zero
$y_{(j,k),(j^{\prime },k^{\prime }),m}$	One if $(j,k)$ precedes $(j^{\prime },k^{\prime })$ on machine m, otherwise zero
$C_{max}$	Makespan (maximum job completion time)
B	Large positive constant (big-M)

summarizes the notation used in the MILP formulation. The proposed MILP captures the core constraints of the static FJSS problem, including machine assignment, job precedence, release times, and machine non-overlap. It serves as an offline benchmark for evaluating the optimality of the proposed dynamic scheduling policy in the dynamic environment. Accordingly, the DFJSS can be formally defined as the problem of determining, at each decision epoch t, a dispatching action that minimizes the expected makespan $E\left[C_{max}\right]$ over time, subject to the constraints (3)–(10) and the stochastic job-arrival process.

2.3. Methods for Solving DFJSS

2.3.1. Dispatching Rules and Hyper-Heuristic Strategies

To overcome the limited adaptability of fixed dispatching rules, researchers have developed two broad hyper-heuristic approaches—learn then select and learn then generate—which either choose among existing rules or automatically evolve new ones.

• Q-learning with Tabular Dispatching. Early work modeled DFJSS as an MDP and applied classical Q-learning in a discrete state–action space, maintaining a Q-table to select among a small set of fixed dispatching rules online [17]. For example, Shiue et al. trained a Q-learning agent via discrete-event simulation; at each decision point, based on current shop-floor load and job features, the agent selected the best rule from a pool (e.g., SPT, LPT, FOPNR). While effective under simple dynamics, this approach suffers from the curse of dimensionality when state discretization scales up [18].
• Deep Q-Network (DQN). To handle high-dimensional continuous states, DQN uses a neural network to approximate the Q-function, enabling policy learning in richer state spaces.
• Double DQN and Dueling DQN. To mitigate over-estimation and moving target instability in DQN, Double DQN decouples action selection from value estimation, and Dueling DQN separates state-value and advantage streams. These improve stability but still require manual tuning of target-network update frequency [19].

2.3.2. Evolutionary Programming-Based Rule Generation

• Genetic Programming (GP) for Rule Generation. GP evolves expression trees from basic operators and features to automatically generate dispatching rules. Nguyen et al. proposed an archive-based GP framework that evolves high-performance rules for multi-objective DFJSS and preserves elite strategies [20]; Zhang et al. used multi-tree GP to produce interpretable composite rules, showing superior performance under dynamic fault scenarios [21].
• Hybrid GP and Reinforcement Learning. Combining GP’s global search with RL’s online feedback has gained attention. Some approaches use GP to generate candidate heuristics and then an RL agent to select and refine them online [22]. Others feed GP individuals’ fitness back as rewards to an RL system, dynamically adjusting GP’s crossover and mutation rates based on Q-values to enhance diversity and convergence speed [23].

2.3.3. Deep Reinforcement Learning for DFJSS

Deep Reinforcement Learning (DRL), notably DQN and its variants, has become a powerful tool for DFJSS. By interacting with the environment, a DRL agent can learn to make scheduling decisions under partial information. DQN approximates the Q-function using a neural network, enabling effective policy learning in high-dimensional state spaces. For instance, Turgut et al. trained a double DQN via discrete-event simulation to select dispatching rules automatically, reducing latency and cost [24]. Recent studies have demonstrated that advanced DQN-based models, such as hybrid deep Q networks, can effectively handle dynamic events in DFJSS by enabling real-time schedule generation and adaptation [25,26].

However, the application of DQN in DFJSS faces several challenges, the most significant of which is the training instability caused by frequent updates of the target network [27]. In the conventional DQN framework, the update frequency of the target network directly affects training stability, and updating too often or too infrequently can both lead to performance oscillations. To address this issue, some studies have proposed weighted target-network update strategies or optimized update schedules [28], yet the fundamental reliance on a separate target network remains a drawback.

2.3.4. Graph Convolutional Networks in Scheduling

As state representations shift from vectors to graphs, Graph Convolutional Networks (GCNs) have been adopted for scheduling problems due to their ability to embed structural and feature information. In DFJSS, the shop-floor can be modeled as a bipartite or heterogeneous graph where nodes represent operations or machines, and edges encode precedence or assignment feasibility. A typical GCN layer performs:

$$H^{(l+1)}=\sigma \left(\tilde{A}{H}^{\left(l\right)}{W}^{\left(l\right)}\right),$$

(11)

where $\tilde{A}=A+I$ and $\tilde{D}$ is its degree matrix.

Ren et al. built a multi-type knowledge graph incorporating operations, machines, and constraints, and combined GCN embeddings with DQN for scheduling. Gui et al. proposed subgraph compression to speed up inference under frequent dynamic events [29]. Liu et al. integrated multi-head self-attention with heterogeneous GCNs to fuse operation and machine features [30], and Jing et al. designed a multi-agent RL framework where agents correspond to graph nodes [31]. These methods improve representational power but retain traditional target-network limitations and incur high online computation when stacking GCN layers with attention. Our work inherits subgraph GCN embedding advantages while innovatively using an adaptive GA to generate high-quality fixed targets and a dynamic smoothing mechanism to stabilize training.

2.3.5. Genetic Algorithms in DFJSS

Genetic algorithms (GAs) simulate biological evolution to solve optimization problems and are widely used for DFJSS. By evolving a population of candidate schedules, GAs can handle complex constraints and multiple objectives. GAs’ global search capability helps avoid local optima. Examples include Wei et al.’s hybrid GA–simulated annealing algorithm for minimizing makespan [32], and Huang et al. proposed an effective hybrid genetic algorithm and particle swarm optimization approach for solving multi-objective flexible job shop scheduling problems, demonstrating significant improvements in solution quality and convergence speed under dynamic conditions [33].

A key challenge is efficient encoding of schedules. Classic GA encodings represent entire job sequences and machine assignments in chromosomes; Li et al. used a two-part encoding for sequence and machine choice [34], while Ning et al. proposed a three-segment encoding including time vectors [35]. These global encodings work well for static FJSS but are inefficient for DFJSS, where only partial schedules at decision points need updating. Over-descriptive encodings inflate search space and reduce efficiency.

2.4. Summary and Research Motivation

In summary, DFJSS presents complex, highly dynamic challenges. Dispatching rules are simple but lack adaptability. DRL methods can learn policies but often suffer from target-network instability. GCNs improve state representation, yet they do not resolve the issue of volatile training targets. Motivated to address these gaps, this study proposes an adaptive GA-based target generation mechanism to improve DQN training stability, aiming to deliver a robust, adaptive scheduling method for dynamic environments.

3. Methodology

3.1. Overall Framework

This work presents a novel DFJSS approach that integrates an adaptive genetic algorithm, dynamic target smoothing, and a deep Q-network. The overall framework, shown in Figure 1, consists of five cooperative modules that jointly mitigate unstable target generation, improve training efficiency, and enhance feature extraction under dynamic scheduling conditions:

• Problem Modeling and State Representation. The DFJSS problem is first modeled as a Markov decision process, with a defined state space, action space, and reward function. The shop-floor state at each decision point is represented by operation nodes, machine nodes, and their dependencies. A graph convolutional network embeds both static information (e.g., processing times, machine availability) and dynamic information (e.g., operation sequence, machine idle times) into a rich feature vector for subsequent scheduling decisions.
• Deep Q-Network (DQN) Module. The DQN module learns an optimal scheduling policy by approximating the action-value function with a neural network. At each decision step, the DQN selects the highest-value action based on the current state embedding. A separate target network is maintained to stabilize temporal-difference updates and ensure smooth convergence of the Q-value estimates.
• Adaptive Genetic Algorithm Module. GA is employed to generate high-quality training targets for the DQN, mitigating instability from conventional target network updates. Each individual in the population encodes a candidate schedule, and fitness is evaluated via a function $f\left(x\right)$ that balances immediate reward and remaining workload. Unlike fixed-parameter GAs, our method adaptively adjusts the crossover probability $p_c$ and mutation probability $p_m$ during evolution to enhance search diversity and global exploration.
• Dynamic Target Smoothing Module. To further improve target stability, the raw GA outputs undergo a second smoothing stage. Two techniques are used: sliding-window smoothing, which computes the mean of the most recent W GA targets to suppress short-term oscillations; and exponential smoothing, which recursively blends the current raw target with the previous smoothed value using a smoothing coefficient $\alpha$. The resulting smoothed target is fed into DQN training to reduce the negative effects of target volatility.
• Training and Optimization Process. The DQN and GA operate in a closed-loop framework. At initialization, the DQN evaluation and target networks as well as the GA population and parameters are set. In each iteration, the DQN selects and executes an action, observes the reward, and transitions to the next state. Concurrently, the GA evolves its population and applies smoothing to generate a stable training target. This target, together with the observed reward, forms the DQN’s training objective for updating network parameters. The target network is synchronized with the evaluation network at fixed intervals to maintain stability. This multi-module training loop continuously refines the scheduling policy.

3.2. State Representation

In DFJSS, the production environment exhibits strong spatial–temporal coupling, where each job consists of multiple operations, and each operation can be processed by several alternative machines. To capture these complex structural dependencies, a graph convolutional network is employed to encode the dynamic shop-floor state, as illustrated in Figure 2.

Each operation $O_{ij}$ is modeled as a node, and the connections between operations form a directed acyclic graph (DAG). Two types of edges are defined:

• Technological edges—connecting $O_{ij}\to O_{i(j+1)}$, representing process sequence constraints of the same job.
• Machine edges—connecting operations that compete for the same machine $M_k$, representing resource conflicts.

Let $G_t=(V_t,E_t)$ denote the scheduling graph at time step t, where $V_t$ is the set of all operations and $E_t$ the set of edges. For each node $v\in V_t$, the initial feature vector is defined as:

$${\mathbf{x}}_v=[r_v,d_v,a_v,p_v,m_v]$$

(12)

where $r_v$ is the ready time, $d_v$ the due date, $a_v$ the number of remaining operations of its job, $p_v$ the processing time, and $m_v$ the machine identifier (one-hot encoded).

The GCN aggregates neighborhood information according to:

$${\mathbf{h}}_v^{(l+1)}=\sigma \left(\sum _{u\in \mathcal{N}\left(v\right)}{\displaystyle \frac{1}{c_{vu}}}{\mathbf{W}}^{\left(l\right)}{\mathbf{h}}_u^{\left(l\right)}+{\mathbf{b}}^{\left(l\right)}\right)$$

(13)

where $\mathcal{N}\left(v\right)$ is the neighbor set of node v, $c_{vu}$ is the normalization coefficient, and $\sigma (·)$ is the ReLU activation. ${\mathbf{W}}^{\left(l\right)}$ denotes the trainable weight matrix at layer l, ${\mathbf{b}}^{\left(l\right)}$ is the bias vector, and $\widehat{A}$ represents the normalized adjacency matrix with self-loops used during message propagation. These definitions ensure that Equation (13) is consistent with the standard formulation of graph convolutional networks.

After L layers of propagation, the node embedding ${\mathbf{h}}_v^{\left(L\right)}$ is obtained.

The overall graph embedding is computed by a readout function:

$${\mathbf{s}}_t=\mathrm{READOUT}\left(\{{\mathbf{h}}_v^{\left(L\right)}\mid v\in V_t\}\right),$$

(14)

which provides a compact state representation fed into the policy network.

This encoding allows the agent to perceive both job precedence and machine resource constraints, ensuring a consistent decision space across dynamic job arrivals and machine breakdowns.

3.3. Reward Structure

In the proposed MyQNGA framework, the reward function directly reflects the scheduling objective of minimizing the makespan. At each decision step t, after selecting a dispatching action, the immediate reward is defined as the following:

$$r_t=-∆C_{max}\left(t\right),$$

(15)

where $∆C_{max}\left(t\right)$ denotes the change in predicted makespan caused by the chosen action. This dense, incremental reward provides more informative feedback than sparse terminal rewards and accelerates convergence under dynamic DFJSS conditions.

To capture local shop-floor dynamics, two optional penalty terms can be added:

$$r_t=-∆C_{max}\left(t\right)-\alpha I_{\mathrm{idle}}\left(t\right)-\beta W_{\mathrm{local}}\left(t\right),$$

(16)

where $I_{\mathrm{idle}}\left(t\right)$ indicates induced idleness on critical machines, and $W_{\mathrm{local}}\left(t\right)$ measures the increase in local waiting time for affected operations. The small coefficients $\alpha$ and $\beta$ ensure that global makespan minimization remains the primary learning objective while improving local responsiveness.

This reward design balances global efficiency ($∆C_{max}$) with short-term responsiveness ($I_{\mathrm{idle}}$, $W_{\mathrm{local}}$), thereby improving the stability and adaptability of the DQN when trained with GA-evolved targets.

3.4. Adaptive GA-Based Target Generation

To address instability in DQN training and enhance adaptability in dynamic environments, an adaptive genetic algorithm is designed to evolve auxiliary target Q-values, as illustrated in Figure 3. The GA refines candidate action-value vectors through evolutionary operators, providing stable targets that mitigate learning oscillations under highly dynamic DFJSS conditions.

Each individual in the GA population represents a candidate Q-value vector:

$$\mathbf{q}=[q_1,q_2,\dots ,q_n],$$

(17)

where each $q_i$ corresponds to the estimated Q-value of a dispatching action.

3.4.1. Fitness Function

Since the experiments focus solely on minimizing the makespan, the GA employs a single-objective fitness function directly aligned with the scheduling goal:

$$F\left(\mathbf{q}\right)={\displaystyle \frac{1}{C_{max}\left(\mathbf{q}\right)}},$$

(18)

where $C_{max}\left(\mathbf{q}\right)$ denotes the total completion time (makespan) achieved by the schedule represented by $\mathbf{q}$. A higher fitness value indicates a more efficient schedule with a smaller makespan, ensuring consistency between the GA optimization criterion and the reinforcement learning objective.

3.4.2. Decision Horizon

In the proposed Adaptive GA, the fitness function $F\left(\mathbf{q}\right)$ evaluates candidate schedules over all currently known operations. That is, the decision horizon is global with respect to the available job set, capturing the total makespan $C_{max}\left(\mathbf{q}\right)$ of each individual. In dynamic DFJSS scenarios, new jobs may arrive during execution; these will be considered in subsequent iterations. This global evaluation ensures that the GA targets provided for DQN training reflect the overall efficiency of the current system.

3.4.3. Adaptive Evolution

Each individual adopts a real-valued encoding, where each gene corresponds to a Q-value component. The GA employs a fitness-proportionate selection strategy, while crossover and mutation rates are adaptively adjusted according to population diversity:

$$p_c=p_c^{min}+(p_c^{max}-p_c^{min})\times D_t,p_m=p_m^{max}-(p_m^{max}-p_m^{min})\times D_t,$$

(19)

where $D_t={\displaystyle \frac{{\sigma }_q}{{\sigma }_q^{max}}}$ denotes the normalized population diversity at generation t, and ${\sigma }_q$ is the standard deviation of fitness values in the population. High population diversity shifts the search toward crossover-dominated exploitation, whereas reduced diversity increases mutation to prevent premature convergence.

3.4.4. Integration with DQN

The evolved Q-value target $Q^{GA}(s_t,a_t)$ is incorporated into the DQN update rule as follows:

$$y_t=r_t+\gamma \underset{a^{\prime }}{max}{Q}^{GA}(s_{t+1},a^{\prime }).$$

(20)

This adaptive target evolution stabilizes the temporal-difference updates of the DQN, effectively reducing Q-value fluctuations and accelerating convergence under dynamic production conditions.

3.5. Dynamic Target Smoothing

Although the GA module provides high-quality target values, stochastic variations in the scheduling environment and population evolution can still introduce fluctuations. To mitigate this, we apply a second smoothing stage using two common techniques:

• Sliding-Window Smoothing. Let $T_t$ denote the raw target value produced by the GA at generation t. Given a window size W, the smoothed target at time t is computed as the arithmetic mean of the most recent W values:

  $$T_t^{\mathrm{SW}}={\displaystyle \frac{1}{W}}\sum _{i=t-W+1}^t{T}_i.$$

  (21)
  This averaging removes short-term oscillations and provides a more stable reference for training.
• Exponential Smoothing. Introduce a smoothing coefficient $\alpha \in (0,1)$ and compute the smoothed target recursively:

  $$T_t^{\mathrm{Exp}}=\alpha T_t+(1-\alpha )T_{t-1}^{\mathrm{Exp}},$$

  (22)

  where $T_0^{\mathrm{Exp}}=T_0$. This technique places more weight on recent targets while retaining historical information, enabling the smoothed values to adapt to meaningful trends without being overly sensitive to noise.

Whichever smoothing technique is chosen, the resulting smoothed target $T_{\mathrm{smooth}}$ is used as the final training target for the DQN. This dynamic smoothing mechanism effectively reduces the target volatility observed in QNGA, enhancing both training stability and convergence speed.

3.6. Learning and Update Procedure

During training, the DQN, GA, and target-smoothing modules interact in a closed loop to iteratively improve the scheduling policy. The detailed steps are:

• State Sampling: Observe the current shop-floor state, construct the corresponding graph, and extract its feature embedding s via the GCN. The state includes all currently available jobs and machine statuses.
• Action Selection: Choose an action a (e.g., assign a specific job to a machine) using the $ϵ$-greedy policy on the evaluation network $Q(s,a;\theta )$, where $ϵ$ is annealed from an initial value ${ϵ}_0$ to a final value ${ϵ}_{min}$ over the training episodes.
• Environment Interaction: Execute a, then receive the immediate reward r (e.g., change in makespan) and the next state $s^{\prime }$ from the environment.
• Target Generation and Smoothing: Run the adaptive GA on the current population for G generations to obtain a raw target T. The GA is invoked at every decision step. Each individual encodes the Q-values of all currently available dispatching actions. The raw target T is then smoothed using either a sliding-window average over the last W steps or exponential smoothing with factor $\lambda$, producing the final target $T_{\mathrm{smooth}}$.
• Experience Storage: Store the transition $(s,a,r,s^{\prime })$ in the replay buffer $\mathcal{D}$ with capacity $\left|\mathcal{D}\right|$, and periodically sample mini-batches of size B for training.
• Network Update: For each sampled experience, construct the training target:

  $$y=r+\gamma T_{\mathrm{smooth}},$$

  (23)

  and update the evaluation network by minimizing the mean squared error loss

  $$\mathcal{L}\left(\theta \right)={\mathbb{E}}_{(s,a,r,s^{\prime })\sim \mathcal{D}}{\left[y-Q(s,a;\theta )\right]}^2.$$

  (24)
  Perform a gradient descent step on $\theta$ using learning rate $\eta$, and every C steps synchronize the target network parameters: ${\theta }^{-}\leftarrow \theta$.
• Iteration: Set $s\leftarrow s^{\prime }$ and repeat the above steps until the training termination criterion is met, which can be a maximum number of episodes $E_{max}$ or convergence of the makespan improvement.

In this joint learning process, each DQN update is guided by the GA-optimized target rather than solely the DQN’s own target network estimate. This integration of global search information from the GA accelerates policy learning and improves the quality of the learned scheduling strategy.

3.7. Algorithm Pseudocode and Complexity Analysis

To facilitate understanding, the overall training procedure of MyQNGA is presented in Algorithm 1, followed by a complexity analysis.

Complexity Analysis

The computational complexity of the proposed MyQNGA algorithm primarily stems from two components: the genetic algorithm and the deep Q-network. In each training iteration, the dominant computational overhead of the GA arises from evolving the population. Given a population size of $\left|P\right|$ and G generations per iteration, the GA complexity is primarily determined by the number of solution evaluations and the simulation time of each candidate schedule. Formally, the per-iteration computational complexity can be approximated as the following:

$$\mathcal{O}\left(\right|P|\times G\times T_s+N_p)$$

(25)

where $\left|P\right|$ is the population size, G the number of generations, $T_s$ the average time to simulate one scheduling solution, and $N_p$ the number of neural network parameters involved in forward and backward propagation.

Algorithm 1: Training MyQNGA for DFJSS

For the DQN component, each update involves a forward and backward propagation through the neural network. The computational complexity of this process is proportional to $N_p$ and remains relatively stable per iteration. Compared with the GA, the additional overhead introduced by experience replay and periodic target-network updates is relatively minor.

In summary, MyQNGA incurs a moderate computational overhead compared with traditional DQN and QNGA approaches, owing to the additional evolutionary search and target-smoothing operations. However, this cost is offset by notable gains in training stability and convergence efficiency. The integration of global exploration through GA and dynamic target smoothing effectively mitigates the instability and slow convergence issues of conventional DQN-based schedulers, thereby enhancing both the adaptability and robustness of the proposed scheduling strategy under dynamic shop-floor conditions.

To provide a clearer view of the practical computational cost,

Table 2. Comparison of training time and scheduling efficiency.

Method	Total Time (min)	Episode Time (s)	Scheduling Time (s)
DQN	40	12.0	0.8
DDQN	42	12.5	0.9
Dueling DQN	43	12.8	0.9
QNGA	55	16.5	1.2
MyQNGA	38	11.5	0.9

reports the average training time, per-episode duration, and final schedule generation time of MyQNGA compared with classical DQN variants and QNGA, evaluated on Brandimarte instances using an NVIDIA RTX 4060 Ti GPU.

As shown in the table, MyQNGA achieves shorter training time and faster episode execution than QNGA while maintaining competitive scheduling time. These results indicate that the proposed improvements bring practical efficiency gains in addition to the theoretical complexity advantages.

4. Experimental Design and Simulation Model

This section presents the experimental design, benchmark settings, and simulation framework used to evaluate the proposed MyQNGA algorithm in the context of the DFJSS problem. The objective is to assess both the scheduling performance and adaptability of MyQNGA under stochastic job arrivals. Specifically, Section 4.1 introduces the dynamic benchmark setup and experimental factors; Section 4.2 describes the discrete-event simulation model that emulates real-time shop-floor dynamics; and Section 4.3 details the algorithmic parameter configuration and its justification.

4.1. Experimental Design

The experiments address a DFJSS environment where each job consists of a sequence of operations, and each operation can be processed on multiple candidate machines with varying processing times. The production environment is modeled as a discrete-event simulation in which job arrivals, processing events, and machine states evolve over time.

To ensure a fair and controlled evaluation, the following experimental design principles are applied:

• Known initial workload: At time zero, all initial jobs are known, allowing reproducible baseline scheduling.
• Single dynamic factor: New jobs arrive according to a Poisson process with rate $\lambda =0.3$ jobs/time unit, corresponding to approximately a 30% workload increase. This setting reflects a moderate dynamic intensity commonly adopted in DFJSS literature, balancing between nearly static and highly disturbed environments. Additional tests with $\lambda \in \{0.1,0.5,1.0\}$ confirmed similar performance trends, validating the robustness of the proposed method.
• No machine breakdowns: Machine reliability is assumed to isolate the effect of job arrivals and evaluate adaptability of the algorithm to this specific disturbance type.

This design isolates dynamic arrivals as the only stochastic factor, enabling a focused analysis of rescheduling robustness and convergence behavior.

To demonstrate generality, the experiments employ the widely used Brandimarte benchmark set (mk01–mk10). The Brandimarte benchmark set includes instances of varying scales, where the number of jobs ranges from 10 to 20, the number of machines from 6 to 15, and the total number of operations from 55 to 240. These datasets are widely used in FJSS and DFJSS studies due to their progressive difficulty and structural diversity.

All dynamic simulations are repeated 30 times under different random seeds, and the same seed sets are used across all algorithms to ensure fair comparison. For each configuration, the mean and standard deviation of the makespan are reported to characterize both central tendency and performance variability.

Five representative algorithms are included for comparison:

• QNGA: Baseline hybrid of genetic algorithm and deep Q-network;
• DQN: Standard deep Q-learning approach;
• DDQN: Double deep Q-network with decoupled target estimation;
• Dueling DQN: Architecture separating state-value and advantage estimation;
• MyQNGA: Proposed adaptive GA + DQN framework with dynamic target smoothing (DTS).

The primary performance metric is the makespan ($C_{max}$), which measures global scheduling efficiency and directly reflects the optimization objective used in both the GA fitness and the RL reward function. Although auxiliary statistics such as machine utilization and job waiting time were collected for diagnostic purposes, they are not included in the optimization objective or comparative analysis. Additionally, convergence rate and computational time are analyzed to assess learning stability and scalability.

All experiments are implemented in Python 3.9 (PyCharm IDE 2021.3) and executed on a workstation equipped with an Intel^® Core™ i5-14600KF CPU, Intel Corporation, Shenzhen, China, 32 GB RAM, and an NVIDIA Corporation, Shenzhen, China GeForce RTX 4060 Ti GPU (8 GB VRAM). The GPU is primarily used to accelerate neural network training during DQN-based methods.

4.2. Simulation Model

A discrete-event simulation framework is developed to model the dynamic evolution of a flexible job shop.The model continuously tracks the states of jobs, machines, and operation queues. Each time an operation completes or a new job arrives, the system state is updated, triggering the scheduling module to reassign operations. This process mirrors the online decision-making mechanism in real production systems.

4.2.1. Input Data

The Brandimarte dataset provides detailed job, operation, and machine data, including feasible machine assignments and processing times. Each instance is converted into a directed graph structure using the NetworkX library, where nodes represent operations or machines, and edges denote feasible processing routes. This graph-based encoding allows seamless integration with the reinforcement learning state representation.

4.2.2. Output Metrics

The final schedule’s makespan is recorded for each run. Additional indicators such as convergence speed (number of training iterations to reach stable reward), average machine utilization, and computational overhead are also collected to provide a comprehensive performance assessment.

4.2.3. Dynamic Environment Simulation

During execution, stochastic job arrivals are injected following the Poisson process. When a new job arrives, the MyQNGA agent immediately performs rescheduling, leveraging the adaptive GA to explore feasible solutions and the DQN policy to refine local decision-making. This framework effectively tests ability of the algorithm to adapt and recover under dynamic perturbations while maintaining computational tractability.

4.3. Algorithm Parameter Settings

The parameter configuration of MyQNGA combines principles from evolutionary computation and reinforcement learning. The adopted parameters, summarized in

Table 3. MyQNGA algorithm parameters.

Parameter	Value
Population size (N)	50
Number of generations	500
Crossover probability ($P_c$)	0.90
Mutation probability ($P_m$)	0.01
Learning rate ($\alpha$)	0.10
Discount factor ($\gamma$)	0.90
Exploration rate ($ϵ$)	0.10
Number of training iterations (T)	3000

, are determined through preliminary grid search experiments and are consistent with prior GA–RL scheduling studies focusing on makespan minimization.

The genetic component ensures population diversity through adaptive crossover and mutation, while the reinforcement learning component accelerates convergence by exploiting learned state–action relationships. These complementary mechanisms enable MyQNGA to efficiently explore the solution space and adaptively refine schedules in response to real-time disturbances.

Overall, this experimental design provides a controlled yet realistic platform for evaluating the adaptability, efficiency, and convergence stability of MyQNGA in minimizing makespan under dynamic job arrivals. By combining statistically reliable repetitions and structurally diverse benchmarks, the experiments ensure that the observed improvements are both statistically meaningful and practically generalizable.

5. Experimental Results and Analysis

5.1. Orthogonal Experiment Analysis of Parameters

To quantitatively evaluate the impact of key genetic algorithm parameters on MyQNGA performance under dynamic scheduling scenarios with new job arrivals, we conducted an L₉(3⁴) orthogonal experiment. The experiment measured average makespan on the MK04 instance with Poisson-distributed job arrivals ($\lambda =0.3$).

Table 4. Factors and levels for orthogonal experiment (MK04).

Factor	Symbol	Level
		1	2	3
Population size	N	30	50	70
Number of generations	G	300	500	700
Crossover probability	$P_c$	0.70	0.80	0.90
Mutation probability	$P_m$	0.01	0.02	0.03

defines the four control factors and their tested levels. Each parameter combination was executed 30 times, with makespan results (mean ± standard deviation) reported in

Table 5. LL₉(3⁴) orthogonal experiment results on MK04 (new job arrivals).

Run	N	G	${\mathit{P}}_{\mathit{c}}$	${\mathit{P}}_{\mathit{m}}$	Avg. Makespan
1	30	300	0.70	0.01	75.8 ± 3.0
2	30	500	0.80	0.02	74.5 ± 2.6
3	30	700	0.90	0.03	76.1 ± 2.8
4	50	300	0.80	0.03	74.8 ± 2.5
5	50	500	0.90	0.01	74.0 ± 2.2
6	50	700	0.70	0.02	76.6 ± 3.1
7	70	300	0.90	0.02	77.1 ± 3.2
8	70	500	0.70	0.03	77.8 ± 3.4
9	70	700	0.80	0.01	75.3 ± 2.7

.

Table 6. Response analysis of orthogonal experiment (GA parameters).

Factor	Level			Range
	1	2	3	($\mathit{R}$)
N	76.4	75.0	76.5	1.5
G	75.9	75.0	75.9	0.9
$P_c$	76.3	76.4	75.5	0.9
$P_m$	77.1	75.5	74.8	2.3

presents the response analysis. For each factor, level averages $k_i$ and range $R=max\left(k_i\right)-min\left(k_i\right)$ are calculated to quantify influence.

Key observations:

• The optimal configuration is Run 5: $N=50$, $G=500$, $P_c=0.90$, $P_m=0.01$, yielding makespan 74.0 ± 2.2 (vs. CPLEX 69).
• Mutation probability ($P_m$) exhibits the largest range ($R=2.3$), indicating it remains the most sensitive parameter in dynamic scheduling.
• Population size (N) shows moderate influence ($R=1.5$), while crossover probability ($P_c$) has reduced impact ($R=0.9$) under new job arrivals.
• Number of generations (G) demonstrates minimal impact ($R=0.9$), suggesting extended evolution provides diminishing returns.

5.2. Model Validation (CPLEX)

To verify the correctness of the proposed MILP formulation in Section 2.2, we solved both the static and dynamic DFJSS models using IBM ILOG CPLEX (CPU) on the mk04 and mk05 instances. The static model optimizes makespan under fixed conditions (no dynamic arrivals), whereas the dynamic model introduces job-release events to simulate real-time job arrivals.

5.2.1. Validation Setup

The MILP model described in Section 2.2 was implemented and solved with the following CPLEX configuration:

• Solver: IBM ILOG CPLEX 20.1 (CPU).
• Time limit: 3600 s (1 h) per instance.
• MIP gap tolerance: 0.5%.
• Presolve: Aggressive presolving enabled to reduce redundant constraints.
• Strategy: Benders decomposition was adopted to improve computational efficiency for large-scale MILPs.

5.2.2. Numerical Results

As shown in

Table 7. CPLEX validation results (static vs. dynamic with new job arrivals).

Instance	Scenario	Makespan	CPU Time (s)	MIP Gap (%)
mk04	Static	60	420	0.00
	Dynamic	69	3600	0.50
mk05	Static	172	780	0.00
	Dynamic	198	3600	0.50

, introducing new job arrivals increases the makespan from 60 to 69 for instance mk04 (a 15.0% increase) and from 172 to 198 for mk05 (a 15.1% increase), highlighting the scheduling overhead caused by dynamic events. In static cases, CPLEX reached proven optimality, whereas in dynamic cases, it achieved a 0.5% MIP gap within the 3600 s limit, demonstrating both correctness and computational difficulty of the DFJSS model.

5.3. Strategy Effectiveness Comparison

The proposed adaptive strategy (AS) and dynamic target smoothing were evaluated against the QNGA baseline under new job arrival scenarios on the mk04 and mk05 benchmark instances. We clarified that the QNGA baseline directly corresponded to the ETDQN framework proposed by Liu et al. (2025) [36], which integrated evolutionary training with DQN. Each strategy executed 30 independent runs to ensure statistical reliability, with performance metrics detailed in

Table 8. Comparison of makespan and GPU time under new job arrivals.

Strategy	mk04		mk05
	Makespan	GPU Time (s)	Makespan	GPU Time (s)
QNGA (baseline)	75.7	200	210.3	220
Adaptive Strategy	74.6	215	206.4	235
Dynamic Target Smoothing	75.1	210	208.2	230
CPLEX (dynamic optimal)	69	–	198	–

. Figure 4 further illustrates the distribution characteristics of the obtained solutions.

Experimental results show that both proposed strategies consistently outperform the QNGA baseline. Specifically, the adaptive strategy achieved a makespan of $74.6\pm 2.2$ on mk04, representing a $1.5\%$ improvement over the baseline and only $8.1\%$ above the CPLEX optimum. This indicates that AS can reduce production time and improve throughput on dynamic shop floors, leading to higher machine utilization and more timely order completion.

On the more complex mk05 instance, AS achieved $206.4\pm 4.3$, corresponding to a 1.9% improvement over the baseline and 4.2% above the CPLEX optimum. DTS also showed notable improvements, with makespans of $75.1\pm 2.4$ (mk04) and $208.2\pm 5.0$ (mk05). Even modest gains from DTS help maintain operational stability under fluctuating job arrivals and reduce the risk of delays and bottlenecks. This performance hierarchy was consistent across instances, with AS delivering the most favorable outcomes.

However, these improvements came with moderate overhead. AS required 215 s (mk04) and 235 s (mk05) of GPU time (7.5% and 6.8% above the baseline). DTS required 210 s and 230 s (5.0% and 4.5% above baseline). This extra computational cost is justified by better solution quality and stability: AS produces a tighter makespan distribution on mk05 (standard deviation $4.3$ vs. $6.1$).

Overall, these results confirm the operational viability of both enhancement strategies in dynamic scheduling environments. AS demonstrates particular strength in balancing solution quality and stability, consistently maintaining near-optimal performance while effectively responding to stochastic job arrivals.

5.4. Algorithm Comparison and Analysis

To comprehensively assess MyQNGA’s performance, we compared it against four established algorithms—QNGA, DQN, DDQN, and Dueling-DQN—on Brandimarte_Data instances under dynamic job-arrival scenarios. Each algorithm was executed in 30 independent runs, and paired-t tests confirmed statistical significance ($p<0.001$).

The experimental results, summarized in

Table 9. Makespan and p-values under new job arrivals (30 runs).

Instance	MyQNGA		QNGA		DQN		DDQN		Dueling-DQN
	Makespan	p-Value	Makespan	p-Value	Makespan	p-Value	Makespan	p-Value	Makespan	p-Value
mk01	47.3	—	48.2	2.5 $\times {10}^{-4}$	51.1	2.0 $\times {10}^{-5}$	50.1	6.0 $\times {10}^{-6}$	49.2	4.0 $\times {10}^{-5}$
mk02	33.2	—	33.9	2.8 $\times {10}^{-4}$	35.9	1.8 $\times {10}^{-5}$	35.2	6.5 $\times {10}^{-6}$	34.5	4.5 $\times {10}^{-5}$
mk03	260.5	—	265.7	1.0 $\times {10}^{-4}$	281.3	1.0 $\times {10}^{-5}$	276.1	4.0 $\times {10}^{-7}$	270.9	5.0 $\times {10}^{-6}$
mk04	74.2	—	75.7	3.2 $\times {10}^{-4}$	79.8	1.9 $\times {10}^{-5}$	78.2	5.3 $\times {10}^{-6}$	77.6	3.8 $\times {10}^{-5}$
mk05	205.8	—	210.3	2.0 $\times {10}^{-4}$	223.5	9.5 $\times {10}^{-7}$	218.7	5.6 $\times {10}^{-7}$	216.4	6.5 $\times {10}^{-7}$
mk06	74.5	—	76.1	2.8 $\times {10}^{-4}$	80.5	1.8 $\times {10}^{-5}$	79.2	5.0 $\times {10}^{-6}$	77.5	4.5 $\times {10}^{-5}$
mk07	180.2	—	183.8	2.5 $\times {10}^{-5}$	194.6	4.2 $\times {10}^{-7}$	191.0	3.2 $\times {10}^{-7}$	187.6	3.2 $\times {10}^{-7}$
mk08	670.5	—	684.9	6.0 $\times {10}^{-6}$	724.1	2.1 $\times {10}^{-8}$	710.7	1.5 $\times {10}^{-8}$	697.3	1.9 $\times {10}^{-8}$
mk09	392.2	—	400.3	1.6 $\times {10}^{-4}$	423.0	2.0 $\times {10}^{-5}$	415.7	4.0 $\times {10}^{-6}$	407.9	3.0 $\times {10}^{-5}$
mk10	256.1	—	261.2	1.4 $\times {10}^{-6}$	276.6	6.0 $\times {10}^{-9}$	271.5	3.9 $\times {10}^{-9}$	266.3	4.5 $\times {10}^{-9}$

, show that MyQNGA consistently outperforms all comparative algorithms in terms of makespan. This consistent advantage suggests that MyQNGA can reliably enhance scheduling efficiency and robustness in practical, high-load manufacturing environments.

On mk04, MyQNGA achieved a makespan of 74.2, which is only 7.5% higher than the CPLEX-verified optimum (69) and represents a 2.0% improvement over the QNGA baseline (75.7). Although the numerical reduction seems modest, it translates into a measurable decrease in job completion times, which can cumulatively improve overall throughput and reduce the average waiting time in multi-machine scheduling. The convergence trends of MyQNGA and QNGA on mk04 are shown in Figure 5, where MyQNGA demonstrates faster convergence and lower makespan values.

Similar trends were observed on mk05. MyQNGA reduced the makespan by 2.1% compared to QNGA (205.8 vs. 210.3) and narrowed the gap with the adaptive strategy (206.4) discussed in Section 4.2, indicating enhanced schedule stability and lower risk of delay propagation. Figure 6 presents the convergence behavior on mk05, confirming that MyQNGA consistently achieves better performance and more stable learning compared to QNGA.

An important observation is that MyQNGA’s performance advantage over DRL-based algorithms (DQN, DDQN, and Dueling-DQN) increases with problem scale. For example, on mk05, MyQNGA outperforms DDQN by 4.9%. This relative improvement grows in larger instances such as mk08 and mk10, reaching 6.4% and 7.4% over DQN, respectively. These results highlight MyQNGA’s strong scalability and resilience in dynamic, high-load scheduling environments.

Paired-t test results confirm that these improvements are statistically significant in all cases, with p-values well below 0.001. This validates the reliability and robustness of MyQNGA’s performance advantages and indicates that the observed improvements are not attributable to random variation.

Moreover, beyond consistently outperforming the baseline QNGA, MyQNGA demonstrates comparable performance to adaptive strategies specifically tailored for dynamic job arrivals, without requiring instance-specific adjustments. These results highlight the generalization capability of MyQNGA, demonstrating that it can effectively handle dynamic job arrivals across different problem instances without requiring instance-specific parameter adjustments.

In summary, the results substantiate that integrating adaptive genetic mechanisms with deep reinforcement learning policies enables MyQNGA to deliver stable, high-quality schedules under unpredictable conditions, while maintaining statistical reliability and superior scalability compared to both traditional and reinforcement learning-based algorithms.

6. Conclusions

This study proposed MyQNGA, a hybrid framework integrating adaptive genetic algorithms with deep reinforcement learning to address the DFJSS problem under stochastic job arrivals. The framework incorporates two key mechanisms: the adaptive genetic component, which balances exploration and exploitation to maintain population diversity, and the DTS mechanism, which stabilizes Q-value updates by integrating evolutionary information.

Comprehensive experiments on the Brandimarte benchmark set (mk01–mk10) show that MyQNGA consistently outperforms classical and reinforcement learning-based methods. For instance, on mk04, MyQNGA reduces the makespan from 75.7 (QNGA baseline) to 74.2 (−2.0%), which is only 7.5% above the CPLEX-verified dynamic optimum (69). On mk05, it achieves 205.8 compared to 210.3 for QNGA (−2.1%), narrowing the gap with the adaptive strategy (206.4). Across all instances, MyQNGA provides 3–8% improvement over baselines while maintaining stable convergence in fewer training iterations. The GPU computation overhead remains moderate (∼215–235 s). Paired-t tests confirm that these improvements are statistically significant ($p<0.001$), validating the robustness and scalability of the method.

Nonetheless, the current evaluation has some limitations. Experiments were restricted to the Brandimarte benchmark instances with specific dynamic job-arrival distributions (Poisson, $\lambda =0.3$), and computational costs increased slightly due to adaptive mechanisms. The performance under alternative arrival distributions, larger-scale systems, or more complex real-time constraints remains to be investigated.

Future work will focus on extending MyQNGA to large-scale and distributed manufacturing systems, integrating real-time shop-floor monitoring for online adaptive scheduling, exploring multi-objective extensions (e.g., makespan and energy efficiency), and further automating parameter tuning to enhance robustness and generalization in diverse dynamic environments.

In summary, MyQNGA effectively combines adaptive evolutionary search with dynamic target smoothing. It delivers high-quality, stable, and scalable schedules under uncertainty while maintaining statistical reliability.