In Model Driven Engineering (MDE), a Model Transformation is a specialized program, often composed of a set of rules to transform models. The Model Transformation By Example (MTBE) approach aims to assist the developer by learning model transformations from source and target model examples.In a previous work, we proposed an approach which takes as input a fragmented source model and a target model, and produces a set of fragment pairs that presents the many-to-many matching links between the two models. In this paper, we propose to mine model transformation patterns (that can be later transformed in transformation rules) from the obtained matching links. We encode our models into labeled graphs that are then classified using the GRAAL approach to get meaningful common subgraphs. New transformation patterns are then found from the classification of the matching links based on their graph ends. We evaluate the feasibility of our approach on two representative small transformation examples.
MDE is a subfield of software engineering that relies on models as a central
artifact for the software development cycle. Models can be manually or automatically
manipulated using model transformations. A model transformation is a program,
often composed of a set of transformation rules, that takes as input a model and
produces as output another model. The models conform to meta-models, as
programs conform to the programming language grammar. If we would like to
transform any Java program into any C++ program, we would express this
transformation at the level of their grammars. In MDE, model transformations are
similarly expressed in terms of the meta-models. Designing a model
transformation is thus a delicate issue, because the developer has to master the specialized
language in which the transformation is written, the meta-modeling activity,
and the subtleties of the source and the target meta-models. In order to
assist the developers, the MTBE approach follows the track of the "Programming
By Example" approach [
The next Section 2 gives an overview of our approach. Section 3 presents the transformation pattern mining approach and Section 4 evaluates its feasibility. Section 5 presents the related work, and we conclude in Section 6. 2
In Model-Driven Engineering, model transformation are programs that transform an input source model into an output target model. A classical model transformation (UML2REL) transforms a UML model into a RELational model. Such transformation programs are often written with declarative or semi-declarative languages and composed of a set of transformation rules, defined at the metamodel level. The meta-model defines the concepts and the relations that are used (and instantiated) to compose the models. For example, the UML meta-model Source
Model Fragments
Target
Model Fragments Matching Links
Source GRAAL Source Graphs LGartatipche Target Graphs
GRAAL Target
Graph Lattice
Matching FCA Matching CFooLnrinmtekaxlt LLatintikce
Transformation
Patterns contains the concept of Class which owns Attributes. This can used to derive a UML model composed of a class P erson owning the attribute N ame. In the UML2REL example, a very simple transformation pattern would be: a UML class owning an attribute is transformed into a relational table owning a column. In this paper, our objective is to learn such transformation patterns that express that a pattern associating entities of the source meta-model (e.g. a UML class owning an attribute) is transformed into a pattern associating entities of the target meta-model (e.g. a relational table owning a column ). Fig. 1 provides an overview of our process. Let us consider that we want to learn rules for transforming UML models to relational models. Our input data (see Fig. 2) are composed of: fragmented source models (a UML source fragment is given in Fig. 3(a)); fragmented target models (a relational target fragment is given in Fig. 3(b)); and matching links between fragments established by experts or by an automatic matching technique. For example a matching link (L1) is established in Fig. 2 between the UML source fragment of Fig. 3(a) and the relational target fragment of Fig. 3(b).
SG2
SG0
Matching links established by experts or by automatic methods can be used to form a set of model transformation patterns. For example, the L2 matching link gives rise to a transformation pattern which indicates that a UML class (with an attribute) with its super-class (with an attribute) is transformed into a unique table with two columns, one being inherited. Nevertheless, matching links often correspond to patterns that combine several simpler transformations or are triggered from domain knowledge. Besides, they may contain minor errors (such as a few additional or missing elements, for example, column date of Table ReservationRequest has in fact no equivalent in Class ReservationRequest). Moreover, what interests us is beyond the model domain. We do not want to learn that Class Client is transformed into Table Client, but rather that a UML class is usually transformed into a table.
Our output is composed of a set of model transformation patterns. Some can directly be inferred from initial matching links (as evoked previously), and some will be found thanks to graph generalization and matching link classification. From our simple example, we want to extract the model transformation pattern presented in Figure 4, whose premise and conclusion patterns do not appear as such in the initial set of matching links (,! means "is transformed into"). clienCtNliuemntber c1l,i1ent reserve reservation ReservationRequest
0,n (a) UML source fragment
ReservationRequest ∞ rdeaqteuestNumber
clientNumber (b) Relational target fragment From model fragments to graphs For our example, the source meta-model is inspired by a tiny part of the UML metamodel (see Figure 5(a)), while the target meta-model has its roots in a simplified relational data-base meta-model (see Fig. 5(c)). The models often are represented in a visual syntax (as shown in Fig. 3(a) and Fig. 3(b)) for readability reasons. Here we use their representation as instance diagrams of their meta-model (using the UML instance diagram syntax). For example, the UML model of Fig. 3(a) is shown as an instantiation of its meta-model in Fig. 5(b), where each object (in a rectangular box) is described by its meta-class in the meta-model, valued attributes and roles conforming to the attributes and associations from the meta-model: e.g. person and client are explicit instances of Class; client:Class has a link towards person labeled by the role specializes; client:Property has the attribute lowerBound (1).
To extract expressive transformation patterns, we transform our models using their instance diagram syntax, into simpler graphs which have labeled vertices. We limited ourselves to locally injective labelled graphs. A locally injective graph is a labeled graph such that all vertices in the neighbor of a given vertex have different labels. This is not so restrictive in our case, because the fragments identified by the experts rarely include similar neighborhood for an entity. Here are the rules that we use in the transformation from simplified UML instance diagrams to labeled graphs. We associate a labeled node to Objects, Roles, Attributes, Attribute values. Instance diagram of Figure 5(b) and corresponding labeled graph from 6(a) are used to illustrate the transformation: person:Class object is transformed into node 1 labeled class_1 and one of the attribute value 1 is transformed into node 13 labeled one_13. Edges come from the following situations: an object has an attribute; an attribute has a value; an object has a role (is source of a role); an object is the target of a role. For example, for the property which has an attribute lowerBound (equal to zero), there is a corresponding edge (property_17, lowerBound_18).
specializes
Class
Property ownsAttribute lowerBound hasType upperBound
ownedEnd {Ordered} 1 ownsAttributeIdentifier PropertyIdentifier
Association
(a) UML metamodel
Classification of graphs (GRAAL approach) After the previous step, we
obtain a set of source graphs, and a set of target graphs. We illustrate the
remainder of this section by using the three source graphs of Fig. 6, the three
target graphs of Fig. 7, and the matching links (Source graph i, Target graph i),
for i 2 f0; 1; 2g. To get meaningful common subgraphs (on which new
transformation patterns will be discovered), we use the graph mining approach proposed
in [
(a) Source graph 1 (b) Source graph 0
(c) Source graph 2 Classification of transformation links In the previous section, we have shown how Galois lattices can be computed on the labeled graphs that represent our model fragments. Now a matching link is described by a pair composed of a source fragment (whose corresponding graph is in the extent of some concepts in the source graph lattice) and a target fragment (whose corresponding graph is in the extent of some concepts in the source graph lattice). This is described in a formal context, where objects are the matching links and attributes are the concepts of the two lattices (source graph lattice and target graph lattice). In this formal context (presented in Table 11(a)), a matching link is associated with the concepts having respectively its source graph and its target graph in their extent. This means that the matching link is described by the graph of its source fragment and by the generalizations of this graph in the lattice. This is the same for the graphs of the target fragments. For example, matching link L0, connecting source fragment 0 to target fragment 0, is associated in the formal context to concepts sfc01, sfc012, tfc01, tfc012. (a) Target graph 1 (b) Target graph 0
(c) Target graph 2
The concept lattice associated with the matching link formal context of Fig. 11(a) is shown in Fig. 11(b). In this representation (obtained with RCAexplore1) each box describes a concept: the first compartment informs about the name of the concept, the second shows the simplified intent (here concepts from source fragment lattice and target fragment lattice) and the third one shows the simplified extent (here matching links). Concept_MatchingLinksFca_4 extent is composed of the links L0 and L1, while the intent is composed of source graph concepts sfc01, sfc012 and target graph concepts tfc01, tfc012.
Model transformation pattern mining The last step of the process consists in extracting model transformation patterns from the matching link lattice. This has close connections to the problem of extracting implication rules in a concept lattice, but using only pairs of source and target graph concepts. The more 1 http://dolques.free.fr/rcaexplore.php (a) Concept sfc2
Concept reliable transformation patterns are given when using a source graph and a target graph in the same simplified intent of a concept, because this corresponds to the fact that the source graph is always present when the target graph is present too (and reversely). For example, from Concept_MatchingLinksFca_0, we obtain the following transformation pattern:
graph of sfc012 intent ,! graph of tfc012 intent This pattern expresses a new transformation pattern (new in the sense that it does not directly come from a matching link):
A UML model where a class Cd specializes another class Cm which owns an attribute a is transformed into a relational model where a table T owns a (inherited) column c.
Due to the simplicity of our illustrative example, the other reliable patterns obtained from source and target graphs from the same simplified intent just correspond to matching links.
Obtaining other, less reliable patterns, relies on the fact that if a source graph and a target graph are not in the same simplified intent, but the concept (b) Concept 2
(c) Concept 01
Model transformationFriug.le1s1.lMeaartcnhiinngglink formal context and corresponding concept lattice.
Cs which introduces the source graph is below the concept Ct which introduces the target graph, then we infer the following transformation pattern:
part of graph of Cs intent ,! graph of Ct intent Model Transformation is a key component of Model Driven Engineering (MDE).
In this paper, we learn moFdoerl terxaanmspfoler,maastisofnc1froamppemaorsdebleltorwantsffocr1m2,atwioencatnradceeds.uce that, when the inWe can distinguish betwepeunt towf othceattreagnosrfioersmoaftiostnractoengtiaeisnsttohegegnrearpahteoftirnatnesnftoro-f sfc1, thus the output mation traces: the first cacteognotariyns[?t]h,e[?g]r,a[p?h],o[f?i]n,t[e?n]t, [o?f],tf[?c]1,2[.?T]dheespeenpdatsteornnsthaere less reliable, because the source graph may contain many things that have nothing to do with the tartransformation program or engine. The corresponding approaches generate trace
get graph (compare sfc1 and tfc12 to see this phenomenon). However, experts links through the executiocnaonf haavmeoadellootrkanonsfothrmesaetpioant.teTrnhse tsoecfionndd sceavteergaolr(yco[n?c],urrent) transformation [?], [?] consists in generatinpgatatetrrnasnwsfhoernmsaetvieornaltsroaucercienmdeopdeenldfreangtmlyenfrtosmarea ttrraannssf-ormed into a same tarformation program. get model fragment. We have a symmetric situation when a source graph and a target graph are not in the same simplified intent, but the concept Ct which introduces the4target graph is below the concept Cs which introduces the source graph. 4
We evaluated the feasibility of the approach on two different realistic transformation examples: (1) UML class diagram to relational schema model that contains 108 model elements, 10 fragments (5 sources, 5 targets) and 5 matching links (U2S) and (2) UML class diagram to entity relationship model that contains 66 model elements, 6 fragments (3 sources, 3 targets) and 3 matching links (U2E). We compute from the obtained graphs for each transformation example several pattern categories (see left-hand side of Table 1).
(1) The transformation patterns coming from simplified intents (which we think are the most relevant patterns): they correspond to graphs pairs (GS ; GT ) such that GS and GT are in the simplified intent of a same concept. They can be divided into two sets. The set T Pl groups the patterns that are inferred from the initial matching links (GS , GT are the ends of a matching link). The set T Pn contains the patterns that are learned from graph generalization and matching link classification.
(2) The transformation patterns (T Pnparts ) coming from the graphs GS and GT , such that GS is in simplified intent of a concept Cs which is a subconcept of the concept Ct which has GT in its simplified intent and all concepts greater than Cs and lower than Ct have an empty simplified intent. In addition, we consider only the case where simplified intent of Cs contains only source graphs or (inclusively) simplified intent of Ct contains only target graphs.
(3) Symmetrically, the transformation patterns (T Pnpartt ) coming from the graphs GS and GT , such that GT is in simplified intent of a concept Ct which is a subconcept of the concept Cs which has GS in its simplified intent and all concepts greater than Ct and lower than Cs have an empty simplified intent. In addition, we consider only the case where simplified intent of Cs contains only source graphs or (inclusively) simplified intent of Ct contains only target graphs.
We also evaluate each extracted transformation pattern using a precision metric. Precision here is the number of elements in the source and target graphs that participate correctly to the transformation (according to a human expert) divided by the number of elements in the graphs. We then associate a precision measure to a set of transformation patterns, which is the average of the precisions of its elements (See right-hand side of Table 1).
The results show that we learn transformation patterns that correspond to
the initial mapping links. These patterns are relevant and efficient (precision =
1). 17 new transformation patterns are also learned from the three used examples.
These patterns seems also relevant, with a precision average than 0.83.
Several approaches have been proposed to mine model transformation. The
MTBE approach consists in learning model transformation from examples. An
example is composed of a source model, the corresponding transformed model,
and matching links between the two models. In [
Our problem has close connections with the pattern structure approach [
We have proposed an approach to assist a designer in her/his task of writing a
declarative model transformation. The approach relies on model transformation
examples composed of source and target model fragments and matching links.
Models and their fragments are represented by graphs with labelled vertices that
are classified. This classification is in turn, used for classifying the matching links.
Finally, the mined model transformation patterns express how a source model
fragment is transformed into a target model fragment. Future directions of this
work include extending the evaluation to other kinds of source and target
metamodels, and define a notion of support for the patterns. We also would like
to explore the different kinds of graph mining approaches, in particular to go
beyond the limitation of using locally injective graphs. Finally, we plan to apply
our approach [