Original: Deep Attentive Belief Propagation: Integrating Reasoning and Learning for Solving Constraint Optimization Problems
Revised: Deep Attentive Belief Propagation: Integrating Reasoning and Learning for Solving Constraint Optimization Problems

Original: Abstract
Revised: Abstract

Original: Belief Propagation (BP) is an important message-passing algorithm for variousreasoning tasks over graphical models, including solving the Constraint Optimization Problems (COPs).
Revised: Belief Propagation (BP) is an important message-passing algorithm for various reasoning tasks over graphical models, including solving the Constraint Optimization Problems (COPs).

Original: It has been shown that BP can achieve state-of-the-artperformance on various benchmarks by mixing old and new messages beforesending the new one, i.e., damping .
Revised: It has been shown that BP can achieve state-of-the-art performance on various benchmarks by mixing old and new messages before sending the new one, i.e., damping .

Original: However, existing methods on tuning a staticdamping factor for BP not only is laborious but also harms their performance.
Revised: However, existing methods of tuning a static damping factor for BP not only are laborious but also harm their performance.

Original: Moreover, existing BP algorithms treat each variable node’s neighbors equallywhen composing a new message, which also limits their exploration ability.
Revised: Moreover, existing BP algorithms treat each variable node’s neighbors equally when composing a new message, which also limits their exploration ability.

Original: Toaddress these issues, we seamlessly integrate BP, Gated Recurrent Units (GRUs),and Graph Attention Networks (GATs) within the message-passing frameworkto reason about dynamic weights and damping factors for composing new BPmessages.
Revised: To address these issues, we seamlessly integrate BP, Gated Recurrent Units (GRUs), and Graph Attention Networks (GATs) within the message-passing framework to reason about dynamic weights and damping factors for composing new BP messages.

Original: Our model, Deep Attentive Belief Propagation (DABP), takes the factorgraph and the BP messages in each iteration as the input and infers the optimalweights and damping factors through GRUs and GATs, followed by a multi-headattention layer.
Revised: Our model, Deep Attentive Belief Propagation (DABP), takes the factor graph and the BP messages in each iteration as the input and infers the optimal weights and damping factors through GRUs and GATs, followed by a multi-head attention layer.

Original: Furthermore, unlike existing neural-based BP variants, we proposea novel self-supervised learning algorithm for DABP with a smoothed solutioncost, which does not require expensive training labels and also avoids the commonout-of-distribution issue through efficient online learning.
Revised: Furthermore, unlike existing neural-based BP variants, we propose a novel self-supervised learning algorithm for DABP with a smoothed solution cost, which does not require expensive training labels and also avoids the common out-of-distribution issue through efficient online learning.

Original: Extensive experimentsshow that our model significantly outperforms state-of-the-art baselines.
Revised: Extensive experiments show that our model significantly outperforms state-of-the-art baselines.

Original:  Introduction
Revised:  Introduction

Original: Belief Propagation (BP) [22,31] is an important message-passing algorithm for various reasoningtasks over graphical models, e.g., computing partition function of a Markov random field [45],estimating the marginal distribution of a given set of random variables [1], and decoding LPDCcodes [27].
Revised: Belief Propagation (BP) [25, 34] is an important message-passing algorithm for various reasoning tasks over graphical models, e g., computing partition function of a Markov random field [49], estimating the marginal distribution of a given set of random variables [1], and decoding LPDC codes [30].

Original: Constraint Optimization Problems (COPs) [28,36] are a general mathematical paradigmfor modeling many real-world problems like transportation, supply chain, energy, finance andscheduling [5,36].
Revised: Constraint Optimization Problems (COPs) [31, 39] are a general mathematical paradigm for modeling many real-world problems like transportation, supply chain, energy, finance, and scheduling [6, 22, 23, 39].

Original: When solving COPs, BP, also known as Min-sum message passing [14], seeks tofind a cost-optimal solution by propagating cost information over the corresponding factor graph.
Revised: When solving COPs, BP, also known as Min-sum message passing [15], seeks to find a cost-optimal solution by propagating cost information over the corresponding factor graph.

Original: It is known that vanilla BP does not guarantee convergence on a factor graph containing loops andthus, it often explores low-quality solutions on COPs with cyclic factor graphs due to excessive loopy propagation.
Revised: It is known that vanilla BP does not guarantee convergence on a factor graph containing loops and thus, it often explores low-quality solutions on COPs with cyclic factor graphs due to excessive loopy propagation.

Original: Therefore, considerable research efforts [6,8,33,34,35,49] have been devoted to tackling the convergence issue of loopy BP.
Revised: Therefore, considerable research efforts [7, 9, 36–38, 53] have been devoted to tackling the convergence issue of loopy BP.

Original: Among them, Damped BP (DBP) 1 [8] has drawnsignificant attention recently.
Revised: Among them, Damped BP (DBP) 1 [9] has drawn significant attention recently.

Original: By mixing the new message composed in each iteration with the oldmessage composed in the previous iteration, i.e., damping, it has been shown that DBP with a suitabledamping factor will often converge and achieve state-of-the-art performance in practice.
Revised: By mixing the new message composed in each iteration with the old message composed in the previous iteration, i.e., damping, it has been shown that DBP with a suitable damping factor will often converge and achieve state-of-the-art performance in practice.

Original: In fact,damping can be considered as a degree of freedom to balance exploration and exploitation in BP [8].
Revised: In fact, damping can be considered as a degree of freedom to balance exploration and exploitation in BP [9].

Original: Due to the significant impact of damping on BP [48], a damping factor is often treated as a hyperparameter and requires laborious case-by-case tuning.
Revised: Due to the significant impact of damping on BP [52], a damping factor is often treated as a hyperparameter and requires laborious case-by-case tuning.

Original: Besides, existing works often use a homogeneousand static damping factor for all variable-nodes which limits DBP’s capability.
Revised: Besides, existing works often use a homogeneous and static damping factor for all variable-nodes which limits DBP’s capability.

Original: Moreover, DBPsimply treats each variable-node’s neighbors equally when composing a new message, which fails toexplore optimal composition strategy.
Revised: Moreover, DBP simply treats each variable-node’s neighbors equally when composing a new message, which fails to explore optimal composition strategy.

Original: On the other hand, Deep Neural Networks (DNNs) have beenapplied to boost the performance of BP [23,38,46].
Revised: On the other hand, Deep Neural Networks (DNNs) have been applied to boost the performance of BP [26, 41, 50].

Original: However, existing DNN-based BP variants oftenrequire supervised learning and expensive training labels and thus, they cannot be directly applied tosolve COPs when training labels are not available.
Revised: However, existing DNN-based BP variants often require supervised learning and expensive training labels and thus, they cannot be directly applied to solve COPs when training labels are not available.

Original: They also manipulate or simulate the BP messageswith some black-box DNN components, which destroys the semantic of a BP message being theweighted sum of cost functions’ marginalizations and thus, the variable decision-making rule of BPfor COPs is no longer applied (i.e., selecting the assignments with the minimum beliefs).
Revised: They also manipulate or simulate the BP messages with some black-box DNN components, which destroys the semantic of a BP message being the weighted sum of cost functions’ marginalizations and thus, the variable decision-making rule of BP for COPs is no longer applied (i.e., selecting the assignments with the minimum beliefs).

Original: To address the above issues, we propose the first self-supervised DNN-based BP for solving COPsby seamlessly integrating BP, Gated Recurrent Units (GRUs) [7], and Graph Attention Networks(GATs) [41] within the massage-passing framework to reason about dynamic weights and dampingfactors for composing new BP messages.
Revised: To address the above issues, we propose the first self-supervised DNN-based BP for solving COPs by seamlessly integrating BP, Gated Recurrent Units (GRUs) [8], and Graph Attention Networks (GATs) [45] within the massage-passing framework to reason about dynamic weights and damping factors for composing new BP messages.

Original: Specifically, we make the following key contributions:
Revised: Specifically, we make the following key contributions:

Original: • We extend DBP by allowing dynamic damping factors and different neighbor weights for each variable-node.
Revised: • We extend DBP by allowing dynamic damping factors and different neighbor weights for each variable-node.

Original: Consequently, we have more fine-grained control for composing newmessages to trigger effective exploration without altering the semantic of BP messages.
Revised: Consequently, we have more fine-grained control for composing new messages to trigger effective exploration without altering the semantic of BP messages.

Original: • We infer the optimal damping factors and neighbor weights for each iteration automatically by seamlessly integrating BP and DNNs.
Revised: • We infer the optimal damping factors and neighbor weights for each iteration automatically by seamlessly integrating BP and DNNs.

Original: Our model, Deep Attentive Belief Propagation(DABP), firstly embeds respectively the factor graph and BP messages with GATs and GRUs,and infers damping factors and neighbor weights through a multi-head attention [2, 40]layer; Then, BP runs with those updated factors and weights to compose and propagate newmessages, and so on.
Revised: Our model, Deep Attentive Belief Propagation (DABP) 2 , firstly embeds respectively the factor graph and BP messages with GATs and GRUs, and infers damping factors and neighbor weights through a multi-head attention [2, 43] layer; Then, BP runs with those updated factors and weights to compose and propagate new messages, and so on.

Original: Note that integrating GRUs can capture the dynamics of BP messages and avoid the gradient vanishing/exploding issue in long BP reasoning sequences.•
Revised: Note that integrating GRUs can capture the dynamics of BP messages and avoid the gradient vanishing/exploding issue in long BP reasoning sequences.

Original:  We further equip our DABP with a novel self-supervised learning loss which is a smoothed surrogate for the cost under BP decision-making rule.
Revised: • We further equip our DABP with a novel self-supervised learning loss which is a smoothed surrogate for the cost under BP decision-making rule.

Original: Therefore, unlike existing DNN-basedBP variants, we do not require expensive training labels which are often not available inpractice, and also our model can avoid out-of-distribution issue with efficient online learning.
Revised: Therefore, unlike existing DNN-based BP variants, we do not require expensive training labels which are often not available in practice, and also our model can avoid out-of-distribution issue with efficient online learning.

Original: • We conduct extensive experimental evaluations on four standard benchmarks.
Revised: • We conduct extensive experimental evaluations on four standard benchmarks.

Original: The resultsshow that our DABP achieves significantly higher convergence rate, where it successfullyconverges on average 96.25% instances given 1000 iterations, and it also outperforms thestate-of-the-art baselines by considerable margins.  
Revised: The results show that our DABP achieves significantly higher convergence rate, where it successfully converges on average 96.25% instances given 1000 iterations, and it also outperforms the state-of-the-art baselines by considerable margins.  Related Work

Revised: Although COP is NP-hard in general [39], many algorithms have been proposed to solve it in the last several decades, such as BP, local search [19], branch and bound [28], and bucket elimination [11].

Revised: Among them, Min-sum BP is an effective approximate algorithm for solving COPs and has been successfully applied to many real-world scenarios [15, 20, 29].

Revised: However, vanilla BP offers no convergence guarantee and usually returns low-quality solutions on problems with cyclic factor graphs.

Original: Backgrounds
Revised: Rogers et al. proposed to ensure convergence and have a lower bound on solution quality by relaxing the problem, i.e., removing edges to have acyclic factor graphs [36] through minimization marginalization. Further, Rollon et al. improved the bounding scheme by considering both minimization and maximization marginalization [37] and decomposing high-arity factors into unary functions [38]. On the other hand, Zivan et al. proposed to avoid loopy message propagation by strictly controlling the message-passing direction [53].

Revised: They also introduced the Value Propagation (VP) scheme to enforce exploitation.

Revised: To balance exploration and exploitation, a set of non-consecutive

Revised: VP strategies are proposed [7] as well.

Revised: Recently, Damped BP (DBP)

Revised: [9] has been proposed to enhance convergence as well as solution quality in loopy BP by mixing the new messages composed in each iteration with the old messages in previous iterations with a suitable damping factor.

Revised: However, selecting a good damping factor often requires expertise and laborious case-by-case tuning [52], and

Revised: DBP uses a static damping factor and treats each node’s neighbors equally when composing a new message, which limits its exploration.

Revised: Our DABP overcomes the aforementioned issues by learning to attend neighbors with dynamic damping factors and neighbor weights when composing new BP messages.

Revised: Obviously, DABP generalizes DBP since DBP can be considered as a static version of

Revised: DABP.

Revised: Moreover, equipped with a self-supervised learning algorithm, our DABP is able to infer the optimal damping factors and weights to enhance the performance of DBP.

Revised: On the other hand, LP-based methods solve a COP by leveraging message-passing to solve a Linear

Revised: Program (LP) relaxation of the combinatorial problem.

Revised: MPLP [17] is a simple BP variant that solves the convex-dual of the LP relaxation via block gradient descent.

Revised: Unfortunately, the global convergence is not always guaranteed since coordinate descent may get stuck in suboptimal points.

Revised: Tree-reweighted belief propagation (TRBP) [47] and Fractional Belief Propagation [48] consider respectively a linear combination of free energies defined on spanning trees of the factor graph and a fractional free energy that generalizes the well-known Bethe free energy.

Revised: Finally, NormProduct [18] provides a uniform framework that generalizes Max-product, Sum-product and their

Revised: TRBP counterpart.

Revised: Unlike these methods, our DABP directly solve the problem by learning optimal hyperparameters for DBP, and does not require any form of LP relaxation which may either induce intractable number of constraints or only offer a lower bound [27].

Revised: Recently, there has been increasing interest in applying DNNs to boost the performance of BP.

Revised: The most relevant works including: NEBP [41] learns to refine BP messages with some black-box DNN components in each iteration and is applied to solve the error correction decoding task;

Revised: In the same vein, BPNN [26] uses damping layers to modify factor-to-variable messages and is applied to estimate the partition function of Probabilistic Graphical Models (PGMs); FGNN [50] generalizes Graph

Revised: Neural Networks (GNNs) to represent Max-Product BP and is applied to find approximate Maximum

Revised: A Posteriori (MAP) assignment of a PGM.

Revised: However, all these methods require supervised learning and cannot be directly applied to solve COPs when training labels are not available; They also destroy the semantic of a BP message being the weighted sum of cost functions’ marginalizations.

Revised: Contrarily, we only learn optimal dynamic factors and neighbor weights with DNNs to generalize DBP, which preserves the semantic of the BP messages and also enables us using a self-supervised manner to train our model.

Revised: Therefore, our model does not require expensive training labels which are often not available in practice due to the heavy computation of exact solvers; and also avoids out-of-distribution issue and enjoys a nice anytime property [51] through efficient online learning.

Revised: Our method is also closely related to using DNNs to solve combinatorial problems [5, 13, 24, 32, 46].

Revised: In the context of COP solving, Neural RM-RRS [14] uses Multi-layer Perceptrons (MLPs) to parameterize high-dimensional regret tables produced by context-based regret-matching.

Revised: Similarly,

Revised: Deep Bucket Elimination (DBE) [35] uses MLPs to approximate the large bucket functions [11].

Revised: Recently, Deng et al.

Revised: [13] proposed a pretrained cost model which predicts the optimal cost of a given partially instantiated COP.

Revised: The predicted cost is then used to construct heuristics for various COP algorithms such as Large Neighborhood Search (LNS) [19] and backtracking search.

Revised: These methods either replace some heavy computation components of COP algorithms by a fast DNN approximation, or learn effective heuristics (or hyperparameters) to boost the performance of COP algorithms, and our method falls into the second category.

Revised:  Backgrounds

Original: In this section, we review the backgrounds of COPs, factor graphs, and Min-sum BP.
Revised: In this section, we review the backgrounds of COPs, factor graphs, and Min-sum BP.

Original: 2.1 Constraint Optimization Problems and Factor Graph
Revised: 3.1 Constraint Optimization Problems and Factor Graph

Original: A Constraint Optimization Problem (COP) [28] is defined by a triplet ⟨ X, D, F ⟩ , which correspondsto the set of variables, domains, and constraint functions, respectively.
Revised: A Constraint Optimization Problem (COP) [31] is defined by a triplet ⟨ X, D, F ⟩ , which corresponds to the set of variables, domains, and constraint functions, respectively.

Original: Each variable x i ∈ X isassociated with a finite domain D i ∈ D .
Revised: Each variable x i ∈ X is associated with a finite domain D i ∈ D .

Original: Each constraint function f ℓ ∈ F with scope scp ( f ℓ ) ⊆
Revised: Each constraint function f ℓ ∈ F with scope scp ( f ℓ ) ⊆

Original: Xspecifies the cost for each possible assignment of the variables in its scope.
Revised: X specifies the cost for each possible assignment of the variables in its scope.

Original: The objective is to find a[Figure] solution τ 
Revised: The objective is to find a solution τ ∗ =

Original: [Equation]
Revised: ( τ ∗ 1 , . . .

Original: = ( τ [Equation] [Equation] | 
Revised: , τ ∗| X | ) ∈

Original: [Equation] | [Equation]
Revised: Π x i ∈

Original:  D i such that the total cost is minimized:
Revised: X D i such that the total cost is minimized:

Original: [Equation]
Revised: [Equation]

Original: where τ | scp ( f ℓ ) is the projection of τ on scp ( f ℓ ) .
Revised: where τ | scp ( f ℓ ) is the projection of τ on scp ( f ℓ ) .

Original: A COP can be represented by a factor graph whichis a bipartite graph consisting of variable-nodes and function-nodes.
Revised: A COP can be represented by a factor graph which is a bipartite graph consisting of variable-nodes and function-nodes.

Original: Variable-nodes correspond tothe variables, and function-nodes correspond to the constraint functions in a COP.
Revised: Variable-nodes correspond to the variables, and function-nodes correspond to the constraint functions in a COP.

Original: An edge between avariable-node and a function-node is established if the variable belongs to the scope of the function.
Revised: An edge between a variable-node and a function-node is established if the variable belongs to the scope of the function.

Original: 2.2 Min-sum Belief Propagation
Revised: 3.2 Min-sum Belief Propagation

Original: Min-sum Belief Propagation (Min-sum BP) [14] is an important algorithm for COPs which performsmessage-passing on factor graphs.
Revised: Min-sum Belief Propagation (Min-sum BP) [15] is an important algorithm for COPs which performs message-passing on factor graphs.

Original: More specifically, the message sent from a variable-node x i to itsneighbor f ℓ in iteration t is a function µ tx i → f ℓ : D i → R computed by
Revised: More specifically, the message sent from a variable-node x i to its neighbor f ℓ in iteration t is a function µ tx i → f ℓ : D i → R computed by

Original: [Equation]
Revised: [Equation]

Original: where N i is the neighbors of x i in the factor graph, and µ t − 1 f m → x i :
Revised: where N i is the neighbors of x i in the factor graph, and µ t − 1 f m → x i :

Original: D i → R is the message sent fromf m to x i in the previous iteration.
Revised: D i → R is the message sent from f m to x i in the previous iteration.

Original: Similarly, f ℓ computes a message for its neighbor x i by
Revised: Similarly, f ℓ computes a message for its neighbor x i by

Original: [Equation]
Revised: [Equation]

Original: Finally, variable-node x i makes a decision by choosing a value with minimum belief cost:
Revised: Finally, variable-node x i makes a decision by choosing a value with minimum belief cost:

Original: [Equation]
Revised: [Equation]

Original: (4) where µ tf ℓ → x i ( τ i ) is the belief cost of assignment τ i in the message µ tf ℓ → x i .
Revised: where µ tf ℓ → x i ( τ i ) is the belief cost of assignment τ i in the message µ tf ℓ → x i .

Original: However, vanilla Min-sum BP usually suffers from non-convergence and explores low-qualitysolutions on cyclic COPs due to excessive loopy propagation.
Revised: However, vanilla Min-sum BP usually suffers from non-convergence and explores low-quality solutions on cyclic COPs due to excessive loopy propagation.

Original: Damped BP (DBP) [8] attempts toalleviate the issues by damping the messages sent from variable-nodes to function-nodes.
Revised: Damped BP (DBP) [9] attempts to alleviate the issues by damping the messages sent from variable-nodes to function-nodes.

Original: Formally,
Revised: Formally,

Original: [Equation]
Revised: [Equation]

Original: By choosing a suitable damping factor λ ∈ (0 , 1] , DBP can drastically increase the chance ofconvergence as well as the performance of vanilla Min-sum BP.
Revised: By choosing a suitable damping factor λ ∈ (0 , 1] , DBP can drastically increase the chance of convergence as well as the performance of vanilla Min-sum BP.

Original:  Deep Attentive Belief Propagation
Revised:  Deep Attentive Belief Propagation

Original: Although message damping has proved to be an effective technique to improve the performanceof BP on COPs [8], it still suffers from various issues.
Revised: Although message damping has proved to be an effective technique to improve the performance of BP on COPs [9], it still suffers from various issues.

Original: First, selecting a damping factor is largelyaccomplished by empirical tuning, which could be laborious and the number of trials is limitedby computational resources and/or runtime.
Revised: First, selecting a damping factor is largely accomplished by empirical tuning, which could be laborious and the number of trials is limited by computational resources and/or runtime.

Original: Second, using a homogeneous and static damping factor for all variable-nodes may limit DBP’s capability.
Revised: Second, using a homogeneous and static damping factor for all variable-nodes may limit DBP’s capability.

Original: Finally, DBP simply treats each variablenode’s neighbors equally when composing a new message, which fails to explore optimal messagecomposition strategy.
Revised: Finally, DBP simply treats each variablenode’s neighbors equally when composing a new message, which fails to explore optimal message composition strategy.

Original: We address the above limitations by allowing dynamic damping factors and different neighbor weightsfor each variable-node.
Revised: We address the above limitations by allowing dynamic damping factors and different neighbor weights for each variable-node.

Original: More specifically, in our framework a variable-node x i computes a messageto function-node f ℓ at iteration t by
Revised: More specifically, in our framework a variable-node x i computes a message to function-node f ℓ at iteration t by

Original: [Equation]
Revised: [Equation]

Original:  where λ ti → ℓ ∈ [0 , 1] and w tm → i ( ℓ ) ∈ [0 , 1] are learnable damping factor and neighbor weights for themessage from x i to f ℓ at iteration t , respectively.
Revised: [Figure] where λ ti → ℓ ∈ [0 , 1] and w tm → i ( ℓ ) ∈ [0 , 1] are learnable damping factor and neighbor weights for the message from x i to f ℓ at iteration t , respectively.

Original: Particularly, we require (cid:80) f m ∈N i \{ f ℓ } w tm → i ( ℓ ) = 1and use |N
Revised: Particularly, we require (cid:80) f m ∈N i \{ f ℓ } w tm → i ( ℓ ) =and use |N

Original: i | − 1 to rescale the weighted sum of the messages from neighbors.
Revised: i | − 1 to rescale the weighted sum of the messages from neighbors.

Original: Consequently, wehave more fine-grained control for composing new messages to trigger effective exploration withoutaltering the semantic of BP messages.
Revised: Consequently, we have more fine-grained control for composing new messages to trigger effective exploration without altering the semantic of BP messages.

Original: Fig.
Revised: Fig.

Original: 1 compares three different BP variants.
Revised: 1 compares three different BP variants.

Original: A key challenge of our framework is to determine the values of a large number of time-varyingdamping factors and neighbor weights (cf.
Revised: A key challenge of our framework is to determine the values of a large number of time-varying damping factors and neighbor weights (cf.

Original: Eq.
Revised: Eq.

Original: Given a factor graph with | X | variables andmaximum degree of d , running for T iterations would require to select O ( T | X | d 2 ) hyperparametersfrom the continuous range of [0 , 1] , which obviously cannot be done by the traditional trial-basedhyperparameter tuning methods (e.g., grid search, evolutionary optimization).
Revised: Given a factor graph with | X | variables and maximum degree of d , running for T iterations would require to select O ( T | X | d 2 ) hyperparameters from the continuous range of [0 , 1] , which obviously cannot be done by the traditional trial-based hyperparameter tuning methods (e.g., grid search, evolutionary optimization).

Original: Therefore, we propose to automatically infer the optimal hyperparameters for Eq.
Revised: Therefore, we propose to automatically infer the optimal hyperparameters for Eq.

Original: (6) in each iterationby seamlessly integrating BP and DNNs within the parallel message-passing framework.
Revised: (6) in each iteration by seamlessly integrating BP and DNNs within the parallel message-passing framework.

Original: Our model,
Revised: Our model,

Original: Deep Attentive Belief Propagation (DABP), directly outputs the optimal damping factors and weightsby learning to attend neighbors given the factor graph and the BP messages in each iteration:
Revised: Deep Attentive Belief Propagation (DABP), directly outputs the optimal damping factors and weights by learning to attend neighbors given the factor graph and the BP messages in each iteration:

Original: [Equation]
Revised: [Equation]

Original:  where FG is the factor graph, µ 1: t − 1 x → f and µ 1: t − 1 f → x are the BP messages from variable-nodes tofunction-nodes and from function-nodes to variable-nodes in the previous iterations, respectively.
Revised: (7) where FG is the factor graph, µ 1: t − 1 x → f and µ 1: t − 1 f → x are the BP messages from variable-nodes to function-nodes and from function-nodes to variable-nodes in the previous iterations, respectively.

Original: However, implementing such DNN-based model requires to perform inference along with BPmessage-passing iterations (cf.
Revised: However, implementing such DNN-based model requires to perform inference along with BP message-passing iterations (cf.

Original: Eq.
Revised: Eq.

Original: (7)), which could incur a severe gradient vanishing or gradientexploding problem in a long reasoning sequence.
Revised: (7)), which could incur a severe gradient vanishing or gradient exploding problem in a long reasoning sequence.

Original: Moreover, obtaining optimal training labels can beextremely expensive for COPs due to the heavy computation of exact solvers, making it impracticableto perform supervised model training on large instances.
Revised: Moreover, obtaining optimal training labels can be extremely expensive for COPs due to the heavy computation of exact solvers, making it impracticable to perform supervised model training on large instances.

Original: In Sect.
Revised: In Sect.

Original: 3.1, we address the first problem byintroducing GRUs as a part of our encoder; while we design a novel self-supervised loss function andan efficient online learning framework in Sect.
Revised: 4.1, we address the first problem by introducing GRUs as a part of our encoder; while we design a novel self-supervised loss function and an efficient online learning framework in Sect.

Original: 3.2 to address the second issue.
Revised: 4.2 to address the second issue.

Original: 3.1 Model Architecture
Revised: 4.1 Model Architecture

Original: Fig.
Revised: Fig.

Original: 2 gives the overall architecture of our DABP.
Revised: 2 gives the overall architecture of our DABP.

Original: It consists of an encoder to embed the factor graphand the BP messages, and an attention module to infer the dynamic optimal hyperparameters.
Revised: It consists of an encoder to embed the factor graph and the BP messages, and an attention module to infer the dynamic optimal hyperparameters.

Original: Encoder.
Revised: Encoder.

Original: The purpose of our encoder is to embed the factor graph given a sequence of BP messages (cf.
Revised: The purpose of our encoder is to embed the factor graph given a sequence of BP messages (cf.

Original: Fig.
Revised: Fig.

Original: 2(a-d)).
Revised: 2(a-d)).

Original: Therefore, to capture the BP message dynamics and avoid gradient vanishing/exploding issue, we first use two GRUs to embed the BP messages from variable-nodesto function-nodes and the ones from function-nodes to variable-nodes into q -dimensional vectors,respectively (cf. Fig. 2(b)):
Revised: Therefore, to capture the BP message dynamics and avoid gradient vanishing/exploding issue, we first use two GRUs to embed the BP messages from variable-nodes to function-nodes and the ones from function-nodes to variable-nodes into q -dimensional vectors, respectively (cf. Fig. 2(b)):

Original: [Equation]
Revised: [Equation]

Original: where h tx → f , h tf → x ∈ R r × q are the message hiddens for iteration t and r is the number of edges inthe factor graph.
Revised: where h tx → f , h tf → x ∈ R r × q are the message hiddens for iteration t and r is the number of edges in the factor graph.

Original: To consider both the topology of a factor graph and the message dynamics, we insert a set of messagenodes that carry the message hiddens (i.e., the brown and green dots in Fig. 2(c)) and make the graph directed to reflect the message-passing directions.
Revised: To consider both the topology of a factor graph and the message dynamics, we insert a set of message nodes that carry the message hiddens (i.e., the brown and green dots in Fig. 2(c)) and make the graph directed to reflect the message-passing directions.

Original: Then the augmented factor graph is embeddedthrough G layers of GAT (cf.
Revised: Then the augmented factor graph is embedded through G layers of GAT (cf.

Original: Fig. 2(d)).
Revised: Fig. 2(d)).

Original: Formally, in the g ∈ { 1 , . . .
Revised: Formally, in the g ∈ { 1 , . . .

Original: , G } -th layer GAT ψ g , wecompute the embedding e t, ( g ) i for node i according to
Revised: , G } -th layer GAT ψ g , we compute the embedding e t, ( g ) i for node i according to

Original: [Equation]
Revised: [Equation]

Original: where W ( g ) ∈ ψ g is a learnable matrix, s ( g ) ij = a ( g ) ( W ( g ) e t, ( g − 1)
Revised: where W ( g ) ∈ ψ g is a learnable matrix, s ( g ) ij = a ( g ) ( W ( g ) e t, ( g − 1)

Original: i , W ( g )
Revised: i , W ( g )

Original: [Equation]
Revised: [Equation]

Original: ( g − 1) j ) is the attentionscore between nodes i and j , and a ( g ) is a single-layer feed-forward neural network.
Revised: g − 1) j ) is the attention score between nodes i and j , and a ( g ) is a single-layer feed-forward neural network.

Original: Attention Module.
Revised: Attention Module.

Original: Given the embedding e t, ( G ) ℓ for each f ℓ ∈ F , we update the damping factorsand neighbor weights by using a multi-head attention (MHA) layer [40] (cf. Fig. 2(e)), where queriesand keys are the embeddings of the target and corresponding neighboring function-nodes, respectively.
Revised: Given the embedding e t, ( G ) ℓ for each f ℓ ∈ F , we update the damping factors and neighbor weights by using a multi-head attention (MHA) layer [43] (cf. Fig. 2(e)), where queries and keys are the embeddings of the target and corresponding neighboring function-nodes, respectively.

Original: Specifically, for each variable-node x i and a target function-node f ℓ ∈ N i , we first compute anattention score for each neighboring function-node f m ∈ N i in k ∈ { 1 , . . .
Revised: Specifically, for each variable-node x i and a target function-node f ℓ ∈ N i , we first compute an attention score for each neighboring function-node f m ∈ N i in k ∈ { 1 , . . .

Original: , K } -th
Revised: , K } -th

Original: head Att ζ k by:
Revised: head Att ζ k by:

Original: [Equation]
Revised: [Equation]

Original: where σ is the Sigmoid function, || is the concatenation operation and W ( k ) 1 , W ( k ) 2 ,
Revised: where σ is the Sigmoid function, || is the concatenation operation and W ( k ) 1 , W ( k ) 2 ,

Original: W ( k )∈ ζ kare learnable matrices, respectively.
Revised: W ( k )∈ ζ k are learnable matrices, respectively.

Original: Then the attention scores are normalized to compute neighborweights respect to target function-node f ℓ :
Revised: Then the attention scores are normalized to compute neighbor weights respect to target function-node f ℓ :

Original: [Equation]
Revised: [Equation]

Original: Similarly, the damping factor is computed by normalizing the attention score of f ℓ w.r.t.
Revised: Similarly, the damping factor is computed by normalizing the attention score of f ℓ w.r.t.

Original: the meanattention score of the remaining neighboring function-nodes:
Revised: the mean attention score of the remaining neighboring function-nodes:

Original: [Equation]
Revised: [Equation]

Revised: Finally, both the neighbor weights and damping factors are normalized across different heads, i.e.,

Original: [Equation]
Revised: [Equation]

Revised: 13) and are plugged into Eq.(6) to compute new BP messages for iteration t (cf.

Revised: Fig. 2(f)).

Original: Input
Revised: Input: A

Original: [Table]
Revised: [Table]

Revised: D

Original: [Table]
Revised: [Table]

Revised: ⟩ , the

Original: [Table]
Revised: [Table]

Revised: R , the

Original: [Table]
Revised: [Table]

Revised: limit

Original: [Table]
Revised: [Table]

Revised: max , the

Original: [Table]
Revised: [Table]

Revised: interval

Original: [Table] 
Revised: [Table] [Table] ∈ { 1 , . . . , [Table]

Original: [Table]
Revised: [Table]

Revised: of P

Original:  do 
Revised: [Table] [Table] [Table] do 3:

Original: [Table] [Table]
Revised: [Table] [Table]

Revised: do

Original: [Table] [Table]
Revised: [Table] [Table]

Original: 6: compute
Revised: 6: compute

Original: [Table]
Revised: [Table]

Original: [Table] 
Revised: [Table] [Table] [Table] [Table]

Original: [Table]
Revised: [Table]

Original: 7: compute 
Revised: 7: compute µ

Revised: [Table]

Original: 8: compute
Revised: i [Table] to [Table]

Original: T
Revised: [Table] [Table] [Table] i 8: compute solution τ

Original: ← select return
Revised: [Table] = ⟨ [Table] [Table]

Original: Finally, both the neighbor weights and damping factors are normalized across different heads, i.e.,
Revised: . , τ [Table] | X | ⟩ according to Eq. (4) 9: if cost( τ ∗ ) > cost( τ t ) then τ ∗ ← τ t 10: if t %

Original: [Equation]
Revised: [Table]

Revised: = 0 then 11:

Revised: T ∗ ← select the best T

Original: [Equation]
Revised: [Table]

Original: and are plugged into Eq.(6) to compute new BP messages for iteration t (cf.
Revised: iterations according to cost( [Table] t ′ ), t − T upd < t ′ ≤ t 12: compute L

Original: Fig. 2(f)).
Revised: [Table] θ ) according to Eq. [Table] 16), θ ← ADAM( θ, ∇L ( θ )) 13: if BP messages converge then break return τ ∗

Original: 3.2 A Novel Self-supervised Learning Algorithm for Solving COPs
Revised: 4.2 A Novel Self-supervised Learning Algorithm for Solving COPs

Original: Recall that our objective is to find a cost-optimal solution (cf.
Revised: Recall that our objective is to find a cost-optimal solution (cf.

Original: Eq.
Revised: Eq.

Original: (1)), a natural choice of the lossfunction would be the cost of the solution induced by BP messages in each iteration.
Revised: (1)), a natural choice of the loss function would be the cost of the solution induced by BP messages in each iteration.

Original: Unfortunately,such loss function is not differentiable since variables are greedily assigned via argmin (cf.
Revised: Unfortunately, such loss function is not differentiable since variables are greedily assigned via argmin (cf.

Original: Eq.
Revised: Eq.

Original: Instead, we propose to use a smoothed cost as the surrogate objective.
Revised: Instead, we propose to use a smoothed cost as the surrogate objective.

Original: Formally, for each iteration t ,we consider the following self-supervised objective:
Revised: Formally, for each iteration t , we consider the following self-supervised objective:

Original: [Equation]
Revised: [Equation]

Original: where p ti ( τ i ) is the probability of x i
Revised: where p ti ( τ i ) is the probability of x i

Original: =
Revised: =

Original: τ i under the current belief, i.e.,
Revised: τ i under the current belief, i.e.,

Original: [Equation]
Revised: [Equation]

Original: Intuitively, an assignment τ i is associated with a high probability if it has a low belief cost b ti ( τ i ) ,which simulates the behavior of argmin in Eq.
Revised: Intuitively, an assignment τ i is associated with a high probability if it has a low belief cost b ti ( τ i ) , which simulates the behavior of argmin in Eq.

Original: (4) and is in alignment with the objective in Eq.
Revised: (4) and is in alignment with the objective in Eq.

Original: We now theoretically show the error bound of the smoothed cost.
Revised: We now theoretically show the error bound of the smoothed cost.

Original: Proof is given in Appendix B.
Revised: Proof is given in Appendix A.

Original: Theorem 1.
Revised: Theorem 1.

Original: Let 
Revised: Let ∆

Original: [Equation]
Revised: [Equation]

Original: ( τ i 1 , . . .
Revised: ⟩ f [Equation] τ [Equation]

Original: , τ i n ) be the maximum difference between cost values of each constraint function f ℓ and τ t = ⟨ τ t 1 , . ..
Revised: , τ [Equation] n ) be the maximum difference between cost values of each constraint function f ℓ and τ t = ⟨ τ t 1 , . .

Original: , τ t | X | ⟩ be the assignment induced by Eq.
Revised: , τ t | X | ⟩ be the assignment induced by Eq.

Original: We have
Revised: We have

Original: [Equation]
Revised: [Equation]

Original: Given the smoothed objective for each iteration, we define the following loss function:
Revised: Given the smoothed objective for each iteration, we define the following loss function:

Original: [Equation]
Revised: [Equation]

Original: where θ = { ϕ 1 , ϕ 2 , [ ψ 1 , . .
Revised: where θ = { ϕ 1 , ϕ 2 , [ ψ 1 , . .

Original: . , ψ G ] , [ ζ 1 , . .
Revised: . , ψ G ] , [ ζ 1 , . .

Original: . , ζ K ] } is the model parameters and T ∗ is a selected subsetof iterations used for optimizing, respectively.
Revised: . , ζ K ] } is the model parameters and T ∗ is a selected subset of iterations used for optimizing, respectively.

Original: Particularly, we rank each iteration t according tothe quality of solution τ t and select the best T eff iterations as effective iterations T ∗ .
Revised: Particularly, we rank each iteration t according to the quality of solution τ t and select the best T eff iterations as effective iterations T ∗ .

Original: This way, weencourage exploration by considering only good-enough solutions.
Revised: This way, we encourage exploration by considering only good-enough solutions.

Original: Since our model is self-supervised by the smoothed cost, there is no need for costly label generationfor each instance and thus, DABP can be directly applied to solve COPs via online learning withoutany pre-training procedure.
Revised: Since our model is self-supervised by the smoothed cost, there is no need for costly label generation for each instance and thus, DABP can be directly applied to solve COPs via online learning without any pre-training procedure.

Original: That is, from an initial DABP model M θ , we continuously improve itby training on the instance multiple rounds (i.e., restart ) on the COP to be solved and return thebest solution as the result.
Revised: That is, from an initial DABP model M θ , we continuously improve it by training on the instance multiple rounds (i.e., restart ) on the COP to be solved and return the best solution as the result.

Original: Therefore, our DABP avoids the out-of-distribution issue and has a niceanytime property [47].
Revised: Therefore, our DABP avoids the out-of-distribution issue and has a nice anytime property [51].

Original: The procedure is detailed in Alg. 1.
Revised: The procedure is detailed in Alg. 1.

Original: Specifically, each round of restart begins with resetting BP messages to zero vectors (line 3), followedby a sequence of message-passing iterations (line 4-13).
Revised: Specifically, each round of restart begins with resetting BP messages to zero vectors (line 3), followed by a sequence of message-passing iterations (line 4-13).

Original: In each iteration, we query our DABP for thedamping factors and neighbor weights (line 5), perform BP message passing according to the updatedhyperparameters (line 6-7), and finally update the current best solution (line 8-9).
Revised: In each iteration, we query our DABP for the damping factors and neighbor weights (line 5), perform BP message passing according to the updated hyperparameters (line 6-7), and finally update the current best solution (line 8-9).

Original: Particularly, weperform model update every T upd iterations (line 10-12) and thus, we further alleviate the gradientvanishing/exploding issue by restricting the maximum length of reasoning sequence to T upd .
Revised: Particularly, we perform model update every T upd iterations (line 10-12) and thus, we further alleviate the gradient vanishing/exploding issue by restricting the maximum length of reasoning sequence to T upd .

Original: Lastly,we early stop each round whenever BP messages converge (line 13) and return the best solution.
Revised: Lastly, we early stop each round whenever BP messages converge (line 13) and return the best solution.

Original:  Empirical Evaluations
Revised:  Empirical Evaluations

Original: In this section, we perform extensive empirical studies.
Revised: In this section, we perform extensive empirical studies.

Original: We begin with introducing the details ofexperiments and implementation.
Revised: We begin with introducing the details of experiments and implementation.

Original: Then we analyze the impact of the number of selected effectiveiterations in Alg. 1.
Revised: Then we analyze the impact of the number of selected effective iterations in Alg. 1.

Original: Finally, we show the great superiority of our DABP over the state-of-the-arts.
Revised: Finally, we show the great superiority of our DABP over the state-of-the-arts.

Original: Benchmarks & Baselines.
Revised: Benchmarks & Baselines.

Original: We consider four types of standard benchmarks in our experiments, i.e.,random COPs, scale-free networks, small-world networks, and Weighted Graph Coloring Problems(WGCPs).
Revised: We consider four types of standard benchmarks in our experiments, i.e., random COPs, scale-free networks, small-world networks, and Weighted Graph Coloring Problems (WGCPs).

Original: For random COPs and WGCPs, constraints are randomly established according to graphdensity p 1 ∈ (0 , 1] .
Revised: For random COPs and WGCPs, constraints are randomly established according to graph density p 1 ∈ (0 , 1] .

Original: For scale-free networks, we use the BA model [3] with parameters m 0 , m 1 ∈ Z +to generate constraints.
Revised: For scale-free networks, we use the BA model [4] with parameters m 0 , m 1 ∈ Z + to generate constraints.

Original: Finally, we generate constraints for small-world networks by using NewmanWatts-Strogatz model [30] with parameters k ∈ Z
Revised: Finally, we generate constraints for small-world networks by using NewmanWatts-Strogatz model [33] with parameters k ∈ Z

Original: + , p ∈ [0 , 1] .
Revised: + , p ∈ [0 , 1] .

Original: For baselines, we compare our DABP with the following state-of-the-art COP solvers: (1) DBPwith a damping factor of 0.9 and its splitting constraint factor graph version (DBP-SCFG) with asplitting ratio of 0.95 [8]; (2) GAT-PCM-LNS with a destroy probability of 0.2 [12]; (3) Mini-bucket
Revised: For baselines, we compare our DABP with the following state-of-the-art COP solvers: (1) DBP with a damping factor of 0.9 and its splitting constraint factor graph version (DBP-SCFG) with a splitting ratio of 0.95 [9]; (2) GAT-PCM-LNS with a destroy probability of 0.2 [13]; (3) Mini-bucket

Original: Elimination (MBE) with an i -bound of 9 [11], and (4) Toulbar2 with timeout of 1200s [9].
Revised: Elimination (MBE) with an i -bound of 9 [12], and (4) Toulbar2 with timeout of 1200s [10].

Original: All experiments are conducted on an Intel i9-9820X workstation with GeForce RTX 3090 GPUs and384GB memory.
Revised: All experiments are conducted on an Intel i9-9820X workstation with GeForce RTX 3090 GPUs and 384GB memory.

Original: We report the best solution cost for each run, and for each experiment we averagethe results over 100 random problem instances .
Revised: We report the best solution cost for each run, and for each experiment we average the results over 100 random problem instances .

Original: Due to the space constraint, we defer the details ofbenchmarks and baselines to Appendix C.1 and C.2, respectively.
Revised: Due to the space constraint, we defer the details of benchmarks and baselines to Appendix B.1 and B.2, respectively.

Original: Implementation.
Revised: Implementation.

Original: Our DABP consists of two GRUs which embeds BP messages into 8-dimensionalhidden vectors, followed by G = 4 layers of GAT, each of them has 8 output channels and 4 attentionheads.
Revised: Our DABP consists of two GRUs which embeds BP messages into 8-dimensional hidden vectors, followed by G = 4 layers of GAT, each of them has 8 output channels and 4 attentionheads.

Original: We then infer the optimal damping factors and neighbor weights by using a multi-head attentionlayer with K = 4 attention-heads.
Revised: We then infer the optimal damping factors and neighbor weights by using a multi-head attention layer with K = 4 attention-heads.

Original: Finally, we also adopt the SCFG scheme with the splitting ratio of0.95 [8].
Revised: Finally, we also adopt the SCFG scheme with the splitting ratio of 0.95 [9].

Original: Our model was implemented with the PyTorch Geometric framework [15] and the modelwas trained with the Adam optimizer [20] using a learning rate of 10 − 4 and a weight decay ratioof 5 × 10 − 5 .
Revised: Our model was implemented with the PyTorch Geometric framework [16] and the model was trained with the Adam optimizer [21] using a learning rate of 10 − 4 and a weight decay ratio of 5 × 10 − 5 .

Original: For each instance, we perform R = 20 restarts with iteration limit T max = 1000 andupdate the model every T upd = 20 iterations.
Revised: For each instance, we perform R = 20 restarts with iteration limit T max = 1000 and update the model every T upd = 20 iterations.

Original: Performance Comparison.
Revised: Performance Comparison.

Original: Table 1 compares the performance of different methods on the fourstandard benchmarks.
Revised: Table 1 compares the performance of different methods on the four standard benchmarks.

Original: We observe that, although given a relatively high timeout (i.e., 20 minutes),
Revised: We observe that, although given a relatively high timeout (i.e., 20 minutes),

Original: Toulbar2 still performs poorly on the most test cases.
Revised: Toulbar2 still performs poorly on the most test cases.

Original: This is not surprising because it systematicallyexplores the whole solution space, which is often infeasible for large problem instances.
Revised: This is not surprising because it systematically explores the whole solution space, which is often infeasible for large problem instances.

Original: Also, it[Table] highlights the extreme difficulty of obtaining optimal labels with an exact solver for the existing DNNbased BP variants.
Revised: Also, it highlights the extreme difficulty of obtaining optimal labels with an exact solver for the existing DNNbased BP variants.

Original: MBE, on the other hand, performs memory-bounded inference and thus runs muchfaster than Toulbar.
Revised: MBE, on the other hand, performs memory-bounded inference and thus runs much faster than Toulbar.

Original: However, MBE fails to find good solutions and is strictly dominated by the otheralgorithms.
Revised: However, MBE fails to find good solutions and is strictly dominated by the other algorithms.

Original: GAT-PCM-LNS performs iterative large neighborhood search with a machine-learnedrepair heuristic and often outperforms DBP.
Revised: GAT-PCM-LNS performs iterative large neighborhood search with a machine-learned repair heuristic and often outperforms DBP.

Original: However, GAT-PCM-LNS requires significant longerruntime than DBP since it needs to perform multiple times of model inference in each iteration tore-assign the destroyed variables.
Revised: However, GAT-PCM-LNS requires significant longer runtime than DBP since it needs to perform multiple times of model inference in each iteration to re-assign the destroyed variables.

Original: With a small modification in a factor graph, DBP-SCFG drasticallyimproves the performance of DBP but it is computationally heavier.
Revised: With a small modification in a factor graph, DBP-SCFG drastically improves the performance of DBP but it is computationally heavier.

Original: That is because the number offunction-nodes in DBP-SCFG is doubled due to constraint function splitting. 
Revised: That is because the number of function-nodes in DBP-SCFG is doubled due to constraint function splitting. [Table]

Original: Our DABP exhibits great superiority in various benchmarks.
Revised: Our DABP exhibits great superiority in various benchmarks.

Original: Specifically, given 5 times of restart,
Revised: Specifically, given 5 times of restart,

Original: DABP substantially outperforms DBP-SCFG, which is currently the strongest approximate solver for
Revised: DABP substantially outperforms DBP-SCFG, which is currently the strongest approximate solver for

Original: COPs, on all test cases and the gap is widened with the increasing R .
Revised: COPs, on all test cases and the gap is widened with the increasing R .

Original: This demonstrates the meritsof our learned dynamic damping factors and neighbor weights over the static and homogeneouscounterpart.
Revised: This demonstrates the merits of our learned dynamic damping factors and neighbor weights over the static and homogeneous counterpart.

Original: Importantly, although our DABP requires to perform online learning when solveeach instance, our DABP’s runtime results are still comparable to DBP-SCFG and also scales upwell to large problem instances, thanks to our seamlessly integration of BP and DNNs within themessage-passing framework which enables efficient parallel computation on GPUs.
Revised: Importantly, although our DABP requires to perform online learning when solve each instance, our DABP’s runtime results are still comparable to DBP-SCFG and also scales up well to large problem instances, thanks to our seamlessly integration of BP and DNNs within the message-passing framework which enables efficient parallel computation on GPUs.

Original: In fact, whenapplied to scale-free networks, DABP ( R = 5 ) requires less runtime for all configurations, and hasa much lower growing rate ( ∼ 23.81%) than DBP-SCFG ( ∼ 37.37%).
Revised: In fact, when applied to scale-free networks, DABP ( R = 5 ) requires less runtime for all configurations, and has a much lower growing rate ( ∼ 23.81%) than DBP-SCFG ( ∼ 37.37%).

Original: Besides, equipped with the[Figure] [Figure] self-supervised loss function for minimizing the smoothed cost, our DABP is able to infer the optimalhyperparameters that foster fast convergence, which also improves our model’s efficiency.
Revised: Besides, equipped with the self-supervised loss function for minimizing the smoothed cost, our DABP is able to infer the optimal hyperparameters that foster fast convergence, which also improves our model’s efficiency.

Original: Further Performance Analysis.
Revised: Further Performance Analysis.

Original: We further compare the solution quality of different methodsin each iteration and analyze the convergence rate of BP variants on the problem instances with| X | = 80 2 in Fig.
Revised: We further compare the solution quality of different methods in each iteration and analyze the convergence rate of BP variants on the problem instances with | X | = 80 3 in Fig.

Original: 3 and Fig. 4, respectively.
Revised: 3 and Fig. 4, respectively.

Original: We omit the cases of DABP with R = 10 and R = 20in Fig.
Revised: We omit the cases of DABP with R = 10 and R =in Fig.

Original: 4 since they are similar to the one of DABP ( R = 5 ).
Revised: 4 since they are similar to the one of DABP ( R = 5 ).

Original: It can be seen that DBP improvesslowly and fails to find good solutions within 1000 iterations, especially on WGCPs.
Revised: It can be seen that DBP improves slowly and fails to find good solutions within 1000 iterations, especially on WGCPs.

Original: DBP-SCFGsubstantially improves the convergence as well as solution quality of DBP by introducing anotherdegree of freedom through asymmetric function splitting [8].
Revised: DBP-SCFG [Figure] [Figure] substantially improves the convergence as well as solution quality of DBP by introducing another degree of freedom through asymmetric function splitting [9].

Original: On the other hand, our DABP allowsmore flexibility in composing BP messages by reasoning optimal dynamic hyperparameters throughseamlessly integrating BP and DNNs, and it also significantly outperforms and converges much fasterthan both DBP and DBP-SCFG.
Revised: On the other hand, our DABP allows more flexibility in composing BP messages by reasoning optimal dynamic hyperparameters through seamlessly integrating BP and DNNs [Figure] and it also significantly outperforms and converges much faster than both DBP and DBP-SCFG.

Original:  Conclusion
Revised:  Conclusion

Original: In this paper, we propose DABP, the first self-supervised DNN-based BP for solving COPs.
Revised: In this paper, we propose DABP, the first self-supervised DNN-based BP for solving COPs.

Original: Byallowing dynamic damping factors and different neighbor weights for each variable-node, our DABPstrictly generalizes the state-of-the-art DBP and has more fine-grained control for composing newmessages to trigger effective exploration without altering the semantic of BP messages.
Revised: By allowing dynamic damping factors and different neighbor weights for each variable-node, our DABP strictly generalizes the state-of-the-art DBP and has more fine-grained control for composing new messages to trigger effective exploration without altering the semantic of BP messages.

Original: Moreover, byseamlessly integrating BP, GRUs and GATs within the massage-passing framework, DABP is ableto infer the optimal hyperparameters automatically according to the BP message dynamics.
Revised: Moreover, by seamlessly integrating BP, GRUs and GATs within the massage-passing framework, DABP is able to infer the optimal hyperparameters automatically according to the BP message dynamics.

Original: Finally,equipped with a novel self-supervised loss function, our DABP does not require expensive traininglabels and can avoid out-of-distribution issue with efficient online learning.
Revised: Finally, equipped with a novel self-supervised loss function, our DABP does not require expensive training labels and can avoid out-of-distribution issue with efficient online learning.

Original: Extensive experimentsconfirm the great superiority of our DABP over the state-of-the-art baselines.
Revised: Extensive experiments confirm the great superiority of our DABP over the state-of-the-art baselines.

Original: Since it relies smoothed costs as the self-supervised loss function, our DABP is dedicated to solve
Revised: Since it relies smoothed costs as the self-supervised loss function, our DABP is dedicated to solve

Original: COPs and is not trivial to be adapted for other scenarios.
Revised: COPs and is not trivial to be adapted for other scenarios.

Original: Therefore, in future we will explore moretraining paradigms to extend our model to solve other important reasoning tasks over graphical models,e.g., computing partition function [45], and finding constrained most probable explanation [37].
Revised: Therefore, in future we will explore more training paradigms to extend our model to solve other important reasoning tasks over graphical models, e.g., computing partition function [49], and finding constrained most probable explanation [40].

Original: Checklist
Revised: It is also interesting to further boost the performance of our model by incorporating popular deep learning techniques such as contrastive learning [3] and transformer [44]. Acknowledgement This research is supported by the National Research Foundation, Singapore under its Industry Alignment Fund – Pre-positioning (IAF-PP) Funding Initiative.

Original: For all authors...
Revised: Any opinions, findings and conclusions or recommendations expressed in this material are those of the author(s) and do not reflect the views of National Research Foundation, Singapore. We sincerely thank Professor Rina Dechter at University of California, Irvine for her helpful discussions and suggestions. Checklist

Original:  (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?
Revised: For all authors... (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s contributions and scope?

Original: [Yes] See Sect.
Revised: [Yes] See Sect.

Original: 3 and Sect.
Revised: 4 and Sect.

Original: (b) Did you describe the limitations of your work?
Revised: (b) Did you describe the limitations of your work?

Original: [Yes] We have described our limitationin Sect.
Revised: [Yes] We have described our limitation in Sect.

Original: 5.(c) Did you discuss any potential negative societal impacts of your work?
Revised: (c) Did you discuss any potential negative societal impacts of your work?

Original: [N/A]
Revised: [N/A]

Original: Our work is theoretical and we do not see any potential negative societal impacts.
Revised: Our work is theoretical and we do not see any potential negative societal impacts.

Original: (d) Have you read the ethics review guidelines and ensured that your paper conforms to them?
Revised: (d) Have you read the ethics review guidelines and ensured that your paper conforms to them?

Original: [Yes] 
Revised: [Yes] 2.

Original: If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?
Revised: If you are including theoretical results... (a) Did you state the full set of assumptions of all theoretical results?

Original: [N/A](b)
Revised: [Yes] See Theoremin page 7.

Original:  Did you include complete proofs of all theoretical results?
Revised: (b) Did you include complete proofs of all theoretical results?

Original: [N/A]
Revised: [Yes] See Appendix A . 3.

Original: If you ran experiments...
Revised: If you ran experiments...

Original: (a) Did you include the code, data, and instructions needed to reproduce the main ex- perimental results (either in the supplemental material or as a URL)?
Revised: (a) Did you include the code, data, and instructions needed to reproduce the main experimental results (either in the supplemental material or as a URL)?

Original: [Yes] See the supplemental material.
Revised: [Yes] See the Github URL in page 2.

Original: (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?
Revised: (b) Did you specify all the training details (e.g., data splits, hyperparameters, how they were chosen)?

Original: [Yes] See the Implementation paragraph in page 7.
Revised: [Yes] See the Implementation paragraph in page 8.

Original: (c) Did you report error bars (e.g., with respect to the random seed after running experi- ments multiple times)?
Revised: (c) Did you report error bars (e.g., with respect to the random seed after running experiments multiple times)?

Original: [Yes] We display the box-plot or the 95% confidence intervals when presenting cost performance.
Revised: [Yes] We display the box-plot or the 95% confidence intervals when presenting cost performance.

Original: (d) Did you include the total amount of compute and the type of resources used (e g., typeof GPUs, internal cluster, or cloud provider)?
Revised: (d) Did you include the total amount of compute and the type of resources used (e.g., type of GPUs, internal cluster, or cloud provider)?

Original: [Yes] See the Benchmarks & Baselines paragraph in page 7 and Table 1.
Revised: [Yes] See the Benchmarks & Baselines paragraph.

Original: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?
Revised: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets... (a) If your work uses existing assets, did you cite the creators?

Original: [N/A] (b) Did you mention the license of the assets?
Revised: [N/A] (b) Did you mention the license of the assets?

Original: [N/A]  Did you include any  either in the supplemental material or as a 
Revised: [N/A] (c) Did you include any new assets either in the supplemental material or as a URL?

Original: [Figure] discuss how
Revised: [N/A] (d) Did you discuss whether

Original:  obtained from people whose  you’re [Figure] using
Revised: and how consent was obtained from people whose data you’re using/curating?

Original: curating

Original: [Figure]

Original:  discuss whether the data you  contains personally identifiable[Figure] information or offensive content?
Revised: [N/A] (e) Did you discuss whether the data you are using/curating contains personally identifiable information or offensive content?

Original: [N [Figure]
Revised: [N/A] 5.

Original:  conducted research subjects [Figure] text 
Revised: If you used crowdsourcing or conducted research with human subjects... (a) Did you include the full text of instructions given to participants and screenshots, if applicable?

Original: [Figure] participant  Institutional [Figure]
Revised: [N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?

Original: applicable

Original: [N

Original: [Figure]

Original: the

Original:  hourly wage paid to participants and the amountspent on participant compensation [N [Figure]
Revised: [N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation?

Original: A Related Work

Original: Although COP is NP-hard in general [36], many algorithms have been proposed to solve it in thelast several decades, such as BP, local search [18], branch and bound [25], and bucket elimination[10].

Original: Among them, Min-sum BP is an effective approximate algorithm for solving COPs andhas been successfully applied to many real-world scenarios [14, 19, 26].

Original: However, vanilla BPoffers no convergence guarantee and usually returns low-quality solutions on problems with cyclicfactor graphs.

Original: Rogers et al.

Original: proposed to ensure convergence and have a lower bound on solutionquality by relaxing the problem, i.e., removing edges to have acyclic factor graphs [33] throughminimization marginalization.

Original: Further, Rollon et al. improved the bounding scheme by consideringboth minimization and maximization marginalization [34] and decomposing high-arity factors intounary functions [35].

Original: On the other hand, Zivan et al. proposed to avoid loopy message propagation bystrictly controlling the message-passing direction [49].

Original: They also introduced the Value Propagation(VP) scheme to enforce exploitation.

Original: To balance exploration and exploitation, a set of non-consecutive

Original: VP strategies are proposed [6] as well.

Original: Recently, Damped BP (DBP)

Original: [8] has been proposed to enhanceconvergence as well as solution quality in loopy BP by mixing the new messages composed in eachiteration with the old messages in previous iterations with a suitable damping factor.

Original: However,selecting a good damping factor often requires expertise and laborious case-by-case tuning [48], and

Original: DBP uses a static damping factor and treats each node’s neighbors equally when composing a newmessage, which limits its exploration.

Original: Our DABP overcomes the aforementioned issues by learningto attend neighbors with dynamic damping factors and neighbor weights when composing new BPmessages.

Original: Obviously, DABP generalizes DBP since DBP can be considered as a static version of

Original: DABP.

Original: Moreover, equipped with a self-supervised learning algorithm, our DABP is able to infer theoptimal damping factors and weights to enhance the performance of DBP.

Original: On the other hand, LP-based methods solve a COP by leveraging message-passing to solve a Linear

Original: Program (LP) relaxation of the combinatorial problem. MPLP [16] is a simple BP variant thatsolves the convex-dual of the LP relaxation via block gradient descent. Unfortunately, the globalconvergence is not always guaranteed since coordinate descent may get stuck in suboptimal points. Tree-reweighted belief propagation (TRBP)
Revised: [N/A]

Original: [43] and Fractional Belief Propagation [44] considerrespectively a linear combination of free energies defined on spanning trees of the factor graphand a fractional free energy that generalizes the well-known Bethe free energy.

Original: Finally, NormProduct [17] provides a uniform framework that generalizes Max-product, Sum-product and their

Original: TRBP counterpart.

Original: Unlike these methods, our DABP directly solve the problem by learning optimalhyperparameters for DBP, and does not require any form of LP relaxation which may either induceintractable number of constraints or only offer a lower bound [24].

Original: Recently, there has been increasing interest in applying DNNs to boost the performance of BP.

Original: The most relevant works including: NEBP [38] learns to refine BP messages with some black-box

Original: DNN components in each iteration and is applied to solve the error correction decoding task; In thesame vein, BPNN [23] uses damping layers to modify factor-to-variable messages and is applied toestimate the partition function of probabilistic graphical models (PGMs); FGNN [46] generalizes

Original: Graph Neural Networks (GNNs) to represent Max-Product BP and is applied to find approximatemaximum a posteriori (MAP) assignment of a PGM.

Original: However, all these methods require supervisedlearning and cannot be directly applied to solve COPs when training labels are not available; Theyalso destroy the semantic of a BP message being the weighted sum of cost functions’ marginalizations.

Original: Contrarily, we only learn optimal dynamic factors and neighbor weights with DNNs to generalize

Original: DBP, which preserves the semantic of the BP messages and also enables us using a self-supervisedmanner to train our model.

Original: Therefore, our model does not require expensive training labels whichare often not available in practice due to the heavy computation of exact solvers; and also avoidsout-of-distribution issue and enjoys a nice anytime property [47] through efficient online learning.

Original: Our method is also closely related to using DNNs to solve combinatorial problems [4,12,21,29,42].

Original: In the context of COP solving, Neural RM-RRS [13] uses Multi-layer Perceptrons (MLPs) toparameterize high-dimensional regret tables produced by context-based regret-matching.

Original: Similarly,

Original: Deep Bucket Elimination (DBE) [32] uses MLPs to approximate the large bucket functions [10].

Original: Recently, Deng et al.

Original: [12] proposed a pretrained cost model which predicts the optimal cost of a givenpartially instantiated COP.

Original: The predicted cost is then used to construct heuristics for various COPalgorithms such as Large Neighborhood Search (LNS) [18] and backtracking search.

Original: These methodseither replace some heavy computation components of COP algorithms by a fast DNN approximation,or learn effective heuristics (or hyperparameters) to boost the performance of COP algorithms, andour method falls into the second category.

Original: B Proof of Theorem

Original: Proof.
Revised: Proof.

Original: [Table]
Revised: [Table]

Original: =
Revised: f ℓ ∈ F ∆ ℓ   1 − (cid:89) x i ∈ scp ( f ℓ ) p i ( τ ti )

Original: [Table] p [Table] ) 
Revised: 

Original: 
Revised: 

Original: According to Eq.
Revised: According to Eq.

Original: (4) and Eq.
Revised: (4) and Eq.

Original: (15), for each x
Revised: (15), for each x

Original: i ∈
Revised: i ∈

Original: X it must be the case that τ ti = arg min τ i ∈
Revised: X it must be the case that τ ti = arg min τ i ∈

Original: D i b ti ( τ i )and hence τ ti = arg max τ i ∈
Revised: D i b ti ( τ i ) and hence τ ti = arg max τ i ∈

Original: D
Revised: D

Original: i p ti ( τ i ) .
Revised: i p ti ( τ i ) .

Original: We now show that p ti ( τ ti ) ≥ 1 | D i | .
Revised: We now show that p ti ( τ ti ) ≥ 1 | D i | .

Original: Assume by contradictionthat p ti ( τ ti ) <
Revised: Assume by contradiction that p ti ( τ ti ) <

Original: 1 | D i | .
Revised: | D i | .

Original: Since τ ti has the highest probability,(cid:88)
Revised: Since τ ti has the highest probability, (cid:88)

Original: τ i ∈

Original: D i p

Original: [Equation]

Original: (cid:88)

Original: [Equation]
Revised: [Equation]

Original: i p

Original: [Equation]

Original: =

Original: [Equation] p [Equation] ( τ ti ) < 1 , which contradicts to the fact that p ti is a probability distribution over D i .
Revised: which contradicts to the fact that p ti is a probability distribution over D i .

Original: Therefore,
Revised: Therefore,

Original: [Table]
Revised: [Equation]

Original: ∆ ℓ   1 − (cid:89) x i ∈ scp ( f ℓ ) | D i | 
Revised: loss t − (cid:88)

Original:  .
Revised: [Equation]

Original: C Additional Experimental  Results
Revised: B Additional Experimental Details and Results

Original: In this section, we present additional experimental details and results.
Revised: In this section, we present additional experimental details and results.

Original: C.1 Benchmarks
Revised: B.1 Benchmarks

Original: We consider four types of benchmarks in our experiments, i.e., random COPs, scale-free networks,small-world networks, and Weighted Graph Coloring Problems (WGCPs).
Revised: We consider four types of benchmarks in our experiments, i.e., random COPs, scale-free networks, small-world networks, and Weighted Graph Coloring Problems (WGCPs).

Original: For random COPs and
Revised: For random COPs and

Original: WGCPs, given | X | variables and density of p 1 ∈ (0 , 1) , we randomly create a constraint for a pairof variables with probability p 1 .
Revised: WGCPs, given | X | variables and density of p 1 ∈ (0 , 1) , we randomly create a constraint for a pair of variables with probability p 1 .

Original: For scale-free networks, we use the BA model [3] with parameterm 0 and m 1 to generate constraints: starting from a connected graph with m 0 vertices, a new vertexis connected to m 1 vertices with a probability which is proportional to the degree of each existingvertex in each iteration.
Revised: For scale-free networks, we use the BA model [4] with parameter m 0 and m 1 to generate constraints: starting from a connected graph with m 0 vertices, a new vertex is connected to m 1 vertices with a probability which is proportional to the degree of each existing vertex in each iteration.

Original: For small-world networks, we generate problem topology according to
Revised: For small-world networks, we generate problem topology according to

Original: Newman-Watts-Strogatz model [30]: starting from a ring of | X | vertices, each vertex is connected toits k nearest neighbors, and for each edge underlying the ring with k nearest neighbors, we create anew shortcut by randomly selecting another vertex with a probability p .
Revised: Newman-Watts-Strogatz model [33]: starting from a ring of | X | vertices, each vertex is connected to its k nearest neighbors, and for each edge underlying the ring with k nearest neighbors, we create a new shortcut by randomly selecting another vertex with a probability p .

Original: Finally, for each variable andconstraint in the benchmarks except WGCPs, we set domain size to 15 and uniformly sample a cost from [0 , 100] for each possible assignment combination, respectively.
Revised: Finally, for each variable and constraint in the benchmarks except WGCPs, we set domain size to 15 and uniformly sample a cost from [0 , 100] for each possible assignment combination, respectively.

Original: Differently, for WGCPs eachvariable has a domain of 5 values, and for any pair of constrained variables, we uniformly sample acost from [1 , 100] for an unanimous variable assignment and otherwise, a zero cost.
Revised: Differently, for WGCPs each variable has a domain of 5 values, and for any pair of constrained variables, we uniformly sample a cost from [1 , 100] for an unanimous variable assignment and otherwise, a zero cost.

Original: C.2 Baselines
Revised: B.2 Baselines

Original: Since BPNN [38] and NEBP [23] are proposed for partition function estimation and error correctiondecoding, respectively, it is not trivial to adopt them for solving COPs.
Revised: Since BPNN [41] and NEBP [26] are proposed for partition function estimation and error correction decoding, respectively, it is not trivial to adopt them for solving COPs.

Original: Although FGNN [46] can beapplied to solve COPs, all of these existing DNN-based BP variants require expensive supervisedlearning and optimal labels which are not available in our experimental settings because we considerlarge-scale problems and it is not practical to obtain optimal labels using heavy exact solvers.
Revised: Although FGNN [50] can be applied to solve COPs, all of these existing DNN-based BP variants require expensive supervised learning and optimal labels which are not available in our experimental settings because we consider large-scale problems and it is not practical to obtain optimal labels using heavy exact solvers.

Original: Therefore, to be fair and practical, we do not consider existing DNN-based BP variants.
Revised: Therefore, to be fair and practical, we do not consider existing DNN-based BP variants.

Original: We compare our DABP with the following state-of-the-art COP solvers: (1) DBP with a dampingfactor of 0.9 and its splitting constraint factor graph version (DBP-SCFG) with a splitting ratioof 0.95 [8]; (2) GAT-PCM-LNS with a destroy probability of 0.2 [12], which is a local searchmethod combining the LNS framework [18,39] with neural-learned repair heuristics; (3) Mini-bucket
Revised: We compare our DABP with the following state-of-the-art COP solvers: (1) DBP with a damping factor of 0.9 and its splitting constraint factor graph version (DBP-SCFG) with a splitting ratio of 0.95 [9]; (2) GAT-PCM-LNS with a destroy probability of 0.2 [13], which is a local search method combining the LNS framework [19, 42] with neural-learned repair heuristics; (3) Mini-bucket

Original: Elimination (MBE) with an i -bound of 9 [11], which is a memory-bounded inference algorithm; (4)
Revised: Elimination (MBE) with an i -bound of 9 [12], which is a memory-bounded inference algorithm; (4)

Original: Toulbar2 with timeout of 1200s [9], which is a highly optimized exact solver written in C++.
Revised: Toulbar2 with timeout of 1200s [10], which is a highly optimized exact solver written in C++.

Original: Thehyperparameters for DBP and GAT-PCM-LNS are set according to the original papers, while thememory budget for MBE and timeout for Toulbar2 are set based on our computational resources.
Revised: The hyperparameters for DBP and GAT-PCM-LNS are set according to the original papers, while the memory budget for MBE and timeout for Toulbar2 are set based on our computational resources.

Original: All experiments are conducted on an Intel i9-9820X workstation with GeForce RTX 3090 GPUsand 384GB memory.
Revised: All experiments are conducted on an Intel i9-9820X workstation with GeForce RTX 3090 GPUs and 384GB memory.

Original: We terminate DBP(-SCFG) and GAT-PCM-LNS whenever convergence or themaximum iteration limit ( T max = 1000 ) reaches.
Revised: We terminate DBP(-SCFG) and GAT-PCM-LNS whenever convergence or the maximum iteration limit ( T max = 1000 ) reaches.

Original: Finally, we report the best solution cost for eachrun [Figure] and for each experiment we average the results over 100 random problem instances.
Revised: Finally, we report the best solution cost for each run, and for each experiment we average the results over 100 random problem instances.

Original: C.3 Parameter Tuning
Revised: B.3 Parameter Tuning

Original: In this subsection [Figure] we empirically study the impact of damping factor λ on the performance of DBPand DBP-SCFG, and the impact of the number of effective iterations on the performance of our
Revised: In this subsection, we empirically study the impact of damping factor λ on the performance of DBP and DBP-SCFG, and the impact of the number of effective iterations on the performance of our

Original: DABP, respectively.
Revised: DABP, respectively.

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Original: [Figure]
Revised: [Figure]

Original: Impact of Damping Factor λ .
Revised: Impact of Damping Factor λ .

Original: We vary λ from 0.5 to 0.9 with a step size of 0.1, and Fig.5-7 presentthe solution quality performance of DBP and DBP-SCFG under different damping factors.
Revised: We vary λ from 0.5 to 0.9 with a step size of 0.1, and Fig.5-7 present the solution quality performance of DBP and DBP-SCFG under different damping factors.

Original: It can beobserved that the performance of DBP varies a lot with different λ while DBP-SCFG is relatively lesssensitive to the damping factor.
Revised: It can be observed that the performance of DBP varies a lot with different λ while DBP-SCFG is relatively less sensitive to the damping factor.

Original: In more detail, DBP with a small λ (e.g., λ = 0 .
Revised: In more detail, DBP with a small λ (e.g., λ = 0 .

Original: 5 or λ = 0 . 6 ) trendsto produce low-quality solutions, which is due to the fact that a small damping factor usually cannoteliminate the effect of the costs accumulated before the final periodical of the BP process [48].
Revised: 5 or λ = 0 . 6 ) trends to produce low-quality solutions, which is due to the fact that a small damping factor usually cannot eliminate the effect of the costs accumulated before the final periodical of the BP process [52].

Original: Onthe other hand, a large damping factor (e.g., λ = 0 . 9 ) can also lead to poor results, since it requiressignificantly more iterations to update the beliefs before finding a high-quality solution.[Figure]
Revised: On the other hand, a large damping factor (e.g., λ = 0 . 9 ) can also lead to poor results, since it requires significantly more iterations to update the beliefs before finding a high-quality solution.

Original: [Figure]
Revised: [Figure]

Original: However, it can be extremely tedious and time-consuming to tune the damping factor.
Revised: However, it can be extremely tedious and time-consuming to tune the damping factor.

Original: Fig.
Revised: Fig.

Original: 8 presentsthe accumulated runtime of tuning damping factor in DBP and DBP-SCFG, and the one of DABPwith 10 times of restart.
Revised: 8 presents the accumulated runtime of tuning damping factor in DBP and DBP-SCFG, and the one of DABP with 10 times of restart.

Original: It can be seen that both DBP and DBP-SCFG require significantly higherruntime if we tune the damping factor.
Revised: It can be seen that both DBP and DBP-SCFG require significantly higher runtime if we tune the damping factor.

Original: In fact, the runtime is generally proportional to the number ofdamping factors we have attempted.
Revised: In fact, the runtime is generally proportional to the number of damping factors we have attempted.

Original: On the other hand, to obtain high-quality solutions one needs toperform extensive tuning (e.g., by using a smaller step size or a wider range), which substantiallyincreases the overall runtime overhead.
Revised: On the other hand, to obtain high-quality solutions one needs to perform extensive tuning (e.g., by using a smaller step size or a wider range), which substantially increases the overall runtime overhead.

Original: In contrast, our DABP automatically infers the optimalhyperparameters from the BP messages in the previous iterations, eliminating the need of notoriouslylaborious tuning procedure and finding better solutions in all test cases with much smaller runtime.[Figure]
Revised: In contrast, our DABP automatically infers the optimal hyperparameters from the BP messages in the previous iterations, eliminating the need of notoriously laborious tuning procedure and finding better solutions in all test cases with much smaller runtime.

Original: [Figure]
Revised: [Figure]

Original: Impact of the Number of Effective Iterations T eff .
Revised: Impact of the Number of Effective Iterations T eff .

Original: We train our DABP with different T eff onthe Random COPs and WGCPs with 80 variables and p 1 = 0 .
Revised: We train our DABP with different T eff on the Random COPs and WGCPs with 80 variables and p 1 = 0 .

Original: Fig.
Revised: Fig.

Original: 9 presents the solutionquality when varying T eff .
Revised: 9 presents the solution quality when varying T eff .

Original: It can be seen that a large T eff usually produces inferior solutions.
Revised: It can be seen that a large T eff usually produces inferior solutions.

Original: In suchscenario, T ∗ may contain many suboptimal iterations and their solutions are relatively easy to beimproved.
Revised: In such scenario, T ∗ may contain many suboptimal iterations and their solutions are relatively easy to be improved.

Original: Consequently, DABP is more exploitative and thus, it is prone to get trapped in localoptima.
Revised: Consequently, DABP is more exploitative and thus, it is prone to get trapped in local optima.

Original: In contrast, a small T eff forces DABP to improve only good-enough solutions and encouragesexploration.
Revised: In contrast, a small T eff forces DABP to improve only good-enough solutions and encourages exploration.

Original: In our following experiments [Figure] we use T eff = 2 due to its better solution quality.
Revised: In our experiments, we use T eff = 2 due to its better solution quality.

Original: C.4 Results on the Instances with 60 and 100 Variables
Revised: B.4 Results on the Instances with 60 and 100 Variables

Original: [Figure]

Original: [Figure]

Original: [Figure]

Original: N o r m a li

Original: z

Original: [Figure]

Original: d c o s t

Original: [Figure]

Original: [Figure]

Original: C o n v e r g e n c e r a t e

Original: [Figure]

Original: Fig.
Revised: Fig.

Original: 10-13 present solution quality in each iteration and convergence rate on the instances with| X | = 60 and | X | = 100 .
Revised: 10-13 present solution quality in each iteration and convergence rate on the instances with | X | = 60 and | X | = 100 .

Original: Our DABP outperforms the other baselines by considerable marginson a wide range of benchmarks.
Revised: Our DABP outperforms the other baselines by considerable margins on a wide range of benchmarks.

Original: The only exception happens on WGCPs with 60 variables, where
Revised: The only exception happens on WGCPs with 60 variables, where

Original: Toulbar2 exhibits the best performance.
Revised: Toulbar2 exhibits the best performance.

Original: That is because the variables in WGCPs have a relativelysmall domain size (i.e., 5) and the constraint functions are highly structured, which allows effectivepruning and enumeration for exact methods like Toulbar2.
Revised: That is because the variables in WGCPs have a relatively [Figure] [Figure] [Figure]

Revised: li

Revised: [Figure]

Revised: d c

Revised: [Figure]

Revised: t

Revised: [Figure]

Revised: [Figure]

Revised: small domain size (i.e., 5) and the constraint functions are highly structured, which allows effective pruning and enumeration for exact methods like Toulbar2.

Original: It also can be concluded that our DABPconverges much faster than DBP and DBP-SCFG.
Revised: It also can be concluded that our DABP converges much faster than DBP and DBP-SCFG.

Original: Notably, when solving WGCPs with 100 variables(cf.
Revised: Notably, when solving WGCPs with 100 variables (cf.

Original: Fig.
Revised: Fig.

Original: 13(b)), DBP-SCFG has a poor convergence rate and, even worse, DBP entirely fails toconverge, while our DABP still achieve convergence on the most of instances, which demonstratesthe virtues of our learned dynamic hyperparameters.
Revised: 13(b)), DBP-SCFG has a poor convergence rate and, even worse, DBP entirely fails to converge, while our DABP still achieve convergence on the most of instances, which demonstrates the virtues of our learned dynamic hyperparameters.

Original: C.5 Ablation Study
Revised: B.5 Ablation Study

Original: To demonstrate the necessity of heterogeneous hyperparameters of Eq.
Revised: To demonstrate the necessity of heterogeneous hyperparameters of Eq.

Original: (6), we conduct extensiveablation studies by (1) fixing neighbor weights w tm → i ( ℓ ) to 1 | N i |− 1 and inferring only heterogeneousdamping factor λ ti → ℓ (referred as DABP_Heter_ λ ), and (2) fixing neighbor weights w tm → i ( ℓ ) to1 | N i |− 1 and inferring a homogeneous damping factor λ t by averaging all the damping factors computedby Eq.
Revised: (6), we conduct extensive ablation studies by (1) fixing neighbor weights w tm → i ( ℓ ) to 1 | N i |− 1 and inferring only heterogeneous damping factor λ ti → ℓ (referred as DABP_Heter_ λ ), and (2) fixing neighbor weights w tm → i ( ℓ ) to| N i |− 1 and inferring a homogeneous damping factor λ t by averaging all the damping factors computed by Eq.

Original: (12) (referred as DABP_Homo_ λ ).
Revised: (12) (referred as DABP_Homo_ λ ).

Original: It is noteworthy that DABP_Heter_ λ and DABP_Homo_ λreduce the number of hyperparameters from O ( T | X | d 2 ) to O
Revised: It is noteworthy that DABP_Heter_ λ and DABP_Homo_ λ reduce the number of hyperparameters from O ( T | X | d 2 ) to O

Original: ( T | X | d ) and O ( T ) , respectively.
Revised: ( T | X | d ) and O ( T ) , respectively.

Original: Fig.
Revised: Fig.

Original: 14-16 present the results on solution quality.
Revised: 14-16 present the results on solution quality.

Original: It can be observed that without heterogeneousneighbor weights DABP_Heter_ λ often converges to the solutions inferior to the ones found by DABP,given the same number of restarts.
Revised: It can be observed that without heterogeneous neighbor weights DABP_Heter _ λ often converges to the solutions inferior to the ones found by DABP, given the same number of restarts.

Original: DABP_Homo_ λ , on the other hand, performs significantly worsethan DABP_Heter _ λ and DABP, which highlights the merits and necessity of learning heterogeneoushyperparameters in belief propagation for COPs.
Revised: DABP_Homo_ λ , on the other hand, performs significantly worse than DABP_Heter_ λ and DABP, which highlights the merits and necessity of learning heterogeneous hyperparameters in belief propagation for COPs.

Original: Nonetheless, equipped with learnable deep neuralnetworks, DABP_Homo_ λ still substantially outperforms DBP-SCFG which relies solely on a singlestatic damping factor in terms of both solution quality and convergence speed
Revised: Nonetheless, equipped with learnable deep neural networks, DABP_Homo_ λ still substantially outperforms DBP-SCFG which relies solely on a single static damping factor in terms of both solution quality and convergence speed

Original: [Figure] [Figure]
Revised: [Figure] [Figure]

Revised: o r m a li

Original: z
Revised: z

Original: [Figure]
Revised: e

Original: d c o s t
Revised: d c o s t

Original: [Figure]
Revised: [Figure]

Original: C.6 Memory Footprint

Original: Table 2 presents the GPU memory footprint of our DABP.
Revised: Table 2 presents the GPU memory footprint of our DABP.

Original: We do not include CPU memory usagesince DABP has a similar CPU memory footprint of 4.3GB on all test cases
Revised: We do not include CPU memory usage since DABP has a similar CPU memory footprint of 4.3GB on all test cases, It can be observed that the GPU memory footprint on random COPs (whose domain size is 15) is similar to the one on WGCPs (whose domain size is 5), which indicates that the GPU memory usage of our DABP is insensitive to the domain size. Besides, on highly-structured problems like scale-free networks and small-world networks, our DABP trends to consume less memory than uniform problems.

Original: [Figure]
Revised: [Figure]

Original: It can be observed [Figure] [Table]
Revised: Random COPs

Original: WGCPs
Revised: WGCPs

Original: [Table]

Original:  Nets
Revised: SF Nets

Original: SW Nets | X | =6.
Revised: SW Nets | X | =6.

Original: | X | =12.
Revised: | X | =12.

Original: | X | =20.
Revised: | X | =20.

Original: that the GPU memory footprint on random COPs (whose domain size is 15) is similar to the oneon WGCPs (whose domain size is 5), which indicates that the GPU memory usage of our DABP isinsensitive to the domain size.

Original: Besides, on highly-structured problems like scale-free networks and networks