acceptodds
Desk rejected at ICLR 2027

Any-scale Flexible Job Shop Scheduling via Dual-attention Proximal Policy Optimization

Desk rejected at ICLR 2027, so left out of the paper lists and the map.

Abstract

Flexible job shop scheduling (FJSS) plays a critical role in modern intelligent manufacturing systems. With the rapid development of industrial production environments, learning-based scheduling has emerged as a promising paradigm for learning effective scheduling policies from data and enabling fast decision-making. However, existing methods struggle to generalize across variable-sized instances, learn heterogeneous interactions among operations, machines, and processing-time information, and generate reliable decisions under dynamic scheduling constraints. To address these challenges, we propose a dual-attention proximal policy optimization framework for pre-training a generalizable neural scheduler across FJSS scales. Specifically, we introduce a dual-attention representation mechanism that explicitly models the heterogeneous interactions among operations, machines, and dynamically updated completion-time information. An online mask further incorporates scheduling information during sequential decision-making by masking infeasible actions, thereby improving decision reliability and training efficiency. The proposed framework is pre-trained on a large collection of synthetic FJSS instances with diverse job-machine configurations, using high-quality Google Operations Research Tools solutions to construct informative reward and advantage signals. Extensive experiments on 217 FJSS instances from six benchmark families and 129 large-scale synthetic instances, covering problem sizes from 3 × 2 to 100 × 100 (job by machine), demonstrate strong cross-family and cross-scale generalization, with the proposed framework consistently outperforming representative heuristics and state-of-the-art learning-based methods on unseen instances.

Primary area:
optimization
Keywords:
Flexible Job Shop Scheduling, Neural Combinatory Optimization, Transformer, PPO, Generalization, Scalability

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_uj3GOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper introduces an end to end DRL approach to solve the flexible job shop scheduling problem. It proposes a new dual attention network. It achieves lower makespan on different sized FJSP instances in comparison to benchmarked dispatching rules and two existing learning based approaches.

Critical strengths
  • The dual attention network is interesting. The architecture offers a new perspective on how one could transfer the state into a state that is learnable by a transformer.
  • The proposed approach solves the unseen instances better than the benchmarked methods.
Critical weaknesses
  • The proposed dual attention mechanism is interesting, and the authors show it outperforms the existing DRL approaches Resched and DANIEL. However, the proposed model is much larger and requires much more training than Resched and DANIEL: the trained model uses 8 transformer-layers with dimensionality 1028 and 200 million parameters, while training on 8 GPUs that each have 96 GB RAM. To compare, DANIEL is very lightweight with about 28,000 parameters. Resched also uses some transformer layers but only 2 with a dimensionality of 128 and a total of about 800 thousand parameters, while training on a single GPU with 48 GB of memory. Hence, it is unclear where the power of learning a broader set of instances comes from: is it because the proposed dual attention network is much more effective than the previously used ones in the literature, or simply because the network is so much bigger than other benchmarked methods? So, to prove the value of the proposed network, the authors should ideally compare at least with a very large version of Resched and maybe also a smaller version of their network. They should clearly show this comparison for different sizes of architectures to see how performance is affected.

  • It is quite unclear how the authors use the OR-Tools in the training. They only say they use it so "align" but don't specify clearly how this is done. Having to use many or-tools solutions for training in itself is already a disadvantage, as it requires a lot of compute just for this labelling, similar to how this can become an issue for supervised approaches. The authors should at least show the effect of not using the reference solutions in the experiments.

  • For the very large instances, the authors didn’t report the solution quality of OR-Tools, and the experiment is done only for one instance.

  • The authors claim the proposed online mask, that incorporates scheduling information during policy execution, is a contribution. However, to me, it seems not novel and such masking is used by other DRL approaches too.

  • Some part of writing is sloppy. Some notation uses * instead of _ in several formulas. The Gannt charts are also very poorly explained.

Questions for authors

See Weaknesses.

4 comments
AuthorsOpenReview ↗

Response for Summary and Strengths:

Thank you for identifying the capacity comparison and the distinction between our two large-instance evaluations.

We appreciate your assessment of the state representation and the zero-shot benchmark comparison.

AuthorsOpenReview ↗

Response to Critical Weaknesses & Questions:

Q1. Matched Model Size.

Due to training-time constraints, we could not train a full-scale ReSched model. Instead, we trained a smaller AnyFJS variant matched to ReSched's model capacity. The capacity-matched AnyFJS (828,801 deployed parameters) and ReSched (821,185) were trained on the same 160,000 instances. Of the 217 evaluation instances, ReSched completed only 205 within the prescribed time limit. Accordingly, we compare their group-averaged gaps on the 205 instances completed by both methods, spanning 41 groups. With training seed 43 and matched inference budgets, AnyFJS achieved a lower average gap than ReSched (20.02% vs. 20.33%). Together, the higher feasibility coverage and lower solution gap support the effectiveness of our proposed operation–machine cross-attention, bilinear scoring head, and online masking mechanism, demonstrating their advantages in both solution feasibility and quality under matched model capacity.

Q2. Solver Labels and Cost.

OR-Tools serves only as an evaluation reference (baseline); it does not participate in training and provides no rewards, advantages or labels. We will correct the descriptions in the abstract and Section 3.3.

Q3. 100×100100 \times 100 Instances.

CP-SAT returned UNKNOWN without a feasible schedule on these inputs.

Table R5. Four 100×100100 \times 100 instances. One greedy run per input with the submitted checkpoint on one H20 (inference seed 4201). Time and peak allocated GPU memory are for AnyFJS. MPGN had the lowest baseline makespan within each time budget.

InstanceOps.Lower BoundAnyFJS MakespanTime (s)Peak (GiB)
L00468,8004,6414,6811,332.6614.05
L00179,0004,6605,2461,389.3114.36
L01159,0004,5425,1781,385.1314.36
L015511,0005,7816,5102,190.2017.45

Q4. Mask and Contribution.

We agree that feasibility masking is established practice. The dispatch mask enforces precedence and machine eligibility. Our architectural choices concern how each operation aggregates machine-specific processing times, how global context is introduced, and how one bilinear matrix scores all operation–machine pairs.

Q5. Notation and Gantt Charts.

Thank you for reminding us of the mistake. We have corrected the original subscript. We will provide more detailed explanations for the Gantt chart.

Thank you for your answers.

  • The authors didn't compare with similar sized DANIEL. My original concern on whether performance gains come from a much larger architecture stays.
  • OR-Tools is used to generate labels for training. As my initial review indicated, the authors should at least show the effect of not using these reference solutions in the experiments. As far as I can see, this point is not addressed by the authors.
  • I still don't get a good picture of the performance on large instances: for sizes of 100x20, the method is only compared with OR Tools but not any other NCO methods (i.e., DANIEL, HGNN etc, which can be easily applied); For the instance 100x100, it is compared with other NCO methods, but not all PDRs.

I will therefore maintain my original score.

AuthorsOpenReview ↗

### Response to Reviewer uj3G

We thank the reviewer for the constructive follow-up comments. We address the three main concerns with additional experiments and clarifications.  Q1. Capacity-, Data-, and Training-Budget-Matched Comparison.  We retrained DANIEL and ReSched with comparable policy-parameter budgets to AnyFJS, using the same 160k generated training stream and 14,400 s training-time cap. 

MethodParametersAvg. Gap%↓Verified Feasibility
AnyFJS2,424,8019.93217/217
DANIEL2,442,80512.24217/217
ReSched2,466,04920.80217/217*

ReSched's 217/217 feasibility was obtained with an extended inference-time budget and represents eventual feasibility.

Our complete solver achieves the lowest average gap, outperforming DANIEL by 2.31 percentage points and ReSched by 10.87 percentage points. These results demonstrate stronger solution quality under matched model capacity and training resources, while the extended inference budget for ReSched is explicitly distinguished.

Q2. Clarification of OR-Tools Usage.

We apologize for the misleading description in the original manuscript. OR-Tools is used exclusively to generate evaluation references; it does not participate in training or provide rewards, advantages, or labels. PPO training uses the negative partial-makespan increment as the reward, with advantages estimated from sampled returns and critic predictions.

Therefore, the requested experiment removing OR-Tools supervision is not applicable, as our training already uses zero OR-Tools supervision. This was a textual error rather than an experimental dependency. We will correct the abstract and Section 3.3 accordingly.

Q3. Additional Large-Scale Comparisons.

100×100 (Completed). Following the reviewer's suggestion, we added three priority dispatching rule (PDR) baselines—FIFO, MOPNR, and MWKR—on the same single instance reported in the original paper, without introducing additional 100×100 instances.

MethodMakespan ↓
------:
AnyFJS4,652
FIFO8,099
MOPNR8,131
MWKR8,151

AnyFJS reduces makespan by 42.56%, 42.79%, and 42.93% relative to FIFO, MOPNR, and MWKR, respectively, providing additional evidence of its effectiveness on this large-scale instance.

100×20 (Additional comparison). On instance gen_0023 ((k=3, 2,000 operations), AnyFJS achieves a makespan of 4,911, compared with DANIEL (4,944), MPGN (4,964), HGNN (5,017), ReSched-PPO (5,041), FIFO (5,011), MOPNR (5,068), MWKR (5,082), and SeEvo (6,349).

These additional results complement our original large-scale evaluation and demonstrate competitive solution quality against both learned schedulers and conventional dispatching rules on the evaluated instances.

We thank the reviewer again for the suggestions, which have helped strengthen our experimental evaluation and clarify the actual training procedure.
Reviewer_vc5tOpenReview ↗
Rating
1
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes AnyFJS, a Transformer framework for flexible job shop scheduling that aims to minimize makespan and generalize across problem sizes. It combines cross attention between operations and machines, a bilinear policy head, and an online mask for feasible action selection. Training uses PPO on synthetic instances with varying configurations, and the authors describe using OR-Tools reference solutions to construct reward and advantage signals. Experiments assess solution quality and generalization across standard benchmarks and larger synthetic instances.

Critical strengths

This work provides empirical evidence that a single trained model can generalize to substantially larger scheduling instances without retraining. The evaluation includes 128 synthetic instances with 2,000 operations each, alongside 217 standard instances spanning multiple benchmark families, problem sizes, and flexibility levels.

Critical weaknesses

The methodological novelty beyond existing neural scheduling frameworks is insufficiently established. ReSched already combines a Transformer architecture, interactions between operations and machines, feasible action selection, and a PPO variant, while DANIEL also employs dual attention. Although AnyFJS differs in its attention organization and bilinear policy head, the paper does not clearly explain what additional modeling capability these changes provide. More critically, existing NCO methods for scheduling, including HGNN, DANIEL, and ReSched, already exclude infeasible actions through action masking. Some methods impose additional restrictions beyond basic feasibility to further narrow the action space. The proposed online mask therefore does not constitute a new methodological contribution as currently described. Furthermore, existing schedulers already support inputs of varying lengths and dynamically sized action spaces. These properties alone do not establish a new contribution toward Any-scale scheduling, and it remains unclear which specific technical changes improve generalization across problem sizes beyond existing capabilities.

The experimental comparisons do not adequately control for differences in model capacity and training setup. Even considering only the policy network, AnyFJS has hundreds to thousands of times as many parameters as standard public configurations of the neural baselines. The baseline checkpoints were trained on specific problem sizes under their original instance distributions, such as SD1 or SD2, whereas AnyFJS uses mixed configuration training with varying machine counts, operation counts, and flexibility levels. AnyFJS is therefore exposed to over 10 times as many training configurations as the baseline models, which are not retrained under the same training distribution. However, the total number of training instances and sampled trajectories used by AnyFJS is not clearly reported, so the difference in training volume cannot be assessed. These uncontrolled differences make it difficult to establish whether the reported gains reflect the proposed architectural contributions or can be explained by greater model capacity, broader training coverage, and potentially greater training volume.

The paper also contains factual inaccuracies and inconsistent reporting. ReSched is incorrectly classified as an LLM method, although it is a Transformer policy trained through reinforcement learning. Moreover, the main text and Table 1 describe gaps relative to best known solutions, whereas Appendix A.2 states that lower bounds are used for Hurink. These reference values are not interchangeable, leaving the definition and interpretation of the reported gaps unclear.

Questions for authors
  1. Could the authors clarify how their network design differs from HGNN, DANIEL, and ReSched, and provide ablation studies to demonstrate the benefits of these differences?
  2. How many training instances and trajectories are used by AnyFJS? Could the baselines be compared under comparable model capacity, training coverage, and data budgets?
  3. How does the proposed online mask differ from action masking already used in HGNN, DANIEL, and ReSched, and what new contribution does it provide?
  4. What is the rationale for categorizing ReSched as an LLM method?
  5. Are the reported gaps calculated against best known solutions or lower bounds? Please clarify the inconsistency and confirm that all methods use the same reference values.
  6. How are the OR-Tools reference solutions incorporated into the training signals, and how does performance change when these signals are removed?
  7. Which checkpoints and decoding strategies are used for the neural baselines, and are their sampling budgets and evaluation conditions comparable?
5 comments
AuthorsOpenReview ↗

Response for Paper Summary and Critical Strengths:

Thank you for identifying where our contribution and comparison protocol need clearer attribution.

We appreciate your recognition that one trained policy was evaluated on instances substantially larger than the training instances.

AuthorsOpenReview ↗

Response to Critical Weaknesses

W1. Prior Work and Our Positioning

HGNN, DANIEL, and ReSched also mask infeasible actions. AnyFJS integrates three complementary components into a unified dispatch policy:

(i) Operation–machine (O–M) cross-attention. Each operation attends to its eligible machines using their availability and its processing time on each machine. A global Transformer then jointly updates operation, machine, and job tokens, capturing their interactions and the evolving scheduling state. This architecture enables more effective modeling of operation–machine compatibility and dynamic dependencies throughout the scheduling process. On Fattahi, replacing O–M cross-attention with masked mean aggregation raised Avg. Gap from 13.90% to 15.62%.

(ii) Bilinear attention. A single learned matrix scores each pair of updated operation and machine tokens. This shared scoring mechanism naturally accommodates varying numbers of operations and machines without requiring instance-specific pairwise parameters. Together with O–M cross-attention, it enables effective pairwise decision-making based on jointly contextualized operation, machine, and job representations. Replacing it with a pairwise MLP raised Fattahi Avg. Gap from 13.90% to 14.63%.

(iii) Online masking. At each dispatch step, the mask dynamically assigns zero probability to all pairs except each job's first unfinished operation and its eligible machines. By excluding infeasible actions throughout scheduling, this mechanism prevents invalid dispatches, substantially narrows the effective action space, and reduces the associated decision-making overhead.

Overall, these three components play complementary roles: O–M cross-attention and the global Transformer capture rich interactions among operations, machines, jobs, and evolving scheduling states; bilinear scoring efficiently evaluates operation–machine pairs; and online masking explicitly enforces action feasibility while reducing decision overhead. To our knowledge, this combination, together with verified schedules at the 100×100100 \times 100 scale, has not been reported before. We will qualify our novelty claim accordingly and include controlled ablations to isolate the contributions of these components.

W2. Capacity and Training Distribution

The published checkpoints were trained on their own distributions and evaluated on a common benchmark. The submitted AnyFJS run used 5.12 million trajectory draws (20,000×25620,000 \times 256). In the added control, AnyFJS (828,801 deployed parameters) and ReSched (821,185) saw the same 160,000 instances in the same order over 5,000 updates. At training seed 43, matched inference budgets gave Avg. Gap of 20.02% and 20.33%, respectively, on the 205 jointly completed instances in all 41 groups.

W3. Method and Reference Labels

The original grouping of both ReSched and SeEvo under "LLM" is inaccurate. We will relabel them as "LLM/Transformer-based structural methods": SeEvo is an LLM-derived heuristic and ReSched is a Transformer policy trained with reinforcement learning; HGNN and MPGN are GNN-type NCO methods, and DANIEL uses attention blocks but is not a Transformer.

We will also label the numerical reference used by each benchmark family.

AuthorsOpenReview ↗

Response to Questions:

Q1. Network Design and Ablations.

HGNN aggregates messages on a heterogeneous graph, DANIEL exchanges operation and machine messages through two attention blocks, and ReSched applies a Transformer to the remaining subproblem. AnyFJS first lets each operation attend to its eligible machines with pair-specific processing times, then updates all tokens globally before bilinear scoring. On Fattahi the full model achieved 13.90% Avg. Gap. Replacing local attention, bilinear scoring or the second global block gave 15.62%, 14.63% and 14.41%, respectively, on the same training data and decoding budget.

Q2. Training Volume and Matched Policy Size.

The submitted configuration implies 5.12M nominal trajectory draws (20,000×25620,000 \times 256); the original run did not record a deduplicated instance count. In the supplementary control each method sees the same 160,000 training instances per seed over 5,000 updates, with deployed sizes of 828,801 (AnyFJS) and 821,185 (ReSched). Under the matched wall-clock budget, seed 43 gives 20.02% vs. 20.33%, with AnyFJS slightly better; under the strict delivery criterion AnyFJS is 217/217 and ReSched 205/217. Full per-seed results are reported in the appendix.

Q3. Feasibility Masking.

Our mask is recomputed at every step from the heterogeneous token state: for each job only the first unfinished operation is retained, and its pairs with eligible machines enter the same softmax normalization; the mask is encoded together with the job/machine clocks and operation order rather than applied as an external post-processing filter. A machine may still be busy when a dispatch is selected, and the chosen operation starts at the later of machine and job availability. Existing DRL schedulers already use feasibility masks; we treat this as part of the problem modelling and place the novelty in the representation and the feasibility-certified decoding.

Q4. ReSched Classification.

The original paper's label of LLM methods for this group is inaccurate: we will refer to them as "LLM/Transformer-based structural methods" — SeEvo is an LLM-derived heuristic and ReSched is a Transformer policy trained with reinforcement learning; HGNN/MPGN are GNN-type NCO methods and DANIEL uses attention blocks but is not a Transformer. We will correct the text and tables accordingly.

Q5. Gap Definition and Coverage.

For each instance, all methods use the same numerical reference RiR_i to calculate the relative gap as:

100×Ci−RiRi.100 \times \frac{C_i-R_i}{R_i}.

Specifically, we use best-known solutions (BKSs) for Chambers–Barnes (Appendix A.2), lower bounds (LBs) for Hurink, and best-known solutions (BKSs) for Fattahi. For the four Hurink 10 × 10 groups, MPGN and the affected dispatch rules report results on 17 instances, compared with 18 instances for AnyFJS; we will report the corresponding success counts alongside the group means. For the synthetic 100 × 20 instances, we use the best-known solutions obtained by CP-SAT as reference values.

Q6. OR-Tools.

OR-Tools supplied evaluation references only. The reward is the negative increase in partial makespan, and PPO uses the sampled remaining return minus the critic's prediction. We will correct the abstract and Section 3.3 accordingly.

Q7. Checkpoints, Decoding Strategies and Sampling Budgets.

MPGN kept the shortest greedy schedule from three released J15M15 checkpoint pairs per instance (best_value0, best_value00 and best_value5). For the added equal-time comparison, we fixed MPGN to best_value0 and used HGNN save_10_5, DANIEL SD2/20x10+mix, ReSched-PPO SD2-20x10 and ReSched-REINFORCE Old-SD2-20x10. On one H20 each baseline ran greedy decoding and then repeated sampling up to the corresponding AnyFJS finished time.

Reviewer_wnNFOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes AnyFJS, a neural scheduler for flexible job shop scheduling that aims to generalize across instance sizes without retraining.

The model represents jobs, operations, and machines as heterogeneous tokens. An operation–machine-aware cross-attention module incorporates machine states and operation-specific processing times into operation representations. A Transformer encoder then models global scheduling dependencies. Finally, a bilinear policy head scores candidate operation–machine assignments, and a state-dependent feasibility mask removes invalid actions.

The scheduler is trained using PPO. The manuscript additionally states that high-quality OR-Tools solutions inform its reward and advantage signals, although the precise integration is not fully specified.

Evaluation covers 217 benchmark instances in 41 family-size groups and 129 larger synthetic instances. The paper reports better average gaps than the strongest baseline in 40 of the 41 benchmark groups, with one tie. On 128 synthetic 100 × 20 instances, AnyFJS achieves a mean makespan gap of 4.36% relative to feasible solutions obtained by OR-Tools under a 1,800-second time limit.

Critical strengths
  1. Promising cross-scale generalization on a substantial benchmark collection.

    The model is trained with ten jobs and then evaluated on instances with different numbers of jobs and machines, including much larger synthetic problems. Table 2 reports improvements over the strongest baseline in 40 of 41 family-size groups and a tie in the remaining group. These results suggest that the policy can transfer beyond its training sizes without instance-specific fine-tuning.

  2. A coherent scheduling architecture with explicit feasibility handling.

    The architecture combines operation-specific machine information, global scheduling context, and a dynamic operation–machine action space. The feasibility mask makes the relationship between scheduling constraints and policy outputs explicit. The larger-scale evaluation also provides useful evidence that the same representation and decoding interface can be applied to instances containing thousands of operations.

Critical weaknesses
  1. The experiments do not establish the contribution of the proposed architecture.

    The paper does not report ablations removing operation–machine cross-attention, replacing the bilinear scoring head, or varying the global Transformer. It also does not isolate the effects of mixed-configuration training, model size, or OR-Tools-derived supervision.

    This is consequential because AnyFJS uses approximately 212 million actor–critic parameters and nearly 482 GPU-hours of training, while the comparison methods use their released checkpoints and original training distributions. The reported zero-shot comparison is useful for evaluating available systems, but it does not establish that dual attention is responsible for the performance advantage.

    A particularly important comparison would train a simpler Transformer scheduler or a closely related baseline on the same instance distribution, with matched reference supervision and an appropriate capacity or training-budget control.

  2. The training specification and scalability evidence are insufficient for the strongest claims.

    OR-Tools-derived rewards and advantages are presented as important ingredients, but their mathematical definitions, generation budget, and interaction with the critic baseline are missing. Appendix A instead illustrates a reward equal to the negative increase in partial makespan, leaving unclear how the reference solution changes the actual training signal.

    The “any-scale” and efficiency claims also exceed the available evidence. The 100 × 100 result is based on a single instance and requires 2,257.14 seconds, approximately 37.6 minutes. On the standard benchmark, AnyFJS takes 15.35 seconds on average, compared with 0.69 seconds for HGNN and 0.64 seconds for DANIEL. These are meaningful quality–runtime trade-offs, rather than uniformly competitive efficiency.

    Finally, the 4.36% large-instance gap is measured against an OR-Tools feasible upper bound, not a proven optimum. It establishes proximity to that solver’s incumbent but does not establish near-optimality.

Questions for authors
  1. Exact training objective: Please provide the complete actor and critic objectives, including the mathematical contribution of OR-Tools solutions, the definition of β, and the “Valid-Action Prior Regularization” shown in Figure 3. How do these relate to the negative makespan-increment reward described in the appendix?

  2. Component attribution: How does performance change when operation–machine cross-attention or bilinear scoring is replaced with a simpler alternative? What improvement remains when training data, parameter count, and solver-derived supervision are controlled?

  3. Training data and reference cost: How many distinct training instances are generated, what processing-time distributions are used, and how are infeasible operations avoided at low flexibility? What solver time and total computational cost are required to produce the OR-Tools references, and are these costs included in the reported training budget?

  4. Architecture specification: Does each operation attend only to its own feasible machine representations, or to a flattened collection of operation–machine features? Please specify token features, precedence/order encoding, attention masks, normalization, and how the model handles permutations of job and machine identifiers.

  5. Quality–runtime comparison: Can the methods be compared under matched inference budgets, allowing faster baselines to use multiple samples or restarts? Please also separate model-loading time from scheduling time and provide hardware, decoding strategy, and repeated-run measurements.

  6. Generalization and evaluation: Can the 100 × 100 evaluation be expanded beyond one instance, with runtime and memory scaling reported against operation count? Please also report training-seed variability, distinguish reference lower bounds from feasible upper bounds, and explain whether the reported 7.93% benchmark mean weights groups or individual instances equally.

5 comments
AuthorsOpenReview ↗

Response for Paper Summary:

Thank you for identifying the differences in the paper description. This policy provides training on rewards and does not involve OR-tools during the training process. OR-Tools only provide evaluation references for experimental research. We will align the abstract and Section 3.3 with Appendix A.

AuthorsOpenReview ↗

Response to Critical Weaknesses

W1. Ablation Studies and Architectural Contributions

Due to the high training cost of the three ablation models, we use one complete instance family (Fattahi) for validation, covering 10 instances across six equally weighted problem sizes.

(i) Removing operation–machine (O–M) cross-attention. Replacing O–M cross-attention with a simple masked mean increases the Fattahi Avg. Gap from 13.90% to 15.62% (+1.72 percentage points). This demonstrates the importance of explicit O–M cross-attention in capturing fine-grained assignment compatibility.

(ii) Replacing the bilinear scoring head. Replacing the bilinear scoring head with a shared pairwise MLP increases the Fattahi Avg. Gap from 13.90% to 14.63% (+0.73 percentage points). Moreover, the dense pairwise MLP stores a hidden vector for each operation–machine pair, resulting in higher GPU memory consumption. These findings support the necessity of the bilinear scoring head for achieving both scheduling quality and memory efficiency.

(iii) Reducing the global Transformer depth. We reduce the global Transformer from two attention blocks to one by retaining the first block and replacing the second with a token-wise MLP. This increases the Fattahi Avg. Gap from 13.90% to 14.41% (+0.51 percentage points). As shown in Table R3, the token-wise second block prevents competing operations from attending to machine states updated by the first block. This validates the importance of the second global attention block in coordinating competing operations through updated machine-state information.

Small AnyFJS Model

Table R1. Equal-time comparison on the 217 paper instances using training seed 43.

An instance is counted as on time only if all three trials return a verified schedule. For a fair comparison, Avg. Gap is calculated over the 205 instances completed by both methods, with the 41 represented groups weighted equally. ReSched completed only 205 instances within the specified time limit; therefore, the gap comparison uses these same 205 instances.

PolicyParametersOn Time (out of 217)Avg. Gap on 205 (%)Model Load (s)
AnyFJS828,80121720.020.040
ReSched821,18520520.330.018

W2. Clarifications on Training, Runtime, and Evaluation

(i) Training signal. The reward is the negative increase in partial makespan:

rt=Ct−Ct+1.r_t = C_t - C_{t+1}.

From dispatch step tt to the end of the schedule, the rewards sum to:

Gt=∑k=tT−1rk=Ct−CT.G_t = \sum_{k=t}^{T-1} r_k = C_t - C_T.

The critic is trained to fit this return using squared error, and PPO uses the advantage Gt−V(st)G_t - V(s_t). OR-Tools provides evaluation references only; therefore, the training-label cost is zero. We will correct the abstract and Section 3.3 to ensure consistency with Appendix A.

(ii) Quality–runtime trade-offs. Yes. Our submitted beam search takes longer than HGNN and DANIEL because it explores multiple continuations before retaining the shortest schedule. However, it achieves a lower gap in 40 of the 41 groups and ties in the remaining group.

Under equal per-instance time budgets, with repeated baseline sampling or restarts, AnyFJS ties for first on two of the three Fattahi instances and improves the third from 330 to 320. On four 100×100100 \times 100 instances, a single greedy rollout takes 1,333–2,190 seconds on one H20 GPU.

(iii) OR-Tools feasible upper bound. The reported 4.36% represents the mean gap to the OR-Tools incumbent on 128 synthetic 100×20100 \times 20 instances. Since these synthetic instances have no published optimal solutions, we use the best feasible schedule returned by OR-Tools within 1,800 seconds per instance. OR-Tools proves optimality in five cases.

To avoid implying that the incumbent is necessarily optimal, we will rename the metric "gap to the OR-Tools feasible upper bound" in Section 4.3, consistent with Appendix A.4 and Table 6.

AuthorsOpenReview ↗

Response to Questions (Part 1/2)

Q1. Reward and Observed Return

Let CtC_t be the latest scheduled completion time just before dispatch tt, and Ct+1C_{t+1} the value just after it. The reward is:

rt=Ct−Ct+1.r_t = C_t - C_{t+1}.

Once the sampled schedule is complete at step TT, the rewards from step tt onward sum to:

Gt=∑k=tT−1rk=Ct−CT,G_t = \sum_{k=t}^{T-1} r_k = C_t - C_T,

which is one observed training target for the state before that dispatch.

OR-Tools is not used in training: it provides neither rewards, advantages, nor labels, and serves only as an evaluation reference (baseline) for measuring the quality of the trained model.

How the Critic Obtains V(st)V(s_t)

The critic is a separate network. It takes the pre-dispatch state sts_t, including machine and job availability, operation order and dispatch status, and processing times on eligible machines. Each operation attends to its eligible machines. A Transformer mixes the machine, job and operation representations. The critic averages the resulting vectors for all machines, all jobs and all operations still awaiting dispatch. A learned linear layer maps this mean vector hˉ\bar{h} to one number:

V(st)=w⊤hˉ+b.V(s_t) = w^\top \bar{h} + b.

The critic learns its weights from completed rollouts by minimizing the mean squared error:

\mathbb{E}[(V(s_t)-G_t)^2].$$ Its prediction estimates the expected remaining return if the rollout policy continues from this state. ### How the Actor Uses This Prediction After fitting the critic, we evaluate it on each stored state and use: $$A_t = G_t - V(s_t)$$ as a fixed weight during the actor update. A positive advantage means that this sampled continuation added less makespan than the critic expected. Let $\rho$ be the updated probability of the sampled action divided by its stored rollout probability. The actor minimizes: $$-\mathbb{E}[\min(\rho A_t,\operatorname{clip}(\rho,0.9,1.1)A_t)] +\beta\mathbb{E}[\mathrm{KL}(\pi\|q)].$$ ### Valid-Action Prior (Figure 3) The hard mask restricts action sampling to legal pairs. In the actor loss, the KL term with $\beta=0.005$ discourages concentration on just a few legal pairs. With $K$ legal and $I$ illegal pairs, $q$ assigns $(1-I\delta)/K$ to each legal pair and $\delta=10^{-10}$ to each illegal pair. The reward comes solely from the change in makespan. ## Q2. Component Attribution **Table R3(a). Fattahi ablations.** Ten instances in six equally weighted size groups, from $3\times2$ to $12\times8$ jobs and machines. | Policy | Avg. Gap ↓ | |:---|---:| | Full AnyFJS | **13.90%** | | Masked mean for local cross-attention | 15.62% | | Pairwise MLP for bilinear scoring | 14.63% | | Token-wise MLP for the second global block | 14.41% | **Controlled comparison.** All four policies had width 160 and approximately 0.829M deployed parameters. Each used the same 32,000 training instances, 1,000 updates and training seed 43, without solver-derived supervision. We averaged three beam-32 decodes per instance, then weighted the six Fattahi size groups equally. Under these controls, the full model had the lowest Avg. Gap on Fattahi. W1 (i)–(iii) explains each replacement. ## Q3. Training Data and Computational Budget **(i) How many distinct training instances?** The reported 20,000 updates with 256 environments give 5.12 million trajectory draws. The original run did not record a deduplicated count. We will label the draw count in Appendix A.3, Table 5. **(ii) How are processing times sampled?** In the archived mixed-configuration generator used for the paired control, each operation draws an integer base time uniformly from 1 to 90. Each eligible machine adds an independent uniform integer offset from 0 to 9. The original checkpoint does not store its full generator invocation. We will identify the generator version alongside the distribution in Appendix A.3. **(iii) How is feasibility maintained at low flexibility?** Training used 10 jobs, 4–20 machines, 3–15 operations per job and target flexibility $f$ from 0.07 to 1.00. The archived generator samples: $$K=\max(1,\min(M,\operatorname{round}(fM)))$$ distinct machines for each operation, so every operation has at least one eligible machine. We will add the rule beside the flexibility range in Appendix A.3. **(iv) Are reference solves included in the training budget?** No. Training used zero solver-labeling hours. The reported 481.68 GPU-hours cover model training. The 128 test-reference solves took 61.55 hours in total, summed across instances, with a 1,800-second limit per instance. We will report this cost separately in Appendix A.4 alongside Table 6.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Discussion (0)

Sign in to comment.