WO2012037429A2

WO2012037429A2 - Failure prediction and maintenance

Info

Publication number: WO2012037429A2
Application number: PCT/US2011/051873
Authority: WO
Inventors: Dmitriy Fradkin; Fabian Moerchen
Original assignee: Siemens Corp
Current assignee: Siemens Corp
Priority date: 2010-09-16
Filing date: 2011-09-16
Publication date: 2012-03-22
Anticipated expiration: 2013-03-16
Also published as: EP2616976A4; WO2012037429A3; EP2616976A2

Abstract

A method of failure prediction in a work cycle includes generating a plurality of rules for predicting failure (101), evaluating the plurality of rules for predictability with respect to at least one of a machine and a message set generated by the machine and a sensor generating sensor data (102), ranking the plurality of rules based on the evaluation (103), and refining at least one rule of the plurality of rules having a threshold ranking (104)

Description

FAILURE PREDICTION AND MAINTENANCE

CROSS-REFERENCE TO RELATED APPLICATION This is a non-provisional application claiming the benefit of U.S. provisional application serial number 61/383,402, filed September 16, 2010, the contents of which are incorporated by reference herein in their entirety.

BACKGROUND

1. Technical Field

The present disclosure relates to work cycles, and more particularly to a failure prediction and maintenance in a work cycle.

2. Discussion of Related Art

There is a trend to use predictive methods for preventive maintenance of equipment such as medical scanners, gas turbines, wind turbines, solar plants, trains, etc. Preventive maintenance strategies can lower costs and improve customer satisfactions. Repairs can be done via scheduled downtime and spare parts can be ordered ahead of time if there is strong evidence that a particular failure will occur.

BRIEF SUMMARY

According to an embodiment of the present disclosure, a method of failure prediction in a work cycle includes generating a plurality of rules for predicting failure, evaluating the plurality of rules for predictability with respect to at least one of a machine and a message set generated by the machine and a sensor generating sensor data, ranking the plurality of rules based on the evaluation, and refining at least one rule of the plurality of rules having a threshold ranking.

According to an embodiment of the present disclosure, a system for performing a method of failure prediction in a work cycle includes a processor configured to predict failure in a work cycle, the processor generating a plurality of rules for predicting failure, evaluating the plurality of rules for predictability with respect to at least one of the machine and the message set generated by the machine and a sensor generating sensor data, ranking the plurality of rules based on the evaluation, and refining at least one rule of the plurality of rules having a threshold ranking, and a memory configured to store the plurality of rules.

BRIEF DESCRIPTION OF THE DRAWINGS

Preferred embodiments of the present disclosure will be described below in more detail, with reference to the accompanying drawings:

FIG. 1 is a flow diagram showing a method for failure prediction according to an embodiment of the present disclosure;

FIG. 2 is a flow diagram showing a method of data sequence processing according to an embodiment of the present disclosure;

FIG. 3A is a flow diagram showing a method of pattern evaluation according to an embodiment of the present disclosure;

FIG. 3B is a process diagram showing a method of pattern evaluation according to an embodiment of the present disclosure; and

FIG. 4 is a diagram of a system for failure prediction and maintenance in a work cycle according to an embodiment of the present disclosure.

DETAILED DESCRIPTION OF PREFERRED EMBODIMENTS

According to an embodiment of the present disclosure, patterns indicative of an upcoming failure or a need for intervention may be identified. For example, sensor measurements showing sudden significant changes may be indicate a failure or need for recalibration. Apart from sensor data, many systems also generate a log messages.

Occurrences of particular messages, patterns of several messages or changes in frequency of messages and patterns can be indicative of upcoming failures.

According to an inventive concept of the present disclosure, automatic discovery of patterns predictive of equipment failure or of other events of interest is enabled. Exemplary implementations use genetic programming with a framework for representing sequences of heterogeneous objects using a wide range of predicates and patterns. Heterogeneous data (e.g., such as log data, sensor measurements, images, etc.) in a single stream are treated as a sequence of objects. By defining basic predicates/patterns over such objects, as well as functions for combining these into more complicated patterns, complicated relationships and patterns may be represented. Genetic programming is used to find patterns predictive for particular types of equipment failures or other events of interest. According to an

embodiment of the present disclosure, predictive patterns may be found over long streams of data, without explicit negative examples, combining multiple types of information, and can evaluate them over complete history.

Embodiments of the present disclosure may be implemented in a work flow environment comprising a computer system generating logs, a sensor system taking measurements and passing the measurements to a computer system for generating messages, a system generating state data, etc. Embodiments of the present disclosure are applicable to messages or sensors apart from one another.

An exemplary machine embodying a method according to the present disclosure may include one or more sensors, wherein the sensors generate measurements processed by machine to generate messages.

An exemplary work flow environment may include a machine such as a process control system, sensor system (e.g., a Computer Tomography (CT) or Magnetic Resonance

Imaging (MRI) scanner in a medical application for predicting organ failure in a patient), or a component based automation system. Further exemplary work flow environments include a machine such as a remote interface control system (e.g., oil & gas, water and wastewater, power generation and distribution, and transportation), a heating control system (e.g., thermoforming or baking process), door control system, condition monitoring system, and electrical charging component.

Components of a work flow environment that may function as sensors may include audio and video input devices, data loggers, controllers, monitors, input/output (I/O) devices, switching devices, protection equipment, motor starters, load feeders, position switches, commanding/signaling devices, transformers, power supplies, etc.

It should be appreciated that the application is not limited to the work flow environments or components described herein, and that embodiments may be variously implemented.

According to an embodiment of the present disclosure, a failure prediction method takes heterogeneous data and positive cases in a long stream of data as input and searches for patterns that are predictive, by themselves, and for patterns whose frequency changes are predictive. More particularly, a framework is deployed based on genetic programming for finding predictive patterns from data sequences. The framework may directly mine predictive patterns, without generating complete sets of frequent patterns. The framework may perform evaluation of patterns on complete data history, without the need for labeled negative examples. The framework may find predictive over- or under-represented patterns. The framework may further find and incorporate constraints on supplemental information, such as text or numeric data accompanying the sequence.

Embodiments of the present disclosure will be described in terms of the following variables:

An event sequence over a set of events E is a sequence of pairs (t_t;s^ of event sets (consisting of elements of E) and time stamps t The ordering is based on time.

The length of the event sequence is n . A sequence database, SDB , of size N is a collection of N such event sequences.

A pattern P has support (P) - s in an SDB D if D contains s distinct event sequences that match P . A pattern is frequent if and only if its support is no less than a predefined minimum support value t , i.e. support (P) > t .

A frequent pattern P is considered closed in an SDB D, if is there is no pattern P' , such that P is a subsequence of P' and support (Ρ') = support { .

An exemplary implementation may use genetic programming with a rule language tailored to preventive maintenance to automatically find, evaluate, and improve patterns that predict events of interest in historical data gathered from equipment. The rule language covers various conditions. These conditions may include conditions based on sensor data (e.g., violating thresholds, detected drifts, increase or decrease in noise), conditions based on message data (e.g., matching keywords, regular expressions, parameters violating thresholds), conditions based on other data (e.g., features extracted from image data), constraints on the duration between different conditions, and constraints on the frequency of conditions or partial orders of conditions. Conditions may be combined into a partial order expressing (partial) temporal order. Linear and non-linear combinations of conditions and partial orders of conditions may be used as well. In view of the foregoing, a pattern is an antecedent part of a rule. For example, a rule [A before C] predicts failure within 5 minutes, and [A before C] is a pattern predicting a failure F. In the case of one target of interest, where the method is focused on a single failure, then this difference is unimportant. If there can be different failures or EOIs, then it is important, because a method may include multiple rules from a single pattern, and they may have different performance. In embodiments described herein related to predicting a single specific type of failure, the terms rules and patterns are interchangeable.

Referring to FIG. 1, in the genetic programming paradigm initial rules may be generated (101). The initial rules may be evaluated for their predictability with respect to a specific problem (102). An evaluation of the initial rules may be performed by comparing a frequency prior to failures with frequency overall in order to rate the initial rules. Rules may be kept according to the ratings (103) and refined to generate more complex rules (104). The refinement may include combining rules, extending rules by additional conditions, and changing parameters of rules (such as thresholds). In this manner the system can

automatically identify complex rules that combine evidence from different sources. The method may evaluate the refined rules at each cycle to check for a target performance (105), and in the case where insufficient improvement is determined that method may end.

A user can review patterns and guide the system by supplying initial patterns or changing suggested patterns based on domain knowledge where the system may create new, variants of the pattern.

Referring to FIG. 2, a data sequence may be defined as a sequence (ο_;, ^) comprising objects o_; occurring at time t_t (201). The time t_; can be the same for multiple objects. It may be assumed that each object o_i contains a number of fields f_j, which may be referred to as o_v . This is a general setting that can accommodate many applications.

AA sseett ooff BBoooolleeaann ffuunnccttiioonnss bb_kk mmaayy bbee ddeeffiinneedd oonn iinnddiivviidduuaall oobbjjeeccttss,, ee..gg..,, bb

ttaakkeess vvaalluuee 11 iiff aa ppaarrttiiccuullaarr ffiieelldd ssaattiissffiieess aa ppaarrttiiccuullaarr pprreeddiiccaattee,, aanndd ttaakkeess vvaalluuee 00 ootthheerrwwiissee.. EExxaammpplleess ooff pprreeddiiccaatteess iinncclluuddee::

FFoorr ssttrriinngg ffiieellddss ff.. ::

* Equal ly, 5) = 1 if o is exactly equal to a specific string s , * Contains (y, s) = 1 if o_tj contains a specific substring s , and

* Matches (y, r) = 1 if o_tJ matches a regular expression r .

For numeric fields f_j standard comparison functions = >,< < > can be defined with respect to a numeric parameter.

More complicated concepts may be handled by appropriate pre-processing (202). For example, if it is known that under particular circumstances a string field contains a numeric value that could be useful, such values may be extracted into separate fields as pre-processing steps. Such a situation may arise in an application where objects correspond to log messages with a fixed set of fields, and where message text frequently has a pre-specific format with a particular set of parameters, depending on the type of the message. In such a case it is straightforward to extract these parameters into separate fields. For example, in a system where messages have templates, such as 'Component %1 has parameter %2 set at %3', %1, %2, %3 are placeholders for the actual values that may be injected at runtime. The placeholders can be strings, or numbers. If the template is known in advance, messages may be matched to it, and values of all parameters may be determined. Otherwise, similar messages may be grouped and pieces where they differ may be identified.

For example, consider:

'Component X has parameter Temperature set at 30'

'Component Y has parameter Pressure set at 120'

The messages differ in several places: X vs Y, Temperature vs Pressure, and 30 vs 120. It may be assumed that these are parameters, since the other parts of these messages, e.g., "has parameter" and "set at" are aligned.

Given these messages, a method may group together messages by string similarity and identify parts where they differ, and treat the values as parameters.

Another example of a pre-processing is an extraction of trends from sensor data. If a particular object has a numeric property, a new numeric field may be created corresponding to the change in the value of the original field. This will allow for the use of patterns over the original variable and over its rate of change.

The framework defines predicates over images, large texts, and other data structures

(203). Given such Boolean functions, a data sequence may be converted into an event sequence by representing objects with the indices of functions that take value 1 for these objects (204).

For example:

Given object with 3 fields: {5,1 1, "sudden failure"} and with function

b_x = (l, 5), b₂ = (2, 10), b₃≤(y, 12), Z>₄ e (3, "sudden"), the representation of this object with respect to this set of functions is: [1,3,4], since these are the indices of functions that return 1 for this object.

In other words, each object may be represented as an item-set, and the object sequence as a sequence of item-sets, e.g., an event sequence.

Following the definitions above, patterns may be described based on a single object and patterns may be described over multiple objects. This is achieved by allowing patterns to be combined via different functions:

Logical:

* OR \_ip_l , ... , p_n ] ) - any one of the patterns occurs

* - none of these patterns occur

*

- all of the patterns occur

Temporal:

* BEFORE (p_vp^ - pattern p_l occurs before p₂

* DURATION (p_v t) - pattern p_l occurs within a time window of length t

* MNFREQUENCY (p t) - pattern p_l occurs at least t times

Using functions, a traditional sequential, partial order patterns, and complicated patterns may be represented. Since all functions are defined over patterns, and are themselves patterns, arbitrarily complex patterns may be derived by nesting these functions.

Thus, patterns that can be expressed using the framework can include combinations of conditions based on sensor data (e.g., violating thresholds, detected drifts, increase or decrease in noise), conditions based on message data (e.g., matching keywords, regular expressions), and conditions based on other data (e.g., features extracted from image data). The patterns that can be expressed may further include combinations of conditions in a partial order expressing (partial) temporal order, constraints on the duration of a pattern or time between different conditions, and constraints on the frequency of conditions or partial orders of conditions.

Referring now to pattern evaluation; given a historical database and a pattern, a predictive quality of the pattern may be evaluated.

Referring to FIGS. 3A-B, assume a failure or an Event of Interest (EOI) at time T (301). Define a period of time before a failure or event of interest, as [-^,-i₂ ] _> with > t₂ ^as alert window. Define time period ~t₂, t₃), with t₃ > 0 as late window (302). A pattern is considered to be predictive for a particular EOI if it occurs in the alert window, and is considered a false positive if it occurs outside of an alert window or a late window (303).

Patterns occurring during the late window are not counted as either true or false positives.

The quality of a pattern is a measure (or measures) of fraction of pattern occurrences in the alert window, as well as fraction of an EOI that have a pattern in their alert windows.

Standard predictive measures, such as sensitivity (e.g., fraction of cases of interest identified) and specificity (e.g., fraction of true alerts) can thus be determined and used to drive the optimization.

Referring to pattern generation and evolution; patterns, both at object level (e.g., functions b_} ) and at the event sequence level, may be found or determined within the genetic programming framework, which tunes patterns both at the level of objects (e.g., by modifying individual low-level function 6 ), and on the global level, by changing the structure of whole pattern.

An initial population of object-level patterns may be randomly generated using basic predicates (301). An alternative option for generating initial population could include mining of frequent sequential or partial order patterns in the alert windows. A population is then evaluated with respect to predictiveness measures (302), and a new population is generated based on the results (303). Patterns that have higher scores produce more children (whether in the form of exact copies, mutations, or cross-over or combinations with other patterns). Methods of producing a new individual may be characterized as refinements, generalizations, combinations and cross-overs. In the case of refinement a new Boolean function may be added to a particular node in the pattern, or is replaced by a more specific one (e.g., LessThanOrEqual for numbers or Contains for strings could be replaced by Equals). In another refinement method, a parameter is replaced by a more specific one. For example, a numeric parameter in LessThan may be replaced by a smaller one, or a string parameter in Contains may be extended, or Duration time parameter could be shorted or Frequency parameter increased. In another refinement method, a pattern may be wrapped within a new high-level function, such Duration or Frequency.

In the case of generalization, a Boolean function may be removed from a particular node in the pattern, or is replaced by a more general one or a parameter may be replaced by a less specific one.

In the case of a combination, patterns may be combined using high-level functions described above.

In the case of a cross-over, patterns can exchange some of their groups/nodes.

These operations allow for a general evolutionary approach, where best specimens of a population reproduce with crossover, or for local pattern optimization using beam search where independent optimization of individual patterns without mutation takes place.

A number of heuristics can be used to guide the process. For example, if a particular pattern has high specificity but low sensitivity, a generalization might be more preferable, while in the reverse situation generalization could be useful.

Embodiments described herein are applicable in various domains including performance monitoring and failure or EOI prediction for medical scanners, power equipment (e.g., turbines, plants), trains, car and airplanes, business processes, and patients.

The following is an exemplary case of an evolutionary method for generating and refining rules in a system. The exemplary system comprises 2 sensors recording

measurements. That is, sensorl and sensor2 output numeric values (assuming only positive values for this example) and 3 types of messages, with templates. The exemplary message templates are:

Message 1: Component %1 is out of tune. (%1 can be XAxisCamera, YAxisCamera, Motor)

Message2: Restarting module %1. Message3: Starting operation %1.

Assuming that the system has access to a year's worth of data for 10 machines (365* 10 machine-days), for each machine messages may be recorded at random times for at defined events (e.g., , at a start of each patient procedure in the case of a diagnostic procedure). A list of N positive examples of failure (N ~ 20-30) is also available.

In the system, a user may want to trigger alerts when a failure (e.g., stress cracks forming in a piece of equipment) may be expected within 7 days, assuming that alerts on the last day are late.

Using notation above, ti=-7, t₂=-l, h=0, true alerts and false alerts are identified, and a precision is determined as a fraction of alerts that are correct; the fraction of failures for which a true alert is determined.

An initial set of rule(s) may be defined using predicates, for example:

rulel : sensor 1 > 10

rule2: sensor2 > 5

rule3: Message 1 occurs

rule4: Message2 occurs.

These rules are evaluated to determined:

rulel : precision - 10%, recall 60%

rule2: precision 1%, recall 100%

rule3: precision 1%, recall 80%

rule4: precision 80%, recall 30%

Based on the evaluation, it may be determined to:

1) drop rule 2

2) raise a threshold in rulel : sensor 1 > 15 (refinement)

3) generate a new rule from rule 3: Messagel occurs and text=XAxisCamera (adding a new Boolean to a node - refinement)

4) generate a new rule from rule 3: Messagel occurs twice in 5 minutes (frequency constraint - refinement)

5) combine: Message2 occurs OR sensorl>10 A refinement of the rules yields a new set of rules:

rule5: sensor 1 > 15

rule6: Message 1 occurs and text=XAxisCamera

rule7: Message 1 occurs twice in 5 minutes

rule8: Message2 occurs OR sensor 1> 10

The new set of rules may be evaluated. For example:

rule9: Message 1 occurs and text contains 'Camera' (generalization)

rulelO: Message2 occurs AND sensorl>15 within 5 minutes

etc.

Evaluation, ranking and refinement continues, wherein top rules are stored according to a target criteria. For example, top rules may be defined to have a precision above 50% and recall greater than 10%).

It is to be understood that embodiments of the present disclosure may be implemented in various forms of hardware, software, firmware, special purpose processors, or a combination thereof. In one embodiment, a software application program is tangibly embodied on a non-transitory computer-readable storage medium, such as a program storage device or computer-readable storage medium, with an executable program stored thereon. The application program may be uploaded to, and executed by, a machine comprising any suitable architecture.

Referring to FIG. 4, according to an embodiment of the present disclosure, a computer system (block 401) for performing failure prediction in a work cycle includes, inter alia, a CPU (block 402), a memory (block 403) and an input/output (I/O) interface (block 404). The computer system (block 401) is generally coupled through the I/O interface (block 204) to a display (block 405) and various input devices (block 406) such as a mouse, keyboard, medical scanners, power equipment, etc. The display (block 405) may be implemented to display the rules, e.g., as the rules evolve during evaluation, ranking and refinement or as an output set of rules. The support circuits can include circuits such as cache, power supplies, clock circuits, and a communications bus. The memory (block 403) can include random access memory (RAM), read only memory (ROM), disk drive, tape drive, etc., or a combination thereof. The present invention can be implemented as a module (block 407) of the CPU or a routine stored in memory (block 403) and executed by the CPU (block 402) to process input data (block 408). For example, the data may include image information from a camera, which may be stored to memory (block 403) As such the computer system (block 401) is a general purpose computer system that becomes a specific purpose computer system when executing the routine of the present disclosure.

The computer platform (block 401) also includes an operating system and micro instruction code. The various processes and functions described herein may either be part of the micro instruction code or part of the application program (or a combination thereof) which is executed via the operating system. In addition, various other peripheral devices may be connected to the computer platform such as an additional data storage device and a printing device.

It is to be further understood that, because some of the constituent system components and method steps depicted in the accompanying figures may be implemented in software, the actual connections between the system components (or the process steps) may differ depending upon the manner in which the system is programmed. Given the teachings of the present disclosure provided herein, one of ordinary skill in the related art will be able to contemplate these and similar implementations or configurations of the present disclosure.

Having described embodiments for failure prediction in a work cycle, it is noted that modifications and variations can be made by persons skilled in the art in light of the above teachings. It is therefore to be understood that changes may be made in embodiments of the present disclosure that are within the scope and spirit thereof.

Claims

What is claimed is: 1. A method of failure prediction in a work cycle comprising:

generating a plurality of rules for predicting failure;

evaluating the plurality of rules for predictability with respect to at least one of a machine and a message set generated by the machine and a sensor generating sensor data; ranking the plurality of rules based on the evaluation; and

refining at least one rule of the plurality of rules having a threshold ranking.

2. The method of claim 1, further comprising iteratively performing the evaluation, ranking and refining.

3. The method of claim 2, wherein refining comprises removing at least one rule below the threshold ranking from the plurality of rules to be evaluated.

4. The method of claim 1, wherein refining comprises combining two or more rules of the plurality of rules.

5. The method of claim 1, wherein refining comprises extending the at least one rule by a condition.

6. The method of claim 1, wherein refining comprises changing a parameter of the at least one rule.

7. The method of claim 1, further comprising extracting at least one template from the message set, the at least one template identifying parameters and values in messages of the message set.

8. The method of claim 7, wherein the messages of the message set indicate at least one object o occurring at a time t .

9. A computer program storage medium embodying instructions executable by a processor to perform a method for failure prediction in a work cycle, the method comprising:

generating a plurality of rules for predicting failure;

10. The computer program storage medium of claim 9, further comprising iteratively performing the evaluation, ranking and refining.

11. The computer program storage medium of claim 10, wherein refining comprises removing at least one rule below the threshold ranking from the plurality of rules to be evaluated.

12. The computer program storage medium of claim 9, wherein refining comprises combining two or more rules of the plurality of rules.

13. The computer program storage medium of claim 9, wherein refining comprises extending the at least one rule by a condition.

14. The computer program storage medium of claim 9, wherein refining comprises changing a parameter of the at least one rule.

15. The computer program storage medium of claim 9, further comprising extracting at least one template from the message set, the at least one template identifying parameters and values in messages of the message set.

16. The method of claim 15, wherein the messages of the message set indicate at least one object o occurring at a time t .

17. A system for performing a method of failure prediction in a work cycle, the system comprising: a processor configured to predict failure in a work cycle, the processor generating a plurality of rules for predicting failure, evaluating the plurality of rules for predictability with respect to at least one of a machine and a message set generated by the machine and a sensor generating sensor data, ranking the plurality of rules based on the evaluation, and refining at least one rule of the plurality of rules having a threshold ranking; and

a memory configured to store the plurality of rules.

18. The system of claim 17, further comprising the machine processes the sensor data to generate the message set.