GRAPH NEURAL NETWORK GUIDED LOCAL SEARCH
Year: 2021

Abstract:
Solutions to the Traveling Salesperson Problem (TSP) have practical applications to processes in transportation, logistics, and automation, yet must be computed with minimal delay to satisfy the real-time nature of the underlying tasks. However, solving large TSP instances quickly without sacrificing solution quality remains challenging for current approximate algorithms. To close this gap, we present a hybrid data-driven approach for solving the TSP based on Graph Neural Networks (GNNs) and Guided Local Search (GLS). Our model predicts the regret of including each edge of the problem graph in the solution; GLS uses these predictions in conjunction with the original problem graph to find solutions. Our experiments demonstrate that this approach converges to optimal solutions at a faster rate than three recent learning based approaches for the TSP. Notably, we reduce the mean optimality gap on the 100-node problem set from 1.534% to 0.705%, a 2× improvement. When generalizing from 20-node instances to the 100-node problem set, we reduce the optimality gap from 18.845% to 2.622%, a 7× improvement.

text: Solutions to the Traveling Salesperson Problem (TSP) have practical applications to processes in transportation, logistics, and automation, yet must be computed with minimal delay to satisfy the real-time nature of the underlying tasks. However, solving large TSP instances quickly without sacrificing solution quality remains challenging for current approximate algorithms. To close this gap, we present a hybrid data-driven approach for solving the TSP based on Graph Neural Networks (GNNs) and Guided Local Search (GLS). Our model predicts the regret of including each edge of the problem graph in the solution; GLS uses these predictions in conjunction with the original problem graph to find solutions. Our experiments demonstrate that this approach converges to optimal solutions at a faster rate than three recent learning based approaches for the TSP. Notably, we reduce the mean optimality gap on the 100-node problem set from 1.534% to 0.705%, a 2× improvement. When generalizing from 20-node instances to the 100-node problem set, we reduce the optimality gap from 18.845% to 2.622%, a 7× improvement.

heading: 1 INTRODUCTION
text: Sixty years ago, the route of a delivery truck would have been fixed well before the truck departed the warehouse. Today, thanks to the availability of real-time traffic information, and the option to transmit instructions to the driver to add or remove delivery locations on-the-fly, the route is no longer fixed. Nevertheless, minimizing the length or duration of the route remains an important problem. This is an instance of the Traveling Salesperson Problem (TSP), and one of a growing number of practical applications which require solving combinatorial optimization problems in real time. In these problems, there is often a cost attributed to waiting for an optimal solution or hard deadlines at which decisions must be taken. For example, the driver cannot wait for a new solution to be computed – they may miss their deliveries, or the traffic conditions may change again. There is a need for general, anytime combinatorial optimization algorithms that produce high-quality solutions under restricted computation time. This remains challenging for current approaches, as they are specialized for a specific problem (with specific assumptions and constraints), or fail to produce good solutions quickly.
Contributions We present a hybrid data-driven approach for approximately solving the Euclidean TSP based on Graph Neural Networks (GNNs) and Guided Local Search (GLS), which we demonstrate converges to optimal solutions more quickly than three recent learning based approaches. We provide the following contributions:
• Our GLS algorithm is guided by the global regret of each edge in the problem graph. This allows the algorithm to differentiate edges that are very costly to include in the solution from ones that are not so costly, whether or not they are part of the optimal solution. Thus, using regret allows us to find high-quality, rather than optimal, solutions very quickly. We are the first to use a measure of global regret, which we define as the cost of enforcing a decision relative to the cost of an optimal solution.
• We make this computationally tractable by approximating regret with a learned representation. Our GNN-based model operates on the line graph of the problem graph, which allows us to build a network without node features, focusing only on edge weight.
• We present experimental results for our approach and several learning based approaches that are aligned with recent guidelines for computational testing of learning based approaches for the TSP. Our experiments emphasize the trade-off between solution quality and time.
• We reduce the mean optimality gap on the 50-node problem set from 0.268% to 0.009%, a 30× times improvement, and on the 100-node problem set from 1.534% to 0.705%, a 2× improvement. When generalizing from 20-node instances to the 100-node problem set, we reduce the mean optimality gap from 18.845% to 2.622%, a 7× improvement.

heading: 2 RELATED WORK
text: The Operations Research (OR) community is responsible for the majority of research in algorithms for solving combinatorial optimization problems. Concorde (Applegate et al., 2006) is widely regarded as the best exact TSP solver. As an exact solver, it can guarantee the level of optimality of the solutions it finds. It uses cutting plane algorithms (Dantzig et al., 1954; Padberg & Rinaldi, 1990; Applegate et al., 2003) and branch-and-cut methods to iteratively prune away parts of search space that will not contain an optimal solution. LKH-3 (Helsgaun, 2017), and its predecessor, LKH2 (Helsgaun, 2009), are approximate TSP and Capacitated Vehicle Routing Problem (CVRP) solvers based on the κ-opt heuristic (Lin & Kernighan, 1973). While these solvers do not provide any guarantees, experimentation has demonstrated that they are extremely effective. Concorde, LKH-2 and LKH-3 are highly specialized and efficient solvers which can solve challenging TSPs in seconds.
However, practical real-time routing problems often impose constraints on top of the basic TSP or CVRP problem definitions. Highly-specialized solvers are difficult to adapt to these new constraints. Thus, there is a need for general algorithmic frameworks that can produce high-quality solutions with minimal computation time. To address this, Arnold & Sörensen (2019a) introduce KGLS, a GLS algorithm for the CVRP that is guided by three engineered features. They demonstrate that their algorithm can find solutions almost as good as those found by state-of-the-art metaheuristics in a fraction of the time. Our work also aims to address this gap.
Machine learning offers a way to construct flexible, yet effective combinatorial optimization algorithms. This area of research has existed for more than three decades (Smith, 1999), yet new neural architectures, especially GNNs, have driven a surge of activity in this area. As noted by Bengio et al. (2021); Cappart et al. (2021), classical combinatorial optimization approaches solve each problem instance in isolation, overlooking the fact that in practice, problems and their solutions stem from related data distributions. Machine learning offers a way to exploit this observation. We classify learning based approaches for solving the TSP into the three categories identified by Bengio et al. (2021); our approach belongs to the second category, described below.
ML alone provides a solution. These approaches use a machine learning model to output solutions directly from the problem definition. Vinyals et al. (2015) propose PtrNet, a sequence-to-sequence model based on LSTMs, which iteratively constructs a solution by outputting the permutation of the input nodes. They train their model using expert solutions from Concorde. They use beam search (Reddy, 1977) to produce better solutions than those sampled from their model directly. Bello et al. (2016) present a method of training PtrNet without supervision using policy gradients. Their “active search” method resembles early neural network-based approaches to combinatorial optimization, in which a model was trained online to solve a particular problem instance (Smith, 1999). This method effectively solves each problem in isolation, thus it does not leverage expertise extracted from distribution of training problem instances. Kool et al. (2018) take a similar approach to Bello et al. (2016) but use a Transformer architecture (Vaswani et al., 2017) rather than an LSTM. Their model can also be seen as a Graph Attention Network (GAT) (Veličković et al., 2017) applied to a complete graph. Kwon et al. (2021) also take a similar approach but leverage the symmetry of many combinatorial optimization problems to improve performance.
Joshi et al. (2019) train a model to produce a heatmap of which edges in the TSP graph are likely to be part of the optimal solution, and reconstruct valid tours using beam search. Similar to Vinyals et al. (2015), they train their model using expert solutions from Concorde. Kool et al. (2021) extend the work of Joshi et al. (2019) to VRPs, and use a dynamic programming method to construct tours. Also in this category, Fu et al. (2021) train a model to output a heatmap for small TSP instances to and sample small sub-graphs from large instances to construct heatmaps for large instances. They train their approach using reinforcement learning, and use Monte Carlo tree search (MCTS) to construct valid tours.
ML provides information to an OR algorithm. Machine learning may not be suitable to solve a combinatorial optimization problem alone. Instead, it can provide information to augment a combinatorial optimization algorithm. Deudon et al. (2018) use a model based on the Transformer architecture to construct solutions iteratively and train it using policy gradients (they take a similar approach to Kool et al., 2018). They apply a 2-opt local search heuristic to solutions sampled from their model. In contrast to prior work, we are the first to use a machine learning model to approximate regret. Furthermore, many previous works that produce predictions on edges (Joshi et al., 2019; Kool et al., 2021; Fu et al., 2021) construct tours using heuristics, whereas to our knowledge, we are the first to use predictions to inform a metaheuristic (GLS).
ML makes decisions within an OR algorithm. Finally, a machine learning model can be embedded inside a combinatorial optimisation algorithm. In this paradigm, a master algorithm controls the high-level procedure while repeatedly calling a machine learning model to make lower level decisions. Dai et al. (2017) present a model that uses a GNN to learn an embedding of the current partial solution and a DQN (Mnih et al., 2015) to iteratively select nodes to insert using a cheapest insertion heuristic. They also use an “active search” method when solving the TSP. Wu et al. (2020) and da Costa et al. (2020) present policy gradient algorithms to learn policies to apply 2-opt operations to existing feasible solutions. Wu et al. (2020) use a Transformer architecture. da Costa et al. (2020) use a combination of GCN and RNN modules, and acheive better results. These approaches can either be seen as end-to-end learning approaches belonging to the first category, or as local search procedures where an ML model decides where to apply an operator.

heading: 3 PRELIMINARIES
text: Traveling Salesperson Problem We focus on the Euclidean TSP, although our approach can be applied to other routing problems, such as the CVRP. A problem with n cities, typically denoted TSPn, is represented as a complete, undirected, weighted graph G = (V,E) with n nodes. The edges E represent connections between cities and are weighted by the Euclidean distance between the adjacent nodes. A solution, or tour, is a Hamiltonian cycle: a closed path through the graph that visits every node exactly once. An optimal solution is a cycle of minimum weight.
Regret Regret measures the future cost of an action that also yields an immediate reward, and is typically used to make greedy combinatorial optimization algorithms less myopic. Generally, regret is computed over a fixed horizon. For example, Potvin & Rousseau (1993) evaluate the cost of inserting a node in the best versus second-best position when constructing a CVRP solution. Hassin & Keinan (2008) solve the TSP using regret, allowing a greedy construction heuristic to remove the most recently inserted node. It is not computationally feasible to calculate regret over a global horizon, for example, for all possible insertion sequences. However, if it were possible, a greedy algorithm could compute an optimal solution by selecting the lowest regret decision at each step.
Local Search Local Search (LS) is a general improvement heuristic. Starting from an initial solution, local search iteratively moves to neighboring solutions that are lower cost than the current solution according to the objective function g(s). Neighboring solutions are solutions that are reachable from a given solution by applying a certain function, or operator. The set of all solutions reachable from another solution by applying an operator define the neighborhood of that operator. The algorithm terminates when all neighboring solutions are inferior to the current solution, meaning the search has reached a local optimum.
Guided Local Search Guided Local Search (GLS) is a metaheuristic that sits on top of LS and allows it to escape local optima (Voudouris & Tsang, 1996). To apply GLS, the designer must define some aspects of a solution. When trapped in a local optimum, the algorithm penalizes certain aspects of the current solution which are considered to be unfavorable. The underlying LS procedure searches using an objective function that is augmented by these penalties, thus it is incentivized to remove heavily penalized aspects from the solution. The augmented objective function h(s) is
h(s) = g(s) + λ M∑ i=0 piIi(s), (1)
where s is a solution, g(s) is the objective function, λ is a scaling parameter, i indexes the aspects, M is the number of aspects, pi is the current number of penalties assigned to aspect i, and Ii is an
indication of whether s exhibits aspect i, i.e.
Ii(s) = { 1 if s exhibits aspect i, 0 otherwise.
(2)
For the TSP, aspects of the solution are often defined as the edges in the problem graph. Therefore, Ii(s) indicates if an edge is in the solution s. Upon reaching a local optimum, which aspects are penalized is determined by a utility function. The utility of penalising aspect i, utili, is defined as
utili(s∗) = Ii(s∗) ci
1 + pi , (3)
where s∗ is the solution at a local optimum, Ii(s∗) indicates if the solution exhibits aspect i, and ci is the cost of the aspect i. The cost of an aspect measures how unfavorable it is. The higher the cost, the greater the utility of penalizing that aspect. In the context of the TSP, the cost can be the weight of the edge (Voudouris & Tsang, 1999), or a combination of various features (Arnold & Sörensen, 2019a). Conversely, the more penalties assigned to that aspect, the lower the utility of penalising it again. The aspects with the maximum utility are always penalized, which means increasing pi by one. This penalization mechanism distributes the search effort in the search space, favoring areas where a promise is shown (Voudouris & Tsang, 1996).
We use a variation of the classical GLS algorithm (see Voudouris & Tsang, 1999) that applies alternating optimisation and perturbation phases (see Arnold & Sörensen, 2019a). During an optimization phase, the local search procedure is guided by the original objective function g. During a perturbation phase, it is guided by the augmented objection function h. After an edge is penalized, the local search is applied only on the penalized edge. That is, only operations that would remove the penalized edge are considered. This differs from the local search during the optimization phase, which considers all solutions in the neighborhood of the given operator. The perturbation phase continues until K operations (operations that improve the solution according to the augmented objective function h) have been applied to the current solution. These operations perturb the solution enough for the local search to escape a local minimum. The alternating phases continue until the stopping condition is met.

heading: 4 METHOD
text: Our hybrid method, shown in Figure 1, combines a machine learning model and a metaheuristic. Our GNN-based model learns an approximation of the global regret of including each edge of the problem graph in the solution. The metaheuristic, GLS, uses this learned regret conjunction with the original problem graph to quickly find high-quality solutions. The learned regret allows the algorithm to differentiate between edges which are costly to include in the solution and ones that are not so costly, thus improving its ability to steer the underlying local search procedure out of local minima and towards promising areas of the solution space.

heading: 4.1 GLOBAL REGRET
text: We define global regret as the cost of requiring a certain decision to be part of the solution relative to the cost of a globally optimal solution. Unlike previous heuristics using regret, which calculate the
cost of a decision relative to some fixed number of alternatives (for example, the next best, or two next best options), our regret is measured relative to a global optimal solution. Decisions that are part of an optimal solution have zero regret, and all other decisions have positive regret. Mathematically,
ri = g(s∗i )
g(s∗) − 1, (4)
where ri is the regret of decision i, g is the objective function, s∗i is an optimal solution with i fixed, and s∗ a globally optimal solution. With perfect information, a greedy algorithm could construct an optimal solution by sequentially selecting the lowest-regret decisions.
In the TSP, decisions correspond to which edges are included in the solution, thus regret is defined as the cost of requiring that a certain edge be part of the solution. We posit that using regret is preferable to directly classifying which edges are part of the optimal solution (which is the approach taken by Joshi et al., 2019). Where classification can produce a probability that the edge is part of optimal solution, regret can differentiate between edges that are very costly to have as part of the solution and ones that are not so costly, whether or not they are part of the optimal solution. Thus, using regret furthers our goal of finding high-quality, rather than optimal, solutions with minimal computation time.

heading: 4.2 REGRET APPROXIMATION MODEL
text: Calculating the global regret of an edge in the TSP graph requires solving the TSP itself, which is computationally intractable. Instead, we aim to learn a function r̂ij that approximates the regret of an edge rij . We use GNNs to achieve this, as they are universal function approximators that operate on graph-structured data.
Input transformation Typically, GNNs aggregate messages and store states on the nodes of a graph (Gilmer et al., 2017). Instead, we input the line graph of the original problem graph into our model. The line graph L(G) of an undirected graph G is a graph such that there exists a node in L(G) for every edge in G, and that for every two edges in G that share a node, there exists an edge between their corresponding nodes L(G). Figure 2 illustrates this transformation for a simple graph. The result is that our model aggregates messages and stores states on the edges of the problem graph (the nodes of the line graph). Primarily, this allows us to build models with no node features, which is advantageous as the edge weights, not the specific node locations, are relevant when solving the TSP. For a complete, undirected graph G with n nodes, there are n(n− 1)/2 nodes and n(n− 1)(n− 2) edges in L(G). Thus, although G is complete, L(G) can be very sparse.
Model architecture Our model consists of an embedding layer, several GNN layers, and an output layer. The embedding layer is an edge-wise fully connected layer that computes dh-dimensional edge embeddings from dx-dimensional edge features. Node features, if used, are concatenated onto the feature set of the adjacent edges. The forward pass of the embedding layer is written as
h0ij = Wxij + b, (5)
where h0ij is the initial embedding of edge ij, W is a learnable weight matrix, xij are the input features of edge ij (including any node features), and b is a set of learnable biases. We use dx = 1 and dh = 128. The edge embeddings are updated using T message passing layers. Inspired by the encoder layer of Kool et al. (2018), each layer consists of multiple sublayers. The forward pass is
given by
ḣt+1ij = f t BN(h t ij + f t MHA(h t ij , L(G))), (6)
ht+1ij = f t BN(ḣ t+1 ij + f t FF(ḣ t+1 ij )), (7)
where fMHA is a multi-headed GAT layer (Veličković et al., 2017), fFF is a feedforward layer, fBN is batch normalisation (Ioffe & Szegedy, 2015), and ḣt+1u is a hidden state. The layers do not share parameters. The GAT layer uses M = 8 heads and dimensionality dh/M = 16, and the FF layer uses one hidden sublayer with dimensionality 512 and ReLU activation. Finally, the output layer is a single edge-wise fully connected layer that computes a one-dimensional output from the dh-dimensional node embeddings computed by the final message passing layer. This is written as
r̂ij = Wh T ij + b, (8)
where r̂ij is the output for edge ij and hTij is the final embedding of that edge.

heading: 4.3 REGRET-GUIDED LOCAL SEARCH
text: We adapt GLS to use regret to solve the TSP, including how the initial solution is built, the local search procedure, and the perturbation strategy. Our GLS uses alternating optimization and perturbation phases. During an optimization phase, the local search procedure greedily accepts changes to the solution until it reaches a local minimum. During a perturbation phase, the algorithm penalizes and attempts to remove edges in the current solution with high regret, thus allowing it to escape local minima while simultaneously guiding it towards promising areas of the solution space, i.e., those with low regret. Effectively, the regret predictions produced by our model allow our GLS algorithm to undo costly decisions made during the greedy optimization phase.
Initial solution We use a greedy nearest neighbor algorithm to construct an initial solution. Beginning from the origin node we iteratively select the lowest-regret edge leading to an unvisited node, until all nodes have been visited.
Local Search neighborhoods Our LS procedure uses two solution operators for the TSP, relocate and 2-opt. It alternates between using either operator, and uses a “best improvement” strategy, meaning that it exhaustively searches the neighborhood corresponding with the current operator and accepts the solution that improves the objective function the most before continuing with the other operator. The algorithm terminates when no improvement can be found in either neighborhood. The relocate operator simply changes the position of a single node in the tour. The 2-opt operator selects two nodes in the tour to swap. This divides the tour into three segments: an initial segment, an intermediate segment, and a final segment. The tour is reassembled beginning with the initial segment, the intermediate segment in reverse order, and the final segment. It is a special case of the κ-opt operator (Lin & Kernighan, 1973), although it was introduced earlier (Croes, 1958).
Perturbation strategy We define the cost of an edge as the predicted regret r̂ij of that edge. The utility of penalizing edge ij, utilij , is therefore defined as
utilij(s∗) = Iij(s∗) r̂ij
1 + pij , (9)
where we remind the reader that s∗ is the solution at a local optimum, Iij(s∗) indicates if the solution contains edge ij, and pij is the number of penalties assigned to that edge. The edges of maximum utility are penalized. Afterward, the local search is applied only on the penalized edge. That is, only operations that would remove the penalized edge are considered.

heading: 5 EXPERIMENTS
text: We train our model using supervised learning. It uses a single input feature, edge weight (i.e. the Euclidean distance between adjacent nodes), to predict the regret of the edges in the problem graph. Further details of our implementation are found in Appendix A. While further input features could be considered, they come at a computational cost, as seen in Table 4. In Appendix D, we compare 11 input features, and demonstrate that edge weight is the most important feature when predicting the regret of an edge.
Evaluation We evaluate the trade-off between solution quality and computation time when solving randomly generated TSPs as well as TSPLIB instances1. Where available, we use publicly available implementations and pre-trained models. There is no publicly available implementation of Arnold & Sörensen (2019a), so we use the GLS implementation described in section 4.3 with the guides described in their paper.
We compare our approach to the following methods, the first six of which are non-learning based, and the other three are learning based:
1. Nearest Neighbour 2. Farthest Insertion 3. Local Search (as described in section 4.3) 4. Concorde (Applegate et al., 2006) 5. LKH-3 (Helsgaun, 2017) 6. Knowledge-guided local search for the vehicle routing problem (Arnold & Sörensen, 2019a) 7. Attention, learn to solve routing problems! (Kool et al., 2018) 8. An efficient graph convolutional network technique for the travelling salesman problem (Joshi
et al., 2019) 9. Learning 2-opt heuristics for the traveling salesman problem via deep reinforcement learning
(da Costa et al., 2020)
Following Guidelines for the computational testing of machine learning approaches to vehicle routing problems (Accorsi et al., 2021), we conduct two types of experiments. 1) we leave both computation time and solution quality unfixed. We measure the mean optimality gap and computation time per instance across the entire problem set. We use implementations as-described. 2) we fix computation time and measure the solution quality, in terms of mean optimality gap and the number of instances solved optimally. This allows for a direct comparison of approaches that was impossible in the first experiments and previous works. Where possible, we modified implementations to run continuously until the computation time limit is reached. We allow up to 10 seconds to solve each problem, including the time required to calculate input features, evaluate a model, or to construct an initial solution.
We evaluate the problem sets one instance at a time, which allows us to accurately measure computation time per instance. We allow parallelism in the GPU to sample multiple solutions to a single problem at once, where implementations are configured to do so. We use a common, single CPU and single GPU setup for all experiments. More details on the experimental setup and the hyperparameters of different approaches are given in Appendix A.
We conduct both types of experiments on three problem sets, TSP20, TSP50, and TSP100, consisting of one thousand 20, 50, and 100-node 2D Euclidean TSP instances, respectively. We generate the instances by uniform-randomly sampling node locations in the unit square [0, 1]2, which is in line with the methods used by Kool et al. (2018); Joshi et al. (2019); da Costa et al. (2020). In the second type of experiment (fixed computation time), we focus on the learning based approaches and keep Concorde as a benchmark. Furthermore, we evaluate the generalization performance of the learning based approaches from smaller to larger problem sets, and from the randomly generated instances to TSPLIB instances, which are meant to represent real-world problems.
Results The performance of each approach when computation time and solution quality are unfixed is shown in Table 1. Approaches that are not dominated by others (i.e. they produce higherquality solutions or are faster) are bolded. These values form a Pareto front for the trade-off between solution quality and computation time. Non-learning and learning approaches are considered separately. Our approach always lies on the Pareto front. These results are visualized in Figure 3 in Appendix B.1.
To better evaluate this trade-off, the second experiment fixes computation time and measures the solution quality as it evolves over time. Figure 4 in Appendix B.2 visualizes the performance as a function of time, which provides a rich understanding of the trade-off made by each approach. Table 2 shows the performance of the learning based approaches after 10 seconds of computation time per instance. Our approach finds better solutions on average than the other approaches for all problem sets. Notably, we reduce the mean optimality gap on the 50-node problem set from 0.268% to 0.009%, a 30× times improvement, and on the 100-node problem set from 1.534% to 0.705%, a
1Downloaded from http://comopt.ifi.uni-heidelberg.de/software/TSPLIB95/
2× improvement. Joshi et al. (2019) finds more optimal solutions to the TSP100 problem set, but has worse average performance than our approach. Our approach finds more optimal solutions to the TSP20 and TSP50 problem sets than the other approaches.
We evaluate the performance of our approach and other learning based approaches when generalizing from smaller instances to larger ones, and from randomly generated instances to TSPLIB instances, which are meant to represent real-world instances. These results are summarized in Appendix C.1 and Appendix C.2 respectively. Our approach generalizes well. Notably, when generalizing from 20-node instances to the 100-node problem set, we reduce the mean optimality gap from 18.845% to 2.622%, a 7× improvement.

heading: 6 DISCUSSION
text: The results presented in Table 1 align with the results presented by Kool et al. (2018) and da Costa et al. (2020). The results presented for Joshi et al. (2019) differ, due to an implentation error we found in their code (see Appendix A for the correction). However, our experiments using a fixed computation time to directly compare approaches demonstrate that our approach converges to optimal solutions at a faster rate the compared learning based approaches (Kool et al., 2018; Joshi et al., 2019; da Costa et al., 2020) when solving the Euclidean TSP.
Our approach generalizes to larger problems and to real-world problems better than the other learning based approaches. This may be as a result of the unique input transformation we apply to the problem graph. We input the line graph L(G) of the problem graph G, which allows the model to aggregate messages and store states on edges rather than nodes. This allows us to build models
without node features, which is advantageous as the edge weights, not the specific node positions, are relevant when solving the TSP. Including the node positions as features, as done by Kool et al. (2018); Joshi et al. (2019); da Costa et al. (2020) may hinder the learned policy’s ability to generalize. Deudon et al. (2018) apply PCA on the node positions before inputting them into their model so they are rotation invariant, yet they do not report generalization performance. For a Euclidean TSP problem graph with n nodes, L(G) has n(n − 1)/2 nodes, meaning that although G is complete, L(G) can be very sparse, which may help learning (Cappart et al., 2021). However, the model consumes more GPU memory than models using the problem graph G.
Many approaches that learn construction heuristics (for example Kool et al., 2018) treat the tour as a permutation of the input nodes. By considering the solution as a sequence, these approaches miss out on its symmetry: a TSP solution is invariant to the origin city. Outputting the correct sequence, even when augmented by beam search, becomes increasingly difficult as the number of cities increases. This has recently been addressed by Kwon et al. (2021), who leverage the symmetry of the TSP in their approach. Our model learns the regret of including a given edge in the solution based on its features and those of its neighbors. This learning task implicitly assumes the symmetry of a TSP solution and leverages the strengths of GNNs.
Our approach is not specific to the TSP, however one disadvantage is that it relies on an explicitly designed local search algorithm. To apply our framework to another problem, the local search procedure must be modified with operators that are appropriate for that problem. For example, a local search procedure for the CVRP requires intra-route operators (such as 2-opt and relocate) and inter-route operators. In future work, our regret approximation model could be combined with a general learned local search algorithm and could be trained end-to-end. End-to-end training would also remove the need for training set, which becomes cumbersome to produce for larger problems.

heading: 7 CONCLUSION
text: We present a hybrid data-driven approach for solving the TSP based on Graph Neural Networks (GNNs) and Guided Local Search (GLS). To inform GLS, we use a GNN-based model to compute fast, generalizable approximations of the global regret of each edge. Our model operates on the line graph of the TSP graph, which allows us to build a network that uses edge weight alone as an input feature. This approach allows our algorithm to escape local minima and find high-quality solutions with minimal computation time. Finally, we present experimental results for our approach and several recent learning based approaches that emphasize the trade-off between solution quality and computation time. We demonstrate that our approach converges to optimal solutions at a faster rate than the evaluated learning based approaches.

heading: B COMPARISON TO OTHER APPROACHES
text: B.1 PERFORMANCE CHARTS
Following the guidelines in Accorsi et al. (2021), we measure the mean optimality gap and computation time per instance, while both are unfixed. Figure 3 depicts the performance of the evaluated non-learning and learning based approaches averaged across the entire 20, 50, and 100-node problem sets. The axes are scaled so the plots are easily readable. Results that fall outside the plot limits are shown with an arrow pointing towards the horizontal axis at the mean computation time. These plots clearly identify Pareto optimal approaches and dominated ones.
B.2 CONVERGENCE PROFILE CHARTS
We evaluate the solution quality, in terms of mean optimality gap and number of problems solved optimally, as a function of computation time over a fixed computation time. The resulting convergence profile provides a detailed view of how each approach trades off between solution quality and computation time. Figure 4 depicts convergence profiles for our approach and several recent learning based approaches, for models trained and evaluated on 20, 50, and 100-node problem instances. Computation time required to compute input features, evaluate a model, or to construct an initial solution is visible as a gap between the trace and the vertical axis, and is especially noticeable for Joshi et al. (2019).

heading: C GENERALIZATION PERFORMANCE
text: C.1 GENERALIZATION TO LARGER INSTANCES
Figure 5 depicts convergence profiles for the learning based approaches when generalizing from smaller problem instances to larger ones. The plots are arranged in order of increasing difference in size between the training and test problem sets.
18

heading: D ANALYSIS OF ADDITIONAL INPUT FEATURES
text: We evaluate the potential benefit of adding additional features to our regret approximation model. While more features can help produce better predictions, they come at the cost of additional computation time. We consider a total of ten additional features, described in Table 4. We use a Gaussian process-based surrogate model to conduct global sensitivity analysis (Gratiet et al., 2016) of the input features on the validation loss of the model after training. We assume that better regret predictions will equate to better guidance by the GLS algorithm, ultimately resulting in better performance to the problem sets.
We semi-randomly sample 100 input feature sets using Latin hypercube sampling (McKay et al., 1979). We train a model using each of these feature sets for 35 epochs without early stopping and record the final validation loss. Using these results, we fit a Gaussian process to emulate the mapping between the feature set F = {f0, f1, . . . , f10}, and the validation loss l achieved by our model after training, where fn indicates whether or not feature n is used. We then compute Monte-Carlo estimates of the main and total effects of each input feature on the model’s validation loss (Saltelli, 2002). Our implementation uses Emukit (Paleyes et al., 2019). Figure 6 depicts the estimated total effect for each input feature. Edge weight is the most important feature, followed by neighbor rank, depot weight, edge width, and node width. The remaining features have little to no importance.
We train a model using these top five features on 20-node problems and compare its performance to the equivalent model using edge weight as the only feature when solving the 20, 50, and 100- node problem sets. The performance of both models at the computation time limit is shown in Table 5. While the model using additional input features produces slightly more accurate regret predictions, any benefit is cancelled out by the additional time required to compute these features. Note that the results are slightly different from those reported in Figure 5 due to different training hyperparameters.

Review summaries:
This paper proposes a novel deep learning + guided local search heuristic technique for approximately solving the Travelling Salesperson Problem (TSP). This research direction is **well motivated**, as inexpensive but approximate heuristics to graph combinatorial optimization problems such as TSP are promising for enabling real-time applications in vehicle routing and operations research.  From a methodological perspective, the paper’s major contribution is to develop and train a **Graph Neural Network (GNN) on line graphs** for approximating the ‘regret’ of including graph edges in TSP solutions. The use of regret per edge is novel; regret is a metric used in the metaheuristic **Guided Local Search (GLS)**. After the GNN is trained, the proposed technique starts from a greedy solution and uses a TSP-specific Local Search interleaved with the **‘learnt’ GLS metaheuristic** to arrive at the final solution.  From an empirical point of view, this work proposes a **new evaluation setup** to measure solution quality of TSP heuristics within a fixed computational time. Their GNN + GLS approach outperforms popular learnt baselines and handcrafted GLS in this setup for TSPs up to 100 nodes.

The paper presents a hybrid data-driven approach for solving the TSP based on Graph Neural Networks and Guided Local Search. The model predicts the regret of including each edge of the problem graph in the solution; GLS uses these predictions in conjunction with the original problem graph to find solutions. The experiments demonstrate that this approach converges to optimal solutions at a faster rate than state-of-the-art learning-based approaches and non-learning GLS algorithms for the TSP, finding optimal solutions to 96% of the 50-node problem set, 7% more than the next best benchmark, and to 20% of the 100-node problem set, 4.5× more than the next best benchmark. When generalizing from 20-node problems to the 100-node problem set, this approach finds solutions with an average optimality gap of 2.5%, a 10× improvement over the next best learning-based benchmark.

The submission is concerned with developing a heuristic for the traveling salesperson problem (TSP) using graph neural networks an dguided local search. The idea of the approach is to learn the regret incurred by including an edge into the solution and to use this to guide a local search out of local optima. As opposed to previous work, the regret is computed against the global optimum (which is approximated by learning). The submission is limited to the Euclidean TSP variant where we operate on a complete graph whose edge weights are given by Euclidean distances.

The paper presents a machine learning approach to improve Guided Local Search (GLS) for finding high-quality solutions for the Travelling Salesman Problem (TSP). Specifically, the paper proposes to use an ML model to predict the global regret for an edge, i.e., the difference in the objective values of a locally optimal solution with that edge being included and a globally optimal solution. Then, the prediction is used to guide the GLS to escape local optimal solutions.