On Solving Manufacturing Cell Formation via Bicluster Editing

On Solving Manufacturing Cell Formation via Bicluster Editing

Rian G. S. Pinheiro rian.gabriel@ic.uff.com Ivan C. Martins imartins@ic.uff.br Fábio Protti fabio@ic.uff.br Luiz S. Ochi satoru@ic.uff.br Luidi G. Simonetti luidi@ic.uff.br Anand Subramanian anand@ct.ufpb.br Fluminense Federal University
Niterói, RJ - Brazil
Federal University of Paraíba
João Pessoa, PB - Brazil
Abstract

This work investigates the Bicluster Graph Editing Problem (BGEP) and how it can be applied to solve the Manufacturing Cell Formation Problem (MCFP). We develop an exact method for the BGEP that consists of a Branch-and-Cut approach combined with a special separation algorithm based on dynamic programming. We also describe a new preprocessing procedure for the BGEP derived from theoretical results on vertex distances in the input graph. Computational experiments performed on randomly generated instances with various levels of difficulty show that our separation algorithm accelerates the convergence speed, and our preprocessing procedure is effective for low density instances. Other contribution of this work is to reveal the similarities between the BGEP and the MCFP. We show that the BGEP and the MCFP have the same solution space. This fact leads to the proposal of two new exact approaches for the MCFP based on mathematical formulations for the BGEP. Both approaches use the grouping efficacy measure as the objective function. Up to the authors’ knowledge, these are the first exact methods that employ such a measure to optimally solve instances of the MCFP. The first approach consists of iteratively running several calls to a parameterized version of the BGEP, and the second is a linearization of a new fractional-linear model for the MCFP. Computational experiments performed on instances of the MCFP found in the literature show that our exact methods for the MCFP are able to prove several previously unknown optima.

keywords:
Biclusterization, Manufacturing Cell Formation, Graph Partitioning
journal: European Journal of Operational Research

1 Introduction

The Bicluster Graph Editing Problem (BGEP)is described as follows: given a bipartite graph , where and are non-empty stable sets of vertices and is a set of edges linking vertices in to vertices in , the goal is to transform into a disjoint union of complete bipartite graphs (or bicliques) by performing a minimum number of edge editing operations. Each edge editing operation consists of either removing an existing edge in or adding to a new edge between a vertex in to a vertex in .

In a bipartite graph , a bicluster is a subgraph of isomorphic to a biclique. The existence of biclusters indicates a high degree of similarity between the data (vertices). In particular, a perfectly clustered bipartite graph is called a bicluster graph, i.e., a bipartite graph in which each of its connected components is a biclique. Hence, we can alternatively define the goal of the BGEP, as stated by Amit (2004), as follows: “find a minimum number of edge editing operations in order to transform an input bipartite graph into a bicluster graph”.

(a) Instance.
(b) Solution.
Figure 1: BGEP Example.

Figure 1 shows an example where adding an edge between vertices and deleting the edge between vertices transforms into a bicluster graph. Note that this does not correspond to an optimal solution, since can also be transformed into a bicluster graph by simply removing the edge between and . We remark that a single vertex is considered as a bicluster (e.g., vertex 5 in Figure 1).

A problem similar to the BGEPis the Cluster Graph Editing Problem (CGEP), first studied by Gupta and Palit (1979). Its goal is to transform into a disjoint union of complete graphs (cliques). The CGEPand the BGEPare important examples of partition problems in graphs.

The concept of biclustering was introduced in the mid-70s by Hartigan (1975), but its first use appeared in a paper by Cheng and Church (2000), within the context of Computational Biology. Since then, algorithms for biclustering have been proposed and used in various applications, such as multicast network design (Faure et al., 2007) and analysis of biological data (Abdullah and Hussain, 2006; Bisson and Hussain, 2008).

In Biology, concepts such as co-clustering, two-way clustering, among others, are often used in the literature to refer to the same problem. Matrices are used instead of graphs to represent relationships between genes and characteristics, and their rows and columns represent graph partitions; in this case, the goal is to find significant submatrices having certain patterns. The BGEPcan be used to solve any problem whose goal is to obtain a biclusterization with exclusive rows and columns, i.e., each gene (characteristic) must be associated with only one submatrix.

Amit (2004) proved the -hardness of the BGEPvia a polynomial reduction from the 3-Exact 3-Cover Problem; in the same work, a binary integer programming formulation and an 11-approximation algorithm based on the relaxation of a linear program are described. Protti et al. (2006) proposed an algorithm for the parameterized version of the BGEPthat uses a strategy based on modular decomposition techniques. Guo et al. (2008) developed a randomized 4-approximation algorithm for the BGEP. More recently, Sousa Filho et al. (2012) proposed a GRASP-based heuristic for the BGEP.

Other important application of the BGEP, introduced in this work, is related to the Manufacturing Cell Formation Problem (MCFP). We show that such problems have a high degree of similarity, and that good solutions for the BGEPare close to good solutions for the MCFP. Cellular manufacturing is an application of the Group Technology concept. The goal is to identify and cluster similar parts in order to optimize the manufacturing process. Such a concept was originally proposed by Flanders (1924) and formally described by Mitrofanov (1966) in 1966. In the early 70s, Burbidge (1971) proposed one of the first techniques for creating a system of cellular manufacturing. Since this work, several approaches have been proposed to the MCFP, whose goal is to create the cells in order to optimize the manufacturing process, as described in Section 3.

Our contributions can be summarized as follows. In Section 2, we develop an exact method for the BGEPconsisting of a Branch-and-Cut approach combined with a special separation algorithm based on dynamic programming, and we describe a new preprocessing procedure for the BGEPderived from theoretical results on vertex distances in the input graph. In Section 3, we explore the similarity between the BGEPand the MCFP. We show that the BGEPand the MCFPhave the same solution space, and due to this fact we propose two new exact approaches for the MCFPbased on mathematical formulations for the BGEP. Both approaches use the grouping efficacy measure as the objective function. Up to the authors’ knowledge, these are the first exact methods that employ such a measure to optimally solve instances of the MCFP. The first approach (Section 3.3) consists of iteratively running several calls to a parameterized version of the BGEP, and the second (Section 3.4) is a linearization of a new fractional-linear model for the MCFP. In Section 4, we apply our Branch-and-Cut method for the BGEPto randomly generated BGEP instances with various levels of difficulty. Experimental results show that our separation algorithm is able to accelerate the convergence speed, and our preprocessing procedure for the BGEPis effective for low density instances. In addition, computational experiments are performed on instances of the MCFPfound in the literature. Our exact methods for the MCFPare able to prove several previously unknown optima. Section 5 contains our conclusions.

2 Branch-and-Cut Approach for the BGEP

A mathematical model for the BGEPis described in Amit (2004). It relies on the simple fact that the graph (a path with four vertices, shown in Figure 2) is a forbidden induced subgraph for a bicluster graph. More precisely, for a bipartite graph , is a bicluster graph if and only does not contain as an induced subgraph.

Figure 2: Graph .

The formulation proposed in Amit (2004) is as follows:

(1)
s.t. (2)
(3)

where: (a) are binary variables such that if and only if the solution contains edge ; (b) is the set of edges; (c) the set of non-edges. The objective function (1) counts how many edge editing operations are made. The first and second sums represent the number of edge deletions and edge additions, respectively. Constraints (2) eliminate induced subgraphs isomorphic to . Constraints (3) define the domain of the variables.

2.1 Separation Algorithm

Note that the number of constraints (2) in the above formulation is and therefore it is not advisable to consider all these constraints a priori. This becomes computationally expensive for exact methods, especially when dealing with large instances. Alternatively, we start without such constraints and we add them in a cutting plane fashion as they are violated according to the separation algorithm described below:

  1:  procedure Separation(relaxation )
  2:
  3: =
  4: =
  5: =
  6: =
  7:  then add cut 
  8:  end procedure
Algorithm 1 Separation algorithm

Algorithm 1 works with a linear relaxation as input. Its main objective is to find the most violated constraint (2) for each pair of vertices, and then add it to the model. The idea is to use an auxiliary complete bipartite graph where each edge has a nonnegative weight ; the weights are defined according the values obtained by the linear relaxation, i.e., . Note that an edge may have a zero weight.

After the construction of , a dynamic programming approach is used to find the constraints. It calculates the values , where is the maximum cost between and considering paths with internal vertices. This is explained below in detail.

In line 2, is initialized with the value of the linear relaxation . In line 3, for each pair of vertices, the maximum cost between them considering paths with a single internal vertex is calculated; also, the internal vertex by which such a cost is achieved is saved in variable . Line 4 is similar to line 3, but instead of calculating the maximum cost, it calculates the second maximum cost. Line 5 verifies, for all and , if belongs to the maximum cost path, and chooses to use the maximum cost path or the second maximum cost path. In this case, represents the maximum cost between and using a path that avoids , and stores the corresponding internal vertex. Line 6 calculates the maximum cost between and using two internal vertices, and stores it in ; it represents the “ of maximum cost”; variable saves the internal vertex . Finally, in line 7, for each pair , if the constant is violated () then the cut for and is added to the model.

2.2 Preprocessing Procedure

In this section, we propose a preprocessing procedure to fix variables and/or generate new constraints to the BGEP. The procedure is a direct application of Theorem 1, presented below. New generated constraints will be added to the Branch-and-Cut algorithm.

Theorem 1.

Let be vertices of a bipartite graph , and let be the distance between and in . If then there is an optimal solution in which belong to distinct biclusters.

Proof.

The proof consists of showing that, when , the cost of keeping and in the same bicluster is greater than or equal to the cost of keeping them in distinct biclusters. The following notation is useful for the proof. Let and . Let ; informally, is the cost of removing all edges in between and . Also, let , i.e., is the cost of adding all the missing edges between and in order to create a bicluster with vertex set . If , we simply write and instead of and , and similarly if . Denote by the neighborhood of , and let .

For the case , note that and lie in distinct connected components of , and therefore will belong to distinct biclusters in any optimal solution. Now assume that and there is an optimal solution in which vertices belong to a bicluster with vertex set , where and . We analyze two cases: (Case 1) and (Case 2). Case 1 is divided in two sub-cases: (Case 1a) and (Case 1b).

Let , , , and .

(a) Case 1a
(b) Case 1b
(c) Case 2
Figure 3: Cases of Theorem 1

Case 1a:  In this case, note that . Figure (a)a represents this situation, where is a path between and . Let and defined as follows:

where is the subset of vertices in path . Since and are completely connected by edges in , the following cost is associated with the structure represented in Figure (a)a:

Now consider the following subsets: . Let be another solution with distinct biclusters and such that and . The cost associated with this new situation is given by:

Since , the cost of keeping and in distinct biclusters is not greater than the cost of keeping them in the same bicluster.

Case 1b:  If then and belong to the same part, say , and . Let . Figure (b)b depicts the subsets involved in Case 1b.

Let and defined as and Again, since and are completely connected by edges in , the cost associated with the structure in Figure (b)b is given by:

Assume without loss of generality that . Consider now the subsets . If is another solution with distinct biclusters and such that and , the cost associated with is:

The difference of the costs is given by:

Therefore , i.e., keeping and in distinct biclusters is not more costly.

Case 2:  In this case, and belong to different parts. Assume and , as shown in Figure (c)c. Let and defined as and . The cost corresponding to the biclique with vertex set is:

Now let . Also, let be another solution with distinct biclusters and such that and . The cost associated with is:

Again, the separation into two biclusters is not more costly.

For each case above, we have shown that there is another solution in which and belong to distinct biclusters and whose cost is not greater. Then the theorem follows. ∎

Based on the above theorem, after computing the distance between each pair of vertices, variables can be fixed and cuts can be generated as follows: if vertices and are in different parts and then variable is set to 0. Otherwise, and are in the same part, say , and the cut will be generated for every .

2.3 Instances for the BGEP

To the best of our knowledge, no public sites contain instances for the BGEP. Thus, to evaluate the algorithms proposed in this work, we create random bipartite instances using the model, also known as binomial model, which is a particular case of the model proposed by Gilbert (1959). A bipartite instance is created such that , , and each potential edge of is created with probability , independently of the other edges.

3 Application to Manufacturing Cell Formation

The input of the MCFPis given as a binary product-machine matrix where each entry has value 1 if product is manufactured by machine , and 0 otherwise. Any feasible solution of the MCFPconsists of a collection of product-machine cells, where every product (or machine) is allocated to exactly one cell. Hence, in each cell , machines allocated to it are exclusively dedicated to manufacture products in . In an ideal solution of the MCFP, in each cell there must be a high similarity between the products and machines allocated to it. Figure 4 shows an example of the MCFPsolved as a block diagonalization problem. Note that a solution for the MCFPis obtained by a permutation of rows/columns of the input matrix together with a cell assignment for products and machines. In Figure 4, products and machines are gathered to form a cell, while the remaining products/machines form another cell.

0 1 1 0 1 1 0 0 1 0 0 1 1 0 0 1 0 0 1 0 1 0 0 0 1 1 0 1 1 0 0 0 1 0 1

1 1 1 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 1 1 0 0 0 1 1 0 0 1 1 0 0 1 0 1 1

Figure 4: MCFP example.

Among several measures of performance used as objective functions for the MCFP, the most used in literature is the grouping efficacy , defined as:

(4)

where is the total number of 1’s in the input matrix, and () is the total number of 1’s outside (respectively, inside) diagonal blocks in the solution matrix.

3.1 The size of the cells

Some works define a minimum value for the size of the cells. For instance, in (Chandrasekharan and Rajagopalan, 1987; Srinivasan and Narendran, 1991; Gonçalves and Resende, 2004), cells with less than two products or machines are not allowed; such cells are called singletons. However, there is no consensus with respect to the size of the cells. Others studies do not consider any size constraint, allowing the existence of empty cells, such as the work by Pailla et al. (2010). An example of a solution with an empty cell is shown in Figure 5.

This work deals with two versions of the MCFPfound in the literature:

  1. unrestricted version, allowing singletons and empty cells;

  2. with restrictions (minimum size for each cell).

0 1 1 0 1 1 0 0 0 0 0 1 1 0 0 1 0 0 0 0 1 0 0 0 1 0 0 1 1 0 0 0 1 0 1 0 0 0 0 1

1 1 1 0 0 1 1 0 0 0 0 1 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 1 1 0 0 1 0 0 1 0 0 1 0 0

Figure 5: Example with a singleton and an empty cell.

3.2 Similarity between the BGEP and the MCFP

Given an input for the MCFP, we can define an input for the BGEPby setting as the set of products, as the set of machines, and as the set of edges such that is an edge of if and only if the entry of the input matrix for the MCFPhas value 1. In addition, a solution for the BGEPwith input can be transformed into a cell assignment for machines/products.

The two problems (the BGEPand the MCFP) are very similar, but a point to note is that biclusters have no size limitation. Thus, we define a new BGEPvariant, the Bicluster Graph Editing Problem with Size Restriction (BGEPS), to make a more precise correspondence with the MCFP. Informally, the BGEPSis defined by adding size restrictions to the BGEP: every bicluster in must now have at least vertices in and vertices in . In the translation from the BGEPSto the MCFP, is the minimum cell size for rows and the minimum cell size for columns.

We propose the following formulation for the BGEPS:

(5)
(6)
(7)
(8)
(9)

Lemma 2 makes the correspondence between the BGEPSand the MCFP.

Lemma 2.

There is a one-to-one correspondence from the feasible solution set of the BGEPSto the feasible solution set of the MCFP. In addition, for every pair of corresponding feasible solutions, the sizes of biclusters and cells are preserved.

Proof.

Consider an instance of the BGEPSconsisting of a bipartite graph with parts and . It is easy to see that it corresponds to an instance of the MCFP: Figures (a)a and (c)c show an example of a bipartite graph and a corresponding product-machine matrix . Let and be the feasible solution sets of the BGEPSand the MCFP, respectively, associated with and .

Let be the transformation of a solution in to a solution in defined as follows. If vertices and belong to the same bicluster in then product and machine are gathered inside the same cell in , as shown in Figures (b)b and (d)d. Thus, each solution in is uniquely mapped into one solution in .

Similarly, let be the inverse transformation of that maps each solution in into a solution in , as follows: if a product and a machine are in the same cell then the corresponding vertices and belong to the same bicluster in .

Since and are injective functions, there is a one-to-one correspondence between and . Moreover, if and are corresponding feasible solutions, it is easy to see that a bicluster in corresponds to a cell containing exactly products, machines, and entries; also, a cell with entries in corresponds to a bicluster with exactly vertices and edges. ∎

An optimal solution of the BGEPdoes not necessarily correspond to an optimal solution of the MCFP, because the objective functions are different; however, corresponds to a feasible solution of the MCFP. For example, Figure (b)b shows an optimal solution of the BGEP, but in Figure (d)d the corresponding solution of the MCFPis not optimal. This happens because an edge deletion, informally, corresponds to a ‘1’ outside cells, and an edge addition corresponds to a ‘0’ inside a cell. That is, for the BGEP, additions and deletions have the same weight, but for the MCFP, a ‘0 inside’ is preferable than a ‘1 outside’ (using the objective funtion (4)). In Figure (a)a, for instance, adding an edge between vertices and is better than deleting the edge between and , in terms of the corresponding solutions of the MCFP.

(a) BGEPSinstance.
(b) BGEPSsolution.
1 1 0 0
1 1 0 0
0 1 0 0
0 0 1 1
0 0 0 1
(c) MCFPinstance.
1 1 0 0
1 1 0 0
0 1 0 0
0 0 1 1
0 0 0 1
(d) MCFPsolution.
Figure 6: BGEPS MCFPexample.

3.3 A First Exact Algorithm for the MCFP

In this section, we propose an exact iterative method for the MCFP. In Lemma 3 we describe upper/lower bounds for the MCFP. Next, we define a parameterized version of the BGEPSto be used in the exact algorithm.

Lemma 3.

Let be the optimal solution value of the BGEPfor an instance , where and are the number of edge additions and deletions, respectively, and let be the instance of the MCFPcorresponding to . Then is an upper bound and is a lower bound for the optimal solution value of the MCFPwith input , where .

Proof.

Let be the objective function of the MCFP, where and denote, respectively, the number of ones outside cells and zeros inside cells in . Consider also that , for a positive constant .

Taking as a function of , we obtain that

Calculating the derivative,

Since for every , is an increasing function. Since , we have , and thus

In other words, in the best case, the edge editing operations would correspond to edge additions and edge deletions, since as increases, increases as well.

Now consider that is a feasible solution value of the BGEP. It follows that and

Therefore, is an upper bound for the optimal solution value of the MCFP.

Showing that is a lower bound is trivial since is a feasible solution value of the MCFP, as shown in Lemma 2. ∎

We now define a parameterized version of the BGEPS, the Bicluster Graph Editing Problem with Size Restriction() (BGEPS()), which consists of finding a solution of the BGEPSwith exactly edge editing operations, such that the number of edge deletions is minimized. A formulation for the BGEPS()is described below:

(10)
(11)
(12)
(13)
(14)
(15)
(16)

We now describe the exact iterative method for the MCFP(Algorithm 2 below). The idea is to make several calls to the BGEPS(). At each iteration, we seek for a solution with fewer deletions. Constraint (15) tells the model that the optimal value is less than , which is obtained using previous feasible solutions.

1:procedure ECM(instance )
2:     let be the instance of the BGEPScorresponding to
3:      Solve the BGEPSfor input , obtaining additions and deletions
4:     
5:     
6:      A bound for the number of deletions already found
7:     
8:     while  do
9:          Solve the BGEPS()with for
10:         if  then
11:              
12:         end if
13:         if  then
14:              
15:              
16:         end if
17:         
18:         
19:     end while
20:     return
21:end procedure
Algorithm 2 Exact iterative method for the MCFP

The correctness of Algorithm 2 is shown in the next result.

Theorem 4.

Algorithm ECM (Algorithm 2) returns an optimal solution value for the MCFP.

Proof.

Algorithm 2 seeks the optimal solution value iteratively through several calls to the the BGEPS(), starting with the number of edge editing operations of the BGEPS. At each iteration new bounds are calculated (variables and ). Iterations are performed until the upper bound is equal to the lower bound, meaning that from that point there is no better solution.

By Lemma 3, lines 4, 5, and 14 indeed calculate the lower and the upper bounds. It remains to show that line 17 actually calculates an upper bound.

The value of an optimal solution of the BGEPSis not necessarily optimal for the MCFP. In this case, the optimal solution value of the MCFPcorresponds to a solution of the BGEPSwith more editing operations than . To find , we use the BGEPS(). The objective function of the BGEPS()leads to a solution with the maximum number of edge additions among all solutions with exactly editing operations.

In line 9, a call to the BGEPS()is made, using editing operations, and new values and are calculated. Then line 17 actually defines a new upper bound, because if there were a solution value between the new bound and the previous bound, the algorithm would have already found such a value in a previous iteration. Since the upper bound decreases along the iterations, we conclude that Algorithm 2 works correctly. ∎

3.4 New linear-fractional model for the MCFP

According to Lemma 2, the BGEPSand the MCFPhave the same feasible solution space. Thus, the constraints of the BGEPSformulation can be used in a new formulation for the MCFP. The adaptation of the objective function is made according to the grouping efficacy described in Section 3. By setting and , we propose a new formulation for the MCFPbased on linear-fractional programming:

3.5 Linear Formulation for the MCFP

In this section we propose a linearization for the linear-fractional model described above. The process consists of adding binary variables that assume value 1 if and only if the solution contains deletions and additions. Each variable is associated with a cost in the objective function. Let and be lower bounds for the MCFPand BGEP, respectively. Define a set . In this case, can be obtained heuristicaly, whereas can be, for example, the value of the linear relaxation of the BGEP.

The linear formulation proposed is as follows:

(17)
st (18)
(19)
(20)
(21)
(22)
(23)

The objective function (17) computes the maximum cost . Constraints (18) eliminate induced subgraphs isomorphic to . Constraint (19) imposes that exactly one variable should assume value 1. Constraints (20) and (21) state that the number of deletions and additions must be and , respectively. Constraints (22) and (23) define the domain of the variables.

3.6 MCFP Instances

The MCFPhas been explored in the literature for many years, and several works have proposed instances for this problem. In this paper, we used 35 instances available in Gonçalves and Resende (2004), which have been used in many other papers. In Table 1, we present the instances with its dimensions. To the best of our knowledge, this work is the first one that finds the optimal solutions of all such instances.

Instance Dimension Instance Dimension
King1982 Kumar1986
Waghodekar1984 Carrie1973b
Seifoddini1989 Boe1991
Kusiak1992 Chandrasekharan1989_1
Kusiak1987 Chandrasekharan1989_2