Gilles Perrouin
email: gilles.perrouin@unamur.be

Moussa Amrani
email: moussa.amrani@unamur.be

Mathieu Acher
email: mathieu.acher@irisa.fr

Benoit Combemale
email: benoit.combemale@inria.fr

Axel Legay
email: axel.legay@inria.fr

Pierre-Yves Schobbens
email: pierre-yves.schobbens@unamur.be

Featured Model Types: Towards Systematic Reuse in Modelling Language Engineering

Keywords: Model Typing, Metamodelling, Reuse

By analogy with software product reuse, the ability to reuse (meta)models and model transformations is key to achieve better quality and productivity. To this end, various opportunistic reuse techniques have been developed, such as higher-order transformations, metamodel adaptation, and model types. However, in contrast to software product development that has moved to systematic reuse by adopting (model-driven) software product lines, we are not quite there yet for modelling languages, missing economies of scope and automation opportunities. Our vision is to transpose the product line paradigm at the metamodel level, where reusable assets are formed by metamodel and transformation fragments and "products" are reusable language building blocks (model types). We introduce featured model types to concisely model variability amongst metamodelling elements, enabling configuration, automated analysis, and derivation of tailored model types. We provide a wish list of software engineering activities to work with featured model types.

INTRODUCTION

Model-Driven Engineering (Mde), and in particular the area of Domain-Specific Modelling Languages (Dsmls), leads language designers to capture the language's concepts in metamodels. Models, representing particular instances of Permission to make digital or hard copies of all or part of this work for personal or classroom use is granted without fee provided that copies are not made or distributed for profit or commercial advantage and that copies bear this notice and the full citation on the first page. Copyrights for components of this work owned by others than ACM must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from permissions@acm.org.

MiSE '16, May 16-17, 2016, Austin, TX, USA c 2016 ACM. ISBN 978-1-4503-4164-6/16/05. . . $15.00 DOI: http://dx.doi.org/10.1145/2896982.2896987 metamodels, can then be manipulated through transformations to perform translations to other languages, analyses (e.g., static semantics checking, or semantic correctness), evolution (refactorings, etc.) or queries (e.g., metrics or view extraction).

Yet as a Dsml evolves, all the associated transformations need to evolve accordingly. Given the amount of effort that can be put into transformation design, reuse is indispensable. Research on transformation reuse engendered many interesting techniques, that can be roughly sorted in two categories. The first category focusses on adapting the transformations themselves: refactoring of model transformations (e.g. [START_REF] Sánchez Cuadrado | Approaches for model transformation reuse: Factorization and composition[END_REF]), higher-order transformations ( [START_REF] Tisi | On the use of higher-order model transformations[END_REF]), model transformations "lifting" so that they can be applied on all the products of a product line [START_REF] Salay | Lifting model transformations to product lines[END_REF] by changing their execution semantics. The second category reuses transformations without changing their internals, by acting on the model elements to which these model transformations apply: Sen et al. extract the concepts used by a model transformation and adapt the target metamodel to match those concepts [START_REF] Sen | Reusable model transformations[END_REF], Cuadrado et al. defines generic model transformations [START_REF] Cuadrado | Generic model transformations: write once, reuse everywhere[END_REF], generalizing model refactorings proposed by Moha et al. [START_REF] Moha | Generic model refactorings[END_REF]. Genericity is obtained via the definition of templates [START_REF] Lara | Reusable graph transformation templates[END_REF], concept metamodels [START_REF] Cuadrado | Generic model transformations: write once, reuse everywhere[END_REF] or model types [START_REF] Steel | On model typing[END_REF], abstract structures that can be matched against actual target metamodels. There are also hybrid approaches that mixes the two categories, e.g., to deal with heterogeneous metamodels [START_REF] Lara | Towards the flexible reuse of model transformations: A formal approach based on graph transformation[END_REF].

As surveyed by Kusel et al. [START_REF] Kusel | Reuse in model-to-model transformation languages: Are we there yet?[END_REF], transformation reuse approaches can be further categorized along three dimensions: the transformation's genericity , its scope (intra/intermetamodel), and its granularity (large/small parts of the transformation implementation). Picking up a particular combination on these dimensions provides different scenarios for reuse. The authors conclude that despite the large variety of mechanisms, transformations are reused opportunistically, and on a small scale. Three issues, identified by the authors, are independent of the transformation language used for expressing transformations:

I1 -Insufficient abstraction from metamodels, meaning that

Mde lacks standard hierarchies of metamodels and transformations;

I2 -Missing repositories for selection, meaning that repositories of reusable artefacts, both at a fine-grained and coarse-grained level for transformation, are missing for 2016 8th International Workshop on Modeling in Software Engineering 1 supporting large-scale transformation reuse;

I3 -Lack of meta-information for selection, meaning that it is difficult to reuse transformations as is without knowing their internals, which can be overcome by providing appropriate meta-information.

In this paper, we form the vision that adopting the software product line paradigm at the language engineering level is a promising way to overcome these barriers. Software Product Lines (Spls) [START_REF] Pohl | Software Product Line Engineering: Foundations, Principles and Techniques[END_REF] promote the systematic reuse of software assets belonging to a given domain. They do so by carefully managing the assets base, providing compact representations (feature diagrams [START_REF] Kang | Feature-oriented domain analysis (foda) feasibility study[END_REF]) of the commonalities and variabilities amongst products derivable from this asset base, and (semi)-automated combination of these assets in a product based on the selection its user relevant characteristics (features). Spl engineering distinguishes the construction and the management of the assets (Domain Engineering, or De) and the building of products on top of the assets infrastructure (Application Engineering, Ae). Transposing the SPL paradigm for Mde means that the assets base is formed by reusable metamodel and model transformation fragments and the "products" are Dsmls building blocks. As a long-term goal, engineers should be able to derive new Dsmls the same way we configure our cars and clothes on the Internet today.

To this end, we introduce the notion of Featured Model Types (Fmts). This structure can be seen as a kind of metamodel that integrates the variability of a whole family of metamodels in the same place, as well as a catalog of associated transformations applicable depending on certain combinations of features. Therefore, a Fmt provides an abstract and compact way to describe metamodel hierarchies (addressing I1). Explicit variability modelling amongst metamodelling elements allows reuse both at the coarse-grained and fine grained level, thus providing incentives to manage repositories of specialised domain assets (tackling I2). Variability models can serve to engineer user-friendly configuration interfaces [START_REF] Boucher | Deriving configuration interfaces from feature models: a vision paper[END_REF], allowing language engineers to express their needs in a simple but consistent way, through formal reasoning on the Fmt (I3). Once choices enacted, tailored model types can be automatically derived [START_REF] Perrouin | Reconciling automation and flexibility in product derivation[END_REF][START_REF] Perrouin | Weaving variability into domain metamodels[END_REF] prior to their matching and alignment on target metamodels (or use as a new DSML). Thus, our vision does not try to invent new reuse mechanisms but rather encompasses existing ones in a systematic product line development paradigm for metamodels, expecting the same successes this paradigm achieved at the model/code level.

We start by presenting the necessary background on Model Type and Feature Diagrams in Section 2. Then, Section 3 defines our notion of Featured Model Type. Section 4 provide our Fmts operations wish list. Section 5 discusses related approaches and finally, Section 6 wraps up the paper.

BACKGROUND 2.1 Model Type

A Domain-Specific Modelling Language (Dsml) captures the knowledge of an expertise domain through high-level concepts closer to what experts manipulate in a daily basis, rather than constructions tailored to a particular technical solution. By trading generality for specificity, a Dsml allows a higher level of automation: usually, transformations are associated with the Dsml definition to analyse, verify and validate it, test instances, translate them into appropriate formats, or extract relevant information, such as metrics or views [START_REF] Lúcio | Model Transformation Intents and Their Properties[END_REF], thus simplifying the daily manipulation of instances. By nature, a Dsml is built for a limited audience; however, many Dsmls are often specified independently of each other, although they share many basic concepts, but are syntactically incompatible. As a consequence, the associated transformations are also redefined for each particular purpose, thus hindering their reuse. As depicted in Figure 1, the issue is sometimes purely syntactic: metamodels can use different names for the same concepts, or topologically arrange them differently, or add details irrelevant for some manipulations (e.g., semantic details wrt. syntactic transformations). Generally, a model can conform to only one metamodel, the one used to build it.

The notion of Model Type circumvents these limitations: certain metamodels are considered as type, to which client metamodels have to be realigned in order to reuse the associated transformations.

Definition 1 (Model Type). A model type MT ∈ T is a triplet MT = (Name, MM, T)

where Name is the (model) type name, MM is a Mof-compliant [START_REF] Omg | Meta object facility (mof) core specification[END_REF] metamodel, and T is the set of associated transformations (defined as a Moflike operation: name, return type and typed parameters).

The transformations t1, . . . , tn ∈ T are specified with the vocabulary defined in MM: the concepts and the navigation necessary for specifying the building blocks of transformations (either rules in graph-based transformations; or statements and expressions in meta-programmed transformations). Following the metamodel-based approach, a client metamodel MM that needs to reuse t i has to be aligned (also called adaptation in [START_REF] Guy | On model subtyping[END_REF]) to MM, i.e. MM has to be transformed in order to match MM in its vocabulary (i.e., class and class properties' names) and topology (i.e. how classes are connected), so that ti can be used on models complying to MM . This compares to multi-sorted algebras: to reuse operations associated with a sort, a term needs to prove that it belongs to that sort [START_REF] Clavel | All About Maude[END_REF].

The transformations associated with an Mt usually rely on the the operations defined inside the classes of the metamodel. These operations can, in turn, be shared among some of the transformations, leading to so-called intra-level reuse [START_REF] Kusel | Reuse in model-to-model transformation languages: Are we there yet?[END_REF]. However, this granularity is currently not well organised. In particular, operations have to precisely specify which structural elements they use from the Mt, so that sharing them and reusing them among transformations can be performed in a safe way. Several techniques, mostly based on static discovery of metamodel footprints are already available for that purpose [START_REF] Jeanneret | Estimating footprints of model operations[END_REF].

Feature Diagrams

Feature Diagrams, (Fds) introduced by Kang et al. [START_REF] Kang | Feature-oriented domain analysis (foda) feasibility study[END_REF], compactly and abstractly represent commonalities and variabilities of all the members of an Spl in terms of features: some of them are common to all products but some of them are only shared by few products. Each Spl member is thus uniquely identified by a combination of features. An Fd organises features in a taxonomy, graphically depicted as a tree-like structure, in which the selection of leaf features implies the inclusion of their parents and sibling selection is controlled by operators. Fds can be formalised [START_REF] Schobbens | Generic semantics of feature diagrams[END_REF] to ease reasoning about the whole Spl [START_REF] Benavides | Automated analysis of feature models 20 years later: A literature review[END_REF] and to support derivation techniques [START_REF] Perrouin | Reconciling automation and flexibility in product derivation[END_REF][START_REF] Perrouin | Weaving variability into domain metamodels[END_REF].

Definition 2 (Feature Diagram [START_REF] Schobbens | Generic semantics of feature diagrams[END_REF]). A feature diagram FD ∈ F is a quadruplet FD = (N, P, λ, DE, φ) where N is a set of nodes and P ⊆ N a set of primitive nodes, and with a distinguished root node r ∈ N, DE ⊆ N × N a set of (directed) decomposition edges (noted classically n1 -→ n2 iff (n1, n2) ∈ DE), and φ a set of boolean formulae over N expressing constraints. The function λ : N → NT labels each node with an n-ary boolean operator op n ∈ NT that indicates through which operator child nodes are related to their parent. FD is well-formed iff the graph represented by FD is acyclic and only possesses one root (i.e. the top-level entry node) and the arity of each operator op n is respected.

The node type set NT includes the typical operators encountered in classical feature diagrams notations (cf. [START_REF] Schobbens | Generic semantics of feature diagrams[END_REF]). A configuration c is a set of (selected) primitive nodes (i.e. c ∈ ℘(P), where ℘ is the powerset operator). FD thus induces sets of configurations (i.e. elements of ℘(℘(P))). The semantics of an Fd is the set of configurations in which each member satisfies the following conditions: the root is selected; the selected nodes should have their operators evaluate to true.

A graphical representation of an Fd can be found in Figure 2. From the root feature r, we notice its 3 optional (lollipop) children, h, x, t. The requires graphical constraints mandates that each time t is chosen x will be too.

FEATURED MODEL TYPES

This section proposes a new representation of Mt artifacts, called Featured Model Type (Fmt), for representing both the structural and the transformational artifacts variations. Fmts are intended as a compact representation that provides better performance for a large variety of analyses, that expresses choices for new, alternate Mts or transformation reuses. This section defines Fmts and illustrates how they can used to easily derive new Mt from a configuration.

An Fmt basically consists of an annotated metamodel: this metamodel contains all structural variants of the defining metamodels in the model type family, and each of its elements is annotated by a boolean feature expression describing which product(s) will map to this model element. In orange, relevant elements are added in order to deal with executability: a new transformation accept becomes available, which is defined using new concepts: the current State maintained during computation, which starts in Initial states and ends in Final ones. In blue, the time dimension becomes available within States, exhibiting two associated transformations: wcet for computing worst-case execution times; and accept. Note that accept is syntactically different from the previous one, thus using different transformation units. Finally in green, nested States become available for representing hierarchical Fsms that can eventually be flattened.

The third compartment describes an Fd for the structural elements, and each transformation is associated with the relevant features (r is the root; x, t and h represent respectively executability, time and hierarchical variants of the Fsm). The mapping function μ annotates each metamodel element in MMFMT FSM (including Fmt transformations) with a boolean expression indicating whether those features need these metamodel elements or not, i.e. metamodel elements should be present for a given feature (colors were used in Figure 2 instead of annotations to ease reading). Reuse at the intra-level granularity [START_REF] Kusel | Reuse in model-to-model transformation languages: Are we there yet?[END_REF], i.e. at a finer grain than transformations (rules sets in graph transformations; operations like fireable in metaprogrammed transformations, used to specify accept), is achieved with the very same mechanism: features decorate those fine-grained artifacts, describing their inter-relationships and the way they integrate within transformations through constraints. Typically, a transformation will require the operations / rules it uses, which in turns will reference the structural elements in the metamodel they need. For building an Fmt at this finegrained level, we can rely on static analysis techniques for computing call graphs and transformation footprints [START_REF] Jeanneret | Estimating footprints of model operations[END_REF].

Once an Fmt is built for a specific domain, like the Fsm in our example, it becomes possible to derive a minimal, yet complete metamodel suitable for reusing designated transformations. Figure 3 shows such a metamodel, for a configuration composed of flatten and accept. Since the derived metamodel also includes the core ingredients of an Fsm, the derivation mechanism also includes minimize as a candidate transformation for reuse. Fine-grained operations could also be returned, assuming the Fmt includes them.

WORKING WITH FMT -A WISH-LIST

This section presents a wish list of the main operations needed in Fmts environments to enable systematic reuse. For each operation, we provide a description as well as the advances and challenges involved in its realization. The first two operations focus on domain engineering or how to create an operational Fmt infrastructure, while the last four target application engineering or how to exploit Fmt to derive tailored model types. Section 3, we can start from an Mt (that will form the root of the Fmt) and incrementally add metamodel elements and transformations to support variants. This scenario is relevant when we want to build a family of model types from the onset. Yet, as for Spls, this is rarely the case. Indeed, reuse opportunities are often discovered when there is a set of related existing products we want to reuse from. In that case, we need to transition from a set of "clone" metamodels to an Fmt. A clone management framework offers primitives like findFeatures, same?, or merge [START_REF] Rubin | Managing cloned variants: A framework and experience[END_REF]. These primitives can assist domain engineers in the synthesis of Fmts. Modeldriven Product line synthesis [START_REF] Martinez | Automating the extraction of model-based software product lines from model variants[END_REF] is also to be considered here.

Building FMTs

Challenges Manual construction of Fmts is error-prone: it is easy to forget a constraint at the Fmt level, or boolean formulae can be wrongly specified. The possible consequence is to obtain an unsound or incomplete Fmt, hindering a proper derivation or analysis. We should therefore provide Fmt synthesis primitives (computing features and their dependencies, merging similar metamodel elements, etc.). These primitives have to guarantee correct by construction Fmts, relying on validation operations (see below). Another challenge is the evolution of Fmts: how do we integrate new elements in an existing Fmt? Several strategies can be assessed such as offering these elements, tagged by one unique feature, in a mutually exclusive form first. Progressively, these elements will be annotated with other features enabling finer-grained reuse. Our Fmt proposal currently considers transformations as atomic, a final challenge is to extend Fmts to transformation internals, in a similar way to what is proposed by Strüber et al. [START_REF] Strüber | Variability-based approach to reusable and efficient model transformations[END_REF].

Validating FMTs

Purpose At any step of the Fmt lifecycle, domain engineering validation activities are required. A common check we want to perform is to ensure that there is no combination of model transformations that can lead to an inconsistent Mt. Some inconsistencies, as mentioned earlier, are structural: conflicting names, references with incompatible multiplicities, or attributes with different types. Some others are related to transformation semantics: what does it mean to execute accept on a T xHFSM, since accept is not intended to handle nested states? As for SPL, the goal is to take advantage of commonalities and variabilities to save on the analysis effort by avoiding to enumerate any possible Mt, since the number of possibilities grows exponentially with the number of features. Kästner et al. proposed in [START_REF] Kästner | Type checking annotation-based product lines[END_REF] a technique called variability-aware typechecking, to deal with structural inconsistencies. Regarding semantics incon-sistencies, depending on the nature of the transformation language, either variability-aware verification [START_REF] Classen | Featured transition systems: Foundations for verifying variability-intensive systems and their application to LTL model checking[END_REF] or combinatorial interaction testing approaches [START_REF] Johansen | Properties of realistic feature models make combinatorial testing of product lines feasible[END_REF] may be adapted to that task.

Challenges All family-based analyses can be affected by scalability issues. We believe that Fmt typechecking is feasible on such a large scale, since Kästner et al. [START_REF] Kästner | Type checking annotation-based product lines[END_REF] validated their technique on large code bases. For semantic issues, all will depend on the granularity of the verification. For complex transformations, developing a suite of reusable tests, to be run during application engineering, may be complementary.

Configure a new MT product

Purpose This operation aims at assisting the user for selecting the appropriate fragments suitable for his needs. As available from the Fmts, the user can either select transformations he knows he will have to reuse, or structural fragments from Mt that capture the concepts of his language.

Challenges Similarly to Pl configuration, several design choices appear when building configurators based on Fmts. When a configuration is complete, i.e. all features have been resolved, it only remains to check for the configuration's validity. However, a configuration may be only partial, because the user is not sure which choices to select for certain features, or because some choices are left open for exploration purposes. Presenting the remaining unresolved features in a useful way for helping the user to actually perform the desired transformations can be challenging. On another hand, a configurator can be designed in a guided way, pruning choices that become impossible when new features are selected, or designed in a more permissive way (e.g., for expert users), but bundled with stronger analysis capabilities for checking configurations at the end of the process.

It is an open issue to know which scheme works best for Fmts, and there are chances that it is application-specific (or depends on the engineer expertise). In all cases, adequately documenting transformations and Mts is a key enabler for performing meaningful choices, as already noticed by Kusel et al. [START_REF] Kusel | Reuse in model-to-model transformation languages: Are we there yet?[END_REF].

Derive an MT product from a configuration

Purpose From a validated configuration, it is important to be able to derive a product. In our case, the product corresponds to an Mt, to which the user has to align his metamodel in order to reuse the associated transformations.

Challenges When several Fmts already exist for the domains targeted by the user, deriving a product consists in simply reusing the existing technology for software product lines, except that products are in this context Fmts, i.e. metamodels accompanied with transformations. For example, Figure 3 shows a derived Fmt, obtained from selecting the flatten() and accept() transformations: the derived Mt shows metamodel elements that do not appear within the original Mts. The user has then to align his client metamodel with the obtained Mt in order to be able to fully reuse the selected transformations. Several techniques already exist for that purpose, e.g. based on standard languages like Ocl [START_REF] Lara | A-posteriori typing for model-driven engineering[END_REF].

Validate an MT Product

Purpose Once the Mt has been derived, there may remain individual validation operations to perform, which are too complex to be assessed for all possible Mt at the domain engineering level. This can be the case for ensuring that every transformation of the newly build Mt works as intended by their specifications. Depending of the model transformation nature (model-to-model, model-to-text) verification [START_REF] Amrani | Formal verification techniques for model transformations: A tridimensional classification[END_REF] and testing techniques [START_REF] Fleurey | Validation in model-driven engineering: testing model transformations[END_REF] may also be applied for an individual Mt product.

Challenges Naturally, we do not expect verification properties and tests to be rewritten for each derived Mt, but to reuse them. This raises the challenge of defining such validation artifacts on Fmt, i.e. envisioning all the semantics variations a transformation may support when used with different combination of features. If these artifacts existed prior to the inclusion of the transformation in an Fmt, then lifting might be an option [START_REF] Salay | Lifting model transformations to product lines[END_REF]. Another question that arises is the validation of generic Fmt test suites. Techniques such as mutation analysis [START_REF] Mottu | Mutation analysis testing for model transformations[END_REF] may also need to be lifted to the Fmt formalism. As mentioned by Kusel et al. [START_REF] Kusel | Reuse in model-to-model transformation languages: Are we there yet?[END_REF] we may still need to write "integration tests" (i.e., detecting unexpected interactions amongst model transformation) for a derived Mt.

MT Matching and Customization

Purpose Once derived and validated, the Mt product is ready to be used on concrete metamodels. If the Mt is derived from a complete configuration, all choices have been resolved and existing matching techniques apply [START_REF] Guy | On model subtyping[END_REF][START_REF] Steel | On model typing[END_REF]. Depending on the context, transformations' semantics, more or less strict matching relationships between the derived Mt product and target metamodel may be enforced.

Challenges Challenges arise when: (i) the configuration is partial (in that case, derived product still contains some unresolved features, technically being an Fmt) or (ii) further customization is required on the model type, for example to support unexpected model elements or/and transformation. Answering to (i) involves revisiting exiting matching relationships to cover the presence of variability. The second challenge requires the customization is done in a disciplined way [START_REF] Perrouin | Reconciling automation and flexibility in product derivation[END_REF], by defining additional constraints on the derived Mt [START_REF] Zschaler | Towards constraint-based model types -a generalised formal foundation for model genericity[END_REF], possibly inherited from Fmt, to ensure that the customization does not break the derive Mt properties and transformation semantics.

RELATED WORK

Model Types were initially introduced by Steel [START_REF] Steel | On model typing[END_REF], and the notion was further explored by Guy et al. [START_REF] Guy | On model subtyping[END_REF] and Degueule et al. [START_REF] Degueule | Melange: A meta-language for modular and reusable development of dsls[END_REF]. It fully exploits the characteristics of Mof, and has therefore no equivalent in Graph-Based Model Transformations. Zschaler [START_REF] Zschaler | Towards constraint-based model types -a generalised formal foundation for model genericity[END_REF] proposed an unified representation of model types based on constraints. This paper proposes to enrich Mts with variability (features) in order to manage an Mt hierarchy. Variability for metamodels has already been explored in [START_REF] Perrouin | Weaving variability into domain metamodels[END_REF]. Techniques were presented to weave variability in metamodel constructs. The goal was to add more flexibility in the usage of a given metamodel. In our approach we aim to manage a set of existing metamodels. Our vision also encompasses the consistent management of transformations associated with Mts.

Several contributions applied variability management to programming or modelling languages: Vacchi et al. [START_REF] Vacchi | Automating variability model inference for component-based language implementations[END_REF] for reverse engineering techniques with Neverlang, a modular language implementation framework; Cengarle et al. for describing variations of a base language in MontiCore; or Haugen et al. [START_REF] Haugen | Adding standardized variability to domain specific languages[END_REF] for modelling possible variations in Dsmls in Cvl (Common Variability Language); or White et al. [START_REF] White | Improving domain-specific language reuse with software product-line configuration techniques[END_REF] for improving reusability of features among a language family, among others. Our vision proposes an explicit, concise formalism for Fmts for managing a family of languages (or metamodels); a potential target language can be Clafer [START_REF] Bak | Feature and meta-models in clafer: mixed, specialized, and coupled[END_REF][START_REF] Haugen | Adding standardized variability to domain specific languages[END_REF], a metamodelling language mixing features and classes.

Inferring product lines models has already been studied [START_REF] Acher | Composing your compositions of variability models[END_REF][START_REF] Holthusen | Family model mining for function block diagrams in automation software[END_REF][START_REF] Martinez | Automating the extraction of model-based software product lines from model variants[END_REF][START_REF] Martinez | Identifying and visualising commonality and variability in model variants[END_REF][START_REF] Rubin | Combining related products into product lines[END_REF][START_REF] Rubin | Quality of Merge-Refactorings for Product Lines[END_REF][START_REF] Vacchi | Automating variability model inference for component-based language implementations[END_REF][START_REF] Zhang | Model comparison to synthesize a model-driven software product line[END_REF][START_REF] Zhang | Augmenting product lines[END_REF]. Holthusen et al. [START_REF] Holthusen | Family model mining for function block diagrams in automation software[END_REF] propose to mine a so-called family model for function block diagrams. Martinez et al. propose feature mining and visualization techniques for managing variability of model variants [START_REF] Martinez | Identifying and visualising commonality and variability in model variants[END_REF]. Rubin and Chechik propose to combine related product (models) into product lines (models annotated with presence conditions) [START_REF] Rubin | Combining related products into product lines[END_REF][START_REF] Rubin | Quality of Merge-Refactorings for Product Lines[END_REF]. For example, it is possible to infer from Uml models a product line representation. In their case, all input models are instances of the same metamodel. Hence their approach does not consider the inference (or synthesis) of families of languages. Zhang et al. describe comparison techniques to synthesize model-based product lines [START_REF] Zhang | Model comparison to synthesize a model-driven software product line[END_REF] as Cvl models [START_REF] Haugen | Adding standardized variability to domain specific languages[END_REF]. An extension to augment product lines and thus to support the incremental synthesis of product lines is subsequently proposed in [START_REF] Zhang | Augmenting product lines[END_REF]. The specific problem of synthesising Fmt from a set of input metamodels has not been explored so far and remains a challenge (see Section 4.1).

Salay et al. propose to make applicable transformations defined on individual products on the whole product line, by changing the execution semantics of the transformation (defined in terms of rewriting rules) [START_REF] Salay | Lifting model transformations to product lines[END_REF]. In our work, we aim to have a catalog of transformations that can be applied to any "product" metamodel.

CONCLUSION

In this paper, we described a vision in which model types should be engineered as families rather than independently. We introduced the formal notion of featured model type to this end and exhibited how techniques originally developed in the Spl community can be applied to Fmt to provide automated support for model type derivation depending on architectural / behavioural concerns as well as family-wise analyses. We first plan to realise our vision using DSML frameworks such as Clafer [START_REF] Bak | Feature and meta-models in clafer: mixed, specialized, and coupled[END_REF], Melange [START_REF] Degueule | Melange: A meta-language for modular and reusable development of dsls[END_REF], and/or Familiar [START_REF] Acher | Familiar: A domain-specific language for large scale management of feature models[END_REF] to specify Fmt. The next item on the research agenda concerns the semi-automated synthesis of Fmt from a collection of existing artifacts. Finally we will also investigate type-checking and consistency analyses at the Fmt level to guarantee certain properties on derived model types.

  Graph-Based representation of an Fsm. An Fsm with a different topology. Extension of the FSM metamodel with execution details.

Figure 1 :

 1 Figure 1: Variations on the FSM Dsml: (a) Base Metamodel (for simplifying the metamodels, references between State and Transition are omitted here and in the remainder of the paper); (b) Variation on the concepts' names (Vertex and Edge instead of State and Transition); (c) Different topology (State, instead of FSM in (a), contains Transition); (d) Additional details for execution purpose.

Definition 3 (

 3 Featured Model Type). A Featured Model Type FMT ∈ FT is a tuple FMT = (Name, MM, FD, T, μ) where (Name, MM, T) ∈ T is a model type, FD ∈ F is a feature diagram and μ : MElement ∪ T → B(N, ∧, ∨, ¬) a partial function mapping metamodel elements (classes, operations and class properties) and Fmt transformations to a boolean formulae over the node set N of FD.

Figure 2

 2 Figure 2 depicts an Fmt for the Finite State Machines (Fsms) domain. The name FMT FSM appears in the first compartment. The second compartment contains the metamodel elements present in each Fsm variant. The fourth one contains the associated transformations. All together, they form a valid Mt. A core metamodel, in black (with a root container FSM containing States and Transitions -Note we omitted associations between them to enhance readability), is progressively extended to represent three other variants.In orange, relevant elements are added in order to deal with executability: a new transformation accept becomes available, which is defined using new concepts: the current State maintained during computation, which starts in Initial states and ends in Final ones. In blue, the time dimension becomes available within States, exhibiting two associated transformations: wcet for computing worst-case execution times; and accept. Note that accept is syntactically different from the previous one, thus using different transformation units. Finally in green, nested States become available for representing hierarchical Fsms that can eventually be flattened.The third compartment describes an Fd for the structural elements, and each transformation is associated with the relevant features (r is the root; x, t and h represent respectively executability, time and hierarchical variants of the Fsm). The mapping function μ annotates each metamodel element in MMFMT FSM (including Fmt transformations) with a boolean expression indicating whether those features need these metamodel elements or not, i.e. metamodel elements should be present for a given feature (colors were used in Figure2instead of annotations to ease reading).

Figure 2 :

 2 Figure 2: An Fmt for the Finite State Machine domain: executability, hierarchy and time concerns.

PurposeFigure 3 :

 3 Figure 3: Derived Fmt based on selecting transformations flatten() and accept().


Manel Achichi

Zohra Bellahsene

Dino Ienco
email: dino.ienco@teledetection.fr

Konstantin Todorov

Towards Linked Data Extraction From Tweets

à la diffusion de documents scientifiques de niveau recherche, publiés ou non, émanant des établissements d'enseignement et de recherche français ou étrangers, des laboratoires publics ou privés.

Introduction

One of the goals of the Linked Open Data (LOD) initiative is to structure and interconnect data on the web by using semantic web technologies, such as the Resource Description Framework (RDF), thus taking the web of today up to a new level where data are interpretable and accessible by both humans and machines [START_REF] Bizer | Linked data -the story so far[END_REF]. A considerable effort has been made in that direction throughout the last couple of years. However, many sources of valuable information on the web still remain unexplored, although they contain useful data that can be beneficial for the LOD project. In this paper, we focus on the social medium Twitter that provides a platform for the publication of short messages (tweets) of maximal length of 140 characters. The network has enjoyed a growing popularity through the past years, becoming a major source of novel information about many important events, made available in real time, often even before its diffusion through the conventional broadcasting channels. The main motivation of our work is to enable the integration of the information flowing daily through the Twitter stream to the web of data. We propose a method for the extraction of relevant data from Tweets, their conversion into RDF and their storing into an RDF triplestore with the final objective of their publication as linked open data. Our approach covers the entire processing chain following a well-defined workflow, which will be presented in Section 3.

A big family of related approaches focuses on relation extraction from text, divided into those based on dependency and those based on syntactic parsing. We can cite systems like Reverb [START_REF] Fader | Identifying relations for open information extraction[END_REF] or the multilingual DepOE [START_REF] Gamallo | Dependency-based open information extraction[END_REF] from the latter group and CLAUSIE [START_REF] Corro | Clausie: clause-based open information extraction[END_REF] -from the former. The system OLLIE [START_REF] Schmitz | Open language learning for information extraction[END_REF]) is based on relation patterns which are extracted by Reverb.

There are two main categories of approaches to extract RDF triples from text. The first category exploits background knowledge to infer new facts from text. One example is the method proposed in [START_REF] Anantharangachar | Ontology guided information extraction from unstructured text[END_REF], where RDF triples are extracted using domain specific dictionaries induced by an existing ontology. The methods belonging to the second category usually apply semantic analysis on text [START_REF] Exner | Entity extraction: From unstructured text to dbpedia rdf triples[END_REF][START_REF] Augenstein | Lodifier: Generating linked data from unstructured text[END_REF][START_REF] Cattoni | The knowledgestore: an entity-based storage system[END_REF]. In [START_REF] Cattoni | The knowledgestore: an entity-based storage system[END_REF], a large-scale infrastructure to store and interlink multimedia resources is presented. The system is able to import and annotate knowledge in the form of RDF, automatically associating resources to entities and creating new knowledge in the form of RDF triples. One particularity of this system is the association of context information to each managed resource.

We distinguish between two approaches to tweets summarization -the first group provides a bag of terms as a summary [START_REF] Cataldi | Personalized emerging topic detection based on a term aging model[END_REF][START_REF] Benhardus | Streaming trend detection in twitter[END_REF][START_REF] Mathioudakis | Twittermonitor: trend detection over the twitter stream[END_REF], while the second extracts representative tweets. Approaches of the second group are more suitable to us, as they preserve some kind of structural coherence and conciseness in the derived summary. In [START_REF] Sharifi | Summarizing microblogs automatically[END_REF], a set of tweets is summarized by a sentence derived by a graph representation of the words (co-)occuring in a collection of tweets. [START_REF] Chua | Automatic summarization of events from social media[END_REF] retrieve the most relevant tweets as summary of a tweets collection, based on topic models. Two other techniques are proposed in [START_REF] Olariu | Hierarchical clustering in improving microblog stream summarization[END_REF]. The first one first merges all the tweets in a word graph (similarly to [START_REF] Chua | Automatic summarization of events from social media[END_REF]) and then computes a score function to select a path of the graph as a possible summary. The second one selects the most frequent words subsequence (phrase).

Overview of the Approach

Our processing chain covers the entire process from the constitution of a Twitter corpus to the generation of an RDF triplestore (Figure 1).

Constituting a corpus of tweets. Tweets written in English are first collected from trusted sources -Twitter accounts of established media (e.g., the BBC). These tweets are then grouped together topic-wise, by using topic identification techniques, forming homogeneous clusters. We have chosen the K-MEANS clustering algorithm for its simplicity and efficiency. We set K at the lowest value that maintains the ratio {average intra-cluster distance / average intercluster distance} under a given threshold. Further, for every topic, we collect crowded tweets from ordinary users accounts, which are used to enrich the information contained in every topic. Finally, we only keep the tweets closely related to topics that we want to represent, i.e., tweets containing previously extracted keywords (the most frequent words in each cluster).

Filtering and preprocessing. A filtering component is applied to both trusted and crowd sources. The aim is to only keep tweets that contain named entities, and particularly ones that have DBpedia URIs, in preparation of the linking of the (yet to be) extracted RDF triples to the web of data. The crowded tweets are additionally filtered with respect to their adequacy to a given topic by the help of a set of keywords describing each topic. Moreover, all tweets are preprocessed by removing hashtags, urls and retweets and by lemmatizing the text.

Crowded tweets classification. We introduced a text classification module, based on the principle of sentiment analysis, in order to classify the crowded tweets into two categories: (i) fact, including neutral, objective information that we want to keep and use to enrich the trusted tweets, and (ii) other, including opinion, private messages, etc. We used the coreNLP tool. Here, we assume that a tweet that conveys factual information (or a piece of news) is stripped from both positive and negative sentiment. However, assessing the polarity of a tweet was not sufficient in order to judge on its objectivity. As additional classification criteria, we check for the absence of the following set of features within each tweet: (i) the "@" symbol indicating a private message, (ii) repetitive letters or abuse of ponctuation, (iii) smileys that reflect a mindstate, and (iv) misspelled words.

Automatic summarization. After constituing a tweets corpus per topic, we proceed to generate a summary of this corpus, in order to remove redundant and unnecessary information. The algorithm that we have developed generates automatically a summary of a topic in the form of a concise and coherent set of tweets. It takes two parameters as input: a set of tweets corresponding to a topic and a threshold to control tweets similarity (σ). First, the algorithm constructs a weighted undirected graph (G) where the vertices are the tweets and an edge exists between two vertices if the cosine similarity between the two corresponding tweets is greater than σ. Further, the algorithm proceeds to extract the maximal cliques from G, relying on the well-known Bron-Kerbosch algorithm. The assumption here is that a maximal clique represents a cluster of potentially redundant information that can be represented by one single tweet. The PageRank algorithm is then used to assign scores to the vertices within each clique and select the one with the highest score as a summary of the clique. If we have several tweets with the same score, the algorithm selects the longest one. The summary of the entire topic is given by the set of tweets representing each maximal clique within the topic graph.

From tweets to RDF. Finally, the last step consists in transforming every summary into an RDF graph. We were inspired by the state-of-the-art approach to RDF extraction from text, LODifier [START_REF] Augenstein | Lodifier: Generating linked data from unstructured text[END_REF], since it relies on the idea of anchoring the extracted semantic information in DBpedia's namespace. Our approach consists of four main steps:

(1) Semantic analysis. The semantics of every phrase is modeled as a (set of) triple(s) of the kind subject, verb, object . The algorithm given in [START_REF] Rusu | Triplet extraction from sentences[END_REF]) was adopted and adapted because of its effectiveness combined with the Stanford Parser. This algorithm works well with simple single-clause sentences but fails to handle properly multi-clause sentences. We propose the following clause-splitting iterative algorithm : (1) Apply dependency analysis on the complex phrase. (2) For each dependency relationship of type "nsubj" (nominal subject), retrieve all relationships of its arguments, except for the "nsubj" type relationships. ( 3) Repeat (2) for each retrieved relationship until no new relationship is added. ( 4) For all dependencies enveloped by a relationship of type "nsubj", extract and organize all the words in ascending order of the numbers associated to them. These numbers indicate the order of words in the original sentence.

(2) Disambiguation. Before assigning a DBpedia URI to a word, we choose its most appropriate sense in a given context. We have applied a commonly used method based on synset identification in WordNet.

(3) DBpedia URI assignment. We assign to every term its corresponding DBpedia URI.

(4) Generation of an RDF graph. During the semantic analysis, the sentences were decomposed to simple clauses and each clause has been structured as a triple of the kind subject, verb, object . In this last step, the system performs a conversion of these triples in an RDF graph. Arguments created during the semantic analysis are analyzed to identify the named entities that correspond to RDF subjects and objects and assign to each of them the corresponding DBpedia URI. To do this, we match the subject and the object of the extracted triples to the existing triples in the DBpedia graph.

Prototyping and Experiments on Real Twitter Data

We use the Twitter4J1 API to collect tweets from stream, the TextRazor2 service to recognize entities and successively assign them a Wikipedia URL, and the Stanford CoreNLP library to deal with natural language processing and sentiment analysis.

The collection of trusted tweets is obtained by crawling the social medium on October 9, 2014 for a period of 24 hours. We followed the accounts of BBC World, CNN, New York Times, New York Times World, and Breaking News.We kept those tweets that contain at least one named entity that corresponds to a DBpedia URI. This first collection is composed by 125 tweets. The collection of crowded tweets is retrieved on October 10, 2014 by considering keywords extracted from the trusted tweets. In our dataset, we were able to detect 50 different topics from the trusted tweets. Here is an example of a topic composed by 5 tweets: {(1) Swimming made Michael Phelps a dominant athlete but it couldn't guide him outside of the pool; (2) USA Swimming announces 6 months suspension for Michael Phelps after DUI arrest;

(3) Michael Phelps suspended by USA Swimming; (4) Michael Phelps received a six months suspension from swimming; (5) Swimmer Michael Phelps suspended for six months.}. For that example, we retrieved 1 325 short messages from crowded sources by using trusted tweets keywords. Successively, we classify the tweets as news or other by applying the classification rules presented in Section 3. Table 1 reports the results of the classification. We obtain an accuracy of 76.22%. We also analyze the behavior of our method by only considering the class news. To this end, we compute Precision, Recall and F-Measure for this class obtaining, respectively, 0.628, 0.722 and 0.672. This evaluation underlines the quality of our strategy and shows that our method is able to detect about 2 out of 3 tweets containing factual information. We note that low values (between 0.3 and 0.5) of the σ parameter correspond to a high number of maximal cliques, while the trend for values between 0.5 and 0.95 is quite stable.

In Table 2, we show several triples produced by our method with σ equaling 0.65. These triples represent information that is automatically induced by the set of tweets on the topic Michael Phelps. In total, 10 triplets were extracted of which 4 triplets are identical. The small number of extracted triples is due to the fact that collecting the tweets was performed during 24 hours only. All the RDF triples are then stored in a triple store3 , ready to be published and interlinked on the web of data.

Conclusion

The approach that we propose is complete -we take as an input the heterogeneous stream of tweets flowing daily through the social medium and we output an RDF triplestore containing only factual information about entities that live in DBpedia's namespace. Among the original contributions of our framework, we underline: i) the use of two main sources of data -trusted (tweets coming from established mainstream media) and crowd (ordinary users tweets). The latter source is used to enrich the data collected from the former. In order to limit redundancy in the collected information and prepare the corpus of tweets for the RDF triples extraction phase, ii) we introduce a novel approach to automatically generate a summary of a set of tweets, relevant to a given topic. As the extracted summaries can be rich and structurally complex, iii) we design a strategy to split multi-clause tweets into simple chunks of information in order to easily identify the components of a RDF triple. Finally, the entire approach is implemented in a modular prototype.

FIG. 1 -

 1 FIG. 1 -The workflow of the system.

http://twitter4j.org/en/index.html

https://www.textrazor.com/

Virtuoso, http://virtuoso.openlinksw.com/


F. CHATELAIN T T Le

C Berenguer

Competing deterioration processes modeling and RUL estimation based on Factorial Hidden Markov Models

Deterioration modeling and Remaining Useful Life (RUL) estimation play an important role in implementing a predictive maintenance program since it helps to predict early the failure time caused by an incipient deterioration, and thus to provide sufficient time for maintenance crew to act before the actual failure eventually occurs. One well-identified challenge in deterioration modeling is that equipment does not always deteriorate following only one single mechanism, instead several deterioration modes can co-exist in competition due to the dynamics and variability of operating and environmental conditions. In this paper, we study the phenomenon where different modes co-evolve in parallel within a single component until one of them lead the component to fail. The observations contain hence information of the states of each mode, leading the inference problem being difficult. To deal with this problem, the Factorial Hidden Markov Model (FHMM) and the variational approximation technique are adapted. The associated RUL estimation method is also developed. To evaluate the performance of the proposed approach, a numerical study is given.

Introduction

Predictive Maintenance (PM) plays nowadays an important role in maintaining production equipment thanks to its ability to eliminate unnecessary scheduled preventive maintenance operations as well as to avoid unforeseen failures; hence it can significantly reduce the maintenance cost [START_REF] Jardine | A review on machinery diagnostics and prognostics implementing condition-based maintenance[END_REF]. Within a PM framework, the RUL estimation is a key enabling task since it could provide sufficient time for maintenance engineers to schedule an intervention or to acquire replacement components before an actual failure. As pointed out in [START_REF] Gorjian | A review on degradation models in reliability analysis[END_REF], evaluation of the current equipment's health state is an essential task in estimating its RUL in practical applications. To this end, deterioration phenomena of the equipment should be carefully investigated and properly modeled.

In the literature, stochastic models are often studied to model deterioration processes thanks to its capacity of taking into account the stochastic nature of the deterioration phenomena. Depending on the types of its states space, one can divide the stochastic models into two main classes: continuous or discrete. Lévy process [START_REF] Van Noortwijk | A survey of the application of gamma processes in maintenance[END_REF], general path model [START_REF] Lu | Using degradation measures to estimate a time-to-failure distribution[END_REF] are examples of the first class. Regarding the continuous-state processes, we can list here Markovian-based models, such as Hidden Markov Models (HMMs) [START_REF] Rabiner | A tutorial on hidden Markov models and selected applications in speech recognition[END_REF], Hidden semi-Markov models (HsMM) [START_REF] Dong | A segmental hidden semi-Markov model (HSMM)-based diagnostics and prognostics framework and methodology[END_REF]. Compared to the first one, the second class models the health states of equipment by a finite number of discrete states which could be easier for maintenance engineers to interpreter the obtained results. A detailed review of deterioration models used in reliability analysis can be found in [START_REF] Gorjian | A review on degradation models in reliability analysis[END_REF].

While modeling the deterioration processes, a well identified difficulty is to deal with the co-existence of multiple modes of deterioration [START_REF] Compare | Interacting multiple-models, state augmented Particle Filtering for fault diagnostics[END_REF]; [START_REF] Le | Multi-branch hidden Markov models for remaining useful life estimation of systems under multiple deterioration modes[END_REF]. These different mechanisms, coexisting even within a single component, can lead to different temporal evolution behaviors of deterioration indicators. An example of such phenomenon can be found in a rolling element bearing, an essential component of every rotating machinery in industry. In effect, under operation, point defects such as cracks, pits and spalls appearing on different constituent elements (i.e. outer race, inner race, cage, etc.) can lead to different deterioration dynamics of the bearing [START_REF] Heng | Intelligent prognostics of machinery health utilising suspended condition monitoring data[END_REF]. Taking this phenomenon into account is hence crucial both for a comprehensive assessment of the health state of equipment as well as for an accurate RUL estimation. To tackle this problem, the concept of multi-branch models has been proposed recently by the current authors in [START_REF] Le | Multi-branch hidden Markov models for remaining useful life estimation of systems under multiple deterioration modes[END_REF][START_REF] Le | Jump Markov Linear Systems for deterioration modeling and Remaining Useful Life estimation[END_REF]. As Markov-based models, the multi-branch methods showed promising results in RUL estimation compared to the ones obtained with the standard "mono-branch" models especially when multiple deterioration modes co-exist. Nevertheless, the works in [START_REF] Le | Multi-branch hidden Markov models for remaining useful life estimation of systems under multiple deterioration modes[END_REF] considered only the modes competition in an incubation period, meaning that once one of them has already initiated, the equipment cannot change to the others. In Le et al. (2015a), the modes transitions were allowed but the equipment can be only in one of them at a time.

In this paper, we are interested in modeling the deterioration phenomenon where several modes coexist in parallel. Specifically, different deterioration modes evolve independently and all contribute to observed default symptoms. It is sufficient that only one of these modes reaches its own failure state can lead to the breakdown of the equipment. The mixed contribution of the modes at the observation level leads to difficulties in diagnosing the equipment's health state as well as in predicting its RUL. To overcome these problems, we propose in this paper a diagnostics/prognostics framework based on the factorial hidden Markov model (FHMM) [START_REF] Ghahramani | Factorial hidden Markov models[END_REF]. The remainder of the paper is organized as follows. Section 2 is devoted to review some mathematical background of the FHMM model and explain how to estimate its model parameters via an approximated method. The application of the FHMM model for the diagnostics and prognostics of a bearing is investigated in Section 3. Finally, conclusion follows in Section 4.

Factorial Hidden Markov Model

Model structure

The Factorial Hidden Markov Model (FHMM) is an extension of the HMM one with distributed state representation which is a particular class of probabilistic graphical model [START_REF] Ghahramani | Factorial hidden Markov models[END_REF]. The model consists of several branches in parallel in which each one can be considered as a single Markov chain. At any instants, the distributed states all contribute to the observations as shown in Figure 1.

Figure 1. Factorial Hidden Markov Model

Similar to the standard HMM models, states transitions within a branch m of the FHMM model is characterized by an initial state distribution π (m) and a state transition matrix P (m) [START_REF] Rabiner | A tutorial on hidden Markov models and selected applications in speech recognition[END_REF] where the superscript is used to denote the corresponding branch in this paper. A combination of the states in all constituent branches at a given time t is called the meta-state, that is

S t = S (1) t , S (2) t , . . . , S (M) t
where M is the number of branches.

Furthermore, the states within the branch m can take one of

K (m) discrete values, i.e. S (m) t ∈ 1, 2, . . . , K (m) .
For the seek of simplicity, we assume in this paper that K (m) = K, ∀m. The generation to the case of different K (m) values is straightforward [START_REF] Ghahramani | Factorial hidden Markov models[END_REF].

In the FHMM model, the observation emitted at a given time depends on the individual states within the branches at that time. Its density can be modeled as a function of the ones of the branch states:

p (O t | S t ) = f P O t | S (1) t , P O t | S (2) t , . . . , P O t | S (M) t (1)
The precise nature of the function f depends on the proportions to which the observations from the individual components are mixed in the current one. The contribution of each component could depend on several factors and is difficult to be determined precisely [START_REF] Reyes-Gomez | Multi-channel source separation by factorial HMMs[END_REF]. For continuous observations, a simple form for this dependence is linear Gaussian [START_REF] Ghahramani | Factorial hidden Markov models[END_REF]. That is, the observation O t is a Gaussian random vector whose mean is a linear function of the component ones: Concerning the covariance parameter, there exists two main possibilities in the literature : global or composed covariance approaches [START_REF] Reyes-Gomez | Multi-channel source separation by factorial HMMs[END_REF]. It should be noted that the composed covariance could lead the model learning procedure being more complex than in the global covariance case since it introduces more free parameters to be estimated. For the seek of simplicity, only the global covariance matrix is considered in this paper, meaning that all factorial states have in common a covariance matrix C.

µ t = M ∑ m=1 w (m) µ µ (m) t (2)

Parameters estimation

Denote Θ = π (m) , P (m) , w (m) µ ,C m=1:M
the parameters vector of the FHMM model. Since the states are hidden, the standard expectation-maximization (EM) algorithm [START_REF] Dempster | Maximum likelihood from incomplete data via the EM algorithm[END_REF] appears to be a suitable tool for parameters estimation. However, as pointed out in [START_REF] Ghahramani | Factorial hidden Markov models[END_REF], the expectation (E) step is computationally intractable in this case. Therefore we adapt in this section the variational approximation technique proposed by [START_REF] Ghahramani | Factorial hidden Markov models[END_REF] to overcome this problem.

The basic of the variational technique is to approximate the posterior distribution over the hidden variables P (S 1:T | O 1:T ) by a tractable distribution Q (S 1:T ) where S 1:T and O 1:T denote the sequence of metastates and observations from time 1 to T . More specifically, at any kth iteration of the standard EM algorithm, the Jensen's inequality can be applied in computing the expected complete data log-likelihood as follows:

Q Θ | Θ k-1 = log ∑ S 1:T P (S 1:T , O 1:T | Θ) = log ∑ S 1:T Q (S 1:T ) P (S 1:T , O 1:T | Θ) Q (S 1:T ) ≥ ∑ S 1:T Q (S 1:T ) log p (S 1:T , O 1:T | Θ) Q (S 1:T ) = F (Q, Θ) (3)
This inequality provides a lower bound on the log-likelihood that can be used to obtain an efficient learning algorithm. The difference between Q and F is given by the Kullback-Leibler divergence:

KL (Q||P) = ∑ S 1:T Q (S 1:T ) log Q (S 1:T ) P (S 1:T | O 1:T , Θ new ) (4)
By minimizing this divergence, the log-likelihood is assured to increase until it reaches a (local) maximum.

It should be noted that the function Q must be chosen to be tractable. Depending on the form of this function, two variational techniques were proposed: completely factorized and structured variational inference [START_REF] Ghahramani | Factorial hidden Markov models[END_REF]. Compared to the first one which factors the posterior probability such that all the state variables are statistically independent, the second technique can preserve more the probabilistic structure of the original FHMM model and hence will be used in this paper.

Based on this approximation technique, the parameters vector Θ is computed in the maximization (M) step. More details about the calculation formulas can be found in [START_REF] Ghahramani | Factorial hidden Markov models[END_REF].

State estimation and RUL prediction

Suppose that we have trained the FHMM model in an offline phase from the historical until-failure data. We move now to an online phase where the deterioration signals of a monitored system are acquired in real time via a condition monitoring system. The objective is to estimate the actual states of all the deterioration modes at a given time and then predict the system's RUL.

The estimation of the deterioration states given the observations in case of the FHMM model is itself a complex task since it can be referred as the source separation problem found in the speech recognition community [START_REF] Reyes-Gomez | Multi-channel source separation by factorial HMMs[END_REF]. Several methods have been developed in the literature for accomplishing this problem. One of the most simple solutions is to transform the FHMM model into a meta-HMM one with K M "meta-states" and then applied the Viterbi algorithm [START_REF] Rabiner | A tutorial on hidden Markov models and selected applications in speech recognition[END_REF] in a standard way. Although this method leads to more computation time compared to another ones, its performance is still acceptable in several practical applications since only the maximization is retained after each recursive iteration.

This method allows us to estimate the most likely sequence of meta-state given a sequence of observations. The corresponding state sequences of each individual branch of the FHMM model is then obtained by decomposing it into a base-M system. After that, the last state of each decomposed sequence can be considered as the current health state of the deterioration mode corresponding to that sequence. Given the estimated states, the RUL can be defined as follows:

RUL = min k RUL (k) (5)
where RUL (k) is the remaining time for the mode k to reach the final state from its current state. In other words, RUL (k) is referred as the RUL of a standard HMM model corresponding to the kth branch of the FHMM model. The RUL probability density function (pdf) calculation for a standard HMM model for the discrete time case can be found in [START_REF] Le | Multi-branch hidden Markov models for remaining useful life estimation of systems under multiple deterioration modes[END_REF].

Given the individual RUL density functions, the cumulative distribution function (cdf) of the overall RUL of the FHMM model can be obtained by:

CDF RUL (x) = 1 -P RUL (1) > x, RUL (2) > x, . . . , RUL (M) > x = 1 - M ∏ k=1 CDF (k) RUL (x) (6)

Numerical study

In this section, the diagnostics and prognostics performances of the FHMM model are evaluated through the case of a defected rolling element bearing with multiple point defects. The bearing is chosen because it is an essential component for all rotating machinery found in industry. Firstly, we simulate vibration signals generated by a bearing in case that several point defects coexist within it. The kurtosis features are then extracted and used as observations for training the FHMM model. The RUL estimation performance of the learned FHMM model is compared with the one obtained by a standard HMM model.

Multiple point defects simulation with severity evolution

McFadden & Smith (1985) proposed a simple mathematical model for simulating the vibration signals produced by a bearing with multiple point defects. By assuming that the bearing operates under constant radial load, the vibration response v(t) can be modeled as the product of repetitious impulses d(t) at the fault frequency with the distribution of load q(t), convolved with an exponential decay h(t) due to damping:

v(t) = [d(t) • q(t)] * h(t) + n(t) (7)
where the notation * represents the convolution operation and n(t) are the noises added to corrupt the signal.

Figure 2a shows the simulated raw vibration signals of the bearing in case that two point defects co-exist, one is on the inner race and the other on the outer race. The co-existence of these two defects can be verified on the frequency spectrum obtained through an envelope analysis (c.f. Figure 2b). This model although represents well the vibration signals of a defected bearing, it does not however take into account the temporal evolution of the defaults. In the literature, vibration data are usually acquired periodically and temporal features such as the kurtosis are extracted and plotted in order to study the evolution trend of fault severity over time for the bearing prognostics purpose. To simulate deterioration processes, the above defective bearing vibration signals are repeatedly generated with progressive impulse amplitudes d(t). Each repetition corresponds to one data acquisition time in practice. In this study, we suppose that the impulse amplitudes d(t) generated by each point defect increase over time following a homogeneous Gamma process. A random delay following a Poisson distribution is also added in order to represent the bias between the appearance times of the two defects. The kurtosis feature is used to represent the overall defect severity of the bearing. Finally, the data generation is stopped once the extracted kurtosis value reaches for the first time a critical threshold L = 10. Beyond this boundary, the bearing is considered to be failed. By repeating this procedure several times, different kurtosis evolution curves can be obtained as represented in Figure 3a. These values are considered as the training data for estimating the parameters of the FHMM model. Figure 3b shows the convergence of the log-likelihood curve which demonstrates the effectiveness of the variational approximation technique in training the FHMM model.

FHMM vs HMM

In studying the FHMM model, an interesting question is to compare it with a "standard" HMM model in term of RUL estimation performance. To this end, we firstly train the two models by the same training data set. The branches of the FHMM model are supposed to have the same number of discrete states as in the HMM one. This number can be determined by using the Bayesian Information Criterion (BIC) as presented in [START_REF] Le | Multi-branch hidden Markov models for remaining useful life estimation of systems under multiple deterioration modes[END_REF].

The next step is to use the two learned models to estimate the RUL of same test data set. The root mean squared errors (RMSE) is used for the comparison purpose. Since the prognostics performance depends on the instant at which the RUL estimation is carried out, we further define a critical level at which the prediction is triggered for all the test cases. In other words, the diagnostic and prognostic tasks for every test cases are started once its corresponding kurtosis feature reaches this level for the first time. Figure 4 shows the RMSE values obtained by the two models as the function of the triggered level. We can see that the RUL estimation errors for the both models decrease with the increment of the triggered level. This is due to the fact that the latter the prediction is performed, the more information become available and hence leading to the better RUL estimation results. Furthermore, compared to the standard HMM model, the FHMM one shows the better performance in terms of RMSE criterion, especially when one want to trigger the prediction earlier. This can be explained by the fact that the FHMM model helps to take into account the coexistence of different deterioration modes at early stage of deterioration process. More lately, one of the deterioration modes may already dominate the others, leading to the similar RMSE results between the FHMM and the HMM models.

Conclusion

The present paper proposes the use of the factorial Hidden Markov Model (FHMM) in order to deal with the deterioration modeling problem in case that several competing modes co-exist within a single component. The variational approximation technique is adapted to overcome the model parameters learning problems. In terms of diagnostics, this model helps to evaluate the actual deterioration states within every existed modes. The RUL of the component is then estimated as the minimum time for one of these modes to reach its own failure state. The numerical results show that by taking into account the coexistence of several deterioration modes, the FHMM gives better performance in RUL estimation in comparison with the traditional HMM model.

Future research will be focused on the extension of the FHMM model to represent the dependency between the different deterioration modes. The proposed method should also be validated on real world systems data.

  where µ (m) t represents the D dimensional mean vector of the Gaussian distribution corresponding to the component state S (m) t and w (m) µ is a D × D weighting matrix.

Figure 2 .

 2 Figure 2. Multiple point defects bearing simulation

Figure 3 .

 3 Figure 3. Training data and learned log-likelihood curve

Figure 4 .

 4 Figure 4. RMSE values at different prediction triggered levels