Patent Application
20140129594
The minimum graph bisection problem is a well known problem that seeks to partition a graph into two equally-sized cells while minimizing the number of edges between them. More particularly, the input to the minimum graph bisection problem is an undirected, unweighted graph G=(V, E), and its goal is to partition V into two sets or cells A and B such that |A|, |B|≦┌|V|/2┐, and the number of edges between cells A and B (the cut size) is minimized. This combinatorial optimization problem is a case of graph partitioning which asks for arbitrarily many cells. It has many applications, including image processing, computer vision, divide-and-conquer algorithms, VLSI circuit layout, distributed computing, and route planning.
Known software libraries (e.g., METIS, SCOTCH, JOSTLE, etc.) solve the graph partitioning problem but the quality of the obtained solutions is often unacceptable. Heuristics directed to particular graph classes, such as DibaP (for meshes) and PUNCH (for road networks), are also known. These techniques cannot prove optimality or provide approximation guarantees, and do not perform well unless imbalance is allowed.
There is much literature on computing exact solutions to the graph bisection and partitioning problems, mostly using the branch-and-bound framework. These techniques can only solve instances of moderate size (with hundreds or a few thousand vertices) to optimality, even after a few hours of processing.
Techniques are described for graph partitioning, and in particular, graph bisection. A combinatorial lower bound is provided that is computed in near-linear time. These bounds may be used to determine optimum solutions to real-world graphs with many vertices (e.g., more than a million for road networks, or tens of thousands for VLSI and mesh instances).
In various implementations, combinatorial techniques to reduce the size of the branch-and-bound search tree may use tree packing, assign vertices to trees, and use fractional assignment of vertices to trees.
In an implementation, lower bounds for the minimum graph bisection problem, within a branch-and-bound framework, enable the solution of a wide variety of instances with tens of thousands of vertices to optimality. The techniques are combinatorial. For graph bisection, each node of the branch-and-bound tree corresponds to a partial assignment of vertices to both cells. It is determined by the lower bound early in the process that certain partial assignments cannot lead to the optimum bisection.
This summary is provided to introduce a selection of concepts in a simplified form that are further described below in the detailed description. This summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used to limit the scope of the claimed subject matter.
The foregoing summary, as well as the following detailed description of illustrative embodiments, is better understood when read in conjunction with the appended drawings. For the purpose of illustrating the embodiments, there are shown in the drawings example constructions of the embodiments; however, the embodiments are not limited to the specific methods and instrumentalities disclosed. In the drawings:
The computing device 100 comprises a graph bisection component 110 which may perform the graph partitioning described herein. Although implementations described herein are directed to graph bisection, it is contemplated that the techniques described herein may be used to partition a graph into any number of sections or partitions.
As described further herein, bounds are determined for the minimum graph bisection problem, which is known to be NP-hard. To solve this problem, an implementation is based on the known branch-and-bound framework. For graph bisection, each node of the branch-and-bound tree corresponds to a partial assignment of vertices to both cells (e.g., cells A and B). A combinatorial bound is determined by building collections of disjoint paths. Moreover, some vertices may be fixed to one of the cells without actually branching on them.
The graph bisection component 110 may comprise modules that perform various techniques described herein. A decomposition module 112 may be used to reduce an input graph into multiple subproblems that are less complex to solve. A branch-and-bound module 116 uses the branch-and-bound technique, generating a search tree to solve the graph bisection problem. A lower bound module 118 may be used to compute lower bounds for each subproblem and a forced assignment module 120 may be used to force vertex assignments, as described further herein.
The modules of the graph bisection component 110 may be used independently of each other, or in conjunction with each other, depending on the implementation, and may perform various alternative and/or additional techniques as described further herein.
The computing device 100 may communicate with a local area network (not shown) via a physical connection. Alternatively, the computing device 100 may communicate with the local area network via a wireless wide area network or wireless local area network media, or via other communications media. The network may be a variety of network types including the public switched telephone network (PSTN), a cellular telephone network (e.g., 3G, 4G, CDMA, etc), and a packet switched network (e.g., the Internet). Any type of network and/or network interface may be used for the network. The user of the computing device 100, as a result of the supported network medium, is able to access network resources, typically through the use of a browser application running on the computing device 100. The browser application facilitates communication with a remote network over, for example, the Internet.
As described further herein, the graph bisection component 110 can perform graph partitioning (e.g., bisecting) and provide results to the graph partitioning problem on any graph. The term “cut” is used herein to denote a set of edges that separates the graph into two or more regions. It is contemplated that graph partitioning as described herein may be used with any application requiring balanced graph cuts, i.e., cuts in which the regions have (approximately) the same size.
To visualize methods contemplated herein, it is helpful to represent the input (an abstract graph with vertices and undirected edges) as points with connecting segments. Vertices may correspond to locations or points, and edges may correspond to segments between locations. The edges may be weighted according any criteria about the corresponding segment. For manipulation by computing devices, graphs may be stored in a contiguous block of computer memory as a collection of records, each record representing a single graph node or edge along with associated data.
As used herein, G=(V, E) denotes an input graph, with n=|V| vertices and m=|E| edges. Each vertex v∈V may have an associated integral weight, denoted by w(v), and each edge e∈E has an associated integral cost c(e). W denotes the sum of all the integral weights. A partition of G is a partition of V, i.e., a set of subsets of V which are disjoint and whose union is V. Each such subset is referred to as a cell, whose weight is defined as the sum of the weights of its vertices. The cost of a partition is the sum of the costs of all edges whose endpoints belong to different cells. A bisection is a partition into two cells (such as cells A and B). A bisection is ε-balanced if each cell has weight at most (1+ε)┌W/2┐. If ε=0, the partition is balanced. The minimum graph bisection problem is that of finding the minimum-cost balanced bisection. A minimum ε-balanced bisection of a graph G may be defined as a partition of V into exactly two sets (cells) such that (1) the weight of each cell is at most W+=└(1+ε)┌W/2┐┘, and (2) the number of edges between cells (cut size) is minimized. Conversely, W−=W−W+ is the minimum allowed cell size.
Unless otherwise noted herein, the unweighted, balanced version of the problem is considered, where w(v)=1 for all v∈V, c(e)=1 for all e∈E, and ε=0. The graph G is therefore partitioned into two cells A and B, each with weight at most ┌n/2┐, while minimizing the number of edges between cells. These techniques can be generalized to handle less restricted inputs, such as arbitrary weights and imbalance.
At 230, a branch-and-bound technique is used to determine the optimum balanced bisection of the input graph. The branch-and-bound technique is used to generate a tree for use in solving each instance of the graph bisection problem (or other partitioning problem). The branch-and-bound technique may determine lower bounds, use the lower bounds in pruning the tree, and may use forced assignments of one or more vertices to further reduce the tree. An optimum balanced bisection of the vertices of the graph may thus be determined. At 240, the partitioned (i.e., bisected) graph may be outputted (e.g., provided to the user and/or storage and/or an application for processing).
Branch-and-bound is a technique that performs an implicit enumeration by dividing a problem into two or more simpler subproblems, solving them recursively, and picking the best solution found. Each node of a branch-and-bound tree corresponds to a distinct subproblem. In a minimization context, the technique keeps a global upper bound U on the solution of the original problem, which can be updated as the algorithm determines improved solutions. To process a node in the tree, first compute a lower bound L on any solution to the corresponding subproblem. If the lower bound L is greater than or equal to the upper bound U, prune the node because it cannot lead to a better solution. Otherwise, branch to create two or more simpler subproblems.
More particularly,
Lower bounds may be determined and the branch-and-bound tree may be pruned. Thus, at 330, compute the lower bound L using techniques described herein for example. At 340, it is determined whether the lower bound L is greater than or equal to the upper bound U. If so, then the node of the tree is pruned at 350. Otherwise, at 360, further vertices in the graph may be assigned to A and B using forced assignments (i.e., the problem may be further simplified using forced assignments of one or more vertices). At 370, a branching vertex v is selected, and two subproblems (A, B+v) and (A+v, B) are returned (where A and B correspond to the two sets of assigned vertices, respectively).
In an implementation, for each subproblem created by the decomposition, multiple calls to a function “Solve” may be used to process each individual subproblem. Let S be the set of open subproblems available (initially containing a single problem). While S is not empty, call the function “Solve” on S (referred herein as “Solve(S)”). Solve(S) is defined as follows: (1) remove a problem P from S, (2) compute a lower bound for P, (3) if P is at least as high as the best known U upper bound, return, (4) perform forced assignments, and (5) pick a branching node v, generate two subproblems of P (assigning vertex v to set A or set B), and add them both to S.
In the case of graph bisection, each node of a branch-and-bound tree corresponds to a partial assignment (A, B), where A, B⊂V and A∩B=Ø. The vertices already fixed to sets A or B are assigned, and all others are free (or unassigned). This node represents the valid bisections (A+, B+) that are extensions of (A, B), i.e., such that A⊂A+ and B⊂B+. In particular, the root node, which represents all valid bisections, has the form (A, B)=({v}, Ø). Note that the root can fix an arbitrary vertex v to one set to break symmetry.
To process an arbitrary node (A, B), a lower bound L(A, B) is computed on the value of any extension (A+, B+) of (A, B). In an implementation, combinatorial bounds are used. In particular, the well-known flow bound may be used: the minimum s-t cut (maximum s-t flow) between set A and set B. It is a valid lower bound because any extension (A+, B+) separates A from B. If the minimum cut s-t is balanced, the node can be pruned and the upper bound U may be updated. Otherwise, a free vertex v may be chosen and branched on, generating subproblems (A∪{v}, B) and (A, B∪{v}).
The flow lower bound works well when A and B have similar sizes; even in this case, however, the corresponding minimum cuts are often far from balanced, with one side containing many more vertices than the other. This makes the flow bound weak by itself. To overcome these issues, an edge-based packing bound may be used.
To take the balance constraint into account, a lower bounding technique is described, referred to herein as an edge-based packing bound. Consider a partial assignment (A, B). Let f be the value of the maximum A-B flow, and Gf be the graph obtained by removing all flow edges from graph G. Without loss of generality, let set A be the main side, i.e., the set of vertices reachable from set A in Gf has higher total weight than those reachable from B. The new bound on Gf is computed, and this can be added to f to obtain a unified lower bound.
To compute the bound, a collection of trees T is determined. This collection of trees T may be referred to as a tree packing T and is a collection of trees (acyclic connected subgraphs of Gf) such that: (1) the trees are edge-disjoint; (2) each tree contains exactly one edge incident to set A; and (3) the trees are maximal (no edge can be added to T without violating the previous properties). Given a set S⊂V, let T(S) be the subset of T consisting of all trees that contain a vertex in S. By extension, let T(v)=T ({v}).
The building of a tree packing T is described further below. With T, it can be reasoned about any extension (A+,B+) of (A,B). By definition, a tree Ti∈T contains a path from each of its vertices to A; if a vertex in B+ is in Ti, at least one edge from Ti must be cut in (A+,B+). Since each tree Ti∈T(B+) contains a separate path from A to B+ in Gf, the following holds: If B+ is an extension of B, then f+|T(B+)| is a lower bound on the cost of the corresponding bisection (V\B+,B+).
This applies to a fixed extension B+ of B. A lower bound is determined that applies to all (exponentially many) possible extensions. A worst-case extension B* (i.e., one that minimizes the bound) may be determined. First, note that w(B*)≧W−, since the bisection (V\ B*,B*) is a valid bisection. Second, let Df⊂V be the set of all vertices that are unreachable from A in Gf (in particular, B⊂Df). Without loss of generality, let B* contain Df. Any vertex v∈Df is deadweight: since there is no path from v to A, it does not contribute to the lower bound.
To reason about other vertices in B*, establish a relationship between T and vertex weights by predefining a vertex allocation, i.e., a mapping from vertices to trees. Allocate each reachable free vertex v (i.e., v∈V\(Df∪A)) to one of the trees in T (v), as described further below. The weight w(Ti) of a tree Ti∈T is the sum of the weights of all vertices allocated to Ti.
Given a fixed allocation, without loss of generality, if B* contains a single vertex allocated to a tree Ti, it will contain all vertices allocated to Ti. This is because the first vertex increases the lower bound by one unit, but the other vertices in the tree are free.
Moreover, B* contains a feasible set of trees T′⊂T, i.e., a set whose total weight w(T′) (defined as ΣTiεt′w(Ti)) is at least as high as the target weight Wf=W−−w(Df). Since B* is the worst-case extension, one must pick a feasible set T′ of minimum cardinality. Formally, given a partial assignment (A,B), a flow f, a tree packing T, and an associated vertex allocation, define the packing bound p(T) as the minimum |T′| such that T′⊂T and w(T′)≧Wf. Note that this bound can be computed by a greedy algorithm, which picks trees in decreasing order of weight until their accumulated weight is at least Wf.
This bound may be strengthened by allowing fractional allocations. Instead of allocating v's weight to a single tree, distribute w(v) arbitrarily among all trees in T(v). For v's allocation to be valid, each tree receives a nonnegative fraction of v's weight, and these fractions add up to one. The weight of a tree T is defined as the sum of the fractional weights allocated to T. Fractional allocations can improve the packing bound by making trees more balanced. They are particularly useful when the average number of vertices per tree is small, or when some vertices have high degree.
Thus, it is determined that considering a partial assignment (A,B), a flow f, a tree packing T, and a valid fractional allocation of weights, then f+p(T) is a lower bound on the cost of any valid extension of (A,B).
The packing bound is a generalization of a previous known bounding technique, which also creates a set of disjoint trees and uses a greedy packing algorithm to compute a lower bound. A difference is that, while with the present techniques the trees are edge-disjoint, the previous known techniques require them to be vertex-disjoint. Thus, the previous known techniques are referred to herein as VBB (for vertex-based bound). Dropping vertex-disjointness not only allows the present techniques to balance the trees more effectively (since they can allocate vertex weights more flexibly), but also increases the number of available trees. This results in significantly better lower bounds, leading to much smaller branch-and-bound trees.
Regarding bound computation, in an implementation, a two-stage approach is used for determining trees and weight allocations.
With regard to generating trees, the first stage generates maximal edge-disjoint trees rooted at A that are as balanced and intertwined as possible. This may be done by growing these trees simultaneously, trying to balance their sizes.
More precisely, at 510, each tree starts with a single edge (the one adjacent to the cell A) and is marked active. At 520, in each step, pick an active tree with minimum size (number of edges) and try to expand it by one edge in a DFS (depth-first search) manner. A tree that cannot be expanded is marked as inactive at 530. At 540, stop when there are no active trees left. This technique is referred to as SDFS (simultaneous depth-first search).
An efficient implementation of SDFS uses a careful choice of data structures. In particular, a standard DFS implementation associates information (such as parent pointers and status within the search) with vertices, which are the entities added and removed from the DFS stack. In contrast, during SDFS the same vertex may be in several trees (and stacks) simultaneously. To handle this, associate information with edges instead. Since each edge belongs to at most one tree, it has at most one parent and is inserted into at most one stack.
Given this representation, an operation of SDFS is described in more detail. First, pick an active tree Ti of minimum size (using buckets or a priority queue, for example). Let (u, v) be the edge on top of Si (the stack associated with Ti), and assume v is farther from Ti's root than u is (considering distances within the tree itself). Scan vertex v, looking for an expansion edge. This is an edge (v,w) such that (1) (v,w) is free (not assigned to any tree yet) and (2) no edge incident to w belongs to Ti. The first condition ensures that the final trees are disjoint, while the second makes sure they have no cycles. If no such expansion edge exists, pop (u,v) from Si; if Si becomes empty, Ti can no longer grow, so mark it as inactive. If expansion edges do exist, pick one such edge (v,w), push it onto Si, and add it to Ti by setting parent (v,w)←(u,v). The process repeats until there are no more active trees.
To define which expansion edge (v,w) to select when processing (u,v), use an edge (v,w) such that w has several free incident edges (to help keep the tree growing) and is as far as possible from A (to minimize congestion around the roots, which is also why DFS may be performed). Note that the distances from A to all vertices can be precomputed with a single BFS during initialization.
Regarding weight allocation (i.e., assigning vertex weights to trees), once a tree packing T is built at 610, and at 620 allocate the weight of each vertex v to the trees T(v) it is incident to. The weights are as evenly distributed among the trees as possible. This may be performed in two stages: initial allocation and local search.
The first stage allocates each free vertex to a single tree. Maintain, for each tree Ti, its maximum potential weight Π(i), defined as the sum of the weights of all vertices that are adjacent to Ti and have not yet been allocated to another tree. To keep the trees balanced, allocate weight to trees with smaller Π(•) values first. More precisely, initially all vertices in T are available (not allocated), all trees Ti are active, and Π(i) is the sum of the weights of all available vertices incident to Ti. In each step, the algorithm picks an active tree Ti such that Π(i) is minimum. If there is an available vertex v incident to Ti, allocate it to Ti; otherwise, mark the tree as inactive. Stop when no active tree remains.
To implement this, maintain the active trees in a priority queue (according to Π(i)), and each tree Ti keeps a list of all available vertices it is incident to. When v is allocated to a tree Ti, decrease Π(j) for all trees Tj≠Ti that are incident to v (Π(i) does not change), remove v from the associated lists, and update the priority queue.
Given an initial allocation, then run a local search to rebalance the trees. Unlike the constructive algorithm, it allows fractional allocations. Process one vertex at a time (in arbitrary order) by reallocating v's weight among the trees in T(v) in a locally optimal way. More precisely, v is processed in two steps. First, reset v's existing allocation by removing v from all trees it is currently allocated to, thus reducing their weights. Then distribute v's weight among the trees in T(v) (from lightest to heaviest), evening out their weights as much as possible. In other words, add weight to the lightest tree until it is as heavy as the second lightest, then add weight to the first two trees (at the same rate) until each is as heavy as the third, and so on. Stop as soon as v's weight is fully allocated.
Forced assignments are now described. Consider a partial assignment (A,B). If the current lower bound for (A,B) is close enough to the upper bound U, one can often infer that certain free vertices v are to be assigned to A (or B) with no need to branch, reducing the size of the branch-and-bound tree. These forced assignments assign vertices without branching on them, and have been used with other techniques, such as the known VBB. They can be generalized to work with the stronger edge-based bounds. Assume without loss of generality that A is the main side, let T be a tree packing with weight allocations, and let f+p(A) be the current lower bound.
First, consider flow-based forced assignments.
A symmetric argument can be made for vertices w that are reachable from B in Gf, as long as an edge packing T′B is computed on B's side. Assigning such a vertex w to A would increase the overall bound by |T′B(w)| (because the extra flow is on B's side, it does not affect p(T)). If the new bound f+p(T)+|T′B(w)| is U or higher, assign w to B.
Another technique that may be used is subdivision-based forced assignments, which subdivides heavy trees in T.
In an implementation, to recompute the packing bound, compute the total weight allocated to each of the newly-created trees. To do so efficiently, use some precomputation. For each edge e, let T(e)∈T be the tree to which e belongs. Define s(e) as the weight of the subtree of T(e) rooted at e: this is the sum, over all vertices descending from e in T(e), of the (fractional) weights allocated to T(e). If e belongs to no tree, s(e) is undefined. The s(e) values can be computed with a bottom-up traversal of all trees.
These precomputed values are useful when the forced assignment routine processes a vertex v. Each edge e=(v,u) is either a parent or a child edge, depending on whether u is on the path from v to T(e)'s root or not. If e is a child edge, it will generate a tree of size s(e). If e is a parent edge, the new tree will have size s(r(e))-s(e), where r(e) is the root edge of T(e).
Note that both forced-assignment techniques (flow-based and subdivision-based) compute a new packing bound p(T′) for each vertex v they process, which may be costly. In an implementation, an incremental algorithm may be used instead. When computing the original p(T) bound, remember the entire state of its computation (including the sorted list of all original tree weights). To compute p(T′), start from this initial state, discarding trees that are no longer valid and considering new ones appropriately.
VBB branches on the free vertex v that maximizes a certain score based on three parameters: the degree of v, the distance from v to A∪B, and the average weight of the trees T(v) that v belongs to. Together, these criteria aim to maximize the overall (flow and packing) bound. Besides these, a fourth criterion may be considered: whenever the current minimum cut A-B is almost balanced, branch on vertices that already carry some flow in order to increase the number of reachable vertices in Gf. Different combinations of these (or other) criteria may be considered as well.
Like VBB, only update the best upper bound U when the minimum A-B cut happens to be balanced. Moreover, do not use any heuristics to try to find a good initial bound U. Instead, just call the branch-and-bound algorithm repeatedly, with increasing values of U, and stop when the bound it proves is better than the input.
As in VBB, the quality of the lower bounds depends on the degrees of the vertices already assigned to A or B (which limit both the A-B flow and the number of trees). If a graph with small degrees has a large bisection, the branch-and-bound tree can get quite deep. An optional decomposition-based preprocessing technique gets around this.
Numerous other general purpose or special purpose computing system environments or configurations may be used. Examples of well known computing systems, environments, and/or configurations that may be suitable for use include, but are not limited to, PCs, server computers, handheld or laptop devices, multiprocessor systems, microprocessor-based systems, network PCs, minicomputers, mainframe computers, embedded systems, distributed computing environments that include any of the above systems or devices, and the like.
Computer-executable instructions, such as program modules, being executed by a computer may be used. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. Distributed computing environments may be used where tasks are performed by remote processing devices that are linked through a communications network or other data transmission medium. In a distributed computing environment, program modules and other data may be located in both local and remote computer storage media including memory storage devices.
With reference to
Computing device 1100 may have additional features/functionality. For example, computing device 1100 may include additional storage (removable and/or non-removable) including, but not limited to, magnetic or optical disks or tape. Such additional storage is illustrated in
Computing device 1100 typically includes a variety of computer readable media. Computer readable media can be any available media that can be accessed by computing device 1100 and include both volatile and non-volatile media, and removable and non-removable media.
Computer storage media include volatile and non-volatile, and removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Memory 1104, removable storage 1108, and non-removable storage 1110 are all examples of computer storage media. Computer storage media include, but are not limited to, RAM, ROM, electrically erasable program read-only memory (EEPROM), flash memory or other memory technology, CD-ROM, digital versatile disks (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by computing device 1100. Any such computer storage media may be part of computing device 1100.
Computing device 1100 may contain communications connection(s) 1112 that allow the device to communicate with other devices. Computing device 1100 may also have input device(s) 1114 such as a keyboard, mouse, pen, voice input device, touch input device, etc. Output device(s) 1116 such as a display, speakers, printer, etc. may also be included. All these devices are well known in the art and need not be discussed at length here.
It should be understood that the various techniques described herein may be implemented in connection with hardware or software or, where appropriate, with a combination of both. Thus, the processes and apparatus of the presently disclosed subject matter, or certain aspects or portions thereof, may take the form of program code (i.e., instructions) embodied in tangible media, such as floppy diskettes, CD-ROMs, hard drives, or any other machine-readable storage medium where, when the program code is loaded into and executed by a machine, such as a computer, the machine becomes an apparatus for practicing the presently disclosed subject matter.
Although exemplary implementations may refer to utilizing aspects of the presently disclosed subject matter in the context of one or more stand-alone computer systems, the subject matter is not so limited, but rather may be implemented in connection with any computing environment, such as a network or distributed computing environment. Still further, aspects of the presently disclosed subject matter may be implemented in or across a plurality of processing chips or devices, and storage may similarly be effected across a plurality of devices. Such devices might include PCs, network servers, and handheld devices, for example.
Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are disclosed as example forms of implementing the claims.
