Exploiting Instance and Variable Similarity to Improve Learning-Enhanced Branching

Security-Constrained Unit Commitment (SCUC) is a fundamental optimization problem solved daily by power system operators that seeks to minimize electricity production costs by finding the most effective generator commitment schedule and power output levels and is widely used in power system applications such as electricity market clearing and reliability assessment. SCUC is a generalization of the unit commitment problem ([12]), and is typically modeled in industrial practice as a large-scale Mixed Integer Linear Programming (MILP) problem. Numerous MILP formulations for the problem have been proposed (see, for example, [22, 41, 38]). Besides being difficult in the theoretical sense (see [8] for NP-hardness of SCUC), SCUC is made even more challenging by the fact that a new near-optimal solution must be obtained every day within a very limited time window.

The branch-and-bound algorithm was proposed in the landmark paper [33] to provide a finite algorithm to solve MILPs, and today it is at the heart of all state-of-the-art MILP solvers. To completely define the algorithm, it is necessary to specify a variable selection rule, which decides how to partition the problem into multiple subproblems, and a node selection rule, which defines what subproblem to process next ([43, 13]). On the node selection side, it is well-known that using the best-bound rule produces the smallest trees for realistic benchmark instances ([1]). Recently, [16] also showed that, for certain classes of random integer programs, using this rule guarantees a polynomial-size branch-and-bound tree with high probability. The more challenging rule to optimize is the variable selection rule. Negative results due to [28, 11, 14, 15, 7, 17, 19] show that, no matter what variable selection rule is used, the branch-and-bound tree is, of exponential size in the worst case. In practice, the variable selection rule has a huge influence on the size of the branch-and-bound tree. Today, it is well-established that strong branching ([6]) typically produces the smallest trees for a variety of optimization problems. Although this rule produces high-quality decisions ([18]), it is extremely computationally demanding, and most times prohibitive to implement ([2]). See [35, 36] for a nice overview of computational issues with the branch-and-bound algorithm. Since strong branching produces high-quality decisions, but at a high computational cost, multiple works in the literature have attempted to mimic it using machine learning methods [31, 4, 23, 47, 25, 39]. See [37] for a review of this direction of research.

Most traditional non-ML branching methods can be generally modelled as a score function $S(i,I)$, where $i$ represents the index of the candidate variable and $I$ represents general information about current and previous nodes. Given this function, the candidate variable chosen for branching is the one with the best (highest) score.

Most-infeasible branching (MIB) is one of the most simple branching strategies, which uses a score function of $S_{MIB}(i,I)=\min\{x_{i},1-x_{i}\}$, the infeasibility or “fraction” of the candidate variable at current node. While MIB is extremely cheap to evaluate, it is unfortunately known to perform poorly compared to other branching methods. Reliability branching (RB:$\lambda$:$\eta$) is the state-of-the-art branching scheme with respect to running time ([2]). The method relies on probing, during which it actually solves the linear relaxations of both upward and downward branches for the fractional variable. More specifically, at each node, the candidate fractional variables are sorted by pseudocost, then at most $\lambda$ variables are probed. If a given variable has already been probed $\eta$ times during the entire execution of the algorithm, its pseudocosts are deemed reliable, and no more probes are performed for the variable. The score function is usually $S(i,I)=\max\{\tilde{\Delta}_{i}^{-},\epsilon\}\cdot\max\{\tilde{\Delta}_{i}^{+},\epsilon\}$, where $\tilde{\Delta}_{i}^{\pm}$ are the objective increases if probed, or the pseudocost estimations otherwise.

The scheme covers RB:inf:inf, so called full strong branching, where every fractional variable is probed, and which was shown in numerous results (like [2]) to generate the smallest branch-and-bound trees compared to other rules. However, since every fractional variable to be probed translates to two linear relaxations to be solved, this scheme is computationally prohibitive for large scale problems. On the other hand, reduced versions of RB:$\lambda$:$\eta$ with smaller values of $\lambda$ and $\eta$ can achieve good branching while being considerably faster. Considering the size of our problems, we use settings of RB:100:inf as the practical strong branching oracle.

In this work, we evaluate our proposed ML scheme against the method described in [4], denoted as ML:ET. In general, ML:ET can be formulated as

where $\phi_{i}$ is the feature vector from available information $I$, and $f_{ML:ET}$ is the learned machine-learning model, which is used to mimic a good branching oracle like strong branching. A wide variety of handcrafted features, including static problem features, dynamic problem features and dynamic optimization features, are used. Training problem instances are solved using strong branching, without any heuristics or cut generation, to collect strong branching scores, and then Extremely Randomized Trees (ExtraTrees, [24]) are used to approximate them.

To ensure consistent training data and reproducible experimental results, in this work we implemented, in the Julia programming language, a textbook version of the branch-and-bound algorithm, as well multiple variable branching rules and multiple node selection rules. While cutting planes can significantly enhance the performance of textbook branch-and-bound methods, in this work we did not consider their usage, as they make the analysis of branching rules significantly more difficult. The algorithm was also given the primal optimal value to eliminate the influence of primal heuristics. The implementation relies on an external LP solver, accessed through MathOptInterface, to process node relaxations and evaluate strong branching decisions. In our experiments, we used best-bound with plunging for node selection and Gurobi 9.0 ([26]) as the LP solver. The branch-and-bound implementation has been made available as part of the open-source package MIPLearn ([45]). MIPLearn was also used to compute variable features. Machine learning models were implemented in Python 3.9 with scikit-learn, and PyCall.jl was used to call the ML models from Julia.

Both training and testing were processed in parallel on the high-performance computational cluster of ISyE, Georgia Tech, which contains roughly 2,340 cores of x86-64 processing with over 28.9TB of memory spread across the systems and each task was processed on a dedicated core with 8GB of memory. A time limit of one week (604,800 seconds) was imposed when solving all MILPs, though never activated, since all runs finished within the allotted time. In all runs, the branch-and-bound algorithm was also configured to terminate when a 0.01% relative gap was reached.

Five realistic large-scale security-constrained unit commitment instances from UnitCommitment.jl [46], corresponding to five European transmission networks from MATPOWER ([49, 21, 30]), were used to evaluate the performance of the ML branching rules. For each network, 50 instance variations were generated by applying the randomization algorithm described in [44] – thus giving us 250 instance variations in total. For each network, the first 40 instances variations were used for training, while the remaining 10 were used for testing. The sizes of the resulting instances are displayed in Table 1. We highlight that the instances used in our experiments are quite large, with up to 400,000 decision variables and 350,000 constraints. To the best of our knowledge, most papers in the learning-to-branch literature have not dealt with such large instances, with the notable exception of [39].

The package UnitCommitment.jl was also used to construct the MILP, using a state-of-the-art formulation of the problem. In the following, we list the description of all binary variables in the formulated MILP, as it is of particular interest for both per-variable and per-group approach. We refer to the package documentation for more details:

• •

  is_on[g,t]: True if generator $g$ is on at time $t$

• •

  switch_on[g,t]: True if generator $g$ switches on at time $t$.

• •

  switch_off[g,t]: True if generator $g$ switches off at time $t$.

• •

  startup[g,t,s]: True if generator $g$ switches on at time $t$ incurring start-up costs from start-up category $s$.

To generate the training dataset, we solved each training instance using RB:100:inf and, for each strong branching call made by the algorithm, we collected features describing the evaluated variable, as well as the logarithm of the computed strong branching score (due to the fact that it spans several orders of magnitude). We enforced a node limit of 1000, a time limit of $1.2\times 10^{6}$ seconds (roughly 2 weeks, due to server limitation) and a relative gap limit of 0.01%. The algorithm stopped when any of these limits were reached.

For each network, one model was trained for ML:ET, while a series of models were trained for the per-variable scheme or the per-group schemes. To the best of our ability and understanding, ML:ET is an accurate implementation of the method described in [4]. In particular, we used the same set of features and the same ML regressors. We also performed hyperparameters tuning, using Scikit-Learn’s GridSearchCV, to improve the classifier’s performance and to manage its memory requirements. Our final set of hyperparameters for ML:ET were min_samples_split=10, max_depth=25 and n_estimators=25.

For the per-group scheme, we chose three different grouping methods:

• •

  Per-generator (ML:PGE): Two variables are grouped together if they have the same base name (e.g. is_on, switch_on, switch_off), the same generator index $g$ and the same startup category $s$. Each group, therefore, consists of 24 variables, corresponding to different values of time $t$.

• •

  Per-time (ML:PTI): Variables are grouped together if they have the same base name, the same time $t$ and the same startup category $s$. We allow, therefore, grouping of variables corresponding to different generators.

• •

  Per-name (ML:PNA): Variables are grouped together if the have the same base name and the same startup category $s$. Since the benchmark instances have three different startup categories, we have exactly 6 groups in total. This grouping strategy was the closest to ML:ET in the number of models.

As described in Section 3, we also used ExtraTrees as classifier for per-group strategies, but a different set of hyperparameters, found through Scikit-Learn’s GridSearchCV, to avoid over-fitting. For all regressors, we used n_estimators=25. For per-variable ML:PV and the per-generator ML:PGE, we selected min_samples_split=5 and max_depth=12. For per-time ML:PTI, we used min_samples_split=8 and max_depth=12. For per-name ML:PNA, we used min_samples_split=8 and max_depth=16.

In Table 2, we display the number of groups for each grouping strategy and for each network. Note that these numbers indicate the maximum number of ML models trained; if the strong branching routine is never called during training for all variables in certain group, or if it is only called less than 10 times, then not enough training data is available for that group, and therefore no ML model is trained. We recall that the strong branching routine is not called for a given variable if either the variable is already integral at the node, or if the maximum number of strong branching evaluations has been reached. The actual number of generated models is displayed in Table 3. We noticed that the difference between the number of generated models and the theoretical limits gets more prominent as the groups become finer, which is expected. During inference time, if a per-variable or per-group model is not available, we fall back to the general-purpose ML:ET model.

To measure the accuracy of different grouping strategies, we used $k$-fold cross-validation, a standard approach to test the quality of ML classifiers and regressors. The training data was split into $k$ parts (folds), then $k$ estimators were trained on data from $k-1$ folds and their performance was evaluated on the remaining fold. See [27] for details.

Figure 1 shows the 5-fold cross-validated mean squared error (MSE) for all grouping strategies on one particular network (case1888rte). We omit other networks, since they presented similar results. In the charts, “actual value” corresponds to the strong branching scores, as generated by the non-ML branching oracle RB:100:inf during training data collection, while “predicted value” is the branching score predicted by each ML model.

While all grouping strategies were able to approximate strong branching score to some extent, MSE scores got better as grouping became finer and each group became smaller. This was especially true for the per-variable model ML:PV, the finest grouping, which achieved much better MSE results than all other methods, including ML:ET.

In the previous subsection, we evaluated the performance of the ML models in isolation, based on MSE. In this subsection, we integrate the models into the branch-and-bound algorithm and evaluate their effectiveness at solving an actual MILP. Our main focus is the quality of branching, measured by the final relative MIP gap after a certain number of branch-and-bound nodes. We do not focus on total running time since this metric depends heavily on the quality of the software implementation, instead of simply on the fundamental properties of the branching rule. It is also self-evident, in our opinion, that all evaluated ML-based branching rules, if carefully implemented, would require significantly less computational effort per node than strong branching, since they involve only the evaluation of a few small decision trees per variable, instead of the solution of a large-scale linear programming problem.

In our first set of experiments, we compared the relative MIP gap attained by seven different ML and non-ML branching methods (MIB, RB:100:inf, ML:ET, ML:PNA, ML:PTI, ML:PGE and ML:PV) after the exploration of at most 1,000 branch-and-bound nodes. This node limit was set relatively low because we wanted to include RB:100:inf, a computationally expensive branching rule. Note that even though RB:100:inf is faster than full strong branching (RB:inf:inf), for the size of our instances, it is not fast enough to be a practical branching method. Table 4 presents a summary of the results. We remind the reader that 10 test instances were solved for each network; therefore, each cell in the table represents the average of 10 values. For each network, we also highlighted the ML branching rule with best performance.

As clearly illustrated, the per-variable approach ML:PV outperformed ML:ET on almost all networks. Moreover, ML:PV presented a relative MIP gap of 0.40%, which is only about 22% worse than RB:100:inf, and therefore provides a relatively close approximation of strong branching.

Per-generator ML:PGE and per-time ML:PTI approaches also significantly outperformed ML:ET, although to a smaller degree in most instances. The per-name ML:PNA approach overall offered little improvement, likely due to its similarity to the original ML:ET.

As explained in Subsection 4.5, when we need to estimate the strong branching score of a variable that does not have a per-group ML model, we fall back to the most general ML:ET model. It is thus worth investigating how often such phenomenon occurred. Table 5 shows what percentage of all evaluations relied on the fallback model, instead of the specific per-group model, due to missing data.

It is clear that, with finer grouping strategies, fallback happened more often, indicating that fewer variables were covered during training. This highlights the need to balance between more groups and more data per group. While finer groups leads to improved accuracy, this comes at the cost of reduced coverage. Nevertheless, it is also clear that the fallback rate is quite low, and that fallback does not hinder the potential of the per-group or per-variable approach. With a more substantial dataset, we also expect that we should be able to reduce the occurrence of fallback or even eliminate it altogether.

While the experiments in Section 5.2 clearly demonstrate the superiority of the per-group methods in smaller branch-and-bound trees, it is natural to ask whether these results still hold for larger trees. To answer this question, in this section we repeat the experiments of Section 5.2 with a larger budget of 10,000 nodes. Due to the significant computational cost of RB:100:inf, we omit this method in the following experiments.

Table 6 shows a summary of our results. With larger trees, the performance improvement of ML:PV over ML:ET becomes more clear, and the per-variable method now outperforms ML:ET in every network. Consistently with our previous experients, other per-group schemes, especially per-time (ML:PTI) or per-generator (ML:PGE), also outperform ML:ET in most cases. For network case3375wp, in particular, ML:PGE presents much better performance than all the other ML methods.

The approach we propose in this work fundamentally depends on variables and variable groups keeping their identity across multiple instances. While it is true that, in operational problems, one often has to solve instances where changes are only made to the matrix coefficients, objective function and right-hand side, in practice these MILPs would still go through an extra presolve step just before being solved, where the MILP solver makes further changes to the problem in an attempt to make it easier, based on the actual problem data. These changes could potentially modify the problem structure. To determine whether the proposed scheme would still work under this scenario, we ran further computational experiments where the test instances are presolved by Gurobi prior to being solved by our branch-and-bound implementation. No presolve, however, is applied to the training instances. Because of this, during inference, we made the decision to provide to the ML models static variable features (e.g. objective coefficient) corresponding to the original problem, not the presolved one, together with dynamic features extracted at the current node (e.g. depth of the node).

Tables 7 and 8 show the relative MIP gap results after 1,000 and 10,000 branch-and-bound nodes, respectively. As shown in the tables, even though the test instances are slightly different the training ones, the machine learning methods still presented good relative MIP gap closures, demonstrating the robustness of the method. Moreover, the per-variable and per-group approaches again outperformed ML:ET on most networks, for both node limit settings.