Preference-Based Gradient Estimation for ML-Guided Approximate Combinatorial Optimization
Authors: Arman Mielke
Uwe Bauknecht
Thilo Strauss
Mathias Niepert
Venue: Accepted by TMLR ()

Abstract: Combinatorial optimization (CO) problems arise across a broad spectrum of domains, including medicine, logistics, and manufacturing. While exact solutions are often computationally infeasible, many practical applications require high-quality solutions within a given time budget. To address this, we propose a learning-based approach that enhances existing non-learned heuristics for CO. Specifically, we parameterize these heuristics and train graph neural networks (GNNs) to predict parameter values that yield near-optimal solutions. Our
method is trained end-to-end in a self-supervised fashion, using a novel gradient estimation scheme that treats the heuristic as a black box. This approach combines the strengths of learning and traditional algorithms: the GNN learns from data to guide the algorithm toward better solutions, while the heuristic ensures feasibility. We validate our method on two well-known combinatorial optimization problems: the travelling salesman problem (TSP) and the minimum k-cut problem. Our results demonstrate that the proposed approach is competitive with state-of-the-art learned CO solvers.

Published in Transactions on Machine Learning Research (03/2026)
Preference-Based Gradient Estimation for ML-Guided Approximate Combinatorial Optimization
Arman Mielke
crman.mielke@etas.ccom
ETAS Research
Computer Science Department, University of Stuligart
Mar Planck Research School for Intelligent Systems (IMPRS-1S)
Uwe Bauknecht
wwe. www.benuknechht@eeaaa..oo
ETAS Research
Thilo Strauss
Mnloo.srruus@xxittuuuu...m
School of AI and Advanced Computing, Xi'an Jinotong-Liverpool Unsversity
Mathias Niepert
mathias..ieeertteee wwwp:/rrtttikuiittttttttooooom
Compuler Science Department, University of Stuligart
NEC Laboratories Europe
Mar. Planck Research School for Intelligent Systems (IMPRS-IS)
Reviewed on OpenReview: https: // openreview. net/ forum? id= 2S224XC378
Abstract
Combinatorial optimization (CO) problems arise across broad spectrum of domains, includ- ing medicine, logistics, and manufacturing. While exact solutions are often computationally infeasible, many practical applications require high-quality solutions within a given time budget. To address this, we propose a learning-baser approach that enhances existing non-learned heuristics for CO. Specifically, we parameterize these heuristics and train graph neural networks (GNNs) to predict parameter values that yield near-optimal solutions. Our method is trained end-to-end in a self-supervised fashion, using novel gradient estimation scheme that treats the heuristic as black box. This approach combines the strengths of learning and traditional algorithms: the GNN learns from data to guide the algorithm toward better solutions, while the heuristic ensures feasibility. We validate our method on two well-known CO problems: the travelling salesman problem (TSP) and the minimum k-cut problem. Our results demonstrate that the proposed approach is competitive with state-of-the-art learned CO solvers.
1 Introduction
The design and analysis of heuristics for combinatorial optimization (CO) often focuses on improving worst- performance. However, such worst-case scenarios may rarely occur in real-world settings. Learning-based approaches offer the advantage of adapting to the distribution of problem instances encountered in practice. Graph neural networks (GNNs) are often the method of choice since most CO problems are cither defined on graphs or admit graph-based formulations. Since neural networks camnot directly predict solutions guaranteed to be feasible, generic algorithms such as Monte Carlo tree search and beam search are often used to decode their outputs. However, these methods are impractical use during training because of their prohibitively long runtime. On the other hand, omitting them during training introduces a discrepancy between training and inference, which can severely impact the optimality gap and generalization.

---

Published in Transactions on Machine Learning Research (03/2026)
T 1
Forward
4
11
1
Pass
Y1 92 ~
O O 0
O
GNN fe
Heuristic h
U2
a
Graph g
Edge Scores 8
Backward Pass
Ve
Jco (i1) Joo (U2)
V Vo 8) d(ūw. Dw)
0-11
Automatic Differentiation
Gradient Estimation with PBGE
In the forward pass, the GNN predicts edge scores that are used as imput parameters for CO heuristic. The heuristic operates on these parameters by using them to scale the graph's 's edge weights and runming an off-the-shelf heuristic on the modified graph to obtain a solution ÿ. Since the CO heuristic is not differentiable general, a gradient estimation scheme based on preference between pair solutions 91, 92 used in the backward pass.
Figure 1: Overview of the proposed framework for ML-guided approximate CO.
To overcome these limitations, we propose to use GNNs to augment highly efficient heuristics that commonly available for many CO problems. The GNNs are trained to predict parameters for the heuristics that influence their behavior. Specifically, we focus on edge-selection problems, i.c. problems where the solution is a subset of the edges in the problem graph. The GNN predicts edge weights for the input graph, then we apply the heuristic to this modified graph. By choosing fast heuristics, we can incorporate them into the training loop and use the exact same pipeline during training and inference. Our approach combines the strengths of data-driven methods and established heuristic algorithms: the GNN learns to perform well on frequently encountered instances, and the heuristic, in turn, ehsures the fcasibility of the resulting solutions.
Once trained, the GNN-augmented heuristic serves as drop-in replacement for the original heuristic, preserving efficiency and usability while improving solution quality. Indeed, we provide theoretical guarantee that, for the hcuristics that we consider in this work, a suitably trained upstream GNN can learn parameters that render the heuristic optimal.
Since the heuristics return discrete solutions, the gradients of their outputs with respect their inputs are zero almost everywhere. We therefore need to apply gradient estimation techniques such the score function and straight-through estimators (Williams 1992 Bengio et al, 2013) to backpropagate through the algorithms. Since existing gradient estimators cannot be used in a self-supervised setting or have high variance, we propose preference-based gradient estimation (PBGE), which estimates gradients through a comparison of solutions sampled from the given heuristic. This approach enables fully self-supervised training, eliminating the need to pre-compute exact solutions as ground-trute labels, an often costly or even infeasible roquirement for many CO problems. Figure illustrates the proposed PBGE framework.
We evaluate our approach two well-known CO problems, the travelling salesman problem (TSP) and the minimum k-cut problem. Our approach improves the performance of a commonly used heuristic by an order of magnitude in the case of minimum k-cut while only minimally increasing the runtime. On TSP, our approach is competitive with existing learned approaches and achieves Pareto-optimalityy
summary, our contributions include:
1. A novel gradient estimation scheme, PBGE, for backpropagating through CO heuristics, and
2. An extensive experimental evaluation thereof on common CO problems.
The source code is available at http::///tthtccoooee/e/e//eeaaae
2

---

Published in Transactions on Machine Learning Research (03/2026)
2
Related work
The easiest way of training a model for CO is to assume the existence of ground truth solutions to the CO problems and train in a supervised fashion. Nowak et al. (2017). Joshi et al. (2019) use a GNN to predict an approximate solution as a heatmap, which is then decoded into a feasible solution to the CO problem using beam search. |Vnyaal et al.] (2015) introduce pointer networks, which leverage the fact that many CO problems ask to identify a subset or permutation of the input. [Georgiev et al. (2023) follow a neural algorithmic reasoning approach to learn to imitate CO solvers. Gasse et al. (2019). Kahng et al. (2024) replace components of an existing algorithm that would otherwise be expensive to compute with neural networks. Antoniadis et al. (2025) augment existing algorithms using discrete predictions. Finally, (un & Yang 2023)), 3 Yu et al. (2024) use graph-based denoising diffusion to generate high-quality solutions. However, these supervised approaches aren't applicable to such cases where calculating exact solutions for the training problems is not feasible.
Several approaches have used reinforcement learning (RL) to remove this dependence on a labeled dataset
(Kwon et al. 2021 Qiu et al. 2022 Kim et al. 2024). A common approach is to formulate the CO problem
Deudon et al., 2018 Xu et al. 2020 Wu et al. 2022 Khalil ct al. (017)) Kool ct al. (2019) use the GNN autoregressively to predict which node should be added next to the solution set and repeal that process until a valid solution is reached. Cheng el al. (0023), Pan et al. (2023), McCarty et al. (2021) tackle large-scale instances by locally optimizing sub-parts of the instance individually. However, RL is often sample-ineffiiiet and difficult to train due to the high variance of the gradient estimations.
as Markov decision process [Bello et al. 2017
A common self-supervised approach that does not rely on RL is to formulate a surrogate loss consisting of term that encourages high quality solutions and one that softly enforces the constraints (Karalias &
Loukas 2020 Sun et al. 2022 Min et al.) 2022 2023 Bu et al.) 2024 Wenkel et al. 2024 Duan et al. 2002
train self self-supervised using a contrastive loss instead. Schuetz et al. (2022] Sanokowski et al. (2024) focus
on quadratic and polynomial unconstrained binary optimization, allowing them to formulate self-supervised
loss functions for these problem familics. [Tönhhoff et al. (2021) use an LSTM- architecture to solve
binary maximum constraint satisfaction problems, which many CO problems can be formulated as. Corsini
ct al. 2024) train pointer network-based model in self-upervised fashion. Zhang et al. 20023 tackle
CO using GFlowNets (Bengio et al. 2021). Yau et al. (2024) propose GNN architecture that can capture message passing algorithms with provable approximation guarantees for large class of CO problems. Pan
et al. (2025), Liao et al. (2025) also apply preference learning to CO; Pan et al. (2025) decode solutions by modelling the CO problem as a Markov decision process and constructing the solution autoregressively, while
Liao el al. (2025) use a sampling decoder and thin out the solution pool while relaining a range solutions
of different quality.
Joshi et al.
2021 compare some of the paradigms introduced in other papers in structured experiments. Xia et al. (0024) argue that the common pattern of training the GNN using a surrogate loss, but testing it using a decoder, means that the GNN is applied inconsistently, leading to uncertain performance during testing. Our approach addresses this problem by incorporating the decoder during training. There have been two lines of work on backpropagating through CO problems. Firstly, we have a set of optimal solutions given as training data, we can use supervised learning to train the GNN to output adjacency matrices as close as possible to the optimal solutions (Elmachtoub & Grigas) 2022 3. This is often called "predict, then optimize". Secondly, there are several methods to backpropagate through a non-differentiable CO algorithm, such as [Niepert et al.
2021), Minervini et al. (2023), Vlastelica et al. 22220). Related to work is decision-focusee learning, which
has developed several methods to backpropagate through CO solvers (Mandi et al.] 2024). Our approach follows this paradigm. The implicit. maximum likelihood estimator (I-MLE) (Niepert el. al., 2021 is another such method; we compare against it in our experiments and show that our approach improves over I-MLE, Preference learning has previously been used outside CO for fine-tuning large language models (LLMs) Badrinath et al., 2024 Rafailov et al. 20223] Meng et al. 2024).. For instance, Badrinath et al. (2024) propose hybrid approach between preference learning and reinforcement. learning from human feedback.
3

---

Published in Transactions on Machine Learning Research (03/2026)
3 Background
CO problems. A combinatorial optimization (CO) problem asks us, given discrete set M and an objective function Jco .M + IR to find the minimum
min (x).
#EM
Maximization problems can be turned into minimization problems by inverting the sign of the objective function. Since finding the exact global optimum is often not required in practice, this paper focuses on efficiently finding approximate solutions.
To illustrate our approach, we will refer to specific CO problems as follows. The minimum k-cut problem asks, given a weighted, undirected graph and desired number & of connected components, find set of edges with minimum total weight whose removal leaves the graph with exactly & connected components. A commonly used heuristic for this problem is the Karger-Stein algorithm (Karger & Stein 1993). In the travelling salesman problem (TSP), we are given a weighted, undirected graph, and are asked to find a minimum-weiie weight Hamiltonian cycle, i.e. a cycle that visits every node exactly once and where the sum of the weights of edges that are traversed in the cycle is minimal. A well-known probabilistic hcuristic for solving the TSP the random insertion algorithm (Karg & Thompson, 1964). The variant of the TSP most commonly experimented on related literature (Kool et al.j 2019 Joshi et al., 2019: 2021) the Fuclidean TSP, where the graph is fully connected, the nodes represent points in the unit square and the edge weights are the Euclidean distances between these points. We give formal definitions for both problems as well descriptions of the algorithms mentioned in Appendix A
Graph neural networks (GNNs). Let = E) be a graph with = [V| the number of nodes. Let X gaxd be the feature matrix that associates each node of the graph with d-dimensional feature vector and let A E R=** be the adjacency matrix. GNNs based on the message passing paradigm have three basic operations, which are defined as
bf = (3EN()))) (hī-1, , r.)),
where y, s,, and & represent update, aggregation and message function respectively. Propagation step. The message-passing network computes a message miy = @h (1 h :ra)) between every pair of neighboring nodes (V,, Uy)) v2). The function takes in input v,'s and vy 's representations h and hf-1 at the previous layer & 1,, 1, and the relation riy between the two nodes. Aggregation step. For each node in the graph, the network performs an aggregation computation over the messages from vs's neighborhood ((x)) to calculate an aggrogated message Mf = (((ml) uy E ((u)))) The ien of the aggregation function differs bet methods.
Update step. Finally, the model non-linearly transforms the aggregated message Mf and vs's representation from previous layer - to obtain vy representation at layer l as bf = 7(b MM))
Gradient Estimators for Discrete Distributions. Learning systems that backpropagate through discrete distributions and algorithms require gradient estimation approaches. This is because gradients cannot. be directly computed are zero almost everywhere for operations such sampling from categorical distribution running solver for CO problems. The standard estimator is the score function estimator, also known as the REINFORCE estimator (Williams) 1992). Given a function J and parameterized probability distribution po(x) (x) it estimates the true gradient as follows:
1
[J()]] (x V [V (o))
Vo. Yi ~ po()),
S
where is the number of samples used to estimate the expectation. While this estimator is unbiasod, it suffers from large variance. There are other estimators, such as the traiihh-thhouuge estimator (Bengio et al. 2013) and I-ML.E. (Niepert al. 2021) with smaller variance but biased gradient estimates.
4

---

Published in Transactions on Machine Learning Research (03/2026)
4 Problem statement
We consider CO problems on graphs with a linear objective function (co = (Ū,c) for some constant c E TRIE,, and a probabilistic heuristic. The heuristic takes as input a graph g = (V, F, w) with nodes V, edges E and edge weights w : E + R and returns (samples) a potentially suboptimal solution ÿ. The heuristic, therefore, defines probability distribution h(ÿ 9) over the solutions it outputs for a given graph G. For instance, we might have the minimum k-cut problem using the Karger Stein algorithm the heuristic.
We now want to use GNN fe parameterized by 0 applied to the input graphs G to compute updated graph g' = fe (G) such that the probabilistic heuristic when applied to this new graph is improved in expectation. Hence, we want to solve the following optimization problem:
min E (yy-M() [C)]
For each input graph G, h(0 fo) is a discrete probability distribution (due to the assumption that h is probabilistic) parameterized by 9. The main challenge in solving this optimization problem is that (discrete) heuristics are typically not differentiable functions and that optimal solutions are prohibitively expensive to obtain as training data, making supervised training infeasible. Moreover, we assume that the heuristic is a black box- while we can sample from the probability distribution defined by it, we cannot compute a probability mass for a given sample.
5 Method
We introduce a novel approach CO by deriving a new gradient estimator that enables backpropagation through probabilistic heuristics. This allows us, for the first time, directly leverage solution quality rankings, which are automatically generated via objective function-based comparisons, to learn to improve CO heuristics. We use GNNs to guide existing probabilistic heuristics for given CO problem. The GNN receives the problem graph as input and produces a prior score for each edge. These scores are used as additional input alongside the graph for a parameterized version of an off-the-shelf CO heuristic, which then produces a solution to the CO problem. Figure shows an overview of our approach.
Since the hcuristic is not diffcrentiable in general, we use gradient estimation to obtain the gradients with respect to the GNN's output. Existing gradient estimation schemes, such as REINFORCE, the straight- through estimator, Gumbel softmax, or I-MLE, either exhibit high bias or variance require differentiable loss function. We instead propose new gradient estimation scheme based preference- based optimization, which we term preference-basee gradient estimation (PBGE).
5.1 Parameterizing heuristics
A heuristic that takes a problem graph as input can be indirectly parameterized by modifying the graph before executing the algorithm; the modification applied to the graph influences the behavior and output of the heuristic. We modify an input graph G by using the GNN's output to change its edge weights. Assume there is an arbitrary but fixed ordering of edges. The model outputs prior scores s = fg) E R| one score per edge. A high score for a given edge is interpreted to mean that the respective edge should belong to the solution set with a higher probability mass. The heuristics we use prefer including edges of low weight in the solution set, therefore we scale down the weights of edges that received high scores. Specifically, the edge weights are multiplied with 1 - (s), where is the element-wise sigmoid function. By running the CO heuristic on this modified graph, we paramcterize the hcuristic using the GNN's output scores s. Importantly, since the heuristic guarantees that its output satisfies the constraints of the CO problem, the same is also true for the parameterized heuristic. In the remainder of this paper, h(g G, = h G') denotes the probability distribution defined by a probabilistic CO hcuristic parameterized this way. It samples and outputs vector e E (0, 1318| that represents a solution to the CO problem, such as a TSP tour or k-cut. A value of in ÿ means that the corresponding edge is in the solution set.
5

---

Published in Transactions on Machine Learning Research (03/2026)
5.2 Preference- gradient estimation (PBGE)
In preference learning, training instance consists of an inpul and pair of possible outputs. The supervision signal is an annotation indicating that one of the outputs ye is of higher quality than the other output ye We can construct a similar sctup for CO by leveraging a pro-existing probabilistic CO hcuristic h. Sampling from the heuristic multiple times likely yields two solutions Φ1. 92.92 ~ h(y | s's of different quality for a given problem instance 9 ~ D from dataset DD Here we use s' = fo for (g) obtained from the previous training iteration's model. These solutions can easily be ranked by applying the CO problem's objective function" Jco. This means assigning fw (winner) and ÿJ (loser) such that (Co S Jco(
We now propose the following preference-based loss function:
h(u 9,s)
L(D, 8) Be 9~ D d(Dwr 91) 91) log
h(g.. 9
Intuitively, this rewards assigning a high probability to the better solution Dw and a low probability to the worse solution dt- d(wwr Dr) is a scaling factor as we will see later, its purpose is to scale the gradients basod on the distance between the objective values of ÿu and ÿt.
Since we treat the CO heuristic hii 9) directly. We therefore introduce a proxy distribution ~ 9) s h(D 9 for which we can obtain probabilities directly. For all heuristics used in this paper, high prior score in s for a certain edge increases the probability of this edge being included in the output ÿ. This motivates the use of an exponential family distribution to model the proxy distribution π for h:
black box, we cannot calculate the probabilities h g) and
exp( (1. 8))
T0 (, = E Eyee exp( (y', 8))
where (.,-) is the inner product and C is the set of all solutions to the CO problem. Since the CO problem's objective function Jco is linear, π models a distribution proportional to Jco- On top of this, the numerator of ι is easily differentiable, which we can use to estimate the gradient of the loss.
Replacing h with π in Equation and inserting Equation simplifies the loss function to
L(D, 8) = - S-D [d( D:) ((I, s) (Ow, (0w, +))]
(3)
Now, the gradient of this expectation with respect to is
V.L(D, 8) = -.g....rrM(ils... SoD dd (0) 9w)),
(4)
whose singlo-sample Monte Carlo estimate can be written
V.L(g, 8) x d(gw. (0) - 9w), where Dw 91 ~ h(0 g,
(5)
Intuitively, the gradient is negative at a certain edge if that edge is in the better solution, but not in the worse solution. A negative gradient raises the GNN's output score, meaning that the GNN will be nudged towards including this edge in its solution. Similarly, positive gradient means that the corresponding edge was in the worse solution, but not in the better solution. This nudges the GNN's output down, so it pushes the GNN towards not including this edge.
The form of the gradient is reminiscent of those used for preference learning with LLMs Rafailov et al. 2023 Meng et al. 2024b. There, the gradient makes the model increase the likelihood of the better solution and decrease the likelihood of the worse solution, and scaling factor is used to weigh important gradients more highly. Unlike the preference learning setting used with LLMs, we not only know which solution in pair is better, but we can measure the quality of each solution exactly using the objective function. This eliminates the need for human annotators to rank pairs of examples. Moreover, we can leverage the objective function to more easily compute a suitable scaling factor.
While Jco depends on graph and predicted solution ú. we omit the graph parameter for readability. TTh input graph & is also an argument but we omit it for ease of readability.
6

---

Published in Transactions on Machine Learning Research (03/2026)
Gradient scaling. If the solutions th and are of similar quality, we do not want to strongly move the GNN towards either solution. We therefore scale the gradient with the relative optimality gap between the two solutions,
(Co 1. d(ww: 91) (Co
This is always non-negative, since, by definition, Joo (tw) Using this scaling factor places more weight pairs of solutions where the difference in their respective optimality gaps is large. In particular, due to the -1 term, if the two solutions are of the same quality, the gradient is set to zero. This means we do not move the GNN towards either solution. The scaled gradient is
Jco(Di) [Joo(D)))) -1) (ūr tw) Jco (Dw)
VxL( ~
Solution pool. The variance of the gradient can be reduced by estimating the expectation Equa- lion 4y creating a pool of solutions with the heuris- tic and by constructing pairs from this pool. We form the pairs by combining the best solution from the pool with each of the weaker solutions. In prac- tice, the accuracy of the gradients depends heavily on the quality of the best found solution Φw. At the beginning of training, the GNN cannot yet output good enough scores to consistently find reasonable Tw- To remedy this, we also run the heuristic the unmodified graph and add the resulting solutions to the pool from which the pairs are generated. This has the additional benefit of ensuring that multiple distinct solutions can always occur the solution pool, even if the GNN outputs scores that strongly favor one particular solution, thus preventing train- ing from stalling. The complete training procodure is described in Algorithm
Algorithm 1 One training iteration with PBGE
s' for
Sample n solutions from h guided by the current s', and m unguided solutions
91...., In ~ h(u 9, s')
Dn Dat1..... Intm ~ h( 9)
) 4- ( {n
Uw +- arg minges (c)
Estimate gradient using each pair involving Uw
V.C(g, s0 Σ
Jco - 1 (3i - 2w)
Jco (w))
DI
Backpropagate gradient (,L(G,
Decoding at test time. At test time, the model's output needs converted (decoded) to solution the CO problem. This can simply be done by running the CO heuristic with the model's output as input, described in [Section The solution can be improved by running probabilistic CO heuristic repeatedly and using the best solution found final output.
5.3 Theoretical analysis
We provide the following theoretical result, which illustrates that we can turn probabilistic CO heuristic into an exact algorithm if we find optimal modified input graph.
7

---

Published in Transactions on Machine Learning Research (03/2026)
Theorem Let g (V, F, w) be an undirected, weighted graph. Moreover, let h(g 9, 8) be the probability distribution defined by one of the following heuristics, guided by porameters I8 Eg]
the Karger Steie algorithm for the minimum k-cut problem,
an insertion algorithm for the TSP, e-g- random insertion, or
the (deterministic) Christofides algorithm for the TSP.
Finally, let y be an optimal solution for the respective problem G. There erists set of parameters E BI such that
h(y 8) 1.
In other words, there are GNN output parameters that guarantee that an optimal solution is found, even if a randomized heuristic such as Parger-Steil or random insertion used. In Appendix B we break this theorem down for each individual algorithm and provide more rigorous formulations as well as proofs.
6 Experiments
We validate our approach on two well-known CO problems: the TSP and the minimum k-cut problem. For both problems, we synthetically generate problem instances and establish basclines as reference. We use residual gated graph convnets [Bresson & Laurent 2017), but adapt them to include edge features ety and dense attention map v/ following Joshi et al. (2019). Please see Appendix for details.
The selection of the probabilistic heuristic for PBGE should be made with the trade-off between solution quality and runtime in mind. The algorithm needs to be fast enough to be during training, while simultaneously delivering good enough solutions for PBGE to construct useful gradients. For the minimum k-cut problem, use the Karger Stein algorithu our heuristic, as it is considered optimal in terms of the probability of finding the minimum k-cut (Gupta et al. 2020), and runs quickly enough to be used during training. For the TSP, we choose the random insertion heuristic; while higher-quality heuristics exist, their longer runtime prevents them from being useful during training.
Table 1: Minimum k-cut optimality gaps on graphs with 100 nodes and = 2, using Kargor-Stein as docodor. Mean = standard deviation were calculated over ten evaluation runs on the same model parameters. the supervised and self-supervised rows, a GNN trained with the indicated method used to guide the Karger Stein algorithm. In the columns labeled "Best out of 3 runs", the Karger Stein algorithm is run three times on the same GNN outputs, and the best result is used.
Method
Unweighted graphs
NOIgen+
Single run
Best out of runs
Single run
Best out of 3 runs
Non-learned
Karger-Sted -tein
3.21
(330ms)
0.62%++0.07 (971ms)
11.29%+0.77 (352ms)
0.43%+0.11 (1.00s)
Supervised
BCE loss
0.20%
(402ms)
0.03%++0.02
(1.05s)
0.41%+0.07
(415ms)
0.06%+0.04
(1.04s)
I-MLE
1.67%+1.110
(415ms)
0.14%
(1.03s)
2.53%+10.12
(435ms)
0.28%=+0.06
(1.08s)
Self-supervised
REINFORCE
2.18%+0.115
(408ms)
0.41%
(1.03s)
3.15%++0.36
(440ms)
0.18%+0.08
(1.09s)
I-MLE
1.39%
(402ms)
0.52%
(1.01s)
7.63%
(444ms)
0.41%110.07
(1.10s)
Id.
3..2%%+0.15
(407ms)
0.61%+0.05
(1.02s)
+.44%
(428ms)
0.42%+0.07
(1.06s)
PBGE (ours)
0..8%
(398ms)
0.06%-10.05
(1.01s)
0.58%
(439ms)
0.09%+1.00
(1.08s)
8

---

Published in Transactions on Machine Learning Research (03/2026)
minimum cut was found
100%
minimum cut was found
100%
Graphs for which the
Graphs for which the
90%
90%
80%
80%
70%
70%
60%
Karger-Stein without GNN
60%
Karger-Stein without GNN
50%
GNN trained self-suee with PBGE
50%
GNN trained self-suprrvised with PBGE
GNN trained supervised with BCE loss
GNN trained supervised with BCE loss
40%
40%
8
1
2
10
Number of Karger-Stein runs
Number of Karger-Stein runs
(a) On graphs without edge weights and 100 nodes.
(b) On graphs without edge weights and 200 nodes.
The number of graphs for which the minimum k-cut was found after a given number of Karger Stein runs, on 2. For example, for Karger- Stein without GNN on graphs with 100 nodes (Figure 2a), two Karger-Steie Stein runs suffice find the minimum k-cut for 83% of graphs in the validation sct.
Figure 2:
Table 2: Minimum k-cut optimality gaps on unweighted graphs with 100 nodes, for h 3 and k 4. The row labeled "PBGE" refers to GNN trained self-supervised with PBGE, using the Karger Stein algorithm as decoder. In the columns labeled "Best out of 3 runs", the Karger-Stein algorithm is run three times on the same GNN outputs, and the best result is used.
Method
k = 3
k 4
Single run
Best out of 3 runs
Single run
Best out of 3 runs
Karger Stein
32.95%
4.93%
45.92%
9.16%
PBGE (ours)
3.71%
0.04%
9.72%
0.81%
6.1 Problem instance generation and baselines
For minimum k-cut, we use the established graph generator NOIgen Nagamochi el al. 1994). Since it relies on dramatically scaling down the weights of edges that are in the minimum k-cut in order to avoid trivial solutions, makes casy for a GNN identify the correct edges. To make the graphs more challenging, we extend NOIgen also use graph structure to avoid trivial solutions, which allows us to scale down edge weights less dramatically. We call this improved graph generator NOTgen We also generate unweighted graphs that only rely graph structure to prevent trivial solutions. Graphs for the TSP are generated according to the established method described in Kool et al. (2019), Joshi et al. 2009 2021). These datasets are named TSP-20, TSP-50 and TSP-100 according to the number of nodes in each graph. For each dataset, we generate 10,000 training graphs, 1,000 validation graphs and 1,000 test graphs. Please refer to Appendix E for further details.
Since we assume a setting without access to ground truth solutions the CO problems, our primary baselines are gradient estimation schemes for unsupervised training. We set the loss to
L(D,8) Bl [Jc((D]]
and estimate VgL(D,s) using I-MLE Niepert et al. 2021). and REINFORCE (Williams 1992). as well "Id." in tables. Here, I-ML.E and
identity with projection (Sahoo et al. 2023), which refer identity with projection act representatives of the decision-focused learning paradigm (Mandi et al. 2024
We note that other approaches from this field, such as Berthet et al. 22020 can also be applied here. We also train supervised baselines using an edge-level binary cross entropy (BCE) loss comparing the GNN's output scores & with a pre-calculated ground truth solution y. Additionally, we train models using I-MLE in a supervised fashion, comparing the heuristic's output ÿ with y using Hamming loss. See Appendix D for details on these baselines.
9

---

Published in Transactions on Machine Learning Research (03/2026)
-10
Loss
-20
mil M / / Mo
12
Deudon et al. (sampling 1280 times)
30
10-
Optimality gap (%)
Deudon et al. (greedy)
40
8
-50
25
50
75
100
125
150
175
PBGE (random insertion, 20 runs)
Iteration
PBGE (random insertion, 100 runs)
Figure 3: Evolution of the unscaled loss while train- ing on minimum k-cut with 2, using unweighted graphs with 100 nodes.
Kool et al. (greedy)
Kool et al. (sampling 1280 times)
0
10
20
30
40
50
60
Table 3:
The amount of time required to train GNN for minimum k-cut on unweighted graphs using PBGE, for different graph sizes (n) and values of k.
Runtime (minutes)
Figure 4: The Pareto frontier of self-supervised meth- ods on TSP-100. Pon-Paarto-optinal basclines with very high optimality gaps or very long runtimes are omitted for clarity.
k =
k ==
k 4
n 100
4h 8min
7h 39min
6h 13min
n 200
15h 46min
6.2 Results
Minimum k-Cut. We evaluate our method on the minimum k-cut problem, using the Karger-Stein algorithm as a base. Table I shows optimality gaps of the unmodified Karger- Stein algorithm, as well as several versions of our method. Each version angments the Karger-Stein algorithm with a GNN, and they differ by how the GNN was trained. In practice, is common to run the Karger Stein algorithum multiple times, and to use the best found cut as the final result. We therefore report optimality gaps after decoding using single Karger-Stein run, well as decoding with 3 Karger-Stein runs the same GNN outputs. Note that when augmenting the Karger-Stein algorithm with GNN trained with PBGE, the optimality gap improves by an order of magnitude compared to the unmodified Karger Stein algorithm. On top of this, the GNN trained with PBGE comes close to matching the GNN trained supervised with BCE loss. This is despite the fact that the BCE loss assumes access to ground truth solutions for supervised training, which leads to a much easier setting.
In practice, the most important metric is the number of runs for Karger Stein to find the optimal k-cut. If this number is low, minimum k-eut was found. Figure 2 shows for how many graphs the minimum k-eut is found in set number of runs, comparing the unmodified Karger-Ste Stein algorithm with two versions that were augmented using a GNN. On both datasets, the augmented Karger Stein algorithm needs much fewer runs to find the minimum k-cut, almost always finding on the first attempt. Again, the GNN trained self-supervised with PBGE comes close matching supervised performance.
Karger-Stein a small number of times and be reasonably certain that the
The results so far have used A 2, but our approach can be applied to any value of k. Table shows optimality gaps of PBGE and Karger-Ster -Seein with k 3 and & 4. In both cases, augmenting the Karger Stein algorithm using a GNN trained self-supervised with PBGE substantially improves the optimality gap. Figure 3 shows how the (unscaled) loss in [Equatin 3 evolves during training. The figure demonstrates that the loss decreases until training converges, indicating that the PBGE update rule optimizes the proposed objective. Note that we only calculate the loss for logging purposes here; since we train using the estimated gradient, the loss generally does not need be computed explicitly. We show an overview of the amount of time required train using PBGE for different values of n and & in Table 3 Additional experiments can be found in Appendix F.1
10

---

Published in Transactions on Machine Learning Research (03/2026)
Table 4: TSP optimality gaps, with mean + standard deviation, calculated over ten evaluation runs on the same model paramcters. We indicate the decoder used in parentheses. Values with are obtained from these papers and therefore do not include standard deviations. We provide an extended version of this table with more baselines, inchuding supervised BCE and I-MLE, in Appendix F.2
Method (decoder parentheses)
T1 = 20
n 50
n = 100
Self-supervised
Bello et al.
(greedy)
1.42%*
4.46%
6.90%
Khalil et al.
(greedy)
1.42%
5.16%*
7.03%*
Deudon et al.
(greedy)
0.66% * (2m
3.98% (5m)
8.41%* (8m)
Dendon et al.
(greedy + 20PT)
0.42% (4m)
2.77%* (26m)
5.21%* (3h)
Deudon et
(sampling 1280 times)
0.11%* (5m)
1.28% (17m)
12.70%* (56m)
Deudon et al.
(sampling 1280 times + 20PT)
0.09%* * (6m)
1.00%* (32m)
4.64% (5h)
Kool al.
ggreddy)
0.34%*
1.76%* (2s)
4.53%* (Gs)
Kool et al.
(sampling 1280 times)
0.08%* * (5m)
0.52% x (24m)
2.26% * (1h)
REINFORCE (random ins., 20 runs)
7.98%++0.08 (769ms)
23.84 23.84%++..10 (11.625)
52.83% 00.477770.47 (1.38m)
REINFORCE (random ins., 100 runs)
4.78%+0.03 (3.64s)
11.24% (57.85s)
31 31.06%+0.25 (7.53m)
I-MLE (random ims., 20 runs)
10.54%=0.15 (761ms)
35.87%.10.34
(11,
61.42%.10.22 0.23 (1.37m)
I-MLE (random ins., 100 runs)
6.55%++0.10 (3.68s)
19.40%+00.24
(56.63s)
40.42%+0.14
(7.51m)
1d. (random ins., 20 runs)
8.92%.10.13 (762mss)
31.87%
(11.10s)
56.55%:10.33
(1.41m)
1d. (random ins., 100 runs)
5.16% (3.66s)
17.85% 09 (55.92s)
39.69%
(7.48m)
PRGE (ours) (random ins., 20 runs) PBGE (ours) (random ins., 100 runs)
0.000 (763ms)
2.37%+0.02
(11.118)
5.12%+00.0
(1.43m)
0.05%:10.01
(3.73s)
1.13%10.03 (53.98s)
3.60% (7.44m)
Non-learned heuristics
Christofides
8.72%110.00 (45ms)
11.07%:10.00
(685ms)
11.86%10.00
(4.45s)
Random Insertion
4.46%+0.08 (41ms)
7.57%+00.8
(575ms)
9.63%++0.11 (4.34s)
Farthest Insertion
2.38%:10.00 (57ms)
5.50% (909ms)
7.58% (5.68s)
LKH3
0.00% (18s)
0.00%% (5m)
0..0%** (21m)
Travelling salesman problem (TSP). Table showw the optimality gaps of our approach and its variants on TSP. All of our models were trained using random insertion as the CO heuristic. For PBGE, we sampled 10 solutions from h G, s) and 10 solutions from h( g).
The decoder used at test time is listed after the name of the respective method in parentheses. "Random ins., 20 runs" refers to running the random insertion algorithm 20 times and using the best tour as the final output. Greedy search starts from an arbitrary node, and follows the edge with the highest score to select the next node. This process of greedily following the best odge is repeated until each node has been visited once. To ensure that the resulting lour is valid, edges that lead to nodes that have already been visited are excluded. Sampling simply refers to sampling multiple solutions and using the best one. "+ 20PT" refers improving the decoded solution using 20PT local scarch (Croes) 1958).
F Figure 4 shows the Pareto frrntier of sell-supervised methods on TSP- PBGE achieves Parelo-optimality w.r.t. our baselines when decoding with 100 random insertion runs.
7 Conclusion
We introduced a method to improve existing heuristics for CO using GNNs. The GNN predicts parameters, which are used as input for the non-lcarned heuristic produce a high-quality solution to the CO problem. The GNN is trained based on the CO problem's 's downstream objective, without the need for labeled data. To achieve this, we used gradient estimation to backpropagate through the heuristic. We proposed novel gradient estimation scheme for this purposc, which we called preference-based gradient estimation (PBGE).
Limitations and future work. Incorporating CO heuristic during training means that the training process is more computationally intensive compared to competing approaches. This also means that an existing probabilistic heuristic is required for our approach, and the choice of this heuristic has a large impact on the final performance. From theoretical perspective, the derivation of PBGE makes use of approximations, limiting its accuracy.
11

---

Published in Transactions on Machine Learning Research (03/2026)
There are several ways in which this work can be extended. Firstly, generalizing PBGE to nonlinear objectives would greatly broaden its applicability. Secondly, while our current theoretical analysis tackles expressivity, further investigation into learnability could provide a better understanding of PBGE's capabilities. Lastly, we only experimented on CO problems for which solutions can be represented in terms of the graph's edges. More insight could be gained from applying this approach to different kinds of CO problems and to larger CO instances.
Acknowledgments
The authors would like to thank Ancesh Barthakur, Matteo Palmas, Roman Freiberg, and Jiaqi Wang for fruitful discussions. The authors thank the International Max Planck Research School for Intelligent Systems (IMPRS-IS) for supporting Arman Mielke. The contributions of Thilo Strauss were carried out while employed with ETAS Research.
References
Antonios Antoniadis, Marek Eliáš, Adam Polak, and Moritz Venzin. Approximation algorithms for combina- torial optimization with predictions. In International Conference on Learning Representations, 2025.
David L. Applegate, Robert E. Bixby, Vašek Chvatál, and William J. Cook. The Traveling Salesman Problem: A Computational Study. Princeton University Press, 2006.
Anirudhan Badrinath, Prabhat Agarwal, and Jiajing Xu. Hybrid preference optimization: Augmenting direct preference optimization with auxiliary objectives. arXiv e-prints, pp. arXiv 2405, 2024.
Irwan Bello, Hicu Pham, Quoe V. Le, Mohammad Norouzi, and Samy Bengio. Neural combinatorial optimization with reinforcement learning. In International Conference on Learning Representations, 2017.
Emmanuel Bengio, Moksh Jain, Maksym Korablyov, Doina Precup, and Yoshua Bengio. Flow network
based generative models for non-iterative diverse candidate generation. In Advances in Neural Information Processing Systems, volume 34, pp. 27381 27394. Curran Associates, Inc., 2021.
Yoshua Bengio, Nicholas Léonard, and Aaron Courville. Estimating or propagating gradients through stochastic neurons for conditional computation, 2013.
Quentin Berthet, Mathieu Blondel, Olivier Teboul, Marco Cuturi, Jean-Philippe Vert, and Francis Bach. Learning with differentiable pertubed optimizers. In Advances in Neural Information Processing Systems, volume 33, pp. 9508 9519..999...1111111111 Curran Associates, Inc., 2020.
Xavier Bresson and Thomas Laurent. Residual gated graph convnets. arXiv preprint 2017.
Fanchen Bu, Hyeonsoo Jo, Soo Yong Lee, Sungsoo Ahn, and Kijung Shin. Tackling prevalent conditions in unsupervised combinatorial optimization: Cardinality, minimum, covering, and more. In Proceedings of the 41st International Conference Machine Learning, volume 235 of Proceedings of Machine Learning Research, pp. 4696 4729. PMLR, Jul 2024.
Chandra S. Chekuri, Andrew V. Goldberg, David R. Karger, Matthew S. Levine, and Cliff Stein. Exporimental study of minimum cut algorithms. In Proceedings of the Fighth Annual ACM-STAM M Symposium on Discrele Algorithms, SODA '97, pp. 324 333. Society for Industrial and Applied Mathematics, 1997.
Hanni Cheng, Haosi Zheng, Ya Cong, Weihao Jiang, and Shiliang Pu. Select and optimize: Learning to solve large-scale TSP instances. In Proceedings of The 26th International Conference on Artificial Intelligence and Statistics, volume 206 of Proceedings of Machine Learning Reseorch, pp. 1219-1231. PMLR, Apr 2023.
Andrea Corsini, Angelo Porrello, Simone Calderara, and Mauro Dell' Amico. Self-labeling the job shop scheduling problem. In Advances in Newral Information Processing Systems, volume 37, pp. 105528- 105551. Curran Associates, Inc., 2024.
12

---

Published in Transactions on Machine Learning Research (03/2026)
G. A. Croes. A method for solving traveling-salesme problems. Operations Research, 6(6):791-812, Dec 1958.
Michel Deudon, Pierre Cournut, Alexandre Lacoste, Yossiri Adulyasak, and Louis-Martin Rousseau. Learning heuristics for the TSP by policy gradient. In Integration of Constraint Programming. Artificial Intelligence, and Operations Research: 15th International Conference, CPATOR, pp- 170-181. Springer-Verlng, Jun 2018.
Haonan Duan, Pashootan Vaezipoor, Max B Paulus, Yangjun Ruan, and Chris Maddison. Augment with care: Contrastive learning for combinatorial problems. In Proceedings of the 39th International Conference on Machine Learning, volume 162 of Proceedings of Machine Learning Research, pp. 5627 5642. PMLR,
Jul 2022.
Adam N Elmachtoub and Paul Grigas. Smart "predict, then optimize". Management Science, 68(1):9-26, Jan 2022.
Maxime Gasse, Didier Chetelat, Nicola Ferroni, Laurent Charlin, and Andrea Lodi. Exact combinatorial optimization with graph convolutional neural networks. In Advances in Neural Information Processing Systems, volume 32. Curran Associates, Inc., 2019.
Dobrik Georgiev Georgiev, Danilo Numeroso, Davide Bacciu, and Pietro Lio. Neural algorithmic reasoning for combinatorial optimisation. Tn Proceedings of the Second Learning on Graphs Conference, volume 231 Proceedings of Machine Learning Research, pp. 28:1 28:15. PMLR, Nov 2023.
A Anupam Gupta, Euiwoong Tee, and Jason Li. The karger-stein algorithm is optimal for k-cut. In Proceedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing, pp. 473 473-484, 2020.
Chaitanya K Joshi, Thomas Laurent, and Xavier Bresson. An efficient graph convolutional network technique for the travelling salesman problem. arXiv preprint arXiv:1906.0 01227, 2019.
Chaitanya K Joshi, Quentin Cappart, Loris-Martin Rousseau, and Thomas Laurent. Learning TSP re- quires rethinking generalization. In International Conference Principles and Practice of Constraint Programming, 2021.
Andrew Kahng, Robert Nerem, Yusu Wang, and Chien-Yi Yi Yang. NN-Steiner: A mixed algorthico approach for the rectilincar Steiner minimum tree problem. Proceedings of the AAAI Conference on Artificial Intelligence, 38:13022 13030, Mar 2024.
Nikolaos Karalias and Andreas Loukas. Erdös goes neural: An unsupervised learning framework for combinatorial optimization on graphs. In Advances in Neural Information Processing Systems, volume 33, pp. 6659 6672. Curran Associates, Inc., 2020.
Robert L. Karg and Gerald L. Thompson. A heuristic approach to solving travelling salesman problems. Management Science, (0(2):225-246) 1964. doi: 10.1288/mmss..0..2222
David R. Karger. Global min-cuts in RNC, and other ramifications of a simple min-cut algorithm. In Proceedings of the Fourth Annual ACM-SIAM Symposium on Discrete Algorithmss, SODA '93, pp. 21 30. Society for Industrial and Applied Mathematics, 1993.
David R. Karger and Clifford Stein. An Ó(n²) algorithm for minimum cuts. In Proceedings of the Twenty-Fifth Annuaal ACM Symposium on Theory of Compuling, STOC '93, pp. 757-765. Association for Computing Machinery, 1993. doi:
Elias Khalil, Hanjun Dai, Yuyu Zhang, Bistra Dilkina, and Le Song. Learning combinatorial optimization algorithms over graphs. In Advances in Neural Information Processing Systems, volume 30. Curran Associates, Inc., 2017.
Hyeonah Kim, Minsu Kim, Sungsoo Ahn, and Jinkyoo Park. Symmetric replay training: Enhancing sample efficiency in deep reinforcement learning for combinatorial optimization. In Proceedings of the 41st International Conference on Machine Learning, volume 235 of Proceedings of Machine Learning Research, pp. 111164... PMLR, Jul 2024.
13

---

Published in Transactions on Machine Learning Research (03/2026)
Wouter Kool, Herke van Hoof, and Max Welling. Attention, learn to solve routing problems! In International Conference on Learning Representations, 2019.
Yeong-Dac Kwon, Jinho Choo, Iijoo Yoon, Minah Park, Duwon Park, and Youngjune Gwon. Matrix encoding networks for neural combinatorial optimization. In Advances in Neural Information Processing Systems, volume 34, pp. 1138-51149 Curran Associates, Inc., 2021.
Zijun Liao, Jinbiao Chen, Debing Wang, Zizhen Zhang, and Jiahai Wang. BOPO: Neural combinatorial opti- mization via best-anchored and srrectivegguided preference optimization. or preprint arXiv:2503.07588
Mar 2025.
Jayanta Mandi, James Kotary, Senne Berden, Maxime Mulamba, Victor Bucarey, Tias Guns, and Ferdinando Fioretto. Decision-focused learning: Foundations, state of the art, benchmark and future opportunities. J. Artif. Int. Res., 80:1623 1701, Sep 2024.
Evan McCarty, Qi Zhao, Anastasios Sidiropoulos, and Yusu Wang. NN-Baker: A neural-network infused algorithmic framework for optimization problems on geometric intersection graphs. In Advances in Neural Information Processing Systems, volume 34, pp.
Curran Associates, Inc., 2021.
Yu Meng, Mengzhou Xia, and Danqi Chen. SimPO: Simple preference optimization with a reference-free reward. In Advances in Neural Information Processing Systems, volune 37, pp. 124198 124235. Curran Associates, Inc., 2024.
Yimeng Min, Frederik Wenkel, Michael Perlmutter, and Guy Wolf. Can hybrid geometric scattering networks help solve the maximum clique problem? In Advances in Neural Information Processing Systems, volume 35, pp. 22713 222244. Curran Associates, Inc., 2022.
Yimeng Min, Yiwei Bai, and Carla P Gomes. Unsupervised learning for solving the travelling salesman problem. In Advances in Neural Information Processing Systems, volume 36, pp. 47264-47278. Curran Associates, Inc., 2023.
Pasquale Minervini, Luca Franceschi, and Mathias Niepert. Adaptive perturbation--ased gradient estimation for discrete latent variable models. In Proceedings of the Thirty-Sevene Seventh AAAI Conference Artificial Intelligence. AAAT Press, 2023. doi: 10.1609/anai. 111100//aai..3378..66111
Hiroshi Nagamochi, Tadashi Ono, and Toshihide Ibaraki. Implementing an efficient minimum capacity cut algorithm. Mathematical Programming, 67:325-341, 1994.
Mathias Niepert, Pasquale Minervini, and Luca Francoschi. Implicit MLE: Backpropagating through discrete exponential family distributions. In Advances in Neural Information Processing Systems, volume 34, pp. 14567-14579. Curran Associates, Inc., 2021.
Alex Nowak, Soledad Villar, Afonso Bandeira, and Joan Bruna. A note learning algorithms for quadratic assignment with graph neural networks. arXiv preprint arXiv:1706 11K$::1706.04500, Jun 2017.
Mingjun Pan, Guanquan Lin, You- Wei Luo, Bin Zhu, Zhien Dai, Lijun Sun, and Chun Yuan. Preference optimization for combinatorial optimization problems. arXio preprint orxi:2200 08735, May 2025.
Xuanhao Pan, Yan Jin, Yuandong Ding, Mingxiao Feng, Li Zhao, Lei Song, and Jiang Bian. H-TSP: Hierarchically solving the large-scale traveling salesman problem. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 37, pp. 9345-9353, 9353, Jun 2023.
Ruizhong Qiu, Zhiqing Sun, and Yiming Yang. Dimes: A differentiable meta solver for combinatorial optimization problems. In Advances in Newral Information Processing Systems, volume 35, pp. 25531 25546. Curran Associates, Inc., 2022.
Rafael Rafailov, Archit Sharma, Eric Mitchell, Christopher D Manning, Stefano Ermon, and Chelsea Finn. Direct preference optimization: Your language model is secretly a reward model. In Advances in Neural Information Processing Systems, volume 36, pp. 53728-544 537411 Curran Associates, Inc., 2023.
14

---

Published in Transactions on Machine Learning Research (03/2026)
Daniel J Rosenkrantz, Richard E Stearns, and Philip M Lewis II. An analysis of several heuristics for the traveling salesman problem. STAM journal on computing, 6(3):563-588 581, Sep 1977.
Subham Sekhar Sahoo, Anselm Paulus, Marin Vlastelica, Vit Musil, Volodymyr Kuleshov, and Georg Martius. Backpropagation through combinatorial algorithms: Identity with projection works. In The Fleventh International Conference on Learning Representations, 2023.
Sebastian Sanokowski, Sepp Hochreiter, and Sebastian Lehner. A diffusion model framework for unsupervised neural combinatorial optimization. In Proceedings of the 41st International Conference on Machine Learning, volume 235 of Proceedings of Machine Learning Research, pp. 43346 433664433... PMLR, Jul 2024.
Martin J. A. Schuetz, J. Kyle Brubaker, and Helmut G. Katzgraber. Combinatorial optimization with graph neural networks. Nature Machine Intelligence, 4(4): 377, Apr 2022.
Haoran Sun, Etash K Guha, and Hanjun Dai. Annealed training for combinatorial optimization graphs.
arXiv preprint arXio:2207.11542, 2022.
Zhiqing Sun and Yiming Yang. DIFUSCO: Graph-based diffusion solvers for combinatorial optimization. In Advances in Newral Information Processing Systems, volume 36, pp. 3706-3731. Curran Associates, Inc., 2023.
Jan Tönshoff, Martin Ritzert, Hinrikus Wolf, and Martin Grohe. Graph neural networks for maximum constraint satisfaction. Frontiers in artificial intelligence, 3:580607, 2021.
Oriol Vinyals, Meire Fortunato, and Navdeep Jaitly. Pointer networks. In Advances in Neural Information Processing Systems, volume 28. Curran Associates, Inc., 2015.
Marin Vlastelica, Anselm Paulus, Vit Musil, Georg Martius, and Michal Rolinek. Differentiation of blackbox combinatorial solvers. In International Conference on Learning Representations, May 2020.
Frederik Wenkel, Semih Cantürk, Stefan Horoi, Michael Perlmutter, and Guy Wolf. Towards a general recipe for combinatorial optimization with multi-filter GNNs. In The Third Learning on Graphs Conference, 2024.
Ronald J. Williams. Simple statistical gradient-following algorithms for connectionist. reinforcement learning. Machine Learning, 8(3 4):229 256, May 1992. doi: N0.1007/BF00992600
Yaoxin Wu, Wen Song, Zhiguang Cao, Jie Zhang, and Andrew Lim. Learning improvement heuristics for solving routing problems. IEEE Transactions on Neural Networks and Learning Systems, 3395955007, 2022.
Yifan Xia, Xianliang Yang, Zichuan Liu, Zhihao Liu, Lei Song, and Jiang Bian. Position: Rethinking post-hoc search-based neural approaches for solving large-scale traveling salesman problems. In Proceedings of the 41st International Conference on Machine Learning, volume 235 of Proceedings of Machine Learning Research, pp. 54178 54190. PMLR, Jul 2024.
Zijian Xu, Kenshin Abe, Issci Sato, and Masashi Sugiyama. Solving NP-hard problems on graphs with extended AlphaGo Zero. arXiv preprint ar X 1905. 1 11623, 2020.
Morris Yau, Nikolaos Karalias, Eric Lu, Jessica Xu, and Stefanie Jegelka. Are graph neural networks optimal approximation algorithms? In Advances in Neural Information Processing Systems, volume 37, pp. 73124-73181. Curran Associates, Inc., 2024.
Kexiong Yu, Hang Zhao, Yuhang Huang, Renjiao Yi, Kai Xu, and Chenyang Zhu. DISCO: Efficient diffuusion solver for large-scale combinatorial optimization problems. arXiv preprint ar 200iv:2400.19755 2024.
Dinghuai Zhang, Hanjun Dai, Nikolay Malkin, Aaron C Courville, Yoshua Bengio, and Ling Pan. Let the flows tell: Solving graph combinatorial problems with GFlowNets. In Advances in Newral Information Processing Systems, volume 36, pp. 11952 -1969. Curran Associates, Inc., 2023.
15

---

Published in Transactions on Machine Learning Research (03/2026)
A Combinatorial optimization problems and heuristics
A.1 Minimum k-cut problem
A.1.1 Problem Definition
We are given connected, undirected graph 9 (V, E, w) with edge weights w E - Rzo, well desired number of connected components & E N, S k s [V]. The goal is to find a set of edges C g E with minimal total weight whose removal leaves k connected components. This set is called minimum k-cut. Formally, we are optimizing
CCE Ew(e) such that graph (V,E)C) has connected components.
min
eEC
A.1.2 Karger's algorithm
Karger's algorithm (Karger 1993 is a Monte Carlo algorithm for the minimum k-cut problem.
The algorithm is based on the contruction operation: An edge e = {æ, is contracted by merging its nodes æ and y into a new node zy. For clarity, we will call the node that results from this merger a meta-node. Every edge that was incident to exactly one of the two merged nodes is now altered to instead be incident to the mota-node zy: An edge {æ, 2] or {y, 2) bocomes {ay,2]. This may result in parallel odges, meaning that the resulting graph multigraph. All edges {ar, y) removed, so that the resulting multigraph contains self-loops.
Karger's s algorithm works by repcatedly sampling an edge, where the probability of each edge is proportional to its weight, then contracting that edge. This is repeated until there are only k nodes left. Each of these remaining & noda- represents a connected component in the original graph, with each node of the original graph that was subsoquently been merged into that meta-node belonging to this connected component. Any edge in the original graph that spans between two connected components is cut.
Since this algorithm is not guaranteed to find the minimum k-cut, common strategy is to run the algorithm repeatedly and use the smallest found cut as the final result.
A.1.3 Karger-Stein algorithm
The Karger-Ster Steger--Stein-iee algorithm (Krger & Stein 1993 is recursive version of Karger's algorithm, shown in
A Agorit 2
A.2
Travelling Salesman Problem (TSP)
A.2.1 Problem Definition
We are given a complete directed or undirected graph g = EV, with edge weights w E - R. Our goal is find a minimum weight Hamiltonian cycle in G. A Hamiltonian cycle, also called a tour, is a sequence of nodes where each node in the graph appears exactly once, each node in the sequence is adjacent to the previous node, and the first node is adjacent to the last node. The weight of the cycle is the sum of all edge weights of edges between nodes that appear next to each other in the cycle, including the edge from the last to the first node. Instead of representing a tour a sequence of nodes, we will represent it as the set of edges between nodes that appear next to each other in the sequence. Formally, we are optimizing
min TCE cET
Σ w(e)
such that T forms a Hamiltonian cycle.
The nodes are commonly called cities, and the weight of an edge is commonly called the distance between the two cities. The TSP is NP complete.
16

---

Published in Transactions on Machine Learning Research (03/2026)
Algorithm Karger Stein algorithm
KARGER-STEIN
Input: connected, undirected graph g = (V, w)
if [V] S 6 then
return CONTRACT((,2)
else
V target V2
91 CONTRACT(G,))
G2 < CONTRACT(G,
return min KARGGR (TENIN)))) LARREER-STEIN(AA >> Return the lower- cut
end if
CONTRACT
Input: connected, undirected graph EV, w), target number of nodes while [V] > t do
G - sample edge in G and contract it end while return G
Metric TSP. The metric version of TSP additionally assumes that the distances between the cities form metric. This means that
the graph is undirocted (or w(x, y) w(y x) for all x, E V),
distances between citics at different locations are positive, and
the edge weights satisfy the triangle inoquality, L.c. w(x, v) + w(y, w(x, for all 2,y.2
Euclidean TSP. Euclidean TSP is special case of metric TSP in which the cities are located at points in the unit square and the distances between the citics are the Euclidean distances between the respective points. Research on solving the TSP using neural networks often focuses on this version the problem (Kool
ct al. 2019 Joshi et al. 2019 2021
A.2.2 Random insertion algorithm
The random insertion algorithm Karg & Thompson, 1964 is Monte Carlo algorithm for the TSP.
Since a Hamiltonian cycle to a given graph = (V, E) required to contain every u E V exactly once, it is a straight approach to iteratively sample and remove nodes from V until it is emply. The random insertion algorithm, as suggested by Karg and Thompson, begins by selecting two nodes s, E V at random and adds the edges ts, and (t) to initial cycle. In order to extend the cycle to include all nodes, the algorithm now samples node V \ {s, fJ and selects the edges (I, v) and (v,y) such that and are already part of the partial cycle with x F y and such that the sum of the metric distances of (r, v) and (v, 3) is minimal.
The cycles obtained in this way are at most (flog [V[1 + 1) times longer than the optimal cycle (Roenkrantz et al. 1977).
The algorithm is summarized in Algorithm 3
B Proofs
We assume that the edges E of graph G (V, E, w) are an arbitrary but fixed order. This means that the scores assigned to the edges by GNN can be represented vector RI We use sa to denote
17

---

Published in Transactions on Machine Learning Research (03/2026)
Algorithm Random insertion
Imput: connected, undirected graph (V, E, w) T + TSP tour consisting of one random node V - sample node in V that is not part of T yet T + insert v into T to form a loop of two nodes for E [I.....[[[] do V < sample node V that not part of yet
T + insert into T the point in the tour T where it increases the tour's length by the least amount end for return g
the entry of vector associated with edge E E. A subset of edges D can be represented as ÿ E (),1) where a indicates that the respective edge is in the set. For notational simplicity, we will still write E ý for edges that are in this subset.
A probabilistic CO heuristic for an edge subset problem defines a probability distribution over the subsets of edges. We use h( s) to denote the probability that the output is edge subset ÿ given input graph & and edge scores 8, described in [Section 5
We use to denote the element-wise sigmoid function (xx Ite
B.1 Probability of finding the minimum k-cut using the Karger-Steil algorithm
Let G = EV) be undirected graph. During the first iterations of the modified Karger's algorithm, some edges have been merged away. Let E, be the set of edges that are left at iteration (this means E₁ E)). The probability that specific edge is selected for contraction at iteration i is
1 1 ((8))) pi(e) EvEE, 01
Theorem 2. Let G (V, E) be an undirected graph, and let y E {0, 131E1 be a minimum k-cut on G. Moreover, let h(y G, be the probability distribution defined by Karger's algorithm guided by paramelers R E and let be the elemenl-wise sigmoid function. Here, o(s) - y means that o(s)) + Me and o(s.) + 0 if ye = O. Then,
lim My 8) 1. a
In other words, in the limit, Karger's algorithm guided by always finds optimal solution y.
Proof. Assuming that no edge in has been contracted yet, the probability that the edge that is selected for contraction in iteration i is in is
Eeey (1- (1-o(se) eEN Ever, (1 o (8.))
Pi(E =
Karger's algorithm outputs a given cut y if and only if no edge in is contracted by the algorithm (sce Karger & Stein 1993), lemma 2.1). Let k be the parameter for minimum k-cut, i.e. the number of desired connected components. Karger's algorithm will always terminate after [V] - k contraction steps. The probability that no edge in y contracted during the [V| contraction steps
IV|=
1
(1 1-
EvEE, (1 (1- o(s))) )
Ecey (1 (1-o (1-))))))
h(y G) = II (1 - (1-p((e E v) = II
18

---

Published in Transactions on Machine Learning Research (03/2026)
In the numerator, (=) Eeey (1-o(se)) = 0, since all (((e) go to 1. The denominator is greater than zero, because there is al least one edge left. that is not in y, otherwise the algorithm would be finished. Since the fraction goes towards zero, all terms of the product go towards 1. Formally, each term in the product corresponds to the conditional probability of not contracting any edge in y given previous contractions, but since all factors lend to 1, their finile product does as well. Therefore, we arrive al
lim h(y s) =1
x(#)
This conclusion holds for any minimum k-cut y, even if multiple optimal cuts exist, since the argument. depends only on the edges of the specific y.
The result can trivially be extended to the Karger Stein algorithm, a variant of Karger's algorithm, and to weighted graphs (V, E, w)).
B.2 Finding the optimal TSP tour using the Christofides algorithm
Theorem 3. Let G = (V, E, w) an undirected metric graph, and let y be an optimal TSP tour on G. Moreover, let hg be the (determénistic) Christofides algorithm guided by parameters R and let be the element-wise sigmoid function. Here, a(8) + y means that (8.) if ye 1 and (ss)) + 0 Ue O. Then,
(8) lim hg(s) = y.
Proof. Let G' = (V, w²) be the graph that the heuristic receives as input after modification through 8, i.e. w'(e) = (1-o (v.) As a(s) approaches y, meaning that o(8)) + if ye = 1 and (ss.) - ye = 0, the edge weights of g' approach
lim w'e)) lim (1 - o(8))) = fo i y. a(a)by
o(e)-v
w(e) if $ y.
This means for any 0 > O, the GNN will reach oss) such that w'(e) 2 w(e) - for all & and (y) = Eecy ('()) S 6.
The Christofides algorithm begins by calculating a minimum spanning tree Tmin- By choosing = 6, 2: < min.gg w(e), we can guarantee that, once the respective (ss) is reached, the minimum spanning tree looks follows. Tmin consists of all edges in tour y, except for the edge with the highest modified weight in y:
Tinn = y fert.
where e, arg max w/ (e).
egy
(There may be more then one hiigttt edge in y, in which case the minimum spanning tree is not unique. However, all minimum spanning trees are of this form.)
Tmin is a spanning tree, since it is a path that traverses all nodes. To see why Tuin is a minimum spanning tree, consider any set of edges T C E.
If T contains any edge e y, then
w (T) 2 w'(e) 2 w(e) - 5> c 22 w'(z) w vo(Tmin).
Therefore, S cannot be minimum spanning tree.
T y, then T is a cycle and therefore not tree.
19

---

Published in Transactions on Machine Learning Research (03/2026)
If = \ fe) for any edge E y, then w')e) I w/ (e,) and therefore
w (T) w' (Tmin) - w' (e) + w (er) 2 w' (Tmiu).
Tiin is still a minimum spanning tree. Note that the case w' w'") w (Tmin) only occurs if T Tmin or if there are multiple edges in y with the highest modified weight, in which case both T and Tuin are minimum spanning trees of the form described above.
If T includes only edges in y, but is missing two or more edges from y, then it is not spanning tree. T is either not connected, and therefore not tree, or it does not cover all nodes.
The Christofides algorithm picks (one of) the minimum spanning tree(s) of the form described above. Next, it calculates the set of nodes in this minimum spanning tree with odd degree. Since Tinn is path, the only nodes with odd degrec are the endpoints, which the two nodes connected by e,.
Then, the algorithm forms a minimum-weii weight perfect matching on this set of odd-degree nodes. Since the set only contains two nodes, the matching is unique and consists of the single edge er.
In the next step, the Christofides algorithm combines this matching with the minimum spanning tree Tiin- In other words, adds edge e, to Tiin; resulting in Tmin U {e+}= =
Finally, the Christofides algorithm modifies the tour such that each node is only visited once. However, since y is already Hamiltonian cycle, no changes are made and y is returned.
B.3 Probability of finding the optimal TSP tour using an insertion algorithm
Thcorem 4. Let G = (V, E, w) be an undirected metric graph, and let y be an optimal TSP tour on G. Moreover, let h(p s) be the probability distribution defined by an insertion algorithm for the TSP (e-g. random insertion), guided by parameters 8 E TRIEE, There evists a set of parameters s S ER such that
hly 9) =
In other words, there are GNN output parameters that guarantee that the optimal TSP tour is found, even if randomized insertion algorithm such as random insertion is used.
on be the order of the nodes as they are traversed by the optimal tour y, starting at an Proof. Let Un
arbitrary starting node un and going in an arbitrary direction. We assign a 2D position f(e) = (ai,e??) to each node Us We choose E so small that en? < a. This puts the nodes in a line that is almost straight and only slightly curves upwards based on ei?. Let d(v,, vy) be the distance between nodes uy in this 2D space.
Let G = EV) be the graph that the heuristic receives as input after modification through 8, i.e. (1-o)(((s))))
We will assign the scores such that for each edge {u, v), the modified edge weight is w')) = d(u, v). Since 0 a(s.) 1, the edge weights can only be scaled down. We will choose a so small that the smallest edge weight in w is larger than the largest distance in d. Since the x and y coordinates of each node vs increase monotonically with increasing i, the largest distance in d is between the first and last node, d(vi, vx). We choose a, small enough that min.er wie) > d(v1, v,). This means that for each edge e = {u, v). w(e)= > d(u, v),, and therefore there exists a score s, such that (1 - a (s.))w(()) = d(u, v).
We have established that there exists set of scores such that the modified graph G' is metric graph with metric d. It remains to show that on this modified graph, an insertion algorithm will always find TSP tour y- We will prove by induction that the insertion algorithm always maintains monotone tour, i.e. a tour that traverses its nodes in the same order as y (up to reversal). This means that after the last insertion step, the algorithm returns y.
The first three nodes that are chosen are always connected by a minimum-length cycle, which is necessarily monotone (up to reversal). For each node that inserted into the tour afterwards, the tour remains monotone
20

---

Published in Transactions on Machine Learning Research (03/2026)
regardless of how the node is selected. Suppose current tour visits subset S C V in monotone order. Let E V \ S be the next node selected by the insertion algorithm, and let p (resp. q) be the largest index in S with p < & (resp. the smallest with q > k), when such indices exist. If and exist, i.e. if the tour already contains nodes on either side of Uy in the ordering v1,...,, Un, then inserting Up at an odge {a, changes the length by
A by ux)) ) d(a, ux) + d(vi. b) d(a, b).
Since e is negligibly small compared to a, for indices i S l S j one has d(v,, vk) + d(ux, v2) d( 03) < a. In contrast, if l < iss j (or i j < k) the increase is strictly larger than a. Because the current tour is monotone, the unique edge whose endpoints straddle k in the path order is (vp: ug is inserted there because this insertion yields (lpp.ig Dgg 0&) < a, while every other insertion yields A > a.
If only one of 9 exists (i.e. lies outside the current hull of S), the unique best insertion is adjacent to that boundary node by the same calculation. Thus the minimum-increase insertion places vk between this boundary node and either of its neighbors in the current tour. Note that because the tour is monotonous, one of these neighbors is the boundary node at the other end of S. The e-perturbation ensures that out of the two options, the insertion algorithm favors inserting the new node between the first and last node in S. This preserves monotonicity as the newly inserted node becomes the new first node. To see why this option is always taken, let Uf, Va: t be the first, second, and last node in S respectively, and let & < f (this is without loss of generality, the case k > is the same with inverted order of the nodes). As discussed above, the choice is between inserting U2 at edge {ey, fa (breaking monotonicity) or at edge {uy, (preserving monotonicity). The increase incurred by each respoctive choice is
A(yy, U2; Us) = d(vr, 0x) + d(wx Uz) - d(vy, A Mi5 ux) = d(v + d(vi, m/) d(wy, m).
The points Uk, Uy, Uaa in form a (strictly) convex quadrilateral. It is easy to see that a convex quadrilateral, the sum of the lengths of the diagonals is greater than the sum of the lengths of two opposing sides We
therefore have d(vk, Us) + d(v,, fi) > d(vi, e)) d(vy, v.) and therefore A(Vy, Us; v&) A(ry, M1; ux). Since inserting U/ at edge (1y, vi incurs a smaller increase in tour length than {U,, J, the insertion algorithm inserts the node at edge (1y, w/ and monotonicily is preserved.
When all nodes have been inserted, the tour is exactly oi.-.., Ux or its reversal, Le. the same tour as y, independently of how the next node to insert is selected. This proves the claim.
C Implementation details
C.1 Residual gated graph convnets
We use residual gated graph convnets (Bresson & Laurent 2017), but adapt them to include edge features e| and a dense attention map v following Joshi et al. (2019). The input node features xi and edge features oy are first pre-processed using a single-layer MLP (multi-layer perceptron) for each of the two. Each further layer is computed as follows:
x. - = o! + ReLU BN
(BN(WW) W/o!+
Σ nly o wiss) JEN.
o(ei,) with m/. Eyen, o (ely +6)
E ERd
1-1 = e/ + ReLU BN Wieely + W/at + Wyae) 2
where Wi.... W E Rdxd are learnable weights, d is the hidden dimension, ReLU is the rectified linear unit, e" T+er is the element-wise sigmoid function, and e is an arbitrary small value. c denotes the Hadamard product, and N; denotes the set of nodes that are adjacent to i.
BN is batch normalization,
LLtt b, d be the points of (strictly) convex quadrilateral. We want to show that l/a dIl + bbb ell l|a -ll ||e dll. Let
ell || all l|z bll |x |e-c||+ -|x d|- By the triangle inequality, we have || all +||++I [|== > [ba-bil and ||--c| [| dIl >> ||e-d]] dll. These strict
be the point in which the diagonals intersect. We therefore divide the diagonals into ||a dIl 1 ||b
inequalities since æ, a. (resp. 2, c, d) are not collinear. Hence we arrive at. [--=|]| [|=--]]] -il 1| -ell [|==-]] |la-b]] + -[cc-d] d].
21

---

Published in Transactions on Machine Learning Research (03/2026)
The final edge-level output is calculated from the last layer's edge features e/ using another MLP. f(g) E R refers to applying this GNN on graph g.
C.2 Decoding using the Karger-Stein algorithm
In the case of the Karger-Stein algorithm, we noticed empirically that simply modifying the input graph can lead to degenerate behavior during testing. The Karger Stein algorithm uses the graph's edge weights in two places: (1) when sampling edge for contraction and (2) when comparing the cuts that resulted from different recursion arms. We noticed that the performance of our overall method can be improved when using model trained with the setting described in Section 5.2 by using the modified edge weights for the first case and the original edge weights for the second case. Intuitively, if the GNN makes a mistake when scaling the edge weights, using the original edge weights for comparing cuts can allow the Karger Stein algorithm to find the optimal cut regardless.
Details regarding baselines
D.1 Supervised training with binary cross entropy loss
The task is treated as an edge-level binary classification task. The network is trained using a BCE loss:
ofo((()
A
Lsupervised (CE(G, v) BCE((, y)
Σ log d: + (1 y)) log(1 - 9:)
where So GNN, 9 is the input graph, y (0, 1)181 is the ground truth solution and f E (0, El the predicted solution.
A ground truth label of 1 represents that edge belongs minimum k-cut or TSP tour.
D.2 REINFORCE
Recall that the REINFORCE algorithm calculates
WWlliams 1992 also known as the score function estimator,
B [(v)] = Ey-ro(m) [J() log (x)
where J is an objective function, and (a) is a probability distribution parameterized by 0. We assume that po discrete constrained exponential family distribution, i.e.
exp ((x,0) 0))
if satisfies the constraints
(x) En exp ((z 0))
otherwise
For valid x,,
log pa (x) (x. 0) A(O),
where A(0) is the log- log-partition function
A(0) = log
Σ C'EC
exp ((x',0)) .0))
Since voA(0) = Ey<po(s)ly), we get
o log po()) (p)p
22

---

Published in Transactions on Machine Learning Research (03/2026)
Inserting this into the REINFORCE formula gives
V Vel [J0]] = By-po(a) (x) (( (v- By Bor-ooto)e)))
Using the Gumbel-max trick, we sample from po by sampling e ~ Gumbel(0, 1), then calculating y = h(0 + Estimating the outer expectation by sampling once and the inner expectation by sampling N times, we arrive at [Algritthm 4
Algorithm 4 REINFORCE
Input: distribution parameter 0 8 ~ G0m
y - h(0 +
N
VoJ(y) - J(V)
Σ Ve
N
where E ~ (0m 1)
yi + h(O + Ei)
return VoJ(v)
D.3 Implicit maximum likelihood estimator (I-MLE)
I-MLE (Niepert et al. 2021 allows estimating gradients with respect to the paramcters of discrete exponential lamily distributions. This can be used to backpropagate through CO solvers as follows. In the forward pass, perturb the input 0 E R² to the CO solver using noise e~ p(E) sampled from a suitable noise distribution. Then run the CO solver on the perturbed input 0 + E, obtaining output z.
In the backward pass, assume know the gradient of the loss w.r.l. z, V.L. First, obtain modified input O' for which
expect better outputs compared to A. One generally applicable option suggested by Niepert et al. [202]] is O' = 0 - XV where À is a hyperparameter. Using the same noise as in the forward pass, perturb 0' and run the CO solver on 0' c,, obtaining x'. Finally, return the estimated gradient VoL=z=z'
This produces biased gradient estimates, but with much smaller variance than REINFORCE. To further reduce variance, this procedure can be repeated times, sampling new noise e, p(e;) each time and averaging the results.
We used three noise samples from the Sum-of- Gammaa noise distribution suggested by Niepert et al. 2022 using K = 5 and 100 iterations.
D.3.1 Supervised training with I-MLE
The outputs of the GNN are used to guide CO heuristic. This heuristic outputs solution the CO problem, which can be compared to the ground truth solution using Hamming loss. During backpropagation, I-MLEE (Niepert et al. 2021 is used to estimate the gradient of the loss with respect to the GNN's output. This setting has no practical benefit over the simple supervised training using BCE loss, but it serves to measure the effectiveness of I-MLE
The training procedure works as follows.
8 = o (fo(9))
9 h(9 9)
E
1
Csupervised I-MLE (G, y)
Da w1 + (1 -.)y%
E
23

---

Published in Transactions on Machine Learning Research (03/2026)
Note that here, 9 {0, 13181 is guaranteed to be valid solution to the given CO problem. I-MLE is used to estimate dc
D.3.2 I-MLE target distribution
We're using custom target distribution for I-MLE in the supervised setting. This target distribution is similar to the target distribution for CO problems presented in (Niepert et al. 2021). The idea behind it is to recover the ground truth label from the loss, which is possible when using the Hamming loss:
8(0, v) = f(1 - y) + (1 - 9)9
( y) 1
dø
1 1 dy y = 2
(0).))
The best value for 0 is 1 - (we have to invert it because the input to the heuristic is inverted) P With this we arrive at the following target distribution:
1
C
0' =
dg
D.3.3 Self-supervised training with I-MLE
Since we're using a CO heuristic that guarantees that its outputs are valid solutions to the CO problem, we can use the CO problem's objective function as a loss directly instead of the supervised Hamming loss. The ground truth labels are therefore no longer required.
In the case of minimum k-cut, the size of the cut is used loss function. For TSP, the length of the tour is used.
s o (f((9)) 0 = N(g, 1 -88 8)
Lselt-supervised (ML (C)
where Jeo the objective function of the CO problem. Note that the CO problem's constraints do not. explicitly appear here, because the CO heuristic already guarantees that the constraints met.
d(s-1) In this sctting, the general-purpose target distribution for I-MLE presented in (Niepert al.) 2021 is used, setting 20 as suggested by that paper.
As before, I-MLE is used to estimate de
E Graph generation
E.1 Minimum k-cut
Many commonly used graph generators create graphs with low-degree nodes. These graphs contain trivial solutions to the minimum k-cut problem in which & connected components only contain node, and one connected component contains all of the remaining nodes. When creating a dataset for minimum k-cut, care must therefore be taken to avoid graphs with low-degree nodes.
4Using in the same sense Niepert
2021
case,
24

---

Published in Transactions on Machine Learning Research (03/2026)
Graphs without edge weights. A simple method to generate graphs with meaningful solutions to the minimum k-cut problem is as follows. Create k fully connected subgraphs of random sizes within given range. Then, add random number of edges between random nodes of different subgraphs while ensuring that the resulting graph is connected. An additional benefit of this method is that, if the number of edges added between subgraphs smaller than the number of nodes the smallest subgraph by at least two, then the minimum k-cut known from the construction: the cut consists of exactly the edges that were added between subgraphs. However, since all graphs generated this way consist of fully connected subgraphs, these problem instances are limited in diversity.
The range of possible problem instances can be improved by generating graphs of varying density. Start by assigning nodes to k subgraphs of random sizes within a given range. Then, add random number of edges that connect nodes of different subgraphs. For each subgraph, add edges between random nodes within the same subgraph until all nodes have a higher degree than the number of edges between subgraphs. As long as there are enough edges between subgraphs, the minimum k-cut very likely consists of the edges between subgraphs. The minimum node degree and hence the density of the graph depends on the number of edges between subgraphs and therefore on the size of the minimum k-cut.
Graphs with edge weights. For minimum k-cut graphs with edge weights, graph generator commonly called NOIgen (Nagamochi et al., 1994) (named after the initials of the authors) is often used. NOIgen works by first creating specified number of nodes and adding edges between random nodes until a specified density is reached (sometimes, a Hamilton path is created first to ensure that the graph is connected). The weights of the edges are chosen uniformly at random. Finally, the nodes are randomly divided into subgraphs. The weights of edges that connect nodes of different subgraphs are scaled down by fixed factor.
When testing traditional, non-learned algorithms, the scaling factor is sometimes chosen to be very small, such that the minimum k-cut is very likely to consist of the edges between subgraphs (Chekuri et al. 1997] However, this makes the problem trivially easy for GNNs, which can learn that very low edge weight corresponds to an edge belonging to the minimum k-cut, This allows the GNN to disregard the graph structure and therefore circumvent the challenging part of the problem. On the other hand, if the weights of edges between subgraphs are not scaled down enough, the generated graph might have a trivial solution that simply cuts out
nodes.
To combat this problem, we modify NOIgen by controlling not just the weights of edges between subgraphs, but also the number of edges between subgraphs. We add parameter that specifies which fraction of edges is generated between subgraphs (as opposed to within the same subgraph). Ensuring that there are few enough edges between subgraphs allows for milder downscaling of their edge weights without introducing a trivial solution. This in turn prevents the GNN from inferring whether an edge belongs to the minimum k-cut simply from its weight.
The minimum k-cut in these graphs usually consists of the edges between subgraphs, but this is not guaranteed. The ground truth solution is therefore calculated separately to make sure that it reflects the optimal cut, described in Section E.3, Another benefit of calculating them separately is that we can set the number of subgraphs to a different number than k, generating more interesting graphs.
E.2 Travelling salesman problem
Instances of Euclidean TSP are commonly generated with this simple algorithm:
Create a fully connected graph with n nodes
2. For each node, draw a position in the unit square uniformily at random and assign it as node features
3. Calculate the distances between the nodes and assign them edge features
25

---

Published in Transactions on Machine Learning Research (03/2026)
E.3 Calculating ground truth labels for supervised training
In general, ground truth labels are generated using traditional (i.e. non-learned) algorithm. In some settings, the graph can be constructed such that the ground truth solution can be obtained simultaneously from the same construction process, in which case running the traditional algorithm not nocessary.
Minimum k-cut: For graphs without edge weights, the graphs can be constructed with known ground truth solutions. See Secciio E.1 for details. For graphs with edge weights, the Karger-Stein algorithm KKrger & Stein, 1993) is run 100 times, and the smallest cut found is treated as the ground truth minimum cut.
TSP: The well-established Concorde solver Applegate al. 2006), which guarantees optimal
solutions, is used to generate ground truth labels.
F Extended experiments
F.1 Minimum k-cut with k >
It is common to run the Karger-Sue Stein algorithm repeatedly until the minimum k-cut is found with sufficiently large probability. Figure 5) shows for how many graphs the minimum k-cut is found in set number of runs, for and k = For both values of k our approach reduces the number Karger-Stein runs required to find the minimum k-cut with 99% probability by more than half, thus providing a considerable speed up.
F.2 Extended comparison for TSP
Table
compares PBGE with more baselines, including ones that make use of supervised learning.
We also compare against a simple self-supervised baseline that runs random insertion on the input graph 20 times and treats the best solution found as ground truth for BCE loss. We call this baseline "Best-of-20".
The beam search decoder works similarly the greedy decoder. It starts with arbitrary node, then explores the edges with the highest scores. This gives b partial solutions. In each iteration, each partial solution is expanded at its last node, and out of the resulting paths, the b best partial solutions are kept. Edges that would lead to invalid tours are ignored. The parameter called the beam width, and beam search with corresponds to greedy scarch.
minimum cut was found
100%
Graphs for which the minimum cut was found
100%
Graphs for which the
90%
90%
80%
80%
70%
70%
60%
60%
50%
Karger-Stein without GNN
50%
Karger-Stein without GNN
GNN trained self-supervised with PBGE
GNN trained self-superviiee with PBGE
40%
40%
1
2
5 6 7 9
10 11 12
1
3 4
6
8 10 11 12 13
Number of Karger-Stein runs
Number of Karger-Stein runs
(a) Results on 3.
(b) Results on
Figure 5: The number of graphs for which the minimum k-cut found after given number of Karger-Steen runs, k = 3 and k 4.
26

---

Published in Transactions on Machine Learning Research (03/2026)
Table 5: TSP optimality gaps with mean + standard deviation calculated over len evaluation runs on the same model parameters. We group methods by their original paper and indicate the decoder used in parentheses. Results marked with are values obtained from the indicated papers and therefore do not include standard deviations.
Method (decoder parentheses)
n = 20
50
100
Self-supervised
Bello et al.
2017
[greedy)
1.42%*
4.46%
6.90%*
Deudon et al.
2018
(greedy)
0.66%* (2m)
3.98% (5m)
8.41%* (8m)
(greedy + 20PT)
0.42% (4m)
2.77%* (26m)
5.21%* (3h)
(sampling 1280 times)
0.11% (5m)
1.28% (17m)
12.70% (56m)
(sampling 1280 times + 2OPT)
0.09% (6m)
1.00% (32m)
4.64% (5h)
Khalil et 2017
[greedy]
1.42%*
5.16%*
7.03%*
Kool et 20199
[greedy]
0.34%*
1.76%* (2s)
4.53%* (6s)
(sampling 1280 times)
0.08%* (5m)
0.52% * (24m)
2.26% * (1h)
REINFORCE (random ins., 20 runs)
7.98% (769ms)
23.84%10.11 1010 (11.62s)
52.83%10.47 (1.38m)
REINFORCE (random ims., 100 runs)
4.78%=2003 (3.64s)
11.24%110.0 (57.85s)
31.06%.0.22 (7.53m)
1-MLE (random ins., 20 runs)
10.54%110.15 (761ms)
35.87%10.33
(11.14s)
61.22%
(1.37m)
T-MLE (random ins., 100 runs)
6.55%==0.10 (3.68s)
19.40%+0.21
(56.63s)
41.42%+0.14
(7.51m)
Id. (random ins., 20 runs)
8.92%=0013 (762ms)
31.87%+0032
(11.10s)
56.55%+0.33
(1.41m)
Id. (random ins., 100 runs)
5.16%==0.99 (3.66s)
17.85%+0.09
(55.92s)
39.69%
(7.48m)
Best-of-20 (random insertion, 20 runs)
0.40%=0.03 (787ms)
11.91%:40.11
(11.03s)
15.82%
(1.47m)
Best-of-20 (random insertion, 100 runs)
0.10%=0.01 (3.70s)
5.11%=
(52.82s)
9.82%+10.99
(7.38m)
PBGE (ours) (random ins., 20 runs)
0.18%10.01 (763ms)
2.37%=0.02
(11.11s)
5.12%+1.066
(1.43m)
PBGE (ours) (random ins., 100 runs)
0.00%11.01 (3.73s)
1.10% (53.98s)
3..05 (7.44m)
Supervised, not directly comparable
Joshi et al. 2019
(greedy)
0.60%* (6s)
3.10%* (55s)
8.38%* (6m)
(beam search, beam width 1280)
0.10% (20s)
0.26% (2m)
2.11% (10m)
(beam search, width 1280 + heuristic)
0.01% (12m)
0.01%* (18m)
1.39%* (40m)
Sun & Yang 2023
[greedy)
0.10%*
0.24%*
(sampling 16 times)
0.00%*
0.00%*
BCE loss (random insertion, 20 runs)
0.15%=0.01 (787ms)
0.95%=0.00 (10.92s)
2.86%
(1.47m)
BCE loss (random insertion, 100 runs)
0.04%=0.00 (3.75s)
0.59%=0.02 (54.79s)
1.75%=0.03 (7.35m)
I-MLE (random ins., 20 runs)
2.67%=0006 (765ms)
14.71%##.18 (11.24s)
26.57%=#0.17 (1.41m)
I-MLE (random ins., 100 runs)
1.17%=0.04 (3.63s)
9.66%=0.10 (54.80s)
18.91%#0.11 (7.49m)
Non-learned heuristics
Christofides
8.72%=0.00 (45ms)
11.07%.1..00 (685ms)
1186%_10.00
(4.45s)
Random Insertion
4.46%=0.08 (41ms)
7.57%=0.08
(575ms)
9.63%:1.111
(4.34s)
Farthest Insertion
2.38%=0.00 (57ms)
5.50%=00.00
(909ms)
7.58%. (5.68s)
LKH3
0.00%* (18s)
0.00%* (5m)
0.00% (21m)
Exact solvers, not directly comparable
Concorde (Applegate et al.
2006
0.00% (1m)
0.00%* (2m)
0.00%* (3m)
Gurobi
0.00%* * (7s)
0.00%* * (2m)
0.00%* (17m)
27

---

Published in Transactions on Machine Learning Research (03/2026)
Table 6: Hyperparameters used for minimum k-cut.
Hyperparameter
Value
GNN layers
4
GNN hidden channels
32
MLP prediction head layers
2
Optimizer
AdamW
Weight Decay
0.01
Learning rate scheduler
Initial learning rate
0.001
Learning rate scheduler patience
4
Batch size
64 graphs
Table 7: Hyperparameters used for TSP.
Hyperparameter
Value
GNN layers
12
GNN hidden channels
100
MLP prediction head layers
3
Optimizer
AdamW
Weight Decay
0.01
Learning rale scheduler
ReduceL.ROnPlateer
Initial learning rate
0.0001
Learning rate scheduler paticnce
Batch size
64 graphs
G Hyperparameters and other details
Table 6 and Table detail the hyperparameters used for experiments on minimum k-cut and TSP, respectively.
Our training sets for minimum k-cut contain 10,000 graphs, and the validation sets contain 1,000 graphs. For TSP, our training sets consist of 1,000,000 graphs, and our validation sets contain 1,000 graphs.
Hardware resources used for experiments
We used an AMD EPYC 7313 16-Core processor and an NVIDIA H100 GPU in our experiments. Runtime measurements were taken on an 11th Gen Intel Core 17-11850H processor with a base speed of 2.50 GHz, using a single CPU core and no GPU, with a batch size of
28


Reviews:
[{"review_id": "Q36UsSmGj3", "reviewer": "Reviewer_fBYg", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "Yes", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "**Summary:**\nThe paper proposes a way to augment existing heuristics for combinatorial optimization problems with a machine learning component. They specifically target problems that admit a graph-based formulation. Its approach consists of training a graph neural network to predict altered edge weights on the problem's graph representation, over which an existing (fast) heuristic is then executed. By learning to predict the right edge weights, this pipeline can produce higher-quality solutions than the ones obtained by running the heuristic on the original, unmodified graph. One obstacle to this approach is the fact that the heuristics produce discrete solutions. Thus, the gradient of the solution with respect to the predicted edge weights is zero almost everywhere, obstructing gradient-based training. To tackle this issue, the authors propose a novel gradient estimation technique called preference-based gradient estimation (PBGE), which operates by comparing the quality of multiple solutions sampled using the heuristic, and which can be used in a self-supervised learning setup. The authors evaluate the performance of their technique on two CO problems: the travelling salesman problem (TSP) and the minimum k-cut problem.\n\n\n**Strengths:**\n\n* The paper introduces an interesting method for parameterizing heuristics in a generic, heuristic-agnostic manner by modifying the input graph on which the heuristic operates.\n\n* To train the model that predicts the input modifications, the paper introduces a novel gradient estimation scheme.\n\n* The paper is well written, clearly structured and pleasant to read.\n\n* The experimental results are quite convincing (see below).\n\n**Weaknesses:**\n\n* The approach is only applicable to graph-based problems where the decision variables represent edge selections.\n\n* The approach is only applicable when using probabilistic heuristics.\n\nI also have some questions that I would like the authors to address, as well as several requests for changes to the paper. Please see the sections below.", "claims_and_evidence_yn": "Yes", "claims_explanation": "The results are quite convincing. The authors compared their approach against standard heuristics, as well as heuristics parameterized according to their proposed scheme but trained using methods other than PBGE (e.g., I-MLE, BCE, REINFORCE). They experiment on two problems: the minimum k-cut problem and the TSP. On top of the base tables of results (Table 1 and Table 3), some very welcome additional insights are provided. On the minimum k-cut problem, we are given insight into how the proportion of graphs for which the optimal cut is found changes when the number of runs of the heuristic increases, for different training methods. We are also given results for varying values of *k.* For the TSP, an extensive list of baselines is used for comparison, and the results are nicely visualized along with a Pareto frontier in Figure 3.\n\nHowever, while I generally like the exposition of the results, I also have some questions:\n\n* **Q1:** What is the size of the test sets? Very little information is given in general about the dataset size and the training-validation-test splits used. All I could find on this matter is given in appendix G, but here too, test set sizes are not reported.\n\n* **Q2:** Why is the REINFORCE baseline only used on the TSP, and not on the minimum k-cut problem? Presently, no motivation is given for this decision.\n\n* **Q3:** Similarly, the supervised baselines are only used on the minimum k-cut problem, and not on the TSP, without a clear motivation given. What is the reasoning behind this decision?\n\n* **Q4:** It is unclear to me what the “best out of 3 runs” columns in Table 1 contribute to the insight we are supposed to draw from the table. This is not explicitly touched upon in the accompanying text either.\n\n* **Q5:** For the supervised baselines in Table 1, is the time required to compute the optimal solution (for supervision) included in the reported computation times? \n\n* **Q6:** What do the runs in Table 3 (e.g., “I-MLE (random ins., 20 runs)”) refer to? Are these different runs, of which the best one is selected and reported?\n\n* **Q7:** I feel like the claim “I-MLE acts as a representative of the decision-focused learning paradigm” needs some backing. Why is I-MLE chosen? Would other approaches, like the perturbed optimizers from [1] or the negative identity with projection from [2], also work?\n\n[1] Berthet, Q., Blondel, M., Teboul, O., Cuturi, M., Vert, J. P., & Bach, F. (2020). Learning with differentiable pertubed optimizers. *Advances in neural information processing systems*, *33*, 9508-9519.\n\n[2] Sahoo, S. S., Paulus, A., Vlastelica, M., Musil, V., Kuleshov, V., & Martius, G. Backpropagation through Combinatorial Algorithms: Identity with Projection Works. In *The Eleventh International Conference on Learning Representations*.", "audience_yn": "Yes", "audience_explanation": "This paper will certainly be of interest to members of TMLR’s audience, particularly readers interested in intersections between combinatorial optimization and machine learning. I myself found the paper very interesting, and especially its approach of indirectly parameterizing heuristics by having a machine learning component alter the input graph.", "requested_changes": "* If there are no clear motivations behind the decisions that I refer to in questions **Q2**, **Q3**, and **Q7**, I feel like these matters should be addressed by adding the appropriate experiments.\n\n* More information on the size of the datasets and the train-validation-test splits must be given in the main text.\n\n* I would like to see a more refined discussion in the introduction of which class of problems this approach can be applied to exactly.  Only when encountering Equation 2, in which the inner product of decision variables $\\hat{y}$ and GNN scores $s$ is taken, I realized that the proposed approach is not applicable to all graph problems, but only to graph problems where the decision variables represent edge selections. So, for example, the maximum weight independent set problem, cannot be tackled, since its decision variables represent node selections, rather than edge selections. This understanding was only explicitly confirmed in the future work section, at the very end of the paper. This feels somewhat misleading. I feel that this should be cleared up much earlier on in the paper.\n\n* In Section 5, the discussion of the solution pools and what happens at test time now fall under the “Gradient scaling.” paragraph. I suggest to separate them, by giving them their own named paragraphs, e.g., “Solutions pools.” for the former, and “Test time.” for the latter.\n\n* I really like the intuitive explanation of the gradient, given right under Equation 5. I would like to similarly see an intuitive explanation of loss as well, under Equation 1. The way I understand it, the loss is large when the probability of the ‘loser’ (i.e., $\\hat{y}_l$) in the numerator is large compared to the probability of the ‘winner’ (i.e., $\\hat{y}_w$) in the denominator. Some clarification of this in the text would be appreciated.\n\n* At the end of the introduction, the authors write: “Our approach improves the performance of a commonly used heuristic by an order of magnitude in the case of minimum k-cut while only minimally increasing the runtime.” Strangely, a similar sentence summarizing the results on the TSP is not given. I suggest to add such a sentence, perhaps referring to the fact that PBGE achieves Pareto-optimality on the TSP.\n\n* There is currently a typo in the theorem (“let and let”).\n\n* Currently, “combinatorial optimization” is still used in full after the introduction of the acronym “CO”. Similarly, both forms “i.e., …” and “i.e. …” are used. I would appreciate another pass over the paper to resolve these minor inconsistencies.", "broader_impact_concerns": "I have no broader impact concerns.", "additional_comments": "* **Q8**: Why is the $-1$ term included in the scaling factor? Is this important?\n\n* **Q9**: I see a clear connection between PBGE and the pairwise learning-to-rank approach (e.g., used in [3] in a decision-focused learning context), and particularly its best-vs-rest variant. This makes me wonder: could the use of other ranking approaches also work in the setting of this paper? For example, could a listwise approach be used? I expect that this would come at no additional cost, since it could be applied over the same solution pools currently used for PBGE. Is this something you have experimented with? What are your thoughts?\n\n* **Q10**: I find it surprising that, by design, the difference in solutions $\\hat{y}_1$ and $\\hat{y}_2$ may only arise from randomness inherent to the heuristic used. If my understanding is correct, $\\hat{y}_1$ and $\\hat{y}_2$ differ only when two runs of the heuristic on the same scores produce different solutions. I am curious why this design is chosen. Does this not make the approach reliant the use of a sufficiently stochastic heuristic? An alternative could be to have the GNN predict a Gaussian distribution over outputs $s$ (using the reparameterization trick), and to run the heuristic on these perturbed scores. In addition to removing the reliance on stochastic heuristics, this could also provide more control over the difference between $\\hat{y}_1$ and $\\hat{y}_2$ (through the size of the Gaussian’s variance). Would this also be a valid approach? What are your thoughts?\n\n[3] Mandi, J., Bucarey, V., Tchomba, M. M. K., & Guns, T. (2022). Decision-focused learning: Through the lens of learning to rank. In *International conference on machine learning* (pp. 14935-14947). PMLR.", "extra_scores": {}, "extra_text": {}}, {"review_id": "7ed8aWkL1p", "reviewer": "Reviewer_ht8e", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "No", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "Overall, the paper presents an interesting idea by integrating heuristics into a preference-based training framework, but many key motivations and claimed advantages are not sufficiently validated. The experimental analysis is limited, the baseline coverage is incomplete, and several important concerns about scalability, theory–practice gap, and reliance on heuristics remain unresolved.", "claims_and_evidence_yn": "No", "claims_explanation": "1. The paper claims several advantages, but these are not empirically verified; the experiments only compare final solution quality without analyzing whether the proposed benefits actually materialize.\n2. The motivation for integrating the heuristic directly into the training loop is not convincingly supported by experiments, and the paper does not clearly demonstrate why this design is preferable to directly using heatmaps with strong decoders such as 2-opt or MCTS.\n3. The core contribution, the preference-based gradient estimator, lacks analysis of training stability, hyperparameter sensitivity, ablations, and training cost, making it difficult to assess its robustness or practical usability.\n4. The comparison omits many baselines, including preference-based approaches such as BOPO and POCO, heatmap-based self-supervised methods, and other state-of-the-art neural combinatorial optimization (NCO) self-supervised techniques, leading to an incomplete empirical evaluation.\n5. From the original POMO results, it appears that POMO still performs better on TSP-100 in both quality and runtime; moreover, POMO is an early and relatively basic self-supervised NCO method, which further highlights the gap in performance. It suggests the proposed method may not yet match strong self-supervised baselines.\n6. The method depends heavily on the underlying heuristic, such as random insertion for TSP, which limits solution quality. Since the model only guides the heuristic, the overall performance remains constrained by the heuristic’s inherent strength.\n7. The theoretical results are purely existential and do not bridge the gap to practical learnability. It remains unclear whether the model can realistically approximate such heatmaps in real-world scenarios.", "audience_yn": "No", "audience_explanation": "8. The experiments use small problem sizes such as TSP-100, which is insufficient to demonstrate scalability, especially considering that recent NCO research routinely evaluates significantly larger instances.\n9. The evaluation lacks experiments on standard benchmark datasets and relies mainly on synthetic distributions, raising concerns about generalization and practical applicability.\n10. The Pareto front in Figure 3 may be incomplete, as it excludes strong solvers like LKH3. In addition, adjusting the sampling budgets of other self-supervised methods could potentially lead them to dominate the proposed method.", "requested_changes": "reject", "broader_impact_concerns": "no suggestion", "additional_comments": "", "extra_scores": {}, "extra_text": {}}, {"review_id": "ebzygZB5Q5", "reviewer": "Reviewer_cbsU", "summary": "", "questions": "", "limitations": "", "rating": null, "confidence": null, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "No", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "paper_topic_and_main_contributions": "", "excitement": null, "reproducibility": null, "ethical_concerns": "", "main_review": "", "summary_of_the_paper": "", "summary_of_the_review": "", "strength_and_weaknesses": "", "limitations_and_societal_impact": "", "review_text": "", "summary_of_contributions": "Summary:\n\nThe paper proposes a learning-based framework to enhance existing non-learned heuristics for CO problems, specifically validating the method on the TSP and the Minimum k-cut problem. The core approach involves parameterizing standard heuristics (like Karger-Stein or Random Insertion) by training a GNN to predict edge scores, which are then used to modify the edge weights of the input graph before the heuristic is applied. To enable end-to-end self-supervised training without ground-truth labels, the authors introduce a novel gradient estimation scheme called preference-based gradient estimation (PBGE). PBGE treats the heuristic as a black box and estimates gradients by comparing pairs of solutions sampled from the heuristic, using a proxy distribution to approximate the heuristic's behavior for differentiability. Empirical results demonstrate that the approach improves the performance of the base heuristics, notably on the minimum k-cut problem.\n\n\nStrengths:\n\n1) Hybrid approach ensuring feasibility: By using the GNN to predict parameters (edge weights) for an off-the-shelf heuristic rather than predicting the solution directly, the method ensures valid solutions are produced without complex constraint management.\n\n2) Self-supervised learning: The framework is fully self-supervised, eliminating the need for expensive pre-computed optimal solutions as ground-truth labels, which is often a bottleneck in CO.\n\n3) Strong empirical results on k-cut: The method demonstrates significant performance gains on the Minimum k-cut problem, improving the optimality gap by an order of magnitude compared to the unaugmented heuristic.\n\nWeaknesses:\n\n1) Unprincipled derivation and approximations: The mathematical derivation of the gradient estimator relies on significant approximations that are not rigorously justified:\n\n- The authors replace the true heuristic distribution $h$ with a tractable proxy distribution $\\pi$ within the loss function. This introduces a disconnect between the optimization objective and the actual heuristic behavior.\n\n- When computing the gradient of the loss with respect to scores $s$ in Equation 4, the derivation appears to neglect the fact that the expectation's sampling distribution $h(\\hat{y}|\\mathcal{G}, s)$ depends on $s$. Standard gradient estimation (like REINFORCE) would require a score function term ($\\nabla \\log p$), but Equation 5 suggests the derivative is applied only to the inner term. This looks like a mathematical error or an undefined approximation.\n\n2) Limited theoretical analysis: The theoretical results are restricted to existence proofs. Theorem 1 states that for the considered heuristics, there exists a set of parameters $s$ that renders the heuristic optimal. This is a result on expressivity/universality, but the paper lacks statistical learning theory analysis regarding generalization bounds or sample complexity.\n\n3) Fragility of the \"probabilistic heuristic\" definition: The method relies on sampling distinct solutions $\\hat{y}_1, \\hat{y}_2$ to create rankings. If the probabilistic heuristic outputs a Dirac distribution (i.e., acts deterministically or the GNN becomes highly confident), the sampled solutions will be identical. In this case, the gradient scaling factor $d(\\hat{y}_w, \\hat{y}_l)$ becomes zero, potentially causing the gradient to vanish and learning to stall.\n\n4) Arbitrary restriction to linear objectives: The problem statement explicitly restricts the focus to linear objective functions $J_{CO}$. However, the proposed gradient estimator only relies on the scalar values of the objective function to compute the scaling factor, suggesting the framework could theoretically handle any black-box objective.", "claims_and_evidence_yn": "No", "claims_explanation": "While the empirical evidence demonstrates that the method performs well on the minimum k-cut problem, the mathematical derivation supporting the central contribution (the Preference-Based Gradient Estimation) appears theoretically flawed or significantly under-explained in its current form: see weaknesses above.", "audience_yn": "Yes", "audience_explanation": "Neural combinatorial optimization (NCO) is a significant area of interest within the machine learning community. The paper addresses a key bottleneck in the field: the difficulty of training models without expensive ground-truth optimal solutions. The proposed \"hybrid\" approach, which integrates GNNs with classical heuristics to ensure feasibility, is a practical direction that practitioners would find relevant. Furthermore, the strong empirical results on the Minimum k-cut problem, where the method improves optimality gaps by an order of magnitude, would be of interest to researchers focusing on graph algorithms and self-supervised learning. The attempt to link preference-based learning (popular in LLMs) to CO is also a novel angle that could inspire future work.", "requested_changes": "Critical change (required for acceptance):\n\nClarify the gradient derivation (Equation 4 & 5): The authors must address the mathematical derivation of the gradient. Specifically, they must explain why the dependence of the sampling distribution $h(\\hat{y}|\\mathcal{G}, s)$ on $s$ is ignored when computing the gradient. Is this a deliberate stop-gradient operation? If so, this must be explicitly stated as a heuristic approximation rather than a derived gradient. If it is not a stop-gradient, the authors must explain the absence of the $\\nabla \\log p$ term standard in expectations of this form.\n\nStrengthening changes (recommended):\n\n1) Address deterministic collapse: Discuss the behavior of the gradient estimator if the GNN becomes highly confident or the heuristic acts deterministically (outputting a Dirac). For example, by making additional assumptions on the heuristic so that this does not happen (which would contradict the result of theorem 1, however).\n\n2) Expand theoretical analysis: The current Theorem 1 provides an existence proof (universality). It would significantly strengthen the paper to provide insights into generalization bounds or sample complexity to show the method can actually learn these optimal parameters. To do so, studying distributions on graph instances would be interesting.\n\n3) Clarify linearity restriction: The paper restricts $J_{CO}$ to linear objective functions. However, the gradient estimator seems to rely only on scalar evaluations of $J_{CO}$ for ranking. Please clarify if this restriction is technically necessary; if not, broadening the scope to black-box functions would strengthen the contribution.", "broader_impact_concerns": "I have no concerns on the ethical implications of this work.", "additional_comments": "", "extra_scores": {}, "extra_text": {}}]

Author rebuttal:

Decision: Accept (poster)