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 variousreasoning 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-artperformance on various benchmarks by mixing old and new messages beforesending 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 on tuning a staticdamping factor for BP not only is laborious but also harms 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 equallywhen 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 massage-passing frameworkto reason about dynamic weights and damping factors for composing new BPmessages.
Revised: 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.

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 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.

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 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.

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

Original:  Introduction
Revised:  Introduction

Original: Belief Propagation (BP) [20,28] is an important message-passing algorithm for various reasoningtasks over graphical models, e.g., computing partition function of a Markov random field [40],estimating the marginal distribution of a given set of random variables [1], and decoding LPDCcodes [24].
Revised: Belief Propagation (BP) [20,28] is an important message-passing algorithm for various reasoningtasks over graphical models, e.g., computing partition function of a Markov random field [42],estimating the marginal distribution of a given set of random variables [1], and decoding LPDCcodes [24].

Original: Constraint Optimization Problems (COPs) [25,33] are a general mathematical paradigmfor modeling many real-world problems like transportation, supply chain, energy, finance andscheduling [5,33].
Revised: Constraint Optimization Problems (COPs) [25,33] are a general mathematical paradigmfor modeling many real-world problems like transportation, supply chain, energy, finance andscheduling [5,33].

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 [14], seeks tofind 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 andthus, it often explores low-quality solutions on COPs with cyclic factor graphs due to excessive loopy propagation.

Original: Therefore, considerable research efforts [6,8,30,31,32,44] have been devoted to tackling the convergence issue of loopy BP.
Revised: Therefore, considerable research efforts [6,8,30,31,32,46] 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 [8] has drawnsignificant 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 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.

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 [8].

Original: Due to the significant impact of damping on BP [43], 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 [45], 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 homogeneousand 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, DBPsimply treats each variable-node’s neighbors equally when composing a new message, which fails toexplore optimal composition strategy.

Original: On the other hand, Deep Neural Networks (DNNs) have beenapplied to boost the performance of BP [21,35,41].
Revised: On the other hand, Deep Neural Networks (DNNs) have beenapplied to boost the performance of BP [21,35,43].

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 oftenrequire supervised learning and expensive training labels and thus, they cannot be directly applied tosolve 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 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).

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)
Revised: 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)

Original: [38] within the massage-passing framework to reason about dynamic weights and dampingfactors for composing new BP messages.
Revised: [38] within the massage-passing framework to reason about dynamic weights and dampingfactors 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
Revised: • We extend DBP by allowing dynamic damping factors and different neighbor weights for

Original: each variable-node.
Revised: 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 newmessages 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
Revised: • We infer the optimal damping factors and neighbor weights for each iteration automatically

Original: by seamlessly integrating BP and DNNs.
Revised: 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, 37]layer;
Revised: 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, 37]layer;

Original: Then, BP runs with those updated factors and weights to compose and propagate newmessages, and so on.
Revised: Then, BP runs with those updated factors and weights to compose and propagate newmessages, and so on.

Original: Note that integrating GRUs can capture the dynamics of BP messages
Revised: Note that integrating GRUs can capture the dynamics of BP messages

Original: and avoid the gradient vanishing/exploding issue in long BP reasoning sequences.•
Revised: 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
Revised: We further equip our DABP with a novel self-supervised learning loss which is a smoothed

Original: surrogate for the cost under BP decision-making rule.
Revised: 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-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.

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 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.

Original:  Backgrounds
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: 2.1 Constraint Optimization Problems and Factor Graph

Original: A Constraint Optimization Problem (COP) [25] 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) [25] is defined by a triplet ⟨ X, D, F ⟩ , which correspondsto 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 isassociated 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: Xspecifies the cost for each possible assignment of the variables in its scope.

Original: The objective is to find a
Revised: The objective is to find a

Original: [Figure]
Revised: [Figure]

Original: solution 
Revised: solution τ

Original: [Equation]
Revised: [Equation]

Original: = 
Revised: = ( τ [Equation] [Equation] |

Revised: [Equation]

Revised: |

Original: [Equation]
Revised: [Equation]

Original: D i such that the total cost is minimized:
Revised: 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 whichis 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 tothe 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 avariable-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: 2.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) [14] is an important algorithm for COPs which performsmessage-passing on factor graphs.

Original: More specifically, the message sent from a variable-node x i to itsneighbor f ℓ in iteration t is  computed by
Revised: 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

Original: [Equation]
Revised: [Equation]

Original: where N i is the neighbors of x i in the factor graph, and µ t − 1  m →  i  is the message sent from f m to x i inthe previous iteration.
Revised: where N i is the neighbors of x i in the factor graph, and µ t − 1 f m → x i : D i → R is the message sent fromf m to x i in the previous iteration.

Original: Similarly,a function-node f ℓ computes a message for its neighbor x i :
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 that minimizes the current belief:
Revised: Finally, variable-node x i makes a decision by choosing a value with minimum belief cost:

Original: [Equation]
Revised: [Equation]

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

Original:  However, vanilla Min-sum BP usually suffers from non-convergence and explores low-qualitysolutions on cyclic COPs due to excessive loopy propagation.
Revised: τ i in the message µ tf ℓ → x i . However, vanilla Min-sum BP usually suffers from non-convergence and explores low-qualitysolutions 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) [8] attempts toalleviate 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 ofconvergence 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 performanceof BP on COPs [8], 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. Second, using a homogeneous and static dampingfactor for all variable-nodes may limit DBP’s capability.
Revised: First, selecting a damping factor is largelyaccomplished by empirical tuning, which could be laborious and the number of trials is limited bycomputational resources and/or runtime.gaaaa 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 messagecomposition 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 weightsfor 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 messageto 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: 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.

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

Original: 1and use |N
Revised: 1and 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, wehave more fine-grained control for composing new messages to trigger effective exploration withoutaltering 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-varyingdamping 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 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).

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 iterationby 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 weightsby 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: 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.

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 BPmessage-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 gradientexploding 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 beextremely expensive for COPs due to the heavy computation of exact solvers, making it impracticableto 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: 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.

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

Original: 3.1 Model Architecture
Revised: 3.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 graphand 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-nodesto 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 inthe 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 graphdirected 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 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.

Original: Then the augmented factor graph is embeddedthrough G layers of GAT (cf.
Revised: Then the augmented factor graph is embeddedthrough 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 , we compute the embedding e t, ( g ) i for node i according to
Revised: , G } -th layer GAT ψ g , wecompute the embedding e t, ( g ) i for node i according to

Original: [Equation]
Revised: [Equation]

Original: LeakyReLU [Equation] 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 − [Equation] 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 attentionscore 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 [37] (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 factorsand neighbor weights by using a multi-head attention (MHA) layer [37] (cf. Fig. 2(e)), where queriesand 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 anattention 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 )∈
Revised: W ( k )∈

Original: ζ kare learnable matrices, respectively.
Revised: ζ kare 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 neighborweights 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 meanattention score of the remaining neighboring function-nodes:

Original: [Equation] [Equation]
Revised: [Equation] [Equation]

Revised: Input

Revised: [Table]

Revised: [Table]

Revised: [Table]

Revised: [Table]

Revised: [Table]

Revised: [Table]

Revised: [Table]

Revised: [Table]

Revised: do

Revised: [Table]

Revised: [Table]

Revised: [Table]

Revised: [Table]

Revised: 6: compute

Revised: [Table]

Revised: [Table]

Revised: [Table]

Revised: 7: compute

Revised: 8: compute

Original:  Finally, both the neighbor weights and damping factors are normalized across different heads, i.e.,
Revised: T ← select return Finally, both the neighbor weights and damping factors are normalized across different heads, i.e.,

Original: [Equation]
Revised: [Equation]

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

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

Original: Input do 5:

Original: − x f t − 1 f → x

Original: 6: compute

Original: ∈ X f ℓ ∈ N i 7: compute i

Original: N i 8: compute solution then τ τ t 10:

Original: T ∗ ← select

Original: 3.2 A Novel Self-supervised Learning Algorithm for Solving COPs
Revised: 3.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 nature 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 lossfunction 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: Given the smoothed objective for each iteration, we define the following loss function:
Revised: We now theoretically show the error bound of the smoothed cost. Proof is given in Appendix B. Theorem 1. Let

Revised: [Equation]

Revised: ( τ i 1 , . . .

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

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

Revised: We have

Original: [Equation]
Revised: [Equation]

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 subsetof 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 tothe 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, weencourage 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.
Revised: 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.

Original: Thatis, for each COP to be solved, we continuously improve DABP by training on the instance multiplerounds (i.e., restart )  and return the best solution as the result.
Revised: 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.

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

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), followedby 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 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).

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, 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 .

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: 16 T eff 29.

Original: N o r m a li z e d c o s t (a) Random COPs

Original: 16 T eff 0.

Original: N o r m a li z e d c o s t (b) WGCPs

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 ofexperiments 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 effectiveiterations 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 graphdensity 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 [3] with parameters m 0 , m 1 ∈ Z +to generate constraints.

Original: Finally, we generate constraints for small-world networks by using NewmanWatts-Strogatz model [27] with parameters k ∈ Z
Revised: Finally, we generate constraints for small-world networks by using NewmanWatts-Strogatz model [27] 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) 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

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 [11], and (4) Toulbar2 with timeout of 1200s [9].

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 and384GB 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 averagethe results over 100 random problem instances .

Original: Due to the space constraint, we defer the details ofbenchmarks and baselines to Appendix B.1 and B.2, respectively.
Revised: Due to the space constraint, we defer the details ofbenchmarks and baselines to Appendix C.1 and C.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-dimensionalhidden 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 attentionlayer 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 of0.95 [8].

Original: Our model was implemented with the PyTorch Geometric framework [15] and the modelwas trained with the Adam optimizer [18] 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 [15] and the modelwas trained with the Adam optimizer [18] using a learning rate of 10 − 4 and a weight decay ratioof 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 andupdate the model every T upd = 20 iterations.

Original: 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 .

Original: Fig.

Original: 3 presents the solutionquality when varying T eff .

Original: 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.

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

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

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

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 fourstandard 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: [Table]

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 systematicallyexplores the whole solution space, which is often infeasible for large problem instances.

Original: Also, ithighlights the extreme difficulty of obtaining optimal labels with an exact solver for the existing DNNbased BP variants.
Revised: Also, it [Table] 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 muchfaster 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 otheralgorithms.

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-learnedrepair 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 longerruntime than DBP since it needs to perform multiple times of model inference in each iteration tore-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 drasticallyimproves 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 offunction-nodes in DBP-SCFG is doubled due to constraint function splitting.

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 meritsof our learned dynamic damping factors and neighbor weights over the static and homogeneouscounterpart.

Original: Importantly,  our DABP’s runtime performance is comparable to DBP-SCFG and alsoscales up well to large problem instances, thanks to our seamlessly integration of BP and DNNswithin the message-passing framework which enables efficient parallel computation on GPUs.
Revised: 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.

Original: Infact, when applied to scale-free networks, DABP ( R = 5 ) requires less runtime for all configurations, 
Revised: 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%). Besides, equipped with the

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

Original: and has a much lower growing rate ( ∼ 23.81%) than DBP-SCFG ( ∼ 37.37%).

Original: Besides, equipped withthe self-supervised loss function for minimizing the smoothed cost, our DABP is able to infer theoptimal hyperparameters that foster fast convergence, which also improves our model’s efficiency.
Revised: 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.

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 methodsin each iteration and analyze the convergence rate of BP variants on the problem instances with| X | = 80 2 in Fig.

Original: 4 and Fig. 5, 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 = 20in Fig.

Original: 5 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 improvesslowly 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-SCFGsubstantially improves the convergence as well as solution quality of DBP by introducing anotherdegree of freedom through asymmetric function splitting [8].

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 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.

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: 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.

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, 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.

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 traininglabels 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 experimentsconfirm 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 [40], and finding constrained most probable explanation [34]
Revised: 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 [42], and finding constrained most probable explanation [34].

Original: Checklist
Revised: Checklist

Original: For all authors...
Revised: For all authors...

Original: (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s
Revised: (a) Do the main claims made in the abstract and introduction accurately reflect the paper’s

Original: contributions and scope?
Revised: contributions and scope?

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

Original: 3 and Sect.
Revised: 3 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 limitation
Revised: [Yes] We have described our limitation

Original: in Sect.
Revised: in Sect.

Original: (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
Revised: Our work

Original: is theoretical and we do not see any potential negative societal impacts.
Revised: 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
Revised: (d) Have you read the ethics review guidelines and ensured that your paper conforms to

Original: them?
Revised: them?

Original: [Yes]
Revised: [Yes]

Original: If you are including theoretical results...
Revised: If you are including theoretical results...

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

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

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

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

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-
Revised: (a) Did you include the code, data, and instructions needed to reproduce the main ex-

Original: perimental results (either in the supplemental material or as a URL)?
Revised: perimental results (either in the supplemental material or as a URL)?

Original: [Yes] See the
Revised: [Yes] See the

Original: supplemental material.
Revised: supplemental material.

Original: (b) Did you specify all the training details (e
Revised: (b) Did you specify all the training details (e

Original: g., data splits, hyperparameters, how theywere chosen)?
Revised: 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 7.

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

Original: ments multiple times)?
Revised: ments multiple times)?

Original: [Yes] We display the box-plot or the 95% confidence intervals
Revised: [Yes] We display the box-plot or the 95% confidence intervals

Original: when presenting cost performance.(d)
Revised: when presenting cost performance.

Original:  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 & Baselinesparagraph in page 7 and Table 1.4.
Revised: [Yes] See the Benchmarks & Baselines paragraph in page 7 and Table 1.

Original: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...( a)
Revised: If you are using existing assets (e.g., code, data, models) or curating/releasing new assets...

Original:  If your work uses existing assets , did you cite the creators
Revised: (a) If your work uses existing assets, did you cite the creators?

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

Original: b) Did you mention the license of the 
Revised: (b) Did you mention the license of the assets?

Original: assets?

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

Original: c

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

Original: as

Original: a URL

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

Original: d ) Did you discuss whether and how consent was obtained from people whose data you’reusing/curating?
Revised: (d) Did you discuss whether and how consent was obtained from people whose data you’re using/curating?

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

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

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

Original: If you used crowdsourcing or conducted research with human subjects...(
Revised: If you used crowdsourcing or conducted research with human subjects...

Original: a) Did you include the full text of instructions given to participants and screenshots, ifapplicable?
Revised: (a) Did you include the full text of instructions given to participants and screenshots, if applicable?

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

Original: b)
Revised: [Table]

Original: Did you describe any potential participant risks,
Revised: [Table]

Original: with
Revised: [Table]

Original: links to Institutional Review Board (IRB) approvals, if applicable?
Revised: [Table]

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

Original: c) Did you include the estimated hourly wage paid to participants and the total amountspent on participant compensation
Revised: [Table]

Original: [N/A
Revised: [Table]

Original: A Related Work
Revised: A Related Work

Original: Although COP is NP-hard in general [33], many algorithms have been proposed to solve it in thelast several decades, such as BP, local search [16], branch and bound [22], and bucket elimination[10].
Revised: Although COP is NP-hard in general [33], many algorithms have been proposed to solve it in thelast several decades, such as BP, local search [16], branch and bound [22], 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, 17, 23].
Revised: Among them, Min-sum BP is an effective approximate algorithm for solving COPs andhas been successfully applied to many real-world scenarios [14, 17, 23].

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

Original: Rogers et al.
Revised: 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 [30] throughminimization marginalization.
Revised: proposed to ensure convergence and have a lower bound on solutionquality by relaxing the problem, i.e., removing edges to have acyclic factor graphs [30] throughminimization marginalization.

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

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

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

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

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

Original: Recently, Damped BP (DBP)
Revised: 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.
Revised: [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 [43], and
Revised: However,selecting a good damping factor often requires expertise and laborious case-by-case tuning [45], and

Original: DBP uses a static damping factor and treats each node’s neighbors equally when composing a newmessage, which limits its exploration.
Revised: 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.
Revised: 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
Revised: Obviously, DABP generalizes DBP since DBP can be considered as a static version of

Original: DABP.
Revised: 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.
Revised: 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.

Revised: On the other hand, TRBP [40] and Fractional Belief Propagation [41] are another class of methodswhich cope with non-convergence of BP by efficiently solve a linear program (LP) relaxation ofthe combinatorial problem, then select value assignments based on the solution to the LP.

Revised: Likeour method, these approaches also introduce weights in updating messages.

Revised: However, they relyon a predetermined and static weights, while we automatically learn the best weight through ourself-supervised objective, eliminating the need of prior domain knowledge.

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

Original: The most relevant works including: NEBP [35] learns to refine BP messages with some black-box
Revised: The most relevant works including: NEBP [35] 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 [21] uses damping layers to modify factor-to-variable messages and is applied toestimate the partition function of probabilistic graphical models (PGMs); FGNN [41] generalizes
Revised: DNN components in each iteration and is applied to solve the error correction decoding task; In thesame vein, BPNN [21] uses damping layers to modify factor-to-variable messages and is applied toestimate the partition function of probabilistic graphical models (PGMs); FGNN [43] generalizes

Original: Graph Neural Networks (GNNs) to represent Max-Product BP and is applied to find approximatemaximum a posteriori (MAP) assignment of a PGM.
Revised: 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.
Revised: 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
Revised: 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.
Revised: 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 [42] through efficient online learning.
Revised: 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 [44] through efficient online learning.

Original: Our method is also closely related to using DNNs to solve combinatorial problems [4,12,19,26,39].
Revised: Our method is also closely related to using DNNs to solve combinatorial problems [4,12,19,26,39].

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.
Revised: 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,
Revised: Similarly,

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

Original: Recently, Deng et al.
Revised: Recently, Deng et al.

Original: [12] proposed a pretrained cost model which predicts the optimal cost of a givenpartially instantiated COP.
Revised: [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) [16] and backtracking search.
Revised: The predicted cost is then used to construct heuristics for various COPalgorithms such as Large Neighborhood Search (LNS) [16] 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.
Revised: 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 [Table] andour method falls into the second category.

Original: B Additional Experimental Results
Revised: B Proof of Theorem

Revised: [Table] Proof [Table]

Revised: τ

Revised: [Equation]

Revised: fℓ

Revised: [Equation]

Revised: ℓ

Revised: [Equation]

Revised: =1: n

Revised: [Equation]

Revised: [Equation]

Revised: F

Revised: [Equation]

Revised: 

Revised: [Equation]

Revised: x

Revised: [Equation]

Revised: ∈

Revised: [Equation]

Revised: ℓ ) p

Revised: [Equation]

Revised: t i ) 

Revised: 

Revised: According to Eq.

Revised: (4) and Eq.

Revised: (15), for each x

Revised: i ∈

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

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

Revised: D

Revised: i p ti ( τ i ) .

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

Revised: Assume by contradictionthat p ti ( τ ti ) <

Revised: 1 | D i | .

Revised: Since τ ti has the highest probability,

Original: In this section, we present additional experimental details and results.
Revised: [Equation] which contradicts to the fact that p ti is a probability distribution over D i . Therefore, [Equation]

Original: Sect.
Revised: loss [Equation]

Original: B.3.
Revised: (cid:88) [Equation] C Additional Experimental Results In this section, we present additional experimental details and results.

Original: B.1 Benchmarks
Revised: C.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 pairof 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 [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.

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 [27]: 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 [27]: 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 .

Original: Finally, for each variable andconstraint in the benchmarks except WGCPs, we set domain size to 15 and uniformly sample a costfrom [0 , 100] for each possible assignment combination, respectively.
Revised: Finally, for each variable andconstraint in the benchmarks except WGCPs, we set domain size to 15 and uniformly sample a costfrom [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 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.

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

Original: Since BPNN [35] and NEBP [21] are proposed for partition function estimation and error correctiondecoding, respectively, it is not trivial to adopt them for solving COPs.
Revised: Since BPNN [35] and NEBP [21] are proposed for partition function estimation and error correctiondecoding, respectively, it is not trivial to adopt them for solving COPs.

Original: Although FGNN [41] 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 [43] 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.

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 [16,36] 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 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 [16,36] 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 [11], 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 [9], 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: 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.

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 GPUsand 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 themaximum iteration limit ( T max = 1000 ) reaches.

Original: Finally, we report the best solution cost for eachrun, and for each experiment we average the results over 100 random problem instances. 
Revised: Finally, we report the best solution cost for eachrun, and for each experiment we average the results over 100 random problem instances. C.3 Parameter Tuning

Revised: In this subsection, 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: DABP, respectively

Original: B.3 Results on the Instances with 60 and 100 Variables
Revised: [Figure] [Figure] Impact of Damping Factor λ . 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: It can beobserved that the performance of DBP varies a lot with different λ while DBP-SCFG is relatively lesssensitive to the damping factor.

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

Revised: 5 or λ = 0 . 6 ) trends

Revised: [Figure]

Revised: to 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 [45].

Revised: 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.

Revised: [Figure]

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

Revised: Fig.

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

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

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

Revised: 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: 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.

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

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

Revised: Fig.

Revised: 9 presents the solutionquality when varying T eff .

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

Revised: In suchscenario, T ∗ may contain many suboptimal iterations and their solutions are relatively easy to be

Revised: [Figure]

Revised: [Figure]

Revised: improved.

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

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

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

Revised: C.

Revised: 4 Results on the Instances with 60 and 100 Variables

Revised: [Figure]

Revised: [Figure]

Revised: r g e

Original: [Figure]
Revised: [Figure]

Revised: c e r a t e

Revised: [Figure]

Revised: [Figure]

Revised: [Figure]

Original: Fig.
Revised: Fig.

Original: 6-9 present solution quality in each iteration and convergence rate on the instances with | X | = 60and | 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 margins on a widerange of benchmarks.
Revised: Our DABP outperforms the other baselines by considerable marginson a wide range of benchmarks.

Original: The only exception happens on WGCPs with 60 variables, where[-Toulbar
-]
Revised: The only exception happens on WGCPs with 60 variables, where[-Toulbar
-]

Original: [Figure] [Figure] [Figure] exhibits the best performance.
Revised: Toulbar2 exhibits the best performance.

Original: That is because the variables in WGCPs have a relatively small domainsize (i.e., 5) and the constraint functions are highly structured, which allows effective pruning andenumeration for exact methods like Toulbar2.
Revised: That is because the variables in WGCPs have a relativelysmall 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 DABP convergesmuch faster than DBP and DBP-SCFG.
Revised: It also can be concluded that our DABPconverges 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. Fig.

Original: Fig. 9(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 virtuesof our learned dynamic hyperparameters. 
Revised: 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. C.5 Ablation Study

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

Revised: (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: (12) (referred as DABP_Homo_ λ ).

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

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

Revised: Fig.

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

Revised: 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: DABP_Homo_ λ , on the other hand, performs significantly worsethan DABP_Heter

Revised: _ λ and DABP, which highlights the merits and necessity of learning heterogeneoushyperparameters in belief propagation for COPs.

Revised: 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: [Figure]

Revised: [Figure]

Revised: li z e d c o s t

Revised: [Figure]

Revised: C.6 Memory Footprint

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

Revised: We do not include CPU memory usagesince DABP has a similar CPU memory footprint of 4.3GB on all test cases, It can be observedthat 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.

Revised: Besides, on highly-structured problems like scale-free networks andsmall-world networks, our DABP trends to consume less memory than uniform problems.

Revised: [Figure]

Revised: Random COPs

Revised: WGCPs

Revised: SF Nets

Revised: SW Nets | X | =6.

Revised: | X | =12.

Revised: | X | =20.