Add files using upload-large-folder tool

.gitattributes

@@ -15407,3 +15407,78 @@ parse/test/JVeM7uwDwK/JVeM7uwDwK_origin.pdf filter=lfs diff=lfs merge=lfs -text
 parse/test/JVeM7uwDwK/JVeM7uwDwK_span.pdf filter=lfs diff=lfs merge=lfs -text
 parse/test/JVeM7uwDwK/JVeM7uwDwK_layout.pdf filter=lfs diff=lfs merge=lfs -text
 parse/test/nKvGCUoiuW/nKvGCUoiuW_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/XSEBx0iSjFQ/XSEBx0iSjFQ_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/VYYf6S67pQc/VYYf6S67pQc_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/3FvF1db-bKT/3FvF1db-bKT_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/T8wHz4rnuGL/T8wHz4rnuGL_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/Loek7hfb46P/Loek7hfb46P_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/UKd6dpVGdu/UKd6dpVGdu_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/3RBY8fKjHeu/3RBY8fKjHeu_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/NHeAUKlTO8/NHeAUKlTO8_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/UKd6dpVGdu/UKd6dpVGdu_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/83LJRUzXWj/83LJRUzXWj_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/dev/NHeAUKlTO8/NHeAUKlTO8_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1WRibb0Z/S1WRibb0Z_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1WRibb0Z/S1WRibb0Z_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1WRibb0Z/S1WRibb0Z_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/lM2971LAwV/lM2971LAwV_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/lM2971LAwV/lM2971LAwV_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/lM2971LAwV/lM2971LAwV_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rJxt0JHKvS/rJxt0JHKvS_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rJxt0JHKvS/rJxt0JHKvS_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rJxt0JHKvS/rJxt0JHKvS_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HJWHIKqgl/HJWHIKqgl_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HJWHIKqgl/HJWHIKqgl_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HJWHIKqgl/HJWHIKqgl_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rJqFGTslg/rJqFGTslg_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rJqFGTslg/rJqFGTslg_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rJqFGTslg/rJqFGTslg_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1vuO-bCW/S1vuO-bCW_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1vuO-bCW/S1vuO-bCW_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1vuO-bCW/S1vuO-bCW_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1c2cvqee/S1c2cvqee_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1c2cvqee/S1c2cvqee_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1c2cvqee/S1c2cvqee_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rJe4_xSFDB/rJe4_xSFDB_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rJe4_xSFDB/rJe4_xSFDB_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/rJe4_xSFDB/rJe4_xSFDB_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Skn9Shcxe/Skn9Shcxe_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Skn9Shcxe/Skn9Shcxe_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Skn9Shcxe/Skn9Shcxe_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/BJgcwh4FwS/BJgcwh4FwS_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/BJgcwh4FwS/BJgcwh4FwS_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/BJgcwh4FwS/BJgcwh4FwS_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Sk-oDY9ge/Sk-oDY9ge_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Sk-oDY9ge/Sk-oDY9ge_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/Sk-oDY9ge/Sk-oDY9ge_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/hm0i-cunzGW/hm0i-cunzGW_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/hm0i-cunzGW/hm0i-cunzGW_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/hm0i-cunzGW/hm0i-cunzGW_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/r1lZgyBYwS/r1lZgyBYwS_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/r1lZgyBYwS/r1lZgyBYwS_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/r1lZgyBYwS/r1lZgyBYwS_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HJem3yHKwH/HJem3yHKwH_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HJem3yHKwH/HJem3yHKwH_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/HJem3yHKwH/HJem3yHKwH_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/TR-Nj6nFx42/TR-Nj6nFx42_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/TR-Nj6nFx42/TR-Nj6nFx42_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/TR-Nj6nFx42/TR-Nj6nFx42_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/FsLTUzZlsgT/FsLTUzZlsgT_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/FsLTUzZlsgT/FsLTUzZlsgT_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/FsLTUzZlsgT/FsLTUzZlsgT_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/0lz69oI5iZP/0lz69oI5iZP_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/0lz69oI5iZP/0lz69oI5iZP_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/0lz69oI5iZP/0lz69oI5iZP_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/B1IzH7cxl/B1IzH7cxl_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/B1IzH7cxl/B1IzH7cxl_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/B1IzH7cxl/B1IzH7cxl_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/q8qLAbQBupm/q8qLAbQBupm_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/q8qLAbQBupm/q8qLAbQBupm_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/q8qLAbQBupm/q8qLAbQBupm_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SkVhlh09tX/SkVhlh09tX_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SkVhlh09tX/SkVhlh09tX_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/SkVhlh09tX/SkVhlh09tX_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1lvm305YQ/S1lvm305YQ_span.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1lvm305YQ/S1lvm305YQ_origin.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/S1lvm305YQ/S1lvm305YQ_layout.pdf filter=lfs diff=lfs merge=lfs -text
+parse/train/YUEFlzlG_0c/YUEFlzlG_0c_origin.pdf filter=lfs diff=lfs merge=lfs -text

parse/dev/3FvF1db-bKT/3FvF1db-bKT_layout.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:143ba12f5d9ddf5e2eb3191f785d462b660faf64f77b155dc1c42c616dc3663b
+size 743641

parse/dev/3RBY8fKjHeu/3RBY8fKjHeu_span.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ac3f154a4d5c59c8ed7f6e70ea7eb2c7f40626e36c450a35b7260a1d86b802c2
+size 3191163

parse/dev/5uIL1E8h1E/5uIL1E8h1E.md

@@ -0,0 +1,539 @@
+# Residual Scheduling: A New Reinforcement Learning Approach to Solving Job Shop Scheduling Problem
+
+Anonymous Author(s)   
+Affiliation   
+Address   
+email
+
+# Abstract
+
+1 Job-shop scheduling problem (JSP) is a mathematical optimization problem widely   
+2 used in industries like manufacturing, and flexible JSP (FJSP) is also a common   
+3 variant. Since they are NP-hard, it is intractable to find the optimal solution for   
+4 all cases within reasonable times. Thus, it becomes important to develop efficient   
+5 heuristics to solve JSP/FJSP. A kind of method of solving scheduling problems   
+6 is construction heuristics, which constructs scheduling solutions via heuristics.   
+7 Recently, many methods for construction heuristics leverage deep reinforcement   
+8 learning (DRL) with graph neural networks (GNN). In this paper, we propose a new   
+9 approach, named residual scheduling, to solving JSP/FJSP. In this new approach,   
+10 we remove irrelevant machines and jobs such as those finished, such that the states   
+11 include the remaining (or relevant) machines and jobs only. Our experiments show   
+12 that our approach reaches state-of-the-art (SOTA) among all known construction   
+13 heuristics on most well-known open JSP and FJSP benchmarks. In addition, we   
+14 also observe that even though our model is trained for scheduling problems of   
+15 smaller sizes, our method still performs well for scheduling problems of large sizes.   
+16 Interestingly in our experiments, our approach even reaches zero gap for 49 among   
+17 50 JSP instances whose job numbers are more than 150 on 20 machines.
+
+# 18 1 Introduction
+
+19 The job-shop scheduling problem (JSP) is a mathematical optimization (MO) problem widely used in   
+20 many industries, like manufacturing (Zhang et al., 2020; Waschneck et al., 2016). For example, a   
+21 semiconductor manufacturing process can be viewed as a complex JSP problem (Waschneck et al.,   
+22 2016), where a set of given jobs are assigned to a set of machines under some constraints to achieve   
+23 some expected goals such as minimizing makespan which is focused on in this paper. While there are   
+24 many variants of JSP (Abdolrazzagh-Nezhad and Abdullah, 2017), we also consider an extension   
+25 called flexible JSP (FJSP) where job operations can be done on designated machines.   
+26 A generic approach to solving MO problems is to use mathematical programming, such as mixed   
+27 integer linear programming (MILP) and constraint satisfaction problem (CSP). Two popular generic   
+28 MO solvers for solving MO are OR-Tools (Perron and Furnon, 2019) and IBM ILOG CPLEX   
+29 Optimizer (abbr. CPLEX) (Cplex, 2009). However, both JSP and FJSP, as well as many other MO   
+30 problems, have been shown to be NP-hard (Garey and Johnson, 1979; Lageweg et al., 1977). That   
+31 said, it is unrealistic and intractable to find the optimal solution for all cases within reasonable times.   
+32 These tools can obtain the optimal solutions if sufficient time (or unlimited time) is given; otherwise,   
+33 return best-effort solutions during the limited time, which usually have gaps to the optimum. When   
+34 problems are scaled up, the gaps usually grow significantly.   
+35 In practice, some heuristics (Gupta and Sivakumar, 2006; Haupt, 1989) or approximate methods   
+36 (Jansen et al., 2000) were used to cope with the issue of intractability. A simple greedy approach is to   
+37 use the heuristics following the so-called priority dispatching rule (PDR) (Haupt, 1989) to construct   
+38 solutions. These can also be viewed as a kind of solution construction heuristics or construction   
+39 heuristics. Some of PDR examples are First In First Out (FIFO), Shortest Processing Time (SPT),   
+40 Most WorK Remaining (MWKR), and Most Operation Remaining (MOR). Although these heuristics   
+41 are usually computationally fast, it is hard to design generally effective rules to minimize the gap to   
+42 the optimum, and the derived results are usually far from the optimum.   
+43 Furthermore, a generic approach to automating the design of heuristics is called metaheuristics, such   
+44 as tabu search (Dell’Amico and Trubian, 1993; Saidi-Mehrabad and Fattahi, 2007) , genetic algorithm   
+45 (GA) (Pezzella et al., 2008; Ren and Wang, 2012), and PSO algorithms (Lian et al., 2006; Liu et al.,   
+46 2011). However, metaheuristics still take a high computation time, and it is not ensured to obtain the   
+47 optimal solution either.   
+48 Recently, deep reinforcement learning (DRL) has made several significant successes for some   
+49 applications, such as AlphaGo (Silver et al., 2016), AlphaStar (Vinyals et al., 2019), AlphaTensor   
+50 (Fawzi et al., 2022), and thus it also attracted much attention in the MO problems, including chip   
+51 design (Mirhoseini et al., 2021) and scheduling problems (Zhang et al., 2023). In the past, several   
+52 researchers used DRL methods as construction heuristics, and their methods did improve scheduling   
+53 performance, illustrated as follows. Park et al. (2020) proposed a method based on DQN (Mnih et al.,   
+54 2015) for JSP in semiconductor manufacturing and showed that their DQN model outperformed GA   
+55 in terms of both scheduling performance (namely gap to the optimum on makespan) and computation   
+56 time. Lin et al. (2019) and Luo (2020) proposed different DQN models to decide the scheduling action   
+57 among the heuristic rules and improved the makespan and the tardiness over PDRs, respectively.   
+58 A recent DRL-based approach to solving JSP/FJSP problems is to leverage graph neural networks   
+59 (GNN) to design a size-agnostic representation (Zhang et al., 2020; Park et al., 2021b,a; Song et al.,   
+60 2023). In this approach, graph representation has better generalization ability in larger instances   
+61 and provides a holistic view of scheduling states. Zhang et al. (2020) proposed a DRL method   
+62 with disjunctive graph representation for JSP, called L2D (Learning to Dispatch), and used GNN   
+63 to encode the graph for scheduling decision. Besides, Song et al. (2023) extended their methods   
+64 to FJSP. Park et al. (2021b) used a similar strategy of (Zhang et al., 2020) but with different state   
+65 features and model structure. Park et al. (2021a) proposed a new approach to solving JSP, called   
+66 ScheduleNet, by using a different graph representation and a DRL model with the graph attention for   
+67 scheduling decision. Most of the experiments above showed that their models trained from small   
+68 instances still worked reasonably well for large test instances, and generally better than PDRs. Among   
+69 these methods, ScheduleNet achieved state-of-the-art (SOTA) performance. There are still other   
+70 DRL-based approaches to solving JSP/FJSP problems, but not construction heuristics. Zhang et al.   
+71 (2022) proposes another approach, called Learning to Search (L2S), a kind of search-based heuristics.   
+72 In this paper, we propose a new approach to solving JSP/FJSP, a kind of construction heuristics, also   
+73 based on GNN. In this new approach, we remove irrelevant machines and jobs, such as those finished,   
+74 such that the states include the remaining machines and jobs only. This approach is named residual   
+75 scheduling in this paper to indicate to work on the remaining graph.   
+76 Without irrelevant information, our experiments show that our approach reaches SOTA by outper  
+77 forming the above mentioned construction methods on some well-known open benchmarks, seven   
+78 for JSP and two for FJSP, as described in Section 4. We also observe that even though our model   
+79 is trained for scheduling problems of smaller sizes, our method still performs well for scheduling   
+80 problems of large sizes. Interestingly in our experiments, our approach even reaches zero gap for 49   
+81 among 50 JSP instances whose job numbers are more than 150 on 20 machines.
+
+# 82 2 Problem Formulation
+
+# 2.1 JSP and FJSP
+
+A $n \times m$ JSP instance contains $n$ jobs and $m$ machines. Each job $J _ { j }$ consists of a sequence of $k _ { j }$ operations $\{ O _ { j , 1 } , \dotsc , O _ { j , k _ { j } } \}$ , where operation $O _ { j , i }$ must be started after $O _ { j , i - 1 }$ is finished. One machine can process at most one operation at a time, and preemption is not allowed upon processing operations. In JSP, one operation $O _ { j , i }$ is allowed to be processed on one designated machine, denoted by $M _ { j , i }$ , with a processing time, denoted by $T _ { j , i } ^ { ( o p ) }$ . Table 1 (a) illustrates a $3 \times 3$ JSP instance, where the three jobs have 3, 3, 2 operations respectively, each of which is designated to be processed on
+
+90 one of the three machines $\{ M _ { 1 } , M _ { 2 } , M _ { 3 } \}$ in the table. A solution of a JSP instance is to dispatch all   
+91 operations Oj,i to the corresponding machine Mj,i at time τ (s)j,i  , such that the above constraints are   
+92   
+93 While there are different expected goals, such as makespan, tardiness, etc., this paper focuses on   
+94 makespan. Let the first osolution is defined to be $\tau = 0$ in a JSP soluti all operations nitially. , where   
+95 $T ^ { ( m k s p ) } = \operatorname* { m a x } ( \tau _ { j , i } ^ { ( c ) } )$ $O _ { j , i }$ $\tau _ { j , i } ^ { ( c ) } = \tau _ { j , i } ^ { ( s ) } + T _ { j , i } ^ { ( o p ) }$   
+96 denotes the completion time of $O _ { j , i }$ . The makespans for the two solutions illustrated in Figure 1 (a)   
+97 and (b) are 12 and 15 respectively. The objective is to derive a solution that minimizes the makespan   
+98 $T ^ { ( m k s p ) }$ , and the solution of Figure 1 (a) reaches the optimal.   
+99 A $n \times m$ FJSP instance is also a $n \times m$ JSP instance with the following difference. In FJSP,   
+100 all operations $O _ { j , i }$ are allowed to be dispatched to multiple designated machines with designated   
+101 processing times. Table 1 (b) illustrates a $3 \times 3$ FJSP instance, where multiple machines can be   
+102 designated to be processed for one operation. Figure 1 (c) illustrates a solution of an FJSP instance,   
+103 which takes a shorter time than that in Figure 1 (d).
+
+Table 1: JSP and FJSP instances   
+(b) A $3 \times 3$ FJSP instance   
+
+<table><tr><td rowspan=1 colspan=1>Job</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>M1</td><td rowspan=1 colspan=1>M2</td><td rowspan=1 colspan=1>M3</td></tr><tr><td rowspan=3 colspan=1>Job 1</td><td rowspan=1 colspan=1>O1,1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>O1.2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>O1.3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=3 colspan=1>Job 2</td><td rowspan=1 colspan=1>O2,1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>02.2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>02.3</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=2 colspan=1>Job 3</td><td rowspan=1 colspan=1>O3,1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>03.2</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2</td></tr></table>
+
+(a) A $3 \times 3$ JSP instance   
+
+<table><tr><td rowspan=1 colspan=1>Job</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>M1</td><td rowspan=1 colspan=1>M2</td><td rowspan=1 colspan=1>M3</td></tr><tr><td rowspan=3 colspan=1>Job 1</td><td rowspan=1 colspan=1>O1,1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>O1.2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>O1.3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=3 colspan=1>Job 2</td><td rowspan=1 colspan=1>O2,1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>02,2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>O2,3</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=2 colspan=1>Job 3</td><td rowspan=1 colspan=1>O3，1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>03.2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2</td></tr></table>
+
+![](images/54e0e1086515bc311b9d4a17fdee1c89c424b15d95726a4af33fc4a68fbe5ad1.jpg)  
+Figure 1: Both (a) and (b) are solutions of the $3 \mathrm { x } 3$ JSP instance in Table 1 (a), and the former has the minimal makespan, 12. Both (c) and (d) are solutions of the $3 \mathrm { x } 3$ FJSP instance in Table 1 (b), and the former has the minimal makespan, 9.
+
+# 104 2.2 Construction Heuristics
+
+105 An approach to solving these scheduling problems is to construct solutions step by step in a greedy   
+106 manner, and the heuristics based on this approach is called construction heuristics in this paper. In   
+107 the approach of construction heuristics, a scheduling solution is constructed through a sequence of   
+108 partial solutions in a chronicle order of dispatching operations step by step, defined as follows. The   
+109 $t$ -th partial solution $S _ { t }$ associates with a dispatching time $\tau _ { t }$ and includes a partial set of operations   
+110 that have been dispatched by $\tau _ { t }$ (inclusive) while satisfying the above JSP constraints, and all the   
+111 remaining operations must be dispatched after $\tau _ { t }$ (inclusive). The whole construction starts with $S _ { 0 }$   
+112 where none of operations have been dispatched and the dispatching time is $\tau _ { 0 } = 0$ . For each $S _ { t }$ , a set   
+113 of operations to be chosen for dispatching form a set of pairs of $( M , O )$ , called candidates $C _ { t }$ , where   
+114 operations $O$ are allowed to be dispatched on machines $M$ at $\tau _ { t }$ . An agent (or a heuristic algorithm)   
+115 chooses one from candidates $C _ { t }$ for dispatching, and transits the partial solution to the next $S _ { t + 1 }$ . If   
+116 there exists no operations for dispatching, the whole solution construction process is done and the   
+117 partial solution is a solution, since no further operations are to be dispatched.   
+118 Figure 2 illustrates a solution construction process for the 3x3 JSP instance in Table 1(a), constructed   
+119 through nine partial solutions step by step. The initial partial solution $S _ { 0 }$ starts without any operations   
+120 dispatched as in Figure 2 (a). The initial candidates $C _ { 0 }$ are $\{ ( M _ { 1 } , O _ { 1 , 1 } ) , ( M _ { 3 } , O _ { 2 , 1 } ) , ( \bar { M _ { 1 } } , O _ { 3 , 1 } ) \}$   
+121 Following some heuristic, construct a solution from partial solution $S _ { 0 }$ to $S _ { 9 }$ step by step as in the   
+122 Figure, where the dashed line in red indicate the time $\tau _ { t }$ . The last one $S _ { 9 }$ , the same as the one in   
+123 Figure 1 (a), is a solution, since all operations have been dispatched, and the last operation ends at   
+124 time 12, the makespan of the solution.   
+125 For FJSP, the process of solution construction is almost the same except for that one operation have   
+126 multiple choices from candidates. Besides, an approach based on solution construction can be also   
+127 viewed as the so-called Markov decision process $( M D P )$ , and the MDP formulation for solution   
+128 construction is described in more detail in the appendix.
+
+![](images/cb96d32bb1f5dcecc876eaf54a9e7682b46451e9161fb74084ead5c2b39e2e49.jpg)  
+Figure 2: Solution construction, a sequence of partial solutions from $S _ { 0 }$ to $S _ { 8 }$ .
+
+# 129 3 Our Approach
+
+130 In this section, we present a new approach, called residual scheduling, to solving scheduling problems.   
+131 We introduce the residual scheduling in Subsection 3.1, describe the design of the graph representation   
+132 in Subsection 3.2, propose a model architecture based on graph neural network in Subsection 3.3 and   
+133 present a method to train this model in Subsection 3.4;
+
+# 34 3.1 Residual Scheduling
+
+135 In our approach, the key is to remove irrelevant information, particularly for operations, from states   
+136 (including partial solutions). An important benefit from this is that we do not need to include all   
+137 irrelevant information while training to minimize the makespan. Let us illustrate by the state for the   
+138 partial solution $S _ { 3 }$ at time $\tau _ { 3 } = 3$ in Figure 2 (d). All processing by $\tau _ { 3 }$ are irrelevant to the remaining   
+139 scheduling. Since operations $O _ { 1 , 1 }$ and $O _ { 2 , 1 }$ are both finished and irrelevant the rest of scheduling,   
+140 they can be removed from the state of $S _ { 3 }$ . In addition, operation $O _ { 2 , 2 }$ is dispatched at time 2 (before   
+141 $\tau _ { 3 } = 3$ ) and its processing time is $T _ { 2 , 1 } ^ { ( o p ) } = 4$ , so the operation is marked as ongoing. Thus, the   
+142 operation can be modified to start at $\tau _ { 3 } = 3$ with a processing time . Thus, the modified   
+143 state for $S _ { 3 }$ do not contain both $O _ { 1 , 1 }$ and $O _ { 2 , 1 }$ , and modify $O _ { 2 , 2 }$ as above. Let us consider two more   
+144 examples. For $S _ { 4 }$ , one more operation $O _ { 2 , 2 }$ is dispatched and thus marked as ongoing, however, the   
+145 time $\tau _ { 4 }$ remains unchanged and no more operations are removed. In this case, the state is almost the   
+146 same except for including one more ongoing operation $O _ { 2 , 2 }$ . Then, for $S _ { 5 }$ , two more operations $O _ { 3 , 1 }$   
+147 and $O _ { 2 , 2 }$ are removed and the ongoing operation $O _ { 1 , 2 }$ changes its processing time to the remaining   
+148 time (5-3).   
+149 For residual scheduling, we also reset the dispatching time $\tau = 0$ for all states with partial solutions   
+150 modified as above, so we derive makespans which is also irrelevant to the earlier operations. Given   
+151 a scheduling policy $\pi$ , $T _ { \pi } ^ { ( m k s p ) } ( S )$ is defined to be the makespan derived from an episode starting   
+152 from states $S$ by following $\pi$ , and $T _ { \pi } ^ { ( m k s p ) } ( S , a )$ the makespan by taking action $a$ on $S$ .
+
+# 153 3.2 Residual Graph Representation
+
+154 In this paper, our model design is based on graph neural network (GNN), and leverage GNN to   
+155 extract the scheduling decision from the relationship in graph. In this subsection, we present the   
+156 graph representation. Like many other researchers such as Park et al. (2021a), we formulate a partial   
+157 solution into a graph $\mathcal { G } = ( \nu , \mathcal { E } )$ , where $\nu$ is a set of nodes and $\mathcal { E }$ is a set of edges. A node is either a   
+158 machine node $M$ or an operation node $O$ . An edge connects two nodes to represent the relationship   
+159 between two nodes, basically including three kinds of edges, namely operation-to-operation $( O \to O$ ),   
+160 machine-to-operation $M  O$ ) and operation-to-machine $( O \to M$ ). All operations in the same   
+161 job are fully connected as $O  O$ edges. If an operation $O$ is able to be performed on a machine   
+162 $M$ , there exists both $O \to M$ and $M  O$ directed edges. In (Park et al., 2021a), they also let all   
+163 machines be fully connected as $M \to M$ edges. However, our experiments in section 4 show that   
+164 mutual $M \to M$ edges do not help much based on our Residual Scheduling. An illustration for graph   
+165 representation of $S _ { 3 }$ is depicted in Figure 3 (a).   
+166 In the graph representation, all nodes need to include some attributes so that a partial solution $S$ at   
+167 the dispatching time $\tau$ can be supported in the MDP formulation (in the appendix). Note that many of   
+168 the attributes below are normalized to reduce variance. For nodes corresponding to operations $O _ { j , i }$ ,   
+169 we have the following attributes:   
+170 Status $\phi _ { j , i }$ : The operation status $\phi _ { j , i }$ is completed if the operation has been finished by $\tau$ , ongoing if   
+171 the operation is ongoing (i.e., has been dispatched to some machine by $\tau$ and is still being processed   
+172 at $\tau$ ), ready if the operation designated to the machine which is idle has not been dispatched yet and   
+173 its precedent operation has been finished, and unready otherwise. For example, in Figure 3 (a), the   
+174 gray nodes are completed, the red ongoing, the yellow ready and the white unready. In our residual   
+175 scheduling, there exists no completed operations in all partial solutions, since they are removes for   
+176 irrelevance of the rest of scheduling. The attribute is a one-hot vector to represent the current status   
+177 of the operation, which is one of ongoing, ready and unready. Illustration for all states $S _ { 0 }$ to $S _ { 8 }$ are   
+178 shown in the appendix.   
+179 Normalized processing time $\bar { T } _ { j , i } ^ { ( o p ) }$ : Let the maximal processing time be $T _ { m a x } ^ { ( o p ) } = \operatorname* { m a x } _ { \forall j , i } ( T _ { j , i } ^ { ( o p ) } )$   
+180 Then, T¯(op)j,i $\bar { T } _ { j , i } ^ { ( o p ) } = T _ { j , i } ^ { ( o p ) } / T _ { m a x } ^ { ( o p ) }$ . In our residual scheduling, the operations that have been finished are   
+181 removed in partial solutions and therefore their processing time can be ignored; the operations that   
+182 has not been dispatched yet still keep their processing times the same; the operations that are ongoing   
+183 change their processing times to the remaining times after the dispatching time $\tau _ { t }$ . As for FJSP, the   
+184 operations that has not been dispatched yet may have several processing times on different machines,   
+185 and thus we can simply choose the average of these processing times.
+
+![](images/a3a8af5ab1851b807add19a4a2a54f81ec9c7979dcede6e1a0cd5113aacd0d36.jpg)  
+Figure 3: Graph representation and networks.
+
+ob remaining time , and let the process $\bar { T } _ { j , i } ^ { ( j o b ) }$ : Let the rest of pre for the whole job $J _ { j }$ $T _ { j , i } ^ { ( j o b ) } =$ $\sum _ { \forall i ^ { \prime } \geq i } T _ { j , i ^ { \prime } } ^ { ( o p ) }$ aced by th ing timocessing time for the original jo $j$ $\begin{array} { r } { T _ { j } ^ { ( j o b ) } = \sum _ { \forall i ^ { \prime } } T _ { j , i ^ { \prime } } ^ { ( o p ) } } \end{array}$ . In practice, T ( j ob )j is $j$ $\bar { T } _ { j , i } ^ { ( j o b ) } = T _ { j , i } ^ { ( j o b ) } / T _ { j } ^ { ( j o b ) }$ . For FJSP, since operations $O _ { j , i }$ can be dispatched to different designated machines $M _ { l }$ , say with the processing time T (op)j,i,l , we simply let T (op)j,i be the average of $T _ { j , i , l } ^ { ( o p ) }$ for all $M _ { l }$ .
+
+For machine nodes corresponding to machines $M _ { l }$ , we have the following attributes:
+
+Machine status $\phi _ { l }$ : The machine status $\phi _ { l }$ is processing if some operation has been dispatched to and is being processed by $M _ { l }$ at $\tau$ , and idle otherwise (no operation is being processed at $\tau$ ). The attribute is a one-hot vector to represent the current status, which is one of processing and idle.
+
+Normalized operation processing time $\bar { T } _ { l } ^ { ( m a c ) }$ : On the machine $M _ { l }$ , the processing time $T _ { l } ^ { ( m a c ) }$ is $T _ { j , i } ^ { ( o p ) }$ (the same as the normalized processing time for node $O _ { j , i }$ ) if the machine status is processing, i.e., some ongoing operation $O _ { j , i }$ is being processed but not finished yet, is zero if the machine status is idle. Then, this attribute is normalized to $T _ { m a x } ^ { ( o p ) }$ and thus $\bar { T } _ { l } ^ { ( m a c ) } = T _ { l } ^ { ( m a c ) } / T _ { m a x } ^ { ( o p ) }$ .
+
+Now, consider edges in a residual scheduling graph. As described above, there exists three relationship sets for edges, $O  O$ , $O \to M$ and $M  O$ . First, for the same job, say $J _ { j }$ , all of its operation nodes for $O _ { j , i }$ are fully connected. Note that for residual scheduling the operations finished by the dispatching time $\tau$ are removed and thus have no edges to them. Second, a machine node for $M _ { l }$ is connected to an operation node for $O _ { j , i }$ , if the operation $O _ { j , i }$ is designated to be processed on the machine $M _ { l }$ , which forms two edges $\dot { O }  M$ and $M  O$ . Both contains the following attribute.
+
+Normalized operation processing tim e T¯(edge): The attribute is $\bar { T } _ { j , i , l } ^ { ( e d g e ) } = T _ { j , i } ^ { ( o p ) } / T _ { m a x } ^ { ( o p ) }$ . Here, $T _ { j , i } ^ { ( o p ) } = T _ { j , i , l } ^ { ( o p ) }$ $O _ { j , i }$ $T _ { j , i } ^ { ( o p ) }$ is the remaining time as described above.
+
+# 3.3 Graph Neural Network
+
+In this subsection, we present our model based on graph neural network (GNN). GNN are a family of deep neural networks (Battaglia et al., 2018) that can learn representation of graph-structured data, widely used in many applications (Lv et al., 2021; Zhou et al., 2020). A GNN aggregates information from node itself and its neighboring nodes and then update the data itself, which allows the GNN to capture the complex relationships within the data graph. For GNN, we choose Graph Isomorphism Network (GIN), which was shown to have strong discriminative power ( $\mathrm { { X u } }$ et al., 2019) and summarily reviewed as follows. Given a graph $\mathcal { G } = ( \nu , \mathcal { E } )$ and $K$ GNN layers $K$ iterations), GIN performs the $k$ -th iterations of updating feature embedding $h ^ { ( k ) }$ for each node $v \in \mathcal V$ :
+
+$$
+h _ { v } ^ { ( k ) } = M L P ^ { ( k ) } ( ( 1 + \epsilon ^ { ( k ) } ) h _ { v } ^ { ( k - 1 ) } + \sum _ { u \in N _ { b } ( v ) } h _ { u } ^ { ( k - 1 ) } ) ,
+$$
+
+217 where $h _ { v } ^ { ( k ) }$ is the embedding of node $v$ at the $k$ -th layer, $\epsilon ^ { ( k ) }$ is an arbitrary number that can be   
+218 learned, and $N _ { b } ( v )$ is the neighbors of $v$ via edges in $\mathcal { E }$ . Note that $h _ { v } ^ { ( 0 ) }$ refers to its raw features for   
+219 input. $M L P ^ { ( k ) }$ is a Multi-Layer Perceptron $( M L P )$ for the $k$ -th layer with a batch normalization   
+220 (Ioffe and Szegedy, 2015).   
+221 Furthermore, we actually use heterogeneous GIN, also called HGIN, since there are two types of   
+222 nodes, machine and operation nodes, and three relations, $O  O$ , $O \to M$ and $M  O$ in the   
+223 graph representation. Although we do not have cross machine relations $M \to M$ as described above,   
+224 updating machine nodes requires to include the update from itself as in (1), that is, there is also one   
+225 more relation $M \to M$ . Thus, HGIN encodes graph information between all relations by using the   
+226 four MLPs as follows,
+
+$$
+h _ { v } ^ { ( k + 1 ) } = \sum _ { \mathcal { R } } M L P _ { \mathcal { R } } ^ { ( k + 1 ) } ( ( 1 + \epsilon _ { \mathcal { R } } ^ { ( k + 1 ) } ) h _ { v } ^ { ( k ) } + \sum _ { u \in N _ { \mathcal { R } } ( v ) } h _ { u } ^ { ( k ) } )
+$$
+
+where 227 $\mathcal { R }$ is one of the above fo elatio $M L P _ { \mathcal { R } } ^ { ( k ) }$ is the MLP for $\mathcal { R }$ . For example, for $S _ { 0 }$ in Figure 2 (a), the embedding of $M _ { 1 }$ $( k + 1 )$ -st iteration can be derived as follows.
+
+$$
+h _ { M _ { 1 } } ^ { ( k + 1 ) } = M L P _ { M M } ^ { ( k + 1 ) } ( ( 1 + \epsilon _ { M M } ^ { ( k + 1 ) } ) h _ { M _ { 1 } } ^ { ( k ) } ) + M L P _ { O M } ^ { ( k + 1 ) } ( h _ { O _ { 1 , 1 } } ^ { ( k ) } + h _ { O _ { 1 , 2 } } ^ { ( k ) } + h _ { O _ { 1 , 3 } } ^ { ( k ) } )
+$$
+
+229 Similarly, the embedding of $O _ { 1 , 1 }$ in the $( k + 1 )$ -st iteration is:
+
+$$
+h _ { O _ { 1 , 1 } } ^ { ( k + 1 ) } = M L P _ { O O } ^ { ( k + 1 ) } ( ( 1 + \epsilon _ { O O } ^ { ( k + 1 ) } ) h _ { O _ { 1 , 1 } } ^ { ( k ) } + h _ { O _ { 1 , 2 } } ^ { ( k ) } + h _ { O _ { 1 , 3 } } ^ { ( k ) } ) + M L P _ { M O } ^ { ( k + 1 ) } ( h _ { M _ { 1 } } ^ { ( k ) } )
+$$
+
+230 In our approach, an action includes the two phases, graph embedding phase and action selection phase.   
+231 Let $h _ { \mathcal { G } } ^ { ( k ) }$ denote the whole embedding of the graphs $\mathcal { G }$ , a summation of the embeddings of all nodes,   
+232 $h _ { v } ^ { ( k + 1 ) }$ . In the graph embedding phase, we use an HGIN to encode node and graph embeddings as   
+233 described above. An example with three HGIN layers is illustrated in Figure 3 (b).
+
+In the action selection phase, we select an action based on a policy, after node and graph embedding are encoded in the graph embedding phase. The policy is described as follows. First, collect all ready operations $O$ to be dispatched to machines $M$ . Then, for all pairs $( M , O )$ , feed their node embeddings $( h _ { M } ^ { ( k ) } , h _ { O } ^ { ( k ) } )$ into a MLP $S c o r e ( M , O )$ to calculate their scores as shown in Figure 3 (c). The probability of selecting $( M , O )$ is calculated based on a softmax function of all scores, which also serves as the model policy $\pi$ for the current state.
+
+# 3.4 Policy-Based RL Training
+
+41 In this paper, we propose to use a policy-based RL training mechanism that follows REINFORCE   
+42 (Sutton and Barto, 2018) to update our model by policy gradient with a normalized advantage   
+43 makespan with respect to a baseline policy $\pi _ { b }$ as follows.
+
+$$
+A _ { \pi } ( S , a ) = { \frac { T _ { \pi _ { b } } ^ { ( m k s p ) } ( S , a ) - T _ { \pi } ^ { ( m k s p ) } ( S , a ) } { T _ { \pi _ { b } } ^ { ( m k s p ) } ( S , a ) } }
+$$
+
+244 In this paper, we choose a lightweight PDR, MWKR, as baseline $\pi _ { b }$ , which performed best for   
+245 makespan among all PDRs reported from the previous work (Zhang et al., 2020). In fact, our   
+246 experiment also shows that using MWKR is better than the other PDRs shown in the appendix. The   
+247 model for policy $\pi$ is parametrized by $\theta$ , which is updated by $\nabla _ { \boldsymbol { \theta } } l o g \pi _ { \boldsymbol { \theta } } A _ { \pi _ { \boldsymbol { \theta } } } \bigl ( S _ { t } , a _ { t } \bigr )$ . Our algorithm   
+248 based on REINFORCE is listed in the appendix.
+
+# 4 Experiments
+
+# 4.1 Experimental Settings and Evaluation Benchmarks
+
+In our experiments, the settings of our model are described as follows. All embedding and hidden vectors in our model have a dimension of 256. The model contains three HGIN layers for graph embedding, and an MLP for the score function, as shown in Figure 3 (b) and (c). All MLP networks including those in HGIN and for score contain two hidden layers. The parameters of our model, such as MLP, generally follow the default settings in PyTorch (Paszke et al., 2019) and PyTorch Geometric (Fey and Lenssen, 2019). More settings are in the appendix.
+
+Each of our models is trained with one million episodes, each with one scheduling instance. Each instance is generated by following the procedure which is used to generate the TA dataset (Taillard, 1993). Given $( N , M )$ , we use the procedure to generate an $n \times m$ JSP instance by conforming to the following distribution, $n \sim \mathcal { U } ( \bar { 3 } , N )$ , $m \sim \mathcal { U } ( 3 , n )$ , and operation count $k _ { j } = m$ , where $\boldsymbol { \mathcal { U } } ( \boldsymbol { x } , \boldsymbol { y } )$ represents a distribution that uniformly samples an integer in a close interval $[ x , y ]$ at random. The details of designation for machines and processing times refer to (Taillard, 1993) and thus are omitted here. We choose (10,10) for all experiments, since (10,10) generally performs better than the other two as described in the appendix. Following the method described in Subsection 3.4, the model is updated from the above randomly generated instances. For testing our models for JSP and FJSP, seven JSP open benchmarks and two FJSP open benchmarks are used, as listed in the appendix.
+
+67 The performance for a given policy method $\pi$ on an instance is measured by the makespan gap $G$   
+68 defined as
+
+$$
+G = \frac { T _ { \pi } ^ { \left( m k s p \right) } - T _ { \pi * } ^ { \left( m k s p \right) } } { T _ { \pi * } ^ { \left( m k s p \right) } }
+$$
+
+where 269 $T _ { \pi * } ^ { ( m k s p ) }$ is the optimal makespan or the best-effort makespan, from a mathematical optimization 270 tool, OR-Tools, serving as . By the best-effort makespan, we mean the makespan derived with a
+
+Table 2: Average makespan gaps for TA benchmarks.   
+
+<table><tr><td rowspan=1 colspan=1>Size</td><td rowspan=1 colspan=1>15×15</td><td rowspan=1 colspan=1>20×15</td><td rowspan=1 colspan=1>20×20</td><td rowspan=1 colspan=1>30×15</td><td rowspan=1 colspan=1>30×20</td><td rowspan=1 colspan=1>50×15</td><td rowspan=1 colspan=1>50×20</td><td rowspan=1 colspan=1>100×20</td><td rowspan=1 colspan=1>Aug.</td></tr><tr><td rowspan=1 colspan=1>RS</td><td rowspan=1 colspan=1>0.148</td><td rowspan=1 colspan=1>0.165</td><td rowspan=1 colspan=1>0.169</td><td rowspan=1 colspan=1>0.144</td><td rowspan=1 colspan=1>0.177</td><td rowspan=1 colspan=1>0.067</td><td rowspan=1 colspan=1>0.100</td><td rowspan=2 colspan=1>0.0260.050</td><td rowspan=2 colspan=1>0.1250.150</td></tr><tr><td rowspan=1 colspan=1>RS+op</td><td rowspan=1 colspan=1>0.143</td><td rowspan=1 colspan=1>0.193</td><td rowspan=1 colspan=1>0.159</td><td rowspan=1 colspan=1>0.192</td><td rowspan=1 colspan=1>0.213</td><td rowspan=1 colspan=1>0.123</td><td rowspan=1 colspan=1>0.126</td></tr><tr><td rowspan=1 colspan=1>MWKR</td><td rowspan=2 colspan=1>0.1910.2050.258</td><td rowspan=2 colspan=1>0.2330.2350.328</td><td rowspan=2 colspan=1>0.2180.2170.277</td><td rowspan=2 colspan=1>0.2390.2280.352</td><td rowspan=2 colspan=1>0.2510.2490.344</td><td rowspan=3 colspan=1>0.1680.1730.2410.206</td><td rowspan=3 colspan=1>0.1790.1760.2550.239</td><td rowspan=3 colspan=1>0.0830.0910.1440.135</td><td rowspan=3 colspan=1>0.1950.1970.2750.254</td></tr><tr><td rowspan=1 colspan=1>MORSPT</td></tr><tr><td rowspan=1 colspan=1>FIFO</td><td rowspan=1 colspan=1>0.239</td><td rowspan=1 colspan=1>0.314</td><td rowspan=1 colspan=1>0.273</td><td rowspan=1 colspan=1>0.311</td><td rowspan=1 colspan=1>0.311</td></tr><tr><td rowspan=2 colspan=1>L2DParkSchN</td><td rowspan=2 colspan=1>0.2590.2010.152</td><td rowspan=1 colspan=1>0.300</td><td rowspan=1 colspan=1>0.316</td><td rowspan=1 colspan=1>0.329</td><td rowspan=1 colspan=1>0.336</td><td rowspan=1 colspan=1>0.223</td><td rowspan=1 colspan=1>0.265</td><td rowspan=2 colspan=1>0.1360.0920.066</td><td rowspan=2 colspan=1>0.2700.2210.161</td></tr><tr><td rowspan=1 colspan=1>0.2490.194</td><td rowspan=1 colspan=1>0.2920.172</td><td rowspan=1 colspan=1>0.2460.190</td><td rowspan=1 colspan=1>0.3190.237</td><td rowspan=1 colspan=1>0.1590.138</td><td rowspan=1 colspan=1>0.2120.135</td></tr></table>
+
+271 sufficiently large time limitation, namely half a day with OR-Tools. For comparison in experiments,   
+272 we use a server with Intel Xeon E5-2683 CPU and a single NVIDIA GeForce GTX 1080 Ti GPU.   
+273 Our method uses a CPU thread and a GPU to train and evaluate, while OR-Tools uses eight threads   
+274 to find the solution.
+
+# 4.2 Experiments for JSP
+
+For JSP, we first train a model based on residual scheduling, named RS. For ablation testing, we also train a model, named $\mathrm { R S + o p }$ , by following the same training method but without removing irrelevant operations. When using these models to solve testing instances, action selection is based on the greedy policy that simply chooses the action $( M , O )$ with the highest score deterministically, obtained from the score network as in Figure 3 (c).
+
+281 For comparison, we consider the three DRL construction heuristics, respectively developed in (Zhang   
+282 et al., 2020) called L2D, (Park et al., 2021b) by Park et al., and (Park et al., 2021a), called ScheduleNet.   
+283 We directly use the performance results of these methods for open benchmarks from their articles.   
+284 For simplicity, they are named L2D, Park and SchN respectively in this paper. We also include some   
+285 construction heuristics based PDR, such as MWKR, MOR, SPT and FIFO. Besides, to derive the   
+286 gaps to the optimum in all cases, OR-Tools serve as $\pi *$ as described in (6).   
+287 Now, let us analyze the performances of RS as follows. Table 2 shows the average makespan gaps   
+288 for each collection of JSP TA benchmarks with sizes, $1 5 { \times } 1 5$ , $2 0 \times 1 5$ , $2 0 \times 2 0$ , $3 0 \times 1 5$ , $3 0 \times 2 0$ , $5 0 \times 1 5$ ,   
+289 $5 0 \times 2 0$ and $1 0 0 \times 2 0$ , where the best performances (the smallest gaps) are marked in bold. In general,   
+290 RS performs the best, and generally outperforms the other methods for all collections by large   
+291 margins, except for that it has slightly higher gaps than ${ \mathrm { R S + o p } }$ for the two collections, $1 5 \times 1 5$ and   
+292 $2 0 \times 2 0$ . In fact, ${ \mathrm { R S + o p } }$ also generally outperforms the rest of methods, except for that it is very   
+293 close to SchN for two collections. For the other six open benchmarks, ABZ, FT, ORB, YN, SWV   
+294 and LA, the performances are similar and thus presented in the appendix. It is concluded that RS   
+295 generally performs better than other construction heuristics by large margins.
+
+# 296 4.3 Experiments for FJSP
+
+Table 3: Average makespan gaps for FJSP open benchmarks   
+
+<table><tr><td>Method</td><td>MK</td><td>LA(rdata)</td><td>LA(edata)</td><td>LA(vdata)</td></tr><tr><td>RS</td><td>0.232</td><td>0.099</td><td>0.146</td><td>0.031</td></tr><tr><td>RS+op</td><td>0.254</td><td>0.113</td><td>0.168</td><td>0.029</td></tr><tr><td>DRL-G</td><td>0.254</td><td>0.111</td><td>0.150</td><td>0.040</td></tr><tr><td>MWKR MOR</td><td>0.282 0.296 0.457</td><td>0.125 0.147</td><td>0.149 0.179</td><td>0.051 0.061</td></tr></table>
+
+297 For FJSP, we also train a model based on residual scheduling, named RS, and a ablation version,   
+298 named $\mathrm { R S + o p }$ , without removing irrelevant operations. We compares ours with one DRL construction   
+299 heuristics developed by (Song et al., 2023), called DRL-G, and four PDR-based heuristics, MOR,   
+00 MWKR, SPT and FIFO. We directly use the performance results of these methods for open datasets   
+01 according to the reports from (Song et al., 2023).   
+02 Table 3 shows the average makespan gaps in the four open benchmarks, MK, LA(rdata), LA(edata)   
+03 and LA(vdata). From the table, RS generally outperforms all the other methods for all benchmarks   
+04 by large margins, except for that ${ \mathsf { R S + o p } }$ is slightly better for the benchmark LA(vdata).
+
+# 05 5 Discussions
+
+In this paper, we propose a new approach, called residual scheduling, to solving JSP an FJSP problems, and the experiments show that our approach reaches SOTA among DRL-based construction heuristics on the above open JSP and FJSP benchmarks. We further discusses three issues: large instances, computation times and further improvement.
+
+![](images/1b83fd2ef9921abe986163a176919527de1940ffe5a722430f846b273b3a20da.jpg)  
+Figure 4: Average makespan gaps of JSP instances with different problem sizes.
+
+310 First, from the above experiments particularly for TA benchmark for JSP, we observe that the average   
+311 gaps gets smaller as the number of jobs increases, even if we use the same model trained with   
+312 $\bar { ( \cal N , M ) } = ( 1 0 , 1 0 )$ . In order to investigate size-agnostics, we further generate 13 collections of JSP   
+313 instances of sizes for testing, from $1 5 \times 1 5$ to $2 0 0 \times 2 0$ , and generate 10 instances for each collection   
+314 by using the procedure above. Figure 4 shows the average gaps for these collections for RS and L2D,   
+315 and these collections are listed in the order of sizes in the x-axis. Note that we only show the results   
+316 of L2D in addition to our RS, since L2D is the only open-source among the above DRL heuristics.   
+317 Interestingly, using RS, the average gaps are nearly zero for the collections with sizes larger than 100   
+318 $\times 1 5$ , namely, $1 0 0 \times 1 5$ , $1 0 0 \times 2 0$ , $1 5 0 \times 1 5$ , $2 0 0 \times 1 5$ and $2 0 0 \times 2 0$ . Among the 50 JSP instances   
+319 in the five collections, 49 reaches zero gaps. A strong implication is that our RS approach can be   
+320 scaled up for job sizes and even reach the optimal for sufficient large job count.   
+321 Second, the computation times for RS are relatively small and has low variance like most of other   
+322 construction heuristics. Here, we just use the collection of TA $1 0 0 \mathrm { x } 2 0$ for illustration. It takes about   
+323 30 seconds on average for both RS and $\mathrm { R S + o p }$ , about 28 for L2D and about 444 for SchN. In contrast,   
+324 it takes about 4000 seconds with high variance for OR-tools. The times for other collections are listed   
+325 in more detail in the appendix.   
+326 Third, as proposed by Song et al. (2023), construction heuristics can further improve the gap by   
+327 constructing multiple solutions based on the softmax policy, in addition to the greedy policy. They   
+328 had a version constructing 100 solutions for FJSP, called $\mathrm { \ D R L + 1 0 0 }$ in this paper. In this paper, we   
+329 also implement a RS version for FJSP based on the softmax policy, as described in Subsection 3.3,   
+330 and then use the version, called ${ \mathrm { R S } } { + } 1 0 0 \ $ , to constructing 100 solutions. In Table 4, the experimental   
+331 results show that ${ \mathrm { R S } } { + } 1 0 0 \ $ performs the best, much better than RS, DRL-G and $\mathrm { \ D R L + 1 0 0 }$ . An   
+332 important property for such an improvement is that constructing multiple solutions can be done in   
+333 parallel. That is, for construction heuristics, the solution quality can be improved by adding more   
+334 computation powers.
+
+Table 4: Average makespan gaps for FJSP open benchmark.   
+
+<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>MK</td><td rowspan=1 colspan=1>LA(rdata)</td><td rowspan=1 colspan=1>LA(edata)</td><td rowspan=1 colspan=1>LA(vdata)</td></tr><tr><td rowspan=1 colspan=1>RSRS+100</td><td rowspan=1 colspan=1>0.2320.154</td><td rowspan=1 colspan=1>0.0990.047</td><td rowspan=1 colspan=1>0.1460.079</td><td rowspan=1 colspan=1>0.0310.007</td></tr><tr><td rowspan=1 colspan=1>DRL-GDRL+100</td><td rowspan=1 colspan=1>0.2540.190</td><td rowspan=1 colspan=1>0.1110.058</td><td rowspan=1 colspan=1>0.1500.082</td><td rowspan=1 colspan=1>0.0400.014</td></tr></table>
+
+# References
+
+Majid Abdolrazzagh-Nezhad and Salwani Abdullah. 2017. Job Shop Scheduling: Classification, Constraints and Objective Functions. International Journal of Computer and Information Engineering 11, 4 (2017), 429–434.
+
+Joseph William Adams, Egon Balas, and Daniel J. Zawack. 1988. The Shifting Bottleneck Procedure for Job Shop Scheduling. Management science 34, 3 (1988), 391–401.
+
+David L. Applegate and William J. Cook. 1991. A Computational Study of the Job-Shop Scheduling Problem. INFORMS Journal on Computing 3, 2 (1991), 149–156. https://doi.org/10.1287/ ijoc.3.2.149
+
+Peter W. Battaglia, Jessica B. Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinícius Flores Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, Çaglar Gülçehre, H. Francis Song, Andrew J. Ballard, Justin Gilmer, George E. Dahl, Ashish Vaswani, Kelsey R. Allen, Charles Nash, Victoria Langston, Chris Dyer, Nicolas Heess, Daan Wierstra, Pushmeet Kohli, Matthew M. Botvinick, Oriol Vinyals, Yujia Li, and Razvan Pascanu. 2018. Relational inductive biases, deep learning, and graph networks. CoRR abs/1806.01261 (2018). arXiv:1806.01261 http://arxiv.org/abs/1806.01261
+
+Dennis Behnke and Martin Josef Geiger. 2012. Test instances for the flexible job shop scheduling problem with work centers. Arbeitspapier/Research Paper/Helmut-Schmidt-Universität, Lehrstuhl für Betriebswirtschaftslehre, insbes. Logistik-Management (2012).
+
+Paolo Brandimarte. 1993. Routing and scheduling in a flexible job shop by tabu search. Ann. Oper. Res. 41, 3 (1993), 157–183. https://doi.org/10.1007/BF02023073
+
+IBM ILOG Cplex. 2009. V12. 1: User’s Manual for CPLEX. International Business Machines Corporation 46, 53 (2009), 157.
+
+Mauro Dell’Amico and Marco Trubian. 1993. Applying tabu search to the job-shop scheduling problem. Annals of Operations Research 41, 3 (1993), 231–252. https://doi.org/10.1007/ BF02023076
+
+Alhussein Fawzi, Matej Balog, Aja Huang, Thomas Hubert, Bernardino Romera-Paredes, Mohammadamin Barekatain, Alexander Novikov, Francisco J R Ruiz, Julian Schrittwieser, Grzegorz Swirszcz, et al. 2022. Discovering faster matrix multiplication algorithms with reinforcement learning. Nature 610, 7930 (2022), 47–53.
+
+Matthias Fey and Jan Eric Lenssen. 2019. Fast Graph Representation Learning with PyTorch Geometric, In ICLR Workshop on Representation Learning on Graphs and Manifolds. CoRR abs/1903.02428. arXiv:1903.02428 http://arxiv.org/abs/1903.02428
+
+M. R. Garey and David S. Johnson. 1979. Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman, USA.
+
+Amit Kumar Gupta and Appa Iyer Sivakumar. 2006. Job shop scheduling techniques in semiconductor manufacturing. The International Journal of Advanced Manufacturing Technology 27, 11 (2006), 1163–1169.
+
+Reinhard Haupt. 1989. A survey of priority rule-based scheduling. Operations-Research-Spektrum 11, 1 (1989), 3–16.
+
+Johann Hurink, Bernd Jurisch, and Monika Thole. 1994. Tabu search for the job-shop scheduling problem with multi-purpose machines. Operations-Research-Spektrum 15 (1994), 205–215.
+
+Sergey Ioffe and Christian Szegedy. 2015. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. In International Conference on Machine Learning (ICML) (JMLR Workshop and Conference Proceedings, Vol. 37), Francis R. Bach and David M. Blei (Eds.). JMLR.org, 448–456. http://proceedings.mlr.press/v37/ioffe15.html
+
+381 Klaus Jansen, Monaldo Mastrolilli, and Roberto Solis-Oba. 2000. Approximation Algorithms for   
+382 Flexible Job Shop Problems. In Latin American Symposium on Theoretical Informatics (Lecture   
+383 Notes in Computer Science, Vol. 1776), Gaston H. Gonnet, Daniel Panario, and Alfredo Viola   
+384 (Eds.). Springer, 68–77. https://doi.org/10.1007/10719839_7   
+385 BJ Lageweg, JK Lenstra, and AHG Rinnooy Kan. 1977. Job-shop scheduling by implicit enumeration.   
+386 Management Science 24, 4 (1977), 441–450.
+
+Stephen Lawrence. 1984. Resouce constrained project scheduling: An experimental investigation of heuristic scheduling techniques (Supplement). Graduate School of Industrial Administration, Carnegie-Mellon University (1984).
+
+90 Zhigang Lian, Bin Jiao, and Xingsheng Gu. 2006. A similar particle swarm optimization algorithm   
+91 for job-shop scheduling to minimize makespan. Appl. Math. Comput. 183, 2 (2006), 1008–1017.   
+92 https://doi.org/10.1016/j.amc.2006.05.168   
+93 Chun-Cheng Lin, Der-Jiunn Deng, Yen-Ling Chih, and Hsin-Ting Chiu. 2019. Smart Manufacturing   
+394 Scheduling With Edge Computing Using Multiclass Deep Q Network. IEEE Trans. Ind. Informatics   
+395 15, 7 (2019), 4276–4284. https://doi.org/10.1109/TII.2019.2908210   
+96 Min Liu, Zhi-jiang Sun, Junwei Yan, and Jing-song Kang. 2011. An adaptive annealing genetic   
+97 algorithm for the job-shop planning and scheduling problem. Expert Systems with Applications 38,   
+98 8 (2011), 9248–9255. https://doi.org/10.1016/j.eswa.2011.01.136   
+99 Shu Luo. 2020. Dynamic scheduling for flexible job shop with new job insertions by deep reinforce  
+00 ment learning. Applied Soft Computing 91 (2020), 106208. https://doi.org/10.1016/j.   
+01 asoc.2020.106208   
+402 Mingqi Lv, Zhaoxiong Hong, Ling Chen, Tieming Chen, Tiantian Zhu, and Shouling Ji. 2021.   
+403 Temporal Multi-Graph Convolutional Network for Traffic Flow Prediction. IEEE Transactions   
+404 on Intelligent Transportation Systems 22, 6 (2021), 3337–3348. https://doi.org/10.1109/   
+405 TITS.2020.2983763   
+406 Azalia Mirhoseini, Anna Goldie, Mustafa Yazgan, Joe Wenjie Jiang, Ebrahim M. Songhori, Shen   
+407 Wang, Young-Joon Lee, Eric Johnson, Omkar Pathak, Azade Nazi, Jiwoo Pak, Andy Tong, Kavya   
+408 Srinivasa, Will Hang, Emre Tuncer, Quoc V. Le, James Laudon, Richard Ho, Roger Carpenter, and   
+409 Jeff Dean. 2021. A graph placement methodology for fast chip design. Nature 594, 7862 (2021),   
+410 207–212.   
+411 Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Belle  
+412 mare, Alex Graves, Martin A. Riedmiller, Andreas Fidjeland, Georg Ostrovski, Stig Petersen,   
+413 Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra,   
+414 Shane Legg, and Demis Hassabis. 2015. Human-level control through deep reinforcement learning.   
+415 Nature 518, 7540 (2015), 529–533. https://doi.org/10.1038/nature14236
+
+416 J.F. Muth and G.L. Thompson. 1963. Industrial Scheduling. Prentice-Hall.
+
+417 In-Beom Park, Jaeseok Huh, Joongkyun Kim, and Jonghun Park. 2020. A Reinforcement Learning   
+418 Approach to Robust Scheduling of Semiconductor Manufacturing Facilities. IEEE Transactions on   
+419 Automation Science and Engineering 17, 3 (2020), 1420–1431. https://doi.org/10.1109/   
+420 TASE.2019.2956762   
+421 Junyoung Park, Sanjar Bakhtiyar, and Jinkyoo Park. 2021a. ScheduleNet: Learn to solve multi-agent   
+422 scheduling problems with reinforcement learning. CoRR abs/2106.03051 (2021). arXiv:2106.03051   
+423 https://arxiv.org/abs/2106.03051   
+424 Junyoung Park, Jaehyeong Chun, Sang Hun Kim, Youngkook Kim, and Jinkyoo Park. 2021b.   
+425 Learning to schedule job-shop problems: representation and policy learning using graph neural   
+426 network and reinforcement learning. International Journal of Production Research 59, 11 (2021),   
+427 3360–3377. https://doi.org/10.1080/00207543.2020.1870013   
+429 Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Köpf, Ed  
+430 ward Z. Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit   
+431 Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. 2019. PyTorch: An Imperative Style, High  
+432 Performance Deep Learning Library. In Neural Information Processing Systems (NeurIPS),   
+433 Hanna M. Wallach, Hugo Larochelle, Alina Beygelzimer, Florence d’Alché-Buc, Emily B. Fox,   
+434 and Roman Garnett (Eds.). 8024–8035. https://proceedings.neurips.cc/paper/2019/   
+435 hash/bdbca288fee7f92f2bfa9f7012727740-Abstract.html   
+436 Laurent Perron and Vincent Furnon. 2019. OR-Tools. Google. https://developers.google.   
+437 com/optimization/   
+438 Ferdinando Pezzella, Gianluca Morganti, and Giampiero Ciaschetti. 2008. A genetic algorithm for   
+439 the Flexible Job-shop Scheduling Problem. Computers and Operations Research 35, 10 (2008),   
+440 3202–3212. https://doi.org/10.1016/j.cor.2007.02.014   
+441 Qing-dao-er-ji Ren and Yuping Wang. 2012. A new hybrid genetic algorithm for job shop scheduling   
+442 problem. Computers and Operations Research 39, 10 (2012), 2291–2299. https://doi.org/   
+443 10.1016/j.cor.2011.12.005   
+444 Mohammad Saidi-Mehrabad and Parviz Fattahi. 2007. Flexible job shop scheduling with tabu search   
+445 algorithms. The International Journal of Advanced Manufacturing Technology 32, 5 (2007),   
+446 563–570.   
+447 David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driess  
+448 che, Julian Schrittwieser, Ioannis Antonoglou, Vedavyas Panneershelvam, Marc Lanctot, Sander   
+449 Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy P. Lillicrap,   
+450 Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. 2016. Mastering   
+451 the game of Go with deep neural networks and tree search. Nature 529, 7587 (2016), 484–489.   
+452 https://doi.org/10.1038/nature16961   
+453 Wen Song, Xinyang Chen, Qiqiang Li, and Zhiguang Cao. 2023. Flexible Job-Shop Scheduling via   
+454 Graph Neural Network and Deep Reinforcement Learning. IEEE Trans. Ind. Informatics 19, 2   
+455 (2023), 1600–1610. https://doi.org/10.1109/TII.2022.3189725   
+456 Robert H. Storer, S. David Wu, and Renzo Vaccari. 1992. New search spaces for sequencing problems   
+457 with application to job shop scheduling. Management science 38, 10 (1992), 1495–1509.   
+458 Richard S. Sutton and Andrew G. Barto. 2018. Reinforcement Learning: An Introduction (second   
+459 ed.). The MIT Press. http://incompleteideas.net/book/the-book-2nd.html   
+460 Éric D. Taillard. 1993. Benchmarks for basic scheduling problems. european journal of operational   
+461 research 64, 2 (1993), 278–285.   
+462 Oriol Vinyals, Igor Babuschkin, Wojciech M. Czarnecki, Michaël Mathieu, Andrew Dudzik, Junyoung   
+463 Chung, David H. Choi, Richard Powell, Timo Ewalds, Petko Georgiev, Junhyuk Oh, Dan Horgan,   
+464 Manuel Kroiss, Ivo Danihelka, Aja Huang, Laurent Sifre, Trevor Cai, John P. Agapiou, Max   
+465 Jaderberg, Alexander Sasha Vezhnevets, Rémi Leblond, Tobias Pohlen, Valentin Dalibard, David   
+466 Budden, Yury Sulsky, James Molloy, Tom Le Paine, Çaglar Gülçehre, Ziyu Wang, Tobias Pfaff,   
+467 Yuhuai Wu, Roman Ring, Dani Yogatama, Dario Wünsch, Katrina McKinney, Oliver Smith, Tom   
+468 Schaul, Timothy P. Lillicrap, Koray Kavukcuoglu, Demis Hassabis, Chris Apps, and David Silver.   
+469 2019. Grandmaster level in StarCraft II using multi-agent reinforcement learning. Nature 575,   
+470 7782 (2019), 350–354. https://doi.org/10.1038/s41586-019-1724-z   
+471 Bernd Waschneck, Thomas Altenmüller, Thomas Bauernhansl, and Andreas Kyek. 2016. Production   
+472 Scheduling in Complex Job Shops from an Industry 4.0 Perspective: A Review and Challenges   
+473 in the Semiconductor Industry. In Proceedings of the 1st International Workshop on Science,   
+474 Application and Methods in Industry 4.0 (i-KNOW) (CEUR Workshop Proceedings, Vol. 1793),   
+475 Roman Kern, Gerald Reiner, and Olivia Bluder (Eds.). CEUR-WS.org. http://ceur-ws.org/   
+476 Vol-1793/paper3.pdf   
+477 Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. 2019. How Powerful are Graph Neural   
+478 Networks? (2019). https://openreview.net/forum?id=ryGs6iA5Km   
+479 Takeshi Yamada and Ryohei Nakano. 1992. A Genetic Algorithm Applicable to Large-Scale Job  
+480 Shop Problems. In Parallel Problem Solving from Nature 2, (PPSN-II), Reinhard Männer and   
+481 Bernard Manderick (Eds.). Elsevier, 283–292.   
+482 Cong Zhang, Wen Song, Zhiguang Cao, Jie Zhang, Puay Siew Tan, and Chi Xu. 2020. Learning   
+483 to Dispatch for Job Shop Scheduling via Deep Reinforcement Learning. In Neural Information   
+484 Processing Systems (NeurIPS), Hugo Larochelle, Marc’Aurelio Ranzato, Raia Hadsell, Maria  
+485 Florina Balcan, and Hsuan-Tien Lin (Eds.). https://proceedings.neurips.cc/paper/   
+486 2020/hash/11958dfee29b6709f48a9ba0387a2431-Abstract.html   
+487 Cong Zhang, Wen Song, Zhiguang Cao, Jie Zhang, Puay Siew Tan, and Chi Xu. 2022. Learning to   
+488 Search for Job Shop Scheduling via Deep Reinforcement Learning. CoRR abs/2211.10936 (2022).   
+489 https://doi.org/10.48550/arXiv.2211.10936 arXiv:2211.10936   
+490 Cong Zhang, Yaoxin Wu, Yining Ma, Wen Song, Zhang Le, Zhiguang Cao, and Jie Zhang. 2023. A   
+491 review on learning to solve combinatorial optimisation problems in manufacturing. IET Collabora  
+492 tive Intelligent Manufacturing 5, 1 (2023), e12072. https://doi.org/10.1049/cim2.12072   
+493 arXiv:https://ietresearch.onlinelibrary.wiley.com/doi/pdf/10.1049/cim2.12072   
+494 Jie Zhou, Ganqu Cui, Shengding Hu, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, Lifeng Wang,   
+495 Changcheng Li, and Maosong Sun. 2020. Graph neural networks: A review of methods and   
+496 applications. AI Open 1 (2020), 57–81. https://doi.org/10.1016/j.aiopen.2021.01.001

parse/dev/5uIL1E8h1E/5uIL1E8h1E_content_list.json

@@ -0,0 +1,1382 @@
+[
+    {
+        "type": "text",
+        "text": "Residual Scheduling: A New Reinforcement Learning Approach to Solving Job Shop Scheduling Problem ",
+        "text_level": 1,
+        "bbox": [
+            176,
+            122,
+            823,
+            172
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Anonymous Author(s)   \nAffiliation   \nAddress   \nemail ",
+        "bbox": [
+            423,
+            226,
+            578,
+            281
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "Abstract ",
+        "text_level": 1,
+        "bbox": [
+            462,
+            318,
+            535,
+            334
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "1 Job-shop scheduling problem (JSP) is a mathematical optimization problem widely   \n2 used in industries like manufacturing, and flexible JSP (FJSP) is also a common   \n3 variant. Since they are NP-hard, it is intractable to find the optimal solution for   \n4 all cases within reasonable times. Thus, it becomes important to develop efficient   \n5 heuristics to solve JSP/FJSP. A kind of method of solving scheduling problems   \n6 is construction heuristics, which constructs scheduling solutions via heuristics.   \n7 Recently, many methods for construction heuristics leverage deep reinforcement   \n8 learning (DRL) with graph neural networks (GNN). In this paper, we propose a new   \n9 approach, named residual scheduling, to solving JSP/FJSP. In this new approach,   \n10 we remove irrelevant machines and jobs such as those finished, such that the states   \n11 include the remaining (or relevant) machines and jobs only. Our experiments show   \n12 that our approach reaches state-of-the-art (SOTA) among all known construction   \n13 heuristics on most well-known open JSP and FJSP benchmarks. In addition, we   \n14 also observe that even though our model is trained for scheduling problems of   \n15 smaller sizes, our method still performs well for scheduling problems of large sizes.   \n16 Interestingly in our experiments, our approach even reaches zero gap for 49 among   \n17 50 JSP instances whose job numbers are more than 150 on 20 machines. ",
+        "bbox": [
+            148,
+            348,
+            766,
+            583
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "18 1 Introduction ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            608,
+            312,
+            626
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "19 The job-shop scheduling problem (JSP) is a mathematical optimization (MO) problem widely used in   \n20 many industries, like manufacturing (Zhang et al., 2020; Waschneck et al., 2016). For example, a   \n21 semiconductor manufacturing process can be viewed as a complex JSP problem (Waschneck et al.,   \n22 2016), where a set of given jobs are assigned to a set of machines under some constraints to achieve   \n23 some expected goals such as minimizing makespan which is focused on in this paper. While there are   \n24 many variants of JSP (Abdolrazzagh-Nezhad and Abdullah, 2017), we also consider an extension   \n25 called flexible JSP (FJSP) where job operations can be done on designated machines.   \n26 A generic approach to solving MO problems is to use mathematical programming, such as mixed   \n27 integer linear programming (MILP) and constraint satisfaction problem (CSP). Two popular generic   \n28 MO solvers for solving MO are OR-Tools (Perron and Furnon, 2019) and IBM ILOG CPLEX   \n29 Optimizer (abbr. CPLEX) (Cplex, 2009). However, both JSP and FJSP, as well as many other MO   \n30 problems, have been shown to be NP-hard (Garey and Johnson, 1979; Lageweg et al., 1977). That   \n31 said, it is unrealistic and intractable to find the optimal solution for all cases within reasonable times.   \n32 These tools can obtain the optimal solutions if sufficient time (or unlimited time) is given; otherwise,   \n33 return best-effort solutions during the limited time, which usually have gaps to the optimum. When   \n34 problems are scaled up, the gaps usually grow significantly.   \n35 In practice, some heuristics (Gupta and Sivakumar, 2006; Haupt, 1989) or approximate methods   \n36 (Jansen et al., 2000) were used to cope with the issue of intractability. A simple greedy approach is to   \n37 use the heuristics following the so-called priority dispatching rule (PDR) (Haupt, 1989) to construct   \n38 solutions. These can also be viewed as a kind of solution construction heuristics or construction   \n39 heuristics. Some of PDR examples are First In First Out (FIFO), Shortest Processing Time (SPT),   \n40 Most WorK Remaining (MWKR), and Most Operation Remaining (MOR). Although these heuristics   \n41 are usually computationally fast, it is hard to design generally effective rules to minimize the gap to   \n42 the optimum, and the derived results are usually far from the optimum.   \n43 Furthermore, a generic approach to automating the design of heuristics is called metaheuristics, such   \n44 as tabu search (Dell’Amico and Trubian, 1993; Saidi-Mehrabad and Fattahi, 2007) , genetic algorithm   \n45 (GA) (Pezzella et al., 2008; Ren and Wang, 2012), and PSO algorithms (Lian et al., 2006; Liu et al.,   \n46 2011). However, metaheuristics still take a high computation time, and it is not ensured to obtain the   \n47 optimal solution either.   \n48 Recently, deep reinforcement learning (DRL) has made several significant successes for some   \n49 applications, such as AlphaGo (Silver et al., 2016), AlphaStar (Vinyals et al., 2019), AlphaTensor   \n50 (Fawzi et al., 2022), and thus it also attracted much attention in the MO problems, including chip   \n51 design (Mirhoseini et al., 2021) and scheduling problems (Zhang et al., 2023). In the past, several   \n52 researchers used DRL methods as construction heuristics, and their methods did improve scheduling   \n53 performance, illustrated as follows. Park et al. (2020) proposed a method based on DQN (Mnih et al.,   \n54 2015) for JSP in semiconductor manufacturing and showed that their DQN model outperformed GA   \n55 in terms of both scheduling performance (namely gap to the optimum on makespan) and computation   \n56 time. Lin et al. (2019) and Luo (2020) proposed different DQN models to decide the scheduling action   \n57 among the heuristic rules and improved the makespan and the tardiness over PDRs, respectively.   \n58 A recent DRL-based approach to solving JSP/FJSP problems is to leverage graph neural networks   \n59 (GNN) to design a size-agnostic representation (Zhang et al., 2020; Park et al., 2021b,a; Song et al.,   \n60 2023). In this approach, graph representation has better generalization ability in larger instances   \n61 and provides a holistic view of scheduling states. Zhang et al. (2020) proposed a DRL method   \n62 with disjunctive graph representation for JSP, called L2D (Learning to Dispatch), and used GNN   \n63 to encode the graph for scheduling decision. Besides, Song et al. (2023) extended their methods   \n64 to FJSP. Park et al. (2021b) used a similar strategy of (Zhang et al., 2020) but with different state   \n65 features and model structure. Park et al. (2021a) proposed a new approach to solving JSP, called   \n66 ScheduleNet, by using a different graph representation and a DRL model with the graph attention for   \n67 scheduling decision. Most of the experiments above showed that their models trained from small   \n68 instances still worked reasonably well for large test instances, and generally better than PDRs. Among   \n69 these methods, ScheduleNet achieved state-of-the-art (SOTA) performance. There are still other   \n70 DRL-based approaches to solving JSP/FJSP problems, but not construction heuristics. Zhang et al.   \n71 (2022) proposes another approach, called Learning to Search (L2S), a kind of search-based heuristics.   \n72 In this paper, we propose a new approach to solving JSP/FJSP, a kind of construction heuristics, also   \n73 based on GNN. In this new approach, we remove irrelevant machines and jobs, such as those finished,   \n74 such that the states include the remaining machines and jobs only. This approach is named residual   \n75 scheduling in this paper to indicate to work on the remaining graph.   \n76 Without irrelevant information, our experiments show that our approach reaches SOTA by outper  \n77 forming the above mentioned construction methods on some well-known open benchmarks, seven   \n78 for JSP and two for FJSP, as described in Section 4. We also observe that even though our model   \n79 is trained for scheduling problems of smaller sizes, our method still performs well for scheduling   \n80 problems of large sizes. Interestingly in our experiments, our approach even reaches zero gap for 49   \n81 among 50 JSP instances whose job numbers are more than 150 on 20 machines. ",
+        "bbox": [
+            147,
+            638,
+            825,
+            736
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            742,
+            825,
+            867
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            873,
+            825,
+            901
+        ],
+        "page_idx": 0
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            92,
+            825,
+            174
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            181,
+            825,
+            250
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            256,
+            825,
+            395
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            145,
+            401,
+            825,
+            594
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            601,
+            825,
+            656
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            662,
+            825,
+            746
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "82 2 Problem Formulation ",
+        "text_level": 1,
+        "bbox": [
+            153,
+            766,
+            385,
+            784
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "2.1 JSP and FJSP ",
+        "text_level": 1,
+        "bbox": [
+            169,
+            797,
+            312,
+            813
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "A $n \\times m$ JSP instance contains $n$ jobs and $m$ machines. Each job $J _ { j }$ consists of a sequence of $k _ { j }$ operations $\\{ O _ { j , 1 } , \\dotsc , O _ { j , k _ { j } } \\}$ , where operation $O _ { j , i }$ must be started after $O _ { j , i - 1 }$ is finished. One machine can process at most one operation at a time, and preemption is not allowed upon processing operations. In JSP, one operation $O _ { j , i }$ is allowed to be processed on one designated machine, denoted by $M _ { j , i }$ , with a processing time, denoted by $T _ { j , i } ^ { ( o p ) }$ . Table 1 (a) illustrates a $3 \\times 3$ JSP instance, where the three jobs have 3, 3, 2 operations respectively, each of which is designated to be processed on ",
+        "bbox": [
+            161,
+            824,
+            823,
+            911
+        ],
+        "page_idx": 1
+    },
+    {
+        "type": "text",
+        "text": "90 one of the three machines $\\{ M _ { 1 } , M _ { 2 } , M _ { 3 } \\}$ in the table. A solution of a JSP instance is to dispatch all   \n91 operations Oj,i to the corresponding machine Mj,i at time τ (s)j,i  , such that the above constraints are   \n92   \n93 While there are different expected goals, such as makespan, tardiness, etc., this paper focuses on   \n94 makespan. Let the first osolution is defined to be $\\tau = 0$ in a JSP soluti all operations nitially. , where   \n95 $T ^ { ( m k s p ) } = \\operatorname* { m a x } ( \\tau _ { j , i } ^ { ( c ) } )$ $O _ { j , i }$ $\\tau _ { j , i } ^ { ( c ) } = \\tau _ { j , i } ^ { ( s ) } + T _ { j , i } ^ { ( o p ) }$   \n96 denotes the completion time of $O _ { j , i }$ . The makespans for the two solutions illustrated in Figure 1 (a)   \n97 and (b) are 12 and 15 respectively. The objective is to derive a solution that minimizes the makespan   \n98 $T ^ { ( m k s p ) }$ , and the solution of Figure 1 (a) reaches the optimal.   \n99 A $n \\times m$ FJSP instance is also a $n \\times m$ JSP instance with the following difference. In FJSP,   \n100 all operations $O _ { j , i }$ are allowed to be dispatched to multiple designated machines with designated   \n101 processing times. Table 1 (b) illustrates a $3 \\times 3$ FJSP instance, where multiple machines can be   \n102 designated to be processed for one operation. Figure 1 (c) illustrates a solution of an FJSP instance,   \n103 which takes a shorter time than that in Figure 1 (d). ",
+        "bbox": [
+            145,
+            90,
+            825,
+            137
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/4261351e53a18de76aff84d9645da1b0e5c1ee65d6c98a9dfa3509a2e1823974.jpg",
+        "table_caption": [
+            "Table 1: JSP and FJSP instances ",
+            "(b) A $3 \\times 3$ FJSP instance "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Job</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>M1</td><td rowspan=1 colspan=1>M2</td><td rowspan=1 colspan=1>M3</td></tr><tr><td rowspan=3 colspan=1>Job 1</td><td rowspan=1 colspan=1>O1,1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>O1.2</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>O1.3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1>3</td></tr><tr><td rowspan=3 colspan=1>Job 2</td><td rowspan=1 colspan=1>O2,1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>02.2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>02.3</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=2 colspan=1>Job 3</td><td rowspan=1 colspan=1>O3,1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>03.2</td><td rowspan=1 colspan=1>2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2</td></tr></table>",
+        "bbox": [
+            501,
+            191,
+            774,
+            323
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "table",
+        "img_path": "images/ee2298f6d1a4eedfbf6f7eea3fd20b3dd269d7f61439042e8181cd727720a23e.jpg",
+        "table_caption": [
+            "(a) A $3 \\times 3$ JSP instance "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Job</td><td rowspan=1 colspan=1>Operation</td><td rowspan=1 colspan=1>M1</td><td rowspan=1 colspan=1>M2</td><td rowspan=1 colspan=1>M3</td></tr><tr><td rowspan=3 colspan=1>Job 1</td><td rowspan=1 colspan=1>O1,1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>O1.2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>5</td></tr><tr><td rowspan=1 colspan=1>O1.3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=3 colspan=1>Job 2</td><td rowspan=1 colspan=1>O2,1</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2</td></tr><tr><td rowspan=1 colspan=1>02,2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>4</td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>O2,3</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=2 colspan=1>Job 3</td><td rowspan=1 colspan=1>O3，1</td><td rowspan=1 colspan=1>3</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td></tr><tr><td rowspan=1 colspan=1>03.2</td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1></td><td rowspan=1 colspan=1>2</td></tr></table>",
+        "bbox": [
+            220,
+            193,
+            490,
+            323
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/54e0e1086515bc311b9d4a17fdee1c89c424b15d95726a4af33fc4a68fbe5ad1.jpg",
+        "image_caption": [
+            "Figure 1: Both (a) and (b) are solutions of the $3 \\mathrm { x } 3$ JSP instance in Table 1 (a), and the former has the minimal makespan, 12. Both (c) and (d) are solutions of the $3 \\mathrm { x } 3$ FJSP instance in Table 1 (b), and the former has the minimal makespan, 9. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            178,
+            364,
+            813,
+            445
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            517,
+            825,
+            608
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            614,
+            825,
+            684
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "104 2.2 Construction Heuristics ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            704,
+            379,
+            719
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "text",
+        "text": "105 An approach to solving these scheduling problems is to construct solutions step by step in a greedy   \n106 manner, and the heuristics based on this approach is called construction heuristics in this paper. In   \n107 the approach of construction heuristics, a scheduling solution is constructed through a sequence of   \n108 partial solutions in a chronicle order of dispatching operations step by step, defined as follows. The   \n109 $t$ -th partial solution $S _ { t }$ associates with a dispatching time $\\tau _ { t }$ and includes a partial set of operations   \n110 that have been dispatched by $\\tau _ { t }$ (inclusive) while satisfying the above JSP constraints, and all the   \n111 remaining operations must be dispatched after $\\tau _ { t }$ (inclusive). The whole construction starts with $S _ { 0 }$   \n112 where none of operations have been dispatched and the dispatching time is $\\tau _ { 0 } = 0$ . For each $S _ { t }$ , a set   \n113 of operations to be chosen for dispatching form a set of pairs of $( M , O )$ , called candidates $C _ { t }$ , where   \n114 operations $O$ are allowed to be dispatched on machines $M$ at $\\tau _ { t }$ . An agent (or a heuristic algorithm)   \n115 chooses one from candidates $C _ { t }$ for dispatching, and transits the partial solution to the next $S _ { t + 1 }$ . If   \n116 there exists no operations for dispatching, the whole solution construction process is done and the   \n117 partial solution is a solution, since no further operations are to be dispatched.   \n118 Figure 2 illustrates a solution construction process for the 3x3 JSP instance in Table 1(a), constructed   \n119 through nine partial solutions step by step. The initial partial solution $S _ { 0 }$ starts without any operations   \n120 dispatched as in Figure 2 (a). The initial candidates $C _ { 0 }$ are $\\{ ( M _ { 1 } , O _ { 1 , 1 } ) , ( M _ { 3 } , O _ { 2 , 1 } ) , ( \\bar { M _ { 1 } } , O _ { 3 , 1 } ) \\}$   \n121 Following some heuristic, construct a solution from partial solution $S _ { 0 }$ to $S _ { 9 }$ step by step as in the   \n122 Figure, where the dashed line in red indicate the time $\\tau _ { t }$ . The last one $S _ { 9 }$ , the same as the one in   \n123 Figure 1 (a), is a solution, since all operations have been dispatched, and the last operation ends at   \n124 time 12, the makespan of the solution.   \n125 For FJSP, the process of solution construction is almost the same except for that one operation have   \n126 multiple choices from candidates. Besides, an approach based on solution construction can be also   \n127 viewed as the so-called Markov decision process $( M D P )$ , and the MDP formulation for solution   \n128 construction is described in more detail in the appendix. ",
+        "bbox": [
+            140,
+            731,
+            825,
+            911
+        ],
+        "page_idx": 2
+    },
+    {
+        "type": "image",
+        "img_path": "images/cb96d32bb1f5dcecc876eaf54a9e7682b46451e9161fb74084ead5c2b39e2e49.jpg",
+        "image_caption": [
+            "Figure 2: Solution construction, a sequence of partial solutions from $S _ { 0 }$ to $S _ { 8 }$ . "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            194,
+            90,
+            787,
+            367
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            421,
+            825,
+            518
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            525,
+            825,
+            582
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "129 3 Our Approach ",
+        "text_level": 1,
+        "bbox": [
+            145,
+            603,
+            326,
+            621
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "130 In this section, we present a new approach, called residual scheduling, to solving scheduling problems.   \n131 We introduce the residual scheduling in Subsection 3.1, describe the design of the graph representation   \n132 in Subsection 3.2, propose a model architecture based on graph neural network in Subsection 3.3 and   \n133 present a method to train this model in Subsection 3.4; ",
+        "bbox": [
+            142,
+            637,
+            825,
+            693
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "34 3.1 Residual Scheduling ",
+        "text_level": 1,
+        "bbox": [
+            153,
+            713,
+            354,
+            728
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "135 In our approach, the key is to remove irrelevant information, particularly for operations, from states   \n136 (including partial solutions). An important benefit from this is that we do not need to include all   \n137 irrelevant information while training to minimize the makespan. Let us illustrate by the state for the   \n138 partial solution $S _ { 3 }$ at time $\\tau _ { 3 } = 3$ in Figure 2 (d). All processing by $\\tau _ { 3 }$ are irrelevant to the remaining   \n139 scheduling. Since operations $O _ { 1 , 1 }$ and $O _ { 2 , 1 }$ are both finished and irrelevant the rest of scheduling,   \n140 they can be removed from the state of $S _ { 3 }$ . In addition, operation $O _ { 2 , 2 }$ is dispatched at time 2 (before   \n141 $\\tau _ { 3 } = 3$ ) and its processing time is $T _ { 2 , 1 } ^ { ( o p ) } = 4$ , so the operation is marked as ongoing. Thus, the   \n142 operation can be modified to start at $\\tau _ { 3 } = 3$ with a processing time . Thus, the modified   \n143 state for $S _ { 3 }$ do not contain both $O _ { 1 , 1 }$ and $O _ { 2 , 1 }$ , and modify $O _ { 2 , 2 }$ as above. Let us consider two more   \n144 examples. For $S _ { 4 }$ , one more operation $O _ { 2 , 2 }$ is dispatched and thus marked as ongoing, however, the   \n145 time $\\tau _ { 4 }$ remains unchanged and no more operations are removed. In this case, the state is almost the   \n146 same except for including one more ongoing operation $O _ { 2 , 2 }$ . Then, for $S _ { 5 }$ , two more operations $O _ { 3 , 1 }$   \n147 and $O _ { 2 , 2 }$ are removed and the ongoing operation $O _ { 1 , 2 }$ changes its processing time to the remaining   \n148 time (5-3).   \n149 For residual scheduling, we also reset the dispatching time $\\tau = 0$ for all states with partial solutions   \n150 modified as above, so we derive makespans which is also irrelevant to the earlier operations. Given   \n151 a scheduling policy $\\pi$ , $T _ { \\pi } ^ { ( m k s p ) } ( S )$ is defined to be the makespan derived from an episode starting   \n152 from states $S$ by following $\\pi$ , and $T _ { \\pi } ^ { ( m k s p ) } ( S , a )$ the makespan by taking action $a$ on $S$ . ",
+        "bbox": [
+            140,
+            739,
+            825,
+            911
+        ],
+        "page_idx": 3
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            150,
+            92,
+            825,
+            119
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            126,
+            825,
+            189
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "153 3.2 Residual Graph Representation ",
+        "text_level": 1,
+        "bbox": [
+            148,
+            215,
+            433,
+            231
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "154 In this paper, our model design is based on graph neural network (GNN), and leverage GNN to   \n155 extract the scheduling decision from the relationship in graph. In this subsection, we present the   \n156 graph representation. Like many other researchers such as Park et al. (2021a), we formulate a partial   \n157 solution into a graph $\\mathcal { G } = ( \\nu , \\mathcal { E } )$ , where $\\nu$ is a set of nodes and $\\mathcal { E }$ is a set of edges. A node is either a   \n158 machine node $M$ or an operation node $O$ . An edge connects two nodes to represent the relationship   \n159 between two nodes, basically including three kinds of edges, namely operation-to-operation $( O \\to O$ ),   \n160 machine-to-operation $M  O$ ) and operation-to-machine $( O \\to M$ ). All operations in the same   \n161 job are fully connected as $O  O$ edges. If an operation $O$ is able to be performed on a machine   \n162 $M$ , there exists both $O \\to M$ and $M  O$ directed edges. In (Park et al., 2021a), they also let all   \n163 machines be fully connected as $M \\to M$ edges. However, our experiments in section 4 show that   \n164 mutual $M \\to M$ edges do not help much based on our Residual Scheduling. An illustration for graph   \n165 representation of $S _ { 3 }$ is depicted in Figure 3 (a).   \n166 In the graph representation, all nodes need to include some attributes so that a partial solution $S$ at   \n167 the dispatching time $\\tau$ can be supported in the MDP formulation (in the appendix). Note that many of   \n168 the attributes below are normalized to reduce variance. For nodes corresponding to operations $O _ { j , i }$ ,   \n169 we have the following attributes:   \n170 Status $\\phi _ { j , i }$ : The operation status $\\phi _ { j , i }$ is completed if the operation has been finished by $\\tau$ , ongoing if   \n171 the operation is ongoing (i.e., has been dispatched to some machine by $\\tau$ and is still being processed   \n172 at $\\tau$ ), ready if the operation designated to the machine which is idle has not been dispatched yet and   \n173 its precedent operation has been finished, and unready otherwise. For example, in Figure 3 (a), the   \n174 gray nodes are completed, the red ongoing, the yellow ready and the white unready. In our residual   \n175 scheduling, there exists no completed operations in all partial solutions, since they are removes for   \n176 irrelevance of the rest of scheduling. The attribute is a one-hot vector to represent the current status   \n177 of the operation, which is one of ongoing, ready and unready. Illustration for all states $S _ { 0 }$ to $S _ { 8 }$ are   \n178 shown in the appendix.   \n179 Normalized processing time $\\bar { T } _ { j , i } ^ { ( o p ) }$ : Let the maximal processing time be $T _ { m a x } ^ { ( o p ) } = \\operatorname* { m a x } _ { \\forall j , i } ( T _ { j , i } ^ { ( o p ) } )$   \n180 Then, T¯(op)j,i $\\bar { T } _ { j , i } ^ { ( o p ) } = T _ { j , i } ^ { ( o p ) } / T _ { m a x } ^ { ( o p ) }$ . In our residual scheduling, the operations that have been finished are   \n181 removed in partial solutions and therefore their processing time can be ignored; the operations that   \n182 has not been dispatched yet still keep their processing times the same; the operations that are ongoing   \n183 change their processing times to the remaining times after the dispatching time $\\tau _ { t }$ . As for FJSP, the   \n184 operations that has not been dispatched yet may have several processing times on different machines,   \n185 and thus we can simply choose the average of these processing times. ",
+        "bbox": [
+            140,
+            246,
+            826,
+            412
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "image",
+        "img_path": "images/a3a8af5ab1851b807add19a4a2a54f81ec9c7979dcede6e1a0cd5113aacd0d36.jpg",
+        "image_caption": [
+            "Figure 3: Graph representation and networks. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            435,
+            820,
+            556
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            612,
+            826,
+            667
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            674,
+            825,
+            799
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            805,
+            826,
+            912
+        ],
+        "page_idx": 4
+    },
+    {
+        "type": "text",
+        "text": "ob remaining time , and let the process $\\bar { T } _ { j , i } ^ { ( j o b ) }$ : Let the rest of pre for the whole job $J _ { j }$ $T _ { j , i } ^ { ( j o b ) } =$ $\\sum _ { \\forall i ^ { \\prime } \\geq i } T _ { j , i ^ { \\prime } } ^ { ( o p ) }$ aced by th ing timocessing time for the original jo $j$ $\\begin{array} { r } { T _ { j } ^ { ( j o b ) } = \\sum _ { \\forall i ^ { \\prime } } T _ { j , i ^ { \\prime } } ^ { ( o p ) } } \\end{array}$ . In practice, T ( j ob )j is $j$ $\\bar { T } _ { j , i } ^ { ( j o b ) } = T _ { j , i } ^ { ( j o b ) } / T _ { j } ^ { ( j o b ) }$ . For FJSP, since operations $O _ { j , i }$ can be dispatched to different designated machines $M _ { l }$ , say with the processing time T (op)j,i,l , we simply let T (op)j,i be the average of $T _ { j , i , l } ^ { ( o p ) }$ for all $M _ { l }$ . ",
+        "bbox": [
+            148,
+            88,
+            826,
+            183
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "For machine nodes corresponding to machines $M _ { l }$ , we have the following attributes: ",
+        "bbox": [
+            166,
+            185,
+            725,
+            202
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Machine status $\\phi _ { l }$ : The machine status $\\phi _ { l }$ is processing if some operation has been dispatched to and is being processed by $M _ { l }$ at $\\tau$ , and idle otherwise (no operation is being processed at $\\tau$ ). The attribute is a one-hot vector to represent the current status, which is one of processing and idle. ",
+        "bbox": [
+            173,
+            207,
+            825,
+            250
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Normalized operation processing time $\\bar { T } _ { l } ^ { ( m a c ) }$ : On the machine $M _ { l }$ , the processing time $T _ { l } ^ { ( m a c ) }$ is $T _ { j , i } ^ { ( o p ) }$ (the same as the normalized processing time for node $O _ { j , i }$ ) if the machine status is processing, i.e., some ongoing operation $O _ { j , i }$ is being processed but not finished yet, is zero if the machine status is idle. Then, this attribute is normalized to $T _ { m a x } ^ { ( o p ) }$ and thus $\\bar { T } _ { l } ^ { ( m a c ) } = T _ { l } ^ { ( m a c ) } / T _ { m a x } ^ { ( o p ) }$ . ",
+        "bbox": [
+            173,
+            256,
+            826,
+            327
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Now, consider edges in a residual scheduling graph. As described above, there exists three relationship sets for edges, $O  O$ , $O \\to M$ and $M  O$ . First, for the same job, say $J _ { j }$ , all of its operation nodes for $O _ { j , i }$ are fully connected. Note that for residual scheduling the operations finished by the dispatching time $\\tau$ are removed and thus have no edges to them. Second, a machine node for $M _ { l }$ is connected to an operation node for $O _ { j , i }$ , if the operation $O _ { j , i }$ is designated to be processed on the machine $M _ { l }$ , which forms two edges $\\dot { O }  M$ and $M  O$ . Both contains the following attribute. ",
+        "bbox": [
+            173,
+            330,
+            825,
+            415
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "Normalized operation processing tim e T¯(edge): The attribute is $\\bar { T } _ { j , i , l } ^ { ( e d g e ) } = T _ { j , i } ^ { ( o p ) } / T _ { m a x } ^ { ( o p ) }$ . Here, $T _ { j , i } ^ { ( o p ) } = T _ { j , i , l } ^ { ( o p ) }$ $O _ { j , i }$ $T _ { j , i } ^ { ( o p ) }$ is the remaining time as described above. ",
+        "bbox": [
+            173,
+            420,
+            826,
+            474
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "3.3 Graph Neural Network ",
+        "text_level": 1,
+        "bbox": [
+            174,
+            488,
+            375,
+            503
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "In this subsection, we present our model based on graph neural network (GNN). GNN are a family of deep neural networks (Battaglia et al., 2018) that can learn representation of graph-structured data, widely used in many applications (Lv et al., 2021; Zhou et al., 2020). A GNN aggregates information from node itself and its neighboring nodes and then update the data itself, which allows the GNN to capture the complex relationships within the data graph. For GNN, we choose Graph Isomorphism Network (GIN), which was shown to have strong discriminative power ( $\\mathrm { { X u } }$ et al., 2019) and summarily reviewed as follows. Given a graph $\\mathcal { G } = ( \\nu , \\mathcal { E } )$ and $K$ GNN layers $K$ iterations), GIN performs the $k$ -th iterations of updating feature embedding $h ^ { ( k ) }$ for each node $v \\in \\mathcal V$ : ",
+        "bbox": [
+            153,
+            513,
+            826,
+            627
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/2ff8cf48f7fc89b4b2026b4e2f6ba5a18a536573b1a5ce94368e07ebd887b7e6.jpg",
+        "text": "$$\nh _ { v } ^ { ( k ) } = M L P ^ { ( k ) } ( ( 1 + \\epsilon ^ { ( k ) } ) h _ { v } ^ { ( k - 1 ) } + \\sum _ { u \\in N _ { b } ( v ) } h _ { u } ^ { ( k - 1 ) } ) ,\n$$",
+        "text_format": "latex",
+        "bbox": [
+            320,
+            628,
+            676,
+            664
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "217 where $h _ { v } ^ { ( k ) }$ is the embedding of node $v$ at the $k$ -th layer, $\\epsilon ^ { ( k ) }$ is an arbitrary number that can be   \n218 learned, and $N _ { b } ( v )$ is the neighbors of $v$ via edges in $\\mathcal { E }$ . Note that $h _ { v } ^ { ( 0 ) }$ refers to its raw features for   \n219 input. $M L P ^ { ( k ) }$ is a Multi-Layer Perceptron $( M L P )$ for the $k$ -th layer with a batch normalization   \n220 (Ioffe and Szegedy, 2015).   \n221 Furthermore, we actually use heterogeneous GIN, also called HGIN, since there are two types of   \n222 nodes, machine and operation nodes, and three relations, $O  O$ , $O \\to M$ and $M  O$ in the   \n223 graph representation. Although we do not have cross machine relations $M \\to M$ as described above,   \n224 updating machine nodes requires to include the update from itself as in (1), that is, there is also one   \n225 more relation $M \\to M$ . Thus, HGIN encodes graph information between all relations by using the   \n226 four MLPs as follows, ",
+        "bbox": [
+            140,
+            667,
+            825,
+            731
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            138,
+            736,
+            826,
+            819
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/392e5b294a0810c8146e8d439eb968e34c1d3cbeae97269e1e396ed5a736bbd6.jpg",
+        "text": "$$\nh _ { v } ^ { ( k + 1 ) } = \\sum _ { \\mathcal { R } } M L P _ { \\mathcal { R } } ^ { ( k + 1 ) } ( ( 1 + \\epsilon _ { \\mathcal { R } } ^ { ( k + 1 ) } ) h _ { v } ^ { ( k ) } + \\sum _ { u \\in N _ { \\mathcal { R } } ( v ) } h _ { u } ^ { ( k ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            299,
+            819,
+            699,
+            857
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "where 227 $\\mathcal { R }$ is one of the above fo elatio $M L P _ { \\mathcal { R } } ^ { ( k ) }$ is the MLP for $\\mathcal { R }$ . For example, for $S _ { 0 }$ in Figure 2 (a), the embedding of $M _ { 1 }$ $( k + 1 )$ -st iteration can be derived as follows. ",
+        "bbox": [
+            135,
+            859,
+            828,
+            891
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3d184bbed84e82a3cd83570384051eeed279a8eb4a46bf70afb8b0f65157e291.jpg",
+        "text": "$$\nh _ { M _ { 1 } } ^ { ( k + 1 ) } = M L P _ { M M } ^ { ( k + 1 ) } ( ( 1 + \\epsilon _ { M M } ^ { ( k + 1 ) } ) h _ { M _ { 1 } } ^ { ( k ) } ) + M L P _ { O M } ^ { ( k + 1 ) } ( h _ { O _ { 1 , 1 } } ^ { ( k ) } + h _ { O _ { 1 , 2 } } ^ { ( k ) } + h _ { O _ { 1 , 3 } } ^ { ( k ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            892,
+            761,
+            916
+        ],
+        "page_idx": 5
+    },
+    {
+        "type": "text",
+        "text": "229 Similarly, the embedding of $O _ { 1 , 1 }$ in the $( k + 1 )$ -st iteration is: ",
+        "bbox": [
+            140,
+            90,
+            580,
+            106
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/3a318d233ecc5b46d854239d39f00d2fdff89b88a439536327c31a2b3834eceb.jpg",
+        "text": "$$\nh _ { O _ { 1 , 1 } } ^ { ( k + 1 ) } = M L P _ { O O } ^ { ( k + 1 ) } ( ( 1 + \\epsilon _ { O O } ^ { ( k + 1 ) } ) h _ { O _ { 1 , 1 } } ^ { ( k ) } + h _ { O _ { 1 , 2 } } ^ { ( k ) } + h _ { O _ { 1 , 3 } } ^ { ( k ) } ) + M L P _ { M O } ^ { ( k + 1 ) } ( h _ { M _ { 1 } } ^ { ( k ) } )\n$$",
+        "text_format": "latex",
+        "bbox": [
+            235,
+            109,
+            761,
+            133
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "230 In our approach, an action includes the two phases, graph embedding phase and action selection phase.   \n231 Let $h _ { \\mathcal { G } } ^ { ( k ) }$ denote the whole embedding of the graphs $\\mathcal { G }$ , a summation of the embeddings of all nodes,   \n232 $h _ { v } ^ { ( k + 1 ) }$ . In the graph embedding phase, we use an HGIN to encode node and graph embeddings as   \n233 described above. An example with three HGIN layers is illustrated in Figure 3 (b). ",
+        "bbox": [
+            140,
+            142,
+            825,
+            208
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In the action selection phase, we select an action based on a policy, after node and graph embedding are encoded in the graph embedding phase. The policy is described as follows. First, collect all ready operations $O$ to be dispatched to machines $M$ . Then, for all pairs $( M , O )$ , feed their node embeddings $( h _ { M } ^ { ( k ) } , h _ { O } ^ { ( k ) } )$ into a MLP $S c o r e ( M , O )$ to calculate their scores as shown in Figure 3 (c). The probability of selecting $( M , O )$ is calculated based on a softmax function of all scores, which also serves as the model policy $\\pi$ for the current state. ",
+        "bbox": [
+            158,
+            213,
+            825,
+            301
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "3.4 Policy-Based RL Training ",
+        "text_level": 1,
+        "bbox": [
+            168,
+            315,
+            393,
+            330
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "41 In this paper, we propose to use a policy-based RL training mechanism that follows REINFORCE   \n42 (Sutton and Barto, 2018) to update our model by policy gradient with a normalized advantage   \n43 makespan with respect to a baseline policy $\\pi _ { b }$ as follows. ",
+        "bbox": [
+            150,
+            340,
+            825,
+            383
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/b06d82d1c07484ee7e7eab67883f499d4e532d443dc6370d26bccc60092f3d81.jpg",
+        "text": "$$\nA _ { \\pi } ( S , a ) = { \\frac { T _ { \\pi _ { b } } ^ { ( m k s p ) } ( S , a ) - T _ { \\pi } ^ { ( m k s p ) } ( S , a ) } { T _ { \\pi _ { b } } ^ { ( m k s p ) } ( S , a ) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            351,
+            386,
+            647,
+            428
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "244 In this paper, we choose a lightweight PDR, MWKR, as baseline $\\pi _ { b }$ , which performed best for   \n245 makespan among all PDRs reported from the previous work (Zhang et al., 2020). In fact, our   \n246 experiment also shows that using MWKR is better than the other PDRs shown in the appendix. The   \n247 model for policy $\\pi$ is parametrized by $\\theta$ , which is updated by $\\nabla _ { \\boldsymbol { \\theta } } l o g \\pi _ { \\boldsymbol { \\theta } } A _ { \\pi _ { \\boldsymbol { \\theta } } } \\bigl ( S _ { t } , a _ { t } \\bigr )$ . Our algorithm   \n248 based on REINFORCE is listed in the appendix. ",
+        "bbox": [
+            140,
+            435,
+            825,
+            507
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4 Experiments ",
+        "text_level": 1,
+        "bbox": [
+            166,
+            525,
+            312,
+            542
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "4.1 Experimental Settings and Evaluation Benchmarks ",
+        "text_level": 1,
+        "bbox": [
+            160,
+            555,
+            568,
+            570
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "In our experiments, the settings of our model are described as follows. All embedding and hidden vectors in our model have a dimension of 256. The model contains three HGIN layers for graph embedding, and an MLP for the score function, as shown in Figure 3 (b) and (c). All MLP networks including those in HGIN and for score contain two hidden layers. The parameters of our model, such as MLP, generally follow the default settings in PyTorch (Paszke et al., 2019) and PyTorch Geometric (Fey and Lenssen, 2019). More settings are in the appendix. ",
+        "bbox": [
+            169,
+            580,
+            825,
+            665
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "Each of our models is trained with one million episodes, each with one scheduling instance. Each instance is generated by following the procedure which is used to generate the TA dataset (Taillard, 1993). Given $( N , M )$ , we use the procedure to generate an $n \\times m$ JSP instance by conforming to the following distribution, $n \\sim \\mathcal { U } ( \\bar { 3 } , N )$ , $m \\sim \\mathcal { U } ( 3 , n )$ , and operation count $k _ { j } = m$ , where $\\boldsymbol { \\mathcal { U } } ( \\boldsymbol { x } , \\boldsymbol { y } )$ represents a distribution that uniformly samples an integer in a close interval $[ x , y ]$ at random. The details of designation for machines and processing times refer to (Taillard, 1993) and thus are omitted here. We choose (10,10) for all experiments, since (10,10) generally performs better than the other two as described in the appendix. Following the method described in Subsection 3.4, the model is updated from the above randomly generated instances. For testing our models for JSP and FJSP, seven JSP open benchmarks and two FJSP open benchmarks are used, as listed in the appendix. ",
+        "bbox": [
+            161,
+            670,
+            825,
+            809
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "67 The performance for a given policy method $\\pi$ on an instance is measured by the makespan gap $G$   \n68 defined as ",
+        "bbox": [
+            155,
+            815,
+            823,
+            842
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "equation",
+        "img_path": "images/f381b1f4ca34a456d19d426492d9502ae08f10b6d9c37038fd76c7e426b573a4.jpg",
+        "text": "$$\nG = \\frac { T _ { \\pi } ^ { \\left( m k s p \\right) } - T _ { \\pi * } ^ { \\left( m k s p \\right) } } { T _ { \\pi * } ^ { \\left( m k s p \\right) } }\n$$",
+        "text_format": "latex",
+        "bbox": [
+            413,
+            839,
+            583,
+            878
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "text",
+        "text": "where 269 $T _ { \\pi * } ^ { ( m k s p ) }$ is the optimal makespan or the best-effort makespan, from a mathematical optimization 270 tool, OR-Tools, serving as . By the best-effort makespan, we mean the makespan derived with a ",
+        "bbox": [
+            143,
+            881,
+            826,
+            912
+        ],
+        "page_idx": 6
+    },
+    {
+        "type": "table",
+        "img_path": "images/d571f08c06cb4d62d220b992e5665dea662faf647c622b0c5bde8cc35206e59a.jpg",
+        "table_caption": [
+            "Table 2: Average makespan gaps for TA benchmarks. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Size</td><td rowspan=1 colspan=1>15×15</td><td rowspan=1 colspan=1>20×15</td><td rowspan=1 colspan=1>20×20</td><td rowspan=1 colspan=1>30×15</td><td rowspan=1 colspan=1>30×20</td><td rowspan=1 colspan=1>50×15</td><td rowspan=1 colspan=1>50×20</td><td rowspan=1 colspan=1>100×20</td><td rowspan=1 colspan=1>Aug.</td></tr><tr><td rowspan=1 colspan=1>RS</td><td rowspan=1 colspan=1>0.148</td><td rowspan=1 colspan=1>0.165</td><td rowspan=1 colspan=1>0.169</td><td rowspan=1 colspan=1>0.144</td><td rowspan=1 colspan=1>0.177</td><td rowspan=1 colspan=1>0.067</td><td rowspan=1 colspan=1>0.100</td><td rowspan=2 colspan=1>0.0260.050</td><td rowspan=2 colspan=1>0.1250.150</td></tr><tr><td rowspan=1 colspan=1>RS+op</td><td rowspan=1 colspan=1>0.143</td><td rowspan=1 colspan=1>0.193</td><td rowspan=1 colspan=1>0.159</td><td rowspan=1 colspan=1>0.192</td><td rowspan=1 colspan=1>0.213</td><td rowspan=1 colspan=1>0.123</td><td rowspan=1 colspan=1>0.126</td></tr><tr><td rowspan=1 colspan=1>MWKR</td><td rowspan=2 colspan=1>0.1910.2050.258</td><td rowspan=2 colspan=1>0.2330.2350.328</td><td rowspan=2 colspan=1>0.2180.2170.277</td><td rowspan=2 colspan=1>0.2390.2280.352</td><td rowspan=2 colspan=1>0.2510.2490.344</td><td rowspan=3 colspan=1>0.1680.1730.2410.206</td><td rowspan=3 colspan=1>0.1790.1760.2550.239</td><td rowspan=3 colspan=1>0.0830.0910.1440.135</td><td rowspan=3 colspan=1>0.1950.1970.2750.254</td></tr><tr><td rowspan=1 colspan=1>MORSPT</td></tr><tr><td rowspan=1 colspan=1>FIFO</td><td rowspan=1 colspan=1>0.239</td><td rowspan=1 colspan=1>0.314</td><td rowspan=1 colspan=1>0.273</td><td rowspan=1 colspan=1>0.311</td><td rowspan=1 colspan=1>0.311</td></tr><tr><td rowspan=2 colspan=1>L2DParkSchN</td><td rowspan=2 colspan=1>0.2590.2010.152</td><td rowspan=1 colspan=1>0.300</td><td rowspan=1 colspan=1>0.316</td><td rowspan=1 colspan=1>0.329</td><td rowspan=1 colspan=1>0.336</td><td rowspan=1 colspan=1>0.223</td><td rowspan=1 colspan=1>0.265</td><td rowspan=2 colspan=1>0.1360.0920.066</td><td rowspan=2 colspan=1>0.2700.2210.161</td></tr><tr><td rowspan=1 colspan=1>0.2490.194</td><td rowspan=1 colspan=1>0.2920.172</td><td rowspan=1 colspan=1>0.2460.190</td><td rowspan=1 colspan=1>0.3190.237</td><td rowspan=1 colspan=1>0.1590.138</td><td rowspan=1 colspan=1>0.2120.135</td></tr></table>",
+        "bbox": [
+            173,
+            109,
+            834,
+            257
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "271 sufficiently large time limitation, namely half a day with OR-Tools. For comparison in experiments,   \n272 we use a server with Intel Xeon E5-2683 CPU and a single NVIDIA GeForce GTX 1080 Ti GPU.   \n273 Our method uses a CPU thread and a GPU to train and evaluate, while OR-Tools uses eight threads   \n274 to find the solution. ",
+        "bbox": [
+            142,
+            281,
+            826,
+            337
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "4.2 Experiments for JSP ",
+        "text_level": 1,
+        "bbox": [
+            158,
+            353,
+            357,
+            369
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "For JSP, we first train a model based on residual scheduling, named RS. For ablation testing, we also train a model, named $\\mathrm { R S + o p }$ , by following the same training method but without removing irrelevant operations. When using these models to solve testing instances, action selection is based on the greedy policy that simply chooses the action $( M , O )$ with the highest score deterministically, obtained from the score network as in Figure 3 (c). ",
+        "bbox": [
+            171,
+            378,
+            825,
+            449
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "281 For comparison, we consider the three DRL construction heuristics, respectively developed in (Zhang   \n282 et al., 2020) called L2D, (Park et al., 2021b) by Park et al., and (Park et al., 2021a), called ScheduleNet.   \n283 We directly use the performance results of these methods for open benchmarks from their articles.   \n284 For simplicity, they are named L2D, Park and SchN respectively in this paper. We also include some   \n285 construction heuristics based PDR, such as MWKR, MOR, SPT and FIFO. Besides, to derive the   \n286 gaps to the optimum in all cases, OR-Tools serve as $\\pi *$ as described in (6).   \n287 Now, let us analyze the performances of RS as follows. Table 2 shows the average makespan gaps   \n288 for each collection of JSP TA benchmarks with sizes, $1 5 { \\times } 1 5$ , $2 0 \\times 1 5$ , $2 0 \\times 2 0$ , $3 0 \\times 1 5$ , $3 0 \\times 2 0$ , $5 0 \\times 1 5$ ,   \n289 $5 0 \\times 2 0$ and $1 0 0 \\times 2 0$ , where the best performances (the smallest gaps) are marked in bold. In general,   \n290 RS performs the best, and generally outperforms the other methods for all collections by large   \n291 margins, except for that it has slightly higher gaps than ${ \\mathrm { R S + o p } }$ for the two collections, $1 5 \\times 1 5$ and   \n292 $2 0 \\times 2 0$ . In fact, ${ \\mathrm { R S + o p } }$ also generally outperforms the rest of methods, except for that it is very   \n293 close to SchN for two collections. For the other six open benchmarks, ABZ, FT, ORB, YN, SWV   \n294 and LA, the performances are similar and thus presented in the appendix. It is concluded that RS   \n295 generally performs better than other construction heuristics by large margins. ",
+        "bbox": [
+            142,
+            454,
+            825,
+            537
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            143,
+            544,
+            825,
+            670
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "296 4.3 Experiments for FJSP ",
+        "text_level": 1,
+        "bbox": [
+            142,
+            685,
+            367,
+            700
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "table",
+        "img_path": "images/c99b51216be96430166143b65903ab65a9561dbec698a97fd465ba2717ab21ec.jpg",
+        "table_caption": [
+            "Table 3: Average makespan gaps for FJSP open benchmarks "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td>Method</td><td>MK</td><td>LA(rdata)</td><td>LA(edata)</td><td>LA(vdata)</td></tr><tr><td>RS</td><td>0.232</td><td>0.099</td><td>0.146</td><td>0.031</td></tr><tr><td>RS+op</td><td>0.254</td><td>0.113</td><td>0.168</td><td>0.029</td></tr><tr><td>DRL-G</td><td>0.254</td><td>0.111</td><td>0.150</td><td>0.040</td></tr><tr><td>MWKR MOR</td><td>0.282 0.296 0.457</td><td>0.125 0.147</td><td>0.149 0.179</td><td>0.051 0.061</td></tr></table>",
+        "bbox": [
+            303,
+            738,
+            694,
+            856
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "297 For FJSP, we also train a model based on residual scheduling, named RS, and a ablation version,   \n298 named $\\mathrm { R S + o p }$ , without removing irrelevant operations. We compares ours with one DRL construction   \n299 heuristics developed by (Song et al., 2023), called DRL-G, and four PDR-based heuristics, MOR,   \n00 MWKR, SPT and FIFO. We directly use the performance results of these methods for open datasets   \n01 according to the reports from (Song et al., 2023).   \n02 Table 3 shows the average makespan gaps in the four open benchmarks, MK, LA(rdata), LA(edata)   \n03 and LA(vdata). From the table, RS generally outperforms all the other methods for all benchmarks   \n04 by large margins, except for that ${ \\mathsf { R S + o p } }$ is slightly better for the benchmark LA(vdata). ",
+        "bbox": [
+            143,
+            869,
+            825,
+            912
+        ],
+        "page_idx": 7
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            90,
+            825,
+            119
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            150,
+            126,
+            828,
+            167
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "05 5 Discussions ",
+        "text_level": 1,
+        "bbox": [
+            156,
+            190,
+            300,
+            207
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "In this paper, we propose a new approach, called residual scheduling, to solving JSP an FJSP problems, and the experiments show that our approach reaches SOTA among DRL-based construction heuristics on the above open JSP and FJSP benchmarks. We further discusses three issues: large instances, computation times and further improvement. ",
+        "bbox": [
+            173,
+            223,
+            826,
+            279
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "image",
+        "img_path": "images/1b83fd2ef9921abe986163a176919527de1940ffe5a722430f846b273b3a20da.jpg",
+        "image_caption": [
+            "Figure 4: Average makespan gaps of JSP instances with different problem sizes. "
+        ],
+        "image_footnote": [],
+        "bbox": [
+            174,
+            292,
+            825,
+            388
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "310 First, from the above experiments particularly for TA benchmark for JSP, we observe that the average   \n311 gaps gets smaller as the number of jobs increases, even if we use the same model trained with   \n312 $\\bar { ( \\cal N , M ) } = ( 1 0 , 1 0 )$ . In order to investigate size-agnostics, we further generate 13 collections of JSP   \n313 instances of sizes for testing, from $1 5 \\times 1 5$ to $2 0 0 \\times 2 0$ , and generate 10 instances for each collection   \n314 by using the procedure above. Figure 4 shows the average gaps for these collections for RS and L2D,   \n315 and these collections are listed in the order of sizes in the x-axis. Note that we only show the results   \n316 of L2D in addition to our RS, since L2D is the only open-source among the above DRL heuristics.   \n317 Interestingly, using RS, the average gaps are nearly zero for the collections with sizes larger than 100   \n318 $\\times 1 5$ , namely, $1 0 0 \\times 1 5$ , $1 0 0 \\times 2 0$ , $1 5 0 \\times 1 5$ , $2 0 0 \\times 1 5$ and $2 0 0 \\times 2 0$ . Among the 50 JSP instances   \n319 in the five collections, 49 reaches zero gaps. A strong implication is that our RS approach can be   \n320 scaled up for job sizes and even reach the optimal for sufficient large job count.   \n321 Second, the computation times for RS are relatively small and has low variance like most of other   \n322 construction heuristics. Here, we just use the collection of TA $1 0 0 \\mathrm { x } 2 0$ for illustration. It takes about   \n323 30 seconds on average for both RS and $\\mathrm { R S + o p }$ , about 28 for L2D and about 444 for SchN. In contrast,   \n324 it takes about 4000 seconds with high variance for OR-tools. The times for other collections are listed   \n325 in more detail in the appendix.   \n326 Third, as proposed by Song et al. (2023), construction heuristics can further improve the gap by   \n327 constructing multiple solutions based on the softmax policy, in addition to the greedy policy. They   \n328 had a version constructing 100 solutions for FJSP, called $\\mathrm { \\ D R L + 1 0 0 }$ in this paper. In this paper, we   \n329 also implement a RS version for FJSP based on the softmax policy, as described in Subsection 3.3,   \n330 and then use the version, called ${ \\mathrm { R S } } { + } 1 0 0 \\ $ , to constructing 100 solutions. In Table 4, the experimental   \n331 results show that ${ \\mathrm { R S } } { + } 1 0 0 \\ $ performs the best, much better than RS, DRL-G and $\\mathrm { \\ D R L + 1 0 0 }$ . An   \n332 important property for such an improvement is that constructing multiple solutions can be done in   \n333 parallel. That is, for construction heuristics, the solution quality can be improved by adding more   \n334 computation powers. ",
+        "bbox": [
+            138,
+            429,
+            826,
+            582
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            587,
+            825,
+            657
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "table",
+        "img_path": "images/89ca0c42d2768ed4edd4d57820fcff3afe69503db3148f90ca2752b714a6be6a.jpg",
+        "table_caption": [
+            "Table 4: Average makespan gaps for FJSP open benchmark. "
+        ],
+        "table_footnote": [],
+        "table_body": "<table><tr><td rowspan=1 colspan=1>Method</td><td rowspan=1 colspan=1>MK</td><td rowspan=1 colspan=1>LA(rdata)</td><td rowspan=1 colspan=1>LA(edata)</td><td rowspan=1 colspan=1>LA(vdata)</td></tr><tr><td rowspan=1 colspan=1>RSRS+100</td><td rowspan=1 colspan=1>0.2320.154</td><td rowspan=1 colspan=1>0.0990.047</td><td rowspan=1 colspan=1>0.1460.079</td><td rowspan=1 colspan=1>0.0310.007</td></tr><tr><td rowspan=1 colspan=1>DRL-GDRL+100</td><td rowspan=1 colspan=1>0.2540.190</td><td rowspan=1 colspan=1>0.1110.058</td><td rowspan=1 colspan=1>0.1500.082</td><td rowspan=1 colspan=1>0.0400.014</td></tr></table>",
+        "bbox": [
+            297,
+            694,
+            699,
+            770
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            786,
+            825,
+            912
+        ],
+        "page_idx": 8
+    },
+    {
+        "type": "text",
+        "text": "References ",
+        "text_level": 1,
+        "bbox": [
+            161,
+            90,
+            266,
+            106
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Majid Abdolrazzagh-Nezhad and Salwani Abdullah. 2017. Job Shop Scheduling: Classification, Constraints and Objective Functions. International Journal of Computer and Information Engineering 11, 4 (2017), 429–434. ",
+        "bbox": [
+            171,
+            114,
+            825,
+            156
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Joseph William Adams, Egon Balas, and Daniel J. Zawack. 1988. The Shifting Bottleneck Procedure for Job Shop Scheduling. Management science 34, 3 (1988), 391–401. ",
+        "bbox": [
+            165,
+            167,
+            825,
+            196
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "David L. Applegate and William J. Cook. 1991. A Computational Study of the Job-Shop Scheduling Problem. INFORMS Journal on Computing 3, 2 (1991), 149–156. https://doi.org/10.1287/ ijoc.3.2.149 ",
+        "bbox": [
+            163,
+            208,
+            825,
+            251
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Peter W. Battaglia, Jessica B. Hamrick, Victor Bapst, Alvaro Sanchez-Gonzalez, Vinícius Flores Zambaldi, Mateusz Malinowski, Andrea Tacchetti, David Raposo, Adam Santoro, Ryan Faulkner, Çaglar Gülçehre, H. Francis Song, Andrew J. Ballard, Justin Gilmer, George E. Dahl, Ashish Vaswani, Kelsey R. Allen, Charles Nash, Victoria Langston, Chris Dyer, Nicolas Heess, Daan Wierstra, Pushmeet Kohli, Matthew M. Botvinick, Oriol Vinyals, Yujia Li, and Razvan Pascanu. 2018. Relational inductive biases, deep learning, and graph networks. CoRR abs/1806.01261 (2018). arXiv:1806.01261 http://arxiv.org/abs/1806.01261 ",
+        "bbox": [
+            161,
+            261,
+            825,
+            359
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Dennis Behnke and Martin Josef Geiger. 2012. Test instances for the flexible job shop scheduling problem with work centers. Arbeitspapier/Research Paper/Helmut-Schmidt-Universität, Lehrstuhl für Betriebswirtschaftslehre, insbes. Logistik-Management (2012). ",
+        "bbox": [
+            156,
+            371,
+            821,
+            414
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Paolo Brandimarte. 1993. Routing and scheduling in a flexible job shop by tabu search. Ann. Oper. Res. 41, 3 (1993), 157–183. https://doi.org/10.1007/BF02023073 ",
+        "bbox": [
+            166,
+            425,
+            825,
+            454
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "IBM ILOG Cplex. 2009. V12. 1: User’s Manual for CPLEX. International Business Machines Corporation 46, 53 (2009), 157. ",
+        "bbox": [
+            161,
+            464,
+            825,
+            494
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Mauro Dell’Amico and Marco Trubian. 1993. Applying tabu search to the job-shop scheduling problem. Annals of Operations Research 41, 3 (1993), 231–252. https://doi.org/10.1007/ BF02023076 ",
+        "bbox": [
+            165,
+            505,
+            823,
+            547
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Alhussein Fawzi, Matej Balog, Aja Huang, Thomas Hubert, Bernardino Romera-Paredes, Mohammadamin Barekatain, Alexander Novikov, Francisco J R Ruiz, Julian Schrittwieser, Grzegorz Swirszcz, et al. 2022. Discovering faster matrix multiplication algorithms with reinforcement learning. Nature 610, 7930 (2022), 47–53. ",
+        "bbox": [
+            171,
+            559,
+            826,
+            616
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Matthias Fey and Jan Eric Lenssen. 2019. Fast Graph Representation Learning with PyTorch Geometric, In ICLR Workshop on Representation Learning on Graphs and Manifolds. CoRR abs/1903.02428. arXiv:1903.02428 http://arxiv.org/abs/1903.02428 ",
+        "bbox": [
+            160,
+            627,
+            823,
+            670
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "M. R. Garey and David S. Johnson. 1979. Computers and Intractability: A Guide to the Theory of NP-Completeness. W. H. Freeman, USA. ",
+        "bbox": [
+            160,
+            680,
+            826,
+            710
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Amit Kumar Gupta and Appa Iyer Sivakumar. 2006. Job shop scheduling techniques in semiconductor manufacturing. The International Journal of Advanced Manufacturing Technology 27, 11 (2006), 1163–1169. ",
+        "bbox": [
+            168,
+            720,
+            823,
+            763
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Reinhard Haupt. 1989. A survey of priority rule-based scheduling. Operations-Research-Spektrum 11, 1 (1989), 3–16. ",
+        "bbox": [
+            166,
+            775,
+            823,
+            804
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Johann Hurink, Bernd Jurisch, and Monika Thole. 1994. Tabu search for the job-shop scheduling problem with multi-purpose machines. Operations-Research-Spektrum 15 (1994), 205–215. ",
+        "bbox": [
+            160,
+            814,
+            826,
+            844
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "Sergey Ioffe and Christian Szegedy. 2015. Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift. In International Conference on Machine Learning (ICML) (JMLR Workshop and Conference Proceedings, Vol. 37), Francis R. Bach and David M. Blei (Eds.). JMLR.org, 448–456. http://proceedings.mlr.press/v37/ioffe15.html ",
+        "bbox": [
+            171,
+            856,
+            826,
+            912
+        ],
+        "page_idx": 9
+    },
+    {
+        "type": "text",
+        "text": "381 Klaus Jansen, Monaldo Mastrolilli, and Roberto Solis-Oba. 2000. Approximation Algorithms for   \n382 Flexible Job Shop Problems. In Latin American Symposium on Theoretical Informatics (Lecture   \n383 Notes in Computer Science, Vol. 1776), Gaston H. Gonnet, Daniel Panario, and Alfredo Viola   \n384 (Eds.). Springer, 68–77. https://doi.org/10.1007/10719839_7   \n385 BJ Lageweg, JK Lenstra, and AHG Rinnooy Kan. 1977. Job-shop scheduling by implicit enumeration.   \n386 Management Science 24, 4 (1977), 441–450. ",
+        "bbox": [
+            142,
+            90,
+            826,
+            147
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            148,
+            159,
+            825,
+            188
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "Stephen Lawrence. 1984. Resouce constrained project scheduling: An experimental investigation of heuristic scheduling techniques (Supplement). Graduate School of Industrial Administration, Carnegie-Mellon University (1984). ",
+        "bbox": [
+            163,
+            200,
+            823,
+            242
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "90 Zhigang Lian, Bin Jiao, and Xingsheng Gu. 2006. A similar particle swarm optimization algorithm   \n91 for job-shop scheduling to minimize makespan. Appl. Math. Comput. 183, 2 (2006), 1008–1017.   \n92 https://doi.org/10.1016/j.amc.2006.05.168   \n93 Chun-Cheng Lin, Der-Jiunn Deng, Yen-Ling Chih, and Hsin-Ting Chiu. 2019. Smart Manufacturing   \n394 Scheduling With Edge Computing Using Multiclass Deep Q Network. IEEE Trans. Ind. Informatics   \n395 15, 7 (2019), 4276–4284. https://doi.org/10.1109/TII.2019.2908210   \n96 Min Liu, Zhi-jiang Sun, Junwei Yan, and Jing-song Kang. 2011. An adaptive annealing genetic   \n97 algorithm for the job-shop planning and scheduling problem. Expert Systems with Applications 38,   \n98 8 (2011), 9248–9255. https://doi.org/10.1016/j.eswa.2011.01.136   \n99 Shu Luo. 2020. Dynamic scheduling for flexible job shop with new job insertions by deep reinforce  \n00 ment learning. Applied Soft Computing 91 (2020), 106208. https://doi.org/10.1016/j.   \n01 asoc.2020.106208   \n402 Mingqi Lv, Zhaoxiong Hong, Ling Chen, Tieming Chen, Tiantian Zhu, and Shouling Ji. 2021.   \n403 Temporal Multi-Graph Convolutional Network for Traffic Flow Prediction. IEEE Transactions   \n404 on Intelligent Transportation Systems 22, 6 (2021), 3337–3348. https://doi.org/10.1109/   \n405 TITS.2020.2983763   \n406 Azalia Mirhoseini, Anna Goldie, Mustafa Yazgan, Joe Wenjie Jiang, Ebrahim M. Songhori, Shen   \n407 Wang, Young-Joon Lee, Eric Johnson, Omkar Pathak, Azade Nazi, Jiwoo Pak, Andy Tong, Kavya   \n408 Srinivasa, Will Hang, Emre Tuncer, Quoc V. Le, James Laudon, Richard Ho, Roger Carpenter, and   \n409 Jeff Dean. 2021. A graph placement methodology for fast chip design. Nature 594, 7862 (2021),   \n410 207–212.   \n411 Volodymyr Mnih, Koray Kavukcuoglu, David Silver, Andrei A. Rusu, Joel Veness, Marc G. Belle  \n412 mare, Alex Graves, Martin A. Riedmiller, Andreas Fidjeland, Georg Ostrovski, Stig Petersen,   \n413 Charles Beattie, Amir Sadik, Ioannis Antonoglou, Helen King, Dharshan Kumaran, Daan Wierstra,   \n414 Shane Legg, and Demis Hassabis. 2015. Human-level control through deep reinforcement learning.   \n415 Nature 518, 7540 (2015), 529–533. https://doi.org/10.1038/nature14236 ",
+        "bbox": [
+            151,
+            255,
+            826,
+            297
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            150,
+            309,
+            826,
+            352
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            364,
+            826,
+            406
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            151,
+            417,
+            828,
+            460
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            473,
+            826,
+            529
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            541,
+            826,
+            611
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            140,
+            623,
+            828,
+            694
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "416 J.F. Muth and G.L. Thompson. 1963. Industrial Scheduling. Prentice-Hall. ",
+        "bbox": [
+            142,
+            705,
+            663,
+            720
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "417 In-Beom Park, Jaeseok Huh, Joongkyun Kim, and Jonghun Park. 2020. A Reinforcement Learning   \n418 Approach to Robust Scheduling of Semiconductor Manufacturing Facilities. IEEE Transactions on   \n419 Automation Science and Engineering 17, 3 (2020), 1420–1431. https://doi.org/10.1109/   \n420 TASE.2019.2956762   \n421 Junyoung Park, Sanjar Bakhtiyar, and Jinkyoo Park. 2021a. ScheduleNet: Learn to solve multi-agent   \n422 scheduling problems with reinforcement learning. CoRR abs/2106.03051 (2021). arXiv:2106.03051   \n423 https://arxiv.org/abs/2106.03051   \n424 Junyoung Park, Jaehyeong Chun, Sang Hun Kim, Youngkook Kim, and Jinkyoo Park. 2021b.   \n425 Learning to schedule job-shop problems: representation and policy learning using graph neural   \n426 network and reinforcement learning. International Journal of Production Research 59, 11 (2021),   \n427 3360–3377. https://doi.org/10.1080/00207543.2020.1870013   \n429 Killeen, Zeming Lin, Natalia Gimelshein, Luca Antiga, Alban Desmaison, Andreas Köpf, Ed  \n430 ward Z. Yang, Zachary DeVito, Martin Raison, Alykhan Tejani, Sasank Chilamkurthy, Benoit   \n431 Steiner, Lu Fang, Junjie Bai, and Soumith Chintala. 2019. PyTorch: An Imperative Style, High  \n432 Performance Deep Learning Library. In Neural Information Processing Systems (NeurIPS),   \n433 Hanna M. Wallach, Hugo Larochelle, Alina Beygelzimer, Florence d’Alché-Buc, Emily B. Fox,   \n434 and Roman Garnett (Eds.). 8024–8035. https://proceedings.neurips.cc/paper/2019/   \n435 hash/bdbca288fee7f92f2bfa9f7012727740-Abstract.html   \n436 Laurent Perron and Vincent Furnon. 2019. OR-Tools. Google. https://developers.google.   \n437 com/optimization/   \n438 Ferdinando Pezzella, Gianluca Morganti, and Giampiero Ciaschetti. 2008. A genetic algorithm for   \n439 the Flexible Job-shop Scheduling Problem. Computers and Operations Research 35, 10 (2008),   \n440 3202–3212. https://doi.org/10.1016/j.cor.2007.02.014   \n441 Qing-dao-er-ji Ren and Yuping Wang. 2012. A new hybrid genetic algorithm for job shop scheduling   \n442 problem. Computers and Operations Research 39, 10 (2012), 2291–2299. https://doi.org/   \n443 10.1016/j.cor.2011.12.005   \n444 Mohammad Saidi-Mehrabad and Parviz Fattahi. 2007. Flexible job shop scheduling with tabu search   \n445 algorithms. The International Journal of Advanced Manufacturing Technology 32, 5 (2007),   \n446 563–570.   \n447 David Silver, Aja Huang, Chris J. Maddison, Arthur Guez, Laurent Sifre, George van den Driess  \n448 che, Julian Schrittwieser, Ioannis Antonoglou, Vedavyas Panneershelvam, Marc Lanctot, Sander   \n449 Dieleman, Dominik Grewe, John Nham, Nal Kalchbrenner, Ilya Sutskever, Timothy P. Lillicrap,   \n450 Madeleine Leach, Koray Kavukcuoglu, Thore Graepel, and Demis Hassabis. 2016. Mastering   \n451 the game of Go with deep neural networks and tree search. Nature 529, 7587 (2016), 484–489.   \n452 https://doi.org/10.1038/nature16961   \n453 Wen Song, Xinyang Chen, Qiqiang Li, and Zhiguang Cao. 2023. Flexible Job-Shop Scheduling via   \n454 Graph Neural Network and Deep Reinforcement Learning. IEEE Trans. Ind. Informatics 19, 2   \n455 (2023), 1600–1610. https://doi.org/10.1109/TII.2022.3189725   \n456 Robert H. Storer, S. David Wu, and Renzo Vaccari. 1992. New search spaces for sequencing problems   \n457 with application to job shop scheduling. Management science 38, 10 (1992), 1495–1509.   \n458 Richard S. Sutton and Andrew G. Barto. 2018. Reinforcement Learning: An Introduction (second   \n459 ed.). The MIT Press. http://incompleteideas.net/book/the-book-2nd.html   \n460 Éric D. Taillard. 1993. Benchmarks for basic scheduling problems. european journal of operational   \n461 research 64, 2 (1993), 278–285.   \n462 Oriol Vinyals, Igor Babuschkin, Wojciech M. Czarnecki, Michaël Mathieu, Andrew Dudzik, Junyoung   \n463 Chung, David H. Choi, Richard Powell, Timo Ewalds, Petko Georgiev, Junhyuk Oh, Dan Horgan,   \n464 Manuel Kroiss, Ivo Danihelka, Aja Huang, Laurent Sifre, Trevor Cai, John P. Agapiou, Max   \n465 Jaderberg, Alexander Sasha Vezhnevets, Rémi Leblond, Tobias Pohlen, Valentin Dalibard, David   \n466 Budden, Yury Sulsky, James Molloy, Tom Le Paine, Çaglar Gülçehre, Ziyu Wang, Tobias Pfaff,   \n467 Yuhuai Wu, Roman Ring, Dani Yogatama, Dario Wünsch, Katrina McKinney, Oliver Smith, Tom   \n468 Schaul, Timothy P. Lillicrap, Koray Kavukcuoglu, Demis Hassabis, Chris Apps, and David Silver.   \n469 2019. Grandmaster level in StarCraft II using multi-agent reinforcement learning. Nature 575,   \n470 7782 (2019), 350–354. https://doi.org/10.1038/s41586-019-1724-z   \n471 Bernd Waschneck, Thomas Altenmüller, Thomas Bauernhansl, and Andreas Kyek. 2016. Production   \n472 Scheduling in Complex Job Shops from an Industry 4.0 Perspective: A Review and Challenges   \n473 in the Semiconductor Industry. In Proceedings of the 1st International Workshop on Science,   \n474 Application and Methods in Industry 4.0 (i-KNOW) (CEUR Workshop Proceedings, Vol. 1793),   \n475 Roman Kern, Gerald Reiner, and Olivia Bluder (Eds.). CEUR-WS.org. http://ceur-ws.org/   \n476 Vol-1793/paper3.pdf   \n477 Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. 2019. How Powerful are Graph Neural   \n478 Networks? (2019). https://openreview.net/forum?id=ryGs6iA5Km   \n479 Takeshi Yamada and Ryohei Nakano. 1992. A Genetic Algorithm Applicable to Large-Scale Job  \n480 Shop Problems. In Parallel Problem Solving from Nature 2, (PPSN-II), Reinhard Männer and   \n481 Bernard Manderick (Eds.). Elsevier, 283–292.   \n482 Cong Zhang, Wen Song, Zhiguang Cao, Jie Zhang, Puay Siew Tan, and Chi Xu. 2020. Learning   \n483 to Dispatch for Job Shop Scheduling via Deep Reinforcement Learning. In Neural Information   \n484 Processing Systems (NeurIPS), Hugo Larochelle, Marc’Aurelio Ranzato, Raia Hadsell, Maria  \n485 Florina Balcan, and Hsuan-Tien Lin (Eds.). https://proceedings.neurips.cc/paper/   \n486 2020/hash/11958dfee29b6709f48a9ba0387a2431-Abstract.html   \n487 Cong Zhang, Wen Song, Zhiguang Cao, Jie Zhang, Puay Siew Tan, and Chi Xu. 2022. Learning to   \n488 Search for Job Shop Scheduling via Deep Reinforcement Learning. CoRR abs/2211.10936 (2022).   \n489 https://doi.org/10.48550/arXiv.2211.10936 arXiv:2211.10936   \n490 Cong Zhang, Yaoxin Wu, Yining Ma, Wen Song, Zhang Le, Zhiguang Cao, and Jie Zhang. 2023. A   \n491 review on learning to solve combinatorial optimisation problems in manufacturing. IET Collabora  \n492 tive Intelligent Manufacturing 5, 1 (2023), e12072. https://doi.org/10.1049/cim2.12072   \n493 arXiv:https://ietresearch.onlinelibrary.wiley.com/doi/pdf/10.1049/cim2.12072   \n494 Jie Zhou, Ganqu Cui, Shengding Hu, Zhengyan Zhang, Cheng Yang, Zhiyuan Liu, Lifeng Wang,   \n495 Changcheng Li, and Maosong Sun. 2020. Graph neural networks: A review of methods and   \n496 applications. AI Open 1 (2020), 57–81. https://doi.org/10.1016/j.aiopen.2021.01.001 ",
+        "bbox": [
+            142,
+            733,
+            826,
+            787
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            147,
+            800,
+            825,
+            843
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            142,
+            856,
+            826,
+            911
+        ],
+        "page_idx": 10
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            137,
+            104,
+            828,
+            921
+        ],
+        "page_idx": 11
+    },
+    {
+        "type": "text",
+        "text": "",
+        "bbox": [
+            137,
+            90,
+            828,
+            382
+        ],
+        "page_idx": 12
+    }
+]

parse/dev/83LJRUzXWj/83LJRUzXWj_origin.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:42fcec027856616cdbc4c22372fc39f004b73dc4c68e1c7eebdad89357bc0d5f
+size 2765181