SlowGuess/NeurIPS_2023_OCR huggingface dataset:
Yimeng Min*
Dept. of Computer Science
min@cs.cornell.edu
Yiwei Bai*
bywbilly@gmail.com
Carla P. Gomes
gomes@cs.cornell.edu
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.
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.
In this paper, we study symmetric TSP on a 2D plane. Given  $n$  cities and the coordinates  $(x_i, y_i) \in \mathbb{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 \in \{1, 2, 3, \dots, n\}$  is the index of the city.
3.1 Graph Neural Network
Given a TSP instance, let  $\mathbf{D}_{i,j}$  denote the Euclidean distance between city  $i$  and city  $j$ .  $\mathbf{D} \in \mathbb{R}^{n \times n}$  is the distance matrix. We first build adjacency matrix  $\mathbf{W} \in \mathbb{R}^{n \times n}$  with  $\mathbf{W}_{i,j} = e^{-\mathbf{D}_{i,j} / \tau}$  and node feature  $\mathbf{F} \in \mathbb{R}^{n \times 2}$  based on the input coordinates, where  $\mathbf{F}_i = (x_i, y_i)$  and  $\tau$  is the temperature. The node feature matrix  $\mathbf{F}$  and the weight matrix  $\mathbf{W}$  are then fed into a GNN to generate a soft indicator matrix  $\mathbb{T} \in \mathbb{R}^{n \times 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 \in \mathbb{R}^{n \times 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  $\mathbb{T}_{i,j} = e^{\mathcal{S}_{i,j}} / \sum_{k=1}^{n} e^{\mathcal{S}_{k,j}}$ .
This ensures that each element in  $\mathbb{T}$  is greater than zero and the summation of each column is 1. We then use  $\mathbb{T}$  to build a heat map  $\mathcal{H}$ , where  $\mathcal{H} \in \mathbb{R}^{n \times n}$ .
In our model, we use  $\mathcal{H}$  to estimate the probability of each edge belonging to the optimal solution and use  $\mathbb{T}$  to build a surrogate loss of the Hamiltonian Cycle constraint. This will allow us to build a non-smooth heat map  $\mathcal{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  $\mathcal{H}$ . To address this, we introduce the  $\mathbb{T} \to \mathcal{H}$  transformation, which enables the model to implicitly encode the Hamiltonian Cycle constraint.
Figure 1: We use a SAG to generate a non-smooth soft indicator matrix  $\mathbb{T}$ . The SAG model is a function of coordinates and weighted adjacency matrix. We then build the heat map  $\mathcal{H}$  based on  $\mathbb{T}$  using the transformation in Equation 1.
To better understand the  $\mathbb{T} \to \mathcal{H}$  transformation, we show a binary instance in Figure 1. Figure 1 illustrates a soft indicator matrix  $\mathbb{T}$ , its heat map  $\mathcal{H}$  following the transformation  $\mathbb{T} \to \mathcal{H}$ , and their corresponding routes. When we directly use the soft indicator matrix  $\mathbb{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  $\mathbb{T} \to \mathcal{H}$  transformation, the corresponding heat  $\mathcal{H}$  is a Hamiltonian Cycle, as shown in the right part in Figure 1.
3.3  $\mathbb{T}\to \mathcal{H}$  transformation
We build the heat map  $\mathcal{H}$  based on  $\mathbb{T}$ . As mentioned,  $\mathcal{H}_{i,j}$  is the probability for edge  $(i,j)$  to belong to the optimal TSP solution. We define  $\mathcal{H}$  as:
$$
\mathcal {H} = \sum_ {t = 1} ^ {n - 1} p _ {t} p _ {t + 1} ^ {T} + p _ {n} p _ {1} ^ {T}, \tag {1}
$$
where  $p_t \in \mathbb{R}^{n \times 1}$  is the  $t_{th}$  column of  $\mathbb{T}$ ,  $\mathbb{T} = [p_1|p_2|\dots|p_n]$ . As shown in Figure 1, the first row in  $\mathcal{H}$  is the probability distribution of directed edges from city 1, and since the third element is the only non-zero one in the first row, we then add directed edge  $1 \rightarrow 3$  to our TSP solution. Similarly, the first column in  $\mathcal{H}$  can be regarded as the probability distribution of directed edges which end in city 1. Ideally, given a graph  $\mathcal{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  $\mathbb{T}$  whose heat map  $\mathcal{H}$  assigns large probabilities to the edges in the TSP solution and small probabilities to the other edges.
Overall, the  $\mathbb{T} \to \mathcal{H}$  transformation in Equation 1 enables us to build a proxy for the Hamiltonian Cycle constraint. We further prove that  $\mathcal{H}$  represents one Hamiltonian Cycle when each row and column in  $\mathbb{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  $\mathbb{T}$ , we minimize the following objective function:
$$
\mathcal {L} = \lambda_ {1} \underbrace {\sum_ {i = 1} ^ {n} \left(\sum_ {j = 1} ^ {n} \mathbb {T} _ {i , j} - 1\right) ^ {2}} _ {\text {R o w - w i s e c o n s t r a i n t}} + \lambda_ {2} \underbrace {\sum_ {i} ^ {n} \mathcal {H} _ {i , i}} _ {\text {N o s e l f - l o o p s}} + \underbrace {\sum_ {i = 1} ^ {n} \sum_ {j = 1} ^ {n} \mathbf {D} _ {i , j} \mathcal {H} _ {i , j}} _ {\text {M i n i m i z e t h e d i s t a n c e}}. \tag {2}
$$
The first term in  $\mathcal{L}$  encourages the summation of each row in  $\mathbb{T}$  to be close to 1. As mentioned, we normalize each column of  $\mathbb{T}$  using Softmax activation. So when the first term is minimized to zero, each row and column in  $\mathbb{T}$  are normalized (doubly stochastic). The second term penalizes the weight on the main diagonal of  $\mathcal{H}$ , this discourages self-loops in TSP solutions. The third term can be regarded as the expected TSP length of the heat map  $\mathcal{H}$ , where  $\mathbf{D}_{i,j}$  is the distance between city  $i$  and  $j$ . As mentioned, since  $\mathcal{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  $\sum_{i = 1}^{n}\sum_{j = 1}^{n}\mathbf{D}_{i,j}\mathcal{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  $\sum_{i = 1}^{n}\sum_{j = 1}^{n}\mathbf{D}_{i,j}\mathcal{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  $\mathbb{T}\rightarrow \mathcal{H}$  transformation.
3.5 Edge Elimination
Given a heat map  $\mathcal{H}$ , we consider  $M$  largest elements in each row (without diagonal elements) and set other  $n - M$  elements as 0. Let  $\tilde{H}$  denote the new heat map, we then symmetrize the new heat map by  $\mathcal{H}' = \tilde{H} + \tilde{H}^T$ . Let  $\mathbf{E}_{ij} \in \{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 \leq n$  and define  $\mathbf{E}_{ij}$  as:
$$
\mathbf {E} _ {i j} = \left\{ \begin{array}{l l} 1, & \text {i f} \mathcal {H} _ {i j} ^ {\prime} = \mathcal {H} _ {j i} ^ {\prime} > 0 \\ 0, & \text {o t h e r w i s e} \end{array} \right..
$$
Let  $\Pi$  denote the set of undirected edges  $(i,j)$  with  $\mathbf{E}_{ij} = 1$ . Ideally, we would build a prediction edge set  $\Pi$  with a small  $M$  value, and  $\Pi$  can cover all the ground truth edges so that we can reduce search space size from  $n(n - 1)/2$  to  $|\Pi|$ . In practice, we aim to let  $\Pi$  cover as many ground truth edges as possible and use  $\mathcal{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(\text{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}, \ldots, 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 \leq i \leq k$ ) are removed from the tour and  $(v_{i}, u_{i+1})(1 \leq i \leq 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 \geq 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 \geq 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} = \mathcal{H}_{u,v}' + \alpha \sqrt{\frac{\log(S+1)}{N_{u,v}+1}}$ , where  $\alpha$  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  $\mathcal{H}'$  is updated as:
$$
\mathcal {H} _ {v _ {i}, u _ {i + 1}} ^ {\prime} = \mathcal {H} _ {v _ {i}, u _ {i + 1}} ^ {\prime} + \beta [ \exp (\frac {L (s) - L \left(s ^ {\prime}\right)}{L (s)}) - 1 ],
$$
where  $\beta$  is a search parameters and  $(v_{i},u_{i + 1})(1\leq i\leq k)$  is the actions used to transform  $s$  to  $s^{\prime}$ . 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.
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.
Table 1: Results of SAG + Local Search w.r.t. existing baselines. We evaluate the models on 10,000 TSP 20 instances and 10,000 TSP 50 instances. Baselines include GAT-RL1: Deudon et al. [2018]; GAT-RL2: Kool et al. [2019]; GCN-SL1: Joshi et al. [2019a]; POMO: Kwon et al. [2020] and AttGCRN Fu et al. [2021].
Method	Type	TSP20	TSP50
Length	Gap (%)	Time	Length	Gap (%)	Time
Concorde	Solver	3.8303	0.0000	2.31m	5.6906	0.0000	13.68m
Gurobi	Solver	3.8302	-0.0001	2.33m	5.6905	0.0000	26.20m
LKH3	Heuristic	3.8303	0.0000	20.96m	5.6906	0.0008	26.65m
GAT-RL1	RL, S	3.8741	1.1443	10.30m	6.1085	7.3438	19.52m
GAT-RL1	RL, S	3.8501	0.5178	15.62m	5.8941	3.5759	27.81m
2-OPT
GAT-RL2	RL, S	3.8322	0.0501	16.47m	5.7185	0.4912	22.85m
GAT-RL2	RL, G	3.8413	0.2867	6.03s	5.7849	1.6568	34.92s
GAT-RL2	RL, BS	3.8304	0.0022	15.01m	5.7070	0.2892	25.58m
GCN-SL1	SL, G	3.8552	0.6509	19.41s	5.8932	3.5608	2.00m
GCN-SL1	SL, BS	3.8347	0.1158	21.35m	5.7071	0.2905	35.13m
GCN-SL1	SL, BS*	3.8305	0.0075	22.18m	5.6920	0.0251	37.56m
POMO	RL	3.83	0.00	3s	5.69	0.03	16s
Att-GCRN	SL+RL	3.8300	-0.0074	23.33s + 1.05m	5.6908	0.0032	2.59m + 2.63m
MCTS
UTSP (ours)	UL, Search	3.8303	-0.0009	38.23s + 1.04m	5.6894	-0.0200	1.34m+ 2.60m
Table 2: Results of SAG + Local Search w.r.t. existing baselines. We evaluate the models on 10,000 TSP 100 instances and 128 TSP 200 instances. Baselines include GAT-RL1: Deudon et al. [2018]; GAT-RL2: Kool et al. [2019]; GCN-SL1: Joshi et al. [2019a]; POMO: Kwon et al. [2020] and AttGCRN Fu et al. [2021].
Method	Type	TSP100	TSP200
Length	Gap (%)	Time	Length	Gap (%)	Time
Concorde	Solver	7.7609	0.0000	1.04h	10.7191	0.0000	3.44m
Gurobi	Solver	7.7609	0.0000	3.57h	10.7036	-0.1446	40.49m
LKH3	Heuristic	7.7611	0.0026	49.96m	10.7195	0.0040	2.01m
GAT-RL1	RL, S	8.8372	13.8679	47.78m	13.1746	22.9079	4.84m
GAT-RL1	RL, S	8.2449	6.2365	4.95h	11.6104	8.3159	9.59m
2-OPT
GAT-RL2	RL, S	7.9735	2.7391	1.23h	11.4497	6.8160	4.49m
GAT-RL2	RL, G	8.1008	4.3791	1.83m	11.6096	8.3081	5.03s
GAT-RL2	RL, BS	7.9536	2.4829	1.68h	11.3769	6.1364	5.77m
GCN-SL1	SL, G	8.4128	8.3995	11.08m	17.0141	58.7272	59.11s
GCN-SL1	SL, BS	7.8763	1.4828	31.80m	16.1878	51.0185	4.63m
GCN-SL1	SL, BS*	7.8719	1.4299	1.20h	16.2081	51.2079	3.97m
POMO	RL	7.77	0.14	1m	-	-	-
Att-GCRN	SL+RL MCTS	7.7616	0.0096	3.94m + 5.25m	10.7358	0.1563	20.62s + 1.33m
UTSP (ours)	UL, Search	7.7608	-0.0011	5.68m + 5.21m	10.7289	0.0918	0.56m+ 1.11m
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.
Table 3: Results of SAG + Local Search w.r.t. existing baselines. We evaluate the models on 128 TSP 500 instances and 128 TSP 1000 instances. Baselines include GAT-RL1: Deudon et al. [2018]; GAT-RL2: Kool et al. [2019]; GCN-SL1: Joshi et al. [2019a]; DIMES: Qiu et al. [2022]; DIFUSCO: Sun and Yang [2023] and Att-GCRN Fu et al. [2021].
Method	Type	TSP500	TSP1000
Length	Gap (%)	Time	Length	Gap (%)	Time
Concorde	Solver	16.5458	0.0000	37.66m	23.1182	0.0000	6.65h
Gurobi	Solver	16.5171	-0.1733	45.63h	-	-	-
LKH3	Heuristic	16.5463	0.0029	11.41m	23.1190	0.0036	38.09m
GAT-RL1	RL, S	28.6291	73.0293	20.18m	50.3018	117.5860	37.07m
GAT-RL1	RL, S	23.7546	43.5687	57.76m	47.7291	106.4575	5.39h
2-OPT
GAT-RL2	RL, S	22.6409	36.8382	15.64m	42.8036	85.1519	63.97m
GAT-RL2	RL, G	20.0188	20.9902	1.51m	31.1526	34.7539	3.18m
GAT-RL2	RL, BS	19.5283	18.0257	21.99m	29.9048	29.2359	1.64h
GCN-SL1	SL, G	29.7173	79.6063	6.67m	48.6151	110.2900	28.52m
GCN-SL1	SL, BS	30.3702	83.5523	38.02m	51.2593	121.7278	51.67m
GCN-SL1	SL, BS*	30.4258	83.8883	30.62m	51.0992	121.0357	3.23h
DIMES	RL+S	18.84	13.84	1.06m	26.36	14.01	2.38m
DIMES	RL+MCTS	16.87	1.93	2.92m	23.73	2.64	6.87m
DIMES	RL+AS+MCTS	16.84	1.76	2.15h	23.69	2.46	4.62h
DIFUSCO	SL+MCTS	16.63	0.46	10.13m	23.39	1.17	24.47m
Att-GCRN	SL+RL MCTS	16.7471	1.2169	31.17s + 3.33m	23.5153	1.7179	43.94s + 6.68m
UTSP (Ours)	UL, Search	16.6846	0.8394	1.37m + 1.33m	23.3903	1.1770	3.35m+ 2.67m
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  $\mathcal{H}$ ) and the search time (running search algorithm).