Title: Unsupervised Learning for Solving the Travelling Salesman Problem
Venue: NeurIPS 2023
Accepted: yes
Keywords: Combinatorial Optimization

Graph Neural Network

Travelling Salesman Problem
Abstract: We propose UTSP, an Unsupervised Learning (UL) framework for solving the Travelling Salesman Problem (TSP). We train a Graph Neural Network (GNN) using a surrogate loss. The GNN outputs a heat map representing the probability for each edge to be part of the optimal path. We then apply local search to generate our final prediction based on the heat map. Our loss function consists of two parts: one pushes the model to find the shortest path and the other serves as a surrogate for the constraint that the route should form a Hamiltonian Cycle. 
Experimental results show that UTSP 
outperforms the existing data-driven TSP heuristics.
Our approach is parameter efficient as well as data efficient: the model takes  $\sim$ 10\% of the number of parameters and $\sim$ 0.2\% of training samples compared with Reinforcement Learning or Supervised Learning methods.

Unsupervised Learning for Solving the Travelling Salesman Problem

Abstract

We propose UTSP, an Unsupervised Learning (UL) framework for solving the Travelling Salesman Problem (TSP). We train a Graph Neural Network (GNN) using a surrogate loss. The GNN outputs a heat map representing the probability for each edge to be part of the optimal path. We then apply local search to generate our final prediction based on the heat map. Our loss function consists of two parts: one pushes the model to find the shortest path and the other serves as a surrogate for the constraint that the route should form a Hamiltonian Cycle. Experimental results show that UTSP outperforms the existing data-driven TSP heuristics. Our approach is parameter efficient as well as data efficient: the model takes ∼ 10% of the number of parameters and ∼ 0.2% of training samples compared with Reinforcement Learning or Supervised Learning methods.

1 Introduction

Euclidean Travelling Salesman Problem (TSP) is one of the most famous and intensely studied NP-hard problems in the combinatorial optimization community. Exact methods, such as Concorde Applegate et al. [2006], use the cutting-plane method, iteratively solving linear programming relaxations of the TSP. These methods are usually implemented within a branch-and-cut framework, integrating the cutting-plane algorithm into a branch-and-bound search. While these exact methods can find solutions with guaranteed optimality for up to tens of thousands of nodes, the execution time can be exceedingly expensive. A different strategy is using heuristics such as LKH Helsgaun [2000]. These heuristics aim to find near-optimal solutions with a notable reduction in time complexity. Typically, they are manually crafted, drawing upon expert insights and domain-specific knowledge.

Recently, the success of Graph Neural Networks (GNNs) for a variety of machine learning tasks has sparked interests in building data-driven heuristics for approximating TSP solutions. For example, Kwon et al. [2020] uses a data-driven approach known as Policy Optimization with Multiple Optima (POMO), POMO relies on Reinforcement Learning (RL) and avoids the utilization of hand-crafted heuristics. Qiu et al. [2022] proposes a Meta-Learning framework which enhances the stability of RL training. Sun and Yang [2023] applies Supervised Learning (SL) and adopts a graph-based diffusion framework. Additionally, the authors use a cosine inference schedule to improve the efficiency of their model. Joshi et al. [2019a] trains their GNN model in a SL fashion, and the model outputs an edge adjacency matrix that indicates the likelihood of edges being part of the TSP tour. The edge predictions form a heat map, which is transformed into a valid tour through a beam search method. Similarly, Fu et al. [2021] trains the GNN model on small sub-graphs to generate the corresponding heat maps using SL. These small heat maps are then integrated to build a large final heat map.

Overall, these learning-based models usually build heuristics by reducing the length of TSP tours via RL or directly learning from the optimal solutions via SL. However, since TSP is NP-hard, SL can cause expensive annotation problems due to the costly search time involved in generating optimal solutions. For RL, when dealing with big graphs, the model will run into the sparse reward problem because the reward is decided after decoding a complete solution. The sparse reward problem results in poor generalization performance and high training variance. Furthermore, both RL and SL suffer from expensive large-scale training. These models take more than one million training samples when dealing with TSP with 100 nodes, making the training process very time-consuming.

2 Our Model

In this work, we build a data-driven TSP heuristic in an Unsupervised Learning (UL) fashion and generate the heat map non-autoregressively. We construct a surrogate loss function with two parts: one encourages the GNN to find the shortest path, and the other acts as a proxy for the constraint that the path should be a Hamiltonian Cycle over all nodes. The surrogate loss enables us to update the model without decoding a complete solution. This helps alleviate the sparse reward problem encountered in RL, and thus, it avoids unstable training or slow convergence Kool et al. [2019]. Our UTSP method does not rely on labelled data, which helps the model avoid the expensive annotation problems encountered in SL and significantly reduces the time cost. In fact, due to the prohibitive time cost of building training datasets for large instances, many SL methods are trained on relatively small instances only Fu et al. [2021]Joshi et al. [2019a]. Such SL models scale poorly to big instances, while with our UTSP model, we can train our model on larger instances directly. Overall, our training does not rely on any labelled training data and converges faster compared to RL/SL methods.

The model takes the coordinates as the input of GNN. The distance between two nodes determines the edge weight in the adjacency matrix. After training the GNN, the heat map is converted to a valid tour using local search. We evaluate the performance of UTSP through comparisons on TSP cases of fixed graph sizes up to 1,000 nodes. We note that UTSP is fundamentally different from RL, which may also be considered unsupervised. While RL requires a Markov Decision Process (MDP), and its reward is extracted after obtaining solutions, our method does not use a MDP and the loss function (reward) is determined based on a heat map.

Overall, UTSP requires only a small amount of (unlabelled) data and compensates for it by employing an unsupervised surrogate loss function and an expressive GNN. The heat maps built using UTSP help reduce the search space and facilitate the local search. We further show that the expressive power of GNNs is critical for generating non-smooth heat maps.

3 Methodologies

In this paper, we study symmetric TSP on a 2D plane. Given n cities and the coordinates ( x i , y i ) ∈ R 2 of these cities, our goal is to find the shortest possible route that visits each city exactly once and returns to the origin city, where i ∈ { 1 , 2 , 3 , ..., n } is the index of the city.

3.1 Graph Neural Network

Given a TSP instance, let D i,j denote the Euclidean distance between city i and city j . D ∈ R n × n is the distance matrix. We first build adjacency matrix W ∈ R n × n with W i,j = e -D i,j /τ and node feature F ∈ R n × 2 based on the input coordinates, where F i = ( x i , y i ) and τ is the temperature. The node feature matrix F and the weight matrix W are then fed into a GNN to generate a soft indicator matrix T ∈ R n × n .

In our model, we use Scattering Attention GNN (SAG), SAG has both low-pass and band-pass filters and can build adaptive representations by learning node-wise weights for combining multiple different channels in the network using attention-based architecture. Recent studies show that SAG can output expressive representations for graph combinatorial problems such as maximum clique and remain lightweight Min et al. [2022].

Let S ∈ R n × n denote the output of SAG, we first apply a column-wise Softmax activation to the GNN's output and we can summarize this operation in matrix notation as T i,j = e S i,j / ∑ n k =1 e S k,j .

This ensures that each element in T is greater than zero and the summation of each column is 1. We then use T to build a heat map H , where H ∈ R n × n .

In our model, we use H to estimate the probability of each edge belonging to the optimal solution and use T to build a surrogate loss of the Hamiltonian Cycle constraint. This will allow us to build a non-smooth heat map H and improve the performance of the local search.

3.2 Building the Heat Map using the soft indicator matrix

Before building the unsupervised loss, let's recall the definition of TSP. The objective of TSP is to identify the shortest Hamiltonian Cycle of a graph. Therefore, the unsupervised surrogate loss should act as a proxy for two requirements: the Hamiltonian Cycle constraint and the shortest path constraint. However, designing a surrogate loss for the Hamiltonian Cycle constraint can be challenging, particularly when working with a heat map H . To address this, we introduce the T → H transformation, which enables the model to implicitly encode the Hamiltonian Cycle constraint.

Coordinates

W

i,j

=

e

-

D

i,j

/τ

Graph Neural Network

Soft Indicator Matrix

T

1

1

1

1

1

1

2

3

4

5

Route with cycles

1

2

3

4

5

T

→H

Input Cities

1

1

1

1

1

Heat Map

H

1

2

3

4

5

TSP solution

To better understand the T → H transformation, we show a binary instance in Figure 1. Figure 1 illustrates a soft indicator matrix T , its heat map H following the transformation T →H , and their corresponding routes. When we directly use the soft indicator matrix T as the heat map. It can result in loops (parallel edges) between cities, such as (2,3) and (4,5) in Figure 1 (middle). After we apply the T →H transformation, the corresponding heat H is a Hamiltonian Cycle, as shown in the right part in Figure 1.

3.3 T →H transformation

We build the heat map H based on T . As mentioned, H i,j is the probability for edge ( i , j ) to belong to the optimal TSP solution. We define H as:

where p t ∈ R n × 1 is the t th column of T , T = [ p 1 | p 2 | ... | p n ] . As shown in Figure 1, the first row in H is the probability distribution of directed edges start from city 1 , and since the third element is the only non-zero one in the first row, we then add directed edge 1 → 3 to our TSP solution. Similarly, the first column in H can be regarded as the probability distribution of directed edges which end in city 1 . Ideally, given a graph G with n nodes, we want to build a soft indicator matrix where each row and column are assigned with one value 1 (True) and n -1 values 0 (False), so that the heat map will only contain one valid solution. In practice, we will build a soft indicator matrix T whose heat map H assigns large probabilities to the edges in the TSP solution and small probabilities to the other edges.

Overall, the T → H transformation in Equation 1 enables us to build a proxy for the Hamiltonian Cycle constraint. We further prove that H represents one Hamiltonian Cycle when each row and column in T have one value 1 (True) and n -1 value 0 (False). We refer to the proof in appendix D.

3.4 Unsupervised Loss

In order to generate such an expressive soft indicator matrix T , we minimize the following objective function:

The first term in L encourages the summation of each row in T to be close to 1. As mentioned, we normalize each column of T using Softmax activation. So when the first term is minimized to zero, each row and column in T are normalized (doubly stochastic). The second term penalizes the weight on the main diagonal of H , this discourages self-loops in TSP solutions. The third term can be regarded as the expected TSP length of the heat map H , where D i,j is the distance between city i and j . As mentioned, since H corresponds to a Hamiltonian Cycle given an ideal soft indicator matrix with one value 1 (True) and n -1 value 0 (False) in each row and column. Then the minimum value of ∑ n i =1 ∑ n j =1 D i,j H i,j is the shortest Hamiltonian Cycle on the graph, which is the optimal solution of TSP. To summarize, we build a loss function which contains both the shortest and the Hamiltonian Cycle constraints. The shortest constraint is realized by minimizing ∑ n i =1 ∑ n j =1 D i,j H i,j . For the Hamiltonian Cycle constraint, instead of writing it in a Lagrangian relaxation style penalty, we use a GNN which encourages a non-smooth representation, along with the doubly stochastic penalty, and the T →H transformation.

3.5 Edge Elimination

Given a heat map H , we consider M largest elements in each row (without diagonal elements) and set other n -M elements as 0. Let ˜ H denote the new heat map, we then symmetrize the new heat map by H ′ = ˜ H + ˜ H T . Let E ij ∈ { 0 , 1 } denote whether an undirected edge ( i, j ) is in our prediction or not. Without loss of generality, we can assume 0 < i < j ≤ n and define E ij as :

.

Let Π denote the set of undirected edges ( i, j ) with E ij = 1 . Ideally, we would build a prediction edge set Π with a small M value, and Π can cover all the ground truth edges so that we can reduce search space size from n ( n -1) / 2 to | Π | . In practice, we aim to let Π cover as many ground truth edges as possible and use H ′ to guide the local search process.

4 Local Search

4.1 Heat Map Guided Best-first Local Search

We employ the best-first local search guided by the heat map to generate the final solution. Best-first search is a heuristic search that explores the search space by expanding the most promising node selected w.r.t. an evaluation function f ( node ) . In our framework, each node of the search tree is a

complete TSP solution. For the initialization of one search tree, we randomly generate a valid TSP solution and improve it using the 2-opt heuristic until no better solution is found. The expand action of the search node refers to Fu et al. [2021] and is based on the widely used k-opt heuristic Croes [1958], where it replaces k old edges (in the current solution) with k new edges, i.e., transforms the old solution to a new solution. More formally, we use a series of cities, u 1 , v 1 , u 2 , . . . , u k , v k +1 , to represent an action, where v k +1 = u 1 to ensure it is a valid solution. All the edges ( u i , v i ) (1 ≤ i ≤ k ) are removed from the tour and ( v i , u i +1 )(1 ≤ i ≤ k ) are added to the tour. Note that once we know u i , v i is deterministically decided. u 1 is randomly selected for each expansion, and v 1 is decided subsequently. Then we select u i +1 ( i ≥ 1) as follows: (1) if u i +1 = u 1 , i.e., forms a new TSP tour, leads to an improved solution then we set u i +1 = u 1 and have a candidate solution. (2) if i ≥ K , then we will discard this action and start a new expand action, where K is a hyperparameter which controls the maximal edges we can remove in one action. (3) otherwise, we select u i +1 based on the heat map stochastically. We use N u,v to denote the times the edge ( u, v ) is selected during the entire search procedure. The likelihood of selecting the edge ( u, v ) is denoted by L u,v = H ′ u,v + α √ log( S +1) N u,v +1 , where α is a hyper-parameter and S is the local search's total number of expand actions. The first term encourages the algorithm to select the edge with a high heat map value, while the second term diversifies the selected edges. Moreover, when selecting the city v given u , we only consider the cities from the candidate set of v . This candidate set consists of cities with the top M heat map value or the nearest M cities

Among all the possible new solutions, we use the tour's length as the evaluation function f , i.e., we select the solution of the shortest tour length as the next search node. For each search node, we try at most T expand actions. From these T expand actions, if no improved solution is found, we randomly generate a new initial solution and start another round of best-first local search.

4.2 Updating the Heat Map

We borrow the idea of the backpropagation used in Monte Carlo Tree Search (MCTS). We use s to denote the current search node, s ′ to denote the next search node ( s ′ has to improve s ), and L ( s ) to represent the tour length of node s . The heat map H ′ is updated as:

where β is a search parameters and ( v i , u i +1 )(1 ≤ i ≤ k ) is the actions used to transform s to s ′ . We raise the importance of the edges that lead to a better solution. If we cannot find an improved solution for the current node, then no update is executed for the heat map.

4.3 Leveraging Randomness

Randomness is shown to be very powerful in the local search community Gomes et al. [1998], Bresina [1996], Gomes et al. [2000]. Our local search procedure also employs it to improve performance. When we stop the current round of local search by not finding an improved solution within T expand actions and switch to a new best-first local search with a new initial solution, we randomly modify the parameter K . A larger K value results in more time searching from one initial solution. The intuition is that sometimes we want more initial solutions while sometimes we want to search deeper (replace more edges in k-opt) for a specific solution. Besides that, we also randomly decide how we construct the candidate set (based on the heat map or pairwise distance) for each city before the new round of local search.

5 Experiments

5.1 Dataset

Our dataset contains 2,000 samples for training and 1,000 samples for validation. We use the same test dataset in Fu et al. [2021]. The test dataset contains 10 , 000 2D-Euclidean TSP instances for n = 20 , 50 , 100 , and 128 instances for n = 200 , 500 , 1 , 000 . We train our models on TSP instances with 20, 50, 100, 200, 500, and 1,000 vertices. We then build the corresponding heat maps based on these trained models.

5.2 Results

Table 1, Table 2 and Table 3 present model's performance on TSP 20, 50, 100, 200, 500 and 1,000. The first three lines in the tables summarize the performance of two exact solvers (Concorde and Gurobi) and LKH3 heuristic Helsgaun [2017]. The learning-based methods can be divided into RL sub-category and SL sub-category. Greedy decoding (G), Sampling (S), Beam Search (BS), and Monte Carlo Tree Search are the decoding schemes used in RL/SL. The 2-OPT is a greedy local search heuristic.

We compare our model with existing solvers as well as different learning-based algorithms. The performance of our method is averaged of four runs with different random seeds. The running time for our method is divided into two parts: the inference time (building the heat map H ) and the search time (running search algorithm).

On small instances, our results match the ground-truth solutions and generate average gaps of -0.00009% , -0.002% and -0.00011% respectively on instances with n = 20 , 50 , 100 , where the negative values are the results of the rounding problem. The total runtime of our method remains competitive w.r.t. all other learning baselines. On larger instances with n = 200 , 500 and 1 , 000 , we notice that traditional solvers (Concorde, Gurobi) fail to generate the optimal solutions within reasonable time when the size of problems grows. For RL/SL baselines, they generate results far away from ideal solutions, particularly for cases with n = 1 , 000 . Our UTSP method is able to obtain 0.0918% , 0.8394% and 1.1770% on TSP 200 , 500 and 1 , 000 , respectively. We remark that UTSP outperforms the existing learning baselines on larger instances (TSP 200, 500, 1000) 2 . More discussion between Fu et al. [2021] and UTSP can be found in Appendix C.

Our model takes less training time than RL/SL method because we require very few training instances. Taking TSP 100 as an example, RL/SL needs 1 million training instances, and the total training time can take one day using a NVIDIA V100 GPU, while our method only takes about 30 minutes with 2,000 training instances. The training data size does not increase w.r.t. TSP size. Our training data consists of 2,000 instances for TSP 200, 500 and 1,000. At the same time, the UTSP model also remains very lightweight. On TSP 100, we use a 2-layer SAG with 64 hidden units and the model consists of 44,392 trainable parameters. In contrast, RL method in Kool et al. [2019] takes approximately 700,000 parameters and the SL method in Joshi et al. [2022] takes approximately 350,000 parameters.

5.3 Expressive Power of GNNs

Our UL method generalizes well to unseen examples without requiring a large number of training samples. This is because the loss function in Equation 2 is fully differentiable w.r.t. the parameters

100

SAG (Training)

80

SAG (Validation)

S

S

5

GCN (Training)

60

GCN (Validation)

40

0

20

40

60

80

100

Epoch

map H , the model learns to assign large weights to more promising edges and small weights to less promising ones through backpropagation without any prior knowledge of the ground truth or any exploration step. However, when using SL, the model learns from the TSP solutions, which fails when multiple solutions exist or the solutions are not optimal Li et al. [2018]. While for RL, the model often encounters an exploration dilemma and is not guaranteed to converge Bengio et al. [2021]Joshi et al. [2019b]. Overall, UTSP requires fewer training samples and has better generalization compared to SL/RL models.

We aim to generate a non-smooth soft indicator matrix T and build an expressive heat map H to guide the search algorithm. However, most GNNs aggregate information from adjacent nodes and these aggregation steps usually consist of local averaging operations, which can be interpreted as a low-pass filter and causes the oversmoothing problem Wenkel et al. [2022]. The low-pass model generates a smooth soft indicator matrix T , which finally makes the elements in H become indistinguishable. So it becomes difficult to discriminate whether the edges belong to the optimal solution or not. In our model, we assume all nodes in the graph are connected, so every node has n -1 connected to neighbouring nodes. This means every node receives messages from all other nodes and we have a global averaging operation over the graph, this can lead to severe oversmoothing issue.

To avoid oversmoothing, one solution is to use shallow GNNs. However, this would result in narrow receptive fields and create the problem of underreaching Barceló et al. [2020]. Our model uses SAG because this scattering-based method helps overcome the oversmoothing problem by combining band-pass wavelet filters with GCN-type filters Min et al. [2022]. Figure 2 illustrates the training loss on TSP 100 and the differences between our SAG model and the graph convolutional network (GCN) Kipf and Welling [2016], where GCN only performs low-pass filtering on graph signals Nt and Maehara [2019]. When using GCN, the training loss decreases slowly, and the validation loss reaches a plateau after we train the model for 20 epochs. This is because the low-pass model generates a smooth T . Such a smooth T results in an indistinguishable H , detrimentally impacting the training process. Instead, we observe lower training and validation loss when using SAG; this suggests that SAG generates a more expressive representation which facilitates the training process.

Figure 3 illustrates the generated heat maps using GCN and SAG on a TSP 100 instance, we choose this instance from the validation set randomly. When using the GCN, due to the oversmoothing problem, the model generates a smooth representation and H becomes indistinguishable. The elements in H have a small variance and most of them are ∼ 0.01. Instead, the SAG generates a discriminative representation and the elements in the heat map have a larger variance.

1

26

51

76

1

26

51

76

1

0.175

0.014

0.150

0.012

26

26

0.125

0.010

0.100

0.008

51

51

三

0.075

0.006

76

0.004

76

0.050

0.002

0.025

0.000

0.000

Here, we train both GCN and SAG with the same loss function. So the differences illustrated in Figure 3 are the direct result of overcoming the oversmoothing problem.

6 Search Space Reduction

To understand what happens during our training process, we study how the prediction edge set Π changes with training time. As mentioned, let Π denote undirected edge set in H ′ , and let Γ denote the ground truth edge set, η = | Γ ∩ Π | / | Γ | is the extent of how good our prediction set Π covers the solution Γ . If η = 1 , then Γ is a subset of Π , which means our prediction edge set successfully covers all ground truth edges. Similarly, η = 0 . 95 means we cover 95% ground truth edges.

Coefficient

1.0

Number of Instances

800

0.8

600

0.6

SAG (Validation)

SAG(Validation)

400

GCN (Validation)

GCN(Validation)

Overlap

p

0.4

200

0.2

0.0

0

0

20

40

60

80

100

0

20

40

60

80

100

Epoch

Epoch

Figure 4 shows how the average overlap coefficient η changes with training epochs. We calculate the coefficient based on 1,000 validation instances in TSP 100. We notice that the coefficient quickly increases to ∼ 98% after we train SAG for 10 epochs. This suggests that the surrogate loss successfully encourages the SAG to put more weights on the more promising edges. We also compare the performance with GCN. Since the loss does not decrease significantly during our training when using GCN (shown in Figure 2), it is not surprising to see the average overlap coefficient of GCN always maintains at a relatively low level. After training the model for 100 epochs, SAG model has an average coefficient of 99 . 756% while GCN only has 33 . 893% .

We then study the number of cases where our prediction edge set Π covers the ground truth solution. Figure 4 (right) illustrates how the number of fully covered instances ( η = 1 ) changes with time.

After training the model for 100 epochs, we observe 780 fully covered instances in 1,000 validation samples using SAG while 0 instances using GCN. Finally, we calculate the average of size | Π | . Our results show that SAG has an average size of 583 . 134 edges, while for GCN, the number is 738 . 739 .

These results also indicate a correspondence between the loss and the quality of our prediction. In most SL tasks such as classification or regression tasks, a smaller validation loss usually means we achieve better performance and the minimum of the loss corresponds to the optimal solution (100% accuracy). However, there is no theoretical guarantee that our loss in Equation 2 also measures the solution quality. Our empirical results demonstrate that a lower surrogate loss encourages the model to assign larger weights on the promising edges and reduces the search space. This implies that we can assess the quality of the generated heat maps using our loss in Equation 2.

Overall, the UL training reduces the search space from 4950 edges to 583 . 134 edges with over 99% overlap accuracy on average. This helps explain why our search algorithm is able to perform well within reasonable search time.

7 Conclusion

In this paper, we propose UTSP, an Unsupervised Learning method to solve the TSP. We build a surrogate loss that encourages the GNN to find the shortest path and satisfy the constraint that the path should be a Hamiltonian Cycle. The surrogate loss function does not rely on any labelled ground truth solution and helps alleviate sparse reward problems in RL. UTSP uses a two-phase strategy. We first build a heat map based on the GNN's output. The heat map is then fed into a search algorithm. Compared with RL/SL, our method vastly reduces training cost and takes fewer training samples. We further show that our UL training helps reduce the search space. This helps explain why the generated heat maps can guide the search algorithm. On the model side, our results indicate that a low-pass GNN will produce an indistinguishable representation due to the oversmoothing issue, which results in unfavorable heat maps and fails to reduce the search space. Instead, after incorporating band-pass operators into GNN, we can build efficient heat maps that successfully reduce search space. Our findings show that the expressive power of GNNs is critical for generating a non-smooth representation that helps find the solution.

In conclusion, UTSP is competitive with or outperforms other learning-based TSP heuristics in terms of solution quality and running speed. In addition, UTSP takes ∼ 10% of the number of parameters and ∼ 0.2% of (unlabelled) training samples, compared with RL or SL methods. Our UTSP framework demonstrates that by providing a surrogate loss and a GNN which encourages a non-smooth representation, we can learn the hidden patterns in TSP instances without supervision and further reduce the search space. This allows us to build a heuristic by exploiting a small amount of unlabelled data. Future directions include designing more expressive GNNs (such as adding edge features) and using different surrogate loss functions. We anticipate that these concepts will extend to more combinatorial problems.

References

David Applegate, Ribert Bixby, Vasek Chvatal, and William Cook. Concorde tsp solver, 2006.

Keld Helsgaun. An effective implementation of the lin-kernighan traveling salesman heuristic. European journal of operational research , 126(1):106-130, 2000.

Yeong-Dae Kwon, Jinho Choo, Byoungjip Kim, Iljoo Yoon, Youngjune Gwon, and Seungjai Min. Pomo: Policy optimization with multiple optima for reinforcement learning. Advances in Neural Information Processing Systems , 33:21188-21198, 2020.

Ruizhong Qiu, Zhiqing Sun, and Yiming Yang. Dimes: A differentiable meta solver for combinatorial optimization problems. arXiv preprint arXiv:2210.04123 , 2022.

Zhiqing Sun and Yiming Yang. Difusco: Graph-based diffusion solvers for combinatorial optimization. arXiv preprint arXiv:2302.08224 , 2023.

Chaitanya K Joshi, Thomas Laurent, and Xavier Bresson. An efficient graph convolutional network technique for the travelling salesman problem. arXiv preprint arXiv:1906.01227 , 2019a.

Zhang-Hua Fu, Kai-Bin Qiu, and Hongyuan Zha. Generalize a small pre-trained model to arbitrarily large tsp instances. Proceedings of the AAAI Conference on Artificial Intelligence , 35(8):74747482, 2021.

Wouter Kool, Herke van Hoof, and Max Welling. Attention, learn to solve routing problems! In International Conference on Learning Representations , 2019. URL https://openreview.net/ forum?id=ByxBFsRqYm .

Yimeng Min, Frederik Wenkel, Michael Perlmutter, and Guy Wolf. Can hybrid geometric scattering networks help solve the maximum clique problem? Advances in Neural Information Processing Systems , 35:22713-22724, 2022.

Georges A Croes. A method for solving traveling-salesman problems. Operations research , 6(6): 791-812, 1958.

Carla P Gomes, Bart Selman, Henry Kautz, et al. Boosting combinatorial search through randomization. AAAI/IAAI , 98:431-437, 1998.

John L Bresina. Heuristic-biased stochastic sampling. In AAAI/IAAI, Vol. 1 , pages 271-278, 1996.

Carla P Gomes, Bart Selman, Nuno Crato, and Henry Kautz. Heavy-tailed phenomena in satisfiability and constraint satisfaction problems. Journal of automated reasoning , 24(1):67-100, 2000.

Michel Deudon, Pierre Cournut, Alexandre Lacoste, Yossiri Adulyasak, and Louis-Martin Rousseau. Learning heuristics for the tsp by policy gradient. In International Conference on the Integration of Constraint Programming, Artificial Intelligence, and Operations Research , pages 170-181. Springer, 2018.

Keld Helsgaun. An extension of the lin-kernighan-helsgaun tsp solver for constrained traveling salesman and vehicle routing problems. Roskilde: Roskilde University , pages 24-50, 2017.

Chaitanya K Joshi, Quentin Cappart, Louis-Martin Rousseau, and Thomas Laurent. Learning the travelling salesperson problem requires rethinking generalization. Constraints , pages 1-29, 2022.

Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. arXiv preprint arXiv:1609.02907 , 2016.

Zhuwen Li, Qifeng Chen, and Vladlen Koltun. Combinatorial optimization with graph convolutional networks and guided tree search. In Advances in Neural Information Processing Systems , pages 539-548, 2018.

Yoshua Bengio, Andrea Lodi, and Antoine Prouvost. Machine learning for combinatorial optimization: a methodological tour dhorizon. European Journal of Operational Research , 290(2): 405-421, 2021.

Chaitanya K Joshi, Thomas Laurent, and Xavier Bresson. On learning paradigms for the travelling salesman problem. arXiv preprint arXiv:1910.07210 , 2019b.

Frederik Wenkel, Yimeng Min, Matthew Hirn, Michael Perlmutter, and Guy Wolf. Overcoming oversmoothness in graph convolutional networks via hybrid scattering networks. arXiv preprint arXiv:2201.08932 , 2022.

Pablo Barceló, Egor V Kostylev, Mikael Monet, Jorge Pérez, Juan Reutter, and Juan-Pablo Silva. The logical expressiveness of graph neural networks. In 8th International Conference on Learning Representations (ICLR 2020) , 2020.

Hoang Nt and Takanori Maehara. Revisiting graph neural networks: All we have is low-pass filters. arXiv preprint arXiv:1905.09550 , 2019.

James Joseph Sylvester. The Collected Mathematical Papers of James Joseph Sylvester... , volume 3. University Press, 1909.

Diederik P Kingma and Jimmy Ba. Adam: A method for stochastic optimization. arXiv preprint arXiv:1412.6980 , 2014.

A Discussion

A.1 Definition of heat map

We can write H as:

where is the Sylvester shift matrix Sylvester [1909], V ∈ R n × n . Wecan interpret V as a cyclic permutation operator that performs a circular shift.

A.2 Unsupervised Loss

We can also write Equation 2 in a more compact form:

where ˜ D = D + λ 2 I n , I n ∈ R n × n is the identity matrix.

B Training and Search Details

We train our model using Adam Kingma and Ba [2014]. All models are trained using Nvidia V100 GPU. All the search-related parameters are listed in Table 4. M is the size of the candidate set of each city. K is the maximal number of edges we can remove in one action, and for each round of local search, we randomly select one number from the listed interval. T is the total number of actions we will try to expand one node. Here, we set α = 0 to show that our unsupervised model generates an informative heat map. Lower α means the local search algorithm focuses more on the edges with higher heat map value. Actually, in the experiments, we find the results are similar with α ≤ 1 .

C Running Time Discussion

As discussed in Kool et al. [2019], running time is important but hard to compare since it is affected by many factors. In the table 1, we report the time for solving all the test instances.

For the UTSP (our method) and the state-of-the-art learning-based method Att-GCRN Fu et al. [2021], we run the search algorithm on exactly the same environment (one Intel Xeon Gold 6326) for a fair comparison. And for other baselines, we refer to the results from Fu et al. [2021]. So, the time there is only for indicative purposes since the computing hardware is different.

D Proof

Lemma D.1. Let q i denote the row index of the non-zero element in i -th column in T , T q i ,i = 1 , q i ∈ { 1 , 2 , 3 , 4 , ..., n } . When each row and column in T have one value 1 (True) and n -1 value 0 (False), then q i = q j if and only if i = j .

̸

Proof. If there exist a ( i, j ) pair where q i = q j when i = j , then T q i ,i = 1 and T q j ,j = T q i ,j = 1 . This means q i -th row has two non-zero elements, which leads to a contradiction.

Lemma D.2. Consider graph G with n nodes, for any T ∈ R n × n with T i,j ≥ 0 , when each row and column in T have one value 1 (True) and n -1 value 0 (False). Then, each row and column in H also have one value 1 (True) and n -1 value 0 (False), which means each city corresponds to only one beginning point and one ending point.

̸

̸

Proof. First, it is clear that for ∀ a, b , H a,b ∈ Z ≥ 0 . Let's assume T a,l = T b,m = 1( a = b, l = m ) , since H i,j = ∑ n k =1 T i,k T j,k +1(mod n ) , we then have

This implies that the summation of each row in H is 1. Similarly,

This suggests the summation of each column in H is 1 . Since each element in H i,j ∈ Z ≥ 0 , we can then conclude that each row and column in H have one value 1 (True) and n -1 value 0 (False). Also, H ii = ∑ n k =1 T i,k +1(mod n ) T i,k = 0 , this indicates that the elements in the main diagonal of H are 0, which implies no self-loops.

As mentioned, the i -th row in H is the probability distribution of directed edges start from city i , and the j -th column is the probability distribution of directed edges end in city j . Because each row and column in H have one value 1 (True) element and H 's diagonal entries are all zero, this means that each city is the beginning point of one directed edge and is also the ending point of another different directed edge.

Lemma D.3. There is at least one cycle in H which contains n edges and visits all cities when each row and column in T have one value 1 (True) and n -1 value 0 (False).

1

k-1

k

k+1

n-1

n

1

2

3

4

n-1

n

̸

Proof. Lemma D.1 indicates that q i = q j when i = j and q i ∈ { 1 , 2 , 3 , 4 , ..., n } , then ∪ n i =1 q i = { 1 , 2 , 3 , 4 , ..., n } . From Equation 3, we have

̸

Using Lemma D.2, since each row and column in H have one value 1 (True) and n -1 value 0 (False), it suffices to show that 1 ≥ H q i ,q i +1 ≥ 1 , therefore H q i ,q i +1 = 1 . This suggests that there is a directed edge from city q i to q i +1 . We can then construct a cycle C from H , we can write C as

where → is a directed edge. Since ∪ n i =1 q i = { 1 , 2 , 3 , 4 , ..., n } , cycle C visits all n cities and have n edges. One example of how to build H q i ,q i +1 from T is shown in Figure 5.

Corollary D.4. H represents one Hamiltonian Cycle when each row and column in T have one value 1 (True) and n -1 value 0 (False).

Proof. From Lemma D.3, cycle C contains n edges and visits all cities, if there exists another edge ( i, j ) which does not belong to C , then city i is the starting point of at least two edges and city j is the ending point of at least two edges. This results in a contradiction with Lemma D.2. Thus, it suffices to conclude that C visits each city exactly once and H only contains the edges in C . This implies that H represents one Hamiltonian Cycle.

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper proposes UTSP, an unsupervised learning framework, to solve the Travelling Salesman Problem (TSP). It consists of two phases, including heat map construction and local searching. Specifically, a surrogate loss function is proposed to train the GNNs, encouraging the model to find the shortest path and respect the TSP constraint implicitly. The built heat map helps reduce the search space and facilitate the local search afterwards. Empirically, with only ~10\\% model parameters and ~0.2\\% training samples, UTSP is competitive with or outperforms baselines in terms of solution quality and inference time. The analyses about search space and smoothing effect are also conducted.\n\nSTRENGTHS:\n* The proposed method (in Section 2) is sound and novel. The theoretical proof (in Appendix) is correct.\n* Technically, the proposed method significantly reduces the model parameters and training samples. It does not need labeled data, and avoids the spare reward problem, making it more attractive to the SL and RL-based methods. \n* The empirical analyses of the non-smoothing heat map and reduced search space are interesting. \n* The source code is provided.\n\nWEAKNESSES:\n* The scope of this paper may be limited, since:\n  * The proposed method seems to be only applicable to TSP.\n  * Much domain knowledge is involved in the local search process.\n  * Too many hyperparameters in the proposed method.\n* The review of related work is *too limited*. Many recent works regarding neural methods for solving TSP are missing. It is suggested to add the related work section in Appendix.\n* The presentation of local search (in Section 3) is not clear. Could you illustrate the process using a figure?\n* The theory of the proposed method in Section 2 is quite interesting. However, there seems to be a gap between the theory and the proposed method. For example, the theory is based on the assumption that only one value 1 and $n-1$ value 0 in each row and column of $\\mathbb{T}$. However, the objective function does not exert an explicit constraint on the discreteness of $\\mathbb{T}$ or $\\mathcal{H}$. Based on the empirical result in Figure 5, the maximum value of $\\mathcal{H}$ is around 0.175. Have you considered adding a regularization term to achieve this objective? \n* Insufficient Evaluation:\n  * *Lack of Baselines:* Several recent end-to-end neural methods needed to be compared, including POMO [1], DIMES [2], and DIFUSCO [3].\n  * *Larger Size:* The evaluation of this paper is conducted on TSP1000 (maximally), while recent works [2, 3, 4] (also heat map based methods) consider TSP10000. It is interesting to see how your method performs on large-scale instances.\n  * *Lack of Benchmark Results:* Results on the classical TSP benchmark dataset (i.e. TSPLIB [5]) are needed.\n* Minor:\n  * The citation format is not correct. The authors could use ~\\cite{}.\n  * In line 57, \"does not\" -> \"our method does not\".\n  * In line 182, \"me thods\" -> \"methods\".\n  * Please change the blue and red colors in Fig. 7 and 8. The current version is indistinguishable.\n  * In line 414, the formulation should be $\\mathcal{H}\\_{i,i}=\\sum\\_{k=1}^{n}\\mathbb{T}\\_{i,k}\\mathbb{T}_{i,k+1(\\text{mod }n)}=0$.\n  * In the caption of Figure 9, add $q_{n-1}=1$.\n  * Remove the Checklist on Page 17.\n\n[1] POMO: Policy optimization with multiple optima for reinforcement learning. In NeurIPS 2020.\n\n[2] DIMES: A differentiable meta solver for combinatorial optimization problems. In NeurIPS 2022.\n\n[3] DIFUSCO: Graph-based diffusion solvers for combinatorial optimization. In arXiv:2302.08224.\n\n[4] Generalize a small pre-trained model to arbitrarily large tsp instances. In AAAI 2021.\n\n[5] http://comopt.ifi.uni-heidelberg.de/software/TSPLIB95\n\n----\n\n**Overall**, despite several limitations, I lean towards borderline acceptance since I like the idea of this paper. It would be a good submission if the authors resolve most of the concerns.\n\nQUESTIONS:\n* In line 72, why the weight matrix is set as $W_{i,j}=e^{-D_{i,j}/\\tau}$? I do not see any explanation.\n* In line 80, why do you use column-wise Softmax? How about row-wise Softmax, together with the column-wise constraint in Eq. (2)?\n* Could you add more details (e.,g., model structure) about the Scattering Attention GNN (SAG) in Appendix? Currently, it is unclear how to obtain $\\mathbb{T}$ using $W$ and $F$.\n\nLIMITATIONS:\nIt seems that the authors did not discuss the limitations of this work.\n\nNo negative societal impact.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-06-11"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe authors propose a continuous relaxation of the 2D Euclidian Travelling Salesman Problem. Specifically, they replace the combinatorial optimization problem with a continuous optimization problem of the form\n\n*Minimize f(A) over all column-stochastic matrices $A \\in \\mathbb R^{n \\times n}$*\n\nwhere $f$ is a smooth function and $A$ is a soft indicator matrix whose $t^{th}$ column indicate the city visited at step $t$ of the tour. The matrix $A$ is obtained via a deep net $A = \\phi_\\theta(X)$ where $X$ contains the position of the cities, therefore leading to a problem of the form\n\n*Minimize $f(\\phi_\\theta(X))$ over $\\theta$*\n\nwhich is optimized via SGD. From the soft indicator matrix $A$, the authors build a hard indicator matrix by performing a local search algorithm.\n\nThe proposed approach significantly differs from RL approaches, since it is based on optimizing a smooth objective. It is also significantly different from imitation learning approaches, in which a neural network is trained to imitate  the output of an accurate but slow solver (typically the Concorde algorithm, which is more or less the default TSP solver in the OR community).    \n\nThe proposed approach outperforms previous RL approaches and imitation learning approaches.\n\nSTRENGTHS:\n* The proposed approach is simple and outperforms previous deep learning methods when applied to large TSP instance. \n* The accuracy and sample efficiency achieved by the proposed approach are *very* impressive.\n* The TSP problem is an important and prototypical combinatorial optimization problem. The proposed approach, due to its simplicity and performance, has the potential of becoming quite influential.\n\nWEAKNESSES:\n1.  A more extensive discussion of the existing literature is needed. In particular, the authors should explain the method presented in [1], as it is the only one that achieves results comparable to the proposed approach.  I would recommend to have a `related work' subsection.\n\n2. The presentation could be improved. In particular I find that referring to the matrix $T$ as a transition matrix is very confusing. $H$ is a transition matrix, since $H_{ij}$ is to some extent the probability of moving from i to j. If I understand correctly the proposed relaxation, the $t^{th}$ column of $T$ is a probability distribution over the cities that indicates what is the city most likely to be visited at step $t$ of the tour. So I would refer to $T$ as a soft indicator matrix. The left side of Figure 3 is confusing: I take it as meaning that if $T$ is used as a transition matrix, then it leads to a non-Hamiltonian cycle. I think it is better to not encourage the reader to think of $T$ as a transition matrix. If $T=[p_1, \\ldots, p_n]$ is viewed as a soft indicator matrix that indicates the city visited at time $t$, then the formula for $H$ can be written as a sum of outer products\\\n$\n\\displaystyle H = \\sum_{t=1}^{n-1} p_{t} p_{t+1}^T + p_{n} p_{1}^T\n$\\\nfrom which it is clear that $H$ is a transition matrix. I think equation (1) and the displayed matrix $V$ are unnecessary and take lots space. Similarly, figure 1, 2 and 3 take lots of space and do not bring much clarity in my opinion. I think the space could be better used by describing related works in more depth, adding context for the experimental results (which are very impressive), and also maybe discussing continuous relaxations in general.  Overall, the proposed strategy is very simple (which I see as a strength): I think it could be presented in a  more concise and cleaner manner.\n\n3. The experimental section could be polished. I think it is important to explain what is the \"gap\" and the \"rounding problem\". (Also line 177 is hard to read, and the first paragraph is not well written.) \n\n\n\n\n\n[1] Zhang-Hua Fu, Kai-Bin Qiu, and Hongyuan Zha. Generalize a small pre-trained model to arbitrarily\n325 large tsp instances.\n\nQUESTIONS:\nQuestion1: On line 198 the authors write \n> We remark that the UTSP takes a shorter total running time (inference + search) and outperform the existing learning baselines on these large instance. \n\n I am confused: the algorithm from [1] seems faster. Is it not a learning baseline? Again, I think more discussion about [1] is needed.\n\n\nQuestion 2:  The GCN from Kipf and Welling is the `smoothest' GNN. Did you try other GNN/transformer architecture beyond SAG? \n\n[1] Zhang-Hua Fu, Kai-Bin Qiu, and Hongyuan Zha. Generalize a small pre-trained model to arbitrarily\n325 large tsp instances.\n\nLIMITATIONS:\nI did not find a paragraph about the limitation of the proposed approach. Overall this is a very strong work in my opinion. An honest explanation of the shortcomings of the proposed approach would improve the scientific contribution.", "TITLE": "Official Review", "RECOMMENDATION": 8, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 4, "DATE": "2023-06-22"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper proposed a novel unsupervised learning method for solving the Travelling Salesman Problem (TSP). It employs a Scattering Attention GNN (SAG) to encode the node information. Then, the learned representation is transformed into a heatmap, which corresponds to the probability of an edge being included in the optimal solution. A novel unsupervised loss is proposed. Based on the learned heatmap, a local search procedure with randomness is used to derive the final solution. Experiments on TSP instances up to 1000 nodes show that the proposed method can use much less training data, and outperforms several existing deep TSP models.\n\nSTRENGTHS:\n1. The research motivation is clear.\n\n2. The idea of using SAG to build heatmap, and the proposed unsupervised loss is interesting.\n\n3. Strong empirical performance, with detailed analysis on the expressive power of SAG. \n\n4. Generally good writing and organization.\n\nWEAKNESSES:\n1. Since the proposed method is heatmap based, I suggest to give a detailed review and discussion on heatmap based methods, such as [Fu2021], [Qiu2022], [Joshi2022]. Currently the introduction is mainly from the SL/RL perspective.\n\n2. For fair comprison, I suggest to add some ablation studies on the effect of local search. In the main results (Tables 1-3), it is unclear whether the performance improvement is from the better learning mechanism, or the local search procedure. In addition, the baselines use sampling, beam search and Monte carlo tree search as the decoding strategies, while the proposed method uses local search. This also makes it difficult to compare the effectiveness of the learning mechanism. While Figure 4, 5 and 6 provide some insights, they are still indirect results.\n\n3. The baselines are not up-to-date. It would be much stronger if state-of-the-art methods, such as DIMES [Qiu2022] (also a heatmap based method), could be compared.\n\n4. It is unclear how the training data is generated and whether the baselines are retrained. I guess they are not since GAT [Kool2019] and GCN [Joshi2019] is known to be hard to scale to problem of size 1000.\n\n5. More detailed results on the training efficiency (e.g., a table) could be helpful. Currently only an informal discussion is given on Page 6. \n\n6. The local search mechanism relies on randomness. But how it impacts the results is unclear, including how stable the performance is (std is helpful if reported), and what if no randomness is used.\n\n7. The runtime in Table 2 seems incorrect. For the baselines, most runtime for TSP200 is much faster than TSP100. For your approach, the runtime for TSP200 is faster than TSP50. Please thoroughly check the results.\n\n8. The proposed approach is currently limited to TSP. It would be better to have some discussions on how to extend it to other typical routing problems such as CVRP.\n\nQUESTIONS:\nPlease see the above weaknesses.\n\nLIMITATIONS:\nThe propossed approach is limited to TSP. But this is not a severe limitation since it obtains good results on large-scale problems. It would be better to have some discussions on how to generalize the idea to support other routing problems.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-06"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper proposes an unsupervised learning-based heuristic to solve the Travelling Salesman Problem. The approach consists of two steps: first a GNN is trained using a surrogate loss to output a heatmap of the edges then the heatmap is used to guide a local search heuristic. The proposed model has significantly less parameters than similar previous methods and its training is very efficient. It is tested on TSP instances with up to 1000 nodes.\n\nSTRENGTHS:\n1. The paper introduces a light-weight model and sample-efficient training procedure to learn a TSP heuristic\n1. Novel idea of a differentiable surrogate loss that encourages the solution to form a hamiltonian cycle \n1. Nice discussion and motivation of the choice of the GNN and precise comparison between GCN and SAG\n1. The paper is clear and easy to follow\n\nWEAKNESSES:\n1. The main weakness is the limited scope: the paper is very specialized to the TSP, esp. the proposed surrogate loss is specific to the TSP.\n1. Missing some related work: e.g. [1] and [2] and the associated baselines in the experiments. These are known to be much stronger baselines than the ones presented in Tables 1-3.\n1. Some unfounded claims:\n    * The paper says “Such SL models scale poorly to the big instances” while [Fu et al 2021] scales remarkably well to instances with up to 10,000. \n    * L198 “We remark that the UTSP takes a shorter total running time (inference + search) and outperform the existing learning baselines on these large instances. ” But the reported computation times are not shorter than Att-GCRN for TSP200 and TSP50.\n    * L216: “when using SL, the model learns from the TSP solutions, which fails when multiple solutions exist or the solutions are not optimal.” Is there any proof/reference to motivate this statement?\n    * L194 “On larger instances with n = 200, 500 and 1, 000, we notice that traditional solvers and heuristics (Concorde,Gurobi and LKH3) fail to generate the optimal solutions within reasonable time when the size of problems grows”. I’m not sure what is meant exactly, since we see for e.g. in Table 3 that LKH still gives the best optimality gap for TSP1000 in 38minutes. Then for Gurobi, I wonder what was the time limit. Since it is an exact solver, it is expected to be slow. However it should return the best solution it found when it reaches the time limit. Can the authors give more details about the results (or lack of) with Gurobi.\n1. The columns TSP200 in Tab 2 and TSP500 in Tab 3 look exactly the same. Is it a typo?\n1. Many components in the approach and there is only one kind of ablation for the choice of SAG versus GCN for the model architecture. It would be interesting to do precise ablations, esp. for the quality and role of the heatmap in the final results. For example by applying the same local search strategy with the heatmap obtained by other models such as the GCN approach of [Joshi et al 2019a] or the Att-GCRN of [Fu et al 2021].\n1. Experiments only on synthetic instances of the same distribution as training. Could be interesting to test on unseen distributions, e.g. TSPlib.\n\n\n[1] Qiu et al, DIMES: A Differentiable Meta Solver for Combinatorial Optimization Problems, NeurIPS 2022\n\n[2] Kwon et al POMO: Policy Optimization with Multiple Optima for Reinforcement Learning, NeurIPS 2020\n\nQUESTIONS:\n1. The paper says “Such SL models scale poorly to the big instances” while the approach of [Fu et al 2021] scales remarkably well to instances with up to 10,000. Maybe the authors meant *training* such SL models does not scale?\n\n1. Have the authors tried their model on even larger instances, such as TSP10000?\n\n1. Would the approach apply to the non-Euclidian asymmetric version of the TSP?\n\n1. It would be useful to discuss how the temperature parameter (L73) and the number M (of elements to keep in each row of the heatmap) are fixed. In particular, how is the search space reduction (Sec. 5) affected by the choice of M?\n\n1. L156 “when selecting the city v given u , we only consider the cities from the candidate set of v” —> do you mean the candidate set of *u* instead?\n\n1. “the negative values are the results of the rounding problem” can the authors elaborate on what is meant by the rounding problem?\n\nLIMITATIONS:\nThe limitations are not explicitly mentioned in the paper.", "TITLE": "Official Review", "RECOMMENDATION": 4, "REVIEWER_CONFIDENCE": 5, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-07-11"}