Cooperative Based Software Clustering on ... - Semantic Scholar
Cooperative Based Software Clustering on Dependency Graphs A. Ibrahim, D. Rayside
R. Kashef
Electrical & Computer Engineering Dept. Faculty of Engineering University of Waterloo Waterloo, Canada {a24ibrah, derek.rayside}@uwaterloo.ca
Dept. of Management Sciences Faculty of Engineering University of Waterloo Waterloo, Canada [email protected]
Abstract— Software clustering involves the partitioning of software system components into clusters with the goal of obtaining optimum exterior and interior connectivity between the components. Research in this area has produced numerous algorithms with different methodologies and parameters. In this paper, we propose a novel ensemble approach that synthesizes a new solution from the outcomes of multiple constituent clustering algorithms. The main idea behind our cooperative approach was inherited from machine learning, as applied to document clustering, but has been modified for use in software clustering. The conceptual modifications include working with differing numbers of clusters produced by the input algorithms and using graph structures rather than feature vectors. The empirical modifications include experiments for selecting the optimal cluster merging criteria. Case studies using open source software systems show that forging cooperation between leading state-of-the-art algorithms produces better results than any one state-of-the-art algorithm considered.
I.
INTRODUCTION
Software systems support numerous business, government, and social institutions. As the requirements of these institutions change, so must the software that supports them; however, changing software systems that govern complex actions is much more easily said than done. Creating an adequate model of the structure of a system and keeping that model coherent with respect to modifications that occur as the system evolves are among the many critical problems that software developers face. Without an automated approach to acquiring insight into the system design, a software maintainer often modifies the source code without a complete understanding of its organization. Software clustering is an automated approach that can result in improvements in the structure of the software (software restructuring) and a reduction in the complexity of large modules (source code decoupling). In the last two decades, software clustering has been the target of an enormous amount of research [1],[2],[3], with a consequently wide range of criteria for establishing the clusters used in the clustering techniques described in the literature. Most of these algorithms have been successfully applied in specific software systems. However, the question of how a software engineer can identify the clustering algorithm best suited for a particular software system remains unanswered.
Rather than relying on the selection of a single algorithm, our hypothesis is that an ensemble approach that synthesizes a solution from the results of an aggregation of constituent clustering algorithms will produce measurably better results than does any one of those algorithms individually. This paper presents a new proposed ensemble clustering approach that combines a variety of graph-based software clustering techniques in order to provide measurably better modularity clustering than that produced by any single individual technique. The proposed approach not only opens a new perspective on the application of ensemble clustering on graphs but also relaxes some of the assumptions mentioned in the literature [3],[4]. The rest of this paper is organized as follows: section 2 provides a brief review of literature reports related to software clustering. Section 3 presents a detailed explanation of the proposed software clustering approach. Experimental results are discussed in section 4, and a summary of this study is included in section 5, along with suggestions for future work. II. RELATED WORK This section provides a review of the literature related to software ensemble clustering, dependency graphs, and dependency graph partitioning. A. Ensemble Software Clustering Many researchers have investigated the problem of constructing an efficient and robust ensemble committee of clustering algorithms [3], [4], [5], [6], [7]. Strethl et al. [7] proposed a hyper-graph partitioned approach based on a combination of different clustering results using different clustering algorithms. This approach starts by representing each partition in the cluster ensemble with a hyper-edge so that the problem becomes reduced to a hyper-graph partitioning problem. Ayad and Kamel [5] presented a cumulative voting method for obtaining consensus from partitions with differing numbers of clusters. They introduced several cumulative vote-weighting schemes and corresponding algorithms and computed an empirical probability distribution that summarizes the partitions. Zeng et al. [6] proposed a robust meta-clustering approach for combining different clustering results. In their research, they transformed the individual clustering results into a distance
matrix and then applied a hierarchical clustering algorithm to re-cluster the distance matrix. In [4], Kashef et al. used ensemble clustering to achieve a common benefit (e.g., a global clustering solution) based on agreement among peer clustering algorithms. They called their approach cooperative clustering (CC), and it includes three phases: first, run each of the constituent clustering algorithms; second, from the output of the clustering algorithms, find the common elements that they agree on; third, merge these elements into existing (or new) clusters. Although the reported results were extraordinary, they were based on the assumption that an identical number of clusters is produced by each of the input algorithms. The findings were also the result of the use of vectors of quantifiable features, which may not be suitable for direct application in software structures or in dependencies that describe the relationships between various entities in the software. Naseem et al. [3] were inspired by the work of [4]. They investigated whether the results could be improved through the application of CC for software modularization. Although the CC they used was slightly different from the version described in [4], it is still based on the vectors of quantifiable features. They proved that more than one similarity measure can be made to cooperate during the clustering process and confirmed the relation between arbitrary decisions during the clustering process and the modularization results. They also determined that the cooperative technique improves results for different types of hierarchical clustering algorithms with respect to both binary and non-binary features. Other approaches based on ensemble clustering were proposed in [8], [9], [10]. B. Dependency Graphs The quality of software dependencies has a substantial impact on software understandability [11]. A dependency graph is a directed graph that represents the dependencies of several objects one another. Dependencies include several types: data dependencies between the definition and use of values, and call dependencies between the declaration of functions and the sites where they are called. Dependency types are discussed in detail in [12]. Software dependencies can be simple, with one dependent and one dependee; transitive, in which a dependency path is created among multiple items; or cyclic, in which the dependency path starts and ends with the same item. Dependencies in software systems can be modeled and examined in a number of ways, ranging from informal box-and-arrow diagrams to Unified Modeling Language (UML) diagrams or a Dependency Structure Matrix (DSM). In the experiments conducted for this study, a system-wide dependency graph was generated using Lattix [14] at the function level. The Lattix tool provides the option of tracking dependency information at the function level, including calls, imports, and exports. Lattix can generate a system dependency graph from both native and JAVA bytecode. For the purposes of the study presented in this paper, only the occurrence of dependencies such as “A depends on B” were considered; multiple dependencies were disregarded.
C. Dependency Graph Partitioning The literature describes numerous proposed algorithms for partitioning dependency graphs [1],[2],[3]. Most research on dependency graph partitioning has been conducted using Lattix[14] and Bunch [19] tools. In Lattix, dependency graph partitioning is performed by rearranging rows of the DSM matrix so that clusters of elements are positioned along the diagonal. Lattix proposed several algorithms and heuristics to aid in the determination of appropriate objective functions and optimizations. Bunch includes three categories of partitioning algorithms, each with different configurations: hill climbing, genetic, and exhaustive. Bunch begins the partitioning process by creating a random partition of the module dependency graph (MDG) of the structure. In Bunch, clusters are determined by moving nodes between the clusters, or in some cases, creating new clusters in order to maximize an objective function that is defined by Mitchell [15] as the Turbo Modularization Quality (TurboMQ). This function has the property of rewarding cohesive clusters while penalizing extreme coupling between clusters. For this study, Bunch version 3.3.6 was used and the experiments were based on two versions of a hill-climbing algorithm, which are referred to as Nearest Ascent Hill Climbing (NAHC) and Steepest Ascend Hill Climbing (SAHC) [4]. III. COOPERATIVE CLUSTERING ON DEPEDENENCY GRAPHS The work presented in this paper is based on an extension of the idea of cooperative clustering (CC) proposed by Kashef [4] for document categorization in order to synthesize the clustering from the output of an ensemble of constituent clustering algorithms. The CC approach entails three steps. First, execute each of the constituent clustering algorithms. The points of agreement between these constituent clusterings are then determined and take the form of sub-clusters. Finally, a coherent merging of sub-clusters is performed in order to reveal the expected (natural) number of clusters. Four aspects of CC should be modified so that it will be appropriate in the paradigm of software clustering. First, one assumption inherent in CC is that each constituent clustering technique will produce the same number of clusters. The approach should thus be adapted to accommodate the reality that heterogeneous software clustering approaches produce different numbers of clusters. Second, the CC merging operation is based on numerical features extracted from a document corpus, which means that it cannot handle the graph structure inherent in software. Third, CC is built on an assumption that the number of output clusters is known a priori, which is not usually the case in software systems. A final consideration is that the merging criteria in CC are based on the frequency between the numerical features of a document corpus. This function must be revised so that it rewards cohesive and penalizes extreme coupling between software dependency clusters. In this work, CC has therefore been modified to address all of these challenges, and the modified version has been named CC/G to indicate that it is based on graphs rather than on numerical feature vectors. Algorithm 1 illustrates the CC/G algorithm in pseudo code. CC/G is an unsupervised learning algo-
rithm for clustering a software graph structure into k partitions based on cohesion and coupling among its dependencies. The main idea is to apply different clustering algorithms on the software dependency graph. Each algorithm will provide different k clusters. A common agreement among those clusterings is then found. This agreement identifies the minimum number of k clusters that the software should have. The last step is to merge the remaining software elements that exhibited disagreement inbetween the clusters that were initially determined using optimum cohesion and coupling values. Input: program file structure and set of C clusterings Output: k clusters For different values of k 1. Generate the DSM among n software entities 2. Apply each of the input clustering algorithms on the DSM to generate ki clusters, i =1,2,..,C 3. Find the common agreement of the ki clusters in terms of sub-clusters 4. Repeatedly merge sub-clusters until k clusters are reached using the merging factor (mf) 5. Evaluate the quality of the k clusters using the TurboMQ [13] measure End Algorithm 1: Pseudocode for clustering program dependency structures using a cooperative strategy
CC/G was designed with two phases: an agreement phase and a merging phase. The first phase employs a strategy for determining agreement among the multiple clustering algorithms in order to find the set of intersections between the different clusterings in the form of sub-clusters. The extracted sub-clusters are then represented by a vector of the agreement memberships. In the second phase, the sub-clusters are merged into one cluster based on the cohesiveness and coupling between elements. The merging process converges when all software elements are positioned in the established k clusters. A. Agreement Phase This phase is employed in order to discover the common patterns among the different clusterings and to produce a set of disjoint sub-clusters. In the CC approach, the authors assume that each clustering technique produces the same number of clusters (i.e., all ki are identical) [4]. They generate a number of disjoint sub-clusters as kCi , where ki is the number of clusters generated by a partitioning algorithm i, and C is the number of partitioning techniques. However, due to the nature of the software clustering domain, software systems may have different decompositions [16]. Therefore, in this work, we generalized the sub-cluster generation by taking an unequal number of clusters and generating sub-clusters based on kmax , such that kmax = max(ki); i = 1,2, … C. To determine the association between the corresponding set of sub-clusters, a membership vector called ComemVector is generated based on the calculation of a sub-cluster membership value assigned to each software entity xi. This vector is of size
n, where n is the number of software entities. Consequently, ComemVector is defined as ComemVector(i) = mem(xi); i = 1, … , n
(1)
This clustering-mapping recognizes the set of disjoint subclusters generated by the intersection of the C partitioning techniques. The new cooperative sub-cluster membership for a given software entity xi is defined as C −1 mem( xi ) = mem( xi ) P1 kmax + ... + mem( xi ) PC kmax
(2)
where i = 1,..., n ; j = 1,..., C ; and mem( x ) P is a cluster label j for a software entity x assigned by a partitioning algorithm Pj. The membership function satisfies the following condition: for any two classes x and y, if mem(x) = mem(y), then x and y belong to the same cluster (or sub-cluster). Using kmax for the generation of the sub-cluster memberships causes an enormous growth in the number of sub-clusters generated, especially for large values of kmax. In addition, the cooperative membership vector most probably has sparse entries. Therefore, only the non-zero values of ComemVector are passed into the next CC/G phase. B. Merging Phase The concept behind this phase is that the natural number of clusters is obtained through the merging of the generated subclusters. The best sub-clusters chosen for merging are defined as those that achieve maximum intra-connectivity among their own cluster elements and minimum inter-connectivity with respect to other clusters. A novel objective function is used for merging the sub-clusters. This function measures the quality of the merging of two sub-clusters i and j based on the value of the merging factor (mf), which can be calculated as follows:
mf i , j =
µi + µ j + ∑(ε ij + ε ji ) Ni N j ( Ni N j − 1)
(3)
where µi and µj are the intra-connections between the elements of sub-clusters i and j, respectively. A higher value of intraconnectivity is equivalent to a high degree of cohesion. Ɛij is defined as the sum of all relationships that exist between classes in two different sub-clusters i and j. Ɛij has values between 0 and 1. As applied to software systems, a 0 value means that no subsystem-level relations exist between subsystem i and subsystem j, and a value of 1 indicates that all modules in subsystem i are related to all modules in subsystem j and vice versa. A low inter-connectivity value signifies low coupling. Ni and Nj are the number of entities in each sub-cluster i, j, respectively. In case there exist sub-clusters with only one entity (singletons), CC/G is going to add them in separate iterations, so Ni and Nj each will never equal 1 at the same time. The proposed merging factor is used as a measure of the cohesiveness of the merging of two sub-clusters. Thus, the two sub-clusters that have a maximum mf value are merged into a new cluster. The sub-cluster list is then updated based on the new added cluster. This step is repeated until no additional merging is required.
IV.
EXPERIMENTAL SETUP AND RESULTS
This section describes a number of experiments that are conducted in order to demonstrate the superior efficiency of the proposed cooperative methodology and approach compared to the individual clustering techniques with respect to clustering quality and modularity. A. Benchmark Programs The experiential work was conducted with the use of open source software projects. In particular, six open source Java projects randomly selected from a list of Helix benchmark programs were analyzed [17]. The Helix benchmark suite is a compilation of the release histories of a number of non-trivial Java Open Source Software projects. This benchmark dataset is discussed in Vasa’s PhD thesis [18]. The first and second sets of software systems used in our experiments are produced in a variety of sizes, functionalities, and development philosophies, as listed in Tables I and II, respectively. In particular, the first and second columns in Tables I and II show the name of the system used in the experiments and its version. The third and fourth columns indicate the number of classes and interfaces in each program graph, respectively. The program sizes are listed in the last column. It should be noted that Table II provides information about a later version of each software system listed in Table I. TABLE I. Name Acegi Cocoon JabRef Proguard Struts Xwork
FIRST SET OF BENCHMARK PROGRAMS USED IN THE EXPERIMENTS Version 0.5.0 1.7 1.1 1.0 0.5 1.0
Classes 106 84 103 90 102 74
Interfaces 29 21 5 22 4 26
Size in Bytes 165K 166K 405K 136K 152K 145K
TABLE II. SECOND SET OF BENCHMARK PROGRAMS USED IN THE EXPERIMENTS Name Acegi Cocoon JabRef Proguard Struts Xwork
Version 0.5.1 1.8 1.2 1.1 1.0 1.1
Classes 113 90 150 95 183 105
Interfaces 30 23 8 23 2 31
Size in Bytes 173K 239K 584K 140K 319K 224K
B. Clustering Evaluation The quality of the partitioning provides an idea of how good the decomposition is. To evaluate the quality of the software partitioning algorithms, a number of criteria were adopted, including the quality of the generated cluster and the distance (or similarity) between the decompositions. Two experiments are presented in this section as examples of those criteria. Using the TurboMQ measure for the same software systems, the goal of the first experiment was to compare the solutions generated with the proposed cooperative approach and those based on the individual partitioning algorithms. The second experiment was aimed at using the MoJo distance to measure the similarity between the partitioning approaches
[20]. Tables III to VIII list the TurboMQ values for different decompositions, as evaluated for the first set of each test system using the CC/G, Lattix, NAHC, SAHC, and current package structure partitioning. The term “current” in each of the tables refers to the package structure of the benchmark systems based on the version indicated. The symbol “-” at a specific number of clusters k means that the corresponding partitioning algorithm does not generate k clusters. The package structure of the datasets was considered to be flat partitions. A flat partition does not contain nested clusters but has only one level of clusters and one level of entities. Table IX shows the percentage improvement in the TurboMQ measurements when CC/G is used compared to the values obtained for the benchmark systems using the leading approaches. CC/G produces a TurboMQ improvement for up to 53 % compared to that achieved with the current decomposition for Xwork 1.0 and up to 51 % compared to the Lattix result for Proguard 1.0. CC/G also provides a 47 % enhancement in the TurboMQ value compared to that for the NAHC algorithm for the Acegi 0.5, and up to a 59 % improvement compared to the measurement for the SAHC decomposition for Struts 0.5. On average, the TurboMQ value achieved with CC/G represents a 22 %, 39 %, 21 %, and 26 % improvement over those produced with the current decomposition, Lattix, NAHC, and SAHC, respectively, as shown in Table IX. C. Similarity Measures In general, a similarity measure provides an idea of how good (effective) the resultant decomposition is, which can be determined from a comparison of the decomposition produced by the clustering algorithm with the benchmark or expert decomposition. The MoJo [20],[21],[22] distance metric was used for this evaluation. The similarity between two partitioning solutions Ci and CR is defined as follows:
MoJo(Ci , CR ) mSim(Ci , CR ) = 1 − ×100% n
(4)
where CR is the assumed reference decomposition, Ci is the partitioning produced by algorithm i, and n is the number of software entities to be clustered. Intuitively, the higher the mSim(Ci,CR), the closer the clustering results to the reference decomposition. Because no reference decompositions for the software systems other than their current package structure were available, the following results were built based on the assumption that the current system partitioning serves as the reference decomposition. Similarity was hence established by examining how close the different system decompositions were to the current decomposition. The goal was to demonstrate that CC/G is biased toward neither the current system decomposition nor the other partitionings but rather that it adequately generates measurably balanced solutions with improved modularity. Tables X and XI present the similarity (mSim) results for two subsequent versions of the programs under study. The mSim values are percentage values. The larger the mSim value, the closer the decomposition is to its current. In Table X, it can be seen that the CC/G partitioning is not as close to the current partitioning as Lattix is for Acegi 0.5, Proguard 1.0, and Xwork
1.0, nor is it as far as NAHC and SAHC are for Acegi 0.5 and Xwork 1.0.
As shown in Table XI, compared to Lattix, NAHC, and SAHC, CC/G is able to find a measurably better solution for Acegi 0.5.1, Cocoon 1.8, Jabref 1.2, Proguard 1.1, and Xwork 1.1. The Struts 1.0 system, CC/G, and SAHC also generate almost the same partitioning as with the current decomposition.
TABLE III. TURBOMQ VALUES FOR ACEGI 0.5.0 Clustering/# of clusters Current Lattix NAHC SAHC CC/G
k=5
k=8
k = 10
3.1616 3.8859 4.4203
6.2504 6.6756
6.259 8.5162
TABLE IX. IMPROVEMENT (%) IN THE TURBOMQ (TMQ) VALUE PRODUCED BY CC/G
TABLE IV. TURBOMQ VALUES FOR COCOON 1.7 Clustering/# of clusters Current Lattix NAHC SAHC CC/G
k=5
k=7
k = 10
k = 12
k = 18
k = 22
3.357 3.839
5.497 5.839
7.83 8.687
9.401 10.013
11.7726 16.013
14.471 19.76
TABLE V. TURBOMQ VALUES FOR JABREF 1.1 Clustering/# of clusters Current Lattix NAHC SAHC CC/G
k=6
k=7
k = 15
k = 17
4.972 3.139 3.642 4.997
4.716 5.614
9.123 11.934
10.555 12.919
TABLE VI. TURBOMQ VALUES FOR PROGUARD 1.0 Clustering/# of clusters Current Lattix NAHC SAHC CC/G
k=3
k=4
k=5
k=9
1.3049 1.9734
2.1165 2.6231
2.3465 3.3215
5.4928 6.1132
TABLE VII. TURBOMQ VALUES FOR STRUTS 0.5 Clustering/# of clusters Current Lattix NAHC SAHC CC/G
k=4
k=6
k=8
2.798 1.852 3.167
2.776 5.275
2.918 7.114
TABLE VIII. TURBOMQ VALUES FOR XWORK 1.0 Clustering/# of clusters Current Lattix NAHC SAHC CC/G
k=2
k=5
1.0341 1.5282
2.6721 4.0507 3.789 4.1001
decompositions can therefore be accepted as a partitioning solution for both benchmark systems using the mSim formulation.
As shown in Table X, for the Proguard 1.0 and Struts 0.5 systems, the mSim value of CC/G is much closer to that of SAHC. These results indicate that, of the family of solutions provided, the SAHC decomposition of these two benchmark datasets is the closest to the solution generated by CC/G. Both
CC/G vs. Current Lattix NAHC SAHC
Acegi 0.5
Cocoon 1.7
Jabref 1.1
Proguard 1.0
Struts 0.5
Xwork 1.0
Avg. %
36 43 16 13
6 13 27 18
0.5 38 25 17
24 51 11 42
12 42 47 59
53 48 1 8
21.92 39.17 21.17 26.17
TABLE X. SIMILARITY VALUES (%) OBTAINED WITH THE NAHC, SAHC, LATTIX, AND CC/G SYSTEMS WITH RESPECT TO THE CURRENT STATE PARTITIONING (FIRST SET) Programs/Clustering Acegi 0.5 Cocoon 1.7 Jabref 1.1 Proguard 1.0 Struts 0.5 Xwork 1.0 Average similarity
NAHC 37.78 73.27 62.26 67.52 80.19 39 60.00
SAHC 37.04 45.045 41.035 70.09 66.98 35 49.20
Lattix 77.78 44.55 34.435 99.91 51.89 97 67.59
CC/G 47.65 60.73 57.31 74.15 64.78 65.5 61.69
TABLE XI. SIMILARITY VALUES (%) OBTAINED WITH THE NAHC, SAHC, LATTIX, AND CC/G SYSTEMS WITH RESPECT TO THE CURRENT STATE PARTITIONING (SECOND SET) Programs/Clustering Acegi 0.5.1 Cocoon 1.8 Jabref 1.2 Proguard 1.1 Struts 1.0 Xwork 1.1 Average similarity
NAHC 55.92 50 55.92 45.61 48.46 64.38 53.38
SAHC 44.63 53.08 44.63 47.37 54.8 62.75 51.21
Lattix 96.69 100 96.69 82.46 74.23 82.46 88.76
CC/G 67.11 61.49 67.11 64.62 56.69 75.88 65.48
In summary, CC/G produces unbiased results for four of the six benchmark systems listed in Table X and five of the six benchmark systems listed in Table XI. Using the average similarity values from Tables X and XI, it can be seen that, as an ensemble approach, CC/G generates unbiased structure clusterings that are closer to the current state partitioning (reference decomposition) than those produced by the individual approaches adopted. These balanced results are augmented by an enhancement of quality that demonstrates the major advantages of using CC/G as a cooperative consensus clustering approach. The results of these experiments indicate that the concept of using common patterns as a basis for software clustering offers a distinct advantage, because it is clear that this approach can create decompositions that are unbiased toward both the current decomposition and the ones used. V.
CONCLUSION AND FUTURE WORK
A new graph-based clustering approach (CC/G) that is built on a combination of the results of leading state-of-the-art graph
clustering methods is introduced in this paper. The new approach combines a variety of software clustering techniques in order to provide measurably superior clustering compared with that produced by any single individual approach. A variety of experiments have been conducted using a number of software benchmark datasets. Experimental results using different validation measures demonstrate that the proposed CC/G algorithm outperforms the individual software clustering algorithms. Based on the TurboMQ quality measure, the clustering solutions obtained using CC/G have high cohesion and low coupling, which establishes the greater efficiency of the CC/G algorithm compared to that of the input constituents. As established by the MoJo distance measure, CC/G clusterings have been shown to be unbiased toward the current partitioning and toward the decompositions obtained by any of the input algorithms. This work demonstrates the value of CC/G clustering for partitioning software systems. Further investigation is required with respect to the use of other types of clustering algorithms that are based not only on structural information but also on different/orthogonal categories of information, such as information retrieval algorithms, e.g., latent semantic indexing (LSI) [23], latent Dirichlet allocation (LDA) [24], [25] or the CC algorithm [4]. CC/G could also be extended to include the use of the labeling technique presented by Siddique [26], [27]. An additional suggestion is that the proposed approach can be used in a different challenging software domain problems, such as software bug report classification for open-source systems. This approach could serve as a filter between contributors and arriving defect reports.
[8]
[9]
[10]
[11]
[12] [13]
[14]
[15]
[16] [17] [18] [19]
[20]
ACKNOWLEDGMENT We thank the Electrical & Computer Engineering Department at the University of Waterloo for funding this work.
[21]
REFERENCES [1] [2]
[3] [4] [5]
[6]
[7]
Mark Shtern and Vassilios Tzerpos, “Clustering methodologies for software engineering,” Advances in Software Engineering, vol. 2012, Xia Xu, Chung-Horng Lung, M. Zaman, and A. Srinivasan, “Program restructuring through clustering techniques,” in Source Code Analysis and Manipulation, 2004. Fourth IEEE International Workshop on, 2004, pp. 75–84. R. Naseem, O. Maqbool, and S. Muhammad, “Cooperative clustering for software modularization,” Journal of Systems and Software, 2013. Rasha Kashef and Mohamed S. Kamel, “Cooperative clustering,”Pattern Recognition, vol. 43, no. 6, pp. 2315 – 2329, 2010. H.G. Ayad and M.S. Kamel, “Cumulative voting consensus method for partitions with variable number of clusters,” Pattern Analysis and Machine Intelligence, IEEE Transactions on, vol. 30, no. 1, pp. 160– 173, 2008. Yujing Zeng, Jianshan Tang, Javier Garcia-Frias, and Guang R. Gao, “An adaptive meta-clustering approach: Combining the information from different clustering results,” in Proceedings of the IEEE Computer Society Conference on Bioinformatics, Washington, DC, USA, 2002, CSB ’02, pp. 276–, IEEE Computer Society. Alexander Strehl and Joydeep Ghosh, “Cluster ensembles — a knowledge reuse framework for combining multiple partitions,” J. Mach. Learn. Res., vol. 3, pp. 583–617, Mar. 2003.
[22]
[23]
[24]
[25]
[26] [27]
G. Forestier, P. GanÃ˘garski, and C. Wemmert, “Collaborative clustering with background knowledge,” Data & Knowledge Engineering, vol. 69, no. 2, pp. 211 – 228, 2010. A. L N Fred and A.K. Jain, “Data clustering using evidence accumulation,” in Pattern Recognition, 2002. Proceedings. 16th International Conference on, 2002, vol. 4, pp. 276–280 vol.4. Xi Wang, Chunyu Yang, and Jie Zhou, “Clustering aggregation by probability accumulation,” Pattern Recogn., vol. 42, no. 5, pp. 668– 675, May 2009. Cleidson Ronald Botelho De Souza, On the relationship between software dependencies and coordination: field studies and tool support, Ph.D. thesis, California State University at Long Beach, Long Beach, CA, USA, 2005, AAI3200278. Norman Wilde, “Understanding program dependencies,” 1990. Brian S. Mitchell, “A heuristic approach to solving the software clustering problem,” in Software Maintenance, 2003. ICSM 2003. Proceedings. International Conference on, 2003, pp. 285–288. Neeraj Sangal, Ev Jordan, Vineet Sinha, and Daniel Jackson, “Using dependency models to manage complex software architecture,” SIGPLAN Not., vol. 40, no. 10, pp. 167–176, Oct. 2005. Brian S. Mitchell and Spiros Mancoridis, “Craft: a framework for evaluating software clustering results in the absence of benchmark decompositions [clustering results analysis framework and tools],” in Reverse Engineering, 2001. Proceedings. Eighth Working Conference on, 2003, pp. 93–102. Mark Shtern, Methods for evaluating, selecting and improving software clustering algorithms, Ph.D. thesis, York University, Canada, 2010. Rajesh Vasa, Markus Lumpe, and Allan Jones, “Helix – software evolution data set,” 2010. Rajesh Vasa, Growth and change dynamics in open source software systems, Ph.D. thesis, Swinburne Univesity of Technology, 2010. Spiros Mancoridis, Brian S. Mitchell, Yih-Farn R. Chen, and Emden R. Gansner, “Bunch: a clustering tool for the recovery and maintenance of software system structures,” in Software Maintenance, 1999. (ICSM ’99) Proceedings. IEEE International Conference on, 1999, pp. 50–59. Vassilios Tzerpos and Richard C. Holt, “Mojo: a distance metric for software clusterings,” in Reverse Engineering, 1999. Proceedings. Sixth Working Conference on, 1999, pp. 187–193. Jingwei Wu, Ahmed E. Hassan, and Richard C. Holt, “Comparison of clustering algorithms in the context of software evolution,” in Proceedings of the 21st IEEE International Conference on software Maintenance, Washington, DC, USA, 2005, ICSM ’05, pp. 525–535, IEEE Computer Society. R.A. Bittencourt and D.D.S. Guerrero, “Comparison of graph clustering algorithms for recovering software architecture module views,” in Software Maintenance and Reengineering, 2009. CSMR ’09. 13th European Conference on, 2009, pp. 251–254. J.I. Maletic and N. Valluri, “Automatic software clustering via latent semantic analysis,” in Automated Software Engineering, 1999. 14th IEEE International Conference on., 1999, pp. 251–254. Hongjun Wang, Zhishu Li, and Yang Cheng, “Weighted latent dirichlet allocation for cluster ensemble,” in Genetic and Evolutionary Computing, 2008. WGEC ’08. Second International Conference on, 2008, pp. 437–441. E. Linstead, C. Lopes, and P. Baldi, “An application of latent dirichlet allocation to analyzing software evolution,” in Machine Learning and Applications, 2008. ICMLA ’08. Seventh International Conference on, 2008, pp. 813–818. F. Siddique and O. Maqbool, “Enhancing comprehensibility of software clustering results,” Software, IET, vol. 6, no. 4, pp. 283–295, 2012. Ittoo and L. Maruster, “Ensemble similarity measures for clustering terms,” in Computer Science and Information Engineering, 2009 WRI World Congress on, 2009, vol. 4, pp. 315–319.
R. Kashef
Electrical & Computer Engineering Dept. Faculty of Engineering University of Waterloo Waterloo, Canada {a24ibrah, derek.rayside}@uwaterloo.ca
Dept. of Management Sciences Faculty of Engineering University of Waterloo Waterloo, Canada [email protected]
Abstract— Software clustering involves the partitioning of software system components into clusters with the goal of obtaining optimum exterior and interior connectivity between the components. Research in this area has produced numerous algorithms with different methodologies and parameters. In this paper, we propose a novel ensemble approach that synthesizes a new solution from the outcomes of multiple constituent clustering algorithms. The main idea behind our cooperative approach was inherited from machine learning, as applied to document clustering, but has been modified for use in software clustering. The conceptual modifications include working with differing numbers of clusters produced by the input algorithms and using graph structures rather than feature vectors. The empirical modifications include experiments for selecting the optimal cluster merging criteria. Case studies using open source software systems show that forging cooperation between leading state-of-the-art algorithms produces better results than any one state-of-the-art algorithm considered.
I.
INTRODUCTION
Software systems support numerous business, government, and social institutions. As the requirements of these institutions change, so must the software that supports them; however, changing software systems that govern complex actions is much more easily said than done. Creating an adequate model of the structure of a system and keeping that model coherent with respect to modifications that occur as the system evolves are among the many critical problems that software developers face. Without an automated approach to acquiring insight into the system design, a software maintainer often modifies the source code without a complete understanding of its organization. Software clustering is an automated approach that can result in improvements in the structure of the software (software restructuring) and a reduction in the complexity of large modules (source code decoupling). In the last two decades, software clustering has been the target of an enormous amount of research [1],[2],[3], with a consequently wide range of criteria for establishing the clusters used in the clustering techniques described in the literature. Most of these algorithms have been successfully applied in specific software systems. However, the question of how a software engineer can identify the clustering algorithm best suited for a particular software system remains unanswered.
Rather than relying on the selection of a single algorithm, our hypothesis is that an ensemble approach that synthesizes a solution from the results of an aggregation of constituent clustering algorithms will produce measurably better results than does any one of those algorithms individually. This paper presents a new proposed ensemble clustering approach that combines a variety of graph-based software clustering techniques in order to provide measurably better modularity clustering than that produced by any single individual technique. The proposed approach not only opens a new perspective on the application of ensemble clustering on graphs but also relaxes some of the assumptions mentioned in the literature [3],[4]. The rest of this paper is organized as follows: section 2 provides a brief review of literature reports related to software clustering. Section 3 presents a detailed explanation of the proposed software clustering approach. Experimental results are discussed in section 4, and a summary of this study is included in section 5, along with suggestions for future work. II. RELATED WORK This section provides a review of the literature related to software ensemble clustering, dependency graphs, and dependency graph partitioning. A. Ensemble Software Clustering Many researchers have investigated the problem of constructing an efficient and robust ensemble committee of clustering algorithms [3], [4], [5], [6], [7]. Strethl et al. [7] proposed a hyper-graph partitioned approach based on a combination of different clustering results using different clustering algorithms. This approach starts by representing each partition in the cluster ensemble with a hyper-edge so that the problem becomes reduced to a hyper-graph partitioning problem. Ayad and Kamel [5] presented a cumulative voting method for obtaining consensus from partitions with differing numbers of clusters. They introduced several cumulative vote-weighting schemes and corresponding algorithms and computed an empirical probability distribution that summarizes the partitions. Zeng et al. [6] proposed a robust meta-clustering approach for combining different clustering results. In their research, they transformed the individual clustering results into a distance
matrix and then applied a hierarchical clustering algorithm to re-cluster the distance matrix. In [4], Kashef et al. used ensemble clustering to achieve a common benefit (e.g., a global clustering solution) based on agreement among peer clustering algorithms. They called their approach cooperative clustering (CC), and it includes three phases: first, run each of the constituent clustering algorithms; second, from the output of the clustering algorithms, find the common elements that they agree on; third, merge these elements into existing (or new) clusters. Although the reported results were extraordinary, they were based on the assumption that an identical number of clusters is produced by each of the input algorithms. The findings were also the result of the use of vectors of quantifiable features, which may not be suitable for direct application in software structures or in dependencies that describe the relationships between various entities in the software. Naseem et al. [3] were inspired by the work of [4]. They investigated whether the results could be improved through the application of CC for software modularization. Although the CC they used was slightly different from the version described in [4], it is still based on the vectors of quantifiable features. They proved that more than one similarity measure can be made to cooperate during the clustering process and confirmed the relation between arbitrary decisions during the clustering process and the modularization results. They also determined that the cooperative technique improves results for different types of hierarchical clustering algorithms with respect to both binary and non-binary features. Other approaches based on ensemble clustering were proposed in [8], [9], [10]. B. Dependency Graphs The quality of software dependencies has a substantial impact on software understandability [11]. A dependency graph is a directed graph that represents the dependencies of several objects one another. Dependencies include several types: data dependencies between the definition and use of values, and call dependencies between the declaration of functions and the sites where they are called. Dependency types are discussed in detail in [12]. Software dependencies can be simple, with one dependent and one dependee; transitive, in which a dependency path is created among multiple items; or cyclic, in which the dependency path starts and ends with the same item. Dependencies in software systems can be modeled and examined in a number of ways, ranging from informal box-and-arrow diagrams to Unified Modeling Language (UML) diagrams or a Dependency Structure Matrix (DSM). In the experiments conducted for this study, a system-wide dependency graph was generated using Lattix [14] at the function level. The Lattix tool provides the option of tracking dependency information at the function level, including calls, imports, and exports. Lattix can generate a system dependency graph from both native and JAVA bytecode. For the purposes of the study presented in this paper, only the occurrence of dependencies such as “A depends on B” were considered; multiple dependencies were disregarded.
C. Dependency Graph Partitioning The literature describes numerous proposed algorithms for partitioning dependency graphs [1],[2],[3]. Most research on dependency graph partitioning has been conducted using Lattix[14] and Bunch [19] tools. In Lattix, dependency graph partitioning is performed by rearranging rows of the DSM matrix so that clusters of elements are positioned along the diagonal. Lattix proposed several algorithms and heuristics to aid in the determination of appropriate objective functions and optimizations. Bunch includes three categories of partitioning algorithms, each with different configurations: hill climbing, genetic, and exhaustive. Bunch begins the partitioning process by creating a random partition of the module dependency graph (MDG) of the structure. In Bunch, clusters are determined by moving nodes between the clusters, or in some cases, creating new clusters in order to maximize an objective function that is defined by Mitchell [15] as the Turbo Modularization Quality (TurboMQ). This function has the property of rewarding cohesive clusters while penalizing extreme coupling between clusters. For this study, Bunch version 3.3.6 was used and the experiments were based on two versions of a hill-climbing algorithm, which are referred to as Nearest Ascent Hill Climbing (NAHC) and Steepest Ascend Hill Climbing (SAHC) [4]. III. COOPERATIVE CLUSTERING ON DEPEDENENCY GRAPHS The work presented in this paper is based on an extension of the idea of cooperative clustering (CC) proposed by Kashef [4] for document categorization in order to synthesize the clustering from the output of an ensemble of constituent clustering algorithms. The CC approach entails three steps. First, execute each of the constituent clustering algorithms. The points of agreement between these constituent clusterings are then determined and take the form of sub-clusters. Finally, a coherent merging of sub-clusters is performed in order to reveal the expected (natural) number of clusters. Four aspects of CC should be modified so that it will be appropriate in the paradigm of software clustering. First, one assumption inherent in CC is that each constituent clustering technique will produce the same number of clusters. The approach should thus be adapted to accommodate the reality that heterogeneous software clustering approaches produce different numbers of clusters. Second, the CC merging operation is based on numerical features extracted from a document corpus, which means that it cannot handle the graph structure inherent in software. Third, CC is built on an assumption that the number of output clusters is known a priori, which is not usually the case in software systems. A final consideration is that the merging criteria in CC are based on the frequency between the numerical features of a document corpus. This function must be revised so that it rewards cohesive and penalizes extreme coupling between software dependency clusters. In this work, CC has therefore been modified to address all of these challenges, and the modified version has been named CC/G to indicate that it is based on graphs rather than on numerical feature vectors. Algorithm 1 illustrates the CC/G algorithm in pseudo code. CC/G is an unsupervised learning algo-
rithm for clustering a software graph structure into k partitions based on cohesion and coupling among its dependencies. The main idea is to apply different clustering algorithms on the software dependency graph. Each algorithm will provide different k clusters. A common agreement among those clusterings is then found. This agreement identifies the minimum number of k clusters that the software should have. The last step is to merge the remaining software elements that exhibited disagreement inbetween the clusters that were initially determined using optimum cohesion and coupling values. Input: program file structure and set of C clusterings Output: k clusters For different values of k 1. Generate the DSM among n software entities 2. Apply each of the input clustering algorithms on the DSM to generate ki clusters, i =1,2,..,C 3. Find the common agreement of the ki clusters in terms of sub-clusters 4. Repeatedly merge sub-clusters until k clusters are reached using the merging factor (mf) 5. Evaluate the quality of the k clusters using the TurboMQ [13] measure End Algorithm 1: Pseudocode for clustering program dependency structures using a cooperative strategy
CC/G was designed with two phases: an agreement phase and a merging phase. The first phase employs a strategy for determining agreement among the multiple clustering algorithms in order to find the set of intersections between the different clusterings in the form of sub-clusters. The extracted sub-clusters are then represented by a vector of the agreement memberships. In the second phase, the sub-clusters are merged into one cluster based on the cohesiveness and coupling between elements. The merging process converges when all software elements are positioned in the established k clusters. A. Agreement Phase This phase is employed in order to discover the common patterns among the different clusterings and to produce a set of disjoint sub-clusters. In the CC approach, the authors assume that each clustering technique produces the same number of clusters (i.e., all ki are identical) [4]. They generate a number of disjoint sub-clusters as kCi , where ki is the number of clusters generated by a partitioning algorithm i, and C is the number of partitioning techniques. However, due to the nature of the software clustering domain, software systems may have different decompositions [16]. Therefore, in this work, we generalized the sub-cluster generation by taking an unequal number of clusters and generating sub-clusters based on kmax , such that kmax = max(ki); i = 1,2, … C. To determine the association between the corresponding set of sub-clusters, a membership vector called ComemVector is generated based on the calculation of a sub-cluster membership value assigned to each software entity xi. This vector is of size
n, where n is the number of software entities. Consequently, ComemVector is defined as ComemVector(i) = mem(xi); i = 1, … , n
(1)
This clustering-mapping recognizes the set of disjoint subclusters generated by the intersection of the C partitioning techniques. The new cooperative sub-cluster membership for a given software entity xi is defined as C −1 mem( xi ) = mem( xi ) P1 kmax + ... + mem( xi ) PC kmax
(2)
where i = 1,..., n ; j = 1,..., C ; and mem( x ) P is a cluster label j for a software entity x assigned by a partitioning algorithm Pj. The membership function satisfies the following condition: for any two classes x and y, if mem(x) = mem(y), then x and y belong to the same cluster (or sub-cluster). Using kmax for the generation of the sub-cluster memberships causes an enormous growth in the number of sub-clusters generated, especially for large values of kmax. In addition, the cooperative membership vector most probably has sparse entries. Therefore, only the non-zero values of ComemVector are passed into the next CC/G phase. B. Merging Phase The concept behind this phase is that the natural number of clusters is obtained through the merging of the generated subclusters. The best sub-clusters chosen for merging are defined as those that achieve maximum intra-connectivity among their own cluster elements and minimum inter-connectivity with respect to other clusters. A novel objective function is used for merging the sub-clusters. This function measures the quality of the merging of two sub-clusters i and j based on the value of the merging factor (mf), which can be calculated as follows:
mf i , j =
µi + µ j + ∑(ε ij + ε ji ) Ni N j ( Ni N j − 1)
(3)
where µi and µj are the intra-connections between the elements of sub-clusters i and j, respectively. A higher value of intraconnectivity is equivalent to a high degree of cohesion. Ɛij is defined as the sum of all relationships that exist between classes in two different sub-clusters i and j. Ɛij has values between 0 and 1. As applied to software systems, a 0 value means that no subsystem-level relations exist between subsystem i and subsystem j, and a value of 1 indicates that all modules in subsystem i are related to all modules in subsystem j and vice versa. A low inter-connectivity value signifies low coupling. Ni and Nj are the number of entities in each sub-cluster i, j, respectively. In case there exist sub-clusters with only one entity (singletons), CC/G is going to add them in separate iterations, so Ni and Nj each will never equal 1 at the same time. The proposed merging factor is used as a measure of the cohesiveness of the merging of two sub-clusters. Thus, the two sub-clusters that have a maximum mf value are merged into a new cluster. The sub-cluster list is then updated based on the new added cluster. This step is repeated until no additional merging is required.
IV.
EXPERIMENTAL SETUP AND RESULTS
This section describes a number of experiments that are conducted in order to demonstrate the superior efficiency of the proposed cooperative methodology and approach compared to the individual clustering techniques with respect to clustering quality and modularity. A. Benchmark Programs The experiential work was conducted with the use of open source software projects. In particular, six open source Java projects randomly selected from a list of Helix benchmark programs were analyzed [17]. The Helix benchmark suite is a compilation of the release histories of a number of non-trivial Java Open Source Software projects. This benchmark dataset is discussed in Vasa’s PhD thesis [18]. The first and second sets of software systems used in our experiments are produced in a variety of sizes, functionalities, and development philosophies, as listed in Tables I and II, respectively. In particular, the first and second columns in Tables I and II show the name of the system used in the experiments and its version. The third and fourth columns indicate the number of classes and interfaces in each program graph, respectively. The program sizes are listed in the last column. It should be noted that Table II provides information about a later version of each software system listed in Table I. TABLE I. Name Acegi Cocoon JabRef Proguard Struts Xwork
FIRST SET OF BENCHMARK PROGRAMS USED IN THE EXPERIMENTS Version 0.5.0 1.7 1.1 1.0 0.5 1.0
Classes 106 84 103 90 102 74
Interfaces 29 21 5 22 4 26
Size in Bytes 165K 166K 405K 136K 152K 145K
TABLE II. SECOND SET OF BENCHMARK PROGRAMS USED IN THE EXPERIMENTS Name Acegi Cocoon JabRef Proguard Struts Xwork
Version 0.5.1 1.8 1.2 1.1 1.0 1.1
Classes 113 90 150 95 183 105
Interfaces 30 23 8 23 2 31
Size in Bytes 173K 239K 584K 140K 319K 224K
B. Clustering Evaluation The quality of the partitioning provides an idea of how good the decomposition is. To evaluate the quality of the software partitioning algorithms, a number of criteria were adopted, including the quality of the generated cluster and the distance (or similarity) between the decompositions. Two experiments are presented in this section as examples of those criteria. Using the TurboMQ measure for the same software systems, the goal of the first experiment was to compare the solutions generated with the proposed cooperative approach and those based on the individual partitioning algorithms. The second experiment was aimed at using the MoJo distance to measure the similarity between the partitioning approaches
[20]. Tables III to VIII list the TurboMQ values for different decompositions, as evaluated for the first set of each test system using the CC/G, Lattix, NAHC, SAHC, and current package structure partitioning. The term “current” in each of the tables refers to the package structure of the benchmark systems based on the version indicated. The symbol “-” at a specific number of clusters k means that the corresponding partitioning algorithm does not generate k clusters. The package structure of the datasets was considered to be flat partitions. A flat partition does not contain nested clusters but has only one level of clusters and one level of entities. Table IX shows the percentage improvement in the TurboMQ measurements when CC/G is used compared to the values obtained for the benchmark systems using the leading approaches. CC/G produces a TurboMQ improvement for up to 53 % compared to that achieved with the current decomposition for Xwork 1.0 and up to 51 % compared to the Lattix result for Proguard 1.0. CC/G also provides a 47 % enhancement in the TurboMQ value compared to that for the NAHC algorithm for the Acegi 0.5, and up to a 59 % improvement compared to the measurement for the SAHC decomposition for Struts 0.5. On average, the TurboMQ value achieved with CC/G represents a 22 %, 39 %, 21 %, and 26 % improvement over those produced with the current decomposition, Lattix, NAHC, and SAHC, respectively, as shown in Table IX. C. Similarity Measures In general, a similarity measure provides an idea of how good (effective) the resultant decomposition is, which can be determined from a comparison of the decomposition produced by the clustering algorithm with the benchmark or expert decomposition. The MoJo [20],[21],[22] distance metric was used for this evaluation. The similarity between two partitioning solutions Ci and CR is defined as follows:
MoJo(Ci , CR ) mSim(Ci , CR ) = 1 − ×100% n
(4)
where CR is the assumed reference decomposition, Ci is the partitioning produced by algorithm i, and n is the number of software entities to be clustered. Intuitively, the higher the mSim(Ci,CR), the closer the clustering results to the reference decomposition. Because no reference decompositions for the software systems other than their current package structure were available, the following results were built based on the assumption that the current system partitioning serves as the reference decomposition. Similarity was hence established by examining how close the different system decompositions were to the current decomposition. The goal was to demonstrate that CC/G is biased toward neither the current system decomposition nor the other partitionings but rather that it adequately generates measurably balanced solutions with improved modularity. Tables X and XI present the similarity (mSim) results for two subsequent versions of the programs under study. The mSim values are percentage values. The larger the mSim value, the closer the decomposition is to its current. In Table X, it can be seen that the CC/G partitioning is not as close to the current partitioning as Lattix is for Acegi 0.5, Proguard 1.0, and Xwork
1.0, nor is it as far as NAHC and SAHC are for Acegi 0.5 and Xwork 1.0.
As shown in Table XI, compared to Lattix, NAHC, and SAHC, CC/G is able to find a measurably better solution for Acegi 0.5.1, Cocoon 1.8, Jabref 1.2, Proguard 1.1, and Xwork 1.1. The Struts 1.0 system, CC/G, and SAHC also generate almost the same partitioning as with the current decomposition.
TABLE III. TURBOMQ VALUES FOR ACEGI 0.5.0 Clustering/# of clusters Current Lattix NAHC SAHC CC/G
k=5
k=8
k = 10
3.1616 3.8859 4.4203
6.2504 6.6756
6.259 8.5162
TABLE IX. IMPROVEMENT (%) IN THE TURBOMQ (TMQ) VALUE PRODUCED BY CC/G
TABLE IV. TURBOMQ VALUES FOR COCOON 1.7 Clustering/# of clusters Current Lattix NAHC SAHC CC/G
k=5
k=7
k = 10
k = 12
k = 18
k = 22
3.357 3.839
5.497 5.839
7.83 8.687
9.401 10.013
11.7726 16.013
14.471 19.76
TABLE V. TURBOMQ VALUES FOR JABREF 1.1 Clustering/# of clusters Current Lattix NAHC SAHC CC/G
k=6
k=7
k = 15
k = 17
4.972 3.139 3.642 4.997
4.716 5.614
9.123 11.934
10.555 12.919
TABLE VI. TURBOMQ VALUES FOR PROGUARD 1.0 Clustering/# of clusters Current Lattix NAHC SAHC CC/G
k=3
k=4
k=5
k=9
1.3049 1.9734
2.1165 2.6231
2.3465 3.3215
5.4928 6.1132
TABLE VII. TURBOMQ VALUES FOR STRUTS 0.5 Clustering/# of clusters Current Lattix NAHC SAHC CC/G
k=4
k=6
k=8
2.798 1.852 3.167
2.776 5.275
2.918 7.114
TABLE VIII. TURBOMQ VALUES FOR XWORK 1.0 Clustering/# of clusters Current Lattix NAHC SAHC CC/G
k=2
k=5
1.0341 1.5282
2.6721 4.0507 3.789 4.1001
decompositions can therefore be accepted as a partitioning solution for both benchmark systems using the mSim formulation.
As shown in Table X, for the Proguard 1.0 and Struts 0.5 systems, the mSim value of CC/G is much closer to that of SAHC. These results indicate that, of the family of solutions provided, the SAHC decomposition of these two benchmark datasets is the closest to the solution generated by CC/G. Both
CC/G vs. Current Lattix NAHC SAHC
Acegi 0.5
Cocoon 1.7
Jabref 1.1
Proguard 1.0
Struts 0.5
Xwork 1.0
Avg. %
36 43 16 13
6 13 27 18
0.5 38 25 17
24 51 11 42
12 42 47 59
53 48 1 8
21.92 39.17 21.17 26.17
TABLE X. SIMILARITY VALUES (%) OBTAINED WITH THE NAHC, SAHC, LATTIX, AND CC/G SYSTEMS WITH RESPECT TO THE CURRENT STATE PARTITIONING (FIRST SET) Programs/Clustering Acegi 0.5 Cocoon 1.7 Jabref 1.1 Proguard 1.0 Struts 0.5 Xwork 1.0 Average similarity
NAHC 37.78 73.27 62.26 67.52 80.19 39 60.00
SAHC 37.04 45.045 41.035 70.09 66.98 35 49.20
Lattix 77.78 44.55 34.435 99.91 51.89 97 67.59
CC/G 47.65 60.73 57.31 74.15 64.78 65.5 61.69
TABLE XI. SIMILARITY VALUES (%) OBTAINED WITH THE NAHC, SAHC, LATTIX, AND CC/G SYSTEMS WITH RESPECT TO THE CURRENT STATE PARTITIONING (SECOND SET) Programs/Clustering Acegi 0.5.1 Cocoon 1.8 Jabref 1.2 Proguard 1.1 Struts 1.0 Xwork 1.1 Average similarity
NAHC 55.92 50 55.92 45.61 48.46 64.38 53.38
SAHC 44.63 53.08 44.63 47.37 54.8 62.75 51.21
Lattix 96.69 100 96.69 82.46 74.23 82.46 88.76
CC/G 67.11 61.49 67.11 64.62 56.69 75.88 65.48
In summary, CC/G produces unbiased results for four of the six benchmark systems listed in Table X and five of the six benchmark systems listed in Table XI. Using the average similarity values from Tables X and XI, it can be seen that, as an ensemble approach, CC/G generates unbiased structure clusterings that are closer to the current state partitioning (reference decomposition) than those produced by the individual approaches adopted. These balanced results are augmented by an enhancement of quality that demonstrates the major advantages of using CC/G as a cooperative consensus clustering approach. The results of these experiments indicate that the concept of using common patterns as a basis for software clustering offers a distinct advantage, because it is clear that this approach can create decompositions that are unbiased toward both the current decomposition and the ones used. V.
CONCLUSION AND FUTURE WORK
A new graph-based clustering approach (CC/G) that is built on a combination of the results of leading state-of-the-art graph
clustering methods is introduced in this paper. The new approach combines a variety of software clustering techniques in order to provide measurably superior clustering compared with that produced by any single individual approach. A variety of experiments have been conducted using a number of software benchmark datasets. Experimental results using different validation measures demonstrate that the proposed CC/G algorithm outperforms the individual software clustering algorithms. Based on the TurboMQ quality measure, the clustering solutions obtained using CC/G have high cohesion and low coupling, which establishes the greater efficiency of the CC/G algorithm compared to that of the input constituents. As established by the MoJo distance measure, CC/G clusterings have been shown to be unbiased toward the current partitioning and toward the decompositions obtained by any of the input algorithms. This work demonstrates the value of CC/G clustering for partitioning software systems. Further investigation is required with respect to the use of other types of clustering algorithms that are based not only on structural information but also on different/orthogonal categories of information, such as information retrieval algorithms, e.g., latent semantic indexing (LSI) [23], latent Dirichlet allocation (LDA) [24], [25] or the CC algorithm [4]. CC/G could also be extended to include the use of the labeling technique presented by Siddique [26], [27]. An additional suggestion is that the proposed approach can be used in a different challenging software domain problems, such as software bug report classification for open-source systems. This approach could serve as a filter between contributors and arriving defect reports.
[8]
[9]
[10]
[11]
[12] [13]
[14]
[15]
[16] [17] [18] [19]
[20]
ACKNOWLEDGMENT We thank the Electrical & Computer Engineering Department at the University of Waterloo for funding this work.
[21]
REFERENCES [1] [2]
[3] [4] [5]
[6]
[7]
Mark Shtern and Vassilios Tzerpos, “Clustering methodologies for software engineering,” Advances in Software Engineering, vol. 2012, Xia Xu, Chung-Horng Lung, M. Zaman, and A. Srinivasan, “Program restructuring through clustering techniques,” in Source Code Analysis and Manipulation, 2004. Fourth IEEE International Workshop on, 2004, pp. 75–84. R. Naseem, O. Maqbool, and S. Muhammad, “Cooperative clustering for software modularization,” Journal of Systems and Software, 2013. Rasha Kashef and Mohamed S. Kamel, “Cooperative clustering,”Pattern Recognition, vol. 43, no. 6, pp. 2315 – 2329, 2010. H.G. Ayad and M.S. Kamel, “Cumulative voting consensus method for partitions with variable number of clusters,” Pattern Analysis and Machine Intelligence, IEEE Transactions on, vol. 30, no. 1, pp. 160– 173, 2008. Yujing Zeng, Jianshan Tang, Javier Garcia-Frias, and Guang R. Gao, “An adaptive meta-clustering approach: Combining the information from different clustering results,” in Proceedings of the IEEE Computer Society Conference on Bioinformatics, Washington, DC, USA, 2002, CSB ’02, pp. 276–, IEEE Computer Society. Alexander Strehl and Joydeep Ghosh, “Cluster ensembles — a knowledge reuse framework for combining multiple partitions,” J. Mach. Learn. Res., vol. 3, pp. 583–617, Mar. 2003.
[22]
[23]
[24]
[25]
[26] [27]
G. Forestier, P. GanÃ˘garski, and C. Wemmert, “Collaborative clustering with background knowledge,” Data & Knowledge Engineering, vol. 69, no. 2, pp. 211 – 228, 2010. A. L N Fred and A.K. Jain, “Data clustering using evidence accumulation,” in Pattern Recognition, 2002. Proceedings. 16th International Conference on, 2002, vol. 4, pp. 276–280 vol.4. Xi Wang, Chunyu Yang, and Jie Zhou, “Clustering aggregation by probability accumulation,” Pattern Recogn., vol. 42, no. 5, pp. 668– 675, May 2009. Cleidson Ronald Botelho De Souza, On the relationship between software dependencies and coordination: field studies and tool support, Ph.D. thesis, California State University at Long Beach, Long Beach, CA, USA, 2005, AAI3200278. Norman Wilde, “Understanding program dependencies,” 1990. Brian S. Mitchell, “A heuristic approach to solving the software clustering problem,” in Software Maintenance, 2003. ICSM 2003. Proceedings. International Conference on, 2003, pp. 285–288. Neeraj Sangal, Ev Jordan, Vineet Sinha, and Daniel Jackson, “Using dependency models to manage complex software architecture,” SIGPLAN Not., vol. 40, no. 10, pp. 167–176, Oct. 2005. Brian S. Mitchell and Spiros Mancoridis, “Craft: a framework for evaluating software clustering results in the absence of benchmark decompositions [clustering results analysis framework and tools],” in Reverse Engineering, 2001. Proceedings. Eighth Working Conference on, 2003, pp. 93–102. Mark Shtern, Methods for evaluating, selecting and improving software clustering algorithms, Ph.D. thesis, York University, Canada, 2010. Rajesh Vasa, Markus Lumpe, and Allan Jones, “Helix – software evolution data set,” 2010. Rajesh Vasa, Growth and change dynamics in open source software systems, Ph.D. thesis, Swinburne Univesity of Technology, 2010. Spiros Mancoridis, Brian S. Mitchell, Yih-Farn R. Chen, and Emden R. Gansner, “Bunch: a clustering tool for the recovery and maintenance of software system structures,” in Software Maintenance, 1999. (ICSM ’99) Proceedings. IEEE International Conference on, 1999, pp. 50–59. Vassilios Tzerpos and Richard C. Holt, “Mojo: a distance metric for software clusterings,” in Reverse Engineering, 1999. Proceedings. Sixth Working Conference on, 1999, pp. 187–193. Jingwei Wu, Ahmed E. Hassan, and Richard C. Holt, “Comparison of clustering algorithms in the context of software evolution,” in Proceedings of the 21st IEEE International Conference on software Maintenance, Washington, DC, USA, 2005, ICSM ’05, pp. 525–535, IEEE Computer Society. R.A. Bittencourt and D.D.S. Guerrero, “Comparison of graph clustering algorithms for recovering software architecture module views,” in Software Maintenance and Reengineering, 2009. CSMR ’09. 13th European Conference on, 2009, pp. 251–254. J.I. Maletic and N. Valluri, “Automatic software clustering via latent semantic analysis,” in Automated Software Engineering, 1999. 14th IEEE International Conference on., 1999, pp. 251–254. Hongjun Wang, Zhishu Li, and Yang Cheng, “Weighted latent dirichlet allocation for cluster ensemble,” in Genetic and Evolutionary Computing, 2008. WGEC ’08. Second International Conference on, 2008, pp. 437–441. E. Linstead, C. Lopes, and P. Baldi, “An application of latent dirichlet allocation to analyzing software evolution,” in Machine Learning and Applications, 2008. ICMLA ’08. Seventh International Conference on, 2008, pp. 813–818. F. Siddique and O. Maqbool, “Enhancing comprehensibility of software clustering results,” Software, IET, vol. 6, no. 4, pp. 283–295, 2012. Ittoo and L. Maruster, “Ensemble similarity measures for clustering terms,” in Computer Science and Information Engineering, 2009 WRI World Congress on, 2009, vol. 4, pp. 315–319.
