Computer Science
Computer Science-2021.gz:143426
Computer Science
997312bc0499fd4293225784dea1e1f263f0dced
Zero Training Overhead Portfolios for Learning to Solve Combinatorial Problems

There has been an increasing interest in harnessing deep learning to tackle combinatorial optimization (CO) problems in recent years. Typical CO deep learning approaches leverage the problem structure in the model architecture. Nevertheless, the model selection is still mainly based on the conventional machine learning setting. Due to the discrete nature of CO problems, a single model is unlikely to learn the problem entirely. We introduce ZTop, which stands for Zero Training Overhead Portfolio, a simple yet effective model selection and ensemble mechanism for learning to solve combinatorial problems. ZTop is inspired by algorithm portfolios, a popular CO ensembling strategy, particularly restart portfolios, which periodically restart a randomized CO algorithm, de facto exploring the search space with different heuristics. We have observed that well-trained models acquired in the same training trajectory, with similar top validation performance, perform well on very different validation instances. Following this observation, ZTop ensembles a set of well-trained models, each providing a unique heuristic with zero training overhead, and applies them, sequentially or in parallel, to solve the test instances. We show how ZTopping, i.e., using a ZTop ensemble strategy with a given deep learning approach, can significantly improve the performance of the current state-of-the-art deep learning approaches on three prototypical CO domains, the hardest unique-solution Sudoku instances, challenging routing problems, and the graph maximum cut problem, as well as on multi-label classification, a machine learning task with a large combinatorial label space.


Introduction
Deep learning has achieved tremendous success in many areas, including visual object recognition, neural machine translation, and autonomous driving. In contrast, combinatorial optimization problems are challenging for deep learning given that, in general, they are unsupervised or weakly supervised and have a large combinatorial solution space (Bengio et al., 2020;Kool et al., 2018). A classical approach to solving CO problems is to design useful heuristics manually to guide the algorithm on exploring the large combinatorial search space. Nevertheless, a heuristic is typically specialized for a specific problem, and it is not trivial to adapt to other CO problems. Deep reinforcement learning (DRL) is becoming a go-to approach for learning heuristics for CO problems (Bello et al., 2016;Mazyavkina et al., 2020). The hope is that DRL generalizes well to tackle several CO problems by learning heuristics from scratch. The architecture design of a deep learning framework leverages the specific problem structure, e.g., it employs the attention mechanism for routing problems (Kool et al., 2018). However, the model selection method still follows the conventional machine learning style, i.e., it selects only the model with the best validation performance from the same training trajectory. Due to the problems' combinatorial nature, we conjecture that a single model typically is not enough to capture the entire problem structure well and learn a useful heuristic for solving the potentially very different problem instances. We propose a new model selection and ensemble method to tackle this challenge.
The runtime and performance of combinatorial optimization algorithms for a given problem can vary significantly from instances to instances, depending on the heuristics used. Even when solving the same instance, a randomized heuristic can also vary dramatically. In fact, the run time distributions of combinatorial optimization algorithms often exhibit heavy tails (Gomes et al., 2000). To remedy and even exploit the heavy-tailed phenomena and large performance variance of CO search methods, algorithm portfolios, and in particular restart portfolios, are widely used in the CO community (Gomes & Selman, 2001;Xu et al., 2008;Gomes et al., 1998;Biere & Fröhlich, 2018

Model_Best Model_C1 Model_C2 Model_C3
< l a t e x i t s h a 1 _ b a s e 6 4 = " k + I b D T B T j C D c 9 0 V R p g K b 3 + t D C D Q = " > A A A B 6 3 i c b V B N S 8 N A E J 3 U r 1 q / q h 6 9 L B a h X k o i i h 6 L X j x W s B / Q h r L Z b t q l u 5 u w O x F K 6 V / w 4 k E R r / 4 h b / 4 b k z Y H b X 0 w 8 H h v h p l 5 Q S y F R d f 9 d g p r 6 x u b W 8 X t 0 s 7 u 3 v 5 B + f C o Z a P E M N 5 k k Y x M J 6 C W S 6 F 5 E w V K 3 o k N p y q Q v B 2 M 7 z K / / c S N F Z F + x E n M f U W H W o S C U c y k K j 0 v 9 c s V t + b O Q V a J l 5 M K 5 G j 0 y 1 + 9 Q c Q S x T U y S a 3 t e m 6 M / p Q a F E z y W a m X W B 5 T N q Z D 3 k 2 p p o p b f z q / d U b O U m V A w s i k p Z H M 1 d 8 T U 6 q s n a g g 7 V Q U R 3 b Z y 8 T / v G 6 C 4 Y 0 / F T p O k G u 2 W B Q m k m B E s s f J Q B j O U E 5 S Q p k R 6 a 2 E j a i h D N N 4 s h C 8 5 Z d X S e u i 5 l 3 V 3 I f L S v 0 2 j 6 M I J 3 A K V f D g G u p w D w 1 o A o M R P M M r v D n K e X H e n Y 9 F a 8 H J Z 4 7 h D 5 z P H 7 6 / j W I = < / l a t e x i t > (a) < l a t e x i t s h a 1 _ b a s e 6 4 = " u 4 L b R W K H K j S 5 R b n E 4 a B h A D U U D r w = " > A A A B 6 3 i c b V B N S 8 N A E J 3 U r 1 q / q h 6 9 L B a h X k o i i h 6 L X j y k a n B e 6 p c r b s 2 d g 6 w S L y c V y N H o l 7 9 6 g 4 g l i m t k k l r b 9 d w Y / S k 1 K J j k s 1 I v s T y m b E y H v J t S T R W 3 / n R + 6 4 y c p c q A h J F J S y O Z q 7 8 n p l R Z O 1 F B 2 q k o j u y y l 4 n / e d 0 E w x t / K n S c I N d s s S h M J M G I Z I Model_Best can solve instance < l a t e x i t s h a 1 _ b a s e 6 4 = " F R u d D 6 w n x Z q 1 R T y U k x l d o K i u Z m s = " > A A A B 6 X i c b V B N S 8 N A E J 3 U r 1 q / q h 6 9 L B b B U 0 n E o s e i F 4 9 V 7 A e 0 o W y 2 k 3 b p Z h N 2 N 0 I J / Q d e P C j i 1 X / k z X / j t s 1 B W x 8 M P N 6 b Y W Z e k A i u j e t + O 4 W 1 9 Y 3 N r e J 2 a W d 3 b / + g f H j U 0 n G q G D Z Z L G L V C a h G w S U 2 D T c C O 4 l C G g U C 2 8 H 4 d u a 3 n 1 B p H s t H M 0 n Q j + h Q 8 p A z a q z 0 0 J v 2 y x W 3 6 s 5 B V o m X k w r k a P T L X 7 1 B z N I I p W G C a t 3 1 3 M T 4 G V W G M 4 H T U i / V m F A 2 p k P s W i p p h N r P 5 p d O y Z l V B i S M l S 1 p y F z 9 P Z H R S O t J F N j O i J q R X v Z m 4 n 9 e N z X h t Z 9 x m a Q G J V s s C l N B T E x m b 5 M B V 8 i M m F h C m e L 2 V s J G V F F m b D g l G 4 K 3 / P I q a V 1 U v V r V v b + s 1 G / y O I p w A q d w D h 5 c Q R 3 u o A F N Y B D C M 7 z C m z N 2 X p x 3 5 2 P R W n D y m W P 4 A + f z B 5 / e j W s = < / l a t e x i t > } All these models are acquired from the same training trajectory  explore different search space parts, using randomized or pseudo-randomized heuristics and caching useful run information. De facto restarts correspond to using thousands of heuristic variants, with low heuristic switching costs.
We have also observed a large variance in the deep learning models' performance when considering CO problems. In a deep learning setting, we acquire lots of models during the same training trajectory, and each model can be viewed as a heuristic. However, using thousands of models in the test phase would be computationally intractable. Our goal is to select a few models covering very diverse heuristics.
Our Contributions: (1) ZTop, a simple yet effective mechanism to select a diverse set of models covering different heuristics with zero training overhead (see Fig. 1). The basic idea is to find a few models from the same training trajectory with similar average performance (near the best model's performance) but with a high variance with respect to the instances they can solve. Near best performance assures these models are well-trained, while the variance indicates they potentially capture uniquely different heuristics.
(2) ZTop also provides an ensembling technique to leverage different models.  (Chen et al., 2020), the routing problem (Kool et al., 2018), and the graph maximum cut problem (Barrett et al., 2020), as well as multi-label classification (MLC), a machine learning task with a large combinatorial label space, with zero training overhead. These frameworks cover various architecture and learning methods: for Sudoku, a modified Long Short Term Memory (LSTM) (Hochreiter & Schmidhuber, 1997) with weakly supervised learning, for routing problems, a pointer network with attention encoder with reinforcement learning (RL), for Maximum Cut, structure2vector (s2v) with RL, and for MLC, Label Message Passing (LaMP) (Lanchantin et al., 2019) and Higher Order correlation VAE (HotVAE) (Zhao et al., 2021).

Related Work
Deep Learning for Combinatorial Optimization (CO): Several CO deep learning model architectures leverage the problem structures for learning better heuristics. Struc-ture2Vector (s2v) (Dai et al., 2016;Khalil et al., 2017b) was proposed for graph instances. For each node of the graph, a feature vector can be learned, capturing the properties of itself and its neighbors. A Pointer Network (PN)  computes the permutation of variable length sequence data. This subtle model can naturally capture many CO constraints. Graph Neural Networks are also employed for SAT instances (Selsam et al., 2018;Kurin et al., 2019). A modified LSTM, i.e., each LSTM step's input is multiplied with a constraint graph capturing the Sudoku constraints, performs very well on weakly-supervised learning to solve challenging Sudoku problems (Chen et al., 2020). Creating a large labeled dataset is computationally intractable for CO problems. So, deep reinforcement learning or weakly supervised learning is used to learn CO problems, ranging from routing problems (Bello et al., 2016;Kool et al., 2018), the maximum cut problem (Khalil et al., 2017a;Barrett et al., 2020) to the minimum vertex cover problem (Khalil et al., 2017a;Song et al., 2020). Several approaches combine deep models with search algorithms (Kool et al., 2018;Deudon et al., 2018;Abe et al., 2019) to further improve the performance. ZTop can further significantly improve the performance on top of these learning approaches.
Ensemble Methods in Deep Learning: Neural network ensembles (Zhou et al., 2002;Polikar, 2006;Rodriguez et al., 2006) have been widely used to boost the model's performance in the machine learning community. However, they mainly focus on (weighted) averaging the output of the models and training a set of heterogeneous models requiring substantial computational resources. Due to the considerable overhead of traditional ensemble methods, the deep learning community proposes several methods to remedy this issue. "Implicit" ensembles (Srivastava et al., 2014;Wan et al., 2013;Huang et al., 2016;Singh et al., 2016;Krueger et al., 2016;Han et al., 2017) are proposed as an alternative to traditional ensemble methods given their minor overhead in both the training and test phase. One example of "implicit" ensembles is Dropout (Srivastava et al., 2014), which randomly zeros some hidden neurons during each training step. At the test time, every neuron is kept and scaled by the keeping probability of the training phase. An explanation of dropout is that there are a considerable number of models created by dropping neurons, and these models are implicitly ensembled at the test phase. Similar to the dropout mechanism, stochastic depth  proposes to randomly drop some layers during the training time to create different models with various depths. These implicit ensemble methods create many shared-weights models and ensemble them in the test phase implicitly. Several works focus on efficiently acquiring many good models (Huang et al., 2017;Zhang et al., 2020) to decrease the training cost. Snapshot ensemble (Huang et al., 2017) leverages the cyclic learning rates (Loshchilov & Hutter, 2016) to force the model to jump from one local minimum to another local minimum, and ensemble these models of different local minimum to reduce the training phase overhead. However, cyclic learning rates can potentially damage the model's performance, and it is designed for only convolution neural networks. Another line of research focuses on reducing the test time overhead (Buciluǎ et al., 2006;Hinton et al., 2015;Shen et al., 2019;lan et al., 2018). Distill (Hinton et al., 2015) proposes to employ the ensemble of many models as the training label of a single model (similar or smaller size). Learning to improve (L2I) (Lu et al., 2019) proposes a new way to leverage models. L2I employs the model to guide their local search, and they find that taking the best results of many models with small rollout steps is better than one model with much larger rollout steps. However, L2I requires to train these models separately, and the training method is designed specifically for their learning framework. Ensemble methods for MLC fall into three groups: the first group is to ensemble binary relevance classifiers (Read et al., 2011;Wang et al., 2016); the second group is to ensemble label powerset classifiers (Read et al., 2008;Tsoumakas et al., 2010); and, the third group uses random forest of predictive clustering trees (Kocev et al., 2007). All the ensemble methods above except for L2I rely on (weighted) averaging the outputs of many models.
Algorithm Portfolios, used by the CO community (Gomes & Selman, 2001;Leyton-Brown et al., 2003;Xu et al., 2008), ensemble different algorithms and solvers to solve a CO problem. In particular, restart portfolios (restarts) are widely used in the SAT community (Gomes et al., 1998;Biere & Fröhlich, 2018), since they are an effective way of combating long and heavy tailed runtime distributions (Gomes et al., 2000). They are also used in stochastic optimization to solve non-convex problems (Dick et al., 2014;Gagliolo & Schmidhuber, 2007). Restarts periodically restart an algorithm, de facto trying different (pseudo) randomized heuristics, with low heuristic-switching cost.
Restarts in Deep Learning (DL): As an example of restarts in DL, the learning rate is reset based on some manually designed metrics to speed up the training or improve the performance (Gotmare et al., 2018;Loshchilov & Hutter, 2016). DRNets (Chen et al., 2020) also employ restarts in the optimization phase to improve performance, with different random seeds. Nevertheless restarts are not often employed in the deep learning community.
A key feature that differentiates ZTop is that it leverages different models from the same training trajectory in the test phase to improve performance, with zero training overhead.

ZTop, a Novel Ensemble Method
ZTop is a novel ensemble method that selects a set of diverse models for learning to solve CO problems incurring zero training overhead, inspired by the restart portfolios.
The selected models are applied sequentially or in parallel to solve the test instances, taking the best output per instance. ZTop can be used on top of any weakly supervised or reinforcement CO learning framework, or even in some cases on top of a supervised framework, to significantly improve the performance, with zero training overhead and the same test overhead as traditional ensemble methods.
Due to the discrete nature of many CO problems, an oracle heuristic, i.e., a heuristic that works for almost every instance, is unlikely to exist. In the CO community, restarts Take the best output of x in res i,i=1...n end for are widely employed to remedy this issue by periodically switching to a new heuristic. We postulate that it is also difficult for a single deep learning model to perfectly solve all kinds of instances. Surprisingly, we have observed that several models acquired through the same training trajectory contain quite diverse heuristics. These models have similar validation performance, but the subsets of the validation set they perform well vary significantly. It is then promising to select several models from the same training trajectory instead of a single one.
Selecting diverse models from the same training trajectory. The goal is to select several models with similar validation performance, but they should perform well on different subsets of the validation set. Often, in CO problems, we naturally have a metric φ to validate the model's performance, e.g., the average length of the route in the TSP problems. Surprisingly, selecting top-k models with respect to the metric φ on the validation set can achieve the goal. The resulting set of models have very comparable performance as the optimal set of models found by enumerating all the possible combinations, as we show in the experimental section. In terms of the training time overhead, we mark the additional training operation of ZTop in blue in the Alg. 1. We only need to store each model's validation performance along with its parameters. This additional operation incurs zero training cost since traditional model selection also needs to validate these models.
How to leverage these models is another issue. Each model can be viewed as a heuristic, and different heuristics typically work for different instance groups. So averaging these models' output may cancel out each heuristic's contribution.
Ensembling models at test time. ZTop applies its models sequentially or in parallel to solve each test instance and selects the best output per instance (see Alg. 1). For weakly-supervised or reinforcement learning (RL) settings, it is natural to have a metric, e.g., the reward used in RL, to select the best output. Consider using a deep model to solve Sudoku. We employ ZTop's models to solve test Sudoku instances sequentially. If any model solves a test instance, no need to try other models. Note that each test instance is only fed once into each model, so our test time overhead is identical to that of traditional ensemble methods.

Experiments
We show the performance of the ZTop approach on various CO problems learning frameworks and two MLC learning frameworks.

General Experiment Settings
Baselines. ZTop has zero training overhead, thus we compare it with methods that share similar training overhead with us. The first baseline is the conventional machine learning model selection scheme (denoted as Single), i.e., it selects a single model with the best validation performance. Note here, the learning framework's training strategy consists of proper implicit ensemble methods. So we are also comparing ZTop with these implicit ensemble methods. In terms of leveraging the models, we also compare ZTop with the conventional ensemble method, i.e., averaging the output of all models. We denote this baseline as Average: picking top models w.r.t metric φ and averaging the outputs of them. The last method is our method ZTop: selecting top models w.r.t metric φ and taking the best output per instance.
Settings for the learning framework. ZTopping a given learning approach involves adapting released codes and following the original paper's settings (for training/test instances, train models, and test models' performance).

Hardest unique solution Sudoku
< l a t e x i t s h a 1 _ b a s e 6 4 = " k + I b D T B T j C D c 9 0 V R p g K b 3 + t D C D Q = " > A A A B 6 3 i c b V B N S 8 N A E J 3 U r 1 q / q h 6 9 L B a h X k o i i h 6 L X j x W s B / Q h r L Z b t q l u 5 u w O x F K 6 V / w 4 k E R r / 4 h b / 4 b k z Y H b X 0 w 8 H h v h p l 5 Q S y F R d f 9 d g p r 6 x u b W 8 X t 0 s 7 u 3 v 5 B + f C o Z a P E M N 5 k k Y x M J 6 C W S 6 F 5 E w V K 3 o k N p y q Q v B 2 M 7 z K / / c S N F Z F + x E n M f U W H W o S C U c y k K j 0 v 9 c s V t + b O Q V a J l 5 M K 5 G j 0 y 1 + 9 Q c Q S x T U y S a 3 t e m 6 M / p Q a F E z y W a m X W B 5 T N q Z D 3 k 2 p p o p b f z q / d U b O U m V A w s i k p Z H M 1 d 8 T U 6 q s n a g g 7 V Q U R 3 b Z y 8 T / v G 6 C 4 Y 0 / F T p O k G u 2 W B Q m k m B E s s f J Q B j O U E 5 S Q p k R 6 a 2 E j a i h D N N 4 s h C 8 5 Z d X S e u i 5 l 3 V 3 I f L S v 0 2 j 6 M I J 3 A K V f D g G u p w D w 1 o A o M R P M M r v D n K e X H e n Y 9 F a 8 H J Z 4 7 h D 5 z P H 7 6 / j W I = < / l a t e x i t > (a) < l a t e x i t s h a 1 _ b a s e 6 4 = " u 4 L b R W K H K j S 5 R b n E 4 a B h A D U U D r w = " > A A A B 6 3 i c b V B N S 8 N A E J 3 U r 1 q / q h 6 9 L B a h X k o i i h 6 L X j x W s B / Q h r L Z b t q l u 5 u w O x F K 6 V / w 4 k E R r / 4 h b / 4 b k z Y H b X 0 w 8 H h v h p l 5 Q S y F R d f 9 d g p r 6 x u b W 8 X t 0 s 7 u 3 v 5 B + f C o Z a P E M N 5 k k Y x M J 6 C W S 6 F 5 E w V K 3 o k N p y q Q v B 2 M 7 z K / / c S N F Z F + x E n M f U W H W o S C U c y k a n B e 6 p c r b s 2 d g 6 w S L y c V y N H o l 7 9 6 g 4 g l i m t k k l r b 9 d w Y / S k 1 K J j k s 1 I v s T y m b E y H v J t S T R W 3 / n R + 6 4 y c p c q A h J F J S y O Z q 7 8 n p l R Z O 1 F B 2 q k o j u y y l 4 n / e d 0 E w Sudoku is an NP-hard combinatorial number-placement puzzle on an n×n board. We focus on the Sudoku problems on 9 × 9 boards, as they are most widely studied. The object is to complete a 9 × 9 board, pre-filled with several hints Single (0) Single (10) # Ensemble Models Average (0) ZTop (0) Average (10) (Chen et al., 2020). Sudoku accuracy of 17 hint Sudokus for single and ensemble models, under two test modes: 0 and 10 optimization steps.The number in parentheses next to the modality is the optimization step used in the test mode. We mark ZTop's results in blue and bold the best results. ZTop significantly improves the DRNets' performance and outperforms the traditional averaging ensemble method on the two test modes.

x t / K n S c I N d s s S h M J M G I Z I + T g T C c o Z y k h D I j 0 l s J G 1 F D G a b x Z C F 4 y y + v k t Z F z b u q u Q + X l f p t H k c R T u A U q u D B N d T h H h r Q B A Y j e I Z X e H O U 8 + K 8 O x + L 1 o K T z x z D H z i f P 8 B F j W M = < / l a t e x i t > (b)
(numbers pre-assigned to cells), with numbers 1 to 9. In a Sudoku, each row, column , and pre-defined 3 × 3 box cannot have a repeated digit (see Fig. 2). It has been showed that 17 is the minimum number of hints for which a Sudoku has a unique solution (McGuire et al., 2012). So we focus on solving 9 × 9 Sudokus with 17 hints.
We select DRNets (Chen et al., 2020) as the learning framework since it is the state-of-the-art weakly-supervised learning Sudoku framework, supervised only by the Sudoku rules. It employs continuous relaxation to convert the discrete constraints to differentiable loss functions. The training and test of DRNets only require Sudokus without labels.
DRNets assign each digit a learnable embedding and a tensor represents a Sudoku instance. A modified LSTM computes the missing digits given the Sudoku tensor as input. We create 100, 000 Sudoku with 18 to 25 hints for training and validating the models and 1000 Sudoku with 17 hints for testing the model. The other training/validating/testing settings also strictly follow the original paper.
To ensure the model candidates are well-trained, we save the top 100 models from the training phase in terms of the validation performance. Then we select models based on the performance metric φ, which in this case is the Sudoku accuracy, i.e., the number of Sudoku this model correctly solved. We do not assign partial credits. We evaluate the ensemble performance of 3, 5, 10, and 20 models.
Sudoku Accuracy. The results are summarized in Table 1. We consider two test modes of the DRNets framework: 0-step optimization mode and 10-step optimization mode.
Since the loss function of DRNets is derived only from the Sudoku rules, it can still be optimized for the test instances.
Here 0-step mode fixes the models' parameters while 10step mode optimizes the loss function 10 steps in the test phase. In all the cases, ZTop substantially outperforms the single model and standard averaging ensemble methods. We only require 10 models to achieve 75.5% Sudoku accuracy, considerably higher than the single model's 28.9% Sudoku accuracy, reaching 86.7% with 20 models and 10 optimization steps. These results show that a set of diverse models are more effective than a single model to capture the varied structure of 17 hint Sudoku instances.

A Series of Routing Problems
Routing problems are intensively studied in the CO community and have many real-world applications (Ross et al., 2019). We consider four routing problems and their variants. Traveling Salesperson Problems (TSP): Given a set of cities and the distance between any two cities, the goal is to find the shortest route that can traverse every city and return to the start city. Vehicle Routing Problems (VRP): This problem (Toth & Vigo, 2014) is a generalized TSP problem. Given a set of cities and a depot, each city has a demand, i.e., how many people intend to visit the city, the goal is to find an optimal set of routes to meet all the demands. We focus on two variants of this problem. Capacitated VRP (CVRP): The total cities' demands in one route cannot excel a pre-set threshold. Split Delivery VRP (SDVRP): This variant has the same constraint as CVRP, but here the demand of a city can be split through multiple routes. Orienteering Problem (OP) (Golden et al., 1987): We have a set of cities and know the distance between any two cities. Each city contains a prize. The object is to find a route whose length cannot surpass a threshold and we want to maximize the summation of the cities' prizes in this route. Prize Collecting TSP (PCTSP) (Balas, 1989): This is a more challenging variant of the TSP problem. Each city is assigned a prize and a penalty. We need to find a route collecting at least a minimum total prize to minimize the route length plus the sum of missed cities' penalty. Stochastic PCTSP (SPCTSP): This problem is quite similar to the PCTSP problem. The only difference is that the prize of each city is sampled from a fixed distribution. The salesperson only knows the expected prize of each city, and the true prize is revealed when visiting a city.
We select Kool et al.'s (Kool et al., 2018) learning framework (denoted as AM) for these routing problems since it is one of the state-of-the-art methods. This framework employs reinforcement learning (REINFORCE algorithm (Williams, 1992)   Ztop using all the models and the sampling method. Due to the stochastic nature of SPCTSP, AM (sampling) does not work. We compare our method with REOPT (half), a C++ ILS-based algorithm proposed in the original paper. From the top table, we observe that ZTopping AM substantially outperforms AM and the conventional ensemble method using only 3 models for the ensemble. ZTopping AM using 100 the models can surprisingly excel the AM (sampling) method with a considerably shorter time in most cases.
architecture of AM is the pointer network  with an attention encoder. The graph of the problem is fed into the attention encoder to compute the graph embedding and node embeddings. Then the decoder of the pointer network generates the policy of the next action.
The solution generation process of AM is incremental, i.e., the model selects one node (city) per step conditioned on all the previous actions. The data generation and training processes are strictly following the original paper's settings (Kool et al., 2018). We select the best 100 models from the training phase. We evaluate the ensemble performance of 3, 5, 10, and all the 100 models. The metric we used for each problem is illustrated below.
Results. We introduce one more baseline for the AM method since it proposes a sampling method based on the model's output. This method (denoted as AM (sampling)) can generate better solutions with considerable time. AM (sampling) samples 1280 solutions and report the best result for each problem. We now introduce the metrics (Obj. column of the  the AM learning framework even with only 3 models. We also compare the AM (sampling) method with our ZTop using all (100) models and the results are showed in the bottom table. In most cases, our method can also outperform the AM (sampling) method with a considerably shorter time. In the CVRP (n = 100) problem, we achieve the mean length of route 16.19 in 13.4 minutes while AM (sampling) requires 2 hours to achieve only 16.23. In the SPCTSP (n = 100) problem, we achieve 6.11 in 8.4 minutes while RE-OPT (half) algorithm requires a substantially long time of 16 hours to achieves a poorer performance 6.16. We also observe that averaging ensemble method sometimes even decreases the performance, e.g., the objective drops from 31.21 to 31.20 in the OP (n = 100) problem. Moreover, in most cases, averaging ensemble method only achieves minor improvements.

Graph Maximum Cut Problem
The graph maximum cut problem is a classical problem in graph theory. The cut of a graph is a partition of the vertex set into two complementary sets and the number of edges or the sum of edges' weight between these two sets is denoted as the cut's capacity. The maximum cut is the cut that has a maximum capacity.
We employ the state-of-the-art ECO-DQN (Barrett et al., 2020) as the learning framework for the maximum cut problem. ECO-DQN leverages reinforcement learning (Deep Q learning (Mnih et al., 2015)) to learn useful heuristics unsupervisedly. So, like the AM learning framework, we do not require any solution to train the model. The model architecture of ECO-DQN is Message Passing Neural Networks (MPNN) (Gilmer et al., 2017). It represents each vertex as an embedding. Several rounds of message passing update the vertices' embeddings. The probability distribution over all the actions is computed through a readout function. The ECO-DQN proposes the test-time exploration concept where their policy is to improve a given solution instead of constructing a solution from scratch. Their original evaluation protocol is to generate 50 random solutions on the fly, employ the model to improve them and pick the best one. We generate 50 random solutions in advance and ensure every method is improving the same 50 solutions. We select 50 models uniformly from the last quarter of training epochs. We evaluate the ensemble performance of 3, 5, and 10 models. We report the approximation ratio averaged over all the test instances.
Approximation Ratio. We consider two types of random graphs used in the original paper (Barrett et al., 2020). One is Erdős-Rényi (denoted as ER) (Erdos et al., 1960) , and the other is Barabasi-Albert (denoted as BA) (Albert & Barabási, 2002) with the edge weights belong to {0, 1, −1}. We select two worst-performance cases of the original paper to show ZTopping can improve the ECO-DQN learning framework. One case is to train the model on ER (n = 20) graphs and tested on ER (n = 20, 40, 60, 100, 200) graphs where n refers to the number of vertices, the other is to train the model on BA graphs and tested on BA (n = 20, 40, 60, 100, 200) graphs. The results are summarized in Fig 4, and ZTop substantially improves the performance of ECO-DQN in all the scenarios. Furthermore, we also observe a similar phenomenon as in the routing problems: the averaging ensemble method decreases the performance. The more models we used for the averaging ensemble, the lower performance it achieves. This phenomenon verifies our assumptions that the averaging ensemble may cancel out each heuristic's contribution.
We show that ZTop can substantially improve the performance of the three learning approaches above. Moreover, the three learning approaches cover two of the most popular architectures: pointer network and s2v, and they also cover both weakly-supervised learning and reinforcement learning algorithms. The variety of these learning frameworks illustrate the universality of our ZTop method.

Multi-Label Classification
Multi-label classification (MLC) is the problem of assigning a set of labels to a given object. MLC can be viewed as a combinatorial classification problem, since the potential MLC's label set is the powerset of the set of single labels.  ZTop's results are in blue and the best result for each dataset is in bold. m is the number of models used for the ensemble. k is the number of labels. We report ebF1, miF1 and maF1 scores of these approaches. We observe that ZTop significantly improves single LaMP or HotVAE on all the datasets except for Yeast. ZTop only improves slightly on Yeast since the dataset is relatively simple, with only 14 labels.
MLC is typically a supervised problem, with no obvious unsupervised metric to identify the best model at test time.
The MLC models from the same training trajectory are not as heterogeneous as those learned for more standard CO problems, such as TSP or Sudoku. Thus, different MLC models may focus on the object's different label subsets and therefore an averaging ensemble method is a good strategy. So, ZTop selects top validation performance models and averages their outputs, in contrast to other CO problems with well defined unsupervised metrics.
We tested ZTop on the two top state-of-the-art learning approaches for MLC, Label Message Passing (LaMP) (Lanchantin et al., 2019) and Higher Order correlation VAE (HotVAE) (Zhao et al., 2021) and on four datasets: Bibtext (Katakis et al., 2008), Reuters (Lewis et al., 2004), Delicious (Bi & Kwok, 2013) and Yeast (Nakai & Kanehisa, 1992). ZTop trains a single MLC architecture and selects n models with the lowest validation losses. ZTop runs inference with the n models and averages their sigmoid scores for the final prediction probabilities. We consider ZTop ensembles with 5, 10, and 15 models. To our knowledge, there are no other deep learning ensemble methods for MLC.
F1 scores. We report three kinds of F1 scores: ebF1, miF1 and maF1 scores. The main results are summarized in Fig. 5. We can observe that ZTopping LaMP/HotVAE can significantly improve the LaMP/HotVAE on all the datasets except for Yeast. Yeast is a simple dataset with only 14 potential labels, so ZTop can only improve a little on that dataset.

Ablation Study
Herein we show how close ZTop (k models) is to the optimal k-model ensemble, computed by enumerating all possible k-model combinations, out of the top 100 validation models.  Figure 6. The approximation ratio of performance between ZTop (3 best validation models wrt φ) and the optimal 3 models (out of top 100 validation models). n = number of graph vertices.
We only consider ensembles of size 3 since enumerating all the combinations requires considerable time. We compute the optimal 3-model ensemble (out of the top 100 validation models), for the different routing problems. The approximation ratios (Fig 6) are close to 1, the worst case is 98.97, which shows how ZTop'strategy is near-optimal, given the top 100 validation models, implicitly selecting good and diverse models (heuristics) for these combinatorial problems.

Conclusion
We introduce the Zero Training Overhead Portfolio (ZTop) method, a simple yet effective model selection and ensemble mechanism to select a set of diverse models for learning to solve combinatorial problems. We demonstrate how ZTopping substantially improves the current state of the art deep learning frameworks on the hardest unique-solution Sudokus, a series of routing problems, the graph maximum cut problem, and multi-label classification.