Neural Coarsening Process for Multi-level Graph Combinatorial Optimization
Abstract
Combinatorial optimization (CO) is applicable to various industrial fields, but solving CO problems is usually NP -hard.
Thus, previous studies have focused on designing heuristics to solve CO within a reasonable time.
Recent advances in deep learning show the potential to automate the designing process of CO solvers by leveraging the powerful representation capability of deep neural networks.
Practically, solving CO is often cast as a multi-level process; the lower-level CO problems are solved repeatedly so as to solve the upper-level CO problem.
In this case, the number of iterations within the lower-level process can dramatically impact the overall process.
This paper proposes a new graph learning method, Neural Coarsening Process (NCP), to reduce the number of graph neural network inferences for lower-level CO problems.
Experimental results show that NCP effectively reduces the number of inferences as compared to fully sequential decision-making.
Furthermore, NCP outperforms competitive heuristics on CVRP-CapacityCut, a subproblem of the cutting plane method for the capacitated vehicle routing problem (CVRP).
Introduction
Combinatorial optimization (CO) is a research area that is related to discrete mathematics, computational theory and operations research.
CO aims to find a combination of variables that minimizes the cost function (or maximize the objective function), and is applicable to various fields, including bio-synthesis [1], logistics [2] and job scheduling in the manufacturing industry [3].
Many CO problems are naturally defined on graphs, such as the maximum independent set (MIS), maximum-cut (MAX-CUT), and traveling salesman problem (TSP).
We refer to such CO problems as graph CO .
As CO problems are generally NP -hard and intractable to solve within a limited time budget, early studies have focused on designing heuristics that generate near-optimal solutions within a reasonable time [4, 5].
Advances in deep learning relieve the reliance of CO on human-designed heuristics and problemspecific domain knowledge.
The deep learning methods utilize a deep neural network (DNN) to learn the patterns of the combinatorial optimization.
As deep learning automates the design process of the CO solvers via data-driven learning techniques, it overcomes the task expandability problem of the handcrafted heuristic methods.
Recent studies that have used deep learning to solve graph CO problems have shown notable improvements in solution qualities and computational speeds [6, 7, 8].
Deep learning can be employed to solve CO problems by learning an end-to-end approach that maps the problem input to the solution output.
End-to-end approaches have been widely explored, especially in sequential decision-making fashions [6, 9, 10, 7, 8, 11, 12, 13, 14].
These approaches leverage Recurrent Neural Network [6, 9, 10, 12], Transformer [8], and Graph Neural Network (GNN) [7, 14].
Deep learning can also be employed to solve CO problems by combining deep learning approaches with existing algorithms.
For example, exact algorithms, such as the branch-and-bound and cutting plane method, can be strengthened using deep learning approaches [15, 16, 17, 18, 19, 20].
In this case, the CO problems are often tackled using a multi-level process, where the upper-level process (i.e., the main algorithm) calls the lower-level process (i.e., subroutine) to solve the main problem.
Fig.shows the hierarchical structure of a CO algorithm whose subroutines solve subproblems, usually CO problems, derived from the main algorithm.
The main algorithm frequently calls subroutines.
Thus, when one of the subroutines is replaced with deep learning-based methods, improving the subroutines can significantly impact the overall process.
[Figure]
We propose the Neural Coarsening Process (NCP), a graph learning scheme, to solve subCO problems.
NCP employs a graph coarsening procedure that iteratively reduces the size of the graph to handle combinatorial nature.
Specifically, we coarsen the graphs that has N number of nodes with the ratio γ based on the node class prediction, predict the node classes again on the coarsened graph, and then apply a simple rounding on the coarsest graph to make the final decision.
The number of iterations 2 for NCP is hence O (log N ) as we coarsen a graph with N number of nodes.
We evaluate the performances of NCP on CVRP-CapacityCut , which is the subproblem of the cutting plane method for the capacitated vehicle routing problems (CVRPs) [21].
CVRP-CapacityCut is a minimum-cut (MIN-CUT) problem on weighted graphs with constraints.
We show that NCP performs better than fully auto-regressive method and a competitive heuristic in a large-sized CVRPCapacityCut with limited number of iterations.
Related Works
Various works have attempted the graph CO problems by leveraging GNN with sequential decisionmaking [7, 22, 14, 23].
[7] proposed the Structure2Vec Deep Q-learning (S2V-DQN), a graph embedding-based reinforcement learning, which shows tremendous performance on various graph
CO tasks despite requiring O ( N ) decision-making steps to terminate the Markov Decision Process ( N is the number of nodes).
[23] proposed a transformer-based model with an edge weight matrix, which require complex computation to process O ( N 2 ) scale of fully connected edges.
Some researchers have tried to shorten the decision steps by conducting multiple decisions simultaneously at each iteration.
For example, [24] proposed learning what to defer (LwD), which decides on the actions simultaneously by leveraging locally decomposable properties.
Specifically, the defer action is added to the action space and the decisions are made independently on each node.
The next iteration is then conducted only with the deferred nodes.
LwD shows notable performances on graph
CO tasks even though it requires a task-specific transition function to satisfy the constraints.
Outside the research area of CO, the reduction of the number of DNN inferences has gained much attention, especially in text and image generation.
[25] proposed the Denoising Diffusion Models
[Figure]
𝑖
[Figure]
[Figure]
𝑝 𝑖 𝑖∈𝒱 𝑇 𝑓 𝜔 𝑝 𝑖 𝑖∈𝒱
𝑡+ 𝑓 𝜔 𝜸
[Figure]
coarsening
[Figure]
in Discrete State-Spaces (D3PM), which employs a diffusion process and makes multiple decisions at each step.
Similarly, [26] proposed a parallelized auto-aggressive diffusion model (Parallelized
ARDM), which makes multiple decisions by learning the order-agnostic properties.
These studies show remarkable results compared to the conventional auto-regressive generation by reducing the number of inferences.
Neural Coarsening Process
We propose the Neural Coarsening Process (NCP) to solve node-level graph CO tasks for subproblems with a smaller number of iterations.
We employ the graph coarsening procedure to decrease the size of the input graph gradually.
The graph coarsening procedure reduces a given graph G
=
( V 0 , E 0 ) , where V 0 and E 0 are the nodes and edges of G 0 respectively, and |V 0 | =
N , to a sequence of smaller graphs G 1 , G 2 , . . .
, G T , such that |V 0 | > |V 1 | > · · · > |V T | , where T is the number of iterations.
The graph coarsening (or contraction) works by merging multiple nodes into one.
Various contraction strategies can be applied according to the tasks.
The node-level graph CO tasks are node classification tasks, where the nodes are classified into one of the classes in K .
Although some tasks contain neighborhood constraints (e.g. no two adjacent nodes can share the same class in MIS), we focus on node-level tasks without the neighborhood constraints.
We also apply edge contraction for node classification tasks 3 , where a chosen edge ( u, v ) merges two endpoints into a single node v ′ .
The weight of the merged nodes is the sum of the original nodes’ weights, and the parallel edges are aggregated into one edge with the sum of edge values.
Overall, the node class prediction and graph coarsening procedure are conducted iteratively.
The prediction model consists of a graph embedding module and a node classification module; a message passing neural network (MPNN) [27] and a Multi-layer Perceptron (MLP) are employed, respectively.
The model f ω : G → R |K|×|V| gives an independent probability p ki that decides if node i will be included in class k ∈ K .
Specifically, we repeat following steps:
Step1.
For each node i , predict the node class probability p ki via f ω ( G t ) .
Step2.
Coarsens G t to get G t
+1 .
Step2-1.
Greedily select an edge according to probability q ij that decides if its endpoints are in the same class, i.e., arg
[Equation]
where q ij = (cid:88) k ∈K p [Equation]
Step2-2.
Contract the selected edge and repeat Step2 until |V t +1 | =
⌊ γ |V t |⌋ .
Step1 corresponds to the node class prediction, and Step2 corresponds to the graph coarsening with edge contractions.
Note that Step2 can be processed in parallel.
The overall procedure is illustrated in Fig.
Since the graph is coarsened with the ratio γ for every GNN inference, the number of
GNN inferences is bounded to O (log |V| ) .
As the coarsened graph has fewer nodes and contains aggregated information, the node classification becomes less complicated.
When the graph has been coarsened enough, we apply a rounding scheme to de-randomize the final prediction and map the nodes of the coarsened graph G T to that of the original graph G 0 .
We train the model by minimizing the difference between the predicted node class probability and the true labels.
Binary labels y
=
{ y ki } i ∈V ,k ∈K are generated in advance using the exact (or good enough) algorithms with relatively small-sized problems.
For each coarsening step, a collection of pairs D = {G ( n ) , y ( n ) } Nn =0 are gathered, and the parameters are updated to minimize binary cross-entropy (BCE) loss:
[Equation]
When the model is trained, the labels can become invalid when the graphs are coarsened due to inaccurate prediction
p ki (e.g. the nodes with different labels are merged into one).
To keep the labels valid in the entire coarsening process, we compute q ij based on y i instead of p i .
Consequently, the contraction probabilities of crossing edges, whose endpoints have different labels, are guaranteed to be all zero at the training phase.
Experimental Results 4.1 Target Task: CVRP-CapacityCut
In this study, we conduct experiments focused on the cutting plane method for CVRP.
CVRP is represented as a tuple ( G, K, Q ) , where G =
( V, E ) is a complete graph whose node set V corresponds to the union of the depot and customer nodes, and K is the number of vehicles with capacity Q .
CVRP aims to find the routes with the minimum cost for K vehicles where: (i) each customer must be served by only one vehicle; (ii) no vehicle can serve a set of customers whose total demand exceeds the vehicle’s capacity Q ; and (iii) every route starts and ends at the depot.
The cutting plane method is generally used to handle the exponentially-large capacity constraints.
Fig.
3 shows the overall procedure of the cutting plane method for capacity constraints.
First, it relaxes the problem by dropping all capacity and integer constraints.
Second, it iteratively (a) solves the relaxed linear problem, (b) finds the capacity constraints violated by the current linear solution, and (c) appends them to the relaxed problem.
However, designing an effective algorithm for the subroutine (b) is challenging; thus, we replace this subroutine with NCP.
[Figure]
CVRP-CapacityCut is defined as finding a subset S ⊆ V \{ 0 } that violates the corresponding capacity constraints; it is highly related to the MIN-CUT problem on a weighted graph.
See Appendix A for mathematical formulations and further details.
CVRP-CapacityCut is a graph CO problem and solving this is known as NP -hard [28].
4.2 Setup
We apply NCP to solve the CVRP-CapacityCut efficiently.
To be specific, we construct a sparse graph G [-
-]0 =
( V 0 , E 0 ) , where V 0 = V and E
= { ( i, j
) ∈ E : ¯ x ij > 0 } based on the given relaxed solution ¯ x ij .
CVRP-CapacityCut is a node classification task that has two classes (i.e., S and V \ S ), which minimizes the total weight of the crossing edges connecting two nodes of different sets (i.e., one of the endpoints belongs to S and the other belongs to V \ S ).
We let p i =
if node i is included in S , and p i = 0 otherwise to simplify the notations.
The depot node, indexed as 0 , is excluded from S by the definition of CVRP-CapacityCut (i.e. p 0 = 0 ).
G 0 is coarsened according to the procedure defined in Section 3 until there are three nodes remaining (the depot and two aggregated nodes).
We set q ij for the depot connected edges not to coarsen the depot as follows:
[Equation]
otherwise
[Equation]
Thus, the coarsening also terminates when there are no edges to contract.
[Figure]
[Figure]
𝜔 𝑝
[Equation]
𝑇 𝑓 𝜔
[Equation]
[Equation] [Figure] [Equation] [Figure]
[Figure]
After T steps of coarsening, we compute the final node selection probability p i = f ω ( G T ) , then simply round the probability to map the probabilities to the binary values.
If there are no nodes with p i > 0 . 5 , we set the node that has the highest probability as 1.
By doing this, the nodes of G T are classified as the nodes in set S T and in its complement set V T \ S T .
As we keep tracking the node information in the coarsening process, we can map the class of the coarsened nodes to the class of the original nodes directly.
The training data is gathered by conducting the cutting plane method with the exact separation algorithm [21] for relatively small-size, randomly generated CVRP ( | V | ∈ [50 , 100] ).
As the collected labels are highly imbalanced, a positive weighted BCE loss is employed.
The positive weight is defined as the ratio between the number of negative and positive labels.
4.3 Performance Evaluation
Baseline.
We use the CVRPSEP library [29] written in C++ for the baseline separation algorithm.
It consists of four heuristics, one simple connected component algorithm, and three shrinking -based heuristics.
We set the maximum number of cuts for a given relaxed solution as the number of vehicles
K , the same as the proposed algorithm.
Lower bound (LB) gap.
Since the scale of cost varies depending on problem instances, we measure the relative performances by calculating the lower bound gap, GAP , as follows:
[Equation]
where OPT is the known optimal cost and LB is the resulting cost with the cutting plane method.
OPT is challenging to compute and unknown in large-scale CVRP.
Hence, the solution calculated via the hybrid genetic search algorithm (HGS [4]) is used instead of OPT .
Evaluation.
The cutting plane method terminates when the algorithm cannot find any violated capacity constraints, or the number of subroutine calls reaches the limit.
The relaxed solution and its cost (i.e. resulting lower bound) are computed with the constraints appended at the end.
CVRPSEP has at least O (2 | V | ) time complexity in the worst case since the connected component heuristic needs to check all the components, their complements, and unions (refer [29] for details).
Thus, the evaluation with limited calls does not give any advantages to our method.
4.4 Results
Since the exact labels for the large-scale instances are intractable, the model is trained with labels generated from relatively small-sized CVRP.
We evaluate the lower bound for CVRP with different sizes using both CVRPSEP and NCP to verify the performance and scalability of our model.
We conduct the experiments for 10 CVRP instances of each size with limited subroutine calls.
Table 1 shows the overall results of the cutting plane method with CVRPSEP and NCP.
As shown in
Table 1, the cutting plane method with NCP performs more effectively in larger instances, even though the model is trained in the [50 , 100] range.
The average improvement of LB per CVRP-CapacityCut call (denoted as Avg.
∆ LB) is calculated to evaluate the quality of added constraints.
This is done by dividing the total LB improvements by the number of calls.
Table 1 shows that the LB improvements are more significant with the constraints found by NCP as compared to that of CVRPSEP.
We provide additional results with limited wall clock time in Appendix C.
[Table]
[Table]
CapacityCut with NCP
[Table]
[Figure]
The lower bound gap of NCP and CVRPSEP are plotted as shown in Fig.
5a.
In addition, the number of times that the algorithms defeat each other out of the 10 instances (i.e., winning ratio) is measured for each size as shown in Fig.
5b.
The results indicate that our algorithm performs better in large-sized CVRP ( ≥ 300 ) when averaged.
Furthermore, NCP outperforms CVRPSEP for every instances with more than 300 nodes.
More experiments that verify the transferability of NCP are conducted using CVRPLIB X-instances [30] generated using different distributions.
The results show that NCP performs well for out-distribution problems (details are in Appendix C.2).
Fig.
6 illustrates the LB gap of NCP and CVRPSEP according to the number of subroutine calls.
The LB gap is significantly reduced in the early stages, and the improvement diminishes as the capacity cuts are added.
Fig.
6 also shows that NCP converges faster than CVRPSEP.
When the number of nodes is small, CVRPSEP converges to a lower point than NCP eventually.
However, when the number of nodes is large, NCP decreases to a lower point than CVRPSEP within the limited [Figure] subroutine calls.
Since NCP converges faster, it can be more efficient in improving the lower bound, especially in the large-scale CVRP
[Figure]
4.5 Results for the subproblem
We compare NCP with a fully auto-regressive and an one-shot prediction model to verify the effect of NCP on CVRP-CapacityCut .
A fully auto-regressive model makes decisions node by node based on the previous decisions; thus, decisions for the next node are conditioned by the nodes that are decided prior to it.
On the other hand, an one-shot prediction model predicts probabilities of being included in S for all nodes simultaneously.
One-shot prediction equals to NCP with γ = 1 since we apply the same rounding rule to get binary value.
We use the same network architecture (i.e. MPNN + MLP) and train to minimize the differences using the labels (see Appendix B.4 and Appendix B. for details).
We evaluate the models using 100 test data generated in advance for each size of [50 , 75 , 100 , 200] .
The number of inferences (Avg. Steps), the cost gap of the subproblem with labels (Cost Gap), and the ratio of feasible solutions for CVRP-CapacityCut (Feasibility) are measured for each size.
Tableresults clearly show that our method requires a fewer number of inferences for decisions with less satisfaction for the constraints.
Fig.
7 illustrates the lower bound gap computed with the cutting plane method via different algorithms for randomly generated CVRP in the [50 , 500] range.
We follow the evaluation process described in Section 4.3.
The results show that NCP achieves a lower cost gap in subproblems even though [Figure] [Table] [Figure]
[Table]
[Figure] it fails to satisfy constraints occasionally, which leads to better performances in the main CVRP. The fully auto-regressive decoding strictly satisfies the constraints of the CVRP-CapacityCut as the unavailable choices are masked when the decisions are made sequentially.
It is challenging to consider the relationship between the nodes (i.e. variables) in the one-shot prediction, hence its performance deteriorates as it classifies the nodes jointly.
Conclusion
In this work, we proposed the Neural Coarsening Process (NCP), an effective graph learning method for subproblem of the hierarchical structures in graph CO.
Our main contribution is that our method (i) requires a smaller number of inference iterations and (ii) gives a more powerful performances, than the fully auto-regressive method.
The reduced iteration (i.e. the number of GNN inferences) of subproblems can have great effects on the overall procedure since the subproblems are called repeatedly.
The extensive experiments show that our method outperforms both the graph learningbased auto-regressive method and competitive heuristic method on CVRP-CapacityCut .
A Explanation of CVRP-CapacityCut A.1 Mathematical formulation of CVRP
Mathematically, CVRP is written in integer programming (IP).
Following [29], we let x ij represent the number of travels between nodes i and j .
Given a subset of customers S ⊆ V C , δ ( S ) denotes a set of crossing edges, one node of which belongs to S and the other belongs to V \ S .
For arbitrary given edge subset F ⊆ E , x ( F ) denotes the sum of travels of F , i.e. (cid:80) ( i,j ) ∈ F x ij .
The two-index formulation of CVRP is:
Minimize (cid:88)
[Equation]
Subject to x (
[Equation]
( { i
[Equation]
[Equation]
[Equation]
[Equation]
(8) where r ( S ) is the minimum number of required vehicles to serve the customers in S .
The equality in Eq.
(5) impose that the total traveling time of each node is exactly 2 , so each customer is visited once by only one vehicle.
The capacity constraints in Eq.
(6) ensure that the summation of demand cannot exceed the capacity Q and a route have the depot as the connected nodes (i.e., the sub-tour elimination).
The right-hand side r ( S ) is often computed with ⌈ (cid:80) i ∈
S d i /Q ⌉ , called rounded capacity inequalities (RCIs).
The two last constraints in Eqs.
(7) and (8) are the integrality conditions of the decision variables respectively.
Note that if the vehicle visits only one customer, the edge between the depot and the customer j has to be traveled two times (i.e., x 0 j = 2 ).
A.2 Cutting plane method for CVRP
In general, the cutting plane method is an iterative algorithm that first solves a relaxed problem, which is the problem where the hard-to-handle constraints are ignored, and then, out of the ignored constraints, the violated constraints (i.e., the cuts or cutting planes) are appended to the relaxed problem to form the new relaxed problem.
The iteration terminates when the solution of the relaxed problem (i.e. the relaxed solution) becomes feasible to the original problem.
Specifically in CVRP, the cutting plane method often relaxes the RCIs and the integer conditions (e.g. [29]).
In the two-index formulation of CVRP, the relaxed problem for the cutting plane method is as follows:
[Equation]
Note that, in the relaxed problem, RCIs in Eq.
(6) and the integer constraints in Eqs.
(7) and (8) are eliminated, and it becomes linear programming (LP), whose optimal solution can be relatively easily found than the original problem.
In practice, to keep the relaxed problem to be LP, the cutting planes are selected among RCIs.
The relaxed problem does not enforce the RCIs, so the (fractional) solution (i.e., ¯ x in Fig. 3) for the relaxed problem are not feasible for the original IP problem Eq.
(4)–Eq.
To refine the feasible region of the relaxed problem, the separation algorithms find a RCI constraint which are violated by the current solution (i.e., D ¯ x > d ).
The found inequality Dx ≤ d is one of the relaxed RCIs, so the original feasible solutions satisfy the inequality.
Thus, this constraint separates the current solution from the feasible solutions of the original problems.
Once the separating RCI(s) are found, the RCI(s) are appended to the relaxed problem.
A.3 The exact RCI separation
At each separation step, there exist a lot of valid inequalities (i.e. the possible cutting planes) that separate the relaxed optimal solution from the set of the integer feasible solutions.
The exact separation algorithm [21] is designed to produce the tightest cutting planes (i.e., the cut closest to convex hull of the feasible region).
The exact separation can deeply cut the relaxed feasible region by adding the tightest cutting plane into the current relaxed problem, whereas most heuristic separations are designed to find one of the possible cutting planes.
By iteratively cutting the current relaxed solution out, we can get the more refined feasible region of the relaxed problem.
The exact separation is formulated as a mixed-integer programming (MIP).
Given the current relaxed solution ¯ x , we define ¯ G =
( V, ¯ E ) where ¯ E = { ( i, j
) ∈ E : ¯ x ij > 0 } as the support graph, y i as the binary variable whether node i is in S , and w ij as the continuous variable that equals to 1 if ( i, j
) ∈
δ ( S ) .
For each M ∈ { 0 , . . .
, ⌈ (cid:80) i ∈ V C d i /Q
⌉ − 1 } , we can get the minimum crossing edge cost z ( M ) by solving the following:
[Equation]
Subject to w ij ≥ y
[Equation]
y
[Equation]
[Equation] [Equation]
[Equation]
[Equation]
[Equation]
The logical constraints Eq.
(15) and Eq.
(16) means w ij has to be 1 if the y i and y j have different values, which is the definition of w ij .
For the given M , the inequality Eq.
(17) enforces that the total demand of the selected nodes should exceed the entire load of M vehicles.
In other words, the subset S requires at least M + 1 vehicles to satisfy all demands in S (i.e. the subset S requires 2( M + 1) times of traveling).
As the minimum crossing edge weight z ( M ) corresponds to the total traveling number of S ∗ =
{ i ∈ V C :
y ∗ i = 1 } , we can find the corresponding capacity inequality z = ¯ x ( δ ( S ∗ )) ≥ (cid:80) i ∈
S ∗ d i .
Thus, if z ( M ) is less than 2( M +1) , the corresponding RCI is violated.
B Detailed Experimental Setting B.1 Graph representation
Since the message passing operation of MPNN is conducted along the edges, the messages from the isolated nodes cannot be exchanged.
In order to make the support graph connected while keeping the sparsity, edges between the depot and customers are added (i.e. the depot is completely connected to all customers).
The modified graph is defined as ¯ G ′ =
( V, ¯ E ′ ) , where ¯ E ′ =
{ ( i, j ) ∈ E : ¯ x ij > 0 or i = 0 } .
Now, we define the node and edge features of ¯ G ′ to represent the given RCI separation problem
Eq.
(14)-Eq.
The problem has four parameters, cost coefficient ¯ x , constraint coefficient d , and the right-hand side (RHS) M and Q .
These parameters are not included in ¯ G ′ , so we formulate these as the node and edge features.
Node feature The constraint Eq.
(17) is related to the node decision variable y .
It can be reformulated as (cid:80) i ∈ V C d i Q y i > M , and the coefficient d i Q and RHS M define the node feature.
Note that d i Q has the range [0 , 1] by definition, but the range of M varies on the number of vehicles.
Thus, we normalize it by dividing the vehicle number K (i.e., MK ∈ [0 , 1] ).
The node feature of i ∈ V is defined as:
[Equation]
Edge feature The cost function Eq.
(14) are related to the edge decision variable w ij .
We directly use the cost coefficient ¯ x as an edge feature.
Note that ¯ x ij is 0 for the additional edges ( i, j ) ∈ ¯ E ′ \ ¯ E , and every ¯ x ij are in the range [0 , 1] by definition.
The edge feature of ( i, j ) ∈ ¯ E ′ is defined as:
[Equation]
B.2 Network architecture
We employ a message passing neural network (MPNN) and a simple MLP for representation learning for the graph embedding and node classification modules.
Single linear layers with 128 latent dimension are employed for the node and edge initial embedding.
The MPNN consists of 5 graph layers whose node update and message generation functions are MLP with [64 , 32] hidden dimensions.
The policy module is a simple MLP with [64 , 32] hidden dimension.
Note that it has a 1 dimension for the output and employs a sigmoid activation function since the output corresponds to the probability.
B.3 Data generation
To get exact labels for separation problems, we generate random CVRP instances following [30] and apply the cutting plane method with the exact separation algorithm described in Appendix A.3.
The random CVRP instances are generated with uniformly distributed depot and customer positions, and each customer’s demand is sampled from a uniform distribution range of [1 , 100] .
Since the computation of the exact RCI separation problems with a large number of CVRP is intractable ( NP -complete), we only solve the relatively small size of CVRP instances ( | V | ∈ [50 , 100] ).
Support graphs and exact labels for the separation problems are gathered in an offline manner.
Given
LP solution ¯ x , for each M = 0 , . .
, ⌈ (cid:80) i ∈ V C d i /Q
⌉ − 1 , the exact separation algorithm solves MIP
Eqs.
(14) to (20).
Since binary variable y i indicates whether the node i is in S , we can set the exact node label ˆ y i as the optimal values of y ∗ i .
We include label ˆ y =
[ˆ y 0 , . .
, ˆ y | V | ] into training data even if the minimum crossing edge set does not violate RCI.
Hence, the policy learns how to find the minimum crossing edge set by amortizing the computation of the MIP solver.
To get the next separation problem, the violated RCIs are added to the current relaxed problem, and we repeat this until the algorithm fails to find violated RCIs.
To evaluate the trained model, we generate CVRP test instances with different numbers of customers from 50 to 1 , 000 ( 10 instances for each size).
We use the identical distributions with training for depot position, customer position, and demand with CVRP training instances.
B.4 Auto-regressive decoding model
Model.
First, we add a dummy node that indicates the <end of selection> and is connected all nodes so as to gather information about the current set composition (i.e. the dummy node has incoming edges only).
We set the weights of dummy-connected edges as 0 , and add an edge type feature that indicates that its source node is currently included in S .
The dummy nodes are masked to available only when the selected nodes are satisfy constraints at each step.
Training.
We train the model using the same labeled data with NCP.
At each step, the model is trained to imitate the probability ˆ p i , calculated via the exact labels as follows:
[Equation]
otherwise
We employ the mean squared error (MSE) loss because it gives better performances than the cross entropy loss.
B.5 One-shot decoding model
Model.
We construct the same input graph with NCP and predict the independent node selection probabilities directly.
Since the model computes the node selection probabilities independently, we can use the exact label ˆ y i as true probability for node i . To de-randomize the resulting graph, we employ the same rounding scheme with NCP. The one-shot decoding model is identical to the graph coarsening network with the coarsening ratio γ = 1 . Input: Augmented graph G
Output: Selected nodes set S 1 Initialize set S = ∅ ; 2 for step ← 0 to | V C | − 1 do
Predict node selection probability { p i } i ∈ V C \ S ← f ω ( G, S ) ; if training then
Update θ ← ∇L ( { p i } i ∈ V C \ S , { ˆ p i } i ∈ V C \ S ) ;
Randomly select a node j according to { ˆ p i } i ∈ V C \ S ;
Update edge features according to S ; if j = dummy then
Terminate the selection; else
S ← S ∪ { j } ;
Training.
We train the model using the same labeled data with NCP.
The overall training procedure follows Section 3 with γ = 1 except for the loss function.
We employ the MSE loss function because it performs better than BCE loss and positive weighted BCE loss for the one-shot decoding model.
Algorithm 2: Input: Augmented graph G Output: Selected nodes set S 1 Predict node selection probability { p i } i ∈ V C ← f θ ( G ) ; 2 if training then Update θ ← ∇L ( { p i } i ∈ V , { ˆ y i } i ∈ V ) ; 4 else
Set the depot probability p 0 ← 0 , y 0 ← 0 ; y i ← round ( p i ) , ∀ i ∈ V C ; Include i to S if y i = 1 ; C Further Experiments C.1 Experimental results with limited wall clock time
We compare performances of NCP and CVRPSEP with limited wall clock time (2 hours) instead of the limited number of subroutine calls.
Experiments are conducted on the server equipped with
Intel(R) Core(TM) i9-7980XE CPU.
We evaluate the models only using CPU, as CVRPSEP is not implemented to use GPU acceleration.
As shown in Table 3, the lower bound with NCP is tighter than CVRPSEP when the number of nodes is bigger than or equal to 400.
Fig. 8 shows that NCP performs better in the large-scale CVRP. C.2 Experiments on X-instances in CVRPLIB We apply the trained model to X-instances [30] in CVRPLIB without additional training to verify the transferability.
Note that the training data is generated using uniform demand distribution U (1 , 100) but the X-instances have seven different demand distributions.
Table 4 shows that the model performs better when the number of customers exceeds 200 .
NCP achieves a more significant LB improvement per iteration even when the demand distribution is different with the training demand distribution.
Fig.
9 illustrates the lower bound gap with HGS algorithm.
The results suggest that NCP mostly outperforms CVRPSEP in the large-scale problems with limited iterations.
[Table]
[Figure]
[Table]
CapacityCut with NCP (ours) [100, 200) 25,
[Table]
[Table]
[Figure]