Luis Thomas
email: luis.thomas@ensta-bretagne.org

Sebastien Gougeaud
email: sebastien.gougeaud@cea.fr

Stéphane Rubini
email: stephane.rubini@univ-brest.fr

Philippe Deniel
email: philippe.deniel@cea.fr

Jalil Boukhobza
email: jalil.boukhobza@ensta-bretagne.fr

Predicting file lifetimes for data placement in multi-tiered storage systems for HPC

Keywords: CCS Concepts:, Information systems → Information storage systems, Storage management, Hierarchical storage management, Information lifecycle management, Data placement, Multi-Tier Storage, File lifetime, Convolutional Neural Network, Machine Learning, High Performance Computing, Heterogeneous Storage, Storage Hierarchy

The emergence of Exascale machines in HPC will have the foreseen consequence of putting more pressure on the storage systems in place, not only in terms of capacity but also bandwidth and latency. With limited budget we cannot imagine using only storage class memory, which leads to the use of a heterogeneous tiered storage hierarchy. In order to make the most efficient use of the high performance tier in this storage hierarchy, we need to be able to place user data on the right tier and at the right time. In this paper, we assume a 2-tier storage hierarchy with a high performance tier and a high capacity archival tier. Files are placed on the high performance tier at creation time and moved to capacity tier once their lifetime expires (that is once they are no more accessed). The main contribution of this paper lies in the design of a file lifetime prediction model solely based on its path based on the use of Convolutional Neural Network. Results show that our solution strikes a good trade-off between accuracy and under-estimation. Compared to previous work, our model made it possible to reach an accuracy close to previous work (around 98.60% compared to 98.84%) while reducing the underestimations by almost 10x to reach 2.21% (compared to 21.86%). The reduction in underestimations is crucial as it avoids misplacing files in the capacity tier while they are still in use.

Introduction

The amount of data generated in the world seems to grow exponentially, from 4 zetabytes in 2013 to an estimated 185 zetabytes in 2025 [START_REF] Boukhobza | Flash Memory Integration[END_REF]. This trend will continue as new supercomputers are already reaching the exaflop in AI driven workloads [START_REF] Hpc Wire | Fujitsu and RIKEN Take First Place Worldwide in TOP500, HPCG, and HPL-AI with Supercomputer Fugaku[END_REF]. Storage has always been a performance bottleneck in High Performance Computing (HPC) [START_REF] John | Why Aren't Operating Systems Getting Faster As Fast as Hardware[END_REF] [START_REF] Wang | Storage Management for Large Scale Systems[END_REF] [START_REF] Klasky | Exascale Storage Systems the SIRIUS Way[END_REF]. In order to cope with the amount of data that Exascale machines will produce, storage systems need to improve both in terms of capacity and speed (bandwidth and latency) [START_REF] Klasky | Exascale Storage Systems the SIRIUS Way[END_REF]. Since no single storage technology is capable of fulfilling both those roles at a reasonable cost [START_REF] Coughlin | New storage hierarchy for consumer computers[END_REF], we need to use a hierarchy of different storage technologies. The combined use of Flash-based drives, magnetic drives (HDD) and tapes is standard [START_REF] Lüttgau | Survey of Storage Systems for High-Performance Computing[END_REF] in HPC systems. Memory class storage such as 3dX-point are expected to join the aforementioned hierarchy in production to partially fill the gap between DRAM and Flash [START_REF] Hirofuchi | A Prompt Report on the Performance of Intel Optane DC Persistent Memory Module[END_REF] [START_REF] Boukhobza | Emerging NVM: A Survey on Architectural Integration and Research Challenges[END_REF].

The management of this hierarchy is a complex endeavour. Parallel distributed file systems such as Lustre [START_REF] Cochrane | Solving the HPC I/O bottleneck: Sun™ Lustre™ storage system[END_REF] are used to manage the vast amount of disks and data across those disks. The standard architecture used in HPC is a three tier hierarchy [START_REF] Kincade | UniviStor: Next-Generation Data Storage for Heterogeneous HPC[END_REF] composed of clusters of Flash-based drives, magnetic drives and tapes each grouped together in storage nodes and managed by a parallel distributed file system or an object store such as DAOS [START_REF] Liang | DAOS: A Scale-Out High Performance Storage Stack for Storage Class Memory[END_REF]. Because the storage capacity available on the high performance tier is often an order of magnitude lower than that of the other tiers [START_REF] Lüttgau | Survey of Storage Systems for High-Performance Computing[END_REF], the fastest tier of this hierarchy should only contain a subset of files for the time period during which they require such a performance.

In our work, we used a hierarchy of two tiers, a high performance tier and a capacity tier used for archival purpose. The aforementioned issue of data placement over the storage tiers can be translated in two main research questions: 1) when to store files in the performance tier and 2) when to move them to the capacity tier. Questioning about how data should be moved/scheduled from a tier to another is out of the scope of this paper, so is the prefetching issue.

Several state-of-the-art work solutions investigated the data placement of objects or files in high performance tiers [START_REF] Shin | Data Jockey: Automatic Data Management for HPC Multi-tiered Storage Systems[END_REF] [START_REF] Wan | SSD-optimized workload placement with adaptive learning and classification in HPC environments[END_REF] [START_REF] Wadhwa | Toward Transparent Data Management in Multi-Layer Storage Hierarchy of HPC Systems[END_REF]. They were mainly performed for hybrid storage systems composed of flash-based disks and magnetic drives. A large proportion of those studies such as [START_REF] Lockwood | UMAMI: A recipe for generating meaningful metrics through holistic I/O performance analysis[END_REF] [3] relied on continuous system monitoring of I/O patterns [START_REF] Ouarnoughi | A multi-level I/O tracer for timing and performance storage systems in IaaS cloud[END_REF] to infer the moment at which data should be placed in such tier and when they should be evicted. While those strategies performed well in terms of I/O performance, the exhaustive monitoring used makes them hardly usable in large production systems [START_REF] Evans | Democratizing Parallel Filesystem Monitoring[END_REF] [START_REF] Agelastos | The Lightweight Distributed Metric Service: A Scalable Infrastructure for Continuous Monitoring of Large Scale Computing Systems and Applications[END_REF] In [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF], the authors solely relied on file names to infer the time duration where files are accessed, thus reducing drastically the monitoring cost. In fact, they observed that in some CEA ( French Atomic Energy Commission) [START_REF]English Portal -The CEA: a key player in technological research[END_REF][6] supercomputers [START_REF]CEA -HPC -TERA[END_REF] [8], 45.80% of the files were never accessed 10 seconds after their creation [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF]. They defined the duration between the last access to a file and its creation time as the file lifetime. They used machine learning approaches to predict file lifetimes based only on their paths. Paths were chosen as input for two reasons: (1) the path of the file is known at creation time and (2) it often contains metadata about the user and/or the application that created it. With this prediction in hand, they placed each file in the high performance tier once created and moved it to the capacity tier when the file lifetime expires.

The performance of previous solution was measured according to two metrics: (1) the accuracy, it is defined as the percentage of lifetime predictions that are within an order of magnitude from the real value; (2) the under-estimation, defined as the percentage of predictions that are below the real lifetime value. This is particularly important as underestimated file lifetime would result in a premature file eviction leading to a performance degradation. In this previous work, the authors used two Convolutional Neural Networks (CNN):

(1) a CNN trained for accuracy [START_REF] Agelastos | The Lightweight Distributed Metric Service: A Scalable Infrastructure for Continuous Monitoring of Large Scale Computing Systems and Applications[END_REF] and another trained to produce the least amount of under-estimations, for that they used different cost functions. Then trade-offs were found.

In this paper, like previous work [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF], we used the access path of a file to accurately predict when a file will last be accessed. While previous work used two Convolutional Neural Network using two different loss functions, we propose to use a single Convolutional Neural Network using a custom loss function in order to reduce the computing power necessary for a prediction. To achieve this, we designed the custom loss function to optimize the ratio between accuracy and under-estimations. The intuition behind the design of the custom loss function stems from multi task learning [START_REF] Gong | A Comparison of Loss Weighting Strategies for Multi task Learning in Deep Neural Networks[END_REF], we used the weighted average of the two loss functions used in previous work [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF]. Our objective is to increase the accuracy of our predictions while maintaining a low level of under-estimations. We also used early-stopping to prevent overfitting.

Using a dataset of 5 millions entries from a production system at CEA and through several experiments we empirically found that the best weights/ratios between the two loss functions was around 0.2 for the loss function yielding high accuracy and 0.8 for the loss function yielding low under-estimations. With this setting we were able to train our network to reach 98.60% accuracy while keeping under-estimations under 2.21%. In comparison previous work achieved 98.84% accuracy and 21.86% under-estimations using their highly accurate loss function while the other loss function yielded 90.91% accuracy and 0.88% under-estimations. Our solution is also more flexible since we can tune the weights of the loss function to either favor high accuracy or low under-estimations.

We first go over the background of this study, by describing the storage system used at CEA along with the software used to manage data life cycle. Then we describe the solution we designed. We evaluate and analyze our results. We then go over the related work and finally we conclude this paper with our final analysis and future work.

Background

This section introduces the overall system architecture considered and sketched in Fig. 1. The first section describes the used HPC multi tiered storage system architecture represented by the two storage servers in the top left corner of Fig. 1 (high performance and high capacity tiers). The second section introduces the Robinhood policy engine which is represented by the right side of Fig. 1, Robinhood is a software that provides fast access to file metadata in HPC storage systems.

The Storage Hierarchy in HPC

Scientific applications such as weather simulations, genomic sequencing or geoscience necessitate petabytes of storage for datasets and results. These data are archived and their results keep growing larger. Caching and prefetching strategies were put in place in order to speed up the process of reading and writing to storage memory which is several orders of magnitude slower than main memory (DRAM) which is itself orders of magnitude slower than cache and CPU registers [START_REF] Jacob | Memory Systems: Cache, DRAM, Disk[END_REF]. In order to get the best latency and throughput, a common solution is to use Flash-based drives as an intermediate between traditional magnetic drives and main memory [38] [4]. The use of tape is the final piece of the puzzle, as it is used to archive the data. Tapes have a latency of around 20 seconds or more [START_REF] Lüttgau | Survey of Storage Systems for High-Performance Computing[END_REF]. Data stored on tapes does not consume any power which makes it an ideal solution for long term storage. Finally, tape as a technology has the best $/GB ratio and is a necessary technology to reach the exabyte at a feasible economic cost. As an example, 60% of the storage capacity of the TGCC [START_REF]CEA -HPC -TGCC Storage system[END_REF], a CEA supercomputer, relies on tapes.

Robinhood Policy Engine

Robinhood Policy Engine [START_REF] Leibovici | Taking back control of HPC file systems with Robinhood Policy Engine[END_REF] is a versatile tool to manage contents of large file systems, it is developed by the CEA [START_REF]CEA -HPC -Computing centers[END_REF]. It maintains a replicate of file system metadata in a database that can be queried at will. It makes it possible to schedule mass action on file system entries by defining attribute-based policies. Robinhood is linked to the file system through the changelog as shown on the right side of Fig. 1. It stores all metadata information about the file system in a SQL database which makes it possible to retrieve the state of the file system at any time. In a production system, this translates to millions of file entries, with their associated creation time, last access and last modification time. We used the data extracted from Robinhood in the proposed contribution.

Predicting file lifetime for data placement

This section aims to describe the full scope of our contribution, beginning with an overview of our solution inside the existing storage system. We explain how our training and validation data is processed and describe how our solution works. 3.1 Overall predicting system architecture Our contribution consists in a file lifetime predicting system that takes as input file paths. Fig. 1 shows a simplified view of the existing data management system where our solution would be integrated. In the top right corner are Lustre [START_REF] Cochrane | Solving the HPC I/O bottleneck: Sun™ Lustre™ storage system[END_REF] instances with 2 storage servers, those servers contain different media types. The one on the right is a metadata server, it contains metadata about the other Lustre file systems and is connected to them with a secondary network called "management network" with lower latency and bandwidth than the High Performance Data Network. The applications are running on compute nodes which are not represented in this figure; applications are connected to the Lustre Storage Server through the High Performance Data Network.

On the right side of the figure, the block labeled "Robinhood Policy Engine" [START_REF] Leibovici | Taking back control of HPC file systems with Robinhood Policy Engine[END_REF] represents the software solution used to create migration policies between the different tiers. Robinhood is connected to the management network and reads metadata changes from the metadata server. This is represented by the "changelog reader" in the figure. These metadata changes are processed and stored in a database. The database then receives SQL queries to check the state of the file systems without having to contact the metadata server directly. An administrator can then create a policy by periodically checking the state of the file system through the Robinhood database; such policies include data migrations or purges.

Our solution would stand inside Robinhood and filters only the "File creation" events. The path of the file would be processed to generate a prediction of its lifetime. The prediction would then update the database entry related to the file. These predictions are to be used to create a data migration policy, the files with expired lifetimes would be moved from high performance tier to capacity tier. In Fig. 1, this would translate in a migration from the SSD storage server (high performance tier) to the HDD storage server (capacity or archival storage), thus granting us more space for newly created files on the performance tier.

File lifetime training framework

In order to work, our machine learning solution has to be trained on real examples. Training is an iterative process, we refer to each training pass as an epoch. An epoch is defined as the number of times the neural network has processed the entire dataset.

Fig. 2 shows the overall CNN training process. In our case, we used data from a production Robinhood database which had to be processed in order to remove fields with missing information. Those data are then transformed into a form that can be understood by a machine learning model. Then we design a model using Tensorflow and Keras to describe the layers of our Convolutional Neural Network and its hyper parameters such as the learning rate or the number of epochs. The model then goes through training and its performance is evaluated by a loss function (also referred to as cost function). The loss function is fundamental to the learning process as it will define how the neural network will change its parameters. Previous work [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF] used two different loss function to achieve either high accuracy or low under-estimations, we proposed a custom loss function using both of them. The three main components are described in the next sections.

Dataset processing

Data processing is a necessary part of our training system, its role is to transform the data from its source into a form that a machine learning solution can use. In our case we need fixed size inputs and file paths have variable sizes. We need also in this phase to define and normalize the metric of lifetime of files.

Our solution uses data from a production system at CEA [START_REF]English Portal -The CEA: a key player in technological research[END_REF]. They were extracted from a Robinhood Database used to monitor a production file system. Raw data extracted in this manner were the result of an SQL query, a Comma Separated Value (CSV) file that can be viewed as a table. This table contains fields with information on each file in the file system. We had access to the path, time of last access (or read), time of last modification (write), creation time and other associated metadata for each file.

The first step of data processing consists in processing each field of the CSV file in order to remove incoherent data such as a creation time being later than the last access time. The path column of each field was then converted from a character string of variable length (ex: /foo/bar/user/project/...) to a fixed size array of 256 integers. This size was chosen arbitrarily based on the commonly observed size of the paths. When the path was longer than 256 characters it was truncated from the start because we observed that the right part of the path contains more relevant information such as the username, the file extension, etc. The transformed paths were considered as inputs for our CNN. The second step of data processing is to define the lifetime metric. There are three fields containing time information available in Robinhood: the creation time, the time of last access and the time of last modification. We came up with two possible definitions for the lifetime: 𝐷𝑒 𝑓 .1 = 𝑙𝑜𝑔10(𝑙𝑎𝑠𝑡 𝑚𝑜𝑑𝑖 𝑓 𝑖𝑐𝑎𝑡𝑖𝑜𝑛 𝑡𝑖𝑚𝑒 -𝑐𝑟𝑒𝑎𝑡𝑖𝑜𝑛 𝑡𝑖𝑚𝑒) and 𝐷𝑒 𝑓 .2 = 𝑙𝑜𝑔10(𝑙𝑎𝑠𝑡 𝑎𝑐𝑐𝑒𝑠𝑠 𝑡𝑖𝑚𝑒 -𝑐𝑟𝑒𝑎𝑡𝑖𝑜𝑛 𝑡𝑖𝑚𝑒). The decimal logarithm is used to discretize lifetime values. Fig. 3 shows the distribution of lifetimes for each definition. The x-axis represents the decimal logarithm (log10) of the lifetime in seconds and on the y-axis is the percentage of files close to that lifetime. The bars represent the amount of files belonging to a certain lifetime slice in our dataset. It shows from left to right the lifetime distribution according to 𝐷𝑒 𝑓 .1 and 𝐷𝑒 𝑓 .2. We decided to use 𝐷𝑒 𝑓 .2, i.e. the time of last access minus the creation time because it contains more relevant information since the time of the last access can either be a write or a read while the time of last modification is always a write operation. This means that a prediction based on 𝐷𝑒 𝑓 .1 might evict some files before a read and thus would result in a performance penalty. So we defined the lifetime as the decimal logarithm of the difference between the time of last access and the creation time.

Model Architecture

The CNN model architecture used in this paper was inspired from a previous work [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF] which itself relied on [START_REF] Saxe | eXpose: A Character-Level Convolutional Neural Network with Embeddings For Detecting Malicious URLs, File Paths and Registry Keys[END_REF]. A simplified representation of the model is shown on Fig. 4. The architecture of the model is made of 12 layers: 1 input layer, 10 hidden layers and 1 output layer; Given the current trends in computer vision, this is a small CNN by its number of layers, but rather large in terms of parameters. For example, Inception v4 [START_REF] Szegedy | Inception-v4, inception-ResNet and the impact of residual connections on learning[END_REF] contains 70 layers for 36.5 millions parameters while our model contains around 100 millions parameters (also referred as "weights"). We kept the same network layout as it performed adequately on this task in previous work [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF] despite its number of parameters.

Embedding

Layer. The embedding layer transforms the 256 bytes long input into a matrix of 256 by 32 floating numbers, we kept this size from previous work [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF] and through multiple tries with different embedding values [START_REF] Gong | A Comparison of Loss Weighting Strategies for Multi task Learning in Deep Neural Networks[END_REF][START_REF] Shin | Data Jockey: Automatic Data Management for HPC Multi-tiered Storage Systems[END_REF]48,64). Fig. 5 shows an example with an 8 byte long input and an embedding size of 4. Each character is mapped to an array of floating numbers, these numbers change during training because they are learning parameters. We use embedding for two reasons: first, in order to leverage CNN, we need to transform the file paths into matrices of fixed size. Second because the alternative method to embedding, which is one hot encoding, takes too much space [START_REF] Pau Rodríguez | Beyond One-hot Encoding: lower dimensional target embedding[END_REF]. In our case one hot encoding would have multiplied the size of the input matrix by 3.

Convolutional

Layers. The next layers are the convolutional layers, they extract spatial data from the embedding layer that makes sense to the neural network. Theoretically a convolutional layer produces a set of matrices containing features about the data it gets fed. Convolutional layers are defined by two parameters 1) the number of output matrices and 2) the size of the kernel used (128 and 5 for example). Pooling layers are used to reduce the dimension of the input matrices of the next convolutional layer. Our model contains two convolutional layers and two pooling layers as shown in Fig. 4. The process of finding the right amount of layers is empirical and again was the result of experiments in previous work [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF]. The output of a convolutional layer can be represented as a series of matrices containing features.

The layer that sits between the convolutional layers and the dense layers in Fig. 4 is the flatten layer, its role is to serialize the output of the last convolutional layer into a 1 dimensional array. Dense layers are defined by the number of neurons they contain. Each value in the output of the flatten layer is connected to each neuron in the dense layer. The dense layers are fully connected to each others. Almost all of the learning parameters are located in the dense layers, the weights in the previous layers (convolution, embedding) are negligible.

The output of the network takes the output of a dense layer made out of a single node and returns the lifetime of the file as previously defined. This model solves a regression problem since it returns a discrete value instead of probabilities to belong to a certain class.

Loss function

The goal of training a CNN like any other networks is to minimize a loss function. The loss function is used during training to compare the changes needed to be applied to the CNN in order to increase accuracy in the next iteration. It takes as inputs the predicted lifetime value and the real one.

We present 4 loss function in this subsection, the first is one of the most commonly used in regression tasks, the following two were used by previous work [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF] to train their CNNs. Finally we present our custom loss function which makes use of the two from previous work, thus the need to explain how they work.

One of the most commonly used loss function in regression tasks is Mean Squared Error or L2 [START_REF] Nie | An investigation for loss functions widely used in machine learning[END_REF]. MSE is the sum of squared distances between the real value and predicted values, it is defined as:

𝑀𝑆𝐸 = 1 𝑛 𝑛 𝑖=1 (𝑦 𝑖 -ỹ𝑖 ) 2
where 𝑦 represents the real value and ỹ the predicted value. MSE should be used when the target values follow a normal distribution as this loss function would significantly penalize large errors. We observed that our data do not follow a normal distribution which explains why previous work [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF] chose another loss function that is less affected by outliers in the data.

Previous work [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF] used logcosh, which is another regression loss function, in order to achieve high accuracy. It is defined as:

𝐿 = 1 𝑛 𝑛 𝑖=1 log(cos(𝑦 𝑖 -ỹ𝑖 ))
where 𝑦 represents the real value and ỹ the predicted value. It works like MSE except that it is less affected by outliers in the dataset. Previous work [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF] also used quantile99 to achieve a low-level of under-estimations. quantile99 is the name given by [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF] for the quantile loss function when the quantile is 0.99. Quantile loss function is defined as:

𝐿 𝑞 = 1 𝑛 𝑛 𝑖=1 max(𝑞 • (𝑦 𝑖 -ỹ𝑖 ), (𝑞 -1) • (𝑦 𝑖 -ỹ𝑖 ))
where 𝑞 represents the quantile value, 𝑦 the real value and ỹ the predicted value. This loss function gives different values to over-estimations and under-estimations based on the quantile value. The closer the quantile value is to 1 the more it will penalize the under-estimations. The same is true for over-estimation, the closer the quantile is to 0 the more it will penalize over-estimations. A quantile value of 0.5 shows the same behavior as MSE.

The loss function used to train our model is a custom one. We realized through [START_REF] Gong | A Comparison of Loss Weighting Strategies for Multi task Learning in Deep Neural Networks[END_REF] that using the weighted average of quantile99 and logcosh allowed us to combine their properties while alowing for a higher flexibility thanks to the used weights. The custom loss function can be represented as:

𝑐𝑢𝑠𝑡𝑜𝑚𝑙𝑜𝑠𝑠 () = 𝑤 𝑎 • 𝑙𝑜𝑔𝑐𝑜𝑠ℎ() + 𝑤 𝑢 • 𝑞𝑢𝑎𝑛𝑡𝑖𝑙𝑒99()
where 𝑤 𝑎 + 𝑤 𝑢 = 1. By modifying the value of the wieghts 𝑤 𝑎 and 𝑤 𝑢 we can either favor high accuracy or low underestimations.

The goal of this approach is to allow our solution to be adapted according to the system state, for instance, disk usage, I/O bandwidth, performance delta between tiers, the QoS required by the application, etc.

We evaluated different weight configurations in our experimentation, that is :

(𝑤 𝑎 , 𝑤 𝑢 ) ∈ {(0.5, 0.5), (0.4, 0.6), (0.3, 0.7), (0.2, 0.8), (0.1, 0.9)}, the results we obtained are discussed in Section 4.

Experimental Evaluation

This section covers the methodology used to evaluate our solution and the results we obtained against previous work [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF].

We also discuss the flexibility of our solution by tuning the weights of our custom loss function.

Methodology

We trained the convolutional neural network in a docker container which had access to 4 Tesla V100 GPU. We used an optimization called mixed-precision in order to reduce the training time on GPU. We used Tensorflow 2 [START_REF] Abadi | TensorFlow: A system for large-scale machine learning[END_REF] The dataset we used contains 5 millions entries of real data from a production system in HPC. We pre-processed this dataset in order to keep only the path and the lifetime of each file using the method discussed in section 3. We used 70% of data for training and 30% for validation. The validation data were chosen randomly.

The metrics used to evaluate the performance of the network are the accuracy and the under-estimations.

Results

Table 1 shows the performance of logcosh and quantile99 against our solution, best values are emphasized. In this table, the weights of the loss function used for our solution were 0.2 for logcosh and 0.8 for quantile99. While not reaching the accuracy of logcosh our solution manages to be 7.5% more precise than quantile99. On the other hand the number of under-estimations is almost divided by ten compared to logcosh.

By tuning the weights of our loss function we can further approach either the accuracy of logcosh or the underestimations of quantile99. Table 2 shows the influence of the weights of our loss functions on the metrics we observed, best performances are emphasized. A (0.5, 0.5) split between logcosh and quantile99 yields an accuracy of only 0.1% lower than logcosh alone while dividing underestimations by more than 3. In term of under-estimations, our solution is still outperformed by previous work using quantile99 by 0.46% in the (0.1, 0.9) experiment. Overall we can observe that logcosh seems to have a bigger influence on the evaluation metrics than quantile99. Accuracy declines slowly despite the proportion of quantile99 getting larger. Since we defined an accurate prediction as a value an order of magnitude away from the real value then it is possible that the predicted values are getting closer to leaving that interval as the proportion of quantile99 increases. This would explain the steep decline in precision between the (0.2, 0.8) and the (0.1, 0.9) experiments.

The conclusion we have drawn is that minimizing underestimation is costly in terms of accuracy; Through multiple experiments, we were able to quantify the cost of reducing under-estimations in term of accuracy.

Related work

Predicting file lifetimes with Machine Learning was investigated in [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF]. It was the main inspiration of this work. The authors used two machine learning algorithms, random forest and a convolutional neural network (CNN). It showed that, on a dataset of 5 million entries, random forest was outperformed by the CNN both in terms of accuracy using logcosh and in terms of under-estimations using quantile99 as loss functions. Another observation they made from the data they recovered was that 45.80% of the files had a lifetime under 10 seconds.

eXpose [START_REF] Saxe | eXpose: A Character-Level Convolutional Neural Network with Embeddings For Detecting Malicious URLs, File Paths and Registry Keys[END_REF] applies character embedding to URLs in a cybersecurity context. The embedding was used to train a Convolutional Neural Network to recognize malicious URLs. It is a highly influential work to the previously cited paper [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF].

Learning I/O Access Patterns to improve prefetching in SSDs [START_REF] Chakraborttii | Learning I/O Access Patterns to Improve Prefetching in SSDs[END_REF] leverages the use of Long Short-Term Memory (LSTM) which are an extension of Recurent Neural Networks to predict at firmware level (inside a SSD) which Logical Block Address will be used. In [START_REF] Emile Dartois | Investigating Machine Learning Algorithms for Modeling SSD I/O Performance for Container-based Virtualization[END_REF], the authors have evaluated different learning algorithms, this time to model the overall performance of SSDs for Container-based Virtualization to avoid interference that would cause Service Level Objectives violations in a cloud environment Data-Jockey [START_REF] Shin | Data Jockey: Automatic Data Management for HPC Multi-tiered Storage Systems[END_REF] is a data movement scheduling solution that aims to reduce the complexity of moving data across a hierarchy of storage. It uses user-made policies to balance the load across all storage nodes and jobs. It has a view of the entire supercomputer and the end goal is to create a scheduler analog to SLURM for data migration jobs.

Archivist [START_REF] Ren | Archivist: A Machine Learning Assisted Data Placement Mechanism for Hybrid Storage Systems[END_REF] is a data placement solution for hybrid embedded storage, it uses a neural network to classify files and outperforms baseline in latency access given certain conditions.

UMAMI [START_REF] Lockwood | UMAMI: A recipe for generating meaningful metrics through holistic I/O performance analysis[END_REF] uses a range of different monitoring tools to capture a holistic view of the system. They show that their holistic approach allows them to analyse performance problems more efficiently.

The work presented in this paper follows and increments the approach in [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF]. It upgrades the previous solution by 1) enhancing its performance in terms of accuracy and under estimations and 2) providing the administrator with a higher degree of flexibility by supplying a set of solutions allowing a trade-off between accuracy and under estimations.

Conclusions and Future Work

In this paper we propose a method to predict the lifetime of a file based on its path using a Convolutional Neural Network. We used data from a CEA production storage system to train our solution. We designed a custom loss function to get our Convolutional Neural Network to achieve a trade-off between high accuracy and low under-estimations. We then evaluated our solution against previous work [START_REF] Monjalet | Predicting File Lifetimes with Machine Learning[END_REF], which used two loss functions: logcosh and quantile99. The results we obtained show that when using weights of 0.8 for quan-tile99 and 0.2 for logcosh our solution was able to reach an accuracy close to previous work using only logcosh (98.60% compared to 98.84%) while reducing the underestimations by almost 10 times to reach 2.21% (compared to 21.86%). Furthermore our solution is more flexible compared to previous work since it allows system administrators to tune the weights of the loss function during incremental training to either favor high precision or low underestimations.

In future work we would like to investigate the use of our solution on a 3-tiered storage system (we used 2 tiers in this work). In such a context, we need to investigate new parameters to learn when to move data from one tier to another while still keeping the burden of monitoring low. Finally we would like to explore the use of a deeper CNN architecture in order to reduce the number of parameters, much like what is done in computer vision.

Figure 1 .

 1 Figure 1. Simplified view of the system.

Figure 2 .

 2 Figure 2. View of the training process

Figure 3 .

 3 Figure 3. Lifetime distribution.

Figure 4 .

 4 Figure 4. Simplified view of the model.

Figure 5 .

 5 Figure 5. Example of character embedding.

Table 1 .

 1 to conduct all our experiments. With this optimization enabled, it took 2 hours to train our model (while the training lasted 4 hours Comparison of previous work against our solution

	evaluation metric logcosh quantile99 our solution
	accuracy	98.84%	90.91%	98.60%
	under-estimations 21.86%	0.88%	2.21%

Table 2 .

 2 Comparison of different weighted loss function for each (𝑤 𝑎 , 𝑤 𝑢 ) value

	eval. metric (0.5,0.5) (0.4,0.6) (0.3,0.7) (0.2,0.8) (0.1,0.9)
	accuracy	98.83% 98.75% 98.74% 98.60% 97.95%
	under-est.	6.22%	2.53%	2.48%	2.21%	1.34%
	without mixed precision). In order to reduce training time
	we used early-stopping which monitors if the network is
	over-trained and if so stops the training.


Alexandre Sarazin
email: alexandre.sarazin@apsys-airbus.com

Jérémy Bascans
email: jeremy.bascans@apsys-airbus.com

Jean-Baptiste Sciau
email: jeanbaptiste.sciau@activus-group.fr

Jiefu Song
email: jiefu.song@activus-group.fr

Bruno Supiot
email: bruno.supiot@activus-group.fr

Aurélie Montarnal
email: aurelie.montarnal@mines-albi.fr

Xavier Lorca
email: xavier.lorca@mines-albi.fr

Sébastien Truptil
email: sebastien.truptil@cea.fr

Expert system dedicated to condition-based maintenance based on a knowledge graph approach: Application to an aeronautic system

Keywords:

Condition Based Maintenance (CBM) has become the focus of many research topics over the past decades. This is mostly related to the development of new machine learning algorithms and the ever increasing capacity to collect data allowing failures to be detected and the system's remaining lifetime to be estimated while requiring few or no expert knowledge. However, current machine learning based CBM solutions have limitations. They require an extensive and relevant data set to train on and are performed at the component level, not systemwide. Conversely, Expert Systems (ES) do not have these restrictions but should be used on systems with available expert knowledge and are currently suffering from efficiency, scalability and applicability limits. In this paper, an ES solution for CBM based on an heterogeneous information network will be presented to address the efficiency, scalability and applicability issues of modern ES. An application to an aircraft system will be used as case study to illustrate the process and performance of this solution for anomaly detection and diagnostics.

Motivation

The increasing complexity of modern manufacturing systems emphasizes the need for preventive maintenance. At the same time, reducing maintenance costs has become a critical challenge in many industries like transportation [START_REF] Numanoğlu | Analysis of the periodic maintenance costs of aircraft fleet[END_REF] or energy [START_REF] Salameh | Gearbox condition monitoring in wind turbines: A review[END_REF]. Considering this policy, traditional timebased maintenance can be lacking, creating a need for more cost effective condition-based maintenance (CBM) solutions [START_REF] Bayoumi | Conditioned-based maintenance at USc-part IV: Examination and cost-benefit analysis of the CBM process[END_REF][START_REF] Gündüz | Machine learning in the air[END_REF][START_REF] Huynh | Modeling past-dependent partial repairs for condition-based maintenance of continuously deteriorating systems[END_REF].

CBM is based on sensor data analysis in order to detect symptoms and failures, sometimes estimating the systems remaining useful life (RUL). Two main approaches are being used to process sensor data. A first approach is to feed learning algorithms with labeled historical data to solve classification or regression problems from past experience. The main advantage of this solution is its high adaptability as no need for system knowledge is required. Even though a lot of works and applications have been made on supervised machine learning algorithms, the availability and high quality requirements on the training dataset are inherent major issues [START_REF] Sheng | Machine learning with crowdsourcing: A brief summary of the past research and future directions[END_REF]. The solution proposed in this paper focuses on CBM for systems with few available training sets and lots of human expertise or available documentation. Therefore, the machine learning approach has been discarded here.

A second approach to diagnose failures is to capitalize on existing system knowledge to artificially re-create an expert reasoning to reach a conclusion by applying predefined rules related to monitored facts. These systems are being referred to as Expert Systems (ES).

The purpose of this paper is to propose an architecture for CBM addressing current ES limitations. After presenting the related state of the art and its current limitations, a solution will be detailed, experimented and finally discussed.

Literature review

As defined by ISO (AFNOR, 2018), maintenance is a ''set of activities or tasks used to restore an item to a state in which it can perform its designated functions''. It can be divided into two main strategies: corrective and preventive. While corrective maintenance consists in restoring (repairing or replacing) some equipment to its required function after it has failed, preventive maintenance evaluates and/or slows the equipment's degradation, reducing its probability of failure. During the last ten years, due to the increase of sensor data collection, lots of Research focused on a specific type of preventive maintenance named CBM, which evaluates and analyzes the equipment's physical conditions while considering the potential maintenance actions to perform.

In particular, Prognostics and Health Management (PHM) is a kind of CBM introduced as a ''discipline consisting of technologies and methods to assess the reliability of a product in its actual life cycle conditions to determine the advent of failure and mitigate equipment/system risk'' [START_REF] Cheng | Sensor systems for prognostics and health management[END_REF]. This approach consists of three main steps: the monitoring of the system, usually using sensors, the failure identification, consisting in a diagnostics step, and the prognostics step which evaluates the system's remaining useful life (RUL) [START_REF] Jouin | Prognostics and health management of PEMFC -state of the art and remaining challenges[END_REF].

Several PHM-like solutions have been designed for aircrafts and gas turbine engines in particular. [START_REF] Roemer | Advanced diagnostics and prognostics for gas turbine engine risk assessment[END_REF] proposes a review of diagnostics and prognostics solutions with an emphasis on data processing techniques ensuring the input records reliability. [START_REF] Hanachi | Performancebased gas turbine health monitoring, diagnostics, and prognostics: A survey[END_REF] presents another example of health monitoring, diagnostics and prognostics approach based on performance data. However, while these works detail numerous relevant techniques for data collection, failure diagnostics and prognostics, none of them propose an architecture integrating these algorithms. In particular, expert knowledge management still needs to be addressed.

The failure identification is a critical step to select the corresponding degradation model and provide accurate information on the root cause to the user. As a matter of fact, the process of relating sensor data to failures is already performed in diagnostic systems based on the technical documentation and human expertise. The difference between diagnostics and prognostics is that diagnostics is performed after the advent of failure while prognostics estimates the RUL of the system from signs detected before the failure [START_REF] Lee | Prognostics and health management design for rotary machinery systems-Reviews, methodology and applications[END_REF].

According to [START_REF] Zaidan | BayesIan hierarchical models for aerospace gas turbine engine prognostics[END_REF] statistically robust methodologies are more appropriate to deal with large amounts of data in real time for complex systems due to the difficulty in designing physical degradation models. Consequently a Bayesian approach is proposed for prognostics and improved in [START_REF] Zaidan | Gas turbine engine prognostics using Bayesian hierarchical models: A variational approach[END_REF]. The Monte-Carlo approach can also be considered as a probabilistic and stochastic solution [START_REF] Puggina | Development of a statistical methodology for gas turbine prognostics[END_REF].

Jackson (1998) introduces an expert system as a software integrating expert knowledge on a specific domain in order to solve problems and provide advice by reproducing an expert reasoning based on facts and data. According to this definition, the solution proposed in this paper belongs to the expert system's field. As such, it should be composed of three elements: a base of facts, a base of rules and a control structure [START_REF] Levine | Systèmes interactifs d'aide à la décision et systèmes experts[END_REF]. The base of facts is a set of atomic elements of knowledge available before the reasoning. The base of rules regroups all the rules to apply to the base of facts in order to reach a conclusion. These rules can be provided by a human expert or a technical documentation and performed if the status of the base of facts satisfies its activation conditions. The control structure is designed to choose which rule should be activated should a conflict arise due to several rules activation conditions being fulfilled.

As expert systems have been defined several decades ago, many applications have been designed especially in the medical field. Indeed, the process of a physician identifying a disease from symptoms on a patient is similar to the process of identifying faults from anomalies in a system. Consequently the maintenance and medicine fields contributed greatly to ES development. [START_REF] Yanase | A systematic survey of computer-aided diagnosis in medicine: Past and present developments[END_REF] proposes a survey on computer-aided diagnosis in medicine with an entire section describing ES structure and algorithms with related works. Abu-Nasser (2017) details a different description of ES components and lists 33 medical works based on ES. [START_REF] Rajabi | A literature review on current approaches and applications of fuzzy expert systems[END_REF] presents a statistical study of ES works in the medical field over 30 years. It concludes that ''AI and expert systems have a high potential to be employed in almost all fields of medicine''.

The critical criteria to evaluate an ES performance is knowledge management. However, according to [START_REF] Xiaoxue | Review and trend analysis of knowledge graphs for crop pest and diseases[END_REF], current knowledge management techniques have some ''common defects in efficiency, scalability and applicability''. For instance, modern conditionbased systems are supported by technical data increasingly complex, dynamic, semantic and often updated. Knowledge graphs can address these limitations. A knowledge graph can be defined as a ''structured semantic knowledge base that describes concepts and their relationships in the physical world in the form of symbols. It allows knowledge representation and management to solve knowledge association problems, such as knowledge retrieval and semantic question answering. It is the basis and bridge to realize intelligent semantic retrieval'' [START_REF] Xiaoxue | Review and trend analysis of knowledge graphs for crop pest and diseases[END_REF]. Knowledge graphs can be implemented using different solutions like Bayesian networks, conceptual graphs or heterogeneous information networks (HIN).

According to [START_REF] Agrawal | Athena: Mining-based interactive management of text databases[END_REF], Naive Bayes classifiers are recognized to be among the best for classifying text. As such it can be used to create, process, and maintain a hierarchical arrangement of textual documents through interactive mining-based operations. Bayesian networks can also be used in maintenance diagnostic and decisionmaking systems although models should be implemented to grant an improved performance over time [START_REF] Corset | Introduction du retour d'expérience dans les réseaux bayésiens[END_REF].

Conceptual graph are knowledge notations processed by reasoning operators defined by [START_REF] Sowa | Conceptual structures: information processing in mind and machine[END_REF]. It was designed to address problems related to natural language processing, database inference, and knowledge engineering. This work was further improved by numerous researches. [START_REF] Roussey | Un modèle de graphe pour la recherche d'information multilingue[END_REF] implemented the notions of vocabulary and label while [START_REF] Chein | Nested graphs: A graph-based knowledge representation model with FOL semantics[END_REF] introduced the concept of nested graphs.

HIN are defined by [START_REF] Sun | Mining heterogeneous information networks: principles and methodologies[END_REF] as an abstraction of the real world, focusing on the objects and the interactions between the objects. The network structure of HIN provides an increased scalability when increasing the system's complexity as the knowledge processing and intelligibility is improved. [START_REF] Davis | Multi-relational link prediction in heterogeneous information networks[END_REF] presents three different implementations of HIN with a focus on supervised and unsupervised link prediction in a multi-relational setting. Other examples can be found in [START_REF] Angelova | Graffiti: graph-based classification in heterogeneous networks[END_REF] to address the problem of multi-label classification in heterogeneous graphs, where nodes belong to different types and different types have different sets of classification labels.

In order to structure maintenance data in a CBM information network, a metamodel is required. This metamodel should define the functional nature of the different kinds of nodes and edges. In this paper, the work of [START_REF] Guillén | A framework for effective management of condition based maintenance programs in the context of industrial development of E-maintenance strategies[END_REF] has been used as a basis. In this metamodel, the maintenance data is structured in 5 blocks:

• A physical description block describes the systems components from a perspective similar to a bill of materials. The smallest components maintained are called Maintainable Items (MIs). • A functional description block defines the functions performed by a component or subsystem and the corresponding failures they are subjected to. • An information source block gathers information on the system's monitoring from heterogeneous sources like sensors or a maintenance information system. These data are then being transformed into monitoring variables using measurement techniques. • A symptom analysis block designed to detect anomalies in the monitoring variables and relate it to a symptom through descriptors. Depending on the descriptors output, interpretation rules can trigger 3 different kinds of actions: detection, diagnosis or prognosis. • A maintenance decision-making block composed of a set of detection, diagnosis and prognostics processes applied based on the other four blocks. These processes outputs can be aggregated and sent to a maintenance decision process to provide valuable information to the end user.

As a conclusion, this literature review defined the CBM and PHM concepts and detailed the components of most ES. From the metamodel presented, a CBM-oriented ES can be designed. However as most modern ES have limitations in efficiency, scalability and applicability, a solution should be proposed to address these deficiencies. In this perspective, a framework integrating a knowledge graph to support the ES base of facts is proposed.

Contribution

As previously mentioned, most of recent works on CBM focus on data collection, failure diagnostics and prognostics techniques but research on architectures able to integrate these algorithms is lacking. Expert knowledge management is especially challenging. The main limitations to modern ES is the complexity of managing knowledge which induces efficiency, scalability and applicability problems [START_REF] Xiaoxue | Review and trend analysis of knowledge graphs for crop pest and diseases[END_REF].

In this paper, a solution to implement CBM will be proposed. This solution should be designed to integrate human expertise and technical data to perform diagnostics on complex systems, with few occurrences of each failure. Furthermore, it should integrate heterogeneous data from different sources: technical documentation, monitoring data and historical maintenance records. Consequently, the choice of an ES based solution has been made with the perspective of extending it to a PHM solution. In order to address the efficiency, scalability and applicability issues, this paper proposes an ES solution based on HIN to represent and exploit heterogeneous data (sensor data, maintenance records, technical data) from different sources (sensors, maintenance information system, technical documentation). The choice of HIN has been motivated by the criteria illustrated in Table 1.

In this section, we have argued the selection of a HIN expert system for CBM and structured its knowledge base concepts with a CBM-specific meta-model.

Section 4 will detail the solution used to implement the expert system (ES) base of facts, base of rules and control structure in a HIN. In part 5, Section 5 will introduce a real case study on an aircraft system. For this case study, a focus has been made on diagnostic in order to identify a defective component from a detected failure. Section 6 of this paper will propose to implement a probabilistic model on the network in order to improve the diagnostic performance. Finally, the results will be presented and discussed within Section 7.

Knowledge graph based expert system

In the previous sections, the concepts behind CBM, ES and knowledge graphs have been presented and the motivation to design a HIN based ES has been explicited as a solution to address the efficiency, scalability and applicability limitations of current ES. To describe this solution, the base of facts will first be presented as a HIN. Next, the base of rules implementation and their application process through the control structure will be detailed.

Base of facts designed from HIN

According to [START_REF] Levine | Systèmes interactifs d'aide à la décision et systèmes experts[END_REF], an ES base of facts is a set of elementary chunks of knowledge available before the reasoning. It can also be referred to as the ES knowledge base [START_REF] Liebowitz | Expert systems: A short introduction[END_REF]. In this paper, the structure chosen to implement the base of facts is the HIN. [START_REF] Sun | Mining heterogeneous information networks: principles and methodologies[END_REF] defines a information network as ''a directed graph 𝐺 = (𝑉 , 𝐸) with an object type mapping function 𝜏 ∶ 𝑉 → 𝐴 and a link type mapping function 𝜙 ∶ 𝐸 → 𝑅, where each object 𝑣 ∈ 𝑉 belongs to one particular object type 𝜏(𝑣) ∈ 𝐴, each link 𝑒 ∈ 𝐸 belongs to a particular relation 𝜙(𝑒) ∈ 𝑅, and if two links belong to the same relation type, the two links share the same starting object type as well as the ending object type''. If there is more than a single type of object or relation, the information network is heterogeneous.

The variables involved in the proposed meta-model are as follows:

• Sets are uppercase latin letters.

• Values are lowercase greek symbols.

• Functions are lowercase latin letters.

Finally, G is a graph with: 𝐺 = (𝑉 , 𝐸), where 𝑉 = {𝜐 1 , … , 𝜐 𝑢 } is the set of nodes, and 𝐸 = {𝜖 1 , … , 𝜖 𝑒 } the set of edges with

𝐸 = {𝜖 𝑘 = (𝜐 𝑖 , 𝜐 𝑗 ) ∈ 𝑉 2 , (𝑖, 𝑗) ∈ [1; 𝑢] 2 , 𝑖 ≠ 𝑗} (1)
• Each node has a type 𝜏 which belongs to 𝑇 = {𝜏 1 , … , 𝜏 𝑡 }. The function 𝑓 𝑣 ∶ 𝜐 → 𝜏 is used to return the type 𝜏 of node 𝜐.

• Each edge has a type 𝜇 belonging to the set 𝑀 = {𝜇 1 , … , 𝜇 𝑚 }. The function 𝑓 𝜖 ∶ 𝜖 → 𝜇 returns the type 𝜇 of an edge 𝜖.

This formalization can be used to define the nodes and edges characteristics with their types. These types can indeed be specified using a set of attributes from the whole 𝑋 = {𝜒 1 , … , 𝜒 𝑥 }. These attributes are properties and/or characteristics representing the nodes and edges types. These attributes can be customized for any type of node or edge depending on the information requirements to implement and exploit.

All attributes of a node type 𝜏 can be returned by the function

𝑓 𝜏 ∶ 𝜏 → 𝑋 𝑗 𝑤𝑖𝑡ℎ 𝑋 𝑗 ⊂ 𝑋. (2)
Likewise, all attributes of an edge type 𝜇 can be returned by

𝑓 𝜇 ∶ 𝜇 → 𝑋 𝑗 𝑤𝑖𝑡ℎ 𝑋 𝑗 ⊂ 𝑋. ( 3
)
For two nodes 𝜐 𝑝 and 𝜐 𝑛 and an edge type 𝜇 𝑙 , the function 𝑔 (4) returns a concrete edge 𝜖 𝑥 if it exists and (5) the set {𝜖 1 , … , 𝜖 𝑎 } representing all real edges between two nodes 𝜐 𝑝 and 𝜐 𝑛 with {𝜖 1 , … , 𝜖 𝑎 } ⊂ 𝐸 without constraint on edge type.

𝑔 ∶ 𝜐 𝑝 * 𝜐 𝑛 * 𝜇 𝑙 → 𝜖 𝑥 (4) 𝑔 ∶ 𝜐 𝑝 * 𝜐 𝑛 → {𝜖 1 , … , 𝜖 𝑎 } (5)
The value 𝛼 of an attribute 𝜒 for a node 𝜐 is returned by the function:

ℎ 𝜐 ∶ 𝜐 * 𝜒 → 𝛼 (6)
Likewise, the value 𝛽 of an attribute 𝜒 of the edge 𝜖 is returned by the function:

ℎ 𝜖 ∶ 𝜖 * 𝜒 → 𝛽 (7)
Finally, these values can be modified using the function 𝑙:

𝑙 𝜐 ∶ 𝜒 * 𝜐 * 𝛼 → 𝜐 𝑓 𝑜𝑟 𝑎 𝑛𝑜𝑑𝑒 𝜐 (8) 𝑙 𝜖 ∶ 𝜒 * 𝜖 * 𝛼 → 𝜖 𝑓 𝑜𝑟 𝑎𝑛 𝑒𝑑𝑔𝑒 𝜖 (9)

Rules integration

Once the base of facts has been defined, the rules and their application process should be detailed. To build a complex expert system, various rules should be integrated such as 𝑅 = {𝛾 1 , … , 𝛾 𝑛 }. Each rule 𝛾 𝑖 is represented and integrated using a combination of pre-defined declarative algebraic operator. These operators allow to:

• integrate new knowledge (i.e. add new nodes),

• correlate knowledge (i.e. add new edges)

• navigate through the graph (i.e. search paths in the graph depending on rules)

The rules application process proposed in this paper is illustrated in Fig. 1. With each modification of the ES base of facts, the related nodes and edges are identified. The modifications can either be creation, deletion or updates of nodes and/or edges. Browsing through the graph to identify the related nodes and edges can be performed using a read method. From this sub-graph, a set of rules can be extracted using a projection operator. The Fig. 2 illustrates an example of graph. The node 𝜐 1 , of type 𝜏 1 , is related to the nodes 𝜐 3 and 𝜐 4 , of type 𝜏 2 , respectively by the edges 𝜖 1 and 𝜖 2 of type 𝜇 1 . The node 𝜐 2 , of type 𝜏 1 , is related to the node 𝜐 4 by the edge 𝜖 3 of type 𝜇 1 . Nodes of the same type share the same kinds of attributes noted 𝜒 1 and 𝜒 2 . Each edge can have a rule 𝛾. To explain this with a real world example, the situation of a systems' overheat can be considered. In this case, the overheat is caused by the failure of one of two fans. The node ''Overheat'', of type ''FailureMode'', is related to the nodes ''Fan1'' and ''Fan2'', of type ''MaintenableItem'' (MI), by the edges ''P1-F1'' and ''P1-F2'', of type ''IsCausedBy''. Each node has an attribute ''ID'' and the MIs also have a ''Lifetime''. This lifetime impacts the rule ''Probability'' of the edges which indicates the most probable cause for the failure.

A projection operator provides all rules on the connection between two nodes through an edge type 𝜇. In the example presented in Fig. 2, a project applied to the nodes 𝜐 1 and 𝜐 2 related by the edge 𝜖 1 would return the rule 𝛾 1 . The general formula is expressed as:

𝑃 𝑟𝑜𝑗𝑒𝑐𝑡 𝜐𝜈 ∶ 𝜈 𝑎 * 𝜈 𝑏 * 𝜇 → 𝑅 𝑗 𝑤𝑖𝑡ℎ 𝑅 𝑗 ⊂ 𝑅 (10)
A modification of the ES base of facts can trigger several rules. Preventing conflicts to arise is the purpose of the control structure. It is performed here using a check operator which applies a constraint type rule to attributes of a set of nodes or edges. The check result is the list of rules to apply. Using the example given in Fig. 2, one such rule could be that only the nodes of type 𝜏 2 with the maximum number of related nodes of type 𝜏 1 meeting predefined conditions on attribute 𝜒 1 , like a threshold, have their rules applied on the edges. For instance, if the attributes 𝜒 1 of the nodes 𝜐 1 and 𝜐 2 fulfill the conditions, the rules 𝛾 2 and 𝛾 3 are returned by the check function but not 𝛾 1 as 𝜐 3 is only related to a single node 𝜐 1 . A general formula is proposed as:

𝐶ℎ𝑒𝑐𝑘 𝑉 ∶ 𝑋 𝑖 * 𝑉 𝑗 * 𝑅 𝑘 → 𝑅 ′ 𝑘 𝑤𝑖𝑡ℎ 𝑋 𝑖 ⊂ 𝑋, 𝑉 𝑗 ⊂ 𝑉 , 𝑅 ′ 𝑘 ⊂ 𝑅 𝑘 ⊂ 𝑅 (11)
𝐶ℎ𝑒𝑐𝑘 𝐸 ∶ 𝑋 𝑖 * 𝐸 𝑗 * 𝑅 𝑘 → 𝑅 ′ 𝑘 𝑤𝑖𝑡ℎ 𝑋 𝑖 ⊂ 𝑋, 𝐸 𝑗 ⊂ 𝐸, 𝑅 ′ 𝑘 ⊂ 𝑅 𝑘 ⊂ 𝑅 (12) A rule is composed of two main parts: the activation condition and the effect. Only when the activation condition is fulfilled can further processing be performed. Some preprocessing may be necessary at this step. A first processing step can then compute values using complex models or algorithms. The result may be checked in a post processing step before altering the graph. This graph alteration can consist in creating or deleting nodes and/or edges. Some attributes values can also be updated. These modifications can then trigger a new read and repeat the process.

Using this process, the rules from the ES base of rules can be applied to the base of facts structured in a HIN while preventing conflicts. Due to the cyclic behavior of the rule's application process, an acyclic graph is required to reduce the risk of getting into infinite loops. This generic structure should now be used to implement a CBM solution with a case study.

Application to aircraft complex systems

Once the rules' implementation has been theoretically defined, it should be experimented in a real case study. In this paper, the HIN based ES has been applied to an aircraft system. In order to create the HIN, the metamodel presented in [START_REF] Guillén | A framework for effective management of condition based maintenance programs in the context of industrial development of E-maintenance strategies[END_REF] has been adapted according to Fig. 3. In this adapted metamodel, the maintenance decision block was not used as the diagnosis, prognosis, detection and maintenance decision elements are processes to implement on the HIN which do not store information. The functions and functional failures also disappeared because the relation between failure mode and are considered sufficient.

The detection process is meant to generate symptom and failure warnings based on sensor data analysis. Consequently, the ''value'' attribute of the ''Monitoring Variable'' nodes should be updated over time. Following the process detailed in the previous section, the descriptor values' attribute should be computed an updated using the descriptors' formula. Following this update, a second rule may turn the symptoms' activated attribute to true if the condition set from the interpretation rules' rules attribute is met. If all the activated attribute value of all the symptom related to a failure mode are true, then the failure modes' activated attribute is set to true.

The diagnosis process should identify which Maintainable Item (MI) is most probably the cause when a failure occurs. This process has been performed through four steps as described in Fig. 4. Its implementation should be composed of a set of rules applied to the relations between a failure node and the related MI nodes. When a single failure mode is related to several MI, some processing should be performed to sort them depending on their reliability.

In order to create this HIN, documentation data have been implemented following this metamodel. While the considered system is not a whole aircraft but only a subsystem, the resulting graph is composed of more than 4000 nodes and more than 12000 relations. It should be mentioned that only physical MI are considered in this paper as software components cannot be maintained using the same logic. In addition to documentation data, maintenance data can be implemented in the graph. For instance, the MI model can change over time and the MI lifetime increases every time the aircraft flies and is reinitialized every time the equipment is changed or repaired.

In this section, rules have been applied to an aircraft system according to Section 3. A first analysis of this HIN from a diagnostic perspective points that 33% of the graphs failures are related to a single MI. Consequently, for these failures, simple propagation is enough to identify the cause and no further analysis is required. However, for the other 77%, more processing should be performed in order to identify the defected MI. In this paper, an implementation of probabilistic rules based on Weibull distribution is proposed to sort the MI by probability of failure.

Extension to probabilistic rules

Motivation

Even though, in this case study, 43% of failure modes are related to a single MI, in most cases several MI are possibly responsible. In reality, airlines operators often manage to directly identify the failed equipment from the failure modes based on their experience and past occurrences. Following this logic, an expert rule has been implemented in the graph based on a probabilistic approach from an analysis of past failure occurrences. The aim is to sort the MIs related to the Failure Mode by decreasing failure probability. Through this process, the MI with the highest probability of breaking down can be identified. In order to define this probabilistic expert rule, a reliability analysis has been performed to model the failure rate of an equipment. However, this failure rate model depends on the type of equipment considered. Usually, the evolution of a physical equipment's reliability can be divided into three main periods. The first period is the running in period. This period represents the beginning of the equipment's lifetime where failures may occur due to production defects or installation issues. Next is the permanent period which corresponds to the later part of the lifetime. In this period, the failure rate is globally constant and low because the system is in its main phase of life. Random events may occur but independently of the lifetime and with low probability. The third period is the ageing period. During this period, the equipment's lifetime reaches its end. As a consequence, the risk of failure increases due to natural wearing. However, the three phases are not distinct in all types of equipment.

For instance the reliability of a mechanical equipment is different from an electronic equipment [START_REF] Beleulmi | Reliability modeling of transport systems: Influence of the running-in period of life[END_REF]. Mechanical systems usually have a consequent failure rate in the running in period and an increasing failure rate in the ageing period with no clear permanent period. Otherwise, in electronic systems the three periods are usually clearly distinct.

Weibull distribution

In the aeronautic field, reliability is a major concern. As a consequence, aircraft systems have been designed to be extremely reliable which led to relatively low failure occurrences. Several probabilistic distributions are often used in the literature like the Exponential distribution, the Log-Normal distribution or the Weibull distribution [START_REF] Couallier | MTBF computations for aeronautical maintained repairable systems with dormant failure mode of control device. In 20e congrès de maîtrise des risques et de sureté de fonctionnement[END_REF]. According to [START_REF] Beleulmi | Reliability modeling of transport systems: Influence of the running-in period of life[END_REF], the Weibull distribution is the universal distribution. Moreover, in the aeronautic field the three periods can be represented depending on the system. As such, the Weibull distribution has been chosen to model the equipment's reliability.

To model a bathtub-shaped failure rate with all three periods, a combination of two Weibull distributions is used [START_REF] Lai | Generalized weibull distributions[END_REF] and [START_REF] Xie | Reliability analysis using an additive Weibull model with bathtub-shaped failure rate function[END_REF]. The density distribution f and cumulative distribution F functions are respectively given by:

𝑓 (𝑥) = ( ( 𝑘 1 𝜆 1 ) ( 𝑥 𝜆 1 ) (𝑘 1 -1) + ( 𝑘 2 𝜆 2 ) ( 𝑥 𝜆 2 ) (𝑘 2 -1) ) ( 𝑒 - ( 𝑥 𝜆 1 ) 𝑘 1 𝑒 - ( 𝑥 𝜆 2 ) 𝑘 2 ) (13) 𝐹 (𝑥) = 1 -𝑒 - ( 𝑥 𝜆 1 ) 𝑘 1 𝑒 - ( 𝑥 𝜆 2 ) 𝑘 2 (14)
with 𝑘 1 > 0, 𝜆 1 > 0, 𝑘 2 > 0, 𝜆 2 > 0 respectively the shape and scale parameters of Weibull distributions. To estimate the parameters of a Weibull distribution a regression method is performed based on Ordinary Least Square Estimator on the cumulative curve of empirical failures according to [START_REF] Zhang | On weighted least squares estimation for the parameters of Weibull distribution[END_REF]. However, in this case, no weights are attributed to failures. The corrected Akaike Information Criterion (AICc) is used to identify the best distribution between a traditional Weibull distribution and the one presented in (13). The choice of the AICc is motivated by the small size of the failures sample and its efficiency with regression models [START_REF] Hurvich | Regression and time series model selection in small samples[END_REF].

The AICc formula is given by:

𝐴𝐼𝐶𝑐 = 2𝑝 -𝑙𝑛(𝐿) + 2𝑝 (𝑝 + 1) 𝑛 -𝑝 -1 ( 15
)
where p is the number of parameters (𝑝 = 2 for a simple Weibull distribution and 𝑝 = 4 for a combination of Weibull distributions), 𝑛 is the sample size and 𝐿 is the maximum value of likelihood function.

The model with the smallest AICc is chosen. Finally, a Kolmogorov-Smirnov test is performed in accordance with [START_REF] Nwobi | A comparison of methods for the estimation of Weibull distribution parameters[END_REF] to check if the model with the estimated parameters follows a Weibull distribution. If the test of Kolmogorov-Smirnov rejects the Weibull distribution, an other distribution should be used to model the empirical curves. In this case study, the test has never rejected the Weibull distribution hypothesis.

Experiments on the diagnosis process

Experiment's protocol

In the previous sections, the concepts and structure of the HIN based ES have been defined. The aeronautical case study has been presented with the failure detection and diagnosis processes has applications. The diagnosis process relies on 4 steps has described in Fig. 4. The first step is the activation of a failure mode. This activation triggers the collect of accused MIs. These MIs should then be sorted by decreasing probability of failure after these probabilities have been computed. In this case study, the probabilistic rules used to estimate these probabilities are based on Weibull models.

In order to assess the presented ES diagnosis performance, the HIN, base of rules and control structure have been implemented using a tool called Digibrain (Activus) according to Section 3.

The documentation, maintenance and monitoring data have been structured according to the metamodel presented in Fig. 3. Entities are translated as nodes and relations as edges. An associate operator has been used to create and fill the nodes and edges from these different sources. A check operator can also control imported data quality.

The diagnosis process is performed using a projection operator between the failure modes and MIs. A failure mode with an activated status triggers a Read rule to collect the related MIs. An Update is then performed on each MI to calculate the probability of failure from the Weibull distributions and the MI's model and lifetime. Next, an update on the failure mode diagnosis attribute generates the list of affected MIs sorted by decreasing probability of failure. The projection operator can also be used to update an MI's attribute. Indeed, MI's lifetime and/or model should be updated after a repair, a replacement and after each use.

The following steps of this experiment consist in designing the Weibull models for each MI and run the diagnosis process before analyzing the results.

Weibull models design

The first objective of the diagnosis is to identify the model of the failed equipment from past maintenance records. The second objective is to identify the physical position of this failed equipment. The probabilistic rules allowing to identify the failed equipment model and In this perspective, two empirical approaches have been designed. The first approach, named Spare Model (SM), models the failure occurrences by spare model over the equipment's lifetime without considering their physical position in the aircraft. The second approach, named Position Spare Model (PSM), takes this feature into account by modeling the failure occurrences by MI and Spare Model. Indeed, several equipments with the same SM can be located at different positions in the same time on the aircraft. However, a MI refers to an equipment located in a specific position.

Hence, considering an equal amount of failures, the second approach designs more models with less empirical points by model. However, this approach is more detailed as it identifies the failed component on an individual, physical, level. In each case, we chose to model failure instants with a Weibull distribution when there were at least three failure occurrences. Otherwise, the failure rate is constant and close to zero. The results of the modeling are presented in Fig. 5. These figures illustrate the three different behaviors (running in period, ageing period or permanent failure period) for each approach.

Evaluation protocol

In order to evaluate the performance of the graph with these models, records of failure modes have been gathered over a year with the related failed equipment identified.

The aim of the diagnostic is to provide a list of potentially failed Equipment Models ordered by decreasing failure's probability. This list is compared to the real breakdowns to evaluate the diagnostics's accuracy. The experiment is composed of 5 steps. The first step is to identify the MI from the recorded failure mode. The second step is to identify the corresponding degradation model for each MI. The third step is to calculate the maintainable item's failure's probability from the degradation model and the MI's lifetime at the failure occurrence date. The fourth step is to generate the list of potentially failed equipments by decreasing failure probability. Finally, the diagnostics performance is evaluated by observing the ranking of the failed equipment in the previous list.

Noticed that the diagnostic based on the Spare Model can provide the same breakdown probability to different MI if their models and lifetimes are identical. This means that similar MIs installed at the same time on the aircraft will be given the same ranking in the diagnostic result list. However, when using the PSM where the physical position is considered, two MIs, even similar, do not refer to the same curve. As such their breakdown probability and rankings differ.

Figs. 6 and 7 illustrate the ranking of the real failed equipment in the list returned by the diagnostic based on the Spare Model. Colors in the histograms represent the total number of equipment in the list returned by the diagnostic, that is to say the total number of MIs returned by the graph. For instance, the red part with the rank ''1'' corresponds to the number of failure modes where the failed equipment has been correctly identified among 2 possibilities. MIs with the ranking ''0'' represent the situation where a single MI possibly responsible for the failure according to the graph. In this case, which represents 36%, the Weibull models are not needed.

Evaluation results

Fig. 6 illustrates results using Weibull model on Sparse Model. It allows to predict correctly 71% in the first rank in the returned list. The diagnostic obtains an accuracy of 94% by observing the two first propositions only thanks to the probabilistic rule.

In Fig. 7, the ranks ''0'' and ''1'' have been aggregated to represent the actual performance of the diagnostic. The global accuracy of the diagnostic is 81% looking the first MI returned in the list and 96% looking the two first items with the greatest probability of breaking down.

The same approach has been respectively used to represent the results obtained with the PSM. As shown in Fig. 8, 36% of the results are given directly by the graph. The PSM predicts correctly 59% more (81% more in top 2) when a choice is needed and by aggregating all correct answers in Fig. 9, global accuracy is now of 74% (88% in top 2).

The Spare Model and PSM both have their advantages. While the Spare Model is less detailed as it points the model of the failed equipment and not the specific part, it offers better performance and can be sufficient from a logistic perspective to improve the supply chain management and maintenance scheduling for instance. At the same time, the PSM is more interesting for the maintenance operators as it indicates which equipment to test at a physical level, saving time in the repair process.

As a conclusion, using these probabilistic rules, the detection of the failed item improves from 36% with the physical and functional descriptions alone to 81% with the SM and 74% with the PSM. Furthermore, while some failed equipments are ranked in the second place or below in the diagnostics list, it may not mean that equipments ranked before have not failed. Further works could focus on considering this aspect in the results' evaluation.

Conclusion and perspectives

The maintenance domain is confronted to increasing requirements in reliability and cost reduction driving the need for more efficient maintenance policies. In this context, condition-based maintenance, prognostics and health management are promising as they allow a better evaluation of the systems' degradation and environmental conditions. These strategies are mainly implemented based on historical data records using machine learning or based on capitalized expert knowledge through an expert system.

This paper proposes an expert system framework addressing modern ES limitations in efficiency, scalability and applicability. It is based on an heterogeneous information network in charge of supporting and manage the ES base of fact, base of rules and control structure. The choice of the HIN addresses the efficiency and scalability issues of modern ES which are not adapted to complex and dynamic systems. A generic meta-model for CBM is used to answer the adaptability requirements for these systems. A case study on an aircraft is presented to illustrate this frameworks' implementation and provide an example of probabilistic rule based on Weibull distribution for diagnostics.

Despite the frameworks' promising results, some limits and perspectives still need to be addressed. First, the availability of sensor and documentation resources are a necessity for the framework to be implemented. This limit is inherent to most condition based maintenance solutions and can be considered a critical limit to the research development in the field. A second limit is the exploitation and structuring of documentation resources into a base of facts. Some technical documentation being in paper or pdf format, processing these resources to generate an HIN can be considered as a challenge and a strong perspective. An other perspective should be to develop more case studies to challenge the frameworks adaptation ability to different systems. Indeed, as the metamodel was designed to be generic and adaptable, this genericity should be challenged by testing other systems with more nodes and relations to evaluate the overall performance. Finally, more complex models should be integrated to improve the diagnostics and prognostics performance. In particular, several works focused on developing diagnostics and prognostics models for gas turbine engine [START_REF] Hanachi | Performancebased gas turbine health monitoring, diagnostics, and prognostics: A survey[END_REF][START_REF] Puggina | Development of a statistical methodology for gas turbine prognostics[END_REF][START_REF] Roemer | Advanced diagnostics and prognostics for gas turbine engine risk assessment[END_REF][START_REF] Zaidan | Gas turbine engine prognostics using Bayesian hierarchical models: A variational approach[END_REF]. A case study could be designed to implement and test these models with C-MAPSS data.

Fig. 2 .

 2 Fig. 2. Graph example.

Fig. 3 .

 3 Fig. 3. KG metamodel.

Fig. 4 .

 4 Fig. 4. The diagnosis process 4 steps.

Fig. 5 .

 5 Fig. 5. Failures' modeling on Spare Model by Weibull distributions.

Fig. 6 .

 6 Fig. 6. Evaluation of probabilistic rule using modeling on Spare Model on all airlines.

Fig. 7 .

 7 Fig. 7. Global results of the diagnostic using modeling on Spare Model on all airlines.

Fig. 8 .

 8 Fig. 8. Evaluation of probabilistic rule using modeling on Position and Spare Model on all airlines.

Fig. 9 .

 9 Fig. 9. Global results of the diagnostic using modeling on Position and Spare Model on all airlines.

  Conception and design of study, Acquisition of data, Writing -original draft. Jérémy Bascans: Conception and design of study, Acquisition of data, Writing -original draft. Jean-Baptiste Sciau: Conception and design of study, Writing -original draft. Jiefu Song: Conception and design of study, Writing -original draft. Bruno Supiot: Analysis and/or interpretation of data, Writingreview & editing. Aurélie Montarnal: Analysis and/or interpretation of data, Writing -review & editing. Xavier Lorca: Analysis and/or interpretation of data, Writing -review & editing. Sébastien Truptil: Analysis and/or interpretation of data, Writing -review & editing.

Table 1

 1 Comparison table for KG solutions.

	Knowledge graph solution	Genericity	Heterogeneity	Intelligibility	Adaptability	Upgradability	Volumetry	Velocity
	Bayesian networks	!	%	%	!	!	%	%
	Conceptual graphs	!	%	!	!	!	%	%
	HIN	!	!	!	!	!	!	!

Fig. 1. Rules processing referencing related equations.

Acknowledgments

All authors approved the version of the manuscript to be published.

Declaration of competing interest

The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.