Paper: Rethinking Branching on Exact Combinatorial Optimization Solver: The First Deep Symbolic Discovery Framework (ICLR-2024)

Reviewer comment (Evaluation):
Symb4CO, although data efficient during the training, requires feature extraction by human. I have concerns about if the extracted features are expressive enough, and how much efforts does it take for these feature extractions. Does it really the so-called training efficient?

Author response:
## Q1: How about the human effort for feature extractions?

Very insightful question! The question is also asked by Reviewer z5TX. We think the effort for feature extractions is affordable in the branching task (and in many other tasks in the field of combinatorial optimization) due to the extensive existing research in combinatorial optimization (CO) solvers. Human-designed features are *widely* used in learning-based approaches in tasks like branching [1], node selection [2], and cut selection [3]. Even the bipartite graph states employed in the branching task contain 25 human-designed features in the constraints, variables, and edges [4]. 

In fact, during our approach design, we did consider generating features automatically from bipartite graphs based on symbolic models for graph neural networks (GNNs) [5,6]. However, we found three challenges that make the task *non-trivial*:
- First, processing bipartite graphs via symbolic models requires complex computation by traversing the entire graph, and the complexity grows linearly with the number of layers we consider. This might be extremely expensive for inference on purely CPU-based devices compared with human-designed features. 
- Second, existing approaches learn such symbolic models by symbolize the components in GNN one by one, which results in very high training overhead compared to the lightweight Symb4CO (see Table C11 in our Appendix for the training overhead of Symb4CO). 
- Finally, most experiments conducted in previous research [5,6] implicitly assume the message flow passed by GNN carries a specific physical mechanism, which ensures that the message-passing function is sparse enough for symbolizing. However, the message flow in the branching task might not satisfy this assumption. 

We note that our approach is the *first* step towards automated algorithm discovery on modern solvers. Based on your insight question, we fully agree the automated design of input features for different tasks (e.g., branching, cut selection, and primal heuristics)  is an *exciting avenue* for future work!

## Q2: Are the extracted features expressive enough?

Thank you for the question. These features have been proved expressive in previous research [1,7]. The features are first proposed in [1] based on the domain knowledge and previous research in [8,9,10]. These features include static ones describing the input MILP problem and dynamic ones representing the status of the solver at current node, both of which contain human-designed structural information about the bipartite graph. Previous research uses these features to train support vector machines [1] and hybrid deep learning models [7] and achieves high performance on purely CPU-based devices. The bipartite graph features, though contain rich information, require graph neural networks (GNNs) to embed it via time-consuming message passing. Previous research [7] uses the embedded features at root nodes as the input of the hybrid model, but introducing these features might reduce the interpretability of the learned symbolic policies in our paper.

## Q3: Is it really so-called training efficient?

Thank you for the question. As we compared in Figure 1(a) and Table 2 in our main paper, Symb4CO is significantly more efficient for training than all the other learning-based approaches. We use only *1‰* MILP instances to achieve performance comparable to previous state-of-the-art approaches. This is mainly because the symbolic policies are highly lightweight and the use of symbolic operators can be regarded as enforcing strong regularizations. We believe this feature of Symb4CO will *significantly* facilitate its application to real-world tasks.

Reviewer comment (Presentation):
While the paper discusses the limitations of previous ML approaches, it needs to address the potential limitations of Symb4CO. A dedicated section on drawbacks or areas for future improvement would enhance the paper's completeness.

Author response:
Thank you for this very constructive suggestion! We briefly discussed the limitations and the future work in Section 6 (Conclusion and Future Work) in our main paper. Based on the analysis in our submission and the insightful suggestions from all the reviewers, we further provide more discussions in Appendix E. Specifically, we conclude three exciting challenges and their corresponding exciting future work as follows:

-   Automated feature generation. Though the features used in this paper are simple to obtain and effective in practice, the automated feature generation is still promising future work to further help us reduce the domain knowledge for feature design, understand the underlying characteristics of this task, and deploy Symb4CO to more tasks in the field of mathematical optimization.
-   Cross-benchmark symbolic policy for general CO problems. Based on the results in Q14, we highly believe that training a cross-benchmark symbolic policy---though might not achieve the best learning accuracy on specific data distributions---to replace the human-designed general-purpose scoring function in the RPB policy, is a very promising avenue for future work.
-   Graph inputs and GPU-based symbolic policies. Bipartite graph is widely used to formulate a series of combinatorial optimization (CO) problems, handling these inputs is a further step towards general algorithm discovery system for CO problems. Deploying symbolic policies on high-end GPUs (when available) can further accelerate the inference speed of these policies.

Reviewer comment (Experiments):
Out of curiosity, did the authors explore the extent to which the learned symbolic policies generalize across different problem domains within combinatorial optimization? For example, test the policies trained on one benchmark on a different but related benchmark to assess their transferability.

Author response:
Very **constructive** question! We did not conduct this experiment since the learned symbolic policies in Table 5 in our main paper seem to be totally different, and it is widely recognized that learning-based approaches tend to fail at out of distribution data. 

However, we surprisingly found that symbolic policies trained on one benchmark can usually generalize well to another benchmark! See the bold values in the table below (time: $s$), and we also added these new results to Appendix E. A potential reason is that the learned symbolic policies are very compact and their parameters are very sparse, which effectively improves the generalization ability of these policies.

Based on these results and your constructive question, we *highly* believe that training a cross-benchmark symbolic policy---though might not achieve the best learning accuracy on specific data distributions---to replace the SOTA human-designed scoring function in the RPB policy, is a *very promising avenue* for future work!

| Benchmark\Policy From | SetCover  | Cauctions | Facilities | Indset    | RPB (Default) |
| - |-|-|-|-|-|
| Setcover| **7.10**| 21.90| **9.13**| 12.10| 11.40|
| Cauctions| **1.81**| **1.57**| **1.82**| **2.36**| 3.00|
| Facilities| **46.44** | 65.07| **37.76**| **38.40** | 54.05|
| Indset| **22.28** | **22.16** | 66.08| **29.21** | 42.69|

Reviewer comment (Experiments):
The paper relies on manual feature extraction. This leaves open the question what are useful features, which is difficult to answer. Presumably the choice of the features are dependent on the particular benchmarks and can have significant impact on the performance. I get that the alternative deep representation makes the inference more expensive though.

Author response:
Thank you for the insightful question! The question is also raised by Reviewer hTDx. In fact, human-designed features are widely used in learning-based approaches in tasks like branching [1], node selection [2], and cut selection [3]. Even the bipartite graph states in the branching task contain 25 human-designed features in the nodes and edges [4]. Thanks to the extensive classical research in combinatorial optimization (CO) [5,6,7,8,9], designing useful features for each task are not so challenging, and previous learning-based research [1,10] have proved the effectiveness of the features employed in our paper. As expected by the reviewer, the useful features depend on particular benchmarks, but an appealing feature of Symb4CO is that it can automatically select a subset of useful features in its learned expressions (as reported in Table 5 in our main paper). 

During our approach design, we did consider generating features automatically from bipartite graphs based on symbolic models for graph neural networks (GNNs) [11,12]. However, we found three challenges that make the task *non-trivial*:
- First, processing bipartite graphs via symbolic models requires complex computation by traversing the entire graph, and the complexity grows linearly with the number of layers we consider. This might be extremely expensive for inference on purely CPU-based devices compared with human-designed features. 
- Second, existing approaches learn such symbolic models by symbolize the components in GNN one by one, which results in very high training overhead compared to the lightweight Symb4CO. 
- Finally, most experiments conducted in previous research [11,12] implicitly assume the message flow passed by GNN carries a specific physical mechanism, which ensures that the message-passing function is sparse enough for symbolizing. However, the message flow in the branching task might not satisfy this assumption. 

Our approach is the *first* step towards automated algorithm discovery on modern solvers. Based on your insight comment, we fully believe that the automatic design of input features for different tasks (e.g., branching, cut selection, and primal heuristics) is an *exciting avenue* for future work!

Reviewer comment (Experiments):
In the experiments, are the proposed branching heuristics invoked at each node, or only the top node?

Author response:
Thank you for the question. As described in Appendix C, we deploy the learned symbolic policies to the CO solver at depths 0-16 and switch back to the default reliability pseudocost policy (RPB) when depth is larger than 16. Roughly, depths 0-16 can contain more than 131,000 nodes in total. Thus, almost all nodes in the Easy and the Medium datasets and a large part of nodes in the Hard dataset are expanded by the symbolic policy. We employ such implementation since:
- The accuracy of pseudocost gradually increases to comparable to the learned ones at the deep layers of the tree. This is mainly because: a) the pseudocost in deep layers is fully updated after enough node expansions; b) the number of branching candidates is monotonically decreasing with the depth, making the task easier in deep layers. 
- The deep layers of the B&B tree contain a large number of nodes, and RPB policy is faster than symbolic policies in these layers as it reduces to almost purely pseudocost branching (PB) policy. In contrast, learned-based approaches still require extracting features for each branching variable. GNN&GPU-based approaches do not implement in this way due to their higher learning accuracy achieved by complex neural networks together with faster inference speed achieved by high-end hardware.
To further illustrate these reasons, we report: a) the decision time and the normalized full strong branching (FSB) score of these policies in Table 1 below; b) the end-to-end performance of Symb4CO when employed in all layers (Symb4CO-AllLayers) in Table 2 below; c) the curve of the FSB scores v.s. different depths in Figure C3 in Appendix.

| Model: | Symb4CO |  | RPB |  |
| --- | --- | --- | --- | --- |
| Depth/Max Number of B&B Nodes | Normalized FSB score | Decision Time (ms) | Normalized FSB score of the PB function | Decision Time (ms) |
| 0/1 | 0.728 | 56.8000 | 0.144 | 1300.5199 |
| 4/16 | 0.766 | 26.3000 | 0.154 | 571.3723 |
| 8/256 | 0.853 | 14.1000 | 0.262 | 52.0601 |
| 12/4096 | 0.888 | 12.8486 | 0.309 | 27.8487 |
| 16/65536 | 0.667 | 9.9025 | 0.667 | 8.5889 |

| Setcover: | Easy |  | Medium |  | Hard |  |
| --- | --- | --- | --- | --- | --- | --- |
| Model | Time | Nodes | Time | Nodes | Time | Nodes |
| RPB | 11.40 | **212.5** | 100.32 | 6116.0 | 1911.32 | 117450.0 |
| Symb4CO | 7.10 | 304.7 | **86.92** | 5623.2 | **1894.38** | 129231.6 |
| Symb4CO-AllLayers | **6.96** | 297.4 | 93.40 | **5587.6** | 1943.41 | **113149.5** |

Thus, switching the symbolic policy to RPB can further accelerate the solving process on *hard* instances. Intuitively, we can regard the RPB policy as a specific PB policy warm started with FSB, while Symb4CO uses symbolic policies learned with historical data to warm start PB.