SlowGuess/NeurIPS_2023_OCR huggingface dataset:
Definition Traveling Salesman Problem (TSP) seeks the shortest route that visits a given set of nodes and returns to the starting node, visiting each node exactly once.
Instance generation Nodes are sampled uniformly from  $[0,1]^2$  unit.
Model inputs A TSP instance corresponds to a complete graph. Node features are their coordinates, and edge attributes are relative distances between nodes.
Graph sparsification All nodes are only adjacent to their  $k$  nearest neighbors to exclude highly unpromising solution components and speed up computation. The same graph sparsification is conducted for ACO baselines to ensure a fair comparison.  $k$  is set to 10 for TSP20, 20 for TSP50, 20 for TSP100, and 50 for TSP500.
Baseline heuristic The baseline heuristic measure is the inverse of edge length [72].
D.2 Capacitated Vehicle Routing Problem
Definition Capacitated Vehicle Routing Problem (CVRP) is a natural extension of TSP that involves multiple vehicles. In CVRP, each vehicle has a limited capacity, and each customer has its own demand that must be satisfied. The objective is to find the optimal route that satisfies all customer demands and minimizes the total distance traveled by the fleet.
Instance generation We follow the same instance generation settings as in previous work [94]. Customer locations are sampled uniformly in the unit square; customer demands are sampled from the discrete set  $\{1,2,\dots ,9\}$ ; the capacity of each vehicle is set to 50; the depot is located at the center of the unit square.
Model inputs We transform a CVRP instance into a complete graph, where the node features are the demand values, and the edge attributes are relative distances between nodes.
Baseline heuristic The baseline heuristic measure is the inverse of edge length [15].
D.3 Orienteering Problem
Definition Following the problem setup in [54], each node  $i$  has a prize  $p_i$ , and the objective of the Orientering Problem (OP) is to form a tour that maximizes the total collected prize. The tour starts from a special depot node 0 and should be subject to a maximum length constraint.
Instance generation We uniformly sample the nodes, including the depot node, from the unit  $[0,1]^2$ . We use a challenging prize distribution [31]:  $p_i = (1 + \left\lfloor 99 \cdot \frac{d_{0i}}{\max_{j=1}^n d_{0j}} \right\rfloor) / 100$ , where  $d_{0i}$  is the distance between the depot and node  $i$ . The maximum length constraint is also designed to be challenging. As suggested by Kool et al. [54], we set it to 4, 5, and 6 for OP100, OP200, and OP300, respectively.
Model inputs We transform an OP instance into a complete graph. The node features are two-dimensional, consisting of nodes' prizes and distances to the depot. The edge attributes are relative distances between nodes. We do not include the maximum length constraint in input features because, in our case, it is a constant for each problem scale. It is easy to model the constraint explicitly as an additional node feature or context feature, or implicitly by using it to normalize nodes' distances to the depot.
Graph sparsification  $k$  is set to 20 for OP100, 50 for OP200, and 50 for OP300.
Baseline heuristic The baseline heuristic measure  $\eta_{ij} = \frac{p_j}{d_{ij}}$  [74].
D.4 Prize Collecting Traveling Salesman Problem
Definition Prize Collecting Traveling Salesman Problem (PCTSP) is a variant of TSP. In PCTSP, each node has an associated prize and penalty. The objective is to minimize the total length of the tour (which visits a subset of all nodes) plus the sum of penalties for unvisited nodes while also ensuring a specified minimum total prize collected.
Instance generation We follow the design of Kool et al. [54] for instance generation. All nodes are sampled uniformly in the unit square. The prize for each node is sampled uniformly from  $(0,1)$ . As a result, the minimum total prize constraint is set to  $\frac{n}{4}$  for PCTSPn, such that  $\frac{n}{2}$  nodes are expected to be visited. The penalty of each node is sampled uniformly from  $(0,\frac{3L^n}{2n})$ , where  $L^n$  is the expected tour length for TSPn and is set to 4, 8, 18 for  $n = 20, 100, 500$ , respectively. For an additional depot node, its prize and penalty are set to 0.
Model inputs We transform a PCTSP instance into a complete graph. The node features are two-dimensional, consisting of nodes' prizes and penalties. The edge attributes are relative distances between nodes.
Baseline heuristic PCTSP is related to OP but inverts the goal [54]. The baseline heuristic measure of edge  $< i, j >$  is  $\frac{p_j}{d_{ij}}$  [74].
D.5 Sequential Ordering Problem
Definition The Sequential Ordering Problem (SOP) involves finding a consistent and linear ordering of a set of elements. Consider that we have  $n$  jobs to handle sequentially for SOP  $n$ . Let  $x_{i}$  be the processing time of job  $i$  and  $t_{ij}$  the waiting time between job  $i$  and  $j$ . Specially, job 0 is a dummy node, and  $x_{0} = 0$ . We also have a set of constraints that indicate the precedence between jobs. The objective is to minimize the processing time for all jobs under precedence constraints.
Instance generation We sample both  $x_{i}$  and  $t_{ij}$  uniformly from  $(0,1)$ . We stochastically sample the precedence constraints for all job pairs while ensuring at least one feasible solution and maintaining the constraints' transitive property; if job  $i$  precedes job  $j$  and job  $j$  precedes job  $k$ , then job  $i$  precedes job  $k$ . The probability of imposing the constraint on a pair of jobs is set to 0.2.
Model inputs We construct a directed graph where each job is a node and each job pair  $< i, j >$ , as long as job  $j$  does not precedes job  $i$ , is connected with a directed edge. The node feature is  $x_{i}$  for job  $i$  and the edge attribute for job pair  $< i, j >$  is  $t_{ij}$ .
Baseline heuristic The baseline heuristic measure  $\eta_{ij} = \frac{1}{x_j + d_{ij}}$  [70, 71].
D.6 Single Machine Total Weighted Tardiness Problem
Definition The Single Machine Total Weighted Tardiness Problem (SMTWTP) is a scheduling problem in which a set of  $n$  jobs must be processed on a single machine. Each job  $i$  has a processing time  $p_i$ , a weight  $w_i$ , and a due date  $t_i$ . The objective is to minimize the sum of the weighted tardiness of all jobs, where the weighted tardiness is defined as the product of a job's weight and the duration by which its completion time exceeds the due date.
Instance generation Due dates, weights, and processing time are sampled as follows:  $t_i \sim n \times Uni(0,1)$ ,  $w_i \sim Uni(0,1)$ ,  $p_i \sim Uni(0,1)$ .
Model inputs To ensure that all jobs can be the first to get processed, we include a dummy job with all its features set to zero. Then, we transform an SMTWTP instance into a directed complete graph with  $n + 1$  nodes. The features of a node are its normalized due date and weight. The attribute of edge  $< i,j >$  is  $p_j$ .
Baseline heuristic The baseline heuristic prefers jobs with shorter due time:  $\eta_{ij} = \frac{1}{t_j}$  [1].
D.7 Resource-Constrained Project Scheduling Problem
Definition Resource-Constrained Project Scheduling Problem (RCPSP) is to schedule a set of activities and minimize the schedule's makespan while satisfying precedence and resource constraints.
Instances Due to the complexity of generating random RCPCP instances, we draw the instances from PSPLIB [53] for training and held-out test.
Model inputs As stated by Gonzalez-Pardo et al. [36], parallelism is not allowed if we sample directly from the constraint graph. So the input graph is an extension of it by adding edges between unrelated nodes, i.e., the edge between node  $i$  and  $j$  ( $i \neq j$ ) exists only if  $j \notin S_{i}^{*} \land i \notin S_{j}^{*}$ , where  $S_{i}^{*}$  denotes all the successors (direct and indirect) of node  $i$  on the constraint graph.
ACO algorithm The ACO algorithm follows the architecture proposed by Merkle et al. [62] but without the additional features. We sample the ant solutions in a topological order to accelerate the convergence.
Baseline heuristic The baseline heuristic is the combination of the greatest rank positional weight all (GRPWA) heuristic, and the weighted resource utilization and precedence (WRUP) heuristic [62].
D.8 Multiple Knapsack Problem
Definition Knapsack Problem (KP) is to select a subset of items from a given set such that the total weight of the chosen items does not exceed a specified limit and the sum of their values is maximized. Multiple Knapsack Problem (MKP), also known as  $m$ -dimensional Knapsack Problem, impose  $m$  different constraints on  $m$  types of weight. Formally, MKP can be formulated as follows:
$$
\begin{array}{l} \text {m a x i m i z e} \sum_ {j = 1} ^ {n} v _ {j} x _ {j} \\ s. t. \sum_ {j = 1} ^ {n} w _ {i j} x _ {j} \leq c _ {i}, \quad i = 1, \dots , m, \tag {11} \\ x _ {j} \in \{0, 1 \}, \quad j = 1, \dots , n. \\ \end{array}
$$
Here,  $v_{j}$  is the value of the item  $j$ ,  $w_{ij}$  is the  $i$ -th type of weight of the item  $j$ , and  $x_{j}$  is the decision variable indicating whether the item  $j$  is included in the knapsack.
Instance generation The values and weights are uniformly sampled from  $[0,1]$ . To make all instances well-stated [57], we uniformly sample  $c_{i}$  from  $\left(\max_j w_{ij}, \sum_j w_{ij}\right)$ .
Model inputs For  $PH_{suc}$ , we transform an MKP instance into a complete directed graph. The node features are their weights. The attribute of edge  $< i, j >$  is  $v_i$ . For  $PH_{items}$ , the model input is  $m + 1$ -dimensional feature vectors of  $n$  items. The feature vector of item  $j$  is a concatenation of  $v_j$  and  $w_{ij}, i = 1, \ldots, m$  normalized by dividing  $c_i, i = 1, \ldots, m$  respectively.
Baseline heuristic For  $PH_{\text{succ}}$ , the baseline heuristic  $\eta_{ij} = \frac{v_j}{\sum_k w_{kj}}$  [30]. For  $PH_{\text{items}}$ , the baseline heuristic  $\eta_j = \frac{v_j}{\sum_k w_{kj}}$  [30].
D.9 Bin Packing Problem
Definition The objective of the Bin Packing Problem (BPP) is to optimally arrange items within containers of a specific capacity, in order to reduce the overall number of containers used. We follow the specific setup in [58].
Instance generation Following [58], we set the number of items to 120 and the bin capacity to 150. Item sizes are uniformly sampled between 20 and 100.
Model inputs We transform a BPP instance into a complete graph where each node corresponds to an item. Node features are their respective item sizes, while edge features are set to 1. We additionally include a dummy node with 0 item size as an unbiased starting node for solution construction.
Baseline heuristic Heuristic measure of an item equals its size [58]; that is, the heuristic measure of a solution component in  $PH_{suc}$  is the item size of its ending node.