Neural Solver Selection for Combinatorial Optimization

## Abstract

Abstract Machine learning has increasingly been employed to solve NP-hard combinatorial optimization problems, resulting in the emergence of neural solvers that demonstrate remarkable performance, even with minimal domain-specific knowledge. To date, the community has created numerous open-source neural solvers with distinct motivations and inductive biases. While considerable efforts are devoted to designing powerful single solvers, our findings reveal that existing solvers typically demonstrate complementary performance across different problem instances. This suggests that significant improvements could be achieved through effective coordination of neural solvers at the instance level.
In this work, we propose the first general framework to coordinate the neural solvers, which involves feature extraction, selection model, and selection strategy, aiming to allocate each instance to the most suitable solvers. To instantiate, we collect several typical neural solvers with state-of-the-art performance as alternatives, and explore various methods for each component of the framework. We evaluated our framework on two extensively studied combinatorial optimization problems, Traveling Salesman Problem (TSP) and Capacitated Vehicle Routing Problem (CVRP). Experimental results show that the proposed framework can effectively distribute instances and the resulting composite solver can achieve significantly better performance (e.g., reduce the optimality gap by 0.88% on TSPLIB and 0.71% on CVRPLIB) than the best individual neural solver with little extra time cost. Our code is available at https://github.com/lamda-bbo/neural-solver-selection .

## 1 Introduction

Combinatorial Optimization Problems (COPs) involve finding an optimal solution over a set of combinatorial alternatives, which has broad and important applications such as logistics (Konstantakopoulos et al., ) and manufacturing (Zhang et al., ). To solve COPs, traditional approaches usually depend on heuristics designed by experts, requiring extensive domain knowledge and considerable effort. Recently, machine learning techniques have been introduced to automatically discover effective heuristics for COPs (Bengio et al., ; Cappart et al., ), leading to the burgeoning development of end-to-end neural solvers that employ deep neural networks to generate solutions for problem instances (Bello et al., ; Kool et al., ; Joshi et al., ). Compared to traditional approaches, these end-to-end neural solvers can not only get rid of the heavy reliance on expertise, but also realize better inference efficiency (Bello et al., ).

To enhance the capabilities of neural solvers, a variety of methods have been proposed, with intensive effort on the design of frameworks, network architectures, and training procedures. For example, to improve the performance across different distributions, Jiang et al. () proposed adaptively joint training over varied distributions, and Bi et al. () leveraged knowledge distillation to integrate the models trained on different distributions. For generalization on large-scale instances, Fu et al. () implemented a divide-and-conquer strategy, Luo et al. () proposed a heavy-decoder structure to better capture the relationship among nodes, while Gao et al. () utilized the local transferability and introduced an additional local policy model. Diffusion models (Sun & Yang, ) have also been adapted to generate the distribution of optimal solutions, demonstrating impressive results. More works include bisimulation quotienting (Drakulic et al., ), latent space search (Chalumeau et al., ), local reconstruction (Cheng et al., ; Ye et al., ; Zheng et al., ) and so on.

Figure: (a) Percentages of Winning
Refer to caption: x1.png

As various neural solvers are emerging in the community, the state-of-the-art records for the overall performance on benchmark problems are frequently refreshed. However, the detailed comparison of these neural solvers on each instance has been rarely discussed. Here, we empirically examined the performance of several prevailing neural solvers on each instance, as illustrated in Figure 1(a) and 1(b). As expected from the no-free-lunch theorem (Wolpert & Macready, ), we find that

- •
As shown in Figure 1(a), there exists no single neural solver that can dominate all the other neural solvers on every instance, and different neural solvers win on different instances, demonstrating their complementary performance at instance level.
- •
As shown in Figure 1(b), the modification of instance distribution can almost reverse the domination relationship of neural solvers, which further verifies that different neural solvers are good at instances with specific characteristics due to their intrinsic inductive biases.

These observations suggest that it may potentially bring impressive improvements to the overall performance, if multiple neural solvers are coordinated to solve instances together. In fact, recent works have already made preliminary attempts from the perspective of ensemble learning (Jiang et al., ) and population-based training (Grinsztajn et al., ). However, their individual solvers share the same architecture, resulting in limited diversity. On the other hand, as all of the individual solvers should run during inference, these methods can hardly achieve ideal efficiency.

Motivated by the observations above, we, for the first time, propose a general framework to coordinate end-to-end neural solvers for COPs at instance level by selecting suitable individual solvers for each instance, as illustrated in Figure 1(c). Specifically, our proposed framework consists of three key components, which are summarized as follows:

- •
Feature extraction: For each problem instance, extract features that can be effectively used to identify their characteristics.
- •
Selection model: Based on the features of instances, train a selection model that can be utilized to identify suitable solvers for each instance.
- •
Selection strategy: Due to the intricate structures of COPs, using only the most suitable individual solver predicted by the selection model may fail. Therefore, it is important to design robust selection strategies based on the confidence of the selection model.

To verify the effectiveness of our proposed framework, we collect several prevailing open-source neural solvers and their released models with competitive performance in the community to construct the pool of individual solvers, and provide several implementations for each component of the framework. For feature extraction, we utilize the graph attention network (Veličković et al., ; Kool et al., ) to encode COP instances, and further propose a refined encoder with pooling to leverage the hierarchical structures of COPs. For selection model, we train it from the perspective of classification and ranking, respectively. We also implement several selection strategies, including top-$k$ selection, rejection-based selection, and so on. Detailed descriptions are provided in Section 3. We conduct experiments on two widely studied COPs: Traveling Salesman Problem (TSP) and Capacitated Vehicle Routing Problem (CVRP).
Experimental results exhibit that our framework can generally select suitable individual solvers for each instance to achieve significantly better performance with limited extra time consumption. Compared to the best individual solver, our framework reduces the optimality gap by 0.82% on synthetic TSP, 2.01% on synthetic CVRP, 0.88% on TSPLIB (Reinelt, ), and 0.71% on CVRPLIB Set-X (Uchoa et al., ). As this is the first preliminary attempt on neural solver selection for COPs, we also analyze the influence of various implementations of components, and provide some discussion on future improvements.

## 2 Related works

### 2.1 End-to-end neural solvers for COPs

Traditional approaches for COPs have achieved impressive results, but they often rely on problem-specific heuristics and domain knowledge by experts (Helsgaun, ; ). Instead, recent efforts focus on utilizing end-to-end learning methods. A prominent fashion is autoregression, which employs graph neural networks in an encoder-decoder framework and progressively extends a partial solution until a complete solution is constructed (Vinyals et al., ; Bello et al., ; Kool et al., ). However, these methods tend to exhibit poor generalization performance across distributions and scales (Joshi et al., ). To address the generalization issue, considerable efforts have been dedicated within the community. For example, Zhou et al. () took various distributions and scales as different learning tasks and adopted meta-learning over them to obtain a generalizable model. Bi et al. () leveraged knowledge distillation, where models trained on different distributions are utilized as teacher models for one generalizable student model. Liu et al. () used the idea of prompt learning to realize zero-shot adaptation of the pertained model by selecting the most matched prompt for instances. More efforts in autoregressive methods include instance-conditioned adaptation (Zhou et al., ), adversarial training (Wang et al., ) and nested local views (Fang et al., ), to name a few.

Another popular kind of end-to-end learning methods is non-regressive, which predicts or generates the distributions of potential solutions. Typically,  Joshi et al. (); Ye et al. () employed graph neural networks to predict the probability of components appearing in an optimal solution, represented with the form of heatmap. Diffusion models (Sun & Yang, ; Sanokowski et al., ) have also been adapted to generate the distribution of optimal solutions, demonstrating better expressiveness than classical push-forward generative models (Salmona et al., ).

### 2.2 Solving COPs with multiple neural solvers

Recent studies have made preliminary attempts to integrate multiple neural solvers to enhance overall performance on COPs. For example, Jiang et al. () adopted ensemble learning, where multiple neural solvers with identical architecture are trained on different instance distributions through Bootstrap sampling to ensure diversity. During inference, the outputs of all the solvers are gathered by average at each action step. Grinsztajn et al. () proposed a population-based training method Poppy, where multiple decoders with a shared encoder are trained simultaneously as a population of solvers, with a reward targeting at maximizing the overall performance of the population. When solving a problem instance, each solver generates solutions independently, and the best solution is selected as the final result. However, these works suffer from heavy computation cost as multiple solvers have to be run for each instance. Even they propose to share a common encoder for each solver, experimental results still demonstrate undesired inference time (Grinsztajn et al., ). On the other hand, different solvers share the same neural architecture, which may limit the diversity and thus the final performance.

Consider that the burgeoning community has proposed many methods from various perspectives, resulting in diverse end-to-end neural solvers with different inductive biases. Properly coordinating these neural solvers can potentially bring a significant improvement on overall performance. Motivated by the observation in Figure 1(a) and 1(b), we propose to select suitable ones from a pool of diverse individual solvers for each instance. Note that similar idea has been utilized in the area of algorithm selection (Kerschke et al., ) and model selection (Zhang et al., ), but has never been explored in the area of neural combinatorial optimization. By solver selection at instance level, any type of (existing or newly constructed) neural solver can be utilized, and only the selected individual solvers need to be run in inference, thereby maintaining high efficiency.

## 3 The proposed framework

This section will introduce the proposed framework of coordinating neural solvers for COPs. In general, our target is learning to select the suitable solvers for each problem instance. To address this, our proposed framework comprises three key components:

- •
Feature extraction: To select the most suitable neural solvers for each instance, it is essential to extract the instance features, which is challenging as the COPs are usually intricate. In this work, we first utilize the graph attention encoder (Kool et al., ) to encode COP instances, and further propose a refined graph encoder with pooling, which can leverage the hierarchical structures of COPs to obtain better features.
- •
Selection model: We train a neural selection model with the graph encoder to identify the most suitable solvers. Specifically, we implement two loss functions from the perspectives of classification and ranking.
- •
Selection strategies: Due to the complexity of COPs, it may be risky to rely solely on the selection model to consistently identify the most suitable solver. To address this, we propose compromise strategies that allow to allocate multiple solvers (if necessary) to a single instance based on the confidence levels of the selection model, pursuing better performance with limited extra cost.

In the following subsections, we will elaborate the three key components in our framework.

### 3.1 Feature extraction

For feature extraction, it depends on the COP to be solved. Here, we use the two most prevailing problems, TSP and CVPR, in the neural solver community for COPs (Kwon et al., ; Luo et al., ; Drakulic et al., ) as examples, which will also be employed in our experiments. TSP and CVRP involve finding optimal routes over a set of nodes. For TSP, the objective is to find the shortest possible route that visits each node exactly once and returns to the starting node. Each TSP instance consists of nodes distributed in Euclidean space. For CVRP, the goal is to plan routes for multiple vehicles to serve customer nodes with varying demands, starting and ending at a depot node, while minimizing the total travel distance and satisfying vehicle capacity constraints (Dantzig & Ramser, ).
Both TSP and CVRP instances can be represented as fully connected graphs, where nodes correspond to locations (cities or customers). The graph representation makes them suitable for encoding using Graph Neural Networks (GNNs), which can effectively capture the structural information inherent in these problems (Khalil et al., ; Kool et al., ).
In this paper, we design two types of GNN-based encoders tailored for TSP and CVRP instances as follows.

#### Graph attention encoder.

We take the CVRP as an example to describe the computation of the graph encoder.
The raw features $\bm{x}\in\mathbb{R}^{N\times 3}$ of a CVRP instance are a set of nodes $\{(x_{i},y_{i},m_{i})|i\in[N]\}$, where $(x_{i},y_{i})$ are the node coordinates, $m_{i}$ is the node demand, $N$ is the number of nodes, and $[N]$ denotes the set $\{1,2,\ldots,N\}$. First, a linear layer is employed on every node for initial node embeddings, i.e., $H^{0}=\bm{x}W$, where $W\in\mathbb{R}^{3\times d}$ are the weights and $d$ denotes the embedding dimension. Given initial embeddings, multiple graph attention layers (Veličković et al., ; Kool et al., ) are applied to iteratively update the node embeddings as $H^{l}=\text{AttentionLayer}^{l}(H^{l-1})$, where $l\in[L]$ and $L$ is the number of layers. Since the graphs of TSP and CVRP are both fully connected, the graph attention layer covers every pair of nodes and self-connections, which becomes similar to the self-attention mechanism (Vaswani et al., ). Details of the attention layer are provided in Appendix A.1.
Finally, the node embeddings output by the last layer are averaged to form the instance representation, as most COP encoders (Khalil et al., ; Kool et al., ) did.

#### Hierarchical graph encoder.

Averaging the final node embeddings may result in sub-optimal instance representations that are too flat to effectively capture the hierarchical structures inherent in COPs (Goh et al., ). Inspired by (Lee et al., ), we design a hierarchical graph attention encoder to address this limitation, which successively downsamples the graph of an instance using graph pooling, and aggregates features from each downsampling level to construct a comprehensive graph representation, as illustrated in Figure 2.

Figure: Figure 2: Illustration of the hierarchical graph encoder.
Refer to caption: x4.png

The hierarchical graph encoder contains $L$ blocks. In each block, several graph attention layers are first applied, and then the graph pooling layer selects representative nodes to form a coarsened graph that preserves important features. Consider the $l$-th block, where the number of selected nodes is denoted as $N_{l}$. To quantify the representativeness of each node for graph pooling, an additional graph attention layer is introduced to compute representative scores. Specifically, this graph attention layer computes score embeddings $H^{l}_{\text{score}}$ based on the current node embeddings $H^{l}$, which encode rich information about the graph structure and node features. These score embeddings $H^{l}_{\text{score}}$ are then mapped to scalar representative scores via linear layer. The complete process is shown as follows:

$$ $H^{l}_{\text{score}}=\text{AttentionLayer}^{l}_{\text{score}}(H^{l}),\;\;Z^{l} =\sigma(H^{l}_{\text{score}}W^{l}_{\text{score}}),$ $$

where $Z^{l}\in\mathbb{R}^{N^{l-1}\times 1}$ are the representative scores of the $N^{l-1}$ nodes preserved in the $(l-1)$-th block, $\sigma$ is a non-linear function (here we use the $\tanh$ function), and $W^{l}_{\text{score}}\in\mathbb{R}^{d\times 1}$ are the parameters of the linear layer. Subsequently, we sort the nodes according to their representative scores and select top-$N^{l}$ nodes ($N^{l}<N^{l-1}<N$) to preserve.
To make this pooling layer trainable via back-propagation (LeCun et al., ), we further combine the representative score together with the embeddings of their corresponding nodes as follows:
$\tilde{H}^{l}=H^{l}+Z^{l}\bm{1}$, where $\bm{1}\in\mathbb{R}^{1\times d}$ is a vector with all the elements being $1$. Intuitively, this operation can move the embeddings of high scored nodes away from the embeddings of low scored nodes.

Figure 2 shows the complete encoder, where $L$ blocks are stacked, and each block is formed by several graph attention layers followed by a pooling layer. By successively applying $L$ encoder blocks, the number of preserved nodes gradually decreases according to $N^{l}=\alpha\cdot N^{l-1}$ ($\alpha$ is set to 0.8 in our experiments). This process constructs a hierarchy of the original graph and its coarsened versions, enabling the encoder to capture multi-level structural information effectively. Within each block, we apply a readout layer that aggregates the embeddings after the graph attention layers by mean pooling and max pooling (Lee et al., ), i.e.,

$$ $\bm{o}^{l}=\sigma(\text{Mean}(H^{l})\|\text{Max}(H^{l})),$ $$

where $\text{Mean}()$ computes the average embedding over the nodes, $\text{Max}()$ computes the maximum along the column dimension, $\|$ denotes concatenation, and $\sigma$ is a non-linear function. The result $\bm{o}^{l}$ provides the representation of the $l$-th coarsened graph. At the last layer, we also readout $\bm{o}^{L+1}$ from the final embeddings. To form the hierarchical instance representation, we sum the representations of all levels as $\bm{o}=\sum_{l=1}^{L+1}\bm{o}^{l}$.

### 3.2 Selection model

We employ a Multiple-Layer Perception (MLP) to predict compatibility scores of neural solvers, where a higher score indicates that it is more suitable to allocate the instance to the corresponding neural solver.
This MLP model takes the instance representation and the instance scale $N$ as input and outputs a score vector, where the value of each index is the score of the corresponding neural solver. In summary, the graph encoder and the MLP are cascaded to compose a neural selection model, which can produce the compatibility scores of individual solvers from the raw COP instance in an end-to-end manner. Advanced neural solver features can be incorporated for richer information, as discussed in Section 5. However, we find that even using fixed indices of neural solvers has already been effective, which will be clearly shown in our experiments.

We train the selection model using a supervised dataset comprising thousands of synthetic COP instances. The objective values obtained by the neural solvers are recorded as supervision information. Intuitively, a neural solver with a lower objective value (for minimization) has a higher compatibility score. To learn such desired score output, we employ two losses from the perspectives of classification and ranking.

#### Classification.

The selection problem is formulated as a classification task, where the most suitable neural solver for a given instance serves as the ground truth label. By employing classification loss functions such as cross-entropy loss used in our experiments, we can train a selection model. However, this approach focuses on identifying the optimal neural solver and ignores sub-optimal solvers, which may lead to unsatisfactory performance when the selection is inaccurate.

#### Ranking.

The neural solvers can be sorted according to the objective values they obtain, thereby forming a ranking of the given solvers, denoted by $\phi:[M]\rightarrow[M]$, where $\phi(i)$ is the index of the rank-$i$ solver and $M$ is the number of solvers. We then train the selection model by maximizing the likelihood of producing correct rankings based on the computed scores (Xia et al., ),

$$ $\max_{\theta}\mathbb{E}_{I}[\sum_{i=1}^{M}\log\frac{\exp(g_{\theta}(I)_{\phi_{ I}(i)})}{\sum_{j=i}^{M}\exp(g_{\theta}(I)_{\phi_{I}(j)})}],$ $$

where $g_{\theta}$ denotes the selection model with parameters $\theta$, $I$ denotes a problem instance, and $\phi_{I}$ is the ground-truth ranking on instance $I$. This ranking loss can leverage the dominance relationship of all neural solvers, including sub-optimal ones, which thus can make the selection more robust.

### 3.3 Selection strategies

Considering that the intricate structures of COPs may pose great challenge to the selection model, besides greedy selection, we propose several compromise strategies that allow multiple solvers for a single instance based on the confidence level of the selection model, aiming to improve the overall performance with little extra cost.

#### Greedy selection.

The most straightforward approach is the greedy selection, which chooses the neural solver with the highest score. This method is efficient since only one solver is executed per instance. However, it may be inaccurate, potentially leading to sub-optimal performance.

#### Top- k 𝑘 k italic_k selection.

The top-$k$ selection method can be adopted for better optimality, where we select and execute the neural solvers with top-$k$ scores for each instance, thus constructing a portfolio of multiple solvers. This approach increases the likelihood of including the optimal solver but incurs additional computational overhead due to the execution of multiple solvers.

#### Rejection-based selection.

To balance efficiency and effectiveness, we propose the rejection-based selection strategy, which adaptively selects greedy or top-$k$ selection. Recognizing that the confidence of the greedy selection varies across instances, an advanced strategy is to employ the top-$k$ selection for low-confidence instances to enhance performance and utilize only the greedy selection for high-confidence ones to minimize computational cost.
To implement this strategy, we can use a confidence measure to determine whether to accept or reject the greedy selection. If the confidence in the greedy selection is below a threshold, we reject it and apply the top-$k$ selection to the instance for improved optimality. In this paper, we adopt the simple yet effective softmax response (Hendrycks & Gimpel, ) as the confidence measure, and define the threshold by rejecting a certain fraction of test instances with the lowest confidence levels.

#### Top- p 𝑝 p italic_p selection.

We further propose a top-$p$ selection strategy that selects the smallest subset of solvers whose normalized scores (i.e., selection probabilities) sum up to at least $p$. The value of $p$ is predefined or adjusted according to the time budget. Thus, this strategy adaptively determines the number of selected neural solvers by covering a certain amount of probability mass, rather than relying on a fixed number $k$.

## 4 Experiments

To examine the effectiveness of our proposed selection framework, we conduct experiments on TSP and CVRP, investigating the following Research Questions (RQ):
RQ1: How does the proposed selection framework perform compared to individual neural solvers? RQ2: How does the proposed selection framework perform when the problem distribution shifts and the problem scale increases? RQ3: How do different implementations of components affect the performance of the framework? We introduce the experimental settings in Section 4.1 and investigate the above RQs in Section 4.2. The code and data used in our experiments are provided in the supplementary materials.

### 4.1 Experimental settings

#### Synthetic TSP and CVRP.

We generate synthetic TSP and CVRP instances by sampling node coordinates from Gaussian mixture distributions with randomized covariance matrices. In the case of CVRP, vehicle capacities are generated using either the scale-related capacity or the triangular distribution. We consider varying problem scales, where the scale $N$ is sampled uniformly from $[50,500]$. More details of the data generation process are provided in Appendix A.2.

#### Datasets.

For training, we generate $10,000$ TSP and CVRP instances and apply $8$-fold instance augmentation (Kwon et al., ). For test, we generate smaller synthetic datasets comprising $1,000$ instances. Figures 1(a) and 1(b) in Section 1 are based on results from the CVRP test dataset. To evaluate the out-of-distribution performance, we utilize two well-known benchmarks with more complex problem distributions and larger problem scales (up to $N=1002$): TSPLIB (Reinelt, ) and CVRPLIB Set-X (Uchoa et al., ). For TSPLIB, we select a subset of instances with $N\leq 1002$, and CVRPLIB Set-X includes instances ranging from $N=100$ to $1000$. These problem scales are larger than the scale $N\in[50,500]$ of our training datasets.

#### Open-source neural solvers.

We choose recent open-source neural solvers with state-of-the-art performance as the candidates, including Omni (Zhou et al., ), BQ (Drakulic et al., ), LEHD (Luo et al., ), DIFUSCO (Sun & Yang, ), T2T (Li et al., ), ELG (Gao et al., ), INViT (Fang et al., ) and MVMoE (Zhou et al., ). Greedy decoding is used for all the methods to avoid stochasticity. We set the pomo size to $100$ and the augmentation number to $8$ for the methods based on POMO (Kwon et al., ). The number of denoising steps is set to $50$ and the number of $2$-opt iterations is set to $100$ for diffusion-based methods. These individual solvers constitute a neural solver zoo. Ideally, if we can always select the best solver from the zoo for each instance, the optimal performance is achieved, which is also the performance upper bound of our selection model. Considering that some neural solvers contribute little to the overall performance, we iteratively eliminate the least contributive solver from the candidates, resulting in a more compact neural solver zoo.
This process reduces the zoo size to $7$ solvers for TSP and $5$ for CVRP. Further details of the elimination procedure are provided in Appendix A.3.

#### Hyperparameters.

(1) Hyperparameters of graph encoders. For the graph attention encoder, we set the number of layers to $4$. For the hierarchical graph encoder, we use $2$ blocks where each block has $2$ attention layers. The embedding dimension is set to $128$. Other hyperparameters of encoders can be found in Appendix A.1. (2) Hyperparameters of training. The Adam optimizer (Kingma & Ba, ) is employed for training, where we set the learning rate to $1\times 10^{-4}$ and the weight decay to $1\times 10^{-6}$. The number of epochs is set to $50$. The final model is chosen according to the performance on a validation dataset with $1,000$ synthetic instances. We train 5 selection models using different random seeds and report the mean and standard deviation of their performance. (3) Hyperparameters of selection strategies. For the top-$k$ strategy, we set $k=2$. For the rejection-based strategy, we reject the 20% of instances with the lowest confidence levels (i.e., the highest selection probability of all individual solvers), and apply top-$2$ selection to these rejected instances. For the top-$p$ strategy, we set $p=0.5$ for TSP and $p=0.8$ for CVRP.

#### Performance metrics.

Following previous studies, we employ the gap to the best-known solution $\frac{c_{I}(\hat{\sigma})-c_{I}(\sigma^{*})}{c_{I}(\sigma^{*})}$ as the performance metric, called optimality gap, where $\hat{\sigma}$ is the solution obtained by each method, $\sigma^{*}$ is the best-known solution computed by extensive search of expert solvers (Helsgaun, ; Vidal, ), and $c_{I}()$ is the cost function of problem instance $I$. We also report the average time to evaluate efficiency, which includes both the running of neural solvers and selection.

### 4.2 Experimental results

#### RQ1: How does the proposed selection framework perform compared to individual neural solvers?

In Table 1, we present the performance of several implementations of our selection framework on synthetic TSP and CVRP, alongside the results of the top-$3$ individual neural solvers(^*^**DIFUSCO and T2T have multiple trained models. We only report the best results of these models.). We can observe that all implementations of our framework outperform the best neural solver on both TSP and CVRP, demonstrating the effectiveness of our framework. For example, using ranking loss and the top-$k$ selection strategy with $k=2$, our framework achieves average optimality gaps of 1.51% on TSP and 4.82% on CVRP, surpassing the best individual solver’s gaps of 2.33% on TSP and 6.82% on CVRP, achieved by DIFUSCO and Omni, respectively. Moreover, except utilizing the top-$k$ strategy, our selection framework is nearly as efficient as running a single solver. In some cases, our framework can obtain better optimality gaps while consuming even less time. For instance, using ranking loss and greedy selection on TSP leads to the average optimality gap 1.86% with 1.33s, while the best individual solver DIFUSCO achieves 2.33% gap with 1.45s. In Table 1, OPT (the fourth row) denotes the optimal performance for selection, which is obtained by running all individual solvers for each instance and selecting the best one. The best optimality gaps achieved by our selection framework (using ranking loss and top-$k$ selection with $k=2$) are close to OPT, with gaps of 1.51% on TSP and 4.81% on CVRP, compared to OPT’s gaps of 1.24% on TSP and 4.64% on CVRP. Furthermore, our framework can offer significant speed advantages over OPT, e.g., consuming an average time of 2.56s on TSP, whereas OPT requires an average time of 8.93s. Note that complete results for all individual solvers are provided in Appendix A.10.

**Table 1: Empirical results on synthetic TSP and CVRP datasets, reporting the mean (standard deviation) over five independent runs. The top three individual solvers are included for comparison, and OPT denotes the optimal performance for selection, which is computed by running all individual solvers in the zoo for each instance and selecting the best one. The best individual solver and its results are underlined, and the best optimality gaps, excluding OPT, are highlighted in boldface.**
| Methods | TSP |  |
| --- | --- | --- |
| Gap | Time |  |
| BQ (3rd) | 3.00% | 1.40s |
| T2T (2nd) | 2.40% | 1.58s |
| DIFUSCO (1st) | 2.33% | 1.45s |
| OPT | 1.24% | 8.93s |
| Selection by classification |  |  |
| Greedy | 1.94% (0.02%) | 1.36s (0.01s) |
| Top-$k$ ($k=2$) | 1.53% (0.01%) | 2.52s (0.04s) |
| Rejection ($20\%$) | 1.81% (0.01%) | 1.63s (0.01s) |
| Top-$p$ ($p=0.5$) | 1.84% (0.03%) | 1.55s (0.06s) |
| Selection by ranking |  |  |
| Greedy | 1.86% (0.01%) | 1.33s (0.01s) |
| Top-$k$ ($k=2$) | 1.51% (0.02%) | 2.56s (0.03s) |
| Rejection ($20\%$) | 1.75% (0.02%) | 1.63s (0.01s) |
| Top-$p$ ($p=0.5$) | 1.68% (0.02%) | 1.86s (0.07s) |

#### Extension of RQ1: Is the performance of the top- k 𝑘 k italic_k selection better than the solver portfolio with the same size?

The top-$k$ strategy enhances the performance by running a selected subset of the solver zoo for each instance, which certainly costs more time than individual solvers. For a fair comparison, we benchmark our top-$k$ selection method against a solver portfolio of the same size $k$. We construct this solver portfolio by exhaustively enumerating all possible subsets of size $k$ and selecting the one with the best overall performance. As shown in Appendix A.5, our top-$k$ selection consistently outperforms the size-$k$ solver portfolio across $k=\{1,2,3,4\}$ on all datasets, i.e., TSP, CVRP, TSPLIB and CVRPLIB Set-X, demonstrating the effectiveness of our selection model.

#### RQ2: How does the proposed selection framework perform when the problem distribution shifts and the problem scale increases?

We evaluate the generalization performance on two benchmarks, TSPLIB and CVRPLIB Set-X, which contain out-of-distribution and larger-scale instances. As shown in Table 2, all implementations of our selection framework generalize well, where the ranking model using top-$k$ selection improves the optimality gap by 0.88% (i.e., 1.95%-1.07%) on TSPLIB and by 0.71% (i.e., 6.10%-5.39%) on CVRPLIB Set-X, compared to the best individual solvers T2T and ELG on these two benchmarks. These results show that our selection framework is robust against the distribution shifts and increases in problem scale.

#### RQ3: How do different implementations affect performance?

We evaluate and compare different implementations of the three components in our framework:

**Table 2: Generalization results to TSPLIB and CVRPLIB Set-X datasets, which contain real-world out-of-distribution instances with larger scales.**
| Methods | TSPLIB |  |
| --- | --- | --- |
| Gap | Time |  |
| BQ (3rd) | 3.04% | 1.44s |
| DISFUCO (2nd) | 2.13% | 1.44s |
| T2T (1st) | 1.95% | 1.74s |
| OPT | 0.89% | 9.14s |
| Selection by classification |  |  |
| Greedy | 1.54% (0.05%) | 1.33s (0.02s) |
| Top-$k$ ($k=2$) | 1.22% (0.10%) | 2.47s (0.02s) |
| Rejection ($20\%$) | 1.42% (0.11%) | 1.54s (0.03s) |
| Top-$p$ ($p=0.5$) | 1.49% (0.11%) | 1.37s (0.02s) |
| Selection by ranking |  |  |
| Greedy | 1.33% (0.06%) | 1.28s (0.03s) |
| Top-$k$ ($k=2$) | 1.07% (0.03%) | 2.48s (0.02s) |
| Rejection ($20\%$) | 1.26% (0.03%) | 1.51s (0.04s) |
| Top-$p$ ($p=0.5$) | 1.28% (0.04%) | 1.46s (0.06s) |

**Table 3: Mean (standard deviation) of optimality gaps of different feature extraction methods. All the models are trained using ranking loss, and employ greedy selection.**
| Datasets | Best solver | Manual | Attention encoder | Hierarchical encdoer |
| --- | --- | --- | --- | --- |
| TSP | 2.33% | 1.97% (0.01%) | 1.87% (0.02%) | 1.86% (0.01%) |
| CVRP | 6.82% | 5.49% (0.08%) | 5.30% (0.01%) | 5.31% (0.01%) |
| TSPLIB | 1.95% | 1.83% (0.03%) | 1.45% (0.11%) | 1.33% (0.06%) |
| CVRPLIB | 6.10% | 6.35% (0.06%) | 5.87% (0.06%) | 5.76% (0.04%) |

(1) Feature extraction methods. We compare the manual features (Smith-Miles et al., ) (see Appendix A.4), graph attention encoder Kool et al. (), and hierarchical graph encoder in Table 3. All methods are trained using ranking loss, and we report the optimality gap with greedy selection. As shown in Table 3, even the simplest manual features perform well, achieving better results than the best individual solver across three datasets — TSP, CVRP, and TSPLIB. This further validates the effectiveness of our selection framework. Comparing the third and fourth columns, we observe that the graph attention encoder consistently outperforms manual features on all datasets, verifying the superiority of learned features. Furthermore, by comparing the fourth and fifth columns, we find that while the graph attention encoder has already been effective on synthetic datasets, introducing the hierarchical encoder can further improve generalization performance on out-of-distribution datasets, TSPLIB and CVRPLIB Set-X, which is quite important in practice. This enhanced generalization capability may be attributed to the hierarchical encoder’s ability to leverage the inherent hierarchical structures in COPs. More ablation studies of the hierarchical encoder are provided in Appendix A.6.

(2) Loss functions to train the selection model.
We can clearly observe from Tables 1 and 2 that the model trained with ranking loss generally outperforms the one trained with classification loss, particularly when employing top-$p$ selection or under out-of-distribution settings. We also compare their accuracy of selecting the best single individual, which is similar as shown Appendix A.8. Thus, the benefit of ranking loss over classification loss shows the importance of incorporating the dominance relationships among sub-optimal solvers, which can make the selection more robust.

(3) Selection strategies.
Greedy selection is efficient by selecting only the predicted best solver. Instead, top-$k$ selection selects the best $k$ solvers for better optimality gaps, but resulting in longer time. Rejection-based and top-$p$ selection provide a trade-off between optimality gap and time. Here, we focus on the evaluation of rejection-based and top-$p$ selection. We tune their hyperparameters (e.g., rejection ratio, $k$, and $p$) to obtain a range of results, provided in Appendix A.7. The results show the rejection-based selection with smaller $k$ ($k=2$ or $3$) tends to achieve better trade-off. Comparing top-$p$ selection and rejection-based selection, their performance has no significant difference. This is expected, because both of their principles are running more individual neural solvers when the confidence of the selection model is insufficient. However, the top-$p$ selection may be preferable in practice, where only one hyperparameter $p$ is associated.

## 5 Conclusion and discussions

In this paper, we propose a general framework for neural solver selection for the first time, which can effectively select suitable solvers for each instance, leading to significantly better performance with little additional computational time, as validated by the extensive experiments on two well-studied COPs, TSP and CVRP. We hope this preliminary work can open a new line for the topic of neural combinatorial optimization. Within the proposed selection framework, we preliminarily investigate several implementations of the three key components: Feature extraction, training loss functions, and selection strategies. Techniques such as hierarchical graph encoder, ranking loss, rejection-based selection, and top-$p$ selection notably enhance overall performance.
Beyond the techniques presented, we discuss several promising avenues for further research under this framework.

#### Feature extraction for neural solvers.

In our implementation, we only extracted features for problem instances and used fixed indices for neural solvers, which assumes a static neural solver zoo and can not directly utilize any newly added neural solver during deployment. To enable zero-shot generalization to unseen neural solvers, it is essential to construct a smooth feature space for solvers, where those with similar preferences and biases are positioned closely together. Here we design a preliminary method for extracting features of neural solvers to facilitate generalization to unseen solvers. This method is based on the insight that a neural solver’s preferences can be characterized by representative instances where it significantly outperforms other solvers. For each neural solver, we sort those instances where it performs the best in an ascending order according to the ratio of the objective value that the solver obtains to the runner-up objective value, and select top 1% as its representative instances. Each representative instance is then treated as a token, and we apply a transformer to learn a summary feature from these instance tokens, which serves as the feature representation of the neural solver. Detailed implementations and results are provided in Appendix A.9. The results show that the preliminary method enables generalization to unseen neural solvers, where adding an extra solver can improve the selection performance.

Furthermore, advanced neural solver features should provide richer and deeper information than only using instance features to increase the capacity of the selection model. However, our preliminary method is based on the representative instances and fails to provide deeper information into the solvers’ internal mechanisms. For future improvements, some approaches may be worth exploring, such as utilizing large language models to encode the code of neural solvers (Wu et al., ) or learning neural representations from their trained parameters (Kofinas et al., ), which can access internal solver information, and potentially improving selection performance.

#### Runtime-aware selection for learn-to-seach solvers.

In this paper, since the average runtime of most individual neural solvers is short (approximately 1–2 seconds), we ignored their time difference during the training of the selection model, and only used the objective values obtained by the neural solvers as supervision information (by classification or ranking). However, if there are some time-consuming learn-to-search solvers, such as NeuOpt (Ma et al., ; ) and local reconstruction methods (Kim et al., ; Ye et al., ), in the solver pool, the runtime should be considered in the performance ranking. In such cases, developing a runtime-aware selection method to balance computational time and solution optimality would be necessary. To address this, we could penalize objective values based on time consumption or simultaneously optimize both metrics using multi-objective learning methods (Lin et al., ).

#### Enhance the neural solver zoo by training.

As shown in Figure 1, current neural solvers can exhibit complementary performance over instances without any modification, which has motivated our framework of neural solver selection. Inspired by the population-based training (Grinsztajn et al., ), we can further enhance their complementary ability through finetuning, i.e., each neural solver is finetuned on those instances where it performs the best. We can also train new solvers from scratch by maximizing their performance contribution to the current solver zoo and iteratively add such new solvers for enhancement. Moreover, to facilitate the training and deployment of a neural solver zoo, it is essential to develop a unified platform that provides interfaces for executing and training diverse neural solvers, such as an extension to the existing RL4CO (Berto et al., ).

## Appendix A Appendix

### A.1 Graph attention layer

The graph attention layer is composed of two sub-layers: a multi-head attention sub-layer (Vaswani et al., ) and a feed-forward sub-layer. Each sub-layer is equipped with residual connection (He et al., ) and ReZero normalization (Bachlechner et al., ) for stable convergence of training. Denote the embedding of the $i$-th node as $\bm{h}_{i}$ (i.e., the $i$-th row of $H$). Since the graphs of TSP and CVRP are typically considered to be fully connected, the graph attention layer is calculated as

$$ $\displaystyle\bm{\hat{h}}_{i}$ $\displaystyle=\bm{h}^{l-1}_{i}+\alpha^{l}\text{MHA}^{l}_{i}(\bm{h}^{l-1}_{1}, \bm{h}^{l-1}_{2},...,\bm{h}^{l-1}_{N}),$ $\displaystyle\bm{h}^{l}_{i}$ $\displaystyle=\bm{\hat{h}}_{i}+\alpha^{l}\text{FF}(\bm{\hat{h}}_{i}),$ $$

where $l$ is the layer index, $i$ is the node index, $\alpha^{l}$ is a learnable parameter used in the ReZero normalization, MHA and FF are short for the multi-head attention and the feed-forward network, respectively. For the implementations of the basic components MHA and FF, we refer to Vaswani et al. () for details. Specifically, following the common settings of previous works, we set the dimension of $\bm{h}$ to 128, the number of heads in MHA to 8, and the hidden dimension of FF to 512.

### A.2 Data generation

Synthetic TSP and CVRP instances are generated for training, where the node coordinates, demands, and vehicle capacities are all sampled from manually defined distributions. The scale of each instance is sampled from $[50,500]$ randomly. Details of node coordinates, vehicle capacity, and node demands are introduced as follows.

#### Node coordinates

To generate diverse training instances, we utilize Gaussian mixture distributions to sample the node coordinates for both TSP and CVRP, which is common in previous works (Manchanda et al., ; Zhou et al., ) and demonstrates effectiveness on approximating various node distributions with different hardness levels (Smith-Miles et al., ).
First, we randomly select the number of Gaussian components $c\sim U(0,15)$ (when $c=0$, we use the uniform distribution) and partition the nodes randomly into $c$ groups, one for each component.
For each Gaussian component, we sample the mean coordinates $\bm{\mu}=(x_{\mu},y_{\mu})$ by $x_{\mu}\sim U(0,1)$ and $y_{\mu}\sim U(0,1)$, and sample the variances ${\rm var}_{x}$ and ${\rm var}_{y}$ uniformly from $[1,100]$. The covariance ${\rm cov}$ is sampled uniformly from $[-\sqrt{{\rm var}_{x}\cdot{\rm var}_{y}},\sqrt{{\rm var}_{x}\cdot{\rm var}_{y}})$, forming the covariance matrix $\Sigma={\left[\begin{array}[]{cc}{\rm var}_{x}&{\rm cov}\\
{\rm cov}&{\rm var}_{y}\end{array}\right]}$.
Node coordinates are sampled from the $N(\bm{\mu},\Sigma)$ and then scaled to the square of $x,y\in[0,1]$. Unlike conventional Gaussian mixture distributions (Manchanda et al., ; Zhou et al., ), which often use an identity covariance matrix, our approach employs randomized covariance matrices $\Sigma$. This modification can produce more diverse instances by introducing more variability in the node distributions.

#### Vehicle capacity and node demands

We employ two vehicle capacity distributions to generate CVRP instances: (1) Scale-related distribution (Zhou et al., ): The vehicle capacity is proportional to the scale $N$, defined as $Q=30+\lceil\frac{N}{5}\rceil$.
(2) Triangular distributions (Uchoa et al., ): The parameters of the triangular distribution include the upper limit $ub$, mode $m$, and lower limit $lb$, which are randomly sampled in succession as follows: $ub\sim U(20,\frac{N}{2})$, $m\sim U(5,ub)$, and $lb\sim U(3,m)$. The triangular distribution $T(lb,m,ub)$ is then used to generate vehicle capacities, resulting in more diverse CVRP instances compared to the fixed capacity setting (Nazari et al., ). Each capacity distribution is selected with equal probability. Node demands $m_{i}$ are sampled uniformly from $U(1,10)$ and normalized by dividing by $Q$.

### A.3 Eliminate useless neural solvers

The preserved neural solvers should have distinct strengths in certain problem instances, ensuring that they can bring significant improvements in overall performance. Motivated by this, we propose a simple yet effective heuristic strategy to build the neural solver zoo based on the assessment of their contribution to the overall performance.

Given the alternative neural solvers $\bm{S}=\{s_{1},s_{2},s_{3},....\}$, we assess the contribution of a specific solver $s_{i}\in\bm{S}$ by the degradation of performance after removing it. That is, the assessment of $s_{i}$ can be formalized as

$$ $\mathcal{A}(s_{i})=\mathbb{E}_{I}\left[\mathcal{P}_{I}(\bm{S})-\mathcal{P}_{I} (\bm{S}/s_{i})\right],$ $$

where $\mathcal{P}_{I}(\cdot)$ denotes the performance of a neural solver zoo on instance $I$. Here we use the percentage of the optimality gap to define $\mathcal{P}_{I}(\cdot)$ and employ a validation set for the estimation of expectations. According to this criteria, we can estimate the alternative solvers and remove the one with the lowest assessed contribution from $\bm{S}$. This process repeats iteratively until for all $s_{i}\in\mathcal{S}$, $\mathcal{A}(s_{i})$ surpasses the predefined threshold $\delta$, indicating the significance of each alternative neural solver. In practice, we collect the prevailing competitive neural solvers in the community to compose the original $\mathcal{S}$ and set $\delta$ as $0.01\%$.

The neural solver zoos before and after elimination are listed in Table 4. Note that for DIFUSCO and T2T, multiple models are released. We collect both the models trained on the N = 100 dataset and the N = 500 dataset as alternatives simultaneously.

**Table 4: The neural solver zoo before and after elimination.**
| Stage | Neural solver zoo for TSP | Neural solver zoo for CVRP |
| --- | --- | --- |
| Before elimination | BQ, LEHD, Omni, ELG, INViT,<br>DIFUSCO (N=100), DIFUSCO (N=500),<br>T2T (N=100), T2T (N=500) | BQ, LEHD, Omni, ELG, INViT, MVMoE |
| After elimination | BQ, LEHD, ELG,<br>DIFUSCO (N=100), DIFUSCO (N=500),<br>T2T (N=100), T2T (N=500) | BQ, LEHD, Omni, ELG, MVMoE |

### A.4 Manual features

We reproduce the manual features proposed by Smith-Miles et al. (), which use statistical information and cluster analysis results to describe the characteristics of TSP. In this paper, we adopt these features: the standard deviation of the distances, the coordinates of the instance centroid, the radius of the TSP instance, the fraction of distinct distances, the variance of the normalized nearest neighbour distances (nNNd’s), the coefficient of variation of the nNNd’s, the ratio of the number of clusters to the number of nodes (Here we use HDBSCAN algorithm (Campello et al., ) to generate clusters), the ratio of number of outliers to nodes, and the mean radius of the clusters. For CVRP, we further add the mean and standard deviation of node demands to the features.

### A.5 Results of top- k 𝑘 k italic_k selection.

We compare the performance of our top-$k$ selection and the solver portfolio with the same size $k$ on four datasets, including TSP, CVRP, TSPLIB and CVRPLIB Set-X. As shown in Figure 3, our top-$k$ selection consistently outperforms the size-$k$ solver portfolio across $k\in\{1,2,3,4\}$. We also observe that the performance of our top-$k$ selection is close to the OPT when $k=4$. Moreover, it is expected that the performance improvement of our top-$k$ selection gradually diminishes as $k$ increases, since the performance of solver portfolio is also approaching the OPT (the gray line).

Figure: Figure 3: Comparisons of the proposed top-$k$ selection and the solver portfolio with size $k$.
Refer to caption: x5.png

### A.6 Ablation of the hierarchical graph encoder.

The proposed hierarchical graph encoder utilizes graph pooling to downsample the instance graph and aggregates features obtained from multiple levels of the downsampled graphs. To evaluate the effectiveness of the graph pooling, we employ a graph encoder that aggregates the features from multiple layers for comparison, which is a clear ablation study since the main difference is that it does not have the graph pooling operation.

The results in Table 5 show that using our hierarchical graph encoder outperforms the encoder that simply accumulates multi-layer features, especially in terms of the generalization performance on CVRPLIB Set-X. This demonstrates the effectiveness of the graph pooling operation.

**Table 5: Ablation study of hierarchical graph encoder. We report the mean and standard deviation of five independent runs. All the models are trained using ranking loss, and employ greedy selection.**
| Datasets | Attention encoder | + Multi-layer features | Hierarchical encoder |
| --- | --- | --- | --- |
| TSP | 1.87% (0.02%) | 1.87% (0.01%) | 1.86% (0.01%) |
| CVRP | 5.30% (0.01%) | 5.30% (0.02%) | 5.31% (0.01%) |
| TSPLIB | 1.45% (0.11%) | 1.35% (0.05%) | 1.33% (0.06%) |
| CVRPLIB | 5.87% (0.06%) | 5.86% (0.08%) | 5.76% (0.04%) |

### A.7 Detailed results of rejection-based selection and top- p 𝑝 p italic_p selection.

The rejection-based selection and top-$p$ selection are both designed to achieve better performance with little additional time consumption. To evaluate them in detail, we tune their parameters (e.g., rejection ratio, $k$ and $p$) to obtain a range of results. For the rejection-based selection, we use $k\in\{2,3,4\}$ and vary the rejection ratio from 0.05 to 0.85 in increments of 0.05. For the top-$p$ selection, we adjust the the value of $p$ from 0.40 to 0.95 in increments of 0.01. The results of optimality gap and time consumption are provided in Figure 4. As shown in the figures, the rejection strategy with smaller $k$ tends to achieve better optimality gaps using the same time consumption. Therefore, we recommend $k=2$ or $3$ when using rejection-based selection. Comparing top-$p$ selection and rejection-based selection, we can not definitively conclude which strategy is superior, which is expected since they share similar idea of utilizing confidence levels to decide whether to employ multiple solvers. However, the top-$p$ selection may be preferable in practice due to its simplicity, where only a single hyperparameter $p$ requires tuning.

Figure: (a) Selection by classification
Refer to caption: x6.png

### A.8 Selection accuracy

We present the accuracy of selecting the optimal neural solver in Table 6. The results show that the ranking model and classification model generally have similar selection accuracy, except that the ranking model achieves better accuracy than the classification model on CVRPLIB.

**Table 6: Accuracy of models trained by different losses using greedy selection. We report the mean and standard deviation of five independent runs.**
| Metrics | Classification | Ranking |
| --- | --- | --- |
| Accuracy on TSP | 36% (1%) | 35% (1%) |
| Accuracy on CVRP | 61% (1%) | 62% (0%) |
| Accuracy on TSPLIB | 40% (3%) | 40% (7%) |
| Accuracy on CVRPLIB | 52% (2%) | 56% (3%) |

### A.9 Neural solver features

To enable generalization to unseen neural solvers, we design a preliminary feature extraction method for neural solver, which utilizes representative instances to represent a neural solver. For each neural solver, we sort those instances where the neural solver performs the best in an ascending order according to the ratio of the objective value that the solver obtains to the runner-up objective value, and select top 1% as its representative instances. Then, we use an instance encoder to obtain embeddings for each representative instance, serving as their token vectors. A transformer with two layers is employed to learn a summary feature from these instance tokens, which serves as the feature representation of the neural solver. More details are described as follows.

#### Instance tokenization.

We use a hierarchical graph encoder as the tokenization encoder to generate embeddings for each representative instance. Note that the parameters $\theta^{\prime}$ of the tokenization encoder are not updated by back-propagation. Instead, to stabilize the instance tokens during training, we update $\theta^{\prime}$ using a momentum-based moving average of the parameters $\theta$ of the instance feature encoder: $\theta^{\prime}\leftarrow m\cdot\theta^{\prime}+(1-m)\cdot\theta$, where $m\in[0,1)$ is a momentum coefficient (We set $m=0.99$ in experiments). Only the parameters $\theta$ are updated via back-propagation. This momentum update ensures that $\theta^{\prime}$ evolve more smoothly than $\theta$, resulting in stable instance tokenization.

#### Transformer architecture.

For each neural solver, we utilize the tokens of its representative instances along with a learnable summary token to compute a summary representation. We apply two attention layers for this purpose. The first layer is a self-attention mechanism applied over all tokens (including the summary token), enabling interactions among them. The second attention layer uses only the summary token as the query and all tokens as keys and values, effectively aggregating information from all tokens into the summary token. The final embedding of the summary token is then output as the neural solver’s representation.

#### Selection model with neural solver feature.

The selection model integrates both the instance features and the neural solver features to output a score for each instance-solver pair. We employ an MLP to compute these scores. For each instance, the scores across all neural solvers are normalized to derive the probability distribution for solver selection.

To integrate a newly added neural solver, we first identify its representative instances from the training dataset and employ the aforementioned networks to compute its feature representation. The selection model can then leverage this new solver by considering its feature during selection, without the need for any fine-tuning.

To evaluate the effectiveness of this method, we remove the second best neural solver from the current solver zoo, train the selection model using the supervision information provided by the pruned solver zoo, and reintroduce the removed solver during testing. Figure 5 presents the top-$k$ selection performance with and without the newly added (extra) solver. The results show that the performance with newly added solver is generally better than the performance without it, demonstrating that the selection model can leverage the information of unseen solvers without any finetuning. In other words, the selection model can generalize to unseen solvers. However, we observe a slight decrease in top-$1$ performance, indicating that the preliminary method requires further improvement.

Figure: Figure 5: Performance of introducing an extra neural solver based on the neural solver feature. The results of top-$k$ selection with and without extra neural solver are presented.
Refer to caption: x8.png

### A.10 Complete results with all neural solvers

**Table 7: Empirical results on synthetic TSP and TSPLIB datasets, reporting the mean (standard deviation) over five independent runs. All individual solvers are included for comparison, and OPT denotes the optimal performance for selection, which is computed by running all individual solvers in the zoo for each instance and selecting the best one. The best individual solver and its results are underlined, and the best optimality gaps, excluding OPT, are highlighted in boldface. The suffixes ’-N100’ and ’-N500’ indicate models trained on datasets with N=100 and N=500, respectively.**
| Methods | TSP |  |
| --- | --- | --- |
| Gap | Time |  |
| BQ | 3.00% | 1.61s |
| ELG | 3.70% | 0.45s |
| LEHD | 3.57% | 0.86s |
| T2T-N100 | 2.48% | 1.71s |
| T2T-N500 | 2.40% | 1.98s |
| DIFUSCO-N100 | 2.84% | 1.46s |
| DIFUSCO-N500 | 2.33% | 1.45s |
| OPT | 1.24% | 8.93s |
| Selection by classification |  |  |
| Greedy | 1.94% (0.02%) | 1.36s (0.01s) |
| Top-$k$ ($k=2$) | 1.53% (0.01%) | 2.52s (0.04s) |
| Rejection ($20\%$) | 1.81% (0.01%) | 1.63s (0.01s) |
| Top-$p$ ($p=0.5$) | 1.84% (0.03%) | 1.55s (0.06s) |
| Selection by ranking |  |  |
| Greedy | 1.86% (0.01%) | 1.33s (0.01s) |
| Top-$k$ ($k=2$) | 1.51% (0.02%) | 2.56s (0.03s) |
| Rejection ($20\%$) | 1.75% (0.02%) | 1.63s (0.01s) |
| Top-$p$ ($p=0.5$) | 1.68% (0.02%) | 1.86s (0.07s) |

**Table 8: Empirical results on synthetic CVRP and CVRPLIB Set-X datasets, reporting the mean (standard deviation) over five independent runs. All individual solvers are included for comparison.**
| Methods | CVRP |  |
| --- | --- | --- |
| Gap | Time |  |
| BQ | 7.20% | 1.59s |
| ELG | 7.81% | 0.82s |
| LEHD | 7.37% | 1.01s |
| MVMoE | 13.56% | 0.70s |
| Omni | 6.82% | 0.24s |
| OPT | 4.64% | 4.38s |
| Selection by classification |  |  |
| Greedy | 5.35% (0.02%) | 0.64s (0.01s) |
| Top-$k$ ($k=2$) | 4.81% (0.01%) | 1.87s (0.03s) |
| Rejection ($20\%$) | 5.19% (0.03%) | 0.77s (0.01s) |
| Top-$p$ ($p=0.8$) | 5.16% (0.03%) | 0.87s (0.08s) |
| Selection by ranking |  |  |
| Greedy | 5.31% (0.01%) | 0.62s (0.01s) |
| Top-$k$ ($k=2$) | 4.82% (0.01%) | 1.90s (0.04s) |
| Rejection ($20\%$) | 5.15% (0.02%) | 0.74s (0.01s) |
| Top-$p$ ($p=0.8$) | 4.99% (0.02%) | 1.03s (0.03s) |

## Peer Reviews

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: (1) Do you have any results on TSP-10000 or large instances? Trying to train your selection model on TSP-1000 and see how it can be generalized to TSP-10000 is critical.
(2) Are the instances training the selection model generated from the same distribution of the testing instances?
soundness: 3
strengths: (1) Since the CO problems are typically too hard, a single solver cannot capture the entire problem structure. Different solvers have their own advantages, which we can leverage to improve performance.
(2) The experiment results show the ability to generalize.
summary: This paper considers a new perspective on solving the Combinatorial Optimization (CO) problem using deep learning. Given an instance, a deep learning framework is trained to select the best suitable solver for this instance from a state-of-the-art solver pool. The general idea is (1) feature extraction of the input instance, (2) selection based on several criteria, e.g., top k, and the output of a trained classifier/ranking model.  (3) run the instance on the select solver(s). 

The experiment results show that the proposed method can improve the current single solver performance with few efforts. It also shows the ability to generalize. The key idea behind this paper is similar to this paper: Bai Y, Zhao W, Gomes C P. Zero Training Overhead Portfolios for Learning to Solve Combinatorial Problems[J]. arXiv preprint arXiv:2102.03002, 2021. Since the CO problems are typically too hard, so a single sovler cannot capture the entire problem structure. So, different solvers have their own advantages, then we can leverage this to improve the performance.
weaknesses: See questions.

---

confidence: 3
contribution: 3
initial_rating: 5
presentation: 3
questions: 1. The paper mentions that the hierarchical encoder can better leverage the hierarchical structural features in COPs. However, the intuitive interpretation of these hierarchical features is unclear. How do these structures correspond to specific instance properties of problems such as TSP or CVRP?
2. The paper mentions the use of graph features and instance scale as inputs for the selection model, while the specific features of different neural solvers are not directly involved in the learning process. Would the absence of these solver-specific features limit the generalization ability of the selection model?
3. During the score calculation phase, how exactly does the MLP relate to different solvers? In other words, how are the features of different solvers reflected in the MLP, and how does this ensure that the classification results are correlated with the solvers' features?
4. In the Top-p selection strategy, the paper defines a threshold probability $p$ to decide which solvers to retain. Is this threshold set adaptively based on the problem's features, allowing for optimal performance? 
5. The introduction of a hierarchical encoder adds complexity to the model. How does this impact the overall training efficiency and inference speed of the model? Is there any quantitative analysis showing the trade-off between the hierarchical encoder's added complexity and the model's performance improvements?
soundness: 2
strengths: 1. The paper introduces a novel combination of hierarchical graph encoders and multiple selection strategies, which together enhance solver performance for different combinatorial optimization problem instances.
2. The experimental results cover a range of combinatorial optimization tasks and demonstrate improvements in performance compared to using a single solver.
3. The proposed Adaptive Solver Selection Framework for selecting solvers based on instance characteristics is flexible.
summary: This paper proposes a novel framework for selecting the most suitable neural solver for different instances of combinatorial optimization problems (COPs). The framework effectively combines graph feature extraction through attention mechanisms and hierarchical encoders, as well as multiple solver selection strategies, including Greedy, Top-k, and Rejection-based approaches. The experimental results demonstrate the superiority of the proposed method over traditional approaches on tasks like TSP and CVRP. Overall, the paper offers valuable insights to instance-specific solver selection.
weaknesses: 1. The current selection strategies include Greedy selection, Top-k, Rejection-based, and Top-p. While these strategies have demonstrated effectiveness in different experimental settings, the basis for choosing the most suitable strategy for different types of instances is not clear. For example, what kind of instances would make Top-k more suitable than Top-p? 
2. The paper could benefit from including more graphical representations.

---

confidence: 4
contribution: 2
initial_rating: 6
presentation: 3
questions: See weaknesses.
soundness: 2
strengths: + This paper is well written and easy to follow.

+ Algorithm selection is an important strategy for classic (combinatorial) optimization, and it has not yet been well studied for NCO. This work is a timely contribution to this important research direction.

+ The proposed algorithm selection framework can achieve promising performance on different TSP and CVRP instances.
summary: This work proposes a neural solver selection framework to efficiently select a subset of suitable neural combinatorial optimization (NCO) solvers to handle each problem instance at the inference time. Three key components (feature extraction, training loss, and selection strategies) have been proposed and investigated in detail for solver selection. Experimental results show that the proposed framework can achieve promising performance on the traveling salesman problem (TSP) and the capacitated vehicle routing problem (CVRP) with little extra time cost.
weaknesses: **1. Connection to Neural Combinatorial Optimization (NCO) and Novelty**

Although this work's main motivation is to propose a neural solver selection framework for NCO, it seems that the proposed solver selection approach is actually agnostic to NCO. It is more like an independent learning-based solver selection method that can be used for other solvers, including the traditional ones. What makes the proposed method specific for NCO?

On the other hand, algorithm selection is already a popular research direction in the optimization community. As correctly mentioned in this paper, many (learning-based) algorithm/solver selection methods have already been proposed and widely used in practice (for example, see [1] for TSP algorithm selection). Many of them can be easily adapted to select NCO solvers. What is the novelty/contribution of the proposed framework over the existing algorithm selection methods?

[1] https://tspalgsel.github.io/

**2. Discussion/Comparison with Existing Algorithm Selection Methods**

I think the claim "[the traditional method] has never been explored in the area of neural combinatorial optimization" is far from enough to truly distinguish the proposed method from the traditional algorithm selection method. A detailed discussion/comparison with traditional algorithm selection methods is needed. 

What are the advantages/disadvantages of the proposed method compared with existing (learning-based and non-learning-based) algorithm selection methods? What is the performance of existing algorithm selection methods with NCO solvers? What is the performance of the proposed method with classic solvers?

**3. Novelty of the Key Components**

The proposed framework has three key components, namely feature extraction, selection model, and selection strategies. However, it seems that these components and the proposed structures are quite common in the NCO and algorithm selection community. The novelty and unique contribution of these components should be highlighted with solid evidence.  

**4. Generalization Performance**

Although experimental results show the proposed framework has good performance with problem distribution/scale shifts, it is unclear why it can achieve good out-of-distribution generalization performance as a learning-based method. 

**5. Experiments**

In the experiments, only a single summary table is provided for each comparison. I think a complete table with separate results for different instances (e.g., with different numbers of nodes), as widely used in other NCO papers, could be very helpful to better understand the performance of the proposed method.

As mentioned above, a detailed comparison with existing (learning-based and non-learning-based) algorithm selection methods is also needed.

---

confidence: 5
contribution: 2
initial_rating: 5
presentation: 3
questions: Please see the weaknesses part for questions and suggestions.
soundness: 3
strengths: The paper is generally well-structured and easy to follow. The writing is clear and the presentation of the idea is concise. The idea of selecting neural solvers at instance level is interesting and of practical significance.
summary: This paper introduces a framework for selecting the most appropriate neural solvers for TSP and CVRP at instances level. The framework enhances performance by allocating each problem instance to the most suitable solvers from a pool of available neural solvers via graph encoding and tailored selection model and strategy.
weaknesses: 1. The novelty of this work is somewhat limited because the idea of ranking different existing solvers for individual instances is not technically innovative, and the framework seems to highly rely on previous solvers, graph encoders, as well as established losses and selection strategies.
2. To gain the supervision for training requires executing multiple solvers on the same training set, which is probably time-consuming. Furthermore, given such computational overhead, it is believed that a tediously sequential performing of them on the targeted dataset can have been already done for simple selection of the optimal result. Thus, further clarification is needed on the necessity of this proposal.
3. The OPT in the evaluation is somewhat misleading. I suggest the authors solving the test instances with exact solvers or powerful heuristics like Gurobi, LKH3, HGS, etc, as reference solution for the computation of optimality gaps, which also better aligns with previous works. 
4. Additionally, adding such heuristics (in point 3) in your selection zoo is worth considering for further experimental results. If the neural solvers achieve comparable performance as the learning-free methods, the significance of this work is further strengthened.
5. More mainstream solvers should be included, such as [1-7]. They are a set of representing (but not limited to) neural works for routing problem solving, including supervised-, reinforced-, unsupervised-, meta-reinforced-, divide-and-conquer-, and neural-heuristic-mannered approaches. It is acceptable the authors include a subset of them into the framework, but this would benefit the completeness for your empirical evaluation.
6. The authors are also suggested to evaluate their framework on the conventionally used uniform TSP dataset (like those consistent test files through [1,2,4,5,7, etc.]). And please report the origianal objective for the COPs in addition to currently only the gap.
7. The claim in the title is broader than what is done within the paper. If the framework is to be a neural solver selection of combinatorial optimization, can it be readily applied to more complex problems beyond TSP and CVRP? And what is the solution at larger-scaled (e.g., $N\ge 1000$) instances where most neural solvers struggle to produce satisfactory results compared to the traditional heuristics?

**References:**

[1] DIMES: A Differentiable Meta Solver for Combinatorial Optimization Problems.

[2] An Efficient Graph Convolutional Network Technique for the Travelling Salesman Problem.

[3] Unsupervised Learning for Solving the Travelling Salesman Problem.

[4] Graph Neural Network Guided Local Search for the Travelling Salesperson Problem.

[5] Generalize a Small Pre-trained Model to Arbitrarily Large TSP Instances.

[6] GLOP: Learning Global Partition and Local Construction for Solving Large-scale Routing Problems in Real-time.

[7] Attention, Learn to Solve Routing Problems!

Meta-review: This paper proposed a learning based solver selection method for neural vehicle routing models. It involves feature extraction, selection model, and selection strategy, aiming to allocate each instance to the most suitable solver from a pool of neural VRP models. Reviewers agreed that the proposed method is interesting and neural solver selection is of practical meaning. However, they also raised several key concerns including 1) insufficient discussion and comparison to existing algorithm selection methods; 2) insufficient link to NCO; and 3) insufficient technical novelty. I particularly agree with the first point. Algorithm selection is a classic topic with many mature methods that can easily be applied to select neural VRP solvers, but this paper lacks a systematic discussion of the literature, as well as proper comparison to SOTA methods. In addition, the link to NCO is indeed not strong, as it appears to be a neural algorithm selection method that can be applied to other algorithms. So overall, this paper is interesting, but still requires major improvement to reach the acceptance threshold.

Decision: Reject