G RAPH - BASED D ETERMINISTIC P OLICY G RADIENT FOR R EPETITIVE C OMBINATORIAL O PTIMIZATION P
ROBLEMS
Anonymous authors
Paper under double-blind review
A BSTRACT
We propose an actor-critic framework for graph-based machine learning pipelines with non-differentiable blocks, and apply it to repetitive combinatorial optimization problems (COPs) under hard constraints.
Repetitive COP refers to problems to be solved repeatedly on graphs of the same or slowly changing topology but rapidly changing node or edge weights.
Compared to one-shot COPs, repetitive COPs often rely on fast (distributed) heuristics to solve one instance of the problem before the next one arrives, at the cost of a relatively large optimality gap.
Through numerical experiments on several discrete optimization problems, we show that our approach can learn reusable policies to reduce the optimality gap of fast (distributed) heuristics for independent repetitive COPs, and can optimize the long-term objectives for repetitive COPs embedded in graph-based Markov decision processes.
Source code at https://github.com/XzrTGMu/twin-nphard .
I NTRODUCTION
In a general network setting, the network state is captured by a graph G =
( V , E , S ) , that comprises a vertex set V , an edge set E , and a matrix S capturing the node features.
A vector o ∈ R |V| captures the outcomes on individual nodes of a non-differentiable network process, f net ( · ) , as: o = f net ( G ) . We aim to optimize the system-level objective f obj ( o ) , where f obj : R | o | → R is a known linear combination, by improving parts of the network process f net ( · ) .
In particular, we are interested in network processes that involve graph-based repetitive combinatorial optimization problems (R-COPs) (Kraay & Harker, 1996) – COPs that need to be solved repeatedly on graphs of the same or slowly changing topology ( V or E ) but rapidly changing node features ( S ), under hard constraints that must be satisfied at all times (Kendall, 1975), which often make COPs NP-hard.
R-COPs have many real-world applications, such as task scheduling (Pinedo, 2012), route planning (Vogiatzis & Pardalos, 2013), link scheduling (Joo & Shroff, 2012; Paschalidis et al., 2015; Eisen et al., 2019; Zhao et al., 2022a;b) and routing (Oliveira et al., 2011) in communication networks, and energy management in smart grids (Chau et al., 2018), where a node or edge weight captures varying cost or utility.
In practice, solvers for R-COPs are often subject to restricted runtime and/or distributed execution.
For example, in scheduling, network routing, and multi-object tracking in computer vision, COPs need to be solved within tens of milliseconds to a few seconds.
Although memory-based approaches can avoid solving each instance from scratch for some applications (Kraay & Harker, 1996; Wang, 2021), in general, R-COPs rely on fast heuristics to meet the strict time constraints, at the cost of relatively large optimality gaps.
Moreover, in real-time networked systems, such as communication networks, smart grids, and robot swarms (Tolstaya et al., 2020), centralized solvers often suffer from the large communication overhead of gathering the full network state, high computational complexity, and risk of single point of failure.
Therefore, distributed solutions (Moser & Tardos, 2010) are preferred for better scalability and robustness, in which nodes across the network work in parallel to collect and process the information of only their local neighborhoods for decision making.
Depending on the definition of f obj , R-COPs can be categorized as, 1) independent R-COPs, i.e.,
S ( t 1 ) and S ( t 2 ) are considered as independent if t 1 ̸ = t 2 , and 2) R-COPs embedded in a graph-based
Markov decision process (MDP).
For example, in link scheduling for wireless multiple networks (Zhao et al., 2022a;b), the network state G ( t ) =
( V , E , S ( t )) , where S ( t ) captures the packet backlogs of all the links at time t , depends on the schedule of t − 1 found by solving a maximum weight independent set (MWIS) problem defined on G ( t − 1) .
Scheduling for maximum throughput (number of data packets transmitted on the schedule) is equivalent to optimize each MWIS instance individually (Zhao et al., 2022a), which is formulated as an independent R-COP.
However, to minimize the average backlog (packets left in the queues by the schedule) across links and over time , the transition of network states must be considered and the scheduling is formulated as R-COP in a graph-based MDP (Zhao et al., 2022b).
Similar MDP formulations can also be found in wireless scheduling for battery lifetime (Sikandar et al., 2020), vehicle routing for waste collection (Wu et al., 2020), and inventory control in distribution networks (Çelebi, 2015).
However, the 2nd type of R-COPs have rarely been addressed, except in an ad-hoc manner for link scheduling (Zhao et al., 2022b).
Therefore, a general approach to R-COPs in graph-based MDPs would be of high interest.
1. E XISTING A PPROACHES TO COP S
The general approach for exactly solving a COP is to formulate it as a mixed-integer program, and solve it by branch-and-bound (Land & Doig, 1960) or dynamic programming.
Commercial Gurobi solvers (LLC, 2020) can exactly solve COPs on graphs of hundreds of nodes in reasonable time.
Although large real-world graphs with certain structural properties can be reduced (Lamm et al., 2019) to smaller sizes for exact solutions, problems facing large scale or stringent time limit generally rely on efficient heuristics to approximate the solution; common strategies include greedy algorithms, local search (Wang et al., 2018), tabu search, ant colony (Jovanovic et al., 2010), and simulated annealing.
In many recent machine learning-based COP solvers, graph neural networks (GNNs) (Wu et al., 2021) are trained to guide an algorithmic framework that guarantees that the constraints are always satisfied, such as branching (Khalil et al., 2016; Gasse et al., 2019; Nair et al., 2020; Zarpellon et al., 2021), tree search (Li et al., 2018), greedy algorithms (Khalil et al., 2017; Zhao et al., 2022a), and local search (Hudson et al., 2022).
These approaches typically formulate a COP instance as a finite episode of an MDP, in which a state captures the residual graph of an intermediate step, based on which an action of adding one vertex in the residual graph to the partial solution is generated by a GNN, and a solution is built from a sequence of such scalar actions.
This formulation has a time complexity of no less than O ( |V||E| ) , since a GNN of time complexity of O ( |E| ) (Wu et al., 2021) is called in each intermediate step.
(Drori et al., 2020; Hottung et al., 2022) lowered the time complexity of vehicle routing problems to O ( |E| ) (typically, |E| > |V| ) by encoding the graph by a
GNN only once per COP instance.
However, for R-COPs, this formulation is limited by centralized execution and the complexity of a GNN, and does not apply to R-COPs in graph-based MDPs.
Popular distributed approaches to find solutions to COPs include Moser-Tardos algorithm (Moser & Tardos, 2010) and dynamic programming.
The complexity of distributed algorithms is usually measured by local communication complexity, which is the number of rounds of message exchanges between a node and its neighbors (Joo & Shroff, 2012; Zhao et al., 2022a).
For example, on MWIS,
Moser-Tardos algorithm (Joo & Shroff, 2012; Moser & Tardos, 2010) can converge in O (log ∗ | V | ) rounds, whereas distributed dynamic programming (Paschalidis et al., 2015) in O ( | V | ) rounds.
However, the lack of global information may cause distributed algorithms to have larger optimality gaps.
Topological metrics can be used to reduce the optimality gap, such as edge betweenness for the Steiner tree problem (Fujita et al., 2016).
Compared to their centralized counterparts, learning-based distributed COP solvers have received less attention.
(Zhao et al., 2022a) proposed an architecture, GCN-LGS, for a repetitive MWIS problem, in which an L -layer graph convolutional neural network (GCNN) generates a vector z for a topology ( V , E ) , and a greedy heuristic solves modified instances ( V , E , c ( t ) ⊙ z ) , rather than the original ones ( V , E , c ( t )) , for the next N time slots t ∈ { 1 , . .
. , N } , assuming the topology would not change by t = N .
GCN-LGS can reduce the optimality gap of greedy solvers (Joo & Shroff, 2012) by 1 / 3 to 1 / 2 , with a time complexity of O
( L |E| /N
+ |V| ) , or can converge in O
( L/N + log | V | ) iterations in a distributed setting.
For large reusing factor N , the overhead of GCNN is negligible.
However, the training methods in (Zhao et al., 2022a;b) are ad hoc and specific to MWIS problems, which could not be directly applied to other types of R-COPs.
In this work, we generalize the GCN-LGS architecture in (Zhao et al., 2022a;b) to broader R-COPs, by proposing a unified framework including the problem formulation and an actor-critic architecture for training.
Rather than using a sequence of scalar actions to solve a COP instance formulated as a finite episode of an MDP, our actor network generates a high-dimensional intermediate action to parameterize a given classical heuristic, h ′ ( · ) , which generates vectorized decisions by solving one or multiple instances of an R-COP.
The classical heuristic h ′ ( · ) guarantees the hard constraints being always followed by the decisions.
This formulation allows us to pick a fast and/or distributed classical heuristic h ′ ( · ) to follow various practical restrictions.
For independent R-COPs, an intermediate action encodes the underlying topology shared by N instances to improve the average quality of their solutions, further reducing the overhead of running the GNN from O ( |E| ) (Drori et al., 2020;
Hottung et al., 2022) to O ( |E| /N ) , which is arbitrarily small for a large N .
For R-COPs embedded in a graph-based MDP, the long-term objective can be optimized through a sequence of vectorized intermediate actions and corresponding decisions, each based on the network state in a time slot.
The challenge, however, is that our policy network contains a non-differentiable block, e.g., h ′ ( · ) .
1. L EARNING IN N ON - DIFFERENTIABLE P IPELINES
Training with supervised or unsupervised learning methods is challenging in the presence of nondifferentiable blocks, such as f net ( · ) in (1).
Reinforcement learning (RL) (Sutton & Barto, 2018) deals with this problem by treating the non-differentiable block as (part of) the environment (Silver et al., 2014; Khalil et al., 2017; Zhao et al., 2022a).
Policy gradient (Silver et al., 2014) with highdimensional action space is most suited for the parallel and dynamic nature of networks, whereas the popular Q-learning (Watkins & Dayan, 1992) is inherently sequential.
A major issue in RL for networks is how to assign credit to individual elements based on the system-level reward.
Zeroth-order optimization (ZOO) (Liu et al., 2020) is the last resort for non-differentiable pipelines, as it requires numerous evaluations of f net ( · ) , which could be computationally prohibitive.
In some scenarios, such non-differentiable pipeline can be circumvented by using soft constraints (Kendall, 1975), which allows a fully differentiable policy network that can be trained by policy gradient-based primal-dual optimization (Eisen et al., 2019) or imitation learning (Ross et al., 2011).
To address the aforementioned shortcomings, we propose a graph-based deterministic policy gradient (GDPG-Twin) following the actor-critic method (Sutton & Barto, 2018, ch. 13).
The core idea is to train a differentiable twin of the non-differentiable policy block in f net ( · ) , e.g., h ′ ( · ) , as part of the critic network, to facilitate the training of the actor network.
A similar idea, called differentiable approximation bridges (DAB) was proposed in (Ramapuram & Webb, 2020) to approximate the immediate behavior of a non-differentiable block in standalone systems.
We improve DAB from three aspects: we use a twin network to predict the element-wise expected outcomes of the nondifferentiable policy network, use a GNN to account for the permutation equivariance in network settings, and use random policy sampling for static policy parameters Z in a fixed topology.
Our
GDPG-Twin is suitable for network settings with hard constraints, and is more efficient than ZOO.
Although we focus on node-related problems, our approach also applies to edge-related problems, e.g., by designing a twin based on simplicial neural networks (Roddenberry et al., 2021).
1. C ONTRIBUTIONS
In summary, our proposed framework: 1) can generalize to learning for different COPs without handcrafting the credit assignment strategies as in other schemes of network-based RL (Eisen et al., 2019; Zhao et al., 2022a;b), 2) works for R-COPs with hard constraints, 3) requires fewer evaluations of f net ( · ) than ZOO (Liu et al., 2020), and 4) has the advantage of RL schemes in not relying on expensive data labeling as in supervised learning or a computationally intensive supervising algorithm as in imitation learning (Ross et al., 2011).
Our contribution contains the following three aspects:
• We propose a general approach to R-COPs under hard constraints and practical restrictions.
Our approach can reduce the optimality gap of fast and/or distributed heuristics for independent R-COPs, at the cost of only an upfront computation and communication overhead, and can optimize the long-term objectives for R-COPs in a graph-based MDP.
• We propose GDPG-Twin, an actor-critic architecture for network settings.
By using a twin network that learns the element-wise expected outcomes o of a non-differentiable policy network in f net ( · ) , the critic can leverage the knowledge of the linear combination of the system-level objective f obj ( o ) to address the challenge of credit assignment across the network, which is a major roadblock for discrete or mixed-integer network processes.
• We adopt a random policy sampling strategy in the training of the twin network, which enables optimizing a static policy for R-COPs defined on fixed topologies.
Moreover, our approach requires significantly fewer evaluations of the network process f net ( · ) than ZOO.
Notation.
Upright bold lower-case (upper-case) symbols are used to denote column vectors, e.g., x (matrices, e.g., X ).
x i denotes the i th element of vector x , X i,j denotes the element at row i and column j of matrix X , X i ∗ (or X ∗ j ) denotes row i (or column j ) of matrix X .
Unless otherwise specified, calligraphic upper-case symbols (e.g., V ) are used to denote sets.
( · ) ⊤ and ⊙ denote transpose and element-wise product, respectively.
P ROBLEM F ORMULATION
Many binary discrete COPs have the following formulation,
[Equation]
other problem-specific constraints ,
[Equation] 2c [Equation] where x and c are respectively the vectors of decisions and weights on nodes.
Since many problems in (2) are NP-hard, we seek to develop efficient heuristics to approximate x ∗ .
Furthermore, we define the function space F of valid heuristics, meaning that x = f ( V , E , c ) satisfies the constraints in (2) for all f ∈ F . We also define the space P of practical functions, i.e., functions that satisfy pre-specified practical restrictions, e.g., limited runtime and/or distributed execution.
2. I NDEPENDENT R EPETITIVE COP S
For independent R-COPs, the weight c of an instance is considered to be a random vector drawn from its target sampling distribution Ω c .
We formulate independent R-COPs as finding a valid heuristic (policy) that optimizes the expectation of the objective function in (2a) under practical restrictions
[Equation]
3b
[Equation]
2. R EPETITIVE COP S IN A G RAPH - BASED M ARKOV D ECISION P ROCESS
Given network state G ( t ) =
( V ( t ) , E ( t ) , S ( t )) , where S ( t ) captures features on nodes at time t , our objective is to find a valid heuristic h for a COP in (2) and a cost function Ψ , which together form a policy that – subject to the practical restrictions – maps G ( t ) into x ( t ) and maximizes the system-level value over time horizon T , as follows:
[Equation]
In (4), o ( t ) is the value vector of current state G ( t ) under policy { h, Ψ } , 0 ≤ γ ≤ 1 is the discount factor, (4a) states that the system-level objective is a known linear combination, f obj : R | o | → R , of the value vector o ( t ) , (4d) states that a decision vector x ( t ) is generated by a valid heuristic h ∈ F of a COP based on the network topology ( V ( t ) , E ( t ) ) and cost vector c ( t ) , which is a function of the network state G ( t ) as stated by (4e), and (4c) and (4f) define the MDP by respectively stating that the reward vector r ( t ) and the next state S ( t + 1) depend on the current state S ( t ) and the decisions x ( t ) .
In general, f r ( · ) and f s ( · ) in (4) are stochastic functions, capturing some stationary random processes in the environment.
The formulation in (4) can capture R-COPs with accumulative objectives, such as latency and battery lifetime in wireless scheduling, waste level in vehicle routing for waste collection, and inventory in distribution networks.
Notice that if T = t , γ = 1 , S ( t ) =
c ( t ) ( Ψ is bypassed), r ( t ) =
c ( t ) ⊙ x ( t ) , f obj ( o )
= 1 ⊤ o , and we set f s in (4f) as drawing a random vector from Ω c , then (4) boils down to (3).
In many practical independent R-COPs formulated as (3), a node weight c i ( t ) is defined as a given (cost/utility) function of the node feature S i ∗ ( t ) , whereas the goal is to optimize another metric linked to the total cost/utility.
Therefore, (4) actually generalizes all R-COPs.
G RAPH - BASED DETERMINISTIC POLICY GRADIENT
Our downstream pipeline follows the existing methodology of using a neural network to guide a discrete operation, which guarantees the hard constraints, but keeps the neural network outside the iterations of the algorithmic framework for lower complexity (Zhao et al., 2022a).
In this section, we provide the main solution, whereas the full procedures of optimization for Sections 3.1 and 3.2 are given by Algorithms 1 and 2 in Appendix C. Since (3) and (4) are functional optimization problems, we seek to approximately solve them by parameterizing the policy ( h or { h, Ψ } ) and reformulating (3) and (4) as finding the optimal set of parameters. To meet the practical restrictions, we rely on manual selections (or design) of a baseline heuristic h ′ ∈ F and the parameterizations.
3. L EARNING FOR INDEPENDENT REPETITIVE COP
For independent R-COPs, we reformulate (3) as
[Equation]
The objectives in (3a) and (5a) are equal due to the linearity of expectation, i.e., E c ∼ Ω c ( c ⊤ x ) =
E c ∼ Ω c ( (cid:80) | c | i = 1 c i x i ) = (cid:80) | c | i =
1 E c ∼ Ω c ( c i x i ) = 1 ⊤ o . Constraints (5c) and (5d) further break the parameterized policy in (3b), h ( · ; Z ) , into a baseline heuristic h ′ ( · ) ∈ ( F ∩ P ) given in advance and a parameterized local function f loc ( · ; Z i ∗ ) , where Z i ∗ ∈ R 1 × g captures the g local parameters for node i ∈ V .
The local function f loc ( · ; Z i ∗ ) can be chosen as, e.g., a multiplier, a single neuron, or even a small neural network, and depends on node-specific parameters Z i ∗ .
To solve the problem formulated in (5), we employ deterministic policy gradient reinforcement learning, where the policy parameters are Z .
However, the gradient ∇ Z 1 ⊤ o is not available since h ′ ( · ) is non-differentiable.
To address this problem, we introduce a trainable and differentiable twin network f twin ( · ; Θ c ) to learn the element-wise expected outcome of h ( · ; Z ) .
In contrast to the critic in a typical standalone setting, which directly predicts the system-level objective, the twin network works for network settings, where the policy parameters and outcome are supported on graphs.
The twin can be implemented by a graph or a simplicial neural network (Roddenberry et al., 2021), depending on the specific COP.
The expected behavior of the twin can be described by
[Equation]
Based on (5a) and (6), we can estimate the system objective as 1 ⊤ ˆ o .
Based on (6) and the chain rule ∂ 1 ⊤ ˆ o ∂ Z = 1 ⊤ ∂ ˆ o ∂ Z , the policy gradient is estimated as (Silver et al., 2014) [Equation]
[Equation]
Given a policy learning rate 0 ≤ α p ≤ 1 , we can update the policy parameters as, Z ← Z − α p ∇ Z 1 ⊤ ˆ o .
If the policy parameters are generated by an actor, Z = Ψ( V , E , ¯ c ; Θ p ) , we can estimate the gradient ∇ Θ p 1 ⊤ ˆ o = ∇ Θ p Ψ
( V , E , ¯ c ; Θ p ) ∇ Z
1 ⊤ ˆ o , and update the actor parameters as, Θ {+p ← Θ p − α p ∇ Θ p 
+}
⊤ ˆ o . From the perspective of the actor Ψ( · ; Θ p ) , its input is ( V , E , ¯ c ) instead of the instantaneous network state ( V , E , c ) , and it generates an intermediate action Z , which is used as the policy parameters.
Given a learning rate 0 ≤ α c ≤ 1 , the twin network can be updated by the following gradient descent,
[Equation]
where the loss function ℓ mse (ˆ o , o ) is the mean-square-error (MSE) between ˆ o and o .
Since o is an expectation over sampling space Ω c , we can implement the following stochastic gradient descent
[Equation]
by minimizing the MSE loss in (9) with an off-the-shelf optimizer.
Notice that we need to evaluate h ′ ( · ) and f loc ( · ; Z ) to get x in (9).
A detailed derivation of (9) is given in Appendix A.
3.1. R ANDOM S AMPLING A ROUND C URRENT P OLICY
For applications based on static topologies, i.e., ( V , E , ¯ c ) are constant, we no longer need an actor to generate Z . In this case, the twin is likely to be overfitted if we only feed it with a static Z during training.
To address this problem, we feed the twin f twin ( · ) and h ( · ; Z ) with random samples around the current policy parameters Z ( j ) =
Z + N ( j ) , N ( j ) m,n ∈ U ( − ϵ, ϵ ) where ϵ is the sampling radius.
The loss in (9) then becomes ℓ mse (ˆ o ( j ) , c ⊙ x ( j ) ) .
This random sampling strategy enables the critic, comprising the twin f twin ( · ; Θ c ) and system-level objective function f obj (ˆ o ) , to learn the loss landscape around the current Z , thus improve the quality of gradient in (7).
In ZOO, a policy gradient is estimated from at least two random samples around the current Z (including Z itself)
(Liu et al., 2020).
While fewer policy samples requires fewer evaluations of h ( · ; Z ) , which could be computationally expensive in many applications, it could degrade the convergence by raising the noise floor of the gradient estimate.
Compared to ZOO, our twin-based critic can continuously learn, refine, and memorize the loss landscape around the current policy as new samples coming in, leading to better gradient estimate in backpropagation (improved convergence as shown in Figure. 1), and higher policy sampling efficiency, as shown in Sections 4.2 and 4.3.
3. L EARNING FOR R EPETITIVE COP IN A G RAPH - BASED M ARKOV D ECISION P ROCESS
For R-COP in a graph-based MDP, we parameterize the policy in (4), { h, Ψ } , with a given baseline heuristic h ′ ∈ F , and a parameterized cost function Ψ( · ; Θ p ) .
We then reformulate (4) as:
[Equation]
By fixing h in the policy { h, Ψ } to a given baseline heuristic h ′ in (10d), we only need to optimize the actor network Ψ( · ; Θ p ) that generates the intermediate action c ( t ) based on G ( t ) in (10e).
Similar to (7), we estimate the gradient ∇ c ( t ) f
obj ( E t ≤ T [ o ( t )]) through a twin network that predicts the value vector in (10b) as o ( t )
≈ ˆ o ( t ) =
f twin ( V ( t ) , E ( t ) , S ( t ) , c ( t ); Θ c ) .
Based on linearity of expectation and that f obj ( · ) is a known linear combination, the policy gradient estimate is (Silver et al., 2014) [Equation]
[Equation]
Then, we can update the policy network as Θ p ← Θ [Equation] + α
[Equation] t ≤ T [ o ( t )]) . According to the detailed derivation in Appendix B, the twin network can be trained by stochastic gradient descent, implemented by minimizing the following loss with an off-the-shelf optimizer:
[Equation]
[Equation] T [Equation] [Equation]
N UMERICAL R ESULTS 4. I NDEPENDENT R-COP S
We first demonstrate our GDPG-Twin framework on four independent R-COPs, including maximum weighted independent set (MWIS), minimum weighted dominating set (MWDS), node weighted
Steiner tree (NWST), and minimum weighted connected dominating set (MWCDS).
These problems are all NP-hard, and need to be solved repetitively in a wide range of applications.
For example, the MWIS problem appears in various schedulers (Pinedo, 2012; Joo & Shroff, 2012;
Zhao et al., 2022a) and multi-object tracking in computer vision (Brendel et al., 2011).
The MWDS problem is encountered in wireless network clustering (Shahraki et al., 2020).
Multicast routing in communication networks involves the NWST problem (Sun et al., 2020).
The MWCDS problem can establish a virtual backbone network in wireless multihop networks, that covers all the nodes with the lowest cost in energy consumption or security vulnerability (Oliveira et al., 2011). We refer the readers to
Appendix E for more detailed descriptions of the aforementioned applications.
[Figure]
r o x [Figure]
a t i o
[Figure]
t .
[Figure]
p t i m
[Figure]
l
[Figure] [Figure] [Figure]
L o c a l
C o mm un i c a t i o n C o m p l e x i t y
[Figure]
[Figure]
We develop four similar ML pipelines respectively for the four R-COPs, in which the actor and twin networks are implemented by L -layer and 5-layer GCNNs, respectively, the baseline heuristics h ( · ) in (5c) are selected as centralized or distributed greedy solvers. The details of the four ML pipelines are in Appendix D for the equations of GCNN, Appendix C for the detailed training configurations, and Appendix G for the hyperparameters of GCNNs and brief descriptions of the chosen baseline heuristics.
We aim to demonstrate the effectiveness of our proposed learning framework in closing the optimality gaps of some widely used fast heuristics for R-COPs, at the cost of negligible overhead, e.g., an additional computational complexity of O
( L |E| /N ) or local communication complexity of O ( L/N ) per instance on sparse graphs.
We do not claim smaller optimality gaps than the state-of-theart (slower and centralized) heuristics, nor that GCNN is the best candidate graph neural architecture for these problems.
An appealing characteristic of our framework is its modularity, which allows the
GCNNs being replaced by any other (non-convolutional)
GNN while our approach is still valid.
The four COPs are widely applied in various wireless networks, involving graphs of up to hundreds of nodes, and restricted runtimes from tens of milliseconds to a few seconds.
Due to the dynamic nature and the lack of real-world datasets of wireless network topologies, we follow the norm of wireless research by running our experiments on four sets of synthetic random graphs: Erd˝os–Rényi (ER) (Erd˝os & Rényi, 1959), Barabási–Albert (BA) (Albert & Barabási, 2002), Gaussian Random Partition (GRP), and connected Watts-Strogatz small-world (WS) graphs.
Each test dataset containsrandom graphs generated by a graph model with parameters detailed in Appendix E.
The optimality of a heuristic is evaluated by the average approximation ratio, E Ω ′ ( c ⊤ x ( h ) /
c ⊤ x ( b ) ) , on a test set Ω ′ , where x ( h ) and x ( b ) are respectively the solutions from the heuristic of interests and a reference algorithm.
Only in MWIS, the optimal solutions from (Zhao et al., 2022a) are used as reference, in other COPs, greedy heuristics are the references.
MWIS:
An independent (vertex) set for a graph is a subset of vertices not connected by any edges.
The MWIS problem is to find an independent set on a vertex weighted graph that maximizes the total weight.
The baseline heuristic is a distributed local greedy solver (LGS-MWIS)
(Joo & Shroff, 2012), with a local communication complexity of O (log |V| ) .
We test multiple distributed MWIS solvers, including the GCNN-enhanced and vanilla LGS-MWIS, and a message passing (MP) algorithm
[Figure]
[Figure]
(Paschalidis et al., 2015) on a set of 500 random ER graphs from (Zhao et al., 2022a).
3 GCNNs are respectively trained by ad hoc RL (Zhao et al., 2022a), GDPG-Twin, and ZOO (Liu et al., 2020), on a set of 6000 ER graphs.
The approximation ratios of the tested solvers w.r.t.
the optimal solver are shown in Figure 1.
GDPG-Twin ( 93 . 1% ) works equally well as the ad hoc RL ( 93 . 2% ), and slightly outperforms ZOO ( 92 . 7% ) with only 1 / 3 to 1 / 2 evaluations of f net ( · ; Z ) (see Section 4.3).
The GCNN can reduce the optimality gap of LGS-MWIS ( 89 . 7% ) by 1 / 3 , beating the MP algorithm ( 90 . 7% ).
Figure 3 shows that GCNN-enhanced and vanilla LGS-MWIS converge in 3 ∼ 4 rounds in this test (MP algorithm converges in 2 |V| rounds), where the former is slightly faster for a large N .
MWDS:
A dominating set for a graph G =
( V , E ) is a subset D of V such that every vertex not in
D is adjacent to at least one member of D .
In the MWDS problem, every node is associated with a non-negative weight, and the objective is to find a dominating set of minimum total weight.
The baseline heuristic is a centralized greedy algorithm, Greedy-MWDS, as detailed in Appendix G.
The approximation ratio of the GCNN-enhanced Greedy-MWDS w.r.t.
the vanilla Greedy-MWDS on the 4 sets of random graphs described earlier, are shown in Figure 2.
On average, GCNN improves the performance of Greedy-MWDS by 11 .
42% on BA graphs, 6 . 8% on ER graphs, 3 . 0% on GRP graphs, and 2 .
6% on WS graphs.
The improvement is more pronounced on larger graphs.
As shown in Figure 4, the average runtime of the GCNN-enhanced Greedy-MWDS on a laptop of 4 CPUs
no
GPU (detailed in Appendix H) ranges from 32 to 78 milliseconds per instance, and is linear to the graph size, which can be further cut to 2-17 milliseconds for a large reusing factor N .
NWST:
In the NWST problem, we are given an undirected graph G with node cost (non-negative weight) and a subset of nodes called terminals.
The goal is to find a minimum cost subgraph of G that connects the terminals.
In the test, the terminals are selected by randomly removing 10% ∼ 50% nodes from a maximal independent set (MIS) on the graph.
The baseline heuristic is a distributed greedy algorithm, Kruskal’s shortest path heuristic (K-SPH-NWST)
(Matsuyama, 1980; Bauer &
Varma, 1996).
The approximation ratio of the GCNN-enhanced K-SPH-NWST w.r.t.
the vanilla
K-SPH-NWST on the 4 sets of random graphs, are shown in Figure 5.
GCNN can improve K-SPHNWST by 6 . 8% on BA graphs, 1 . 2% on GRP graphs, 1 . 4% on ER graphs, 0 .
9% on WS graphs, and 0 .
9% on a real-world dataset of Internet backbone topology (Knight et al., 2011) with |V| = 31 .on average.
The noticeable gain on BA graphs is meaningful to large real-world networks, such as the Internet, World Wide Web, and social networks (Posfai & Barabasi, 2016, Ch. 5).
MWCDS:
In MWCDS problem, we are given an undirected and connected graph, and our goal is to find a minimum weighted dominating set that is connected.
Our baseline heuristic is a distributed greedy algorithm (Dist.
Greedy), whereas the reference algorithm is a centralized greedy heuristic.
Both MWCDS heuristics are implemented in two steps (Sun et al., 2019): 1) find a MWDS, 2) connect the MWDS by solving a NWST problem where the terminals are the solution of step 1.
The approximation ratios of the vanilla and GCNN-enhanced distributed heuristics w.r.t.
the centralized greedy heuristic on 4 sets of random graphs, each with 2000 graphs, are shown in Figure 6.
Despite the large gap between distributed and centralized greedy algorithms, GCNN can improve the distributed greedy by 17 . 8% on GRP graphs, 16 . 0% on ER graphs, 6 . 6% on WS graphs, and 4 . 0% on BA graphs.
The average centralized runtimes of GCNN-enhanced distributed solvers for the MWIS, NWST,
MWCDS problems are respectively 0 .
017 ∼ 0 .
07 ∼ 1 . 5 , 0 .
08 ∼ 2 . 0 seconds per instance, as
[Figure] [Figure]
reported in Appendix H, along with their estimated computational time (not the execution time) in distributed execution, as less than 0 .
18 , 5 . 1 , and 5 . 8 milliseconds, respectively [Figure]
4. R EPETITIVE MWIS IN A G RAPH - BASED M ARKOV D ECISION P ROCESS
GDPG-Twin for R-COP in a graph-based MDP is demonstrated through the delay-oriented distributed link scheduling in (Zhao et al., 2022b), in which the distributed scheduler contains a 1-layer GCNN and LGS, and the twin is a 5-layer GCNN.
The state feature S ( t ) =
q ( t ) ⊙ l ( t ) , where q ( t ) captures the queue lengths on wireless links (nodes in conflict graph), and l ( t ) captures the link rates.
The state transition in (4f) is based on q ( t + 1) =
q ( t ) + a ( t ) − min( q ( t ) , l ( t ) ⊙ x ( t )) , where a ( t ) captures random packets arrivals, and x ( t ) ∈ { 0 , 1 } |V| captures scheduling decisions.
The objective is to minimize the average backlog, E i ∈V ,t ≤ T [ q i ( t )] .
As shown in Figure 7, two distributed schedulers respectively trained by 5-step lookahead RL (Zhao et al., 2022b) and GDPG-Twin achieve similar performance in terms of the mean and median backlogs on conflict graphs with different levels of centralization, as indicated by the number on the x-axis.
However, GPDG-Twin is 5 times faster than lookahead RL, as the former needs only 2 evaluations of h ( · ) per t , whereas the latter needs 10.
4. C OMPARISON WITH ZEROTH - ORDER OPTIMIZATION
The trajectories of relative performances of GCNN-enhanced LGS-MWIS (as detailed in Section 4.1) w.r.t.
vanilla LGS-MWIS, under different training methods, are illustrated in Figure 8, where x-axis is the number of evaluations of the non-differentiable h ( · ) (LGS-MWIS).
Each point on the curve is the average value of 100 instances.
During training, random weights are generated on-the-fly for a training graph, whereas the weights on a validation graph are unchanged.
GDPG-Twin and ZOO are configured with the same sampling radius and learning rate.
GDPG-Twin converges within only 1 / 3 to/ 2 evaluations of h ( · ) required by the fastest ZOO based on 2-point gradient estimation.
This result shows that GDPG-twin has a better sampling efficiency than ZOO, by a factor of 2 to 3.
C ONCLUSION
We address repetitive combinatorial optimization problems under practical restrictions in runtime and/or distributed execution, by introducing a non-differentiable policy network based on a hand-picked, fast and/or distributed heuristic, which is parameterized by a continuous-valued highdimensional intermediate action from an actor GNN.
The actor GNN is optimized by graph-based deterministic policy gradient with the help of a critic based on a twin network that can predict the node-wise expected outcomes of the policy network.
Through 5 examples, we demonstrate that our approach can: 1) leverage the shared underlying topology of independent R-COPs, to reduce the average optimality gap of the fast and/or distributed heuristics, and 2) optimize the long-term objectives for R-COPs in a graph-based Markov decision process.
In terms of limitations, our work has not addressed the variance and worst-case of the optimality gap, which are important for many real-world applications.
Our evaluation is based on synthetic rather than real-world graphs.
Moreover, the actor and critic networks in our framework would need further design for broader tasks, e.g., edge related R-COPs.
In addition, we do not expect our work to have any impact on social equality.
A A PPENDIX : SGD FOR TWIN NETWORK IN INDEPENDENT REPETITIVE COP S
Give MSE loss,
[Equation]
the partial derivative of ℓ mse (ˆ o , o ) w.r.t.
the parameters of the twin network is
[Equation]
where from (14b) to (14c) is based on the linearity of expectation.
Based on (14c), by drawing c ∼ Ω c , we have the following unbiased stochastic gradient estimation:
[Equation]
where
[Equation]
Therefore, the stochastic gradient estimation for the parameters of the twin network is
[Equation]
B A PPENDIX : SGD FOR TWIN NETWORK IN R-COP S IN G RAPH - BASED MDP
We define a return vector supported on the nodes of the graph as
[Equation] [Equation]
which can be expressed in a recursive form
[Equation]
g ( t ) = 0 , ∀ t > T . [Equation]
[Equation]
The outcome (value) vector of state G ( t ) is the expected return vector under policy Θ p ,
[Equation]
The gradient ∇ Θ c ℓ mse (ˆ o ( t ) , o ( t )) can be found by the following partial derivative
[Equation]
where from (21b) to (21c) is based on the linearity of expectation, and that ˆ o ( t ) is a function of G ( t ) , generated by the twin network, as defined in (12).
Based on (19), we have the following unbiased estimation of the partial derivative in (21a)
[Equation]
where
[Equation]
In (23b), r ( t ) is the reward vector collected under current state G ( t ) , as defined in (10c), and g ( t + 1) |G
( t ) is the return of the next state G ( t + 1) , evolved from the current state G ( t ) according to (10f).
The return of the next state G ( t + 1) is estimated as g ( t + 1)
≈ ˆ
o
( t + 1) by the twin network, as defined in (12).
As a result, we have the following approximation
[Equation]
Plugging (24) to (23b), we have
[Equation]
Therefore, the stochastic gradient estimation for the parameters of the twin network is
[Equation]
C A PPENDIX : P ROCEDURES OF GDPG-T WIN
Input : Ω c , Ω G , h ( · ) , α p , α c , E, B, ϵ
Output : Z or Θ p , Θ c 1: Initialize Z or Θ p , Θ c randomly or as pretrained models, ¯ c = E Ω c ( c ) 2: for e ∈ { 1 , 2 , . .
, E } do 3:
Q p = ∅ , Q c = ∅ /* Clear gradient buffers */ 4: for b ∈ { 1 , . . .
, B } do 5:
Draw G ( V , E ) ∈ Ω G , c ∈ Ω c /* Draw data from training dataset or target distribution */ 6: if Actor network is used then 7:
Z = Ψ( V , E , ¯ c ; Θ p ) 8: end if 9:
Z ( j ) =
Z + N ( j ) , N ( j ) ∈ U ( − ϵ, ϵ ) /
* Random policy sampling */ 10: ˆ o =
f twin ( V , E , ¯ c , Z ( j ) ;
Θ ∗ c ) 11: x = f net ( V , E , c ; Z ( j ) ) based on h ( · ) in (5c) and f loc ( · ) in (5d) 12:
Estimate gradient ∇ Θ c ℓ mse (ˆ o , c ⊙ x ) for critic 13:
Q c ← Q c ∪ {∇ Θ c ℓ mse (ˆ o , c ⊙ x ) } 14:
Estimate policy gradient ∇ Z 1 ⊤ ˆ o based on (7) 15: if Actor network is used then 16:
Estimate gradient ∇ Θ p 1 ⊤ ˆ o = ∇ Θ p Ψ( V , E , ¯ c ; Θ p ) ∇ Z 1 ⊤ ˆ o for actor 17:
Q p ← Q p ∪ {∇ Θ p 1 ⊤ ˆ o } 18: else 19:
Q p ← Q p ∪ {∇ Z 1 ⊤ ˆ o } 20: end if 21: end for 22:
Θ c ← Θ c − α c E Q c [ ∇ Θ c ℓ mse (ˆ o , c ⊙ x )] 23:
Z ← Z − α p E Q c (cid:0) ∇ Z 1 ⊤ ˆ o (cid:1) or Θ p ← Θ p − α p E Q p (cid:0) ∇ Θ p 1 ⊤ ˆ o (cid:1) 24: end for 25: Output Z or Θ p , Θ c
For the four demonstrated R-COPs with independent instances, we set the hyperparameters of training procedure in Algorithm 1 as follows: α p = α c = 0 . 0001 , E = 25 , B = 100 , ϵ = 0 . 15 .
Input : Ω c , Ω G , h ( · ) , α p , α c , T, E
Output : Θ p , Θ c 1: Initialize Θ p , Θ c randomly or as pretrained models 2: for e ∈ { 1 , 2 , . . .
, E } do 3:
Q e = ∅ , Q p = ∅ , Q c = ∅ /* Clear experience & gradient buffers */ 4:
Initialize state G (0) =
( V (0) , E (0) , S (0)) 5: for t ∈ { 0 , . .
, T } do 6: c ( t ) =
Ψ( V ( t ) , E ( t ) , S ( t ); Θ p ) 7: ˆ o ( t ) =
f twin ( V ( t ) , E ( t ) , S ( t ) , c ( t );
Θ ∗ c ) 8:
Obtain decision vector x ( t ) based on (10d) 9:
Observe reward vector r ( t ) according to (10c) 10:
Update state feature S ( t + 1) according to (10f) 11:
Estimate stochastic policy gradient ∇ Θ p f obj (ˆ o ( t )) based on (11) 12:
Q p ← Q p ∪ {∇ Θ p
f
obj
(ˆ o ( t )) } 13:
Q e ← Q e ∪ { < r ( t ) , ˆ o ( t ) > } 14: end for 15: for t ∈ { 0 , . .
, T } do 16:
Fetch r ( t ) , ˆ o ( t ) , ˆ o ( t + 1) from Q e 17:
Estimate stochastic gradient ∇ Θ c ℓ mse (ˆ o ( t ) , r ( t )
+ γ
ˆ o ( t + 1))
for critic 18:
Q c ← Q c ∪ {∇ Θ c ℓ mse (ˆ o ( t ) , r ( t ) + γ ˆ o ( t + 1)) } 19: end for 20: Θ c ← Θ c − α c E Q c [ ∇ Θ c ℓ mse (ˆ o ( t ) , r ( t )
+ γ
ˆ o ( t + 1))
] 21: Θ p ← Θ p + α p E Q p (cid:2) ∇ Θ p f obj
(ˆ o ( t )) (cid:3) /
* Objective maximization */ 22: end for 23: Output Θ p , Θ c
For the demonstrated delay-oriented link scheduling (Zhao et al., 2022b), we use the following hyperparameters in training described in Algorithm 2: α p = α c = 0 . 0001 , T = 64 , E = 200 .
The types and mixture of the training graphs, random processes, etc., are identical to (Zhao et al., 2022b).
D A PPENDIX : G RAPH CONVOLUTIONAL NEURAL NETWORKS
An L -layer GCNN is implemented as follows:
Given the input feature S (0) =
S supported on a graph
G , the output is Z = S ( L ) =
f GCN ( G , S ; Θ ) , where an intermediate l th layer of the GCNN is
[Equation]
In (27), L is the normalized Laplacian of graph G , Θ l 0 , Θ l 1 ∈ R g l − 1 × g l are the trainable parameters, g l − 1 and g l are the dimensions of the output features of layers l − 1 and l , respectively, and σ l ( . ) is an element-wise activation function.
In a distributed system, (27) can be implemented by the following local operation on node v ∈ V , [Equation]
[Equation]
where S lv ∗ ∈ R 1 × g l is the v th row of matrix S l , which captures the features on node v , d ( v ) is the degree of node v , and N ( v ) is the set of neighboring nodes of node v .
E A PPENDIX : C ONFIGURATIONS OF RANDOM GRAPHS FOR TRAINING AND TESTING
p ∈ U (0 . 15 , 0 . 35) , k ∈
⌊ U (10 , 30) ⌉ .
Training graph size |V| ∈ { 100 , 150 , 200 , 250 , 300 } .
Testing graph size |V| ∈ { 100 , 150 , 200 , 250 , 300 , 350 , 400 , 450 , 500 } (varies by problem).
ER: size |V| , edge probability |V| / k .
BA: size |V| , number of edges to attach from a new node to existing nodes m =
⌊ pk ⌉ .
WS: size |V| , each node is joined with its k nearest neighbors in a ring topology, p : the probability of rewiring each edge.
GRP: size |V| , mean cluster size k , shape parameter min(7 , k ) , probability of intra-cluster connection p , probability of inter cluster connection max(0 .
1 , p / 3 ) .
For MWIS problem in Section 4.1, the test set of 500 ER graphs and the corresponding optimal solutions are from https://github.com/zhongyuanzhao/distgcn (Zhao et al., 2022a). F A PPENDIX : A PPLICATIONS OF THE FOUR EXEMPLARY R-COP S F. MWIS IN SCHEDULING AND COMPUTER VISION
Definition: An independent (vertex) set for a graph is a subset of vertices not connected by any edges.
The MWIS problem is to find an independent set on a vertex weighted graph that maximizes the total weight.
MWIS for wireless scheduling: MWIS can be applied to link scheduling in wireless multihop networks with orthogonal multiple access (Joo & Shroff, 2012; Zhao et al., 2022a). In a wireless multihop network, a wireless link refers to a pair of nearby wireless transceivers that can directly talk to each other. In orthogonal multiple access, two links would conflict with each other if they share the same transceiver (which can only be tuned to one link at a time), or they would block out each other if activated simultaneously (e.g., any transceiver(s) of a link are located too close to any transceiver(s) of the other link to interfere the reception of wireless signal). In each time slot, a link scheduler (Max-Weight scheduler) would determine a set of non-interfering links to be activated, so that it would maximize the total utility of the wireless network.
Max-Weight scheduling is essentially finding a MWIS on the conflict graph of the wireless network, which is defined as follows: each vertex in the conflict graph is a link in the wireless network, and an edge captures the conflict relationship between two links.
For example, with a per-link utility function based on the length of backlogged data packets of each link, Max-Weight scheduling can achieve the maximum throughput (the amount of data packets transmitted in a time slot) of the wireless network.
The typical length of a time slot in various wireless communication protocols ranges from 1 ∼ 100 milliseconds, which means that a
Max-Weight scheduler needs to solve an MWIS instance every 1 ∼ 100 milliseconds.
Meanwhile, the topology of the conflict graph in wireless scheduling (determined by the topology of the wireless networks and physical locations of transceivers) evolves at much lower pace, such as seconds to minutes for mobile wireless networks, or remain the same if all the transceivers (such as microwave towers and wireless sensors) are static.
Graph coloring problems are also applied to wireless scheduling, especially, multi-channel wireless scheduling.
The conflict graph is formulated similarly in the previous single-channel scheduling, but instead of finding a MWIS, each node in the conflict graph (link in the wireless network) is assigned a color representing a particular channel, so that neighboring nodes (conflicting links) will never have the same color (channel).
In Cornaz et al.
(2017), the four types of graph coloring problems: Vertex coloring problem (VCP), equitable vertex coloring problem (ECP), Max-coloring (Max-Col) which can be seen as the weighted version of VCP, and Bin Packing Problem with Conflict (BPPC), can be converted to solving MWIS on an associated graph.
MWIS for multiobject tracking in computer vision:
In multiobject tracking (Brendel et al., 2011), a detector first identifies a set of objects in a video frame, records the following properties of the corresponding bounding box of each object: location, size, the histograms of color, intensity gradients, and optical flow.
Next, the detected objects across different video frames needs to be linked according to their properties to maintain their unique identities.
The second step is formulated as finding a MWIS on a graph, in which nodes represent candidate matches (of two objects) from every two consecutive frames, referred as tracklets; node weights encode the similarity of the corresponding matches; and edges connect nodes whose corresponding tracklets violate the hard constraints that no two matches share the same object.
If there are 10 objects in each of the two consecutive frames, there would be 100 tracklets.
The MWIS on such a graph is a set of matches that maximize the total similarities of tracklets, resulting in the most plausible tracking of multiple objects.
In this formulation, a MWIS instance needs to be solved every video frame (24, 30 frames per second), while the topology of the graphs of consecutive MWIS instances would be similar since consecutive frames in a typical video stream would remain similar.
F. MWDS IN WIRELESS SENSOR NETWORKS AND COVERING CODES
Definition: A dominating set for a graph G = ( V , E ) is a subset D of V such that every vertex not in D is adjacent to at least one member of D .
In the MWDS problem, every node is associated with a non-negative weight, and the objective is to find a dominating set of minimum total weight.
MWDS for clustering in wireless sensor networks: Wireless sensor networks are a type of ad-hoc network for monitoring purposes.
It usually include a large number of sensor nodes, which are resource-constrained (such as battery power), but can connect to other nodes of the network for transmitting sensed data.
Each node can also forward data from neighbors to the sink (or gateway, base station, server, etc.)
(Shahraki et al., 2020).
Clustering is one of the most popular techniques for the topology management of wireless sensor networks .
It organizes sensor nodes into a set of groups called clusters, each cluster has one or more cluster heads which gathers data from other members of the cluster and send the (fused) data to the sink directly or indirectly.
Using clustering techniques, resource-constrained sensor nodes do not need to send their data to the sink directly, which can cause energy depletion, resource consumption inefficiency and interference.
Clustering can be formulated as MWDS problem, where the cluster heads form a dominating set so that the rest of the sensor nodes can directly reach at least one cluster head.
By defining the node weight as the cost of being a cluster head, MWDS can minimize the total cost of wireless sensor networks, such as energy consumption or quality of service.
To maximize the lifetime of the wireless sensor network, it may need to select a different set of cluster heads once in a while to avoid draining the battery of cluster heads.
The node weight would change based on the battery levels of the sensor nodes.
F. NWST FOR MULTICAST ROUTING IN WIRELESS NETWORKS
Definition:
In the NWST problem, we are given an undirected graph G with node cost (non-negative weight) and a subset of nodes called terminals.
The goal is to find a minimum cost subgraph of G that connects the terminals.
NWST in multicast routing:
A multicast route is a network route that connects more than two nodes at the same time (Oliveira et al., 2011).
Multicast routing is applicable to networking scenarios where data needs to be shared by a group of users, such as a software company sends out a security patch to the computers across the Internet installed with its software, or a company pushes a notification to the smart phones installed with its mobile app.
In these example, the Internet would be the graph, the server and the recipients are defined as the terminals in the Steiner tree problem, and the non-terminal nodes are the routers, gateways, and other computers on the Internet.
Multicast routing in wireless multihop networks can be formulated as node weighted Steiner tree (NWST) problem (Sun et al., 2020).
The graph models the network, e.g., a node represents a wireless device and an edge represents a link between two wireless devices.
The terminals in the NWST are the subset of wireless devices that need to connected with each other, and the non-terminal nodes are the rest of the wireless devices in the network.
The node weight captures the cost of a non-terminal node relaying packets, such as the consumption of energy, bandwidth, and/or CPU load.
By formulating the multicast routing as a NWST, we can connect all the terminals at minimal total cost.
Whenever there is a request to establish a multicast route, a NWST problem in the network needs to be solved.
In medium to large-scale wireless networks, distributed algorithms are always preferred since it does not require a centralized coordinator to collect the real-time network state and compute the solution.
F. MWCDS IN MOBILE AD - HOC NETWORKS
Definition:
In MWCDS problem, we are given an undirected connected graph, and our goal is to find a minimum weighted dominating set that is connected.
MWCDS for virtual backbone computation:
In mobile ad-hoc networks, a virtual backbone is a set of nodes that can be used to take routing decisions and that act as proxies for routing packets (Oliveira et al., 2011).
It can reduce the amount of routing information shared among nodes of the system, by requiring only a subset of nodes to be actively involved in routing decisions.
Formally, we would define the mobile ad-hoc network as a undirected graph, in which each node represents a mobile device, and each edge represents a link between two mobile devices.
A virtual backbone needs to a connected subgraph so that packets from one node can always reach to another node in the virtual backbone.
A node in the network needs to be either a member of the virtual backbone or adjacent to at least one member of the virtual backbone, so that it can reach to the rest of the network. Therefore, a virtual backbone needs to be a dominating set of the graph. Moreover, since members of the virtual backbone take the responsibility of routing, which comes with extra cost in battery power consumption and routing packets, we want to minimize the total cost of implementing a virtual backbone. Therefore, the computation of a virtual backbone is to find the minimum weighted connected dominating set of the network.
The virtual backbone in mobile ad-hoc networks needs to be re-established after a while, in order to adapt to the changing traffic conditions, network topology, as well as the battery levels of the mobile devices. The network topology may change slowly, whereas the battery levels of mobile devices and traffic conditions may change more frequently. Re-establishing the virtual backbone once a while could avoid draining the batteries of the members of the virtual backbone. Moreover, virtual backbone computation requires distributed algorithm to find the MWCDS, since there is no server or base-station in mobile ad-hoc network to perform such computation.
G A PPENDIX : ML PIPELINES AND BASELINE HEURISTICS G. MWIS PIPELINE
We adopt the GCN-LGS pipeline in (Zhao et al., 2022a) as the actor network, which comprises a 3-layer GCNN followed by a distributed local greedy solver (LGS-MWIS)
(Joo & Shroff, 2012).
The actor GCNN is {+configured as follows: the dimensions of GCNN layers are g l = 32 , l = 1 , 2 , and g 
 = g 3 = 1 , the hidden layers employ leaky ReLU activation, while the output layer ReLU activation.+}
The GCNN outputs vector c ∈ R |V| .
The local function in (5d) is instantiated as a multiplier, f loc ( c i , z i ) =
c i z i .
The twin network is implemented by a 5-layer GCNN, in which the hidden layers have dimensions of g l = 64 , l = 1 , . .
, 4 and leaky ReLU activation, and the output layer has a dimension of g 5 = 2 and Softmax activation.
The training takes about an hour on a server with 16 GB memory, 8 CPUs and 1 GPU (Nvidia 1080 Ti).
The basic greedy heuristic first sorts the nodes by their weight in decreasing order, then iteratively adds a node to the solution and removes the node and its neighbors from the sorted list, until the list is empty.
The distributed heuristic LGS-MWIS (Joo & Shroff, 2012) iteratively builds a solution as follows: in an iteration, each node compares its weight with its neighbors; if a node has the maximal weight in the neighborhood, it marks itself as 1, and broadcasts a control message to its neighbors, who then mark themselves as -1; the unmarked nodes enter the next iteration.
When all nodes are marked, the solution is the set of nodes marked as 1.
LGS-MWIS has an average local communication complexity of O (log |V| ) on general graphs.
The centralized greedy algorithm and LGS-MWIS are detailed in (Zhao et al., 2022a, Algo 1 and Appendix Algo 1).
For MWIS problem in Section 4.1, the test set of 500 ER graphs and the corresponding optimal solutions are from https://github.com/zhongyuanzhao/distgcn (Zhao et al., 2022a).
G. MWDS PIPELINE AND G REEDY -MWIDS
We augment Greedy-MWDS with a 5-layer actor GCNN and the same local function in the MWIS pipeline in Appendix G.1.
The actor GCNN is configured as follows: the input and hidden layers have dimensions of g l = 32 , l = 1 , . .
. , 4 and leaky ReLU activations, the input and output dimensions are g 0 = g 5 = 1 , and the output layer employs ReLU activation.
The twin is also implemented by a 5-layer GCNN configured the same as the twin GCNN in the MWIS pipeline in Appendix G.1, except that g l = 32 , l = 1 , . . .
The GCNN is trained on randomly generated ER graphs of 100 to 300 nodes.
The training takes about an hour on a server with 16 GB memory, 8 CPUs and 1 GPU (Nvidia 1080 Ti)
The greedy algorithm, Greedy-MWDS, iteratively builds a solution by adding to the solution the most cost-effective node from the vertices not yet in the solution, marking its neighbors as covered, until all nodes are either in the solution or covered.
A good metric for the cost-effectiveness of node v ∈ V is (Jovanovic et al., 2010):
[Equation]
where smaller ω ( v ) means better cost-effectiveness, c ( v ) is the weight of node v , D ′ is the partial solution (initialized as ∅ ), N ( · ) refers to the neighbors of a node or a vertex set, W ′ is the set of uncovered nodes.
An alternative greedy algorithm (Greedy-MWIDS) selects the most cost-effective node only from the uncovered vertices in each iteration, which builds an independent dominating set (IDS).
GreedyMWIDS can be implemented by the distributed LGS-MWIS (Joo & Shroff, 2012), and is used as part of the distributed heuristic for the MWCDS problem in Appendix G.4.
G. NWST PIPELINE AND BASELINE HEURISTICS
The actor, twin, and local function are configured the same as in the MWDS pipeline in Appendix G.2.
The input node feature for the actor and twin GCNNs is one-hot encoded indicator of whether a node is a terminal.
The GCNNs are trained on randomly generated GRP graphs with 100 to 300 nodes.
The training takes about 5 hours on a server with 16 GB memory, 8 CPUs and 1 GPU (Nvidia Ti).
Shortest path heuristic (SPH) (Matsuyama, 1980) initializes the terminals as a set of subtrees; starting from an arbitrary subtree, it iteratively merges with its nearest subtree through the shortest path.
The distance of a path is the total cost of nodes on it, where terminals have zero cost.
The algorithm terminates when only one tree is left.
The shortest path is found by Dijkstra’s algorithm (Dijkstra et al., 1959).
Kruskal’s SPH (Bauer & Varma, 1996)
(K-SPH) is a distributed variation of SPH, in which every subtree merges with its nearest subtree until only one tree is left.
SPH has an approximation ratio of 2 (Matsuyama, 1980).
G. MWCDS PIPELINE , BASELINE AND REFERENCE HEURISTICS
A low complexity heuristic for MWCDS problem (Sun et al., 2019) can be implemented in two steps: 1) find a MWDS, 2) connect the MWDS by solving a NWST problem where the terminals are the solution of step 1.
In our baseline heuristic, we choose Greedy-MWIDS in Appendix G.2 for step 1, and K-SPH-NWST in Appendix G.3 for step 2, and treat them as a single distributed greedy heuristic (Dist.
Greedy).
Our reference algorithm is a centralized greedy heuristic, composed of Greedy-MWDS in Appendix G.2 for step 1 and SPH-NWST in Appendix G.3 for step 2.
The actor GCNN is configured as follows: the input and hidden layers have dimensions of g l = 32 , l = 1 , . .
{+. , 4 and leaky ReLU activations, the input and output dimensions are g 
+}
= 1 , g 5 = 2 , and the output layer employs linear activation. The actor outputs Z ∈ R |V|× 2 , and the local function is a single neuron, f loc ( c i , Z i ∗ ) =
ReLU ( Z i, 1 c
i + Z i, 2 ) .
The twin network is implemented by a 5-layer
GCNN with identical configuration in Appendices G.2 and G.3, except that its input dimension fits the output dimension of its own actor GCNN.
The GCNN is trained on GRP graphs of 100 tonodes.
The training takes about 8 hours on a server with 16 GB memory, 8 CPUs and 1 GPU (Nvidia 1080 Ti).
H A PPENDIX : C ENTRALIZED RUNTIME IN SECONDS
We report the actual runtime of GCNN-enhanced COP solvers demonstrated in Section 4, measured on a laptop computer (Macbook Pro, 16GB memory, 2 GHz Quad-Core Intel Core i5, CPU only).
It should be noted that these runtimes are based on our Python code, of which the implementation could be further optimized for running speed.
For the examples demonstrated by distributed COP solvers, the centralized runtime does not represent their distributed runtime.
Therefore, we report both the total centralized runtime and the per-node centralized runtime for each distributed solver.
The latter represents the estimated computational time in distributed execution.
However, the major component of distributed runtime for distributed solvers is the communication time rather than the computational time, which could not be measured in our setting.
In general, the GCNN no longer dominate the total runtime for these distributed COP solvers.
For MWIS in Figure 9(a) and 9(b), the centralized runtime of distributed COP solvers are still linear to the graph size.
For NWST (Figures 10(a) and 10(b)) and MWCDS (Figures 11(a) and 11(b)), the major component of the centralized runtime is Dijkstra’s algorithm for the shortest path, which has a time complexity of O ( |V| 2 ) or O (( |V| + |E| ) log |V| ) .
[Figure] [Figure]
z e d r un t i m e p e r n o d e ( s )
[Figure] [Figure]