Learning Subproblem Complexities in Distributed Branch and Bound

Transcription

1 Learning Subproblem Complexities in Distribute Branch an Boun Lars Otten Department of Computer Science University of California, Irvine Rina Dechter Department of Computer Science University of California, Irvine Abstract In the context of istribute Branch an Boun Search for Graphical Moels, effective loa balancing is crucial yet har to achieve ue to early pruning of search branches. This paper proposes learning a regression moel over structural as well as cost function-base features to more accurately preict subproblem ahea of time, thereby enabling more balance parallel workloas. Early results show the promise of this approach. 1 Introuction This paper explores the application of learning for improve loa balancing in the context of istribute search for iscrete combinatorial optimization over graphical moels (e.g., Bayesian networks, weighte CSPs). Specifically, we consier one of the best exact search algorithms for solving the MPE/MAP task over graphical moels, AND/OR Branch an Boun (AOBB) [9], ranke first or secon in the UAI an evaluations. We aapt the establishe concept of parallel tree search [], where a search tree is explore centrally up to a certain epth an the remaining subtrees are solve in parallel. In the graphical moel context we explore the search space of partial instantiations up to a certain point an solve the resulting conitione subproblems in parallel. The istribute framework is built with a gri computing environment in min, i.e., a set of autonomous, loosely connecte systems notably, we cannot assume any kin of share memory which many parallel algorithms buil upon [,, 1]. The primary challenge an focus of this paper is therefore to fin a set of subproblems with balance, so that the overall parallel runtime will not be ominate by just a few of them. In the optimization context, however, the use of cost an heuristic functions for pruning makes it very har to reliably preict an balance subproblem ahea of time, even if structural parameters like inuce with are known. Our suggeste approach an the main contribution of this paper is to estimate subproblem by learning a regression moel over the subproblems parameters, structural as well as with respect to the cost function. This moel is traine uring preprocessing on a small number of subproblem samples an then use to preict the size of each subproblem s search space in avance, merging/splitting accoringly. Prior work on estimating search goes back to [] an more recently [], which preict the size of general backtrack trees through ranom probing. Similar schemes were evise for Branch an Boun algorithms [], where search is run for a limite time an the partially explore tree is extrapolate. Our approach iffers by sampling an learning entirely uring preprocessing, allowing very fast repeate estimates when the parallelization frontier is iteratively compute. We present some early results of this ongoing work, running with a varying egree of parallelism on haplotyping problems from the omain of genetic linkage analysis. While limite in scope at this point, results are promising, with goo parallel speeups in particular. 1

2 (a) (b) (c) () Figure 1: (a) Example primal graph with six variables, (b) its inuce graph along orering = A,B,C,D,E,F, (c) a corresponing pseuo tree, an () the resulting context-minimal AND/OR search graph. Backgroun We assume the usual efinitions of a graphical moel as a set of functions F = {f 1,...,f m } over iscrete variables X = {X 1,...,X n }, its primal graph, inuces graph, an inuce with. Figure 1(a) epicts the primal graph of an example problem with six variables. The inuce graph for the example problem along orering = A,B,C,D,E,F is epicte in Figure 1(b), its inuce with is. Note that ifferent orerings will vary in their implie inuce with; fining an orering of minimal inuce with is known to be NP-har, in practice heuristics like minfill [] are use to obtain approximations..1 AND/OR Search Spaces The concept of AND/OR search spaces has been introuce as a unifying framework for avance algorithmic schemes for graphical moels to better capture the structure of the unerlying graph [3]. Its main virtue consists in exploiting conitional inepenencies between variables, which can lea to exponential speeups. The search space is efine using a pseuo tree, which captures problem ecomposition: DEFINITION 1 (pseuo tree) Given an unirecte graph G = (X,E), a pseuo tree of G is a irecte, roote treet = (X,E ) with the same set of noesx,such that every arc ofgthat is not inclue in E is a back-arc in T, namely it connects a noe in T to an ancestor in T. The arcs in E may not all be inclue ine. AND/OR Search Trees : Given a graphical moel instance with variables X an functions F, its primal graph(x,e), an a pseuo treet, the associate AND/OR search tree consists of alternating levels of OR an AND noes. OR noes are labele X i an correspon to the variables in X. AND noes are labele X i,x i, or justx i an correspon to the values of the OR parent s variable. The structure of the AND/OR search tree is base on the unerlying pseuo tree T : the root of the AND/OR search tree is an OR noe labele with the root oft. The chilren of an OR noe X i are AND noes labele with assignments X i,x i ; the chilren of an AND noe X i,x i are OR noes labele with the chilren of X i in T, representing conitionally inepenent subproblems. It was shown that, given a pseuo tree T of height h, the size of the AND/OR search tree base on T is O(n k h ), where k bouns the omain size of variables [3]. AND/OR Search Graphs : Different noes may root ientical subproblems an can be merge through caching, yieling an AND/OR search graph of smaller size, at the expense of using aitional memory uring search. A mergeable noe X i can be ientifie by its context, the partial assignment of the ancestors of X i which separates the subproblem below X i from the rest of the network. Merging all context-mergeable noes yiels the context minimal AND/OR search graph. Given a graphical moel, its primal graph G, an a pseuo tree T, the size of the context-minimal AND/OR search graph iso(n k w ), wherew is the inuce with of G over a epth-first traversal of T an k bouns the omain size [3]. Figure 1(c) epicts a pseuo tree extracte from the inuce graph in Figure 1(b) an Figure 1() shows the corresponing context-minimal AND/OR search graph. Note that the AND noes for

3 B have two chilren each, representing inepenent subproblems an thus emonstrating problem ecomposition. Furthermore, the OR noes for D (with context {B, C}) an F (context {B, E}) have two eges converging from the AND level above them, signifying caching. Weighte AND/OR Search Graphs : Given an AND/OR search graph, each ege from an OR noe X i to an AND noe x i can be annotate by weights erive from the set of cost functions F in the graphical moel: the weight l(x i,x i ) is the sum of all cost functions whose scope inclues X i an is fully assigne along the path from the root to x i, evaluate at the values along this path. Furthermore, each noe in the AND/OR search graph can be associate with a value: the valuev(n) of a noenis the minimal solution cost to the subproblem roote atn, subject to the current variable instantiation along the path from the root to n. v(n) can be compute recursively using the values of n s successors [3]. AND/OR Branch an Boun : AND/OR Branch an Boun is a state-of-the-art algorithm for solving optimization problems over graphical moels. Assuming a maximization task, it traverses the context-minimal AND/OR graph in a epth-first manner while keeping track of a current lower boun on the optimal solution cost. During expansion of a noe n, this lower boun l is compare with a heuristic upper boun u(n) on the optimal solution below n if u(n) l the algorithm can prune the subproblem below n [3]. Distribute AND/OR Branch an Boun : Our istribute implementation of AND/OR Branch an Boun is base on the notion of parallel tree search [], where a search tree is explore centrally up to a certain epth an the remaining subtrees are solve in parallel. In the context of graphical moels we explore the search space of partial instantiations up to a certain point an solve the resulting conitione subproblems in parallel. Applie to the search graph from Figure 1(), for instance, we coul obtain eight inepenent subproblems as shown in Figure, with a conitioning search space (in Figure : Parallelization applie to the example problem from Figure 1, resulting in eight inepenent subproblems, with conitioning search space in gray. gray) spanning the first two levels (variablesaanb). In the following we will outline our approach to fining a balance set of subproblems. 3 Loa Balancing through Complexity Preiction Our general scheme to fin a balance set of subproblems is outline in Algorithm 1: starting with just the search space root noe (corresponing to a single, large subproblem), we iteratively pick the subproblem with largest estimate an conition it further, until the esire level of parallelism (measure by the number of subproblems, typically chosen to be ten times the number of available CPUs) is obtaine. Note that each noe generate nees to have its subproblem estimate, resulting in many such queries; it is therefore avisable to keep most of the estimation to an offline preprocessing phase in orer to ensure fast preiction queries. The following section erives our principle approach to subproblem preiction, which we formulate as a regression learning problem. We note that, while the goal in the present context is Algorithm 1 Pseuo coe for subproblem generation Input: Pseuo tree T with root X, minimum subproblem count p, estimator ˆN. Output: SetF of subproblem root noes with F p. 1: F { X } : while F < p : 3: n argmax n F ˆN(n) : F F \{n } : F F chilren(n ) 3

4 to ensure balance subproblem in the istribute scheme, accurate preiction is a worthwhile issue in itself an a possible subject of future research. 3.1 Subproblem Complexity Preiction Given a search noe n, we propose to moel the of the subproblem below it (measure by the number of noe expansions require for its solution) as an exponential function of various subproblem features x j (n), capturing the exponential nature of the search space size as follows: N(n) = b j λjxj(n) (1) The subproblem features x j (n) we consier can be ivie into two groups: Structural: (n), epth of n in the conitioning search space; h(n), height of the subproblem pseuo tree below n; w(n), inuce with of the conitione subproblem below n; c(n), the number of problem variables in the subproblem below n. Cost-function relate: U(n), heuristic upper boun on the subproblem solution cost below n, as use by the Branch an Boun algorithm for pruning; L(n), lower boun on the subproblem solution cost as erive from the current best (overall) solution. If we instea consier the log, Equation 1 becomes the following: logn(n) = j λ j x j (n) () Fining suitable parameter values λ j can thus be formulate as a well-known linear regression problem. In other wors, given a set ofmsample subproblemsn k an their respective complexities N(n k ), 1 k m, we aim to fin parameters λ j that minimize the mean square error: MSE = 1 m ( λ j x j (n k ) logn(n k )) (3) m k=1 j The optimal selection of λ j s can be compute using the orinary least squares metho: We take each sample subproblem s features as a row of the esign matrix X (i.e., X i,j = x j (n i )) an let Y withy i = log(n(n i )) enote the column vector of log subproblem sizes. With as the Eucliean norm, we then minimize XΛ Y through the close-form expression ˆΛ = (X T X) 1 X T Y. Optionally applying rige regression for regularization we get: ˆΛ = (X T X +αi) 1 X T Y () where I is the ientity matrix an α R a small constant (e.g. α =.1). Given the learne parameters ˆλ j we can then preict the (log) of a new subproblem n as: log ˆN(n ) = j ˆλ j x j (n ) () In the following we briefly escribe how we can obtain the sample set of subproblems require to learn the parameter values ˆλ j of the regression moel. 3. Subproblem Sampling Recall first that AND/OR Branch an Boun is a epth-first search scheme. Secon, we realize that any leaf noe that is generate is a subproblem in itself (of size 1) an as the algorithm backtracks from the leaf the solve subproblem expans in size. Hence obtaining a single sample subproblem is straightforwar: we run the search for a limite number of operations an take the largest solve subproblem as the sample. To obtain multiple ifferent samples, we introuce ranomness in the value choices of the search up to a certain epth, below which the algorithm continues to use the heuristic upper boun as a value selection heuristic as before. For the parallel results in the following section, for a given problem instance we sample 1 subproblems each of size approx. 1,,,,,, 1,, 1,, an, noes, for a total of samples. This sampling process takes aroun 1 minutes per problem instance an is performe offline at this stage eventually it will be fully integrate into the parallel scheme.

5 (a) Peigree1, 1 CPUs / 1 subproblems (root) [y] (b) Peigree13, CPUs / subproblems (root) [y] (c) Peigree31, 1 CPUs / 1 subproblems 1 1 () Peigree1, 1 CPUs / 1 subproblems 1 1 (root) [y] (root) [y] (e) Peigree19, 3 CPUs / 3 subproblems (root) [y] Regression estimate (log1).. (f) Peigree1, 1 CPUs, 1 subproblems. subproblems optimal... Actual subproblem (log1) Regression estimate (log1).. (g) Peigree31, 1 CPUs / 1 subproblems. subproblems optimal... Actual subproblem (log1) Regression estimate (log1).. (h) Peigree1, 1 CPUs / 1 subproblems. subproblems optimal... Actual subproblem (log1) Figure 3: (a) (e): Subproblem statistics for select runs. Shown are each subproblem s as well as the epth of its root in the central search space (plotte against secon y-axis). (f) (h): Scatter plots of subproblem complexities against regression estimates. Empirical Results This line of work is an ongoing effort, with a more comprehensive stuy to be carrie out in the future; here we present some early results. We note that fining suitable benchmark problems is not an easy feat: if problems are too simple, parallelization is most likely etrimental overall, ue to preprocessing an overhea from the istribute scheme. Many very har problems, on the other han, will still remain infeasible for practical purposes, in particular since every experiment bins a potentially large number of share parallel resources for an extene perio of time. We report on five haplotyping problems from the omain of genetic linkage analysis, which correspon to MPE queries over Bayesian networks. With sequential runtimes from uner one hour to over six ays, we varie the number of CPUs epening on the problem, since massive parallelism is futile for relatively simple problems. For each instance below, n is the number of problem variables, k its maximum omain size, w the inuce with, an h the pseuo tree height. Table 1 contains results in terms of parallel runtime with varying levels of parallelism, epening on overall problem. Also inclue are sequential solution times (using plain AOBB)

6 sequential CPUs time sp CPUs time sp peigree1, 1 3 peigree13 1, 1 1,3 1 1 peigree31 9,, 1 1,13 1 peigree1,11 1,3 9 3, 1 peigree19 1,9,3 3,39 19 Table 1: Sequential an parallel runtime results for ifferent number of CPUs (number of subproblems is always ten times number of CPUs). sp is speeup vs. sequential. All times in secons. an relative speeup. Figure 3 shows etaile subproblems statistics: (a) through (e) epict the of the iniviual subproblems for select runs an allow us to assess loa balancing; (f) through (h) irectly contrast the estimates from the learne regression moel with the actual subproblem complexities, enabling evaluation of the preiction quality. Peigree1 (n = 1,k =,w = 33,h = 1) : Solve sequentially in uner one hour, this problem oesn t leave room for much parallelism an using more than 1 CPUs woul a little benefit. The subproblem complexities, however, seem fairly balance (Fig. 3(a)). Peigree13 (n = 1,k = 3,w = 3,h = 1) : Sequential AOBB takes about 3 1/ hours on this problem, using 1 CPUs yiels almost perfect linear speeup. The effect oesn t hol as strongly for CPUs, but the time improvement is still pronounce. The loa balancing is acceptable as well (Fig. 3(b)), however we foun that the unerlying moel preictions (not picture) are many orers of magnitue ifferent from the actual complexities, which will nee further investigation. Peigree31 (n = 113,k =,w = 3,h = ) : We obtain favorable speeups with up to 1 processors. Similarly, the istribution of subproblem complexities seems relatively balance (Fig. 3(c)). The unerlying estimates, however, are again not very accurate (Fig. 3(g)). Peigree1 (n = 11,k =,w = 39,h = 9) : One of the two problems where using all available 3 CPUs makes sense, yieling a substantial speeup. The subproblem complexities are not quite as balance (Fig. 3()) an the unerlying preictions quite crue (Fig. 3(h)), but it oes not appear to impact the overall solution time negatively. Peigree19 (n = 93,k =,w =,h = 9) : The harest problem in this set, its parallel speeup is a bit less istinct. We think this is ue to the consierable imbalance across subproblems (Fig. 3(e)); in fact the overall time is ominate by a few long-running subproblems. Overall, however, we observe very reasonable parallel speeups across instances; loa balancing seems fairly effective, with the exception of peigree19, which we nee to investigate more closely. However, while our framework appears to generally enable effective loa balancing, the accuracy of the unerluing estimates is meiocre at best; further research is neee here as well. Conclusion & Future Work We have evelope a istribute Branch an Boun framework that uses learning to achieve better loa balancing on a computational gri. In particular, we propose to train a linear regression moel on structural an cost-function base features of sample subproblems. The resulting moel is then use to etermine a suitable parallelization of the entire problem search space. Early results shown in Section have shown promise, but also highlighte areas for future work. We were able to obtain very goo parallel speeups for very complex as well as (using fewer CPUs) relatively simple problems an generally observe effective loa balancing. However, we also foun that in most cases the learne regression moel in t preict complexities very accurately, sometimes leaing to imbalance subproblem complexities. The most notable example in this regar was peigree19, which will require more in-epth analysis. Future work will involve ientifying aitional features to a to the moel, experimenting with varying sample sizes, an, most importantly, a more extensive empirical evaluation of the various aspects of our scheme on more problem instances. Another path worth investigating might be using non-linear moels an to compare their performance to the current linear regression.

7 References [1] Geoffrey Chu, Christian Schulte, an Peter J. Stuckey. Confience-base work stealing in parallel constraint programming. In Ian Gent, eitor, CP, volume 3 of Lecture Notes in Computer Science, pages 1, Lisbon, Portugal, September 9. Springer-Verlag. [] Gérar Cornuéjols, Miroslav Karamanov, an Yanjun Li. Early estimates of the size of branchan-boun trees. INFORMS Journal on Computing, 1(1): 9,. [3] Rina Dechter an Robert Mateescu. AND/OR search spaces for graphical moels. Artif. Intell., 11(-3):3 1,. [] Bernar Genron an Teoor Gabriel Crainic. Parallel branch-an-boun algorithms: Survey an synthesis. Operations Research, ():1 1, 199. [] Ananth Grama an Vipin Kumar. State of the art in parallel search techniques for iscrete optimization problems. IEEE Trans. Knowl. Data Eng., 11(1): 3, [] Philip Kilby, John Slaney, Sylvie Thiébaux, an Toby Walsh. Estimating search tree size. In AAAI, pages AAAI Press,. [] Uffe Kjaerulff. Triangulation of graphs algorithms giving small total state space. Technical report, Aalborg University, 199. [] Donal E. Knuth. Estimating the efficiency of backtrack programs. Mathematics of Computation, 9(19):11 13, 19. [9] Rau Marinescu an Rina Dechter. AND/OR Branch-an-Boun search for combinatorial optimization in graphical moels. Artif. Intell., 13(1-1):1 191, 9.