Title: Maximum Independent Set: Self-Training through Dynamic Programming
Venue: NeurIPS 2023
Accepted: yes
Keywords: Maximum Independent Set

Combinatorial Optimization

Graph Neural Networks

Dynamic Programming
Abstract: This work presents a graph neural network (GNN) framework for solving the maximum independent set (MIS) problem, inspired by dynamic programming (DP). Specifically, given a graph, we propose a DP-like recursive algorithm based on GNNs that firstly constructs two smaller sub-graphs, predicts the one with the larger MIS, and then uses it in the next recursive call. To train our algorithm, we require annotated comparisons of different graphs concerning their MIS size. Annotating the comparisons with the output of our algorithm leads to a self-training process that results in more accurate self-annotation of the comparisons and vice versa. We provide numerical evidence showing the superiority of our method vs prior methods in multiple synthetic and real-world datasets.

Maximum Independent Set: Self-Training through Dynamic Programming

Abstract

This work presents a graph neural network (GNN) framework for solving the maximum independent set (MIS) problem, inspired by dynamic programming (DP). Specifically, given a graph, we propose a DP-like recursive algorithm based on GNNs that firstly constructs two smaller sub-graphs, predicts the one with the larger MIS, and then uses it in the next recursive call. To train our algorithm, we require annotated comparisons of different graphs concerning their MIS size. Annotating the comparisons with the output of our algorithm leads to a self-training process that results in more accurate self-annotation of the comparisons and vice versa. We provide numerical evidence showing the superiority of our method vs prior methods in multiple synthetic and real-world datasets.

1 Introduction

Deep neural networks (DNNs) have achieved unprecedented success in extracting intricate patterns directly from data without the need for handcrafted rules, while still generalizing well to new and previously unseen instances [He et al., 2016, Vaswani et al., 2017]. Among other applications, this success has led to the development of frameworks that utilize DNNs to solve combinatorial optimization (CO) problems, such as the Traveling Salesman Problem [Xing and Tu, 2020, Hu et al., 2020, Prates et al., 2019], the Job-Shop Scheduling Problem [Zhang et al., 2020, Park et al., 2021], and the Quadratic Assignment Problem [Nowak et al., 2017].

A core challenge for deep learning approaches on CO is the lack of training data. Annotating such data requires the solution of a huge number of instances of the CO, hence such supervised learning approaches are computationally infeasible for NP -hard problems [Yehuda et al., 2020]. Circumventing this difficulty is key to unlocking the full potential of otherwise broadly applicable DNNs for CO.

Our work demonstrates how classical ideas in CO together with DNNs can lead to a scalable selfsupervised learning approach, mitigating the lack of training data. Concretely, we focus on the Maximum Independent Set (MIS) problem: Given a graph G ( V, E ) , MIS asks for a set of nodes of maximum cardinality such that no two nodes in the selected set are connected with an edge. MIS is an NP -hard problem with several hand-crafted heuristics (e.g., greedy heuristic , local search ). More recently, several deep learning approaches have been proposed [Karalias and Loukas, 2020, Toenshoff et al., 2019, Schuetz et al., 2022a].

Our approach involves the following steps to determine an MIS in a graph. We use graph neural networks (GNNs) [Wu et al., 2020] to enable a model to generate approximate maximum independent sets after training on data that was annotated by the model itself. For this purpose, we draw inspiration

from dynamic programming (DP) and employ a DP-like recursive algorithm. Initially, we are given a graph. At each recursive step, we select a random vertex from that graph and create two sub-graphs: one by removing the selected vertex and another by removing all its neighboring vertices. We then make a comparison between these sub-graphs to determine which sub-graph is likely to have a larger independent set, and we use the sub-graph with the highest estimated independent set for the next recursive call. We repeat this process until we reach a graph consisting only of isolated vertices, which signifies the discovery of an independent set for the original graph.

Dynamic programming guarantees that if our predictions are accurate (i.e., we select the sub-graph with the largest MIS value), our recursive algorithm will always result in a maximum independent set. To make accurate predictions, we introduce 'graph comparing functions,' which take two graphs as input and output a winner. We implement such graph-comparing functions with GNNs.

We adopt a self-training approach to train our graph-comparing function and optimize the parameters of the GNN. In each epoch, we update the graph-comparing function parameters to ensure it accurately fits the data it has seen so far. The data comprises pairs of graphs ( G,G ′ ) along with a label Label( G,G ′ ) ∈ { 0 , 1 } . For annotating the labels, we utilize the output of the recursive algorithm that leverages the graph-comparing function. Supported by theoretical and experimental evidence, we demonstrate how the self-annotation process improves parameter selection.

We conduct a thorough validation of our self-training approach in three real-world graph distribution datasets. Our algorithm surpasses the performance of previous deep learning methods [Karalias and Loukas, 2020, Toenshoff et al., 2019, Ahn et al., 2020] in the context of the MIS problem. To further validate the efficacy of our method, we explore its robustness on out-of-distribution data. Notably, our results demonstrate that the induced algorithm achieves competitive performance, showcasing the generalization capability of the learned comparator across different graph structures and distributions. In addition, we extend the evaluation of our DP-based self-training approach to tackle the Minimum Vertex Cover (MVC) problem in Appendix E. Encouragingly, similar to the MIS case, our induced GNN-based algorithms for MVC admit competitive performance with respect to other deep-learning approaches.

The code for the experiments and models discussed in this paper is available at: https://github. com/LIONS-EPFL/dynamic-MIS .

2 Related Work

Our work lies in the intersection of various domains, i.e., combinatorial optimization, Dynamic Programming, and (graph) neural networks. We review the most critical ideas in each domain here and defer a more detailed discussion in Appendix A.

Graph Neural Networks (GNNs) have gained widespread popularity due to their ability to learn representations of graph-structured data [Xiao et al., 2022, Zhang and Chen, 2018, Zhu et al., 2021, Errica et al., 2019] invariant to the size of the graph. More complex architectural blocks, such as the Graph Convolutional Network (GCN) [Kipf and Welling, 2017, Zhang et al., 2019], the Graph Attention Network (GAT) [Veliˇ ckovi´ c et al., 2017], and the Graph Isomorphism Network [Xu et al., 2018] have become influential instances of GNNs. In our work, we utilize a simple GNN architecture to showcase the effectiveness of our proposed framework. While our choice of architecture is intentionally simple, we emphasize its modular nature, which enables us to incorporate more complex GNNs with ease.

Combinatorial Optimization : Supervised learning approaches have been used for tackling CO tasks, such as the Traveling Salesman Problem (TSP) [Vinyals et al., 2015], the Vehicle Routing Problem (VRP) [Shalaby et al., 2021], and Graph Coloring [Lemos et al., 2019]. Due to the graph structure of the problems, GNNs are often used for tackling those tasks [Prates et al., 2019, Nazari et al., 2018, Schuetz et al., 2022b]. However, owing to the computational overhead of obtaining supervised labels, such supervised approaches often do not scale well. Instead, unsupervised approaches have been deployed recently [Wang and Li, 2023]. A popular approach relies on a continuous relaxation of the loss function [Karalias and Loukas, 2020, Wang et al., 2022, Wang and Li, 2023]. In contrast to the previous unsupervised works, we adopt Dynamic Programming techniques to diminish the overall time complexity of the algorithm. Another approach uses reinforcement learning (RL) methods to address CO tasks, such as in Covering Salesman Problem [Li et al., 2021], the TSP [Zhang et al.,

2022], the VRP [James et al., 2019], and the Minimum Vertex Cover (MVC) [Tian and Li, 2021]. However, applying RL to CO problems can be challenging because of the long learning time required and the non-differentiable nature of the loss function.

Dynamic Programming has been a powerful problem-solving technique since at least the 50s [Bellman, 1954]. In recent years, researchers have explored the use of deep neural networks (DNNs) to replace the function responsible for dividing a problem into subproblems and estimating the optimal decision at each step [Yang et al., 2018]. Despite the progress, implementing CO tasks with Dynamic Programming suffers from significant computational overheads, since the size of the search space grows exponentially with the problem size [Xu et al., 2020]. Our approach overcomes this issue by utilizing a model that approximates the standard lookup table from Dynamic Programming, meaning that we avoid the exponential search space typically associated with DP.

3 An Optimal Solution to Maximum Independent Set (MIS)

Firstly, let us introduce MIS and its relationship with Dynamic Programming.

Notation : G ( V, E ) denotes an undirected graph where V stands for vertices and E for the edges. N ( v ) denotes the neighbors of vertex v ∈ V , N ( v ) = { u ∈ V : ( u, v ) ∈ E } . The degree of vertex v ∈ V is d ( v ) := |N ( v ) | . Given a set of vertices S ⊆ V , G/S denotes the remaining graph of G after removing all nodes v ∈ S .

Definition 1 (Maximum Independent Set) . Given an undirected graph G ( V, E ) , find a maximum set of nodes S ⊆ V such that ( u, v ) / ∈ E for all vertices u, v ∈ S . We denote with | MIS( G ) | the size of the maximum independent set of graph G .

Dynamic Programming is a powerful technique for algorithmic design in which the optimal solution of the instance of interest is constructed by combining the optimal solution of smaller sub-instances. The combination step is governed by local optimality conditions which, in the context of MIS, take the form of Theorem 1. Theorem 1 establishes that the decision to remove a node v ∈ V or its neighbors N ( v ) during the recursive process depends on whether | MIS( G/ N ( v )) | ≥ | MIS( G/v ) | . This decision continues until a graph with no edges is reached. According to Theorem 1, if at each step of the recursion, the choice is made based on whether | MIS( G/ N ( v )) | ≥ | MIS( G/v ) | or not, then the resulting empty graph is guaranteed to be an optimal solution. The proof is this theorem can be found in Appendix I.

Theorem 1. Let a graph G ( V, E ) ∈ G . Then for any vertex v ∈ V with d ( v ) ≥ 1 ,

4 Graph Neural Network-Based Algorithm for MIS

In this section, we present our approach for developing algorithms for MIS parameterized by parameters θ ∈ Θ . Initially in Sec. 4.1 we present how any graph-comparing function taking as input two different graphs and outputting a { 0 , 1 } value can be used in the construction of an algorithm computing an independent set (not necessarily optimal). In Sec. 4.2 we present how Graph Neural Networks can be used in the construction of such graph-comparing functions. Finally, in Sec. 4.3, we present our inference algorithm that computes an independent set of any graph G ∈ G .

4.1 MIS Algorithms induced by Graph Comparing Functions

Consider a function CMP : G×G ↦→ { 0 , 1 } that compares two graphs G,G ′ based on the size of their MIS. Namely, if | MIS( G ) | ≥ | MIS( G ′ ) | then CMP( G,G ′ ) = 0 and CMP( G,G ′ ) = 1 otherwise.

Theorem 1 ensures that if we have access in such a graph-comparing function then we can compute an independent set of maximum size for any graph G . From a starting node v , with an initial graph from G , and by recursively selecting either G/ { v } or G/ N ( v ) based on | MIS( G/ { v } ) | ≥ | MIS( G/ N ( v )) | , we are ensured to end in an independent set of maximum size. The decision of

Algorithm 1 Randomized Comparator-Induced Algorithm

whether | MIS( G/ { v } ) | ≥ | MIS( G/ N ( v )) | at each recursive call can be made according to the output of CMP( G/ { v } , G/ N ( v )) .

̸

The cornerstone idea of our approach is that any graph-comparing function CMP induces such a recursive algorithm for a MIS. Recursively selecting G/ { v } or G/ N ( v ) based on the output of a graph generating function CMP( G/ { v } , G/ N ( v )) ∈ { 0 , 1 } always guarantees to reach an independent set of the original graph. In case CMP( G,G ′ ) = I [ | MIS( G ) | < | MIS( G ′ ) | ] , where I is the indicator function, it is not guaranteed that the computed independent set is of the maximum size. However, there might exist reasonable graph comparing functions that i ) are efficiently computable ii ) lead to near-optimal solutions.

In Definition 2 and Algorithm 1 we formalize the idea above.

Definition 2. A comparator CMP : G × G ↦→ { 0 , 1 } is a function taking as input two graphs G,G ′ and outputing a { 0 , 1 } value.

Proposition 1. Any comparator CMP : G × G ↦→ { 0 , 1 } induces a randomized algorithm A CMP (Algorithm 1).

Remark 1. Given a graph-comparing function CMP : G × G ↦→ { 0 , 1 } , the induced algorithm is randomized, since at Step 4 of Algorithm 1, a vertex v is randomly selected. Notice that Algorithm 1 recursively proceeds until a subgraph with 0 edges is reached (see Step 2 ).

Remark 2. Two different comparators CMP and CMP ′ induce two different algorithms A CMP and A CMP ′ for estimating the maximum independent set.

4.2 Comparators through Graph Neural Networks

In this section, we discuss the architecture of a model M θ : G ↦→ R , parameterized by θ ∈ Θ , that is used for the construction of a comparator function

In order to embed graph-level information, we introduce a new GNN module, which we refer to as the Graph Embedding Module (GEM). Unlike standard GNN modules, this module captures different semantic meanings of differing embeddings of a node, its neighbors, and anti-neighbors.

Graph Embedding Module (GEM) :

The GEM operates using the following recursive formula:

Initially, all nodes in this graph have zeros embeddings µ 0 v = ⃗ 0 ∈ R 3 p . Here, µ 0 v denotes the initial embedding vector of node v . In Eq. (1), for all iterations k ∈ [0 , . . . , K -1] , the embeddings of a

for

iterations

: Neighbors

: Anti-neighbors

node denoted by µ k v ∈ R 3 p , its neighbors, and its anti-neighbors v are put through their own linear layers, denoted by θ k 0 , θ k 1 , θ k 2 ∈ R p × 3 p , which are the parameters of the module. The bias term is omitted in the equation for readability purposes. We incorporate anti-neighbors in the GEM to capture complementary relationships between nodes. By using separate linear layers for different features, we emphasize the contrasting semantic meaning between neighbors and anti-neighbors, representing negative and positive relationships in the graph. Then, the individual feature embeddings are concatenated, which is denoted by [ . . . ∥ . . . ] , followed by a GELU activation function [Hendrycks and Gimpel, 2016] and layer normalization [Ba et al., 2016a]. We note that the computational complexity of this module is O ( | V | 2 ) .

The complete model architecture is depicted in Fig. 1. At a high level, the architecture uses a Graph Embedding Module to extract a global graph embedding from the input graph, which is then passed through a set of fully connected layers to output a logit for that graph. During the training process of the comparator function, we utilize CMP θ ( G,G ′ ) = softmax ([ M θ ( G ) ∥ M θ ( G ′ )]) , which forms a differentiable loss function for classification.

4.3 Inference Algorithm

In the previous section, we discussed how a parameterization θ ∈ Θ defines the graph-comparing function CMP θ ( G,G ′ ) = I [ M θ ( G ) < M θ ( G ′ )] . As a result, the same parameterization θ ∈ Θ defines an algorithm A CMP θ , where at Step 6 of Algorithm 1, the comparing function CMP θ is used. Since the number of graph comparisons is upper-bounded by | V | , the inference algorithm admits to a computational complexity of O ( | V | 3 ) .

5 Self-Supervised Training through the Consistency Property

In this section, we present our methodology for selecting the parameters θ ∈ Θ so that the resulting inference algorithm A CMP θ ( · ) computes independent sets with (close to) the maximum value.

The most straightforward approach is to select the parameters θ ∈ Θ such that CMP θ ( G,G ′ ) ≃ I [ | MIS( G ) | < | MIS( G ′ ) | ] using labeled data. The problem with this approach is that a huge amount of annotated data of the form { (( G,G ′ ) , I [ | MIS( G ) | < | MIS( G ′ ) | ]) } are required. Since finding the MIS is an NP -Hard problem, annotating such data comes with an insurmountable computational burden.

The key idea to overcome the latter limitation is to annotate the data of the form { ( G,G ′ ) } by using the algorithm A CMP θ ( · ) that runs in polynomial time with respect to the size of the graph. Intuitively, our proposed framework entails the optimization of the parameterized comparator function CMP θ on data generated using algorithm A CMP θ . A better comparator function leads to a better algorithm, which leads to better data, and vice versa. This mutually reinforcing relationship between the two components of our framework is theoretically indicated by Theorem 2 that we present in Section 5.1. The exact steps are detailed below.

5.1 Consistent Graph Comparing Functions

In this section, we introduce the notion of a consistent graph-comparing function (Definition 3) that plays a critical role in our self-supervised learning approach. Kindly take note that A CMP utilizes the unparameterized variant of a comparator function, whereas A CMP θ utilizes its parameterized counterpart.

Definition 3 (Consistency) . A graph-comparing function CMP : G×G ↦→ { 0 , 1 } is called consistent if and only if for any pair of graphs G,G ′ ∈ G ,

Remark 3. In Definition 3 we use E [∣ ∣ A CMP ( G ) ∣ ∣ ] , E [∣ ∣ A CMP ( G ′ ) ∣ ∣ ] since, as we have already discussed, a comparator CMP induces a randomized algorithm A CMP , where the expectation is over the nodes in the graphs.

In Theorem 2, we formally establish that any consistent graph-comparing function CMP induces an optimal algorithm for the MIS.

Theorem 2. Consider a consistent comparator CMP : G×G ↦→ { 0 , 1 } . Then, the algorithm A CMP ( · ) always computes a Maximum Independent Set, E [∣ ∣ A CMP ( G ) ∣ ∣ ] = | MIS( G ) | for all G ∈ G .

Theorem 2 guarantees that any consistent graph comparing function CMP induces an optimal algorithm A CMP for MIS. The proof for this theorem can be found in Appendix I. Hence, the selection of parameters θ ⋆ ∈ Θ should be selected such that CMP θ ⋆ is consistent . More precisely:

Goal of Training: Find parameters θ ⋆ ∈ Θ such that for all G,G ′ ∈ G :

5.2 Training a Consistent Comparator

The cornerstone idea of our self-supervised learning approach is to make the comparator more and more consistent over time. Namely, the idea is to update the parameters as follows:

where ℓ ( · , · ) is a binary classification loss. In Eq. (2), θ t are the fixed parameters of the previous epoch. Thus, in the next few paragraphs, we only use the notation A CMP θ t to denote the fixed parameters. Gradient updates are only computed over θ .

Remark 4. We remark that neither solving the non-convex minimization problem of Eq. (2) nor the existence of parameters θ ⋆ ∈ Θ such that CMP θ ⋆ can be guaranteed. However, using a first-order method for Eq. (2) and a large enough parameterization can lead to an approximately consistent comparator with approximately optimal performance.

In Algorithm 2, we present the basic pipeline of the self-training approach that selects the parameters θ ∈ Θ such that the inference algorithm A CMP θ t admits a competitive performance given as input graphs G following a graph distribution D ⊆ G . We further improve this basic pipeline with several tweaks that we incorporate into our training process:

Creating a graph buffer B : Weare given a shuffled dataset of graphs D , which represents the training data for the model. The core difference between the pipeline and the training process comes from the graph buffer B . In Algorithm 2, this buffer stores any graph G that is found during the recursive call of A CMP θ t ( G init ) on G init ∼ D (Step 6 of Algorithm 2). However, in the implementation of the graph buffer, it stores pairs of graphs ( G,G ′ ) that were generated by A CMP θ t ( G init ) , alongside a binary label that indicates which of the two graphs has a larger estimated MIS size. How this estimate is generated, will be explained further down this section.

The training process: Prior to starting training, we first set two hyperparameters: one that specifies the number of graphs used to populate the buffer before training the model, and another that determines the number of graph pairs generated from A CMP θ t ( G ) per graph G ∼ D . Then, a dataset is created by generating these pairs for the set number of graphs. The dataset is then added to the graph buffer,

Algorithm 2 Basic Pipeline of our Training Approach

1: Input: A distribution D over graphs.

2: Initialize parameters θ 0 ∈ Θ .

3: Initialize a graph-buffer B ← ∅ .

4: for each epoch t = 0 , . . . , T -1 do

5: Sample a graph G init ∼ D .

6: Run A CMP θ t ( G init ) and store in B all graphs produced during each recursive call of Algorithm 1.

7: Update the parameters θ ∈ Θ such that

t +1 θ t +1 := argmin θ ∈ Θ E ( G,G ′ ) ∼B [ ℓ ( CMP θ ( G,G ′ ) , I [ E [ |A CMP θ t ( G ) | ] < E [ |A CMP θ t ( G ′ ) |

8: end for

Step (1) Computing

and populating

Step (2) Creating dataset from samples in

Computing

(roll-out)

Constructing dataset with pairwise samples

replacing steps 5 and 6 in Algorithm 2, which only does this with one graph per epoch. Next, training starts, and after completing a set number of epochs, a new dataset is created using the updated model, and the process is repeated iteratively.

Estimating the MIS: Finally, the loss function in Step 7 of Algorithm 2, also operates slightly differently. The main difference arises from I [ E [ |A CMP θ t ( G ) | ] < E [ |A CMP θ t ( G ′ ) | ]] , since the estimates | MIS( G ) | ≈ E [ |A CMP θ t ( G ) | ] and | MIS( G ′ ) | ≈ E [ |A CMP θ t ( G ′ ) | ] are not directly utilized. Instead, we propose two other approaches, which are better approximations than the expectations used in Algorithm 2, since they use a maximizing operator.

The first approach involves performing so-called "roll-outs" on the graph pairs generated G and G ′ by A CMP θ t , in order to estimate their MIS sizes. To perform the roll-outs, we simply run A CMP θ t on graphs G and G ′ m times and use the maximum size of the found independent sets as an estimate of their MIS. Formally, in a roll-out on a graph G , we sample the independent sets ISS 1 , ISS 2 , . . . , ISS m ∼ A CMP θ t ( G ) . Then, the estimate of the MIS size of G is max( | ISS 1 | , | ISS 2 | , . . . , | ISS m | ) .

An example of the entire process of generating the dataset using roll-outs can be found in Fig. 2. In practice, we observe an increasing consistency of the model during training, as can be seen in Appendix J.

Mixed roll-out variant : We introduce a variant of the aforementioned method, which utilizes the deterministic greedy algorithm. This greedy algorithm iteratively creates an independent set by removing the node with the lowest degree and adding it to the independent set. This algorithm is often an efficient approximation to the optimum solution. Our variant is constructed as follows: we compute the maximum between the roll-outs of the model and the result of the greedy algorithm, which creates a dataset with more accurate self-supervised approximations of the MIS values. This, in turn, generates binary targets for the buffer that are more likely to be accurate. Thus, for this second variant, the estimate of the MIS size of a graph G would be max( | Greedy( G ) | , | ISS 1 | , | ISS 2 | , . . . , | ISS m | ) .

6 Experiments

In this section, we conduct an evaluation of the proposed method for the MIS problem. Let us first describe the training setup, the baselines, and the datasets. Additional details and experiments on MIS are displayed in the Appendices C and D. Our method also generalizes well in MVC, as the results in Appendix E illustrate.

6.1 Training Setup

Our model : We implement two comparator models: one using just roll-outs with the model, and another using the roll-outs together with greedy, called "mixed roll-out". We train each model using a graph embedding module with K = 3 iterations, which takes in 32 -dimensional initial node embeddings.

Baselines : We compare against the neural approaches Erdos GNN [Karalias and Loukas, 2020], RUNCSP from Toenshoff et al. [2019], and a method specifically for the MIS problem: LwDMIS [Ahn et al., 2020]. Since we observe unexpected poor performances from RUN-CSP on the COLLAB and RB datasets, we have omitted those results from the table. We train every model for 300 epochs. Each experiment is performed on a single GPU with 6GB RAM.

Besides neural approaches, we use traditional baselines, such as the Greedy MIS [Wormald, 1995] , Simple Local Search [Feo et al., 1994] and a Random Comparator as a sanity check. Furthermore, we implement two mixed-integer linear programming solvers: SCIP 8.0.3 and the highly optimized commercial solver Gurobi 10.0 .

Datasets : We evaluate our model on three standard datasets, following Karalias and Loukas [2020]: COLLAB [Yanardag and Vishwanathan, 2015], TWITTER [Leskovec and Krevl, 2014] and RB [Xu et al., 2007, Toenshoff et al., 2019]. In addition, we introduce the SPECIAL dataset that includes challenging graphs for handcrafted approaches as we detail in Appendix C.

6.2 Results

Table 1 reports the average approximation ratios on the test instances of the various datasets. The approximation ratio is computed by dividing a solution's independent set size by the optimum solution, which is computed using the Gurobi solver with a time limit of 1 hour per graph.

The results indicate that the greedy algorithm performs strongly in three of the four datasets, which is consistent with the observation of Angelini and Ricci-Tersenghi [2022]. However, notice that our proposed approach outperforms the greedy in both the Twitter and the SPECIAL datasets, which validates that the greedy heuristic is not optimal in every case and is prone to failing in few cases. Importantly, among the neural approaches that are the main compared methods, our proposed method performs favorably in all datasets. The performance of our method indicates that the proposed self-training scheme is able to learn from diverse data distributions and generalize reasonably well in the test sets of the respective dataset. In addition, the proposed method is faster than the rest neural approaches.

The mixed roll-out model in Table 1 outperforms the normal roll-out model in almost all datasets, indicating the effectiveness of the greedy heuristic in roll-outs. This is particularly evident in the RB dataset. However, for SPECIAL instances, the normal model performs marginally better, possibly due to the unsuitability of the greedy guiding heuristic as a baseline for this dataset.

Out of distribution: We examine the performance of the learned comparator through its generalization to new graph distributions. Concretely, we conduct an out-of-distribution analysis as follows:

each model is trained in one graph distribution, indicated by the rows of Table 2. Then, the model is evaluated on different graph distributions, indicated by the columns of Table 2. The analysis is conducted on both our model and the approach of Erdos GNN [Karalias and Loukas, 2020].

Surprisingly, our model trained over COLLAB displays good generalization skills across different datasets, even outperforming the RB-trained model on the RB dataset. Conversely, Erdos GNN trained over RB performs poorly over the COLLAB dataset. Both models trained over the RB dataset perform more poorly in general, likely due to the highly specific graph distribution of the RB dataset. Moreover, our model, on the whole, exhibits good generalization skills over different graph distributions.

7 Conclusion

Motivated by the principles of Dynamic Programming, we develop a self-training approach for important CO problems, such as the Maximum Independent Set and the Minimum Vertex Cover. Our approach embraces the power of self-training, offering the dual benefits of data self-annotation and data generation. These inherent attributes are instrumental in providing an unlimited source of data indicating that the performance of the induced algorithms can be significantly improved with sufficient scaling on the computational resources. We firmly believe that a thorough investigation into the interplay between Dynamic Programming and self-training techniques can pave the way for new deep-learning-oriented approaches for demanding CO problems.

Limitations : Our current empirical approach lacks theoretical guarantees on the convergence or the approximate optimality of the obtained algorithm. Additionally, the implemented GNN is using simple modules, while more complex modules could result in further empirical improvements, which can be the next step in this direction. Furthermore, randomly selecting a vertex could be sub-optimal. One interesting future direction would be to explore predicting the next vertex to select.

References

Sungsoo Ahn, Younggyo Seo, and Jinwoo Shin. Learning what to defer for maximum independent sets. International Conference on Machine Learning (ICML) , 2020.

Réka Albert and Albert-László Barabási. Statistical mechanics of complex networks. Reviews of modern physics , 74(1):47, 2002.

Maria Chiara Angelini and Federico Ricci-Tersenghi. Cracking nuts with a sledgehammer: when modern graph neural networks do worse than classical greedy algorithms. arXiv preprint arXiv:2206.13211 , 2022.

Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E. Hinton. Layer normalization, 2016a.

Jimmy Lei Ba, Jamie Ryan Kiros, and Geoffrey E Hinton. Layer normalization. arXiv preprint arXiv:1607.06450 , 2016b.

Richard Bellman. The theory of dynamic programming. BULL , 60(6):503-515, 1954.

Richard Bellman. Dynamic programming treatment of the travelling salesman problem. JACM , 9(1): 61-63, 1962.

Paul Erd˝ os, Alfréd Rényi, et al. On the evolution of random graphs. Publ. Math. Inst. Hung. Acad. Sci , 5(1):17-60, 1960.

Federico Errica, Marco Podda, Davide Bacciu, and Alessio Micheli. A fair comparison of graph neural networks for graph classification. arXiv preprint arXiv:1912.09893 , 2019.

Thomas A Feo, Mauricio GC Resende, and Stuart H Smith. A greedy randomized adaptive search procedure for maximum independent set. Journal of Global Optimization , 42(5):860-878, 1994.

Maxime Gasse, Didier Chételat, Nicola Ferroni, Laurent Charlin, and Andrea Lodi. Exact combinatorial optimization with graph convolutional neural networks. NIPS , 32, 2019.

Kaiming He, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. Deep residual learning for image recognition. In Conference on Computer Vision and Pattern Recognition (CVPR) , pages 770-778, 2016.

Dan Hendrycks and Kevin Gimpel. Gaussian error linear units (gelus). arXiv preprint arXiv:1606.08415 , 2016.

Yujiao Hu, Yuan Yao, and Wee Sun Lee. A reinforcement learning approach for optimizing multiple traveling salesman problems over graphs. Knowledge-Based Systems , 204:106244, 2020.

JQ James, Wen Yu, and Jiatao Gu. Online vehicle routing with neural combinatorial optimization and deep reinforcement learning. IEEE Transactions on Intelligent Transportation Systems , 20 (10):3806-3817, 2019.

Steven James, George Konidaris, and Benjamin Rosman. An analysis of monte carlo tree search. AAAI Conference on Artificial Intelligence , 31(1), Feb. 2017. URL https://ojs.aaai.org/ index.php/AAAI/article/view/11028 .

Nikolaos Karalias and Andreas Loukas. Erdos goes neural: an unsupervised learning framework for combinatorial optimization on graphs. Advances in neural information processing systems (NeurIPS) , 33:6659-6672, 2020.

Maryam Karimi-Mamaghan, Mehrdad Mohammadi, Patrick Meyer, Amir Mohammad KarimiMamaghan, and El-Ghazali Talbi. Machine learning at the service of meta-heuristics for solving combinatorial optimization problems: A state-of-the-art. EJOR , 296(2):393-422, 2022.

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

Thomas N Kipf and Max Welling. Semi-supervised classification with graph convolutional networks. International Conference on Learning Representations (ICLR) , 2017.

Henrique Lemos, Marcelo Prates, Pedro Avelar, and Luis Lamb. Graph colouring meets deep learning: Effective graph neural network models for combinatorial problems. In International Conference on Tools for Artificial Intelligence (ICTAI) , pages 879-885. IEEE, 2019.

Jure Leskovec and Andrej Krevl. SNAP Datasets: Stanford large network dataset collection. http: //snap.stanford.edu/data , June 2014.

Kaiwen Li, Tao Zhang, Rui Wang, Yuheng Wang, Yi Han, and Ling Wang. Deep reinforcement learning for combinatorial optimization: Covering salesman problems. IEEE Transactions on Cybernetics , 52(12):13142-13155, 2021.

Zhuwen Li, Qifeng Chen, and Vladlen Koltun. Combinatorial optimization with graph convolutional networks and guided tree search. Advances in neural information processing systems (NeurIPS) , 31, 2018.

Nina Mazyavkina, Sergey Sviridov, Sergei Ivanov, and Evgeny Burnaev. Reinforcement learning for combinatorial optimization: A survey. COR , 134:105400, 2021.

Christopher Morris, Nils M. Kriege, Franka Bause, Kristian Kersting, Petra Mutzel, and Marion Neumann. Tudataset: A collection of benchmark datasets for learning with graphs. In International Conference on Machine Learning (ICML) , 2020. URL www.graphlearning.io .

Mohammadreza Nazari, Afshin Oroojlooy, Lawrence Snyder, and Martin Takác. Reinforcement learning for solving the vehicle routing problem. Advances in neural information processing systems (NeurIPS) , 31, 2018.

Alex W. Nowak, Soledad Villar, Afonso S. Bandeira, and Joan Bruna. A note on learning algorithms for quadratic assignment with graph neural networks. ArXiv , abs/1706.07450, 2017.

Junyoung Park, Sanjar Bakhtiyar, and Jinkyoo Park. Schedulenet: Learn to solve multi-agent scheduling problems with reinforcement learning, 2021.

Marcelo Prates, Pedro HC Avelar, Henrique Lemos, Luis C Lamb, and Moshe Y Vardi. Learning to solve np-complete problems: A graph neural network for decision tsp. In AAAI Conference on Artificial Intelligence , volume 33, pages 4731-4738, 2019.

Martin JA Schuetz, J Kyle Brubaker, and Helmut G Katzgraber. Combinatorial optimization with physics-inspired graph neural networks. Nature Machine Intelligence , 4(4):367-377, 2022a.

Martin JA Schuetz, J Kyle Brubaker, Zhihuai Zhu, and Helmut G Katzgraber. Graph coloring with physics-inspired graph neural networks. Physical Review Research , 4(4):043131, 2022b.

Ulrich Schwalbe and Paul Walker. Zermelo and the early history of game theory. Games and economic behavior , 34(1):123-137, 2001.

Mohamed A Wahby Shalaby, Ayman R Mohammed, and Sally S Kassem. Supervised fuzzy c-means techniques to solve the capacitated vehicle routing problem. IAJIT , 18(3A):452-463, 2021.

Hong Tian and Dazi Li. Graph convolutional neural networks with am-actor-critic for minimum vertex cover problem. In 2021 33rd Chinese Control and Decision Conference (CCDC) , pages 3841-3846. IEEE, 2021.

Jan Toenshoff, Martin Ritzert, Hinrikus Wolf, and Martin Grohe. Run-csp: unsupervised learning of message passing networks for binary constraint satisfaction problems. CoRR , 2019.

Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N Gomez, Łukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in neural information processing systems (NeurIPS) , pages 5998-6008, 2017.

Petar Veliˇ ckovi´ c, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, and Yoshua Bengio. Graph attention networks. arXiv preprint arXiv:1710.10903 , 2017.

Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. NeurIPS , 28, 2015.

Haoyu Wang and Pan Li. Unsupervised learning for combinatorial optimization needs meta-learning. arXiv preprint arXiv:2301.03116 , 2023.

Haoyu Peter Wang, Nan Wu, Hang Yang, Cong Hao, and Pan Li. Unsupervised learning for combinatorial optimization with principled objective relaxation. In NIPS , 2022.

Duncan J Watts and Steven H Strogatz. Collective dynamics of 'small-world'networks. nature , 393 (6684):440-442, 1998.

Nicholas C Wormald. Differential equations for random processes and random graphs. AAP , pages 1217-1235, 1995.

Zonghan Wu, Shirui Pan, Fengwen Chen, Guodong Long, Chengqi Zhang, and S Yu Philip. A comprehensive survey on graph neural networks. IEEE transactions on neural networks and learning systems , 32(1):4-24, 2020.

Shunxin Xiao, Shiping Wang, Yuanfei Dai, and Wenzhong Guo. Graph neural networks in node classification: survey and evaluation. Mach. Vis. Appl. , 33:1-19, 2022.

Zhihao Xing and Shikui Tu. A graph neural network assisted monte carlo tree search approach to traveling salesman problem. IEEE Access , 8:108418-108428, 2020.

Zhihao Xing, Shikui Tu, and Lei Xu. Solve traveling salesman problem by monte carlo tree search and deep neural network. arXiv preprint arXiv:2005.06879 , 2020.

Ke Xu, Frédéric Boussemart, Fred Hemery, and Christophe Lecoutre. Random constraint satisfaction: Easy generation of hard (satisfiable) instances. Artificial intelligence , 171(8-9):514-534, 2007.

Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. How powerful are graph neural networks? arXiv preprint arXiv:1810.00826 , 2018.

Ruiyang Xu and Karl Lieberherr. Learning self-play agents for combinatorial optimization problems. KER , 35:e11, 2020.

Shenghe Xu, Shivendra S Panwar, Murali Kodialam, and TV Lakshman. Deep neural network approximated dynamic programming for combinatorial optimization. In Proceedings of the AAAI Conference on Artificial Intelligence , volume 34, pages 1684-1691, 2020.

Pinar Yanardag and S. V. N. Vishwanathan. Deep graph kernels. SIGKDD , 2015.

Feidiao Yang, Tiancheng Jin, Tie-Yan Liu, Xiaoming Sun, and Jialin Zhang. Boosting dynamic programming with neural networks for solving np-hard problems. In ACML , pages 726-739. PMLR, 2018.

Gal Yehuda, Moshe Gabel, and Assaf Schuster. It's not what machines can learn, it's what we cannot teach. In ICML , pages 10831-10841. PMLR, 2020.

Cong Zhang, Wen Song, Zhiguang Cao, Jie Zhang, Puay Siew Tan, and Xu Chi. Learning to dispatch for job shop scheduling via deep reinforcement learning. Advances in neural information processing systems (NeurIPS) , 33:1621-1632, 2020.

Muhan Zhang and Yixin Chen. Link prediction based on graph neural networks. NeurIPS , 31, 2018.

Rongkai Zhang, Cong Zhang, Zhiguang Cao, Wen Song, Puay Siew Tan, Jie Zhang, Bihan Wen, and Justin Dauwels. Learning to solve multiple-tsp with time window and rejections via deep reinforcement learning. IEEE Transactions on Intelligent Transportation Systems , 2022.

Si Zhang, Hanghang Tong, Jiejun Xu, and Ross Maciejewski. Graph convolutional networks: a comprehensive review. Computational Social Networks , 6(1):1-23, 2019.

Zhaocheng Zhu, Zuobai Zhang, Louis-Pascal Xhonneux, and Jian Tang. Neural bellman-ford networks: A general graph neural network framework for link prediction. NeurIPS , 34:2947629490, 2021.

Contents of the Appendix

We describe the contents of the supplementary material below:

In Appendix A, we provide further information on the prior work and related research, including additional references and links to relevant papers.

In Appendix B, we explore applications of our method beyond the MIS problem. Specifically, we discuss how our method can be applied to the Minimum Vertex Cover (MVC) problem.

In Appendix C, we provide detailed experimental details used in our experiments.

In Appendix D, we present additional experiments conducted specifically on the MIS problem.

In Appendix E, we extend our investigations to the MVC problem. We present experimental results on benchmarks and discuss the performance and insights gained from the experiments.

Appendix F provides additional background information on relevant concepts related to the MIS and MVC problems.

In Appendix G, we present an ablation study where we systematically analyze the impact of different architecture configurations in our method.

Appendix H delves into the broader impact of our work, discussing the potential implications of using our self-supervised approach for CO problems.

In Appendix I, we provide the omitted proofs of theorems mentioned in the main paper.

Finally, in Appendix J, we gain some insight into the decisions of the comparator through the consistency property.

A Additional Links to Prior Work

In Appendix A.1, we delve into an analysis of multiple deep learning techniques for solving CO (Combinatorial Optimization) problems, including how different works have addressed the noncontinuity of the loss function. Additionally, in Appendix A.2 we provide a brief explanation of Dynamic Programming and Monte Carlo Tree Search.

A.1 Deep Learning Approaches for CO

The growing interest in employing machine learning techniques to tackle combinatorial optimization problems has led to addressing the task using different neural approaches [Karimi-Mamaghan et al., 2022, Mazyavkina et al., 2021]. Moreover, some works combine elements from classic heuristics with deep learning techniques, like branch-and-bound [Gasse et al., 2019] and local search [Li et al., 2018].

As we mention in Sec. 2, several works use a continuous relaxation of the loss function. Following the settings of Wang and Li [2023], CO problems consist of assigning values to discrete optimization variables X = ( x i ) 1 ≤ i ≤ n ∈ { 0 , 1 } n such that an energy (or loss) function F ( G,X ) is minimized or maximized in X . Since F ( G,X ) is not continuous, Karalias and Loukas [2020] employs a relaxed probabilistic loss function, which is later refined by Wang et al. [2022] by assuming continuous values and taking the values of F ( G,X ) at the discrete points X . Since some CO problems require instancewise good solutions , Wang and Li [2023] focuses more on obtaining good initialization instances. Given that certain CO issues necessitate the acquisition of individual-level optimal solutions , Wang and Li [2023] places greater emphasis on attaining favorable initializations for subsequent instances rather than providing immediate solutions.

A.2 Dynamic Programming

Dynamic Programming is especially effective for solving problems that demonstrate the principle of optimality. This principle states that an optimal solution to a problem can be achieved by recursively finding the optimal solutions to smaller subproblems.

Xu et al. [2020] utilize DNNs to replace the function responsible for dividing a problem into subproblems and estimating the optimal decision at each step. Their results demonstrate significant

reductions in computation time for classical combinatorial optimization problems such as the 'TSP', compared to the Bellman-Held-Karp algorithm [Bellman, 1962].

The work of Yang et al. [2018] addresses the problem of the size of the lookup table, which may require exponential space, used to store solutions of sub-problems in Dynamic Programming. In their work, Yang et al. [2018] argue that it is possible to approximate a Dynamic Programming function with a much smaller neural network.

The Dynamic Programming Tree (DPT) is often employed for solving CO tasks. Each node of the tree represents a problem, and its child nodes represent two sub-problems derived from it. The DPT is designed to explore the solution space of a problem similar to Dynamic Programming, but it only considers a subset of the possible solutions due to the large size of the solution space. To construct the DPT, a Monte Carlo Tree Search (MCTS) technique [James et al., 2017] is utilized. The MCTS algorithm begins at the root node and navigates the tree to add new nodes to the structure. Upon reaching a new leaf node, MCTS employs a simulation to estimate the value of the node. The results of these simulations are subsequently backpropagated up through the tree, updating the node values accordingly.

Due to the reasons stated above, Monte Carlo Tree Search (MCTS) and other tree search methods have been utilized in the context of CO problems as a replacement for pure Dynamic Programming. MCTS is capable of significantly reducing computational complexity as it operates on a smaller search space. In Xing et al. [2020], MCTS is employed to solve the TSP problem on graphs with a maximum of 100 nodes. Additionally, Xu and Lieberherr [2020] employs MCTS to convert CO problems into Zermelo games [Schwalbe and Walker, 2001], and maps the winning strategy of the Zermelo games to provide solutions for CO problems.

B Beyond Maximum Independent Set

Our proposed method for solving CO problems using DP and GNNs with self-supervised training extends beyond the realm of the MIS problem. While our focus has primarily been on MIS, the underlying framework and techniques can be applied to various other CO settings. In this section, we explore the potential application and adaptation of our approach to address a different problem domain. We will focus on another problem, called the Minimum Vertex Cover (MVC) problem. We will benchmark against various neural approaches. The goal of the MVC problem is the following:

Definition 4. Given a graph G ( V, E ) find a set of nodes S ⊆ V with minimum size such that for each edge ( v, u ) ∈ E either v ∈ S or u ∈ S .

Minimum Vertex Cover asks for the smallest set of vertices S such that all edges of G are "covered" by at least one vertex in the set. Dynamic Programming provides similar optimality guarantees as that of Maximum Independent Set described in Theorem 1. The respective optimality guarantees for Minimum Vertex Cover are formally stated in Corollary 1.

Corollary 1. Let a graph G ( V, E ) ∈ G . Then for any vertex v ∈ V with d ( v ) ≥ 1 ,

G ′ := G ( V \ { v } , E \ { ( u, ℓ ) | u ∈ N ( v ) ∧ ℓ ∈ N ( u ) } ) , G ′ is created by removing v from G as well as all the edges incident to neighbors of v .

G 0 := G ′ ( V ∪{ u ′ | u ∈ N ( v ) } , E ∪{ ( u ′ , u ) | u ∈ N ( v ) } ) , G 0 is created from G ′ by adding the copy nodes u ′ |∀ u ∈ N ( v ) and the edges ( u ′ , u ) for all u ∈ N ( v ) (each vertex u is connected with its copy u ′ ). G 0 represents the situation where vertex v is not selected in the MVC, but its neighbors are.

G 1 = G ( V ∪{ v ′ } , E \ { ( u, v ) | u ∈ N ( v ) } ∪ { ( v ′ , v ) } ) , G 1 is created from G by removing all edges incident to v and adding a copy node v ′ that is then connected to v . G 1 represents the situation where v is selected to be part of the MVC.

where

Corollary 1 is based on the fact that for any node v ∈ V either v or all of its neighbors N ( v ) lie in the optimal solution. The first case is captured through G 1 . Notice that G 1 is constructed by G by removing all the incident edges to v ∈ V since they are already covered by v . The new copy node v ′ is added and connected to v so as to encode that either node v or its copy v ′ should be selected in the minimum vertex cover of G 1 . Symmetrically, the graph G 0 is constructed by repeating the latter process for each u ∈ N ( v ) .

As in Algorithm 1, a graph comparing function CMP MVC ( G,G ′ ) induces the following recursive algorithm for computing a vertex cover. The latter is formally described in Algorithm 3. By Corollary 1 in case CMP MVC ( G,G ′ ) = I [ | MVC( G ) | > | MVC( G ′ ) | ] 3 then Algorithm 3 always computes a minimum vertex cover.

Algorithm 3 Comparator-Induced Algorithm for the MVC problem

By adjusting the notion of consistency (see Definition 3) in the context of minimum vertex cover as CMP MVC ( G,G ′ ) = 0 if and only if E [∣ ∣ A CMP MVC ( G ) ∣ ∣ ] ≤ E [∣ ∣ A CMP MVC ( G ′ ) ∣ ∣ ] , one can establish that, if CMP MVC is a consistent comparator, A CMP MVC ( · ) always outputs a minimum vertex cover. In Appendix E, we present our experimental results produced after the self-training of a consistent in the context of Minimum Vertex Cover.

C Experimental Details

Additional information related to the hyper-parameters, baselines, and datasets are depicted in this section.

C.1 Training Setup and Baselines

Training setup : The sizes of the linear layers at each iteration are as follows: 96 × 32 , 96 × 32 , and 96 × 32 . After this module, 4 linear layers follow, with the following sizes: 96 × 32 , 32 × 32 , 32 × 32 , and 64 × 1 . Furthermore, the output of the last GEM iteration has a skip connection into the last dense layer of the model, which is also why the final layer has 64 input neurons. Every linear layer in the entire network is followed by layer normalization [Ba et al., 2016b]. Each model is trained for 300 epochs total with batch size 32 using Adam optimizer [Kingma and Ba, 2014] and a learning rate of 0 . 001 . We split the graph datasets into 80% for training and 20% for testing, except

for COLLAB and RB datasets where the number of test graphs is much bigger than the number of train graphs. From the training data, a validation set is constructed by dedicating 20% of the data in the buffer to it. Considering the baseline methods, we trained them for 300 epochs, and in the case of reinforcement learning, for 300 episodes. A precise description of the Hyper-parameters values is reported in Table 3.

Baselines : Besides the methods specified in Sec. 6, in Appendix D we employ the IMDB dataset [Morris et al., 2020] and graphs coming from the Erdos-Renyi [Erd˝ os et al., 1960], Barabasi-Albert [Albert and Barabási, 2002] and Watts-Strogatz [Watts and Strogatz, 1998] distributions. Moreover, in Appendix E we use two datasets (RB200 and RB500) that resemble the RB dataset employed in Sec. 6, but the two datasets have different numbers of nodes. As mentioned in Sec. 6 and in Appendix E, we use traditional baselines, such as the Greedy MIS employed in Sec. 6 and Greedy MVC employed in Appendix E. Greedy MIS iteratively chooses the node with the minimum degree to be part of the independent set and removes its neighbors from the graph, while Greedy MVC considers the node with the highest degree as part of the vertex cover set, still removing the neighbors of the node. We also implement Simple Local Search , which, given a time limit, randomly adds a node to the independent set and removes conflicting nodes. The largest set in the time period is used as the solution of the algorithm.

Hardware : Any experiment with a reported execution time has been performed on a laptop with Windows 10 and Python 3.10. The device uses a CUDA-enabled NVIDIA GeForce GTX 1060 Max-Q GPU with 6GB VRAM, and an Intel(R) Core(TM) I7-7700HQ CPU with a 2.80GHz clock speed, and 16GB of RAM. Our method is implemented in PyTorch.

C.2 Datasets

Two important parameters are considered for the analysis of the datasets: the size and the density of the graphs. The first parameter is measured in terms of total number of nodes. The second one reflects how sparse a graph is and it is measured as the ratio between the total number of edges of the graph and the total number of edges if the graph would have been complete.

Real-world datasets and RB : Our work utilizes real-world datasets that simulate social network scenarios, like IMDB, COLLAB and TWITTER. The RB dataset that we employ consists of the same graphs utilized in the research conducted by Karalias and Loukas [2020], whereas the RB200 and RB500 datasets align with those employed in the work by Wang and Li [2023]. Notably, RB200 and RB500 were generated by configuring a small hyper-parameter ρ = 0 . 25 , making the instances within these datasets challenging, as specified by Wang and Li [2023].

Graph distribution : In Appendix D, we conduct testing on well-known graph distributions, specifically the Erdos-Renyi , Barabasi-Albert , and Watts-Strogatz distributions [Erd˝ os et al., 1960, Albert and Barabási, 2002, Watts and Strogatz, 1998], abbreviated as ER, BA, and WS in Table 4. The objective is to evaluate the performance of our model on datasets where the instance densities differ from those of real-world datasets.

Special dataset : The Special dataset has two nodes, u and v , which are connected to a set of nodes I . The size of set I is denoted as n . Moreover, the nodes within I are all independent of each other, since there are no connections between any pair of nodes i and j within I . Additionally, all nodes in I are connected to every node in a clique of nodes called C , which has a total of n + a nodes. When employing the Greedy MIS heuristic, nodes u , v , and one node from C are selected as part of the MIS (Maximum Independent Set), while the MIS itself in reality corresponds to I , which has a dimensionality of n . Notice that the Greedy MIS heuristic performs poorly in these instances.

D Additional Experiments on MIS

Besides the datasets of Table 1, we also performed experiments in the IMDB dataset and in three known graph distributions: Erdos Renyi , Barabasi Albert and Watts Strogatz . Table 5 shows that all methods, except for the random comparator, always achieve optimal results for the IMDB dataset, since the size of the IMDB instances is extremely small, as depicted by Table 4. Moreover, it is worth noticing that, on the ER dataset, our method outperforms the greedy heuristic in the mixed roll-outs case.

E Experiments on Minimum Vertex Cover

Experiments for the MVC problem are performed over the RB200 and RB500 Xu et al. [2007], which were specifically designed to generate hard instances. In addition, we evaluate our results by comparing them with the methodologies proposed in Erdos' GNN Karalias and Loukas [2020], RUN-CSP Toenshoff et al. [2019], and Meta-EGN Wang and Li [2023]. Specifically, the results presented in Table 6 are sourced from Wang and Li [2023], with the exception of the comparator and Greedy MVC, and all experiments were conducted using the same datasets as in their study.[Wang and Li, 2023].

Among the neural approaches, Table 6 highlights similar results for the two datasets, and our model achieves the best result for the RB500 dataset. Moreover, as depicted by the last rows of Table 6, optimal solvers do not always reach the optimal value over the graphs of the datasets, since, as mentioned before, RB instances are known to be hard.

Our model, benefiting from dynamic programming techniques, possesses the ability to decompose complex instances into more manageable sub-instances. As a result, it shows good skills in addressing the inherent complexity of the RB200 and RB500 datasets, surpassing other methods in this regard.

F Additional Background Information

In our work, we use Gurobi as a matter of comparison for our results. Since Gurobi is an Integer Linear Programming (ILP) solver, we believe it is useful to briefly revise the ILP formulations of the MIS and MVC problems. In particular, given a graph G ( V, E ) with n = | V | , we use binary decision variables X = ( x i ) 1 ≤ i ≤ n ∈ { 0 , 1 } n for each vertex i ∈ V such that x i = 1 if vertex i is considered as part of the solution and x i = 0 otherwise. In ILP, the goal is to assign values to every x i variable such that a function F ( G,X ) , called energy function, is either maximized or minimized under a set of constraints.

F.1 Integer Linear Programming for the Maximum Independent Set

In MIS, the energy function is defined as the sum of every binary decision variable: F ( G,X ) = ∑ i ∈ V x i . Since every edge ( i, j ) can have at most one of its nodes in the independent set (otherwise the independent condition is violated), the sum of decision variables of i and j is at most one:

F.2 Integer Linear Programming for the Minimum Vertex Cover

Differently from MIS, the ILP formulation for the MVC consists in minimizing the objective function F ( G,X ) = ∑ i ∈ V x i . Since every edge of the graph has to have at least one of the two nodes in the vertex cover set (otherwise the edge wouldn't be covered), the sum of the decision variables of the two nodes defining the edge has to be greater (or equal) to one:

G Ablation Study

In this section, we perform an ablation study on several parameters of the comparator function (without using mixed roll-outs) on the COLLAB dataset. The following parameters will be tweaked:

D : The dimensionality of the initial node embeddings, and the output size of the layers in the network.

K : The number of iterations in the Graph Embedding Module.

L : The number of fully connected layers in the network.

We experiment linearly with the following parameters: D ∈ [8 , 16 , 32 , 48 , 64] , K ∈ [1 , 2 , 3 , 4 , 5] , and L ∈ [2 , 3 , 4 , 5] , with a base configuration of D = 32 , K = 3 , and L = 4 . This means that when testing with D = 48 , the model configuration will be D = 48 , K = 3 , and L = 4 . The meaning of these parameters can be found in greater detail in Sec. 4.2.

All models were trained for 200 epochs, with the experiments performed on a single GPU with 6GB RAM.

From Tables 7 to 9, we can see that a value of D = 32 , K = 3 , and L = 4 is a reasonable choice for the model architecture, also taking into account runtimes during inference for a model with smaller parameters. Interestingly, the model performance starts to degrade for K = 5 , possibly due to over-smoothing.

H Broader Impact

Designing neural networks for combinatorial optimization (CO) problems is still in its infancy, and as such there are a lot of exciting questions. Nonetheless, delving even more in this direction might potentially impact our society. Important fields like medicine or biology require the solution of CO problems in a short time since the execution time can be critical for the health of a patient. Therefore, tackling CO problems with deep learning techniques can bring important benefits to society, but can also be used for malicious purposes. Therefore, we do encourage the community to consider those challenges and perspectives.

I Omitted Proofs

Theorem 1 . Let a graph G ( V, E ) ∈ G . Then for any vertex v ∈ V with d ( v ) ≥ 1 ,

Proof. Let G ( V, E ) be a graph and MIS( G ) be its maximum independent set. We want to show that for any vertex v ∈ V with d ( v ) ≥ 1 , the size of MIS( G ) can be obtained by either removing v or removing its neighbors N ( v ) .

Consider two cases:

v ∈ MIS( G )

In this case, if we remove N ( v ) from G , the resulting graph is denoted as G ′ = G \ N ( v ) . Since the neighbors of v cannot be in the maximum independent set, removing it does not affect the size of MIS( G ) . Therefore, MIS( G ) = MIS( G ′ ) .

v / ∈ MIS( G )

In this case, we can remove v from G to obtain the graph G ′ = G \ { v } . Since v is not in the maximum independent set, removing it does not affect the size of MIS( G ) . Therefore, MIS( G ) = MIS( G ′ ) .

By considering these two cases, we have shown that for any vertex v ∈ V , the maximum independent set MIS( G ) can be obtained by either removing v or removing its neighbors N ( v ) . Thus, we can express the size of the maximum independent set as follows:

Theorem 2 . Let a consistent comparator CMP : G × G ↦→ { 0 , 1 } . Then the algorithm A CMP ( · ) always computes a Maximum Independent Set, E [∣ ∣ A CMP ( G ) ∣ ∣ ] = | MIS( G ) | for all G ∈ G .

Proof. Let us consider a consistent comparator CMP . We will establish Theorem 2 with an induction on the number of edges i .

Induction Basis ( i = 0 ): Let G ( V, E ) ∈ G [0] then A CMP ( G ) = V = MIS( G ) .

Induction Hypothesis : E [∣ ∣ A CMP ( G ) ∣ ∣ ] = | MIS( G ) | for all G ∈ G [ j ] with j ≤ i .

Induction Step : Let G ∈ G [ i + 1] and consider a node v with degree d ( v ) ≥ 1 . Consider also the graphs G 0 := G/ { v } and G 1 := G/ {N ( v ) } . Both G 0 and G 1 admit less than i edges and thus by the inductive hypothesis, E [∣ ∣ A CMP ( G 0 ) ∣ ∣ ] = | MIS( G 0 ) | and E [∣ ∣ A CMP ( G 1 ) ∣ ∣ ] = | MIS( G 1 ) | . Hence CMP( G 0 , G 1 ) = 0 if and only if | MIS( G 0 ) | ≥ | MIS( G 1 ) | . As a result, |A CMP ( G ) | = max( | MIS( G 0 ) | , | MIS( G 1 ) | ) and Theorem 1 implies that |A CMP ( G ) | = | MIS( G ) | .

J Additional Experiments on Consistency

In an attempt to gain insight into the decisions of the comparator, we measure something that we refer to as the consistency value of a comparator. The consistency of a comparator is the proportion of graph pairs in which the equation of consistency from definition 3 is fulfilled.

Fig. 3 shows the consistency values as the training progresses for three different benchmark datasets. Overall, the consistency curves have an increasing behavior, indicating an increase in the consistency of the decision that a comparator makes as training progresses.

0

10

20

30

40

iteration

0.775

0.800

0.825

0.850

0.875

0.900

0.925

0.950

0.975

consistency

Consistency of the comparator for three datasets

COLLAB

TWITTER

RB

Peer reviews:
{"IS_META_REVIEW": false, "comments": "SUMMARY:\nMaximum Independent Set:\nA Dynamic programming approach (DP) to GNNs. The idea is to solve a Combinatorial Optimization problem, in particular the Maximum Independent Set (MIS): max set of nodes so that no two nodes are neighbors (set of nodes not linked by edges). The problem is NP-Hard but a GNN can generate an approximation. DP partitions the graph in subgraphs. The main idea is to avoid the exponential space. \n\nTheorem 1 enables the recursive search. The idea is to remove nodes recursively or their neighbors. Basically, if a vertex is in the MIS, its neighbors cannot be! \n\nGNNs for MIS. The approach is incremental. \nA) Build comparator CMP based on theorem 1, for determining whether to graphs have approximately MIS size.\nB)  Implement CMP using GNNs. Initially, we have neighbors and anti-neighbors (as the degree of freedom). However, the initial embedding is ZERO for ALL of them. The new embedding for a node comes by concatenating that of its neighbors with that of the anti-neighbors. Later on, when this information is pooled to form a global embedding and fed to an MLP, its decision will be sent backward. This is explained in section 5. \n\nSelf-Learning using CMP. Since the problem is NP-Hard it is reasonable to use the randomized CMP as a provider of examples. In this regard, Theorem 2 guarantees that any consistent graph comparing function CMP (the expectation of the randomized CMP is greater for the graph it has to be) induces an optimal algorithm ACMP for MIS. The basic idea is to choose to parameterize  CMP_theta in such a way that it is consistent. This is exactly the GOAL OF TRAINING. \n\nExperiments. Compare the proposal with greedy methods. Usually greedy methods works very well but in some graphs. The method seems to generalize a bit. \n\nI agree with the conclusions: “We firmly believe that a thorough investigation into the interplay between Dynamic Programming and self-training techniques can pave the way for\nnew deep-learning-oriented approaches for demanding CO problems”.\n\nSTRENGTHS:\nA nice paper for illustrating the use of GNNs in CO problems through self learning, specially in NP-Hard Problems. \nNice time complexity for a fixed budget.\n\nWEAKNESSES:\nDespite the framework is nice, there is no insight in terms of verifying whether the resulting embeddings of the nodes verify the decision taken. A probable approach is to hash the compatible nodes to one code and the incompatible one to another code. In this way the method will be more explanatory and will enlarge the consistency of the response.\n\nQUESTIONS:\nHow do the parameters of the CMP_theta evolve? How far/close are them of resturning consistent/inconsistent responses? In other words, use the analysis of these parameters to diagnose how hard is the problem for different graphs.\n\nLIMITATIONS:\nMaybe better GNNs could improve the results. Agree with the authors the lack of convergence analysis. In this regard, it seems to me that making the CMP_theta more explainable will help.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 5, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-05"}

comments: SUMMARY:
This paper studies the combination optimization problem, maximum independent set, via self-training. By training a consistent graph comparator function to determine the larger MIS of two different graphs, the MIS of original graph can be obtained recursively efficiently.

STRENGTHS:
1. The notations and presentation are clear.
2. The idea of using the intermediate results during algorithm execution to supervise the model itself is novel.

WEAKNESSES:
1. The most important component in the proposed method is the consistent graph comparator. It would be better to include more detailed explanation on why the learned graph comparator will be consistent.
2. As the algorithm $A$ depends on $CMP_\theta$, and the whole training pipeline relies on $A$, what will happen if $CMP_\theta$ makes a lot of mistakes initially? This should be discussed.
3. The computational complexity/overhead should be discussed.

QUESTIONS:
See in weaknesses.

LIMITATIONS:
Limitations are mentioned. Negative societal impact is not applicable.
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 2
DATE: 2023-07-06

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis work uses a dynamic programming framework for approximately solving the maximum independent set (MIS) and minimum vertex cover (MVC) problems. A graph neural network (GNN) is used to replace a heuristic step in the randomized version of the DP algorithm. Essentially, MIS (and MVC) can be broken down into (2^n) recursive decisions about whether to include a vertex in the output set or not. The randomized version doesn’t go through all of these, but decides for a random vertex whether or not to include it. This setup ensures that the output will be a valid independent set regardless of the decisions. In this paper, the decisions are made by a trained GNN (heuristic). The GNN is trained by comparing the output IS with random independent sets formed by performing rollouts starting with the alternative choice. E.g., if the GNN decides to include vertex v in the IS, then the rollouts are performed on the graph without v. The greedy rollout is included in the mixed version, to potentially improve this training signal. The GNN architecture used is referred to as GEM, but as far as I can tell, the GNN is exchangeable for any other GNN architecture.\n\nSTRENGTHS:\n1. This is a neat setup for DP problems on graphs. The framework ensures that the outputs are valid, and using a GNN as a heuristic can make sense. It's a nice idea to replace a heuristic step in an algorithm with a GNN (but this is not the first work to do so).\n2. The approach is clearly laid out and easy to follow.\n3. Some of the results are promising. The GNN also clearly outperforms the random CMP, indicating that the GNN is learning something useful and contributing positively to the algorithm.\n\nWEAKNESSES:\n1. It is not clear how much impact this paper might have. I’m sure the framework can be used for some other CO problems where the output is a subset of the input, but it is not clear how widely applicable it might be, especially given its runtime complexity.\n2. The main novelty seems to be the use of a GNN for the decision step in the algorithm.\n3. GEM is given a new name, but it is essentially fully-connected message passing, where neighbours and non-neighbours are aggregated separately. This is not a novel contribution, so I don’t think it deserves a new name.\n4. The proposed model is not scalable to larger graphs. Already the GNN used (GEM) is n^2 per layer (n being the number of nodes), which simply doesn’t scale to large graphs. Moreover it is applied n times at inference, giving n^3 runtime. What are the largest graphs you can run on? How does the complexity compare with the complexity of the other approaches?\n5. Greedy baseline outperforms the proposed approach on 2/4 datasets.\n6. The results are not very convincing for MVC.\n\nQUESTIONS:\n1. Have you tried using any other GNN architectures (GIN, GAT, Erdos, Graph Transformer, ...) for the heuristic step?\n2. Are the anti-neighbors needed? How is the performance without (this would help in lowering the overall complexity)? \n3. How many rollouts are needed for the results?\n4. Why not use a GNN to decide on the next vertex to consider rather than doing it randomly? There might be some vertices that are easier to decide whether to include at a given time.\n5. Why is SPECIAL missing from Table 2?\n6. Is RB or TWITTER really out-of-distribution for COLLAB? Maybe those datasets are very similar in distribution.\n7. What about using only the greedy rollout? \n8. Some symmetry breaking is probably needed for the greedy approach (e.g. if there are (neighboring) nodes with the lowest degree in the graph), so multiple rollouts could be done here and the max taken. Do you consider only a single (random) rollout? Or do you run greedy multiple times?\n9. The random CMP could be replaced by a degree-weighted random CMP, i.e. selecting lower degree nodes with a higher probability, but not necessarily taking a lowest degree node. This would essentially make the greedy approach a little more robust to “special” graphs, maybe providing a better baseline.\n10. Do you have any insights into the GNN decisions?\n\nLIMITATIONS:\nyes", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-07"}

comments: SUMMARY:
This paper proposes a method to solve the maximum independent set (MIS) problem using self-trained dynamic programming and carefully-designed GNNs. The MIS problem is decomposed into dynamic programs and solved by comparing two reduced graphs.

STRENGTHS:
It is interesting and innovative to address the MIS problem using GNNs in a self-training manner.
The proposed method is effective and efficient for solving the MIS problem.

WEAKNESSES:
The following improvements could enhance the experiments:

1. Baseline comparisons: In Line 74, several recent baselines are mentioned. It would be beneficial to include comparisons with these methods in the experiments to demonstrate the superiority of the proposed approach.

2. Evaluations on large-scale graphs: Existing methods [Schuetz et al., 2022b, Wang and Li, 2023] have demonstrated their effectiveness on larger-scale graphs with more than $10^4$ nodes. It would be valuable to showcase the results of the proposed method on such graphs.

3. Comparisons on model training: Since the proposed method employs self-training, it would be informative to compare the training cost of the proposed method with that of the baselines. Including such comparisons would provide insights into the efficiency of the proposed approach.

QUESTIONS:
None

LIMITATIONS:
Please check the weaknesses.
TITLE: Official Review
SOUNDNESS_CORRECTNESS: 3
DATE: 2023-07-07

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThe paper proposes a GNN based method to approximate the largest independent set for a graph. The algorithm proposes to train a GNN layer to decide at each iteration whether a randomly selected node should be a part of the independent set, the resulting graph (either losing the neighbours of the chosen node or only the node the itself) is then the input at the next iteration. For graph distribution datasets are used for empirical evaluation.\n\nSTRENGTHS:\nThe paper employs a DNN module at an appropriate place, i.e. as the graph comparator function, which is sensible. This would be a reasonable contribution if the weaknesses would be addressed.\n\nWEAKNESSES:\nEDIT: Summary: Some of the weaknesses mentioned were incorrect (W1,W2,W4) (apologies to the authors). Some of the weaknesses simply need to be discussed in the paper (W3,W5,W6,W7,W9). In my opinion the deciding factor should be W8, does the AC think that simply using benchmarks with no real-world connection to the problem we are trying solve are good empirical evaluation (only used because prior work did and nobody checked that) is good enough. If Yes, the paper should clearly be accepted (score of 7), else it should be rejected as the accepted benchmark should be updated. Thus, I have updated my score to a 5, 7 if the authors decide to add a benchmark with a real world connection or explain why one of the current benchmarks has a real-world connection and thus represents the distribution of graphs one might find in practice. \n\n1. I retract the first point in the bullet list below, it is indeed incorrect as the authors point out in the rebuttal. \n2. In the second bullet point, I also did forget a word (\"might\") that does matter, however, I regarding remark 4 I maintain my criticism, while the interpretation that the authors provide in the rebuttal makes sense what is written in the paper is much more broad. I suggest they reword for the camera ready. \n3. Regarding point 3, I thank the authors for addressing the computational complexity more directly, but the comparison in run-time to Gurobi seems unfair as that tries to find the optimal solution as far as I understood, which is naturally exponential in the worst case, so this seems to be an apple to oranges comparison, the greedy heuristic may be a better comparison point. \n4. I also retract W4. \n5. It is a weakness that the paper doesn't discuss this in it's current form.\n6. I stand by W6 given the current phrasing in the paper which is \"Since we observe unexpected performance from RUN-CSP on the COLLAB and RB269 datasets, we have omitted those results from the table.\" This doesn't explain why it has been removed, which is necesary.\n7. Units should still be explained. One prior work doesn't make it standard enough to not mention it.\n8. Prior work having used the benchmarks is in my opinion a weak argument without any other benchmarks. But I understand that this is a contentious issue within the ML community. I leave this up the AC, but as far as I can tell from the response of the authors, there is no particular use in the real-world to compute the MIS on something like the Twitter dataset.\n9. I agree that such work is still valuable, but it's an obvious limitation that needs to be discussed and wasn't in the paper.\n\nThe paper has substantial weaknesses that prevent acceptance at this time in my view:\n\n1. The authors demonstrated knowledge of what NP-hard means is poor, frequently mis-using the term and similarly the context of approximation algorithms is missing completely. In more detail: NP is a class of BINARY decision problems, i.e. the problem asks a yes or no question. Maximum Independent Set (Defintion 1) as defined in the problem is not such a problem and thus cannot be classified as NP-hard or anywhere in that complexity hierarchy. Leading to several incorrect claims in the paper (e.g. line 181). Furthermore, problems that are NP-hard are considered computationally infeasible for anything but the smallest instance sizes, so a sentence like \"computationally infeasible for NP-hard problems\" (line 21) does not make sense. If we want to discuss the optimisation problems associated with an NP-hard problem, e.g. finding the optimal route of the travelling salesman problem or finding the maximum independent set, this is a different computational complexity class with it's own hierarchy. This is especially important once we care about approximations, doubly so when we want to considered the randomized approximation algorithms, however, any such discussion is missing. \n2. Various statements about the quality of the solutions of the algorithm are imprecise or plain wrong. For instance,  in line 136 the claim is made \"there exist a reasonable graph comparing functions that i) are efficiently computable ii) lead to near optimal solutions\" with no reference to any proof or evidence. These baseless claims decrease the authors credibility significantly. (another example can be found in remark 4 the second sentence).\n3. The computational computational complexity of the algorithm is never discussed, which is particularly relevant given we are approximating solutions and thus there is a fundamental trade-off between time and the quality of the solution found. The algorithm proposed is of high-computational complexity, a single GEM module layer as proposed in equation 1. is already of complexity O(n^2) where n is the number of nodes. This would quickly be infeasible for problems of an interesting size and also raises the question why a GraphTransformer architecture wasn't considered. Furthermore, the GEM layers need to be applied O(n) time in the worst case, as the recursion depth of algorithm 1 is O(n) in the worst case. Thus giving us at least O(n^3) at inference time, neglecting the training time here, making the algorithm expensive to run. This is not compared against any other method either, e.g. the computational complexity of traditional solvers like Gurobi or other baseline methods is also not given.\n4. Theorem 1 seems to be missing a +1, presumably when we remove a node v from the graph and add it to the independen set this should lead to a +1 appearing somewhere in the equation of |MIS(G)|.\n5. The computational complexity of computing the expectation in the loss function given in equation 2 seems prohibitively high and there is no discussion about the variance in estimating the expectation by using only samples. In practice, this seems to be replaced with roll-outs another form of probabilistic estimation, whose complexity or variance remain unmentioned. Again, a claim is made that these roll-outs are better than the original expectation without any empirical or theoretical evidence.\n6. The empirical evaluation removes the results from the RUN-CSP baseline with the words \"unexpected performance\" without any further justification, this is highly unusual and not acceptable practice.\n7. Table 1 uses an unexplained unit of s/g.\n8. The benchmark datasets aren't justified, why is it interesting to compute the MIS of a twitter graph? Given that the graph distribution will be highly relevant to performance this is important. While it is understandable to re-use benchmark datasets that prior work has used, it doesn't help the paper if the benchmark datasets aren't specfic to any real world problem people care about. At least one dataset needs to be of relevance to a real world problem, e.g. MIS is used in compiler optimisations.\n9. There is no adequate discussion of running time or discussion of any benefits of the proposed method or DNN methods in general over classical optimisation solvers for the problem studied. Indeed, from Table 1. I cannot discern why a practioner would use the method proposed over Gurobi over SCIP.\n\nQUESTIONS:\nNone.\n\nLIMITATIONS:\nNo the limitations are not adressed, see the weaknesses.", "TITLE": "Official Review", "RECOMMENDATION": 5, "REVIEWER_CONFIDENCE": 4, "SOUNDNESS_CORRECTNESS": 2, "DATE": "2023-07-24"}

{"IS_META_REVIEW": false, "comments": "SUMMARY:\nThis paper proposes a novel graph neural network (GNN) framework for solving the maximum independent set (MIS) problem. The idea is to use a randomized divide-and-conquer algorithm (which is termed as dynamic programming in the paper though) to pick a random node or its neighborhood and divide the problem into two subproblems recursively. In order to choose one of two actions at each step, the authors propose to parameterize the comparator with a GNN over the current graph structure. The advantage of this method is that it can bootstrap training data generation with a trained GNN, and then improve the GNN with the new training data. This reduces the cost of training data generation for MIS, which is an NP-hard problem. Experiments on 4 datasets show that the proposed CMP method achieves the best results among all deep-learning-based methods under similar time budgets.\n\nSTRENGTHS:\n- S1: This paper proposes a novel solution for the MIS problem. It induces a random MIS inference algorithm from a comparator function, where the comparator function is parameterized by a GNN model.\n- S2: One of the challenge for NP-hard problems is the cost for generating annotated data. The authors employ a smart way to bootstrap data generation from a learned GNN comparator and use the generated data to further train the model.\n- S3: Experiments on 4 datasets show that the proposed CMP method achieves the best result among all deep-learning-based methods under similar time budgets.\n\nWEAKNESSES:\n- W1: The paper mistakes recursive algorithms for dynamic programming. This makes the paper somehow hard to understand. Dynamic programming is for problems with overlapping sub-problems. If the sub-problems are non-overlapping, then it is called divide-and-conquer algorithms. If every action only results in a single sub-problem, then it is merely a normal recursive algorithm. According to Alg. 1, the proposed model is a recursive algorithm.\n- W2: The writing of this paper can be improved. The authors don’t emphasize the randomized nature of their inference algorithm very much, so it’s hard to understand what an expectation over the inference algorithm is at first glance. As the randomized inference algorithm is the key technique to achieve the goal of self-training, the authors may emphasize it more in the abstract and the introduction.\n- W3: There are some concerns regarding the time complexity of the proposed CMP model. According to Alg. 1 and Eqn. 1, the time complexity of this paper is $O(n^2|MIS(G)|)$ in the worst case. The datasets used in this paper mostly contain around a hundred nodes, which can’t reveal the disadvantage in the time complexity. It’s recommended that the authors analyze this in the paper. Also is it possible to avoid $O(n^2)$ dense propagation in the GNN?\n\nQUESTIONS:\n- Q1: Line 20-21: According to [1], any polynomial-time sampler generates an easier sub-problem of an NP-hard problem. It looks to me that the CMP model can’t avoid this problem, either. Can you explain that?\n- Q2: Line 22-23: How do you circumvent this difficulty? Please be explicit in the introduction.\n- Q3: Algorithm 1: Please emphasize this is a randomized algorithm.\n- Q4: Line 183-184: This sentence requires more clarification. From my understanding, a model can’t learn anything from what it infers, unless it is a randomized algorithm or some planning algorithms as in this paper.\n- Q5: Algorithm 2 Line 5: Where is $G_{init}$ used?\n- Q6: Line 240-241: It’s a little bit confusing that you replace the basic pipeline, which is something you proposed, with two other approaches. You may say “improve the basic pipeline by …”. The title of the paragraph may be changed to “Better MIS estimation”.\n- Q7: Line 249: Mixed roll-out variant should be parallel with the first approach, not with “Estimating the MIS”. It may be renamed to “Mixed roll-out estimator”.\n- Q8: Line 316-317: What do you mean by “core modules”?\n\n[1] Yehuda et al. It’s not what machines can learn, it’s what we cannot teach. ICML 2020.\n\nLIMITATIONS:\nThe authors discuss the limitations but not the societal impact in the paper. It seems that the proposed method will not cause obvious negative societal impact, but the authors are encouraged to discuss it.", "TITLE": "Official Review", "RECOMMENDATION": 6, "REVIEWER_CONFIDENCE": 3, "SOUNDNESS_CORRECTNESS": 3, "DATE": "2023-07-26"}