Method for predicting failure of an industrial machine, computer-implemented method, industrial machine, computer-implemented method for training a module arrangement, computer program product, and computer system

Abstract

The computer-implemented fault predictor has a module arrangement (373) with first and second secondary modules (313, 323) secondary to the output module (363). The first and second secondary modules process data from the industrial machine to determine first and second intermediate state indicators. A third secondary module (333) determines an operating mode indicator, and the output module (363) processes the state indicators and operating mode indicators to predict faults in the industrial machine. The module arrangement has been trained via cascaded training to include training the secondary modules (312, 322, 332), subsequently operating the trained secondary modules, and subsequently training the output module.

Description

Technical Field

[0001] In general, this disclosure relates to industrial machinery; and more specifically, this disclosure relates to computer systems, methods, and computer program products for predicting failures of industrial machinery. Prior Technology

[0002] Industrial machines that operate continuously without any interruption are as rare as perpetual motion machines.

[0003] In short, there are at least two main reasons for machine interruptions. Machine operators typically shut down the machine at regular intervals for maintenance. Alternatively, the machine may stop due to a malfunction.

[0004] Over the past few decades, computer models have made significant progress in predicting failures. So-called predictive maintenance models allow operators to shut down machines for maintenance when a failure is anticipated. This approach increases the total time machines are operational and reduces downtime.

[0005] Computer models receive sensor data (and other data) from a machine and predict failures using detailed information such as failure time and failure type. The computer model needs to know causal relationships. In many cases, such relationships are unknown, so the computer is trained using training data (typically a combination of historical sensor data and historical failure data) to approximate these relationships.

[0006] Predictive accuracy is crucial. For example, a computer might predict a malfunction within a week, and the operator could shut down the machine for immediate maintenance. Incorrect predictions, however, are serious. In scenarios with incorrect predictions, immediate maintenance might not actually be necessary, and the machine could have operated normally without interruption.

[0007] To improve accuracy, technicians face numerous challenges and limitations, including a potential lack of data (such as sensor data or fault data), a potential lack of expert commentary (for identifying historical faults), discrepancies between different commentaries from different experts, potentially inaccurate data correlation assessments, and so on. Other challenges will be explained below, but overall there is a need to improve accuracy for any prediction.

[0008] Stich et al. describe the use of multiple computer models to classify wafer fabs as sub-components of complex industrial systems (STICH PETER ET AL: "Yield prediction in semiconductor manufacturing using an AI-based cascading classification system", 2020 IEEE INTERNATIONAL CONFERENCE ON ELECTRO INFORMATION TECHNOLOGY (EIT), IEEE, 31 July 2020 (2020-07-31), pages 609-614).

[0009] US Patent Application Publication No. US 2013 / 0132001 A1 relates to industrial equipment and explains fault detection and fault prediction using a model. The document discusses specific examples and also mentions the training of the model. Summary of the Invention

[0010] In short, the prediction does not come from a single functional module that receives machine data and provides the prediction data; instead, the prediction comes from a module arrangement with output modules and sub-ordinated modules. In this sense, the module arrangement implements a meta-model, because the output modules predict failures by processing intermediate metrics from the sub-modules (or the base model).

[0011] Arranging multiple modules in a hierarchical structure also affects training: secondary modules are pre-trained as higher-level modules.

[0012] More specifically, the module arrangement includes first and second intermediate modules secondary to the output module. At least the first and second secondary modules process machine data to determine first and second intermediate state indicators, respectively. Such state indicators can be correlated with the operating configuration of the industrial machine.

[0013] In parallel, a sub-ordinated module, the operation mode classifier, also receives sensor data and determines the operating mode (operation mode index) of the industrial machine. The output module processes intermediate state indices and operation mode indices and predicts industrial machine failures. Compared to the single functional module mentioned above, prediction accuracy is improved because failures are associated with different operating modes.

[0014] The accompanying drawings also illustrate a computer program or computer program product. When a computer program product is loaded into the computer's memory and executed by at least one processor of the computer, the computer program product causes the computer to perform the steps of a computer-implemented method. In other words, the program provides instructions to the module. Similarly, when a processing module is executed by a computer system, the computer system, which includes multiple processing modules, performs the steps of a computer-implemented method.

[0015] This invention relates to a computer-implemented method for predicting industrial machine failures as described in claim 1. The computer-implemented method for predicting industrial machine failures involves a method of arranging processing modules (the attribute "processing" is sometimes omitted in the text for brevity). The computer receives machine data from the industrial machine through first, second, and third-level processing modules. These modules are arranged to provide intermediate data to an output processing module. The arrangement has been trained in advance through cascaded training. Through the first-level module, the computer processes the machine data to determine a first intermediate state indicator. Through the second-level module, the computer processes the machine data to determine a second intermediate state indicator. The third-level module is an operation mode classifier module, through which the computer processes the machine data to determine an operation mode indicator of the industrial machine. The computer processes the first and second intermediate state indicators and the operation mode indicator through an output module. Thus, the output module predicts the failure of the industrial machine by providing predictive data.

[0016] Optionally, the computer uses an arrangement that has been trained according to the following training sequence: training a third-level module with historical machine data; running the trained third-level module to obtain historical pattern indicators by processing historical machine data; training first and second-level modules with historical machine data and historical pattern indicators; running the trained first and second-level modules to obtain first and second intermediate state indicators by processing historical machine data; and training an output module with historical pattern indicators, historical machine data, and historical fault data.

[0017] Optionally, when determining operating pattern metrics, the computer uses an operating pattern classifier that has been trained on historical machine data that has been annotated by human experts.

[0018] Optionally, the historical machine data annotated by experts is sensor data.

[0019] Optionally, an operation pattern classifier has been trained based on historical machine data. During training, the operation pattern classifier clusters the machine's operation time into clusters of time series segments.

[0020] Optionally, the clustering of time series segments can be assigned to operational pattern indicators, which can be selected from automatic assignment or assignment through interaction with human experts.

[0021] Optionally, the operating mode indicator is provided by the number of times the mode changes over time.

[0022] Optionally, the state indicators are selected from current indicators that indicate the current state and predictive indicators that indicate the future state.

[0023] Optionally, the output module predicts the failure of industrial machines, and the prediction is selected from the following: failure time, failure type, remaining service life, and failure interval.

[0024] Optionally, the operating mode index can also be used as the deviation between the processing by the first and second secondary processing modules.

[0025] Optionally, the computer receives machine data by receiving a subset of sensor data; and the computer determines first and second intermediate state indicators by first and second secondary modules that process the subset of sensor data.

[0026] Optionally, the computer receives machine data. This action includes receiving data via a data coordinator, which provides machine data or filters incoming machine data via virtual sensors based on the contribution of the machine data to fault prediction.

[0027] Optionally, the computer receives machine data through a data coordinator. This action includes receiving machine data from a coordinator carrying modules that have been pre-trained through transfer learning.

[0028] Optionally, the computer receives machine data that has been at least partially enhanced by data generated by simulation.

[0029] From a broader perspective, this method for predicting industrial machine failures can be applied to use cases where predictive data is forwarded to a machine controller. The machine controller can then instruct the industrial machine to adopt a mode where the failure time is predicted to occur latest, and the controller can also instruct / allow the industrial machine to adopt a mode where machine maintenance is performed latest.

[0030] Furthermore, industrial machines can be adapted to provide machine data to a computer (for executing the method). Industrial machines can also be adapted to receive predictive data from a computer. In such scenarios, the industrial machine is associated with a machine controller that switches the machine's operating mode according to predefined optimization objectives.

[0031] Optionally, the predefined optimization objective is selected from the following: avoid maintenance for as long as possible, and operate in a mode where failure prediction occurs at the latest.

[0032] Industrial machinery can be selected from: chemical reactors, metallurgical furnaces, containers, pumps, motors, and engines.

[0033] Furthermore, there are computer-implemented methods for training module arrangements having first, second, and third-level modules connected to an output module, enabling the module arrangement to provide fault indicators with fault prediction for industrial machines. This method includes applying cascaded training to train secondary modules, subsequently operating the trained secondary modules, and then training the output module.

[0034] Optionally, the cascaded training includes: training a third-level module with historical machine data; running the trained third-level module to obtain historical pattern indicators by processing historical machine data; training first and second-level modules with historical machine data and historical pattern indicators; running the trained first and second-level modules to obtain first and second intermediate state indicators by processing historical machine data; and training an output module with historical pattern indicators, historical machine data, and historical fault data.

[0035] From another perspective, the computer-implemented fault predictor has a module arrangement with first and second secondary modules subordinate to the output module. The first and second secondary modules process data from the industrial machine to determine first and second intermediate state indicators. A third secondary module determines operating mode indicators, and the output module processes the state indicators and operating mode indicators to predict faults in the industrial machine. The module arrangement has been trained via cascaded training, which includes training the secondary modules, subsequently operating the trained secondary modules, and subsequently training the output module. Simple Explanation of the Diagram

[0036] Embodiments of the present invention will now be described in detail with reference to the accompanying drawings, wherein: Figures 1A and 1B illustrate the layout of industrial machines and modules; Figure 2 illustrates the module arrangement, which includes hierarchical secondary modules below the output modules; Figure 3 illustrates a time graph combining the operation and fault prediction of industrial machinery; Figure 4 illustrates a time graph combining mode-specific fault intervals in predictions made by the operation and mode-specific modules of industrial machinery. Figure 5 illustrates a block diagram of an industrial machine; Figure 6 illustrates a multivariate time series with historical data; Figure 7 illustrates a simplified timeline for cascaded training; Figure 8 illustrates a simplified time graph of cascaded training in the variant; Figure 9 illustrates a flowchart of a computer-based method for predicting industrial machine failures; Figure 10 illustrates the time sequence of pattern indicators for two patterns, as an example, which can optionally be used to determine the pattern change rate; Figure 11 illustrates a state transition diagram with mode switching; Figure 12 illustrates multiple industrial machines and historical time series with machine data and historical time series with fault data; Figure 13 illustrates different industrial machines in a method for coordinating machine data (and possible fault data Q); Figure 14 illustrates the machine data in a time series, including data provided by sensors and data provided by a data processor; and Figure 15 illustrates a general-purpose computer. Implementation

[0037] [Overview and Writing Conventions()] [Writing conventions] [)] []

[0038] This explanation uses a top-down approach, illustrating the industrial machine and module layout in Figures 1A, 1B, and 2; discussing accuracy using simplified time diagrams in Figures 3 and 4 in conjunction with operating modes; and showing details of the industrial machines in Figure 5. Figure 6 discusses time series data with machine data separated according to operating modes. This explanation then discusses training in conjunction with Figures 7 and 8, and prediction using a flowchart in Figure 9. Other aspects are given in Figures 10 through 15.

[0039] This instruction uses terms such as “running module” or “running computer” to describe computer activities, and uses terms with the word “operation” to describe machine activities. [Industrial Machine and Module Layout] []

[0040] Figures 1A and 1B provide an overview of the method in spatial (Figure 1A) and temporal (Figure 1B) contexts.

[0041] Figure 1A illustrates an industrial machine 113 and its associated computer. Machine 113 provides (current) machine data 153{{X1...XM}}N (or simply {{X...}}N) to the module arrangement (or module unit) 373 as input. Module arrangement 373 provides (current prediction data {Z...}) at its output.

[0042] The symbol “computer” (singular, without figure mark) represents computing functionality or the functionality of a module implemented in a computer. This functionality can be distributed across different physical computers.

[0043] As used in this paper, a “module” is a functional unit (or computational unit) that uses one or more internal variables obtained through training.

[0044] Those skilled in the art are familiar with various such modules, and they are sometimes referred to as "machine learning tools" or "ML tools." This description does not use "ML" or similar terms simply because "M" stands for computer performing computations. As used herein, (industrial) machines relate to machine data X, but the machines themselves do not perform computations.

[0045] The accompanying diagrams, from different perspectives, illustrate a computer system module comprising multiple processing modules, showing the steps of a computer-implemented method executed by the computer system. Industrial machines are not considered computer modules.

[0046] The module implements an algorithm that solves tasks such as regression, classification, and clustering.

[0047] Given its internal structure, the module can be: • Neural network (where the variables are weights, and the symbols in Figure 1A have nodes arranged in a hierarchical manner), • Decision tree structures with a single tree or multiple trees (such as random forests) or other modules.

[0048] Those skilled in the art can implement the internal structure using frameworks (such as Tensorflow), libraries (such as Keras), and programming languages ​​(such as Python, R, or Julia).

[0049] The accompanying diagram also illustrates the possible reception of the forecast data by the operator 193. The operator (or any other person responsible for the industrial machine) may take appropriate measures, such as timely maintenance of the machine, keeping the machine running until a failure is expected, changing operating details to achieve an operating mode in which the failure can be delayed, and so on.

[0050] However, the predicted data {Z...} can also be forwarded to other computers, and the measures can be triggered (semi-)automatically.

[0051] The predicted data {Z...} has several aspects, such as, for example · t_fail_a (earliest future time point expected to occur), · t_fail_b (predicts the latest future time when the failure will occur), • failure_type (failure type indicator, such as by identifying the machine component that will fail), or • A prediction that the machine will operate without failure, at least for a certain time interval in the future.

[0052] Figure 1B illustrates a matrix where rows represent machines, computers, and users, and columns represent time processes (from left to right). Figure 1B can be viewed as Figure 1A tilted 90 degrees.

[0053] In a very simple way, the machine provides machine data, the computer implements methods 702, 802 and 203, and the user receives the prediction data {Z...}. [stage] []

[0054] For convenience, the accompanying drawings and descriptions therefore distinguish at least the following stages: • Preparation phase **1, beginning around time t1, involves collecting data in time series format during which the machine operates; • Training phase **2, implemented at time t2, involves the arrangement of training modules (see method 702 or 802 in Figures 7 and 8), regardless of whether the machine is operating in **2; and • Operation phase **3, indicating the operation of the machine and the collection of data to be used for fault prediction, where t3 is the time for performing prediction in method 203 (see secondary module and output module, Figure 2). [Time Series]

[0055] Data (such as machine data) can be available in the form of time series, that is, a sequence of data values ​​labeled with time order for subsequent time points. Figure 1A introduces the time series through abbreviation symbols (“rounded” rectangle 153) and a matrix below the rectangle, while Figure 1B repeats the rectangle symbols in the context of time.

[0056] The symbol {X1 ... XM} represents a single (i.e., univariate) time series with data elements Xm (or simply "elements"). Elements Xm from time point 1 to time point M are: X1, X2, ..., Xm, ...XM (i.e., "measurement time series"). The suffix m is the time point suffix. Time point m is followed by time point (m+1), which are typically at equal intervals Δt. The symbol {X1...} is an abbreviation.

[0057] An example is the rotational speed of a machine drive at M time points: {1400 ... 1500}. Those skilled in the art can preprocess the data values, for example, to normalize them to [0,1] or {0.2 ... 1}. The data format is not limited to scalars or vectors; {X1 ... XM} can also represent the order of M image or sound samples obtained from time point 1 to time point M.

[0058] The notation {{X1 ... XM}}N (or its abbreviation {{X...}}N) represents a multivariate time series with a data element vector {X_m}N from time point 1 to time point M. The vector has a cardinality N (the number of variables, i.e., the parameters that are available for the data), meaning that at any time point from 1 to M, there are N available data elements. The matrix indicator variable index n is the row index (from x_1 to x_N).

[0059] For example, a single time series on rotation may be accompanied by a single time series on temperature, another single time series on data regarding the chemical composition of the material, or so on.

[0060] Those skilled in the art will understand that this description is simplified. The actual number of variables, N, can reach or even exceed several thousand. Time series are not ideal. Elements may occasionally be missing, but those skilled in the art can handle such situations.

[0061] The choice of time interval Δt and the number of time points M depends on the process or the activities performed by the machine. The total duration of the time series Δt*M (i.e., the window size) corresponds to the machine parameter shift that takes the longest time.

[0062] Since the time point tm specifies the time during which the module arrangement (or its components) processes the data, some data can be preprocessed. For example, a temperature sensor may provide data every minute, but (for example) for Δt = 15 minutes, some data may be discarded, averaged over Δt, or otherwise preprocessed.

[0063] The time series notation {...} is applicable in the following situations: • For example, the machine data {X...} being explained, • In modules, especially in secondary modules, intermediate data {Y...} is developed during computer processing. • Fault prediction data {Z...} at the module layout output. • Fault data {Q...} represents actual or past faults ({Q...} is not a prediction).

[0064] X, Y, Z, and Q data can also be obtained as multivariate time series.

[0065] However, univariate and multivariate time series are just examples of data formats, and those skilled in the art can process data in other formats. [Machine Data] [X]

[0066] As the label indicates, machine data X is related to industrial machines. Data X is processed because the predicted faults are related to machine operation. Since not all variables in the machine data contribute to the prediction, a rough distinction exists based on the relationship between the data source and the machine.

[0067] Machine data can be categorized as: • Data obtained from sensors associated with the machine (“sensor data”), and • Data obtained from other sources (“Additional Data” or “Characteristic Data”).

[0068] Additionally, data can represent the object the machine is processing (having attributes such as object type, object material, load conditions, etc.) or the machine's tools (especially when the tools change over time). Other data can be environmental data during operation (such as temperature). Further examples include maintenance data.

[0069] It's possible to hide sensor data from machine operators or other users because they won't associate specific sensor data with specific meanings. The consequence is that expert users might not be able to label such data. Alternatively, the data might be more publicly available. For example, a sensor reading representing the vibration of a specific component might not have semantic meaning for an expert, but the expert might be very familiar with the effects of ambient temperature on the machine. [Calendar Time] []

[0070] As mentioned, the numeral m is a time point numeral. The symbols in the time series are convenient, and technicians can easily convert the time symbols into actual calendar time points. The time series can be obtained sequentially (Figure 1B has Ω sequential time series), and the calendar intervals can be much longer than Δt*M. [Train and differentiate historical data from current data] []

[0071] Since the module acquires internal variables (such as weights or other machine learning-related variables) by training 702 / 802 with data, this description distinguishes "historical data" from "current data." Historical data is data that can be used to train the module (Figure 1B shows methods 702 and 802 in Figures 7 and 8). Therefore, historical data must be available before training. In other words, the data illustrated to the left of method 702 / 802 will be historical data (historical machine data, historical failure data).

[0072] Figure 1B illustrates the training using a single box 702 / 802, with the width of this box symbolizing the runtime between t2 and t2'. It is possible to repeat training with newly arriving data (i.e., the "increasing" boxes on the right, as shown by the box at t2''). As the amount of historical data increases over time, the module can be retrained (by repeating methods 702 and 802) to achieve more accurate predictive performance.

[0073] Figure 1B illustrates a continuous time series with labels (1), (2)...(Ω). It is convenient to process historical data for a single total duration Δt*M at once (i.e., N*M data values ​​processed as N*M inputs to the training arrangement, plus M data values ​​for Q), but those skilled in the art can apply the data to the module in other ways. The number Ω (of the time series) increases over time.

[0074] Conversely, the current data is data that the trained module can process to predict potential future failures (method 203 in Figure 9). Figure 1B illustrates this with a time series 153 containing {{X...} that will be processed during the execution of prediction method 203. Theoretically, it is possible to process the current data, which actually overlaps with historical data (see the second box at the end of t2''). [Raw Data]

[0075] As shown in the figure, the module arrangement receives raw data, i.e., data that has not yet been processed by the module (except for preprocessing used to harmonize data formats). During training using methods 702 / 802, the module arrangement receives raw historical data and obtains variables (or "weights"). Once trained, the module arrangement in prediction method 203 receives raw current data and provides prediction data {Z...}. Raw data has been mentioned here because during training 702 / 802 and during prediction 203, the arranged modules provide and process intermediate data. Typically, historical data remains historical data, and current data remains current data. [Predicting and distinguishing between the past and the future]

[0076] The runtime of the computer implementing prediction method 203 is negligible / short (compared to M intervals in the time series). Therefore, this specification uses t3 as the earliest time point at which the operator can be notified of the fault prediction {Z...}. Therefore, Figure 1B also illustrates the prediction as a time series. As will be explained in detail below, one element of the fault prediction data {Z...} is the identification of the fault time point (t_fail).

[0077] Starting from t3 (not earlier), the operator can see / know the prediction.

[0078] Future time points can also be given relative to the computer's runtime (see t3 in Figure 3). "Failure Time" marks the interval or duration from t3 to the earliest failure time point.

[0079] The accuracy of the output prediction can be considered as timing accuracy, type accuracy, and so on. These aspects are interrelated. For the sake of brevity, this explanation focuses on improving timing accuracy. [Collecting data for training]

[0080] Figure 1A also shows reference numeral 111 for industrial machines during historical operation, and reference numeral 151 for historical machine data (and historical fault data) in phase **1. It also shows reference numeral 372 for the arrangement of training. [Module Layout]

[0081] Figure 2 illustrates a module arrangement 373 with secondary modules 313, 323, and 333, which (in hierarchy) are subordinate to (relatively higher level) output module 363. Secondary module 333 has the specific function of an operation mode classifier.

[0082] For the sake of brevity, this description uses the label “classifier,” but this label also includes the meaning of “clustering.” Submodule 333 can operate as a classifier (which allocates machine operation time to classes, such as MODE_1 or MODE_2), but module 333 can also operate as a clustering tool (which separates machine operation time based on data observed at different operation times).

[0083] Assigning a specific cluster to a specific pattern is optional.

[0084] For example, module 333 can process data and cluster operation times (i.e., time points m) into first and second clusters. The computer can then automatically assign these clusters to first and second operation modes (used as classes). In other words, there is a semantic difference between "clustering" and "mode". The module observes the machine's operations and distinguishes operation times into (non-overlapping) clusters. There are assignments (first cluster assigned to first mode, second cluster assigned to second mode, etc.), and modes can be set as classification targets. The module can then be trained to distinguish operation times according to the target (no longer clustering, but classifying). In further repetitions with different data, module 333 can then determine whether the machine is operating in the first or second mode.

[0085] Optionally, human experts may selectively participate in assigning clusters to classes (e.g., experts simply provide the pattern names for clusters, experts identify correlations with faults, or so on). Assignments can be more specialized (two clusters may belong to the same pattern). However, in general, human expert involvement is not required. Not involving users can be advantageous. Differences between operating patterns may be "invisible" to experts (or the least detectable, e.g., see Figure 5). In other words, clusters and / or patterns can be hidden from experts. However, differences can affect predictions (and the machine's operation, see Figure 4), and the computer can recognize the existence of such differences. Similarly, differences can be hidden from users but not from the computer.

[0086] Clustering is not mandatory; it is also possible for experts to annotate historical machine data with operational patterns, such as by providing annotations for sensor data. [Different Modules]

[0087] Different modules perform different tasks (such as regression and classification / clustering). Using secondary modules (specifically designed for a particular task) in an arrangement can improve prediction accuracy compared to a single module (i.e., a module without secondary modules). Prediction accuracy will be explained in terms of temporal accuracy with reference to Figures 3 and 4.

[0088] Since module arrangement 373 has several components that can require specific data as input, the following will further explain the alternative methods, including the following: • Compensate for data deficiency by using data from virtual sensors (see the method in Figure 13); • The lack of expert knowledge in distinguishing operational patterns is compensated for by automatically classifying patterns (see Figures 7 and 8, using this automatically acquired data), optionally starting with clustering; • Arrange the modules in a specific training sequence for cascade training (starting with the pattern classifier, see Figures 7 and 8); • Compensate for data deficiency by at least partially simulating at least some of the behavior of industrial machines (see Figure 14) or by otherwise predicting the behavior of machines; • Enhanced training data through manually annotated labels (not further illustrated); • Compensating for data scarcity (or data surplus) by transmitting data, such as by coordinating the availability of data variables when the data to be processed comes from different physical machines (see Figure 13 for an explanation of historical data); or • By training the output module using a bias that indicates the confidence of the input (instead of binary classification), different modules can compete for accuracy (e.g., disjunctive pattern metrics or probabilistic metrics, as explained below).

[0089] From an overall perspective, module arrangement 373 receives machine data 153 from industrial machine 113 (see Figure 1A) and predicts industrial machine failures (data {Z...}).

[0090] Observing its topology, module arrangement 373 includes two or more modules that are secondary to the output module. (Between peer modules) the secondary modules may differ in the following ways: • The source of machine data can be module-specific. For example, secondary modules 313 and 323 can process machine data from different machine components; for example, module 313 can receive {{X...}}N1, which is a subset of {{X...}}N, module 323 can receive a subset {{X...}}N2, and so on (see Figure 2). • The set of weights (or other machine learning variables) applied to the secondary modules during processing can be different. • Intermediate data (such as {Y...}) can also be module-specific. The attached diagram illustrates 1 {Y...} as a first intermediate state indicator at the output of module 313, 2 {Y...} as a second intermediate state indicator at the output of module 323, and 3 {Y...} as an operation mode indicator at the output of operation mode classifier 333.

[0091] Topology affects data availability. When intermediate data becomes available, the output module can process the intermediate data (pipeline structure, from left to right in the attached diagram).

[0092] Topology also affects training. As will be explained below with reference to Figures 7 and 8, secondary modules are trained before the trainable output modules. The same principle applies to hierarchies with additional levels, used for training in the order of sub-sub-sub-modules, sub-sub-modules, and higher-level modules.

[0093] This topology is suitable for individual modules performing different tasks. For example, module 333 provides clustering (or classification to MODE) and thus provides bias to the output module. [The aspect of mixing]

[0094] Referring to Figure 1, this description has introduced modules for performing tasks such as regression, classification, and clustering. Distinguishing tasks is convenient but not core. Predicting fault data {Z...} has a regressive aspect (fault times obtained from consecutive future times) and a classification aspect (fault type or so). Similarly, module 333 can provide pattern indicators, which can be disjunctive (e.g., as a result of classification, or MODE_1 or MODE_2) or can be a probabilistic classifier (details below). [stage]

[0095] Unless otherwise stated, the illustration shows the arrangement of industrial machines and modules during operation phase **3. Training **2 will be explained in conjunction with Figures 7 and 8. For convenience, Figure 2 also illustrates the reference numerals applicable during training: the module arrangement 372 for training, in which secondary modules 312, 322, and 322, as well as output module 362, are all being trained (see Figures 7 and 8 for details).

[0096] Figure 2 also illustrates the optional index derivation module 374, which will be explained in conjunction with Figures 9 and 10. [Timing accuracy in predicting failure time]

[0097] Figure 3 illustrates a time graph combining the operation of industrial machine 113 (Figures 1A and 1B) with fault intervals in fault prediction performed by the module. The module may be a conventional module (without secondary) or a module arrangement 373.

[0098] Horizontal lines indicate the operation of industrial machines in simplified operating scenarios. Scenario 1: The machine continues to operate until it fails when t_fail_1 < t_fail_a. The module does not provide an acceptable indication. Scenario 2: The machine continues to operate until it fails within the predicted failure interval [t_fail_a, t_fail_b]. The module does provide acceptable indications, but the operator decides not to perform maintenance on the machine. • Scenario 3: The machine continues to operate until it fails at t_fail_3 after the predicted failure interval [t_fail_a, t_fail_b]. Scenario 4: The machine operates continuously until maintenance interruption "stops". Maintenance begins shortly before the predicted t_fail_a. The machine resumes operation and will eventually fail at t_fail_4. This is almost an ideal scenario.

[0099] The goal is to make predictions more accurate. The attached figure illustrates this with a modified predicted failure interval [t_fail_a', t_fail_b'], which is shorter than the original interval. Operators can postpone maintenance until shortly before t_fail_a'. This improvement is feasible for module layouts (cascaded modules, see Figure 2).

[0100] The module is deployed to operate at runtime t3 (see Figure 2), and the calculation duration (the time spent by the computer to calculate {Z...}) is negligible. The interval [t_fail_a, t_fail_b] is the predicted failure interval.

[0101] The illustration is simplified; those skilled in the art can derive other measures, in which: • Remaining Useful Life (RUL). Faults are not all the same, and not all types of faults render a machine unusable. For example, a "no oil" indicator on a bearing gives the operator an opportunity to perform maintenance on that bearing, and the machine can continue operating. The operator will obtain the RUL by collecting additional data that indicates faults beyond simple lubrication shortages (such as motor failure). • The time to failure (TTF) will be the interval from t3 to t_fail_a (short TTF) or to t_fail_b (long TTF). • The failure risk, as an indicator of severity, can be derived from t_type (optionally, time should also be taken into consideration).

[0102] As will be explained, a single module receiving data {{X…}}N from virtually all available machine data may provide predictive data {Z...} that is unsuitable for an operator to make appropriate decisions.

[0103] Figure 4 illustrates a time graph combining the operation of an industrial machine (Figure 1A) with the predictions made by the mode-specific module for mode-specific fault intervals.

[0104] The module arrangement can distinguish the predicted fault intervals by mode. The attached figure shows the diagrams for MODE_1 and MODE_2 (t_fail_1, t_fail_2).

[0105] Machine operators can understand operating modes to reflect easily detectable states, such as "ON" (machine is running), "STAND-BY" (machine operates at low energy but does not deliver products), "FULLY-LOADED," and so on. However, the mode is associated with predicted failures, and the operator does not need to know that the machine has switched modes. In fact, the machine is not even required to perform mode switching. The mode is an attribute representing the machine's operation.

[0106] In the simplified example, the machine in MODE_1 will fail earlier than the machine in MODE_2. This information is important to the operator. As illustrated below, at t3 (the operation time of module placement), the operator learns the predicted failure interval, which is for both modes and optionally for a combination of the two modes ("MODE_1 OR _2").

[0107] Until t3, the operator can control the machine to run in MODE_1 or MODE_2, or the machine can operate in any mode without explicit control over a specific mode.

[0108] Possibly, the operator can continue in MODE_2 until t4 (shortly before t_fail_1 regarding MODE_1). Maintenance can be postponed, or from approximately t4 the operator can only allow the machine to operate in MODE_2.

[0109] The diagram is very simplified. During machine operation after t3 (represented by the current data obtained from t3 to t4), the computer will update the prediction. Continuing to operate the machine in MODE_1 (after t3) may shift t_fail (with respect to MODE_1) to the left. Therefore, the operator can decide to switch to MODE_2 only shortly after t3 (rather than at t4).

[0110] It is important to note that the operator does not need to know the mode in advance; they can switch machines to operate in different ways, and the mode indicator will tell them the mode.

[0111] The modular arrangement that differentiates operating modes allows for more accurate identification of (overall) fault intervals. This description, in conjunction with Figure 5, explains the details of improving prediction accuracy, but briefly discusses application scenarios where a combination of fault prediction data {Z...} and pattern recognition data can be used to control the machine. (Semi-)Automatic mode adaptation []

[0112] Figure 4 and its explanation serve as an example for establishing control rules. The machine controller can process the fault prediction data {Z...} (available at t3) into actual control commands to control the machine's operation. Rules can be enhanced by higher-level optimization objectives. For example, for the optimization objective of "avoiding maintenance for as long as possible," the controller will allow the machine to operate in any mode until t4, but from t4 onwards, operation in MODE_1 will not be permitted.

[0113] The involvement of human experts will be minimized (e.g., defining t4 as having some predefined window before t_fail).

[0114] A controller that sends control commands to a machine can change patterns. But essentially at any time, the (trained) module arrangement (or at least its pattern classifier) ​​can establish patterns (or at least clusters) so that commands can be reversed if needed. Alternatively, the controller examines the possible effects of its commands on patterns.

[0115] In other words, the predictions implemented by the arrangement (method 203, see Figure 1B) can be used by forwarding {Z...} to the machine controller, which instructs the machine to adopt the mode in which the failure time is predicted to occur latest, the mode in which the maintenance time occurs latest, or according to other criteria.

[0116] From different perspectives, industrial machines can be associated with machine controllers that switch operating modes based on predefined optimization objectives. The aforementioned criteria can also be written as objectives, such as avoiding maintenance (for as long as possible) or operating the machine in a mode where failure is predicted to occur last (compared to other modes). [Machine Example]

[0117] Figure 5 illustrates a block diagram of industrial machine 110. The machine is fictional in the sense of having symbolic components representing real components in a real machine. Examples of non-fictional machines include chemical reactors, metallurgical furnaces, containers, pumps, motors, and engines.

[0118] Machine 110 has a driver 120. Vibration sensor 130 is attached to the driver and provides signals in the form of a time series {X...}. In this simplified example, the machine data should only include sensor data. The machine uses replaceable tools (or actuators) 140-1 / 140-2. The accompanying drawings symbolize tools by showing the machine operating alternately with tool 1 or tool 2 (“arrow tool” or “triangle tool”). The machine interacts with object 150 (in this example, via the tool). During the interaction, the object should change its shape (e.g., the machine is a metalworking lathe), its position (transportation machine), its color (painting robot), or so on.

[0119] In the simplified illustration of Figure 5, the choice of tools determines the machine configuration (such as the first and second configurations). In more realistic scenarios, machines can have many more components, resulting in a variety of configurations. Configuration complexity increases the complexity of the causal relationships mentioned above, and therefore increases the complexity of fault prediction. For simplicity, this description focuses on vibration as the sole hypothetical cause of possible failures. Mechanical vibration during operation (represented by signals {X...}) is normal. In a very simplified sense, industrial machines emit sounds. Depending on the combination or configuration of tools / objects, the sounds emitted by the machine differ (see different frequency diagrams).

[0120] The accompanying figure also illustrates a very simplified frequency diagram (obtained, for example, by a fast Fourier transform of the sensor signal, as is well known in the art). Of course, the frequency distribution will change over time for various reasons (e.g., the object will change its shape), but the figure provides an approximate view of the main frequencies.

[0121] Generally speaking, vibration should not always lead to failure. However, there are notable exceptions. At the natural frequency (or resonance frequency, fR in this case), vibrations with relatively high amplitudes can increase the risk of failure. Again, this is a simplified explanation: real-world scenarios involve different resonance frequencies.

[0122] As shown in the figure, the machine can vibrate near the resonant frequency using tool 1 (“arrow”), and vibrates at other frequencies using tool 2 (“triangle”). This simplified view does not rule out the risk that the machine will eventually vibrate at fR, but the risk is higher for tool 1. Small variations can occur (in some properties such as the tool’s Young’s modulus, etc.) and the vibration can reach fR.

[0123] Experts in the relevant field might be able to investigate vibrations and find correlations between the use of different tools and frequencies. However, in the real-world scenarios mentioned, industrial machines are far more complex (many different tools, many different objects), and expert knowledge is generally unavailable.

[0124] As will be explained, computers can distinguish operating patterns (or at least cluster operating times), and even patterns that experts cannot distinguish. This description simplifies to first and second operating patterns, and the tool semantics are irrelevant to the computer.

[0125] In this simplified example, the two operating modes are distinguished by different frequency shares. Simply put, for the first mode, the frequency is dominant in the lower band (below fR); while for the second mode, the frequency is dominant in the higher band (above fR).

[0126] Although they have different probabilities, they can reach the resonant frequency in both modes.

[0127] Returning to Figure 2, the operation mode classifier 333 provides the operation mode indicator 3{Y...}. Although this description uses the singular term "indicator," it should be noted that it can change over time. Therefore, it is given as a time series. Examples of how 3{Y...} changes over time are given in Figures 10 and 11.

[0128] In principle, there are multiple options. • The operation pattern classifier 333 can operate as an exclusive classifier, with its output corresponding to the variables of the operation pattern (e.g., pattern 1 XOR pattern 2). Alternatively, in the case of multiple operation patterns, the operation pattern classifier 333 is a predefined set of values ​​from the value set {MODE_1, MODE_2, MODE_3, etc.}. In alternative cases, the number of patterns is not predefined, but determined as the number of clusters. • The operation pattern classifier 333 can operate as a probability classifier, and its output is a variable with the probability of the operation pattern (e.g., 80% for mode 1 and 20% for mode 2). • The operational pattern classifier 333 can be a combination of two: it can be a combination of predefined values ​​and probability ranges. For example, 3{Y...} can be implemented as a vector with two variables, a bivariate time series 3{{Y...}2: the first variable indicates the pattern, and the second variable indicates the probability. For example, for a given time point tm, the probability of the pattern being MODE_1 is 80%. [Optional: Split historical machine data]

[0129] Assuming that the operation pattern classifier 332 / 333 has been trained (see Figure 2), it can, at least through initial training, process historical machine data {{X...}}N (multivariate time series, or {{X...}}N3) into historical machine data in two subsequences. Details will be explained in conjunction with Figures 6 and 8.

[0130] Figure 6 illustrates the historical multivariate time series {{X...}}N as shown in Figure 1B. The operation pattern classifier can distinguish patterns (MODE_1 and MODE_2 in this case) in the operation pattern index 3 {Y...}.

[0131] As a result, the X data can be distributed across two (or more) multivariate time series. In the example, MODE_1 was detected at m = 1, 2, 3, ... and MODE_2 was detected at m = 4, 5, 8, 9.

[0132] Variations are possible. For example, pattern differentiation can be established with only relatively low probability (see the discussion above), and specific data can be assigned to two patterns.

[0133] For pattern-specific time series, the left-out time slots can be ignored, thus the time appears to advance in consecutive time slots. Those skilled in the art can introduce new time counters or the like.

[0134] In this sense, historical data {{X...}}N is transformed into historical data {{X...@1}}N and {{X...@2}}N with pattern annotations. However, supervision by human experts is not required.

[0135] Although not illustrated here, splitting can also be applied to fault data. This will include historical faults that occurred during either Mode 1 or Mode 2 operation.

[0136] In step 852 of Figure 8, split historical machine data (or fault data) can be used.

[0137] Splitting historical data (machine or failure data) can be viewed as clustering. Clustering results in distinguishable time series segments (e.g., distinguished by 3{Y...}). It is convenient to automatically assign specific clusters to specific patterns. The example uses two clusters assigned to two patterns.

[0138] The accompanying diagram illustrates, by way of example only, segm_1 (in MODE_1), segm_2 (in MODE_2), segm_3 (also in MODE_1), segm_4 (also in MODE_2), and so on. Time series segments can have different durations (e.g., segm_1 has 3*Δt, segm_2 has 2*Δt, and so on). The segments are separated into a first cluster with (segm_1, segm_3, ...) and a second cluster with (segm_2, segm_4, ...).

[0139] It is convenient to separate the operating time (of industrial machines) into different clusters because the operating pattern is a function of time (3{...} is a time series). [Re-examine the original data()] [Original data revisited] [)]

[0140] As mentioned above (Figure 1B), a trainable module can be used to process data. During the training module deployment (see Figure 2, which has a two-layer hierarchy), the secondary module transforms the raw data (machine data {X...}, fault data {Q...}, etc.) into intermediate data {Y...}, all of which are historical data. The output module processes the intermediate and raw data, which are also historical data.

[0141] Once the module deployment has been trained, it receives raw data (such as {{X...}}N) and provides predictions {Z...}, which is the current data. However, at least the output module can receive both raw data and intermediate data, both of which are current data.

[0142] The following are advantageous: Higher-level modules (such as output modules) receive a combination of raw data (i.e., unprocessed data) and intermediate data. Intermediate data has a specific function, and The availability of such intermediate data is cascaded (during training and prediction).

[0143] At least one example scenario is given. Because it is difficult for human experts to annotate the raw data, intermediate data (such as pattern indicators) can serve as de facto annotations. The order remains unchanged: the output module will use the de facto annotation as soon as it is available, not earlier.

[0144] The method will be explained with reference to two layers (see Figure 2), but additional layers may be introduced. [Cascade Training()] [Cascaded training] [)]

[0145] Figure 7 illustrates a simplified timeline of cascaded training 702. Thick horizontal lines indicate data availability during training. Vertical arrows indicate data usage during training. Although multiple vertical lines may originate from the same horizontal line, this does not necessarily mean that the same data must be used. Sometimes, reusing data can imply the use of different variables (see {{X...}}N may not come from all N variables, but from different subsets of variables). Once data has been used, it remains available: the horizontal line changes from solid to dashed. It is convenient to reuse data when repeating some training steps.

[0146] Time progresses from left to right, with time point t2 indicating the start of phase **2 and time point t3 indicating the start of operation phase **3 (see Figure 3, t3 marks the computer's execution of the prediction runtime).

[0147] The boxes symbolize method steps 712, 722, and 732, but the width of the boxes is not proportional to the time. On the right, the boxes may have thick vertical lines 742 and 762, which symbolize running the trained (secondary) modules to provide output.

[0148] This description occasionally refers back to Figure 1A (reference numeral 111 for the machine, providing historical machine data 151), Figure 2 (topology, applying reference numeral **2), and Figure 5 (example of a machine with two modes).

[0149] This description uses the term "preliminary" to indicate the optional repetition of method steps. In other words, a single training step may be repeated. For convenience, this description refers to data semantics (e.g., faults at frequency or fR), but computers need not take such semantics into account.

[0150] Historical data is available from the beginning (i.e., before t2). For example, historical data can be in the form of a time series. The attached figure distinguishes historical data into historical fault data {Q...} and historical machine data {{X...}}N (which is received from industrial machine 111 or from different machines).

[0151] Although fault data are given as univariate time series {Q...}, different fault types (i.e. fault variables) can be represented by multivariate time series (such as {{Q...}}). [step] [712 / 742]

[0152] In step 712, the computer uses historical machine data (and optional fault data, not shown) to (preliminarily) train a pattern classifier (i.e., secondary module 333 in Figure 2). Once trained, the operational pattern classifier 333 can use the historical machine data to compute historical pattern indices 3{Y...}. No supervision (i.e., handling expert annotations) is required for this step.

[0153] In step 742, the computer calculates the historical pattern index 3{Y...}. Since the historical machine data {{X...}}N and the historical pattern index 3{Y...} are available synchronously, and the time point tm remains unchanged, the two data points form a data pair (in the sense of the automatically generated annotation, this pair includes the pattern index).

[0154] For example, 3{Y...} can be a time series that indicates alternating operation in mode 1 within the first 24-hour interval and in mode 2 within the second 24-hour interval.

[0155] Identifying the cause (such as using Tool 1 or Tool 2 or other semantics) is not required to be advantageous. The computer uses available data, but supervised training or other forms of expert involvement are not required. [step] [722 / 762]

[0156] In step 722, the computer uses historical machine data {{X...}}N and (optionally) historical pattern indicators 3{Y...} to train secondary modules 313 and 323. Once trained, secondary modules 313 and 323 can provide intermediate state indicators 1{Y...} and 2{Y...}. For example, intermediate state indicators 1{Y...} and 2{Y...} can be values ​​indicating frequency changes, such as increasing or decreasing over time.

[0157] Although the attached figure illustrates this step with a single block, the step is performed separately for the two secondary modules (serially or in parallel).

[0158] In step 762, the computer again uses the historical machine data {{X...}}N to calculate intermediate state indices 1{Y...} and 2{Y...}, which are, of course, historical indices. For example, both intermediate state indices indicate a historical increase in frequency. (Although the semantics are irrelevant.) [step]

[0732]

[0159] Historical fault data Q (real fault data) is available, even from earlier times, but it can potentially be used for comparison with intermediate state indicators. Such fault data can be acquired automatically. In a simplified implementation, the fault will be represented by sensor signals {Q...}, which again serve as a time series indicating the time of the (actually occurring) fault.

[0160] In step 732, the computer uses historical fault data {Q...}, intermediate state indicators 1 {Y...} and 2 {Y...}, and pattern indicator 3 {Y...} to train output module 362.

[0161] Through training, output module 362 is transformed into output module 363 (Figure 2), and the secondary modules are also transformed into modules with reference numeral **3. To maintain the example semantics, module arrangement 373 will be able to detect faults under MODE_1 at elevated frequencies, where t_fail_a and t_fail_b will occur between 10 and 14 hours after the mode change (at frequencies just close to fR). For MODE_2, the frequency is also elevated (but far from fR), and t_fail will be different.

[0162] In other words, by differentiating operating modes, module arrangement 373 can provide improved timing accuracy for predictions. [Cascaded training using split historical data]

[0163] Figure 8 illustrates a simplified time diagram of the cascaded training 802 in the variation of the training explained in Figure 7.

[0164] The steps correspond to those explained in Figure 7, but the computer performs an additional step 852 (to split historical machine data, see Figure 6), and step 722 (in Figure 7) is performed as step 822@1 of secondary modules 312 / 313 and as step 822@2 of secondary modules 322 / 323.

[0165] (In step 812) Once the pattern classifier module has been trained, the computer calculates the historical pattern index 3{Y...} in step 842. As explained in Figure 6, 3{Y...} is then used to split the historical machine data into historical data {{X...@1}}N and {{X...@2}}N with pattern annotations. (Steps 842 and 852 can be implemented in combination.)

[0166] The secondary network is then trained separately (steps 822@1, 822@2) to provide intermediate state indicators 1{Y...} and 2{Y...}.

[0167] It is convenient not to split historical fault data {Q...}. (When the machine is operating in MODE_2, faults caused by the environment under MODE_1 may occur, and vice versa.) [Method Overview]

[0168] Figure 9 illustrates a flowchart of a computer-implemented method 203 for predicting industrial machine failures. In implementing method 203, the computer uses an arrangement of processing modules, such as module arrangement 373 in Figure 2, or an arrangement with additional layers. For convenience, the figure illustrates a flowchart along with symbolic representations of Figure 2 containing data X, Y, and Z.

[0169] In receiving step 213, the computer receives machine data ({{X...}}N) from industrial machine 113 through first, second, and third stage processing modules 313, 323, and 333, which are arranged to provide intermediate data 1{Y...}, 2{Y...}, and 3{Y...} to output processing module 363. Arrangement 373 has been pre-trained through cascade training, see 702 / 802 in Figures 7 and 8.

[0170] The computer uses the first-level module 313 to process machine data 223A to determine the first intermediate state index 1 {Y...}; uses the second-level module 323 to process machine data 223B to determine the second intermediate state index 2 {Y...}; and uses the third-level module 333 (as an operation mode classifier module) to process machine data 223C to determine the operation mode index 3 {Y...}. All three indices are indices of industrial machine 113.

[0171] In processing step 243, the computer processes the first and second intermediate state indices 1{Y...}, 2{Y...} and the operation mode index 3{Y...} via output module 363. Thus, output module 363 predicts the failure of industrial machine 113 by providing prediction data {Z...}. [Operation Example] []

[0172] The module arrangement 373, which now receives the current machine data 153 (see Figures 1 and 2), will identify the mode (module 333) and status indicators (modules 313 and 323) at the actual time point t3 (see Figure 3). [Selection of Machine Data]

[0173] As mentioned, machine data {{X...}} can be sensor data and other data.

[0174] Suppose that human experts cannot select the relevant subset of machine data (for fault prediction). Therefore, the selection (during module training) is done by the module itself. Some machine data can be processed with higher weights, while other sensor data can be processed with lower weights.

[0175] For non-sensor data, human experts have better insight to make choices (in which case, experts can label some data as irrelevant).

[0176] In the implementation, subsets {{X...}}N1 and {{X...}}N2 can be further divided by grouping the time series according to variables, see the symbol element ∈ in Figure 2. [Indicators derived using modules (such as pattern indicators)]

[0177] In modern industrial environments, it is expected that industrial machines will frequently change their operating modes. One reason for this is the trend towards smaller production batches. The mode change rate (the number of mode changes per unit time) can be correlated with failure rates, not for all machines, but for some. [Pattern change as an indicator of derivation pattern]

[0178] Figure 10 illustrates the time sequence with mode indices 3{Y...} for two modes (MODE_1 "Black" and MODE_2 "White"). The time windows (equal durations with a predefined number of time intervals Δt per window) are related to the number of mode changes (from MODE_1 to MODE_2 or vice versa). The method can be considered as a derivation of the mode function over time.

[0179] The computer can determine the pattern change rate by processing the output of the operating pattern classifier (see Figure 2), and this change rate can be an additional input value to the output module 363. The pattern change rate can be calculated based on current data and historical data. To illustrate this optional operation, Figure 2 shows the pattern index derivation module 374 between the classifier 333 and the output module 363.

[0180] Figure 10 simplifies the process by showing only two modes, but mode changes can also be quantified for other scenarios.

[0181] In alternative implementations, the number of time intervals need not be predefined. Clustering is also possible to identify clusters based on different window durations and / or the occurrence of different pattern changes.

[0182] Figure 11 illustrates a state transition diagram (with 5 modes or states) and shows mode transitions. A diagram is applied to a time window (Figure 10) and can indicate the occurrence of mode transitions (e.g., A to B, B to C, C to D, and vice versa). The diagram uses line thickness to symbolize the number of transitions that occur, with D to A being a significant transition. Of course, the number can change during other time windows. Again, the number of transitions occurring for each specific transition can be input to output modules 362 / 363.

[0183] This calculation can be performed, for example, by index derivation module 374 (see Figure 2).

[0184] In alternative implementations, clustering is also possible, such as clustering transformations and, for example, distinguishing modes with high or low sub-mode transformations. [Multiple machines providing historical data]

[0185] Figure 12 illustrates the historical time series of multiple industrial machines 111α, 111β, and 111γ, along with machine data {{X...}}N and fault data {Q...}. For simplicity, not all available labels are used in the figure.

[0186] As mentioned above, data may not be available in sufficient quantities. Therefore, the attached figure illustrates multiple industrial machines providing historical machine data X and historical failure data Q. The figure symbolizes that, under ideal conditions, time series with data would be available in quantities equal to the number of time series per machine multiplied by the number of machines (simplified to have only 3 machines α, β, γ).

[0187] For training in methods 702 / 802, the computer (receiving training arrangement 372) will process the time series {{X...]}}N and the time series {Q...} at N+1 input variables all at once. Then the computer will move on to the next time series.

[0188] Possibly, the computer will process continuous time series (1), (2) to (Ω), such as {{X...}}N and {Q...} in the “single input” mentioned in Figure 1B. Those skilled in the art can arrange repetitions for α, β, and γ, or even have the computer process α{{X...}}N, β{{X...}}N, γ{{X...}}N, α{Q...}, β{Q...}, and γ{Q...} immediately. Other processing options are also available. [Through virtual sensors and transfer learning()] [transfer learning] [) Enhancement and compensation for missing variables]

[0189] Scenarios with multiple machines, such as those described in Figure 12, would ideally operate with machine data (and fault data) from substantially equal sources.

[0190] For example, a univariate time series α{X...}n will be similar to a univariate time series β{X...}n because the sensors for variable n in both machines α and β will be the same type of sensor. However, not all machines are equipped with the same sensors. This description now explains how to handle such limitations.

[0191] Figure 13 illustrates different industrial machines in a method for coordinating machine data (and possible fault data Q). Coordination can be applied to historical data (stage **1) and to current data (stage **3).

[0192] The attached figures repeat industrial machines 111α, 111β, and 111γ (from Figure 12), but point out the different availability of machine data. Machine α should have the usual number of N variables, machine β should be missing one variable (N-1 variables), and machine γ should have a greater number of variables (N+1 variables).

[0193] The attached diagram illustrates data coordinators 382β and 382γ. Data coordinator 382β provides missing data via a virtual sensor (Xn in this case), and data coordinator 382γ filters incoming data (i.e., removes excess data).

[0194] The attached figures are simplified; the lack or excess of data depends on the contribution of specific variables to the prediction. Some machine data (i.e., some variables in that data) are completely irrelevant to predicting failures.

[0195] Both coordinators employ modules that have been pre-trained via transfer learning (in terms of stages, this is **1**). For example, machines α and γ could be master machines to teach coordinator β how to simulate sensor Xn. Alternatively, machines α and β could be master machines used to learn on a specific dataset at a negligible level.

[0196] As shown in the diagram, the coordinator will not change the fault data {Q...}.

[0197] A domain adaptation machine learning model, trained through transfer learning, processes historical machine data (obtained as a multivariate time series from multiple industrial machines of a specific type, but with multiple domains). This historical machine data reflects the state of the corresponding machines across multiple domains. Typically, each machine has hundreds or thousands of sensors measuring operating parameters, such as, for example, temperature, pressure, chemical composition, etc. (see the relatively high number of variables N). Such parameters measured at a specific point in time define the corresponding state of the machine at that point. Due to the multiple characteristics of each machine (e.g., operating mode, size, input materials such as material composition, etc.), it is impossible to directly compare two machines (source machine and target machine) without applying specialized transformations to the multivariate time series data.

[0198] Different transfer learning methods can be used. For example, domain adaptation machine learning models can be implemented using deep learning neural networks with convolutional and / or recurrent layers, trained to extract domain-invariant features from historical machine data as a first domain-invariant dataset. Transfer learning can be implemented to extract domain-invariant features from historical machine data. Features in deep learning are abstract representations of specific machine features extracted from multivariate time series data generated by the operations of that specific machine. By applying transfer learning, it is possible to extract domain-invariant features from multiple real-world machines independent of specific types (i.e., independent of multiple domains).

[0199] In alternative approaches, the domain-adaptive machine learning model is trained to learn multiple mappings from multiple machines to a reference machine corresponding to the original data. The reference machine could be a virtual machine representing some kind of average machine, or it could be an actual machine. Each mapping is a representation of the transformation from the reference machine to the corresponding specific machine. In this method, multiple mappings correspond to a first domain-invariant dataset. For example, such a domain-adaptive machine learning model can be implemented using a generative deep learning architecture based on CycleGAN. This architecture has become popular in various application areas: for generating artificial (or “fake”) images. CycleGAN is an extension of the GAN architecture that involves training two generator models and two discriminator models simultaneously. One generator takes data from the first domain as input and outputs data for the second domain, while the other generator takes data from the second domain as input and generates data for the first domain. The discriminator models are then used to determine the credibility of the generated data and update the generator models accordingly. CycleGAN uses an additional extension to this architecture called cycle consistency. The idea behind this is that the data output by the first generator can be used as input to the second generator, and the output of the second generator should match the original data. Conversely, it is also true: the output from the second generator can be used as input to the first generator, and the result should match the input of the second generator.

[0200] Cycle consistency is a concept from machine translation, where terms translated from English to French should be translated back from French to English and be identical to the original terms. The reverse process should also be true. CycleGAN encourages cycle consistency by adding an additional loss to measure the difference between the output of the generated second generator and the original image (and vice versa). This acts as a regularization of the generator model, thus guiding the image generation process in the new domain toward image translation. To adapt the original CycleGAN architecture from image processing to processing multivariate time series data for obtaining first-domain invariant datasets, the following modification can be implemented, which is to learn the temporal dependencies of multivariate time series data by using recurrent layers (for example, LSTM) combined with convolutional layers, as described in detail in C. Schockaert, H. Hoyez, (2020) “MTS-CycleGAN: An Adversarial-based Deep Mapping Learning Network for Multivariate Time Series Domain Adaptation Applied to the Ironmaking Industry”, In arXiv: 2007.07518.

[0201] An overview of transfer learning can be found in the following literature: Fuzhen Zhuang, Zhiyuan Qi, Keyu Duan, Dongbo Xi, Yongchun Zhu, Hengshu Zhu, Hui Xiong, Qing He: "A Comprehensive Survey on Transfer Learning" arXiv:1911.02685. [Through simulation compensation]

[0202] Figure 14 illustrates machine data in a bivariate time series {{X..}N where N=2, with the first time series provided by sensor 135 (as in normal cases, see sensor 130 in Figure 5) and the second time series provided by data processor 165.

[0203] For example, a tool (140 in Figure 5) may become dull over time. There may not be a sensor available to measure this, and setting up a virtual sensor may also be difficult (the main sensor may be missing because it is difficult to measure sharpness).

[0204] The data processor 165 can be implemented by a computer using formulas developed by experts. For example, human experts can correlate existing data with calculations of the decrease in sharpness over time (and therefore with the point in time when the tool must be replaced (or sharpened)). Such data may include, for example, the time the tool has been inserted into the machine, the number of operations, or the number of objects.

[0205] In an alternative implementation, the data processor 165 may be implemented as a computer performing the simulation. In this sense, the computer can operate as described above, not to predict the failure of the machine as a whole, but to predict the failure of the tool (“no longer sharp” being the failure condition). Setting up a simulator may require only minimal interaction with human experts.

[0206] The principle of fault detection described above can also be applied to machine parts. Tools will eventually fail. There are two consequences: First, tool failure is a specific type of failure (and can be predicted accordingly). Secondly, tool malfunctions can be simulated and used as input. Pattern-Specific Training

[0207] Figure 7, combined with Figure 8, illustrates the secondary modules that can be trained separately for different modes.

[0208] Suppose there are two sub-modules (as shown in Figure 2). The pattern classifier can distinguish historical data based on the pattern, so that the first module is trained with MODE_1 data and the second module is trained with MODE_2 data.

[0209] For the current data, both modules will provide intermediate state indicators (such as 1{Y...} and 2{Y...}) and will not receive mode indications (see Figure 2). Therefore, each time the machine operates in MODE_2, the first module will generate "garbage" (and vice versa for the second module). However, since the operating mode classifier 333 provides mode indicators (current data) 3{Y...}, the output network (if trained) will ignore some intermediate data.

[0210] More generally, when the pattern classifier module performs clustering, the number of clusters can be more than two. It is possible to dynamically add or remove secondary modules (not from the pattern classifier) ​​based on the number of pattern clusters. [Pattern-Specific Bias]

[0211] According to the topology in Figure 2, the operation mode index 3{Y...} is directed to the output module 363. In the implementation, the index can also be used as the deviation between secondary modules 313 and 323. [General-purpose computer] []

[0212] Figure 15 illustrates an example of a general-purpose computer device that can be used with the techniques described herein. The accompanying figure is a diagram illustrating examples of a general-purpose computer device 900 and a general-purpose mobile computer device 950 that can be used with the techniques described herein. Computing device 900 is intended to represent various forms of digital computers, such as laptops, desktops, workstations, personal digital assistants, servers, blade servers, mainframes, and other suitable computers. Computing device 950 is intended to represent various forms of mobile devices, such as personal digital assistants, cellular phones, smartphones, vehicle driver assistance systems or in-vehicle computers, and other similar computing devices. For example, a user (e.g., an operator of an industrial machine) may use computing device 950 as a front end to interact with computing device 900. The components, their connections and relationships, and their functions shown herein are intended to be exemplary only and are not intended to limit the implementation of the inventions described and / or claimed herein.

[0213] Computing device 900 includes a processor 902, memory 904, storage device 906, a high-speed interface 908 connected to memory 904 and a high-speed expansion port 910, and a low-speed interface 912 connected to a low-speed bus 914 and storage device 906. Each component 902, 904, 906, 908, 910, and 912 is interconnected using multiple buses and may be mounted on a common motherboard or otherwise. Processor 902 processes instructions for execution within computing device 900, including instructions stored in memory 904 or storage device 906, to display graphical messages for a GUI on an external input / output device, such as a display 916 coupled to high-speed interface 908. In other embodiments, multiple processors and / or multiple buses, as well as multiple memories and memory types, may be used as appropriate. Furthermore, multiple computing devices 900 may be connected, each providing a portion of the necessary operation (e.g., as a server group, blade server group, or multiprocessor system).

[0214] Memory 904 stores information within computing device 900. In one embodiment, memory 904 is one or more volatile memory cells. In another embodiment, memory 904 is one or more non-volatile memory cells. Memory 904 may also be another form of computer-readable medium, such as a magnetic disk or optical disk.

[0215] Storage device 906 provides large-capacity storage for computing device 900. In one embodiment, storage device 906 may be or includes computer-readable media, such as floppy disk devices, hard disk devices, optical disk devices, or magnetic tape devices, flash memory or other similar solid-state memory devices, or device arrays, including devices in a storage area network or other configuration. The computer program product may be tangibly implemented in a message carrier. The computer program product may also include instructions that, when executed, perform one or more methods, such as those described above. The message carrier is a computer or machine-readable medium, such as memory 904, storage device 906, or memory on processor 902.

[0216] High-speed controller 908 manages bandwidth-intensive operations for computing device 900, while low-speed controller 912 manages less bandwidth-intensive operations. This functional assignment is merely exemplary. In one embodiment, high-speed controller 908 is coupled to memory 904, display 916 (e.g., via a graphics processor or accelerator), and to a high-speed expansion port 910 that accepts various expansion cards (not shown). In another embodiment, low-speed controller 912 is coupled to storage device 906 and low-speed expansion port 914. The low-speed expansion port may include various communication ports (e.g., USB, Bluetooth, Ethernet, Wireless Ethernet) and may be coupled to one or more input / output devices, such as keyboards, pointing devices, scanners, or network devices, such as switches or routers, coupled via network adapters.

[0217] As shown in the accompanying drawings, computing device 900 can be implemented in a variety of different forms. For example, it can be implemented as a standard server 920 or as multiple servers in a group. It can also be implemented as part of a rack-mounted server system 924. Alternatively, it can be implemented in a personal computer, such as a notebook computer 922. Alternatively, components from computing device 900 can be combined with other components in a mobile device (not shown), such as device 950. Each of such devices can contain one or more of computing devices 900, 950, and the entire system can consist of multiple computing devices 900, 950 communicating with each other.

[0218] In addition to other components, computing device 950 specifically includes processor 952, memory 964, input / output devices (such as display 954), communication interface 966, and transceiver 968. Device 950 may also provide storage devices (such as microdrives or other devices) to provide additional storage. Each of components 950, 952, 964, 954, 966, and 968 is interconnected using multiple buses, and some components may be mounted on a common motherboard or otherwise, as appropriate.

[0219] Processor 952 can execute instructions within computing device 950, including instructions stored in memory 964. The processor can be implemented as a chipset comprising individual and multiple analog and digital processors. For example, the processor can provide coordination for other components of device 950, such as control of the user interface, applications running on device 950, and wireless communications of device 950.

[0220] Processor 952 can communicate with the user via control interface 958 and display interface 956 connected to display 954. For example, display 954 may be a TFT LCD (Thin Film Liquid Crystal Display) or OLED (Organic Light Emitting Diode) display or other suitable display technology. Display interface 956 may include suitable circuitry for driving display 954 to present graphics and other information to the user. Control interface 958 can receive commands from the user and translate those commands for submission to processor 952. Additionally, an external interface 962 may be provided to communicate with processor 952 to enable near-field communication between device 950 and other devices. For example, external interface 962 may be provided for wired communication in some embodiments, or for wireless communication in others, and multiple interfaces may be used.

[0221] Memory 964 stores information within computing device 950. Memory 964 may be implemented as one or more computer-readable media, one or more volatile memory cells, or one or more non-volatile memory cells. Extended memory 984 may also be provided and connected to device 950 via an extended interface 982, for example, the extended interface 982 may include a SIMM (Single In-line Memory Module) card interface. Such extended memory 984 may provide additional storage space for device 950, or may store applications or other information for device 950. Specifically, extended memory 984 may include instructions for performing or supplementing the processes described above, and may also include security messages. Thus, for example, extended memory 984 may function as a security module for device 950 and may be programmable with instructions that allow secure use of device 950. Furthermore, secure applications and additional messages, such as immutable identification information placed on the SIMM card, may be provided via a SIMM card.

[0222] As discussed below, for example, memory may include flash and / or NVRAM memory. In one embodiment, a computer program product is tangibly embodied in a message carrier. The computer program product contains instructions that, when executed, perform one or more methods, such as those described above. The message carrier is a computer-readable or machine-readable medium, such as memory 964, extended memory 984, or memory on processor 952, which may be received, for example, on transceiver 968 or external interface 962.

[0223] Device 950 can communicate wirelessly via communication interface 966, which may include digital signal processing circuitry if necessary. Communication interface 966 provides communication for various modes or protocols, particularly such as GSM voice calls, SMS, EMS or MMS messages, CDMA, TDMA, PDC, WCDMA, CDMA2000, or GPRS. For example, such communication can occur via radio frequency transceiver 968. Additionally, short-range communication can occur, such as using Bluetooth, WiFi, or other transceivers (not shown). Furthermore, GPS (Global Positioning System) receiver module 980 can provide device 950 with additional navigation and location-related wireless data, which may be used by applications running on device 950, as appropriate.

[0224] Device 950 can also communicate audibly using audio codec 960, which can receive spoken messages from a user and convert them into usable digital messages. Similarly, audio codec 960 can generate audible sounds for the user, such as through a speaker in, for example, the handset of device 950. Such sounds may include sounds from voice telephone calls, recorded sounds (e.g., voice messages, music files, etc.), and sounds generated by applications operating on device 950.

[0225] As shown in the accompanying drawings, the computing device 950 can be implemented in several different forms. For example, it can be implemented as a cellular telephone 980. It can also be implemented as a smartphone 982, a personal digital assistant, or part of another similar mobile device.

[0226] The various implementations of the systems and technologies described herein can be achieved using digital electronic circuits, integrated circuits, specially designed ASICs (application-specific integrated circuits), computer hardware, hardware, software, and / or combinations thereof. These various implementations may include implementation as one or more computer programs that are executable and / or interpretable on a programmable system, including at least one programmable processor, at least one input device, and at least one output device. The programmable processor may be a dedicated or general-purpose processor coupled to receive data and instructions from and transfer data and instructions to a storage system.

[0227] These computer programs (also referred to as programs, software, software applications, or code) include machine instructions for programmable processors and may be implemented in high-level procedural and / or object-oriented programming languages, and / or in assembly / machine language. As used herein, the terms “machine-readable medium” and “computer-readable medium” refer to any computer program product, apparatus, and / or device (e.g., magnetic disk, optical disk, memory, programmable logic devices (PLDs)) used to provide machine instructions and / or data to a programmable processor, including machine-readable media that receive machine instructions as machine-readable signals. The term “machine-readable signal” refers to any signal used to provide machine instructions and / or data to a programmable processor.

[0228] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to the user and a keyboard and pointing device (e.g., a mouse or trackball) through which the user can provide input to the computer. Other types of devices may also be used to provide interaction with the user; for example, feedback provided to the user may be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user may be received in any form, including sound, speech, or tactile input.

[0229] The systems and technologies described herein can be implemented in computing devices that include back-end components (e.g., as a data server), middleware components (e.g., an application server), or front-end components (e.g., a client computer with a graphical user interface or a web browser through which a user can interact with embodiments of the systems and technologies described herein), or any combination of such back-end, middleware, or front-end components. Components of the system can be interconnected via any form of digital data communication or medium (e.g., a communication network). Examples of communication networks include local area networks (“LANs”), wide area networks (“WANs”), and the Internet.

[0230] A computing system may include clients and servers. Clients and servers are generally remote to each other and typically interact via a communication network. The relationship between clients and servers is established by computer programs running on the respective computers and having client-server relationships with each other.

[0231] Several embodiments have been described. However, it will be understood that various modifications can be made without departing from the spirit and scope of the invention.

[0232] Furthermore, the logical flow depicted in the accompanying drawings does not require a specific order or sequence of steps to achieve the desired result. Additionally, other steps may be provided, or steps may be omitted from the described flow, and other components may be added to or removed from the described system. Accordingly, other embodiments are within the scope of the appended claims.

[0233] 110: Machine 111: Industrial Machines 111α: Industrial machinery 111β: Industrial machinery 111γ: Industrial machinery 113: Industrial machinery 120: Driver 130: Vibration sensor 135: Sensor 140-1: Tools 140-2: Tools 150: Object 151: Machine Data 153: Machine Data 165: Data Processor 193: Operator 203: Prediction Methods 213: Steps 223A: Processing 223B: Processing 223C: Processing 243: Steps 312: Secondary Module 313: Secondary Module 322: Secondary Module 323: Secondary Module 332: Operation Mode Classifier 333: Operation Pattern Classifier 362: Output Module 363: Output Module 372: Module Layout 373: Module Layout 374: Indicator Derivation Module 382β: Coordinator 382γ: Coordinator 702: Training 712: Steps 722: Steps 732: Steps 742: Steps 762: Steps 802: Training 812: Steps 822@1: Steps 822@2: Steps 832: Steps 842: Steps 862: Steps 900: Computing devices 902: Processor 904: Memory 906: Storage devices 908: High-speed interface 910: High-speed expansion port 912: Low-speed interface 914: Low-speed bus 916: Monitor 920: Standard Server 922: Laptop computer 924: Rack-mounted server system 950: Equipment 952: Processor 954: Monitor 956: Display Interface 958: Control Interface 960: Audio Codec 962: External Interface 964: Memory 966: Communication Interface 968: Transceiver 980: Receiver Module 982: Expansion Interface

Claims

1. A computer-implemented method (203) for predicting faults in an industrial machine (113), the method using an arrangement (373) of processing modules (313, 323, 333, 363), the method (203) comprising: Machine data ({{X...}}N) from the industrial machine (113) is received by first, second, and third stage processing modules (313, 323, 333), which are arranged to provide intermediate data (1{Y...}, 2{Y...}, 3{Y...}) to the output processing module (363), wherein the arrangement (373) has been trained in advance by cascade training (702 / 802); the machine data is processed (223A) by the first stage processing module (313) to determine a first intermediate state indicator (1{Y...}); the machine data is processed (223B) by the second stage processing module (323) to determine a second intermediate state indicator (2{Y...}); The third-level processing module (333) is an operation mode classifier module, which processes (223C) the machine data to determine the operation mode index (3{Y...}) of the industrial machine (113); and the output processing module (363) processes (243) the first and second intermediate state indices (1{Y...}, 2{Y...}) and the operation mode index (3{Y...}), wherein the output processing module (363) predicts the failure of the industrial machine (113) by providing prediction data ({Z...}) in a regression or classification manner; wherein the computer uses the arrangement (373) that has been trained according to the following training order: training (712, 812) the third-level processing module (333) with historical machine data ({{X...}}N); Run (742) the trained third-level processing module (333) to obtain historical pattern indicators (3{Y...}) by processing historical machine data ({{X...}}N); train (722, 822) the first and second-level processing modules (312, 322) with historical machine data ({{X...}}N) and with the historical pattern indicators (3{Y...}); run (762, 862) the trained first and second-level processing modules (312, 322) to obtain the first and second intermediate state indicators (1{Y...}, 2{Y...}) by processing historical machine data ({{X...}}N); and train (732, 832) the output processing module (362) with the historical pattern indicators, with historical machine data and with historical fault data ({Q...}).

2. The method according to request item 1, wherein, The determination of the operation pattern index (3{Y...}) is performed by the operation pattern classifier (333) that has been trained on historical machine data that has been annotated by human experts.

3. The method according to request item 2, wherein, The historical machine data annotated by experts is sensor data.

4. The method according to request item 1, wherein, The operation pattern classifier (333) has been trained based on historical machine data, such that during training, the operation pattern classifier (333) has clustered the machine operation time (tm) into clusters of time series segments (segm_1 / 3, segm_2 / 4).

5. The method according to request item 4, wherein, The clusters (segm_1 / 3, segm_2 / 4) of the time series segments are assigned to operating mode indicators (MODE_1, MODE_2), the assignment being selected from automatic assignment or assignment through interaction with human experts.

6. The method according to any one of claims 1 to 5, wherein, The operating mode indicator is provided by the number of times the mode changes over time.

7. The method according to any one of claims 1 to 5, wherein, The state indicators (1{Y...}, 2{Y...}) are selected from current indicators that indicate the current state and predictive indicators that indicate the future state.

8. The method according to any one of claims 1 to 5, wherein, The output processing module (363) predicts the failure of the industrial machine, and the prediction is selected from the following: failure time, failure type, remaining service life, and failure interval.

9. The method according to any one of claims 1 to 5, wherein, The operation mode index (3{Y...}) is also used as the deviation between the processing by the first and second level processing modules (313, 323).

10. The method according to any one of claims 1 to 5, wherein, Receiving machine data is performed by receiving a subset of sensor data; and wherein determining the first and second intermediate state indicators is performed by the first and second level processing modules that process the subset of sensor data.

11. The method according to any one of claims 1 to 5, wherein, Receiving machine data (213) includes receiving machine data through data coordinators (382β, 382γ), which provide virtual machine data or filter incoming machine data through virtual sensors based on the contribution of the machine data to the fault prediction.

12. The method according to request item 11, wherein, Receiving machine data (213) through the data coordinator (382β, 382γ) includes receiving machine data from a coordinator with a processing module that has been pre-trained by transfer learning.

13. The method according to any one of claims 1 to 5, wherein, Receiving machine data (213) includes receiving machine data that has been at least partially enhanced by data generated by simulation.

14. A method for predicting the failure of an industrial machine (113), the method being implemented by the computer according to any one of claims 1 to 13, by forwarding prediction data ({Z...}) to a machine controller that controls the machine.

15. The method for predicting the failure of an industrial machine (113) according to claim 14, wherein, The machine controller instructs the industrial machine to adopt a mode in which the failure time is predicted to occur at the latest.

16. The method for predicting the failure of an industrial machine (113) according to claim 14, wherein, The machine controller causes the industrial machine to adopt the mode in which the machine maintenance time occurs latest.

17. An industrial machine (113) adapted to provide machine data ({{X...}}N) to a computer, the computer being adapted to perform the method according to any one of claims 1 to 13 and further adapted to receive prediction data ({Z...}) from the computer, wherein, The industrial machine (113) is associated with a machine controller that switches the operating mode of the industrial machine according to a predefined optimization objective.

18. The industrial machine (113) according to claim 17, wherein, The predefined optimization objectives are selected from the following: avoid maintenance for as long as possible, and operate in a mode where fault prediction is the latest occurrence.

19. The industrial machine (113) according to claim 17 or 18, which is selected from chemical reactors, metallurgical furnaces, containers, pumps, motors and engines.

20. A computer-implemented method (702 / 802) for training a module arrangement (372) having first, second, and third secondary processing modules (312, 322, 332) connected to an output processing module (362) such that the module arrangement (372) can provide fault indicators ({Z...}) with fault prediction for industrial machines, the method comprising applying cascaded training to train the secondary processing modules (312, 322, 332), subsequently operating the trained secondary processing modules, and subsequently training the output processing module, wherein, The cascaded training includes: training (712, 812) the third-level processing module (332) with historical machine data ({{X...}}N); running (742) the trained third-level processing module (333) to obtain a historical pattern index (3{Y...}) by processing the historical machine data ({{X...}}N); and training (722, 822) the first and second-level processing modules (312, 322) with historical machine data ({{X...}}N) and the historical pattern index (3{Y...}). Run (762, 862) the trained first and second level processing modules (312, 322) to obtain the first and second intermediate state indices (1{Y...}, 2{Y...}) by processing historical machine data ({{X...}}N); and train (732, 832) the output processing module (362) by the historical pattern indices, by the historical machine data and by the historical fault data ({Q...}).

21. A computer program product, when loaded into the memory of a computer system and executed by at least one processor of the computer system, causes the computer system to perform the steps of a computer-implemented method according to any one of claims 1 to 13 or claim 20.

22. A computer system comprising a plurality of processing modules, wherein when the modules are executed by the computer system, the modules perform the steps of a computer-implemented method according to any one of claims 1 to 13 or claim 20.

23. An industrial machine (113) including a computer, said computer being adapted to process machine data ({{X...}}N) by performing the method according to any one of claims 1 to 13, and said computer being further adapted to provide predictive data ({Z...}), wherein, The computer responds to the predicted data and switches the operating mode of the industrial machine according to a predefined optimization objective selected from the following: avoiding maintenance for as long as possible, and operating in the mode where the latest failure is predicted.

Images