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 various reasoning 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-art performance on various benchmarks by mixing old and new messages before sending 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 of tuning a static damping factor for BP not only are laborious but also harm 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 equally when 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: 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.
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 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.
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 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.
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 experiments show 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) [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].
Revised: Belief Propagation (BP) [27, 36] is an important message-passing algorithm for various reasoning tasks over graphical models, e g., computing partition function of a Markov random field [50], estimating the marginal distribution of a given set of random variables [1], and decoding LPDC codes [32].

Original: 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].
Revised: Constraint Optimization Problems (COPs) [33, 41] are a general mathematical paradigm for modeling many real-world problems like transportation, supply chain, energy, finance, and scheduling [6, 24, 25, 41].

Original: 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.
Revised: When solving COPs, BP, also known as Min-sum message passing [16], 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 and thus, 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 [7, 9, 36–38, 53] have been devoted to tackling the convergence issue of loopy BP.
Revised: Therefore, considerable research efforts [7, 9, 38–40, 54] have been devoted to tackling the convergence issue of loopy BP.

Original: Among them, Damped BP (DBP) 1 [9] has drawn significant 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 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.
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 [9].
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 [52], 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 [53], a damping factor is often treated as a hyperparameter and requires laborious case-by-case tuning.

Original: Besides, existing works often use a homogeneous and 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, DBP simply treats each variable-node’s neighbors equally when composing a new message, which fails to explore 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 been applied to boost the performance of BP [26, 41, 50].
Revised: On the other hand, Deep Neural Networks (DNNs) have been applied to boost the performance of BP [28, 43, 51].

Original: 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.
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 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).
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 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.
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) [46] 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 new messages 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) 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.
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, 44] 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-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.
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 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.
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.

Original:  Related Work
Revised:  Related Work

Original: 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: Although COP is NP-hard in general [41], many algorithms have been proposed to solve it in the last several decades, such as BP, local search [21], branch and bound [30], and bucket elimination [11, 12, 18].

Original: 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: Among them, Min-sum BP is an effective approximate algorithm for solving COPs and has been successfully applied to many real-world scenarios [16, 22, 31].

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

Original: Rogers et al.
Revised: Rogers et al.

Original: 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.
Revised: 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 [38] through minimization marginalization.

Original: 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].
Revised: Further, Rollon et al. improved the bounding scheme by considering both minimization and maximization marginalization [39] and decomposing high-arity factors into unary functions [40].

Original: On the other hand, Zivan et al. proposed to avoid loopy message propagation by strictly controlling the message-passing direction [53].
Revised: On the other hand, Zivan et al. proposed to avoid loopy message propagation by strictly controlling the message-passing direction [54].

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 VP strategies are proposed [7] as well.
Revised: To balance exploration and exploitation, a set of non-consecutive VP strategies are proposed [7] as well.

Original: Recently, Damped BP (DBP)
Revised: Recently, Damped BP (DBP)

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

Original: However, selecting a good damping factor often requires expertise and laborious case-by-case tuning [52], and DBP uses a static damping factor and treats each node’s neighbors equally when composing a new message, which limits its exploration.
Revised: However, selecting a good damping factor often requires expertise and laborious case-by-case tuning [53], and DBP uses a static damping factor and treats each node’s neighbors equally when composing a new message, which limits its exploration.

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

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

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

Original: On the other hand, LP-based methods solve a COP by leveraging message-passing to solve a Linear
Revised: 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.
Revised: Program (LP) relaxation of the combinatorial problem.

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

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

Original: 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: Tree-reweighted belief propagation (TRBP) [48] and Fractional Belief Propagation [49] 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.

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

Original: TRBP counterpart.
Revised: TRBP counterpart.

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

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 [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: The most relevant works including: NEBP [43] learns to refine BP messages with some black-box DNN components in each iteration and is applied to solve the error correction decoding task;

Original: 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: In the same vein, BPNN [28] uses damping layers to modify factor-to-variable messages and is applied to estimate the partition function of Probabilistic Graphical Models (PGMs); FGNN [51] generalizes Graph

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

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

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

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

Original: 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: 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 [52] through efficient online learning.

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

Original: 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: In the context of COP solving, Neural RM-RRS [15] uses Multi-layer Perceptrons (MLPs) to parameterize high-dimensional regret tables produced by context-based regret-matching.

Original: Similarly,
Revised: Similarly,

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

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

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

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

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

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: 3.1 Constraint Optimization Problems and Factor Graph
Revised: 3.1 Constraint Optimization Problems and Factor Graph

Original: 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.
Revised: A Constraint Optimization Problem (COP) [33] 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 ∈
Revised: Each variable x i ∈

Original: X is associated with a finite domain D i ∈ D .
Revised: 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: X specifies 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 solution τ ∗ =
Revised: The objective is to find a solution τ ∗ =

Original: ( τ ∗ 1 , . . .
Revised: ( τ ∗ 1 , . . .

Original: , τ ∗| X | ) ∈
Revised: , τ ∗| X | ) ∈

Original: Π x i ∈
Revised: Π x i ∈

Original: X 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 which is 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 to the 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 a variable-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: 3.2 Min-sum Belief Propagation
Revised: 3.2 Min-sum Belief Propagation

Original: Min-sum Belief Propagation (Min-sum BP) [15] is an important algorithm for COPs which performs message-passing on factor graphs.
Revised: Min-sum Belief Propagation (Min-sum BP) [16] 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 its neighbor 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 from f 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: 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-quality solutions 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)
Revised: Damped BP (DBP)

Original: [9] attempts to alleviate the issues by damping the messages sent from variable-nodes to function-nodes.
Revised: [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 of convergence 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 performance of BP on COPs [9], 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 largely accomplished by empirical tuning, which could be laborious and the number of trials is limited by 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 message composition 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 weights for 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 message to 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: [Figure]
Revised: [Figure]

Original: 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.
Revised: 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 ( ℓ ) =and 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, we have more fine-grained control for composing new messages 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: 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-varying damping 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 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).
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 iteration by 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 weights by 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: (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.
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 BP message-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 gradient exploding 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 be extremely expensive for COPs due to the heavy computation of exact solvers, making it impracticable to 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: 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.
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: 4.2 to address the second issue.
Revised: 4.2 to address the second issue.

Original: 4.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 graph and 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-nodes to 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 in the 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 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.
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 embedded through 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 , we compute 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 attention score 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 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.
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 [44] (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 an attention 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 )∈ ζ k are learnable matrices, respectively.
Revised: W ( k )∈ ζ k are learnable matrices, respectively.

Original: Then the attention scores are normalized to compute neighbor weights 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 mean attention score of the remaining neighboring function-nodes:
Revised: the mean attention score of the remaining neighboring function-nodes:

Original: [Equation]
Revised: [Equation]

Original: Finally, both the neighbor weights and damping factors are normalized across different heads, i.e.,
Revised: 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: 13) 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: A
Revised: Input: A

Original: [Table]
Revised: [Table]

Original: D
Revised: D

Original: [Table]
Revised: [Table]

Original: ⟩ , the
Revised: ⟩ , the

Original: [Table]
Revised: [Table]

Original: R , the
Revised: R , the

Original: [Table]
Revised: [Table]

Original: limit
Revised: limit

Original: [Table]
Revised: [Table]

Original: max , the
Revised: max , the

Original: [Table]
Revised: [Table]

Original: interval
Revised: interval

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

Original: ∈ { 1 , . . . ,
Revised: ∈ { 1 , . . . ,

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

Original: of P
Revised: of P

Original: [Table]
Revised: [Table]

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

Original: do 3:
Revised: do 3:

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

Original: do
Revised: do

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

Original: 6: compute
Revised: 6: compute

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

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

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

Original: 7: compute µ
Revised: 7: compute µ

Original: [Table]
Revised: [Table]

Original: i
Revised: i

Original: [Table]
Revised: [Table]

Original: to
Revised: to

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

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

Original: i 8: compute solution τ
Revised: i 8: compute solution τ

Original: [Table]
Revised: [Table]

Original: = ⟨
Revised: = ⟨

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

Original: . , τ
Revised: . , τ

Original: [Table]
Revised: [Table]

Original: | X | ⟩ according to Eq.
Revised: | X | ⟩ according to Eq.

Original: (4) 9: if cost( τ ∗ ) > cost( τ t ) then τ ∗ ← τ t 10: if t %
Revised: (4) 9: if cost( τ ∗ ) > cost( τ t ) then τ ∗ ← τ t 10: if t %

Original: [Table]
Revised: [Table]

Original: = 0 then 11:
Revised: = 0 then 11:

Original: T ∗ ← select the best T
Revised: T ∗ ← select the best T

Original: [Table]
Revised: [Table]

Original: iterations according to cost(
Revised: iterations according to cost(

Original: [Table]
Revised: [Table]

Original: t ′ ), t − T upd < t ′ ≤ t 12: compute L
Revised: t ′ ), t − T upd < t ′ ≤ t 12: compute L

Original: [Table]
Revised: [Table]

Original: θ ) according to Eq.
Revised: θ ) according to Eq.

Original: [Table]
Revised: [Table]

Original: 16), θ ← ADAM( θ, ∇L ( θ )) 13: if BP messages converge then break return τ ∗
Revised: 16), θ ← ADAM( θ, ∇L ( θ )) 13: if BP messages converge then break return τ ∗

Original: 4.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 loss function 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 A.
Revised: Proof is given in Appendix A.

Original: Theorem 1.
Revised: Theorem 1.

Original: Let ∆
Revised: Let ∆

Original: [Equation]
Revised: [Equation]

Original: ⟩ f
Revised: ⟩ f

Original: [Equation]
Revised: [Equation]

Original: τ
Revised: τ

Original: [Equation]
Revised: [Equation]

Original: , τ
Revised: , τ

Original: [Equation]
Revised: [Equation]

Original: n ) be the maximum difference between cost values of each constraint function f ℓ and τ t = ⟨ τ t 1 , . .
Revised: 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 subset of 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 to the 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, we encourage 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 generation for each instance and thus, DABP can be directly applied to solve COPs via online learning without any 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 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.
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 nice anytime property [51].
Revised: Therefore, our DABP avoids the out-of-distribution issue and has a nice anytime property [52].

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), followed by 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 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).
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, 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 .
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 of experiments and implementation.
Revised: We begin with introducing the details of experiments and implementation.

Original: Then we analyze the impact of the number of selected effective iterations 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 graph density 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 [4] 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 [33] with parameters k ∈ Z
Revised: Finally, we generate constraints for small-world networks by using NewmanWatts-Strogatz model [35] 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) 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
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 [14]; (3) Mini-bucket

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

Original: All experiments are conducted on an Intel i9-9820X workstation with GeForce RTX 3090 GPUs and 384GB 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 average the 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 of benchmarks and baselines to Appendix B.1 and B.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-dimensional hidden 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 attention layer 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 of 0.95 [9].
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 [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 .
Revised: Our model was implemented with the PyTorch Geometric framework [17] and the model was trained with the Adam optimizer [23] 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
Revised: For each instance, we perform R = 20 restarts with iteration limit

Original: T max = 1000 and update the model every T upd = 20 iterations.
Revised: 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 four standard 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 systematically explores 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 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 much faster 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 other algorithms.
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-learned repair 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 longer runtime than DBP since it needs to perform multiple times of model inference in each iteration to re-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 drastically improves 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 of function-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.

Original: [Table]
Revised: [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 merits of our learned dynamic damping factors and neighbor weights over the static and homogeneous counterpart.
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 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.
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, 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%).
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 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.
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 methods in each iteration and analyze the convergence rate of BP variants on the problem instances with | X | = 80 3 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 =in 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 improves slowly 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-SCFG
Revised: DBP-SCFG

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

Original: substantially improves the convergence as well as solution quality of DBP by introducing another degree of freedom through asymmetric function splitting [9].
Revised: 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 allows more flexibility in composing BP messages by reasoning optimal dynamic hyperparameters through seamlessly integrating BP and DNNs
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

Original: [Figure]
Revised: [Figure]

Original: and it also significantly outperforms and converges much faster than both DBP and DBP-SCFG.
Revised: 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: 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.
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, 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.
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 training labels 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 experiments confirm 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 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].
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 [50], and finding constrained most probable explanation [42].

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

Original: Acknowledgement
Revised: Acknowledgement

Original: This research is supported by the National Research Foundation, Singapore under its Industry Alignment Fund – Pre-positioning (IAF-PP)
Revised: This research is supported by the National Research Foundation, Singapore under its Industry Alignment Fund – Pre-positioning (IAF-PP)

Original: Funding Initiative.
Revised: Funding Initiative.

Original: Any opinions, findings and conclusions or recommendations expressed in this material are those of the author(s) and do not reflect the views of
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

Original: National Research Foundation, Singapore.
Revised: National Research Foundation, Singapore.

Revised: The work of Caihua Liu is partially supported and funded by the Humanities and Social Sciences Youth Foundation, Ministry of Education of the People’s

Revised: Republic of China (Grant No.21YJC870009).

Original: We  sincerely thank Professor Rina Dechter at University of California, Irvine for her helpful discussions and suggestions.
Revised: We also sincerely thank Professor Rina Dechter at University of California, Irvine for her helpful discussions and suggestions.

Original: Checklist
Revised: Checklist

Original: For all authors... (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: 4 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 limitation in Sect.
Revised: [Yes] We have described our limitation 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 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] 2.
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: [Yes] See Theoremin page 7.
Revised: [Yes] See Theoremin page 7.

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

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

Original: If you ran experiments... (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)?
Revised: If you ran experiments... (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 Github URL in page 2.
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 8.
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 experiments 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., type of 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.
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] (c) Did you include any new assets either in the supplemental material or as a URL?
Revised: [N/A] (c) Did you include any new assets either in the supplemental material or as a URL?

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

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

Original: [N/A] (e) Did you discuss whether the data you are using/curating contains personally identifiable 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/A] 5.
Revised: [N/A] 5.

Original: 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?
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: [N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?[N/A] (c) Did you include the estimated hourly wage paid to participants and the total amount spent on participant compensation? [N/A] Proof.
Revised: [N/A] (b) Did you describe any potential participant risks, with links to Institutional Review Board (IRB) approvals, if applicable?

Original: [Table] f ℓ ∈ F ∆ ℓ   1 − (cid:89) x i ∈ scp ( f ℓ ) p i ( τ ti )  
Revised: [N/A] (c) Did you include the estimated

Original: According to Eq.

Original: (4) and Eq.

Original: (15), for each x i ∈ X it must be the case that τ ti = arg min τ i ∈ D i b ti ( τ i ) and hence τ ti = arg max τ i ∈
Revised: hourly wage paid to participants and the total amount spent on participant compensation?

Original: D

Original: i p ti ( τ i ) .

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

Original: Assume by contradiction

Original: that p ti ( τ ti ) <

Original: | D i | .

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

Original: [Equation]

Original: which contradicts to the fact that p ti is a probability distribution over D i .

Original: Therefore,

Original: [Equation]

Original: loss t − (cid:88)

Original: [Equation]

Original: B Additional Experimental Details and Results

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

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

Original: For random COPs and

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

Original: 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 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 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: B.2 Baselines

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

Original: 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 [12], which is a memory-bounded inference algorithm; (4)

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

Original: 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 GPUs and 384GB memory.

Original: 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 each run, and for each experiment we average the results over 100 random problem instances.

Original: B.3 Parameter Tuning

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

Original: [Figure]

Original: [Figure]

Original: [Figure]

Original: Impact of Damping Factor λ .

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

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

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

Original: Fig.

Original: 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 higher runtime if we tune the damping factor.

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

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

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

Original: Fig.

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

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

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

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

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

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

Original: Fig.

Original: 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 wide range of benchmarks.

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

Original: Toulbar2 exhibits the best performance.

Original: That is because the variables in WGCPs have a relatively

Original: [Figure]

Original: [Figure]

Original: [Figure]

Original: li

Original: [Figure]

Original: d c

Original: [Figure]

Original: t

Original: [Figure]

Original: [Figure]

Original: 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 DABP converges much faster than DBP and DBP-SCFG.

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

Original: Fig.

Original: 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: B.5 Ablation Study

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

Original: (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_ λ ).

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

Original: Fig.

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

Original: It can be observed that without heterogeneous neighbor weights DABP_Heter

Original: _ λ 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 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 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]

Original: [Figure]

Original: o r m a li

Original: z

Original: e

Original: d c o s t

Original: [Figure]

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

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

Original: 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: [N/A]

Original: Random COPs

Original: WGCPs

Original: SF Nets

Original: SW Nets | X | =6.

Original: | X | =12.

Original: | X | =20.