Artificial intelligence-based alarm information correlation processing method

Abstract

This invention discloses an artificial intelligence-based alarm information association processing method. The method includes: acquiring alarm information and preprocessing the alarm information; performing association analysis on different alarm items of the alarm information based on artificial intelligence algorithms to construct association rules between the alarm items; the association rules are used to characterize whether there is a correlation between the occurrence of alarm items; and compressing and filtering the alarm information based on the association rules between the alarm items. This invention provides an artificial intelligence-based alarm information association processing method that uses association rule mining technology to find causal relationships between alarms and compresses and filters alarm information according to the association rules, thereby reducing the existence of nuisance alarms.

Description

Technical Field

[0001] This invention relates to the field of intelligent alarm technology, and in particular to an alarm information association processing method based on artificial intelligence. Background Technology

[0002] In the field of industrial safety, alarm systems have always played a crucial role. Their purpose is to ensure workplace safety, prevent potential hazards in a timely manner, and provide a rapid response in the event of an emergency. In the past, when Distributed Control Systems (DCS) were not widely adopted, alarm systems primarily relied on hard-wiring technology. At that time, installing a new alarm was not only costly, but the number of alarms that could be installed was also greatly limited due to limited panel space. Therefore, only the most critical alarms were installed, and any addition of a new alarm required a rigorous justification and approval process.

[0003] With the rapid development of technology, the close integration of alarm systems and DCS has brought about tremendous changes. The ease with which new alarm devices can be configured in modern industry has led to the installation of a large number of alarm devices, many of which have not been properly optimized. This results in operators having to handle a large number of alarms, many of which are useless nuisance alarms that provide no new information and require no action.

[0004] The presence of disruptive alarms can cause operators to miss critical alarms during a flood of alerts, as they become overwhelmed by a large number of useless alarms. Identifying and managing disruptive alarms becomes crucial. Especially in nuclear power plant applications, with the increasing complexity of nuclear power plant systems, traditional alarm systems face significant challenges in providing effective early warnings and responding to various operating states and potential faults. Inadequate alarm management is one of the main causes of unplanned shutdowns and potential accidents and hazards in nuclear power plants. Summary of the Invention

[0005] The technical problem to be solved by the present invention is to overcome the above-mentioned defects in the prior art and provide an alarm information association processing method based on artificial intelligence.

[0006] The present invention solves the above-mentioned technical problems through the following technical solution:

[0007] This invention provides an alarm information association processing method based on artificial intelligence, the alarm information association processing method comprising:

[0008] Acquire alarm information and preprocess the alarm information;

[0009] Based on artificial intelligence algorithms, correlation analysis is performed on different alarm items in the alarm information to construct correlation rules between the alarm items; the correlation rules are used to characterize whether there is a correlation between the occurrence of alarm items.

[0010] The alarm information is compressed and filtered based on the association rules between the alarm items.

[0011] Preferably, the preprocessing step for the alarm information includes:

[0012] Identify and suppress disturbing alarm signals in the alarm information.

[0013] Preferably, the step of identifying disturbance alarm information in the alarm information includes:

[0014] Calculate the dynamic disturbance index of the alarm signals in the alarm information to identify the disturbed alarm signals in the alarm information; the dynamic disturbance index is used to characterize the time difference and the number of occurrences between alarm signals within a preset time period.

[0015] Preferably, the alarm information includes several alarm transactions; the alarm transactions include several alarm items; and the artificial intelligence algorithm includes a frequent pattern growth algorithm.

[0016] The steps for performing correlation analysis on different alarm items based on artificial intelligence algorithms include:

[0017] Calculate the support of all alarm items in the alarm information to determine frequent alarm items; the frequent alarm items are used to characterize alarm items whose support is greater than a preset support threshold.

[0018] Frequent alarm items in each alarm transaction are sequentially inserted into the alarm frequency pattern tree, and the count of the frequent alarm items appearing in the alarm information is maintained; each node of the alarm frequency pattern tree represents an alarm item.

[0019] Preferably, the step of constructing the association rules between the alarm items includes:

[0020] The conditional pattern base is constructed upwards from the most frequent alarm item with the lowest support in the frequent alarm pattern tree, so as to create a conditional frequent pattern tree for each conditional pattern base.

[0021] Recursively mine all frequent patterns in the frequent pattern tree for each condition to obtain the association rules between the alarm items; the frequent pattern is used to characterize the correlation between the occurrence of alarm items of that frequent pattern.

[0022] Preferably, the alarm information includes several alarm transactions; the alarm transaction includes several alarm items; and the artificial intelligence algorithm includes the ECLAT algorithm.

[0023] The steps for constructing association rules between different alarm items based on artificial intelligence algorithms include:

[0024] Each alarm item in the alarm information is associated with the alarm transaction in which it appears, so as to obtain an alarm transaction list for each alarm item;

[0025] Calculate the support of all alarm items to identify frequent alarm items; the frequent alarm items are used to characterize alarm items whose support is greater than a preset support threshold.

[0026] A first frequent alarm itemset is generated by intersecting the alarm transaction lists of each alarm item, and a second frequent alarm itemset is generated by intersecting the alarm transaction lists of the first frequent itemset; the support of the frequent alarm itemset is calculated by the length of the intersection result.

[0027] The process of recursively intersecting the alarm transaction list is continued to generate all alarm frequent itemsets that meet the preset minimum support threshold; the alarm frequent itemsets are used to characterize the correlation between the occurrence of alarm items in the alarm frequent itemsets.

[0028] Preferably, the step of compressing and filtering the alarm information based on the association rules between the alarm items includes:

[0029] Similar alarm information is merged based on the association rules between the alarm items; the similar alarm information reflects the same problem or the same type of fault; and / or,

[0030] The priority of alarm information is ranked based on the strength of the association rules between the alarm items; the strength of the association rules includes at least one of support, confidence, or lift; and / or,

[0031] Based on the association rules between the alarm items, similar alarm information that occurs frequently is aggregated.

[0032] The present invention also provides a nuclear power plant alarm analysis method, the nuclear power plant alarm analysis method comprising:

[0033] The alarm information association processing method based on artificial intelligence, as described above, is used to associate and process alarm information from nuclear power plants.

[0034] Nuclear power plant faults are analyzed and processed based on the nuclear power plant alarm information after correlation processing.

[0035] The present invention also provides a computer program product, including a computer program, which, when executed by a processor, implements the alarm information association processing method based on artificial intelligence as described above or the nuclear power plant alarm analysis method as described above.

[0036] The present invention also provides an electronic device, including a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it implements the alarm information association processing method based on artificial intelligence as described above or the nuclear power plant alarm analysis method as described above.

[0037] The positive and progressive effects of this invention are as follows:

[0038] The alarm information association processing method based on artificial intelligence provided by this invention finds the causal relationship between alarms by using association rule mining technology, and compresses and filters alarm information according to association rules, thereby reducing the existence of nuisance alarms, one of the main causes of alarm floods. Attached Figure Description

[0039] To more clearly illustrate the technical solutions of the embodiments in this specification, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are merely some examples or embodiments of this specification. For those skilled in the art, these drawings can be applied to other similar scenarios without creative effort. Unless obvious from the context or otherwise specified, the same reference numerals in the drawings represent the same structures or operations.

[0040] Figure 1 This is a schematic diagram of the alarm process in an existing alarm system.

[0041] Figure 2 This is a schematic diagram of the first process of the alarm information association processing method based on artificial intelligence in Embodiment 1 of the present invention.

[0042] Figure 3 This is a schematic diagram of the second process of the alarm information association processing method based on artificial intelligence in Embodiment 1 of the present invention.

[0043] Figure 4a , 4b 4c, 4d, 4e, 4f, 4g, 4h, 4i, and 4j are schematic diagrams of multiple FP trees in Example 1;

[0044] Figure 5 This is a schematic diagram comparing the computation time and memory usage of the Fp-Growth algorithm and the Eclat algorithm in Embodiment 1 of the present invention.

[0045] Figure 6This is a schematic diagram comparing the generated rule results of the Fp-Growth algorithm and the Eclat algorithm in Embodiment 1 of the present invention.

[0046] Figure 7 This is a schematic diagram illustrating the core principle of deep learning in Embodiment 1 of the present invention.

[0047] Figure 8 This is a schematic diagram illustrating the core principle of the support vector machine in Embodiment 1 of the present invention.

[0048] Figure 9 This is a schematic diagram of the confusion matrix of the evaluation classification model in Embodiment 1 of the present invention.

[0049] Figure 10 This is a schematic diagram of creating a time vector in Embodiment 1 of the present invention.

[0050] Figure 11 This is a schematic diagram of the binary alarm matrix in Embodiment 1 of the present invention.

[0051] Figure 12 This is a schematic diagram of the travel calculation of the binary alarm matrix in Embodiment 1 of the present invention.

[0052] Figure 13 This is the histogram of the travel distribution in Embodiment 1 of the present invention.

[0053] Figure 14 This is a schematic diagram showing the normalization of the travel distribution to obtain a discrete probability function in Embodiment 1 of the present invention.

[0054] Figure 15 This is a schematic diagram of the dynamic disturbance index iteration in Embodiment 1 of the present invention.

[0055] Figure 16 This is a schematic diagram of the vector of dynamic disturbance index obtained by iterative dynamic disturbance index in Embodiment 1 of the present invention.

[0056] Figure 17 This is a schematic diagram of the simulation results of the initial performance test of three algorithms, namely logistic regression, deep learning and support vector machine, in Embodiment 1 of the present invention.

[0057] Figure 18 This is a schematic diagram of the confusion matrix used in the initial performance test of three algorithms—logistic regression, deep learning, and support vector machine—in Embodiment 1 of the present invention.

[0058] Figure 19 This is a schematic diagram of the simulation results of the re-performance test of three algorithms, namely logistic regression, deep learning and support vector machine, in Embodiment 1 of the present invention.

[0059] Figure 20This is a schematic diagram of the confusion matrix used in Embodiment 1 of the present invention to retest the performance of three algorithms: logistic regression, deep learning, and support vector machine.

[0060] Figure 21 This is a first schematic diagram showing how the accuracy, recall, and precision of logistic regression change with a threshold in Embodiment 1 of the present invention.

[0061] Figure 22 This is a second schematic diagram showing the changes in accuracy, recall, and precision of logistic regression with respect to a threshold in Embodiment 1 of the present invention.

[0062] Figure 23 This is a schematic diagram of the electronic device in Embodiment 3 of the present invention. Detailed Implementation

[0063] The present invention will be further illustrated by way of embodiments below, but the present invention is not limited to the scope of the embodiments described herein.

[0064] In this document, the term "embodiment" means that a particular feature, structure, or characteristic described in connection with an embodiment may be included in at least one embodiment of this application. The appearance of this phrase in various places throughout the document does not necessarily refer to the same embodiment, nor is it a separate or alternative embodiment mutually exclusive with other embodiments. It will be explicitly and implicitly understood by those skilled in the art that the embodiments described herein can be combined with other embodiments.

[0065] It should be understood that the terms “device,” “system,” “unit,” and / or “module” used herein are one way to distinguish different components, elements, parts, sections, or assemblies at different levels. However, if other terms can achieve the same purpose, they may be replaced by other expressions.

[0066] As illustrated herein, unless the context clearly indicates otherwise, the words “a,” “an,” “an,” and / or “the” do not specifically refer to the singular and may also include the plural. Generally speaking, the terms “comprising” and “including” only indicate the inclusion of explicitly identified steps and elements, which do not constitute an exclusive list, and the method or apparatus may also include other steps or elements.

[0067] The definitions used herein, such as the terms “having,” “may have,” “comprising,” or “may include,” indicate the presence of the corresponding function, operation, element, etc., and do not limit the presence of one or more other functions, operations, elements, etc. Furthermore, it should be understood that the terms “comprising” or “having” as used herein indicate the presence of the features, figures, steps, operations, elements, components, or combinations thereof described in the specification, without excluding the presence or addition of one or more other features, figures, steps, operations, elements, components, or combinations thereof.

[0068] Flowcharts are used in this document to illustrate the operations performed by the system according to the embodiments herein. It should be understood that the preceding or following operations are not necessarily performed in exact order. Instead, the steps can be processed in reverse order or simultaneously. Furthermore, other operations can be added to these processes, or one or more steps can be removed from them.

[0069] Example 1

[0070] Alarm system

[0071] An alarm system is a combination of hardware and software used to detect alarm status, generate alarm signals in a timely manner, and transmit these signals to the operator. As the core of security protection, the alarm system plays a vital role in ensuring overall safety.

[0072] An alarm system consists of several key components, typically including: input devices such as sensors and alarm buttons; controllers; alarm devices such as relays and audible and visual alarms; and a management platform.

[0073] Modern alarm systems can generally be controlled automatically after detecting anomalies. However, during some abnormal events, the automatic control system may fail, requiring manual intervention from the operator. The alarm system will then notify the operator through audio and visual signals, enabling the operator to identify abnormal conditions or malfunctioning equipment.

[0074] For a description of the alarm system process, please refer to [link / reference]. Figure 1 The working process of an alarm system is to first sense changes in the external environment, such as liquid level and air pressure, and then convert these changes into signals for transmission.

[0075] The controller can receive and process signals, making judgments and analyses. If the controller determines that it is an abnormal event, it will activate the corresponding alarm procedure. The alarm device will be activated, emitting sound and / or light signals to alert people, or it will be handled by the automatic control system. Simultaneously, the alarm event will be recorded for later analysis.

[0076] An alarm system is not a static component; the operator is also part of the alarm system and can affect its performance. A good alarm system, in addition to hardware and software, also needs to consider human factors engineering, incorporating the operator's status into the design.

[0077] Please refer to Figure 2 This is a schematic diagram of the first process of the alarm information association processing method based on artificial intelligence in this embodiment, as shown below. Figure 1 As shown, the alarm information association processing method includes:

[0078] S11. Obtain alarm information and preprocess the alarm information;

[0079] S12. Based on artificial intelligence algorithms, perform correlation analysis on different alarm items of alarm information and construct correlation rules between alarm items; the correlation rules are used to characterize whether there is a correlation between the occurrence of alarm items;

[0080] Association rules

[0081] An association rule can be represented as A→B, meaning that if alarm item A appears in an alarm transaction, then alarm item B may also appear in the same alarm transaction. This rule is usually accompanied by a certain confidence level and lift level.

[0082] A transaction is a single entry in a dataset, typically consisting of a set of items. Let D = {y1, y2, ..., ym} be a set of alarm transactions, referred to as the database.

[0083] Item: A possible element in a dataset. Let X = {x1, x2, ..., xn} be a set of n binary attributes, called an item.

[0084] Each transaction y in database D has a unique transaction ID and contains a subset of items in X. Each y is represented as a binary vector, where y[k] = 1 indicates that y contains item xk, and y[k] = 0 indicates that y does not contain item xk.

[0085] Itemset: The sum of all items.

[0086] The following examples illustrate some important concepts and evaluation metrics in association rule mining. Table 1 shows a sample database generated by an alarm system, and Table 2 shows the binary vector form of the sample database from Table 1.

[0087] Table 1: Example Database of Alarm Systems

[0088]

[0089] Table 2: Binary Vector Form of Example Database for Alarm Systems

[0090]

[0091] In this example, the set of alarm items is X = {alarm1, alarm2, alarm3, alarm4, alarm5}.

[0092] Support: Itemset support measures the prevalence of an itemset, a fundamental metric for assessing the statistical significance of an association rule. Itemset support is the frequency with which an itemset appears in database D. The support of itemset A in database D is defined as the proportion of transactions y in D that contain A, calculated using the following formula:

[0093] ;

[0094] Where y is the number of times item set A appears, and Y is the total number of transactions.

[0095] The support of itemset A = {alarm 1, alarm 3} is s({alarm 1, alarm 3}) = 3 / 5 = 0.6, which means that X appears in 60% of all transactions. The support of itemset B = {alarm 2} is s({alarm 2}) = 3 / 5 = 0.6.

[0096] Confidence: The probability that itemset B also exists given that itemset A exists. It is used to evaluate the reliability of a rule. A rule with high confidence usually indicates a reliable association.

[0097] ;

[0098] The confidence score for association rule A⇒B is calculated as follows:

[0099] ;

[0100] Lift: Represents the relationship between the occurrence of A and the occurrence of B. It helps identify meaningful associations. A lift greater than 1 indicates a positive association, equal to 1 indicates no association, and less than 1 indicates a negative association. A higher lift value is better, meaning that the probability of B occurring given A is higher than the probability of randomness.

[0101] ;

[0102] The lift of association rule A⇒B is calculated as follows:

[0103] ;

[0104] Support, confidence, and lift are all important metrics for evaluating association rules. Support demonstrates the rule's coverage, confidence demonstrates its accuracy, and lift demonstrates whether the rule is meaningful.

[0105] S13. Compress and filter alarm information based on the association rules between alarm items.

[0106] Please refer to Figure 3 This is a schematic diagram of the second process of the alarm information association processing method based on artificial intelligence in this embodiment, as shown below. Figure 2 As shown, step S11 includes:

[0107] S111. Identify and suppress disturbing alarm signals in the alarm information.

[0108] In this embodiment, step S111 specifically includes:

[0109] Calculate the dynamic disturbance index of alarm signals in alarm information to identify disturbed alarm signals in alarm information; the dynamic disturbance index is used to characterize the time difference and the number of occurrences between alarm signals within a preset time period.

[0110] Dynamic Disturbance Index

[0111] Disturbance alarms come in various forms, including disruptive alarms, transient alarms, obsolete alarms, and redundant alarms. Each type of disturbance alarm has its unique characteristics and behavioral patterns. Disturbance alarms are the most common type. According to the definition provided by ANSI / ISA-18.2, a disturbance alarm is defined as "an alarm that is excessively and unnecessarily triggered, or that fails to return to normal after operator action." Therefore, disturbance alarms do not provide any new information to the operator or can not be reduced through action. A rule of thumb for identifying disturbance alarms is defined as three or more alarms occurring within one minute. However, the definition is vague, and there are no standards or guidelines to quantify the disruptive behavior of alarms. In this embodiment, the quantification method for disturbance alarms consists of five steps:

[0112] 1. Creation of a binary matrix;

[0113] 2. Calculation of distance (r);

[0114] 3. Calculation of Travel Distributed Range (RLD);

[0115] 4. Calculation of Discrete Probability Function (DPF);

[0116] 5. Calculation of the disturbance index (Ψ).

[0117] The Dynamic Disturbance Index is a method for assessing disturbances in real time. It quantifies the trend of disturbances by associating them with each alarm event over a future period of time (such as one hour).

[0118] Unlike conventional disturbance indices, dynamic disturbance indices are calculated every time a "1" (i.e., a disturbance alarm event) occurs in a binary sequence within a given timeframe; this is called an "iteration." For each unique alarm, a dynamic disturbance index equal to the number of times the alarm event occurred is calculated, whereas previous disturbance indices were only used once per unique alarm. The purpose of using dynamic disturbance indices is to provide a more detailed and dynamic assessment.

[0119] When calculating the dynamic disturbance index, it is necessary to determine the "future" time range. This time range is a design parameter that can be adjusted, but a trade-off must be made between the reliability of the statistical data and the preservation of the dynamic characteristics. If the defined time is too short, the index may be unreliable due to insufficient data; if the time is too long, the dynamic characteristics may be lost, causing the dynamic disturbance index to converge with the initial disturbance index.

[0120] In this embodiment, "future" is defined as one hour. Each time an alarm event occurs, a dynamic disturbance index is calculated, representing the trend of disturbance for that alarm within the next hour. The dynamic disturbance index can be used to predict upcoming disturbance behavior. A threshold is set, for example, 0.05 alarms / second previously. When the dynamic disturbance index is higher than this threshold, it can be considered that alarm events within the next hour will trigger disturbance behavior.

[0121] The specific calculation method for the dynamic disturbance index is as follows:

[0122] 1. For a unique alarm, select index (serial number) = i;

[0123] 2. Select all alarm events within one hour after index=i;

[0124] 3. Calculate the perturbation index of all events selected in step 2 and store them in a vector.

[0125] For each unique alarm, a vector containing multiple dynamic disturbance indices will be obtained. This vector can be used to determine a label, enabling the training and prediction of a machine learning model, thereby achieving real-time assessment of future disturbance behavior.

[0126] In one optional implementation, the alarm information includes several alarm transactions; the alarm transaction includes several alarm items; the artificial intelligence algorithm includes a frequent pattern growth algorithm; step S12 includes:

[0127] S121. Calculate the support of all alarm items in the alarm information to determine frequent alarm items; frequent alarm items are used to characterize alarm items whose support is greater than a preset support threshold.

[0128] S122. Insert the frequent alarm items in each alarm transaction into the alarm frequency pattern tree in sequence, and maintain the count of the frequent alarm items appearing in the alarm information; each node of the alarm frequency pattern tree represents an alarm item.

[0129] S123. Construct conditional pattern bases upwards from the most frequent alarm item with the lowest support in the frequent alarm pattern tree, so as to create a conditional frequent pattern tree for each conditional pattern base.

[0130] S124. Recursively mine all frequent patterns in the frequent pattern tree for each condition to obtain the association rules between alarm items; frequent patterns are used to characterize the correlation between the occurrence of alarm items of that frequent pattern.

[0131] Frequent pattern growth algorithm

[0132] Frequent Pattern Growth (FP-Growth) is an efficient algorithm for association rule mining, designed to address the inefficiency of the Apriori algorithm when dealing with large numbers of candidate itemsets. FP-Growth constructs a special data structure—the Frequent Pattern Tree (FP-tree)—that allows for the direct mining of frequent itemsets without generating candidate itemsets.

[0133] Basic steps of the FP-Growth algorithm:

[0134] 1. Construct an FP-tree:

[0135] (1) First, scan the dataset to calculate the support of all items and determine which items are frequent (usually by setting a minimum support threshold).

[0136] (2) After discarding infrequent items, sort the frequent items in descending order of support.

[0137] (3) Rescan the dataset and insert the frequent items in the transactions into the FP-tree according to the previous sorting. Each node of the FP-tree represents an item and maintains the count of the item's occurrences in the dataset.

[0138] 2. Detecting frequent patterns:

[0139] (1) Construct the conditional pattern base from the bottom of the FP-tree upwards (starting from the lowest frequent item). The conditional pattern base refers to the items that remain after deleting the item from all the paths output in the FP-tree when a certain item is given.

[0140] (2) Create a "conditional FP-tree" for each conditional pattern base. The conditional FP-tree is built on the conditional pattern base, which means that for each frequent item, you only need to focus on other frequent items that are combined with that item.

[0141] (3) Recursively mine all frequent patterns in each conditional FP-tree.

[0142] The following is a further explanation of the conditional pattern base:

[0143] In the FP-growth algorithm, the process of constructing the FP-tree and mining frequent patterns is performed in steps. The following is a detailed explanation of the three steps involved in mining frequent patterns:

[0144] Step 1: Construct the conditional pattern base from the bottom of the FP-tree upwards (starting from the lowest frequent item).

[0145] Conditional pattern base concept:

[0146] A conditional pattern base in an FP-tree refers to the set of all paths containing a given item, and the set of items remaining after removing the item from these paths. These paths can be understood as the set of all paths ending with the given item, used to construct the conditional FP-tree.

[0147] Specific steps:

[0148] (1) From bottom to top: In FP-tree, it is usually started from the lowest frequent item (that is, the item in the leaf part of the tree) and processed one by one from the bottom up.

[0149] (2) Delete items and record paths: For each frequent item, traverse all paths in the FP-tree and find the path containing the item. Then, delete the item from the path, and the remaining items form the conditional pattern base.

[0150] For example, suppose there is the following path in an FP-tree:

[0151] Path 1: {A, B, E};

[0152] Path 2: {B, E, D};

[0153] Path 3: {A, B, C, E};

[0154] Suppose we are currently mining frequent terms E. For each path containing E, the remaining part after removing E constitutes the conditional pattern base. For example:

[0155] Path 1: {A, B};

[0156] Path 2: {B, D};

[0157] Path 3: {A, B, C};

[0158] The sets of these paths {A, B}, {B, D}, {A, B, C} constitute the conditional pattern base of the frequent term E.

[0159] Purpose:

[0160] By using conditional pattern bases, the problem is gradually narrowed down from the global frequent itemset to the subtrees related to a specific frequent item, thereby effectively reducing the search space and facilitating the construction of a conditional FP-tree.

[0161] Step 2: Create a "conditional FP-tree" for each conditional schema base.

[0162] Conditional FP-tree concept:

[0163] A conditional FP-tree is a tree structure built on a conditional pattern base. It contains paths related to a specific frequent item. By further mining the conditional pattern base, a new FP-tree can be constructed that focuses only on other frequent items related to that frequent item.

[0164] Specific steps:

[0165] (1) Constructing a conditional FP-tree: Based on the paths in the conditional pattern base, sort the frequent itemsets according to their frequency and create a new FP-tree. This tree structure contains only other frequent items related to the current frequent item.

[0166] (2) Sorting: When constructing the conditional FP-tree, the items in the conditional pattern base are first sorted by frequency to ensure that the most frequent items are placed first. This sorting is similar to the process of sorting items in the global FP-tree.

[0167] For example:

[0168] Suppose that in a certain conditional schema base, the frequent itemset is {A, B, C}, and these items appear 3, 5, and 4 times respectively in transactions. When constructing a conditional FP-tree, these items are first sorted by frequency, resulting in the order {B, C, A}. (Note: This example is not related to the database mentioned in the text; it is only for ease of understanding. Different algorithmic designs may exist for creating a conditional FP-tree from a conditional schema base.)

[0169] Then, based on this sorting, the paths in the conditional pattern base can be processed to construct a new FP-tree. This new FP-tree will only contain the three items {B, C, A} and the connections between them, forming the conditional FP-tree.

[0170] Purpose:

[0171] The purpose of constructing conditional FP-trees is to further refine the mining of frequent itemsets, remove irrelevant items, and efficiently store the relationships between related items through a tree structure, thereby accelerating the discovery of frequent patterns.

[0172] Step 3: Recursively mine all frequent patterns in the FP-tree for each condition.

[0173] Recursive mining:

[0174] After obtaining each conditional FP-tree, frequent pattern mining is performed recursively. Each recursive process is equivalent to repeating the previous two steps: constructing a conditional pattern base and creating a conditional FP-tree based on it.

[0175] Specific steps:

[0176] (1) Recursive process: For each conditional FP-tree, firstly, frequent itemsets are mined through the conditional pattern base, and then a new conditional FP-tree is constructed.

[0177] (2) Discovery of frequent patterns: By recursively mining the conditional FP-tree, all frequent itemsets can eventually be discovered. Each recursion will discover higher-order frequent itemsets until there are no more frequent itemsets.

[0178] For example:

[0179] Suppose a frequent item {B} is found in the conditional FP-tree, then a conditional pattern base can be built in this subtree and mining can continue. If the conditional FP-tree for {B} is empty, it means that this item can no longer generate more frequent itemsets, and the recursion ends.

[0180] Purpose:

[0181] Recursive mining can efficiently discover frequent patterns at multiple levels. The recursive nature ensures that it starts with the smallest frequent itemset and gradually builds a larger frequent itemset, while reducing the amount of computation.

[0182] Summarize:

[0183] (1) Conditional pattern base: Given a frequent item, the set of paths related to that item is extracted from the FP-tree and used for subsequent conditional FP-tree construction.

[0184] (2) Conditional FP-tree: It is a tree structure built on conditional pattern base, which contains items related to the current frequent items, making it easier to further mine frequent patterns.

[0185] (3) Recursive mining: By recursively processing each conditional FP-tree, all frequent itemsets are gradually discovered until there are no new frequent itemsets.

[0186] 3. Pseudocode for FP-Growth;

[0187] FP-Growth algorithm (Tree, α);

[0188] Input: An FP-tree constructed from transactions;

[0189] Output: A complete set of frequent patterns;

[0190] 1. If the tree contains a single path P from the root to a leaf node;

[0191] 2. Then for each combination of nodes in path P (denoted as β);

[0192] 3. Generate a pattern β∪α, with support equal to the minimum support of nodes in β;

[0193] 4. Otherwise, for each ai in the Tree header table (#ai is a frequent item);

[0194] 5. Generate the pattern β = ai∪α;

[0195] 6. Construct the conditional mode basis for β;

[0196] 7. Construct a conditional FP-tree for β: Treeβ;

[0197] 8. If Treeβ≠ ;

[0198] 9. Then call FP-Growth(Treeβ, β);

[0199] Where α is a prefix of the frequent patterns identified in the current recursive step.

[0200] β∪α: Represents a frequent pattern.

[0201] As can be seen, FP-Growth significantly improves the efficiency of association rule mining by effectively compressing dataset information into an FP-tree and using a recursive method to mine frequent itemsets. The following example further illustrates this. Assume we have the alarm transaction dataset shown in Table 3 below (with a pre-set minimum support of 3):

[0202] Table 3: Alarm Transaction Dataset

[0203]

[0204] 1. Calculate the frequency of each item;

[0205] Calculate the support (number of times) of frequent terms:

[0206] A: 4;

[0207] B: 5;

[0208] C: 4;

[0209] D: 2 (Does not meet the minimum support threshold of 3, should be discarded);

[0210] E: 5;

[0211] Since D has a support of 2, which is lower than the minimum support of 3, it will be eliminated.

[0212] 2. Construct the header table;

[0213] Only items with a support greater than or equal to 3 are retained, therefore the frequent itemset is {A, B, C, E}. The constructed header table is as follows:

[0214] Header:

[0215] A: 4 linked list pointers;

[0216] B: 5. Linked list pointers;

[0217] C: 4. Linked list pointers;

[0218] E: 5. Linked list pointers;

[0219] 3. Sorting items in a transaction;

[0220] Now, sort each transaction by frequency, keeping only the most frequent items. The following is the sorted set of transactions:

[0221] T1: {A, B, D, E} is sorted as {A, B, E} (removing D);

[0222] T2: {B, C, E} is sorted as {B, C, E};

[0223] T3: {A, B, C, E} is sorted as {A, B, C, E};

[0224] T4: {A, B, C, D, E} is sorted as {A, B, C, E} (removing D);

[0225] T5: {A, B, C, E} is sorted as {A, B, C, E};

[0226] 4. Insert the transaction into the FP-tree;

[0227] Next, the sorted transactions are inserted into the FP-tree one by one.

[0228] (1) Insert transaction T1: {A, B, E};

[0229] Insert A: Insert A into the FP-tree. The child node of the root node Root is A, and the counter is 1.

[0230] Insert B: B becomes a child node of A, and its counter is 1.

[0231] Insert E: E becomes a child node of B, and its counter is 1.

[0232] The FP-tree structure becomes, as follows: Figure 4a As shown.

[0233] (2) Insert transaction T2: {B, C, E};

[0234] Insert B: Find B, increment B's counter by 1, and the counter becomes 2.

[0235] Insert C: C becomes a child node of B, with a counter of 1.

[0236] Insert E: E becomes a child node of B, with a counter of 2.

[0237] The FP-tree structure becomes: Figure 4b As shown.

[0238] (3) Insert transaction T3: {A, B, C, E};

[0239] Insert A: Find A, increment A's counter by 1, and the counter becomes 2.

[0240] Insert B: Find B, increment B's counter by 1, and the counter becomes 3.

[0241] Insert C: C becomes a child node of B, with a counter of 2.

[0242] Insert E: E becomes a child node of B, with a counter of 3.

[0243] The FP-tree structure becomes, as follows: Figure 4c As shown.

[0244] (4) Insert transaction T4: {A, B, C, E};

[0245] Insert A: Find A, increment A's counter by 1, and the counter becomes 3.

[0246] Insert B: Find B, increment B's counter by 1, and the counter becomes 4.

[0247] Insert C: Find C, increment C's counter by 1, and the counter becomes 3.

[0248] Insert E: Find E, increment E's counter by 1, and the counter becomes 4.

[0249] The FP-tree structure becomes as follows Figure 4d As shown.

[0250] (5) Insert transaction T5: {A, B, C, E};

[0251] Insert A: Find A, increment A's counter by 1, and the counter becomes 4.

[0252] Insert B: Find B, increment B's counter by 1, and the counter becomes 5.

[0253] Insert C: Find C, increment C's counter by 1, and the counter becomes 4.

[0254] Insert E: Find E, increment E's counter by 1, and the counter becomes 5.

[0255] The final FP-tree structure is as follows: Figure 4e As shown.

[0256] Header table updated;

[0257] The final header table is as follows:

[0258] A: 4. Linked list pointers;

[0259] B: 5 linked list pointers;

[0260] C: 4. Linked list pointers;

[0261] E: 4. Linked list pointers;

[0262] When constructing an FP-tree, all terms that do not meet the minimum support threshold should be removed. In our example, term D has a support of 2, which is below the threshold of 3, so D will not appear in the FP-tree. When processing transactions, only frequent terms are retained and sorted in descending order of frequency. Finally, the transactions are inserted into the FP-tree. In this way, interference from low-support terms is avoided, and the FP-tree is constructed efficiently.

[0263] The following example illustrates how to further explore frequent patterns. For a hypothetical dataset of alarm transactions (with a pre-set minimum support of 3):

[0264] Step 1: Construct an FP-tree;

[0265] (1) Calculate the support for each item:

[0266] A: Appeared 4 times;

[0267] B: Appeared 5 times;

[0268] C: Appeared 4 times;

[0269] D: Appears twice (support less than 3, removed);

[0270] E: Appears 5 times;

[0271] Because the minimum support is set to 3, only items A, B, C, and E are frequent.

[0272] (2) Adjusting items in a transaction:

[0273] For example, T1 was originally {A, B, D, E}, but after removing D, it becomes {A, B, E}. Similar operations are applied to other transactions.

[0274] Therefore, the sorted transactions are:

[0275] T1: {A, B, E};

[0276] T2: {B, C, E};

[0277] T3: {A, B, C, E};

[0278] T4: {A, B, C, E};

[0279] T5: {A, B, C, E};

[0280] (3) Construct an FP-tree:

[0281] Use these sorted transactions to construct an FP-tree. The root node of the FP-tree is empty, each item is a node, and the path represents the combination and frequency of items. The constructed FP-tree looks like this. Figure 4f As shown.

[0282] Step 2: Construct a conditional pattern base;

[0283] A conditional pattern base is defined as follows: for a frequent item, find all paths in the FP-tree that have that item as a prefix, remove that item, and what remains is the conditional pattern base.

[0284] (1) Conditional pattern base of item A:

[0285] Find all paths that begin with the letter A, and delete the part remaining after deleting the letter A:

[0286] A -B - E (appears 3 times);

[0287] A -B - C (appears twice);

[0288] A -C (appears once);

[0289] The conditional pattern basis of A is: {B, E} (support level 3);

[0290] (2) Conditional pattern base of item B:

[0291] Find all paths that begin with the letter B, and delete the part remaining after deleting the letter B:

[0292] B -A - E (appears 3 times);

[0293] B -C - E (appears twice);

[0294] B -C (appears twice);

[0295] The conditional pattern bases for B are: {A, E} (support of degree 3), {C, E} (support of degree 2);

[0296] (3) Conditional pattern base of term C:

[0297] Find all paths that begin with the letter C, and delete the part remaining after the letter C:

[0298] C -A -B -E (appears twice);

[0299] C -A - B (appears once);

[0300] The conditional pattern basis of C is: {A, B, E} (support quadratic).

[0301] (4) Conditional pattern basis of term E:

[0302] Find all paths that begin with the letter E, and delete the part after the letter E:

[0303] E - A - B (appears 3 times);

[0304] E - B - C (appears twice);

[0305] E - B (appears once);

[0306] The conditional pattern basis of E is: {A, B} (support level 3);

[0307] Step 3: Construct a conditional FP-tree for each conditional schema base;

[0308] Next, for each conditional schema base, the FP-tree is reconstructed. Only items in the conditional schema base are considered, and a new tree is built based on their support.

[0309] (1) Conditional FP-tree: For item A;

[0310] The conditional pattern base is {B, E}, so the new tree contains only B and E, and their support is 3. For example... Figure 4g As shown.

[0311] (2) Conditional FP-tree: For item B;

[0312] Given a conditional schema base of {A, E} and {C, E}, the new tree contains A, E, and C, with supports of 3, 3, and 2 respectively. For example... Figure 4h As shown.

[0313] (3) Conditional FP-tree: For item C;

[0314] Given a conditional schema base of {A, B, E}, the new tree contains A, B, and E, with a support of 2. For example... Figure 4i As shown.

[0315] (4) Conditional FP-tree: For item E;

[0316] The conditional pattern base is {A, B}, therefore the new tree contains both A and B, and has a support of 3. For example... Figure 4j As shown.

[0317] Step 4: Recursively mine frequent patterns;

[0318] For each conditional FP-tree, recursively mine frequent items. Each time, starting from an item in the tree, if the support of an item meets the minimum support requirement, it is considered a frequent itemset.

[0319] Summarize:

[0320] These steps allow for the recursive mining of all frequent itemsets from an FP-tree. This process fully utilizes the FP-tree data structure, avoiding the candidate itemset generation process and making the algorithm more efficient.

[0321] In another optional implementation, the alarm information includes several alarm transactions; the alarm transaction includes several alarm items; the artificial intelligence algorithm includes the ECLAT algorithm;

[0322] Step S12 includes:

[0323] S125. Associate each alarm item in the alarm information with the alarm transaction in which it occurs to obtain an alarm transaction list for each alarm item.

[0324] S126. Calculate the support of all alarm items to identify frequent alarm items; frequent alarm items are used to characterize alarm items whose support is greater than a preset support threshold.

[0325] S127. A first frequent alarm itemset is generated by intersecting the alarm transaction lists of each alarm item, and a second frequent alarm itemset is generated by intersecting the alarm transaction lists of the first frequent itemset; the support of the frequent alarm itemset is calculated by the length of the intersection result.

[0326] S128. Recursively continue the intersection process of the alarm transaction list to generate all alarm frequent itemsets that meet the preset minimum support threshold; the alarm frequent itemsets are used to characterize the correlation between the occurrence of alarm items in the alarm frequent itemsets.

[0327] ECLAT algorithm

[0328] The ECLAT algorithm is a frequent itemset mining algorithm that works based on a vertical data format. Unlike the Apriori algorithm, which processes horizontal data (row-based transaction organization), ECLAT uses a list of transactions for each item (vertical representation). This approach allows for more efficient itemset intersection operations and is suitable for datasets that can fit into memory.

[0329] Basic steps of the ECLAT algorithm:

[0330] 1. Vertical data format conversion:

[0331] Convert the transaction dataset from a horizontal format to a vertical format, where each item is associated with a list of transaction IDs (TID list) in which it appears.

[0332] 2. Frequent itemset generation:

[0333] Starting with a list of individual TIDs, larger itemsets are generated through intersection operations. TID list intersection is a core operation of ECLAT, directly calculating the support of the new itemset by intersecting the TID lists.

[0334] Frequent itemsets are generated by the intersection of the TID lists of smaller itemsets, and support is calculated by the length of the intersection result.

[0335] The process continues recursively to generate all frequent itemsets that satisfy a predefined minimum support threshold. The recursive exploration of itemsets ensures that all combinations are considered, similar to a depth-first search in a tree.

[0336] 3. Recursive mining:

[0337] For each frequent itemset, continue the intersection operation on the TID list to generate a larger candidate itemset.

[0338] This bottom-up approach efficiently explores item set lattices.

[0339] 4. ECLAT pseudocode;

[0340] The following is a simplified pseudocode representation of the ECLAT algorithm:

[0341] The algorithm is ECLAT(itemset, min_support);

[0342] Input: A set of items with a list of TIDs and a minimum support threshold;

[0343] Output: Frequent itemsets that exceed a given support threshold;

[0344] 1. For each item i in the dataset;

[0345] 2. Calculate the support of i by counting the entries in the TID list;

[0346] 3. If support (i) ≥ min_support;

[0347] 4. Add i to the list of frequent items;

[0348] 5. Call the ECLAT({i}, min_support) procedure: ECLAT(prefix, min_support);

[0349] 6. For each item j in the itemset with the current prefix;

[0350] 7. Create a new candidate set by adding j to the prefix;

[0351] 8. Obtain a new list of TIDs by finding the intersection of the prefix sums of j and the TID list;

[0352] 9. Calculate the support of the new itemset using the length of the intersection TID list;

[0353] 10. If the support (new itemset) ≥ min_support;

[0354] 11. Output the new frequent itemset;

[0355] 12. Recursively apply ECLAT using a new itemset as a prefix;

[0356] Here, "prefix" refers to expanding upon the current itemset (prefix) at each step to explore more combinations and build a larger itemset from a smaller ones.

[0357] The ECLAT algorithm significantly reduces the computational overhead of horizontal formatting methods by leveraging the efficient intersection and support calculations of vertical itemset representations, offering significant advantages for certain types of datasets and computing environments. The following example further illustrates how the ECLAT algorithm performs frequent itemset mining using a vertical data format (a list of transaction IDs for the itemset).

[0358] Suppose we have a simplified transaction dataset, as shown in Table 4 below, where each row represents a transaction (Transaction ID, TID) and its contained items.

[0359] Table 4: Simplified Transaction Dataset

[0360]

[0361] The goal is to find frequent itemsets with min_support = 2. The specific steps include:

[0362] 1. Dataset transformation: Generate a list of TIDs for the itemset;

[0363] First, extract the TID list for each item:

[0364] A: {T1, T3, T4};

[0365] B: {T1, T2, T3, T5};

[0366] C: {T2, T3, T4, T5};

[0367] D: {T1, T2, T3, T4, T5};

[0368] 2. Execute ECLAT;

[0369] To begin executing the ECLAT algorithm, the following are detailed instructions for each step:

[0370] Step 1: Initialization;

[0371] For each item (e.g., A, B, C, D), calculate its support. If the support is greater than or equal to min_support, add it to the list of frequent itemsets.

[0372] Support (A) = 3 (T1, T3, T4) → Support >= 2, A is a frequent itemset;

[0373] Support (B) = 4 (T1, T2, T3, T5) → Support >= 2, B is a frequent itemset;

[0374] Support (C) = 4 (T2, T3, T4, T5) → Support >= 2, C is a frequent itemset;

[0375] Support (D) = 5 (T1, T2, T3, T4, T5) → Support >= 2, D is a frequent itemset;

[0376] Frequent itemset: {A, B, C, D};

[0377] Step 2: Recursively generate frequent itemsets;

[0378] Next, ECLAT recursively combines itemsets to generate candidate itemsets and calculates their support.

[0379] Example: Combining A and B;

[0380] A's TID list: {T1, T3, T4};

[0381] B's TID list: {T1, T2, T3, T5};

[0382] The list of TIDs for the intersection of A and B: {T1, T3}, with support = 2;

[0383] Since the support is greater than or equal to min_support, {A, B} is a frequent itemset.

[0384] Continue recursively to other combinations:

[0385] A and C: Intersection TID list = {T3, T4}, support = 2 → frequent itemset {A, C};

[0386] B and C: Intersection TID list = {T2, T3, T5}, support = 3 → frequent itemset {B, C};

[0387] A and D: The intersection of TID list = {T1, T3, T4}, support = 3 → frequent itemset {A, D};

[0388] B and D: The intersection of TID list = {T1, T2, T3, T5}, support = 4 → frequent itemset {B, D};

[0389] C and D: The intersection of TID list = {T2, T3, T4, T5}, support = 4 → frequent itemset {C, D};

[0390] Step 3: Recursively generate higher-order frequent itemsets;

[0391] Next, ECLAT continues to combine frequent binary itemsets to generate higher-order itemsets and recalculates the support.

[0392] For example, combining {A,B} and {C}:

[0393] TID lists for A and B: {T1, T3};

[0394] C's TID list: {T2,T3,T4,T5};

[0395] The intersection TID list = {T3} has a support of 1, which is lower than min_support. Therefore, {A,B,C} is not a frequent itemset.

[0396] Continue with other advanced combinations:

[0397] The support of the intersection of {A,B} and {D} is ≥2;

[0398] The support of the intersection of {A,C} and {D} is ≥2;

[0399] Output the results;

[0400] Finally, ECLAT outputs all frequent itemsets that meet the support threshold:

[0401] One-item frequent itemsets: {A}, {B}, {C}, {D};

[0402] Binary frequent itemsets: {A,B},{A,C},{B,C},{A,D},{B,D},{C,D};

[0403] Three frequent itemsets: {A,B,D},{A,C,D},{B,C,D};

[0404] Comparative Analysis of FP-Growth Algorithm and Eclat Algorithm

[0405] This embodiment uses a nuclear power plant application scenario as an example. Based on simulation test data of some fault scenarios from a nuclear power plant simulation platform, it compares and analyzes the FP-Growth algorithm and the Eclat algorithm. First, the data is preprocessed, converting each transaction into an alarm-like item, arranged according to the order of alarm triggering. Next, the processed data is fed into both algorithms, and the same evaluation indicators are selected for testing. Based on the test results, the more suitable algorithm is further adjusted in terms of parameters. By setting the same minimum support and minimum confidence, their performance, as well as their stability and consistency under different conditions, can be objectively tested.

[0406] Table 5 below shows the specific results of testing the two algorithms on the same database:

[0407] Table 5: Comparison of Algorithm Test Results

[0408]

[0409] Furthermore, such as Figure 5 As shown, the two algorithms perform similarly in terms of computation time and memory usage. Fp-Growth's execution time is approximately between 0.25 and 0.29 seconds, with memory consumption between 12.03 MB and 12.56 MB; while Eclat's ranges from 0.22 to 0.26 seconds, with memory usage between 11.63 MB and 12.23 MB. Figure 6 As shown in the figure, the rules generated by both algorithms are relatively stable. However, due to the differences in the algorithms, the FP-Growth algorithm usually generates more rules than the Eclat algorithm. This difference mainly stems from the different algorithmic mechanisms they use to process data.

[0410] The test results show the following: In terms of computation time: The two algorithms perform essentially the same. Fp-Growth's execution time is approximately between 0.25 and 0.29 seconds, while Eclat's is slightly shorter, ranging from 0.22 to 0.26 seconds. This indicates that Eclat is slightly faster under this specific dataset and support settings. In terms of memory usage: There is no significant difference. Fp-Growth's memory consumption is between 12.03 MB and 12.56 MB, while Eclat's memory usage is between 11.63 MB and 12.23 MB. Although Eclat saved slightly more memory in the test, the difference is minor. This shows that under these dataset conditions, memory usage is not a bottleneck for either algorithm.

[0411] Although the two algorithms are similar in execution time and memory usage, they differ in the results of rule mining:

[0412] 1. Rule Complexity: FP-Growth can often uncover more complex rules with multiple antecedents or consequents. This is because its unique FP-tree structure allows it to explore possible combinations of itemsets more efficiently. Therefore, it exhibits more complex rules with multi-element sets containing many subset items.

[0413] 2. Rule Bias: Eclat tends to find simpler rules, and because it calculates frequent itemsets based on a vertical data format (TID list intersection operation), its rule output may favor simpler rules. In terms of rule sets, this also means that Eclat may lack complex rules composed of multiple elements, or these complex rules may be broken down and presented as simpler rules.

[0414] 3. Stability and consistency:

[0415] Through multiple tests, it was observed that both algorithms exhibited good stability and consistency under different operating conditions. Although the aforementioned differences in rule complexity exist, these are mainly related to the nature and structure of the algorithms and do not affect their consistent performance under given conditions.

[0416] If you require complex rules or want to explore multi-element combinations in depth, Fp-Growth might be more suitable. For those who prefer simple rules and need fast computation, Eclat can be considered. Both have their advantages and disadvantages; the appropriate choice ultimately depends on the specific application scenario and the characteristics of the dataset.

[0417] In summary, based on the test results above, the inventors believe that Fp-Growth may be more suitable for rule mining in existing power plant fault scenarios. This is because rules in power plant fault scenarios often need to cover multiple factors or variables, such as multiple conditions for equipment failure or combinations of multiple fault modes. These types of problems require mining relatively complex rules, and Fp-Growth's FP-tree structure can effectively mine complex combinations of multi-element rules, thus making it more suitable for multidimensional data in power plant fault scenarios.

[0418] In this embodiment, step S13 includes one or more of the following methods:

[0419] Similar alarm information is merged based on association rules between alarm items; similar alarm information reflects the same problem or the same type of fault;

[0420] Alarm information is prioritized based on the strength of the association rules between alarm items; the strength of the association rule includes at least one of support, confidence, or lift.

[0421] Based on the association rules between alarm items, similar alarm information that occurs frequently is aggregated.

[0422] Specifically, the association rules derived by the Fp-Growth algorithm mostly meet the set minimum support and confidence levels. These rules can then be used to compress alarm information, effectively reducing the operator's processing workload. Specific applications include:

[0423] 1. Merge similar alarm messages: If multiple alarm messages reflect the same problem or the same type of fault, they can be merged into one alarm to avoid the operator receiving duplicate and redundant information.

[0424] 2. Alarm Prioritization: By setting priorities for alarm information (e.g., high, medium, low), operators can ensure that the most important alarms are handled first. Priorities can be dynamically adjusted based on the strength of association rules (e.g., support, confidence, and lift).

[0425] 3. Alarm information aggregation: For events that occur frequently, aggregation technology can be used to merge multiple similar alarms, reducing the number of alarms and thus reducing the burden on operators.

[0426] The following example further illustrates how to identify disturbance alarms using a dynamic disturbance index:

[0427] Data collection and processing

[0428] First, it's necessary to clearly identify whether the disturbance alarm is a classification problem, a regression problem, or a clustering problem. Defining the problem type helps in selecting an appropriate algorithm and evaluating model performance. Identifying whether an alarm exhibits disturbance behavior is clearly a classification problem, specifically a binary classification problem, because an alarm can only represent "0" or "1," i.e., disturbance and non-disturbance.

[0429] Next is data collection. This is the cornerstone of machine learning, and the performance of the model is easily affected by the quality of the data. The data needs to be representative, diverse, and sufficient in quantity. Generally, data can be collected through experiments, surveys, web scraping, or public datasets. Since data could not be obtained directly from the nuclear power plant, simulated data from a simulator was chosen.

[0430] The data will then be processed. Data processing includes data cleaning, transformation, and standardization. After cleaning, missing values, outliers, and duplicate values ​​are largely resolved. For missing values, imputation methods can be selected based on the data distribution, such as mean imputation, median imputation, or predictive imputation using algorithms.

[0431] The database will then be divided into two parts: a training set and a test set. Before splitting the original database, the data rows need to be randomly sorted to address the issue of poor data distribution. The test set will have its last column removed—whether the "label" is a perturbation alarm—and the "label" will be stored in a separate variable. This is because the goal of the evaluation phase is to predict the "label"; therefore, the algorithm must not access the true "label" value during this phase.

[0432] Algorithm selection

[0433] The ultimate goal of machine learning algorithms is to find a function that accurately represents the relationship between inputs (features) and outputs (labels). An "algorithm" defines how the function is constructed and its main properties. Optimal parameters are obtained by training the model on data. The trained model is a well-defined function that, given input, can accurately map to the output. This example uses three different models: logistic regression, deep learning, and support vector machines. The following is an introduction to these algorithms.

[0434] Logistic Regression

[0435] Logistic regression is a generalized linear regression analysis model primarily used for binary classification problems, and it has wide applications in data mining, automated disease diagnosis, economic forecasting, and many other fields. Logistic regression uses the sigmoid function to map the output of linear regression to a range between 0 and 1, thus obtaining a probability value. This probability value can be used to determine the likelihood of a sample belonging to a certain category. The formula for logistic regression can be expressed as:

[0436] ;

[0437] Where z = w0 + w1x1 + w2x2 + ... + w n x n ;

[0438] w is the weighting coefficient, x is the eigenvalue, and n is the number of features. In this formula, z is a composite index obtained by linearly combining multiple features; this index can be converted into a probability value using a logistic function.

[0439] Logistic regression is an algorithm that offers advantages such as low computational cost, ease of understanding, and ease of implementation. It is suitable for large datasets due to its fast computation time. Furthermore, logistic regression can also handle sparse data, thus offering advantages when dealing with high-dimensional datasets.

[0440] While logistic regression has many advantages, there are some issues to consider when using it. For example, when the data is complex, logistic regression may fail to capture non-linear relationships, in which case alternative models should be considered. Also, logistic regression is very sensitive to outliers, so outliers must be handled during data preprocessing.

[0441] Deep learning

[0442] See Figure 7 The core principle of deep learning is to process data using neural network models. A neural network consists of three parts: an input layer, hidden layers, and an output layer. The input signal enters the neural network and proceeds layer by layer until the desired output and effect are achieved. During this process, deep learning algorithms continuously optimize the network's performance through backpropagation. By comparing the error between the network output and the true label, the signal is propagated backward, and the network is updated accordingly.

[0443] Activation functions and loss functions are crucial components of deep learning. Activation functions, such as sigmoid and ReLU, are used to increase the non-linearity of neural networks, enabling them to learn and simulate more complex patterns. Loss functions, such as cross-entropy and mean squared error, measure the difference between the network's output and the true label. Deep learning optimizes the overall performance of the network by minimizing the loss function.

[0444] Deep learning has wide applications across various fields. As a powerful machine learning algorithm, deep learning has become a significant force driving the development of artificial intelligence. By simulating human cognitive processes, it enables machines to understand and process various types of data more deeply and accurately, providing a possible direction for achieving higher levels of artificial intelligence.

[0445] Support Vector Machine

[0446] See Figure 8 Support Vector Machines (SVMs) are a common machine learning algorithm that is highly effective in solving binary classification problems. Its principle is to find an optimal hyperplane to separate the data, maximizing the margin between the two classes.

[0447] The basic principle of Support Vector Machines (SVMs) is to find a maximum-margin hyperplane to separate the data into two classes. This hyperplane should not only correctly separate the samples in the training dataset, but also maximize the distance (margin) between the two classes of data to the hyperplane.

[0448] In Support Vector Machines (SVMs), there is a special type of sample point called "support vectors." These points are the data points closest to the hyperplane and play a crucial role in determining the hyperplane with the largest margin. Support vectors directly affect the results, while other points far from the hyperplane generally do not affect the classification results.

[0449] Model Evaluation

[0450] See Figure 9 In machine learning, the performance of classification models is evaluated using three metrics: accuracy, recall, and precision. These metrics can be calculated using four key values ​​in the confusion matrix.

[0451] The following is a detailed explanation:

[0452] True positive (TP): A "true positive" occurs when the model correctly predicts the label "1" (i.e., during the evaluation phase, for a set of features, the model predicts the label as 1, and the true label is also 1).

[0453] True negative (TN): The model predicts a label of 0, and the true label is 0;

[0454] False positive (FP): The model predicts a label of 1, while the true label is 0;

[0455] False negative (FN): The model predicts a label of 0, while the true label is 1.

[0456] Accuracy: Accuracy is the proportion of samples that are correctly predicted out of the total sample. It measures the overall predictive ability of the model. The formula for calculating accuracy is:

[0457] ;

[0458] Recall: Recall (also known as true positive rate or sensitivity) is the ratio of actual values ​​of 1 to all positive samples that were predicted as 1. It measures the model's ability to identify all samples that were actually predicted as 1. The formula for recall is:

[0459] ;

[0460] Precision: Precision is the proportion of samples that were predicted as 1 and actually became 1 out of all correctly predicted samples. In other words, how many of the instances predicted as 1 are actually positive samples? The formula for calculating precision is:

[0461] ;

[0462] These metrics are very useful in evaluating model performance, especially when evaluating imbalanced datasets. While accuracy provides an overall prediction success rate, it becomes inaccurate in imbalanced datasets. If a dataset contains far more negative samples than positive samples, the model may consistently predict negative samples, achieving high accuracy but sacrificing the ability to predict positive samples.

[0463] Precision and recall are often used together to evaluate a model's performance on imbalanced data. High precision means that when the model predicts a sample to be positive, that prediction is likely correct; while high recall means that the model is able to find a majority of correct positive samples.

[0464] At the same time, precision and recall often trade off against each other. Lowering the threshold for predicting a positive sample will increase recall because more positive samples will be detected, but it will also decrease precision because more negative samples will be incorrectly predicted as positive samples.

[0465] Choosing the right evaluation metrics depends on the specific needs and requires selecting appropriate standards for the appropriate scenario. For example, in disease detection, recall may be more important because the goal is to detect as many genuine patients as possible; while in spam filters, precision is more important to avoid identifying legitimate emails as spam.

[0466] Disturbance Index

[0467] The disturbance index is a quantification of alarm disturbances, and its calculation involves five steps:

[0468] 1. Creation of a binary matrix;

[0469] 2. Calculation of distance (r);

[0470] 3. Calculation of Travel Distributed Path (RLD);

[0471] 4. Calculation of Discrete Probability Function (DPF);

[0472] 5. Calculation of the disturbance index (Ψ).

[0473] The following will detail each step:

[0474] Creation of a binary matrix;

[0475] An alarm event is uniquely identified by three attributes: a timestamp, a tag name, and an alarm identifier. The tag name and alarm identifier together form a unique alarm. A unique alarm can be represented by a binary sequence, which is a vector of "0"s and "1"s, with each element representing whether an alarm occurred within one second. These binary sequences can be combined to form a binary alarm matrix, providing a foundation for subsequent technologies.

[0476] The construction of a binary alarm matrix involves the following steps:

[0477] 1. In the alarm database, first identify all unique alarms that occurred during the observation period and store them in a row vector;

[0478] 2. Next, create a time vector, spaced one second apart, from the beginning to the end of the observation period. See [link / reference] Figure 10 For each unique alarm that has been identified, a vector of the same length as the time vector is constructed; in the figure, M represents the month, D represents the day, H represents the hour, m represents the minute, and S represents the second.

[0479] 3. If a unique alarm occurs at a specific time point, the corresponding binary vector position is marked as "1", otherwise it is marked as "0".

[0480] See Figure 11 In the diagram, Y represents the year, M represents the month, D represents the day, H represents the hour, m represents the minute, and S represents the second. This results in a matrix where the first row contains all unique alarms, and the first five columns are time vectors. In the diagram, 3ABP1002KA- represents different alarm sources for alarm behavior at a given time. If a row or column is entirely zero, the entire row or column is deleted.

[0481] Calculation of distance (r);

[0482] See Figure 12 In the diagram, Y represents the year, M represents the month, D represents the day, H represents the hour, m represents the minute, and S represents the second.

[0483] A trip is defined as "the time difference between two consecutive alarms on the same tag". In binary matrix data, whenever a "1" appears, it indicates that an alarm is activated. The time difference between that "1" and the next "1" needs to be calculated; this is the trip. Using a binary matrix, the position of each "1" can be tracked, and the trip of each unique alarm signal can be calculated accordingly. Column SO in the diagram represents the alarm source of an alarm action at a certain moment. `timecount` is the total number of seconds converted from year, month, day, hour, minute, and second, and `r` is the trip.

[0484] Calculation of travel distribution (RLD);

[0485] See Figure 13To quantify alarm perturbation behavior, Kondaveeti et al. proposed calculating the repetition count of each trip in the alarm binary sequence to form a trip distribution histogram. Perturbation behavior is indicated when most alarm trips are short. For each unique alarm in the binary matrix, the number of alarms associated with each trip is calculated, generating a list of trips and their corresponding alarm counts. Each unique alarm has a perturbation index.

[0486] Calculation of Discrete Probability Function (DPF);

[0487] See Figure 14 The travel distribution can be normalized to obtain a discrete probability function using the factor ∑. r n r Normalization yields:

[0488] ;

[0489] Where r represents the distance traveled;

[0490] nr represents the number of times path r appears;

[0491] Pr is the probability that the course r occurs nr times;

[0492] Disturbance index (Ψ) calculation;

[0493] The disturbance index for a single alarm can be calculated by adding the products of each probability function Pr and the reciprocal of the travel r:

[0494] ;

[0495] Using the reciprocal of the travel distance as a weighting function allows for a focus on alarm counts with short travel distances. Each unique alarm will have a disturbance index calculated; if the disturbance index exceeds a threshold, the alarm will be flagged as a disturbance alarm.

[0496] Based on the rule of thumb for disturbance alarms, three or more alarm records within one minute constitute a disturbance alarm. We can initially set the threshold at 0.05 alarms / second. That is, when Ψ > 0.05, the single alarm is considered a disturbance alarm.

[0497] Ideally, whenever an alarm event occurs, an algorithm should predict whether the alarm will generate disruptive behavior. To achieve this, machine learning algorithms need to be trained on historical datasets. However, the resulting disturbance index is a static result—a historical disturbance index of a single alarm that has occurred in the past—while the objective is a dynamic process. Therefore, a new, more flexible tool is needed to meet the requirements of real-time assessment and further prediction.

[0498] Dynamic Disturbance Index

[0499] The specific calculation method for the dynamic disturbance index is as follows:

[0500] 1. For a single alarm, according to Figure 15 In the table, select index (serial number) = i; in the figure, Y represents the year, M represents the month, D represents the day, H represents the hour, m represents the minute, S represents the second, and the subsequent code represents the alarm number.

[0501] 2. Select all alarm events within one hour after index=i;

[0502] 3. Calculate the perturbation index of all events selected in step 2 and store them in a vector.

[0503] Figure 15 In the diagram, the red solid box represents the first iteration, the green dashed box represents the second iteration, the blue dashed box represents the third iteration, and the purple solid box represents the fifth iteration.

[0504] Finally, see Figure 16 In the diagram, index represents the sequence number, Y represents the year, M represents the month, D represents the day, H represents the hour, m represents the minute, S represents the second, the subsequent code represents the alarm number, and ψD represents the disturbance index. For each unique alarm, a vector containing multiple dynamic disturbance indices is obtained. This vector can be used to determine the label, enabling the training and prediction of machine learning models, thereby achieving real-time assessment of future disturbance behavior.

[0505] Results and Analysis:

[0506] The simulation used two different databases and performed performance tests on three algorithms: logistic regression, deep learning, and support vector machine. The initial simulation results are as follows: Figure 17 As shown: The confusion matrix is ​​as follows Figure 18 As shown, Figure 18 The images, from left to right, show the confusion matrices for logistic regression, deep learning, and support vector machine, respectively. Note that the default threshold is 0.5. The Y-axis represents the true label, and the X-axis represents the predicted label.

[0507] The results show that logistic regression exhibits good performance in terms of accuracy and recall, reaching 0.85 and 0.97 respectively, indicating that it can effectively identify most positive samples while having a relatively low false positive rate. However, its accuracy is slightly lower than that of support vector machines.

[0508] In contrast, deep learning models performed very poorly in simulations, with accuracy, recall, and precision all significantly lower than other algorithms. This result may be related to the size of the database sample, as deep learning models typically require a large amount of data for training to acquire sufficient features and patterns. If the amount of sample data is insufficient, the model training process will be inadequate, leading to a decline in deep learning performance.

[0509] Support Vector Machines (SVMs) demonstrated excellent accuracy, achieving 0.857, which is higher than logistic regression and deep learning. Its accuracy and recall were also relatively high, indicating that it maintains good stability and accuracy when handling classification problems.

[0510] The second simulation used a different set of sample data for testing, and the results were as follows: Figure 19 and Figure 20 As shown: Figure 20 The confusion matrices from left to right in the middle represent logistic regression, deep learning, and support vector machine, respectively.

[0511] The results showed that logistic regression and support vector machine (SVM) performed well, both achieving an accuracy of 0.9. However, they differed slightly in recall and precision: logistic regression had a high recall of 0.999, meaning it could identify almost all positive samples; while SVM's precision was 0.89, slightly higher than logistic regression's 0.8696, indicating that it was better at reducing false positives. The performance of deep learning models remained poor, with accuracy, recall, and precision still at relatively low levels.

[0512] However, see Figure 21 During the threshold adjustment process, logistic regression showed good accuracy and recall only within the threshold range of 0.4-0.6, but its precision remained poor. This is because the issue of database sample size remained unresolved. Data in the nuclear industry is relatively limited, and the amount available for simulator operation is often limited.

[0513] For this dataset, both logistic regression and support vector machine (SVM) demonstrated excellent performance. Logistic regression outperformed SVM in recall, while SVM excelled in accuracy.

[0514] Taking into account the results of the two simulations, logistic regression was ultimately determined to be the best model.

[0515] The next step will be to study the changes in the threshold. For example... Figure 22 As shown, when the probability threshold changes between 0 and 1, the accuracy, recall, and precision of logistic regression also change.

[0516] Input the results into an Excel spreadsheet and perform some simple processing. You can see that as the threshold increases, precision first rises and then falls, while recall continues to decrease. Precision generally increases, but it fluctuates.

[0517] The trend in accuracy is easy to understand because when the threshold is 0 or 1, there is only one of TP and TN, reaching its maximum value in the middle. As the threshold increases, TP decreases, but TP+FN remains relatively stable, thus reducing recall. The main difficulty with changes in precision lies in the fact that TP+FP changes inconsistently with TP as the threshold changes, making it more complex.

[0518] Depend on Figure 22 It can also be seen that the model performs best when the threshold is between 0.5 and 0.6.

[0519] Example 2

[0520] This embodiment provides a nuclear power plant alarm analysis method, which includes:

[0521] The alarm information association processing method based on artificial intelligence in Example 1 is used to perform association processing on the alarm information of the nuclear power plant;

[0522] Nuclear power plant faults are analyzed and processed based on the nuclear power plant alarm information after correlation processing.

[0523] Example 3

[0524] Figure 23 This is a schematic diagram of an electronic device according to Embodiment 3 of the present invention. The electronic device includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the program, it implements the method of Embodiment 1 or Embodiment 2. Figure 23 The electronic device 30 shown is merely an example and should not impose any limitation on the functionality and scope of use of the embodiments of the present invention.

[0525] like Figure 23 As shown, the electronic device 30 can be manifested as a general-purpose computing device, such as a server device. The components of the electronic device 30 may include, but are not limited to: at least one processor 31, at least one memory 32, and a bus 33 connecting different system components (including memory 32 and processor 31).

[0526] Bus 33 includes a data bus, an address bus, and a control bus.

[0527] The memory 32 may include volatile memory, such as random access memory (RAM) 321 and / or cache memory 322, and may further include read-only memory (ROM) 323.

[0528] The memory 32 may also include a program / utility 325 having a set (at least one) of program modules 324, including but not limited to: an operating system, one or more application programs, other program modules, and program data, each or some combination of these examples may include an implementation of a network environment.

[0529] The processor 31 executes various functional applications and data processing, such as the methods of Embodiment 1 or Embodiment 2 of the present invention, by running computer programs stored in the memory 32.

[0530] Electronic device 30 can also communicate with one or more external devices 34 (e.g., keyboard, pointing device, etc.). This communication can be performed through input / output (I / O) interface 35. Furthermore, electronic device 30 can also communicate with one or more networks (e.g., local area network (LAN), wide area network (WAN), and / or public network, such as the Internet) via network adapter 36. As shown, network adapter 36 communicates with other modules of electronic device 30 via bus 33. It should be understood that, although not shown in the figure, other hardware and / or software modules can be used in conjunction with electronic device 30, including but not limited to: microcode, device drivers, redundant processors, external disk drive arrays, RAID (disk array) systems, tape drives, and data backup storage systems.

[0531] It should be noted that although several units / modules or sub-units / modules of the electronic device have been mentioned in the detailed description above, this division is merely exemplary and not mandatory. In fact, according to embodiments of the present invention, the features and functions of two or more units / modules described above can be embodied in one unit / module. Conversely, the features and functions of one unit / module described above can be further divided and embodied by multiple units / modules.

[0532] Example 4

[0533] This embodiment provides a computer-readable storage medium having a computer program stored thereon, which, when executed by a processor, implements the method of Embodiment 1 or Embodiment 2.

[0534] The readable storage medium may be more specifically adopted, including but not limited to: portable disk, hard disk, random access memory, read-only memory, erasable programmable read-only memory, optical storage device, magnetic storage device, or any suitable combination thereof.

[0535] In a possible implementation, the present invention can also be implemented as a program product comprising program code, which, when the program product is run on a terminal device, is used to cause the terminal device to execute the method of embodiment 1 or embodiment 2.

[0536] The program code for executing the present invention can be written in any combination of one or more programming languages. The program code can be executed entirely on the user device, partially on the user device, as a standalone software package, partially on the user device and partially on a remote device, or entirely on a remote device.

[0537] While specific embodiments of the present invention have been described above, those skilled in the art should understand that these are merely illustrative examples, and the scope of protection of the present invention is defined by the appended claims. Those skilled in the art can make various changes or modifications to these embodiments without departing from the principles and essence of the present invention, but all such changes and modifications fall within the scope of protection of the present invention.

Claims

1. A method for processing alarm information association based on artificial intelligence, characterized in that, The alarm information association processing method includes: Acquire alarm information and preprocess the alarm information; Based on artificial intelligence algorithms, correlation analysis is performed on different alarm items in the alarm information to construct correlation rules between the alarm items; the correlation rules are used to characterize whether there is a correlation between the occurrence of alarm items. The alarm information is compressed and filtered based on the association rules between the alarm items; The alarm information includes several alarm transactions; the alarm transactions include several alarm items; the artificial intelligence algorithm includes a frequent pattern growth algorithm. The steps for performing correlation analysis on different alarm items based on artificial intelligence algorithms include: Calculate the support of all alarm items in the alarm information to determine frequent alarm items; the frequent alarm items are used to characterize alarm items whose support is greater than a preset support threshold. Frequent alarm items in each alarm transaction are sequentially inserted into the alarm frequency pattern tree, and the count of the frequent alarm items in the alarm information is maintained; each node of the alarm frequency pattern tree represents an alarm item. The steps for constructing the association rules between the alarm items include: The conditional pattern base is constructed upwards from the most frequent alarm item with the lowest support in the frequent alarm pattern tree, so as to create a conditional frequent pattern tree for each conditional pattern base. Recursively mine all frequent patterns in the frequent pattern tree for each condition to obtain the association rules between the alarm items; the frequent pattern is used to characterize the correlation between the occurrence of alarm items of that frequent pattern. or, The artificial intelligence algorithm includes the ECLAT algorithm; The steps for constructing association rules between different alarm items based on artificial intelligence algorithms include: Each alarm item in the alarm information is associated with the alarm transaction in which it appears, so as to obtain an alarm transaction list for each alarm item; Calculate the support of all alarm items to identify frequent alarm items; the frequent alarm items are used to characterize alarm items whose support is greater than a preset support threshold. A first frequent alarm itemset is generated by intersecting the alarm transaction lists of each alarm item, and a second frequent alarm itemset is generated by intersecting the alarm transaction lists of the first frequent itemset; the support of the frequent alarm itemset is calculated by the length of the intersection result. The process of recursively intersecting the alarm transaction list is continued to generate all alarm frequent itemsets that meet the preset minimum support threshold; the alarm frequent itemsets are used to characterize the correlation between the occurrence of alarm items in the alarm frequent itemsets.

2. The alarm information association processing method based on artificial intelligence as described in claim 1, characterized in that, The steps for preprocessing the alarm information include: Identify and suppress disturbing alarm signals in the alarm information.

3. The alarm information association processing method based on artificial intelligence as described in claim 2, characterized in that, The steps for identifying disturbance alarm information in the alarm information include: Calculate the dynamic disturbance index of the alarm signals in the alarm information to identify the disturbed alarm signals in the alarm information; the dynamic disturbance index is used to characterize the time difference and the number of occurrences between alarm signals within a preset time period.

4. The alarm information association processing method based on artificial intelligence as described in claim 1, characterized in that, The steps for compressing and filtering the alarm information based on the association rules between the alarm items include: Similar alarm information is merged based on the association rules between the alarm items; the similar alarm information reflects the same problem or the same type of fault; and / or, The priority of alarm information is ranked based on the strength of the association rules between the alarm items; the strength of the association rules includes at least one of support, confidence, or lift; and / or, Based on the association rules between the alarm items, similar alarm information that occurs frequently is aggregated.

5. A method for analyzing alarms in nuclear power plants, characterized in that, The nuclear power plant alarm analysis method includes: The alarm information of a nuclear power plant is correlated using the alarm information correlation processing method based on artificial intelligence as described in any one of claims 1-4; Nuclear power plant faults are analyzed and processed based on the nuclear power plant alarm information after correlation processing.

6. A computer program product, characterized in that, It includes a computer program, which, when executed by a processor, implements the artificial intelligence-based alarm information association processing method as described in any one of claims 1 to 4 or the nuclear power plant alarm analysis method as described in claim 5.

7. An electronic device comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the alarm information association processing method based on artificial intelligence as described in any one of claims 1 to 4 or the nuclear power plant alarm analysis method as described in claim 5.

Images