Venue: NeurIPS 2021 Conference

Reviews:

final_score: rating: 7: Good paper, accept
review_content: summary: Linear integer programming is an incredibly important algorithmic tool that is used widely in practice.  In general the problem is NP-hard and so we have to resort to heuristics. These heuristics often use the branch-and-cut framework: we branch on "guesses" on variables and we cut by adding valid inequalities that tightens the linear relaxation of the integer program.

When dealing with such heuristics, an obvious question arises: which cut should I add and on which variable should I branch? The goal here is to limit  the size of the search tree and therefore getting a good running time. There has been a growing amount of experimental work on using ML algorithms to guide this choice.  

The paper under submission considers this problem from a more theoretical perspective. The main results bound the sample complexity for finding "good" cuts complementing and generalizing a prior work that studied this question for variable selection.
main_review: The paper studies an important problem and give original new contributions.  The paper is also written extremely well and is a pleasure to read.  In what follows, I detail some of the contributions of the paper and comment on their strengths and weaknesses.

The first question that the authors study is the following. Suppose you have an (unknown) distribution over m-constraint IPs. You would like to find the best Chvatal-Gomory (CG) cut u in the following sense. If I add u to the IP then I would like to have the smallest search tree in expectation over the randomly chosen IP (from the distribution). More specifically, the authors study the sample complexity of u and show that it is near linear in m under reasonable norm bounds on the coefficients of the IP instances.  The proofs of this is not hard and uses a connection to pseudo-dimension used in prior work. The key insight is the observation that for a fixed IP the number of Chvatal-Gomory cuts of interest is  exponential.  The authors also generalize this to when you add several cuts to the root of the search tree.

The  strength of the first line of results is that it give new insights to a classic and very natural family of cuts (Chvatal-Gomory cuts). The weaknesses are that (1) the results do not tell us much about when we can find a good cut efficiently; and, as the author points out, (2) the current cut does not depend on the actual IP only on the distribution which is quite unnatural.  It would be good if the authors further explain when this setting is natural and also to comment on the efficiency issue.

Indeed, many solvers uses different scoring rules (that depend on the IP) to select the cuts to add. This is the second part of the paper where the authors analyze the sample complexity of learning such scores. The statement of this result is interesting. The techniques to get it are not striking: basically they show that a good combination of d scoring rules is learnable. Assuming the coefficients in front of these scoring rules don't have huge bit complexity, this follows since then the number of options is say poly(n)^d (or even exp(n)^d if we allow polynomial bit complexity in our coefficients). Now the authors have to work  a little more since they don't make such an assumption.  

The authors also generalize this to a more generalize tree search model in which they are able to recover and generalize prior work that only considered the sample complexity of variable selection.

Overall, I see this as a nice paper that is interesting. It touches on a very interesting problem where we can expect ML to lead to huge speedups. It is unclear how the the sample complexity of the problems considered here will inform such improvements and it would be great if the authors would comment more on this. Overall, I'd recommend the paper to be accepted.


limitations_and_societal_impact: I do wish the authors would have discussed more why the sample complexity is important for cut selection. Perhaps it is a necessity but it is not sufficient (the sample complexity of exponentially many functions is low but we can't try all). As aforementioned, it would also have been good if the authors would have been given a concrete examples where we would expect to have a distribution of IPs and select our cuts depending on this distribution and not the instance.
review_title: null

final_score: rating: 7: Good paper, accept
review_content: summary: Combinatorial optimization solvers often add cutting planes during solving, which are additional constraints in the problem that accelerate solving. These cutting planes have a major impact on the size of the final branch-and-bound tree, and therefore of the speed of the overall solving, but their impact is badly understood theoretically. At minimum, it is empirically understood that the size of the branch-and-bound tree is a complicated and sensitive function of the parameters of the cutting planes that were added during solving: a slightly different cutting plane might have been much more, or much less, effective.

In this paper the authors look at the problem of trying to learn these functions that relate the size of the branch-and-bound tree (a measure of solving performance) as a function of the instance data (A, b, c) when cuts with given parameters u_1, ..., u_k are added to the problem. They compute an order of magnitude of samples required to learn well this function, both for a single cut, a sequence of cuts, or rounds of sequences of cuts (as are used in practice). They also compute the number of samples required for the generalized problem of predicting tree size as a function of the instance data (A, b, c) for an algorithm that would pick the cut parameters to maximize a convex combination of scores, for given algorithm hyperparameters (the convex weights.) Finally, they do the same for more general algorithms that would pick an action, during solving, by maximizing a convex combination of scores, such as when doing node selection or variable selection.
main_review: I think the paper is overall interesting. Although branch-and-cut is the main algorithm used by combinatorial optimization solvers, very little theory has been developed for it, mostly because it is devilishly difficult. The current paper develops some theory related to a more tangential aspect (how hard is it to learn the function mapping cuts, or scoring weights, to the tree size?), but which might be useful for cut selection. In some sense only the initial results of the paper (Theorem 3.1, Lemma 3.2, Lemma 3.4) really seem to have to do with cutting planes per se; the rest is more a consequence of generic results about learning discrete functions, like the tree size, as a function of continuous parameters. Nonetheless the results are not trivial and are certainly original.

On the criticisms side, I think there could be ways for the presentation in Section 4 to be improved.
1) I think the authors should really separate better the paragraph starting at line 298 in two, at line 301. I found the lack of break confusing: the text switches from discussion Theorem 4.1 to moving on to the next result without a breath in between.
2) I think the authors should explain better in Theorem 4.1 what is the main result of Balcan et al. (2021) (Theorem 3.3?) and how it gets invoked in the proof, since the setup and notation of that second paper is quite different from this one. Right now I find the current proof a bit too hand-wavey for my taste, for what is ultimately (with Theorem 5.2) the most interesting result of the paper.
3) My third question is perhaps a bit more philosophical, but is there a good reason why the bound of Theorem 4.1 seems to have no relationship at all with the scoring functions? One might have thought that more complex scoring functions would have led to tree sizes that are more sensitive to their input, and therefore needing more samples to learn, but your bound seems independent of their complexity. Perhaps a little high level explanation would be welcome in the text.

Otherwise, I think the literature review section could be improved. There is a lot of applied papers missing, mostly from more recent years - the list is far from being up to date, both for variable selection, node selection and cut selection. For cut selection there is the recent Huang et al. (2021); for node selection there is Yilmaz and Yorke-Smith (2021). For variable selection (the most studied problem) there is quite a bit missing out, probably at least 10 papers or so since 2017-2018. Conversely, I am not sure I understand the relevance of the paragraph discussing Ferber et al. (2020), except that the method uses cutting planes - this has not really much to do with branch-and-cut?

I also think the tone is sometimes a bit too grandiose in the abstract and the paper. "In this paper we prove the first guarantees for learning high-performing cut-selection policies tailored to the instance distribution at hand using samples" makes it sound like the authors have a procedure with guarantees to produce high-quality cuts - this is not the case. Or in sentences like, "we bound the sample complexity of learning high-performing cutting planes" - I don't think they bound at all the sample complexity of learning the (optimal) planes, they bound the sample complexity of learning a metric, the tree size. This is different in my mind. Now, I do agree that the results of the paper might be useful for deriving such procedures-with-guarantees, for example by optimization of the empirical mean performance over instances (empirical risk minimization), but this is not discussed in the paper, and there would be more work needed to get there. In fact, I think the paper does in that respect an underwhelming job of explaining why these results are interesting, and on that aspect better explaining how they could be useful for cutting plane algorithms would be useful.

Another more minor comment: in Section 3 (and elsewhere in the paper), the authors discuss "waves of cuts". I am personally much more used to hear about "rounds" of cuts, which I think (perhaps incorrectly) is the more standard term in the combinatorial optimization community. To help readers, perhaps it would be valuable to switch to this terminology? Unless there is a distinction I did not quite grasp between the two concepts.

Overall, my recommendation would be acceptance of the paper, with the criticisms I described above having been addressed.
limitations_and_societal_impact: As I mentioned, although I like in general the contributions, I found the tone sometimes a bit too bombastic in the claim of its breath. On a positive note however, they do discuss how their results are mostly focused on Gomory fractional cuts and not other families.
review_title: null

final_score: rating: 7: Good paper, accept
review_content: summary: The paper focuses on the sample complexity of learning to select Chvatal-Gomory cuts for integer linear programming. We assume that there is an unknown distribution that generates ILP instances. CG cuts are parametrized by a set of weights, one per constraint. How large should the set of training instances be for one to accurately estimate the "goodness" of a given parametrization? This is the main question tackled here.

Using the data-driven algorithm design framework of Balcan et al. [8], this paper shows that three flavors of the learning problem can be analyzed effectively. The main contribution is to show that there is structure to the cut generation process as its parameters vary; the space of possible cuts can be partitioned, the form of the boundaries that determine the partition is identified, and the behavior of the cut generation is constant within each region. These can be plugged into a very general PAC learning bound from Balcan et al. [8].

Additionally, the sample complexity of generic tree search is analyzed. It is shown that variable, node, and cut selection can be parameterized simultaneously, each with its own additive scoring function, and sample complexity bounds can be derived accordingly. This result generalizes a previous branching-only bound from Balcan et al. [5].

main_review: Clarity: The paper is very well-written and easy to read. Proofs are either concise or sketched in the main text, which I appreciate.  

Originality: The sample complexity of learning to generate CG cuts is a new problem as far as I know. Deriving the partitions of the parameter spaces do involve some careful analysis.

Quality: The paper is expertly executed. I have checked the proofs to the extent that I am capable, and identified one potential mistake which is likely inconsequential:

In line 203, you say $\sum_{i=1}^{n}{2A_i} \in O(\lVert A \rVert_{1,1})$. I suspect this should be $O(n\lVert A \rVert_{1,1})$: consider the case where all column norms are equal, then summing them up gives $2n \lVert A \rVert_{1,1}$.

If you ignore logarithmic factors in the sample complexity bound of line 210, this missing factor of $n$ is ignored anyways, so even if I were right about this, it is maybe not a big issue. I'd like the authors to comment on this.

Significance: There's a basic issue with the set of results in section 3. The values of the parameter vector depend on the index of the constraint, i.e., $u[1]$ corresponds to the first constraint, etc. Now consider two identical ILP instances with the constraints permuted. The same parameter vector can potentially produce a different cut. A practical scenario for this is a graph optimization problem, say Max. Independent Set (MIS), where each linear constraint expresses independence along an edge of the graph; there is no intrinsic ordering to the edges and thus to the constraints. This is to say that unlike the scoring rules in section 4, the parameters in section 3 make little sense unless you make strong assumptions on the distribution of instances, e.g., if all instances have the exact same constraints but a random objective function, which makes the ordering argument irrelevant.

I am not 100% sure of it, but I think section 4 does not suffer from this issue, as the scoring rules take pre-generated cuts as input.

More broadly though, while the technical work involved in deriving the sample complexity bounds in this paper is solid, I don't see what the theory tells us about the practice: the sample complexity bounds often require a large number of instances (e.g., line 210, quadratic in the maximum search tree size), and there is no clear path to a practical empirical risk minimization procedure that exploits the partition of the parameter space. I would be interested in hearing what the authors think about this.

Minor:
- Line 318: "which allow the cuts B&C that selects" --> "which allow the cuts that B&C selects"
- This paper might be relevant to your literature review: Baltean-Lugojan, Radu, et al. Scoring positive semidefinite cutting planes for quadratic optimization via trained neural networks. Working paper., 2019, http://www. optimization-online. org/DB_HTML/2018/11/6943. html, 2019.

limitations_and_societal_impact: N/A
review_title: null

final_score: rating: 7: Good paper, accept
review_content: summary: This paper studies the sample complexity of cutting plane selection in branch-and-cut algorithms for integer programming problems. The authors study a handful of different settings, with the goal of characterizing the intrinsic difficulty of learning: (i) the tree size upon adding a single cut at the root, (ii) the tree size upon adding a sequence of cuts at the root, (iii) the tree size upon adding a series of waves of cuts at the root, and (iv) the score of cuts according to a set of predefined scoring rules. Finally, the authors generalize the results to bound the sample complexity of generic tree search policies with sequential operations that can be scored.
main_review: The paper is nicely written, tackles an interesting problem, and covers a nice range of related, but still distinct, settings. I view it as a worthy addition to the literature, though I am not particularly well-suited to evaluate the learning aspects of the work (i.e. its novelty or deepness).

I have two questions/comments for the authors:
1.This is nitpicky, but: [10], as cited on L136, restricts attention to bounded polyhedron, whereas the authors do not make the same assumption.
2. How much of this machinery is specialized for integer programming as opposed to mixed-integer programming? I would be interested to hear the authors thoughts, though I do not feel that a lengthy discussion is needed in the paper itself.
limitations_and_societal_impact: N/A
review_title: null

Meta-review: The paper shows sampling bounds for the problem of identifying good cuts in branch-and-bound search using cutting planes. The reviewers appreciated the importance of the problem and the contribution of the paper. Some reviewers were concerned that sampling bounds by themselves do not provide efficient algorithms for finding good cuts, but these concerns were mostly resolved during the rebuttal phase.
Decision: Accept (Spotlight)