Software Data Analytics Part 2: Formal Concept Analysis. Oscar Nierstrasz Luca Liechti

Transcription

1 Software Data Analytics Part 2: Formal Concept Analysis Oscar Nierstrasz Luca Liechti

2 Roadmap > Basics of Formal Concept Analysis > Applications of FCA to Software > Computing the concept lattice > FCA tools (demo) 2

3 Selected literature The Art and Science of Analyzing Software Data, Christian Bird, Tim Menzies, Thomas Zimmermann 3

4 This book contains a good introduction to FCA in chapter 2: Mining Patterns and Violations using Concept Analysis. A preprint is available online:

5 Roadmap > Basics of Formal Concept Analysis > Applications of FCA to Software > Computing the concept lattice > FCA tools (demo) 4

6 What patterns do you see? What outliers? fourlegged haircovered intelligent marine thumbed Cats x x Dogs x x Dolphins x x Gibbons x x x Humans x x Whales x x 5

7 Here we see six objects, each with a selection of five properties or attributes. Clearly there is a pattern present in that only cats and dogs are both four-legged and hair-covered, but are there other patterns present? How can we identify them reliably? Example adapted from Siff & Thomas Reps. Identifying Modules via Concept Analysis. IEEE-TSE 25(6), Nov

8 Rearranging rows and columns fourlegged haircovered thumbed intelligent marine Cats x x Dogs x x Gibbons x x x Humans x x Dolphins x x Whales x x 6

9 By rearranging the rows and columns we can more easily identify maximal blocks of objects and properties that belong together. We find five such blocks, several of which overlap.

10 Formal Concept Analysis > FCA organizes a collection of objects, each with a set of properties, into a lattice of nodes, where all objects in a given node have the same properties Objects of a child node have all the properties of its parent nodes The top node holds objects sharing no properties Objects in the bottom node have all properties 7

11 Formal Concept Analysis refers to a set of methods to analyze a collection of objects and properties to form a concept hierarchy. The hierarchy forms a complete lattice, that is, each pair of nodes has a common join (least upper bound) and meet (greatest lower bound). Each node (representing a concept ) consists of a maximal set of objects and a maximal set of properties such that all those objects (and no more) share all the properties (and no more). The join of two nodes takes the union of their objects and the intersection of their properties (vice versa for meet). The appendix to Arévalo s PhD thesis contains a concise introduction to FCA:

12 A concept lattice 8

13 Here we see the concept lattice of our example. Note that the top node contains all objects but no properties. The bottom node contains all properties, and all objects with all those properties (i.e., none). Note that every node is maximal, in that we cannot add any more objects or properties to it. Also note that absent combinations do not form concepts, for example: ({Humans}, {thumbed}), since we can add Gibbons to the objects and intelligent to the properties. In the diagram we have highlighted in bold the where properties are first introduced (top-down) or objects (bottom-up).

14 A concept lattice (v2) 9

15 Here is a more compact way to represent the same lattice. Bottom-up we indicate where objects are introduced. Objects propagate up to all the nodes above. Conversely properties are introduced top-down and propagate downward, so the node labeled thumbed and Humans also includes the property intelligent and the object Gibbons.

16 A concept is a maximal block of objects and features > Let R O F relate objects O O with features F F Let O = { f F (o,f) R o O } i.e., all the features shared by all objects in O Let F = { o O (o,f) R f F } i.e., all the objects sharing all the features in F Then (O,F) is a concept iff O = F and F = O i.e., O contains all the objects with features in F and vice versa O is the extent and F is the intent of the concept (O,F) 10

17 The triple (O, F, R) is known as the context. To define concepts formally, we need the closure operator that generates all the properties shared by a set of objects, and conversely, all the objects sharing a set of properties. Starting, for example, with Cats and Gibbons: {Cats, Gibbons} = {hair-covered} {hair-covered} = {Cats, Dogs, Gibbons} Repeated applications can yield no further objects or properties, so we have identified the concept: ({Cats, Dogs, Gibbons}, {hair-covered})

18 What is FCA good for? > Identify important concepts from objects and properties > Recognize patterns in objects and relationships NB: need to map relationships to properties > Identify outliers i.e., objects that violate recognized patterns 11

19 Roadmap > Basics of Formal Concept Analysis > Applications of FCA to Software > Computing the concept lattice > FCA tools (demo) 12

20 Mining Ruby calling patterns Call relation for Ruby The pattern {va_start, va_end} becomes visible as a block. It is violated by the function vafuncall. This violation becomes visible as an imperfect block. Mining Patterns and Violations using Concept Analysis, Ch 2., The Art and Science of Analyzing Software Data 13

21 FCA can be applied to analyze software in a great variety of ways. It suffices to determine the objects and properties of interest. One natural way is to map them respectively to the callers and callees in a software system. The patterns that emerge indicate which callers tend to call the same group of callees. In this example, we see that callers in Ruby tend to call both va_start and va_end, suggesting that this may be a best practice. Callers that violate this pattern may be in error. FCA therefore not only can identify interesting patterns, but also outliers that may be violating a desirable pattern. This example is from Mining Patterns and Violations using Concept Analysis.

22 Detecting structural patterns in code > Objects : tuples of classes > Properties: relationships between (or over) classes subclasses accesses is abstract Detecting Software Patterns using Formal Concept Analysis, Buchli

23 In this example, we attempt to discover recurring structural patterns in code (analogous to structural design patterns). The objects are tuples of two or more classes, and the properties are relationships over one or more of those classes, such as is abstract (1 class), subclasses (2 classes), accesses (2 classes). Post filtering is required to deal with (1) disconnected patterns (all objects must be related for a pattern to be meaningful, else it can be decomposed into smaller patterns), and (2) equivalent patterns (permutations of tuples will appear as different patterns, and must be merged). Buchli. Detecting Software Patterns using Formal Concept Analysis. Diploma Thesis, Arévalo, Buchli, & Nierstrasz. Detecting Implicit Collaboration Patterns. WCRE

24 Some detected patterns

25 Note that some known design design patterns are clearly recognized by FCA as concepts, such as Facade, Composite, Adapter, and Bridge.

26 Detecting coding patterns in class hierarchies > Objects : invocations (C,m) and accesses (C,a) > Properties: C accesses a via accessors C accesses a directly C defines a C invokes m via self C invokes m via super C delegates m via super m m is abstract in C m is concrete in C m in cancelled in C Generating a Catalog of Unanticipated Schemas in Class Hierarchies using Formal Concept Analysis, Arévalo et al

27 In this study, the objects invocations and accesses (similar to the first study of callers and callees), while the properties are not callers but attributes describing the invocation or accessing relationship. The goal is to uncover common practices or schemas implicit in class hierarchies. Arévalo, et al. Generating a catalog of unanticipated schemas in class hierarchies using Formal Concept Analysis. IST,

28 Sample class hierarchy lattice 17

29 Some patterns (good and bad) Template and Hook Redefined Concrete Behavior invoked via self, is abstract locally, is concrete in descendant Cn. invoked via self, is concrete locally, is concrete in ancestor Cm, (2) invoked via self, is concrete in descendant Cn, is concrete in ancestor Cm. Abstracting Concrete Methods Broken super send Chain (1) invoked via self, is cancelled locally, is concrete in ancestor Cn, (2) invoked via self, is concrete locally, is cancelled in descendant Cn delegated via super, is concrete locally, is concrete in ancestor Cn. 18

30 The patterns detected sometimes reflect best practices and some design patterns, such as template and hook methods, but also some anti-patterns emerged.

31 Lessons Learned > Modeling software entities as FCA components is an iterative process deciding what should be modeled as objects and properties is nontrivial > Performance can be a bottleneck not only computing the lattice may be expensive but also computing the properties > Post-filtering is essential not all concepts and properties are useful; the resulting lattice may need to be post-processed to remove noise > Interpretation is non-obvious what do concepts mean in practice? how should the lattice hierarchy be interpreted? Lessons Learned in Applying Formal Concept Analysis to Reverse Engineering, Arévalo et al

32 These lessons emerged from early experience with FCA in the course of Arévalo s PhD research. The first point is that it may require some experimentation to discover what precisely should be modeled as objects and properties. FCA is completely neutral in this regard. Performance can be an issue if there are large numbers of objects or properties to analyze. Computing the properties may be expensive, but as well the way in which the analysis is carried out may be critical as computing the lattice can be expensive. Once the concepts and the concept lattice have been computed, some filtering may be needed to remove noise (recall the permutations of structural patterns). Interpretation of the results can also be tricky as concepts may represent either good or bad practice (or neither). Arevalo et al. Lessons Learned in Applying Formal Concept Analysis to Reverse Engineering. ICFCA

33 Roadmap > Basics of Formal Concept Analysis > Applications of FCA to Software > Computing the concept lattice > FCA tools (demo) 20

34 Naive algorithm (1) 1. collect all the atomic concepts (e.g., take closures over maximal property sets) ({Cats, Dogs}, {four-legged, hair-covered}) ({Dolphins, Whales}, {intelligent, marine}) ({Gibbons}, {hair-covered, intelligent, thumbed}) ({Gibbons, Humans}, {intelligent, thumbed}) 21

35 There are good and bad ways to compute a concept lattice. The most natural (but inefficient) way is to start by identifying the atomic concepts in the context. These are easily identified, for example, by identifying the maximal property sets held by some objects, and then taking their closures to obtain all the objects with those properties. The diagram shows this for the running example. Unfortunately this is not a complete lattice, as meets and joins are missing for selected pairs of nodes. For example, the join (lub) of the node for Cats and Dogs and the node for Gibbons should not be Top.

36 Naive algorithm (2) 2. Take joins over all possible pairs of concepts to generate missing concepts 22

37 The next step is to generate the missing meets and joins. (Going bottom-up, it is sufficient to take all possible joins.) Now we have the complete lattice. Note that we do not generate nodes where just four-legged, thumbed, or marine as properties are introduced, as these will not form concepts. Unfortunately this approach will be very inefficient in general, as it requires us to (iteratively) take joins of all possible pairs of nodes.

38 Ganter s algorithm Ganter avoids exponential computation by imposing a lectic order on sets of properties, and generating closures in linear order. 23

39 A key insight by Ganter is that it is not actually necessary to compute the joins of all atomic concepts, but instead one can iterate linearly through sets of properties in a particular ( lectic ) order, and compute closures to generate all concepts. The details are beyond the scope of this short lecture, but for a nice introduction, see the following slides: B. Ganter. Finger Exercises in Formal Concept Analysis. Dresden Summer School For a comparison of algorithms, see: Kuznetsov & Obiedkov. Comparing performance of algorithms for generating concept lattices. J. Experimental & Theoretical AI

40 Sets as Bit Strings Aside: An efficient way to compare sets is to encode them as Bit Vectors. 24

41 Comparing sets can be very expensive. Checking whether the properties of one object are the same as, or a subset of, those of another object can be inefficient using typical representations of sets. Instead one can use a bit vector. This requires that all sets use the same bits to encode the same properties (a dictionary can keep track of the mapping). Bit vectors can be encoding as integers, or Big Numbers, in case more than 32 properties are needed. Equality, intersection or union are trivial to compute, as are subset and superset tests.

42 Roadmap > Basics of Formal Concept Analysis > Applications of FCA to Software > Computing the concept lattice > FCA tools (demo) 25

43 Free and Open-Source FCA Tools > ConExp > Concept Explorer FX (a "partial reimplementation" of ConExp) > Moose (Pharo-based data analysis platform) Instructions: 26

44 What you should know! > In what sense is a concept a maximal set of of objects and properties? > What is the closure of a set of objects or properties? > What is an atomic concept? > What do concepts mined from callers as objects and callees as properties reveal? > How can the Composite design pattern be viewed as a concept? 27

45 Can you answer these questions? > Why don t certain combinations of objects and properties qualify as concepts? > What does it mean if a concept is a parent or a child of another one in a concept lattice? > Methods that use super to call another method are a known code smell. How could you use concept analysis to detect such smells? > Suppose you modeled classes as objects and authors who contributed changes to those classes as properties. How would you interpret the resulting concept lattice? 28

46 Attribution-ShareAlike 4.0 International (CC BY-SA 4.0) You are free to: Share copy and redistribute the material in any medium or format Adapt remix, transform, and build upon the material for any purpose, even commercially. The licensor cannot revoke these freedoms as long as you follow the license terms. Under the following terms: Attribution You must give appropriate credit, provide a link to the license, and indicate if changes were made. You may do so in any reasonable manner, but not in any way that suggests the licensor endorses you or your use. ShareAlike If you remix, transform, or build upon the material, you must distribute your contributions under the same license as the original. No additional restrictions You may not apply legal terms or technological measures that legally restrict others from doing anything the license permits.